src/util/service.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2016 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/service_new.c
  23  * @brief functions related to starting services (redesign)
  24  * @author Christian Grothoff
  25  * @author Florian Dold
  26  */
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_protocols.h"
  30 #include "gnunet_constants.h"
  31 #include "gnunet_resolver_service.h"
  32 #include "speedup.h"
  33
  34 #if HAVE_MALLINFO
  35 #include <malloc.h>
  36 #include "gauger.h"
  37 #endif
  38
  39
  40 #define LOG(kind,...) GNUNET_log_from (kind, "util-service", __VA_ARGS__)
  41
  42 #define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util-service", syscall)
  43
  44 #define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util-service", syscall, filename)
  45
  46
  47 /**
  48  * Information the service tracks per listen operation.
  49  */
  50 struct ServiceListenContext
  51 {
  52
  53   /**
  54    * Kept in a DLL.
  55    */
  56   struct ServiceListenContext *next;
  57
  58   /**
  59    * Kept in a DLL.
  60    */
  61   struct ServiceListenContext *prev;
  62
  63   /**
  64    * Service this listen context belongs to.
  65    */
  66   struct GNUNET_SERVICE_Handle *sh;
  67
  68   /**
  69    * Socket we are listening on.
  70    */
  71   struct GNUNET_NETWORK_Handle *listen_socket;
  72
  73   /**
  74    * Task scheduled to do the listening.
  75    */
  76   struct GNUNET_SCHEDULER_Task *listen_task;
  77
  78 };
  79
  80
  81 /**
  82  * Reasons why we might be suspended.
  83  */
  84 enum SuspendReason
  85 {
  86  /**
  87   * We are running normally.
  88   */
  89  SUSPEND_STATE_NONE = 0,
  90
  91  /**
  92   * Application requested it.
  93   */
  94  SUSPEND_STATE_APP = 1,
  95
  96  /**
  97   * OS ran out of file descriptors.
  98   */
  99  SUSPEND_STATE_EMFILE = 2,
 100
 101  /**
 102   * Both reasons, APP and EMFILE apply.
 103   */
 104  SUSPEND_STATE_APP_AND_EMFILE = 3,
 105
 106  /**
 107   * Suspension because service was permanently shutdown.
 108   */
 109  SUSPEND_STATE_SHUTDOWN = 4
 110 };
 111
 112
 113 /**
 114  * Handle to a service.
 115  */
 116 struct GNUNET_SERVICE_Handle
 117 {
 118   /**
 119    * Our configuration.
 120    */
 121   const struct GNUNET_CONFIGURATION_Handle *cfg;
 122
 123   /**
 124    * Name of our service.
 125    */
 126   const char *service_name;
 127
 128   /**
 129    * Main service-specific task to run.
 130    */
 131   GNUNET_SERVICE_InitCallback service_init_cb;
 132
 133   /**
 134    * Function to call when clients connect.
 135    */
 136   GNUNET_SERVICE_ConnectHandler connect_cb;
 137
 138   /**
 139    * Function to call when clients disconnect / are disconnected.
 140    */
 141   GNUNET_SERVICE_DisconnectHandler disconnect_cb;
 142
 143   /**
 144    * Closure for @e service_init_cb, @e connect_cb, @e disconnect_cb.
 145    */
 146   void *cb_cls;
 147
 148   /**
 149    * DLL of listen sockets used to accept new connections.
 150    */
 151   struct ServiceListenContext *slc_head;
 152
 153   /**
 154    * DLL of listen sockets used to accept new connections.
 155    */
 156   struct ServiceListenContext *slc_tail;
 157
 158   /**
 159    * Our clients, kept in a DLL.
 160    */
 161   struct GNUNET_SERVICE_Client *clients_head;
 162
 163   /**
 164    * Our clients, kept in a DLL.
 165    */
 166   struct GNUNET_SERVICE_Client *clients_tail;
 167
 168   /**
 169    * Message handlers to use for all clients.
 170    */
 171   struct GNUNET_MQ_MessageHandler *handlers;
 172
 173   /**
 174    * Closure for @e task.
 175    */
 176   void *task_cls;
 177
 178   /**
 179    * IPv4 addresses that are not allowed to connect.
 180    */
 181   struct GNUNET_STRINGS_IPv4NetworkPolicy *v4_denied;
 182
 183   /**
 184    * IPv6 addresses that are not allowed to connect.
 185    */
 186   struct GNUNET_STRINGS_IPv6NetworkPolicy *v6_denied;
 187
 188   /**
 189    * IPv4 addresses that are allowed to connect (if not
 190    * set, all are allowed).
 191    */
 192   struct GNUNET_STRINGS_IPv4NetworkPolicy *v4_allowed;
 193
 194   /**
 195    * IPv6 addresses that are allowed to connect (if not
 196    * set, all are allowed).
 197    */
 198   struct GNUNET_STRINGS_IPv6NetworkPolicy *v6_allowed;
 199
 200   /**
 201    * Do we require a matching UID for UNIX domain socket connections?
 202    * #GNUNET_NO means that the UID does not have to match (however,
 203    * @e match_gid may still impose other access control checks).
 204    */
 205   int match_uid;
 206
 207   /**
 208    * Do we require a matching GID for UNIX domain socket connections?
 209    * Ignored if @e match_uid is #GNUNET_YES.  Note that this is about
 210    * checking that the client's UID is in our group OR that the
 211    * client's GID is our GID.  If both "match_gid" and @e match_uid are
 212    * #GNUNET_NO, all users on the local system have access.
 213    */
 214   int match_gid;
 215
 216   /**
 217    * Are we suspended, and if so, why?
 218    */
 219   enum SuspendReason suspend_state;
 220
 221   /**
 222    * Our options.
 223    */
 224   enum GNUNET_SERVICE_Options options;
 225
 226   /**
 227    * If we are daemonizing, this FD is set to the
 228    * pipe to the parent.  Send '.' if we started
 229    * ok, '!' if not.  -1 if we are not daemonizing.
 230    */
 231   int ready_confirm_fd;
 232
 233   /**
 234    * Overall success/failure of the service start.
 235    */
 236   int ret;
 237
 238   /**
 239    * If #GNUNET_YES, consider unknown message types an error where the
 240    * client is disconnected.
 241    */
 242   int require_found;
 243 };
 244
 245
 246 /**
 247  * Handle to a client that is connected to a service.
 248  */
 249 struct GNUNET_SERVICE_Client
 250 {
 251
 252   /**
 253    * Kept in a DLL.
 254    */
 255   struct GNUNET_SERVICE_Client *next;
 256
 257   /**
 258    * Kept in a DLL.
 259    */
 260   struct GNUNET_SERVICE_Client *prev;
 261
 262   /**
 263    * Service that this client belongs to.
 264    */
 265   struct GNUNET_SERVICE_Handle *sh;
 266
 267   /**
 268    * Socket of this client.
 269    */
 270   struct GNUNET_NETWORK_Handle *sock;
 271
 272   /**
 273    * Message queue for the client.
 274    */
 275   struct GNUNET_MQ_Handle *mq;
 276
 277   /**
 278    * Tokenizer we use for processing incoming data.
 279    */
 280   struct GNUNET_MessageStreamTokenizer *mst;
 281
 282   /**
 283    * Task that warns about missing calls to
 284    * #GNUNET_SERVICE_client_continue().
 285    */
 286   struct GNUNET_SCHEDULER_Task *warn_task;
 287
 288   /**
 289    * Task run to finish dropping the client after the stack has
 290    * properly unwound.
 291    */
 292   struct GNUNET_SCHEDULER_Task *drop_task;
 293
 294   /**
 295    * Task that receives data from the client to
 296    * pass it to the handlers.
 297    */
 298   struct GNUNET_SCHEDULER_Task *recv_task;
 299
 300   /**
 301    * Task that transmit data to the client.
 302    */
 303   struct GNUNET_SCHEDULER_Task *send_task;
 304
 305   /**
 306    * Pointer to the message to be transmitted by @e send_task.
 307    */
 308   const struct GNUNET_MessageHeader *msg;
 309
 310   /**
 311    * User context value, value returned from
 312    * the connect callback.
 313    */
 314   void *user_context;
 315
 316   /**
 317    * Time when we last gave a message from this client
 318    * to the application.
 319    */
 320   struct GNUNET_TIME_Absolute warn_start;
 321
 322   /**
 323    * Current position in @e msg at which we are transmitting.
 324    */
 325   size_t msg_pos;
 326
 327   /**
 328    * Persist the file handle for this client no matter what happens,
 329    * force the OS to close once the process actually dies.  Should only
 330    * be used in special cases!
 331    */
 332   int persist;
 333
 334   /**
 335    * Is this client a 'monitor' client that should not be counted
 336    * when deciding on destroying the server during soft shutdown?
 337    * (see also #GNUNET_SERVICE_start)
 338    */
 339   int is_monitor;
 340
 341   /**
 342    * Are we waiting for the application to call #GNUNET_SERVICE_client_continue()?
 343    */
 344   int needs_continue;
 345
 346   /**
 347    * Type of last message processed (for warn_no_receive_done).
 348    */
 349   uint16_t warn_type;
 350 };
 351
 352
 353 /**
 354  * Check if any of the clients we have left are unrelated to
 355  * monitoring.
 356  *
 357  * @param sh service to check clients for
 358  * @return #GNUNET_YES if we have non-monitoring clients left
 359  */
 360 static int
 361 have_non_monitor_clients (struct GNUNET_SERVICE_Handle *sh)
 362 {
 363   for (struct GNUNET_SERVICE_Client *client = sh->clients_head;
 364        NULL != client;
 365        client = client->next)
 366   {
 367     if (client->is_monitor)
 368       continue;
 369     return GNUNET_YES;
 370   }
 371   return GNUNET_NO;
 372 }
 373
 374
 375 /**
 376  * Suspend accepting connections from the listen socket temporarily.
 377  * Resume activity using #do_resume.
 378  *
 379  * @param sh service to stop accepting connections.
 380  * @param sr reason for suspending accepting connections
 381  */
 382 static void
 383 do_suspend (struct GNUNET_SERVICE_Handle *sh,
 384             enum SuspendReason sr)
 385 {
 386   struct ServiceListenContext *slc;
 387
 388   GNUNET_assert (0 == (sh->suspend_state & sr));
 389   sh->suspend_state |= sr;
 390   for (slc = sh->slc_head; NULL != slc; slc = slc->next)
 391   {
 392     if (NULL != slc->listen_task)
 393     {
 394       GNUNET_SCHEDULER_cancel (slc->listen_task);
 395       slc->listen_task = NULL;
 396     }
 397   }
 398 }
 399
 400
 401 /**
 402  * Shutdown task triggered when a service should be terminated.
 403  * This considers active clients and the service options to see
 404  * how this specific service is to be terminated, and depending
 405  * on this proceeds with the shutdown logic.
 406  *
 407  * @param cls our `struct GNUNET_SERVICE_Handle`
 408  */
 409 static void
 410 service_shutdown (void *cls)
 411 {
 412   struct GNUNET_SERVICE_Handle *sh = cls;
 413
 414   switch (sh->options)
 415   {
 416   case GNUNET_SERVICE_OPTION_NONE:
 417     GNUNET_SERVICE_shutdown (sh);
 418     break;
 419   case GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN:
 420     /* This task should never be run if we are using
 421        the manual shutdown. */
 422     GNUNET_assert (0);
 423     break;
 424   case GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN:
 425     if (0 == (sh->suspend_state & SUSPEND_STATE_SHUTDOWN))
 426       do_suspend (sh,
 427                   SUSPEND_STATE_SHUTDOWN);
 428     if (GNUNET_NO == have_non_monitor_clients (sh))
 429       GNUNET_SERVICE_shutdown (sh);
 430     break;
 431   }
 432 }
 433
 434
 435 /**
 436  * Check if the given IP address is in the list of IP addresses.
 437  *
 438  * @param list a list of networks
 439  * @param add the IP to check (in network byte order)
 440  * @return #GNUNET_NO if the IP is not in the list, #GNUNET_YES if it it is
 441  */
 442 static int
 443 check_ipv4_listed (const struct GNUNET_STRINGS_IPv4NetworkPolicy *list,
 444                    const struct in_addr *add)
 445 {
 446   unsigned int i;
 447
 448   if (NULL == list)
 449     return GNUNET_NO;
 450   i = 0;
 451   while ( (0 != list[i].network.s_addr) ||
 452           (0 != list[i].netmask.s_addr) )
 453   {
 454     if ((add->s_addr & list[i].netmask.s_addr) ==
 455         (list[i].network.s_addr & list[i].netmask.s_addr))
 456       return GNUNET_YES;
 457     i++;
 458   }
 459   return GNUNET_NO;
 460 }
 461
 462
 463 /**
 464  * Check if the given IP address is in the list of IP addresses.
 465  *
 466  * @param list a list of networks
 467  * @param ip the IP to check (in network byte order)
 468  * @return #GNUNET_NO if the IP is not in the list, #GNUNET_YES if it it is
 469  */
 470 static int
 471 check_ipv6_listed (const struct GNUNET_STRINGS_IPv6NetworkPolicy *list,
 472                    const struct in6_addr *ip)
 473 {
 474   unsigned int i;
 475   unsigned int j;
 476   struct in6_addr zero;
 477
 478   if (NULL == list)
 479     return GNUNET_NO;
 480   memset (&zero,
 481           0,
 482           sizeof (struct in6_addr));
 483   i = 0;
 484 NEXT:
 485   while (0 != memcmp (&zero,
 486                       &list[i].network,
 487                       sizeof (struct in6_addr)))
 488   {
 489     for (j = 0; j < sizeof (struct in6_addr) / sizeof (int); j++)
 490       if (((((int *) ip)[j] & ((int *) &list[i].netmask)[j])) !=
 491           (((int *) &list[i].network)[j] & ((int *) &list[i].netmask)[j]))
 492       {
 493         i++;
 494         goto NEXT;
 495       }
 496     return GNUNET_YES;
 497   }
 498   return GNUNET_NO;
 499 }
 500
 501
 502 /**
 503  * Task run when we are ready to transmit data to the
 504  * client.
 505  *
 506  * @param cls the `struct GNUNET_SERVICE_Client *` to send to
 507  */
 508 static void
 509 do_send (void *cls)
 510 {
 511   struct GNUNET_SERVICE_Client *client = cls;
 512   ssize_t ret;
 513   size_t left;
 514   const char *buf;
 515
 516   LOG (GNUNET_ERROR_TYPE_DEBUG,
 517        "service: sending message with type %u",
 518        ntohs(client->msg->type));
 519
 520
 521   client->send_task = NULL;
 522   buf = (const char *) client->msg;
 523   left = ntohs (client->msg->size) - client->msg_pos;
 524   ret = GNUNET_NETWORK_socket_send (client->sock,
 525                                     &buf[client->msg_pos],
 526                                     left);
 527   GNUNET_assert (ret <= (ssize_t) left);
 528   if (0 == ret)
 529   {
 530     LOG (GNUNET_ERROR_TYPE_DEBUG,
 531          "no data send");
 532     GNUNET_MQ_inject_error (client->mq,
 533                             GNUNET_MQ_ERROR_WRITE);
 534     return;
 535   }
 536   if (-1 == ret)
 537   {
 538     if ( (EAGAIN == errno) ||
 539          (EINTR == errno) )
 540     {
 541       /* ignore */
 542       ret = 0;
 543     }
 544     else
 545     {
 546       if (EPIPE != errno)
 547         GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
 548                              "send");
 549       LOG (GNUNET_ERROR_TYPE_DEBUG,
 550            "socket send returned with error code %i",
 551            errno);
 552       GNUNET_MQ_inject_error (client->mq,
 553                               GNUNET_MQ_ERROR_WRITE);
 554       return;
 555     }
 556   }
 557   if (0 == client->msg_pos)
 558   {
 559     GNUNET_MQ_impl_send_in_flight (client->mq);
 560   }
 561   client->msg_pos += ret;
 562   if (left > (size_t) ret)
 563   {
 564     GNUNET_assert (NULL == client->drop_task);
 565     client->send_task
 566       = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
 567                                         client->sock,
 568                                         &do_send,
 569                                         client);
 570     return;
 571   }
 572   GNUNET_MQ_impl_send_continue (client->mq);
 573 }
 574
 575
 576 /**
 577  * Signature of functions implementing the sending functionality of a
 578  * message queue.
 579  *
 580  * @param mq the message queue
 581  * @param msg the message to send
 582  * @param impl_state our `struct GNUNET_SERVICE_Client *`
 583  */
 584 static void
 585 service_mq_send (struct GNUNET_MQ_Handle *mq,
 586                  const struct GNUNET_MessageHeader *msg,
 587                  void *impl_state)
 588 {
 589   struct GNUNET_SERVICE_Client *client = impl_state;
 590
 591   (void) mq;
 592   if (NULL != client->drop_task)
 593     return; /* we're going down right now, do not try to send */
 594   GNUNET_assert (NULL == client->send_task);
 595   LOG (GNUNET_ERROR_TYPE_DEBUG,
 596        "Sending message of type %u and size %u to client\n",
 597        ntohs (msg->type),
 598        ntohs (msg->size));
 599   client->msg = msg;
 600   client->msg_pos = 0;
 601   client->send_task
 602     = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
 603                                       client->sock,
 604                                       &do_send,
 605                                       client);
 606 }
 607
 608
 609 /**
 610  * Implementation function that cancels the currently sent message.
 611  *
 612  * @param mq message queue
 613  * @param impl_state state specific to the implementation
 614  */
 615 static void
 616 service_mq_cancel (struct GNUNET_MQ_Handle *mq,
 617                    void *impl_state)
 618 {
 619   struct GNUNET_SERVICE_Client *client = impl_state;
 620
 621   (void) mq;
 622   GNUNET_assert (0 == client->msg_pos);
 623   client->msg = NULL;
 624   GNUNET_SCHEDULER_cancel (client->send_task);
 625   client->send_task = NULL;
 626 }
 627
 628
 629 /**
 630  * Generic error handler, called with the appropriate
 631  * error code and the same closure specified at the creation of
 632  * the message queue.
 633  * Not every message queue implementation supports an error handler.
 634  *
 635  * @param cls closure with our `struct GNUNET_SERVICE_Client`
 636  * @param error error code
 637  */
 638 static void
 639 service_mq_error_handler (void *cls,
 640                           enum GNUNET_MQ_Error error)
 641 {
 642   struct GNUNET_SERVICE_Client *client = cls;
 643   struct GNUNET_SERVICE_Handle *sh = client->sh;
 644
 645   if ( (GNUNET_MQ_ERROR_NO_MATCH == error) &&
 646        (GNUNET_NO == sh->require_found) )
 647   {
 648     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 649                 "No handler for message of type %u found\n",
 650                 (unsigned int) client->warn_type);
 651     GNUNET_SERVICE_client_continue (client);
 652     return; /* ignore error */
 653   }
 654   GNUNET_SERVICE_client_drop (client);
 655 }
 656
 657
 658 /**
 659  * Task run to warn about missing calls to #GNUNET_SERVICE_client_continue().
 660  *
 661  * @param cls our `struct GNUNET_SERVICE_Client *` to process more requests from
 662  */
 663 static void
 664 warn_no_client_continue (void *cls)
 665 {
 666   struct GNUNET_SERVICE_Client *client = cls;
 667
 668   GNUNET_break (0 != client->warn_type); /* type should never be 0 here, as we don't use 0 */
 669   client->warn_task
 670     = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
 671                                     &warn_no_client_continue,
 672                                     client);
 673   LOG (GNUNET_ERROR_TYPE_WARNING,
 674        _("Processing code for message of type %u did not call `GNUNET_SERVICE_client_continue' after %s\n"),
 675        (unsigned int) client->warn_type,
 676        GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (client->warn_start),
 677                                                GNUNET_YES));
 678 }
 679
 680
 681 /**
 682  * Functions with this signature are called whenever a
 683  * complete message is received by the tokenizer for a client.
 684  *
 685  * Do not call #GNUNET_MST_destroy() from within
 686  * the scope of this callback.
 687  *
 688  * @param cls closure with the `struct GNUNET_SERVICE_Client *`
 689  * @param message the actual message
 690  * @return #GNUNET_OK on success, #GNUNET_SYSERR if the client was dropped
 691  */
 692 static int
 693 service_client_mst_cb (void *cls,
 694                        const struct GNUNET_MessageHeader *message)
 695 {
 696   struct GNUNET_SERVICE_Client *client = cls;
 697
 698   LOG (GNUNET_ERROR_TYPE_DEBUG,
 699        "Received message of type %u and size %u from client\n",
 700        ntohs (message->type),
 701        ntohs (message->size));
 702   GNUNET_assert (GNUNET_NO == client->needs_continue);
 703   client->needs_continue = GNUNET_YES;
 704   client->warn_type = ntohs (message->type);
 705   client->warn_start = GNUNET_TIME_absolute_get ();
 706   GNUNET_assert (NULL == client->warn_task);
 707   client->warn_task
 708     = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
 709                                     &warn_no_client_continue,
 710                                     client);
 711   GNUNET_MQ_inject_message (client->mq,
 712                             message);
 713   if (NULL != client->drop_task)
 714     return GNUNET_SYSERR;
 715   return GNUNET_OK;
 716 }
 717
 718
 719 /**
 720  * A client sent us data. Receive and process it.  If we are done,
 721  * reschedule this task.
 722  *
 723  * @param cls the `struct GNUNET_SERVICE_Client` that sent us data.
 724  */
 725 static void
 726 service_client_recv (void *cls)
 727 {
 728   struct GNUNET_SERVICE_Client *client = cls;
 729   int ret;
 730
 731   client->recv_task = NULL;
 732   ret = GNUNET_MST_read (client->mst,
 733                          client->sock,
 734                          GNUNET_NO,
 735                          GNUNET_YES);
 736   if (GNUNET_SYSERR == ret)
 737   {
 738     /* client closed connection (or IO error) */
 739     if (NULL == client->drop_task)
 740     {
 741       GNUNET_assert (GNUNET_NO == client->needs_continue);
 742       GNUNET_SERVICE_client_drop (client);
 743     }
 744     return;
 745   }
 746   if (GNUNET_NO == ret)
 747     return; /* more messages in buffer, wait for application
 748                to be done processing */
 749   GNUNET_assert (GNUNET_OK == ret);
 750   if (GNUNET_YES == client->needs_continue)
 751     return;
 752   if (NULL != client->recv_task)
 753     return;
 754   /* MST needs more data, re-schedule read job */
 755   client->recv_task
 756     = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 757                                      client->sock,
 758                                      &service_client_recv,
 759                                      client);
 760 }
 761
 762
 763 /**
 764  * We have successfully accepted a connection from a client.  Now
 765  * setup the client (with the scheduler) and tell the application.
 766  *
 767  * @param sh service that accepted the client
 768  * @param sock socket associated with the client
 769  */
 770 static void
 771 start_client (struct GNUNET_SERVICE_Handle *sh,
 772               struct GNUNET_NETWORK_Handle *csock)
 773 {
 774   struct GNUNET_SERVICE_Client *client;
 775
 776   client = GNUNET_new (struct GNUNET_SERVICE_Client);
 777   GNUNET_CONTAINER_DLL_insert (sh->clients_head,
 778                                sh->clients_tail,
 779                                client);
 780   client->sh = sh;
 781   client->sock = csock;
 782   client->mq = GNUNET_MQ_queue_for_callbacks (&service_mq_send,
 783                                               NULL,
 784                                               &service_mq_cancel,
 785                                               client,
 786                                               sh->handlers,
 787                                               &service_mq_error_handler,
 788                                               client);
 789   client->mst = GNUNET_MST_create (&service_client_mst_cb,
 790                                    client);
 791   if (NULL != sh->connect_cb)
 792     client->user_context = sh->connect_cb (sh->cb_cls,
 793                                            client,
 794                                            client->mq);
 795   GNUNET_MQ_set_handlers_closure (client->mq,
 796                                   client->user_context);
 797   client->recv_task
 798     = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 799                                      client->sock,
 800                                      &service_client_recv,
 801                                      client);
 802 }
 803
 804
 805 /**
 806  * We have a client. Accept the incoming socket(s) (and reschedule
 807  * the listen task).
 808  *
 809  * @param cls the `struct ServiceListenContext` of the ready listen socket
 810  */
 811 static void
 812 accept_client (void *cls)
 813 {
 814   struct ServiceListenContext *slc = cls;
 815   struct GNUNET_SERVICE_Handle *sh = slc->sh;
 816
 817   slc->listen_task = NULL;
 818   while (1)
 819   {
 820     struct GNUNET_NETWORK_Handle *sock;
 821     const struct sockaddr_in *v4;
 822     const struct sockaddr_in6 *v6;
 823     struct sockaddr_storage sa;
 824     socklen_t addrlen;
 825     int ok;
 826
 827     addrlen = sizeof (sa);
 828     sock = GNUNET_NETWORK_socket_accept (slc->listen_socket,
 829                                          (struct sockaddr *) &sa,
 830                                          &addrlen);
 831     if (NULL == sock)
 832     {
 833       if (EMFILE == errno)
 834         do_suspend (sh,
 835                     SUSPEND_STATE_EMFILE);
 836       else if (EAGAIN != errno)
 837         GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
 838                              "accept");
 839       break;
 840     }
 841     switch (sa.ss_family)
 842     {
 843     case AF_INET:
 844       GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
 845       v4 = (const struct sockaddr_in *) &sa;
 846       ok = ( ( (NULL == sh->v4_allowed) ||
 847                (check_ipv4_listed (sh->v4_allowed,
 848                                    &v4->sin_addr))) &&
 849              ( (NULL == sh->v4_denied) ||
 850                (! check_ipv4_listed (sh->v4_denied,
 851                                      &v4->sin_addr)) ) );
 852       break;
 853     case AF_INET6:
 854       GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
 855       v6 = (const struct sockaddr_in6 *) &sa;
 856       ok = ( ( (NULL == sh->v6_allowed) ||
 857                (check_ipv6_listed (sh->v6_allowed,
 858                                    &v6->sin6_addr))) &&
 859              ( (NULL == sh->v6_denied) ||
 860                (! check_ipv6_listed (sh->v6_denied,
 861                                      &v6->sin6_addr)) ) );
 862       break;
 863 #ifndef WINDOWS
 864     case AF_UNIX:
 865       ok = GNUNET_OK;            /* controlled using file-system ACL now */
 866       break;
 867 #endif
 868     default:
 869       LOG (GNUNET_ERROR_TYPE_WARNING,
 870            _("Unknown address family %d\n"),
 871            sa.ss_family);
 872       return;
 873     }
 874     if (! ok)
 875     {
 876       LOG (GNUNET_ERROR_TYPE_DEBUG,
 877            "Service rejected incoming connection from %s due to policy.\n",
 878            GNUNET_a2s ((const struct sockaddr *) &sa,
 879                        addrlen));
 880       GNUNET_break (GNUNET_OK ==
 881                     GNUNET_NETWORK_socket_close (sock));
 882       continue;
 883     }
 884     LOG (GNUNET_ERROR_TYPE_DEBUG,
 885          "Service accepted incoming connection from %s.\n",
 886          GNUNET_a2s ((const struct sockaddr *) &sa,
 887                      addrlen));
 888     start_client (slc->sh,
 889                   sock);
 890   }
 891   if (0 != sh->suspend_state)
 892     return;
 893   slc->listen_task
 894     = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 895                                      slc->listen_socket,
 896                                      &accept_client,
 897                                      slc);
 898 }
 899
 900
 901 /**
 902  * Resume accepting connections from the listen socket.
 903  *
 904  * @param sh service to resume accepting connections.
 905  * @param sr reason that is no longer causing the suspension,
 906  *           or #SUSPEND_STATE_NONE on first startup
 907  */
 908 static void
 909 do_resume (struct GNUNET_SERVICE_Handle *sh,
 910            enum SuspendReason sr)
 911 {
 912   struct ServiceListenContext *slc;
 913
 914   GNUNET_assert ( (SUSPEND_STATE_NONE == sr) ||
 915                   (0 != (sh->suspend_state & sr)) );
 916   sh->suspend_state -= sr;
 917   if (SUSPEND_STATE_NONE != sh->suspend_state)
 918     return;
 919   for (slc = sh->slc_head; NULL != slc; slc = slc->next)
 920   {
 921     GNUNET_assert (NULL == slc->listen_task);
 922     slc->listen_task
 923       = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 924                                        slc->listen_socket,
 925                                        &accept_client,
 926                                        slc);
 927   }
 928 }
 929
 930
 931 /**
 932  * First task run by any service.  Initializes our shutdown task,
 933  * starts the listening operation on our listen sockets and launches
 934  * the custom logic of the application service.
 935  *
 936  * @param cls our `struct GNUNET_SERVICE_Handle`
 937  */
 938 static void
 939 service_main (void *cls)
 940 {
 941   struct GNUNET_SERVICE_Handle *sh = cls;
 942
 943   if (GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN != sh->options)
 944     GNUNET_SCHEDULER_add_shutdown (&service_shutdown,
 945                                    sh);
 946   do_resume (sh,
 947              SUSPEND_STATE_NONE);
 948
 949   if (-1 != sh->ready_confirm_fd)
 950   {
 951     GNUNET_break (1 == WRITE (sh->ready_confirm_fd, ".", 1));
 952     GNUNET_break (0 == CLOSE (sh->ready_confirm_fd));
 953     sh->ready_confirm_fd = -1;
 954   }
 955
 956   if (NULL != sh->service_init_cb)
 957     sh->service_init_cb (sh->cb_cls,
 958                          sh->cfg,
 959                          sh);
 960 }
 961
 962
 963 /**
 964  * Parse an IPv4 access control list.
 965  *
 966  * @param ret location where to write the ACL (set)
 967  * @param sh service context to use to get the configuration
 968  * @param option name of the ACL option to parse
 969  * @return #GNUNET_SYSERR on parse error, #GNUNET_OK on success (including
 970  *         no ACL configured)
 971  */
 972 static int
 973 process_acl4 (struct GNUNET_STRINGS_IPv4NetworkPolicy **ret,
 974               struct GNUNET_SERVICE_Handle *sh,
 975               const char *option)
 976 {
 977   char *opt;
 978
 979   if (! GNUNET_CONFIGURATION_have_value (sh->cfg,
 980                                          sh->service_name,
 981                                          option))
 982   {
 983     *ret = NULL;
 984     return GNUNET_OK;
 985   }
 986   GNUNET_break (GNUNET_OK ==
 987                 GNUNET_CONFIGURATION_get_value_string (sh->cfg,
 988                                                        sh->service_name,
 989                                                        option,
 990                                                        &opt));
 991   if (NULL == (*ret = GNUNET_STRINGS_parse_ipv4_policy (opt)))
 992   {
 993     LOG (GNUNET_ERROR_TYPE_WARNING,
 994          _("Could not parse IPv4 network specification `%s' for `%s:%s'\n"),
 995          opt,
 996          sh->service_name,
 997          option);
 998     GNUNET_free (opt);
 999     return GNUNET_SYSERR;
1000   }
1001   GNUNET_free (opt);
1002   return GNUNET_OK;
1003 }
1004
1005
1006 /**
1007  * Parse an IPv6 access control list.
1008  *
1009  * @param ret location where to write the ACL (set)
1010  * @param sh service context to use to get the configuration
1011  * @param option name of the ACL option to parse
1012  * @return #GNUNET_SYSERR on parse error, #GNUNET_OK on success (including
1013  *         no ACL configured)
1014  */
1015 static int
1016 process_acl6 (struct GNUNET_STRINGS_IPv6NetworkPolicy **ret,
1017               struct GNUNET_SERVICE_Handle *sh,
1018               const char *option)
1019 {
1020   char *opt;
1021
1022   if (! GNUNET_CONFIGURATION_have_value (sh->cfg,
1023                                          sh->service_name,
1024                                          option))
1025   {
1026     *ret = NULL;
1027     return GNUNET_OK;
1028   }
1029   GNUNET_break (GNUNET_OK ==
1030                 GNUNET_CONFIGURATION_get_value_string (sh->cfg,
1031                                                        sh->service_name,
1032                                                        option,
1033                                                        &opt));
1034   if (NULL == (*ret = GNUNET_STRINGS_parse_ipv6_policy (opt)))
1035   {
1036     LOG (GNUNET_ERROR_TYPE_WARNING,
1037          _("Could not parse IPv6 network specification `%s' for `%s:%s'\n"),
1038          opt,
1039          sh->service_name,
1040          option);
1041     GNUNET_free (opt);
1042     return GNUNET_SYSERR;
1043   }
1044   GNUNET_free (opt);
1045   return GNUNET_OK;
1046 }
1047
1048
1049 /**
1050  * Add the given UNIX domain path as an address to the
1051  * list (as the first entry).
1052  *
1053  * @param saddrs array to update
1054  * @param saddrlens where to store the address length
1055  * @param unixpath path to add
1056  * @param abstract #GNUNET_YES to add an abstract UNIX domain socket.  This
1057  *          parameter is ignore on systems other than LINUX
1058  */
1059 static void
1060 add_unixpath (struct sockaddr **saddrs,
1061               socklen_t *saddrlens,
1062               const char *unixpath,
1063               int abstract)
1064 {
1065 #ifdef AF_UNIX
1066   struct sockaddr_un *un;
1067
1068   un = GNUNET_new (struct sockaddr_un);
1069   un->sun_family = AF_UNIX;
1070   strncpy (un->sun_path,
1071            unixpath,
1072            sizeof (un->sun_path) - 1);
1073 #ifdef LINUX
1074   if (GNUNET_YES == abstract)
1075     un->sun_path[0] = '\0';
1076 #endif
1077 #if HAVE_SOCKADDR_UN_SUN_LEN
1078   un->sun_len = (u_char) sizeof (struct sockaddr_un);
1079 #endif
1080   *saddrs = (struct sockaddr *) un;
1081   *saddrlens = sizeof (struct sockaddr_un);
1082 #else
1083   /* this function should never be called
1084    * unless AF_UNIX is defined! */
1085   GNUNET_assert (0);
1086 #endif
1087 }
1088
1089
1090 /**
1091  * Get the list of addresses that a server for the given service
1092  * should bind to.
1093  *
1094  * @param service_name name of the service
1095  * @param cfg configuration (which specifies the addresses)
1096  * @param addrs set (call by reference) to an array of pointers to the
1097  *              addresses the server should bind to and listen on; the
1098  *              array will be NULL-terminated (on success)
1099  * @param addr_lens set (call by reference) to an array of the lengths
1100  *              of the respective `struct sockaddr` struct in the @a addrs
1101  *              array (on success)
1102  * @return number of addresses found on success,
1103  *              #GNUNET_SYSERR if the configuration
1104  *              did not specify reasonable finding information or
1105  *              if it specified a hostname that could not be resolved;
1106  *              #GNUNET_NO if the number of addresses configured is
1107  *              zero (in this case, `*addrs` and `*addr_lens` will be
1108  *              set to NULL).
1109  */
1110 static int
1111 get_server_addresses (const char *service_name,
1112                       const struct GNUNET_CONFIGURATION_Handle *cfg,
1113                       struct sockaddr ***addrs,
1114                       socklen_t **addr_lens)
1115 {
1116   int disablev6;
1117   struct GNUNET_NETWORK_Handle *desc;
1118   unsigned long long port;
1119   char *unixpath;
1120   struct addrinfo hints;
1121   struct addrinfo *res;
1122   struct addrinfo *pos;
1123   struct addrinfo *next;
1124   unsigned int i;
1125   int resi;
1126   int ret;
1127   int abstract;
1128   struct sockaddr **saddrs;
1129   socklen_t *saddrlens;
1130   char *hostname;
1131
1132   *addrs = NULL;
1133   *addr_lens = NULL;
1134   desc = NULL;
1135   if (GNUNET_CONFIGURATION_have_value (cfg,
1136                                        service_name,
1137                                        "DISABLEV6"))
1138   {
1139     if (GNUNET_SYSERR ==
1140         (disablev6 =
1141          GNUNET_CONFIGURATION_get_value_yesno (cfg,
1142                                                service_name,
1143                                                "DISABLEV6")))
1144       return GNUNET_SYSERR;
1145   }
1146   else
1147     disablev6 = GNUNET_NO;
1148
1149   if (! disablev6)
1150   {
1151     /* probe IPv6 support */
1152     desc = GNUNET_NETWORK_socket_create (PF_INET6,
1153                                          SOCK_STREAM,
1154                                          0);
1155     if (NULL == desc)
1156     {
1157       if ( (ENOBUFS == errno) ||
1158            (ENOMEM == errno) ||
1159            (ENFILE == errno) ||
1160            (EACCES == errno) )
1161       {
1162         LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
1163                       "socket");
1164         return GNUNET_SYSERR;
1165       }
1166       LOG (GNUNET_ERROR_TYPE_INFO,
1167            _("Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"),
1168            service_name,
1169            STRERROR (errno));
1170       disablev6 = GNUNET_YES;
1171     }
1172     else
1173     {
1174       GNUNET_break (GNUNET_OK ==
1175                     GNUNET_NETWORK_socket_close (desc));
1176       desc = NULL;
1177     }
1178   }
1179
1180   port = 0;
1181   if (GNUNET_CONFIGURATION_have_value (cfg,
1182                                        service_name,
1183                                        "PORT"))
1184   {
1185     if (GNUNET_OK !=
1186         GNUNET_CONFIGURATION_get_value_number (cfg,
1187                                                service_name,
1188                                                "PORT",
1189                                                &port))
1190     {
1191       LOG (GNUNET_ERROR_TYPE_ERROR,
1192            _("Require valid port number for service `%s' in configuration!\n"),
1193            service_name);
1194     }
1195     if (port > 65535)
1196     {
1197       LOG (GNUNET_ERROR_TYPE_ERROR,
1198            _("Require valid port number for service `%s' in configuration!\n"),
1199            service_name);
1200       return GNUNET_SYSERR;
1201     }
1202   }
1203
1204   if (GNUNET_CONFIGURATION_have_value (cfg,
1205                                        service_name,
1206                                        "BINDTO"))
1207   {
1208     GNUNET_break (GNUNET_OK ==
1209                   GNUNET_CONFIGURATION_get_value_string (cfg,
1210                                                          service_name,
1211                                                          "BINDTO",
1212                                                          &hostname));
1213   }
1214   else
1215     hostname = NULL;
1216
1217   unixpath = NULL;
1218   abstract = GNUNET_NO;
1219 #ifdef AF_UNIX
1220   if ((GNUNET_YES ==
1221        GNUNET_CONFIGURATION_have_value (cfg,
1222                                         service_name,
1223                                         "UNIXPATH")) &&
1224       (GNUNET_OK ==
1225        GNUNET_CONFIGURATION_get_value_filename (cfg,
1226                                                 service_name,
1227                                                 "UNIXPATH",
1228                                                 &unixpath)) &&
1229       (0 < strlen (unixpath)))
1230   {
1231     /* probe UNIX support */
1232     struct sockaddr_un s_un;
1233
1234     if (strlen (unixpath) >= sizeof (s_un.sun_path))
1235     {
1236       LOG (GNUNET_ERROR_TYPE_WARNING,
1237            _("UNIXPATH `%s' too long, maximum length is %llu\n"),
1238            unixpath,
1239            (unsigned long long) sizeof (s_un.sun_path));
1240       unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath);
1241       LOG (GNUNET_ERROR_TYPE_INFO,
1242            _("Using `%s' instead\n"),
1243            unixpath);
1244     }
1245 #ifdef LINUX
1246     abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg,
1247                                                      "TESTING",
1248                                                      "USE_ABSTRACT_SOCKETS");
1249     if (GNUNET_SYSERR == abstract)
1250       abstract = GNUNET_NO;
1251 #endif
1252     if ( (GNUNET_YES != abstract) &&
1253          (GNUNET_OK !=
1254           GNUNET_DISK_directory_create_for_file (unixpath)) )
1255       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
1256                                 "mkdir",
1257                                 unixpath);
1258   }
1259   if (NULL != unixpath)
1260   {
1261     desc = GNUNET_NETWORK_socket_create (AF_UNIX,
1262                                          SOCK_STREAM,
1263                                          0);
1264     if (NULL == desc)
1265     {
1266       if ((ENOBUFS == errno) ||
1267           (ENOMEM == errno) ||
1268           (ENFILE == errno) ||
1269           (EACCES == errno))
1270       {
1271         LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
1272                       "socket");
1273         GNUNET_free_non_null (hostname);
1274         GNUNET_free (unixpath);
1275         return GNUNET_SYSERR;
1276       }
1277       LOG (GNUNET_ERROR_TYPE_INFO,
1278            _("Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"),
1279            service_name,
1280            STRERROR (errno));
1281       GNUNET_free (unixpath);
1282       unixpath = NULL;
1283     }
1284     else
1285     {
1286       GNUNET_break (GNUNET_OK ==
1287                     GNUNET_NETWORK_socket_close (desc));
1288       desc = NULL;
1289     }
1290   }
1291 #endif
1292
1293   if ((0 == port) && (NULL == unixpath))
1294   {
1295     LOG (GNUNET_ERROR_TYPE_ERROR,
1296          _("Have neither PORT nor UNIXPATH for service `%s', but one is required\n"),
1297          service_name);
1298     GNUNET_free_non_null (hostname);
1299     return GNUNET_SYSERR;
1300   }
1301   if (0 == port)
1302   {
1303     saddrs = GNUNET_new_array (2,
1304                                struct sockaddr *);
1305     saddrlens = GNUNET_new_array (2,
1306                                   socklen_t);
1307     add_unixpath (saddrs,
1308                   saddrlens,
1309                   unixpath,
1310                   abstract);
1311     GNUNET_free_non_null (unixpath);
1312     GNUNET_free_non_null (hostname);
1313     *addrs = saddrs;
1314     *addr_lens = saddrlens;
1315     return 1;
1316   }
1317
1318   if (NULL != hostname)
1319   {
1320     LOG (GNUNET_ERROR_TYPE_DEBUG,
1321          "Resolving `%s' since that is where `%s' will bind to.\n",
1322          hostname,
1323          service_name);
1324     memset (&hints,
1325             0,
1326             sizeof (struct addrinfo));
1327     if (disablev6)
1328       hints.ai_family = AF_INET;
1329     hints.ai_protocol = IPPROTO_TCP;
1330     if ((0 != (ret = getaddrinfo (hostname,
1331                                   NULL,
1332                                   &hints,
1333                                   &res))) ||
1334         (NULL == res))
1335     {
1336       LOG (GNUNET_ERROR_TYPE_ERROR,
1337            _("Failed to resolve `%s': %s\n"),
1338            hostname,
1339            gai_strerror (ret));
1340       GNUNET_free (hostname);
1341       GNUNET_free_non_null (unixpath);
1342       return GNUNET_SYSERR;
1343     }
1344     next = res;
1345     i = 0;
1346     while (NULL != (pos = next))
1347     {
1348       next = pos->ai_next;
1349       if ( (disablev6) &&
1350            (pos->ai_family == AF_INET6) )
1351         continue;
1352       i++;
1353     }
1354     if (0 == i)
1355     {
1356       LOG (GNUNET_ERROR_TYPE_ERROR,
1357            _("Failed to find %saddress for `%s'.\n"),
1358            disablev6 ? "IPv4 " : "",
1359            hostname);
1360       freeaddrinfo (res);
1361       GNUNET_free (hostname);
1362       GNUNET_free_non_null (unixpath);
1363       return GNUNET_SYSERR;
1364     }
1365     resi = i;
1366     if (NULL != unixpath)
1367       resi++;
1368     saddrs = GNUNET_new_array (resi + 1,
1369                                struct sockaddr *);
1370     saddrlens = GNUNET_new_array (resi + 1,
1371                                   socklen_t);
1372     i = 0;
1373     if (NULL != unixpath)
1374     {
1375       add_unixpath (saddrs,
1376                     saddrlens,
1377                     unixpath,
1378                     abstract);
1379       i++;
1380     }
1381     next = res;
1382     while (NULL != (pos = next))
1383     {
1384       next = pos->ai_next;
1385       if ( (disablev6) &&
1386            (AF_INET6 == pos->ai_family) )
1387         continue;
1388       if ( (IPPROTO_TCP != pos->ai_protocol) &&
1389            (0 != pos->ai_protocol) )
1390         continue;               /* not TCP */
1391       if ( (SOCK_STREAM != pos->ai_socktype) &&
1392            (0 != pos->ai_socktype) )
1393         continue;               /* huh? */
1394       LOG (GNUNET_ERROR_TYPE_DEBUG,
1395            "Service `%s' will bind to `%s'\n",
1396            service_name,
1397            GNUNET_a2s (pos->ai_addr,
1398                        pos->ai_addrlen));
1399       if (AF_INET == pos->ai_family)
1400       {
1401         GNUNET_assert (sizeof (struct sockaddr_in) == pos->ai_addrlen);
1402         saddrlens[i] = pos->ai_addrlen;
1403         saddrs[i] = GNUNET_malloc (saddrlens[i]);
1404         GNUNET_memcpy (saddrs[i],
1405                        pos->ai_addr,
1406                        saddrlens[i]);
1407         ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
1408       }
1409       else
1410       {
1411         GNUNET_assert (AF_INET6 == pos->ai_family);
1412         GNUNET_assert (sizeof (struct sockaddr_in6) == pos->ai_addrlen);
1413         saddrlens[i] = pos->ai_addrlen;
1414         saddrs[i] = GNUNET_malloc (saddrlens[i]);
1415         GNUNET_memcpy (saddrs[i],
1416                        pos->ai_addr,
1417                        saddrlens[i]);
1418         ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
1419       }
1420       i++;
1421     }
1422     GNUNET_free (hostname);
1423     freeaddrinfo (res);
1424     resi = i;
1425   }
1426   else
1427   {
1428     /* will bind against everything, just set port */
1429     if (disablev6)
1430     {
1431       /* V4-only */
1432       resi = 1;
1433       if (NULL != unixpath)
1434         resi++;
1435       i = 0;
1436       saddrs = GNUNET_new_array (resi + 1,
1437                                  struct sockaddr *);
1438       saddrlens = GNUNET_new_array (resi + 1,
1439                                     socklen_t);
1440       if (NULL != unixpath)
1441       {
1442         add_unixpath (saddrs,
1443                       saddrlens,
1444                       unixpath,
1445                       abstract);
1446         i++;
1447       }
1448       saddrlens[i] = sizeof (struct sockaddr_in);
1449       saddrs[i] = GNUNET_malloc (saddrlens[i]);
1450 #if HAVE_SOCKADDR_IN_SIN_LEN
1451       ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[i];
1452 #endif
1453       ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
1454       ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
1455     }
1456     else
1457     {
1458       /* dual stack */
1459       resi = 2;
1460       if (NULL != unixpath)
1461         resi++;
1462       saddrs = GNUNET_new_array (resi + 1,
1463                                  struct sockaddr *);
1464       saddrlens = GNUNET_new_array (resi + 1,
1465                                     socklen_t);
1466       i = 0;
1467       if (NULL != unixpath)
1468       {
1469         add_unixpath (saddrs,
1470                       saddrlens,
1471                       unixpath,
1472                       abstract);
1473         i++;
1474       }
1475       saddrlens[i] = sizeof (struct sockaddr_in6);
1476       saddrs[i] = GNUNET_malloc (saddrlens[i]);
1477 #if HAVE_SOCKADDR_IN_SIN_LEN
1478       ((struct sockaddr_in6 *) saddrs[i])->sin6_len = saddrlens[0];
1479 #endif
1480       ((struct sockaddr_in6 *) saddrs[i])->sin6_family = AF_INET6;
1481       ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
1482       i++;
1483       saddrlens[i] = sizeof (struct sockaddr_in);
1484       saddrs[i] = GNUNET_malloc (saddrlens[i]);
1485 #if HAVE_SOCKADDR_IN_SIN_LEN
1486       ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[1];
1487 #endif
1488       ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
1489       ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
1490     }
1491   }
1492   GNUNET_free_non_null (unixpath);
1493   *addrs = saddrs;
1494   *addr_lens = saddrlens;
1495   return resi;
1496 }
1497
1498
1499 #ifdef MINGW
1500 /**
1501  * Read listen sockets from the parent process (ARM).
1502  *
1503  * @param sh service context to initialize
1504  * @return NULL-terminated array of sockets on success,
1505  *         NULL if not ok (must bind yourself)
1506  */
1507 static struct GNUNET_NETWORK_Handle **
1508 receive_sockets_from_parent (struct GNUNET_SERVICE_Handle *sh)
1509 {
1510   static struct GNUNET_NETWORK_Handle **lsocks;
1511   const char *env_buf;
1512   int fail;
1513   uint64_t count;
1514   uint64_t i;
1515   HANDLE lsocks_pipe;
1516
1517   env_buf = getenv ("GNUNET_OS_READ_LSOCKS");
1518   if ( (NULL == env_buf) ||
1519        (strlen (env_buf) <= 0) )
1520     return NULL;
1521   /* Using W32 API directly here, because this pipe will
1522    * never be used outside of this function, and it's just too much of a bother
1523    * to create a GNUnet API that boxes a HANDLE (the way it is done with socks)
1524    */
1525   lsocks_pipe = (HANDLE) strtoul (env_buf,
1526                                   NULL,
1527                                   10);
1528   if ( (0 == lsocks_pipe) ||
1529        (INVALID_HANDLE_VALUE == lsocks_pipe))
1530     return NULL;
1531   fail = 1;
1532   do
1533   {
1534     int ret;
1535     int fail2;
1536     DWORD rd;
1537
1538     ret = ReadFile (lsocks_pipe,
1539                     &count,
1540                     sizeof (count),
1541                     &rd,
1542                     NULL);
1543     if ( (0 == ret) ||
1544          (sizeof (count) != rd) ||
1545          (0 == count) )
1546       break;
1547     lsocks = GNUNET_new_array (count + 1,
1548                                struct GNUNET_NETWORK_Handle *);
1549
1550     fail2 = 1;
1551     for (i = 0; i < count; i++)
1552     {
1553       WSAPROTOCOL_INFOA pi;
1554       uint64_t size;
1555       SOCKET s;
1556
1557       ret = ReadFile (lsocks_pipe,
1558                       &size,
1559                       sizeof (size),
1560                       &rd,
1561                       NULL);
1562       if ( (0 == ret) ||
1563            (sizeof (size) != rd) ||
1564            (sizeof (pi) != size) )
1565         break;
1566       ret = ReadFile (lsocks_pipe,
1567                       &pi,
1568                       sizeof (pi),
1569                       &rd,
1570                       NULL);
1571       if ( (0 == ret) ||
1572            (sizeof (pi) != rd))
1573         break;
1574       s = WSASocketA (pi.iAddressFamily,
1575                       pi.iSocketType,
1576                       pi.iProtocol,
1577                       &pi,
1578                       0,
1579                       WSA_FLAG_OVERLAPPED);
1580       lsocks[i] = GNUNET_NETWORK_socket_box_native (s);
1581       if (NULL == lsocks[i])
1582         break;
1583       else if (i == count - 1)
1584         fail2 = 0;
1585     }
1586     if (fail2)
1587       break;
1588     lsocks[count] = NULL;
1589     fail = 0;
1590   }
1591   while (fail);
1592   CloseHandle (lsocks_pipe);
1593
1594   if (fail)
1595   {
1596     LOG (GNUNET_ERROR_TYPE_ERROR,
1597          _("Could not access a pre-bound socket, will try to bind myself\n"));
1598     for (i = 0; (i < count) && (NULL != lsocks[i]); i++)
1599       GNUNET_break (GNUNET_OK ==
1600                     GNUNET_NETWORK_socket_close (lsocks[i]));
1601     GNUNET_free (lsocks);
1602     return NULL;
1603   }
1604   return lsocks;
1605 }
1606 #endif
1607
1608
1609 /**
1610  * Create and initialize a listen socket for the server.
1611  *
1612  * @param server_addr address to listen on
1613  * @param socklen length of @a server_addr
1614  * @return NULL on error, otherwise the listen socket
1615  */
1616 static struct GNUNET_NETWORK_Handle *
1617 open_listen_socket (const struct sockaddr *server_addr,
1618                     socklen_t socklen)
1619 {
1620   struct GNUNET_NETWORK_Handle *sock;
1621   uint16_t port;
1622   int eno;
1623
1624   switch (server_addr->sa_family)
1625   {
1626   case AF_INET:
1627     port = ntohs (((const struct sockaddr_in *) server_addr)->sin_port);
1628     break;
1629   case AF_INET6:
1630     port = ntohs (((const struct sockaddr_in6 *) server_addr)->sin6_port);
1631     break;
1632   case AF_UNIX:
1633     port = 0;
1634     break;
1635   default:
1636     GNUNET_break (0);
1637     port = 0;
1638     break;
1639   }
1640   sock = GNUNET_NETWORK_socket_create (server_addr->sa_family,
1641                                        SOCK_STREAM,
1642                                        0);
1643   if (NULL == sock)
1644   {
1645     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
1646                   "socket");
1647     errno = 0;
1648     return NULL;
1649   }
1650   /* bind the socket */
1651   if (GNUNET_OK != GNUNET_NETWORK_socket_bind (sock,
1652                                                server_addr,
1653                                                socklen))
1654   {
1655     eno = errno;
1656     if (EADDRINUSE != errno)
1657     {
1658       /* we don't log 'EADDRINUSE' here since an IPv4 bind may
1659        * fail if we already took the port on IPv6; if both IPv4 and
1660        * IPv6 binds fail, then our caller will log using the
1661        * errno preserved in 'eno' */
1662       LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
1663                     "bind");
1664       if (0 != port)
1665         LOG (GNUNET_ERROR_TYPE_ERROR,
1666              _("`%s' failed for port %d (%s).\n"),
1667              "bind",
1668              port,
1669              (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6");
1670       eno = 0;
1671     }
1672     else
1673     {
1674       if (0 != port)
1675         LOG (GNUNET_ERROR_TYPE_WARNING,
1676              _("`%s' failed for port %d (%s): address already in use\n"),
1677              "bind", port,
1678              (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6");
1679       else if (AF_UNIX == server_addr->sa_family)
1680       {
1681         LOG (GNUNET_ERROR_TYPE_WARNING,
1682              _("`%s' failed for `%s': address already in use\n"),
1683              "bind",
1684              GNUNET_a2s (server_addr, socklen));
1685       }
1686     }
1687     GNUNET_break (GNUNET_OK ==
1688                   GNUNET_NETWORK_socket_close (sock));
1689     errno = eno;
1690     return NULL;
1691   }
1692   if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock,
1693                                                  5))
1694   {
1695     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
1696                   "listen");
1697     GNUNET_break (GNUNET_OK ==
1698                   GNUNET_NETWORK_socket_close (sock));
1699     errno = 0;
1700     return NULL;
1701   }
1702   if (0 != port)
1703     LOG (GNUNET_ERROR_TYPE_DEBUG,
1704          "Server starts to listen on port %u.\n",
1705          port);
1706   return sock;
1707 }
1708
1709
1710 /**
1711  * Setup service handle
1712  *
1713  * Configuration may specify:
1714  * - PORT (where to bind to for TCP)
1715  * - UNIXPATH (where to bind to for UNIX domain sockets)
1716  * - DISABLEV6 (disable support for IPv6, otherwise we use dual-stack)
1717  * - BINDTO (hostname or IP address to bind to, otherwise we take everything)
1718  * - ACCEPT_FROM  (only allow connections from specified IPv4 subnets)
1719  * - ACCEPT_FROM6 (only allow connections from specified IPv6 subnets)
1720  * - REJECT_FROM  (disallow allow connections from specified IPv4 subnets)
1721  * - REJECT_FROM6 (disallow allow connections from specified IPv6 subnets)
1722  *
1723  * @param sh service context to initialize
1724  * @return #GNUNET_OK if configuration succeeded
1725  */
1726 static int
1727 setup_service (struct GNUNET_SERVICE_Handle *sh)
1728 {
1729   int tolerant;
1730   struct GNUNET_NETWORK_Handle **lsocks;
1731 #ifndef MINGW
1732   const char *nfds;
1733   unsigned int cnt;
1734   int flags;
1735   char dummy[2];
1736 #endif
1737
1738   if (GNUNET_CONFIGURATION_have_value
1739       (sh->cfg,
1740        sh->service_name,
1741        "TOLERANT"))
1742   {
1743     if (GNUNET_SYSERR ==
1744         (tolerant =
1745          GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
1746                                                sh->service_name,
1747                                                "TOLERANT")))
1748     {
1749       LOG (GNUNET_ERROR_TYPE_ERROR,
1750            _("Specified value for `%s' of service `%s' is invalid\n"),
1751            "TOLERANT",
1752            sh->service_name);
1753       return GNUNET_SYSERR;
1754     }
1755   }
1756   else
1757     tolerant = GNUNET_NO;
1758
1759   lsocks = NULL;
1760 #ifndef MINGW
1761   errno = 0;
1762   if ( (NULL != (nfds = getenv ("LISTEN_FDS"))) &&
1763        (1 == SSCANF (nfds,
1764                      "%u%1s",
1765                      &cnt,
1766                      dummy)) &&
1767        (cnt > 0) &&
1768        (cnt < FD_SETSIZE) &&
1769        (cnt + 4 < FD_SETSIZE) )
1770   {
1771     lsocks = GNUNET_new_array (cnt + 1,
1772                                struct GNUNET_NETWORK_Handle *);
1773     while (0 < cnt--)
1774     {
1775       flags = fcntl (3 + cnt,
1776                      F_GETFD);
1777       if ( (flags < 0) ||
1778            (0 != (flags & FD_CLOEXEC)) ||
1779            (NULL ==
1780             (lsocks[cnt] = GNUNET_NETWORK_socket_box_native (3 + cnt))))
1781       {
1782         LOG (GNUNET_ERROR_TYPE_ERROR,
1783              _("Could not access pre-bound socket %u, will try to bind myself\n"),
1784              (unsigned int) 3 + cnt);
1785         cnt++;
1786         while (NULL != lsocks[cnt])
1787           GNUNET_break (GNUNET_OK ==
1788                         GNUNET_NETWORK_socket_close (lsocks[cnt++]));
1789         GNUNET_free (lsocks);
1790         lsocks = NULL;
1791         break;
1792       }
1793     }
1794     unsetenv ("LISTEN_FDS");
1795   }
1796 #else
1797   if (NULL != getenv ("GNUNET_OS_READ_LSOCKS"))
1798   {
1799     lsocks = receive_sockets_from_parent (sh);
1800     putenv ("GNUNET_OS_READ_LSOCKS=");
1801   }
1802 #endif
1803
1804   if (NULL != lsocks)
1805   {
1806     /* listen only on inherited sockets if we have any */
1807     struct GNUNET_NETWORK_Handle **ls;
1808
1809     for (ls = lsocks; NULL != *ls; ls++)
1810     {
1811       struct ServiceListenContext *slc;
1812
1813       slc = GNUNET_new (struct ServiceListenContext);
1814       slc->sh = sh;
1815       slc->listen_socket = *ls;
1816       GNUNET_CONTAINER_DLL_insert (sh->slc_head,
1817                                    sh->slc_tail,
1818                                    slc);
1819     }
1820     GNUNET_free (lsocks);
1821   }
1822   else
1823   {
1824     struct sockaddr **addrs;
1825     socklen_t *addrlens;
1826     int num;
1827
1828     num = get_server_addresses (sh->service_name,
1829                                 sh->cfg,
1830                                 &addrs,
1831                                 &addrlens);
1832     if (GNUNET_SYSERR == num)
1833       return GNUNET_SYSERR;
1834
1835     for (int i = 0; i < num; i++)
1836     {
1837       struct ServiceListenContext *slc;
1838
1839       slc = GNUNET_new (struct ServiceListenContext);
1840       slc->sh = sh;
1841       slc->listen_socket = open_listen_socket (addrs[i],
1842                                                addrlens[i]);
1843       GNUNET_free (addrs[i]);
1844       if (NULL == slc->listen_socket)
1845       {
1846         GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
1847                              "bind");
1848         GNUNET_free (slc);
1849         continue;
1850       }
1851       GNUNET_CONTAINER_DLL_insert (sh->slc_head,
1852                                    sh->slc_tail,
1853                                    slc);
1854     }
1855     GNUNET_free_non_null (addrlens);
1856     GNUNET_free_non_null (addrs);
1857     if ( (0 != num) &&
1858          (NULL == sh->slc_head) )
1859     {
1860       /* All attempts to bind failed, hard failure */
1861       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1862                   _("Could not bind to any of the ports I was supposed to, refusing to run!\n"));
1863       return GNUNET_SYSERR;
1864     }
1865   }
1866
1867   sh->require_found = tolerant ? GNUNET_NO : GNUNET_YES;
1868   sh->match_uid
1869     = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
1870                                             sh->service_name,
1871                                             "UNIX_MATCH_UID");
1872   sh->match_gid
1873     = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
1874                                             sh->service_name,
1875                                             "UNIX_MATCH_GID");
1876   process_acl4 (&sh->v4_denied,
1877                 sh,
1878                 "REJECT_FROM");
1879   process_acl4 (&sh->v4_allowed,
1880                 sh,
1881                 "ACCEPT_FROM");
1882   process_acl6 (&sh->v6_denied,
1883                 sh,
1884                 "REJECT_FROM6");
1885   process_acl6 (&sh->v6_allowed,
1886                 sh,
1887                 "ACCEPT_FROM6");
1888   return GNUNET_OK;
1889 }
1890
1891
1892 /**
1893  * Get the name of the user that'll be used
1894  * to provide the service.
1895  *
1896  * @param sh service context
1897  * @return value of the 'USERNAME' option
1898  */
1899 static char *
1900 get_user_name (struct GNUNET_SERVICE_Handle *sh)
1901 {
1902   char *un;
1903
1904   if (GNUNET_OK !=
1905       GNUNET_CONFIGURATION_get_value_filename (sh->cfg,
1906                                                sh->service_name,
1907                                                "USERNAME",
1908                                                &un))
1909     return NULL;
1910   return un;
1911 }
1912
1913
1914 /**
1915  * Set user ID.
1916  *
1917  * @param sh service context
1918  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
1919  */
1920 static int
1921 set_user_id (struct GNUNET_SERVICE_Handle *sh)
1922 {
1923   char *user;
1924
1925   if (NULL == (user = get_user_name (sh)))
1926     return GNUNET_OK;           /* keep */
1927 #ifndef MINGW
1928   struct passwd *pws;
1929
1930   errno = 0;
1931   pws = getpwnam (user);
1932   if (NULL == pws)
1933   {
1934     LOG (GNUNET_ERROR_TYPE_ERROR,
1935          _("Cannot obtain information about user `%s': %s\n"),
1936          user,
1937          errno == 0 ? _("No such user") : STRERROR (errno));
1938     GNUNET_free (user);
1939     return GNUNET_SYSERR;
1940   }
1941   if ( (0 != setgid (pws->pw_gid)) ||
1942        (0 != setegid (pws->pw_gid)) ||
1943 #if HAVE_INITGROUPS
1944        (0 != initgroups (user,
1945                          pws->pw_gid)) ||
1946 #endif
1947        (0 != setuid (pws->pw_uid)) ||
1948        (0 != seteuid (pws->pw_uid)))
1949   {
1950     if ((0 != setregid (pws->pw_gid,
1951                         pws->pw_gid)) ||
1952         (0 != setreuid (pws->pw_uid,
1953                         pws->pw_uid)))
1954     {
1955       LOG (GNUNET_ERROR_TYPE_ERROR,
1956            _("Cannot change user/group to `%s': %s\n"),
1957            user,
1958            STRERROR (errno));
1959       GNUNET_free (user);
1960       return GNUNET_SYSERR;
1961     }
1962   }
1963 #endif
1964   GNUNET_free (user);
1965   return GNUNET_OK;
1966 }
1967
1968
1969 /**
1970  * Get the name of the file where we will
1971  * write the PID of the service.
1972  *
1973  * @param sh service context
1974  * @return name of the file for the process ID
1975  */
1976 static char *
1977 get_pid_file_name (struct GNUNET_SERVICE_Handle *sh)
1978 {
1979   char *pif;
1980
1981   if (GNUNET_OK !=
1982       GNUNET_CONFIGURATION_get_value_filename (sh->cfg,
1983                                                sh->service_name,
1984                                                "PIDFILE",
1985                                                &pif))
1986     return NULL;
1987   return pif;
1988 }
1989
1990
1991 /**
1992  * Delete the PID file that was created by our parent.
1993  *
1994  * @param sh service context
1995  */
1996 static void
1997 pid_file_delete (struct GNUNET_SERVICE_Handle *sh)
1998 {
1999   char *pif = get_pid_file_name (sh);
2000
2001   if (NULL == pif)
2002     return;                     /* no PID file */
2003   if (0 != UNLINK (pif))
2004     LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
2005                        "unlink",
2006                        pif);
2007   GNUNET_free (pif);
2008 }
2009
2010
2011 /**
2012  * Detach from terminal.
2013  *
2014  * @param sh service context
2015  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
2016  */
2017 static int
2018 detach_terminal (struct GNUNET_SERVICE_Handle *sh)
2019 {
2020 #ifndef MINGW
2021   pid_t pid;
2022   int nullfd;
2023   int filedes[2];
2024
2025   if (0 != PIPE (filedes))
2026   {
2027     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
2028                   "pipe");
2029     return GNUNET_SYSERR;
2030   }
2031   pid = fork ();
2032   if (pid < 0)
2033   {
2034     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
2035                   "fork");
2036     return GNUNET_SYSERR;
2037   }
2038   if (0 != pid)
2039   {
2040     /* Parent */
2041     char c;
2042
2043     GNUNET_break (0 == CLOSE (filedes[1]));
2044     c = 'X';
2045     if (1 != READ (filedes[0],
2046                    &c,
2047                    sizeof (char)))
2048       LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
2049                     "read");
2050     fflush (stdout);
2051     switch (c)
2052     {
2053     case '.':
2054       exit (0);
2055     case 'I':
2056       LOG (GNUNET_ERROR_TYPE_INFO,
2057            _("Service process failed to initialize\n"));
2058       break;
2059     case 'S':
2060       LOG (GNUNET_ERROR_TYPE_INFO,
2061            _("Service process could not initialize server function\n"));
2062       break;
2063     case 'X':
2064       LOG (GNUNET_ERROR_TYPE_INFO,
2065            _("Service process failed to report status\n"));
2066       break;
2067     }
2068     exit (1);                   /* child reported error */
2069   }
2070   GNUNET_break (0 == CLOSE (0));
2071   GNUNET_break (0 == CLOSE (1));
2072   GNUNET_break (0 == CLOSE (filedes[0]));
2073   nullfd = OPEN ("/dev/null",
2074                  O_RDWR | O_APPEND);
2075   if (nullfd < 0)
2076     return GNUNET_SYSERR;
2077   /* set stdin/stdout to /dev/null */
2078   if ( (dup2 (nullfd, 0) < 0) ||
2079        (dup2 (nullfd, 1) < 0) )
2080   {
2081     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
2082                   "dup2");
2083     (void) CLOSE (nullfd);
2084     return GNUNET_SYSERR;
2085   }
2086   (void) CLOSE (nullfd);
2087   /* Detach from controlling terminal */
2088   pid = setsid ();
2089   if (-1 == pid)
2090     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
2091                   "setsid");
2092   sh->ready_confirm_fd = filedes[1];
2093 #else
2094   /* FIXME: we probably need to do something else
2095    * elsewhere in order to fork the process itself... */
2096   FreeConsole ();
2097 #endif
2098   return GNUNET_OK;
2099 }
2100
2101
2102 /**
2103  * Tear down the service, closing the listen sockets and
2104  * freeing the ACLs.
2105  *
2106  * @param sh handle to the service to tear down.
2107  */
2108 static void
2109 teardown_service (struct GNUNET_SERVICE_Handle *sh)
2110 {
2111   struct ServiceListenContext *slc;
2112
2113   GNUNET_free_non_null (sh->v4_denied);
2114   GNUNET_free_non_null (sh->v6_denied);
2115   GNUNET_free_non_null (sh->v4_allowed);
2116   GNUNET_free_non_null (sh->v6_allowed);
2117   while (NULL != (slc = sh->slc_head))
2118   {
2119     GNUNET_CONTAINER_DLL_remove (sh->slc_head,
2120                                  sh->slc_tail,
2121                                  slc);
2122     if (NULL != slc->listen_task)
2123       GNUNET_SCHEDULER_cancel (slc->listen_task);
2124     GNUNET_break (GNUNET_OK ==
2125                   GNUNET_NETWORK_socket_close (slc->listen_socket));
2126     GNUNET_free (slc);
2127   }
2128 }
2129
2130
2131 /**
2132  * Function to return link to AGPL source upon request.
2133  *
2134  * @param cls closure with the identification of the client
2135  * @param msg AGPL request
2136  */
2137 static void
2138 return_agpl (void *cls,
2139              const struct GNUNET_MessageHeader *msg)
2140 {
2141   struct GNUNET_SERVICE_Client *client = cls;
2142   struct GNUNET_MQ_Handle *mq;
2143   struct GNUNET_MQ_Envelope *env;
2144   struct GNUNET_MessageHeader *res;
2145   size_t slen;
2146
2147   (void) msg;
2148   slen = strlen (GNUNET_AGPL_URL) + 1;
2149   env = GNUNET_MQ_msg_extra (res,
2150                              GNUNET_MESSAGE_TYPE_RESPONSE_AGPL,
2151                              slen);
2152   memcpy (&res[1],
2153           GNUNET_AGPL_URL,
2154           slen);
2155   mq = GNUNET_SERVICE_client_get_mq (client);
2156   GNUNET_MQ_send (mq,
2157                   env);
2158   GNUNET_SERVICE_client_continue (client);
2159 }
2160
2161
2162 /**
2163  * Low-level function to start a service if the scheduler
2164  * is already running.  Should only be used directly in
2165  * special cases.
2166  *
2167  * The function will launch the service with the name @a service_name
2168  * using the @a service_options to configure its shutdown
2169  * behavior. When clients connect or disconnect, the respective
2170  * @a connect_cb or @a disconnect_cb functions will be called. For
2171  * messages received from the clients, the respective @a handlers will
2172  * be invoked; for the closure of the handlers we use the return value
2173  * from the @a connect_cb invocation of the respective client.
2174  *
2175  * Each handler MUST call #GNUNET_SERVICE_client_continue() after each
2176  * message to receive further messages from this client.  If
2177  * #GNUNET_SERVICE_client_continue() is not called within a short
2178  * time, a warning will be logged. If delays are expected, services
2179  * should call #GNUNET_SERVICE_client_disable_continue_warning() to
2180  * disable the warning.
2181  *
2182  * Clients sending invalid messages (based on @a handlers) will be
2183  * dropped. Additionally, clients can be dropped at any time using
2184  * #GNUNET_SERVICE_client_drop().
2185  *
2186  * The service must be stopped using #GNUNET_SERVICE_stop().
2187  *
2188  * @param service_name name of the service to run
2189  * @param cfg configuration to use
2190  * @param connect_cb function to call whenever a client connects
2191  * @param disconnect_cb function to call whenever a client disconnects
2192  * @param cls closure argument for @a connect_cb and @a disconnect_cb
2193  * @param handlers NULL-terminated array of message handlers for the service,
2194  *                 the closure will be set to the value returned by
2195  *                 the @a connect_cb for the respective connection
2196  * @return NULL on error
2197  */
2198 struct GNUNET_SERVICE_Handle *
2199 GNUNET_SERVICE_start (const char *service_name,
2200                       const struct GNUNET_CONFIGURATION_Handle *cfg,
2201                       GNUNET_SERVICE_ConnectHandler connect_cb,
2202                       GNUNET_SERVICE_DisconnectHandler disconnect_cb,
2203                       void *cls,
2204                       const struct GNUNET_MQ_MessageHandler *handlers)
2205 {
2206   struct GNUNET_SERVICE_Handle *sh;
2207
2208   sh = GNUNET_new (struct GNUNET_SERVICE_Handle);
2209   sh->service_name = service_name;
2210   sh->cfg = cfg;
2211   sh->connect_cb = connect_cb;
2212   sh->disconnect_cb = disconnect_cb;
2213   sh->cb_cls = cls;
2214   sh->handlers = GNUNET_MQ_copy_handlers2 (handlers,
2215                                            &return_agpl,
2216                                            NULL);
2217   if (GNUNET_OK != setup_service (sh))
2218   {
2219     GNUNET_free_non_null (sh->handlers);
2220     GNUNET_free (sh);
2221     return NULL;
2222   }
2223   do_resume (sh,
2224              SUSPEND_STATE_NONE);
2225   return sh;
2226 }
2227
2228
2229 /**
2230  * Stops a service that was started with #GNUNET_SERVICE_start().
2231  *
2232  * @param srv service to stop
2233  */
2234 void
2235 GNUNET_SERVICE_stop (struct GNUNET_SERVICE_Handle *srv)
2236 {
2237   struct GNUNET_SERVICE_Client *client;
2238
2239   GNUNET_SERVICE_suspend (srv);
2240   while (NULL != (client = srv->clients_head))
2241     GNUNET_SERVICE_client_drop (client);
2242   teardown_service (srv);
2243   GNUNET_free_non_null (srv->handlers);
2244   GNUNET_free (srv);
2245 }
2246
2247
2248 /**
2249  * Creates the "main" function for a GNUnet service.  You
2250  * should almost always use the #GNUNET_SERVICE_MAIN macro
2251  * instead of calling this function directly (except
2252  * for ARM, which should call this function directly).
2253  *
2254  * The function will launch the service with the name @a service_name
2255  * using the @a service_options to configure its shutdown
2256  * behavior. Once the service is ready, the @a init_cb will be called
2257  * for service-specific initialization.  @a init_cb will be given the
2258  * service handler which can be used to control the service's
2259  * availability.  When clients connect or disconnect, the respective
2260  * @a connect_cb or @a disconnect_cb functions will be called. For
2261  * messages received from the clients, the respective @a handlers will
2262  * be invoked; for the closure of the handlers we use the return value
2263  * from the @a connect_cb invocation of the respective client.
2264  *
2265  * Each handler MUST call #GNUNET_SERVICE_client_continue() after each
2266  * message to receive further messages from this client.  If
2267  * #GNUNET_SERVICE_client_continue() is not called within a short
2268  * time, a warning will be logged. If delays are expected, services
2269  * should call #GNUNET_SERVICE_client_disable_continue_warning() to
2270  * disable the warning.
2271  *
2272  * Clients sending invalid messages (based on @a handlers) will be
2273  * dropped. Additionally, clients can be dropped at any time using
2274  * #GNUNET_SERVICE_client_drop().
2275  *
2276  * @param argc number of command-line arguments in @a argv
2277  * @param argv array of command-line arguments
2278  * @param service_name name of the service to run
2279  * @param options options controlling shutdown of the service
2280  * @param service_init_cb function to call once the service is ready
2281  * @param connect_cb function to call whenever a client connects
2282  * @param disconnect_cb function to call whenever a client disconnects
2283  * @param cls closure argument for @a service_init_cb, @a connect_cb and @a disconnect_cb
2284  * @param handlers NULL-terminated array of message handlers for the service,
2285  *                 the closure will be set to the value returned by
2286  *                 the @a connect_cb for the respective connection
2287  * @return 0 on success, non-zero on error
2288  */
2289 int
2290 GNUNET_SERVICE_run_ (int argc,
2291                      char *const *argv,
2292                      const char *service_name,
2293                      enum GNUNET_SERVICE_Options options,
2294                      GNUNET_SERVICE_InitCallback service_init_cb,
2295                      GNUNET_SERVICE_ConnectHandler connect_cb,
2296                      GNUNET_SERVICE_DisconnectHandler disconnect_cb,
2297                      void *cls,
2298                      const struct GNUNET_MQ_MessageHandler *handlers)
2299 {
2300   struct GNUNET_SERVICE_Handle sh;
2301   char *cfg_filename;
2302   char *opt_cfg_filename;
2303   char *loglev;
2304   const char *xdg;
2305   char *logfile;
2306   int do_daemonize;
2307   unsigned long long skew_offset;
2308   unsigned long long skew_variance;
2309   long long clock_offset;
2310   struct GNUNET_CONFIGURATION_Handle *cfg;
2311   int ret;
2312   int err;
2313
2314   struct GNUNET_GETOPT_CommandLineOption service_options[] = {
2315     GNUNET_GETOPT_option_cfgfile (&opt_cfg_filename),
2316     GNUNET_GETOPT_option_flag ('d',
2317                                "daemonize",
2318                                gettext_noop ("do daemonize (detach from terminal)"),
2319                                &do_daemonize),
2320     GNUNET_GETOPT_option_help (NULL),
2321     GNUNET_GETOPT_option_loglevel (&loglev),
2322     GNUNET_GETOPT_option_logfile (&logfile),
2323     GNUNET_GETOPT_option_version (PACKAGE_VERSION " " VCS_VERSION),
2324     GNUNET_GETOPT_OPTION_END
2325   };
2326
2327   err = 1;
2328   memset (&sh,
2329           0,
2330           sizeof (sh));
2331   xdg = getenv ("XDG_CONFIG_HOME");
2332   if (NULL != xdg)
2333     GNUNET_asprintf (&cfg_filename,
2334                      "%s%s%s",
2335                      xdg,
2336                      DIR_SEPARATOR_STR,
2337                      GNUNET_OS_project_data_get ()->config_file);
2338   else
2339     cfg_filename = GNUNET_strdup (GNUNET_OS_project_data_get ()->user_config_file);
2340   sh.ready_confirm_fd = -1;
2341   sh.options = options;
2342   sh.cfg = cfg = GNUNET_CONFIGURATION_create ();
2343   sh.service_init_cb = service_init_cb;
2344   sh.connect_cb = connect_cb;
2345   sh.disconnect_cb = disconnect_cb;
2346   sh.cb_cls = cls;
2347   sh.handlers = GNUNET_MQ_copy_handlers (handlers);
2348   sh.service_name = service_name;
2349
2350   /* setup subsystems */
2351   loglev = NULL;
2352   logfile = NULL;
2353   opt_cfg_filename = NULL;
2354   do_daemonize = 0;
2355   ret = GNUNET_GETOPT_run (service_name,
2356                            service_options,
2357                            argc,
2358                            argv);
2359   if (GNUNET_SYSERR == ret)
2360     goto shutdown;
2361   if (GNUNET_NO == ret)
2362   {
2363     err = 0;
2364     goto shutdown;
2365   }
2366   if (GNUNET_OK != GNUNET_log_setup (service_name,
2367                                      loglev,
2368                                      logfile))
2369   {
2370     GNUNET_break (0);
2371     goto shutdown;
2372   }
2373   if (NULL != opt_cfg_filename)
2374   {
2375     if ( (GNUNET_YES !=
2376           GNUNET_DISK_file_test (opt_cfg_filename)) ||
2377          (GNUNET_SYSERR ==
2378           GNUNET_CONFIGURATION_load (cfg,
2379                                      opt_cfg_filename)) )
2380     {
2381       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2382                   _("Malformed configuration file `%s', exit ...\n"),
2383                   opt_cfg_filename);
2384       goto shutdown;
2385     }
2386   }
2387   else
2388   {
2389     if (GNUNET_YES ==
2390         GNUNET_DISK_file_test (cfg_filename))
2391     {
2392       if (GNUNET_SYSERR ==
2393           GNUNET_CONFIGURATION_load (cfg,
2394                                      cfg_filename))
2395       {
2396         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2397                     _("Malformed configuration file `%s', exit ...\n"),
2398                     cfg_filename);
2399         goto shutdown;
2400       }
2401     }
2402     else
2403     {
2404       if (GNUNET_SYSERR ==
2405           GNUNET_CONFIGURATION_load (cfg,
2406                                      NULL))
2407       {
2408         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2409                     _("Malformed configuration, exit ...\n"));
2410         goto shutdown;
2411       }
2412     }
2413   }
2414   if (GNUNET_OK != setup_service (&sh))
2415     goto shutdown;
2416   if ( (1 == do_daemonize) &&
2417        (GNUNET_OK != detach_terminal (&sh)) )
2418   {
2419     GNUNET_break (0);
2420     goto shutdown;
2421   }
2422   if (GNUNET_OK != set_user_id (&sh))
2423     goto shutdown;
2424   LOG (GNUNET_ERROR_TYPE_DEBUG,
2425        "Service `%s' runs with configuration from `%s'\n",
2426        service_name,
2427        (NULL != opt_cfg_filename) ? opt_cfg_filename : cfg_filename);
2428   if ((GNUNET_OK ==
2429        GNUNET_CONFIGURATION_get_value_number (sh.cfg,
2430                                               "TESTING",
2431                                               "SKEW_OFFSET",
2432                                               &skew_offset)) &&
2433       (GNUNET_OK ==
2434        GNUNET_CONFIGURATION_get_value_number (sh.cfg,
2435                                               "TESTING",
2436                                               "SKEW_VARIANCE",
2437                                               &skew_variance)))
2438   {
2439     clock_offset = skew_offset - skew_variance;
2440     GNUNET_TIME_set_offset (clock_offset);
2441     LOG (GNUNET_ERROR_TYPE_DEBUG,
2442          "Skewing clock by %dll ms\n",
2443          clock_offset);
2444   }
2445   GNUNET_RESOLVER_connect (sh.cfg);
2446
2447   /* actually run service */
2448   err = 0;
2449   GNUNET_SCHEDULER_run (&service_main,
2450                         &sh);
2451   /* shutdown */
2452   if (1 == do_daemonize)
2453     pid_file_delete (&sh);
2454
2455 shutdown:
2456   if (-1 != sh.ready_confirm_fd)
2457   {
2458     if (1 != WRITE (sh.ready_confirm_fd,
2459                     err ? "I" : "S",
2460                     1))
2461       LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
2462                     "write");
2463     GNUNET_break (0 == CLOSE (sh.ready_confirm_fd));
2464   }
2465 #if HAVE_MALLINFO
2466   {
2467     char *counter;
2468
2469     if ( (GNUNET_YES ==
2470           GNUNET_CONFIGURATION_have_value (sh.cfg,
2471                                            service_name,
2472                                            "GAUGER_HEAP")) &&
2473          (GNUNET_OK ==
2474           GNUNET_CONFIGURATION_get_value_string (sh.cfg,
2475                                                  service_name,
2476                                                  "GAUGER_HEAP",
2477                                                  &counter)) )
2478     {
2479       struct mallinfo mi;
2480
2481       mi = mallinfo ();
2482       GAUGER (service_name,
2483               counter,
2484               mi.usmblks,
2485               "blocks");
2486       GNUNET_free (counter);
2487     }
2488   }
2489 #endif
2490   teardown_service (&sh);
2491   GNUNET_free_non_null (sh.handlers);
2492   GNUNET_SPEEDUP_stop_ ();
2493   GNUNET_CONFIGURATION_destroy (cfg);
2494   GNUNET_free_non_null (logfile);
2495   GNUNET_free_non_null (loglev);
2496   GNUNET_free (cfg_filename);
2497   GNUNET_free_non_null (opt_cfg_filename);
2498
2499   return err ? GNUNET_SYSERR : sh.ret;
2500 }
2501
2502
2503 /**
2504  * Suspend accepting connections from the listen socket temporarily.
2505  * Resume activity using #GNUNET_SERVICE_resume.
2506  *
2507  * @param sh service to stop accepting connections.
2508  */
2509 void
2510 GNUNET_SERVICE_suspend (struct GNUNET_SERVICE_Handle *sh)
2511 {
2512   do_suspend (sh,
2513               SUSPEND_STATE_APP);
2514 }
2515
2516
2517 /**
2518  * Resume accepting connections from the listen socket.
2519  *
2520  * @param sh service to resume accepting connections.
2521  */
2522 void
2523 GNUNET_SERVICE_resume (struct GNUNET_SERVICE_Handle *sh)
2524 {
2525   do_resume (sh,
2526              SUSPEND_STATE_APP);
2527 }
2528
2529
2530 /**
2531  * Task run to resume receiving data from the client after
2532  * the client called #GNUNET_SERVICE_client_continue().
2533  *
2534  * @param cls our `struct GNUNET_SERVICE_Client`
2535  */
2536 static void
2537 resume_client_receive (void *cls)
2538 {
2539   struct GNUNET_SERVICE_Client *c = cls;
2540   int ret;
2541
2542   c->recv_task = NULL;
2543   /* first, check if there is still something in the buffer */
2544   ret = GNUNET_MST_next (c->mst,
2545                          GNUNET_YES);
2546   if (GNUNET_SYSERR == ret)
2547   {
2548     if (NULL == c->drop_task)
2549       GNUNET_SERVICE_client_drop (c);
2550     return;
2551   }
2552   if (GNUNET_NO == ret)
2553     return; /* done processing, wait for more later */
2554   GNUNET_assert (GNUNET_OK == ret);
2555   if (GNUNET_YES == c->needs_continue)
2556     return; /* #GNUNET_MST_next() did give a message to the client */
2557   /* need to receive more data from the network first */
2558   if (NULL != c->recv_task)
2559     return;
2560   c->recv_task
2561     = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
2562                                      c->sock,
2563                                      &service_client_recv,
2564                                      c);
2565 }
2566
2567
2568 /**
2569  * Continue receiving further messages from the given client.
2570  * Must be called after each message received.
2571  *
2572  * @param c the client to continue receiving from
2573  */
2574 void
2575 GNUNET_SERVICE_client_continue (struct GNUNET_SERVICE_Client *c)
2576 {
2577   GNUNET_assert (NULL == c->drop_task);
2578   GNUNET_assert (GNUNET_YES == c->needs_continue);
2579   GNUNET_assert (NULL == c->recv_task);
2580   c->needs_continue = GNUNET_NO;
2581   if (NULL != c->warn_task)
2582   {
2583     GNUNET_SCHEDULER_cancel (c->warn_task);
2584     c->warn_task = NULL;
2585   }
2586   c->recv_task
2587     = GNUNET_SCHEDULER_add_now (&resume_client_receive,
2588                                 c);
2589 }
2590
2591
2592 /**
2593  * Disable the warning the server issues if a message is not
2594  * acknowledged in a timely fashion.  Use this call if a client is
2595  * intentionally delayed for a while.  Only applies to the current
2596  * message.
2597  *
2598  * @param c client for which to disable the warning
2599  */
2600 void
2601 GNUNET_SERVICE_client_disable_continue_warning (struct GNUNET_SERVICE_Client *c)
2602 {
2603   GNUNET_break (NULL != c->warn_task);
2604   if (NULL != c->warn_task)
2605   {
2606     GNUNET_SCHEDULER_cancel (c->warn_task);
2607     c->warn_task = NULL;
2608   }
2609 }
2610
2611
2612 /**
2613  * Asynchronously finish dropping the client.
2614  *
2615  * @param cls the `struct GNUNET_SERVICE_Client`.
2616  */
2617 static void
2618 finish_client_drop (void *cls)
2619 {
2620   struct GNUNET_SERVICE_Client *c = cls;
2621   struct GNUNET_SERVICE_Handle *sh = c->sh;
2622
2623   c->drop_task = NULL;
2624   GNUNET_assert (NULL == c->send_task);
2625   GNUNET_assert (NULL == c->recv_task);
2626   GNUNET_assert (NULL == c->warn_task);
2627   GNUNET_MST_destroy (c->mst);
2628   GNUNET_MQ_destroy (c->mq);
2629   if (GNUNET_NO == c->persist)
2630   {
2631     GNUNET_break (GNUNET_OK ==
2632                   GNUNET_NETWORK_socket_close (c->sock));
2633     if ( (0 != (SUSPEND_STATE_EMFILE & sh->suspend_state)) &&
2634          (0 == (SUSPEND_STATE_SHUTDOWN & sh->suspend_state)) )
2635       do_resume (sh,
2636                  SUSPEND_STATE_EMFILE);
2637   }
2638   else
2639   {
2640     GNUNET_NETWORK_socket_free_memory_only_ (c->sock);
2641   }
2642   GNUNET_free (c);
2643   if ( (0 != (SUSPEND_STATE_SHUTDOWN & sh->suspend_state)) &&
2644        (GNUNET_NO == have_non_monitor_clients (sh)) )
2645     GNUNET_SERVICE_shutdown (sh);
2646 }
2647
2648
2649 /**
2650  * Ask the server to disconnect from the given client.  This is the
2651  * same as returning #GNUNET_SYSERR within the check procedure when
2652  * handling a message, wexcept that it allows dropping of a client even
2653  * when not handling a message from that client.  The `disconnect_cb`
2654  * will be called on @a c even if the application closes the connection
2655  * using this function.
2656  *
2657  * @param c client to disconnect now
2658  */
2659 void
2660 GNUNET_SERVICE_client_drop (struct GNUNET_SERVICE_Client *c)
2661 {
2662   struct GNUNET_SERVICE_Handle *sh = c->sh;
2663
2664   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2665               "Client dropped: %p (MQ: %p)\n",
2666               c,
2667               c->mq);
2668 #if EXECINFO
2669   {
2670     void *backtrace_array[MAX_TRACE_DEPTH];
2671     int num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH);
2672     char **backtrace_strings =
2673       backtrace_symbols (backtrace_array,
2674                          t->num_backtrace_strings);
2675     for (unsigned int i = 0; i < num_backtrace_strings; i++)
2676       LOG (GNUNET_ERROR_TYPE_DEBUG,
2677            "client drop trace %u: %s\n",
2678            i,
2679            backtrace_strings[i]);
2680   }
2681 #endif
2682   if (NULL != c->drop_task)
2683   {
2684     /* asked to drop twice! */
2685     GNUNET_assert (0);
2686     return;
2687   }
2688   GNUNET_CONTAINER_DLL_remove (sh->clients_head,
2689                                sh->clients_tail,
2690                                c);
2691   if (NULL != sh->disconnect_cb)
2692     sh->disconnect_cb (sh->cb_cls,
2693                        c,
2694                        c->user_context);
2695   if (NULL != c->warn_task)
2696   {
2697     GNUNET_SCHEDULER_cancel (c->warn_task);
2698     c->warn_task = NULL;
2699   }
2700   if (NULL != c->recv_task)
2701   {
2702     GNUNET_SCHEDULER_cancel (c->recv_task);
2703     c->recv_task = NULL;
2704   }
2705   if (NULL != c->send_task)
2706   {
2707     GNUNET_SCHEDULER_cancel (c->send_task);
2708     c->send_task = NULL;
2709   }
2710   c->drop_task = GNUNET_SCHEDULER_add_now (&finish_client_drop,
2711                                            c);
2712 }
2713
2714
2715 /**
2716  * Explicitly stops the service.
2717  *
2718  * @param sh server to shutdown
2719  */
2720 void
2721 GNUNET_SERVICE_shutdown (struct GNUNET_SERVICE_Handle *sh)
2722 {
2723   struct GNUNET_SERVICE_Client *client;
2724
2725   if (0 == (sh->suspend_state & SUSPEND_STATE_SHUTDOWN))
2726     do_suspend (sh,
2727                 SUSPEND_STATE_SHUTDOWN);
2728   while (NULL != (client = sh->clients_head))
2729     GNUNET_SERVICE_client_drop (client);
2730 }
2731
2732
2733 /**
2734  * Set the 'monitor' flag on this client.  Clients which have been
2735  * marked as 'monitors' won't prevent the server from shutting down
2736  * once #GNUNET_SERVICE_stop_listening() has been invoked.  The idea is
2737  * that for "normal" clients we likely want to allow them to process
2738  * their requests; however, monitor-clients are likely to 'never'
2739  * disconnect during shutdown and thus will not be considered when
2740  * determining if the server should continue to exist after
2741  * shutdown has been triggered.
2742  *
2743  * @param c client to mark as a monitor
2744  */
2745 void
2746 GNUNET_SERVICE_client_mark_monitor (struct GNUNET_SERVICE_Client *c)
2747 {
2748   c->is_monitor = GNUNET_YES;
2749   if ( (0 != (SUSPEND_STATE_SHUTDOWN & c->sh->suspend_state) &&
2750         (GNUNET_NO == have_non_monitor_clients (c->sh)) ) )
2751     GNUNET_SERVICE_shutdown (c->sh);
2752 }
2753
2754
2755 /**
2756  * Set the persist option on this client.  Indicates that the
2757  * underlying socket or fd should never really be closed.  Used for
2758  * indicating process death.
2759  *
2760  * @param c client to persist the socket (never to be closed)
2761  */
2762 void
2763 GNUNET_SERVICE_client_persist (struct GNUNET_SERVICE_Client *c)
2764 {
2765   c->persist = GNUNET_YES;
2766 }
2767
2768
2769 /**
2770  * Obtain the message queue of @a c.  Convenience function.
2771  *
2772  * @param c the client to continue receiving from
2773  * @return the message queue of @a c
2774  */
2775 struct GNUNET_MQ_Handle *
2776 GNUNET_SERVICE_client_get_mq (struct GNUNET_SERVICE_Client *c)
2777 {
2778   return c->mq;
2779 }
2780
2781
2782 /* end of service_new.c */