aboutsummaryrefslogtreecommitdiff
path: root/src/dns/dns_api.c
diff options
context:
space:
mode:
authorChristian Grothoff <christian@grothoff.org>2019-10-05 15:09:28 +0200
committerChristian Grothoff <christian@grothoff.org>2019-10-05 15:09:28 +0200
commitc4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch)
treecac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/dns/dns_api.c
parentfbb71d527c7d6babf269a8fefce1db291b9f7068 (diff)
downloadgnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz
gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/dns/dns_api.c')
-rw-r--r--src/dns/dns_api.c220
1 files changed, 111 insertions, 109 deletions
diff --git a/src/dns/dns_api.c b/src/dns/dns_api.c
index 4dc8e00dd..cd208d820 100644
--- a/src/dns/dns_api.c
+++ b/src/dns/dns_api.c
@@ -31,7 +31,8 @@
31/** 31/**
32 * Handle to identify an individual DNS request. 32 * Handle to identify an individual DNS request.
33 */ 33 */
34struct GNUNET_DNS_RequestHandle { 34struct GNUNET_DNS_RequestHandle
35{
35 /** 36 /**
36 * Handle to DNS API. 37 * Handle to DNS API.
37 */ 38 */
@@ -52,7 +53,8 @@ struct GNUNET_DNS_RequestHandle {
52/** 53/**
53 * DNS handle 54 * DNS handle
54 */ 55 */
55struct GNUNET_DNS_Handle { 56struct GNUNET_DNS_Handle
57{
56 /** 58 /**
57 * Connection to DNS service, or NULL. 59 * Connection to DNS service, or NULL.
58 */ 60 */
@@ -103,7 +105,7 @@ struct GNUNET_DNS_Handle {
103 * @param tc scheduler context (unused) 105 * @param tc scheduler context (unused)
104 */ 106 */
105static void 107static void
106reconnect(void *cls); 108reconnect (void *cls);
107 109
108 110
109/** 111/**
@@ -112,17 +114,17 @@ reconnect(void *cls);
112 * @param dh handle with the connection 114 * @param dh handle with the connection
113 */ 115 */
114static void 116static void
115force_reconnect(struct GNUNET_DNS_Handle *dh) 117force_reconnect (struct GNUNET_DNS_Handle *dh)
116{ 118{
117 if (NULL != dh->mq) 119 if (NULL != dh->mq)
118 { 120 {
119 GNUNET_MQ_destroy(dh->mq); 121 GNUNET_MQ_destroy (dh->mq);
120 dh->mq = NULL; 122 dh->mq = NULL;
121 } 123 }
122 dh->reconnect_task = 124 dh->reconnect_task =
123 GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, 125 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
124 &reconnect, 126 &reconnect,
125 dh); 127 dh);
126} 128}
127 129
128 130
@@ -135,12 +137,12 @@ force_reconnect(struct GNUNET_DNS_Handle *dh)
135 * @param error error code 137 * @param error error code
136 */ 138 */
137static void 139static void
138mq_error_handler(void *cls, 140mq_error_handler (void *cls,
139 enum GNUNET_MQ_Error error) 141 enum GNUNET_MQ_Error error)
140{ 142{
141 struct GNUNET_DNS_Handle *dh = cls; 143 struct GNUNET_DNS_Handle *dh = cls;
142 144
143 force_reconnect(dh); 145 force_reconnect (dh);
144} 146}
145 147
146 148
@@ -153,14 +155,14 @@ mq_error_handler(void *cls,
153 * @param req message from the service (request) 155 * @param req message from the service (request)
154 */ 156 */
155static int 157static int
156check_request(void *cls, 158check_request (void *cls,
157 const struct GNUNET_DNS_Request *req) 159 const struct GNUNET_DNS_Request *req)
158{ 160{
159 if (0 != ntohl(req->reserved)) 161 if (0 != ntohl (req->reserved))
160 { 162 {
161 GNUNET_break(0); 163 GNUNET_break (0);
162 return GNUNET_SYSERR; 164 return GNUNET_SYSERR;
163 } 165 }
164 return GNUNET_OK; 166 return GNUNET_OK;
165} 167}
166 168
@@ -173,22 +175,22 @@ check_request(void *cls,
173 * @param msg message from the service (request) 175 * @param msg message from the service (request)
174 */ 176 */
175static void 177static void
176handle_request(void *cls, 178handle_request (void *cls,
177 const struct GNUNET_DNS_Request *req) 179 const struct GNUNET_DNS_Request *req)
178{ 180{
179 struct GNUNET_DNS_Handle *dh = cls; 181 struct GNUNET_DNS_Handle *dh = cls;
180 size_t payload_length = ntohs(req->header.size) - sizeof(*req); 182 size_t payload_length = ntohs (req->header.size) - sizeof(*req);
181 struct GNUNET_DNS_RequestHandle *rh; 183 struct GNUNET_DNS_RequestHandle *rh;
182 184
183 rh = GNUNET_new(struct GNUNET_DNS_RequestHandle); 185 rh = GNUNET_new (struct GNUNET_DNS_RequestHandle);
184 rh->dh = dh; 186 rh->dh = dh;
185 rh->request_id = req->request_id; 187 rh->request_id = req->request_id;
186 rh->generation = dh->generation; 188 rh->generation = dh->generation;
187 dh->pending_requests++; 189 dh->pending_requests++;
188 dh->rh(dh->rh_cls, 190 dh->rh (dh->rh_cls,
189 rh, 191 rh,
190 payload_length, 192 payload_length,
191 (const char*)&req[1]); 193 (const char*) &req[1]);
192} 194}
193 195
194 196
@@ -198,33 +200,33 @@ handle_request(void *cls,
198 * @param cls handle with the connection to connect 200 * @param cls handle with the connection to connect
199 */ 201 */
200static void 202static void
201reconnect(void *cls) 203reconnect (void *cls)
202{ 204{
203 struct GNUNET_DNS_Handle *dh = cls; 205 struct GNUNET_DNS_Handle *dh = cls;
204 struct GNUNET_MQ_MessageHandler handlers[] = { 206 struct GNUNET_MQ_MessageHandler handlers[] = {
205 GNUNET_MQ_hd_var_size(request, 207 GNUNET_MQ_hd_var_size (request,
206 GNUNET_MESSAGE_TYPE_DNS_CLIENT_REQUEST, 208 GNUNET_MESSAGE_TYPE_DNS_CLIENT_REQUEST,
207 struct GNUNET_DNS_Request, 209 struct GNUNET_DNS_Request,
208 dh), 210 dh),
209 GNUNET_MQ_handler_end() 211 GNUNET_MQ_handler_end ()
210 }; 212 };
211 struct GNUNET_MQ_Envelope *env; 213 struct GNUNET_MQ_Envelope *env;
212 struct GNUNET_DNS_Register *msg; 214 struct GNUNET_DNS_Register *msg;
213 215
214 dh->reconnect_task = NULL; 216 dh->reconnect_task = NULL;
215 dh->mq = GNUNET_CLIENT_connect(dh->cfg, 217 dh->mq = GNUNET_CLIENT_connect (dh->cfg,
216 "dns", 218 "dns",
217 handlers, 219 handlers,
218 &mq_error_handler, 220 &mq_error_handler,
219 dh); 221 dh);
220 if (NULL == dh->mq) 222 if (NULL == dh->mq)
221 return; 223 return;
222 dh->generation++; 224 dh->generation++;
223 env = GNUNET_MQ_msg(msg, 225 env = GNUNET_MQ_msg (msg,
224 GNUNET_MESSAGE_TYPE_DNS_CLIENT_INIT); 226 GNUNET_MESSAGE_TYPE_DNS_CLIENT_INIT);
225 msg->flags = htonl(dh->flags); 227 msg->flags = htonl (dh->flags);
226 GNUNET_MQ_send(dh->mq, 228 GNUNET_MQ_send (dh->mq,
227 env); 229 env);
228} 230}
229 231
230 232
@@ -239,24 +241,24 @@ reconnect(void *cls)
239 * @param rh request that should now be forwarded 241 * @param rh request that should now be forwarded
240 */ 242 */
241void 243void
242GNUNET_DNS_request_forward(struct GNUNET_DNS_RequestHandle *rh) 244GNUNET_DNS_request_forward (struct GNUNET_DNS_RequestHandle *rh)
243{ 245{
244 struct GNUNET_MQ_Envelope *env; 246 struct GNUNET_MQ_Envelope *env;
245 struct GNUNET_DNS_Response *resp; 247 struct GNUNET_DNS_Response *resp;
246 248
247 GNUNET_assert(0 < rh->dh->pending_requests--); 249 GNUNET_assert (0 < rh->dh->pending_requests--);
248 if (rh->generation != rh->dh->generation) 250 if (rh->generation != rh->dh->generation)
249 { 251 {
250 GNUNET_free(rh); 252 GNUNET_free (rh);
251 return; 253 return;
252 } 254 }
253 env = GNUNET_MQ_msg(resp, 255 env = GNUNET_MQ_msg (resp,
254 GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE); 256 GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE);
255 resp->drop_flag = htonl(1); 257 resp->drop_flag = htonl (1);
256 resp->request_id = rh->request_id; 258 resp->request_id = rh->request_id;
257 GNUNET_MQ_send(rh->dh->mq, 259 GNUNET_MQ_send (rh->dh->mq,
258 env); 260 env);
259 GNUNET_free(rh); 261 GNUNET_free (rh);
260} 262}
261 263
262 264
@@ -267,24 +269,24 @@ GNUNET_DNS_request_forward(struct GNUNET_DNS_RequestHandle *rh)
267 * @param rh request that should now be dropped 269 * @param rh request that should now be dropped
268 */ 270 */
269void 271void
270GNUNET_DNS_request_drop(struct GNUNET_DNS_RequestHandle *rh) 272GNUNET_DNS_request_drop (struct GNUNET_DNS_RequestHandle *rh)
271{ 273{
272 struct GNUNET_MQ_Envelope *env; 274 struct GNUNET_MQ_Envelope *env;
273 struct GNUNET_DNS_Response *resp; 275 struct GNUNET_DNS_Response *resp;
274 276
275 GNUNET_assert(0 < rh->dh->pending_requests--); 277 GNUNET_assert (0 < rh->dh->pending_requests--);
276 if (rh->generation != rh->dh->generation) 278 if (rh->generation != rh->dh->generation)
277 { 279 {
278 GNUNET_free(rh); 280 GNUNET_free (rh);
279 return; 281 return;
280 } 282 }
281 env = GNUNET_MQ_msg(resp, 283 env = GNUNET_MQ_msg (resp,
282 GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE); 284 GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE);
283 resp->request_id = rh->request_id; 285 resp->request_id = rh->request_id;
284 resp->drop_flag = htonl(0); 286 resp->drop_flag = htonl (0);
285 GNUNET_MQ_send(rh->dh->mq, 287 GNUNET_MQ_send (rh->dh->mq,
286 env); 288 env);
287 GNUNET_free(rh); 289 GNUNET_free (rh);
288} 290}
289 291
290 292
@@ -298,37 +300,37 @@ GNUNET_DNS_request_drop(struct GNUNET_DNS_RequestHandle *rh)
298 * @param reply reply data 300 * @param reply reply data
299 */ 301 */
300void 302void
301GNUNET_DNS_request_answer(struct GNUNET_DNS_RequestHandle *rh, 303GNUNET_DNS_request_answer (struct GNUNET_DNS_RequestHandle *rh,
302 uint16_t reply_length, 304 uint16_t reply_length,
303 const char *reply) 305 const char *reply)
304{ 306{
305 struct GNUNET_MQ_Envelope *env; 307 struct GNUNET_MQ_Envelope *env;
306 struct GNUNET_DNS_Response *resp; 308 struct GNUNET_DNS_Response *resp;
307 309
308 GNUNET_assert(0 < rh->dh->pending_requests--); 310 GNUNET_assert (0 < rh->dh->pending_requests--);
309 if (rh->generation != rh->dh->generation) 311 if (rh->generation != rh->dh->generation)
310 { 312 {
311 GNUNET_free(rh); 313 GNUNET_free (rh);
312 return; 314 return;
313 } 315 }
314 if (reply_length + sizeof(struct GNUNET_DNS_Response) 316 if (reply_length + sizeof(struct GNUNET_DNS_Response)
315 >= GNUNET_MAX_MESSAGE_SIZE) 317 >= GNUNET_MAX_MESSAGE_SIZE)
316 { 318 {
317 GNUNET_break(0); 319 GNUNET_break (0);
318 GNUNET_free(rh); 320 GNUNET_free (rh);
319 return; 321 return;
320 } 322 }
321 env = GNUNET_MQ_msg_extra(resp, 323 env = GNUNET_MQ_msg_extra (resp,
322 reply_length, 324 reply_length,
323 GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE); 325 GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE);
324 resp->drop_flag = htonl(2); 326 resp->drop_flag = htonl (2);
325 resp->request_id = rh->request_id; 327 resp->request_id = rh->request_id;
326 GNUNET_memcpy(&resp[1], 328 GNUNET_memcpy (&resp[1],
327 reply, 329 reply,
328 reply_length); 330 reply_length);
329 GNUNET_MQ_send(rh->dh->mq, 331 GNUNET_MQ_send (rh->dh->mq,
330 env); 332 env);
331 GNUNET_free(rh); 333 GNUNET_free (rh);
332} 334}
333 335
334 336
@@ -342,19 +344,19 @@ GNUNET_DNS_request_answer(struct GNUNET_DNS_RequestHandle *rh,
342 * @return DNS handle 344 * @return DNS handle
343 */ 345 */
344struct GNUNET_DNS_Handle * 346struct GNUNET_DNS_Handle *
345GNUNET_DNS_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, 347GNUNET_DNS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
346 enum GNUNET_DNS_Flags flags, 348 enum GNUNET_DNS_Flags flags,
347 GNUNET_DNS_RequestHandler rh, 349 GNUNET_DNS_RequestHandler rh,
348 void *rh_cls) 350 void *rh_cls)
349{ 351{
350 struct GNUNET_DNS_Handle *dh; 352 struct GNUNET_DNS_Handle *dh;
351 353
352 dh = GNUNET_new(struct GNUNET_DNS_Handle); 354 dh = GNUNET_new (struct GNUNET_DNS_Handle);
353 dh->cfg = cfg; 355 dh->cfg = cfg;
354 dh->flags = flags; 356 dh->flags = flags;
355 dh->rh = rh; 357 dh->rh = rh;
356 dh->rh_cls = rh_cls; 358 dh->rh_cls = rh_cls;
357 dh->reconnect_task = GNUNET_SCHEDULER_add_now(&reconnect, dh); 359 dh->reconnect_task = GNUNET_SCHEDULER_add_now (&reconnect, dh);
358 return dh; 360 return dh;
359} 361}
360 362
@@ -365,21 +367,21 @@ GNUNET_DNS_connect(const struct GNUNET_CONFIGURATION_Handle *cfg,
365 * @param dh DNS handle 367 * @param dh DNS handle
366 */ 368 */
367void 369void
368GNUNET_DNS_disconnect(struct GNUNET_DNS_Handle *dh) 370GNUNET_DNS_disconnect (struct GNUNET_DNS_Handle *dh)
369{ 371{
370 if (NULL != dh->mq) 372 if (NULL != dh->mq)
371 { 373 {
372 GNUNET_MQ_destroy(dh->mq); 374 GNUNET_MQ_destroy (dh->mq);
373 dh->mq = NULL; 375 dh->mq = NULL;
374 } 376 }
375 if (NULL != dh->reconnect_task) 377 if (NULL != dh->reconnect_task)
376 { 378 {
377 GNUNET_SCHEDULER_cancel(dh->reconnect_task); 379 GNUNET_SCHEDULER_cancel (dh->reconnect_task);
378 dh->reconnect_task = NULL; 380 dh->reconnect_task = NULL;
379 } 381 }
380 /* make sure client has no pending requests left over! */ 382 /* make sure client has no pending requests left over! */
381 GNUNET_break(0 == dh->pending_requests); 383 GNUNET_break (0 == dh->pending_requests);
382 GNUNET_free(dh); 384 GNUNET_free (dh);
383} 385}
384 386
385/* end of dns_api.c */ 387/* end of dns_api.c */