src/util/plugin_rest_copying.c

   1 /*
   2    This file is part of GNUnet.
   3    Copyright (C) 2012-2018 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 Martin Schanzenbach
  22  * @file gns/plugin_rest_copying.c
  23  * @brief REST plugin that serves licensing information.
  24  *
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_rest_plugin.h"
  29 #include <gnunet_rest_lib.h>
  30
  31 #define GNUNET_REST_API_NS_COPYING "/copying"
  32
  33 #define GNUNET_REST_COPYING_TEXT "GNU Affero General Public License version 3 or later. See also: <http://www.gnu.org/licenses/>"
  34
  35 /**
  36  * @brief struct returned by the initialization function of the plugin
  37  */
  38 struct Plugin
  39 {
  40   const struct GNUNET_CONFIGURATION_Handle *cfg;
  41 };
  42
  43 const struct GNUNET_CONFIGURATION_Handle *cfg;
  44
  45 struct RequestHandle
  46 {
  47   /**
  48    * Handle to rest request
  49    */
  50   struct GNUNET_REST_RequestHandle *rest_handle;
  51
  52   /**
  53    * The plugin result processor
  54    */
  55   GNUNET_REST_ResultProcessor proc;
  56
  57   /**
  58    * The closure of the result processor
  59    */
  60   void *proc_cls;
  61
  62   /**
  63    * HTTP response code
  64    */
  65   int response_code;
  66
  67 };
  68
  69
  70 /**
  71  * Cleanup request handle.
  72  *
  73  * @param handle Handle to clean up
  74  */
  75 static void
  76 cleanup_handle (struct RequestHandle *handle)
  77 {
  78   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
  79               "Cleaning up\n");
  80   GNUNET_free (handle);
  81 }
  82
  83
  84 /**
  85  * Task run on shutdown.  Cleans up everything.
  86  *
  87  * @param cls unused
  88  * @param tc scheduler context
  89  */
  90 static void
  91 do_error (void *cls)
  92 {
  93   struct RequestHandle *handle = cls;
  94   struct MHD_Response *resp;
  95
  96   resp = GNUNET_REST_create_response (NULL);
  97   handle->proc (handle->proc_cls, resp, handle->response_code);
  98   cleanup_handle (handle);
  99 }
 100
 101
 102 /**
 103  * Handle rest request
 104  *
 105  * @param handle the lookup handle
 106  */
 107 static void
 108 get_cont (struct GNUNET_REST_RequestHandle *con_handle,
 109               const char* url,
 110               void *cls)
 111 {
 112   struct MHD_Response *resp;
 113   struct RequestHandle *handle = cls;
 114
 115   resp = GNUNET_REST_create_response (GNUNET_REST_COPYING_TEXT);
 116   handle->proc (handle->proc_cls,
 117                 resp,
 118                 MHD_HTTP_OK);
 119   cleanup_handle (handle);
 120 }
 121
 122
 123
 124 /**
 125  * Handle rest request
 126  *
 127  * @param handle the lookup handle
 128  */
 129 static void
 130 options_cont (struct GNUNET_REST_RequestHandle *con_handle,
 131               const char* url,
 132               void *cls)
 133 {
 134   struct MHD_Response *resp;
 135   struct RequestHandle *handle = cls;
 136
 137   resp = GNUNET_REST_create_response (NULL);
 138   MHD_add_response_header (resp,
 139                            "Access-Control-Allow-Methods",
 140                            MHD_HTTP_METHOD_GET);
 141   handle->proc (handle->proc_cls,
 142                 resp,
 143                 MHD_HTTP_OK);
 144   cleanup_handle (handle);
 145 }
 146
 147
 148 /**
 149  * Function processing the REST call
 150  *
 151  * @param method HTTP method
 152  * @param url URL of the HTTP request
 153  * @param data body of the HTTP request (optional)
 154  * @param data_size length of the body
 155  * @param proc callback function for the result
 156  * @param proc_cls closure for @a proc
 157  * @return #GNUNET_OK if request accepted
 158  */
 159 static void
 160 rest_copying_process_request (struct GNUNET_REST_RequestHandle *conndata_handle,
 161                               GNUNET_REST_ResultProcessor proc,
 162                               void *proc_cls)
 163 {
 164   static const struct GNUNET_REST_RequestHandler handlers[] = {
 165     {MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_COPYING, &get_cont},
 166     {MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_COPYING, &options_cont},
 167     GNUNET_REST_HANDLER_END
 168   };
 169   struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
 170   struct GNUNET_REST_RequestHandlerError err;
 171
 172   handle->proc_cls = proc_cls;
 173   handle->proc = proc;
 174   handle->rest_handle = conndata_handle;
 175
 176   if (GNUNET_NO == GNUNET_REST_handle_request (conndata_handle,
 177                                                handlers,
 178                                                &err,
 179                                                handle))
 180   {
 181     handle->response_code = err.error_code;
 182     GNUNET_SCHEDULER_add_now (&do_error, handle);
 183   }
 184 }
 185
 186
 187 /**
 188  * Entry point for the plugin.
 189  *
 190  * @param cls the "struct GNUNET_NAMESTORE_PluginEnvironment*"
 191  * @return NULL on error, otherwise the plugin context
 192  */
 193 void *
 194 libgnunet_plugin_rest_copying_init (void *cls)
 195 {
 196   static struct Plugin plugin;
 197   cfg = cls;
 198   struct GNUNET_REST_Plugin *api;
 199
 200   if (NULL != plugin.cfg)
 201     return NULL;                /* can only initialize once! */
 202   memset (&plugin, 0, sizeof (struct Plugin));
 203   plugin.cfg = cfg;
 204   api = GNUNET_new (struct GNUNET_REST_Plugin);
 205   api->cls = &plugin;
 206   api->name = GNUNET_REST_API_NS_COPYING;
 207   api->process_request = &rest_copying_process_request;
 208   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 209               _("COPYING REST API initialized\n"));
 210   return api;
 211 }
 212
 213
 214 /**
 215  * Exit point from the plugin.
 216  *
 217  * @param cls the plugin context (as returned by "init")
 218  * @return always NULL
 219  */
 220 void *
 221 libgnunet_plugin_rest_copying_done (void *cls)
 222 {
 223   struct GNUNET_REST_Plugin *api = cls;
 224   struct Plugin *plugin = api->cls;
 225
 226   plugin->cfg = NULL;
 227   GNUNET_free (api);
 228   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 229               "COPYING REST plugin is finished\n");
 230   return NULL;
 231 }
 232
 233 /* end of plugin_rest_copying.c */