Download JSON using libcurl. More...

Data Structures
struct	GNUNET_CURL_DownloadBuffer
	Buffer data structure we use to buffer the HTTP download before giving it to the JSON parser. More...

Typedefs
typedef void(*	GNUNET_CURL_RescheduleCallback) (void *cls)
	Function called by the context to ask for the event loop to be rescheduled, that is the application should call GNUNET_CURL_get_select_info() as the set of sockets we care about just changed. More...

typedef void (	GNUNET_CURL_RawParser) (struct GNUNET_CURL_DownloadBuffer db, CURL eh, long *response_code)
	Parses the raw response we got from the Web server. More...

typedef void(*	GNUNET_CURL_ResponseCleaner) (void *response)
	Deallocate the response. More...

typedef void(*	GNUNET_CURL_JobCompletionCallback) (void cls, long response_code, const void response)
	Function to call upon completion of a job. More...

Functions
struct GNUNET_CURL_Context *	GNUNET_CURL_init (GNUNET_CURL_RescheduleCallback cb, void *cb_cls)
	Initialise this library. More...

void	GNUNET_CURL_get_select_info (struct GNUNET_CURL_Context ctx, fd_set read_fd_set, fd_set write_fd_set, fd_set except_fd_set, int max_fd, long timeout)
	Obtain the information for a select() call to wait until GNUNET_CURL_perform() is ready again. More...

int	GNUNET_CURL_append_header (struct GNUNET_CURL_Context ctx, const char header)
	Add custom request header. More...

void	GNUNET_CURL_perform (struct GNUNET_CURL_Context *ctx)
	Run the main event loop for the CURL interaction. More...

void	GNUNET_CURL_perform2 (struct GNUNET_CURL_Context *ctx, GNUNET_CURL_RawParser rp, GNUNET_CURL_ResponseCleaner rc)
	Run the main event loop for the Taler interaction. More...

void	GNUNET_CURL_fini (struct GNUNET_CURL_Context *ctx)
	Cleanup library initialisation resources. More...

struct GNUNET_CURL_Job *	GNUNET_CURL_job_add (struct GNUNET_CURL_Context ctx, CURL eh, int add_json, GNUNET_CURL_JobCompletionCallback jcc, void *jcc_cls)
	Schedule a CURL request to be executed and call the given jcc upon its completion. More...

struct GNUNET_CURL_Job *	GNUNET_CURL_job_add2 (struct GNUNET_CURL_Context ctx, CURL eh, const struct curl_slist job_headers, GNUNET_CURL_JobCompletionCallback jcc, void jcc_cls)
	Schedule a CURL request to be executed and call the given jcc upon its completion. More...

void	GNUNET_CURL_job_cancel (struct GNUNET_CURL_Job *job)
	Cancel a job. More...

struct GNUNET_CURL_RescheduleContext *	GNUNET_CURL_gnunet_rc_create (struct GNUNET_CURL_Context *ctx)
	Initialize reschedule context. More...

struct GNUNET_CURL_RescheduleContext *	GNUNET_CURL_gnunet_rc_create_with_parser (struct GNUNET_CURL_Context *ctx, GNUNET_CURL_RawParser rp, GNUNET_CURL_ResponseCleaner rc)
	Initialize reschedule context; with custom response parser. More...

void	GNUNET_CURL_gnunet_rc_destroy (struct GNUNET_CURL_RescheduleContext *rc)
	Destroy reschedule context. More...

void	GNUNET_CURL_gnunet_scheduler_reschedule (void *cls)
	Implementation of the GNUNET_CURL_RescheduleCallback for GNUnet's scheduler. More...

void	GNUNET_CURL_enable_async_scope_header (struct GNUNET_CURL_Context ctx, const char header_name)
	Enable sending the async scope ID as a header. More...

Detailed Description

Download JSON using libcurl.

Typedef Documentation

◆ GNUNET_CURL_RescheduleCallback

typedef void(* GNUNET_CURL_RescheduleCallback) (void *cls)

Function called by the context to ask for the event loop to be rescheduled, that is the application should call GNUNET_CURL_get_select_info() as the set of sockets we care about just changed.

Parameters

cls closure

Definition at line 51 of file gnunet_curl_lib.h.

◆ GNUNET_CURL_RawParser

typedef void*(* GNUNET_CURL_RawParser) (struct GNUNET_CURL_DownloadBuffer *db, CURL *eh, long *response_code)

Parses the raw response we got from the Web server.

Parameters

db	the raw data
eh	handle
response_code	HTTP response code

Returns: the parsed object

Definition at line 88 of file gnunet_curl_lib.h.

◆ GNUNET_CURL_ResponseCleaner

typedef void(* GNUNET_CURL_ResponseCleaner) (void *response)

Deallocate the response.

Parameters

response object to clean

Definition at line 98 of file gnunet_curl_lib.h.

◆ GNUNET_CURL_JobCompletionCallback

typedef void(* GNUNET_CURL_JobCompletionCallback) (void *cls, long response_code, const void *response)

Function to call upon completion of a job.

Parameters

cls	closure
response_code	HTTP response code from server, 0 on hard error
json	response, NULL if response was not in JSON format

Definition at line 205 of file gnunet_curl_lib.h.

Function Documentation

◆ GNUNET_CURL_init()

struct GNUNET_CURL_Context* GNUNET_CURL_init	(	GNUNET_CURL_RescheduleCallback	cb,
		void *	cb_cls
	)

Initialise this library.

This function should be called before using any of the following functions.

Parameters

cb	function to call when rescheduling is required
cb_cls	closure for cb

Returns: library context

Definition at line 175 of file curl.c.

References GNUNET_CURL_Context::cb, GNUNET_CURL_Context::cb_cls, GNUNET_CURL_Job::ctx, curl_fail, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_new, GNUNET_CURL_Context::multi, multi, and GNUNET_CURL_Context::share.

 {
   struct GNUNET_CURL_Context *ctx;
   CURLM *multi;
   CURLSH *share;
 
   if (curl_fail)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Curl was not initialised properly\n");
     return NULL;
   }
   if (NULL == (multi = curl_multi_init ()))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Failed to create a Curl multi handle\n");
     return NULL;
   }
   if (NULL == (share = curl_share_init ()))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Failed to create a Curl share handle\n");
     return NULL;
   }
   ctx = GNUNET_new (struct GNUNET_CURL_Context);
   ctx->cb = cb;
   ctx->cb_cls = cb_cls;
   ctx->multi = multi;
   ctx->share = share;
   return ctx;
 }

◆ GNUNET_CURL_get_select_info()

void GNUNET_CURL_get_select_info	(	struct GNUNET_CURL_Context *	ctx,
		fd_set *	read_fd_set,
		fd_set *	write_fd_set,
		fd_set *	except_fd_set,
		int *	max_fd,
		long *	timeout
	)

Obtain the information for a select() call to wait until GNUNET_CURL_perform() is ready again.

Basically, a client should use this API to prepare for select(), then block on select(), then call GNUNET_CURL_perform() and then start again until the work with the context is done.

This function will NOT zero out the sets and assumes that max_fd and timeout are already set to minimal applicable values. It is safe to give this API FD-sets and max_fd and timeout that are already initialized to some other descriptors that need to go into the select() call.

Parameters

ctx	context to get the event loop information for
read_fd_set	will be set for any pending read operations
write_fd_set	will be set for any pending write operations
except_fd_set	is here because curl_multi_fdset() has this argument
max_fd	set to the highest FD included in any set; if the existing sets have no FDs in it, the initial value should be "-1". (Note that `max_fd + 1` will need to be passed to select().)
timeout	set to the timeout in milliseconds (!); -1 means no timeout (NULL, blocking forever is OK), 0 means to proceed immediately with GNUNET_CURL_perform().

Note that calling any other GNUNET_CURL-API may also imply that the library is again ready for GNUNET_CURL_perform().

Basically, a client should use this API to prepare for select(), then block on select(), then call GNUNET_CURL_perform() and then start again until the work with the context is done.

This function will NOT zero out the sets and assumes that max_fd and timeout are already set to minimal applicable values. It is safe to give this API FD-sets and max_fd and timeout that are already initialized to some other descriptors that need to go into the select() call.

Parameters

ctx	context to get the event loop information for
read_fd_set	will be set for any pending read operations
write_fd_set	will be set for any pending write operations
except_fd_set	is here because curl_multi_fdset() has this argument
max_fd	set to the highest FD included in any set; if the existing sets have no FDs in it, the initial value should be "-1". (Note that `max_fd + 1` will need to be passed to select().)
timeout	set to the timeout in milliseconds (!); -1 means no timeout (NULL, blocking forever is OK), 0 means to proceed immediately with GNUNET_CURL_perform().

Definition at line 659 of file curl.c.

References GNUNET_assert, GNUNET_MAX, GNUNET_CURL_Context::jobs_head, m, GNUNET_CURL_Context::multi, and timeout.

Referenced by context_task().

 {
   long to;
   int m;
 
   m = -1;
   GNUNET_assert (CURLM_OK == curl_multi_fdset (ctx->multi,
                                                read_fd_set,
                                                write_fd_set,
                                                except_fd_set,
                                                &m));
   to = *timeout;
   *max_fd = GNUNET_MAX (m, *max_fd);
   GNUNET_assert (CURLM_OK == curl_multi_timeout (ctx->multi, &to));
 
   /* Only if what we got back from curl is smaller than what we
      already had (-1 == infinity!), then update timeout */
   if ((to < *timeout) && (-1 != to))
     *timeout = to;
   if ((-1 == (*timeout)) && (NULL != ctx->jobs_head))
     *timeout = to;
 }

Here is the caller graph for this function:

◆ GNUNET_CURL_append_header()

int GNUNET_CURL_append_header	(	struct GNUNET_CURL_Context *	ctx,
		const char *	header
	)

Add custom request header.

Parameters

ctx	cURL context.
header	header string; will be given to the context AS IS.

Returns: GNUNET_OK if no errors occurred, GNUNET_SYSERR otherwise.

Definition at line 502 of file curl.c.

References GNUNET_CURL_Context::common_headers, GNUNET_OK, and GNUNET_SYSERR.

 {
   ctx->common_headers = curl_slist_append (ctx->common_headers, header);
   if (NULL == ctx->common_headers)
     return GNUNET_SYSERR;
 
   return GNUNET_OK;
 }

◆ GNUNET_CURL_perform()

void GNUNET_CURL_perform ( struct GNUNET_CURL_Context * ctx )

Run the main event loop for the CURL interaction.

Parameters

ctx	the library context

Run the main event loop for the CURL interaction.

Parameters

ctx	the library context

Definition at line 622 of file curl.c.

References GNUNET_CURL_download_get_result_(), and GNUNET_CURL_perform2().

 {
   GNUNET_CURL_perform2 (ctx,
                         &GNUNET_CURL_download_get_result_,
                         (GNUNET_CURL_ResponseCleaner) &json_decref);
 }

Here is the call graph for this function:

◆ GNUNET_CURL_perform2()

void GNUNET_CURL_perform2	(	struct GNUNET_CURL_Context *	ctx,
		GNUNET_CURL_RawParser	rp,
		GNUNET_CURL_ResponseCleaner	rc
	)

Run the main event loop for the Taler interaction.

Parameters

ctx	the library context
rp	parses the raw response returned from the Web server.
rc	cleans/frees the response

Definition at line 521 of file curl.c.

References UrlRequestData::bytes_received, UrlRequestData::bytes_sent, UrlRequestData::count, get_url_benchmark_data(), GNUNET_assert, GNUNET_break, GNUNET_CURL_job_cancel(), GNUNET_TIME_relative_add(), GNUNET_TIME_relative_max(), job, GNUNET_CURL_Context::multi, GNUNET_TIME_Relative::rel_value_us, response, rp, UrlRequestData::time, and UrlRequestData::time_max.

Referenced by context_task(), and GNUNET_CURL_perform().

 {
   CURLMsg *cmsg;
   int n_running;
   int n_completed;
 
   (void) curl_multi_perform (ctx->multi, &n_running);
   while (NULL != (cmsg = curl_multi_info_read (ctx->multi, &n_completed)))
   {
     struct GNUNET_CURL_Job *job;
     long response_code;
     void *response;
 
     /* Only documented return value is CURLMSG_DONE */
     GNUNET_break (CURLMSG_DONE == cmsg->msg);
     GNUNET_assert (CURLE_OK == curl_easy_getinfo (cmsg->easy_handle,
                                                   CURLINFO_PRIVATE,
                                                   (char **) &job));
     GNUNET_assert (job->ctx == ctx);
     response_code = 0;
     response = rp (&job->db, job->easy_handle, &response_code);
 #if ENABLE_BENCHMARK
     {
       char *url = NULL;
       double total_as_double = 0;
       struct GNUNET_TIME_Relative total;
       struct UrlRequestData *urd;
       /* Some care required, as curl is using data types (long vs curl_off_t vs
      * double) inconsistently to store byte count. */
       curl_off_t size_curl = 0;
       long size_long = 0;
       uint64_t bytes_sent = 0;
       uint64_t bytes_received = 0;
 
       GNUNET_break (CURLE_OK == curl_easy_getinfo (cmsg->easy_handle,
                                                    CURLINFO_TOTAL_TIME,
                                                    &total_as_double));
       total.rel_value_us = total_as_double * 1000 * 1000;
 
       GNUNET_break (CURLE_OK == curl_easy_getinfo (cmsg->easy_handle,
                                                    CURLINFO_EFFECTIVE_URL,
                                                    &url));
 
       /* HEADER_SIZE + SIZE_DOWNLOAD_T is hopefully the total
        number of bytes received, not clear from curl docs. */
 
       GNUNET_break (CURLE_OK == curl_easy_getinfo (cmsg->easy_handle,
                                                    CURLINFO_HEADER_SIZE,
                                                    &size_long));
       bytes_received += size_long;
 
       GNUNET_break (CURLE_OK == curl_easy_getinfo (cmsg->easy_handle,
                                                    CURLINFO_SIZE_DOWNLOAD_T,
                                                    &size_curl));
       bytes_received += size_curl;
 
       /* REQUEST_SIZE + SIZE_UPLOAD_T is hopefully the total number of bytes
        sent, again docs are not completely clear. */
 
       GNUNET_break (CURLE_OK == curl_easy_getinfo (cmsg->easy_handle,
                                                    CURLINFO_REQUEST_SIZE,
                                                    &size_long));
       bytes_sent += size_long;
 
       /* We obtain this value to check an invariant, but never use it otherwise. */
       GNUNET_break (CURLE_OK == curl_easy_getinfo (cmsg->easy_handle,
                                                    CURLINFO_SIZE_UPLOAD_T,
                                                    &size_curl));
 
       /* CURLINFO_SIZE_UPLOAD_T <= CURLINFO_REQUEST_SIZE should
        be an invariant.
        As verified with
          curl -w "foo%{size_request} -XPOST --data "ABC" $URL
       the CURLINFO_REQUEST_SIZE should be the whole size of the request
       including headers and body.
      */
       GNUNET_break (size_curl <= size_long);
 
       urd = get_url_benchmark_data (url, (unsigned int) response_code);
       urd->count++;
       urd->time = GNUNET_TIME_relative_add (urd->time, total);
       urd->time_max = GNUNET_TIME_relative_max (total, urd->time_max);
       urd->bytes_sent += bytes_sent;
       urd->bytes_received += bytes_received;
     }
 #endif
     job->jcc (job->jcc_cls, response_code, response);
     rc (response);
     GNUNET_CURL_job_cancel (job);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_CURL_fini()

void GNUNET_CURL_fini ( struct GNUNET_CURL_Context * ctx )

Cleanup library initialisation resources.

This function should be called after using this library to cleanup the resources occupied during library's initialisation.

Parameters

ctx	the library context

Definition at line 696 of file curl.c.

References GNUNET_CURL_Context::common_headers, GNUNET_assert, GNUNET_free, GNUNET_CURL_Context::jobs_head, GNUNET_CURL_Context::multi, and GNUNET_CURL_Context::share.

 {
   /* all jobs must have been cancelled at this time, assert this */
   GNUNET_assert (NULL == ctx->jobs_head);
   curl_share_cleanup (ctx->share);
   curl_multi_cleanup (ctx->multi);
   curl_slist_free_all (ctx->common_headers);
   GNUNET_free (ctx);
 }

◆ GNUNET_CURL_job_add()

struct GNUNET_CURL_Job* GNUNET_CURL_job_add	(	struct GNUNET_CURL_Context *	ctx,
		CURL *	eh,
		int	add_json,
		GNUNET_CURL_JobCompletionCallback	jcc,
		void *	jcc_cls
	)

Schedule a CURL request to be executed and call the given jcc upon its completion.

Note that the context will make use of the CURLOPT_PRIVATE facility of the CURL eh.

This function modifies the CURL handle to add the "Content-Type: application/json" header if add_json is set.

Parameters

ctx	context to execute the job in
eh	curl easy handle for the request, will be executed AND cleaned up
add_json	add "application/json" content type header
jcc	callback to invoke upon completion
jcc_cls	closure for jcc

Returns: NULL on error (in this case, is still released!)

Definition at line 372 of file curl.c.

References GNUNET_assert, GNUNET_CURL_job_add2(), GNUNET_YES, job, and GNUNET_CURL_Job::job_headers.

 {
   struct GNUNET_CURL_Job *job;
   struct curl_slist *job_headers = NULL;
 
   if (GNUNET_YES == add_json)
   {
     GNUNET_assert (
       NULL != (job_headers =
                  curl_slist_append (NULL, "Content-Type: application/json")));
   }
 
   job = GNUNET_CURL_job_add2 (ctx, eh, job_headers, jcc, jcc_cls);
   curl_slist_free_all (job_headers);
   return job;
 }

Here is the call graph for this function:

◆ GNUNET_CURL_job_add2()

struct GNUNET_CURL_Job* GNUNET_CURL_job_add2	(	struct GNUNET_CURL_Context *	ctx,
		CURL *	eh,
		const struct curl_slist *	job_headers,
		GNUNET_CURL_JobCompletionCallback	jcc,
		void *	jcc_cls
	)

Schedule a CURL request to be executed and call the given jcc upon its completion.

Note that the context will make use of the CURLOPT_PRIVATE facility of the CURL eh.

This function modifies the CURL handle to add the "Content-Type: application/json" header if add_json is set.

Parameters

ctx	context to execute the job in
eh	curl easy handle for the request, will be executed AND cleaned up
job_headers	extra headers to add for this request
jcc	callback to invoke upon completion
jcc_cls	closure for jcc

Returns: NULL on error (in this case, is still released!)

Note that the context will make use of the CURLOPT_PRIVATE facility of the CURL eh.

This function modifies the CURL handle to add the "Content-Type: application/json" header if add_json is set.

Parameters

ctx	context to execute the job in
eh	curl easy handle for the request, will be executed AND cleaned up. NOTE: the handle should never have gotten any headers list, as that would then be ovverridden by jcc. Therefore, always pass custom headers as the job_headers parameter.
job_headers	extra headers to add for this request
jcc	callback to invoke upon completion
jcc_cls	closure for jcc

Returns: NULL on error (in this case, is still released!)

Definition at line 280 of file curl.c.

Referenced by GNUNET_CURL_job_add().

 {
   struct GNUNET_CURL_Job *job;
   struct curl_slist *all_headers = NULL;
 
   for (const struct curl_slist *curr = job_headers; curr != NULL;
        curr = curr->next)
   {
     GNUNET_assert (NULL !=
                    (all_headers = curl_slist_append (all_headers, curr->data)));
   }
 
   for (const struct curl_slist *curr = ctx->common_headers; curr != NULL;
        curr = curr->next)
   {
     GNUNET_assert (NULL !=
                    (all_headers = curl_slist_append (all_headers, curr->data)));
   }
 
   if (NULL != ctx->async_scope_id_header)
   {
     struct GNUNET_AsyncScopeSave scope;
 
     GNUNET_async_scope_get (&scope);
     if (GNUNET_YES == scope.have_scope)
     {
       char *aid_header = NULL;
       aid_header =
         GNUNET_STRINGS_data_to_string_alloc (&scope.scope_id,
                                              sizeof (
                                                struct GNUNET_AsyncScopeId));
       GNUNET_assert (NULL != aid_header);
       GNUNET_assert (NULL != curl_slist_append (all_headers, aid_header));
       GNUNET_free (aid_header);
     }
   }
 
   if (CURLE_OK != curl_easy_setopt (eh, CURLOPT_HTTPHEADER, all_headers))
   {
     GNUNET_break (0);
     curl_slist_free_all (all_headers);
     curl_easy_cleanup (eh);
     return NULL;
   }
 
   job = GNUNET_new (struct GNUNET_CURL_Job);
   job->job_headers = all_headers;
 
   if ((CURLE_OK != curl_easy_setopt (eh, CURLOPT_PRIVATE, job)) ||
       (CURLE_OK !=
        curl_easy_setopt (eh, CURLOPT_WRITEFUNCTION, &download_cb)) ||
       (CURLE_OK != curl_easy_setopt (eh, CURLOPT_WRITEDATA, &job->db)) ||
       (CURLE_OK != curl_easy_setopt (eh, CURLOPT_SHARE, ctx->share)) ||
       (CURLM_OK != curl_multi_add_handle (ctx->multi, eh)))
   {
     GNUNET_break (0);
     GNUNET_free (job);
     curl_easy_cleanup (eh);
     return NULL;
   }
 
   job->easy_handle = eh;
   job->ctx = ctx;
   job->jcc = jcc;
   job->jcc_cls = jcc_cls;
   GNUNET_CONTAINER_DLL_insert (ctx->jobs_head, ctx->jobs_tail, job);
   ctx->cb (ctx->cb_cls);
   return job;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_CURL_job_cancel()

void GNUNET_CURL_job_cancel ( struct GNUNET_CURL_Job * job )

Cancel a job.

Must only be called before the job completion callback is called for the respective job.

Parameters

job	job to cancel

Definition at line 401 of file curl.c.

References GNUNET_CURL_DownloadBuffer::buf, GNUNET_CURL_Job::ctx, GNUNET_CURL_Job::db, GNUNET_CURL_Job::easy_handle, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_free_non_null, GNUNET_CURL_Job::job_headers, GNUNET_CURL_Context::jobs_head, GNUNET_CURL_Context::jobs_tail, and GNUNET_CURL_Context::multi.

Referenced by GNUNET_CURL_perform2().

 {
   struct GNUNET_CURL_Context *ctx = job->ctx;
 
   GNUNET_CONTAINER_DLL_remove (ctx->jobs_head, ctx->jobs_tail, job);
   GNUNET_break (CURLM_OK ==
                 curl_multi_remove_handle (ctx->multi, job->easy_handle));
   curl_easy_cleanup (job->easy_handle);
   GNUNET_free_non_null (job->db.buf);
   curl_slist_free_all (job->job_headers);
   GNUNET_free (job);
 }

Here is the caller graph for this function:

◆ GNUNET_CURL_gnunet_rc_create()

struct GNUNET_CURL_RescheduleContext* GNUNET_CURL_gnunet_rc_create ( struct GNUNET_CURL_Context * ctx )

Initialize reschedule context.

Parameters

ctx	context to manage

Returns: closure for GNUNET_CURL_gnunet_scheduler_reschedule().

Definition at line 102 of file curl_reschedule.c.

References clean_result(), GNUNET_CURL_RescheduleContext::cleaner, GNUNET_CURL_RescheduleContext::ctx, GNUNET_CURL_download_get_result_(), GNUNET_new, and GNUNET_CURL_RescheduleContext::parser.

 {
   struct GNUNET_CURL_RescheduleContext *rc;
 
   rc = GNUNET_new (struct GNUNET_CURL_RescheduleContext);
   rc->ctx = ctx;
   rc->parser = &GNUNET_CURL_download_get_result_;
   rc->cleaner = &clean_result;
   return rc;
 }

Here is the call graph for this function:

◆ GNUNET_CURL_gnunet_rc_create_with_parser()

struct GNUNET_CURL_RescheduleContext* GNUNET_CURL_gnunet_rc_create_with_parser	(	struct GNUNET_CURL_Context *	ctx,
		GNUNET_CURL_RawParser	rp,
		GNUNET_CURL_ResponseCleaner	rc
	)

Initialize reschedule context; with custom response parser.

Parameters

ctx	context to manage

Returns: closure for GNUNET_CURL_gnunet_scheduler_reschedule().

Definition at line 69 of file curl_reschedule.c.

References GNUNET_CURL_RescheduleContext::cleaner, GNUNET_CURL_RescheduleContext::ctx, GNUNET_new, GNUNET_CURL_RescheduleContext::parser, and rp.

 {
   struct GNUNET_CURL_RescheduleContext *rctx;
 
   rctx = GNUNET_new (struct GNUNET_CURL_RescheduleContext);
   rctx->ctx = ctx;
   rctx->parser = rp;
   rctx->cleaner = rc;
 
   return rctx;
 }

◆ GNUNET_CURL_gnunet_rc_destroy()

void GNUNET_CURL_gnunet_rc_destroy ( struct GNUNET_CURL_RescheduleContext * rc )

Destroy reschedule context.

Parameters

rc	context to destroy

Definition at line 120 of file curl_reschedule.c.

References GNUNET_free, GNUNET_SCHEDULER_cancel(), and GNUNET_CURL_RescheduleContext::task.

 {
   if (NULL != rc->task)
     GNUNET_SCHEDULER_cancel (rc->task);
   GNUNET_free (rc);
 }

Here is the call graph for this function:

◆ GNUNET_CURL_gnunet_scheduler_reschedule()

void GNUNET_CURL_gnunet_scheduler_reschedule ( void * cls )

Implementation of the GNUNET_CURL_RescheduleCallback for GNUnet's scheduler.

Will run the CURL context using GNUnet's scheduler. Note that you MUST immediately destroy the reschedule context after calling GNUNET_CURL_fini().

Parameters

cls	must point to a `struct GNUNET_CURL_RescheduleContext *` (pointer to a pointer!)

Definition at line 191 of file curl_reschedule.c.

References context_task(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), and GNUNET_CURL_RescheduleContext::task.

 {
   struct GNUNET_CURL_RescheduleContext *rc = *(void **) cls;
 
   if (NULL != rc->task)
     GNUNET_SCHEDULER_cancel (rc->task);
   rc->task = GNUNET_SCHEDULER_add_now (&context_task, rc);
 }

Here is the call graph for this function:

◆ GNUNET_CURL_enable_async_scope_header()

void GNUNET_CURL_enable_async_scope_header	(	struct GNUNET_CURL_Context *	ctx,
		const char *	header_name
	)

Enable sending the async scope ID as a header.

Parameters

ctx	the context to enable this for
header_name	name of the header to send.

Definition at line 214 of file curl.c.

References GNUNET_CURL_Context::async_scope_id_header.

 {
   ctx->async_scope_id_header = header_name;
 }

Data Structures

Typedefs

Functions

Detailed Description

Typedef Documentation

◆ GNUNET_CURL_RescheduleCallback

◆ GNUNET_CURL_RawParser

◆ GNUNET_CURL_ResponseCleaner

◆ GNUNET_CURL_JobCompletionCallback

Function Documentation

◆ GNUNET_CURL_init()

◆ GNUNET_CURL_get_select_info()

◆ GNUNET_CURL_append_header()

◆ GNUNET_CURL_perform()

◆ GNUNET_CURL_perform2()

◆ GNUNET_CURL_fini()

◆ GNUNET_CURL_job_add()

◆ GNUNET_CURL_job_add2()

◆ GNUNET_CURL_job_cancel()

◆ GNUNET_CURL_gnunet_rc_create()

◆ GNUNET_CURL_gnunet_rc_create_with_parser()

◆ GNUNET_CURL_gnunet_rc_destroy()

◆ GNUNET_CURL_gnunet_scheduler_reschedule()

◆ GNUNET_CURL_enable_async_scope_header()