diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/dns/dns_api.c | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-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.c | 220 |
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 | */ |
34 | struct GNUNET_DNS_RequestHandle { | 34 | struct 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 | */ |
55 | struct GNUNET_DNS_Handle { | 56 | struct 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 | */ |
105 | static void | 107 | static void |
106 | reconnect(void *cls); | 108 | reconnect (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 | */ |
114 | static void | 116 | static void |
115 | force_reconnect(struct GNUNET_DNS_Handle *dh) | 117 | force_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 | */ |
137 | static void | 139 | static void |
138 | mq_error_handler(void *cls, | 140 | mq_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 | */ |
155 | static int | 157 | static int |
156 | check_request(void *cls, | 158 | check_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 | */ |
175 | static void | 177 | static void |
176 | handle_request(void *cls, | 178 | handle_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 | */ |
200 | static void | 202 | static void |
201 | reconnect(void *cls) | 203 | reconnect (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 | */ |
241 | void | 243 | void |
242 | GNUNET_DNS_request_forward(struct GNUNET_DNS_RequestHandle *rh) | 244 | GNUNET_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 | */ |
269 | void | 271 | void |
270 | GNUNET_DNS_request_drop(struct GNUNET_DNS_RequestHandle *rh) | 272 | GNUNET_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 | */ |
300 | void | 302 | void |
301 | GNUNET_DNS_request_answer(struct GNUNET_DNS_RequestHandle *rh, | 303 | GNUNET_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 | */ |
344 | struct GNUNET_DNS_Handle * | 346 | struct GNUNET_DNS_Handle * |
345 | GNUNET_DNS_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, | 347 | GNUNET_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 | */ |
367 | void | 369 | void |
368 | GNUNET_DNS_disconnect(struct GNUNET_DNS_Handle *dh) | 370 | GNUNET_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 */ |