src/util/network.c

   1 /*\r
   2      This file is part of GNUnet.\r
   3      (C) 2009 Christian Grothoff (and other contributing authors)\r
   4 \r
   5      GNUnet is free software; you can redistribute it and/or modify\r
   6      it under the terms of the GNU General Public License as published\r
   7      by the Free Software Foundation; either version 2, or (at your\r
   8      option) any later version.\r
   9 \r
  10      GNUnet is distributed in the hope that it will be useful, but\r
  11      WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\r
  13      General Public License for more details.\r
  14 \r
  15      You should have received a copy of the GNU General Public License\r
  16      along with GNUnet; see the file COPYING.  If not, write to the\r
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,\r
  18      Boston, MA 02111-1307, USA.\r
  19 */\r
  20 \r
  21 /**\r
  22  * @file util/network.c\r
  23  * @brief basic, low-level networking interface\r
  24  * @author Nils Durner\r
  25  */\r
  26 \r
  27 #include "platform.h"\r
  28 #include "gnunet_disk_lib.h"\r
  29 #include "disk.h"\r
  30 #include "gnunet_container_lib.h"\r
  31 \r
  32 #define DEBUG_SOCK GNUNET_NO\r
  33 \r
  34 struct GNUNET_NETWORK_Handle\r
  35 {\r
  36   int fd;\r
  37 };\r
  38 \r
  39 struct GNUNET_NETWORK_FDSet\r
  40 {\r
  41   /* socket descriptors */\r
  42   int nsds;\r
  43   fd_set sds;\r
  44 #ifdef WINDOWS\r
  45   /* handles */\r
  46   struct GNUNET_CONTAINER_SList *handles;\r
  47 #endif\r
  48 };\r
  49 \r
  50 #ifndef FD_COPY\r
  51 #define FD_COPY(s, d) (memcpy ((d), (s), sizeof (fd_set)))\r
  52 #endif\r
  53 \r
  54 /**\r
  55  * accept a new connection on a socket\r
  56  *\r
  57  * @param desc bound socket\r
  58  * @param address address of the connecting peer, may be NULL\r
  59  * @param address_len length of address\r
  60  * @return client socket\r
  61  */\r
  62 struct GNUNET_NETWORK_Handle *\r
  63 GNUNET_NETWORK_socket_accept (const struct GNUNET_NETWORK_Handle *desc,\r
  64                               struct sockaddr *address,\r
  65                               socklen_t * address_len)\r
  66 {\r
  67   struct GNUNET_NETWORK_Handle *ret;\r
  68 \r
  69   ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle));\r
  70   ret->fd = accept (desc->fd, address, address_len);\r
  71 #ifdef MINGW\r
  72   if (INVALID_SOCKET == ret->fd)\r
  73     SetErrnoFromWinsockError (WSAGetLastError ());\r
  74 #endif\r
  75   return ret;\r
  76 }\r
  77 \r
  78 /**\r
  79  * Bind to a connected socket\r
  80  * @param desc socket\r
  81  * @param address address to be bound\r
  82  * @param address_len length of address\r
  83  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
  84  */\r
  85 int\r
  86 GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc,\r
  87                             const struct sockaddr *address,\r
  88                             socklen_t address_len)\r
  89 {\r
  90   int ret;\r
  91 \r
  92   ret = bind (desc->fd, address, address_len);\r
  93 #ifdef MINGW\r
  94   if (SOCKET_ERROR == ret)\r
  95     SetErrnoFromWinsockError (WSAGetLastError ());\r
  96 #endif\r
  97   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
  98 }\r
  99 \r
 100 /**\r
 101  * Set if a socket should use blocking or non-blocking IO.\r
 102  * @param fd socket\r
 103  * @param doBlock blocking mode\r
 104  * @return GNUNET_OK on success, GNUNET_SYSERR on error\r
 105  */\r
 106 int\r
 107 GNUNET_NETWORK_socket_set_blocking (struct GNUNET_NETWORK_Handle *fd,\r
 108                                     int doBlock)\r
 109 {\r
 110 #if MINGW\r
 111   u_long mode;\r
 112   mode = !doBlock;\r
 113   if (ioctlsocket (fd->fd, FIONBIO, &mode) == SOCKET_ERROR)\r
 114     {\r
 115       SetErrnoFromWinsockError (WSAGetLastError ());\r
 116       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "ioctlsocket");\r
 117       return GNUNET_SYSERR;\r
 118     }\r
 119   return GNUNET_OK;\r
 120 \r
 121 #else\r
 122   /* not MINGW */\r
 123   int flags = fcntl (fd->fd, F_GETFL);\r
 124   if (flags == -1)\r
 125     {\r
 126       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");\r
 127       return GNUNET_SYSERR;\r
 128     }\r
 129   if (doBlock)\r
 130     flags &= ~O_NONBLOCK;\r
 131   else\r
 132     flags |= O_NONBLOCK;\r
 133   if (0 != fcntl (fd->fd, F_SETFL, flags))\r
 134     {\r
 135       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");\r
 136       return GNUNET_SYSERR;\r
 137     }\r
 138   return GNUNET_OK;\r
 139 #endif\r
 140 }\r
 141 \r
 142 /**\r
 143  * Close a socket\r
 144  * @param desc socket\r
 145  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
 146  */\r
 147 int\r
 148 GNUNET_NETWORK_socket_close (struct GNUNET_NETWORK_Handle *desc)\r
 149 {\r
 150   int ret;\r
 151   int eno;\r
 152 \r
 153 #ifdef MINGW\r
 154   ret = closesocket (desc->fd);\r
 155   SetErrnoFromWinsockError (WSAGetLastError ());  \r
 156 #else\r
 157   ret = close (desc->fd);\r
 158 #endif\r
 159   eno = errno;\r
 160   GNUNET_free (desc);\r
 161   errno = eno;\r
 162   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
 163 }\r
 164 \r
 165 /**\r
 166  * Connect a socket\r
 167  * @param desc socket\r
 168  * @param address peer address\r
 169  * @param address_len length of address\r
 170  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
 171  */\r
 172 int\r
 173 GNUNET_NETWORK_socket_connect (const struct GNUNET_NETWORK_Handle *desc,\r
 174                                const struct sockaddr *address,\r
 175                                socklen_t address_len)\r
 176 {\r
 177   int ret;\r
 178 \r
 179   ret = connect (desc->fd, address, address_len);\r
 180 #ifdef MINGW\r
 181   if (SOCKET_ERROR == ret)\r
 182     {\r
 183       SetErrnoFromWinsockError (WSAGetLastError ());\r
 184       if (errno == EWOULDBLOCK)\r
 185         errno = EINPROGRESS;\r
 186     }\r
 187 #endif\r
 188   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
 189 }\r
 190 \r
 191 /**\r
 192  * Get socket options\r
 193  * @param desc socket\r
 194  * @param level protocol level of the option\r
 195  * @param optname identifier of the option\r
 196  * @param optval options\r
 197  * @param optlen length of optval\r
 198  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
 199  */\r
 200 int\r
 201 GNUNET_NETWORK_socket_getsockopt (const struct GNUNET_NETWORK_Handle *desc,\r
 202                                   int level, int optname, void *optval,\r
 203                                   socklen_t * optlen)\r
 204 {\r
 205   int ret;\r
 206 \r
 207   ret = getsockopt (desc->fd, level, optname, optval, optlen);\r
 208 #ifdef MINGW\r
 209   if (ret == 0 && level == SOL_SOCKET && optname == SO_ERROR)\r
 210     *((int *) optval) = GetErrnoFromWinsockError (*((int *) optval));\r
 211   else if (SOCKET_ERROR == ret)\r
 212     SetErrnoFromWinsockError (WSAGetLastError ());\r
 213 #endif\r
 214   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
 215 }\r
 216 \r
 217 /**\r
 218  * Listen on a socket\r
 219  * @param desc socket\r
 220  * @param backlog length of the listen queue\r
 221  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
 222  */\r
 223 int\r
 224 GNUNET_NETWORK_socket_listen (const struct GNUNET_NETWORK_Handle *desc,\r
 225                               int backlog)\r
 226 {\r
 227   int ret;\r
 228 \r
 229   ret = listen (desc->fd, backlog);\r
 230 #ifdef MINGW\r
 231   if (SOCKET_ERROR == ret)\r
 232     SetErrnoFromWinsockError (WSAGetLastError ());\r
 233 #endif\r
 234 \r
 235   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
 236 }\r
 237 \r
 238 /**\r
 239  * Read data from a connected socket\r
 240  * @param desc socket\r
 241  * @param buffer buffer\r
 242  * @param length length of buffer\r
 243  * @param flags type of message reception\r
 244  */\r
 245 ssize_t\r
 246 GNUNET_NETWORK_socket_recv (const struct GNUNET_NETWORK_Handle * desc,\r
 247                             void *buffer, size_t length, int flags)\r
 248 {\r
 249   int ret;\r
 250 \r
 251   ret = recv (desc->fd, buffer, length, flags);\r
 252 #ifdef MINGW\r
 253   if (SOCKET_ERROR == ret)\r
 254     SetErrnoFromWinsockError (WSAGetLastError ());\r
 255 #endif\r
 256 \r
 257   return ret;\r
 258 }\r
 259 \r
 260 /**\r
 261  * Send data\r
 262  * @param desc socket\r
 263  * @param buffer data to send\r
 264  * @param length size of the buffer\r
 265  * @param flags type of message transmission\r
 266  * @return number of bytes sent, GNUNET_SYSERR on error\r
 267  */\r
 268 ssize_t\r
 269 GNUNET_NETWORK_socket_send (const struct GNUNET_NETWORK_Handle * desc,\r
 270                             const void *buffer, size_t length, int flags)\r
 271 {\r
 272   int ret;\r
 273 \r
 274   ret = send (desc->fd, buffer, length, flags);\r
 275 #ifdef MINGW\r
 276   if (SOCKET_ERROR == ret)\r
 277     SetErrnoFromWinsockError (WSAGetLastError ());\r
 278 #endif\r
 279 \r
 280   return ret;\r
 281 }\r
 282 \r
 283 /**\r
 284  * Send data\r
 285  * @param desc socket\r
 286  * @param message data to send\r
 287  * @param length size of the data\r
 288  * @param flags type of message transmission\r
 289  * @param dest_addr destination address\r
 290  * @param dest_len length of address\r
 291  * @return number of bytes sent, GNUNET_SYSERR on error\r
 292  */\r
 293 ssize_t\r
 294 GNUNET_NETWORK_socket_sendto (const struct GNUNET_NETWORK_Handle * desc,\r
 295                               const void *message, size_t length, int flags,\r
 296                               const struct sockaddr * dest_addr,\r
 297                               socklen_t dest_len)\r
 298 {\r
 299   int ret;\r
 300 \r
 301   ret = sendto (desc->fd, message, length, flags, dest_addr, dest_len);\r
 302 #ifdef MINGW\r
 303   if (SOCKET_ERROR == ret)\r
 304     SetErrnoFromWinsockError (WSAGetLastError ());\r
 305 #endif\r
 306 \r
 307   return ret;\r
 308 }\r
 309 \r
 310 /**\r
 311  * Set socket option\r
 312  * @param fd socket\r
 313  * @param level protocol level of the option\r
 314  * @param option_name option identifier\r
 315  * @param option_value value to set\r
 316  * @param option_len size of option_value\r
 317  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
 318  */\r
 319 int\r
 320 GNUNET_NETWORK_socket_setsockopt (struct GNUNET_NETWORK_Handle *fd,\r
 321                                   int level, int option_name,\r
 322                                   const void *option_value,\r
 323                                   socklen_t option_len)\r
 324 {\r
 325   int ret;\r
 326 \r
 327   ret = setsockopt (fd->fd, level, option_name, option_value, option_len);\r
 328 #ifdef MINGW\r
 329   if (SOCKET_ERROR == ret)\r
 330     SetErrnoFromWinsockError (WSAGetLastError ());\r
 331 #endif\r
 332 \r
 333   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
 334 }\r
 335 \r
 336 /**\r
 337  * Create a new socket\r
 338  * @param domain domain of the socket\r
 339  * @param type socket type\r
 340  * @param protocol network protocol\r
 341  * @return new socket, NULL on error\r
 342  */\r
 343 struct GNUNET_NETWORK_Handle *\r
 344 GNUNET_NETWORK_socket_socket (int domain, int type, int protocol)\r
 345 {\r
 346   struct GNUNET_NETWORK_Handle *ret;\r
 347 \r
 348   ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle));\r
 349   ret->fd = socket (domain, type, protocol);\r
 350 #ifdef MINGW\r
 351   if (INVALID_SOCKET == ret->fd)\r
 352     SetErrnoFromWinsockError (WSAGetLastError ());\r
 353 #endif\r
 354 \r
 355   if (ret->fd < 0)\r
 356     {\r
 357       GNUNET_free (ret);\r
 358       ret = NULL;\r
 359     }\r
 360 \r
 361   return ret;\r
 362 }\r
 363 \r
 364 /**\r
 365  * Shut down socket operations\r
 366  * @param desc socket\r
 367  * @param how type of shutdown\r
 368  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
 369  */\r
 370 int\r
 371 GNUNET_NETWORK_socket_shutdown (struct GNUNET_NETWORK_Handle *desc,\r
 372                                 int how)\r
 373 {\r
 374   int ret;\r
 375 \r
 376   ret = shutdown (desc->fd, how);\r
 377 #ifdef MINGW\r
 378   if (ret != 0)\r
 379     SetErrnoFromWinsockError (WSAGetLastError ());\r
 380 #endif\r
 381 \r
 382   return ret == 0 ? GNUNET_OK : GNUNET_SYSERR;\r
 383 }\r
 384 \r
 385 /**\r
 386  * Make a non-inheritable to child processes\r
 387  * @param socket\r
 388  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise\r
 389  * @warning Not implemented on Windows\r
 390  */\r
 391 int\r
 392 GNUNET_NETWORK_socket_set_inheritable (const struct GNUNET_NETWORK_Handle\r
 393                                        *desc)\r
 394 {\r
 395 #ifdef MINGW\r
 396   errno = ENOSYS;\r
 397   return GNUNET_SYSERR;\r
 398 #else\r
 399   return fcntl (desc->fd, F_SETFD,\r
 400                 fcntl (desc->fd,\r
 401                        F_GETFD) | FD_CLOEXEC) ==\r
 402     0 ? GNUNET_OK : GNUNET_SYSERR;\r
 403 #endif\r
 404 }\r
 405 \r
 406 \r
 407 /**\r
 408  * Reset FD set\r
 409  * @param fds fd set\r
 410  */\r
 411 void\r
 412 GNUNET_NETWORK_fdset_zero (struct GNUNET_NETWORK_FDSet *fds)\r
 413 {\r
 414   FD_ZERO (&fds->sds);\r
 415   fds->nsds = 0;\r
 416 #ifdef MINGW\r
 417   GNUNET_CONTAINER_slist_clear (fds->handles);\r
 418 #endif\r
 419 }\r
 420 \r
 421 \r
 422 /**\r
 423  * Add a socket to the FD set\r
 424  * @param fds fd set\r
 425  * @param desc socket to add\r
 426  */\r
 427 void\r
 428 GNUNET_NETWORK_fdset_set (struct GNUNET_NETWORK_FDSet *fds,\r
 429                           const struct GNUNET_NETWORK_Handle *desc)\r
 430 {\r
 431   FD_SET (desc->fd, &fds->sds);\r
 432 \r
 433   if (desc->fd + 1 > fds->nsds)\r
 434     fds->nsds = desc->fd + 1;\r
 435 }\r
 436 \r
 437 \r
 438 /**\r
 439  * Check whether a socket is part of the fd set\r
 440  * @param fds fd set\r
 441  * @param desc socket\r
 442  * @return 0 if the FD is not set\r
 443  */\r
 444 int\r
 445 GNUNET_NETWORK_fdset_isset (const struct GNUNET_NETWORK_FDSet *fds,\r
 446                             const struct GNUNET_NETWORK_Handle *desc)\r
 447 {\r
 448   return FD_ISSET (desc->fd, &fds->sds);\r
 449 }\r
 450 \r
 451 \r
 452 /**\r
 453  * Add one fd set to another\r
 454  * @param dst the fd set to add to\r
 455  * @param src the fd set to add from\r
 456  */\r
 457 void\r
 458 GNUNET_NETWORK_fdset_add (struct GNUNET_NETWORK_FDSet *dst,\r
 459                           const struct GNUNET_NETWORK_FDSet *src)\r
 460 {\r
 461   int nfds;\r
 462 \r
 463   for (nfds = src->nsds; nfds > 0; nfds--)\r
 464     if (FD_ISSET (nfds, &src->sds))\r
 465       {\r
 466         FD_SET (nfds, &dst->sds);\r
 467         if (nfds + 1 > dst->nsds)\r
 468           dst->nsds = nfds + 1;\r
 469       }\r
 470 }\r
 471 \r
 472 \r
 473 /**\r
 474  * Copy one fd set to another\r
 475  * @param to destination\r
 476  * @param from source\r
 477  */\r
 478 void\r
 479 GNUNET_NETWORK_fdset_copy (struct GNUNET_NETWORK_FDSet *to,\r
 480                            const struct GNUNET_NETWORK_FDSet *from)\r
 481 {\r
 482   FD_COPY (&from->sds, &to->sds);\r
 483   to->nsds = from->nsds;\r
 484 #ifdef MINGW\r
 485   struct GNUNET_CONTAINER_SList_Iterator *iter;\r
 486 \r
 487 \r
 488   GNUNET_CONTAINER_slist_clear (to->handles);\r
 489 \r
 490   for (iter = GNUNET_CONTAINER_slist_begin (from->handles);\r
 491       GNUNET_CONTAINER_slist_end (iter) != GNUNET_YES; GNUNET_CONTAINER_slist_next (iter))\r
 492     {\r
 493       void *handle;\r
 494       size_t len;\r
 495 \r
 496       handle = GNUNET_CONTAINER_slist_get (iter, &len);\r
 497       GNUNET_CONTAINER_slist_add (to->handles, GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT, handle, len);\r
 498     }\r
 499 #endif\r
 500 }\r
 501 \r
 502 \r
 503 /**\r
 504  * Copy a native fd set\r
 505  * @param to destination\r
 506  * @param from native source set\r
 507  * @param nfds the biggest socket number in from + 1\r
 508  */\r
 509 void\r
 510 GNUNET_NETWORK_fdset_copy_native (struct GNUNET_NETWORK_FDSet *to,\r
 511                                   const fd_set * from, int nfds)\r
 512 {\r
 513   FD_COPY (from, &to->sds);\r
 514   to->nsds = nfds;\r
 515 }\r
 516 \r
 517 \r
 518 /**\r
 519  * Add a file handle to the fd set\r
 520  * @param fds fd set\r
 521  * @param h the file handle to add\r
 522  */\r
 523 void\r
 524 GNUNET_NETWORK_fdset_handle_set (struct GNUNET_NETWORK_FDSet *fds,\r
 525                                  const struct GNUNET_DISK_FileHandle *h)\r
 526 {\r
 527 #ifdef MINGW\r
 528   HANDLE hw;\r
 529 \r
 530   GNUNET_internal_disk_file_handle (h, &hw, sizeof (HANDLE));\r
 531   GNUNET_CONTAINER_slist_add (fds->handles, GNUNET_NO, &hw, sizeof (HANDLE));\r
 532 #else\r
 533   int fd;\r
 534 \r
 535   GNUNET_internal_disk_file_handle (h, &fd, sizeof (int));\r
 536   FD_SET (fd, &fds->sds);\r
 537   if (fd + 1 > fds->nsds)\r
 538     fds->nsds = fd + 1;\r
 539 #endif\r
 540 }\r
 541 \r
 542 /**\r
 543  * Check if a file handle is part of an fd set\r
 544  * @param fds fd set\r
 545  * @param h file handle\r
 546  * @return GNUNET_YES if the file handle is part of the set\r
 547  */\r
 548 int\r
 549 GNUNET_NETWORK_fdset_handle_isset (const struct GNUNET_NETWORK_FDSet *fds,\r
 550                                    const struct GNUNET_DISK_FileHandle *h)\r
 551 {\r
 552 #ifdef MINGW\r
 553   return GNUNET_CONTAINER_slist_contains (fds->handles, h->h, sizeof (HANDLE));\r
 554 #else\r
 555   return FD_ISSET (h->fd, &fds->sds);\r
 556 #endif\r
 557 }\r
 558 \r
 559 /**\r
 560  * Checks if two fd sets overlap\r
 561  * @param fds1 first fd set\r
 562  * @param fds2 second fd set\r
 563  * @return GNUNET_YES if they do overlap, GNUNET_NO otherwise\r
 564  */\r
 565 int\r
 566 GNUNET_NETWORK_fdset_overlap (const struct GNUNET_NETWORK_FDSet *fds1,\r
 567                               const struct GNUNET_NETWORK_FDSet *fds2)\r
 568 {\r
 569   int nfds;\r
 570 \r
 571   nfds = fds1->nsds;\r
 572   if (nfds < fds2->nsds)\r
 573     nfds = fds2->nsds;\r
 574 \r
 575   for (; nfds >= 0; nfds--)\r
 576     if (FD_ISSET (nfds, &fds1->sds) && FD_ISSET (nfds, &fds2->sds))\r
 577       return GNUNET_YES;\r
 578 \r
 579   return GNUNET_NO;\r
 580 }\r
 581 \r
 582 /**\r
 583  * Creates an fd set\r
 584  * @return a new fd set\r
 585  */\r
 586 struct GNUNET_NETWORK_FDSet *\r
 587 GNUNET_NETWORK_fdset_create ()\r
 588 {\r
 589   struct GNUNET_NETWORK_FDSet *fds;\r
 590 \r
 591   fds = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_FDSet));\r
 592 #ifdef MINGW\r
 593   fds->handles = GNUNET_CONTAINER_slist_create ();\r
 594 #endif\r
 595   GNUNET_NETWORK_fdset_zero (fds);\r
 596   return fds;\r
 597 }\r
 598 \r
 599 \r
 600 /**\r
 601  * Releases the associated memory of an fd set\r
 602  * @param fds fd set\r
 603  */\r
 604 void\r
 605 GNUNET_NETWORK_fdset_destroy (struct GNUNET_NETWORK_FDSet *fds)\r
 606 {\r
 607 #ifdef MINGW\r
 608   GNUNET_CONTAINER_slist_destroy (fds->handles);\r
 609 #endif\r
 610   GNUNET_free (fds);\r
 611 }\r
 612 \r
 613 \r
 614 /**\r
 615  * Check if sockets meet certain conditions\r
 616  * @param rfds set of sockets to be checked for readability\r
 617  * @param wfds set of sockets to be checked for writability\r
 618  * @param efds set of sockets to be checked for exceptions\r
 619  * @param timeout relative value when to return\r
 620  * @return number of selected sockets, GNUNET_SYSERR on error\r
 621  */\r
 622 int\r
 623 GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,\r
 624                               struct GNUNET_NETWORK_FDSet *wfds,\r
 625                               struct GNUNET_NETWORK_FDSet *efds,\r
 626                               const struct GNUNET_TIME_Relative timeout)\r
 627 {\r
 628   int nfds;\r
 629 \r
 630   nfds = 0;\r
 631   if (NULL != rfds)\r
 632     nfds = rfds->nsds;\r
 633   if (NULL != wfds)\r
 634     nfds = GNUNET_MAX (nfds, wfds->nsds);\r
 635   if (NULL != efds)\r
 636     nfds = GNUNET_MAX (nfds, efds->nsds);\r
 637 \r
 638 #ifndef MINGW\r
 639   struct timeval tv;\r
 640 \r
 641   tv.tv_sec = timeout.value / GNUNET_TIME_UNIT_SECONDS.value;\r
 642   tv.tv_usec = 1000 * (timeout.value - (tv.tv_sec * GNUNET_TIME_UNIT_SECONDS.value));\r
 643   if ( (nfds == 0) &&\r
 644        (timeout.value == GNUNET_TIME_UNIT_FOREVER_REL.value) )\r
 645     {\r
 646       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,\r
 647                   _("Fatal internal logic error, process hangs in `%s' (abort with CTRL-C)!\n"),\r
 648                   "select");\r
 649       GNUNET_break (0);\r
 650     }\r
 651   return select (nfds + 1, \r
 652                  (rfds != NULL) ? &rfds->sds : NULL, \r
 653                  (wfds != NULL) ? &wfds->sds : NULL,\r
 654                  (efds != NULL) ? &efds->sds : NULL, \r
 655                  (timeout.value == GNUNET_TIME_UNIT_FOREVER_REL.value) \r
 656                  ? NULL \r
 657                  : &tv);\r
 658 #else\r
 659   DWORD limit;\r
 660   fd_set sock_read, sock_write, sock_except;\r
 661   fd_set aread, awrite, aexcept;\r
 662   int i;\r
 663   struct timeval tvslice;\r
 664   int retcode;\r
 665   DWORD ms_total;\r
 666 \r
 667 #define SAFE_FD_ISSET(fd, set)  (set != NULL && FD_ISSET(fd, set))\r
 668 \r
 669   /* calculate how long we need to wait in milliseconds */\r
 670   if (timeout.value == GNUNET_TIME_UNIT_FOREVER_REL.value)\r
 671     ms_total = INFINITE;\r
 672   else\r
 673     ms_total = timeout.value / GNUNET_TIME_UNIT_MILLISECONDS.value;\r
 674 \r
 675   /* select() may be used as a portable way to sleep */\r
 676   if (!(rfds || wfds || efds))\r
 677     {\r
 678       Sleep (ms_total);\r
 679       return 0;\r
 680     }\r
 681 \r
 682   if (rfds)\r
 683     sock_read = rfds->sds;\r
 684   else\r
 685     FD_ZERO(&sock_read);\r
 686 \r
 687   if (wfds)\r
 688     sock_write = wfds->sds;\r
 689   else\r
 690     FD_ZERO(&sock_write);\r
 691 \r
 692   if (efds)\r
 693     sock_except = efds->sds;\r
 694   else\r
 695     FD_ZERO(&sock_except);\r
 696 \r
 697   /* multiplex between winsock select() and waiting on the handles */\r
 698 \r
 699   FD_ZERO (&aread);\r
 700   FD_ZERO (&awrite);\r
 701   FD_ZERO (&aexcept);\r
 702 \r
 703   limit = GetTickCount () + ms_total;\r
 704   do\r
 705     {\r
 706       retcode = 0;\r
 707 \r
 708       if (nfds > 0)\r
 709         {\r
 710           /* overwrite the zero'd sets here; the select call\r
 711            * will clear those that are not active */\r
 712 \r
 713           FD_COPY (&sock_read, &aread);\r
 714           FD_COPY (&sock_write, &awrite);\r
 715           FD_COPY (&sock_except, &aexcept);\r
 716 \r
 717           tvslice.tv_sec = 0;\r
 718           tvslice.tv_usec = 100000;\r
 719 \r
 720           if ((retcode =\r
 721                select (nfds + 1, &aread, &awrite, &aexcept,\r
 722                        &tvslice)) == SOCKET_ERROR)\r
 723             {\r
 724               SetErrnoFromWinsockError (WSAGetLastError ());\r
 725               if (errno == ENOTSOCK)\r
 726                 errno = EBADF;\r
 727 \r
 728 #if DEBUG_SOCK\r
 729             GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "select");\r
 730 #endif\r
 731 \r
 732               goto select_loop_end;\r
 733             }\r
 734         }\r
 735 \r
 736       /* Poll read pipes */\r
 737       if (rfds)\r
 738         {\r
 739           struct GNUNET_CONTAINER_SList_Iterator *i;\r
 740           int on_next;\r
 741 \r
 742           on_next = GNUNET_NO;\r
 743           for (i = GNUNET_CONTAINER_slist_begin (rfds->handles);\r
 744                     GNUNET_CONTAINER_slist_end (i) != GNUNET_YES;\r
 745                     on_next || GNUNET_CONTAINER_slist_next (i))\r
 746             {\r
 747               HANDLE h;\r
 748               DWORD dwBytes;\r
 749 \r
 750               h = *(HANDLE *) GNUNET_CONTAINER_slist_get (i, NULL);\r
 751               on_next = GNUNET_NO;\r
 752 \r
 753               if (!PeekNamedPipe (h, NULL, 0, NULL, &dwBytes, NULL))\r
 754                 {\r
 755                   GNUNET_CONTAINER_slist_erase (i);\r
 756                   on_next = GNUNET_YES;\r
 757 \r
 758                   retcode = -1;\r
 759                   SetErrnoFromWinError (GetLastError ());\r
 760 #if DEBUG_SOCK\r
 761                   GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "PeekNamedPipe");\r
 762 #endif\r
 763                   goto select_loop_end;\r
 764                 }\r
 765               else if (dwBytes)\r
 766                 {\r
 767                   retcode++;\r
 768                 }\r
 769               else\r
 770                 {\r
 771                   GNUNET_CONTAINER_slist_erase (i);\r
 772                   on_next = GNUNET_YES;\r
 773                 }\r
 774             }\r
 775         }\r
 776 \r
 777       /* Poll for faulty pipes */\r
 778       if (efds)\r
 779         {\r
 780           struct GNUNET_CONTAINER_SList_Iterator *i;\r
 781           int on_next;\r
 782 \r
 783           on_next = GNUNET_NO;\r
 784           for (i = GNUNET_CONTAINER_slist_begin (efds->handles);\r
 785                     GNUNET_CONTAINER_slist_end (i) != GNUNET_YES;\r
 786                     on_next || GNUNET_CONTAINER_slist_next (i))\r
 787             {\r
 788               HANDLE h;\r
 789               DWORD dwBytes;\r
 790 \r
 791               h = *(HANDLE *) GNUNET_CONTAINER_slist_get (i, NULL);\r
 792 \r
 793               if (PeekNamedPipe (h, NULL, 0, NULL, &dwBytes, NULL))\r
 794                 {\r
 795                   GNUNET_CONTAINER_slist_erase (i);\r
 796                   on_next = GNUNET_YES;\r
 797 \r
 798                   retcode++;\r
 799                 }\r
 800               else\r
 801                 on_next = GNUNET_NO;\r
 802             }\r
 803         }\r
 804 \r
 805       /* FIXME */\r
 806       if (wfds)\r
 807         GNUNET_assert (GNUNET_CONTAINER_slist_count (wfds->handles) == 0);\r
 808 \r
 809       /* Check for closed sockets */\r
 810       for (i = 0; i < nfds; i++)\r
 811         {\r
 812           if (SAFE_FD_ISSET (i, &sock_read))\r
 813             {\r
 814               struct sockaddr addr;\r
 815               int len;\r
 816 \r
 817               if (getpeername (i, &addr, &len) == SOCKET_ERROR)\r
 818                 {\r
 819                   int err, len;\r
 820 \r
 821                   len = sizeof (err);\r
 822                   if (getsockopt\r
 823                       (i, SOL_SOCKET, SO_ERROR, (char *) &err, &len) == 0\r
 824                       && err == WSAENOTCONN)\r
 825                     {\r
 826                       if (!SAFE_FD_ISSET (i, &aread))\r
 827                         {\r
 828                           FD_SET (i, &aread);\r
 829                           retcode++;\r
 830                         }\r
 831                     }\r
 832                 }\r
 833             }\r
 834         }\r
 835 \r
 836     select_loop_end:;\r
 837     }\r
 838   while (retcode == 0 && (ms_total == INFINITE || GetTickCount () < limit));\r
 839 \r
 840   if (retcode != -1)\r
 841     {\r
 842       if (rfds)\r
 843         {\r
 844           GNUNET_NETWORK_fdset_zero (rfds);\r
 845           GNUNET_NETWORK_fdset_copy_native (rfds, &aread, retcode);\r
 846         }\r
 847 \r
 848       if (wfds)\r
 849         {\r
 850           GNUNET_NETWORK_fdset_zero (wfds);\r
 851           GNUNET_NETWORK_fdset_copy_native (wfds, &awrite, retcode);\r
 852         }\r
 853 \r
 854       if (efds)\r
 855         {\r
 856           GNUNET_NETWORK_fdset_zero (efds);\r
 857           GNUNET_NETWORK_fdset_copy_native (efds, &aexcept, retcode);\r
 858         }\r
 859     }\r
 860 \r
 861   return retcode;\r
 862 #endif\r
 863 }\r
 864 \r
 865 \r
 866 /* end of network.c */\r