making flags, set non-blocking and set-inheritable internal issues of network.c

diff --git a/src/include/gnunet_network_lib.h b/src/include/gnunet_network_lib.h
index e4ba5585499598870c5327e28486b7ad111fa9ae..513787e082d582ec8f175f7dae92fe28731238a8 100644 (file)
--- a/src/include/gnunet_network_lib.h
+++ b/src/include/gnunet_network_lib.h
@@ -51,8 +51,11 @@ struct GNUNET_NETWORK_FDSet;
 #include "gnunet_disk_lib.h"
 #include "gnunet_time_lib.h"
 
+
 /**
- * accept a new connection on a socket
+ * Accept a new connection on a socket.  Configure it for non-blocking
+ * IO and mark it as non-inheritable to child processes (set the
+ * close-on-exec flag).
  *
  * @param desc bound socket
  * @param address address of the connecting peer, may be NULL
@@ -64,17 +67,6 @@ GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc,
                              struct sockaddr *address,
                              socklen_t *address_len);
 
-/**
- * Make a non-inheritable to child processes (sets the
- * close-on-exec flag).
- *
- * @param h the socket to make non-inheritable
- * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
- * @warning Not implemented on Windows
- */
-int
-GNUNET_NETWORK_socket_set_inheritable (const struct GNUNET_NETWORK_Handle
-                                       *h);
 
 /**
  * Bind to a connected socket
@@ -88,7 +80,7 @@ int GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc,
                     const struct sockaddr *address, socklen_t address_len);
 
 /**
- * Close a socket
+ * Close a socket.
  *
  * @param desc socket to close
  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
@@ -132,16 +124,15 @@ int GNUNET_NETWORK_socket_getsockopt(const struct GNUNET_NETWORK_Handle *desc, i
 int GNUNET_NETWORK_socket_listen (const struct GNUNET_NETWORK_Handle *desc, int backlog);
 
 /**
- * Read data from a connected socket
+ * Read data from a connected socket (always non-blocking).
  *
  * @param desc socket
  * @param buffer buffer
  * @param length length of buffer
- * @param flags type of message reception
  * @return number of bytes read
  */
 ssize_t GNUNET_NETWORK_socket_recv (const struct GNUNET_NETWORK_Handle *desc, void *buffer,
-                        size_t length, int flags);
+                                   size_t length);
 
 /**
  * Check if sockets meet certain conditions
@@ -155,38 +146,32 @@ int GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
     struct GNUNET_NETWORK_FDSet *wfds, struct GNUNET_NETWORK_FDSet *efds,
     struct GNUNET_TIME_Relative timeout);
 
-/**
- * Set if a socket should use blocking or non-blocking IO.
- * @param fd socket
- * @param doBlock blocking mode
- * @return GNUNET_OK on success, GNUNET_SYSERR on error
- */
-int GNUNET_NETWORK_socket_set_blocking (struct GNUNET_NETWORK_Handle *fd, 
-                                       int doBlock);
+
 
 /**
- * Send data
+ * Send data (always non-blocking).
+ *
  * @param desc socket
  * @param buffer data to send
  * @param length size of the buffer
- * @param flags type of message transmission
  * @return number of bytes sent, GNUNET_SYSERR on error
  */
 ssize_t GNUNET_NETWORK_socket_send (const struct GNUNET_NETWORK_Handle *desc,
-                        const void *buffer, size_t length, int flags);
+                        const void *buffer, size_t length);
 
 /**
- * Send data
+ * Send data to a particular destination (always non-blocking).
+ * This function only works for UDP sockets.
+ *
  * @param desc socket
  * @param message data to send
  * @param length size of the data
- * @param flags type of message transmission
  * @param dest_addr destination address
  * @param dest_len length of address
  * @return number of bytes sent, GNUNET_SYSERR on error
  */
 ssize_t GNUNET_NETWORK_socket_sendto (const struct GNUNET_NETWORK_Handle *desc,
-                          const void *message, size_t length, int flags,
+                          const void *message, size_t length, 
                           const struct sockaddr *dest_addr,
                           socklen_t dest_len);
 
@@ -210,14 +195,18 @@ int GNUNET_NETWORK_socket_setsockopt(struct GNUNET_NETWORK_Handle *fd, int level
  */
 int GNUNET_NETWORK_socket_shutdown (struct GNUNET_NETWORK_Handle *desc, int how);
 
+
 /**
- * Create a new socket
+ * Create a new socket.   Configure it for non-blocking IO and
+ * mark it as non-inheritable to child processes (set the
+ * close-on-exec flag).
+ *
  * @param domain domain of the socket
  * @param type socket type
  * @param protocol network protocol
  * @return new socket, NULL on error
  */
-struct GNUNET_NETWORK_Handle *GNUNET_NETWORK_socket_socket (int domain, int type, int protocol);
+struct GNUNET_NETWORK_Handle *GNUNET_NETWORK_socket_create (int domain, int type, int protocol);
 
 /**
  * Reset FD set (clears all file descriptors).

diff --git a/src/util/connection.c b/src/util/connection.c
index 1e2f1fca8c3f20f5662b371f24c6c63c86613168..ad2bf14c0ee824ceafc4a0d5084fe49c60faa14d 100644 (file)
--- a/src/util/connection.c
+++ b/src/util/connection.c
@@ -342,11 +342,6 @@ GNUNET_CONNECTION_create_from_accept (struct GNUNET_SCHEDULER_Handle
       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "accept");
       return NULL;
     }
-#ifndef MINGW
-  if (GNUNET_OK != GNUNET_NETWORK_socket_set_inheritable (sock))
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                         "fcntl");
-#endif
   if (addrlen > sizeof (addr))
     {
       GNUNET_break (0);
@@ -797,25 +792,12 @@ try_connect_using_address (void *cls,
       GNUNET_free (ap);
       return; /* not supported by us */
     }
-  ap->sock = GNUNET_NETWORK_socket_socket (ap->addr->sa_family, SOCK_STREAM, 0);
+  ap->sock = GNUNET_NETWORK_socket_create (ap->addr->sa_family, SOCK_STREAM, 0);
   if (ap->sock == NULL)
     {
       GNUNET_free (ap);
       return; /* not supported by OS */
     }
-#ifndef MINGW
-  if (GNUNET_OK != GNUNET_NETWORK_socket_set_inheritable (ap->sock))
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                        "GNUNET_NETWORK_socket_set_inheritable");
-#endif
-  if (GNUNET_SYSERR == GNUNET_NETWORK_socket_set_blocking (ap->sock, GNUNET_NO))
-    {
-      /* we might want to treat this one as fatal... */
-      GNUNET_break (0);
-      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ap->sock));
-      GNUNET_free (ap);
-      return; 
-    }
 #if DEBUG_CONNECTION
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _("Trying to connect to `%s' (%p)\n"),
@@ -932,27 +914,13 @@ GNUNET_CONNECTION_create_from_sockaddr (struct GNUNET_SCHEDULER_Handle
   struct GNUNET_NETWORK_Handle *s;
   struct GNUNET_CONNECTION_Handle *ret;
 
-  s = GNUNET_NETWORK_socket_socket (af_family, SOCK_STREAM, 0);
+  s = GNUNET_NETWORK_socket_create (af_family, SOCK_STREAM, 0);
   if (s == NULL)
     {
       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING |
                            GNUNET_ERROR_TYPE_BULK, "socket");
       return NULL;
     }
-#ifndef MINGW
-#if 0
-  // FIXME NILS
-  if (0 != fcntl (s, F_SETFD, fcntl (s, F_GETFD) | FD_CLOEXEC))
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                         "fcntl");
-#endif
-#endif
-  if (GNUNET_SYSERR == GNUNET_NETWORK_socket_set_blocking (s, GNUNET_NO))
-    {
-      /* we'll treat this one as fatal */
-      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (s));
-      return NULL;
-    }
   if ((GNUNET_OK != GNUNET_NETWORK_socket_connect (s, serv_addr, addrlen)) && (errno != EINPROGRESS))
     {
       /* maybe refused / unsupported address, try next */
@@ -1093,14 +1061,7 @@ receive_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     }
   GNUNET_assert (GNUNET_NETWORK_fdset_isset (tc->read_ready, sh->sock));
 RETRY:
-  ret = GNUNET_NETWORK_socket_recv (sh->sock, buffer, sh->max,
-#ifndef MINGW
-      // FIXME MINGW
-      MSG_DONTWAIT
-#else
-      0
-#endif
-      );
+  ret = GNUNET_NETWORK_socket_recv (sh->sock, buffer, sh->max);
   if (ret == -1)
     {
       if (errno == EINTR)
@@ -1418,14 +1379,7 @@ transmit_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 RETRY:
   ret = GNUNET_NETWORK_socket_send (sock->sock,
                                    &sock->write_buffer[sock->write_buffer_pos],
-                                   have,
-#ifndef MINGW
-              // FIXME NILS
-              MSG_DONTWAIT | MSG_NOSIGNAL
-#else
-              0
-#endif
-  );
+                                   have);
   if (ret == -1)
     {
       if (errno == EINTR)

diff --git a/src/util/network.c b/src/util/network.c
index 8bdace580b7c740b6a34cfb3dc1e873d7dd4aac7..9a38dc098b5a586d8b9f38fac544272c6be827b2 100644 (file)
--- a/src/util/network.c
+++ b/src/util/network.c
@@ -55,6 +55,75 @@ struct GNUNET_NETWORK_FDSet
 #define FD_COPY(s, d) (memcpy ((d), (s), sizeof (fd_set)))\r
 #endif\r
 \r
+\r
+\r
+/**\r
+ * Set if a socket should use blocking or non-blocking IO.\r
+ * @param fd socket\r
+ * @param doBlock blocking mode\r
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error\r
+ */\r
+static int\r
+socket_set_blocking (struct GNUNET_NETWORK_Handle *fd,\r
+                    int doBlock)\r
+{\r
+#if MINGW\r
+  u_long mode;\r
+  mode = !doBlock;\r
+  if (ioctlsocket (fd->fd, FIONBIO, &mode) == SOCKET_ERROR)\r
+    {\r
+      SetErrnoFromWinsockError (WSAGetLastError ());\r
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "ioctlsocket");\r
+      return GNUNET_SYSERR;\r
+    }\r
+  return GNUNET_OK;\r
+\r
+#else\r
+  /* not MINGW */\r
+  int flags = fcntl (fd->fd, F_GETFL);\r
+  if (flags == -1)\r
+    {\r
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");\r
+      return GNUNET_SYSERR;\r
+    }\r
+  if (doBlock)\r
+    flags &= ~O_NONBLOCK;\r
+  else\r
+    flags |= O_NONBLOCK;\r
+  if (0 != fcntl (fd->fd, F_SETFL, flags))\r
+    {\r
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");\r
+      return GNUNET_SYSERR;\r
+    }\r
+  return GNUNET_OK;\r
+#endif\r
+}\r
+\r
+\r
+#ifndef MINGW\r
+/**\r
+ * Make a non-inheritable to child processes\r
+ *\r
+ * @param h the socket to make non-inheritable\r
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
+ * @warning Not implemented on Windows\r
+ */\r
+static int\r
+socket_set_inheritable (const struct GNUNET_NETWORK_Handle\r
+                                       *h)\r
+{\r
+  int i;\r
+\r
+  i = fcntl (h->fd, F_GETFD);\r
+  if (i == (i | FD_CLOEXEC))\r
+    return GNUNET_OK;\r
+  return (fcntl (h->fd, F_SETFD, i | FD_CLOEXEC) == 0)\r
+    ? GNUNET_OK : GNUNET_SYSERR;\r
+}\r
+#endif\r
+\r
+\r
+\r
 /**\r
  * accept a new connection on a socket\r
  *\r
@@ -88,6 +157,18 @@ GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc,
       errno = EMFILE;\r
       return NULL;\r
     }\r
+#endif\r
+  if (GNUNET_SYSERR == socket_set_blocking (ret, GNUNET_NO))\r
+    {\r
+      /* we might want to treat this one as fatal... */\r
+      GNUNET_break (0);\r
+      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ret));\r
+      return NULL; \r
+    }\r
+#ifndef MINGW\r
+  if (GNUNET_OK != socket_set_inheritable (ret))\r
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,\r
+                        "socket_set_inheritable");\r
 #endif\r
   return ret;\r
 }\r
@@ -114,47 +195,6 @@ GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc,
   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
 }\r
 \r
-/**\r
- * Set if a socket should use blocking or non-blocking IO.\r
- * @param fd socket\r
- * @param doBlock blocking mode\r
- * @return GNUNET_OK on success, GNUNET_SYSERR on error\r
- */\r
-int\r
-GNUNET_NETWORK_socket_set_blocking (struct GNUNET_NETWORK_Handle *fd,\r
-                                    int doBlock)\r
-{\r
-#if MINGW\r
-  u_long mode;\r
-  mode = !doBlock;\r
-  if (ioctlsocket (fd->fd, FIONBIO, &mode) == SOCKET_ERROR)\r
-    {\r
-      SetErrnoFromWinsockError (WSAGetLastError ());\r
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "ioctlsocket");\r
-      return GNUNET_SYSERR;\r
-    }\r
-  return GNUNET_OK;\r
-\r
-#else\r
-  /* not MINGW */\r
-  int flags = fcntl (fd->fd, F_GETFL);\r
-  if (flags == -1)\r
-    {\r
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");\r
-      return GNUNET_SYSERR;\r
-    }\r
-  if (doBlock)\r
-    flags &= ~O_NONBLOCK;\r
-  else\r
-    flags |= O_NONBLOCK;\r
-  if (0 != fcntl (fd->fd, F_SETFL, flags))\r
-    {\r
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");\r
-      return GNUNET_SYSERR;\r
-    }\r
-  return GNUNET_OK;\r
-#endif\r
-}\r
 \r
 /**\r
  * Close a socket\r
@@ -207,6 +247,7 @@ GNUNET_NETWORK_socket_connect (const struct GNUNET_NETWORK_Handle *desc,
 \r
 /**\r
  * Get socket options\r
+ *\r
  * @param desc socket\r
  * @param level protocol level of the option\r
  * @param optname identifier of the option\r
@@ -253,18 +294,22 @@ GNUNET_NETWORK_socket_listen (const struct GNUNET_NETWORK_Handle *desc,
 }\r
 \r
 /**\r
- * Read data from a connected socket\r
+ * Read data from a connected socket (always non-blocking).\r
  * @param desc socket\r
  * @param buffer buffer\r
  * @param length length of buffer\r
- * @param flags type of message reception\r
  */\r
 ssize_t\r
 GNUNET_NETWORK_socket_recv (const struct GNUNET_NETWORK_Handle * desc,\r
-                            void *buffer, size_t length, int flags)\r
+                            void *buffer, size_t length)\r
 {\r
   int ret;\r
+  int flags;\r
 \r
+  flags = 0;\r
+#ifdef MSG_DONTWAIT\r
+  flags |= MSG_DONTWAIT;\r
+#endif\r
   ret = recv (desc->fd, buffer, length, flags);\r
 #ifdef MINGW\r
   if (SOCKET_ERROR == ret)\r
@@ -275,19 +320,27 @@ GNUNET_NETWORK_socket_recv (const struct GNUNET_NETWORK_Handle * desc,
 }\r
 \r
 /**\r
- * Send data\r
+ * Send data (always non-blocking).\r
+ *\r
  * @param desc socket\r
  * @param buffer data to send\r
  * @param length size of the buffer\r
- * @param flags type of message transmission\r
  * @return number of bytes sent, GNUNET_SYSERR on error\r
  */\r
 ssize_t\r
 GNUNET_NETWORK_socket_send (const struct GNUNET_NETWORK_Handle * desc,\r
-                            const void *buffer, size_t length, int flags)\r
+                            const void *buffer, size_t length)\r
 {\r
   int ret;\r
+  int flags;\r
 \r
+  flags = 0;\r
+#ifdef MSG_DONTWAIT\r
+  flags |= MSG_DONTWAIT;\r
+#endif\r
+#ifdef MSG_NOSIGNAL\r
+  flags |= MSG_NOSIGNAL;\r
+#endif\r
   ret = send (desc->fd, buffer, length, flags);\r
 #ifdef MINGW\r
   if (SOCKET_ERROR == ret)\r
@@ -297,24 +350,34 @@ GNUNET_NETWORK_socket_send (const struct GNUNET_NETWORK_Handle * desc,
   return ret;\r
 }\r
 \r
+\r
 /**\r
- * Send data\r
+ * Send data to a particular destination (always non-blocking).\r
+ * This function only works for UDP sockets.\r
+ *\r
  * @param desc socket\r
  * @param message data to send\r
  * @param length size of the data\r
- * @param flags type of message transmission\r
  * @param dest_addr destination address\r
  * @param dest_len length of address\r
  * @return number of bytes sent, GNUNET_SYSERR on error\r
  */\r
 ssize_t\r
 GNUNET_NETWORK_socket_sendto (const struct GNUNET_NETWORK_Handle * desc,\r
-                              const void *message, size_t length, int flags,\r
+                              const void *message, size_t length,\r
                               const struct sockaddr * dest_addr,\r
                               socklen_t dest_len)\r
 {\r
   int ret;\r
+  int flags;\r
 \r
+  flags = 0;\r
+#ifdef MSG_DONTWAIT\r
+  flags |= MSG_DONTWAIT;\r
+#endif\r
+#ifdef MSG_NOSIGNAL\r
+  flags |= MSG_NOSIGNAL;\r
+#endif\r
   ret = sendto (desc->fd, message, length, flags, dest_addr, dest_len);\r
 #ifdef MINGW\r
   if (SOCKET_ERROR == ret)\r
@@ -350,15 +413,20 @@ GNUNET_NETWORK_socket_setsockopt (struct GNUNET_NETWORK_Handle *fd,
   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
 }\r
 \r
+\r
+\r
 /**\r
- * Create a new socket\r
+ * Create a new socket.  Configure it for non-blocking IO and\r
+ * mark it as non-inheritable to child processes (set the\r
+ * close-on-exec flag).\r
+ *\r
  * @param domain domain of the socket\r
  * @param type socket type\r
  * @param protocol network protocol\r
  * @return new socket, NULL on error\r
  */\r
 struct GNUNET_NETWORK_Handle *\r
-GNUNET_NETWORK_socket_socket (int domain, int type, int protocol)\r
+GNUNET_NETWORK_socket_create (int domain, int type, int protocol)\r
 {\r
   struct GNUNET_NETWORK_Handle *ret;\r
 \r
@@ -381,6 +449,20 @@ GNUNET_NETWORK_socket_socket (int domain, int type, int protocol)
       return NULL;\r
     }\r
 #endif\r
+\r
+  if (GNUNET_SYSERR == socket_set_blocking (ret, GNUNET_NO))\r
+    {\r
+      /* we might want to treat this one as fatal... */\r
+      GNUNET_break (0);\r
+      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ret));\r
+      return NULL; \r
+    }\r
+#ifndef MINGW\r
+  if (GNUNET_OK != socket_set_inheritable (ret))\r
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,\r
+                        "socket_set_inheritable");\r
+#endif\r
+\r
   return ret;\r
 }\r
 \r
@@ -405,31 +487,6 @@ GNUNET_NETWORK_socket_shutdown (struct GNUNET_NETWORK_Handle *desc,
   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
 }\r
 \r
-/**\r
- * Make a non-inheritable to child processes\r
- *\r
- * @param h the socket to make non-inheritable\r
- * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
- * @warning Not implemented on Windows\r
- */\r
-int\r
-GNUNET_NETWORK_socket_set_inheritable (const struct GNUNET_NETWORK_Handle\r
-                                       *h)\r
-{\r
-#ifdef MINGW\r
-  errno = ENOSYS;\r
-  return GNUNET_SYSERR;\r
-#else\r
-  int i;\r
-\r
-  i = fcntl (h->fd, F_GETFD);\r
-  if (i == (i | FD_CLOEXEC))\r
-    return GNUNET_OK;\r
-  return (fcntl (h->fd, F_SETFD, i | FD_CLOEXEC) == 0)\r
-    ? GNUNET_OK : GNUNET_SYSERR;\r
-#endif\r
-}\r
-\r
 \r
 /**\r
  * Reset FD set\r

diff --git a/src/util/server.c b/src/util/server.c
index 7214b1939982aa62a703f4d4642ed4463ed9e85c..646299718d79347ff4f687992f6b6c557180cd99 100644 (file)
--- a/src/util/server.c
+++ b/src/util/server.c
@@ -382,17 +382,12 @@ open_listen_socket (const struct sockaddr *serverAddr, socklen_t socklen)
       GNUNET_break (0);
       return NULL;
     }
-  sock = GNUNET_NETWORK_socket_socket (serverAddr->sa_family, SOCK_STREAM, 0);
+  sock = GNUNET_NETWORK_socket_create (serverAddr->sa_family, SOCK_STREAM, 0);
   if (NULL == sock)
     {
       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
       return NULL;
     }
-#ifndef MINGW
-  if (GNUNET_OK != GNUNET_NETWORK_socket_set_inheritable (sock))
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                         "fcntl");
-#endif
   if (GNUNET_NETWORK_socket_setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                          "setsockopt");

diff --git a/src/util/service.c b/src/util/service.c
index 36a1f05b104443fff75a7e4a7b75ff5ad9ee40ec..ee15da2681905960e260b714082a7753590adff2 100644 (file)
--- a/src/util/service.c
+++ b/src/util/service.c
@@ -815,7 +815,7 @@ setup_service (struct GNUNET_SERVICE_Context *sctx)
   if (!disablev6)
     {
       /* probe IPv6 support */
-      desc = GNUNET_NETWORK_socket_socket (PF_INET6, SOCK_STREAM, 0);
+      desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0);
       if (NULL == desc)
         {
           if ((errno == ENOBUFS) ||

diff --git a/src/util/test_connection.c b/src/util/test_connection.c
index 549b3b840d2bd11d37ef682260e64a454e25788a..30eee76ce2c4a5500d1207cd1a3525f1e6936ac2 100644 (file)
--- a/src/util/test_connection.c
+++ b/src/util/test_connection.c
@@ -62,7 +62,7 @@ open_listen_socket ()
 #endif
   sa.sin_port = htons (PORT);
   sa.sin_family = AF_INET;
-  desc = GNUNET_NETWORK_socket_socket (AF_INET, SOCK_STREAM, 0);
+  desc = GNUNET_NETWORK_socket_create (AF_INET, SOCK_STREAM, 0);
   GNUNET_assert (desc != NULL);
   if (GNUNET_NETWORK_socket_setsockopt (desc, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,

diff --git a/src/util/test_connection_addressing.c b/src/util/test_connection_addressing.c
index ce44e6acf7e5df96d2c064ca62ddc1c76865af50..f37352c67b168bc597cb14ac3d0fb76d017e4b1d 100644 (file)
--- a/src/util/test_connection_addressing.c
+++ b/src/util/test_connection_addressing.c
@@ -61,7 +61,7 @@ open_listen_socket ()
   sa.sin_len = sizeof (sa);
 #endif
   sa.sin_port = htons (PORT);
-  desc = GNUNET_NETWORK_socket_socket (AF_INET, SOCK_STREAM, 0);
+  desc = GNUNET_NETWORK_socket_create (AF_INET, SOCK_STREAM, 0);
   GNUNET_assert (desc != 0);
   if (GNUNET_NETWORK_socket_setsockopt (desc, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,

diff --git a/src/util/test_connection_receive_cancel.c b/src/util/test_connection_receive_cancel.c
index 6434228f7b3dc198b98715b48eeb7c561dc9c1b6..e985bf935b41e0a77b0b099329d5941f0a1d6cee 100644 (file)
--- a/src/util/test_connection_receive_cancel.c
+++ b/src/util/test_connection_receive_cancel.c
@@ -60,7 +60,7 @@ open_listen_socket ()
   sa.sin_len = sizeof (sa);
 #endif
   sa.sin_port = htons (PORT);
-  desc = GNUNET_NETWORK_socket_socket (AF_INET, SOCK_STREAM, 0);
+  desc = GNUNET_NETWORK_socket_create (AF_INET, SOCK_STREAM, 0);
   GNUNET_assert (desc != NULL);
   if (GNUNET_NETWORK_socket_setsockopt (desc, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,

diff --git a/src/util/test_connection_timeout.c b/src/util/test_connection_timeout.c
index 73433e434b2e2bdda492c8cbc1c3940098eed95e..5968f797fe5929262d713b39178aad56ed114185 100644 (file)
--- a/src/util/test_connection_timeout.c
+++ b/src/util/test_connection_timeout.c
@@ -57,7 +57,7 @@ open_listen_socket ()
   sa.sin_len = sizeof (sa);
 #endif
   sa.sin_port = htons (PORT);
-  desc = GNUNET_NETWORK_socket_socket (AF_INET, SOCK_STREAM, 0);
+  desc = GNUNET_NETWORK_socket_create (AF_INET, SOCK_STREAM, 0);
   GNUNET_assert (desc != NULL);
   if (GNUNET_NETWORK_socket_setsockopt (desc, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) != GNUNET_OK)
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,

diff --git a/src/util/test_service.c b/src/util/test_service.c
index e9070a912191d68fa9a86d36efd30f5a8a71340d..f615b0cf9e315225495e4ce009efe470c735be10 100644 (file)
--- a/src/util/test_service.c
+++ b/src/util/test_service.c
@@ -311,7 +311,7 @@ main (int argc, char *argv[])
                     NULL);
   ret += check ();
   ret += check ();
-  s = GNUNET_NETWORK_socket_socket (PF_INET6, SOCK_STREAM, 0);
+  s = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0);
   if (NULL == s)
     {
       if ((errno == ENOBUFS) ||