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