src/util/service.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 2, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file util/service.c
  23  * @brief functions related to starting services
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_common.h"
  28 #include "gnunet_configuration_lib.h"
  29 #include "gnunet_crypto_lib.h"
  30 #include "gnunet_directories.h"
  31 #include "gnunet_disk_lib.h"
  32 #include "gnunet_getopt_lib.h"
  33 #include "gnunet_os_lib.h"
  34 #include "gnunet_protocols.h"
  35 #include "gnunet_server_lib.h"
  36 #include "gnunet_service_lib.h"
  37
  38 #define DEBUG_SERVICE GNUNET_NO
  39
  40 /* ******************* access control ******************** */
  41
  42 /**
  43  * @brief IPV4 network in CIDR notation.
  44  */
  45 struct IPv4NetworkSet
  46 {
  47   struct in_addr network;
  48   struct in_addr netmask;
  49 };
  50
  51 /**
  52  * @brief network in CIDR notation for IPV6.
  53  */
  54 struct IPv6NetworkSet
  55 {
  56   struct in6_addr network;
  57   struct in6_addr netmask;
  58 };
  59
  60
  61 /**
  62  * Parse a network specification. The argument specifies
  63  * a list of networks. The format is
  64  * <tt>[network/netmask;]*</tt> (no whitespace, must be terminated
  65  * with a semicolon). The network must be given in dotted-decimal
  66  * notation. The netmask can be given in CIDR notation (/16) or
  67  * in dotted-decimal (/255.255.0.0).
  68  * <p>
  69  * @param routeList a string specifying the forbidden networks
  70  * @return the converted list, NULL if the synatx is flawed
  71  */
  72 static struct IPv4NetworkSet *
  73 parse_ipv4_specification (const char *routeList)
  74 {
  75   unsigned int count;
  76   unsigned int i;
  77   unsigned int j;
  78   unsigned int len;
  79   int cnt;
  80   unsigned int pos;
  81   unsigned int temps[8];
  82   int slash;
  83   struct IPv4NetworkSet *result;
  84
  85   if (routeList == NULL)
  86     return NULL;
  87   len = strlen (routeList);
  88   if (len == 0)
  89     return NULL;
  90   count = 0;
  91   for (i = 0; i < len; i++)
  92     if (routeList[i] == ';')
  93       count++;
  94   result = GNUNET_malloc (sizeof (struct IPv4NetworkSet) * (count + 1));
  95   /* add termination */
  96   memset (result, 0, sizeof (struct IPv4NetworkSet) * (count + 1));
  97   i = 0;
  98   pos = 0;
  99   while (i < count)
 100     {
 101       cnt = sscanf (&routeList[pos],
 102                     "%u.%u.%u.%u/%u.%u.%u.%u;",
 103                     &temps[0],
 104                     &temps[1],
 105                     &temps[2],
 106                     &temps[3], &temps[4], &temps[5], &temps[6], &temps[7]);
 107       if (cnt == 8)
 108         {
 109           for (j = 0; j < 8; j++)
 110             if (temps[j] > 0xFF)
 111               {
 112                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 113                             _("Invalid format for IP: `%s'\n"),
 114                             &routeList[pos]);
 115                 GNUNET_free (result);
 116                 return NULL;
 117               }
 118           result[i].network.s_addr
 119             =
 120             htonl ((temps[0] << 24) + (temps[1] << 16) + (temps[2] << 8) +
 121                    temps[3]);
 122           result[i].netmask.s_addr =
 123             htonl ((temps[4] << 24) + (temps[5] << 16) + (temps[6] << 8) +
 124                    temps[7]);
 125           while (routeList[pos] != ';')
 126             pos++;
 127           pos++;
 128           i++;
 129           continue;
 130         }
 131       /* try second notation */
 132       cnt = sscanf (&routeList[pos],
 133                     "%u.%u.%u.%u/%u;",
 134                     &temps[0], &temps[1], &temps[2], &temps[3], &slash);
 135       if (cnt == 5)
 136         {
 137           for (j = 0; j < 4; j++)
 138             if (temps[j] > 0xFF)
 139               {
 140                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 141                             _("Invalid format for IP: `%s'\n"),
 142                             &routeList[pos]);
 143                 GNUNET_free (result);
 144                 return NULL;
 145               }
 146           result[i].network.s_addr
 147             =
 148             htonl ((temps[0] << 24) + (temps[1] << 16) + (temps[2] << 8) +
 149                    temps[3]);
 150           if ((slash <= 32) && (slash >= 0))
 151             {
 152               result[i].netmask.s_addr = 0;
 153               while (slash > 0)
 154                 {
 155                   result[i].netmask.s_addr
 156                     = (result[i].netmask.s_addr >> 1) + 0x80000000;
 157                   slash--;
 158                 }
 159               result[i].netmask.s_addr = htonl (result[i].netmask.s_addr);
 160               while (routeList[pos] != ';')
 161                 pos++;
 162               pos++;
 163               i++;
 164               continue;
 165             }
 166           else
 167             {
 168               GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 169                           _
 170                           ("Invalid network notation ('/%d' is not legal in IPv4 CIDR)."),
 171                           slash);
 172               GNUNET_free (result);
 173               return NULL;      /* error */
 174             }
 175         }
 176       /* try third notation */
 177       slash = 32;
 178       cnt = sscanf (&routeList[pos],
 179                     "%u.%u.%u.%u;",
 180                     &temps[0], &temps[1], &temps[2], &temps[3]);
 181       if (cnt == 4)
 182         {
 183           for (j = 0; j < 4; j++)
 184             if (temps[j] > 0xFF)
 185               {
 186                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 187                             _("Invalid format for IP: `%s'\n"),
 188                             &routeList[pos]);
 189                 GNUNET_free (result);
 190                 return NULL;
 191               }
 192           result[i].network.s_addr
 193             =
 194             htonl ((temps[0] << 24) + (temps[1] << 16) + (temps[2] << 8) +
 195                    temps[3]);
 196           result[i].netmask.s_addr = 0;
 197           while (slash > 0)
 198             {
 199               result[i].netmask.s_addr
 200                 = (result[i].netmask.s_addr >> 1) + 0x80000000;
 201               slash--;
 202             }
 203           result[i].netmask.s_addr = htonl (result[i].netmask.s_addr);
 204           while (routeList[pos] != ';')
 205             pos++;
 206           pos++;
 207           i++;
 208           continue;
 209         }
 210       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 211                   _("Invalid format for IP: `%s'\n"), &routeList[pos]);
 212       GNUNET_free (result);
 213       return NULL;              /* error */
 214     }
 215   if (pos < strlen (routeList))
 216     {
 217       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 218                   _("Invalid format for IP: `%s'\n"), &routeList[pos]);
 219       GNUNET_free (result);
 220       return NULL;              /* oops */
 221     }
 222   return result;                /* ok */
 223 }
 224
 225
 226 /**
 227  * Parse a network specification. The argument specifies
 228  * a list of networks. The format is
 229  * <tt>[network/netmask;]*</tt> (no whitespace, must be terminated
 230  * with a semicolon). The network must be given in colon-hex
 231  * notation.  The netmask must be given in CIDR notation (/16) or
 232  * can be omitted to specify a single host.
 233  * <p>
 234  * @param routeListX a string specifying the forbidden networks
 235  * @return the converted list, NULL if the synatx is flawed
 236  */
 237 static struct IPv6NetworkSet *
 238 parse_ipv6_specification (const char *routeListX)
 239 {
 240   unsigned int count;
 241   unsigned int i;
 242   unsigned int len;
 243   unsigned int pos;
 244   int start;
 245   int slash;
 246   int ret;
 247   char *routeList;
 248   struct IPv6NetworkSet *result;
 249   unsigned int bits;
 250   unsigned int off;
 251   int save;
 252
 253   if (routeListX == NULL)
 254     return NULL;
 255   len = strlen (routeListX);
 256   if (len == 0)
 257     return NULL;
 258   routeList = GNUNET_strdup (routeListX);
 259   count = 0;
 260   for (i = 0; i < len; i++)
 261     if (routeList[i] == ';')
 262       count++;
 263   if (routeList[len - 1] != ';')
 264     {
 265       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 266                   _
 267                   ("Invalid network notation (does not end with ';': `%s')\n"),
 268                   routeList);
 269       GNUNET_free (routeList);
 270       return NULL;
 271     }
 272
 273   result = GNUNET_malloc (sizeof (struct IPv6NetworkSet) * (count + 1));
 274   memset (result, 0, sizeof (struct IPv6NetworkSet) * (count + 1));
 275   i = 0;
 276   pos = 0;
 277   while (i < count)
 278     {
 279       start = pos;
 280       while (routeList[pos] != ';')
 281         pos++;
 282       slash = pos;
 283       while ((slash >= start) && (routeList[slash] != '/'))
 284         slash--;
 285       if (slash < start)
 286         {
 287           memset (&result[i].netmask, 0xFF, sizeof (struct in6_addr));
 288           slash = pos;
 289         }
 290       else
 291         {
 292           routeList[pos] = '\0';
 293           ret = inet_pton (AF_INET6,
 294                            &routeList[slash + 1], &result[i].netmask);
 295           if (ret <= 0)
 296             {
 297               save = errno;
 298               if ((1 != SSCANF (&routeList[slash + 1],
 299                                 "%u", &bits)) || (bits >= 128))
 300                 {
 301                   if (ret == 0)
 302                     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 303                                 _("Wrong format `%s' for netmask\n"),
 304                                 &routeList[slash + 1]);
 305                   else
 306                     {
 307                       errno = save;
 308                       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
 309                                            "inet_pton");
 310                     }
 311                   GNUNET_free (result);
 312                   GNUNET_free (routeList);
 313                   return NULL;
 314                 }
 315               off = 0;
 316               while (bits > 8)
 317                 {
 318                   result[i].netmask.s6_addr[off++] = 0xFF;
 319                   bits -= 8;
 320                 }
 321               while (bits > 0)
 322                 {
 323                   result[i].netmask.s6_addr[off]
 324                     = (result[i].netmask.s6_addr[off] >> 1) + 0x80;
 325                   bits--;
 326                 }
 327             }
 328         }
 329       routeList[slash] = '\0';
 330       ret = inet_pton (AF_INET6, &routeList[start], &result[i].network);
 331       if (ret <= 0)
 332         {
 333           if (ret == 0)
 334             GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 335                         _("Wrong format `%s' for network\n"),
 336                         &routeList[slash + 1]);
 337           else
 338             GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "inet_pton");
 339           GNUNET_free (result);
 340           GNUNET_free (routeList);
 341           return NULL;
 342         }
 343       pos++;
 344       i++;
 345     }
 346   GNUNET_free (routeList);
 347   return result;
 348 }
 349
 350
 351 /**
 352  * Check if the given IP address is in the list of IP addresses.
 353  *
 354  * @param list a list of networks
 355  * @param add the IP to check (in network byte order)
 356  * @return GNUNET_NO if the IP is not in the list, GNUNET_YES if it it is
 357  */
 358 static int
 359 check_ipv4_listed (const struct IPv4NetworkSet *list,
 360                    const struct in_addr *add)
 361 {
 362   int i;
 363
 364   i = 0;
 365   if (list == NULL)
 366     return GNUNET_NO;
 367
 368   while ((list[i].network.s_addr != 0) || (list[i].netmask.s_addr != 0))
 369     {
 370       if ((add->s_addr & list[i].netmask.s_addr) ==
 371           (list[i].network.s_addr & list[i].netmask.s_addr))
 372         return GNUNET_YES;
 373       i++;
 374     }
 375   return GNUNET_NO;
 376 }
 377
 378 /**
 379  * Check if the given IP address is in the list of IP addresses.
 380  *
 381  * @param list a list of networks
 382  * @param ip the IP to check (in network byte order)
 383  * @return GNUNET_NO if the IP is not in the list, GNUNET_YES if it it is
 384  */
 385 static int
 386 check_ipv6_listed (const struct IPv6NetworkSet *list,
 387                    const struct in6_addr *ip)
 388 {
 389   unsigned int i;
 390   unsigned int j;
 391   struct in6_addr zero;
 392
 393   if (list == NULL)
 394     return GNUNET_NO;
 395
 396   memset (&zero, 0, sizeof (struct in6_addr));
 397   i = 0;
 398 NEXT:
 399   while (memcmp (&zero, &list[i].network, sizeof (struct in6_addr)) != 0)
 400     {
 401       for (j = 0; j < sizeof (struct in6_addr) / sizeof (int); j++)
 402         if (((((int *) ip)[j] & ((int *) &list[i].netmask)[j])) !=
 403             (((int *) &list[i].network)[j] & ((int *) &list[i].netmask)[j]))
 404           {
 405             i++;
 406             goto NEXT;
 407           }
 408       return GNUNET_YES;
 409     }
 410   return GNUNET_NO;
 411 }
 412
 413
 414 /* ****************** service struct ****************** */
 415
 416
 417 /**
 418  * Context for "service_task".
 419  */
 420 struct GNUNET_SERVICE_Context
 421 {
 422   /**
 423    * Our configuration.
 424    */
 425   const struct GNUNET_CONFIGURATION_Handle *cfg;
 426
 427   /**
 428    * Handle for the server.
 429    */
 430   struct GNUNET_SERVER_Handle *server;
 431
 432   /**
 433    * NULL-terminated array of addresses to bind to, NULL if we got pre-bound
 434    * listen sockets.
 435    */
 436   struct sockaddr **addrs;
 437
 438   /**
 439    * Name of our service.
 440    */
 441   const char *serviceName;
 442
 443   /**
 444    * Main service-specific task to run.
 445    */
 446   GNUNET_SERVICE_Main task;
 447
 448   /**
 449    * Closure for task.
 450    */
 451   void *task_cls;
 452
 453   /**
 454    * IPv4 addresses that are not allowed to connect.
 455    */
 456   struct IPv4NetworkSet *v4_denied;
 457
 458   /**
 459    * IPv6 addresses that are not allowed to connect.
 460    */
 461   struct IPv6NetworkSet *v6_denied;
 462
 463   /**
 464    * IPv4 addresses that are allowed to connect (if not
 465    * set, all are allowed).
 466    */
 467   struct IPv4NetworkSet *v4_allowed;
 468
 469   /**
 470    * IPv6 addresses that are allowed to connect (if not
 471    * set, all are allowed).
 472    */
 473   struct IPv6NetworkSet *v6_allowed;
 474
 475   /**
 476    * My (default) message handlers.  Adjusted copy
 477    * of "defhandlers".
 478    */
 479   struct GNUNET_SERVER_MessageHandler *my_handlers;
 480
 481   /**
 482    * Array of the lengths of the entries in addrs.
 483    */
 484   socklen_t * addrlens;
 485
 486   /**
 487    * NULL-terminated array of listen sockets we should take over.
 488    */
 489   struct GNUNET_NETWORK_Handle **lsocks;
 490
 491   /**
 492    * Idle timeout for server.
 493    */
 494   struct GNUNET_TIME_Relative timeout;
 495
 496   /**
 497    * Overall success/failure of the service start.
 498    */
 499   int ret;
 500
 501   /**
 502    * If we are daemonizing, this FD is set to the
 503    * pipe to the parent.  Send '.' if we started
 504    * ok, '!' if not.  -1 if we are not daemonizing.
 505    */
 506   int ready_confirm_fd;
 507
 508   /**
 509    * Do we close connections if we receive messages
 510    * for which we have no handler?
 511    */
 512   int require_found;
 513
 514   /**
 515    * Do we require a matching UID for UNIX domain socket
 516    * connections?
 517    */
 518   int match_uid;
 519
 520   /**
 521    * Do we require a matching GID for UNIX domain socket
 522    * connections?
 523    */
 524   int match_gid;
 525
 526   /**
 527    * Our options.
 528    */
 529   enum GNUNET_SERVICE_Options options;
 530
 531 };
 532
 533
 534 /* ****************** message handlers ****************** */
 535
 536 static size_t
 537 write_test (void *cls, size_t size, void *buf)
 538 {
 539   struct GNUNET_SERVER_Client *client = cls;
 540   struct GNUNET_MessageHeader *msg;
 541
 542   if (size < sizeof (struct GNUNET_MessageHeader))
 543     {
 544       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 545       return 0;                 /* client disconnected */
 546     }
 547   msg = (struct GNUNET_MessageHeader *) buf;
 548   msg->type = htons (GNUNET_MESSAGE_TYPE_TEST);
 549   msg->size = htons (sizeof (struct GNUNET_MessageHeader));
 550   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 551   return sizeof (struct GNUNET_MessageHeader);
 552 }
 553
 554 /**
 555  * Handler for TEST message.
 556  *
 557  * @param cls closure (refers to service)
 558  * @param client identification of the client
 559  * @param message the actual message
 560  */
 561 static void
 562 handle_test (void *cls,
 563              struct GNUNET_SERVER_Client *client,
 564              const struct GNUNET_MessageHeader *message)
 565 {
 566   /* simply bounce message back to acknowledge */
 567   if (NULL == GNUNET_SERVER_notify_transmit_ready (client,
 568                                                    sizeof (struct
 569                                                            GNUNET_MessageHeader),
 570                                                    GNUNET_TIME_UNIT_FOREVER_REL,
 571                                                    &write_test, client))
 572     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 573 }
 574
 575
 576 /**
 577  * Default handlers for all services.  Will be copied and the
 578  * "callback_cls" fields will be replaced with the specific service
 579  * struct.
 580  */
 581 static const struct GNUNET_SERVER_MessageHandler defhandlers[] = {
 582   {&handle_test, NULL, GNUNET_MESSAGE_TYPE_TEST,
 583    sizeof (struct GNUNET_MessageHeader)},
 584   {NULL, NULL, 0, 0}
 585 };
 586
 587
 588
 589 /* ****************** service core routines ************** */
 590
 591
 592 /**
 593  * Check if access to the service is allowed from the given address.
 594  *
 595  * @param cls closure
 596  * @param uc credentials, if available, otherwise NULL
 597  * @param addr address
 598  * @param addrlen length of address
 599  * @return GNUNET_YES to allow, GNUNET_NO to deny, GNUNET_SYSERR
 600  *   for unknown address family (will be denied).
 601  */
 602 static int
 603 check_access (void *cls,
 604               const struct GNUNET_CONNECTION_Credentials *uc,
 605               const struct sockaddr *addr, socklen_t addrlen)
 606 {
 607   struct GNUNET_SERVICE_Context *sctx = cls;
 608   const struct sockaddr_in *i4;
 609   const struct sockaddr_in6 *i6;
 610   int ret;
 611
 612   switch (addr->sa_family)
 613     {
 614     case AF_INET:
 615       GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
 616       i4 = (const struct sockaddr_in *) addr;
 617       ret = ((sctx->v4_allowed == NULL) ||
 618              (check_ipv4_listed (sctx->v4_allowed,
 619                                  &i4->sin_addr)))
 620         && ((sctx->v4_denied == NULL) ||
 621             (!check_ipv4_listed (sctx->v4_denied, &i4->sin_addr)));
 622       break;
 623     case AF_INET6:
 624       GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
 625       i6 = (const struct sockaddr_in6 *) addr;
 626       ret = ((sctx->v6_allowed == NULL) ||
 627              (check_ipv6_listed (sctx->v6_allowed,
 628                                  &i6->sin6_addr)))
 629         && ((sctx->v6_denied == NULL) ||
 630             (!check_ipv6_listed (sctx->v6_denied, &i6->sin6_addr)));
 631       break;
 632 #ifndef WINDOWS
 633     case AF_UNIX:
 634       ret = GNUNET_OK; /* always OK for now */
 635       if ( (sctx->match_uid == GNUNET_YES) ||
 636            (sctx->match_gid == GNUNET_YES) )
 637         ret = GNUNET_NO;
 638       if ( (uc != NULL) &&
 639            ( (sctx->match_uid != GNUNET_YES) ||
 640              (uc->uid == geteuid()) ||
 641              (uc->uid == getuid()) ) &&
 642            ( (sctx->match_gid != GNUNET_YES) ||
 643              (uc->gid == getegid()) ||
 644              (uc->gid == getgid())) )
 645         ret = GNUNET_YES;
 646       else
 647         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 648                     _("Access denied to UID %d / GID %d\n"),
 649                     (uc == NULL) ? -1 : uc->uid,
 650                     (uc == NULL) ? -1 : uc->gid);
 651       break;
 652 #endif
 653     default:
 654       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 655                   _("Unknown address family %d\n"), addr->sa_family);
 656       return GNUNET_SYSERR;
 657     }
 658   if (ret != GNUNET_OK)
 659     {
 660       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 661                   _("Access from `%s' denied to service `%s'\n"),
 662                   GNUNET_a2s (addr, addrlen), sctx->serviceName);
 663     }
 664   return ret;
 665 }
 666
 667
 668 /**
 669  * Get the name of the file where we will
 670  * write the PID of the service.
 671  */
 672 static char *
 673 get_pid_file_name (struct GNUNET_SERVICE_Context *sctx)
 674 {
 675
 676   char *pif;
 677
 678   if (GNUNET_OK !=
 679       GNUNET_CONFIGURATION_get_value_filename (sctx->cfg,
 680                                                sctx->serviceName,
 681                                                "PIDFILE", &pif))
 682     return NULL;
 683   return pif;
 684 }
 685
 686
 687 /**
 688  * Parse an IPv4 access control list.
 689  */
 690 static int
 691 process_acl4 (struct IPv4NetworkSet **ret,
 692               struct GNUNET_SERVICE_Context *sctx, const char *option)
 693 {
 694   char *opt;
 695
 696   if (!GNUNET_CONFIGURATION_have_value (sctx->cfg, sctx->serviceName, option))
 697     return GNUNET_OK;
 698   GNUNET_break (GNUNET_OK ==
 699                 GNUNET_CONFIGURATION_get_value_string (sctx->cfg,
 700                                                        sctx->serviceName,
 701                                                        option, &opt));
 702   if (NULL == (*ret = parse_ipv4_specification (opt)))
 703     {
 704       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 705                   _
 706                   ("Could not parse IPv4 network specification `%s' for `%s:%s'\n"),
 707                   opt, sctx->serviceName, option);
 708       GNUNET_free (opt);
 709       return GNUNET_SYSERR;
 710     }
 711   GNUNET_free (opt);
 712   return GNUNET_OK;
 713 }
 714
 715
 716 /**
 717  * Parse an IPv4 access control list.
 718  */
 719 static int
 720 process_acl6 (struct IPv6NetworkSet **ret,
 721               struct GNUNET_SERVICE_Context *sctx, const char *option)
 722 {
 723   char *opt;
 724   if (!GNUNET_CONFIGURATION_have_value (sctx->cfg, sctx->serviceName, option))
 725     return GNUNET_OK;
 726   GNUNET_break (GNUNET_OK ==
 727                 GNUNET_CONFIGURATION_get_value_string (sctx->cfg,
 728                                                        sctx->serviceName,
 729                                                        option, &opt));
 730   if (NULL == (*ret = parse_ipv6_specification (opt)))
 731     {
 732       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 733                   _
 734                   ("Could not parse IPv6 network specification `%s' for `%s:%s'\n"),
 735                   opt, sctx->serviceName, option);
 736       GNUNET_free (opt);
 737       return GNUNET_SYSERR;
 738     }
 739   GNUNET_free (opt);
 740   return GNUNET_OK;
 741 }
 742
 743 /**
 744  * Add the given UNIX domain path as an address to the
 745  * list (as the first entry).
 746  *
 747  * @param saddrs array to update
 748  * @param saddrlens where to store the address length
 749  * @param unixpath path to add
 750  */
 751 static void
 752 add_unixpath (struct sockaddr **saddrs,
 753               socklen_t *saddrlens,
 754               const char *unixpath)
 755 {
 756 #ifdef AF_UNIX
 757   struct sockaddr_un *un;
 758   size_t slen;
 759
 760   un = GNUNET_malloc (sizeof (struct sockaddr_un));
 761   un->sun_family = AF_UNIX;
 762   slen = strlen (unixpath) + 1;
 763   if (slen >= sizeof (un->sun_path))
 764     slen = sizeof (un->sun_path) - 1;
 765   memcpy (un->sun_path,
 766           unixpath,
 767           slen);
 768   un->sun_path[slen] = '\0';
 769 #if LINUX
 770   un->sun_path[0] = '\0';
 771   slen = sizeof (struct sockaddr_un);
 772 #else
 773   slen += sizeof (sa_family_t);
 774 #endif
 775   *saddrs = (struct sockaddr*) un;
 776   *saddrlens = slen;
 777 #else
 778   /* this function should never be called
 779      unless AF_UNIX is defined! */
 780   GNUNET_assert (0);
 781 #endif
 782 }
 783
 784
 785 /**
 786  * Get the list of addresses that a server for the given service
 787  * should bind to.
 788  *
 789  * @param serviceName name of the service
 790  * @param cfg configuration (which specifies the addresses)
 791  * @param addrs set (call by reference) to an array of pointers to the
 792  *              addresses the server should bind to and listen on; the
 793  *              array will be NULL-terminated (on success)
 794  * @param addr_lens set (call by reference) to an array of the lengths
 795  *              of the respective 'struct sockaddr' struct in the 'addrs'
 796  *              array (on success)
 797  * @return number of addresses found on success,
 798  *              GNUNET_SYSERR if the configuration
 799  *              did not specify reasonable finding information or
 800  *              if it specified a hostname that could not be resolved;
 801  *              GNUNET_NO if the number of addresses configured is
 802  *              zero (in this case, '*addrs' and '*addr_lens' will be
 803  *              set to NULL).
 804  */
 805 int
 806 GNUNET_SERVICE_get_server_addresses (const char *serviceName,
 807                                      const struct GNUNET_CONFIGURATION_Handle *cfg,
 808                                      struct sockaddr ***addrs,
 809                                      socklen_t **addr_lens)
 810 {
 811   int disablev6;
 812   struct GNUNET_NETWORK_Handle *desc;
 813   unsigned long long port;
 814   char *unixpath;
 815   struct addrinfo hints;
 816   struct addrinfo *res;
 817   struct addrinfo *pos;
 818   struct addrinfo *next;
 819   unsigned int i;
 820   int resi;
 821   int ret;
 822   struct sockaddr **saddrs;
 823   socklen_t *saddrlens;
 824   char *hostname;
 825
 826   *addrs = NULL;
 827   *addr_lens = NULL;
 828   desc = NULL;
 829   if (GNUNET_CONFIGURATION_have_value (cfg,
 830                                        serviceName, "DISABLEV6"))
 831     {
 832       if (GNUNET_SYSERR ==
 833           (disablev6 = GNUNET_CONFIGURATION_get_value_yesno (cfg,
 834                                                              serviceName,
 835                                                              "DISABLEV6")))
 836         return GNUNET_SYSERR;
 837     }
 838   else
 839     disablev6 = GNUNET_NO;
 840
 841   if (!disablev6)
 842     {
 843       /* probe IPv6 support */
 844       desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0);
 845       if (NULL == desc)
 846         {
 847           if ((errno == ENOBUFS) ||
 848               (errno == ENOMEM) || (errno == ENFILE) || (errno == EACCES))
 849             {
 850               GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
 851               return GNUNET_SYSERR;
 852             }
 853           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 854                       _
 855                       ("Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"),
 856                       serviceName, STRERROR (errno));
 857           disablev6 = GNUNET_YES;
 858         }
 859       else
 860         {
 861           GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc));
 862           desc = NULL;
 863         }
 864     }
 865
 866   port = 0;
 867   if (GNUNET_CONFIGURATION_have_value (cfg,
 868                                        serviceName, "PORT"))
 869     {
 870       GNUNET_break (GNUNET_OK ==
 871                     GNUNET_CONFIGURATION_get_value_number (cfg,
 872                                                            serviceName,
 873                                                            "PORT",
 874                                                            &port));
 875       if (port > 65535)
 876         {
 877           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 878                       _
 879                       ("Require valid port number for service `%s' in configuration!\n"),
 880                       serviceName);
 881           return GNUNET_SYSERR;
 882         }
 883     }
 884
 885   if (GNUNET_CONFIGURATION_have_value (cfg,
 886                                        serviceName, "BINDTO"))
 887     {
 888       GNUNET_break (GNUNET_OK ==
 889                     GNUNET_CONFIGURATION_get_value_string (cfg,
 890                                                            serviceName,
 891                                                            "BINDTO",
 892                                                            &hostname));
 893     }
 894   else
 895     hostname = NULL;
 896
 897   unixpath = NULL;
 898 #ifdef AF_UNIX
 899   if ((GNUNET_YES == GNUNET_CONFIGURATION_have_value (cfg,
 900                                                       serviceName, "UNIXPATH")) &&
 901       (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg,
 902                                                            serviceName,
 903                                                            "UNIXPATH",
 904                                                            &unixpath)) &&
 905       (0 < strlen(unixpath)))
 906     {
 907       /* probe UNIX support */
 908       struct sockaddr_un s_un;
 909       if (strlen(unixpath) >= sizeof(s_un.sun_path))
 910         {
 911           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 912                       _("UNIXPATH `%s' too long, maximum length is %llu\n"),unixpath, sizeof(s_un.sun_path));
 913           GNUNET_free_non_null (hostname);
 914           GNUNET_free (unixpath);
 915           return GNUNET_SYSERR;
 916         }
 917
 918       desc = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0);
 919       if (NULL == desc)
 920         {
 921           if ((errno == ENOBUFS) ||
 922               (errno == ENOMEM) || (errno == ENFILE) || (errno == EACCES))
 923             {
 924               GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
 925               GNUNET_free_non_null (hostname);
 926               GNUNET_free (unixpath);
 927               return GNUNET_SYSERR;
 928             }
 929           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 930                       _
 931                       ("Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"),
 932                       serviceName, STRERROR (errno));
 933           GNUNET_free (unixpath);
 934           unixpath = NULL;
 935         }
 936       else
 937         {
 938           GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc));
 939           desc = NULL;
 940         }
 941     }
 942 #endif
 943
 944   if ( (port == 0) &&
 945        (unixpath == NULL) )
 946     {
 947       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 948                   _("Have neither PORT nor UNIXPATH for service `%s', but one is required\n"),
 949                   serviceName);
 950       GNUNET_free_non_null(hostname);
 951       return GNUNET_SYSERR;
 952     }
 953   if (port == 0)
 954     {
 955       saddrs = GNUNET_malloc (2 * sizeof(struct sockaddr*));
 956       saddrlens = GNUNET_malloc (2 * sizeof (socklen_t));
 957       add_unixpath (saddrs, saddrlens, unixpath);
 958       GNUNET_free_non_null (unixpath);
 959       GNUNET_free_non_null (hostname);
 960       *addrs = saddrs;
 961       *addr_lens = saddrlens;
 962       return 1;
 963     }
 964
 965   if (hostname != NULL)
 966     {
 967 #if DEBUG_SERVICE
 968       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 969                   "Resolving `%s' since that is where `%s' will bind to.\n",
 970                   hostname,
 971                   serviceName);
 972 #endif
 973       memset (&hints, 0, sizeof (struct addrinfo));
 974       if (disablev6)
 975         hints.ai_family = AF_INET;
 976       if ((0 != (ret = getaddrinfo (hostname,
 977                                     NULL, &hints, &res))) || (res == NULL))
 978         {
 979           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 980                       _("Failed to resolve `%s': %s\n"),
 981                       hostname, gai_strerror (ret));
 982           GNUNET_free (hostname);
 983           GNUNET_free_non_null (unixpath);
 984           return GNUNET_SYSERR;
 985         }
 986       next = res;
 987       i = 0;
 988       while (NULL != (pos = next))
 989         {
 990           next = pos->ai_next;
 991           if ( (disablev6) && (pos->ai_family == AF_INET6))
 992             continue;
 993           i++;
 994         }
 995       if (0 == i)
 996         {
 997           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 998                       _("Failed to find %saddress for `%s'.\n"),
 999                       disablev6 ? "IPv4 " : "", hostname);
1000           freeaddrinfo (res);
1001           GNUNET_free (hostname);
1002           GNUNET_free_non_null (unixpath);
1003           return GNUNET_SYSERR;
1004         }
1005       resi = i;
1006       if (NULL != unixpath)
1007         resi++;
1008       saddrs = GNUNET_malloc ((resi+1) * sizeof(struct sockaddr*));
1009       saddrlens = GNUNET_malloc ((resi+1) * sizeof (socklen_t));
1010       i = 0;
1011       if (NULL != unixpath)
1012         {
1013           add_unixpath (saddrs, saddrlens, unixpath);
1014           i++;
1015         }
1016       next = res;
1017       while (NULL != (pos = next))
1018         {
1019           next = pos->ai_next;
1020           if ( (disablev6) && (pos->ai_family == AF_INET6))
1021             continue;
1022 #if DEBUG_SERVICE
1023           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1024                       "Service `%s' will bind to `%s'\n",
1025                       serviceName,
1026                       GNUNET_a2s (pos->ai_addr,
1027                                   pos->ai_addrlen));
1028 #endif
1029           if (pos->ai_family == AF_INET)
1030             {
1031               GNUNET_assert (pos->ai_addrlen == sizeof (struct sockaddr_in));
1032               saddrlens[i] = pos->ai_addrlen;
1033               saddrs[i] = GNUNET_malloc (saddrlens[i]);
1034               memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
1035               ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
1036             }
1037           else
1038             {
1039               GNUNET_assert (pos->ai_family == AF_INET6);
1040               GNUNET_assert (pos->ai_addrlen == sizeof (struct sockaddr_in6));
1041               saddrlens[i] = pos->ai_addrlen;
1042               saddrs[i] = GNUNET_malloc (saddrlens[i]);
1043               memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
1044               ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
1045             }
1046           i++;
1047         }
1048       GNUNET_free (hostname);
1049       freeaddrinfo (res);
1050     }
1051   else
1052     {
1053       /* will bind against everything, just set port */
1054       if (disablev6)
1055         {
1056           /* V4-only */
1057           resi = 1;
1058           if (NULL != unixpath)
1059             resi++;
1060           i = 0;
1061           saddrs = GNUNET_malloc ((resi+1) * sizeof(struct sockaddr*));
1062           saddrlens = GNUNET_malloc ((resi+1) * sizeof (socklen_t));
1063           if (NULL != unixpath)
1064             {
1065               add_unixpath (saddrs, saddrlens, unixpath);
1066               i++;
1067             }
1068           saddrlens[i] = sizeof (struct sockaddr_in);
1069           saddrs[i] = GNUNET_malloc (saddrlens[i]);
1070 #if HAVE_SOCKADDR_IN_SIN_LEN
1071           ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[i];
1072 #endif
1073           ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
1074           ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
1075         }
1076       else
1077         {
1078           /* dual stack */
1079           resi = 2;
1080           if (NULL != unixpath)
1081             resi++;
1082           saddrs = GNUNET_malloc ((resi+1) * sizeof(struct sockaddr*));
1083           saddrlens = GNUNET_malloc ((resi+1) * sizeof (socklen_t));
1084           i = 0;
1085           if (NULL != unixpath)
1086             {
1087               add_unixpath (saddrs, saddrlens, unixpath);
1088               i++;
1089             }
1090           saddrlens[i] = sizeof (struct sockaddr_in6);
1091           saddrs[i] = GNUNET_malloc (saddrlens[i]);
1092 #if HAVE_SOCKADDR_IN_SIN_LEN
1093           ((struct sockaddr_in6 *) saddrs[i])->sin6_len = saddrlens[0];
1094 #endif
1095           ((struct sockaddr_in6 *) saddrs[i])->sin6_family = AF_INET6;
1096           ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
1097           i++;
1098           saddrlens[i] = sizeof (struct sockaddr_in);
1099           saddrs[i] = GNUNET_malloc (saddrlens[i]);
1100 #if HAVE_SOCKADDR_IN_SIN_LEN
1101           ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[1];
1102 #endif
1103           ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
1104           ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
1105         }
1106     }
1107   GNUNET_free_non_null (unixpath);
1108   *addrs = saddrs;
1109   *addr_lens = saddrlens;
1110   return resi;
1111 }
1112
1113
1114 /**
1115  * Setup addr, addrlen, idle_timeout
1116  * based on configuration!
1117  *
1118  * Configuration may specify:
1119  * - PORT (where to bind to for TCP)
1120  * - UNIXPATH (where to bind to for UNIX domain sockets)
1121  * - TIMEOUT (after how many ms does an inactive service timeout);
1122  * - DISABLEV6 (disable support for IPv6, otherwise we use dual-stack)
1123  * - BINDTO (hostname or IP address to bind to, otherwise we take everything)
1124  * - ACCEPT_FROM  (only allow connections from specified IPv4 subnets)
1125  * - ACCEPT_FROM6 (only allow connections from specified IPv6 subnets)
1126  * - REJECT_FROM  (disallow allow connections from specified IPv4 subnets)
1127  * - REJECT_FROM6 (disallow allow connections from specified IPv6 subnets)
1128  *
1129  * @return GNUNET_OK if configuration succeeded
1130  */
1131 static int
1132 setup_service (struct GNUNET_SERVICE_Context *sctx)
1133 {
1134   struct GNUNET_TIME_Relative idleout;
1135   int tolerant;
1136 #ifndef MINGW
1137   const char *lpid;
1138   unsigned int pid;
1139   const char *nfds;
1140   unsigned int cnt;
1141   int flags;
1142 #endif
1143
1144   if (GNUNET_CONFIGURATION_have_value (sctx->cfg,
1145                                        sctx->serviceName, "TIMEOUT"))
1146     {
1147       if (GNUNET_OK !=
1148           GNUNET_CONFIGURATION_get_value_time (sctx->cfg,
1149                                                sctx->serviceName,
1150                                                "TIMEOUT", &idleout))
1151         {
1152           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1153                       _("Specified value for `%s' of service `%s' is invalid\n"),
1154                       "TIMEOUT",
1155                       sctx->serviceName);
1156           return GNUNET_SYSERR;
1157         }
1158       sctx->timeout = idleout;
1159     }
1160   else
1161     sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
1162
1163   if (GNUNET_CONFIGURATION_have_value (sctx->cfg,
1164                                        sctx->serviceName, "TOLERANT"))
1165     {
1166       if (GNUNET_SYSERR ==
1167           (tolerant = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg,
1168                                                             sctx->serviceName,
1169                                                             "TOLERANT")))
1170         {
1171           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1172                       _("Specified value for `%s' of service `%s' is invalid\n"),
1173                       "TOLERANT",
1174                       sctx->serviceName);
1175           return GNUNET_SYSERR;
1176         }
1177     }
1178   else
1179     tolerant = GNUNET_NO;
1180
1181 #ifndef MINGW
1182   errno = 0;
1183   if ( (NULL != (lpid = getenv ("LISTEN_PID"))) &&
1184        (1 == sscanf (lpid, "%u", &pid)) &&
1185        (getpid () == (pid_t) pid) &&
1186        (NULL != (nfds = getenv ("LISTEN_FDS"))) &&
1187        (1 == sscanf (nfds, "%u", &cnt)) &&
1188        (cnt > 0) &&
1189        (cnt < FD_SETSIZE) &&
1190        (cnt + 4 < FD_SETSIZE) )
1191     {
1192       sctx->lsocks = GNUNET_malloc (sizeof(struct GNUNET_NETWORK_Handle*) * (cnt+1));
1193       while (0 < cnt--)
1194         {
1195           flags = fcntl (3 + cnt, F_GETFD);
1196           if ( (flags < 0) ||
1197                (0 != (flags & FD_CLOEXEC)) ||
1198                (NULL == (sctx->lsocks[cnt] = GNUNET_NETWORK_socket_box_native (3 + cnt))) )
1199             {
1200               GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1201                           _("Could not access pre-bound socket %u, will try to bind myself\n"),
1202                           (unsigned int) 3 +cnt);
1203               cnt++;
1204               while (sctx->lsocks[cnt] != NULL)
1205                 GNUNET_break (0 == GNUNET_NETWORK_socket_close (sctx->lsocks[cnt++]));
1206               GNUNET_free (sctx->lsocks);
1207               sctx->lsocks = NULL;
1208               break;
1209             }
1210         }
1211       unsetenv ("LISTEN_PID");
1212       unsetenv ("LISTEN_FDS");
1213     }
1214 #endif
1215
1216   if ( (sctx->lsocks == NULL) &&
1217        (GNUNET_SYSERR ==
1218         GNUNET_SERVICE_get_server_addresses (sctx->serviceName,
1219                                              sctx->cfg,
1220                                              &sctx->addrs,
1221                                              &sctx->addrlens)) )
1222     return GNUNET_SYSERR;
1223   sctx->require_found = tolerant ? GNUNET_NO : GNUNET_YES;
1224   sctx->match_uid = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg,
1225                                                           sctx->serviceName,
1226                                                           "UNIX_MATCH_UID");
1227   sctx->match_gid = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg,
1228                                                           sctx->serviceName,
1229                                                           "UNIX_MATCH_GID");
1230   process_acl4 (&sctx->v4_denied, sctx, "REJECT_FROM");
1231   process_acl4 (&sctx->v4_allowed, sctx, "ACCEPT_FROM");
1232   process_acl6 (&sctx->v6_denied, sctx, "REJECT_FROM6");
1233   process_acl6 (&sctx->v6_allowed, sctx, "ACCEPT_FROM6");
1234
1235   return GNUNET_OK;
1236 }
1237
1238
1239 /**
1240  * Get the name of the user that'll be used
1241  * to provide the service.
1242  */
1243 static char *
1244 get_user_name (struct GNUNET_SERVICE_Context *sctx)
1245 {
1246
1247   char *un;
1248
1249   if (GNUNET_OK !=
1250       GNUNET_CONFIGURATION_get_value_filename (sctx->cfg,
1251                                                sctx->serviceName,
1252                                                "USERNAME", &un))
1253     return NULL;
1254   return un;
1255 }
1256
1257 /**
1258  * Write PID file.
1259  */
1260 static int
1261 write_pid_file (struct GNUNET_SERVICE_Context *sctx, pid_t pid)
1262 {
1263   FILE *pidfd;
1264   char *pif;
1265   char *user;
1266   char *rdir;
1267   int len;
1268
1269   if (NULL == (pif = get_pid_file_name (sctx)))
1270     return GNUNET_OK;           /* no file desired */
1271   user = get_user_name (sctx);
1272   rdir = GNUNET_strdup (pif);
1273   len = strlen (rdir);
1274   while ((len > 0) && (rdir[len] != DIR_SEPARATOR))
1275     len--;
1276   rdir[len] = '\0';
1277   if (0 != ACCESS (rdir, F_OK))
1278     {
1279       /* we get to create a directory -- and claim it
1280          as ours! */
1281       GNUNET_DISK_directory_create (rdir);
1282       if ((user != NULL) && (0 < strlen (user)))
1283         GNUNET_DISK_file_change_owner (rdir, user);
1284     }
1285   if (0 != ACCESS (rdir, W_OK | X_OK))
1286     {
1287       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "access", rdir);
1288       GNUNET_free (rdir);
1289       GNUNET_free_non_null (user);
1290       GNUNET_free (pif);
1291       return GNUNET_SYSERR;
1292     }
1293   GNUNET_free (rdir);
1294   pidfd = FOPEN (pif, "w");
1295   if (pidfd == NULL)
1296     {
1297       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "fopen", pif);
1298       GNUNET_free (pif);
1299       GNUNET_free_non_null (user);
1300       return GNUNET_SYSERR;
1301     }
1302   if (0 > FPRINTF (pidfd, "%u", pid))
1303     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "fprintf", pif);
1304   GNUNET_break (0 == fclose (pidfd));
1305   if ((user != NULL) && (0 < strlen (user)))
1306     GNUNET_DISK_file_change_owner (pif, user);
1307   GNUNET_free_non_null (user);
1308   GNUNET_free (pif);
1309   return GNUNET_OK;
1310 }
1311
1312
1313 /**
1314  * Task run during shutdown.
1315  *
1316  * @param cls unused
1317  * @param tc unused
1318  */
1319 static void
1320 shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1321 {
1322   struct GNUNET_SERVER_Handle *server = cls;
1323
1324   GNUNET_SERVER_destroy (server);
1325 }
1326
1327
1328 /**
1329  * Initial task for the service.
1330  */
1331 static void
1332 service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1333 {
1334   struct GNUNET_SERVICE_Context *sctx = cls;
1335   unsigned int i;
1336
1337   if (sctx->lsocks != NULL)
1338     sctx->server = GNUNET_SERVER_create_with_sockets (&check_access,
1339                                                       sctx,
1340                                                       sctx->lsocks,
1341                                                       sctx->timeout, sctx->require_found);
1342   else
1343     sctx->server = GNUNET_SERVER_create (&check_access,
1344                                          sctx,
1345                                          sctx->addrs,
1346                                          sctx->addrlens,
1347                                          sctx->timeout, sctx->require_found);
1348   if (sctx->server == NULL)
1349     {
1350       if (sctx->addrs != NULL)
1351         {
1352           i = 0;
1353           while (sctx->addrs[i] != NULL)
1354             {
1355               GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1356                           _("Failed to start `%s' at `%s'\n"),
1357                           sctx->serviceName,
1358                           GNUNET_a2s (sctx->addrs[i], sctx->addrlens[i]));
1359               i++;
1360             }
1361         }
1362       sctx->ret = GNUNET_SYSERR;
1363       return;
1364     }
1365   if (0 == (sctx->options & GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN))
1366     {
1367       /* install a task that will kill the server
1368          process if the scheduler ever gets a shutdown signal */
1369       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
1370                                     &shutdown_task, sctx->server);
1371     }
1372   sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers));
1373   memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers));
1374   i = 0;
1375   while ((sctx->my_handlers[i].callback != NULL))
1376     sctx->my_handlers[i++].callback_cls = sctx;
1377   GNUNET_SERVER_add_handlers (sctx->server, sctx->my_handlers);
1378   if (sctx->ready_confirm_fd != -1)
1379     {
1380       GNUNET_break (1 == WRITE (sctx->ready_confirm_fd, ".", 1));
1381       GNUNET_break (0 == CLOSE (sctx->ready_confirm_fd));
1382       sctx->ready_confirm_fd = -1;
1383       write_pid_file (sctx, getpid ());
1384     }
1385   if (sctx->addrs != NULL)
1386     {
1387       i = 0;
1388       while (sctx->addrs[i] != NULL)
1389         {
1390           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1391                       _("Service `%s' runs at %s\n"),
1392                       sctx->serviceName,
1393                       GNUNET_a2s (sctx->addrs[i], sctx->addrlens[i]));
1394           i++;
1395         }
1396     }
1397   sctx->task (sctx->task_cls, sctx->server, sctx->cfg);
1398 }
1399
1400
1401 /**
1402  * Detach from terminal.
1403  */
1404 static int
1405 detach_terminal (struct GNUNET_SERVICE_Context *sctx)
1406 {
1407 #ifndef MINGW
1408   pid_t pid;
1409   int nullfd;
1410   int filedes[2];
1411
1412   if (0 != PIPE (filedes))
1413     {
1414       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "pipe");
1415       return GNUNET_SYSERR;
1416     }
1417   pid = fork ();
1418   if (pid < 0)
1419     {
1420       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
1421       return GNUNET_SYSERR;
1422     }
1423   if (pid != 0)
1424     {
1425       /* Parent */
1426       char c;
1427
1428       GNUNET_break (0 == CLOSE (filedes[1]));
1429       c = 'X';
1430       if (1 != READ (filedes[0], &c, sizeof (char)))
1431         GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "read");
1432       fflush (stdout);
1433       switch (c)
1434         {
1435         case '.':
1436           exit (0);
1437         case 'I':
1438           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1439                       _("Service process failed to initialize\n"));
1440           break;
1441         case 'S':
1442           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1443                       _
1444                       ("Service process could not initialize server function\n"));
1445           break;
1446         case 'X':
1447           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1448                       _("Service process failed to report status\n"));
1449           break;
1450         }
1451       exit (1);                 /* child reported error */
1452     }
1453   GNUNET_break (0 == CLOSE (0));
1454   GNUNET_break (0 == CLOSE (1));
1455   GNUNET_break (0 == CLOSE (filedes[0]));
1456   nullfd = OPEN ("/dev/null", O_RDWR | O_APPEND);
1457   if (nullfd < 0)
1458     return GNUNET_SYSERR;
1459   /* set stdin/stdout to /dev/null */
1460   if ((dup2 (nullfd, 0) < 0) || (dup2 (nullfd, 1) < 0))
1461     {
1462       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "dup2");
1463       (void) CLOSE (nullfd);
1464       return GNUNET_SYSERR;
1465     }
1466   (void) CLOSE (nullfd);
1467   /* Detach from controlling terminal */
1468   pid = setsid ();
1469   if (pid == -1)
1470     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "setsid");
1471   sctx->ready_confirm_fd = filedes[1];
1472 #else
1473   /* FIXME: we probably need to do something else
1474      elsewhere in order to fork the process itself... */
1475   FreeConsole ();
1476 #endif
1477   return GNUNET_OK;
1478 }
1479
1480
1481 /**
1482  * Set user ID.
1483  */
1484 static int
1485 set_user_id (struct GNUNET_SERVICE_Context *sctx)
1486 {
1487   char *user;
1488
1489   if (NULL == (user = get_user_name (sctx)))
1490     return GNUNET_OK;           /* keep */
1491 #ifndef MINGW
1492   struct passwd *pws;
1493
1494   errno = 0;
1495   pws = getpwnam (user);
1496   if (pws == NULL)
1497     {
1498       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1499                   _("Cannot obtain information about user `%s': %s\n"),
1500                   user, errno == 0 ? _("No such user") : STRERROR (errno));
1501       GNUNET_free (user);
1502       return GNUNET_SYSERR;
1503     }
1504   if ((0 != setgid (pws->pw_gid)) || (0 != setegid (pws->pw_gid)) ||
1505 #if HAVE_INITGROUPS
1506       (0 != initgroups (user, pws->pw_gid)) ||
1507 #endif
1508       (0 != setuid (pws->pw_uid)) || (0 != seteuid (pws->pw_uid)))
1509     {
1510       if ((0 != setregid (pws->pw_gid, pws->pw_gid)) ||
1511           (0 != setreuid (pws->pw_uid, pws->pw_uid)))
1512         {
1513           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1514                       _("Cannot change user/group to `%s': %s\n"), user,
1515                       STRERROR (errno));
1516           GNUNET_free (user);
1517           return GNUNET_SYSERR;
1518         }
1519     }
1520 #endif
1521   GNUNET_free (user);
1522   return GNUNET_OK;
1523 }
1524
1525
1526 /**
1527  * Delete the PID file that was created by our parent.
1528  */
1529 static void
1530 pid_file_delete (struct GNUNET_SERVICE_Context *sctx)
1531 {
1532   char *pif = get_pid_file_name (sctx);
1533   if (pif == NULL)
1534     return;                     /* no PID file */
1535   if (0 != UNLINK (pif))
1536     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", pif);
1537   GNUNET_free (pif);
1538 }
1539
1540
1541 /**
1542  * Run a standard GNUnet service startup sequence (initialize loggers
1543  * and configuration, parse options).
1544  *
1545  * @param argc number of command line arguments
1546  * @param argv command line arguments
1547  * @param serviceName our service name
1548  * @param opt service options
1549  * @param task main task of the service
1550  * @param task_cls closure for task
1551  * @return GNUNET_SYSERR on error, GNUNET_OK
1552  *         if we shutdown nicely
1553  */
1554 int
1555 GNUNET_SERVICE_run (int argc,
1556                     char *const *argv,
1557                     const char *serviceName,
1558                     enum GNUNET_SERVICE_Options opt,
1559                     GNUNET_SERVICE_Main task, void *task_cls)
1560 {
1561 #define HANDLE_ERROR do { err = 1; GNUNET_break (0); goto shutdown; } while (0)
1562
1563   int err;
1564   char *cfg_fn;
1565   char *loglev;
1566   char *logfile;
1567   int do_daemonize;
1568   unsigned int i;
1569   struct GNUNET_SERVICE_Context sctx;
1570   struct GNUNET_CONFIGURATION_Handle *cfg;
1571   struct GNUNET_GETOPT_CommandLineOption service_options[] = {
1572     GNUNET_GETOPT_OPTION_CFG_FILE (&cfg_fn),
1573     {'d', "daemonize", NULL,
1574      gettext_noop ("do daemonize (detach from terminal)"), 0,
1575      GNUNET_GETOPT_set_one, &do_daemonize},
1576     GNUNET_GETOPT_OPTION_HELP (serviceName),
1577     GNUNET_GETOPT_OPTION_LOGLEVEL (&loglev),
1578     GNUNET_GETOPT_OPTION_LOGFILE (&logfile),
1579     GNUNET_GETOPT_OPTION_VERSION (PACKAGE_VERSION),
1580     GNUNET_GETOPT_OPTION_END
1581   };
1582   err = 0;
1583   do_daemonize = 0;
1584   logfile = NULL;
1585   loglev = GNUNET_strdup ("WARNING");
1586   cfg_fn = GNUNET_strdup (GNUNET_DEFAULT_USER_CONFIG_FILE);
1587   memset (&sctx, 0, sizeof (sctx));
1588   sctx.options = opt;
1589   sctx.ready_confirm_fd = -1;
1590   sctx.ret = GNUNET_OK;
1591   sctx.timeout = GNUNET_TIME_UNIT_FOREVER_REL;
1592   sctx.task = task;
1593   sctx.task_cls = task_cls;
1594   sctx.serviceName = serviceName;
1595   sctx.cfg = cfg = GNUNET_CONFIGURATION_create ();
1596   /* setup subsystems */
1597   if (GNUNET_SYSERR == GNUNET_GETOPT_run (serviceName, service_options, argc,
1598       argv))
1599     goto shutdown;
1600   if (GNUNET_OK != GNUNET_log_setup (serviceName, loglev, logfile))
1601     HANDLE_ERROR;
1602   if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg, cfg_fn))
1603     goto shutdown;
1604   if (GNUNET_OK != setup_service (&sctx))
1605     goto shutdown;
1606   if ( (do_daemonize == 1) && (GNUNET_OK != detach_terminal (&sctx)))
1607     HANDLE_ERROR;
1608   if (GNUNET_OK != set_user_id (&sctx))
1609     goto shutdown;
1610 #if DEBUG_SERVICE
1611   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1612               "Service `%s' runs with configuration from `%s'\n",
1613               serviceName, cfg_fn);
1614 #endif
1615   /* actually run service */
1616   GNUNET_SCHEDULER_run (&service_task, &sctx);
1617
1618   /* shutdown */
1619   if ((do_daemonize == 1) && (sctx.server != NULL))
1620     pid_file_delete (&sctx);
1621   GNUNET_free_non_null (sctx.my_handlers);
1622
1623 shutdown:
1624   if (sctx.ready_confirm_fd != -1)
1625     {
1626       if (1 != WRITE (sctx.ready_confirm_fd, err ? "I" : "S", 1))
1627         GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "write");
1628       GNUNET_break (0 == CLOSE (sctx.ready_confirm_fd));
1629     }
1630
1631   GNUNET_CONFIGURATION_destroy (cfg);
1632   i = 0;
1633   if (sctx.addrs != NULL)
1634     while (sctx.addrs[i] != NULL)
1635       GNUNET_free (sctx.addrs[i++]);
1636   GNUNET_free_non_null (sctx.addrs);
1637   GNUNET_free_non_null (sctx.addrlens);
1638   GNUNET_free_non_null (logfile);
1639   GNUNET_free (loglev);
1640   GNUNET_free (cfg_fn);
1641   GNUNET_free_non_null (sctx.v4_denied);
1642   GNUNET_free_non_null (sctx.v6_denied);
1643   GNUNET_free_non_null (sctx.v4_allowed);
1644   GNUNET_free_non_null (sctx.v6_allowed);
1645
1646   return err ? GNUNET_SYSERR : sctx.ret;
1647 }
1648
1649
1650 /**
1651  * Run a service startup sequence within an existing
1652  * initialized system.
1653  *
1654  * @param serviceName our service name
1655  * @param cfg configuration to use
1656  * @return NULL on error, service handle
1657  */
1658 struct GNUNET_SERVICE_Context *
1659 GNUNET_SERVICE_start (const char *serviceName,
1660                       const struct GNUNET_CONFIGURATION_Handle *cfg)
1661 {
1662   int i;
1663   struct GNUNET_SERVICE_Context *sctx;
1664
1665   sctx = GNUNET_malloc (sizeof (struct GNUNET_SERVICE_Context));
1666   sctx->ready_confirm_fd = -1;  /* no daemonizing */
1667   sctx->ret = GNUNET_OK;
1668   sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
1669   sctx->serviceName = serviceName;
1670   sctx->cfg = cfg;
1671
1672   /* setup subsystems */
1673   if (GNUNET_OK != setup_service (sctx))
1674     {
1675       GNUNET_SERVICE_stop (sctx);
1676       return NULL;
1677     }
1678   if (sctx->lsocks != NULL)
1679     sctx->server = GNUNET_SERVER_create_with_sockets (&check_access,
1680                                                       sctx,
1681                                                       sctx->lsocks,
1682                                                       sctx->timeout, sctx->require_found);
1683   else
1684     sctx->server = GNUNET_SERVER_create (&check_access,
1685                                          sctx,
1686                                          sctx->addrs,
1687                                          sctx->addrlens,
1688                                          sctx->timeout,
1689                                          sctx->require_found);
1690
1691   if (NULL == sctx->server)
1692     {
1693       GNUNET_SERVICE_stop (sctx);
1694       return NULL;
1695     }
1696   sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers));
1697   memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers));
1698   i = 0;
1699   while ((sctx->my_handlers[i].callback != NULL))
1700     sctx->my_handlers[i++].callback_cls = sctx;
1701   GNUNET_SERVER_add_handlers (sctx->server, sctx->my_handlers);
1702   return sctx;
1703 }
1704
1705 /**
1706  * Obtain the server used by a service.  Note that the server must NOT
1707  * be destroyed by the caller.
1708  *
1709  * @param ctx the service context returned from the start function
1710  * @return handle to the server for this service, NULL if there is none
1711  */
1712 struct GNUNET_SERVER_Handle *
1713 GNUNET_SERVICE_get_server (struct GNUNET_SERVICE_Context *ctx)
1714 {
1715   return ctx->server;
1716 }
1717
1718
1719 /**
1720  * Stop a service that was started with "GNUNET_SERVICE_start".
1721  *
1722  * @param sctx the service context returned from the start function
1723  */
1724 void
1725 GNUNET_SERVICE_stop (struct GNUNET_SERVICE_Context *sctx)
1726 {
1727   unsigned int i;
1728   if (NULL != sctx->server)
1729     GNUNET_SERVER_destroy (sctx->server);
1730   GNUNET_free_non_null (sctx->my_handlers);
1731   if (sctx->addrs != NULL)
1732     {
1733       i = 0;
1734       while (sctx->addrs[i] != NULL)
1735         GNUNET_free (sctx->addrs[i++]);
1736       GNUNET_free (sctx->addrs);
1737     }
1738   GNUNET_free_non_null (sctx->addrlens);
1739   GNUNET_free_non_null (sctx->v4_denied);
1740   GNUNET_free_non_null (sctx->v6_denied);
1741   GNUNET_free_non_null (sctx->v4_allowed);
1742   GNUNET_free_non_null (sctx->v6_allowed);
1743   GNUNET_free (sctx);
1744 }
1745
1746
1747 /* end of service.c */