1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
/*
This file is part of GNUnet
Copyright (C) 2014, 2015, 2016 GNUnet e.V.
GNUnet is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License,
or (at your option) any later version.
GNUnet is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file src/include/gnunet_curl_lib.h
* @brief library to make it easy to download JSON replies over HTTP
* @author Sree Harsha Totakura <sreeharsha@totakura.in>
* @author Christian Grothoff
*
* @defgroup curl CURL integration library
* Download JSON using libcurl.
* @{
*/
#ifndef GNUNET_CURL_LIB_H
#define GNUNET_CURL_LIB_H
#if HAVE_CURL_CURL_H
#include <curl/curl.h>
#elif HAVE_GNURL_CURL_H
#include <gnurl/curl.h>
#else
#error "needs curl or gnurl"
#endif
#include <jansson.h>
#include "gnunet_util_lib.h"
/**
* 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.
*
* @param cls closure
*/
typedef void
(*GNUNET_CURL_RescheduleCallback)(void *cls);
/**
* Initialise this library. This function should be called before using any of
* the following functions.
*
* @param cb function to call when rescheduling is required
* @param cb_cls closure for @a cb
* @return library context
*/
struct GNUNET_CURL_Context *
GNUNET_CURL_init (GNUNET_CURL_RescheduleCallback cb,
void *cb_cls);
/**
* 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 @a max_fd
* and @a timeout are already set to minimal applicable values. It is
* safe to give this API FD-sets and @a max_fd and @a timeout that are
* already initialized to some other descriptors that need to go into
* the select() call.
*
* @param ctx context to get the event loop information for
* @param read_fd_set will be set for any pending read operations
* @param write_fd_set will be set for any pending write operations
* @param except_fd_set is here because curl_multi_fdset() has this argument
* @param 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().)
* @param 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().
*/
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);
/**
* Run the main event loop for the CURL interaction.
*
* @param ctx the library context
*/
void
GNUNET_CURL_perform (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.
*
* @param ctx the library context
*/
void
GNUNET_CURL_fini (struct GNUNET_CURL_Context *ctx);
/**
* Entry in the context's job queue.
*/
struct GNUNET_CURL_Job;
/**
* Function to call upon completion of a job.
*
* @param cls closure
* @param response_code HTTP response code from server, 0 on hard error
* @param json response, NULL if response was not in JSON format
*/
typedef void
(*GNUNET_CURL_JobCompletionCallback)(void *cls,
long response_code,
const json_t *json);
/**
* Schedule a CURL request to be executed and call the given @a jcc
* upon its completion. Note that the context will make use of the
* CURLOPT_PRIVATE facility of the CURL @a eh.
*
* This function modifies the CURL handle to add the
* "Content-Type: application/json" header if @a add_json is set.
*
* @param ctx context to execute the job in
* @param eh curl easy handle for the request, will
* be executed AND cleaned up
* @param add_json add "application/json" content type header
* @param jcc callback to invoke upon completion
* @param jcc_cls closure for @a jcc
* @return NULL on error (in this case, @eh is still released!)
*/
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);
/**
* Cancel a job. Must only be called before the job completion
* callback is called for the respective job.
*
* @param job job to cancel
*/
void
GNUNET_CURL_job_cancel (struct GNUNET_CURL_Job *job);
/* ******* GNUnet SCHEDULER integration ************ */
/**
* Closure for #GNUNET_CURL_gnunet_scheduler_reschedule().
*/
struct GNUNET_CURL_RescheduleContext;
/**
* Initialize reschedule context.
*
* @param ctx context to manage
* @return closure for #GNUNET_CURL_gnunet_scheduler_reschedule().
*/
struct GNUNET_CURL_RescheduleContext *
GNUNET_CURL_gnunet_rc_create (struct GNUNET_CURL_Context *ctx);
/**
* Destroy reschedule context.
*
* @param rc context to destroy
*/
void
GNUNET_CURL_gnunet_rc_destroy (struct GNUNET_CURL_RescheduleContext *rc);
/**
* 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().
*
* @param cls must point to a `struct GNUNET_CURL_RescheduleContext *`
* (pointer to a pointer!)
*/
void
GNUNET_CURL_gnunet_scheduler_reschedule (void *cls);
#endif
/** @} */ /* end of group */
/* end of gnunet_curl_lib.h */
|
