src/gns/plugin_rest_gns.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 it
   6    under the terms of the GNU Affero General Public License as published
   7    by the Free Software Foundation, either version 3 of the License,
   8    or (at your 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    Affero General Public License for more details.
  14
  15    You should have received a copy of the GNU Affero General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19  */
  20 /**
  21  * @author Philippe Buschmann
  22  * @file gns/plugin_rest_gns.c
  23  * @brief GNUnet Gns REST plugin
  24  */
  25
  26 #include "platform.h"
  27 #include "gnunet_rest_plugin.h"
  28 #include "gnunet_rest_lib.h"
  29 #include "gnunet_json_lib.h"
  30 #include "gnunet_gnsrecord_lib.h"
  31 #include "gnunet_gns_service.h"
  32 #include "microhttpd.h"
  33 #include <jansson.h>
  34
  35 /**
  36  * Rest API GNS Namespace
  37  */
  38 #define GNUNET_REST_API_NS_GNS "/gns"
  39
  40 /**
  41  * Rest API GNS Parameter record_type
  42  */
  43 #define GNUNET_REST_GNS_PARAM_RECORD_TYPE "record_type"
  44
  45 /**
  46  * Rest API GNS ERROR Unknown Error
  47  */
  48 #define GNUNET_REST_GNS_ERROR_UNKNOWN "Unknown Error"
  49
  50 /**
  51  * Rest API GNS ERROR Record not found
  52  */
  53 #define GNUNET_REST_GNS_NOT_FOUND "Record not found"
  54
  55 /**
  56  * The configuration handle
  57  */
  58 const struct GNUNET_CONFIGURATION_Handle *cfg;
  59
  60 /**
  61  * HTTP methods allows for this plugin
  62  */
  63 static char *allow_methods;
  64
  65 /**
  66  * @brief struct returned by the initialization function of the plugin
  67  */
  68 struct Plugin
  69 {
  70   const struct GNUNET_CONFIGURATION_Handle *cfg;
  71 };
  72
  73 /**
  74  * The request handle
  75  */
  76 struct RequestHandle
  77 {
  78   /**
  79    * Connection to GNS
  80    */
  81   struct GNUNET_GNS_Handle *gns;
  82
  83   /**
  84    * Active GNS lookup
  85    */
  86   struct GNUNET_GNS_LookupWithTldRequest *gns_lookup;
  87
  88   /**
  89    * Name to look up
  90    */
  91   char *name;
  92
  93   /**
  94    * Record type to look up
  95    */
  96   int record_type;
  97
  98   /**
  99    * Rest connection
 100    */
 101   struct GNUNET_REST_RequestHandle *rest_handle;
 102
 103   /**
 104    * Desired timeout for the lookup (default is no timeout).
 105    */
 106   struct GNUNET_TIME_Relative timeout;
 107
 108   /**
 109    * ID of a task associated with the resolution process.
 110    */
 111   struct GNUNET_SCHEDULER_Task *timeout_task;
 112
 113   /**
 114    * The plugin result processor
 115    */
 116   GNUNET_REST_ResultProcessor proc;
 117
 118   /**
 119    * The closure of the result processor
 120    */
 121   void *proc_cls;
 122
 123   /**
 124    * The url
 125    */
 126   char *url;
 127
 128   /**
 129    * Error response message
 130    */
 131   char *emsg;
 132
 133   /**
 134    * Response code
 135    */
 136   int response_code;
 137 };
 138
 139
 140 /**
 141  * Cleanup lookup handle
 142  * @param handle Handle to clean up
 143  */
 144 static void
 145 cleanup_handle (void *cls)
 146 {
 147   struct RequestHandle *handle = cls;
 148
 149   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
 150
 151   if (NULL != handle->gns_lookup)
 152   {
 153     GNUNET_GNS_lookup_with_tld_cancel (handle->gns_lookup);
 154     handle->gns_lookup = NULL;
 155   }
 156   if (NULL != handle->gns)
 157   {
 158     GNUNET_GNS_disconnect (handle->gns);
 159     handle->gns = NULL;
 160   }
 161
 162   if (NULL != handle->timeout_task)
 163   {
 164     GNUNET_SCHEDULER_cancel (handle->timeout_task);
 165     handle->timeout_task = NULL;
 166   }
 167   if (NULL != handle->url)
 168     GNUNET_free (handle->url);
 169   if (NULL != handle->name)
 170     GNUNET_free (handle->name);
 171   if (NULL != handle->emsg)
 172     GNUNET_free (handle->emsg);
 173
 174   GNUNET_free (handle);
 175 }
 176
 177
 178 /**
 179  * Task run on errors.  Reports an error and cleans up everything.
 180  *
 181  * @param cls the `struct RequestHandle`
 182  */
 183 static void
 184 do_error (void *cls)
 185 {
 186   struct RequestHandle *handle = cls;
 187   struct MHD_Response *resp;
 188   json_t *json_error = json_object ();
 189   char *response;
 190
 191   if (NULL != handle->timeout_task)
 192     GNUNET_SCHEDULER_cancel (handle->timeout_task);
 193   handle->timeout_task = NULL;
 194   if (NULL == handle->emsg)
 195     handle->emsg = GNUNET_strdup (GNUNET_REST_GNS_ERROR_UNKNOWN);
 196
 197   json_object_set_new (json_error, "error", json_string (handle->emsg));
 198
 199   if (0 == handle->response_code)
 200     handle->response_code = MHD_HTTP_INTERNAL_SERVER_ERROR;
 201   response = json_dumps (json_error, 0);
 202   resp = GNUNET_REST_create_response (response);
 203   handle->proc (handle->proc_cls, resp, handle->response_code);
 204   json_decref (json_error);
 205   GNUNET_free (response);
 206   GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
 207 }
 208
 209
 210 static void
 211 do_timeout (void *cls)
 212 {
 213   struct RequestHandle *handle = cls;
 214
 215   handle->timeout_task = NULL;
 216   handle->response_code = MHD_HTTP_REQUEST_TIMEOUT;
 217   do_error (handle);
 218 }
 219
 220
 221 /**
 222  * Iterator called on obtained result for a GNS lookup.
 223  *
 224  * @param cls closure with the object
 225  * @param was_gns #GNUNET_NO if name was not a GNS name
 226  * @param rd_count number of records in @a rd
 227  * @param rd the records in reply
 228  */
 229 static void
 230 handle_gns_response (void *cls,
 231                      int was_gns,
 232                      uint32_t rd_count,
 233                      const struct GNUNET_GNSRECORD_Data *rd)
 234 {
 235   struct RequestHandle *handle = cls;
 236   struct MHD_Response *resp;
 237   json_t *result_obj;
 238   char *result;
 239
 240   handle->gns_lookup = NULL;
 241
 242   if (GNUNET_NO == was_gns)
 243   {
 244     handle->response_code = MHD_HTTP_NOT_FOUND;
 245     handle->emsg = GNUNET_strdup (GNUNET_REST_GNS_NOT_FOUND);
 246     GNUNET_SCHEDULER_add_now (&do_error, handle);
 247     return;
 248   }
 249
 250   result_obj = GNUNET_JSON_from_gnsrecord (handle->name, rd, rd_count);
 251
 252   result = json_dumps (result_obj, 0);
 253   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result);
 254   resp = GNUNET_REST_create_response (result);
 255   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
 256   GNUNET_free (result);
 257   json_decref (result_obj);
 258   GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
 259 }
 260
 261
 262 /**
 263  * Handle gns GET request
 264  *
 265  * @param con_handle the connection handle
 266  * @param url the url
 267  * @param cls the RequestHandle
 268  */
 269 void
 270 get_gns_cont (struct GNUNET_REST_RequestHandle *con_handle,
 271               const char *url,
 272               void *cls)
 273 {
 274   struct RequestHandle *handle = cls;
 275   struct GNUNET_HashCode key;
 276   char *record_type;
 277   char *name;
 278
 279   name = NULL;
 280   handle->name = NULL;
 281   if (strlen (GNUNET_REST_API_NS_GNS) < strlen (handle->url))
 282   {
 283     name = &handle->url[strlen (GNUNET_REST_API_NS_GNS) + 1];
 284   }
 285
 286   if (NULL == name)
 287   {
 288     handle->response_code = MHD_HTTP_NOT_FOUND;
 289     handle->emsg = GNUNET_strdup (GNUNET_REST_GNS_NOT_FOUND);
 290     GNUNET_SCHEDULER_add_now (&do_error, handle);
 291     return;
 292   }
 293   if (0 >= strlen (name))
 294   {
 295     handle->response_code = MHD_HTTP_NOT_FOUND;
 296     handle->emsg = GNUNET_strdup (GNUNET_REST_GNS_NOT_FOUND);
 297     GNUNET_SCHEDULER_add_now (&do_error, handle);
 298     return;
 299   }
 300   handle->name = GNUNET_strdup (name);
 301
 302   handle->record_type = UINT32_MAX;
 303   GNUNET_CRYPTO_hash (GNUNET_REST_GNS_PARAM_RECORD_TYPE,
 304                       strlen (GNUNET_REST_GNS_PARAM_RECORD_TYPE),
 305                       &key);
 306   if (GNUNET_YES ==
 307       GNUNET_CONTAINER_multihashmap_contains (con_handle->url_param_map, &key))
 308   {
 309     record_type =
 310       GNUNET_CONTAINER_multihashmap_get (con_handle->url_param_map, &key);
 311     handle->record_type = GNUNET_GNSRECORD_typename_to_number (record_type);
 312   }
 313
 314   if (UINT32_MAX == handle->record_type)
 315   {
 316     handle->record_type = GNUNET_GNSRECORD_TYPE_ANY;
 317   }
 318
 319   handle->gns_lookup = GNUNET_GNS_lookup_with_tld (handle->gns,
 320                                                    handle->name,
 321                                                    handle->record_type,
 322                                                    GNUNET_NO,
 323                                                    &handle_gns_response,
 324                                                    handle);
 325 }
 326
 327
 328 /**
 329  * Respond to OPTIONS request
 330  *
 331  * @param con_handle the connection handle
 332  * @param url the url
 333  * @param cls the RequestHandle
 334  */
 335 static void
 336 options_cont (struct GNUNET_REST_RequestHandle *con_handle,
 337               const char *url,
 338               void *cls)
 339 {
 340   struct MHD_Response *resp;
 341   struct RequestHandle *handle = cls;
 342
 343   // independent of path return all options
 344   resp = GNUNET_REST_create_response (NULL);
 345   MHD_add_response_header (resp, "Access-Control-Allow-Methods", allow_methods);
 346   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
 347   GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
 348   return;
 349 }
 350
 351
 352 /**
 353  * Handle rest request
 354  *
 355  * @param handle the request handle
 356  */
 357 static void
 358 init_cont (struct RequestHandle *handle)
 359 {
 360   struct GNUNET_REST_RequestHandlerError err;
 361   static const struct GNUNET_REST_RequestHandler handlers[] =
 362   { { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_GNS, &get_gns_cont },
 363     { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_GNS, &options_cont },
 364     GNUNET_REST_HANDLER_END };
 365
 366   if (GNUNET_NO ==
 367       GNUNET_REST_handle_request (handle->rest_handle, handlers, &err, handle))
 368   {
 369     handle->response_code = err.error_code;
 370     GNUNET_SCHEDULER_add_now (&do_error, handle);
 371   }
 372 }
 373
 374
 375 /**
 376  * Function processing the REST call
 377  *
 378  * @param method HTTP method
 379  * @param url URL of the HTTP request
 380  * @param data body of the HTTP request (optional)
 381  * @param data_size length of the body
 382  * @param proc callback function for the result
 383  * @param proc_cls closure for callback function
 384  * @return GNUNET_OK if request accepted
 385  */
 386 static void
 387 rest_process_request (struct GNUNET_REST_RequestHandle *rest_handle,
 388                       GNUNET_REST_ResultProcessor proc,
 389                       void *proc_cls)
 390 {
 391   struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
 392
 393   handle->response_code = 0;
 394   handle->timeout =
 395     GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60);
 396   handle->proc_cls = proc_cls;
 397   handle->proc = proc;
 398   handle->rest_handle = rest_handle;
 399
 400   handle->url = GNUNET_strdup (rest_handle->url);
 401   if (handle->url[strlen (handle->url) - 1] == '/')
 402     handle->url[strlen (handle->url) - 1] = '\0';
 403   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
 404   handle->gns = GNUNET_GNS_connect (cfg);
 405   init_cont (handle);
 406
 407   handle->timeout_task =
 408     GNUNET_SCHEDULER_add_delayed (handle->timeout, &do_timeout, handle);
 409
 410   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
 411 }
 412
 413
 414 /**
 415  * Entry point for the plugin.
 416  *
 417  * @param cls Config info
 418  * @return NULL on error, otherwise the plugin context
 419  */
 420 void *
 421 libgnunet_plugin_rest_gns_init (void *cls)
 422 {
 423   static struct Plugin plugin;
 424   struct GNUNET_REST_Plugin *api;
 425
 426   cfg = cls;
 427   if (NULL != plugin.cfg)
 428     return NULL; /* can only initialize once! */
 429   memset (&plugin, 0, sizeof(struct Plugin));
 430   plugin.cfg = cfg;
 431   api = GNUNET_new (struct GNUNET_REST_Plugin);
 432   api->cls = &plugin;
 433   api->name = GNUNET_REST_API_NS_GNS;
 434   api->process_request = &rest_process_request;
 435   GNUNET_asprintf (&allow_methods,
 436                    "%s, %s, %s, %s, %s",
 437                    MHD_HTTP_METHOD_GET,
 438                    MHD_HTTP_METHOD_POST,
 439                    MHD_HTTP_METHOD_PUT,
 440                    MHD_HTTP_METHOD_DELETE,
 441                    MHD_HTTP_METHOD_OPTIONS);
 442
 443   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Gns REST API initialized\n"));
 444   return api;
 445 }
 446
 447
 448 /**
 449  * Exit point from the plugin.
 450  *
 451  * @param cls the plugin context (as returned by "init")
 452  * @return always NULL
 453  */
 454 void *
 455 libgnunet_plugin_rest_gns_done (void *cls)
 456 {
 457   struct GNUNET_REST_Plugin *api = cls;
 458   struct Plugin *plugin = api->cls;
 459
 460   plugin->cfg = NULL;
 461
 462   GNUNET_free_non_null (allow_methods);
 463   GNUNET_free (api);
 464   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Gns REST plugin is finished\n");
 465   return NULL;
 466 }
 467
 468
 469 /* end of plugin_rest_gns.c */