X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Futil%2Fnetwork.c;h=101e794d07c892827182455620e7d30dec5f2b88;hb=555214089c7045298f23fea9e060ea931804e75f;hp=3d2ff51de8c9b982f04e3dc1d20b30d73ab19159;hpb=9edcee802d2b2e1b2ce73f840c84ab84544093b5;p=oweals%2Fgnunet.git

diff --git a/src/util/network.c b/src/util/network.c
index 3d2ff51de..101e794d0 100644
--- a/src/util/network.c
+++ b/src/util/network.c
@@ -33,28 +33,47 @@
 
 #ifndef INVALID_SOCKET
 #define INVALID_SOCKET -1
-#endif /*  */
+#endif
+
+
 struct GNUNET_NETWORK_Handle
 {
+#ifndef MINGW
   int fd;
+
+#else
+  SOCKET fd;
+#endif
+
 };
+
+
 struct GNUNET_NETWORK_FDSet
 {
 
-  /* socket descriptors */
+  /**
+   * Maximum number of any socket socket descriptor in the set
+   */
   int nsds;
+
+  /**
+   * Bitset with the descriptors.
+   */
   fd_set sds;
 
 #ifdef WINDOWS
-  /* handles */
+  /**
+   * Linked list of handles
+   */
   struct GNUNET_CONTAINER_SList *handles;
+#endif
 
-#endif                          /*  */
 };
 
 #ifndef FD_COPY
 #define FD_COPY(s, d) (memcpy ((d), (s), sizeof (fd_set)))
-#endif /*  */
+#endif
+
 
 /**
  * Set if a socket should use blocking or non-blocking IO.
@@ -78,7 +97,7 @@ socket_set_blocking (struct GNUNET_NETWORK_Handle *fd, int doBlock)
     }
   return GNUNET_OK;
 
-#else /*  */
+#else
   /* not MINGW */
   int flags = fcntl (fd->fd, F_GETFL);
   if (flags == -1)
@@ -99,8 +118,7 @@ socket_set_blocking (struct GNUNET_NETWORK_Handle *fd, int doBlock)
       return GNUNET_SYSERR;
     }
   return GNUNET_OK;
-
-#endif /*  */
+#endif
 }
 
 
@@ -116,16 +134,20 @@ static int
 socket_set_inheritable (const struct GNUNET_NETWORK_Handle *h)
 {
   int i;
-  i = fcntl (h->fd, F_GETFD);
+
+  i = fcntl (h->fd, F_GETFD);  
+  if (i < 0)
+    return GNUNET_SYSERR;
   if (i == (i | FD_CLOEXEC))
     return GNUNET_OK;
-  return (fcntl (h->fd, F_SETFD, i | FD_CLOEXEC) == 0)
-    ? GNUNET_OK : GNUNET_SYSERR;
+  i |= FD_CLOEXEC;
+  if (fcntl (h->fd, F_SETFD, i) < 0)
+    return GNUNET_SYSERR;
+  return GNUNET_OK;
 }
+#endif
 
 
-#endif /*  */
-
 #ifdef DARWIN
 /**
  * The MSG_NOSIGNAL equivalent on Mac OS X
@@ -140,10 +162,9 @@ socket_set_nosigpipe (const struct GNUNET_NETWORK_Handle *h)
       setsockopt (h->fd, SOL_SOCKET, SO_NOSIGPIPE, &value, sizeof (value)))
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
 }
+#endif
 
 
-#endif /*  */
-
 /**
  * Disable delays when sending data via the socket.
  * (GNUnet makes sure that messages are as big as
@@ -175,31 +196,26 @@ GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc,
                               socklen_t * address_len)
 {
   struct GNUNET_NETWORK_Handle *ret;
+
   ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle));
   ret->fd = accept (desc->fd, address, address_len);
   if (ret->fd == INVALID_SOCKET)
-
     {
-
 #ifdef MINGW
       SetErrnoFromWinsockError (WSAGetLastError ());
-
-#endif /*  */
+#endif
       GNUNET_free (ret);
       return NULL;
     }
-
 #ifndef MINGW
   if (ret->fd >= FD_SETSIZE)
-
     {
       GNUNET_break (0 == close (ret->fd));
       GNUNET_free (ret);
       errno = EMFILE;
       return NULL;
     }
-
-#endif /*  */
+#endif
   if (GNUNET_SYSERR == socket_set_blocking (ret, GNUNET_NO))
 
     {
@@ -214,13 +230,14 @@ GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc,
   if (GNUNET_OK != socket_set_inheritable (ret))
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                          "socket_set_inheritable");
-
-#endif /*  */
+#endif
 #ifdef DARWIN
   socket_set_nosigpipe (ret);
-
-#endif /*  */
-  socket_set_nodelay (ret);
+#endif
+#ifdef AF_UNIX
+  if (address->sa_family != AF_UNIX)
+#endif
+    socket_set_nodelay (ret);
   return ret;
 }
 
@@ -238,13 +255,23 @@ GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc,
                             socklen_t address_len)
 {
   int ret;
-  ret = bind (desc->fd, address, address_len);
 
+  ret = bind (desc->fd, address, address_len);
 #ifdef MINGW
   if (SOCKET_ERROR == ret)
     SetErrnoFromWinsockError (WSAGetLastError ());
-
-#endif /*  */
+#else
+#ifndef LINUX
+  if ( (ret == 0) && (address->sa_family == AF_UNIX))
+    {
+      const struct sockaddr_un *un = (const struct sockaddr_un*) address;
+      if (0 != unlink (un->sun_path))
+	GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+				  "unlink",
+				  un->sun_path);
+    }
+#endif
+#endif
   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
 }
 
@@ -258,23 +285,41 @@ int
 GNUNET_NETWORK_socket_close (struct GNUNET_NETWORK_Handle *desc)
 {
   int ret;
-  int eno;
 
 #ifdef MINGW
   ret = closesocket (desc->fd);
   SetErrnoFromWinsockError (WSAGetLastError ());
-
-#else /*  */
+#else
   ret = close (desc->fd);
-
-#endif /*  */
-  eno = errno;
+#endif
   GNUNET_free (desc);
-  errno = eno;
   return (ret == 0) ? GNUNET_OK : GNUNET_SYSERR;
 }
 
 
+/**
+ * Box a native socket (and check that it is a socket).
+ *
+ * @param fd socket to box
+ * @return NULL on error (including not supported on target platform)
+ */
+struct GNUNET_NETWORK_Handle *
+GNUNET_NETWORK_socket_box_native (int fd)
+{
+#if MINGW
+  return NULL;
+#else
+  struct GNUNET_NETWORK_Handle *ret;
+
+  if (fcntl (fd, F_GETFD) < 0)
+    return NULL; /* invalid FD */
+  ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle)); 
+  ret->fd = fd;
+  return ret;
+#endif
+}
+
+
 /**
  * Connect a socket
  * @param desc socket
@@ -298,8 +343,7 @@ GNUNET_NETWORK_socket_connect (const struct GNUNET_NETWORK_Handle *desc,
       if (errno == EWOULDBLOCK)
         errno = EINPROGRESS;
     }
-
-#endif /*  */
+#endif
   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
 }
 
@@ -329,7 +373,7 @@ GNUNET_NETWORK_socket_getsockopt (const struct GNUNET_NETWORK_Handle *desc,
   else if (SOCKET_ERROR == ret)
     SetErrnoFromWinsockError (WSAGetLastError ());
 
-#endif /*  */
+#endif
   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
 }
 
@@ -351,11 +395,69 @@ GNUNET_NETWORK_socket_listen (const struct GNUNET_NETWORK_Handle *desc,
   if (SOCKET_ERROR == ret)
     SetErrnoFromWinsockError (WSAGetLastError ());
 
-#endif /*  */
+#endif
   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
 }
 
 
+/**
+ * How much data is available to be read on this descriptor?
+ *
+ * Returns GNUNET_NO if no data is available, or on error!
+ * @param desc socket
+ */
+ssize_t
+GNUNET_NETWORK_socket_recvfrom_amount (const struct GNUNET_NETWORK_Handle
+                                       *desc)
+{
+  int error;
+  int pending;
+
+  /* How much is there to be read? */
+#ifndef WINDOWS
+  error = ioctl (desc->fd, FIONREAD, &pending);
+  if (error == 0)
+#else
+  error = ioctlsocket (desc->fd, FIONREAD, &pending);
+  if (error != SOCKET_ERROR)
+#endif
+    return pending;
+  else
+    return GNUNET_NO;
+}
+
+/**
+ * Read data from a connected socket (always non-blocking).
+ * @param desc socket
+ * @param buffer buffer
+ * @param length length of buffer
+ * @param src_addr either the source to recv from, or all zeroes
+ *        to be filled in by recvfrom
+ * @param addrlen length of the addr
+ */
+ssize_t
+GNUNET_NETWORK_socket_recvfrom (const struct GNUNET_NETWORK_Handle * desc,
+                                void *buffer, size_t length,
+                                struct sockaddr * src_addr,
+                                socklen_t * addrlen)
+{
+  int ret;
+  int flags;
+  flags = 0;
+
+#ifdef MSG_DONTWAIT
+  flags |= MSG_DONTWAIT;
+
+#endif
+  ret = recvfrom (desc->fd, buffer, length, flags, src_addr, addrlen);
+#ifdef MINGW
+  if (SOCKET_ERROR == ret)
+    SetErrnoFromWinsockError (WSAGetLastError ());
+#endif 
+  return ret;
+}
+
+
 /**
  * Read data from a connected socket (always non-blocking).
  * @param desc socket
@@ -372,15 +474,12 @@ GNUNET_NETWORK_socket_recv (const struct GNUNET_NETWORK_Handle * desc,
 
 #ifdef MSG_DONTWAIT
   flags |= MSG_DONTWAIT;
-
-#endif /*  */
+#endif
   ret = recv (desc->fd, buffer, length, flags);
-
 #ifdef MINGW
   if (SOCKET_ERROR == ret)
     SetErrnoFromWinsockError (WSAGetLastError ());
-
-#endif /*  */
+#endif
   return ret;
 }
 
@@ -443,19 +542,15 @@ GNUNET_NETWORK_socket_sendto (const struct GNUNET_NETWORK_Handle * desc,
 
 #ifdef MSG_DONTWAIT
   flags |= MSG_DONTWAIT;
-
-#endif /*  */
+#endif
 #ifdef MSG_NOSIGNAL
   flags |= MSG_NOSIGNAL;
-
-#endif /*  */
+#endif
   ret = sendto (desc->fd, message, length, flags, dest_addr, dest_len);
-
 #ifdef MINGW
   if (SOCKET_ERROR == ret)
     SetErrnoFromWinsockError (WSAGetLastError ());
-
-#endif /*  */
+#endif
   return ret;
 }
 
@@ -476,13 +571,12 @@ GNUNET_NETWORK_socket_setsockopt (struct GNUNET_NETWORK_Handle *fd,
                                   socklen_t option_len)
 {
   int ret;
-  ret = setsockopt (fd->fd, level, option_name, option_value, option_len);
 
+  ret = setsockopt (fd->fd, level, option_name, option_value, option_len);
 #ifdef MINGW
   if (SOCKET_ERROR == ret)
     SetErrnoFromWinsockError (WSAGetLastError ());
-
-#endif /*  */
+#endif
   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
 }
 
@@ -504,20 +598,16 @@ GNUNET_NETWORK_socket_create (int domain, int type, int protocol)
   ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle));
   ret->fd = socket (domain, type, protocol);
   if (INVALID_SOCKET == ret->fd)
-
     {
-
 #ifdef MINGW
       SetErrnoFromWinsockError (WSAGetLastError ());
-
-#endif /*  */
+#endif
       GNUNET_free (ret);
       return NULL;
     }
 
 #ifndef MINGW
   if (ret->fd >= FD_SETSIZE)
-
     {
       GNUNET_break (0 == close (ret->fd));
       GNUNET_free (ret);
@@ -525,11 +615,9 @@ GNUNET_NETWORK_socket_create (int domain, int type, int protocol)
       return NULL;
     }
 
-#endif /*  */
+#endif
   if (GNUNET_SYSERR == socket_set_blocking (ret, GNUNET_NO))
-
     {
-
       /* we might want to treat this one as fatal... */
       GNUNET_break (0);
       GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ret));
@@ -540,13 +628,15 @@ GNUNET_NETWORK_socket_create (int domain, int type, int protocol)
   if (GNUNET_OK != socket_set_inheritable (ret))
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                          "socket_set_inheritable");
-
-#endif /*  */
+#endif
 #ifdef DARWIN
   socket_set_nosigpipe (ret);
-
-#endif /*  */
-  if (type == SOCK_STREAM)
+#endif
+  if ( (type == SOCK_STREAM) 
+#ifdef AF_UNIX
+       && (domain != AF_UNIX) 
+#endif
+       )
     socket_set_nodelay (ret);
   return ret;
 }
@@ -562,13 +652,12 @@ int
 GNUNET_NETWORK_socket_shutdown (struct GNUNET_NETWORK_Handle *desc, int how)
 {
   int ret;
-  ret = shutdown (desc->fd, how);
 
+  ret = shutdown (desc->fd, how);
 #ifdef MINGW
   if (ret != 0)
     SetErrnoFromWinsockError (WSAGetLastError ());
-
-#endif /*  */
+#endif
   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;
 }
 
@@ -582,11 +671,9 @@ GNUNET_NETWORK_fdset_zero (struct GNUNET_NETWORK_FDSet *fds)
 {
   FD_ZERO (&fds->sds);
   fds->nsds = 0;
-
 #ifdef MINGW
   GNUNET_CONTAINER_slist_clear (fds->handles);
-
-#endif /*  */
+#endif
 }
 
 /**
@@ -644,6 +731,7 @@ GNUNET_NETWORK_fdset_add (struct GNUNET_NETWORK_FDSet *dst,
 
 /**
  * Copy one fd set to another
+ *
  * @param to destination
  * @param from source
  */
@@ -657,11 +745,18 @@ GNUNET_NETWORK_fdset_copy (struct GNUNET_NETWORK_FDSet *to,
 #ifdef MINGW
   GNUNET_CONTAINER_slist_clear (to->handles);
   GNUNET_CONTAINER_slist_append (to->handles, from->handles);
-#endif /*  */
+#endif
+}
+
+int
+GNUNET_NETWORK_get_fd (struct GNUNET_NETWORK_Handle *desc)
+{
+  return desc->fd;
 }
 
 /**
  * Copy a native fd set
+ *
  * @param to destination
  * @param from native source set
  * @param nfds the biggest socket number in from + 1
@@ -674,6 +769,38 @@ GNUNET_NETWORK_fdset_copy_native (struct GNUNET_NETWORK_FDSet *to,
   to->nsds = nfds;
 }
 
+
+/**
+ * Set a native fd in a set
+ *
+ * @param to destination
+ * @param nfd native FD to set
+ */
+void GNUNET_NETWORK_fdset_set_native (struct GNUNET_NETWORK_FDSet *to,
+				      int nfd)
+{
+  FD_SET (nfd, &to->sds);
+  to->nsds = GNUNET_MAX (nfd + 1, to->nsds);
+}
+
+
+/**
+ * Test native fd in a set
+ *
+ * @param to set to test, NULL for empty set
+ * @param nfd native FD to test, or -1 for none
+ * @return GNUNET_YES if FD is set in the set
+ */
+int 
+GNUNET_NETWORK_fdset_test_native (const struct GNUNET_NETWORK_FDSet *to,
+				  int nfd)
+{
+  if ( (nfd == -1) || (to == NULL) )
+    return GNUNET_NO;
+  return FD_ISSET (nfd, &to->sds) ? GNUNET_YES : GNUNET_NO;
+}
+
+
 /**
  * Add a file handle to the fd set
  * @param fds fd set
@@ -687,16 +814,18 @@ GNUNET_NETWORK_fdset_handle_set (struct GNUNET_NETWORK_FDSet *fds,
 #ifdef MINGW
   HANDLE hw;
   GNUNET_DISK_internal_file_handle_ (h, &hw, sizeof (HANDLE));
-  GNUNET_CONTAINER_slist_add (fds->handles, GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT, &hw, sizeof (HANDLE));
+  GNUNET_CONTAINER_slist_add (fds->handles,
+                              GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+                              &hw, sizeof (HANDLE));
 
-#else /*  */
+#else
   int fd;
   GNUNET_DISK_internal_file_handle_ (h, &fd, sizeof (int));
   FD_SET (fd, &fds->sds);
   if (fd + 1 > fds->nsds)
     fds->nsds = fd + 1;
 
-#endif /*  */
+#endif
 }
 
 
@@ -714,11 +843,9 @@ GNUNET_NETWORK_fdset_handle_isset (const struct GNUNET_NETWORK_FDSet *fds,
 #ifdef MINGW
   return GNUNET_CONTAINER_slist_contains (fds->handles, &h->h,
                                           sizeof (HANDLE));
-
-#else /*  */
+#else
   return FD_ISSET (h->fd, &fds->sds);
-
-#endif /*  */
+#endif
 }
 
 
@@ -741,20 +868,23 @@ GNUNET_NETWORK_fdset_overlap (const struct GNUNET_NETWORK_FDSet *fds1,
       return GNUNET_YES;
 #ifdef MINGW
   {
-      struct GNUNET_CONTAINER_SList_Iterator *it;
-
-      for(it = GNUNET_CONTAINER_slist_begin (fds1->handles); GNUNET_CONTAINER_slist_end (it) != GNUNET_YES; GNUNET_CONTAINER_slist_next (it))
-        {
-          HANDLE *h;
+    struct GNUNET_CONTAINER_SList_Iterator *it;
 
-          h = GNUNET_CONTAINER_slist_get (it, NULL);
-          if (GNUNET_CONTAINER_slist_contains (fds2->handles, h, sizeof (HANDLE)))
-            {
-              GNUNET_CONTAINER_slist_iter_destroy (it);
-              return GNUNET_YES;
-            }
-        }
-      GNUNET_CONTAINER_slist_iter_destroy (it);
+    for (it = GNUNET_CONTAINER_slist_begin (fds1->handles);
+         GNUNET_CONTAINER_slist_end (it) != GNUNET_YES;
+         GNUNET_CONTAINER_slist_next (it))
+      {
+        HANDLE *h;
+
+        h = GNUNET_CONTAINER_slist_get (it, NULL);
+        if (GNUNET_CONTAINER_slist_contains
+            (fds2->handles, h, sizeof (HANDLE)))
+          {
+            GNUNET_CONTAINER_slist_iter_destroy (it);
+            return GNUNET_YES;
+          }
+      }
+    GNUNET_CONTAINER_slist_iter_destroy (it);
   }
 #endif
   return GNUNET_NO;
@@ -770,11 +900,9 @@ GNUNET_NETWORK_fdset_create ()
 {
   struct GNUNET_NETWORK_FDSet *fds;
   fds = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_FDSet));
-
 #ifdef MINGW
   fds->handles = GNUNET_CONTAINER_slist_create ();
-
-#endif /*  */
+#endif
   GNUNET_NETWORK_fdset_zero (fds);
   return fds;
 }
@@ -787,11 +915,9 @@ GNUNET_NETWORK_fdset_create ()
 void
 GNUNET_NETWORK_fdset_destroy (struct GNUNET_NETWORK_FDSet *fds)
 {
-
 #ifdef MINGW
   GNUNET_CONTAINER_slist_destroy (fds->handles);
-
-#endif /*  */
+#endif
   GNUNET_free (fds);
 }
 
@@ -863,11 +989,12 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
                  (timeout.value == GNUNET_TIME_UNIT_FOREVER_REL.value)
                  ? NULL : &tv);
 
-#else /*  */
+#else
   DWORD limit;
   fd_set sock_read, sock_write, sock_except;
   fd_set aread, awrite, aexcept;
-  struct GNUNET_CONTAINER_SList *handles_read, *handles_write, *handles_except;
+  struct GNUNET_CONTAINER_SList *handles_read, *handles_write,
+    *handles_except;
 
   int i;
   struct timeval tvslice;
@@ -915,7 +1042,6 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
   limit = GetTickCount () + ms_total;
 
   do
-
     {
       retcode = 0;
       if (nfds > 0)
@@ -941,7 +1067,7 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
 #if DEBUG_NETWORK
               GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "select");
 
-#endif /*  */
+#endif
               goto select_loop_end;
             }
         }
@@ -968,15 +1094,15 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
                   GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
                                        "PeekNamedPipe");
 
-#endif /*  */
+#endif
                   goto select_loop_end;
                 }
               else if (dwBytes)
 
                 {
                   GNUNET_CONTAINER_slist_add (handles_read,
-                      GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT, &h,
-                      sizeof (HANDLE));
+                                              GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+                                              &h, sizeof (HANDLE));
                   retcode++;
                 }
             }
@@ -1000,8 +1126,8 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
 
                 {
                   GNUNET_CONTAINER_slist_add (handles_except,
-                      GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT, &h,
-                      sizeof (HANDLE));
+                                              GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+                                              &h, sizeof (HANDLE));
                   retcode++;
                 }
             }
@@ -1050,19 +1176,15 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
   while (retcode == 0 && (ms_total == INFINITE || GetTickCount () < limit));
 
   if (retcode != -1)
-
     {
       if (rfds)
-
         {
           GNUNET_NETWORK_fdset_zero (rfds);
           GNUNET_NETWORK_fdset_copy_native (rfds, &aread, retcode);
           GNUNET_CONTAINER_slist_clear (rfds->handles);
           GNUNET_CONTAINER_slist_append (rfds->handles, handles_read);
-
         }
       if (wfds)
-
         {
           GNUNET_NETWORK_fdset_zero (wfds);
           GNUNET_NETWORK_fdset_copy_native (wfds, &awrite, retcode);
@@ -1070,7 +1192,6 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
           GNUNET_CONTAINER_slist_append (wfds->handles, handles_write);
         }
       if (efds)
-
         {
           GNUNET_NETWORK_fdset_zero (efds);
           GNUNET_NETWORK_fdset_copy_native (efds, &aexcept, retcode);
@@ -1084,8 +1205,7 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
   GNUNET_CONTAINER_slist_destroy (handles_except);
 
   return retcode;
-
-#endif /*  */
+#endif
 }