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    * Scheduler for the server.
 434    */
 435   struct GNUNET_SCHEDULER_Handle *sched;
 436
 437   /**
 438    * NULL-terminated array of addresses to bind to.
 439    */
 440   struct sockaddr **addrs;
 441
 442   /**
 443    * Name of our service.
 444    */
 445   const char *serviceName;
 446
 447   /**
 448    * Main service-specific task to run.
 449    */
 450   GNUNET_SERVICE_Main task;
 451
 452   /**
 453    * Closure for task.
 454    */
 455   void *task_cls;
 456
 457   /**
 458    * IPv4 addresses that are not allowed to connect.
 459    */
 460   struct IPv4NetworkSet *v4_denied;
 461
 462   /**
 463    * IPv6 addresses that are not allowed to connect.
 464    */
 465   struct IPv6NetworkSet *v6_denied;
 466
 467   /**
 468    * IPv4 addresses that are allowed to connect (if not
 469    * set, all are allowed).
 470    */
 471   struct IPv4NetworkSet *v4_allowed;
 472
 473   /**
 474    * IPv6 addresses that are allowed to connect (if not
 475    * set, all are allowed).
 476    */
 477   struct IPv6NetworkSet *v6_allowed;
 478
 479   /**
 480    * My (default) message handlers.  Adjusted copy
 481    * of "defhandlers".
 482    */
 483   struct GNUNET_SERVER_MessageHandler *my_handlers;
 484
 485   /**
 486    * Idle timeout for server.
 487    */
 488   struct GNUNET_TIME_Relative timeout;
 489
 490   /**
 491    * Maximum buffer size for the server.
 492    */
 493   size_t maxbuf;
 494
 495   /**
 496    * Overall success/failure of the service start.
 497    */
 498   int ret;
 499
 500   /**
 501    * If we are daemonizing, this FD is set to the
 502    * pipe to the parent.  Send '.' if we started
 503    * ok, '!' if not.  -1 if we are not daemonizing.
 504    */
 505   int ready_confirm_fd;
 506
 507   /**
 508    * Do we close connections if we receive messages
 509    * for which we have no handler?
 510    */
 511   int require_found;
 512
 513   /**
 514    * Can clients ask us to initiate a shutdown?
 515    */
 516   int allow_shutdown;
 517
 518   /**
 519    * Our options.
 520    */
 521   enum GNUNET_SERVICE_Options options;
 522
 523   /**
 524    * Array of the lengths of the entries in addrs.
 525    */
 526   socklen_t * addrlens;
 527
 528 };
 529
 530
 531 /* ****************** message handlers ****************** */
 532
 533 static size_t
 534 write_test (void *cls, size_t size, void *buf)
 535 {
 536   struct GNUNET_SERVER_Client *client = cls;
 537   struct GNUNET_MessageHeader *msg;
 538
 539   if (size < sizeof (struct GNUNET_MessageHeader))
 540     {
 541       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 542       return 0;                 /* client disconnected */
 543     }
 544   msg = (struct GNUNET_MessageHeader *) buf;
 545   msg->type = htons (GNUNET_MESSAGE_TYPE_TEST);
 546   msg->size = htons (sizeof (struct GNUNET_MessageHeader));
 547   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 548   return sizeof (struct GNUNET_MessageHeader);
 549 }
 550
 551 /**
 552  * Handler for TEST message.
 553  *
 554  * @param cls closure (refers to service)
 555  * @param client identification of the client
 556  * @param message the actual message
 557  */
 558 static void
 559 handle_test (void *cls,
 560              struct GNUNET_SERVER_Client *client,
 561              const struct GNUNET_MessageHeader *message)
 562 {
 563   /* simply bounce message back to acknowledge */
 564   if (NULL == GNUNET_SERVER_notify_transmit_ready (client,
 565                                                    sizeof (struct
 566                                                            GNUNET_MessageHeader),
 567                                                    GNUNET_TIME_UNIT_FOREVER_REL,
 568                                                    &write_test, client))
 569     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 570 }
 571
 572
 573 static size_t
 574 transmit_shutdown_deny (void *cls, size_t size, void *buf)
 575 {
 576   struct GNUNET_SERVER_Client *client = cls;
 577   struct GNUNET_MessageHeader *msg;
 578
 579   if (size < sizeof (struct GNUNET_MessageHeader))
 580     {
 581       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 582       return 0;                 /* client disconnected */
 583     }
 584   msg = (struct GNUNET_MessageHeader *) buf;
 585   msg->type = htons (GNUNET_MESSAGE_TYPE_SHUTDOWN_REFUSE);
 586   msg->size = htons (sizeof (struct GNUNET_MessageHeader));
 587   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 588   GNUNET_SERVER_client_drop(client);
 589   return sizeof (struct GNUNET_MessageHeader);
 590 }
 591
 592 static size_t
 593 transmit_shutdown_ack (void *cls, size_t size, void *buf)
 594 {
 595   struct GNUNET_SERVER_Client *client = cls;
 596   struct GNUNET_MessageHeader *msg;
 597
 598   if (size < sizeof (struct GNUNET_MessageHeader))
 599     {
 600       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 601                   _("Failed to transmit shutdown ACK.\n"));
 602       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 603       return 0;                 /* client disconnected */
 604     }
 605
 606   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 607               _("Transmitting shutdown ACK.\n"));
 608
 609   msg = (struct GNUNET_MessageHeader *) buf;
 610   msg->type = htons (GNUNET_MESSAGE_TYPE_SHUTDOWN_ACK);
 611   msg->size = htons (sizeof (struct GNUNET_MessageHeader));
 612   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 613   GNUNET_SERVER_client_drop(client);
 614   return sizeof (struct GNUNET_MessageHeader);
 615 }
 616
 617 /**
 618  * Handler for SHUTDOWN message.
 619  *
 620  * @param cls closure (refers to service)
 621  * @param client identification of the client
 622  * @param message the actual message
 623  */
 624 static void
 625 handle_shutdown (void *cls,
 626                  struct GNUNET_SERVER_Client *client,
 627                  const struct GNUNET_MessageHeader *message)
 628 {
 629   struct GNUNET_SERVICE_Context *service = cls;
 630
 631   /* FIXME: why is this call necessary???? */
 632   GNUNET_SERVER_client_keep(client);
 633   if (!service->allow_shutdown)
 634     {
 635       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 636                   _
 637                   ("Received shutdown request, but configured to ignore!\n"));
 638       GNUNET_SERVER_notify_transmit_ready (client,
 639                                            sizeof(struct GNUNET_MessageHeader),
 640                                            GNUNET_TIME_UNIT_FOREVER_REL,
 641                                            &transmit_shutdown_deny, client);
 642       return;
 643     }
 644   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 645               _("Initiating shutdown as requested by client.\n"));
 646
 647   GNUNET_SERVER_notify_transmit_ready (client,
 648                                        sizeof(struct GNUNET_MessageHeader),
 649                                        GNUNET_TIME_UNIT_FOREVER_REL,
 650                                        &transmit_shutdown_ack, client);
 651
 652   GNUNET_assert (service->sched != NULL);
 653   GNUNET_SERVER_client_persist_ (client);
 654   GNUNET_SCHEDULER_shutdown (service->sched);
 655 }
 656
 657
 658 /**
 659  * Default handlers for all services.  Will be copied and the
 660  * "callback_cls" fields will be replaced with the specific service
 661  * struct.
 662  */
 663 static const struct GNUNET_SERVER_MessageHandler defhandlers[] = {
 664   {&handle_test, NULL, GNUNET_MESSAGE_TYPE_TEST,
 665    sizeof (struct GNUNET_MessageHeader)},
 666   {&handle_shutdown, NULL, GNUNET_MESSAGE_TYPE_SHUTDOWN,
 667    sizeof (struct GNUNET_MessageHeader)},
 668   {NULL, NULL, 0, 0}
 669 };
 670
 671
 672
 673 /* ****************** service core routines ************** */
 674
 675
 676 /**
 677  * Check if access to the service is allowed from the given address.
 678  */
 679 static int
 680 check_access (void *cls, const struct sockaddr *addr, socklen_t addrlen)
 681 {
 682   struct GNUNET_SERVICE_Context *sctx = cls;
 683   const struct sockaddr_in *i4;
 684   const struct sockaddr_in6 *i6;
 685   int ret;
 686
 687   switch (addr->sa_family)
 688     {
 689     case AF_INET:
 690       GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
 691       i4 = (const struct sockaddr_in *) addr;
 692       ret = ((sctx->v4_allowed == NULL) ||
 693              (check_ipv4_listed (sctx->v4_allowed,
 694                                  &i4->sin_addr)))
 695         && ((sctx->v4_denied == NULL) ||
 696             (!check_ipv4_listed (sctx->v4_denied, &i4->sin_addr)));
 697       break;
 698     case AF_INET6:
 699       GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
 700       i6 = (const struct sockaddr_in6 *) addr;
 701       ret = ((sctx->v6_allowed == NULL) ||
 702              (check_ipv6_listed (sctx->v6_allowed,
 703                                  &i6->sin6_addr)))
 704         && ((sctx->v6_denied == NULL) ||
 705             (!check_ipv6_listed (sctx->v6_denied, &i6->sin6_addr)));
 706       break;
 707     default:
 708       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 709                   _("Unknown address family %d\n"), addr->sa_family);
 710       return GNUNET_SYSERR;
 711     }
 712   if (ret != GNUNET_OK)
 713     {
 714       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 715                   _("Access from `%s' denied to service `%s'\n"),
 716                   GNUNET_a2s (addr, addrlen), sctx->serviceName);
 717     }
 718   return ret;
 719 }
 720
 721
 722 /**
 723  * Get the name of the file where we will
 724  * write the PID of the service.
 725  */
 726 static char *
 727 get_pid_file_name (struct GNUNET_SERVICE_Context *sctx)
 728 {
 729
 730   char *pif;
 731
 732   if (GNUNET_OK !=
 733       GNUNET_CONFIGURATION_get_value_filename (sctx->cfg,
 734                                                sctx->serviceName,
 735                                                "PIDFILE", &pif))
 736     return NULL;
 737   return pif;
 738 }
 739
 740
 741 /**
 742  * Parse an IPv4 access control list.
 743  */
 744 static int
 745 process_acl4 (struct IPv4NetworkSet **ret,
 746               struct GNUNET_SERVICE_Context *sctx, const char *option)
 747 {
 748   char *opt;
 749
 750   if (!GNUNET_CONFIGURATION_have_value (sctx->cfg, sctx->serviceName, option))
 751     return GNUNET_OK;
 752   GNUNET_break (GNUNET_OK ==
 753                 GNUNET_CONFIGURATION_get_value_string (sctx->cfg,
 754                                                        sctx->serviceName,
 755                                                        option, &opt));
 756   if (NULL == (*ret = parse_ipv4_specification (opt)))
 757     {
 758       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 759                   _
 760                   ("Could not parse IPv4 network specification `%s' for `%s:%s'\n"),
 761                   opt, sctx->serviceName, option);
 762       GNUNET_free (opt);
 763       return GNUNET_SYSERR;
 764     }
 765   GNUNET_free (opt);
 766   return GNUNET_OK;
 767 }
 768
 769
 770 /**
 771  * Parse an IPv4 access control list.
 772  */
 773 static int
 774 process_acl6 (struct IPv6NetworkSet **ret,
 775               struct GNUNET_SERVICE_Context *sctx, const char *option)
 776 {
 777   char *opt;
 778   if (!GNUNET_CONFIGURATION_have_value (sctx->cfg, sctx->serviceName, option))
 779     return GNUNET_OK;
 780   GNUNET_break (GNUNET_OK ==
 781                 GNUNET_CONFIGURATION_get_value_string (sctx->cfg,
 782                                                        sctx->serviceName,
 783                                                        option, &opt));
 784   if (NULL == (*ret = parse_ipv6_specification (opt)))
 785     {
 786       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 787                   _
 788                   ("Could not parse IPv6 network specification `%s' for `%s:%s'\n"),
 789                   opt, sctx->serviceName, option);
 790       GNUNET_free (opt);
 791       return GNUNET_SYSERR;
 792     }
 793   GNUNET_free (opt);
 794   return GNUNET_OK;
 795 }
 796
 797
 798 /**
 799  * Get the list of addresses that a server for the given service
 800  * should bind to.
 801  *
 802  * @param serviceName name of the service
 803  * @param cfg configuration (which specifies the addresses)
 804  * @param addrs set (call by reference) to an array of pointers to the
 805  *              addresses the server should bind to and listen on; the
 806  *              array will be NULL-terminated (on success)
 807  * @param addr_lens set (call by reference) to an array of the lengths
 808  *              of the respective 'struct sockaddr' struct in the 'addrs'
 809  *              array (on success)
 810  * @return number of addresses found on success,
 811  *              GNUNET_SYSERR if the configuration
 812  *              did not specify reasonable finding information or
 813  *              if it specified a hostname that could not be resolved;
 814  *              GNUNET_NO if the number of addresses configured is
 815  *              zero (in this case, '*addrs' and '*addr_lens' will be
 816  *              set to NULL).
 817  */
 818 int
 819 GNUNET_SERVICE_get_server_addresses (const char *serviceName,
 820                                      const struct GNUNET_CONFIGURATION_Handle *cfg,
 821                                      struct sockaddr ***addrs,
 822                                      socklen_t **addr_lens)
 823 {
 824   int disablev6;
 825   struct GNUNET_NETWORK_Handle *desc;
 826   unsigned long long port;
 827   struct addrinfo hints;
 828   struct addrinfo *res;
 829   struct addrinfo *pos;
 830   struct addrinfo *next;
 831   unsigned int i;
 832   int resi;
 833   int ret;
 834   struct sockaddr **saddrs;
 835   socklen_t *saddrlens;
 836   char *hostname;
 837
 838   *addrs = NULL;
 839   *addr_lens = NULL;
 840   if (GNUNET_CONFIGURATION_have_value (cfg,
 841                                        serviceName, "DISABLEV6"))
 842     {
 843       if (GNUNET_SYSERR ==
 844           (disablev6 = GNUNET_CONFIGURATION_get_value_yesno (cfg,
 845                                                              serviceName,
 846                                                              "DISABLEV6")))
 847         return GNUNET_SYSERR;
 848     }
 849   else
 850     disablev6 = GNUNET_NO;
 851
 852   if (!disablev6)
 853     {
 854       /* probe IPv6 support */
 855       desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0);
 856       if (NULL == desc)
 857         {
 858           if ((errno == ENOBUFS) ||
 859               (errno == ENOMEM) || (errno == ENFILE) || (errno == EACCES))
 860             {
 861               GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
 862               return GNUNET_SYSERR;
 863             }
 864           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 865                       _
 866                       ("Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"),
 867                       serviceName, STRERROR (errno));
 868           disablev6 = GNUNET_YES;
 869         }
 870       else
 871         {
 872           GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc));
 873         }
 874     }
 875
 876
 877   if ((GNUNET_OK !=
 878        GNUNET_CONFIGURATION_get_value_number (cfg,
 879                                               serviceName,
 880                                               "PORT",
 881                                               &port)) || (port > 65535))
 882     {
 883       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 884                   _
 885                   ("Require valid port number for service `%s' in configuration!\n"),
 886                   serviceName);
 887       return GNUNET_SYSERR;
 888     }
 889   if (GNUNET_CONFIGURATION_have_value (cfg,
 890                                        serviceName, "BINDTO"))
 891     {
 892       GNUNET_break (GNUNET_OK ==
 893                     GNUNET_CONFIGURATION_get_value_string (cfg,
 894                                                            serviceName,
 895                                                            "BINDTO",
 896                                                            &hostname));
 897     }
 898   else
 899     hostname = NULL;
 900
 901   if (hostname != NULL)
 902     {
 903 #if DEBUG_SERVICE
 904       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 905                   "Resolving `%s' since that is where `%s' will bind to.\n",
 906                   hostname,
 907                   serviceName);
 908 #endif
 909       memset (&hints, 0, sizeof (struct addrinfo));
 910       if (disablev6)
 911         hints.ai_family = AF_INET;
 912       if ((0 != (ret = getaddrinfo (hostname,
 913                                     NULL, &hints, &res))) || (res == NULL))
 914         {
 915           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 916                       _("Failed to resolve `%s': %s\n"),
 917                       hostname, gai_strerror (ret));
 918           GNUNET_free (hostname);
 919           return GNUNET_SYSERR;
 920         }
 921       next = res;
 922       i = 0;
 923       while (NULL != (pos = next))
 924         {
 925           next = pos->ai_next;
 926           if ( (disablev6) && (pos->ai_family == AF_INET6))
 927             continue;
 928           i++;
 929         }
 930       if (0 == i)
 931         {
 932           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 933                       _("Failed to find %saddress for `%s'.\n"),
 934                       disablev6 ? "IPv4 " : "", hostname);
 935           freeaddrinfo (res);
 936           GNUNET_free (hostname);
 937           return GNUNET_SYSERR;
 938         }
 939       resi = i;
 940       saddrs = GNUNET_malloc ((i+1) * sizeof(struct sockaddr*));
 941       saddrlens = GNUNET_malloc ((i+1) * sizeof (socklen_t));
 942       i = 0;
 943       next = res;
 944       while (NULL != (pos = next))
 945         {
 946           next = pos->ai_next;
 947           if ( (disablev6) && (pos->ai_family == AF_INET6))
 948             continue;
 949 #if DEBUG_SERVICE
 950           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 951                       "Service `%s' will bind to `%s'\n",
 952                       serviceName,
 953                       GNUNET_a2s (pos->ai_addr,
 954                                   pos->ai_addrlen));
 955 #endif
 956           if (pos->ai_family == AF_INET)
 957             {
 958               GNUNET_assert (pos->ai_addrlen == sizeof (struct sockaddr_in));
 959               saddrlens[i] = pos->ai_addrlen;
 960               saddrs[i] = GNUNET_malloc (saddrlens[i]);
 961               memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
 962               ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
 963             }
 964           else
 965             {
 966               GNUNET_assert (pos->ai_family == AF_INET6);
 967               GNUNET_assert (pos->ai_addrlen == sizeof (struct sockaddr_in6));
 968               saddrlens[i] = pos->ai_addrlen;
 969               saddrs[i] = GNUNET_malloc (saddrlens[i]);
 970               memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
 971               ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
 972             }
 973           i++;
 974         }
 975       GNUNET_free (hostname);
 976       freeaddrinfo (res);
 977     }
 978   else
 979     {
 980       /* will bind against everything, just set port */
 981       if (disablev6)
 982         {
 983           /* V4-only */
 984           resi = 1;
 985           saddrs = GNUNET_malloc (2 * sizeof(struct sockaddr*));
 986           saddrlens = GNUNET_malloc (2 * sizeof (socklen_t));
 987           saddrlens[0] = sizeof (struct sockaddr_in);
 988           saddrs[0] = GNUNET_malloc (saddrlens[0]);
 989 #if HAVE_SOCKADDR_IN_SIN_LEN
 990           ((struct sockaddr_in *) saddrs[0])->sin_len = saddrlens[0];
 991 #endif
 992           ((struct sockaddr_in *) saddrs[0])->sin_family = AF_INET;
 993           ((struct sockaddr_in *) saddrs[0])->sin_port = htons (port);
 994         }
 995       else
 996         {
 997           /* dual stack */
 998           resi = 2;
 999           saddrs = GNUNET_malloc (3 * sizeof(struct sockaddr*));
1000           saddrlens = GNUNET_malloc (3 * sizeof (socklen_t));
1001
1002           saddrlens[0] = sizeof (struct sockaddr_in6);
1003           saddrs[0] = GNUNET_malloc (saddrlens[0]);
1004 #if HAVE_SOCKADDR_IN_SIN_LEN
1005           ((struct sockaddr_in6 *) saddrs[0])->sin6_len = saddrlens[0];
1006 #endif
1007           ((struct sockaddr_in6 *) saddrs[0])->sin6_family = AF_INET6;
1008           ((struct sockaddr_in6 *) saddrs[0])->sin6_port = htons (port);
1009
1010           saddrlens[1] = sizeof (struct sockaddr_in);
1011           saddrs[1] = GNUNET_malloc (saddrlens[1]);
1012 #if HAVE_SOCKADDR_IN_SIN_LEN
1013           ((struct sockaddr_in *) saddrs[1])->sin_len = saddrlens[1];
1014 #endif
1015           ((struct sockaddr_in *) saddrs[1])->sin_family = AF_INET;
1016           ((struct sockaddr_in *) saddrs[1])->sin_port = htons (port);
1017
1018         }
1019     }
1020   *addrs = saddrs;
1021   *addr_lens = saddrlens;
1022   return resi;
1023 }
1024
1025
1026 /**
1027  * Setup addr, addrlen, maxbuf, idle_timeout
1028  * based on configuration!
1029  *
1030  * Configuration must specify a "PORT".  It may
1031  * specify:
1032  * - TIMEOUT (after how many ms does an inactive service timeout);
1033  * - MAXBUF (maximum incoming message size supported)
1034  * - DISABLEV6 (disable support for IPv6, otherwise we use dual-stack)
1035  * - ALLOW_SHUTDOWN (allow clients to shutdown this service)
1036  * - BINDTO (hostname or IP address to bind to, otherwise we take everything)
1037  * - ACCEPT_FROM  (only allow connections from specified IPv4 subnets)
1038  * - ACCEPT_FROM6 (only allow connections from specified IPv6 subnets)
1039  * - REJECT_FROM  (disallow allow connections from specified IPv4 subnets)
1040  * - REJECT_FROM6 (disallow allow connections from specified IPv6 subnets)
1041  *
1042  * @return GNUNET_OK if configuration succeeded
1043  */
1044 static int
1045 setup_service (struct GNUNET_SERVICE_Context *sctx)
1046 {
1047   unsigned long long maxbuf;
1048   struct GNUNET_TIME_Relative idleout;
1049   int tolerant;
1050
1051   if (GNUNET_CONFIGURATION_have_value (sctx->cfg,
1052                                        sctx->serviceName, "TIMEOUT"))
1053     {
1054       if (GNUNET_OK !=
1055           GNUNET_CONFIGURATION_get_value_time (sctx->cfg,
1056                                                sctx->serviceName,
1057                                                "TIMEOUT", &idleout))
1058         {
1059           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1060                       _("Specified value for `%s' of service `%s' is invalid\n"),
1061                       "TIMEOUT",
1062                       sctx->serviceName);
1063           return GNUNET_SYSERR;
1064         }
1065       sctx->timeout = idleout;
1066     }
1067   else
1068     sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
1069   if (GNUNET_CONFIGURATION_have_value (sctx->cfg,
1070                                        sctx->serviceName, "MAXBUF"))
1071     {
1072       if (GNUNET_OK !=
1073           GNUNET_CONFIGURATION_get_value_number (sctx->cfg,
1074                                                  sctx->serviceName,
1075                                                  "MAXBUF", &maxbuf))
1076         {
1077           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1078                       _("Specified value for `%s' of service `%s' is invalid\n"),
1079                       "MAXBUF",
1080                       sctx->serviceName);
1081           return GNUNET_SYSERR;
1082         }
1083     }
1084   else
1085     maxbuf = GNUNET_SERVER_MAX_MESSAGE_SIZE;
1086   if (GNUNET_CONFIGURATION_have_value (sctx->cfg,
1087                                        sctx->serviceName, "ALLOW_SHUTDOWN"))
1088     {
1089       if (GNUNET_SYSERR ==
1090           (sctx->allow_shutdown =
1091            GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg, sctx->serviceName,
1092                                                  "ALLOW_SHUTDOWN")))
1093         {
1094           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1095                       _("Specified value for `%s' of service `%s' is invalid\n"),
1096                       "ALLOW_SHUTDOWN",
1097                       sctx->serviceName);
1098           return GNUNET_SYSERR;
1099         }
1100     }
1101   else
1102     sctx->allow_shutdown = GNUNET_NO;
1103
1104
1105   if (GNUNET_CONFIGURATION_have_value (sctx->cfg,
1106                                        sctx->serviceName, "TOLERANT"))
1107     {
1108       if (GNUNET_SYSERR ==
1109           (tolerant = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg,
1110                                                             sctx->serviceName,
1111                                                             "TOLERANT")))
1112         {
1113           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1114                       _("Specified value for `%s' of service `%s' is invalid\n"),
1115                       "TOLERANT",
1116                       sctx->serviceName);
1117           return GNUNET_SYSERR;
1118         }
1119     }
1120   else
1121     tolerant = GNUNET_NO;
1122
1123   if (GNUNET_SYSERR ==
1124       GNUNET_SERVICE_get_server_addresses (sctx->serviceName,
1125                                            sctx->cfg,
1126                                            &sctx->addrs,
1127                                            &sctx->addrlens))
1128     return GNUNET_SYSERR;
1129   sctx->require_found = tolerant ? GNUNET_NO : GNUNET_YES;
1130   sctx->maxbuf = (size_t) maxbuf;
1131   if (sctx->maxbuf != maxbuf)
1132     {
1133       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1134                   _
1135                   ("Value in configuration for `%s' and service `%s' too large!\n"),
1136                   "MAXBUF", sctx->serviceName);
1137       return GNUNET_SYSERR;
1138     }
1139
1140   process_acl4 (&sctx->v4_denied, sctx, "REJECT_FROM");
1141   process_acl4 (&sctx->v4_allowed, sctx, "ACCEPT_FROM");
1142   process_acl6 (&sctx->v6_denied, sctx, "REJECT_FROM6");
1143   process_acl6 (&sctx->v6_allowed, sctx, "ACCEPT_FROM6");
1144
1145   return GNUNET_OK;
1146 }
1147
1148
1149 /**
1150  * Get the name of the user that'll be used
1151  * to provide the service.
1152  */
1153 static char *
1154 get_user_name (struct GNUNET_SERVICE_Context *sctx)
1155 {
1156
1157   char *un;
1158
1159   if (GNUNET_OK !=
1160       GNUNET_CONFIGURATION_get_value_filename (sctx->cfg,
1161                                                sctx->serviceName,
1162                                                "USERNAME", &un))
1163     return NULL;
1164   return un;
1165 }
1166
1167 /**
1168  * Write PID file.
1169  */
1170 static int
1171 write_pid_file (struct GNUNET_SERVICE_Context *sctx, pid_t pid)
1172 {
1173   FILE *pidfd;
1174   char *pif;
1175   char *user;
1176   char *rdir;
1177   int len;
1178
1179   if (NULL == (pif = get_pid_file_name (sctx)))
1180     return GNUNET_OK;           /* no file desired */
1181   user = get_user_name (sctx);
1182   rdir = GNUNET_strdup (pif);
1183   len = strlen (rdir);
1184   while ((len > 0) && (rdir[len] != DIR_SEPARATOR))
1185     len--;
1186   rdir[len] = '\0';
1187   if (0 != ACCESS (rdir, F_OK))
1188     {
1189       /* we get to create a directory -- and claim it
1190          as ours! */
1191       GNUNET_DISK_directory_create (rdir);
1192       if ((user != NULL) && (0 < strlen (user)))
1193         GNUNET_DISK_file_change_owner (rdir, user);
1194     }
1195   if (0 != ACCESS (rdir, W_OK | X_OK))
1196     {
1197       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "access", rdir);
1198       GNUNET_free (rdir);
1199       GNUNET_free_non_null (user);
1200       GNUNET_free (pif);
1201       return GNUNET_SYSERR;
1202     }
1203   GNUNET_free (rdir);
1204   pidfd = FOPEN (pif, "w");
1205   if (pidfd == NULL)
1206     {
1207       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "fopen", pif);
1208       GNUNET_free (pif);
1209       GNUNET_free_non_null (user);
1210       return GNUNET_SYSERR;
1211     }
1212   if (0 > FPRINTF (pidfd, "%u", pid))
1213     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "fprintf", pif);
1214   GNUNET_break (0 == fclose (pidfd));
1215   if ((user != NULL) && (0 < strlen (user)))
1216     GNUNET_DISK_file_change_owner (pif, user);
1217   GNUNET_free_non_null (user);
1218   GNUNET_free (pif);
1219   return GNUNET_OK;
1220 }
1221
1222
1223 /**
1224  * Task run during shutdown.
1225  *
1226  * @param cls unused
1227  * @param tc unused
1228  */
1229 static void
1230 shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1231 {
1232   struct GNUNET_SERVER_Handle *server = cls;
1233
1234   GNUNET_SERVER_destroy (server);
1235 }
1236
1237
1238 /**
1239  * Initial task for the service.
1240  */
1241 static void
1242 service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1243 {
1244   struct GNUNET_SERVICE_Context *sctx = cls;
1245   unsigned int i;
1246
1247   sctx->sched = tc->sched;
1248   sctx->server = GNUNET_SERVER_create (tc->sched,
1249                                        &check_access,
1250                                        sctx,
1251                                        sctx->addrs,
1252                                        sctx->addrlens,
1253                                        sctx->maxbuf,
1254                                        sctx->timeout, sctx->require_found);
1255   if (sctx->server == NULL)
1256     {
1257       i = 0;
1258       while (sctx->addrs[i] != NULL)
1259         {
1260           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1261                       _("Failed to start `%s' at `%s'\n"),
1262                       sctx->serviceName,
1263                       GNUNET_a2s (sctx->addrs[i], sctx->addrlens[i]));
1264           i++;
1265         }
1266       sctx->ret = GNUNET_SYSERR;
1267       return;
1268     }
1269   if (0 == (sctx->options & GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN))
1270     {
1271       /* install a task that will kill the server
1272          process if the scheduler ever gets a shutdown signal */
1273       GNUNET_SCHEDULER_add_delayed (tc->sched,
1274                                     GNUNET_TIME_UNIT_FOREVER_REL,
1275                                     &shutdown_task, sctx->server);
1276     }
1277   sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers));
1278   memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers));
1279   i = 0;
1280   while ((sctx->my_handlers[i].callback != NULL))
1281     sctx->my_handlers[i++].callback_cls = sctx;
1282   GNUNET_SERVER_add_handlers (sctx->server, sctx->my_handlers);
1283   if (sctx->ready_confirm_fd != -1)
1284     {
1285       GNUNET_break (1 == WRITE (sctx->ready_confirm_fd, ".", 1));
1286       GNUNET_break (0 == CLOSE (sctx->ready_confirm_fd));
1287       sctx->ready_confirm_fd = -1;
1288       write_pid_file (sctx, getpid ());
1289     }
1290   i = 0;
1291   while (sctx->addrs[i] != NULL)
1292     {
1293       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1294                   _("Service `%s' runs at %s\n"),
1295                   sctx->serviceName,
1296                   GNUNET_a2s (sctx->addrs[i], sctx->addrlens[i]));
1297       i++;
1298     }
1299   sctx->task (sctx->task_cls, tc->sched, sctx->server, sctx->cfg);
1300 }
1301
1302
1303 /**
1304  * Detach from terminal.
1305  */
1306 static int
1307 detach_terminal (struct GNUNET_SERVICE_Context *sctx)
1308 {
1309 #ifndef MINGW
1310   pid_t pid;
1311   int nullfd;
1312   int filedes[2];
1313
1314   if (0 != PIPE (filedes))
1315     {
1316       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "pipe");
1317       return GNUNET_SYSERR;
1318     }
1319   pid = fork ();
1320   if (pid < 0)
1321     {
1322       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
1323       return GNUNET_SYSERR;
1324     }
1325   if (pid != 0)
1326     {
1327       /* Parent */
1328       char c;
1329
1330       GNUNET_break (0 == CLOSE (filedes[1]));
1331       c = 'X';
1332       if (1 != READ (filedes[0], &c, sizeof (char)))
1333         GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "read");
1334       fflush (stdout);
1335       switch (c)
1336         {
1337         case '.':
1338           exit (0);
1339         case 'I':
1340           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1341                       _("Service process failed to initialize\n"));
1342           break;
1343         case 'S':
1344           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1345                       _
1346                       ("Service process could not initialize server function\n"));
1347           break;
1348         case 'X':
1349           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1350                       _("Service process failed to report status\n"));
1351           break;
1352         }
1353       exit (1);                 /* child reported error */
1354     }
1355   GNUNET_break (0 == CLOSE (0));
1356   GNUNET_break (0 == CLOSE (1));
1357   GNUNET_break (0 == CLOSE (filedes[0]));
1358   nullfd = OPEN ("/dev/null", O_RDWR | O_APPEND);
1359   if (nullfd < 0)
1360     return GNUNET_SYSERR;
1361   /* set stdin/stdout to /dev/null */
1362   if ((dup2 (nullfd, 0) < 0) || (dup2 (nullfd, 1) < 0))
1363     {
1364       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "dup2");
1365       return GNUNET_SYSERR;
1366     }
1367   /* Detach from controlling terminal */
1368   pid = setsid ();
1369   if (pid == -1)
1370     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "setsid");
1371   sctx->ready_confirm_fd = filedes[1];
1372 #else
1373   /* FIXME: we probably need to do something else
1374      elsewhere in order to fork the process itself... */
1375   FreeConsole ();
1376 #endif
1377   return GNUNET_OK;
1378 }
1379
1380
1381 /**
1382  * Set user ID.
1383  */
1384 static int
1385 set_user_id (struct GNUNET_SERVICE_Context *sctx)
1386 {
1387   char *user;
1388
1389   if (NULL == (user = get_user_name (sctx)))
1390     return GNUNET_OK;           /* keep */
1391 #ifndef MINGW
1392   struct passwd *pws;
1393
1394   errno = 0;
1395   pws = getpwnam (user);
1396   if (pws == NULL)
1397     {
1398       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1399                   _("Cannot obtain information about user `%s': %s\n"),
1400                   user, errno == 0 ? _("No such user") : STRERROR (errno));
1401       GNUNET_free (user);
1402       return GNUNET_SYSERR;
1403     }
1404   if ((0 != setgid (pws->pw_gid)) || (0 != setegid (pws->pw_gid)) ||
1405 #if HAVE_INITGROUPS
1406       (0 != initgroups (user, pws->pw_gid)) ||
1407 #endif
1408       (0 != setuid (pws->pw_uid)) || (0 != seteuid (pws->pw_uid)))
1409     {
1410       if ((0 != setregid (pws->pw_gid, pws->pw_gid)) ||
1411           (0 != setreuid (pws->pw_uid, pws->pw_uid)))
1412         {
1413           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1414                       _("Cannot change user/group to `%s': %s\n"), user,
1415                       STRERROR (errno));
1416           GNUNET_free (user);
1417           return GNUNET_SYSERR;
1418         }
1419     }
1420 #endif
1421   GNUNET_free (user);
1422   return GNUNET_OK;
1423 }
1424
1425
1426 /**
1427  * Delete the PID file that was created by our parent.
1428  */
1429 static void
1430 pid_file_delete (struct GNUNET_SERVICE_Context *sctx)
1431 {
1432   char *pif = get_pid_file_name (sctx);
1433   if (pif == NULL)
1434     return;                     /* no PID file */
1435   if (0 != UNLINK (pif))
1436     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", pif);
1437   GNUNET_free (pif);
1438 }
1439
1440
1441 /**
1442  * Run a standard GNUnet service startup sequence (initialize loggers
1443  * and configuration, parse options).
1444  *
1445  * @param argc number of command line arguments
1446  * @param argv command line arguments
1447  * @param serviceName our service name
1448  * @param opt service options
1449  * @param task main task of the service
1450  * @param task_cls closure for task
1451  * @return GNUNET_SYSERR on error, GNUNET_OK
1452  *         if we shutdown nicely
1453  */
1454 int
1455 GNUNET_SERVICE_run (int argc,
1456                     char *const *argv,
1457                     const char *serviceName,
1458                     enum GNUNET_SERVICE_Options opt,
1459                     GNUNET_SERVICE_Main task, void *task_cls)
1460 {
1461 #define HANDLE_ERROR do { err = 1; GNUNET_break (0); goto shutdown; } while (0)
1462
1463   int err;
1464   char *cfg_fn;
1465   char *loglev;
1466   char *logfile;
1467   int do_daemonize;
1468   unsigned int i;
1469   struct GNUNET_SERVICE_Context sctx;
1470   struct GNUNET_CONFIGURATION_Handle *cfg;
1471   struct GNUNET_GETOPT_CommandLineOption service_options[] = {
1472     GNUNET_GETOPT_OPTION_CFG_FILE (&cfg_fn),
1473     {'d', "daemonize", NULL,
1474      gettext_noop ("do daemonize (detach from terminal)"), 0,
1475      GNUNET_GETOPT_set_one, &do_daemonize},
1476     GNUNET_GETOPT_OPTION_HELP (serviceName),
1477     GNUNET_GETOPT_OPTION_LOGLEVEL (&loglev),
1478     GNUNET_GETOPT_OPTION_LOGFILE (&logfile),
1479     GNUNET_GETOPT_OPTION_VERSION (PACKAGE_VERSION),
1480     GNUNET_GETOPT_OPTION_END
1481   };
1482   err = 0;
1483   do_daemonize = 0;
1484   logfile = NULL;
1485   loglev = GNUNET_strdup ("WARNING");
1486   cfg_fn = GNUNET_strdup (GNUNET_DEFAULT_USER_CONFIG_FILE);
1487   memset (&sctx, 0, sizeof (sctx));
1488   sctx.options = opt;
1489   sctx.ready_confirm_fd = -1;
1490   sctx.ret = GNUNET_OK;
1491   sctx.timeout = GNUNET_TIME_UNIT_FOREVER_REL;
1492   sctx.maxbuf = GNUNET_SERVER_MAX_MESSAGE_SIZE;
1493   sctx.task = task;
1494   sctx.serviceName = serviceName;
1495   sctx.cfg = cfg = GNUNET_CONFIGURATION_create ();
1496   /* setup subsystems */
1497   if (GNUNET_SYSERR == GNUNET_GETOPT_run (serviceName, service_options, argc,
1498       argv))
1499     goto shutdown;
1500   if (GNUNET_OK != GNUNET_log_setup (serviceName, loglev, logfile))
1501     HANDLE_ERROR;
1502   if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg, cfg_fn))
1503     goto shutdown;
1504   if (GNUNET_OK != setup_service (&sctx))
1505     goto shutdown;
1506   if ( (do_daemonize == 1) && (GNUNET_OK != detach_terminal (&sctx)))
1507     HANDLE_ERROR;
1508   if (GNUNET_OK != set_user_id (&sctx))
1509     goto shutdown;
1510 #if DEBUG_SERVICE
1511   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1512               "Service `%s' runs with configuration from `%s'\n",
1513               serviceName, cfg_fn);
1514 #endif
1515   /* actually run service */
1516   GNUNET_SCHEDULER_run (&service_task, &sctx);
1517
1518   /* shutdown */
1519   if ((do_daemonize == 1) && (sctx.server != NULL))
1520     pid_file_delete (&sctx);
1521   GNUNET_free_non_null (sctx.my_handlers);
1522
1523 shutdown:
1524   if (sctx.ready_confirm_fd != -1)
1525     {
1526       if (1 != WRITE (sctx.ready_confirm_fd, err ? "I" : "S", 1))
1527         GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "write");
1528       GNUNET_break (0 == CLOSE (sctx.ready_confirm_fd));
1529     }
1530
1531   GNUNET_CONFIGURATION_destroy (cfg);
1532   i = 0;
1533   if (sctx.addrs != NULL)
1534     while (sctx.addrs[i] != NULL)
1535       GNUNET_free (sctx.addrs[i++]);
1536   GNUNET_free_non_null (sctx.addrs);
1537   GNUNET_free_non_null (sctx.addrlens);
1538   GNUNET_free_non_null (logfile);
1539   GNUNET_free (loglev);
1540   GNUNET_free (cfg_fn);
1541   GNUNET_free_non_null (sctx.v4_denied);
1542   GNUNET_free_non_null (sctx.v6_denied);
1543   GNUNET_free_non_null (sctx.v4_allowed);
1544   GNUNET_free_non_null (sctx.v6_allowed);
1545
1546   return err ? GNUNET_SYSERR : sctx.ret;
1547 }
1548
1549
1550 /**
1551  * Run a service startup sequence within an existing
1552  * initialized system.
1553  *
1554  * @param serviceName our service name
1555  * @param sched scheduler to use
1556  * @param cfg configuration to use
1557  * @return NULL on error, service handle
1558  */
1559 struct GNUNET_SERVICE_Context *
1560 GNUNET_SERVICE_start (const char *serviceName,
1561                       struct GNUNET_SCHEDULER_Handle *sched,
1562                       const struct GNUNET_CONFIGURATION_Handle *cfg)
1563 {
1564   int i;
1565   struct GNUNET_SERVICE_Context *sctx;
1566
1567   sctx = GNUNET_malloc (sizeof (struct GNUNET_SERVICE_Context));
1568   sctx->ready_confirm_fd = -1;  /* no daemonizing */
1569   sctx->ret = GNUNET_OK;
1570   sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
1571   sctx->maxbuf = GNUNET_SERVER_MAX_MESSAGE_SIZE;
1572   sctx->serviceName = serviceName;
1573   sctx->cfg = cfg;
1574   sctx->sched = sched;
1575
1576   /* setup subsystems */
1577   if ((GNUNET_OK != setup_service (sctx)) ||
1578       (NULL == (sctx->server = GNUNET_SERVER_create (sched,
1579                                                      &check_access,
1580                                                      sctx,
1581                                                      sctx->addrs,
1582                                                      sctx->addrlens,
1583                                                      sctx->maxbuf,
1584                                                      sctx->timeout,
1585                                                      sctx->require_found))))
1586     {
1587       GNUNET_SERVICE_stop (sctx);
1588       return NULL;
1589     }
1590   sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers));
1591   memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers));
1592   i = 0;
1593   while ((sctx->my_handlers[i].callback != NULL))
1594     sctx->my_handlers[i++].callback_cls = sctx;
1595   GNUNET_SERVER_add_handlers (sctx->server, sctx->my_handlers);
1596   return sctx;
1597 }
1598
1599 /**
1600  * Obtain the server used by a service.  Note that the server must NOT
1601  * be destroyed by the caller.
1602  *
1603  * @param ctx the service context returned from the start function
1604  * @return handle to the server for this service, NULL if there is none
1605  */
1606 struct GNUNET_SERVER_Handle *
1607 GNUNET_SERVICE_get_server (struct GNUNET_SERVICE_Context *ctx)
1608 {
1609   return ctx->server;
1610 }
1611
1612
1613 /**
1614  * Stop a service that was started with "GNUNET_SERVICE_start".
1615  *
1616  * @param sctx the service context returned from the start function
1617  */
1618 void
1619 GNUNET_SERVICE_stop (struct GNUNET_SERVICE_Context *sctx)
1620 {
1621   unsigned int i;
1622   if (NULL != sctx->server)
1623     GNUNET_SERVER_destroy (sctx->server);
1624   GNUNET_free_non_null (sctx->my_handlers);
1625   i = 0;
1626   while (sctx->addrs[i] != NULL)
1627     GNUNET_free (sctx->addrs[i++]);
1628   GNUNET_free_non_null (sctx->addrs);
1629   GNUNET_free_non_null (sctx->addrlens);
1630   GNUNET_free_non_null (sctx->v4_denied);
1631   GNUNET_free_non_null (sctx->v6_denied);
1632   GNUNET_free_non_null (sctx->v4_allowed);
1633   GNUNET_free_non_null (sctx->v6_allowed);
1634   GNUNET_free (sctx);
1635 }
1636
1637
1638 /* end of service.c */