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 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   struct MHD_PostProcessor *pp;
 135
 136   int status;
 137
 138   int state;
 139 };
 140
 141 /* ************************* Global helpers ********************* */
 142
 143
 144 /**
 145  * Task run whenever HTTP server operations are pending.
 146  *
 147  * @param cls NULL
 148  */
 149 static void
 150 do_httpd (void *cls);
 151
 152
 153 /**
 154  * Run MHD now, we have extra data ready for the callback.
 155  */
 156 static void
 157 run_mhd_now ()
 158 {
 159   if (NULL != httpd_task)
 160   {
 161     GNUNET_SCHEDULER_cancel (httpd_task);
 162     httpd_task = NULL;
 163   }
 164   httpd_task = GNUNET_SCHEDULER_add_now (&do_httpd,
 165                                          NULL);
 166
 167 }
 168
 169 /**
 170  * Plugin result callback
 171  *
 172  * @param cls closure (MHD connection handle)
 173  * @param data the data to return to the caller
 174  * @param len length of the data
 175  * @param status #GNUNET_OK if successful
 176  */
 177 static void
 178 plugin_callback (void *cls,
 179                  struct MHD_Response *resp,
 180                  int status)
 181 {
 182   struct MhdConnectionHandle *handle = cls;
 183   handle->status = status;
 184   handle->response = resp;
 185   run_mhd_now();
 186 }
 187
 188
 189 static int
 190 cleanup_url_map (void *cls,
 191                  const struct GNUNET_HashCode *key,
 192                  void *value)
 193 {
 194   GNUNET_free_non_null (value);
 195   return GNUNET_YES;
 196 }
 197
 198
 199 static void
 200 cleanup_handle (struct MhdConnectionHandle *handle)
 201 {
 202   if (NULL != handle->response)
 203     MHD_destroy_response (handle->response);
 204   if (NULL != handle->data_handle)
 205   {
 206
 207     if (NULL != handle->data_handle->header_param_map)
 208     {
 209       GNUNET_CONTAINER_multihashmap_iterate (handle->data_handle->header_param_map,
 210                                              &cleanup_url_map,
 211                                              NULL);
 212       GNUNET_CONTAINER_multihashmap_destroy (handle->data_handle->header_param_map);
 213     }
 214     if (NULL != handle->data_handle->url_param_map)
 215     {
 216       GNUNET_CONTAINER_multihashmap_iterate (handle->data_handle->url_param_map,
 217                                              &cleanup_url_map,
 218                                              NULL);
 219       GNUNET_CONTAINER_multihashmap_destroy (handle->data_handle->url_param_map);
 220     }
 221     GNUNET_free (handle->data_handle);
 222   }
 223   GNUNET_free (handle);
 224 }
 225
 226 static int
 227 header_iterator (void *cls,
 228               enum MHD_ValueKind kind,
 229               const char *key,
 230               const char *value)
 231 {
 232   struct GNUNET_REST_RequestHandle *handle = cls;
 233   struct GNUNET_HashCode hkey;
 234   char *val;
 235
 236   GNUNET_CRYPTO_hash (key, strlen (key), &hkey);
 237   GNUNET_asprintf (&val, "%s", value);
 238   if (GNUNET_OK !=
 239       GNUNET_CONTAINER_multihashmap_put (handle->header_param_map,
 240                                          &hkey,
 241                                          val,
 242                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
 243   {
 244     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 245                 "Could not load add header `%s'=%s\n",
 246                 key, value);
 247   }
 248   return MHD_YES;
 249 }
 250
 251
 252 static int
 253 url_iterator (void *cls,
 254               enum MHD_ValueKind kind,
 255               const char *key,
 256               const char *value)
 257 {
 258   struct GNUNET_REST_RequestHandle *handle = cls;
 259   struct GNUNET_HashCode hkey;
 260   char *val;
 261
 262   GNUNET_CRYPTO_hash (key, strlen (key), &hkey);
 263   GNUNET_asprintf (&val, "%s", value);
 264   if (GNUNET_OK !=
 265       GNUNET_CONTAINER_multihashmap_put (handle->url_param_map,
 266                                          &hkey,
 267                                          val,
 268                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
 269   {
 270     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 271                 "Could not load add url param `%s'=%s\n",
 272                 key, value);
 273   }
 274   return MHD_YES;
 275 }
 276
 277 static int
 278 post_data_iter (void *cls,
 279                          enum MHD_ValueKind kind,
 280                          const char *key,
 281                          const char *filename,
 282                          const char *content_type,
 283                          const char *transfer_encoding,
 284                          const char *data,
 285                          uint64_t off,
 286                          size_t size)
 287 {
 288   struct GNUNET_REST_RequestHandle *handle = cls;
 289   struct GNUNET_HashCode hkey;
 290   char *val;
 291
 292   if (MHD_POSTDATA_KIND != kind)
 293     return MHD_YES;
 294
 295   GNUNET_CRYPTO_hash (key, strlen (key), &hkey);
 296   GNUNET_asprintf (&val, "%s", data);
 297   if (GNUNET_OK !=
 298       GNUNET_CONTAINER_multihashmap_put (handle->url_param_map,
 299                                          &hkey,
 300                                          val,
 301                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
 302   {
 303     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 304                 "Could not load add url param `%s'=%s\n",
 305                 key, data);
 306   }
 307   return MHD_YES;
 308
 309 }
 310
 311 /* ********************************* MHD response generation ******************* */
 312
 313 /**
 314  * Main MHD callback for handling requests.
 315  *
 316  * @param cls unused
 317  * @param con MHD connection handle
 318  * @param url the url in the request
 319  * @param meth the HTTP method used ("GET", "PUT", etc.)
 320  * @param ver the HTTP version string (i.e. "HTTP/1.1")
 321  * @param upload_data the data being uploaded (excluding HEADERS,
 322  *        for a POST that fits into memory and that is encoded
 323  *        with a supported encoding, the POST data will NOT be
 324  *        given in upload_data and is instead available as
 325  *        part of MHD_get_connection_values; very large POST
 326  *        data *will* be made available incrementally in
 327  *        upload_data)
 328  * @param upload_data_size set initially to the size of the
 329  *        @a upload_data provided; the method must update this
 330  *        value to the number of bytes NOT processed;
 331  * @param con_cls pointer to location where we store the 'struct Request'
 332  * @return MHD_YES if the connection was handled successfully,
 333  *         MHD_NO if the socket must be closed due to a serious
 334  *         error while handling the request
 335  */
 336 static int
 337 create_response (void *cls,
 338                  struct MHD_Connection *con,
 339                  const char *url,
 340                  const char *meth,
 341                  const char *ver,
 342                  const char *upload_data,
 343                  size_t *upload_data_size,
 344                  void **con_cls)
 345 {
 346   char *plugin_name;
 347   struct GNUNET_HashCode key;
 348   struct MhdConnectionHandle *con_handle;
 349   struct GNUNET_REST_RequestHandle *rest_conndata_handle;
 350
 351   con_handle = *con_cls;
 352
 353   if (NULL == *con_cls)
 354   {
 355     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 356                 "New connection %s\n", url);
 357     char tmp_url[strlen(url)+1];
 358     strcpy (tmp_url, url);
 359     con_handle = GNUNET_new (struct MhdConnectionHandle);
 360     con_handle->con = con;
 361     con_handle->state = GN_REST_STATE_INIT;
 362     *con_cls = con_handle;
 363
 364     plugin_name = strtok(tmp_url, "/");
 365
 366     if (NULL != plugin_name)
 367     {
 368       GNUNET_CRYPTO_hash (plugin_name, strlen (plugin_name), &key);
 369
 370       con_handle->plugin = GNUNET_CONTAINER_multihashmap_get (plugin_map,
 371                                                               &key);
 372     }
 373     if (NULL == con_handle->plugin)
 374     {
 375       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 376                   "Queueing response with MHD\n");
 377       GNUNET_free (con_handle);
 378       return MHD_queue_response (con,
 379                                  MHD_HTTP_NOT_FOUND,
 380                                  failure_response);
 381     }
 382
 383     return MHD_YES;
 384   }
 385   if (GN_REST_STATE_INIT == con_handle->state)
 386   {
 387     rest_conndata_handle = GNUNET_new (struct GNUNET_REST_RequestHandle);
 388     rest_conndata_handle->method = meth;
 389     rest_conndata_handle->url = url;
 390     rest_conndata_handle->data = upload_data;
 391     rest_conndata_handle->data_size = *upload_data_size;
 392     rest_conndata_handle->url_param_map = GNUNET_CONTAINER_multihashmap_create (16,
 393                                                                                 GNUNET_NO);
 394     rest_conndata_handle->header_param_map = GNUNET_CONTAINER_multihashmap_create (16,
 395                                                                                    GNUNET_NO);
 396     con_handle->data_handle = rest_conndata_handle;
 397     MHD_get_connection_values (con,
 398                                MHD_GET_ARGUMENT_KIND,
 399                                &url_iterator,
 400                                rest_conndata_handle);
 401     con_handle->pp = MHD_create_post_processor(con,
 402                                                4000,
 403                                                post_data_iter,
 404                                                rest_conndata_handle);
 405     if (*upload_data_size)
 406     {
 407       MHD_post_process(con_handle->pp, upload_data, *upload_data_size);
 408     }
 409     else
 410     {
 411       MHD_destroy_post_processor(con_handle->pp);
 412     }
 413     MHD_get_connection_values (con,
 414                                MHD_HEADER_KIND,
 415                                &header_iterator,
 416                                rest_conndata_handle);
 417     con_handle->state = GN_REST_STATE_PROCESSING;
 418     con_handle->plugin->process_request (rest_conndata_handle,
 419                                          &plugin_callback,
 420                                          con_handle);
 421     *upload_data_size = 0;
 422   }
 423   if (NULL != con_handle->response)
 424   {
 425     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 426                 "Queueing response from plugin with MHD\n");
 427     //Handle Preflights
 428     if (NULL != allow_origin)
 429     {
 430       MHD_add_response_header (con_handle->response,
 431                                MHD_HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
 432                                allow_origin);
 433     }
 434     if (NULL != allow_headers)
 435     {
 436       MHD_add_response_header (con_handle->response,
 437                                "Access-Control-Allow-Headers",
 438                                allow_headers);
 439     }
 440     //Always add JSONAPI content type. TODO
 441     MHD_add_response_header (con_handle->response,
 442                              MHD_HTTP_HEADER_CONTENT_TYPE,
 443                              "application/vnd.api+json");
 444     int ret = MHD_queue_response (con,
 445                                   con_handle->status,
 446                                   con_handle->response);
 447     cleanup_handle (con_handle);
 448     return ret;
 449   }
 450   return MHD_YES;
 451 }
 452
 453
 454 /* ******************** MHD HTTP setup and event loop ******************** */
 455
 456 /**
 457  * Function called when MHD decides that we are done with a connection.
 458  *
 459  * @param cls NULL
 460  * @param connection connection handle
 461  * @param con_cls value as set by the last call to
 462  *        the MHD_AccessHandlerCallback, should be our handle
 463  * @param toe reason for request termination (ignored)
 464  */
 465 static void
 466 mhd_completed_cb (void *cls,
 467                   struct MHD_Connection *connection,
 468                   void **con_cls,
 469                   enum MHD_RequestTerminationCode toe)
 470 {
 471   if (MHD_REQUEST_TERMINATED_COMPLETED_OK != toe)
 472     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 473                 "MHD encountered error handling request: %d\n",
 474                 toe);
 475 }
 476
 477
 478 /**
 479  * Kill the MHD daemon.
 480  */
 481 static void
 482 kill_httpd ()
 483 {
 484   if (NULL != httpd)
 485   {
 486     MHD_stop_daemon (httpd);
 487     httpd = NULL;
 488   }
 489   if (NULL != httpd_task)
 490   {
 491     GNUNET_SCHEDULER_cancel (httpd_task);
 492     httpd_task = NULL;
 493   }
 494   if (NULL != ltask4)
 495   {
 496     GNUNET_SCHEDULER_cancel (ltask4);
 497     ltask4 = NULL;
 498   }
 499   if (NULL != ltask6)
 500   {
 501     GNUNET_SCHEDULER_cancel (ltask6);
 502     ltask6 = NULL;
 503   }
 504
 505   if (NULL != lsock4)
 506   {
 507     GNUNET_NETWORK_socket_close (lsock4);
 508     lsock4 = NULL;
 509   }
 510   if (NULL != lsock6)
 511   {
 512     GNUNET_NETWORK_socket_close (lsock6);
 513     lsock6 = NULL;
 514   }
 515   }
 516
 517
 518 /**
 519  * Schedule MHD.  This function should be called initially when an
 520  * MHD is first getting its client socket, and will then automatically
 521  * always be called later whenever there is work to be done.
 522  *
 523  * @param hd the daemon to schedule
 524  */
 525 static void
 526 schedule_httpd ()
 527 {
 528   fd_set rs;
 529   fd_set ws;
 530   fd_set es;
 531   struct GNUNET_NETWORK_FDSet *wrs;
 532   struct GNUNET_NETWORK_FDSet *wws;
 533   int max;
 534   int haveto;
 535   MHD_UNSIGNED_LONG_LONG timeout;
 536   struct GNUNET_TIME_Relative tv;
 537
 538   FD_ZERO (&rs);
 539   FD_ZERO (&ws);
 540   FD_ZERO (&es);
 541   max = -1;
 542   if (MHD_YES != MHD_get_fdset (httpd, &rs, &ws, &es, &max))
 543   {
 544     kill_httpd ();
 545     return;
 546   }
 547   haveto = MHD_get_timeout (httpd, &timeout);
 548   if (MHD_YES == haveto)
 549     tv.rel_value_us = (uint64_t) timeout * 1000LL;
 550   else
 551     tv = GNUNET_TIME_UNIT_FOREVER_REL;
 552   if (-1 != max)
 553   {
 554     wrs = GNUNET_NETWORK_fdset_create ();
 555     wws = GNUNET_NETWORK_fdset_create ();
 556     GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1);
 557     GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
 558   }
 559   else
 560   {
 561     wrs = NULL;
 562     wws = NULL;
 563   }
 564   if (NULL != httpd_task)
 565   {
 566     GNUNET_SCHEDULER_cancel (httpd_task);
 567     httpd_task = NULL;
 568   }
 569   if ( (MHD_YES == haveto) ||
 570        (-1 != max))
 571   {
 572     httpd_task =
 573       GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
 574                                    tv, wrs, wws,
 575                                    &do_httpd, NULL);
 576
 577   }
 578   if (NULL != wrs)
 579     GNUNET_NETWORK_fdset_destroy (wrs);
 580   if (NULL != wws)
 581     GNUNET_NETWORK_fdset_destroy (wws);
 582 }
 583
 584 /**
 585  * Task run whenever HTTP server operations are pending.
 586  *
 587  * @param cls NULL
 588  */
 589 static void
 590 do_httpd (void *cls)
 591 {
 592   httpd_task = NULL;
 593   MHD_run (httpd);
 594   schedule_httpd ();
 595 }
 596
 597
 598 /**
 599  * Accept new incoming connections
 600  *
 601  * @param cls the closure with the lsock4 or lsock6
 602  * @param tc the scheduler context
 603  */
 604 static void
 605 do_accept (void *cls)
 606 {
 607   struct GNUNET_NETWORK_Handle *lsock = cls;
 608   struct GNUNET_NETWORK_Handle *s;
 609   int fd;
 610   const struct sockaddr *addr;
 611   socklen_t len;
 612
 613   GNUNET_assert (NULL != lsock);
 614   if (lsock == lsock4)
 615   {
 616     ltask4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 617                                             lsock,
 618                                             &do_accept, lsock);
 619
 620   }
 621   else if (lsock == lsock6)
 622   {
 623     ltask6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 624                                             lsock,
 625                                             &do_accept, lsock);
 626
 627   }
 628   else
 629     GNUNET_assert (0);
 630   s = GNUNET_NETWORK_socket_accept (lsock, NULL, NULL);
 631   if (NULL == s)
 632   {
 633     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "accept");
 634     return;
 635   }
 636   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 637               "Got an inbound connection, waiting for data\n");
 638   fd = GNUNET_NETWORK_get_fd (s);
 639   addr = GNUNET_NETWORK_get_addr (s);
 640   len = GNUNET_NETWORK_get_addrlen (s);
 641   if (MHD_YES != MHD_add_connection (httpd, fd, addr, len))
 642   {
 643     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 644                 _("Failed to pass client to MHD\n"));
 645     return;
 646   }
 647
 648   schedule_httpd ();
 649 }
 650
 651
 652 /**
 653  * Task run on shutdown
 654  *
 655  * @param cls closure
 656  */
 657 static void
 658 do_shutdown (void *cls)
 659 {
 660   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 661               "Shutting down...\n");
 662   kill_httpd ();
 663   GNUNET_free_non_null (allow_origin);
 664   GNUNET_free_non_null (allow_headers);
 665 }
 666
 667
 668 /**
 669  * Create an IPv4 listen socket bound to our port.
 670  *
 671  * @return NULL on error
 672  */
 673 static struct GNUNET_NETWORK_Handle *
 674 bind_v4 ()
 675 {
 676   struct GNUNET_NETWORK_Handle *ls;
 677   struct sockaddr_in sa4;
 678   int eno;
 679
 680   memset (&sa4, 0, sizeof (sa4));
 681   sa4.sin_family = AF_INET;
 682   sa4.sin_port = htons (port);
 683 #if HAVE_SOCKADDR_IN_SIN_LEN
 684   sa4.sin_len = sizeof (sa4);
 685 #endif
 686   ls = GNUNET_NETWORK_socket_create (AF_INET,
 687                                      SOCK_STREAM,
 688                                      0);
 689   if (NULL == ls)
 690     return NULL;
 691   if (GNUNET_OK !=
 692       GNUNET_NETWORK_socket_bind (ls, (const struct sockaddr *) &sa4,
 693                                   sizeof (sa4)))
 694   {
 695     eno = errno;
 696     GNUNET_NETWORK_socket_close (ls);
 697     errno = eno;
 698     return NULL;
 699   }
 700   return ls;
 701 }
 702
 703
 704 /**
 705  * Create an IPv6 listen socket bound to our port.
 706  *
 707  * @return NULL on error
 708  */
 709 static struct GNUNET_NETWORK_Handle *
 710 bind_v6 ()
 711 {
 712   struct GNUNET_NETWORK_Handle *ls;
 713   struct sockaddr_in6 sa6;
 714   int eno;
 715
 716   memset (&sa6, 0, sizeof (sa6));
 717   sa6.sin6_family = AF_INET6;
 718   sa6.sin6_port = htons (port);
 719 #if HAVE_SOCKADDR_IN_SIN_LEN
 720   sa6.sin6_len = sizeof (sa6);
 721 #endif
 722   ls = GNUNET_NETWORK_socket_create (AF_INET6,
 723                                      SOCK_STREAM,
 724                                      0);
 725   if (NULL == ls)
 726     return NULL;
 727   if (GNUNET_OK !=
 728       GNUNET_NETWORK_socket_bind (ls, (const struct sockaddr *) &sa6,
 729                                   sizeof (sa6)))
 730   {
 731     eno = errno;
 732     GNUNET_NETWORK_socket_close (ls);
 733     errno = eno;
 734     return NULL;
 735   }
 736   return ls;
 737 }
 738
 739
 740 /**
 741  * Callback for plugin load
 742  *
 743  * @param cls NULL
 744  * @param libname the name of the library loaded
 745  * @param lib_ret the object returned by the plugin initializer
 746  */
 747 static void
 748 load_plugin (void *cls,
 749              const char *libname,
 750              void *lib_ret)
 751 {
 752   struct GNUNET_REST_Plugin *plugin = lib_ret;
 753   struct GNUNET_HashCode key;
 754   if (NULL == lib_ret)
 755   {
 756     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 757                 "Could not load plugin `%s'\n",
 758                 libname);
 759     return;
 760   }
 761   GNUNET_assert (1 < strlen (plugin->name));
 762   GNUNET_assert ('/' == *plugin->name);
 763   GNUNET_CRYPTO_hash (plugin->name+1, strlen (plugin->name+1), &key);
 764   if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (plugin_map,
 765                                                       &key,
 766                                                       plugin,
 767                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
 768   {
 769     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 770                 "Could not load add plugin `%s'\n",
 771                 libname);
 772     return;
 773   }
 774   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 775               "Loaded plugin `%s'\n",
 776               libname);
 777 }
 778
 779
 780 /**
 781  * Main function that will be run
 782  *
 783  * @param cls closure
 784  * @param args remaining command-line arguments
 785  * @param cfgfile name of the configuration file used (for saving, can be NULL)
 786  * @param c configuration
 787  */
 788 static void
 789 run (void *cls,
 790      char *const *args,
 791      const char *cfgfile,
 792      const struct GNUNET_CONFIGURATION_Handle *c)
 793 {
 794   cfg = c;
 795   plugin_map = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
 796
 797   /* Get CORS data from cfg */
 798   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "rest",
 799                                                           "REST_ALLOW_ORIGIN",
 800                                                           &allow_origin))
 801   {
 802     //No origin specified
 803     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 804                 "No CORS Access-Control-Allow-Origin Header will be sent...\n");
 805   }
 806
 807   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "rest",
 808                                                           "REST_ALLOW_HEADERS",
 809                                                           &allow_headers))
 810   {
 811     //No origin specified
 812     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 813                 "No CORS Access-Control-Allow-Headers Header will be sent...\n");
 814   }
 815
 816   /* Open listen socket proxy */
 817   lsock6 = bind_v6 ();
 818   if (NULL == lsock6)
 819   {
 820     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
 821   }
 822   else
 823   {
 824     if (GNUNET_OK != GNUNET_NETWORK_socket_listen (lsock6, 5))
 825     {
 826       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "listen");
 827       GNUNET_NETWORK_socket_close (lsock6);
 828       lsock6 = NULL;
 829     }
 830     else
 831     {
 832       ltask6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 833                                               lsock6, &do_accept, lsock6);
 834
 835     }
 836   }
 837   lsock4 = bind_v4 ();
 838   if (NULL == lsock4)
 839   {
 840     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
 841   }
 842   else
 843   {
 844     if (GNUNET_OK != GNUNET_NETWORK_socket_listen (lsock4, 5))
 845     {
 846       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "listen");
 847       GNUNET_NETWORK_socket_close (lsock4);
 848       lsock4 = NULL;
 849     }
 850     else
 851     {
 852       ltask4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
 853                                               lsock4, &do_accept, lsock4);
 854
 855     }
 856   }
 857   if ( (NULL == lsock4) &&
 858        (NULL == lsock6) )
 859   {
 860     GNUNET_SCHEDULER_shutdown ();
 861     return;
 862   }
 863   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 864               "Service listens on port %llu\n",
 865               port);
 866   httpd = MHD_start_daemon (MHD_USE_DEBUG | MHD_USE_NO_LISTEN_SOCKET,
 867                             0,
 868                             NULL, NULL,
 869                             &create_response, NULL,
 870                             MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
 871                             MHD_OPTION_NOTIFY_COMPLETED, &mhd_completed_cb, NULL,
 872                             MHD_OPTION_END);
 873   if (NULL == httpd)
 874   {
 875     GNUNET_SCHEDULER_shutdown ();
 876     return;
 877   }
 878   /* Load plugins */
 879   GNUNET_PLUGIN_load_all ("libgnunet_plugin_rest",
 880                           (void *) cfg,
 881                           &load_plugin,
 882                           NULL);
 883   GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
 884 }
 885
 886
 887 /**
 888  *
 889  * The main function for gnunet-rest-service
 890  *
 891  * @param argc number of arguments from the cli
 892  * @param argv command line arguments
 893  * @return 0 ok, 1 on error
 894  *
 895  */
 896 int
 897 main (int argc, char *const *argv)
 898 {
 899   struct GNUNET_GETOPT_CommandLineOption options[] = {
 900     GNUNET_GETOPT_option_ulong ('p',
 901                                 "port",
 902                                 "PORT",
 903                                 gettext_noop ("listen on specified port (default: 7776)"),
 904                                 &port),
 905     GNUNET_GETOPT_OPTION_END
 906   };
 907   static const char* err_page =
 908     "{}";
 909   int ret;
 910
 911   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
 912     return 2;
 913   GNUNET_log_setup ("gnunet-rest-server", "WARNING", NULL);
 914   failure_response = MHD_create_response_from_buffer (strlen(err_page),
 915                                                       (void*)err_page,
 916                                                       MHD_RESPMEM_PERSISTENT);
 917   ret =
 918     (GNUNET_OK ==
 919      GNUNET_PROGRAM_run (argc, argv, "gnunet-rest-server",
 920                          _("GNUnet REST server"),
 921                          options,
 922                          &run, NULL)) ? 0: 1;
 923   MHD_destroy_response (failure_response);
 924   GNUNET_free_non_null ((char *) argv);
 925   return ret;
 926 }
 927
 928 /* end of gnunet-rest-server.c */