Treat sockaddr::sa_len as the authoritative end of a Unix domain socket name, rather than relying on null termination

groups/nts/ntsu/ntsu_socketutil.cpp

@@ -937,27 +937,48 @@ ntsa::Error SocketUtil::Impl::convert(ntsa::Endpoint*         endpoint,
             const bsl::size_t pathOffset =
                 offsetof(struct sockaddr_un, sun_path);
 
-            if (socketAddressSize == pathOffset) {
+            const bsl::size_t addressSize =
+                static_cast<bsl::size_t>(socketAddressSize);
+
+            if (addressSize <= pathOffset) {
                 localName->setUnnamed();
             }
             else {
+                // The address length reported by the socket API is the
+                // authoritative extent of 'sun_path': the field is not
+                // guaranteed to be null-terminated (abstract names never are,
+                // and a peer may supply a truncated or unterminated path).
+                // Bound the scan by that length, clamped to the capacity of
+                // the field itself, so the scan never reads bytes outside the
+                // address.
+
+                bsl::size_t pathSize = addressSize - pathOffset;
+                if (pathSize > sizeof(socketAddressLocal->sun_path)) {
+                    pathSize = sizeof(socketAddressLocal->sun_path);
+                }
+
                 const char* begin = socketAddressLocal->sun_path;
+                const char* limit = begin + pathSize;
 
                 if (*begin == 0) {
                     localName->setAbstract();
                     ++begin;
                 }
 
                 const char* end = begin;
-                while (*end != 0) {
+                while (end != limit && *end != 0) {
                     ++end;
                 }
 
                 if (begin == end) {
                     localName->setUnnamed();
                 }
                 else {
-                    localName->setValue(bslstl::StringRef(begin, end));
+                    ntsa::Error error =
+                        localName->setValue(bslstl::StringRef(begin, end));
+                    if (error) {
+                        return error;
+                    }
                 }
             }
         }

groups/nts/ntsu/ntsu_socketutil.h

@@ -723,7 +723,11 @@ struct SocketUtil {
 
     /// Load into the specified 'endpoint' the conversion of the specified
     /// 'socketAddress' having the specified 'socketAddressSize'. Return the
-    /// error.
+    /// error. Note a 'socketAddress' indicating a Unix domain name with an
+    /// embedded NUL is successfully decoded but the resulting 'endpoint' local
+    /// name only contains characters up to the first NUL character, not
+    /// including the initital NUL character, if any, that indicates the Unix
+    /// domain name is in the abstract namespace.
     static ntsa::Error decodeEndpoint(ntsa::Endpoint* endpoint,
                                       const void*     socketAddress,
                                       bsl::size_t     socketAddressSize);