diff --git a/.drone.jsonnet b/.drone.jsonnet
index 6be869b..f8881be 100644
--- a/.drone.jsonnet
+++ b/.drone.jsonnet
@@ -189,16 +189,16 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
     ),
 
     linux_pipeline(
-        "Linux 22.04 GCC 12 32 ASAN",
+        "Linux 22.04 GCC 12 32",
         "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' } + asan,
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' },
         "g++-12-multilib",
     ),
 
     linux_pipeline(
-        "Linux 22.04 GCC 12 64 ASAN",
+        "Linux 22.04 GCC 12 64",
         "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '64' } + asan,
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '64' },
         "g++-12-multilib",
     ),
 
@@ -216,6 +216,34 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
         "g++-13-multilib",
     ),
 
+    linux_pipeline(
+        "Linux 23.04 GCC 13 32 ASAN",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' } + asan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 23.04 GCC 13 64 ASAN",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '11,14,17,20,2b', ADDRMD: '64' } + asan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 14 32",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-14', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' },
+        "g++-14-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 14 64",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-14', CXXSTD: '11,14,17,20,2b', ADDRMD: '64' },
+        "g++-14-multilib",
+    ),
+
     linux_pipeline(
         "Linux 16.04 Clang 3.5",
         "cppalliance/droneubuntu1604:1",
@@ -273,17 +301,24 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
     ),
 
     linux_pipeline(
-        "Linux 23.10 Clang 17 UBSAN",
+        "Linux 23.10 Clang 17",
         "cppalliance/droneubuntu2310:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' } + ubsan,
+        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' },
         "clang-17",
     ),
 
     linux_pipeline(
-        "Linux 23.10 Clang 17 ASAN",
-        "cppalliance/droneubuntu2310:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' } + asan,
-        "clang-17",
+        "Linux 24.04 Clang 18 UBSAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '11,14,17,20,2b' } + ubsan,
+        "clang-18",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 Clang 18 ASAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '11,14,17,20,2b' } + asan,
+        "clang-18",
     ),
 
     macos_pipeline(
diff --git a/include/boost/system/detail/generic_category_message.hpp b/include/boost/system/detail/generic_category_message.hpp
index ded2db6..611ce37 100644
--- a/include/boost/system/detail/generic_category_message.hpp
+++ b/include/boost/system/detail/generic_category_message.hpp
@@ -39,7 +39,19 @@ inline char const * strerror_r_helper( int r, char const * buffer ) noexcept
 
 inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
 {
-    return strerror_r_helper( strerror_r( ev, buffer, len ), buffer );
+    if( buffer != nullptr )
+    {
+        return strerror_r_helper( strerror_r( ev, buffer, len ), buffer );
+    }
+    else
+    {
+        // strerror_r requires non-null buffer pointer
+
+        char tmp[ 1 ] = {};
+        char const* r = strerror_r_helper( strerror_r( ev, tmp, 0 ), buffer );
+
+        return r == tmp? nullptr: r;
+    }
 }
 
 inline std::string generic_error_category_message( int ev )
diff --git a/test/error_code_test2.cpp b/test/error_code_test2.cpp
index e423653..6d48651 100644
--- a/test/error_code_test2.cpp
+++ b/test/error_code_test2.cpp
@@ -11,26 +11,53 @@ namespace sys = boost::system;
 
 int main()
 {
-    char buffer[ 1024 ];
-
-    sys::error_code ec;
-
-    BOOST_TEST_EQ( ec.value(), 0 );
-    BOOST_TEST( ec.category() == sys::system_category() );
-    BOOST_TEST_EQ( ec.message(), ec.category().message( ec.value() ) );
-    BOOST_TEST_CSTR_EQ( ec.message( buffer, sizeof( buffer ) ), ec.category().message( ec.value(), buffer, sizeof( buffer ) ) );
-    BOOST_TEST( !ec.failed() );
-    BOOST_TEST( !ec );
-
-    BOOST_TEST_EQ( ec.to_string(), std::string( "system:0" ) );
+    char buffer[ 4096 ], buffer2[ 4096 ];
 
     {
+        sys::error_code ec;
+
+        BOOST_TEST_EQ( ec.value(), 0 );
+        BOOST_TEST( ec.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( ec.message(), ec.category().message( ec.value() ) );
+        BOOST_TEST_CSTR_EQ( ec.message( buffer, sizeof( buffer ) ), ec.category().message( ec.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec.message( buffer, sizeof( buffer ) ), ec.message().c_str() );
+
+        {
+            char const* msg = ec.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( !ec.failed() );
+        BOOST_TEST( !ec );
+
+        BOOST_TEST_EQ( ec.to_string(), std::string( "system:0" ) );
+    }
+
+    {
+        sys::error_code ec;
         sys::error_code ec2( ec );
 
         BOOST_TEST_EQ( ec2.value(), 0 );
         BOOST_TEST( ec2.category() == sys::system_category() );
+
         BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
-        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( !ec2.failed() );
         BOOST_TEST( !ec2 );
 
@@ -41,12 +68,25 @@ int main()
     }
 
     {
+        sys::error_code ec;
         sys::error_code ec2( ec.value(), ec.category() );
 
         BOOST_TEST_EQ( ec2.value(), 0 );
         BOOST_TEST( ec2.category() == sys::system_category() );
+
         BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
-        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( !ec2.failed() );
         BOOST_TEST( !ec2 );
 
@@ -61,34 +101,124 @@ int main()
 
         BOOST_TEST_EQ( ec2.value(), 5 );
         BOOST_TEST( ec2.category() == sys::generic_category() );
+
         BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
-        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( ec2.failed() );
         BOOST_TEST( ec2 );
         BOOST_TEST_NOT( !ec2 );
 
+        sys::error_code ec;
+
         BOOST_TEST_NE( ec, ec2 );
         BOOST_TEST_NOT( ec == ec2 );
 
         BOOST_TEST_EQ( ec2.to_string(), std::string( "generic:5" ) );
     }
 
+    {
+        sys::error_code ec2( -4, sys::generic_category() );
+
+        BOOST_TEST_EQ( ec2.value(), -4 );
+        BOOST_TEST( ec2.category() == sys::generic_category() );
+
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( ec2.failed() );
+        BOOST_TEST( ec2 );
+        BOOST_TEST_NOT( !ec2 );
+
+        sys::error_code ec;
+
+        BOOST_TEST_NE( ec, ec2 );
+        BOOST_TEST_NOT( ec == ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "generic:-4" ) );
+    }
+
     {
         sys::error_code ec2( 5, sys::system_category() );
 
         BOOST_TEST_EQ( ec2.value(), 5 );
         BOOST_TEST( ec2.category() == sys::system_category() );
+
         BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
-        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( ec2.failed() );
         BOOST_TEST( ec2 );
         BOOST_TEST_NOT( !ec2 );
 
+        sys::error_code ec;
+
         BOOST_TEST_NE( ec, ec2 );
         BOOST_TEST_NOT( ec == ec2 );
 
         BOOST_TEST_EQ( ec2.to_string(), std::string( "system:5" ) );
     }
 
+    {
+        sys::error_code ec2( -4, sys::system_category() );
+
+        BOOST_TEST_EQ( ec2.value(), -4 );
+        BOOST_TEST( ec2.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( ec2.failed() );
+        BOOST_TEST( ec2 );
+        BOOST_TEST_NOT( !ec2 );
+
+        sys::error_code ec;
+
+        BOOST_TEST_NE( ec, ec2 );
+        BOOST_TEST_NOT( ec == ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "system:-4" ) );
+    }
+
     return boost::report_errors();
 }
diff --git a/test/error_condition_test3.cpp b/test/error_condition_test3.cpp
index fefecf3..0ab839d 100644
--- a/test/error_condition_test3.cpp
+++ b/test/error_condition_test3.cpp
@@ -11,26 +11,53 @@ namespace sys = boost::system;
 
 int main()
 {
-    char buffer[ 1024 ];
-
-    sys::error_condition en;
-
-    BOOST_TEST_EQ( en.value(), 0 );
-    BOOST_TEST( en.category() == sys::generic_category() );
-    BOOST_TEST_EQ( en.message(), en.category().message( en.value() ) );
-    BOOST_TEST_CSTR_EQ( en.message( buffer, sizeof( buffer ) ), en.category().message( en.value(), buffer, sizeof( buffer ) ) );
-    BOOST_TEST( !en.failed() );
-    BOOST_TEST( !en );
-
-    BOOST_TEST_EQ( en.to_string(), std::string( "cond:generic:0" ) );
+    char buffer[ 4096 ], buffer2[ 4096 ];
 
     {
+        sys::error_condition en;
+
+        BOOST_TEST_EQ( en.value(), 0 );
+        BOOST_TEST( en.category() == sys::generic_category() );
+
+        BOOST_TEST_EQ( en.message(), en.category().message( en.value() ) );
+        BOOST_TEST_CSTR_EQ( en.message( buffer, sizeof( buffer ) ), en.category().message( en.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en.message( buffer, sizeof( buffer ) ), en.message().c_str() );
+
+        {
+            char const* msg = en.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( !en.failed() );
+        BOOST_TEST( !en );
+
+        BOOST_TEST_EQ( en.to_string(), std::string( "cond:generic:0" ) );
+    }
+
+    {
+        sys::error_condition en;
         sys::error_condition en2( en );
 
         BOOST_TEST_EQ( en2.value(), 0 );
         BOOST_TEST( en2.category() == sys::generic_category() );
+
         BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
-        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( !en2.failed() );
         BOOST_TEST( !en2 );
 
@@ -41,12 +68,25 @@ int main()
     }
 
     {
+        sys::error_condition en;
         sys::error_condition en2( en.value(), en.category() );
 
         BOOST_TEST_EQ( en2.value(), 0 );
         BOOST_TEST( en2.category() == sys::generic_category() );
+
         BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
-        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( !en2.failed() );
         BOOST_TEST( !en2 );
 
@@ -61,34 +101,124 @@ int main()
 
         BOOST_TEST_EQ( en2.value(), 5 );
         BOOST_TEST( en2.category() == sys::generic_category() );
+
         BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
-        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( en2.failed() );
         BOOST_TEST( en2 );
         BOOST_TEST_NOT( !en2 );
 
+        sys::error_condition en;
+
         BOOST_TEST_NE( en, en2 );
         BOOST_TEST_NOT( en == en2 );
 
         BOOST_TEST_EQ( en2.to_string(), std::string( "cond:generic:5" ) );
     }
 
+    {
+        sys::error_condition en2( -4, sys::generic_category() );
+
+        BOOST_TEST_EQ( en2.value(), -4 );
+        BOOST_TEST( en2.category() == sys::generic_category() );
+
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( en2.failed() );
+        BOOST_TEST( en2 );
+        BOOST_TEST_NOT( !en2 );
+
+        sys::error_condition en;
+
+        BOOST_TEST_NE( en, en2 );
+        BOOST_TEST_NOT( en == en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:generic:-4" ) );
+    }
+
     {
         sys::error_condition en2( 5, sys::system_category() );
 
         BOOST_TEST_EQ( en2.value(), 5 );
         BOOST_TEST( en2.category() == sys::system_category() );
+
         BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
-        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( en2.failed() );
         BOOST_TEST( en2 );
         BOOST_TEST_NOT( !en2 );
 
+        sys::error_condition en;
+
         BOOST_TEST_NE( en, en2 );
         BOOST_TEST_NOT( en == en2 );
 
         BOOST_TEST_EQ( en2.to_string(), std::string( "cond:system:5" ) );
     }
 
+    {
+        sys::error_condition en2( -4, sys::system_category() );
+
+        BOOST_TEST_EQ( en2.value(), -4 );
+        BOOST_TEST( en2.category() == sys::system_category() );
+
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( en2.failed() );
+        BOOST_TEST( en2 );
+        BOOST_TEST_NOT( !en2 );
+
+        sys::error_condition en;
+
+        BOOST_TEST_NE( en, en2 );
+        BOOST_TEST_NOT( en == en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:system:-4" ) );
+    }
+
     return boost::report_errors();
 }