net: Let maksock() callers perform flowopt cleanup.

[paraslash.git] / net.c

diff --git a/net.c b/net.c
index 740dfa182d4a162f2b493ac77ecebc8140c6f0ae..70cf6a87dfb27bbba74912bb50467a0a74f966bd 100644 (file)
--- a/net.c
+++ b/net.c
@@ -12,6 +12,11 @@
  */
 #define _GNU_SOURCE
 
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <sys/un.h>
+#include <sys/types.h>
+#include <sys/socket.h>
 #include <netdb.h>
 
 /* At least NetBSD needs these. */
@@ -328,7 +333,14 @@ static void flowopt_setopts(int sockfd, struct flowopts *fo)
                }
 }
 
-static void flowopt_cleanup(struct flowopts *fo)
+/**
+ * Deallocate all resources of a flowopts structure.
+ *
+ * \param fo A pointer as returned from flowopt_new().
+ *
+ * It's OK to pass \p NULL here in which case the function does nothing.
+ */
+void flowopt_cleanup(struct flowopts *fo)
 {
        struct pre_conn_opt *cur, *next;
 
@@ -407,7 +419,7 @@ static int lookup_address(unsigned l4type, bool passive, const char *host,
  *
  * 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.
+ * fo is supplied, options are set but cleanup must be performed in the caller.
  *
  * \return File descriptor on success, \p E_MAKESOCK on errors.
  *
@@ -417,65 +429,38 @@ static int lookup_address(unsigned l4type, bool passive, const char *host,
 static int makesock_addrinfo(unsigned l4type, bool passive, struct addrinfo *ai,
                struct flowopts *fo)
 {
-       struct addrinfo *local, *remote, *src = NULL, *dst = NULL;
-       int ret = -E_MAKESOCK, on = 1, sockfd = -1;
-
-       if (passive) {
-               local = ai;
-               remote = NULL;
-       } else {
-               local = NULL;
-               remote = ai;
-       }
-
-       /* 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
-                               && dst->ai_family == AF_INET6)
-                       goto get_next_dst; /* v4 -> v6 is not possible */
+       int ret = -E_MAKESOCK, on = 1;
 
-               ret = socket(src ? src->ai_family : dst->ai_family,
-                       sock_type(l4type), l4type);
+       for (; ai; ai = ai->ai_next) {
+               int fd;
+               ret = socket(ai->ai_family, sock_type(l4type), l4type);
                if (ret < 0)
-                       goto get_next_dst;
-               sockfd = ret;
+                       continue;
+               fd = ret;
+               flowopt_setopts(fd, fo);
+               if (!passive) {
+                       if (connect(fd, ai->ai_addr, ai->ai_addrlen) == 0)
+                               return fd;
+                       close(fd);
+                       continue;
+               }
                /*
                 * Reuse the address on passive sockets to avoid failure on
                 * restart (protocols using listen()) and when creating
                 * multiple listener instances (UDP multicast).
                 */
-               if (passive && setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,
-                                                 &on, sizeof(on)) == -1) {
-                       ret = -ERRNO_TO_PARA_ERROR(errno);
-                       close(sockfd);
-                       PARA_ERROR_LOG("can not set SO_REUSEADDR: %s\n",
-                               para_strerror(-ret));
-                       break;
-               }
-               flowopt_setopts(sockfd, fo);
-
-               if (src) {
-                       if (bind(sockfd, src->ai_addr, src->ai_addrlen) < 0) {
-                               close(sockfd);
-                               goto get_next_src;
-                       }
-                       if (!dst) /* bind-only completed successfully */
-                               break;
+               if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on,
+                               sizeof(on)) == -1) {
+                       close(fd);
+                       continue;
                }
-
-               if (dst && connect(sockfd, dst->ai_addr, dst->ai_addrlen) == 0)
-                       break; /* connection completed successfully */
-               close(sockfd);
-get_next_dst:
-               if (dst && (dst = dst->ai_next))
+               if (bind(fd, ai->ai_addr, ai->ai_addrlen) < 0) {
+                       close(fd);
                        continue;
-get_next_src:
-               if (src && (src = src->ai_next)) /* restart inner loop */
-                       dst = remote;
+               }
+               return fd;
        }
-       if (src == NULL && dst == NULL)
-               return ret < 0? ret : -E_MAKESOCK;
-       return sockfd;
+       return -E_MAKESOCK;
 }
 
 /**
@@ -507,7 +492,6 @@ int makesock(unsigned l4type, bool passive, const char *host, uint16_t port_numb
                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?