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