GNUnet  0.11.x
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 
118 static void
119 do_error (void *cls)
120 {
121  struct RequestHandle *handle = cls;
122  struct MHD_Response *resp;
123 
124  resp = GNUNET_REST_create_response (NULL);
125  handle->proc (handle->proc_cls, resp, handle->response_code);
127 }
128 
129 
130 static void
131 add_sections (void *cls,
132  const char *section,
133  const char *option,
134  const char *value)
135 {
136  json_t *sections_obj = cls;
137  json_t *sec_obj;
138 
139  sec_obj = json_object_get (sections_obj, section);
140  if (NULL != sec_obj)
141  {
142  json_object_set_new (sec_obj, option, json_string (value));
143  return;
144  }
145  sec_obj = json_object ();
146  json_object_set_new (sec_obj, option, json_string (value));
147  json_object_set_new (sections_obj, section, sec_obj);
148 }
149 
150 
151 static void
153  const char *section,
154  const char *option,
155  const char *value)
156 {
157  json_t *section_obj = cls;
158 
159  json_object_set_new (section_obj, option, json_string (value));
160 }
161 
162 
168 static void
170  const char *url,
171  void *cls)
172 {
173  struct MHD_Response *resp;
174  struct RequestHandle *handle = cls;
175  const char *section;
176  char *response;
177  json_t *result;
178 
179  if (strlen (GNUNET_REST_API_NS_CONFIG) > strlen (handle->url))
180  {
181  handle->response_code = MHD_HTTP_BAD_REQUEST;
183  return;
184  }
185  if (strlen (GNUNET_REST_API_NS_CONFIG) == strlen (handle->url))
186  {
187  result = json_object ();
189  }
190  else
191  {
192  result = json_object ();
193  section = &handle->url[strlen (GNUNET_REST_API_NS_CONFIG) + 1];
195  section,
197  result);
198  }
199  response = json_dumps (result, 0);
201  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
202  "Content-Type",
203  "application/json"));
204  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
207  json_decref (result);
208 }
209 
210 
213  const char *section,
214  const char *option,
215  json_t *value)
216 {
217  if (json_is_string (value))
219  json_string_value (value));
220  else if (json_is_number (value))
222  json_integer_value (value));
223  else if (json_is_null (value))
224  GNUNET_CONFIGURATION_set_value_string (config, section, option, NULL);
225  else if (json_is_true (value))
226  GNUNET_CONFIGURATION_set_value_string (config, section, option, "yes");
227  else if (json_is_false (value))
228  GNUNET_CONFIGURATION_set_value_string (config, section, option, "no");
229  else
230  return NULL;
231  return config; // for error handling (0 -> success, 1 -> error)
232 }
233 
234 
240 static void
242  const char *url,
243  void *cls)
244 {
245  struct RequestHandle *handle = cls;
246  char term_data[handle->rest_handle->data_size + 1];
248 
249  json_error_t err;
250  json_t *data_json;
251  const char *section;
252  const char *option;
253  json_t *sec_obj;
254  json_t *value;
255  char *cfg_fn;
256 
257  // invalid url
258  if (strlen (GNUNET_REST_API_NS_CONFIG) > strlen (handle->url))
259  {
260  handle->response_code = MHD_HTTP_BAD_REQUEST;
262  return;
263  }
264 
265  // extract data from handle
266  term_data[handle->rest_handle->data_size] = '\0';
267  GNUNET_memcpy (term_data,
268  handle->rest_handle->data,
269  handle->rest_handle->data_size);
270  data_json = json_loads (term_data, JSON_DECODE_ANY, &err);
271 
272  if (NULL == data_json)
273  {
275  "Unable to parse JSON Object from %s\n",
276  term_data);
278  return;
279  }
280 
281  // POST /config => {<section> : {<option> : <value>}}
282  if (strlen (GNUNET_REST_API_NS_CONFIG) == strlen (handle->url)) // POST /config
283  {
284  // iterate over sections
285  json_object_foreach (data_json, section, sec_obj)
286  {
287  // iterate over options
288  json_object_foreach (sec_obj, option, value)
289  {
290  out = set_value (out, section, option, value);
291  if (NULL == out)
292  {
293  handle->response_code = MHD_HTTP_BAD_REQUEST;
295  json_decref (data_json);
296  return;
297  }
298  }
299  }
300  }
301  else // POST /config/<section> => {<option> : <value>}
302  {
303  // extract the "<section>" part from the url
304  section = &handle->url[strlen (GNUNET_REST_API_NS_CONFIG) + 1];
305  // iterate over options
306  json_object_foreach (data_json, option, value)
307  {
308  out = set_value (out, section, option, value);
309  if (NULL == out)
310  {
311  handle->response_code = MHD_HTTP_BAD_REQUEST;
313  json_decref (data_json);
314  return;
315  }
316  }
317  }
318  json_decref (data_json);
319 
320 
321  // get cfg file path
322  cfg_fn = NULL;
323  const char *xdg = getenv ("XDG_CONFIG_HOME");
324  if (NULL != xdg)
325  GNUNET_asprintf (&cfg_fn,
326  "%s%s%s",
327  xdg,
330  else
331  cfg_fn = GNUNET_strdup (GNUNET_OS_project_data_get ()->user_config_file);
332 
333  GNUNET_CONFIGURATION_write (out, cfg_fn);
334  cfg = out;
335  handle->proc (handle->proc_cls,
337  MHD_HTTP_OK);
338  GNUNET_free (cfg_fn);
340 }
341 
342 
348 static void
350  const char *url,
351  void *cls)
352 {
353  struct MHD_Response *resp;
354  struct RequestHandle *handle = cls;
355 
356  resp = GNUNET_REST_create_response (NULL);
357  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
358  "Access-Control-Allow-Methods",
359  MHD_HTTP_METHOD_GET));
360  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
362 }
363 
364 
376 static enum GNUNET_GenericReturnValue
379  void *proc_cls)
380 {
381  static const struct GNUNET_REST_RequestHandler handlers[] = {
382  { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_CONFIG, &get_cont },
383  { MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_CONFIG, &set_cont },
384  { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_CONFIG, &options_cont },
386  };
387  struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
389 
390  handle->proc_cls = proc_cls;
391  handle->proc = proc;
392  handle->rest_handle = conndata_handle;
393  handle->url = GNUNET_strdup (conndata_handle->url);
394  if (handle->url[strlen (handle->url) - 1] == '/')
395  handle->url[strlen (handle->url) - 1] = '\0';
398  handle);
399  if (GNUNET_NO ==
400  GNUNET_REST_handle_request (conndata_handle, handlers, &err, handle))
401  {
403  return GNUNET_NO;
404  }
405  return GNUNET_YES;
406 }
407 
408 
415 void *
417 {
418  static struct Plugin plugin;
419 
420  cfg = cls;
421  struct GNUNET_REST_Plugin *api;
422 
423  memset (&plugin, 0, sizeof(struct Plugin));
424  plugin.cfg = cfg;
425  api = GNUNET_new (struct GNUNET_REST_Plugin);
426  api->cls = &plugin;
429  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("CONFIG REST API initialized\n"));
430  return api;
431 }
432 
433 
440 void *
442 {
443  struct GNUNET_REST_Plugin *api = cls;
444  struct Plugin *plugin;
445 
446  while (NULL != requests_head)
448  plugin = api->cls;
449  plugin->cfg = NULL;
450  GNUNET_free (api);
451  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CONFIG REST plugin is finished\n");
452  return NULL;
453 }
454 
455 
456 /* 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 Plugin * 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
#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.
Definition: gnunet_common.h:92
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94
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_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:57
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:77
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:1296
#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.