#include "platform.h"
#include "gnunet_rest_plugin.h"
#include "gnunet_peerinfo_service.h"
#include "gnunet_transport_service.h"
#include "gnunet_rest_lib.h"
#include "gnunet_json_lib.h"
#include "microhttpd.h"
#include <jansson.h>

Include dependency graph for plugin_rest_peerinfo.c:

Data Structures
struct	Plugin
	Handle for a plugin. More...

struct	AddressRecord
	Record we keep for each printable address. More...

struct	PrintContext
	Structure we use to collect printable address information. More...

struct	RequestHandle
	The request handle. More...

Macros
#define	GNUNET_REST_API_NS_PEERINFO "/peerinfo"
	Peerinfo Namespace. More...

#define	GNUNET_REST_PEERINFO_PEER "peer"
	Peerinfo parameter peer. More...

#define	GNUNET_REST_PEERINFO_FRIEND "friend"
	Peerinfo parameter friend. More...

#define	GNUNET_REST_PEERINFO_ARRAY "array"
	Peerinfo parameter array. More...

#define	GNUNET_REST_PEERINFO_ERROR_UNKNOWN "Unknown Error"
	Error message Unknown Error. More...

#define	TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
	How long until we time out during address lookup? More...

Functions
static void	cleanup_handle (void *cls)
	Cleanup lookup handle. More...

static void	do_error (void *cls)
	Task run on errors. More...

static void	peerinfo_list_finished (void *cls)
	Function that assembles the response. More...

static int	count_address (void cls, const struct GNUNET_HELLO_Address address, struct GNUNET_TIME_Absolute expiration)
	Iterator callback to go over all addresses and count them. More...

static void	dump_pc (struct PrintContext *pc)
	Print the collected address information to the console and free pc. More...

static void	process_resolved_address (void cls, const char address, int res)
	Function to call with a human-readable format of an address. More...

static int	print_address (void cls, const struct GNUNET_HELLO_Address address, struct GNUNET_TIME_Absolute expiration)
	Iterator callback to go over all addresses. More...

void	peerinfo_list_iteration (void cls, const struct GNUNET_PeerIdentity peer, const struct GNUNET_HELLO_Message hello, const char err_msg)
	Callback that processes each of the known HELLOs for the iteration response construction. More...

void	peerinfo_get (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)
	Handle peerinfo GET request. More...

static void	options_cont (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)
	Respond to OPTIONS request. More...

static enum GNUNET_GenericReturnValue	rest_process_request (struct GNUNET_REST_RequestHandle rest_handle, GNUNET_REST_ResultProcessor proc, void proc_cls)
	Function processing the REST call. More...

void *	libgnunet_plugin_rest_peerinfo_init (void *cls)
	Entry point for the plugin. More...

void *	libgnunet_plugin_rest_peerinfo_done (void *cls)
	Exit point from the plugin. More...

Variables
const struct GNUNET_CONFIGURATION_Handle *	cfg
	The configuration handle. More...

static char *	allow_methods
	HTTP methods allows for this plugin. More...

static struct GNUNET_PEERINFO_Handle *	peerinfo_handle
	Handle to PEERINFO. More...

static struct PrintContext *	pc_head
	Head of list of print contexts. More...

static struct PrintContext *	pc_tail
	Tail of list of print contexts. More...

static struct RequestHandle *	requests_head
	DLL. More...

static struct RequestHandle *	requests_tail
	DLL. More...

Macro Definition Documentation

◆ GNUNET_REST_API_NS_PEERINFO

#define GNUNET_REST_API_NS_PEERINFO "/peerinfo"

Peerinfo Namespace.

Definition at line 39 of file plugin_rest_peerinfo.c.

◆ GNUNET_REST_PEERINFO_PEER

#define GNUNET_REST_PEERINFO_PEER "peer"

Peerinfo parameter peer.

Definition at line 44 of file plugin_rest_peerinfo.c.

◆ GNUNET_REST_PEERINFO_FRIEND

#define GNUNET_REST_PEERINFO_FRIEND "friend"

Peerinfo parameter friend.

Definition at line 49 of file plugin_rest_peerinfo.c.

◆ GNUNET_REST_PEERINFO_ARRAY

#define GNUNET_REST_PEERINFO_ARRAY "array"

Peerinfo parameter array.

Definition at line 54 of file plugin_rest_peerinfo.c.

◆ GNUNET_REST_PEERINFO_ERROR_UNKNOWN

#define GNUNET_REST_PEERINFO_ERROR_UNKNOWN "Unknown Error"

Error message Unknown Error.

Definition at line 59 of file plugin_rest_peerinfo.c.

◆ TIMEOUT

#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)

How long until we time out during address lookup?

Definition at line 64 of file plugin_rest_peerinfo.c.

Function Documentation

◆ cleanup_handle()

static void cleanup_handle ( void * cls )

static

Cleanup lookup handle.

Parameters

handle Handle to clean up

Definition at line 279 of file plugin_rest_peerinfo.c.

 {
   struct RequestHandle *handle = cls;
  
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Cleaning up\n");
   if (NULL != handle->timeout_task)
   {
     GNUNET_SCHEDULER_cancel (handle->timeout_task);
     handle->timeout_task = NULL;
   }
   if (NULL != handle->url)
     GNUNET_free (handle->url);
   if (NULL != handle->emsg)
     GNUNET_free (handle->emsg);
   if (NULL != handle->address)
     GNUNET_free_nz ((char *) handle->address);
   if (NULL != handle->expiration_str)
     GNUNET_free (handle->expiration_str);
   if (NULL != handle->pubkey)
     GNUNET_free (handle->pubkey);
  
   if (NULL != handle->temp_array)
   {
     json_decref (handle->temp_array);
     handle->temp_array = NULL;
   }
   if (NULL != handle->response)
   {
     json_decref (handle->response);
     handle->response = NULL;
   }
  
   if (NULL != handle->list_it)
   {
     GNUNET_PEERINFO_iterate_cancel (handle->list_it);
     handle->list_it = NULL;
   }
   if (NULL != peerinfo_handle)
   {
     GNUNET_PEERINFO_disconnect (peerinfo_handle);
     peerinfo_handle = NULL;
   }
   GNUNET_CONTAINER_DLL_remove (requests_head,
                                requests_tail,
                                handle);
   GNUNET_free (handle);
 }

References GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_free_nz, GNUNET_log, GNUNET_PEERINFO_disconnect(), GNUNET_PEERINFO_iterate_cancel(), GNUNET_SCHEDULER_cancel(), handle, peerinfo_handle, requests_head, and requests_tail.

Referenced by do_error(), libgnunet_plugin_rest_peerinfo_done(), options_cont(), and peerinfo_list_finished().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_error()

static void do_error ( void * cls )

static

Task run on errors.

Reports an error and cleans up everything.

Parameters

cls	the `struct RequestHandle`

Definition at line 335 of file plugin_rest_peerinfo.c.

 {
   struct RequestHandle *handle = cls;
   struct MHD_Response *resp;
   json_t *json_error = json_object ();
   char *response;
  
   if (NULL == handle->emsg)
     handle->emsg = GNUNET_strdup (GNUNET_REST_PEERINFO_ERROR_UNKNOWN);
  
   json_object_set_new (json_error, "error", json_string (handle->emsg));
  
   if (0 == handle->response_code)
     handle->response_code = MHD_HTTP_OK;
   response = json_dumps (json_error, 0);
   resp = GNUNET_REST_create_response (response);
   MHD_add_response_header (resp, "Content-Type", "application/json");
   handle->proc (handle->proc_cls, resp, handle->response_code);
   json_decref (json_error);
   GNUNET_free (response);
   GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
 }

References cleanup_handle(), GNUNET_free, GNUNET_REST_create_response(), GNUNET_REST_PEERINFO_ERROR_UNKNOWN, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, MHD_HTTP_OK, and response.

Referenced by peerinfo_list_finished(), and peerinfo_list_iteration().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ peerinfo_list_finished()

static void peerinfo_list_finished ( void * cls )

static

Function that assembles the response.

Parameters

cls	the `struct RequestHandle`

Definition at line 365 of file plugin_rest_peerinfo.c.

 {
   struct RequestHandle *handle = cls;
   char *result_str;
   struct MHD_Response *resp;
  
   if (NULL == handle->response)
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
     handle->emsg = GNUNET_strdup ("No peers found");
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
  
   result_str = json_dumps (handle->response, 0);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
   resp = GNUNET_REST_create_response (result_str);
   GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
                                                     "Content-Type",
                                                     "application/json"));
   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
   GNUNET_free (result_str);
   GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
 }

References cleanup_handle(), do_error(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_REST_create_response(), GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, MHD_HTTP_NOT_FOUND, and MHD_HTTP_OK.

Referenced by dump_pc().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ count_address()

static int count_address	(	void *	cls,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_TIME_Absolute	expiration
	)

static

Iterator callback to go over all addresses and count them.

Parameters

cls	`struct PrintContext *` with `off` to increment
address	the address
expiration	expiration time

Returns: GNUNET_OK to keep the address and continue

Definition at line 400 of file plugin_rest_peerinfo.c.

 {
   struct PrintContext *pc = cls;
  
   if (0 == GNUNET_TIME_absolute_get_remaining (expiration).rel_value_us)
   {
     return GNUNET_OK;          /* ignore expired address */
   }
  
   pc->off++;
   return GNUNET_OK;
 }

References expiration, GNUNET_OK, GNUNET_TIME_absolute_get_remaining(), and pc.

Referenced by peerinfo_list_iteration().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dump_pc()

static void dump_pc ( struct PrintContext * pc )

static

Print the collected address information to the console and free pc.

Parameters

pc	printing context

Definition at line 422 of file plugin_rest_peerinfo.c.

 {
   struct RequestHandle *handle;
   unsigned int i;
   json_t *response_entry;
   json_t *temp_array;
   json_t *object;
   json_t *address;
   json_t *expires;
   json_t *friend_and_peer_json;
   char *friend_and_peer;
  
   temp_array = json_array ();
   response_entry = json_object ();
  
   for (i = 0; i < pc->num_addresses; i++)
   {
     if (NULL != pc->address_list[i].result)
     {
       object = json_object ();
       address = json_string (pc->address_list[i].result);
       expires = json_string (
         GNUNET_STRINGS_absolute_time_to_string (
           pc->address_list[i].expiration));
       json_object_set (object, "address", address);
       json_object_set (object, "expires", expires);
  
       json_decref (address);
       json_decref (expires);
  
       json_array_append (temp_array, object);
       json_decref (object);
       GNUNET_free (pc->address_list[i].result);
     }
   }
  
   if (0 < json_array_size (temp_array))
   {
     GNUNET_asprintf (&friend_and_peer,
                      "%s%s",
                      (GNUNET_YES == pc->friend_only) ? "F2F:" : "",
                      GNUNET_i2s_full (&pc->peer));
     friend_and_peer_json = json_string (friend_and_peer);
     json_object_set (response_entry,
                      GNUNET_REST_PEERINFO_PEER,
                      friend_and_peer_json);
     json_object_set (response_entry,
                      GNUNET_REST_PEERINFO_ARRAY,
                      temp_array);
     json_array_append (pc->handle->response, response_entry);
     json_decref (friend_and_peer_json);
     GNUNET_free (friend_and_peer);
   }
  
   json_decref (temp_array);
   json_decref (response_entry);
  
   GNUNET_free (pc->address_list);
   GNUNET_CONTAINER_DLL_remove (pc_head,
                                pc_tail,
                                pc);
   handle = pc->handle;
   GNUNET_free (pc);
  
   if ((NULL == pc_head) &&
       (NULL == handle->list_it))
   {
     GNUNET_SCHEDULER_add_now (&peerinfo_list_finished, handle);
   }
 }

References address, GNUNET_asprintf(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_i2s_full(), GNUNET_REST_PEERINFO_ARRAY, GNUNET_REST_PEERINFO_PEER, GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_YES, handle, pc, pc_head, pc_tail, peerinfo_list_finished(), and RequestHandle::temp_array.

Referenced by peerinfo_list_iteration(), and process_resolved_address().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_resolved_address()

static void process_resolved_address	(	void *	cls,
		const char *	address,
		int	res
	)

static

Function to call with a human-readable format of an address.

Parameters

cls	closure
address	NULL on error, otherwise 0-terminated printable UTF-8 string
res	result of the address to string conversion: if GNUNET_OK: address was valid (conversion to string might still have failed) if GNUNET_SYSERR: address is invalid

Definition at line 505 of file plugin_rest_peerinfo.c.

 {
   struct AddressRecord *ar = cls;
   struct PrintContext *pc = ar->pc;
  
   if (NULL != address)
   {
     if (0 != strlen (address))
     {
       if (NULL != ar->result)
         GNUNET_free (ar->result);
       ar->result = GNUNET_strdup (address);
     }
     return;
   }
   ar->atsc = NULL;
   if (GNUNET_SYSERR == res)
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 _ ("Failure: Cannot convert address to string for peer `%s'\n"),
                 GNUNET_i2s (&ar->pc->peer));
   pc->num_addresses++;
   if (pc->num_addresses == pc->address_list_size)
     dump_pc (ar->pc);
 }

References _, address, AddressRecord::atsc, dump_pc(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_strdup, GNUNET_SYSERR, pc, AddressRecord::pc, PrintContext::peer, res, and AddressRecord::result.

Referenced by print_address().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_address()

static int print_address	(	void *	cls,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_TIME_Absolute	expiration
	)

static

Iterator callback to go over all addresses.

Parameters

cls	closure
address	the address
expiration	expiration time

Returns: GNUNET_OK to keep the address and continue

Definition at line 542 of file plugin_rest_peerinfo.c.

 {
   struct PrintContext *pc = cls;
   struct AddressRecord *ar;
  
   if (0 == GNUNET_TIME_absolute_get_remaining (expiration).rel_value_us)
   {
     return GNUNET_OK;          /* ignore expired address */
   }
  
   GNUNET_assert (0 < pc->off);
   ar = &pc->address_list[--pc->off];
   ar->pc = pc;
   ar->expiration = expiration;
   GNUNET_asprintf (&ar->result,
                    "%s:%lu:%u",
                    address->transport_name,
                    (unsigned long) address->address_length,
                    address->local_info);
   ar->atsc = GNUNET_TRANSPORT_address_to_string (cfg,
                                                  address,
                                                  GNUNET_NO,
                                                  TIMEOUT,
                                                  &process_resolved_address,
                                                  ar);
   return GNUNET_OK;
 }

References address, AddressRecord::atsc, cfg, expiration, AddressRecord::expiration, GNUNET_asprintf(), GNUNET_assert, GNUNET_NO, GNUNET_OK, GNUNET_TIME_absolute_get_remaining(), GNUNET_TRANSPORT_address_to_string(), pc, AddressRecord::pc, process_resolved_address(), AddressRecord::result, and TIMEOUT.

Referenced by peerinfo_list_iteration().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ peerinfo_list_iteration()

void peerinfo_list_iteration	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		const struct GNUNET_HELLO_Message *	hello,
		const char *	err_msg
	)

Callback that processes each of the known HELLOs for the iteration response construction.

Parameters

cls	closure, NULL
peer	id of the peer, NULL for last call
hello	hello message for the peer (can be NULL)
err_msg	message

Definition at line 583 of file plugin_rest_peerinfo.c.

 {
   struct RequestHandle *handle = cls;
   struct PrintContext *pc;
   int friend_only;
  
   if (NULL == handle->response)
   {
     handle->response = json_array ();
   }
  
   if (NULL == peer)
   {
     handle->list_it = NULL;
     handle->emsg = GNUNET_strdup ("Error in communication with peerinfo");
     if (NULL != err_msg)
     {
       GNUNET_free (handle->emsg);
       handle->emsg = GNUNET_strdup (err_msg);
       handle->response_code = MHD_HTTP_INTERNAL_SERVER_ERROR;
     }
     if (NULL == pc_head)
       GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
   if (NULL == hello)
     return;
  
   friend_only = GNUNET_NO;
   if (NULL != hello)
     friend_only = GNUNET_HELLO_is_friend_only (hello);
  
   pc = GNUNET_new (struct PrintContext);
   GNUNET_CONTAINER_DLL_insert (pc_head,
                                pc_tail,
                                pc);
   pc->peer = *peer;
   pc->friend_only = friend_only;
   pc->handle = handle;
   GNUNET_HELLO_iterate_addresses (hello,
                                   GNUNET_NO,
                                   &count_address,
                                   pc);
   if (0 == pc->off)
   {
     dump_pc (pc);
     return;
   }
   pc->address_list_size = pc->off;
   pc->address_list = GNUNET_malloc (
     sizeof(struct AddressRecord) * pc->off);
   GNUNET_HELLO_iterate_addresses (hello,
                                   GNUNET_NO,
                                   &print_address,
                                   pc);
 }

References count_address(), do_error(), dump_pc(), PrintContext::friend_only, GNUNET_CONTAINER_DLL_insert, GNUNET_free, GNUNET_HELLO_is_friend_only(), GNUNET_HELLO_iterate_addresses(), GNUNET_malloc, GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, MHD_HTTP_INTERNAL_SERVER_ERROR, pc, pc_head, pc_tail, peer, and print_address().

Referenced by peerinfo_get().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ peerinfo_get()

void peerinfo_get	(	struct GNUNET_REST_RequestHandle *	con_handle,
		const char *	url,
		void *	cls
	)

Handle peerinfo GET request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 652 of file plugin_rest_peerinfo.c.

 {
   struct RequestHandle *handle = cls;
   struct GNUNET_HashCode key;
   const struct GNUNET_PeerIdentity *specific_peer;
   // GNUNET_PEER_Id peer_id;
   int include_friend_only;
   char*include_friend_only_str;
  
   include_friend_only = GNUNET_NO;
   GNUNET_CRYPTO_hash (GNUNET_REST_PEERINFO_FRIEND,
                       strlen (GNUNET_REST_PEERINFO_FRIEND),
                       &key);
   if (GNUNET_YES
       == GNUNET_CONTAINER_multihashmap_contains (con_handle->url_param_map,
                                                  &key))
   {
     include_friend_only_str = GNUNET_CONTAINER_multihashmap_get (
       con_handle->url_param_map, &key);
     if (0 == strcmp (include_friend_only_str, "yes"))
     {
       include_friend_only = GNUNET_YES;
     }
   }
  
   specific_peer = NULL;
   GNUNET_CRYPTO_hash (GNUNET_REST_PEERINFO_PEER,
                       strlen (GNUNET_REST_PEERINFO_PEER),
                       &key);
   if (GNUNET_YES
       == GNUNET_CONTAINER_multihashmap_contains (con_handle->url_param_map,
                                                  &key))
   {
     // peer_id = *(unsigned int*)GNUNET_CONTAINER_multihashmap_get (con_handle->url_param_map, &key);
     // specific_peer = GNUNET_PEER_resolve2(peer_id);
   }
  
   handle->list_it = GNUNET_PEERINFO_iterate (peerinfo_handle,
                                              include_friend_only,
                                              specific_peer,
                                              &peerinfo_list_iteration,
                                              handle);
 }

References GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CRYPTO_hash(), GNUNET_NO, GNUNET_PEERINFO_iterate(), GNUNET_REST_PEERINFO_FRIEND, GNUNET_REST_PEERINFO_PEER, GNUNET_YES, handle, include_friend_only, key, peerinfo_handle, peerinfo_list_iteration(), and GNUNET_REST_RequestHandle::url_param_map.

Here is the call graph for this function:

◆ options_cont()

static void options_cont	(	struct GNUNET_REST_RequestHandle *	con_handle,
		const char *	url,
		void *	cls
	)

static

Respond to OPTIONS request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 707 of file plugin_rest_peerinfo.c.

 {
   struct MHD_Response *resp;
   struct RequestHandle *handle = cls;
  
   // independent of path return all options
   resp = GNUNET_REST_create_response (NULL);
   MHD_add_response_header (resp,
                            "Access-Control-Allow-Methods",
                            allow_methods);
   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
   GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
   return;
 }

References allow_methods, cleanup_handle(), GNUNET_REST_create_response(), GNUNET_SCHEDULER_add_now(), handle, and MHD_HTTP_OK.

Here is the call graph for this function:

◆ rest_process_request()

static enum GNUNET_GenericReturnValue rest_process_request	(	struct GNUNET_REST_RequestHandle *	rest_handle,
		GNUNET_REST_ResultProcessor	proc,
		void *	proc_cls
	)

static

Function processing the REST call.

Parameters

method	HTTP method
url	URL of the HTTP request
data	body of the HTTP request (optional)
data_size	length of the body
proc	callback function for the result
proc_cls	closure for callback function

Returns: GNUNET_OK if request accepted

Definition at line 707 of file plugin_rest_peerinfo.c.

 {
   struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
   struct GNUNET_REST_RequestHandlerError err;
   static const struct GNUNET_REST_RequestHandler handlers[] = {
     { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_PEERINFO, &peerinfo_get },
     { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_PEERINFO, &options_cont },
     GNUNET_REST_HANDLER_END
   };
  
   handle->response_code = 0;
   handle->timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
                                                    60);
   handle->proc_cls = proc_cls;
   handle->proc = proc;
   handle->rest_handle = rest_handle;
  
   handle->url = GNUNET_strdup (rest_handle->url);
   if (handle->url[strlen (handle->url) - 1] == '/')
     handle->url[strlen (handle->url) - 1] = '\0';
   handle->timeout_task =
     GNUNET_SCHEDULER_add_delayed (handle->timeout,
                                   &do_error,
                                   handle);
   GNUNET_CONTAINER_DLL_insert (requests_head,
                                requests_tail,
                                handle);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
   if (GNUNET_NO == GNUNET_REST_handle_request (handle->rest_handle,
                                                handlers,
                                                &err,
                                                handle))
   {
     cleanup_handle (handle);
     return GNUNET_NO;
   }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
   return GNUNET_YES;
 }

Referenced by libgnunet_plugin_rest_peerinfo_init().

Here is the caller graph for this function:

◆ libgnunet_plugin_rest_peerinfo_init()

void* libgnunet_plugin_rest_peerinfo_init ( void * cls )

Entry point for the plugin.

Parameters

cls	Config info

Returns: NULL on error, otherwise the plugin context

Definition at line 787 of file plugin_rest_peerinfo.c.

 {
   static struct Plugin plugin;
   struct GNUNET_REST_Plugin *api;
  
   cfg = cls;
   if (NULL != plugin.cfg)
     return NULL;                /* can only initialize once! */
   memset (&plugin, 0, sizeof(struct Plugin));
   plugin.cfg = cfg;
   api = GNUNET_new (struct GNUNET_REST_Plugin);
   api->cls = &plugin;
   api->name = GNUNET_REST_API_NS_PEERINFO;
   api->process_request = &rest_process_request;
   GNUNET_asprintf (&allow_methods,
                    "%s, %s, %s, %s, %s",
                    MHD_HTTP_METHOD_GET,
                    MHD_HTTP_METHOD_POST,
                    MHD_HTTP_METHOD_PUT,
                    MHD_HTTP_METHOD_DELETE,
                    MHD_HTTP_METHOD_OPTIONS);
   peerinfo_handle = GNUNET_PEERINFO_connect (cfg);
  
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               _ ("Peerinfo REST API initialized\n"));
   return api;
 }

References _, allow_methods, cfg, GNUNET_REST_Plugin::cls, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_PEERINFO_connect(), GNUNET_REST_API_NS_PEERINFO, GNUNET_REST_Plugin::name, peerinfo_handle, plugin, GNUNET_REST_Plugin::process_request, and rest_process_request().

Here is the call graph for this function:

◆ libgnunet_plugin_rest_peerinfo_done()

void* libgnunet_plugin_rest_peerinfo_done ( void * cls )

Exit point from the plugin.

Parameters

cls	the plugin context (as returned by "init")

Returns: always NULL

Definition at line 823 of file plugin_rest_peerinfo.c.

 {
   struct GNUNET_REST_Plugin *api = cls;
   struct Plugin *plugin = api->cls;
  
   plugin->cfg = NULL;
   while (NULL != requests_head)
     cleanup_handle (requests_head);
   if (NULL != peerinfo_handle)
     GNUNET_PEERINFO_disconnect (peerinfo_handle);
  
   GNUNET_free (allow_methods);
   GNUNET_free (api);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Peerinfo REST plugin is finished\n");
   return NULL;
 }

References allow_methods, Plugin::api, cleanup_handle(), GNUNET_BLOCK_PluginFunctions::cls, GNUNET_REST_Plugin::cls, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_PEERINFO_disconnect(), peerinfo_handle, plugin, and requests_head.

Here is the call graph for this function:

Variable Documentation

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

The configuration handle.

Handle to our configuration.

Definition at line 68 of file plugin_rest_peerinfo.c.

Referenced by libgnunet_plugin_rest_peerinfo_init(), and print_address().

◆ allow_methods

char* allow_methods

static

HTTP methods allows for this plugin.

Definition at line 73 of file plugin_rest_peerinfo.c.

Referenced by libgnunet_plugin_rest_peerinfo_done(), libgnunet_plugin_rest_peerinfo_init(), and options_cont().

◆ peerinfo_handle

struct GNUNET_PEERINFO_Handle* peerinfo_handle

static

Handle to PEERINFO.

Definition at line 78 of file plugin_rest_peerinfo.c.

Referenced by cleanup_handle(), libgnunet_plugin_rest_peerinfo_done(), libgnunet_plugin_rest_peerinfo_init(), and peerinfo_get().

◆ pc_head

struct PrintContext* pc_head

static

Head of list of print contexts.

Definition at line 170 of file plugin_rest_peerinfo.c.

Referenced by dump_pc(), and peerinfo_list_iteration().

◆ pc_tail

struct PrintContext* pc_tail

static

Tail of list of print contexts.

Definition at line 175 of file plugin_rest_peerinfo.c.

Referenced by dump_pc(), and peerinfo_list_iteration().

◆ requests_head

struct RequestHandle* requests_head

static

DLL.

Definition at line 267 of file plugin_rest_peerinfo.c.

Referenced by cleanup_handle(), and libgnunet_plugin_rest_peerinfo_done().

◆ requests_tail

struct RequestHandle* requests_tail

static

DLL.

Definition at line 272 of file plugin_rest_peerinfo.c.

Referenced by cleanup_handle().

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

◆ GNUNET_REST_API_NS_PEERINFO

◆ GNUNET_REST_PEERINFO_PEER

◆ GNUNET_REST_PEERINFO_FRIEND

◆ GNUNET_REST_PEERINFO_ARRAY

◆ GNUNET_REST_PEERINFO_ERROR_UNKNOWN

◆ TIMEOUT

Function Documentation

◆ cleanup_handle()

◆ do_error()

◆ peerinfo_list_finished()

◆ count_address()

◆ dump_pc()

◆ process_resolved_address()

◆ print_address()

◆ peerinfo_list_iteration()

◆ peerinfo_get()

◆ options_cont()

◆ rest_process_request()

◆ libgnunet_plugin_rest_peerinfo_init()

◆ libgnunet_plugin_rest_peerinfo_done()

Variable Documentation

◆ cfg

◆ allow_methods

◆ peerinfo_handle

◆ pc_head

◆ pc_tail

◆ requests_head

◆ requests_tail