src/transport/tcp_server_legacy.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2009-2013 GNUnet e.V.
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20
  21 /**
  22  * @file util/server.c
  23  * @brief library for building GNUnet network servers
  24  * @author Christian Grothoff
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_protocols.h"
  30
  31 #define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util-server", syscall, filename)
  32
  33
  34 /**
  35  * List of arrays of message handlers.
  36  */
  37 struct HandlerList
  38 {
  39   /**
  40    * This is a linked list.
  41    */
  42   struct HandlerList *next;
  43
  44   /**
  45    * NULL-terminated array of handlers.
  46    */
  47   const struct GNUNET_SERVER_MessageHandler *handlers;
  48 };
  49
  50
  51 /**
  52  * List of arrays of message handlers.
  53  */
  54 struct NotifyList
  55 {
  56   /**
  57    * This is a doubly linked list.
  58    */
  59   struct NotifyList *next;
  60
  61   /**
  62    * This is a doubly linked list.
  63    */
  64   struct NotifyList *prev;
  65
  66   /**
  67    * Function to call.
  68    */
  69   GNUNET_SERVER_DisconnectCallback callback;
  70
  71   /**
  72    * Closure for callback.
  73    */
  74   void *callback_cls;
  75 };
  76
  77
  78 /**
  79  * @brief handle for a server
  80  */
  81 struct GNUNET_SERVER_Handle
  82 {
  83   /**
  84    * List of handlers for incoming messages.
  85    */
  86   struct HandlerList *handlers;
  87
  88   /**
  89    * Head of list of our current clients.
  90    */
  91   struct GNUNET_SERVER_Client *clients_head;
  92
  93   /**
  94    * Head of list of our current clients.
  95    */
  96   struct GNUNET_SERVER_Client *clients_tail;
  97
  98   /**
  99    * Head of linked list of functions to call on disconnects by clients.
 100    */
 101   struct NotifyList *disconnect_notify_list_head;
 102
 103   /**
 104    * Tail of linked list of functions to call on disconnects by clients.
 105    */
 106   struct NotifyList *disconnect_notify_list_tail;
 107
 108   /**
 109    * Head of linked list of functions to call on connects by clients.
 110    */
 111   struct NotifyList *connect_notify_list_head;
 112
 113   /**
 114    * Tail of linked list of functions to call on connects by clients.
 115    */
 116   struct NotifyList *connect_notify_list_tail;
 117
 118   /**
 119    * Function to call for access control.
 120    */
 121   GNUNET_CONNECTION_AccessCheck access_cb;
 122
 123   /**
 124    * Closure for @e access_cb.
 125    */
 126   void *access_cb_cls;
 127
 128   /**
 129    * NULL-terminated array of sockets used to listen for new
 130    * connections.
 131    */
 132   struct GNUNET_NETWORK_Handle **listen_sockets;
 133
 134   /**
 135    * After how long should an idle connection time
 136    * out (on write).
 137    */
 138   struct GNUNET_TIME_Relative idle_timeout;
 139
 140   /**
 141    * Task scheduled to do the listening.
 142    */
 143   struct GNUNET_SCHEDULER_Task * listen_task;
 144
 145   /**
 146    * Alternative function to create a MST instance.
 147    */
 148   GNUNET_SERVER_MstCreateCallback mst_create;
 149
 150   /**
 151    * Alternative function to destroy a MST instance.
 152    */
 153   GNUNET_SERVER_MstDestroyCallback mst_destroy;
 154
 155   /**
 156    * Alternative function to give data to a MST instance.
 157    */
 158   GNUNET_SERVER_MstReceiveCallback mst_receive;
 159
 160   /**
 161    * Closure for 'mst_'-callbacks.
 162    */
 163   void *mst_cls;
 164
 165   /**
 166    * Do we ignore messages of types that we do not understand or do we
 167    * require that a handler is found (and if not kill the connection)?
 168    */
 169   int require_found;
 170
 171   /**
 172    * Set to #GNUNET_YES once we are in 'soft' shutdown where we wait for
 173    * all non-monitor clients to disconnect before we call
 174    * #GNUNET_SERVER_destroy.  See test_monitor_clients().  Set to
 175    * #GNUNET_SYSERR once the final destroy task has been scheduled
 176    * (we cannot run it in the same task).
 177    */
 178   int in_soft_shutdown;
 179 };
 180
 181
 182 /**
 183  * Handle server returns for aborting transmission to a client.
 184  */
 185 struct GNUNET_SERVER_TransmitHandle
 186 {
 187   /**
 188    * Function to call to get the message.
 189    */
 190   GNUNET_CONNECTION_TransmitReadyNotify callback;
 191
 192   /**
 193    * Closure for @e callback
 194    */
 195   void *callback_cls;
 196
 197   /**
 198    * Active connection transmission handle.
 199    */
 200   struct GNUNET_CONNECTION_TransmitHandle *cth;
 201
 202 };
 203
 204
 205 /**
 206  * @brief handle for a client of the server
 207  */
 208 struct GNUNET_SERVER_Client
 209 {
 210
 211   /**
 212    * This is a doubly linked list.
 213    */
 214   struct GNUNET_SERVER_Client *next;
 215
 216   /**
 217    * This is a doubly linked list.
 218    */
 219   struct GNUNET_SERVER_Client *prev;
 220
 221   /**
 222    * Processing of incoming data.
 223    */
 224   void *mst;
 225
 226   /**
 227    * Server that this client belongs to.
 228    */
 229   struct GNUNET_SERVER_Handle *server;
 230
 231   /**
 232    * Client closure for callbacks.
 233    */
 234   struct GNUNET_CONNECTION_Handle *connection;
 235
 236   /**
 237    * User context value, manipulated using
 238    * 'GNUNET_SERVER_client_{get/set}_user_context' functions.
 239    */
 240   void *user_context;
 241
 242   /**
 243    * ID of task used to restart processing.
 244    */
 245   struct GNUNET_SCHEDULER_Task * restart_task;
 246
 247   /**
 248    * Task that warns about missing calls to #GNUNET_SERVER_receive_done.
 249    */
 250   struct GNUNET_SCHEDULER_Task * warn_task;
 251
 252   /**
 253    * Time when the warn task was started.
 254    */
 255   struct GNUNET_TIME_Absolute warn_start;
 256
 257   /**
 258    * Last activity on this socket (used to time it out
 259    * if reference_count == 0).
 260    */
 261   struct GNUNET_TIME_Absolute last_activity;
 262
 263   /**
 264    * Transmission handle we return for this client from
 265    * #GNUNET_SERVER_notify_transmit_ready.
 266    */
 267   struct GNUNET_SERVER_TransmitHandle th;
 268
 269   /**
 270    * After how long should an idle connection time
 271    * out (on write).
 272    */
 273   struct GNUNET_TIME_Relative idle_timeout;
 274
 275   /**
 276    * Number of external entities with a reference to
 277    * this client object.
 278    */
 279   unsigned int reference_count;
 280
 281   /**
 282    * Was processing if incoming messages suspended while
 283    * we were still processing data already received?
 284    * This is a counter saying how often processing was
 285    * suspended (once per handler invoked).
 286    */
 287   unsigned int suspended;
 288
 289   /**
 290    * Last size given when user context was initialized; used for
 291    * sanity check.
 292    */
 293   size_t user_context_size;
 294
 295   /**
 296    * Are we currently in the "process_client_buffer" function (and
 297    * will hence restart the receive job on exit if suspended == 0 once
 298    * we are done?).  If this is set, then "receive_done" will
 299    * essentially only decrement suspended; if this is not set, then
 300    * "receive_done" may need to restart the receive process (either
 301    * from the side-buffer or via select/recv).
 302    */
 303   int in_process_client_buffer;
 304
 305   /**
 306    * We're about to close down this client.
 307    */
 308   int shutdown_now;
 309
 310   /**
 311    * Are we currently trying to receive? (#GNUNET_YES if we are,
 312    * #GNUNET_NO if we are not, #GNUNET_SYSERR if data is already
 313    * available in MST).
 314    */
 315   int receive_pending;
 316
 317   /**
 318    * Persist the file handle for this client no matter what happens,
 319    * force the OS to close once the process actually dies.  Should only
 320    * be used in special cases!
 321    */
 322   int persist;
 323
 324   /**
 325    * Is this client a 'monitor' client that should not be counted
 326    * when deciding on destroying the server during soft shutdown?
 327    * (see also #GNUNET_SERVICE_start)
 328    */
 329   int is_monitor;
 330
 331   /**
 332    * Type of last message processed (for warn_no_receive_done).
 333    */
 334   uint16_t warn_type;
 335 };
 336
 337
 338
 339 /**
 340  * Return user context associated with the given client.
 341  * Note: you should probably use the macro (call without the underscore).
 342  *
 343  * @param client client to query
 344  * @param size number of bytes in user context struct (for verification only)
 345  * @return pointer to user context
 346  */
 347 void *
 348 GNUNET_SERVER_client_get_user_context_ (struct GNUNET_SERVER_Client *client,
 349                                         size_t size)
 350 {
 351   if ((0 == client->user_context_size) &&
 352       (NULL == client->user_context))
 353     return NULL; /* never set */
 354   GNUNET_assert (size == client->user_context_size);
 355   return client->user_context;
 356 }
 357
 358
 359 /**
 360  * Set user context to be associated with the given client.
 361  * Note: you should probably use the macro (call without the underscore).
 362  *
 363  * @param client client to query
 364  * @param ptr pointer to user context
 365  * @param size number of bytes in user context struct (for verification only)
 366  */
 367 void
 368 GNUNET_SERVER_client_set_user_context_ (struct GNUNET_SERVER_Client *client,
 369                                         void *ptr,
 370                                         size_t size)
 371 {
 372   if (NULL == ptr)
 373   {
 374     client->user_context_size = 0;
 375     client->user_context = ptr;
 376     return;
 377   }
 378   client->user_context_size = size;
 379   client->user_context = ptr;
 380 }
 381
 382
 383 /**
 384  * Scheduler says our listen socket is ready.  Process it!
 385  *
 386  * @param cls handle to our server for which we are processing the listen
 387  *        socket
 388  */
 389 static void
 390 process_listen_socket (void *cls)
 391 {
 392   struct GNUNET_SERVER_Handle *server = cls;
 393   const struct GNUNET_SCHEDULER_TaskContext *tc;
 394   struct GNUNET_CONNECTION_Handle *sock;
 395   unsigned int i;
 396
 397   server->listen_task = NULL;
 398   tc = GNUNET_SCHEDULER_get_task_context ();
 399   for (i = 0; NULL != server->listen_sockets[i]; i++)
 400   {
 401     if (GNUNET_NETWORK_fdset_isset (tc->read_ready,
 402                                     server->listen_sockets[i]))
 403     {
 404       sock =
 405           GNUNET_CONNECTION_create_from_accept (server->access_cb,
 406                                                 server->access_cb_cls,
 407                                                 server->listen_sockets[i]);
 408       if (NULL != sock)
 409       {
 410         LOG (GNUNET_ERROR_TYPE_DEBUG,
 411              "Server accepted incoming connection.\n");
 412         (void) GNUNET_SERVER_connect_socket (server,
 413                                              sock);
 414       }
 415     }
 416   }
 417   /* listen for more! */
 418   GNUNET_SERVER_resume (server);
 419 }
 420
 421
 422 /**
 423  * Create and initialize a listen socket for the server.
 424  *
 425  * @param server_addr address to listen on
 426  * @param socklen length of @a server_addr
 427  * @return NULL on error, otherwise the listen socket
 428  */
 429 static struct GNUNET_NETWORK_Handle *
 430 open_listen_socket (const struct sockaddr *server_addr,
 431                     socklen_t socklen)
 432 {
 433   struct GNUNET_NETWORK_Handle *sock;
 434   uint16_t port;
 435   int eno;
 436
 437   switch (server_addr->sa_family)
 438   {
 439   case AF_INET:
 440     port = ntohs (((const struct sockaddr_in *) server_addr)->sin_port);
 441     break;
 442   case AF_INET6:
 443     port = ntohs (((const struct sockaddr_in6 *) server_addr)->sin6_port);
 444     break;
 445   case AF_UNIX:
 446     port = 0;
 447     break;
 448   default:
 449     GNUNET_break (0);
 450     port = 0;
 451     break;
 452   }
 453   sock = GNUNET_NETWORK_socket_create (server_addr->sa_family, SOCK_STREAM, 0);
 454   if (NULL == sock)
 455   {
 456     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket");
 457     errno = 0;
 458     return NULL;
 459   }
 460   /* bind the socket */
 461   if (GNUNET_OK != GNUNET_NETWORK_socket_bind (sock, server_addr, socklen))
 462   {
 463     eno = errno;
 464     if (EADDRINUSE != errno)
 465     {
 466       /* we don't log 'EADDRINUSE' here since an IPv4 bind may
 467        * fail if we already took the port on IPv6; if both IPv4 and
 468        * IPv6 binds fail, then our caller will log using the
 469        * errno preserved in 'eno' */
 470       LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
 471                     "bind");
 472       if (0 != port)
 473         LOG (GNUNET_ERROR_TYPE_ERROR,
 474              _("`%s' failed for port %d (%s).\n"),
 475              "bind",
 476              port,
 477              (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6");
 478       eno = 0;
 479     }
 480     else
 481     {
 482       if (0 != port)
 483         LOG (GNUNET_ERROR_TYPE_WARNING,
 484              _("`%s' failed for port %d (%s): address already in use\n"),
 485              "bind", port,
 486              (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6");
 487       else if (AF_UNIX == server_addr->sa_family)
 488       {
 489         LOG (GNUNET_ERROR_TYPE_WARNING,
 490              _("`%s' failed for `%s': address already in use\n"),
 491              "bind",
 492              GNUNET_a2s (server_addr, socklen));
 493       }
 494     }
 495     GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
 496     errno = eno;
 497     return NULL;
 498   }
 499   if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock, 5))
 500   {
 501     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
 502                   "listen");
 503     GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
 504     errno = 0;
 505     return NULL;
 506   }
 507   if (0 != port)
 508     LOG (GNUNET_ERROR_TYPE_DEBUG,
 509          "Server starts to listen on port %u.\n",
 510          port);
 511   return sock;
 512 }
 513
 514
 515 /**
 516  * Create a new server.
 517  *
 518  * @param access_cb function for access control
 519  * @param access_cb_cls closure for @a access_cb
 520  * @param lsocks NULL-terminated array of listen sockets
 521  * @param idle_timeout after how long should we timeout idle connections?
 522  * @param require_found if #GNUNET_YES, connections sending messages of unknown type
 523  *        will be closed
 524  * @return handle for the new server, NULL on error
 525  *         (typically, "port" already in use)
 526  */
 527 struct GNUNET_SERVER_Handle *
 528 GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access_cb,
 529                                    void *access_cb_cls,
 530                                    struct GNUNET_NETWORK_Handle **lsocks,
 531                                    struct GNUNET_TIME_Relative idle_timeout,
 532                                    int require_found)
 533 {
 534   struct GNUNET_SERVER_Handle *server;
 535
 536   server = GNUNET_new (struct GNUNET_SERVER_Handle);
 537   server->idle_timeout = idle_timeout;
 538   server->listen_sockets = lsocks;
 539   server->access_cb = access_cb;
 540   server->access_cb_cls = access_cb_cls;
 541   server->require_found = require_found;
 542   if (NULL != lsocks)
 543     GNUNET_SERVER_resume (server);
 544   return server;
 545 }
 546
 547
 548 /**
 549  * Create a new server.
 550  *
 551  * @param access_cb function for access control
 552  * @param access_cb_cls closure for @a access_cb
 553  * @param server_addr address to listen on (including port), NULL terminated array
 554  * @param socklen length of server_addr
 555  * @param idle_timeout after how long should we timeout idle connections?
 556  * @param require_found if YES, connections sending messages of unknown type
 557  *        will be closed
 558  * @return handle for the new server, NULL on error
 559  *         (typically, "port" already in use)
 560  */
 561 struct GNUNET_SERVER_Handle *
 562 GNUNET_SERVER_create (GNUNET_CONNECTION_AccessCheck access_cb,
 563                       void *access_cb_cls,
 564                       struct sockaddr *const *server_addr,
 565                       const socklen_t * socklen,
 566                       struct GNUNET_TIME_Relative idle_timeout,
 567                       int require_found)
 568 {
 569   struct GNUNET_NETWORK_Handle **lsocks;
 570   unsigned int i;
 571   unsigned int j;
 572   unsigned int k;
 573   int seen;
 574
 575   i = 0;
 576   while (NULL != server_addr[i])
 577     i++;
 578   if (i > 0)
 579   {
 580     lsocks = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle *) * (i + 1));
 581     i = 0;
 582     j = 0;
 583     while (NULL != server_addr[i])
 584     {
 585       seen = 0;
 586       for (k=0;k<i;k++)
 587         if ( (socklen[k] == socklen[i]) &&
 588              (0 == memcmp (server_addr[k], server_addr[i], socklen[i])) )
 589         {
 590           seen = 1;
 591           break;
 592         }
 593       if (0 != seen)
 594       {
 595         /* duplicate address, skip */
 596         i++;
 597         continue;
 598       }
 599       lsocks[j] = open_listen_socket (server_addr[i], socklen[i]);
 600       if (NULL != lsocks[j])
 601         j++;
 602       i++;
 603     }
 604     if (0 == j)
 605     {
 606       if (0 != errno)
 607         LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "bind");
 608       GNUNET_free (lsocks);
 609       lsocks = NULL;
 610     }
 611   }
 612   else
 613   {
 614     lsocks = NULL;
 615   }
 616   return GNUNET_SERVER_create_with_sockets (access_cb,
 617                                             access_cb_cls,
 618                                             lsocks,
 619                                             idle_timeout,
 620                                             require_found);
 621 }
 622
 623
 624 /**
 625  * Set the 'monitor' flag on this client.  Clients which have been
 626  * marked as 'monitors' won't prevent the server from shutting down
 627  * once '#GNUNET_SERVER_stop_listening()' has been invoked.  The idea is
 628  * that for "normal" clients we likely want to allow them to process
 629  * their requests; however, monitor-clients are likely to 'never'
 630  * disconnect during shutdown and thus will not be considered when
 631  * determining if the server should continue to exist after
 632  * #GNUNET_SERVER_destroy() has been called.
 633  *
 634  * @param client the client to set the 'monitor' flag on
 635  */
 636 void
 637 GNUNET_SERVER_client_mark_monitor (struct GNUNET_SERVER_Client *client)
 638 {
 639   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 640               "Marking client as monitor!\n");
 641   client->is_monitor = GNUNET_YES;
 642 }
 643
 644
 645 /**
 646  * Helper function for #test_monitor_clients() to trigger
 647  * #GNUNET_SERVER_destroy() after the stack has unwound.
 648  *
 649  * @param cls the `struct GNUNET_SERVER_Handle *` to destroy
 650  */
 651 static void
 652 do_destroy (void *cls)
 653 {
 654   struct GNUNET_SERVER_Handle *server = cls;
 655
 656   GNUNET_SERVER_destroy (server);
 657 }
 658
 659
 660 /**
 661  * Check if only 'monitor' clients are left.  If so, destroy the
 662  * server completely.
 663  *
 664  * @param server server to test for full shutdown
 665  */
 666 static void
 667 test_monitor_clients (struct GNUNET_SERVER_Handle *server)
 668 {
 669   struct GNUNET_SERVER_Client *client;
 670
 671   if (GNUNET_YES != server->in_soft_shutdown)
 672     return;
 673   for (client = server->clients_head; NULL != client; client = client->next)
 674     if (GNUNET_NO == client->is_monitor)
 675       return; /* not done yet */
 676   server->in_soft_shutdown = GNUNET_SYSERR;
 677   (void) GNUNET_SCHEDULER_add_now (&do_destroy, server);
 678 }
 679
 680
 681 /**
 682  * Suspend accepting connections from the listen socket temporarily.
 683  *
 684  * @param server server to stop accepting connections.
 685  */
 686 void
 687 GNUNET_SERVER_suspend (struct GNUNET_SERVER_Handle *server)
 688 {
 689   if (NULL != server->listen_task)
 690   {
 691     GNUNET_SCHEDULER_cancel (server->listen_task);
 692     server->listen_task = NULL;
 693   }
 694 }
 695
 696
 697 /**
 698  * Resume accepting connections from the listen socket.
 699  *
 700  * @param server server to stop accepting connections.
 701  */
 702 void
 703 GNUNET_SERVER_resume (struct GNUNET_SERVER_Handle *server)
 704 {
 705   struct GNUNET_NETWORK_FDSet *r;
 706   unsigned int i;
 707
 708   if (NULL == server->listen_sockets)
 709     return;
 710   if (NULL == server->listen_sockets[0])
 711     return; /* nothing to do, no listen sockets! */
 712   if (NULL == server->listen_sockets[1])
 713   {
 714     /* simplified method: no fd set needed; this is then much simpler
 715        and much more efficient */
 716     server->listen_task =
 717       GNUNET_SCHEDULER_add_read_net_with_priority (GNUNET_TIME_UNIT_FOREVER_REL,
 718                                                    GNUNET_SCHEDULER_PRIORITY_HIGH,
 719                                                    server->listen_sockets[0],
 720                                                    &process_listen_socket, server);
 721     return;
 722   }
 723   r = GNUNET_NETWORK_fdset_create ();
 724   i = 0;
 725   while (NULL != server->listen_sockets[i])
 726     GNUNET_NETWORK_fdset_set (r, server->listen_sockets[i++]);
 727   server->listen_task =
 728     GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
 729                                  GNUNET_TIME_UNIT_FOREVER_REL, r, NULL,
 730                                  &process_listen_socket, server);
 731   GNUNET_NETWORK_fdset_destroy (r);
 732 }
 733
 734
 735 /**
 736  * Stop the listen socket and get ready to shutdown the server
 737  * once only 'monitor' clients are left.
 738  *
 739  * @param server server to stop listening on
 740  */
 741 void
 742 GNUNET_SERVER_stop_listening (struct GNUNET_SERVER_Handle *server)
 743 {
 744   unsigned int i;
 745
 746   LOG (GNUNET_ERROR_TYPE_DEBUG,
 747        "Server in soft shutdown\n");
 748   if (NULL != server->listen_task)
 749   {
 750     GNUNET_SCHEDULER_cancel (server->listen_task);
 751     server->listen_task = NULL;
 752   }
 753   if (NULL != server->listen_sockets)
 754   {
 755     i = 0;
 756     while (NULL != server->listen_sockets[i])
 757       GNUNET_break (GNUNET_OK ==
 758                     GNUNET_NETWORK_socket_close (server->listen_sockets[i++]));
 759     GNUNET_free (server->listen_sockets);
 760     server->listen_sockets = NULL;
 761   }
 762   if (GNUNET_NO == server->in_soft_shutdown)
 763     server->in_soft_shutdown = GNUNET_YES;
 764   test_monitor_clients (server);
 765 }
 766
 767
 768 /**
 769  * Free resources held by this server.
 770  *
 771  * @param server server to destroy
 772  */
 773 void
 774 GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *server)
 775 {
 776   struct HandlerList *hpos;
 777   struct NotifyList *npos;
 778   unsigned int i;
 779
 780   LOG (GNUNET_ERROR_TYPE_DEBUG,
 781        "Server shutting down.\n");
 782   if (NULL != server->listen_task)
 783   {
 784     GNUNET_SCHEDULER_cancel (server->listen_task);
 785     server->listen_task = NULL;
 786   }
 787   if (NULL != server->listen_sockets)
 788   {
 789     i = 0;
 790     while (NULL != server->listen_sockets[i])
 791       GNUNET_break (GNUNET_OK ==
 792                     GNUNET_NETWORK_socket_close (server->listen_sockets[i++]));
 793     GNUNET_free (server->listen_sockets);
 794     server->listen_sockets = NULL;
 795   }
 796   while (NULL != server->clients_head)
 797     GNUNET_SERVER_client_disconnect (server->clients_head);
 798   while (NULL != (hpos = server->handlers))
 799   {
 800     server->handlers = hpos->next;
 801     GNUNET_free (hpos);
 802   }
 803   while (NULL != (npos = server->disconnect_notify_list_head))
 804   {
 805     npos->callback (npos->callback_cls,
 806                     NULL);
 807     GNUNET_CONTAINER_DLL_remove (server->disconnect_notify_list_head,
 808                                  server->disconnect_notify_list_tail,
 809                                  npos);
 810     GNUNET_free (npos);
 811   }
 812   while (NULL != (npos = server->connect_notify_list_head))
 813   {
 814     npos->callback (npos->callback_cls,
 815                     NULL);
 816     GNUNET_CONTAINER_DLL_remove (server->connect_notify_list_head,
 817                                  server->connect_notify_list_tail,
 818                                  npos);
 819     GNUNET_free (npos);
 820   }
 821   GNUNET_free (server);
 822 }
 823
 824
 825 /**
 826  * Add additional handlers to an existing server.
 827  *
 828  * @param server the server to add handlers to
 829  * @param handlers array of message handlers for
 830  *        incoming messages; the last entry must
 831  *        have "NULL" for the "callback"; multiple
 832  *        entries for the same type are allowed,
 833  *        they will be called in order of occurence.
 834  *        These handlers can be removed later;
 835  *        the handlers array must exist until removed
 836  *        (or server is destroyed).
 837  */
 838 void
 839 GNUNET_SERVER_add_handlers (struct GNUNET_SERVER_Handle *server,
 840                             const struct GNUNET_SERVER_MessageHandler *handlers)
 841 {
 842   struct HandlerList *p;
 843
 844   p = GNUNET_new (struct HandlerList);
 845   p->handlers = handlers;
 846   p->next = server->handlers;
 847   server->handlers = p;
 848 }
 849
 850
 851 /**
 852  * Change functions used by the server to tokenize the message stream.
 853  * (very rarely used).
 854  *
 855  * @param server server to modify
 856  * @param create new tokenizer initialization function
 857  * @param destroy new tokenizer destruction function
 858  * @param receive new tokenizer receive function
 859  * @param cls closure for @a create, @a receive, @a destroy
 860  */
 861 void
 862 GNUNET_SERVER_set_callbacks (struct GNUNET_SERVER_Handle *server,
 863                              GNUNET_SERVER_MstCreateCallback create,
 864                              GNUNET_SERVER_MstDestroyCallback destroy,
 865                              GNUNET_SERVER_MstReceiveCallback receive,
 866                              void *cls)
 867 {
 868   server->mst_create = create;
 869   server->mst_destroy = destroy;
 870   server->mst_receive = receive;
 871   server->mst_cls = cls;
 872 }
 873
 874
 875 /**
 876  * Task run to warn about missing calls to #GNUNET_SERVER_receive_done.
 877  *
 878  * @param cls our `struct GNUNET_SERVER_Client *` to process more requests from
 879  */
 880 static void
 881 warn_no_receive_done (void *cls)
 882 {
 883   struct GNUNET_SERVER_Client *client = cls;
 884
 885   GNUNET_break (0 != client->warn_type); /* type should never be 0 here, as we don't use 0 */
 886   client->warn_task =
 887       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
 888                                     &warn_no_receive_done, client);
 889   LOG (GNUNET_ERROR_TYPE_WARNING,
 890        _("Processing code for message of type %u did not call `GNUNET_SERVER_receive_done' after %s\n"),
 891        (unsigned int) client->warn_type,
 892        GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (client->warn_start),
 893                                                GNUNET_YES));
 894 }
 895
 896
 897 /**
 898  * Disable the warning the server issues if a message is not acknowledged
 899  * in a timely fashion.  Use this call if a client is intentionally delayed
 900  * for a while.  Only applies to the current message.
 901  *
 902  * @param client client for which to disable the warning
 903  */
 904 void
 905 GNUNET_SERVER_disable_receive_done_warning (struct GNUNET_SERVER_Client *client)
 906 {
 907   if (NULL != client->warn_task)
 908   {
 909     GNUNET_SCHEDULER_cancel (client->warn_task);
 910     client->warn_task = NULL;
 911   }
 912 }
 913
 914
 915 /**
 916  * Inject a message into the server, pretend it came
 917  * from the specified client.  Delivery of the message
 918  * will happen instantly (if a handler is installed;
 919  * otherwise the call does nothing).
 920  *
 921  * @param server the server receiving the message
 922  * @param sender the "pretended" sender of the message
 923  *        can be NULL!
 924  * @param message message to transmit
 925  * @return #GNUNET_OK if the message was OK and the
 926  *                   connection can stay open
 927  *         #GNUNET_SYSERR if the connection to the
 928  *         client should be shut down
 929  */
 930 int
 931 GNUNET_SERVER_inject (struct GNUNET_SERVER_Handle *server,
 932                       struct GNUNET_SERVER_Client *sender,
 933                       const struct GNUNET_MessageHeader *message)
 934 {
 935   struct HandlerList *pos;
 936   const struct GNUNET_SERVER_MessageHandler *mh;
 937   unsigned int i;
 938   uint16_t type;
 939   uint16_t size;
 940   int found;
 941
 942   type = ntohs (message->type);
 943   size = ntohs (message->size);
 944   LOG (GNUNET_ERROR_TYPE_INFO,
 945        "Received message of type %u and size %u from client\n",
 946        type, size);
 947   found = GNUNET_NO;
 948   for (pos = server->handlers; NULL != pos; pos = pos->next)
 949   {
 950     i = 0;
 951     while (pos->handlers[i].callback != NULL)
 952     {
 953       mh = &pos->handlers[i];
 954       if ((mh->type == type) || (mh->type == GNUNET_MESSAGE_TYPE_ALL))
 955       {
 956         if ((0 != mh->expected_size) && (mh->expected_size != size))
 957         {
 958 #if GNUNET8_NETWORK_IS_DEAD
 959           LOG (GNUNET_ERROR_TYPE_WARNING,
 960                "Expected %u bytes for message of type %u, got %u\n",
 961                mh->expected_size, mh->type, size);
 962           GNUNET_break_op (0);
 963 #else
 964           LOG (GNUNET_ERROR_TYPE_DEBUG,
 965                "Expected %u bytes for message of type %u, got %u\n",
 966                mh->expected_size, mh->type, size);
 967 #endif
 968           return GNUNET_SYSERR;
 969         }
 970         if (NULL != sender)
 971         {
 972           if ( (0 == sender->suspended) &&
 973                (NULL == sender->warn_task) )
 974           {
 975             GNUNET_break (0 != type); /* type should never be 0 here, as we don't use 0 */
 976             sender->warn_start = GNUNET_TIME_absolute_get ();
 977             sender->warn_task =
 978                 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
 979                                               &warn_no_receive_done,
 980                                               sender);
 981             sender->warn_type = type;
 982           }
 983           sender->suspended++;
 984         }
 985         mh->callback (mh->callback_cls, sender, message);
 986         found = GNUNET_YES;
 987       }
 988       i++;
 989     }
 990   }
 991   if (GNUNET_NO == found)
 992   {
 993     LOG (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
 994          "Received message of unknown type %d\n", type);
 995     if (GNUNET_YES == server->require_found)
 996       return GNUNET_SYSERR;
 997   }
 998   return GNUNET_OK;
 999 }
1000
1001
1002 /**
1003  * We are receiving an incoming message.  Process it.
1004  *
1005  * @param cls our closure (handle for the client)
1006  * @param buf buffer with data received from network
1007  * @param available number of bytes available in buf
1008  * @param addr address of the sender
1009  * @param addrlen length of @a addr
1010  * @param errCode code indicating errors receiving, 0 for success
1011  */
1012 static void
1013 process_incoming (void *cls,
1014                   const void *buf,
1015                   size_t available,
1016                   const struct sockaddr *addr,
1017                   socklen_t addrlen,
1018                   int errCode);
1019
1020
1021 /**
1022  * Process messages from the client's message tokenizer until either
1023  * the tokenizer is empty (and then schedule receiving more), or
1024  * until some handler is not immediately done (then wait for restart_processing)
1025  * or shutdown.
1026  *
1027  * @param client the client to process, RC must have already been increased
1028  *        using #GNUNET_SERVER_client_keep and will be decreased by one in this
1029  *        function
1030  * @param ret #GNUNET_NO to start processing from the buffer,
1031  *            #GNUNET_OK if the mst buffer is drained and we should instantly go back to receiving
1032  *            #GNUNET_SYSERR if we should instantly abort due to error in a previous step
1033  */
1034 static void
1035 process_mst (struct GNUNET_SERVER_Client *client,
1036              int ret)
1037 {
1038   while ((GNUNET_SYSERR != ret) && (NULL != client->server) &&
1039          (GNUNET_YES != client->shutdown_now) && (0 == client->suspended))
1040   {
1041     if (GNUNET_OK == ret)
1042     {
1043       LOG (GNUNET_ERROR_TYPE_DEBUG,
1044            "Server re-enters receive loop, timeout: %s.\n",
1045            GNUNET_STRINGS_relative_time_to_string (client->idle_timeout, GNUNET_YES));
1046       client->receive_pending = GNUNET_YES;
1047       if (GNUNET_OK !=
1048           GNUNET_CONNECTION_receive (client->connection,
1049                                      GNUNET_MAX_MESSAGE_SIZE - 1,
1050                                      client->idle_timeout,
1051                                      &process_incoming,
1052                                      client))
1053         return;
1054       break;
1055     }
1056     LOG (GNUNET_ERROR_TYPE_DEBUG,
1057          "Server processes additional messages instantly.\n");
1058     if (NULL != client->server->mst_receive)
1059       ret =
1060           client->server->mst_receive (client->server->mst_cls, client->mst,
1061                                        client, NULL, 0, GNUNET_NO, GNUNET_YES);
1062     else
1063       ret =
1064           GNUNET_SERVER_mst_receive (client->mst, client, NULL, 0, GNUNET_NO,
1065                                      GNUNET_YES);
1066   }
1067   LOG (GNUNET_ERROR_TYPE_DEBUG,
1068        "Server leaves instant processing loop: ret = %d, server = %p, shutdown = %d, suspended = %u\n",
1069        ret, client->server,
1070        client->shutdown_now,
1071        client->suspended);
1072   if (GNUNET_NO == ret)
1073   {
1074     LOG (GNUNET_ERROR_TYPE_DEBUG,
1075          "Server has more data pending but is suspended.\n");
1076     client->receive_pending = GNUNET_SYSERR;    /* data pending */
1077   }
1078   if ( (GNUNET_SYSERR == ret) ||
1079        (GNUNET_YES == client->shutdown_now) )
1080     GNUNET_SERVER_client_disconnect (client);
1081 }
1082
1083
1084 /**
1085  * We are receiving an incoming message.  Process it.
1086  *
1087  * @param cls our closure (handle for the client)
1088  * @param buf buffer with data received from network
1089  * @param available number of bytes available in buf
1090  * @param addr address of the sender
1091  * @param addrlen length of @a addr
1092  * @param errCode code indicating errors receiving, 0 for success
1093  */
1094 static void
1095 process_incoming (void *cls,
1096                   const void *buf,
1097                   size_t available,
1098                   const struct sockaddr *addr,
1099                   socklen_t addrlen,
1100                   int errCode)
1101 {
1102   struct GNUNET_SERVER_Client *client = cls;
1103   struct GNUNET_SERVER_Handle *server = client->server;
1104   struct GNUNET_TIME_Absolute end;
1105   struct GNUNET_TIME_Absolute now;
1106   int ret;
1107
1108   GNUNET_assert (GNUNET_YES == client->receive_pending);
1109   client->receive_pending = GNUNET_NO;
1110   now = GNUNET_TIME_absolute_get ();
1111   end = GNUNET_TIME_absolute_add (client->last_activity,
1112                                   client->idle_timeout);
1113
1114   if ( (NULL == buf) &&
1115        (0 == available) &&
1116        (NULL == addr) &&
1117        (0 == errCode) &&
1118        (GNUNET_YES != client->shutdown_now) &&
1119        (NULL != server) &&
1120        (GNUNET_YES == GNUNET_CONNECTION_check (client->connection)) &&
1121        (end.abs_value_us > now.abs_value_us) )
1122   {
1123     /* wait longer, timeout changed (i.e. due to us sending) */
1124     LOG (GNUNET_ERROR_TYPE_DEBUG,
1125          "Receive time out, but no disconnect due to sending (%p)\n",
1126          client);
1127     client->receive_pending = GNUNET_YES;
1128     GNUNET_CONNECTION_receive (client->connection,
1129                                GNUNET_MAX_MESSAGE_SIZE - 1,
1130                                GNUNET_TIME_absolute_get_remaining (end),
1131                                &process_incoming,
1132                                client);
1133     return;
1134   }
1135   if ( (NULL == buf) ||
1136        (0 == available) ||
1137        (0 != errCode) ||
1138        (NULL == server) ||
1139        (GNUNET_YES == client->shutdown_now) ||
1140        (GNUNET_YES != GNUNET_CONNECTION_check (client->connection)) )
1141   {
1142     /* other side closed connection, error connecting, etc. */
1143     LOG (GNUNET_ERROR_TYPE_DEBUG,
1144          "Failed to connect or other side closed connection (%p)\n",
1145          client);
1146     GNUNET_SERVER_client_disconnect (client);
1147     return;
1148   }
1149   LOG (GNUNET_ERROR_TYPE_DEBUG,
1150        "Server receives %u bytes from `%s'.\n",
1151        (unsigned int) available,
1152        GNUNET_a2s (addr, addrlen));
1153   GNUNET_SERVER_client_keep (client);
1154   client->last_activity = now;
1155
1156   if (NULL != server->mst_receive)
1157   {
1158     ret = client->server->mst_receive (client->server->mst_cls,
1159                                        client->mst,
1160                                        client,
1161                                        buf,
1162                                        available,
1163                                        GNUNET_NO,
1164                                        GNUNET_YES);
1165   }
1166   else if (NULL != client->mst)
1167   {
1168     ret =
1169         GNUNET_SERVER_mst_receive (client->mst,
1170                                    client,
1171                                    buf,
1172                                    available,
1173                                    GNUNET_NO,
1174                                    GNUNET_YES);
1175   }
1176   else
1177   {
1178     GNUNET_break (0);
1179     return;
1180   }
1181   process_mst (client,
1182                ret);
1183   GNUNET_SERVER_client_drop (client);
1184 }
1185
1186
1187 /**
1188  * Task run to start again receiving from the network
1189  * and process requests.
1190  *
1191  * @param cls our `struct GNUNET_SERVER_Client *` to process more requests from
1192  */
1193 static void
1194 restart_processing (void *cls)
1195 {
1196   struct GNUNET_SERVER_Client *client = cls;
1197
1198   GNUNET_assert (GNUNET_YES != client->shutdown_now);
1199   client->restart_task = NULL;
1200   if (GNUNET_NO == client->receive_pending)
1201   {
1202     LOG (GNUNET_ERROR_TYPE_DEBUG, "Server begins to read again from client.\n");
1203     client->receive_pending = GNUNET_YES;
1204     GNUNET_CONNECTION_receive (client->connection,
1205                                GNUNET_MAX_MESSAGE_SIZE - 1,
1206                                client->idle_timeout,
1207                                &process_incoming,
1208                                client);
1209     return;
1210   }
1211   LOG (GNUNET_ERROR_TYPE_DEBUG,
1212        "Server continues processing messages still in the buffer.\n");
1213   GNUNET_SERVER_client_keep (client);
1214   client->receive_pending = GNUNET_NO;
1215   process_mst (client,
1216                GNUNET_NO);
1217   GNUNET_SERVER_client_drop (client);
1218 }
1219
1220
1221 /**
1222  * This function is called whenever our inbound message tokenizer has
1223  * received a complete message.
1224  *
1225  * @param cls closure (struct GNUNET_SERVER_Handle)
1226  * @param client identification of the client (`struct GNUNET_SERVER_Client *`)
1227  * @param message the actual message
1228  *
1229  * @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing
1230  */
1231 static int
1232 client_message_tokenizer_callback (void *cls,
1233                                    void *client,
1234                                    const struct GNUNET_MessageHeader *message)
1235 {
1236   struct GNUNET_SERVER_Handle *server = cls;
1237   struct GNUNET_SERVER_Client *sender = client;
1238   int ret;
1239
1240   LOG (GNUNET_ERROR_TYPE_DEBUG,
1241        "Tokenizer gives server message of type %u and size %u from client\n",
1242        ntohs (message->type), ntohs (message->size));
1243   sender->in_process_client_buffer = GNUNET_YES;
1244   ret = GNUNET_SERVER_inject (server, sender, message);
1245   sender->in_process_client_buffer = GNUNET_NO;
1246   if ( (GNUNET_OK != ret) || (GNUNET_YES == sender->shutdown_now) )
1247   {
1248     GNUNET_SERVER_client_disconnect (sender);
1249     return GNUNET_SYSERR;
1250   }
1251   return GNUNET_OK;
1252 }
1253
1254
1255 /**
1256  * Add a TCP socket-based connection to the set of handles managed by
1257  * this server.  Use this function for outgoing (P2P) connections that
1258  * we initiated (and where this server should process incoming
1259  * messages).
1260  *
1261  * @param server the server to use
1262  * @param connection the connection to manage (client must
1263  *        stop using this connection from now on)
1264  * @return the client handle
1265  */
1266 struct GNUNET_SERVER_Client *
1267 GNUNET_SERVER_connect_socket (struct GNUNET_SERVER_Handle *server,
1268                               struct GNUNET_CONNECTION_Handle *connection)
1269 {
1270   struct GNUNET_SERVER_Client *client;
1271   struct NotifyList *n;
1272
1273   client = GNUNET_new (struct GNUNET_SERVER_Client);
1274   client->connection = connection;
1275   client->server = server;
1276   client->last_activity = GNUNET_TIME_absolute_get ();
1277   client->idle_timeout = server->idle_timeout;
1278   GNUNET_CONTAINER_DLL_insert (server->clients_head,
1279                                server->clients_tail,
1280                                client);
1281   if (NULL != server->mst_create)
1282     client->mst =
1283         server->mst_create (server->mst_cls, client);
1284   else
1285     client->mst =
1286         GNUNET_SERVER_mst_create (&client_message_tokenizer_callback,
1287                                   server);
1288   GNUNET_assert (NULL != client->mst);
1289   for (n = server->connect_notify_list_head; NULL != n; n = n->next)
1290     n->callback (n->callback_cls, client);
1291   client->receive_pending = GNUNET_YES;
1292   if (GNUNET_SYSERR ==
1293       GNUNET_CONNECTION_receive (client->connection,
1294                                  GNUNET_MAX_MESSAGE_SIZE - 1,
1295                                  client->idle_timeout,
1296                                  &process_incoming,
1297                                  client))
1298     return NULL;
1299   return client;
1300 }
1301
1302
1303 /**
1304  * Change the timeout for a particular client.  Decreasing the timeout
1305  * may not go into effect immediately (only after the previous timeout
1306  * times out or activity happens on the socket).
1307  *
1308  * @param client the client to update
1309  * @param timeout new timeout for activities on the socket
1310  */
1311 void
1312 GNUNET_SERVER_client_set_timeout (struct GNUNET_SERVER_Client *client,
1313                                   struct GNUNET_TIME_Relative timeout)
1314 {
1315   client->idle_timeout = timeout;
1316 }
1317
1318
1319 /**
1320  * Notify the server that the given client handle should
1321  * be kept (keeps the connection up if possible, increments
1322  * the internal reference counter).
1323  *
1324  * @param client the client to keep
1325  */
1326 void
1327 GNUNET_SERVER_client_keep (struct GNUNET_SERVER_Client *client)
1328 {
1329   client->reference_count++;
1330 }
1331
1332
1333 /**
1334  * Notify the server that the given client handle is no
1335  * longer required.  Decrements the reference counter.  If
1336  * that counter reaches zero an inactive connection maybe
1337  * closed.
1338  *
1339  * @param client the client to drop
1340  */
1341 void
1342 GNUNET_SERVER_client_drop (struct GNUNET_SERVER_Client *client)
1343 {
1344   GNUNET_assert (client->reference_count > 0);
1345   client->reference_count--;
1346   if ((GNUNET_YES == client->shutdown_now) && (0 == client->reference_count))
1347     GNUNET_SERVER_client_disconnect (client);
1348 }
1349
1350
1351 /**
1352  * Obtain the network address of the other party.
1353  *
1354  * @param client the client to get the address for
1355  * @param addr where to store the address
1356  * @param addrlen where to store the length of the @a addr
1357  * @return #GNUNET_OK on success
1358  */
1359 int
1360 GNUNET_SERVER_client_get_address (struct GNUNET_SERVER_Client *client,
1361                                   void **addr, size_t * addrlen)
1362 {
1363   return GNUNET_CONNECTION_get_address (client->connection, addr, addrlen);
1364 }
1365
1366
1367 /**
1368  * Ask the server to notify us whenever a client disconnects.
1369  * This function is called whenever the actual network connection
1370  * is closed; the reference count may be zero or larger than zero
1371  * at this point.
1372  *
1373  * @param server the server manageing the clients
1374  * @param callback function to call on disconnect
1375  * @param callback_cls closure for @a callback
1376  */
1377 void
1378 GNUNET_SERVER_disconnect_notify (struct GNUNET_SERVER_Handle *server,
1379                                  GNUNET_SERVER_DisconnectCallback callback,
1380                                  void *callback_cls)
1381 {
1382   struct NotifyList *n;
1383
1384   n = GNUNET_new (struct NotifyList);
1385   n->callback = callback;
1386   n->callback_cls = callback_cls;
1387   GNUNET_CONTAINER_DLL_insert (server->disconnect_notify_list_head,
1388                                server->disconnect_notify_list_tail,
1389                                n);
1390 }
1391
1392
1393 /**
1394  * Ask the server to notify us whenever a client connects.
1395  * This function is called whenever the actual network connection
1396  * is opened. If the server is destroyed before this
1397  * notification is explicitly cancelled, the 'callback' will
1398  * once be called with a 'client' argument of NULL to indicate
1399  * that the server itself is now gone (and that the callback
1400  * won't be called anymore and also can no longer be cancelled).
1401  *
1402  * @param server the server manageing the clients
1403  * @param callback function to call on sconnect
1404  * @param callback_cls closure for @a callback
1405  */
1406 void
1407 GNUNET_SERVER_connect_notify (struct GNUNET_SERVER_Handle *server,
1408                               GNUNET_SERVER_ConnectCallback callback,
1409                               void *callback_cls)
1410 {
1411   struct NotifyList *n;
1412   struct GNUNET_SERVER_Client *client;
1413
1414   n = GNUNET_new (struct NotifyList);
1415   n->callback = callback;
1416   n->callback_cls = callback_cls;
1417   GNUNET_CONTAINER_DLL_insert (server->connect_notify_list_head,
1418                                server->connect_notify_list_tail,
1419                                n);
1420   for (client = server->clients_head; NULL != client; client = client->next)
1421     callback (callback_cls, client);
1422 }
1423
1424
1425 /**
1426  * Ask the server to stop notifying us whenever a client connects.
1427  *
1428  * @param server the server manageing the clients
1429  * @param callback function to call on connect
1430  * @param callback_cls closure for @a callback
1431  */
1432 void
1433 GNUNET_SERVER_disconnect_notify_cancel (struct GNUNET_SERVER_Handle *server,
1434                                         GNUNET_SERVER_DisconnectCallback callback,
1435                                         void *callback_cls)
1436 {
1437   struct NotifyList *pos;
1438
1439   for (pos = server->disconnect_notify_list_head; NULL != pos; pos = pos->next)
1440     if ((pos->callback == callback) && (pos->callback_cls == callback_cls))
1441       break;
1442   if (NULL == pos)
1443   {
1444     GNUNET_break (0);
1445     return;
1446   }
1447   GNUNET_CONTAINER_DLL_remove (server->disconnect_notify_list_head,
1448                                server->disconnect_notify_list_tail,
1449                                pos);
1450   GNUNET_free (pos);
1451 }
1452
1453
1454 /**
1455  * Ask the server to stop notifying us whenever a client disconnects.
1456  *
1457  * @param server the server manageing the clients
1458  * @param callback function to call on disconnect
1459  * @param callback_cls closure for @a callback
1460  */
1461 void
1462 GNUNET_SERVER_connect_notify_cancel (struct GNUNET_SERVER_Handle *server,
1463                                      GNUNET_SERVER_ConnectCallback callback,
1464                                      void *callback_cls)
1465 {
1466   struct NotifyList *pos;
1467
1468   for (pos = server->connect_notify_list_head; NULL != pos; pos = pos->next)
1469     if ((pos->callback == callback) && (pos->callback_cls == callback_cls))
1470       break;
1471   if (NULL == pos)
1472   {
1473     GNUNET_break (0);
1474     return;
1475   }
1476   GNUNET_CONTAINER_DLL_remove (server->connect_notify_list_head,
1477                                server->connect_notify_list_tail,
1478                                pos);
1479   GNUNET_free (pos);
1480 }
1481
1482
1483 /**
1484  * Ask the server to disconnect from the given client.
1485  * This is the same as returning #GNUNET_SYSERR from a message
1486  * handler, except that it allows dropping of a client even
1487  * when not handling a message from that client.
1488  *
1489  * @param client the client to disconnect from
1490  */
1491 void
1492 GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client)
1493 {
1494   struct GNUNET_SERVER_Handle *server = client->server;
1495   struct NotifyList *n;
1496
1497   LOG (GNUNET_ERROR_TYPE_DEBUG,
1498        "Client is being disconnected from the server.\n");
1499   if (NULL != client->restart_task)
1500   {
1501     GNUNET_SCHEDULER_cancel (client->restart_task);
1502     client->restart_task = NULL;
1503   }
1504   if (NULL != client->warn_task)
1505   {
1506     GNUNET_SCHEDULER_cancel (client->warn_task);
1507     client->warn_task = NULL;
1508   }
1509   if (GNUNET_YES == client->receive_pending)
1510   {
1511     GNUNET_CONNECTION_receive_cancel (client->connection);
1512     client->receive_pending = GNUNET_NO;
1513   }
1514   client->shutdown_now = GNUNET_YES;
1515   client->reference_count++; /* make sure nobody else clean up client... */
1516   if ( (NULL != client->mst) &&
1517        (NULL != server) )
1518   {
1519     GNUNET_CONTAINER_DLL_remove (server->clients_head,
1520                                  server->clients_tail,
1521                                  client);
1522     if (NULL != server->mst_destroy)
1523       server->mst_destroy (server->mst_cls,
1524                            client->mst);
1525     else
1526       GNUNET_SERVER_mst_destroy (client->mst);
1527     client->mst = NULL;
1528     for (n = server->disconnect_notify_list_head; NULL != n; n = n->next)
1529       n->callback (n->callback_cls,
1530                    client);
1531   }
1532   client->reference_count--;
1533   if (client->reference_count > 0)
1534   {
1535     LOG (GNUNET_ERROR_TYPE_DEBUG,
1536          "RC of %p still positive, not destroying everything.\n",
1537          client);
1538     client->server = NULL;
1539     return;
1540   }
1541   if (GNUNET_YES == client->in_process_client_buffer)
1542   {
1543     LOG (GNUNET_ERROR_TYPE_DEBUG,
1544          "Still processing inputs of %p, not destroying everything.\n",
1545          client);
1546     return;
1547   }
1548   LOG (GNUNET_ERROR_TYPE_DEBUG,
1549        "RC of %p now zero, destroying everything.\n",
1550        client);
1551   if (GNUNET_YES == client->persist)
1552     GNUNET_CONNECTION_persist_ (client->connection);
1553   if (NULL != client->th.cth)
1554     GNUNET_SERVER_notify_transmit_ready_cancel (&client->th);
1555   GNUNET_CONNECTION_destroy (client->connection);
1556   /* need to cancel again, as it might have been re-added
1557      in the meantime (i.e. during callbacks) */
1558   if (NULL != client->warn_task)
1559   {
1560     GNUNET_SCHEDULER_cancel (client->warn_task);
1561     client->warn_task = NULL;
1562   }
1563   if (GNUNET_YES == client->receive_pending)
1564   {
1565     GNUNET_CONNECTION_receive_cancel (client->connection);
1566     client->receive_pending = GNUNET_NO;
1567   }
1568   GNUNET_free (client);
1569   /* we might be in soft-shutdown, test if we're done */
1570   if (NULL != server)
1571     test_monitor_clients (server);
1572 }
1573
1574
1575 /**
1576  * Disable the "CORK" feature for communication with the given client,
1577  * forcing the OS to immediately flush the buffer on transmission
1578  * instead of potentially buffering multiple messages.
1579  *
1580  * @param client handle to the client
1581  * @return #GNUNET_OK on success
1582  */
1583 int
1584 GNUNET_SERVER_client_disable_corking (struct GNUNET_SERVER_Client *client)
1585 {
1586   return GNUNET_CONNECTION_disable_corking (client->connection);
1587 }
1588
1589
1590 /**
1591  * Wrapper for transmission notification that calls the original
1592  * callback and update the last activity time for our connection.
1593  *
1594  * @param cls the `struct GNUNET_SERVER_Client *`
1595  * @param size number of bytes we can transmit
1596  * @param buf where to copy the message
1597  * @return number of bytes actually transmitted
1598  */
1599 static size_t
1600 transmit_ready_callback_wrapper (void *cls, size_t size, void *buf)
1601 {
1602   struct GNUNET_SERVER_Client *client = cls;
1603   GNUNET_CONNECTION_TransmitReadyNotify callback;
1604
1605   client->th.cth = NULL;
1606   callback = client->th.callback;
1607   client->th.callback = NULL;
1608   client->last_activity = GNUNET_TIME_absolute_get ();
1609   return callback (client->th.callback_cls, size, buf);
1610 }
1611
1612
1613 /**
1614  * Notify us when the server has enough space to transmit
1615  * a message of the given size to the given client.
1616  *
1617  * @param client client to transmit message to
1618  * @param size requested amount of buffer space
1619  * @param timeout after how long should we give up (and call
1620  *        notify with buf NULL and size 0)?
1621  * @param callback function to call when space is available
1622  * @param callback_cls closure for @a callback
1623  * @return non-NULL if the notify callback was queued; can be used
1624  *         to cancel the request using
1625  *         #GNUNET_SERVER_notify_transmit_ready_cancel().
1626  *         NULL if we are already going to notify someone else (busy)
1627  */
1628 struct GNUNET_SERVER_TransmitHandle *
1629 GNUNET_SERVER_notify_transmit_ready (struct GNUNET_SERVER_Client *client,
1630                                      size_t size,
1631                                      struct GNUNET_TIME_Relative timeout,
1632                                      GNUNET_CONNECTION_TransmitReadyNotify callback,
1633                                      void *callback_cls)
1634 {
1635   if (NULL != client->th.callback)
1636     return NULL;
1637   client->th.callback_cls = callback_cls;
1638   client->th.callback = callback;
1639   client->th.cth = GNUNET_CONNECTION_notify_transmit_ready (client->connection, size,
1640                                                             timeout,
1641                                                             &transmit_ready_callback_wrapper,
1642                                                             client);
1643   return &client->th;
1644 }
1645
1646
1647 /**
1648  * Abort transmission request.
1649  *
1650  * @param th request to abort
1651  */
1652 void
1653 GNUNET_SERVER_notify_transmit_ready_cancel (struct GNUNET_SERVER_TransmitHandle *th)
1654 {
1655   GNUNET_CONNECTION_notify_transmit_ready_cancel (th->cth);
1656   th->cth = NULL;
1657   th->callback = NULL;
1658 }
1659
1660
1661 /**
1662  * Set the persistent flag on this client, used to setup client connection
1663  * to only be killed when the service it's connected to is actually dead.
1664  *
1665  * @param client the client to set the persistent flag on
1666  */
1667 void
1668 GNUNET_SERVER_client_persist_ (struct GNUNET_SERVER_Client *client)
1669 {
1670   client->persist = GNUNET_YES;
1671 }
1672
1673
1674 /**
1675  * Resume receiving from this client, we are done processing the
1676  * current request.  This function must be called from within each
1677  * GNUNET_SERVER_MessageCallback (or its respective continuations).
1678  *
1679  * @param client client we were processing a message of
1680  * @param success #GNUNET_OK to keep the connection open and
1681  *                          continue to receive
1682  *                #GNUNET_NO to close the connection (normal behavior)
1683  *                #GNUNET_SYSERR to close the connection (signal
1684  *                          serious error)
1685  */
1686 void
1687 GNUNET_SERVER_receive_done (struct GNUNET_SERVER_Client *client,
1688                             int success)
1689 {
1690   if (NULL == client)
1691     return;
1692   GNUNET_assert (client->suspended > 0);
1693   client->suspended--;
1694   if (GNUNET_OK != success)
1695   {
1696     LOG (GNUNET_ERROR_TYPE_DEBUG,
1697          "GNUNET_SERVER_receive_done called with failure indication\n");
1698     if ( (client->reference_count > 0) || (client->suspended > 0) )
1699       client->shutdown_now = GNUNET_YES;
1700     else
1701       GNUNET_SERVER_client_disconnect (client);
1702     return;
1703   }
1704   if (client->suspended > 0)
1705   {
1706     LOG (GNUNET_ERROR_TYPE_DEBUG,
1707          "GNUNET_SERVER_receive_done called, but more clients pending\n");
1708     return;
1709   }
1710   if (NULL != client->warn_task)
1711   {
1712     GNUNET_SCHEDULER_cancel (client->warn_task);
1713     client->warn_task = NULL;
1714   }
1715   if (GNUNET_YES == client->in_process_client_buffer)
1716   {
1717     LOG (GNUNET_ERROR_TYPE_DEBUG,
1718          "GNUNET_SERVER_receive_done called while still in processing loop\n");
1719     return;
1720   }
1721   if ((NULL == client->server) || (GNUNET_YES == client->shutdown_now))
1722   {
1723     GNUNET_SERVER_client_disconnect (client);
1724     return;
1725   }
1726   LOG (GNUNET_ERROR_TYPE_DEBUG,
1727        "GNUNET_SERVER_receive_done causes restart in reading from the socket\n");
1728   GNUNET_assert (NULL == client->restart_task);
1729   client->restart_task = GNUNET_SCHEDULER_add_now (&restart_processing,
1730                                                    client);
1731 }
1732
1733
1734 /* end of server.c */