net: Split makesock(), part 2: Introduce makesock_addrinfo().

This extracts the addressinfo part of makesock() into the new
makesock_addrinfo().  Hence makesock() becomes a simple function
which first calls lookup_address(), then makesock_addrinfo().

The two helper functions lookup_address() and makesock_addrinfo()
can be made public once there is a need for them.

diff --git a/net.c b/net.c
index ccb9632de9a30f566450cea2e4a62e29bd0c530f..2d0c9e22e1a69adeae2759209bbf56f77128b1b7 100644 (file)
--- a/net.c
+++ b/net.c
@@ -397,37 +397,37 @@ static int lookup_address(unsigned l4type, bool passive, const char *host,
        return 1;
 }
 
-/**
- * Resolve IPv4/IPv6 address and create a ready-to-use active or passive socket.
+/*
+ * Create an active or passive socket.
  *
- * \param l4type The layer-4 type (\p IPPROTO_xxx).
- * \param passive Whether this is a passive or active socket.
- * \param host Passed to \ref \a lookup_address().
- * \param port_number Passed to \ref \a lookup_address().
+ * \param l4type \p IPPROTO_TCP, \p IPPROTO_UDP, or \p IPPROTO_DCCP.
+ * \param passive Whether to call bind(2) or connect(2).
+ * \param ai Address information as obtained from \ref lookup_address().
  * \param fo Socket options to be set before making the connection.
  *
- * This creates a ready-made IPv4/v6 socket structure after looking up the
- * necessary parameters.
- *
  * bind(2) is called on passive sockets, and connect(2) on active sockets. The
  * algorithm tries all possible address combinations until it succeeds. If \a
  * fo is supplied, options are set and cleanup is performed.
  *
- * \return Standard.
+ * \return File descriptor on success, \p E_MAKESOCK on errors.
  *
- *  \sa \ref lookup_address(), ipv6(7), getaddrinfo(3), bind(2), connect(2).
+ * \sa \ref lookup_address(), \ref makesock(), ip(7), ipv6(7), bind(2),
+ * connect(2).
  */
-int makesock(unsigned l4type, bool passive,
-            const char *host, uint16_t port_number,
-            struct flowopts *fo)
+static int makesock_addrinfo(unsigned l4type, bool passive, struct addrinfo *ai,
+               struct flowopts *fo)
 {
-       struct addrinfo *local = NULL, *src = NULL, *remote = NULL, *dst = NULL;
-       int rc, on = 1, sockfd = -1;
+       struct addrinfo *local, *remote, *src = NULL, *dst = NULL;
+       int rc = -E_MAKESOCK, on = 1, sockfd = -1;
+
+       if (passive) {
+               local = ai;
+               remote = NULL;
+       } else {
+               local = NULL;
+               remote = ai;
+       }
 
-       rc = lookup_address(l4type, passive, host, port_number, passive?
-               &local : &remote);
-       if (rc < 0)
-               goto out;
        /* Iterate over all src/dst combination, exhausting dst first */
        for (src = local, dst = remote; src != NULL || dst != NULL; /* no op */ ) {
                if (src && dst && src->ai_family == AF_INET
@@ -474,24 +474,52 @@ get_next_src:
                if (src && (src = src->ai_next)) /* restart inner loop */
                        dst = remote;
        }
-out:
-       if (local)
-               freeaddrinfo(local);
-       if (remote)
-               freeaddrinfo(remote);
-       flowopt_cleanup(fo);
-
        if (src == NULL && dst == NULL) {
                if (rc >= 0)
                        rc = -E_MAKESOCK;
-               PARA_ERROR_LOG("can not create %s socket %s#%d.\n",
-                       layer4_name(l4type), host? host : (passive?
-                       "[loopback]" : "[localhost]"), port_number);
                return rc;
        }
        return sockfd;
 }
 
+/**
+ * Resolve IPv4/IPv6 address and create a ready-to-use active or passive socket.
+ *
+ * \param l4type The layer-4 type (\p IPPROTO_xxx).
+ * \param passive Whether this is a passive or active socket.
+ * \param host Passed to \ref lookup_address().
+ * \param port_number Passed to \ref lookup_address().
+ * \param fo Passed to \ref makesock_addrinfo().
+ *
+ * This creates a ready-made IPv4/v6 socket structure after looking up the
+ * necessary parameters. The function first calls \ref lookup_address() and
+ * passes the address information to makesock_addrinfo() to create and
+ * initialize the socket.
+ *
+ * \return The newly created file descriptor on success, a negative error code
+ * on failure.
+ *
+ * \sa \ref lookup_address(), \ref makesock_addrinfo().
+ */
+int makesock(unsigned l4type, bool passive, const char *host, uint16_t port_number,
+               struct flowopts *fo)
+{
+       struct addrinfo *ai;
+       int ret = lookup_address(l4type, passive, host, port_number, &ai);
+
+       if (ret >= 0)
+               ret = makesock_addrinfo(l4type, passive, ai, fo);
+       if (ai)
+               freeaddrinfo(ai);
+       flowopt_cleanup(fo);
+       if (ret < 0) {
+               PARA_ERROR_LOG("can not create %s socket %s#%d.\n",
+               layer4_name(l4type), host? host : (passive?
+               "[loopback]" : "[localhost]"), port_number);
+       }
+       return ret;
+}
+
 /**
  * Create a passive / listening socket.
  *