GNUnet  0.19.3
plugin_rest_config.c
Go to the documentation of this file.
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  */
27 #include "platform.h"
28 #include "gnunet_rest_plugin.h"
29 #include <gnunet_rest_lib.h>
30 #include <gnunet_util_lib.h>
31 #include <jansson.h>
32 
33 #define GNUNET_REST_API_NS_CONFIG "/config"
34 
38 struct Plugin
39 {
40  const struct GNUNET_CONFIGURATION_Handle *cfg;
41 };
42 
44 
45 struct RequestHandle
46 {
50  struct RequestHandle *next;
51 
55  struct RequestHandle *prev;
56 
61 
66 
70  void *proc_cls;
71 
75  int response_code;
76 
80  char *url;
81 };
82 
87 
92 
93 
99 static void
101 {
102  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
103  if (NULL != handle->url)
104  GNUNET_free (handle->url);
107  handle);
109 }
110 
111 
117 static void
118 do_error (void *cls)
119 {
120  struct RequestHandle *handle = cls;
121  struct MHD_Response *resp;
122 
123  resp = GNUNET_REST_create_response (NULL);
124  handle->proc (handle->proc_cls, resp, handle->response_code);
126 }
127 
128 
129 static void
130 add_sections (void *cls,
131  const char *section,
132  const char *option,
133  const char *value)
134 {
135  json_t *sections_obj = cls;
136  json_t *sec_obj;
137 
138  sec_obj = json_object_get (sections_obj, section);
139  if (NULL != sec_obj)
140  {
141  json_object_set_new (sec_obj, option, json_string (value));
142  return;
143  }
144  sec_obj = json_object ();
145  json_object_set_new (sec_obj, option, json_string (value));
146  json_object_set_new (sections_obj, section, sec_obj);
147 }
148 
149 
150 static void
152  const char *section,
153  const char *option,
154  const char *value)
155 {
156  json_t *section_obj = cls;
157 
158  json_object_set_new (section_obj, option, json_string (value));
159 }
160 
161 
167 static void
169  const char *url,
170  void *cls)
171 {
172  struct MHD_Response *resp;
173  struct RequestHandle *handle = cls;
174  const char *section;
175  char *response;
176  json_t *result;
177 
178  if (strlen (GNUNET_REST_API_NS_CONFIG) > strlen (handle->url))
179  {
180  handle->response_code = MHD_HTTP_BAD_REQUEST;
182  return;
183  }
184  if (strlen (GNUNET_REST_API_NS_CONFIG) == strlen (handle->url))
185  {
186  result = json_object ();
188  }
189  else
190  {
191  result = json_object ();
192  section = &handle->url[strlen (GNUNET_REST_API_NS_CONFIG) + 1];
194  section,
196  result);
197  }
198  response = json_dumps (result, 0);
200  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
201  "Content-Type",
202  "application/json"));
203  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
206  json_decref (result);
207 }
208 
209 
212  const char *section,
213  const char *option,
214  json_t *value)
215 {
216  if (json_is_string (value))
218  json_string_value (value));
219  else if (json_is_number (value))
221  json_integer_value (value));
222  else if (json_is_null (value))
223  GNUNET_CONFIGURATION_set_value_string (config, section, option, NULL);
224  else if (json_is_true (value))
225  GNUNET_CONFIGURATION_set_value_string (config, section, option, "yes");
226  else if (json_is_false (value))
227  GNUNET_CONFIGURATION_set_value_string (config, section, option, "no");
228  else
229  return NULL;
230  return config; // for error handling (0 -> success, 1 -> error)
231 }
232 
233 
239 static void
241  const char *url,
242  void *cls)
243 {
244  struct RequestHandle *handle = cls;
245  char term_data[handle->rest_handle->data_size + 1];
247 
248  json_error_t err;
249  json_t *data_json;
250  const char *section;
251  const char *option;
252  json_t *sec_obj;
253  json_t *value;
254  char *cfg_fn;
255 
256  // invalid url
257  if (strlen (GNUNET_REST_API_NS_CONFIG) > strlen (handle->url))
258  {
259  handle->response_code = MHD_HTTP_BAD_REQUEST;
261  return;
262  }
263 
264  // extract data from handle
265  term_data[handle->rest_handle->data_size] = '\0';
266  GNUNET_memcpy (term_data,
267  handle->rest_handle->data,
268  handle->rest_handle->data_size);
269  data_json = json_loads (term_data, JSON_DECODE_ANY, &err);
270 
271  if (NULL == data_json)
272  {
274  "Unable to parse JSON Object from %s\n",
275  term_data);
277  return;
278  }
279 
280  // POST /config => {<section> : {<option> : <value>}}
281  if (strlen (GNUNET_REST_API_NS_CONFIG) == strlen (handle->url)) // POST /config
282  {
283  // iterate over sections
284  json_object_foreach (data_json, section, sec_obj)
285  {
286  // iterate over options
287  json_object_foreach (sec_obj, option, value)
288  {
289  out = set_value (out, section, option, value);
290  if (NULL == out)
291  {
292  handle->response_code = MHD_HTTP_BAD_REQUEST;
294  json_decref (data_json);
295  return;
296  }
297  }
298  }
299  }
300  else // POST /config/<section> => {<option> : <value>}
301  {
302  // extract the "<section>" part from the url
303  section = &handle->url[strlen (GNUNET_REST_API_NS_CONFIG) + 1];
304  // iterate over options
305  json_object_foreach (data_json, option, value)
306  {
307  out = set_value (out, section, option, value);
308  if (NULL == out)
309  {
310  handle->response_code = MHD_HTTP_BAD_REQUEST;
312  json_decref (data_json);
313  return;
314  }
315  }
316  }
317  json_decref (data_json);
318 
319 
320  // get cfg file path
321  cfg_fn = NULL;
322  const char *xdg = getenv ("XDG_CONFIG_HOME");
323  if (NULL != xdg)
324  GNUNET_asprintf (&cfg_fn,
325  "%s%s%s",
326  xdg,
329  else
330  cfg_fn = GNUNET_strdup (GNUNET_OS_project_data_get ()->user_config_file);
331 
332  GNUNET_CONFIGURATION_write (out, cfg_fn);
333  cfg = out;
334  handle->proc (handle->proc_cls,
336  MHD_HTTP_OK);
337  GNUNET_free (cfg_fn);
339 }
340 
341 
347 static void
349  const char *url,
350  void *cls)
351 {
352  struct MHD_Response *resp;
353  struct RequestHandle *handle = cls;
354 
355  resp = GNUNET_REST_create_response (NULL);
356  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
357  "Access-Control-Allow-Methods",
358  MHD_HTTP_METHOD_GET));
359  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
361 }
362 
363 
375 static enum GNUNET_GenericReturnValue
378  void *proc_cls)
379 {
380  static const struct GNUNET_REST_RequestHandler handlers[] = {
381  { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_CONFIG, &get_cont },
382  { MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_CONFIG, &set_cont },
383  { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_CONFIG, &options_cont },
385  };
386  struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
388 
389  handle->proc_cls = proc_cls;
390  handle->proc = proc;
391  handle->rest_handle = conndata_handle;
392  handle->url = GNUNET_strdup (conndata_handle->url);
393  if (handle->url[strlen (handle->url) - 1] == '/')
394  handle->url[strlen (handle->url) - 1] = '\0';
397  handle);
398  if (GNUNET_NO ==
399  GNUNET_REST_handle_request (conndata_handle, handlers, &err, handle))
400  {
402  return GNUNET_NO;
403  }
404  return GNUNET_YES;
405 }
406 
407 
414 void *
416 {
417  static struct Plugin plugin;
418 
419  cfg = cls;
420  struct GNUNET_REST_Plugin *api;
421 
422  memset (&plugin, 0, sizeof(struct Plugin));
423  plugin.cfg = cfg;
424  api = GNUNET_new (struct GNUNET_REST_Plugin);
425  api->cls = &plugin;
428  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("CONFIG REST API initialized\n"));
429  return api;
430 }
431 
432 
439 void *
441 {
442  struct GNUNET_REST_Plugin *api = cls;
443  struct Plugin *plugin;
444 
445  while (NULL != requests_head)
447  plugin = api->cls;
448  plugin->cfg = NULL;
449  GNUNET_free (api);
450  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CONFIG REST plugin is finished\n");
451  return NULL;
452 }
453 
454 
455 /* end of plugin_rest_config.c */
char * getenv()
static char * config_file
Set to the name of the config file used.
Definition: gnunet-arm.c:84
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
struct TestcasePlugin * plugin
The process handle to the testbed service.
static struct MHD_Response * response
Our canonical response.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static char * value
Value of the record to add/remove.
static int result
Global testing status.
static const struct GNUNET_CONFIGURATION_Handle * config
API for helper library to parse/create REST.
GNUnet service REST plugin header.
void GNUNET_CONFIGURATION_set_value_string(struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, const char *value)
Set a configuration value that should be a string.
void GNUNET_CONFIGURATION_iterate(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_CONFIGURATION_Iterator iter, void *iter_cls)
Iterate over all options in the configuration.
void GNUNET_CONFIGURATION_set_value_number(struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long number)
Set a configuration value that should be a number.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_write(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Write configuration file.
void GNUNET_CONFIGURATION_iterate_section_values(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, GNUNET_CONFIGURATION_Iterator iter, void *iter_cls)
Iterate over values of a section in the configuration.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
Duplicate an existing configuration object.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
GNUNET_GenericReturnValue
Named constants for return values.
@ GNUNET_YES
@ GNUNET_NO
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
const struct GNUNET_OS_ProjectData * GNUNET_OS_project_data_get(void)
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:44
int GNUNET_REST_handle_request(struct GNUNET_REST_RequestHandle *conn, const struct GNUNET_REST_RequestHandler *handlers, struct GNUNET_REST_RequestHandlerError *err, void *cls)
Definition: rest.c:64
void(* GNUNET_REST_ResultProcessor)(void *cls, struct MHD_Response *resp, int status)
Iterator called on obtained result for a REST result.
#define GNUNET_REST_HANDLER_END
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1299
@ MHD_HTTP_BAD_REQUEST
Bad Request [RFC7231, Section 6.5.1].
@ MHD_HTTP_OK
OK [RFC7231, Section 6.3.1].
#define DIR_SEPARATOR_STR
Definition: platform.h:165
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
struct GNUNET_CONFIGURATION_Handle * set_value(struct GNUNET_CONFIGURATION_Handle *config, const char *section, const char *option, json_t *value)
void * libgnunet_plugin_rest_config_init(void *cls)
Entry point for the plugin.
const struct GNUNET_CONFIGURATION_Handle * cfg
Handle to our configuration.
static void add_section_contents(void *cls, const char *section, const char *option, const char *value)
static struct RequestHandle * requests_head
DLL.
static void options_cont(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle rest request.
static enum GNUNET_GenericReturnValue rest_config_process_request(struct GNUNET_REST_RequestHandle *conndata_handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
Function processing the REST call.
static void set_cont(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle REST POST request.
static void cleanup_handle(struct RequestHandle *handle)
Cleanup request handle.
#define GNUNET_REST_API_NS_CONFIG
static void add_sections(void *cls, const char *section, const char *option, const char *value)
static struct RequestHandle * requests_tail
DLL.
static void get_cont(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle rest request.
static void do_error(void *cls)
Task run on shutdown.
void * libgnunet_plugin_rest_config_done(void *cls)
Exit point from the plugin.
void * cls
Closure for all of the callbacks.
struct returned by the initialization function of the plugin
char * name
Plugin name.
void * cls
The closure of the plugin.
enum GNUNET_GenericReturnValue(* process_request)(struct GNUNET_REST_RequestHandle *handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
Function to process a REST call.
const char * url
The url as string.
Handle for a plugin.
Definition: block.c:38
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
The request handle.
struct RequestHandle * prev
DLL.
int response_code
Response code.
void * proc_cls
The closure of the result processor.
GNUNET_REST_ResultProcessor proc
The plugin result processor.
struct RequestHandle * next
DLL.
struct GNUNET_REST_RequestHandle * rest_handle
Rest connection.
char * url
The url.