src/util/server.c

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