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