src/rest/gnunet-rest-server.c

   1 /*
   2    This file is part of GNUnet.
   3    Copyright (C) 2012-2015 GNUnet e.V.
   4
   5    GNUnet is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published
   7    by the Free Software Foundation; either version 3, or (at your
   8    option) any later version.
   9
  10    GNUnet is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with GNUnet; see the file COPYING.  If not, write to the
  17    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18    Boston, MA 02110-1301, USA.
  19    */
  20 /**
  21  * @author Martin Schanzenbach
  22  * @file src/rest/gnunet-rest-server.c
  23  * @brief REST service for GNUnet services
  24  *
  25  */
  26 #include "platform.h"
  27 #include <microhttpd.h>
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_rest_plugin.h"
  30
  31
  32 /**
  33  * Default Socks5 listen port.
  34  */
  35 #define GNUNET_REST_SERVICE_PORT 7776
  36
  37 /**
  38  * Maximum supported length for a URI.
  39  * Should die. @deprecated
  40  */
  41 #define MAX_HTTP_URI_LENGTH 2048
  42
  43 /**
  44  * Port for plaintext HTTP.
  45  */
  46 #define HTTP_PORT 80
  47
  48 /**
  49  * Port for HTTPS.
  50  */
  51 #define HTTPS_PORT 443
  52
  53 /**
  54  * After how long do we clean up unused MHD SSL/TLS instances?
  55  */
  56 #define MHD_CACHE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
  57
  58 #define GN_REST_STATE_INIT 0
  59 #define GN_REST_STATE_PROCESSING 1
  60
  61 /**
  62  * The task ID
  63  */
  64 static struct GNUNET_SCHEDULER_Task *httpd_task;
  65
  66 /**
  67  * The port the service is running on (default 7776)
  68  */
  69 static unsigned long port = GNUNET_REST_SERVICE_PORT;
  70
  71 /**
  72  * The listen socket of the service for IPv4
  73  */
  74 static struct GNUNET_NETWORK_Handle *lsock4;
  75
  76 /**
  77  * The listen socket of the service for IPv6
  78  */
  79 static struct GNUNET_NETWORK_Handle *lsock6;
  80
  81 /**
  82  * The listen task ID for IPv4
  83  */
  84 static struct GNUNET_SCHEDULER_Task * ltask4;
  85
  86 /**
  87  * The listen task ID for IPv6
  88  */
  89 static struct GNUNET_SCHEDULER_Task * ltask6;
  90
  91 /**
  92  * Daemon for HTTP
  93  */
  94 static struct MHD_Daemon *httpd;
  95
  96 /**
  97  * Response we return on failures.
  98  */
  99 static struct MHD_Response *failure_response;
 100
 101 /**
 102  * Our configuration.
 103  */
 104 static const struct GNUNET_CONFIGURATION_Handle *cfg;
 105
 106 /**
 107  * Map of loaded plugins.
 108  */
 109 static struct GNUNET_CONTAINER_MultiHashMap *plugin_map;
 110
 111 /**
 112  * Allowed Origins (CORS)
 113  */
 114 static char* allow_origin;
 115
 116 /**
 117  * Allowed Headers (CORS)
 118  */
 119 static char* allow_headers;
 120
 121 /**
 122  * MHD Connection handle
 123  */
 124 struct MhdConnectionHandle
 125 {
 126   struct MHD_Connection *con;
 127
 128   struct MHD_Response *response;
 129
 130   struct GNUNET_REST_Plugin *plugin;
 131
 132   struct GNUNET_REST_RequestHandle *data_handle;
 133
 134   int status;
 135
 136   int state;
 137 };
 138
 139 /* ************************* Global helpers ********************* */
 140
 141
 142 /**
 143  * Task run whenever HTTP server operations are pending.
 144  *
 145  * @param cls NULL
 146  */
 147 static void
 148 do_httpd (void *cls);
 149
 150
 151 /**
 152  * Run MHD now, we have extra data ready for the callback.
 153  */
 154 static void
 155 run_mhd_now ()
 156 {
 157   if (NULL !=
 158       httpd_task)
 159     GNUNET_SCHEDULER_cancel (httpd_task);
 160   httpd_task = GNUNET_SCHEDULER_add_now (&do_httpd,
 161                                          NULL);
 162 }
 163
 164 /**
 165  * Plugin result callback
 166  *
 167  * @param cls closure (MHD connection handle)
 168  * @param data the data to return to the caller
 169  * @param len length of the data
 170  * @param status #GNUNET_OK if successful
 171  */
 172 static void
 173 plugin_callback (void *cls,
 174                  struct MHD_Response *resp,
 175                  int status)
 176 {
 177   struct MhdConnectionHandle *handle = cls;
 178   handle->status = status;
 179   handle->response = resp;
 180   run_mhd_now();
 181 }
 182
 183
 184 static int
 185 cleanup_url_map (void *cls,
 186                  const struct GNUNET_HashCode *key,
 187                  void *value)
 188 {
 189   GNUNET_free_non_null (value);
 190   return GNUNET_YES;
 191 }
 192
 193
 194 static void
 195 cleanup_handle (struct MhdConnectionHandle *handle)
 196 {
 197   if (NULL != handle->response)
 198     MHD_destroy_response (handle->response);
 199   if (NULL != handle->data_handle)
 200   {
 201     if (NULL != handle->data_handle->url_param_map)
 202     {
 203       GNUNET_CONTAINER_multihashmap_iterate (handle->data_handle->url_param_map,
 204                                              &cleanup_url_map,
 205                                              NULL);
 206       GNUNET_CONTAINER_multihashmap_destroy (handle->data_handle->url_param_map);
 207     }
 208     GNUNET_free (handle->data_handle);
 209   }
 210   GNUNET_free (handle);
 211 }
 212
 213
 214 static int
 215 url_iterator (void *cls,
 216               enum MHD_ValueKind kind,
 217               const char *key,
 218               const char *value)
 219 {
 220   struct GNUNET_REST_RequestHandle *handle = cls;
 221   struct GNUNET_HashCode hkey;
 222   char *val;
 223
 224   GNUNET_CRYPTO_hash (key, strlen (key), &hkey);
 225   GNUNET_asprintf (&val, "%s", value);
 226   if (GNUNET_OK !=
 227       GNUNET_CONTAINER_multihashmap_put (handle->url_param_map,
 228                                          &hkey,
 229                                          val,
 230                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
 231   {
 232     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 233                 "Could not load add url param `%s'=%s\n",
 234                 key, value);
 235   }
 236   return MHD_YES;
 237 }
 238
 239 /* ********************************* MHD response generation ******************* */
 240
 241 /**
 242  * Main MHD callback for handling requests.
 243  *
 244  * @param cls unused
 245  * @param con MHD connection handle
 246  * @param url the url in the request
 247  * @param meth the HTTP method used ("GET", "PUT", etc.)
 248  * @param ver the HTTP version string (i.e. "HTTP/1.1")
 249  * @param upload_data the data being uploaded (excluding HEADERS,
 250  *        for a POST that fits into memory and that is encoded
 251  *        with a supported encoding, the POST data will NOT be
 252  *        given in upload_data and is instead available as
 253  *        part of MHD_get_connection_values; very large POST
 254  *        data *will* be made available incrementally in
 255  *        upload_data)
 256  * @param upload_data_size set initially to the size of the
 257  *        @a upload_data provided; the method must update this
 258  *        value to the number of bytes NOT processed;
 259  * @param con_cls pointer to location where we store the 'struct Request'
 260  * @return MHD_YES if the connection was handled successfully,
 261  *         MHD_NO if the socket must be closed due to a serious
 262  *         error while handling the request
 263  */
 264 static int
 265 create_response (void *cls,
 266                  struct MHD_Connection *con,
 267                  const char *url,
 268                  const char *meth,
 269                  const char *ver,
 270                  const char *upload_data,
 271                  size_t *upload_data_size,
 272                  void **con_cls)
 273 {
 274   char *plugin_name;
 275   struct GNUNET_HashCode key;
 276   struct MhdConnectionHandle *con_handle;
 277   struct GNUNET_REST_RequestHandle *rest_conndata_handle;
 278
 279   con_handle = *con_cls;
 280
 281   if (NULL == *con_cls)
 282   {
 283     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 284                 "New connection %s\n", url);
 285     char tmp_url[strlen(url)+1];
 286     strcpy (tmp_url, url);
 287     con_handle = GNUNET_new (struct MhdConnectionHandle);
 288     con_handle->con = con;
 289     con_handle->state = GN_REST_STATE_INIT;
 290     *con_cls = con_handle;
 291
 292     plugin_name = strtok(tmp_url, "/");
 293
 294     if (NULL != plugin_name)
 295     {
 296       GNUNET_CRYPTO_hash (plugin_name, strlen (plugin_name), &key);
 297
 298       con_handle->plugin = GNUNET_CONTAINER_multihashmap_get (plugin_map,
 299                                                               &key);
 300     }
 301     if (NULL == con_handle->plugin)
 302     {
 303       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 304                   "Queueing response with MHD\n");
 305       GNUNET_free (con_handle);
 306       return MHD_queue_response (con,
 307                                  MHD_HTTP_NOT_FOUND,
 308                                  failure_response);
 309     }
 310     return MHD_YES;
 311   }
 312   if (GN_REST_STATE_INIT == con_handle->state)
 313   {
 314     rest_conndata_handle = GNUNET_new (struct GNUNET_REST_RequestHandle);
 315     rest_conndata_handle->method = meth;
 316     rest_conndata_handle->url = url;
 317     rest_conndata_handle->data = upload_data;
 318     rest_conndata_handle->data_size = *upload_data_size;
 319     rest_conndata_handle->url_param_map = GNUNET_CONTAINER_multihashmap_create (16,
 320                                                                                 GNUNET_NO);
 321     con_handle->data_handle = rest_conndata_handle;
 322     MHD_get_connection_values (con,
 323                                MHD_GET_ARGUMENT_KIND,
 324                                &url_iterator,
 325                                rest_conndata_handle);
 326     con_handle->state = GN_REST_STATE_PROCESSING;
 327     con_handle->plugin->process_request (rest_conndata_handle,
 328                                          &plugin_callback,
 329                                          con_handle);
 330     *upload_data_size = 0;
 331   }
 332   if (NULL != con_handle->response)
 333   {
 334     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 335                 "Queueing response from plugin with MHD\n");
 336     //Handle Preflights
 337     if (NULL != allow_origin)
 338     {
 339       MHD_add_response_header (con_handle->response,
 340                                MHD_HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
 341                                allow_origin);
 342     }
 343     if (NULL != allow_headers)
 344     {
 345       MHD_add_response_header (con_handle->response,
 346                                "Access-Control-Allow-Headers",
 347                                allow_headers);
 348     }
 349     int ret = MHD_queue_response (con,
 350                                   con_handle->status,
 351                                   con_handle->response);
 352     cleanup_handle (con_handle);
 353     return ret;
 354   }
 355   return MHD_YES;
 356 }
 357
 358
 359 /* ******************** MHD HTTP setup and event loop ******************** */
 360
 361 /**
 362  * Function called when MHD decides that we are done with a connection.
 363  *
 364  * @param cls NULL
 365  * @param connection connection handle
 366  * @param con_cls value as set by the last call to
 367  *        the MHD_AccessHandlerCallback, should be our handle
 368  * @param toe reason for request termination (ignored)
 369  */
 370 static void
 371 mhd_completed_cb (void *cls,
 372                   struct MHD_Connection *connection,
 373                   void **con_cls,
 374                   enum MHD_RequestTerminationCode toe)
 375 {
 376   if (MHD_REQUEST_TERMINATED_COMPLETED_OK != toe)
 377     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 378                 "MHD encountered error handling request: %d\n",
 379                 toe);
 380 }
 381
 382
 383 /**
 384  * Kill the MHD daemon.
 385  */
 386 static void
 387 kill_httpd ()
 388 {
 389   if (NULL != httpd)
 390   {
 391     MHD_stop_daemon (httpd);
 392     httpd = NULL;
 393   }
 394   if (NULL != httpd_task)
 395   {
 396     GNUNET_SCHEDULER_cancel (httpd_task);
 397     httpd_task = NULL;
 398   }
 399   if (NULL != ltask4)
 400   {
 401     GNUNET_SCHEDULER_cancel (ltask4);
 402     ltask4 = NULL;
 403   }
 404   if (NULL != ltask6)
 405   {
 406     GNUNET_SCHEDULER_cancel (ltask6);
 407     ltask6 = NULL;
 408   }
 409 }
 410
 411
 412 /**
 413  * Task run whenever HTTP server is idle for too long. Kill it.
 414  *
 415  * @param cls NULL
 416  */
 417 static void
 418 kill_httpd_task (void *cls)
 419 {
 420   httpd_task = NULL;
 421   kill_httpd ();
 422 }
 423
 424
 425 /**
 426  * Schedule MHD.  This function should be called initially when an
 427  * MHD is first getting its client socket, and will then automatically
 428  * always be called later whenever there is work to be done.
 429  *
 430  * @param hd the daemon to schedule
 431  */
 432 static void
 433 schedule_httpd ()
 434 {
 435   fd_set rs;
 436   fd_set ws;
 437   fd_set es;
 438   struct GNUNET_NETWORK_FDSet *wrs;
 439   struct GNUNET_NETWORK_FDSet *wws;
 440   int max;
 441   int haveto;
 442   MHD_UNSIGNED_LONG_LONG timeout;
 443   struct GNUNET_TIME_Relative tv;
 444
 445   FD_ZERO (&rs);
 446   FD_ZERO (&ws);
 447   FD_ZERO (&es);
 448   max = -1;
 449   if (MHD_YES != MHD_get_fdset (httpd, &rs, &ws, &es, &max))
 450   {
 451     kill_httpd ();
 452     return;
 453   }
 454   haveto = MHD_get_timeout (httpd, &timeout);
 455   if (MHD_YES == haveto)
 456     tv.rel_value_us = (uint64_t) timeout * 1000LL;
 457   else
 458     tv = GNUNET_TIME_UNIT_FOREVER_REL;
 459   if (-1 != max)
 460   {
 461     wrs = GNUNET_NETWORK_fdset_create ();
 462     wws = GNUNET_NETWORK_fdset_create ();
 463     GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1);
 464     GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
 465   }
 466   else
 467   {
 468     wrs = NULL;
 469     wws = NULL;
 470   }
 471   if (NULL != httpd_task)
 472     GNUNET_SCHEDULER_cancel (httpd_task);
 473   if ( (MHD_YES == haveto) ||
 474        (-1 != max))
 475   {
 476     httpd_task =
 477       GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
 478                                    tv, wrs, wws,
 479                                    &do_httpd, NULL);
 480   }
 481   if (NULL != wrs)
 482     GNUNET_NETWORK_fdset_destroy (wrs);
 483   if (NULL != wws)
 484     GNUNET_NETWORK_fdset_destroy (wws);
 485 }
 486
 487 /**
 488  * Task run whenever HTTP server operations are pending.
 489  *
 490  * @param cls NULL
 491  */
 492 static void
 493 do_httpd (void *cls)
 494 {
 495   httpd_task = NULL;
 496   MHD_run (httpd);
 497   schedule_httpd ();
 498 }
 499
 500
 501 /**
 502  * Accept new incoming connections
 503  *
 504  * @param cls the closure with the lsock4 or lsock6
 505  * @param tc the scheduler context
 506  */
 507 static void
 508 do_accept (void *cls)
 509 {
 510   struct GNUNET_NETWORK_Handle *lsock = cls;
 511   struct GNUNET_NETWORK_Handle *s;
 512   int fd;
 513   const struct sockaddr *addr;
 514   socklen_t len;
 515
 516   if (lsock == lsock4)
 517     ltask4 = NULL;
 518   else
 519     ltask6 = NULL;
 520   if (lsock == lsock4)
 521     ltask4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 522                                             lsock,
 523                                             &do_accept, lsock);
 524   else
 525     ltask6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 526                                             lsock,
 527                                             &do_accept, lsock);
 528   s = GNUNET_NETWORK_socket_accept (lsock, NULL, NULL);
 529   if (NULL == s)
 530   {
 531     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "accept");
 532     return;
 533   }
 534   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 535               "Got an inbound connection, waiting for data\n");
 536   fd = GNUNET_NETWORK_get_fd (s);
 537   addr = GNUNET_NETWORK_get_addr (s);
 538   len = GNUNET_NETWORK_get_addrlen (s);
 539   if (MHD_YES != MHD_add_connection (httpd, fd, addr, len))
 540   {
 541     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 542                 _("Failed to pass client to MHD\n"));
 543     return;
 544   }
 545
 546   schedule_httpd ();
 547 }
 548
 549
 550 /**
 551  * Task run on shutdown
 552  *
 553  * @param cls closure
 554  */
 555 static void
 556 do_shutdown (void *cls)
 557 {
 558   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 559               "Shutting down...\n");
 560   kill_httpd ();
 561   GNUNET_free_non_null (allow_origin);
 562   GNUNET_free_non_null (allow_headers);
 563 }
 564
 565
 566 /**
 567  * Create an IPv4 listen socket bound to our port.
 568  *
 569  * @return NULL on error
 570  */
 571 static struct GNUNET_NETWORK_Handle *
 572 bind_v4 ()
 573 {
 574   struct GNUNET_NETWORK_Handle *ls;
 575   struct sockaddr_in sa4;
 576   int eno;
 577
 578   memset (&sa4, 0, sizeof (sa4));
 579   sa4.sin_family = AF_INET;
 580   sa4.sin_port = htons (port);
 581 #if HAVE_SOCKADDR_IN_SIN_LEN
 582   sa4.sin_len = sizeof (sa4);
 583 #endif
 584   ls = GNUNET_NETWORK_socket_create (AF_INET,
 585                                      SOCK_STREAM,
 586                                      0);
 587   if (NULL == ls)
 588     return NULL;
 589   if (GNUNET_OK !=
 590       GNUNET_NETWORK_socket_bind (ls, (const struct sockaddr *) &sa4,
 591                                   sizeof (sa4)))
 592   {
 593     eno = errno;
 594     GNUNET_NETWORK_socket_close (ls);
 595     errno = eno;
 596     return NULL;
 597   }
 598   return ls;
 599 }
 600
 601
 602 /**
 603  * Create an IPv6 listen socket bound to our port.
 604  *
 605  * @return NULL on error
 606  */
 607 static struct GNUNET_NETWORK_Handle *
 608 bind_v6 ()
 609 {
 610   struct GNUNET_NETWORK_Handle *ls;
 611   struct sockaddr_in6 sa6;
 612   int eno;
 613
 614   memset (&sa6, 0, sizeof (sa6));
 615   sa6.sin6_family = AF_INET6;
 616   sa6.sin6_port = htons (port);
 617 #if HAVE_SOCKADDR_IN_SIN_LEN
 618   sa6.sin6_len = sizeof (sa6);
 619 #endif
 620   ls = GNUNET_NETWORK_socket_create (AF_INET6,
 621                                      SOCK_STREAM,
 622                                      0);
 623   if (NULL == ls)
 624     return NULL;
 625   if (GNUNET_OK !=
 626       GNUNET_NETWORK_socket_bind (ls, (const struct sockaddr *) &sa6,
 627                                   sizeof (sa6)))
 628   {
 629     eno = errno;
 630     GNUNET_NETWORK_socket_close (ls);
 631     errno = eno;
 632     return NULL;
 633   }
 634   return ls;
 635 }
 636
 637
 638 /**
 639  * Callback for plugin load
 640  *
 641  * @param cls NULL
 642  * @param libname the name of the library loaded
 643  * @param lib_ret the object returned by the plugin initializer
 644  */
 645 static void
 646 load_plugin (void *cls,
 647              const char *libname,
 648              void *lib_ret)
 649 {
 650   struct GNUNET_REST_Plugin *plugin = lib_ret;
 651   struct GNUNET_HashCode key;
 652   if (NULL == lib_ret)
 653   {
 654     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 655                 "Could not load plugin `%s'\n",
 656                 libname);
 657     return;
 658   }
 659   GNUNET_assert (1 < strlen (plugin->name));
 660   GNUNET_assert ('/' == *plugin->name);
 661   GNUNET_CRYPTO_hash (plugin->name+1, strlen (plugin->name+1), &key);
 662   if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (plugin_map,
 663                                                       &key,
 664                                                       plugin,
 665                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
 666   {
 667     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 668                 "Could not load add plugin `%s'\n",
 669                 libname);
 670     return;
 671   }
 672   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 673               "Loaded plugin `%s'\n",
 674               libname);
 675 }
 676
 677
 678 /**
 679  * Main function that will be run
 680  *
 681  * @param cls closure
 682  * @param args remaining command-line arguments
 683  * @param cfgfile name of the configuration file used (for saving, can be NULL)
 684  * @param c configuration
 685  */
 686 static void
 687 run (void *cls,
 688      char *const *args,
 689      const char *cfgfile,
 690      const struct GNUNET_CONFIGURATION_Handle *c)
 691 {
 692   cfg = c;
 693   plugin_map = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
 694
 695   /* Get CORS data from cfg */
 696   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "rest",
 697                                                           "REST_ALLOW_ORIGIN",
 698                                                           &allow_origin))
 699   {
 700     //No origin specified
 701     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 702                 "No CORS Access-Control-Allow-Origin Header will be sent...\n");
 703   }
 704
 705   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "rest",
 706                                                           "REST_ALLOW_HEADERS",
 707                                                           &allow_headers))
 708   {
 709     //No origin specified
 710     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 711                 "No CORS Access-Control-Allow-Headers Header will be sent...\n");
 712   }
 713
 714   /* Open listen socket proxy */
 715   lsock6 = bind_v6 ();
 716   if (NULL == lsock6)
 717   {
 718     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
 719   }
 720   else
 721   {
 722     if (GNUNET_OK != GNUNET_NETWORK_socket_listen (lsock6, 5))
 723     {
 724       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "listen");
 725       GNUNET_NETWORK_socket_close (lsock6);
 726       lsock6 = NULL;
 727     }
 728     else
 729     {
 730       ltask6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 731                                               lsock6, &do_accept, lsock6);
 732     }
 733   }
 734   lsock4 = bind_v4 ();
 735   if (NULL == lsock4)
 736   {
 737     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
 738   }
 739   else
 740   {
 741     if (GNUNET_OK != GNUNET_NETWORK_socket_listen (lsock4, 5))
 742     {
 743       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "listen");
 744       GNUNET_NETWORK_socket_close (lsock4);
 745       lsock4 = NULL;
 746     }
 747     else
 748     {
 749       ltask4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 750                                               lsock4, &do_accept, lsock4);
 751     }
 752   }
 753   if ( (NULL == lsock4) &&
 754        (NULL == lsock6) )
 755   {
 756     GNUNET_SCHEDULER_shutdown ();
 757     return;
 758   }
 759   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 760               "Service listens on port %lu\n",
 761               port);
 762   httpd = MHD_start_daemon (MHD_USE_DEBUG | MHD_USE_NO_LISTEN_SOCKET,
 763                             0,
 764                             NULL, NULL,
 765                             &create_response, NULL,
 766                             MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
 767                             MHD_OPTION_NOTIFY_COMPLETED, &mhd_completed_cb, NULL,
 768                             MHD_OPTION_END);
 769   if (NULL == httpd)
 770   {
 771     GNUNET_SCHEDULER_shutdown ();
 772     return;
 773   }
 774   /* Load plugins */
 775   GNUNET_PLUGIN_load_all ("libgnunet_plugin_rest",
 776                           (void *) cfg,
 777                           &load_plugin,
 778                           NULL);
 779   GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
 780 }
 781
 782
 783 /**
 784  *
 785  * The main function for gnunet-rest-service
 786  *
 787  * @param argc number of arguments from the cli
 788  * @param argv command line arguments
 789  * @return 0 ok, 1 on error
 790  *
 791  */
 792 int
 793 main (int argc, char *const *argv)
 794 {
 795   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 796     {'p', "port", NULL,
 797       gettext_noop ("listen on specified port (default: 7776)"), 1,
 798       &GNUNET_GETOPT_set_ulong, &port},
 799     GNUNET_GETOPT_OPTION_END
 800   };
 801   static const char* err_page =
 802     "{}";
 803   int ret;
 804
 805   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
 806     return 2;
 807   GNUNET_log_setup ("gnunet-rest-server", "WARNING", NULL);
 808   failure_response = MHD_create_response_from_buffer (strlen(err_page),
 809                                                       (void*)err_page,
 810                                                       MHD_RESPMEM_PERSISTENT);
 811   ret =
 812     (GNUNET_OK ==
 813      GNUNET_PROGRAM_run (argc, argv, "gnunet-rest-server",
 814                          _("GNUnet REST server"),
 815                          options,
 816                          &run, NULL)) ? 0: 1;
 817   MHD_destroy_response (failure_response);
 818   GNUNET_free_non_null ((char *) argv);
 819   return ret;
 820 }
 821
 822 /* end of gnunet-rest-server.c */