Drv: rename hostname to ipv4Address

Author: Not4right

Drv/Ip/IpSocket.cpp

@@ -45,20 +45,27 @@
 namespace Drv {
 
 IpSocket::IpSocket() : m_timeoutSeconds(0), m_timeoutMicroseconds(0), m_port(0) {
-    ::memset(m_hostname, 0, sizeof(m_hostname));
+    ::memset(this->m_ipv4_address, 0, sizeof(this->m_ipv4_address));
 }
 
-SocketIpStatus IpSocket::configure(const char* const hostname,
+SocketIpStatus IpSocket::configure(const char* const ipv4_address,
                                    const U16 port,
                                    const U32 timeout_seconds,
                                    const U32 timeout_microseconds) {
     FW_ASSERT(timeout_microseconds < 1000000, static_cast<FwAssertArgType>(timeout_microseconds));
     FW_ASSERT(this->isValidPort(port), static_cast<FwAssertArgType>(port));
-    FW_ASSERT(hostname != nullptr);
+    FW_ASSERT(ipv4_address != nullptr);
+    // Defense-in-depth: reject inputs that would have been silently truncated by string_copy.
+    FW_ASSERT(Fw::StringUtils::string_length(ipv4_address,
+                                             static_cast<FwSizeType>(SOCKET_MAX_IPV4_ADDRESS_SIZE))
+              < static_cast<FwSizeType>(SOCKET_MAX_IPV4_ADDRESS_SIZE));
     this->m_timeoutSeconds = timeout_seconds;
     this->m_timeoutMicroseconds = timeout_microseconds;
     this->m_port = port;
-    (void)Fw::StringUtils::string_copy(this->m_hostname, hostname, static_cast<FwSizeType>(SOCKET_MAX_HOSTNAME_SIZE));
+    (void)Fw::StringUtils::string_copy(this->m_ipv4_address, ipv4_address,
+                                       static_cast<FwSizeType>(SOCKET_MAX_IPV4_ADDRESS_SIZE));
+    // Post-condition: NUL termination guaranteed by Fw::StringUtils::string_copy contract.
+    FW_ASSERT(this->m_ipv4_address[SOCKET_MAX_IPV4_ADDRESS_SIZE - 1] == '\0');
     return SOCK_SUCCESS;
 }
 
@@ -83,23 +90,29 @@ SocketIpStatus IpSocket::setupTimeouts(int socketFd) {
     return SOCK_SUCCESS;
 }
 
-SocketIpStatus IpSocket::addressToIp4(const char* address, void* ip4) {
-    FW_ASSERT(address != nullptr);
-    FW_ASSERT(ip4 != nullptr);
+SocketIpStatus IpSocket::addressToIp4(const char* const ipv4_address, void* const out) {
+    FW_ASSERT(ipv4_address != nullptr);
+    FW_ASSERT(out != nullptr);
+    // Pre-zero the destination so that on failure, callers cannot accidentally consume
+    // uninitialized memory. This is a defense-in-depth measure for safety-critical use.
+    (void)::memset(out, 0, sizeof(struct in_addr));
     // Get the IP address from host
 #ifdef TGT_OS_TYPE_VXWORKS
-    int ip = inet_addr(address);
+    int ip = inet_addr(ipv4_address);
     if (ip == ERROR) {
         return SOCK_INVALID_IP_ADDRESS;
     }
     // from sin_addr, which has one struct
     // member s_addr, which is unsigned int
-    *reinterpret_cast<unsigned long*>(ip4) = ip;
+    *static_cast<unsigned long*>(out) = static_cast<unsigned long>(ip);
 #else
-    // First IP address to socket sin_addr
-    if (not ::inet_pton(AF_INET, address, ip4)) {
+    // inet_pton(3) returns 1 on success, 0 if the input is not a valid IPv4 presentation
+    // string, and -1 (with errno=EAFNOSUPPORT) if the family argument is bogus. Only a
+    // strict equality check is safe — a `not` test treats -1 as success and would silently
+    // mask an EAFNOSUPPORT failure. (Power-of-Ten Rule 7: check every return value.)
+    if (::inet_pton(AF_INET, ipv4_address, out) != 1) {
         return SOCK_INVALID_IP_ADDRESS;
-    };
+    }
 #endif
     return SOCK_SUCCESS;
 }

Drv/Ip/IpSocket.hpp

@@ -59,24 +59,32 @@ class IpSocket {
     IpSocket();
     virtual ~IpSocket() {};
     /**
-     * \brief configure the ip socket with host and transmission timeouts
+     * \brief configure the ip socket with an IPv4 address and transmission timeouts
      *
-     * Configures the IP handler (Tcp, Tcp server, and Udp) to use the given hostname and port. When multiple ports are
-     * used for send/receive these settings affect the send direction (as is the case for udp). Hostname DNS translation
-     * is left up to the caller and thus hostname must be an IP address in dot-notation of the form "x.x.x.x". Port
-     * cannot be set to 0 as dynamic port assignment is not supported.
+     * Configures the IP handler (Tcp, Tcp server, and Udp) to use the given IPv4 address and port.
+     * When multiple ports are used for send/receive these settings affect the send direction (as is
+     * the case for udp).
      *
-     * Note: for UDP sockets this is equivalent to `configureSend` and only sets up the transmission direction of the
-     * socket.  A separate call to `configureRecv` is required to receive on the socket and should be made before the
-     * `open` call has been made.
+     * \warning DNS resolution is NOT performed by this driver. The \a ipv4_address argument MUST be
+     * a NUL-terminated IPv4 address in dotted-quad notation of the form "x.x.x.x" (for example,
+     * "127.0.0.1"). Passing a textual hostname (e.g. "localhost") will be rejected at open() time
+     * with SOCK_INVALID_IP_ADDRESS. Callers that need DNS lookup must perform it themselves and
+     * pass the resolved IPv4 string to this function.
      *
-     * \param hostname: socket uses for outgoing transmissions (and incoming when tcp). Must be of form x.x.x.x
+     * Port cannot be set to 0 as dynamic port assignment is not supported.
+     *
+     * Note: for UDP sockets this is equivalent to `configureSend` and only sets up the
+     * transmission direction of the socket. A separate call to `configureRecv` is required to
+     * receive on the socket and should be made before the `open` call has been made.
+     *
+     * \param ipv4_address: IPv4 address (dotted-quad "x.x.x.x") used for outgoing transmissions
+     *                      (and incoming when tcp).
      * \param port: port socket uses for outgoing transmissions (and incoming when tcp). Must NOT be 0.
      * \param send_timeout_seconds: send timeout seconds portion
      * \param send_timeout_microseconds: send timeout microseconds portion. Must be less than 1000000
      * \return status of configure
      */
-    virtual SocketIpStatus configure(const char* hostname,
+    virtual SocketIpStatus configure(const char* const ipv4_address,
                                      const U16 port,
                                      const U32 send_timeout_seconds,
                                      const U32 send_timeout_microseconds);
@@ -179,12 +187,18 @@ class IpSocket {
     SocketIpStatus setupTimeouts(int socketFd);
 
     /**
-     * \brief converts a given address in dot form x.x.x.x to an ip address. ONLY works for IPv4.
-     * \param address: address to convert
-     * \param ip4: IPv4 representation structure to fill
-     * \return: status of conversion
+     * \brief converts a given IPv4 address in dotted-quad form "x.x.x.x" to a network-order
+     *        in_addr structure. ONLY works for IPv4; does NOT perform DNS resolution.
+     *
+     * On failure the destination buffer is zero-initialized so callers cannot accidentally
+     * consume uninitialized stack memory after a failed conversion.
+     *
+     * \param ipv4_address: NUL-terminated dotted-quad IPv4 address to convert (must not be null)
+     * \param out: pointer to a struct in_addr (or equivalently sized buffer) to fill
+     *             (must not be null)
+     * \return: SOCK_SUCCESS on success, SOCK_INVALID_IP_ADDRESS on any malformed input
      */
-    static SocketIpStatus addressToIp4(const char* address, void* ip4);
+    static SocketIpStatus addressToIp4(const char* const ipv4_address, void* const out);
     /**
      * \brief Protocol specific open implementation, called from open.
      * \param socketDescriptor: (output) socket descriptor opened. Only valid on SOCK_SUCCESS. Otherwise will be invalid
@@ -233,8 +247,8 @@ class IpSocket {
 
     U32 m_timeoutSeconds;
     U32 m_timeoutMicroseconds;
-    U16 m_port;                                 //!< IP address port used
-    char m_hostname[SOCKET_MAX_HOSTNAME_SIZE];  //!< Hostname to supply
+    U16 m_port;                                       //!< IP address port used
+    char m_ipv4_address[SOCKET_MAX_IPV4_ADDRESS_SIZE];//!< IPv4 address (dotted-quad "x.x.x.x")
 };
 }  // namespace Drv
 

Drv/Ip/TcpClientSocket.cpp

@@ -63,8 +63,8 @@ SocketIpStatus TcpClientSocket::openProtocol(SocketDescriptor& socketDescriptor)
     address.sin_len = static_cast<U8>(sizeof(struct sockaddr_in));
 #endif
 
-    // First IP address to socket sin_addr
-    if (IpSocket::addressToIp4(m_hostname, &(address.sin_addr)) != SOCK_SUCCESS) {
+    // Convert the configured IPv4 address (dotted-quad) to a network-order in_addr.
+    if (IpSocket::addressToIp4(this->m_ipv4_address, &(address.sin_addr)) != SOCK_SUCCESS) {
         ::close(socketFd);
         return SOCK_INVALID_IP_ADDRESS;
     };
@@ -86,7 +86,7 @@ SocketIpStatus TcpClientSocket::openProtocol(SocketDescriptor& socketDescriptor)
         return SOCK_FAILED_TO_CONNECT;
     }
     socketDescriptor.fd = socketFd;
-    Fw::Logger::log("Connected to %s:%hu as a tcp client\n", m_hostname, m_port);
+    Fw::Logger::log("Connected to %s:%hu as a tcp client\n", this->m_ipv4_address, this->m_port);
     return SOCK_SUCCESS;
 }
 

Drv/Ip/TcpServerSocket.cpp

@@ -60,8 +60,8 @@ SocketIpStatus TcpServerSocket::startup(SocketDescriptor& socketDescriptor) {
 #if defined TGT_OS_TYPE_VXWORKS || TGT_OS_TYPE_DARWIN
     address.sin_len = static_cast<U8>(sizeof(struct sockaddr_in));
 #endif
-    // First IP address to socket sin_addr
-    if (IpSocket::addressToIp4(m_hostname, &(address.sin_addr)) != SOCK_SUCCESS) {
+    // Convert the configured IPv4 address (dotted-quad) to a network-order in_addr.
+    if (IpSocket::addressToIp4(this->m_ipv4_address, &(address.sin_addr)) != SOCK_SUCCESS) {
         ::close(serverFd);
         return SOCK_INVALID_IP_ADDRESS;
     };
@@ -88,7 +88,7 @@ SocketIpStatus TcpServerSocket::startup(SocketDescriptor& socketDescriptor) {
         ::close(serverFd);
         return SOCK_FAILED_TO_LISTEN;  // What we have here is a failure to communicate
     }
-    Fw::Logger::log("Listening for single client at %s:%hu\n", m_hostname, m_port);
+    Fw::Logger::log("Listening for single client at %s:%hu\n", this->m_ipv4_address, this->m_port);
     FW_ASSERT(serverFd != -1);
     socketDescriptor.serverFd = serverFd;
     this->m_port = ntohs(address.sin_port);
@@ -119,7 +119,7 @@ SocketIpStatus TcpServerSocket::openProtocol(SocketDescriptor& socketDescriptor)
         return SOCK_FAILED_TO_SET_SOCKET_OPTIONS;
     }
 
-    Fw::Logger::log("Accepted client at %s:%hu\n", m_hostname, m_port);
+    Fw::Logger::log("Accepted client at %s:%hu\n", this->m_ipv4_address, this->m_port);
     socketDescriptor.fd = clientFd;
     return SOCK_SUCCESS;
 }

Drv/Ip/UdpSocket.cpp

@@ -46,36 +46,42 @@ UdpSocket::UdpSocket() : IpSocket(), m_recv_configured(false) {
 
 UdpSocket::~UdpSocket() = default;
 
-SocketIpStatus UdpSocket::configure(const char* const hostname,
+SocketIpStatus UdpSocket::configure(const char* const ipv4_address,
                                     const U16 port,
                                     const U32 timeout_seconds,
                                     const U32 timeout_microseconds) {
+    (void)ipv4_address;
+    (void)port;
+    (void)timeout_seconds;
+    (void)timeout_microseconds;
     FW_ASSERT(0);  // Must use configureSend and/or configureRecv
     return SocketIpStatus::SOCK_INVALID_CALL;
 }
 
-SocketIpStatus UdpSocket::configureSend(const char* const hostname,
+SocketIpStatus UdpSocket::configureSend(const char* const ipv4_address,
                                         const U16 port,
                                         const U32 timeout_seconds,
                                         const U32 timeout_microseconds) {
-    FW_ASSERT(hostname != nullptr);
+    FW_ASSERT(ipv4_address != nullptr);
     FW_ASSERT(this->isValidPort(port));
     FW_ASSERT(timeout_microseconds < 1000000);
-    return IpSocket::configure(hostname, port, timeout_seconds, timeout_microseconds);
+    return IpSocket::configure(ipv4_address, port, timeout_seconds, timeout_microseconds);
 }
 
-SocketIpStatus UdpSocket::configureRecv(const char* hostname, const U16 port) {
-    FW_ASSERT(hostname != nullptr);
+SocketIpStatus UdpSocket::configureRecv(const char* const ipv4_address, const U16 port) {
+    FW_ASSERT(ipv4_address != nullptr);
     FW_ASSERT(this->isValidPort(port));
-    FW_ASSERT(Fw::StringUtils::string_length(hostname, SOCKET_MAX_HOSTNAME_SIZE) < SOCKET_MAX_HOSTNAME_SIZE);
+    FW_ASSERT(Fw::StringUtils::string_length(ipv4_address,
+                                             static_cast<FwSizeType>(SOCKET_MAX_IPV4_ADDRESS_SIZE))
+              < static_cast<FwSizeType>(SOCKET_MAX_IPV4_ADDRESS_SIZE));
 
     // Initialize the receive address structure
     (void)::memset(&m_addr_recv, 0, sizeof(m_addr_recv));
     m_addr_recv.sin_family = AF_INET;
     m_addr_recv.sin_port = htons(port);
 
-    // Convert hostname to IP address
-    SocketIpStatus status = IpSocket::addressToIp4(hostname, &m_addr_recv.sin_addr);
+    // Convert IPv4 address (dotted-quad) to network-order in_addr
+    SocketIpStatus status = IpSocket::addressToIp4(ipv4_address, &m_addr_recv.sin_addr);
     if (status != SOCK_SUCCESS) {
         return status;
     }
@@ -143,10 +149,11 @@ SocketIpStatus UdpSocket::openProtocol(SocketDescriptor& socketDescriptor) {
         address.sin_len = static_cast<U8>(sizeof(struct sockaddr_in));
 #endif
 
-        // First IP address to socket sin_addr
-        status = IpSocket::addressToIp4(m_hostname, &(address.sin_addr));
+        // Convert the configured IPv4 address (dotted-quad) to a network-order in_addr.
+        status = IpSocket::addressToIp4(this->m_ipv4_address, &(address.sin_addr));
         if (status != SOCK_SUCCESS) {
-            Fw::Logger::log("Failed to resolve hostname %s: %d\n", m_hostname, static_cast<I32>(status));
+            Fw::Logger::log("Failed to parse IPv4 address %s: %d\n",
+                            this->m_ipv4_address, static_cast<I32>(status));
             ::close(socketFd);
             return status;
         };
@@ -187,9 +194,10 @@ SocketIpStatus UdpSocket::openProtocol(SocketDescriptor& socketDescriptor) {
     if ((port == 0) && (recv_port > 0)) {
         Fw::Logger::log("Setup to only receive udp at %s:%hu\n", recv_addr, recv_port);
     } else if ((port > 0) && (recv_port == 0)) {
-        Fw::Logger::log("Setup to only send udp at %s:%hu\n", m_hostname, port);
+        Fw::Logger::log("Setup to only send udp at %s:%hu\n", this->m_ipv4_address, port);
     } else if ((port > 0) && (recv_port > 0)) {
-        Fw::Logger::log("Setup to receive udp at %s:%hu and send to %s:%hu\n", recv_addr, recv_port, m_hostname, port);
+        Fw::Logger::log("Setup to receive udp at %s:%hu and send to %s:%hu\n",
+                        recv_addr, recv_port, this->m_ipv4_address, port);
     }
 
     FW_ASSERT(status == SOCK_SUCCESS, static_cast<FwAssertArgType>(status));

Drv/Ip/UdpSocket.hpp

@@ -57,48 +57,58 @@ class UdpSocket : public IpSocket {
      *
      * \warning configure is disabled for UdpSocket. Use configureSend and configureRecv instead.
      */
-    SocketIpStatus configure(const char* hostname,
+    SocketIpStatus configure(const char* const ipv4_address,
                              const U16 port,
                              const U32 send_timeout_seconds,
                              const U32 send_timeout_microseconds) override;
 
     /**
      * \brief configure the udp socket for outgoing transmissions
      *
-     * Configures the UDP handler to use the given hostname and port for outgoing transmissions. Incoming hostname
-     * and port are configured using the `configureRecv` function call for UDP as it requires separate host/port pairs
-     * for outgoing and incoming transmissions. Hostname DNS translation is left up to the caller and thus hostname must
-     * be an IP address in dot-notation of the form "x.x.x.x". If port is set to 0, the socket will be configured for
-     * ephemeral send (dynamic reply-to) and will use the sender's address from the first received datagram for replies.
-     * It is possible to configure the UDP port as a single-direction send port only.
+     * Configures the UDP handler to use the given IPv4 address and port for outgoing
+     * transmissions. Incoming address and port are configured using the `configureRecv`
+     * function call for UDP as it requires separate address/port pairs for outgoing and
+     * incoming transmissions.
+     *
+     * \warning DNS resolution is NOT performed by this driver. The \a ipv4_address argument
+     * MUST be a NUL-terminated IPv4 address in dotted-quad notation of the form "x.x.x.x".
+     * Callers that need DNS lookup must perform it themselves.
+     *
+     * If port is set to 0, the socket will be configured for ephemeral send (dynamic
+     * reply-to) and will use the sender's address from the first received datagram for
+     * replies. It is possible to configure the UDP port as a single-direction send port only.
      *
      * Note: delegates to `IpSocket::configure`
      *
-     * \param hostname: socket uses for outgoing transmissions. Must be of form x.x.x.x
+     * \param ipv4_address: IPv4 address (dotted-quad "x.x.x.x") for outgoing transmissions.
      * \param port: port socket uses for outgoing transmissions. Can be 0 for ephemeral reply-to mode.
      * \param send_timeout_seconds: send timeout seconds portion
      * \param send_timeout_microseconds: send timeout microseconds portion. Must be less than 1000000
      * \return status of configure
      */
-    SocketIpStatus configureSend(const char* hostname,
+    SocketIpStatus configureSend(const char* const ipv4_address,
                                  const U16 port,
                                  const U32 send_timeout_seconds,
                                  const U32 send_timeout_microseconds);
 
     /**
      * \brief configure the udp socket for incoming transmissions
      *
-     * Configures the UDP handler to use the given hostname and port for incoming transmissions. Outgoing hostname
-     * and port are configured using the `configureSend` function call for UDP as it requires separate host/port pairs
-     * for outgoing and incoming transmissions. Hostname DNS translation is left up to the caller and thus hostname must
-     * be an IP address in dot-notation of the form "x.x.x.x". It is possible to configure the UDP port as a
-     * single-direction receive port only.
+     * Configures the UDP handler to use the given IPv4 address and port for incoming
+     * transmissions. Outgoing address and port are configured using the `configureSend`
+     * function call for UDP as it requires separate address/port pairs for outgoing and
+     * incoming transmissions.
+     *
+     * \warning DNS resolution is NOT performed by this driver. The \a ipv4_address argument
+     * MUST be a NUL-terminated IPv4 address in dotted-quad notation of the form "x.x.x.x".
+     *
+     * It is possible to configure the UDP port as a single-direction receive port only.
      *
-     * \param hostname: socket uses for incoming transmissions. Must be of form x.x.x.x
+     * \param ipv4_address: IPv4 address (dotted-quad "x.x.x.x") to bind for receiving.
      * \param port: port socket uses for incoming transmissions. Can be 0 for ephemeral port assignment.
      * \return status of configure
      */
-    SocketIpStatus configureRecv(const char* hostname, const U16 port);
+    SocketIpStatus configureRecv(const char* const ipv4_address, const U16 port);
 
     /**
      * \brief get the port being received on