Ticket #9943: 0001-Add-length-paramter-to-bind-and-connect.patch

headers/private/net/net_protocol.h

@@ -65 +65 @@
     status_t    (*close)(net_protocol* self);
     status_t    (*free)(net_protocol* self);
 
-    status_t    (*connect)(net_protocol* self, const struct sockaddr* address);
+    status_t    (*connect)(net_protocol* self, const struct sockaddr* address,
+                    socklen_t addressLength);
     status_t    (*accept)(net_protocol* self, net_socket** _acceptedSocket);
     status_t    (*control)(net_protocol* self, int level, int option,
                     void* value, size_t* _length);
@@ -74 +75 @@
     status_t    (*setsockopt)(net_protocol* self, int level, int option,
                     const void* value, int length);
 
-    status_t    (*bind)(net_protocol* self, const struct sockaddr* address);
+    status_t    (*bind)(net_protocol* self, const struct sockaddr* address,
+                    socklen_t addressLength);
     status_t    (*unbind)(net_protocol* self, struct sockaddr* address);
     status_t    (*listen)(net_protocol* self, int count);
     status_t    (*shutdown)(net_protocol* self, int direction);

src/add-ons/kernel/network/protocols/icmp/icmp.cpp

@@ -291 +291 @@
 
 
 status_t
-icmp_connect(net_protocol* protocol, const struct sockaddr* address)
+icmp_connect(net_protocol* protocol, const struct sockaddr* address,
+    socklen_t addressLength)
 {
     return B_ERROR;
 }
@@ -332 +333 @@
 
 
 status_t
-icmp_bind(net_protocol* protocol, const struct sockaddr* address)
+icmp_bind(net_protocol* protocol, const struct sockaddr* address,
+    socklen_t addressLength)
 {
     return B_ERROR;
 }

src/add-ons/kernel/network/protocols/icmp6/icmp6.cpp

@@ -80 +80 @@
 
 
 status_t
-icmp6_connect(net_protocol *protocol, const struct sockaddr *address)
+icmp6_connect(net_protocol *protocol, const struct sockaddr *address,
+    socklen_t addressLength)
 {
     return B_ERROR;
 }
@@ -121 +122 @@
 
 
 status_t
-icmp6_bind(net_protocol *protocol, const struct sockaddr *address)
+icmp6_bind(net_protocol *protocol, const struct sockaddr *address,
+    socklen_t addressLength)
 {
     return B_ERROR;
 }

src/add-ons/kernel/network/protocols/ipv4/ipv4.cpp

@@ -1100 +1100 @@
 
 
 status_t
-ipv4_connect(net_protocol* protocol, const struct sockaddr* address)
+ipv4_connect(net_protocol* protocol, const struct sockaddr* address,
+    socklen_t addressLength)
 {
     return B_ERROR;
 }
@@ -1312 +1313 @@
 
 
 status_t
-ipv4_bind(net_protocol* protocol, const struct sockaddr* address)
+ipv4_bind(net_protocol* protocol, const struct sockaddr* address,
+    socklen_t addressLength)
 {
     if (address->sa_family != AF_INET)
         return EAFNOSUPPORT;
@@ -1321 +1323 @@
     if (((sockaddr_in*)address)->sin_addr.s_addr == INADDR_ANY
         || IN_MULTICAST(ntohl(((sockaddr_in*)address)->sin_addr.s_addr))
         || sDatalinkModule->is_local_address(sDomain, address, NULL, NULL)) {
-        memcpy(&protocol->socket->address, address, sizeof(struct sockaddr_in));
-        protocol->socket->address.ss_len = sizeof(struct sockaddr_in);
+        memcpy(&protocol->socket->address, address, addressLength);
+        protocol->socket->address.ss_len = addressLength;
             // explicitly set length, as our callers can't be trusted to
             // always provide the correct length!
         return B_OK;

src/add-ons/kernel/network/protocols/ipv6/ipv6.cpp

@@ -1040 +1040 @@
 
 
 status_t
-ipv6_connect(net_protocol* protocol, const struct sockaddr* address)
+ipv6_connect(net_protocol* protocol, const struct sockaddr* address,
+    socklen_t addressLength)
 {
     return B_ERROR;
 }
@@ -1180 +1181 @@
 
 
 status_t
-ipv6_bind(net_protocol* protocol, const sockaddr* _address)
+ipv6_bind(net_protocol* protocol, const sockaddr* _address, socklen_t addressLength)
 {
     if (_address->sa_family != AF_INET6)
         return EAFNOSUPPORT;
@@ -1191 +1192 @@
     if (IN6_IS_ADDR_UNSPECIFIED(&address->sin6_addr)
         || IN6_IS_ADDR_MULTICAST(&address->sin6_addr)
         || sDatalinkModule->is_local_address(sDomain, _address, NULL, NULL)) {
-        memcpy(&protocol->socket->address, address, sizeof(sockaddr_in6));
-        protocol->socket->address.ss_len = sizeof(sockaddr_in6);
+        memcpy(&protocol->socket->address, address, addressLength);
+        protocol->socket->address.ss_len = addressLength;
             // explicitly set length, as our callers can't be trusted to
             // always provide the correct length!
         return B_OK;

src/add-ons/kernel/network/protocols/tcp/EndpointManager.cpp

@@ -294 +294 @@
         SocketAddressStorage local(AddressModule());
         local.SetToEmpty();
 
-        status_t status = _BindToEphemeral(endpoint, *local);
+        status_t status = _BindToEphemeral(endpoint, *local, sizeof(*local));
         if (status < B_OK)
             return status;
     }
@@ -360 +360 @@
 
 
 status_t
-EndpointManager::Bind(TCPEndpoint* endpoint, const sockaddr* address)
+EndpointManager::Bind(TCPEndpoint* endpoint, const sockaddr* address,
+    socklen_t addressLength)
 {
     // check the family
     if (!AddressModule()->is_same_family(address))
@@ -369 +370 @@
     WriteLocker locker(fLock);
 
     if (AddressModule()->get_port(address) == 0)
-        return _BindToEphemeral(endpoint, address);
+        return _BindToEphemeral(endpoint, address, addressLength);
 
-    return _BindToAddress(locker, endpoint, address);
+    return _BindToAddress(locker, endpoint, address, addressLength);
 }
 
 
@@ -379 +380 @@
 EndpointManager::BindChild(TCPEndpoint* endpoint)
 {
     WriteLocker _(fLock);
-    return _Bind(endpoint, *endpoint->LocalAddress());
+    return _Bind(endpoint, *endpoint->LocalAddress(),
+        sizeof(*endpoint->LocalAddress()));
 }
 
 
 /*! You must have fLock write locked when calling this method. */
 status_t
 EndpointManager::_BindToAddress(WriteLocker& locker, TCPEndpoint* endpoint,
-    const sockaddr* _address)
+    const sockaddr* _address, socklen_t addressLength)
 {
     ConstSocketAddress address(AddressModule(), _address);
     uint16 port = address.Port();
@@ -440 +442 @@
         }
     } while (retry-- > 0);
 
-    return _Bind(endpoint, *address);
+    return _Bind(endpoint, *address, addressLength);
 }
 
 
 /*! You must have fLock write locked when calling this method. */
 status_t
 EndpointManager::_BindToEphemeral(TCPEndpoint* endpoint,
-    const sockaddr* address)
+    const sockaddr* address, socklen_t addressLength)
 {
     TRACE(("EndpointManager::BindToEphemeral(%p)\n", endpoint));
 
@@ -477 +479 @@
                     true).Data()));
                 T(Bind(endpoint, newAddress, true));
 
-                return _Bind(endpoint, *newAddress);
+                return _Bind(endpoint, *newAddress, addressLength);
             }
 
             counter += step;
@@ -490 +492 @@
 
 
 status_t
-EndpointManager::_Bind(TCPEndpoint* endpoint, const sockaddr* address)
+EndpointManager::_Bind(TCPEndpoint* endpoint, const sockaddr* address,
+    socklen_t addressLength)
 {
     // Thus far we have checked if the Bind() is allowed
 
-    status_t status = endpoint->next->module->bind(endpoint->next, address);
+    status_t status = endpoint->next->module->bind(endpoint->next, address,
+        addressLength);
     if (status < B_OK)
         return status;
 

src/add-ons/kernel/network/protocols/tcp/EndpointManager.h

@@ -80 +80 @@
                                 const sockaddr* interfaceLocal);
             status_t        SetPassive(TCPEndpoint* endpoint);
 
-            status_t        Bind(TCPEndpoint* endpoint,
-                                const sockaddr* address);
+            status_t        Bind(TCPEndpoint* endpoint, const sockaddr* address,
+                                socklen_t addressLength);
             status_t        BindChild(TCPEndpoint* endpoint);
             status_t        Unbind(TCPEndpoint* endpoint);
 
@@ -97 +97 @@
 private:
             TCPEndpoint*    _LookupConnection(const sockaddr* local,
                                 const sockaddr* peer);
-            status_t        _Bind(TCPEndpoint* endpoint,
-                                const sockaddr* address);
+            status_t        _Bind(TCPEndpoint* endpoint, const sockaddr* address,
+                                socklen_t addressLength);
             status_t        _BindToAddress(WriteLocker& locker,
-                                TCPEndpoint* endpoint, const sockaddr* address);
-            status_t        _BindToEphemeral(TCPEndpoint* endpoint,
-                                const sockaddr* address);
+                                TCPEndpoint* endpoint, const sockaddr* address,
+                                socklen_t addressLength);
+            status_t        _BindToEphemeral(TCPEndpoint* endpoint, const sockaddr* address,
+                                socklen_t addressLength);
 
     typedef BOpenHashTable<ConnectionHashDefinition> ConnectionTable;
     typedef MultiHashTable<EndpointHashDefinition> EndpointTable;

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp

@@ -580 +580 @@
     until the connection has been established or refused.
 */
 status_t
-TCPEndpoint::Connect(const sockaddr* address)
+TCPEndpoint::Connect(const sockaddr* address, socklen_t addressLength)
 {
     TRACE("Connect() on address %s", PrintAddress(address));
 
@@ -696 +696 @@
 
 
 status_t
-TCPEndpoint::Bind(const sockaddr *address)
+TCPEndpoint::Bind(const sockaddr *address, socklen_t addressLength)
 {
     if (address == NULL)
         return B_BAD_VALUE;
@@ -708 +708 @@
     if (fState != CLOSED)
         return EISCONN;
 
-    return fManager->Bind(this, address);
+    return fManager->Bind(this, address, addressLength);
 }
 
 

src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.h

@@ -51 +51 @@
             status_t    Open();
             status_t    Close();
             void        Free();
-            status_t    Connect(const struct sockaddr* address);
+            status_t    Connect(const struct sockaddr* address, socklen_t addressLength);
             status_t    Accept(struct net_socket** _acceptedSocket);
-            status_t    Bind(const sockaddr* address);
+            status_t    Bind(const sockaddr* address, socklen_t addressLength);
             status_t    Unbind(struct sockaddr* address);
             status_t    Listen(int count);
             status_t    Shutdown(int direction);

src/add-ons/kernel/network/protocols/tcp/tcp.cpp

@@ -503 +503 @@
 
 
 status_t
-tcp_connect(net_protocol* protocol, const struct sockaddr* address)
+tcp_connect(net_protocol* protocol, const struct sockaddr* address,
+    socklen_t addressLength)
 {
-    return ((TCPEndpoint*)protocol)->Connect(address);
+    return ((TCPEndpoint*)protocol)->Connect(address, addressLength);
 }
 
 
@@ -577 +578 @@
 
 
 status_t
-tcp_bind(net_protocol* protocol, const struct sockaddr* address)
+tcp_bind(net_protocol* protocol, const struct sockaddr* address,
+    socklen_t addressLength)
 {
-    return ((TCPEndpoint*)protocol)->Bind(address);
+    return ((TCPEndpoint*)protocol)->Bind(address, addressLength);
 }
 
 

src/add-ons/kernel/network/protocols/udp/udp.cpp

@@ -75 +75 @@
 public:
                                 UdpEndpoint(net_socket* socket);
 
-            status_t            Bind(const sockaddr* newAddr);
+            status_t            Bind(const sockaddr* newAddr, socklen_t addressLength);
             status_t            Unbind(sockaddr* newAddr);
-            status_t            Connect(const sockaddr* newAddr);
+            status_t            Connect(const sockaddr* newAddr, socklen_t addressLength);
 
             status_t            Open();
             status_t            Close();
@@ -174 +174 @@
     status_t DemuxIncomingBuffer(net_buffer* buffer);
     status_t DeliverError(status_t error, net_buffer* buffer);
 
-    status_t BindEndpoint(UdpEndpoint *endpoint, const sockaddr *address);
-    status_t ConnectEndpoint(UdpEndpoint *endpoint, const sockaddr *address);
+    status_t BindEndpoint(UdpEndpoint *endpoint, const sockaddr *address,
+        socklen_t addressLength);
+    status_t ConnectEndpoint(UdpEndpoint *endpoint, const sockaddr *address,
+        socklen_t addressLength);
     status_t UnbindEndpoint(UdpEndpoint *endpoint);
 
     void DumpEndpoints() const;
 
 private:
-    status_t _BindEndpoint(UdpEndpoint *endpoint, const sockaddr *address);
-    status_t _Bind(UdpEndpoint *endpoint, const sockaddr *address);
-    status_t _BindToEphemeral(UdpEndpoint *endpoint, const sockaddr *address);
-    status_t _FinishBind(UdpEndpoint *endpoint, const sockaddr *address);
+    status_t _BindEndpoint(UdpEndpoint *endpoint, const sockaddr *address,
+        socklen_t addressLength);
+    status_t _Bind(UdpEndpoint *endpoint, const sockaddr *address,
+        socklen_t addressLength);
+    status_t _BindToEphemeral(UdpEndpoint *endpoint, const sockaddr *address,
+        socklen_t addressLength);
+    status_t _FinishBind(UdpEndpoint *endpoint, const sockaddr *address,
+        socklen_t addressLength);
 
     UdpEndpoint *_FindActiveEndpoint(const sockaddr *ourAddress,
         const sockaddr *peerAddress, uint32 index = 0);
@@ -319 +325 @@
 
 status_t
 UdpDomainSupport::BindEndpoint(UdpEndpoint *endpoint,
-    const sockaddr *address)
+    const sockaddr *address, socklen_t addressLength)
 {
     if (!AddressModule()->is_same_family(address))
         return EAFNOSUPPORT;
@@ -329 +335 @@
     if (endpoint->IsActive())
         return EINVAL;
 
-    return _BindEndpoint(endpoint, address);
+    return _BindEndpoint(endpoint, address, addressLength);
 }
 
 
 status_t
 UdpDomainSupport::ConnectEndpoint(UdpEndpoint *endpoint,
-    const sockaddr *address)
+    const sockaddr *address, socklen_t addressLength)
 {
     MutexLocker _(fLock);
 
@@ -381 +387 @@
 
     // we need to activate no matter whether or not we have just disconnected,
     // as calling connect() always triggers an implicit bind():
-    return _BindEndpoint(endpoint, *endpoint->LocalAddress());
+    return _BindEndpoint(endpoint, *endpoint->LocalAddress(),
+        sizeof(*endpoint->LocalAddress()));
 }
 
 
@@ -415 +422 @@
 
 status_t
 UdpDomainSupport::_BindEndpoint(UdpEndpoint *endpoint,
-    const sockaddr *address)
+    const sockaddr *address, socklen_t addressLength)
 {
     if (AddressModule()->get_port(address) == 0)
-        return _BindToEphemeral(endpoint, address);
+        return _BindToEphemeral(endpoint, address, addressLength);
 
-    return _Bind(endpoint, address);
+    return _Bind(endpoint, address, addressLength);
 }
 
 
 status_t
-UdpDomainSupport::_Bind(UdpEndpoint *endpoint, const sockaddr *address)
+UdpDomainSupport::_Bind(UdpEndpoint *endpoint, const sockaddr *address,
+    socklen_t addressLength)
 {
     int socketOptions = endpoint->Socket()->options;
 
@@ -457 +465 @@
         }
     }
 
-    return _FinishBind(endpoint, address);
+    return _FinishBind(endpoint, address, addressLength);
 }
 
 
 status_t
 UdpDomainSupport::_BindToEphemeral(UdpEndpoint *endpoint,
-    const sockaddr *address)
+    const sockaddr *address, socklen_t addressLength)
 {
     SocketAddressStorage newAddress(AddressModule());
     status_t status = newAddress.SetTo(address);
@@ -476 +484 @@
 
     newAddress.SetPort(htons(allocedPort));
 
-    return _FinishBind(endpoint, *newAddress);
+    return _FinishBind(endpoint, *newAddress, addressLength);
 }
 
 
 status_t
-UdpDomainSupport::_FinishBind(UdpEndpoint *endpoint, const sockaddr *address)
+UdpDomainSupport::_FinishBind(UdpEndpoint *endpoint, const sockaddr *address,
+    socklen_t addressLength)
 {
-    status_t status = endpoint->next->module->bind(endpoint->next, address);
+    status_t status = endpoint->next->module->bind(endpoint->next, address,
+        addressLength);
     if (status < B_OK)
         return status;
 
@@ -919 +929 @@
 
 
 status_t
-UdpEndpoint::Bind(const sockaddr *address)
+UdpEndpoint::Bind(const sockaddr *address, socklen_t addressLength)
 {
     TRACE_EP("Bind(%s)", AddressString(Domain(), address, true).Data());
-    return fManager->BindEndpoint(this, address);
+    return fManager->BindEndpoint(this, address, addressLength);
 }
 
 
@@ -935 +945 @@
 
 
 status_t
-UdpEndpoint::Connect(const sockaddr *address)
+UdpEndpoint::Connect(const sockaddr *address, socklen_t addressLength)
 {
     TRACE_EP("Connect(%s)", AddressString(Domain(), address, true).Data());
-    return fManager->ConnectEndpoint(this, address);
+    return fManager->ConnectEndpoint(this, address, addressLength);
 }
 
 
@@ -1141 +1151 @@
 
 
 status_t
-udp_connect(net_protocol *protocol, const struct sockaddr *address)
+udp_connect(net_protocol *protocol, const struct sockaddr *address,
+    socklen_t addressLength)
 {
-    return ((UdpEndpoint *)protocol)->Connect(address);
+    return ((UdpEndpoint *)protocol)->Connect(address, addressLength);
 }
 
 
@@ -1182 +1193 @@
 
 
 status_t
-udp_bind(net_protocol *protocol, const struct sockaddr *address)
+udp_bind(net_protocol *protocol, const struct sockaddr *address,
+    socklen_t addressLength)
 {
-    return ((UdpEndpoint *)protocol)->Bind(address);
+    return ((UdpEndpoint *)protocol)->Bind(address, addressLength);
 }
 
 

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.cpp

@@ -149 +149 @@
 
 
 status_t
-UnixEndpoint::Bind(const struct sockaddr *_address)
+UnixEndpoint::Bind(const struct sockaddr *_address, socklen_t addressLength)
 {
     if (_address->sa_family != AF_UNIX)
         RETURN_ERROR(EAFNOSUPPORT);
@@ -206 +206 @@
             RETURN_ERROR(error);
         }
 
-        size_t addressLen = address->sun_path + pathLen + 1 - (char*)address;
-        memcpy(&socket->address, address, addressLen);
-        socket->address.ss_len = addressLen;
+        memcpy(&socket->address, address, addressLength);
+        socket->address.ss_len = addressLength;
 
         UnixAddressManagerLocker addressLocker(gAddressManager);
         gAddressManager.Add(this);
@@ -261 +260 @@
 
 
 status_t
-UnixEndpoint::Connect(const struct sockaddr *_address)
+UnixEndpoint::Connect(const struct sockaddr *_address, socklen_t addressLength)
 {
     if (_address->sa_family != AF_UNIX)
         RETURN_ERROR(EAFNOSUPPORT);

src/add-ons/kernel/network/protocols/unix/UnixEndpoint.h

@@ -60 +60 @@
         mutex_unlock(&fLock);
     }
 
-    status_t Bind(const struct sockaddr *_address);
+    status_t Bind(const struct sockaddr *_address, socklen_t addressLength);
     status_t Unbind();
     status_t Listen(int backlog);
-    status_t Connect(const struct sockaddr *address);
+    status_t Connect(const struct sockaddr *_address, socklen_t addressLength);
     status_t Accept(net_socket **_acceptedSocket);
 
     ssize_t Send(const iovec *vecs, size_t vecCount,

src/add-ons/kernel/network/protocols/unix/unix.cpp

@@ -110 +110 @@
 
 
 status_t
-unix_connect(net_protocol *_protocol, const struct sockaddr *address)
+unix_connect(net_protocol *_protocol, const struct sockaddr *_address,
+    socklen_t addressLength)
 {
-    return ((UnixEndpoint*)_protocol)->Connect(address);
+    return ((UnixEndpoint*)_protocol)->Connect(_address, addressLength);
 }
 
 
@@ -176 +177 @@
 
 
 status_t
-unix_bind(net_protocol *_protocol, const struct sockaddr *_address)
+unix_bind(net_protocol *_protocol, const struct sockaddr *_address,
+    socklen_t addressLength)
 {
-    return ((UnixEndpoint*)_protocol)->Bind(_address);
+    return ((UnixEndpoint*)_protocol)->Bind(_address, addressLength);
 }
 
 

src/add-ons/kernel/network/stack/link.cpp

@@ -50 +50 @@
             status_t            StartMonitoring(const char* deviceName);
             status_t            StopMonitoring(const char* deviceName);
 
-            status_t            Bind(const sockaddr* address);
+            status_t            Bind(const sockaddr* address, socklen_t addressLength);
             status_t            Unbind();
             bool                IsBound() const
                                     { return fBoundToDevice != NULL; }
@@ -140 +140 @@
 
 
 status_t
-LinkProtocol::Bind(const sockaddr* address)
+LinkProtocol::Bind(const sockaddr* address, socklen_t addressLength)
 {
     // Only root is allowed to bind to a link layer interface
     if (address == NULL || geteuid() != 0)
@@ -182 +182 @@
     fBoundToDevice = boundTo;
     socket->bound_to_device = boundTo->device->index;
 
-    memcpy(&socket->address, address, sizeof(struct sockaddr_storage));
-    socket->address.ss_len = sizeof(struct sockaddr_storage);
+    memcpy(&socket->address, address, addressLength);
+    socket->address.ss_len = addressLength;
 
     return B_OK;
 }
@@ -337 +337 @@
 
 
 static status_t
-link_connect(net_protocol* protocol, const struct sockaddr* address)
+link_connect(net_protocol* protocol, const struct sockaddr* address,
+    socklen_t addressLength)
 {
     return B_NOT_SUPPORTED;
 }
@@ -541 +542 @@
 
 
 static status_t
-link_bind(net_protocol* _protocol, const struct sockaddr* address)
+link_bind(net_protocol* _protocol, const struct sockaddr* address,
+    socklen_t addressLength)
 {
     LinkProtocol* protocol = (LinkProtocol*)_protocol;
-    return protocol->Bind(address);
+    return protocol->Bind(address, addressLength);
 }
 
 

src/add-ons/kernel/network/stack/net_socket.cpp

@@ -1014 +1014 @@
     socket->address.ss_len = sizeof(sockaddr_storage);
 
     status_t status = socket->first_info->bind(socket->first_protocol,
-        (sockaddr*)address);
+        (sockaddr*)address, addressLength);
     if (status != B_OK) {
         // clear address again, as binding failed
         socket->address.ss_len = 0;
@@ -1038 +1038 @@
             return status;
     }
 
-    return socket->first_info->connect(socket->first_protocol, address);
+    return socket->first_info->connect(socket->first_protocol, address,
+        addressLength);
 }