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