diff options
author | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
---|---|---|
committer | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
commit | d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb (patch) | |
tree | 9efd18ea7d425652085ed0bd5e8e45604bc5f6b9 /src/dns | |
parent | a0fce305c565c0937d917a92712f15e9c5736260 (diff) | |
download | gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.tar.gz gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.zip |
uncrustify as demanded.
Diffstat (limited to 'src/dns')
-rw-r--r-- | src/dns/dns.h | 17 | ||||
-rw-r--r-- | src/dns/dns_api.c | 225 | ||||
-rw-r--r-- | src/dns/gnunet-dns-monitor.c | 380 | ||||
-rw-r--r-- | src/dns/gnunet-dns-redirector.c | 234 | ||||
-rw-r--r-- | src/dns/gnunet-helper-dns.c | 1336 | ||||
-rw-r--r-- | src/dns/gnunet-service-dns.c | 1251 | ||||
-rw-r--r-- | src/dns/gnunet-zonewalk.c | 593 | ||||
-rw-r--r-- | src/dns/plugin_block_dns.c | 191 |
8 files changed, 2131 insertions, 2096 deletions
diff --git a/src/dns/dns.h b/src/dns/dns.h index af86bbaed..12d8f6025 100644 --- a/src/dns/dns.h +++ b/src/dns/dns.h | |||
@@ -11,7 +11,7 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
@@ -32,10 +32,9 @@ GNUNET_NETWORK_STRUCT_BEGIN | |||
32 | /** | 32 | /** |
33 | * Message from client to DNS service to register itself. | 33 | * Message from client to DNS service to register itself. |
34 | */ | 34 | */ |
35 | struct GNUNET_DNS_Register | 35 | struct GNUNET_DNS_Register { |
36 | { | ||
37 | /** | 36 | /** |
38 | * Header of type #GNUNET_MESSAGE_TYPE_DNS_CLIENT_INIT | 37 | * Header of type #GNUNET_MESSAGE_TYPE_DNS_CLIENT_INIT |
39 | */ | 38 | */ |
40 | struct GNUNET_MessageHeader header; | 39 | struct GNUNET_MessageHeader header; |
41 | 40 | ||
@@ -49,10 +48,9 @@ struct GNUNET_DNS_Register | |||
49 | /** | 48 | /** |
50 | * Message from DNS service to client: please handle a request. | 49 | * Message from DNS service to client: please handle a request. |
51 | */ | 50 | */ |
52 | struct GNUNET_DNS_Request | 51 | struct GNUNET_DNS_Request { |
53 | { | ||
54 | /** | 52 | /** |
55 | * Header of type #GNUNET_MESSAGE_TYPE_DNS_CLIENT_REQUEST | 53 | * Header of type #GNUNET_MESSAGE_TYPE_DNS_CLIENT_REQUEST |
56 | */ | 54 | */ |
57 | struct GNUNET_MessageHeader header; | 55 | struct GNUNET_MessageHeader header; |
58 | 56 | ||
@@ -67,15 +65,13 @@ struct GNUNET_DNS_Request | |||
67 | uint64_t request_id GNUNET_PACKED; | 65 | uint64_t request_id GNUNET_PACKED; |
68 | 66 | ||
69 | /* followed by original DNS request (without UDP header) */ | 67 | /* followed by original DNS request (without UDP header) */ |
70 | |||
71 | }; | 68 | }; |
72 | 69 | ||
73 | 70 | ||
74 | /** | 71 | /** |
75 | * Message from client to DNS service: here is my reply. | 72 | * Message from client to DNS service: here is my reply. |
76 | */ | 73 | */ |
77 | struct GNUNET_DNS_Response | 74 | struct GNUNET_DNS_Response { |
78 | { | ||
79 | /** | 75 | /** |
80 | * Header of type #GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE | 76 | * Header of type #GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE |
81 | */ | 77 | */ |
@@ -92,7 +88,6 @@ struct GNUNET_DNS_Response | |||
92 | uint64_t request_id GNUNET_PACKED; | 88 | uint64_t request_id GNUNET_PACKED; |
93 | 89 | ||
94 | /* followed by original DNS request (without UDP header) */ | 90 | /* followed by original DNS request (without UDP header) */ |
95 | |||
96 | }; | 91 | }; |
97 | 92 | ||
98 | 93 | ||
diff --git a/src/dns/dns_api.c b/src/dns/dns_api.c index e34f02ef0..4dc8e00dd 100644 --- a/src/dns/dns_api.c +++ b/src/dns/dns_api.c | |||
@@ -11,7 +11,7 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
@@ -31,9 +31,7 @@ | |||
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 | { | ||
36 | |||
37 | /** | 35 | /** |
38 | * Handle to DNS API. | 36 | * Handle to DNS API. |
39 | */ | 37 | */ |
@@ -48,16 +46,13 @@ struct GNUNET_DNS_RequestHandle | |||
48 | * Re-connect counter, to make sure we did not reconnect in the meantime. | 46 | * Re-connect counter, to make sure we did not reconnect in the meantime. |
49 | */ | 47 | */ |
50 | uint32_t generation; | 48 | uint32_t generation; |
51 | |||
52 | }; | 49 | }; |
53 | 50 | ||
54 | 51 | ||
55 | /** | 52 | /** |
56 | * DNS handle | 53 | * DNS handle |
57 | */ | 54 | */ |
58 | struct GNUNET_DNS_Handle | 55 | struct GNUNET_DNS_Handle { |
59 | { | ||
60 | |||
61 | /** | 56 | /** |
62 | * Connection to DNS service, or NULL. | 57 | * Connection to DNS service, or NULL. |
63 | */ | 58 | */ |
@@ -108,7 +103,7 @@ struct GNUNET_DNS_Handle | |||
108 | * @param tc scheduler context (unused) | 103 | * @param tc scheduler context (unused) |
109 | */ | 104 | */ |
110 | static void | 105 | static void |
111 | reconnect (void *cls); | 106 | reconnect(void *cls); |
112 | 107 | ||
113 | 108 | ||
114 | /** | 109 | /** |
@@ -117,17 +112,17 @@ reconnect (void *cls); | |||
117 | * @param dh handle with the connection | 112 | * @param dh handle with the connection |
118 | */ | 113 | */ |
119 | static void | 114 | static void |
120 | force_reconnect (struct GNUNET_DNS_Handle *dh) | 115 | force_reconnect(struct GNUNET_DNS_Handle *dh) |
121 | { | 116 | { |
122 | if (NULL != dh->mq) | 117 | if (NULL != dh->mq) |
123 | { | 118 | { |
124 | GNUNET_MQ_destroy (dh->mq); | 119 | GNUNET_MQ_destroy(dh->mq); |
125 | dh->mq = NULL; | 120 | dh->mq = NULL; |
126 | } | 121 | } |
127 | dh->reconnect_task = | 122 | dh->reconnect_task = |
128 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, | 123 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, |
129 | &reconnect, | 124 | &reconnect, |
130 | dh); | 125 | dh); |
131 | } | 126 | } |
132 | 127 | ||
133 | 128 | ||
@@ -140,12 +135,12 @@ force_reconnect (struct GNUNET_DNS_Handle *dh) | |||
140 | * @param error error code | 135 | * @param error error code |
141 | */ | 136 | */ |
142 | static void | 137 | static void |
143 | mq_error_handler (void *cls, | 138 | mq_error_handler(void *cls, |
144 | enum GNUNET_MQ_Error error) | 139 | enum GNUNET_MQ_Error error) |
145 | { | 140 | { |
146 | struct GNUNET_DNS_Handle *dh = cls; | 141 | struct GNUNET_DNS_Handle *dh = cls; |
147 | 142 | ||
148 | force_reconnect (dh); | 143 | force_reconnect(dh); |
149 | } | 144 | } |
150 | 145 | ||
151 | 146 | ||
@@ -158,14 +153,14 @@ mq_error_handler (void *cls, | |||
158 | * @param req message from the service (request) | 153 | * @param req message from the service (request) |
159 | */ | 154 | */ |
160 | static int | 155 | static int |
161 | check_request (void *cls, | 156 | check_request(void *cls, |
162 | const struct GNUNET_DNS_Request *req) | 157 | const struct GNUNET_DNS_Request *req) |
163 | { | 158 | { |
164 | if (0 != ntohl (req->reserved)) | 159 | if (0 != ntohl(req->reserved)) |
165 | { | 160 | { |
166 | GNUNET_break (0); | 161 | GNUNET_break(0); |
167 | return GNUNET_SYSERR; | 162 | return GNUNET_SYSERR; |
168 | } | 163 | } |
169 | return GNUNET_OK; | 164 | return GNUNET_OK; |
170 | } | 165 | } |
171 | 166 | ||
@@ -178,22 +173,22 @@ check_request (void *cls, | |||
178 | * @param msg message from the service (request) | 173 | * @param msg message from the service (request) |
179 | */ | 174 | */ |
180 | static void | 175 | static void |
181 | handle_request (void *cls, | 176 | handle_request(void *cls, |
182 | const struct GNUNET_DNS_Request *req) | 177 | const struct GNUNET_DNS_Request *req) |
183 | { | 178 | { |
184 | struct GNUNET_DNS_Handle *dh = cls; | 179 | struct GNUNET_DNS_Handle *dh = cls; |
185 | size_t payload_length = ntohs (req->header.size) - sizeof (*req); | 180 | size_t payload_length = ntohs(req->header.size) - sizeof(*req); |
186 | struct GNUNET_DNS_RequestHandle *rh; | 181 | struct GNUNET_DNS_RequestHandle *rh; |
187 | 182 | ||
188 | rh = GNUNET_new (struct GNUNET_DNS_RequestHandle); | 183 | rh = GNUNET_new(struct GNUNET_DNS_RequestHandle); |
189 | rh->dh =dh; | 184 | rh->dh = dh; |
190 | rh->request_id = req->request_id; | 185 | rh->request_id = req->request_id; |
191 | rh->generation = dh->generation; | 186 | rh->generation = dh->generation; |
192 | dh->pending_requests++; | 187 | dh->pending_requests++; |
193 | dh->rh (dh->rh_cls, | 188 | dh->rh(dh->rh_cls, |
194 | rh, | 189 | rh, |
195 | payload_length, | 190 | payload_length, |
196 | (const char*) &req[1]); | 191 | (const char*)&req[1]); |
197 | } | 192 | } |
198 | 193 | ||
199 | 194 | ||
@@ -203,33 +198,33 @@ handle_request (void *cls, | |||
203 | * @param cls handle with the connection to connect | 198 | * @param cls handle with the connection to connect |
204 | */ | 199 | */ |
205 | static void | 200 | static void |
206 | reconnect (void *cls) | 201 | reconnect(void *cls) |
207 | { | 202 | { |
208 | struct GNUNET_DNS_Handle *dh = cls; | 203 | struct GNUNET_DNS_Handle *dh = cls; |
209 | struct GNUNET_MQ_MessageHandler handlers[] = { | 204 | struct GNUNET_MQ_MessageHandler handlers[] = { |
210 | GNUNET_MQ_hd_var_size (request, | 205 | GNUNET_MQ_hd_var_size(request, |
211 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_REQUEST, | 206 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_REQUEST, |
212 | struct GNUNET_DNS_Request, | 207 | struct GNUNET_DNS_Request, |
213 | dh), | 208 | dh), |
214 | GNUNET_MQ_handler_end () | 209 | GNUNET_MQ_handler_end() |
215 | }; | 210 | }; |
216 | struct GNUNET_MQ_Envelope *env; | 211 | struct GNUNET_MQ_Envelope *env; |
217 | struct GNUNET_DNS_Register *msg; | 212 | struct GNUNET_DNS_Register *msg; |
218 | 213 | ||
219 | dh->reconnect_task = NULL; | 214 | dh->reconnect_task = NULL; |
220 | dh->mq = GNUNET_CLIENT_connect (dh->cfg, | 215 | dh->mq = GNUNET_CLIENT_connect(dh->cfg, |
221 | "dns", | 216 | "dns", |
222 | handlers, | 217 | handlers, |
223 | &mq_error_handler, | 218 | &mq_error_handler, |
224 | dh); | 219 | dh); |
225 | if (NULL == dh->mq) | 220 | if (NULL == dh->mq) |
226 | return; | 221 | return; |
227 | dh->generation++; | 222 | dh->generation++; |
228 | env = GNUNET_MQ_msg (msg, | 223 | env = GNUNET_MQ_msg(msg, |
229 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_INIT); | 224 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_INIT); |
230 | msg->flags = htonl (dh->flags); | 225 | msg->flags = htonl(dh->flags); |
231 | GNUNET_MQ_send (dh->mq, | 226 | GNUNET_MQ_send(dh->mq, |
232 | env); | 227 | env); |
233 | } | 228 | } |
234 | 229 | ||
235 | 230 | ||
@@ -244,24 +239,24 @@ reconnect (void *cls) | |||
244 | * @param rh request that should now be forwarded | 239 | * @param rh request that should now be forwarded |
245 | */ | 240 | */ |
246 | void | 241 | void |
247 | GNUNET_DNS_request_forward (struct GNUNET_DNS_RequestHandle *rh) | 242 | GNUNET_DNS_request_forward(struct GNUNET_DNS_RequestHandle *rh) |
248 | { | 243 | { |
249 | struct GNUNET_MQ_Envelope *env; | 244 | struct GNUNET_MQ_Envelope *env; |
250 | struct GNUNET_DNS_Response *resp; | 245 | struct GNUNET_DNS_Response *resp; |
251 | 246 | ||
252 | GNUNET_assert (0 < rh->dh->pending_requests--); | 247 | GNUNET_assert(0 < rh->dh->pending_requests--); |
253 | if (rh->generation != rh->dh->generation) | 248 | if (rh->generation != rh->dh->generation) |
254 | { | 249 | { |
255 | GNUNET_free (rh); | 250 | GNUNET_free(rh); |
256 | return; | 251 | return; |
257 | } | 252 | } |
258 | env = GNUNET_MQ_msg (resp, | 253 | env = GNUNET_MQ_msg(resp, |
259 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE); | 254 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE); |
260 | resp->drop_flag = htonl (1); | 255 | resp->drop_flag = htonl(1); |
261 | resp->request_id = rh->request_id; | 256 | resp->request_id = rh->request_id; |
262 | GNUNET_MQ_send (rh->dh->mq, | 257 | GNUNET_MQ_send(rh->dh->mq, |
263 | env); | 258 | env); |
264 | GNUNET_free (rh); | 259 | GNUNET_free(rh); |
265 | } | 260 | } |
266 | 261 | ||
267 | 262 | ||
@@ -272,24 +267,24 @@ GNUNET_DNS_request_forward (struct GNUNET_DNS_RequestHandle *rh) | |||
272 | * @param rh request that should now be dropped | 267 | * @param rh request that should now be dropped |
273 | */ | 268 | */ |
274 | void | 269 | void |
275 | GNUNET_DNS_request_drop (struct GNUNET_DNS_RequestHandle *rh) | 270 | GNUNET_DNS_request_drop(struct GNUNET_DNS_RequestHandle *rh) |
276 | { | 271 | { |
277 | struct GNUNET_MQ_Envelope *env; | 272 | struct GNUNET_MQ_Envelope *env; |
278 | struct GNUNET_DNS_Response *resp; | 273 | struct GNUNET_DNS_Response *resp; |
279 | 274 | ||
280 | GNUNET_assert (0 < rh->dh->pending_requests--); | 275 | GNUNET_assert(0 < rh->dh->pending_requests--); |
281 | if (rh->generation != rh->dh->generation) | 276 | if (rh->generation != rh->dh->generation) |
282 | { | 277 | { |
283 | GNUNET_free (rh); | 278 | GNUNET_free(rh); |
284 | return; | 279 | return; |
285 | } | 280 | } |
286 | env = GNUNET_MQ_msg (resp, | 281 | env = GNUNET_MQ_msg(resp, |
287 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE); | 282 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE); |
288 | resp->request_id = rh->request_id; | 283 | resp->request_id = rh->request_id; |
289 | resp->drop_flag = htonl (0); | 284 | resp->drop_flag = htonl(0); |
290 | GNUNET_MQ_send (rh->dh->mq, | 285 | GNUNET_MQ_send(rh->dh->mq, |
291 | env); | 286 | env); |
292 | GNUNET_free (rh); | 287 | GNUNET_free(rh); |
293 | } | 288 | } |
294 | 289 | ||
295 | 290 | ||
@@ -303,37 +298,37 @@ GNUNET_DNS_request_drop (struct GNUNET_DNS_RequestHandle *rh) | |||
303 | * @param reply reply data | 298 | * @param reply reply data |
304 | */ | 299 | */ |
305 | void | 300 | void |
306 | GNUNET_DNS_request_answer (struct GNUNET_DNS_RequestHandle *rh, | 301 | GNUNET_DNS_request_answer(struct GNUNET_DNS_RequestHandle *rh, |
307 | uint16_t reply_length, | 302 | uint16_t reply_length, |
308 | const char *reply) | 303 | const char *reply) |
309 | { | 304 | { |
310 | struct GNUNET_MQ_Envelope *env; | 305 | struct GNUNET_MQ_Envelope *env; |
311 | struct GNUNET_DNS_Response *resp; | 306 | struct GNUNET_DNS_Response *resp; |
312 | 307 | ||
313 | GNUNET_assert (0 < rh->dh->pending_requests--); | 308 | GNUNET_assert(0 < rh->dh->pending_requests--); |
314 | if (rh->generation != rh->dh->generation) | 309 | if (rh->generation != rh->dh->generation) |
315 | { | 310 | { |
316 | GNUNET_free (rh); | 311 | GNUNET_free(rh); |
317 | return; | 312 | return; |
318 | } | 313 | } |
319 | if (reply_length + sizeof (struct GNUNET_DNS_Response) | 314 | if (reply_length + sizeof(struct GNUNET_DNS_Response) |
320 | >= GNUNET_MAX_MESSAGE_SIZE) | 315 | >= GNUNET_MAX_MESSAGE_SIZE) |
321 | { | 316 | { |
322 | GNUNET_break (0); | 317 | GNUNET_break(0); |
323 | GNUNET_free (rh); | 318 | GNUNET_free(rh); |
324 | return; | 319 | return; |
325 | } | 320 | } |
326 | env = GNUNET_MQ_msg_extra (resp, | 321 | env = GNUNET_MQ_msg_extra(resp, |
327 | reply_length, | 322 | reply_length, |
328 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE); | 323 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE); |
329 | resp->drop_flag = htonl (2); | 324 | resp->drop_flag = htonl(2); |
330 | resp->request_id = rh->request_id; | 325 | resp->request_id = rh->request_id; |
331 | GNUNET_memcpy (&resp[1], | 326 | GNUNET_memcpy(&resp[1], |
332 | reply, | 327 | reply, |
333 | reply_length); | 328 | reply_length); |
334 | GNUNET_MQ_send (rh->dh->mq, | 329 | GNUNET_MQ_send(rh->dh->mq, |
335 | env); | 330 | env); |
336 | GNUNET_free (rh); | 331 | GNUNET_free(rh); |
337 | } | 332 | } |
338 | 333 | ||
339 | 334 | ||
@@ -347,19 +342,19 @@ GNUNET_DNS_request_answer (struct GNUNET_DNS_RequestHandle *rh, | |||
347 | * @return DNS handle | 342 | * @return DNS handle |
348 | */ | 343 | */ |
349 | struct GNUNET_DNS_Handle * | 344 | struct GNUNET_DNS_Handle * |
350 | GNUNET_DNS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, | 345 | GNUNET_DNS_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, |
351 | enum GNUNET_DNS_Flags flags, | 346 | enum GNUNET_DNS_Flags flags, |
352 | GNUNET_DNS_RequestHandler rh, | 347 | GNUNET_DNS_RequestHandler rh, |
353 | void *rh_cls) | 348 | void *rh_cls) |
354 | { | 349 | { |
355 | struct GNUNET_DNS_Handle *dh; | 350 | struct GNUNET_DNS_Handle *dh; |
356 | 351 | ||
357 | dh = GNUNET_new (struct GNUNET_DNS_Handle); | 352 | dh = GNUNET_new(struct GNUNET_DNS_Handle); |
358 | dh->cfg = cfg; | 353 | dh->cfg = cfg; |
359 | dh->flags = flags; | 354 | dh->flags = flags; |
360 | dh->rh = rh; | 355 | dh->rh = rh; |
361 | dh->rh_cls = rh_cls; | 356 | dh->rh_cls = rh_cls; |
362 | dh->reconnect_task = GNUNET_SCHEDULER_add_now (&reconnect, dh); | 357 | dh->reconnect_task = GNUNET_SCHEDULER_add_now(&reconnect, dh); |
363 | return dh; | 358 | return dh; |
364 | } | 359 | } |
365 | 360 | ||
@@ -370,21 +365,21 @@ GNUNET_DNS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
370 | * @param dh DNS handle | 365 | * @param dh DNS handle |
371 | */ | 366 | */ |
372 | void | 367 | void |
373 | GNUNET_DNS_disconnect (struct GNUNET_DNS_Handle *dh) | 368 | GNUNET_DNS_disconnect(struct GNUNET_DNS_Handle *dh) |
374 | { | 369 | { |
375 | if (NULL != dh->mq) | 370 | if (NULL != dh->mq) |
376 | { | 371 | { |
377 | GNUNET_MQ_destroy (dh->mq); | 372 | GNUNET_MQ_destroy(dh->mq); |
378 | dh->mq = NULL; | 373 | dh->mq = NULL; |
379 | } | 374 | } |
380 | if (NULL != dh->reconnect_task) | 375 | if (NULL != dh->reconnect_task) |
381 | { | 376 | { |
382 | GNUNET_SCHEDULER_cancel (dh->reconnect_task); | 377 | GNUNET_SCHEDULER_cancel(dh->reconnect_task); |
383 | dh->reconnect_task = NULL; | 378 | dh->reconnect_task = NULL; |
384 | } | 379 | } |
385 | /* make sure client has no pending requests left over! */ | 380 | /* make sure client has no pending requests left over! */ |
386 | GNUNET_break (0 == dh->pending_requests); | 381 | GNUNET_break(0 == dh->pending_requests); |
387 | GNUNET_free (dh); | 382 | GNUNET_free(dh); |
388 | } | 383 | } |
389 | 384 | ||
390 | /* end of dns_api.c */ | 385 | /* end of dns_api.c */ |
diff --git a/src/dns/gnunet-dns-monitor.c b/src/dns/gnunet-dns-monitor.c index e822b3211..819cb025d 100644 --- a/src/dns/gnunet-dns-monitor.c +++ b/src/dns/gnunet-dns-monitor.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file src/dns/gnunet-dns-monitor.c | 22 | * @file src/dns/gnunet-dns-monitor.c |
@@ -62,22 +62,31 @@ static unsigned int verbosity; | |||
62 | * @return type as string, only valid until the next call to this function | 62 | * @return type as string, only valid until the next call to this function |
63 | */ | 63 | */ |
64 | static const char * | 64 | static const char * |
65 | get_type (uint16_t type) | 65 | get_type(uint16_t type) |
66 | { | 66 | { |
67 | static char buf[6]; | 67 | static char buf[6]; |
68 | |||
68 | switch (type) | 69 | switch (type) |
69 | { | 70 | { |
70 | case GNUNET_DNSPARSER_TYPE_A: return "A"; | 71 | case GNUNET_DNSPARSER_TYPE_A: return "A"; |
71 | case GNUNET_DNSPARSER_TYPE_NS: return "NS"; | 72 | |
72 | case GNUNET_DNSPARSER_TYPE_CNAME: return "CNAME"; | 73 | case GNUNET_DNSPARSER_TYPE_NS: return "NS"; |
73 | case GNUNET_DNSPARSER_TYPE_SOA: return "SOA"; | 74 | |
74 | case GNUNET_DNSPARSER_TYPE_PTR: return "PTR"; | 75 | case GNUNET_DNSPARSER_TYPE_CNAME: return "CNAME"; |
75 | case GNUNET_DNSPARSER_TYPE_MX: return "MX"; | 76 | |
76 | case GNUNET_DNSPARSER_TYPE_TXT: return "TXT"; | 77 | case GNUNET_DNSPARSER_TYPE_SOA: return "SOA"; |
77 | case GNUNET_DNSPARSER_TYPE_AAAA: return "AAAA"; | 78 | |
78 | case GNUNET_DNSPARSER_TYPE_SRV: return "SRV"; | 79 | case GNUNET_DNSPARSER_TYPE_PTR: return "PTR"; |
79 | } | 80 | |
80 | GNUNET_snprintf (buf, sizeof (buf), "%u", (unsigned int) type); | 81 | case GNUNET_DNSPARSER_TYPE_MX: return "MX"; |
82 | |||
83 | case GNUNET_DNSPARSER_TYPE_TXT: return "TXT"; | ||
84 | |||
85 | case GNUNET_DNSPARSER_TYPE_AAAA: return "AAAA"; | ||
86 | |||
87 | case GNUNET_DNSPARSER_TYPE_SRV: return "SRV"; | ||
88 | } | ||
89 | GNUNET_snprintf(buf, sizeof(buf), "%u", (unsigned int)type); | ||
81 | return buf; | 90 | return buf; |
82 | } | 91 | } |
83 | 92 | ||
@@ -89,16 +98,19 @@ get_type (uint16_t type) | |||
89 | * @return class as string, only valid until the next call to this function | 98 | * @return class as string, only valid until the next call to this function |
90 | */ | 99 | */ |
91 | static const char * | 100 | static const char * |
92 | get_class (uint16_t class) | 101 | get_class(uint16_t class) |
93 | { | 102 | { |
94 | static char buf[6]; | 103 | static char buf[6]; |
104 | |||
95 | switch (class) | 105 | switch (class) |
96 | { | 106 | { |
97 | case GNUNET_TUN_DNS_CLASS_INTERNET: return "IN"; | 107 | case GNUNET_TUN_DNS_CLASS_INTERNET: return "IN"; |
98 | case GNUNET_TUN_DNS_CLASS_CHAOS: return "CHAOS"; | 108 | |
99 | case GNUNET_TUN_DNS_CLASS_HESIOD: return "HESIOD"; | 109 | case GNUNET_TUN_DNS_CLASS_CHAOS: return "CHAOS"; |
100 | } | 110 | |
101 | GNUNET_snprintf (buf, sizeof (buf), "%u", (unsigned int) class); | 111 | case GNUNET_TUN_DNS_CLASS_HESIOD: return "HESIOD"; |
112 | } | ||
113 | GNUNET_snprintf(buf, sizeof(buf), "%u", (unsigned int)class); | ||
102 | return buf; | 114 | return buf; |
103 | } | 115 | } |
104 | 116 | ||
@@ -109,13 +121,13 @@ get_class (uint16_t class) | |||
109 | * @param query query to display. | 121 | * @param query query to display. |
110 | */ | 122 | */ |
111 | static void | 123 | static void |
112 | display_query (const struct GNUNET_DNSPARSER_Query *query) | 124 | display_query(const struct GNUNET_DNSPARSER_Query *query) |
113 | { | 125 | { |
114 | fprintf (stdout, | 126 | fprintf(stdout, |
115 | "\t\t%s %s: %s\n", | 127 | "\t\t%s %s: %s\n", |
116 | get_class (query->dns_traffic_class), | 128 | get_class(query->dns_traffic_class), |
117 | get_type (query->type), | 129 | get_type(query->type), |
118 | query->name); | 130 | query->name); |
119 | } | 131 | } |
120 | 132 | ||
121 | 133 | ||
@@ -125,7 +137,7 @@ display_query (const struct GNUNET_DNSPARSER_Query *query) | |||
125 | * @param record record to display. | 137 | * @param record record to display. |
126 | */ | 138 | */ |
127 | static void | 139 | static void |
128 | display_record (const struct GNUNET_DNSPARSER_Record *record) | 140 | display_record(const struct GNUNET_DNSPARSER_Record *record) |
129 | { | 141 | { |
130 | const char *format; | 142 | const char *format; |
131 | char buf[INET6_ADDRSTRLEN]; | 143 | char buf[INET6_ADDRSTRLEN]; |
@@ -133,86 +145,93 @@ display_record (const struct GNUNET_DNSPARSER_Record *record) | |||
133 | 145 | ||
134 | tmp = NULL; | 146 | tmp = NULL; |
135 | switch (record->type) | 147 | switch (record->type) |
136 | { | ||
137 | case GNUNET_DNSPARSER_TYPE_A: | ||
138 | if (record->data.raw.data_len != sizeof (struct in_addr)) | ||
139 | format = "<invalid>"; | ||
140 | else | ||
141 | format = inet_ntop (AF_INET, record->data.raw.data, buf, sizeof (buf)); | ||
142 | break; | ||
143 | case GNUNET_DNSPARSER_TYPE_AAAA: | ||
144 | if (record->data.raw.data_len != sizeof (struct in6_addr)) | ||
145 | format = "<invalid>"; | ||
146 | else | ||
147 | format = inet_ntop (AF_INET6, record->data.raw.data, buf, sizeof (buf)); | ||
148 | break; | ||
149 | case GNUNET_DNSPARSER_TYPE_NS: | ||
150 | case GNUNET_DNSPARSER_TYPE_CNAME: | ||
151 | case GNUNET_DNSPARSER_TYPE_PTR: | ||
152 | format = record->data.hostname; | ||
153 | break; | ||
154 | case GNUNET_DNSPARSER_TYPE_SOA: | ||
155 | if (NULL == record->data.soa) | ||
156 | format = "<invalid>"; | ||
157 | else | ||
158 | { | 148 | { |
159 | GNUNET_asprintf (&tmp, | 149 | case GNUNET_DNSPARSER_TYPE_A: |
160 | "origin: %s, mail: %s, serial = %u, refresh = %u s, retry = %u s, expire = %u s, minimum = %u s", | 150 | if (record->data.raw.data_len != sizeof(struct in_addr)) |
161 | record->data.soa->mname, | 151 | format = "<invalid>"; |
162 | record->data.soa->rname, | 152 | else |
163 | (unsigned int) record->data.soa->serial, | 153 | format = inet_ntop(AF_INET, record->data.raw.data, buf, sizeof(buf)); |
164 | (unsigned int) record->data.soa->refresh, | 154 | break; |
165 | (unsigned int) record->data.soa->retry, | 155 | |
166 | (unsigned int) record->data.soa->expire, | 156 | case GNUNET_DNSPARSER_TYPE_AAAA: |
167 | (unsigned int) record->data.soa->minimum_ttl); | 157 | if (record->data.raw.data_len != sizeof(struct in6_addr)) |
168 | format = tmp; | 158 | format = "<invalid>"; |
169 | } | 159 | else |
170 | break; | 160 | format = inet_ntop(AF_INET6, record->data.raw.data, buf, sizeof(buf)); |
171 | case GNUNET_DNSPARSER_TYPE_MX: | 161 | break; |
172 | if (record->data.mx == NULL) | 162 | |
173 | format = "<invalid>"; | 163 | case GNUNET_DNSPARSER_TYPE_NS: |
174 | else | 164 | case GNUNET_DNSPARSER_TYPE_CNAME: |
175 | { | 165 | case GNUNET_DNSPARSER_TYPE_PTR: |
176 | GNUNET_asprintf (&tmp, | 166 | format = record->data.hostname; |
177 | "%u: %s", | 167 | break; |
178 | record->data.mx->preference, | 168 | |
179 | record->data.mx->mxhost); | 169 | case GNUNET_DNSPARSER_TYPE_SOA: |
180 | format = tmp; | 170 | if (NULL == record->data.soa) |
181 | } | 171 | format = "<invalid>"; |
182 | break; | 172 | else |
183 | case GNUNET_DNSPARSER_TYPE_SRV: | 173 | { |
184 | if (NULL == record->data.srv) | 174 | GNUNET_asprintf(&tmp, |
185 | format = "<invalid>"; | 175 | "origin: %s, mail: %s, serial = %u, refresh = %u s, retry = %u s, expire = %u s, minimum = %u s", |
186 | else | 176 | record->data.soa->mname, |
187 | { | 177 | record->data.soa->rname, |
188 | GNUNET_asprintf (&tmp, | 178 | (unsigned int)record->data.soa->serial, |
189 | "priority %u, weight = %s, port = %u, target = %s", | 179 | (unsigned int)record->data.soa->refresh, |
190 | (unsigned int) record->data.srv->priority, | 180 | (unsigned int)record->data.soa->retry, |
191 | (unsigned int) record->data.srv->weight, | 181 | (unsigned int)record->data.soa->expire, |
192 | (unsigned int) record->data.srv->port, | 182 | (unsigned int)record->data.soa->minimum_ttl); |
193 | record->data.srv->target); | 183 | format = tmp; |
184 | } | ||
185 | break; | ||
186 | |||
187 | case GNUNET_DNSPARSER_TYPE_MX: | ||
188 | if (record->data.mx == NULL) | ||
189 | format = "<invalid>"; | ||
190 | else | ||
191 | { | ||
192 | GNUNET_asprintf(&tmp, | ||
193 | "%u: %s", | ||
194 | record->data.mx->preference, | ||
195 | record->data.mx->mxhost); | ||
196 | format = tmp; | ||
197 | } | ||
198 | break; | ||
199 | |||
200 | case GNUNET_DNSPARSER_TYPE_SRV: | ||
201 | if (NULL == record->data.srv) | ||
202 | format = "<invalid>"; | ||
203 | else | ||
204 | { | ||
205 | GNUNET_asprintf(&tmp, | ||
206 | "priority %u, weight = %s, port = %u, target = %s", | ||
207 | (unsigned int)record->data.srv->priority, | ||
208 | (unsigned int)record->data.srv->weight, | ||
209 | (unsigned int)record->data.srv->port, | ||
210 | record->data.srv->target); | ||
211 | format = tmp; | ||
212 | } | ||
213 | break; | ||
214 | |||
215 | case GNUNET_DNSPARSER_TYPE_TXT: | ||
216 | GNUNET_asprintf(&tmp, | ||
217 | "%.*s", | ||
218 | (unsigned int)record->data.raw.data_len, | ||
219 | record->data.raw.data); | ||
194 | format = tmp; | 220 | format = tmp; |
221 | break; | ||
222 | |||
223 | default: | ||
224 | format = "<payload>"; | ||
225 | break; | ||
195 | } | 226 | } |
196 | break; | 227 | fprintf(stdout, |
197 | case GNUNET_DNSPARSER_TYPE_TXT: | 228 | "\t\t%s %s: %s = %s (%u s)\n", |
198 | GNUNET_asprintf (&tmp, | 229 | get_class(record->dns_traffic_class), |
199 | "%.*s", | 230 | get_type(record->type), |
200 | (unsigned int) record->data.raw.data_len, | 231 | record->name, |
201 | record->data.raw.data); | 232 | format, |
202 | format = tmp; | 233 | (unsigned int)(GNUNET_TIME_absolute_get_remaining(record->expiration_time).rel_value_us / 1000LL / 1000LL)); |
203 | break; | 234 | GNUNET_free_non_null(tmp); |
204 | default: | ||
205 | format = "<payload>"; | ||
206 | break; | ||
207 | } | ||
208 | fprintf (stdout, | ||
209 | "\t\t%s %s: %s = %s (%u s)\n", | ||
210 | get_class (record->dns_traffic_class), | ||
211 | get_type (record->type), | ||
212 | record->name, | ||
213 | format, | ||
214 | (unsigned int) (GNUNET_TIME_absolute_get_remaining (record->expiration_time).rel_value_us / 1000LL / 1000LL)); | ||
215 | GNUNET_free_non_null (tmp); | ||
216 | } | 235 | } |
217 | 236 | ||
218 | 237 | ||
@@ -240,62 +259,62 @@ display_record (const struct GNUNET_DNSPARSER_Record *record) | |||
240 | * @param request udp payload of the DNS request | 259 | * @param request udp payload of the DNS request |
241 | */ | 260 | */ |
242 | static void | 261 | static void |
243 | display_request (void *cls, | 262 | display_request(void *cls, |
244 | struct GNUNET_DNS_RequestHandle *rh, | 263 | struct GNUNET_DNS_RequestHandle *rh, |
245 | size_t request_length, | 264 | size_t request_length, |
246 | const char *request) | 265 | const char *request) |
247 | { | 266 | { |
248 | static const char *return_codes[] = | 267 | static const char *return_codes[] = |
249 | { | 268 | { |
250 | "No error", "Format error", "Server failure", "Name error", | 269 | "No error", "Format error", "Server failure", "Name error", |
251 | "Not implemented", "Refused", "YXDomain", "YXRRset", | 270 | "Not implemented", "Refused", "YXDomain", "YXRRset", |
252 | "NXRRset", "NOT AUTH", "NOT ZONE", "<invalid>", | 271 | "NXRRset", "NOT AUTH", "NOT ZONE", "<invalid>", |
253 | "<invalid>", "<invalid>", "<invalid>", "<invalid>" | 272 | "<invalid>", "<invalid>", "<invalid>", "<invalid>" |
254 | }; | 273 | }; |
255 | static const char *op_codes[] = | 274 | static const char *op_codes[] = |
256 | { | 275 | { |
257 | "Query", "Inverse query", "Status", "<invalid>", | 276 | "Query", "Inverse query", "Status", "<invalid>", |
258 | "<invalid>", "<invalid>", "<invalid>", "<invalid>", | 277 | "<invalid>", "<invalid>", "<invalid>", "<invalid>", |
259 | "<invalid>", "<invalid>", "<invalid>", "<invalid>", | 278 | "<invalid>", "<invalid>", "<invalid>", "<invalid>", |
260 | "<invalid>", "<invalid>", "<invalid>", "<invalid>" | 279 | "<invalid>", "<invalid>", "<invalid>", "<invalid>" |
261 | }; | 280 | }; |
262 | struct GNUNET_DNSPARSER_Packet *p; | 281 | struct GNUNET_DNSPARSER_Packet *p; |
263 | unsigned int i; | 282 | unsigned int i; |
264 | 283 | ||
265 | p = GNUNET_DNSPARSER_parse (request, request_length); | 284 | p = GNUNET_DNSPARSER_parse(request, request_length); |
266 | if (NULL == p) | 285 | if (NULL == p) |
267 | { | 286 | { |
268 | fprintf (stderr, "Received malformed DNS packet!\n"); | 287 | fprintf(stderr, "Received malformed DNS packet!\n"); |
269 | // FIXME: drop instead? | 288 | // FIXME: drop instead? |
270 | GNUNET_DNS_request_forward (rh); | 289 | GNUNET_DNS_request_forward(rh); |
271 | return; | 290 | return; |
272 | } | 291 | } |
273 | fprintf (stdout, | 292 | fprintf(stdout, |
274 | "%s with ID: %5u Flags: %s%s%s%s%s%s, Return Code: %s, Opcode: %s\n", | 293 | "%s with ID: %5u Flags: %s%s%s%s%s%s, Return Code: %s, Opcode: %s\n", |
275 | p->flags.query_or_response ? "Response" : "Query", | 294 | p->flags.query_or_response ? "Response" : "Query", |
276 | p->id, | 295 | p->id, |
277 | p->flags.recursion_desired ? "RD " : "", | 296 | p->flags.recursion_desired ? "RD " : "", |
278 | p->flags.message_truncated ? "MT " : "", | 297 | p->flags.message_truncated ? "MT " : "", |
279 | p->flags.authoritative_answer ? "AA " : "", | 298 | p->flags.authoritative_answer ? "AA " : "", |
280 | p->flags.checking_disabled ? "CD " : "", | 299 | p->flags.checking_disabled ? "CD " : "", |
281 | p->flags.authenticated_data ? "AD " : "", | 300 | p->flags.authenticated_data ? "AD " : "", |
282 | p->flags.recursion_available ? "RA " : "", | 301 | p->flags.recursion_available ? "RA " : "", |
283 | return_codes[p->flags.return_code & 15], | 302 | return_codes[p->flags.return_code & 15], |
284 | op_codes[p->flags.opcode & 15]); | 303 | op_codes[p->flags.opcode & 15]); |
285 | if (p->num_queries > 0) | 304 | if (p->num_queries > 0) |
286 | fprintf (stdout, | 305 | fprintf(stdout, |
287 | "\tQueries:\n"); | 306 | "\tQueries:\n"); |
288 | for (i=0;i<p->num_queries;i++) | 307 | for (i = 0; i < p->num_queries; i++) |
289 | display_query (&p->queries[i]); | 308 | display_query(&p->queries[i]); |
290 | 309 | ||
291 | if (p->num_answers > 0) | 310 | if (p->num_answers > 0) |
292 | fprintf (stdout, | 311 | fprintf(stdout, |
293 | "\tAnswers:\n"); | 312 | "\tAnswers:\n"); |
294 | for (i=0;i<p->num_answers;i++) | 313 | for (i = 0; i < p->num_answers; i++) |
295 | display_record (&p->answers[i]); | 314 | display_record(&p->answers[i]); |
296 | fprintf (stdout, "\n"); | 315 | fprintf(stdout, "\n"); |
297 | GNUNET_DNSPARSER_free_packet (p); | 316 | GNUNET_DNSPARSER_free_packet(p); |
298 | GNUNET_DNS_request_forward (rh); | 317 | GNUNET_DNS_request_forward(rh); |
299 | } | 318 | } |
300 | 319 | ||
301 | 320 | ||
@@ -303,13 +322,13 @@ display_request (void *cls, | |||
303 | * Shutdown. | 322 | * Shutdown. |
304 | */ | 323 | */ |
305 | static void | 324 | static void |
306 | do_disconnect (void *cls) | 325 | do_disconnect(void *cls) |
307 | { | 326 | { |
308 | if (NULL != handle) | 327 | if (NULL != handle) |
309 | { | 328 | { |
310 | GNUNET_DNS_disconnect (handle); | 329 | GNUNET_DNS_disconnect(handle); |
311 | handle = NULL; | 330 | handle = NULL; |
312 | } | 331 | } |
313 | } | 332 | } |
314 | 333 | ||
315 | 334 | ||
@@ -322,8 +341,8 @@ do_disconnect (void *cls) | |||
322 | * @param cfg configuration | 341 | * @param cfg configuration |
323 | */ | 342 | */ |
324 | static void | 343 | static void |
325 | run (void *cls, char *const *args, const char *cfgfile, | 344 | run(void *cls, char *const *args, const char *cfgfile, |
326 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 345 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
327 | { | 346 | { |
328 | enum GNUNET_DNS_Flags flags; | 347 | enum GNUNET_DNS_Flags flags; |
329 | 348 | ||
@@ -335,41 +354,40 @@ run (void *cls, char *const *args, const char *cfgfile, | |||
335 | if (outbound_only) | 354 | if (outbound_only) |
336 | flags |= GNUNET_DNS_FLAG_RESPONSE_MONITOR; | 355 | flags |= GNUNET_DNS_FLAG_RESPONSE_MONITOR; |
337 | handle = | 356 | handle = |
338 | GNUNET_DNS_connect (cfg, | 357 | GNUNET_DNS_connect(cfg, |
339 | flags, | 358 | flags, |
340 | &display_request, | 359 | &display_request, |
341 | NULL); | 360 | NULL); |
342 | GNUNET_SCHEDULER_add_shutdown (&do_disconnect, NULL); | 361 | GNUNET_SCHEDULER_add_shutdown(&do_disconnect, NULL); |
343 | } | 362 | } |
344 | 363 | ||
345 | 364 | ||
346 | int | 365 | int |
347 | main (int argc, char *const *argv) | 366 | main(int argc, char *const *argv) |
348 | { | 367 | { |
349 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 368 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
369 | GNUNET_GETOPT_option_flag('i', | ||
370 | "inbound-only", | ||
371 | gettext_noop("only monitor DNS queries"), | ||
372 | &inbound_only), | ||
350 | 373 | ||
351 | GNUNET_GETOPT_option_flag ('i', | 374 | GNUNET_GETOPT_option_flag('o', |
352 | "inbound-only", | 375 | "outbound-only", |
353 | gettext_noop ("only monitor DNS queries"), | 376 | gettext_noop("only monitor DNS queries"), |
354 | &inbound_only), | 377 | &outbound_only), |
355 | |||
356 | GNUNET_GETOPT_option_flag ('o', | ||
357 | "outbound-only", | ||
358 | gettext_noop ("only monitor DNS queries"), | ||
359 | &outbound_only), | ||
360 | 378 | ||
361 | GNUNET_GETOPT_option_verbose (&verbosity), | 379 | GNUNET_GETOPT_option_verbose(&verbosity), |
362 | GNUNET_GETOPT_OPTION_END | 380 | GNUNET_GETOPT_OPTION_END |
363 | }; | 381 | }; |
364 | 382 | ||
365 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) | 383 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv)) |
366 | return 2; | 384 | return 2; |
367 | ret = (GNUNET_OK == | 385 | ret = (GNUNET_OK == |
368 | GNUNET_PROGRAM_run (argc, argv, "gnunet-dns-monitor", | 386 | GNUNET_PROGRAM_run(argc, argv, "gnunet-dns-monitor", |
369 | gettext_noop | 387 | gettext_noop |
370 | ("Monitor DNS queries."), options, | 388 | ("Monitor DNS queries."), options, |
371 | &run, NULL)) ? ret : 1; | 389 | &run, NULL)) ? ret : 1; |
372 | GNUNET_free ((void*) argv); | 390 | GNUNET_free((void*)argv); |
373 | return ret; | 391 | return ret; |
374 | } | 392 | } |
375 | 393 | ||
diff --git a/src/dns/gnunet-dns-redirector.c b/src/dns/gnunet-dns-redirector.c index 608540e12..f1978ce92 100644 --- a/src/dns/gnunet-dns-redirector.c +++ b/src/dns/gnunet-dns-redirector.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file src/dns/gnunet-dns-redirector.c | 22 | * @file src/dns/gnunet-dns-redirector.c |
@@ -61,48 +61,51 @@ static unsigned int verbosity; | |||
61 | * @param record record to modify | 61 | * @param record record to modify |
62 | */ | 62 | */ |
63 | static void | 63 | static void |
64 | modify_record (const struct GNUNET_DNSPARSER_Record *record) | 64 | modify_record(const struct GNUNET_DNSPARSER_Record *record) |
65 | { | 65 | { |
66 | char buf[INET6_ADDRSTRLEN]; | 66 | char buf[INET6_ADDRSTRLEN]; |
67 | 67 | ||
68 | switch (record->type) | 68 | switch (record->type) |
69 | { | ||
70 | case GNUNET_DNSPARSER_TYPE_A: | ||
71 | if (record->data.raw.data_len != sizeof (struct in_addr)) | ||
72 | return; | ||
73 | if (NULL != n4) | ||
74 | { | 69 | { |
75 | if (verbosity > 1) | 70 | case GNUNET_DNSPARSER_TYPE_A: |
76 | fprintf (stderr, | 71 | if (record->data.raw.data_len != sizeof(struct in_addr)) |
77 | "Changing A record from `%s' to `%s'\n", | 72 | return; |
78 | inet_ntop (AF_INET, record->data.raw.data, buf, sizeof (buf)), | 73 | if (NULL != n4) |
79 | n4); | 74 | { |
80 | GNUNET_assert (1 == inet_pton (AF_INET, n4, record->data.raw.data)); | 75 | if (verbosity > 1) |
81 | } | 76 | fprintf(stderr, |
82 | break; | 77 | "Changing A record from `%s' to `%s'\n", |
83 | case GNUNET_DNSPARSER_TYPE_AAAA: | 78 | inet_ntop(AF_INET, record->data.raw.data, buf, sizeof(buf)), |
84 | if (record->data.raw.data_len != sizeof (struct in6_addr)) | 79 | n4); |
85 | return; | 80 | GNUNET_assert(1 == inet_pton(AF_INET, n4, record->data.raw.data)); |
86 | if (NULL != n6) | 81 | } |
87 | { | 82 | break; |
88 | if (verbosity > 1) | 83 | |
89 | fprintf (stderr, | 84 | case GNUNET_DNSPARSER_TYPE_AAAA: |
90 | "Changing AAAA record from `%s' to `%s'\n", | 85 | if (record->data.raw.data_len != sizeof(struct in6_addr)) |
91 | inet_ntop (AF_INET6, record->data.raw.data, buf, sizeof (buf)), | 86 | return; |
92 | n6); | 87 | if (NULL != n6) |
93 | GNUNET_assert (1 == inet_pton (AF_INET6, n6, record->data.raw.data)); | 88 | { |
89 | if (verbosity > 1) | ||
90 | fprintf(stderr, | ||
91 | "Changing AAAA record from `%s' to `%s'\n", | ||
92 | inet_ntop(AF_INET6, record->data.raw.data, buf, sizeof(buf)), | ||
93 | n6); | ||
94 | GNUNET_assert(1 == inet_pton(AF_INET6, n6, record->data.raw.data)); | ||
95 | } | ||
96 | break; | ||
97 | |||
98 | case GNUNET_DNSPARSER_TYPE_NS: | ||
99 | case GNUNET_DNSPARSER_TYPE_CNAME: | ||
100 | case GNUNET_DNSPARSER_TYPE_PTR: | ||
101 | case GNUNET_DNSPARSER_TYPE_SOA: | ||
102 | case GNUNET_DNSPARSER_TYPE_MX: | ||
103 | case GNUNET_DNSPARSER_TYPE_TXT: | ||
104 | break; | ||
105 | |||
106 | default: | ||
107 | break; | ||
94 | } | 108 | } |
95 | break; | ||
96 | case GNUNET_DNSPARSER_TYPE_NS: | ||
97 | case GNUNET_DNSPARSER_TYPE_CNAME: | ||
98 | case GNUNET_DNSPARSER_TYPE_PTR: | ||
99 | case GNUNET_DNSPARSER_TYPE_SOA: | ||
100 | case GNUNET_DNSPARSER_TYPE_MX: | ||
101 | case GNUNET_DNSPARSER_TYPE_TXT: | ||
102 | break; | ||
103 | default: | ||
104 | break; | ||
105 | } | ||
106 | } | 109 | } |
107 | 110 | ||
108 | 111 | ||
@@ -130,10 +133,10 @@ modify_record (const struct GNUNET_DNSPARSER_Record *record) | |||
130 | * @param request udp payload of the DNS request | 133 | * @param request udp payload of the DNS request |
131 | */ | 134 | */ |
132 | static void | 135 | static void |
133 | modify_request (void *cls, | 136 | modify_request(void *cls, |
134 | struct GNUNET_DNS_RequestHandle *rh, | 137 | struct GNUNET_DNS_RequestHandle *rh, |
135 | size_t request_length, | 138 | size_t request_length, |
136 | const char *request) | 139 | const char *request) |
137 | { | 140 | { |
138 | struct GNUNET_DNSPARSER_Packet *p; | 141 | struct GNUNET_DNSPARSER_Packet *p; |
139 | unsigned int i; | 142 | unsigned int i; |
@@ -141,35 +144,35 @@ modify_request (void *cls, | |||
141 | size_t len; | 144 | size_t len; |
142 | int ret; | 145 | int ret; |
143 | 146 | ||
144 | p = GNUNET_DNSPARSER_parse (request, request_length); | 147 | p = GNUNET_DNSPARSER_parse(request, request_length); |
145 | if (NULL == p) | 148 | if (NULL == p) |
146 | { | 149 | { |
147 | fprintf (stderr, "Received malformed DNS packet, leaving it untouched\n"); | 150 | fprintf(stderr, "Received malformed DNS packet, leaving it untouched\n"); |
148 | GNUNET_DNS_request_forward (rh); | 151 | GNUNET_DNS_request_forward(rh); |
149 | return; | 152 | return; |
150 | } | 153 | } |
151 | for (i=0;i<p->num_answers;i++) | 154 | for (i = 0; i < p->num_answers; i++) |
152 | modify_record (&p->answers[i]); | 155 | modify_record(&p->answers[i]); |
153 | buf = NULL; | 156 | buf = NULL; |
154 | ret = GNUNET_DNSPARSER_pack (p, 1024, &buf, &len); | 157 | ret = GNUNET_DNSPARSER_pack(p, 1024, &buf, &len); |
155 | GNUNET_DNSPARSER_free_packet (p); | 158 | GNUNET_DNSPARSER_free_packet(p); |
156 | if (GNUNET_OK != ret) | 159 | if (GNUNET_OK != ret) |
157 | { | 160 | { |
158 | if (GNUNET_NO == ret) | 161 | if (GNUNET_NO == ret) |
159 | fprintf (stderr, | 162 | fprintf(stderr, |
160 | "Modified DNS response did not fit, keeping old response\n"); | 163 | "Modified DNS response did not fit, keeping old response\n"); |
161 | else | 164 | else |
162 | GNUNET_break (0); /* our modifications should have been sane! */ | 165 | GNUNET_break(0); /* our modifications should have been sane! */ |
163 | GNUNET_DNS_request_forward (rh); | 166 | GNUNET_DNS_request_forward(rh); |
164 | } | 167 | } |
165 | else | 168 | else |
166 | { | 169 | { |
167 | if (verbosity > 0) | 170 | if (verbosity > 0) |
168 | fprintf (stdout, | 171 | fprintf(stdout, |
169 | "Injecting modified DNS response\n"); | 172 | "Injecting modified DNS response\n"); |
170 | GNUNET_DNS_request_answer (rh, len, buf); | 173 | GNUNET_DNS_request_answer(rh, len, buf); |
171 | } | 174 | } |
172 | GNUNET_free_non_null (buf); | 175 | GNUNET_free_non_null(buf); |
173 | } | 176 | } |
174 | 177 | ||
175 | 178 | ||
@@ -177,13 +180,13 @@ modify_request (void *cls, | |||
177 | * Shutdown. | 180 | * Shutdown. |
178 | */ | 181 | */ |
179 | static void | 182 | static void |
180 | do_disconnect (void *cls) | 183 | do_disconnect(void *cls) |
181 | { | 184 | { |
182 | if (NULL != handle) | 185 | if (NULL != handle) |
183 | { | 186 | { |
184 | GNUNET_DNS_disconnect (handle); | 187 | GNUNET_DNS_disconnect(handle); |
185 | handle = NULL; | 188 | handle = NULL; |
186 | } | 189 | } |
187 | } | 190 | } |
188 | 191 | ||
189 | 192 | ||
@@ -196,66 +199,67 @@ do_disconnect (void *cls) | |||
196 | * @param cfg configuration | 199 | * @param cfg configuration |
197 | */ | 200 | */ |
198 | static void | 201 | static void |
199 | run (void *cls, char *const *args, const char *cfgfile, | 202 | run(void *cls, char *const *args, const char *cfgfile, |
200 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 203 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
201 | { | 204 | { |
202 | struct in_addr i4; | 205 | struct in_addr i4; |
203 | struct in6_addr i6; | 206 | struct in6_addr i6; |
204 | if ( (n4 != NULL) && | 207 | |
205 | (1 != inet_pton (AF_INET, n4, &i4)) ) | 208 | if ((n4 != NULL) && |
206 | { | 209 | (1 != inet_pton(AF_INET, n4, &i4))) |
207 | fprintf (stderr, | 210 | { |
208 | "`%s' is nto a valid IPv4 address!\n", | 211 | fprintf(stderr, |
209 | n4); | 212 | "`%s' is nto a valid IPv4 address!\n", |
210 | return; | 213 | n4); |
211 | } | 214 | return; |
212 | if ( (n6 != NULL) && | 215 | } |
213 | (1 != inet_pton (AF_INET6, n6, &i6)) ) | 216 | if ((n6 != NULL) && |
214 | { | 217 | (1 != inet_pton(AF_INET6, n6, &i6))) |
215 | fprintf (stderr, | 218 | { |
216 | "`%s' is nto a valid IPv6 address!\n", | 219 | fprintf(stderr, |
217 | n6); | 220 | "`%s' is nto a valid IPv6 address!\n", |
218 | return; | 221 | n6); |
219 | } | 222 | return; |
223 | } | ||
220 | 224 | ||
221 | handle = | 225 | handle = |
222 | GNUNET_DNS_connect (cfg, | 226 | GNUNET_DNS_connect(cfg, |
223 | GNUNET_DNS_FLAG_POST_RESOLUTION, | 227 | GNUNET_DNS_FLAG_POST_RESOLUTION, |
224 | &modify_request, | 228 | &modify_request, |
225 | NULL); | 229 | NULL); |
226 | GNUNET_SCHEDULER_add_shutdown (&do_disconnect, NULL); | 230 | GNUNET_SCHEDULER_add_shutdown(&do_disconnect, NULL); |
227 | } | 231 | } |
228 | 232 | ||
229 | 233 | ||
230 | int | 234 | int |
231 | main (int argc, char *const *argv) | 235 | main(int argc, char *const *argv) |
232 | { | 236 | { |
233 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 237 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
234 | GNUNET_GETOPT_option_string ('4', | 238 | GNUNET_GETOPT_option_string('4', |
235 | "ipv4", | 239 | "ipv4", |
236 | "IPV4", | 240 | "IPV4", |
237 | gettext_noop ("set A records"), | 241 | gettext_noop("set A records"), |
238 | &n4), | 242 | &n4), |
239 | 243 | ||
240 | GNUNET_GETOPT_option_string ('6', | 244 | GNUNET_GETOPT_option_string('6', |
241 | "ipv4", | 245 | "ipv4", |
242 | "IPV6", | 246 | "IPV6", |
243 | gettext_noop ("set AAAA records"), | 247 | gettext_noop("set AAAA records"), |
244 | &n6), | 248 | &n6), |
245 | 249 | ||
246 | GNUNET_GETOPT_option_verbose (&verbosity), | 250 | GNUNET_GETOPT_option_verbose(&verbosity), |
247 | GNUNET_GETOPT_OPTION_END | 251 | GNUNET_GETOPT_OPTION_END |
248 | }; | 252 | }; |
249 | 253 | ||
250 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) | 254 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv)) |
251 | return 2; | 255 | return 2; |
252 | 256 | ||
253 | ret = (GNUNET_OK == | 257 | ret = (GNUNET_OK == |
254 | GNUNET_PROGRAM_run (argc, argv, "gnunet-dns-redirector", | 258 | GNUNET_PROGRAM_run(argc, argv, "gnunet-dns-redirector", |
255 | gettext_noop | 259 | gettext_noop |
256 | ("Change DNS replies to point elsewhere."), options, | 260 | ("Change DNS replies to point elsewhere."), options, |
257 | &run, NULL)) ? ret : 1; | 261 | &run, NULL)) ? ret : 1; |
258 | GNUNET_free ((void*) argv); | 262 | GNUNET_free((void*)argv); |
259 | return ret; | 263 | return ret; |
260 | } | 264 | } |
261 | 265 | ||
diff --git a/src/dns/gnunet-helper-dns.c b/src/dns/gnunet-helper-dns.c index 554727094..85c72579d 100644 --- a/src/dns/gnunet-helper-dns.c +++ b/src/dns/gnunet-helper-dns.c | |||
@@ -16,7 +16,7 @@ | |||
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file dns/gnunet-helper-dns.c | 22 | * @file dns/gnunet-helper-dns.c |
@@ -87,8 +87,7 @@ | |||
87 | /** | 87 | /** |
88 | * This is in linux/include/net/ipv6.h, but not always exported... | 88 | * This is in linux/include/net/ipv6.h, but not always exported... |
89 | */ | 89 | */ |
90 | struct in6_ifreq | 90 | struct in6_ifreq { |
91 | { | ||
92 | struct in6_addr ifr6_addr; | 91 | struct in6_addr ifr6_addr; |
93 | uint32_t ifr6_prefixlen; | 92 | uint32_t ifr6_prefixlen; |
94 | unsigned int ifr6_ifindex; | 93 | unsigned int ifr6_ifindex; |
@@ -152,11 +151,11 @@ static int cpipe[2]; | |||
152 | * @param signal signal number of the signal (not used) | 151 | * @param signal signal number of the signal (not used) |
153 | */ | 152 | */ |
154 | static void | 153 | static void |
155 | signal_handler (int signal) | 154 | signal_handler(int signal) |
156 | { | 155 | { |
157 | /* ignore return value, as the signal handler could theoretically | 156 | /* ignore return value, as the signal handler could theoretically |
158 | be called many times before the shutdown can actually happen */ | 157 | be called many times before the shutdown can actually happen */ |
159 | (void) write (cpipe[1], "K", 1); | 158 | (void)write(cpipe[1], "K", 1); |
160 | } | 159 | } |
161 | 160 | ||
162 | 161 | ||
@@ -168,22 +167,22 @@ signal_handler (int signal) | |||
168 | * @param flags open flags (O_RDONLY, O_WRONLY) | 167 | * @param flags open flags (O_RDONLY, O_WRONLY) |
169 | */ | 168 | */ |
170 | static void | 169 | static void |
171 | open_dev_null (int target_fd, | 170 | open_dev_null(int target_fd, |
172 | int flags) | 171 | int flags) |
173 | { | 172 | { |
174 | int fd; | 173 | int fd; |
175 | 174 | ||
176 | fd = open ("/dev/null", flags); | 175 | fd = open("/dev/null", flags); |
177 | if (-1 == fd) | 176 | if (-1 == fd) |
178 | abort (); | 177 | abort(); |
179 | if (fd == target_fd) | 178 | if (fd == target_fd) |
180 | return; | 179 | return; |
181 | if (-1 == dup2 (fd, target_fd)) | 180 | if (-1 == dup2(fd, target_fd)) |
182 | { | 181 | { |
183 | (void) close (fd); | 182 | (void)close(fd); |
184 | abort (); | 183 | abort(); |
185 | } | 184 | } |
186 | (void) close (fd); | 185 | (void)close(fd); |
187 | } | 186 | } |
188 | 187 | ||
189 | 188 | ||
@@ -195,49 +194,50 @@ open_dev_null (int target_fd, | |||
195 | * @return 0 on success, 1 on any error | 194 | * @return 0 on success, 1 on any error |
196 | */ | 195 | */ |
197 | static int | 196 | static int |
198 | fork_and_exec (const char *file, | 197 | fork_and_exec(const char *file, |
199 | char *const cmd[]) | 198 | char *const cmd[]) |
200 | { | 199 | { |
201 | int status; | 200 | int status; |
202 | pid_t pid; | 201 | pid_t pid; |
203 | pid_t ret; | 202 | pid_t ret; |
204 | 203 | ||
205 | pid = fork (); | 204 | pid = fork(); |
206 | if (-1 == pid) | 205 | if (-1 == pid) |
207 | { | 206 | { |
208 | fprintf (stderr, | 207 | fprintf(stderr, |
209 | "fork failed: %s\n", | 208 | "fork failed: %s\n", |
210 | strerror (errno)); | 209 | strerror(errno)); |
211 | return 1; | 210 | return 1; |
212 | } | 211 | } |
213 | if (0 == pid) | 212 | if (0 == pid) |
214 | { | 213 | { |
215 | /* we are the child process */ | 214 | /* we are the child process */ |
216 | /* close stdin/stdout to not cause interference | 215 | /* close stdin/stdout to not cause interference |
217 | with the helper's main protocol! */ | 216 | with the helper's main protocol! */ |
218 | (void) close (0); | 217 | (void)close(0); |
219 | open_dev_null (0, O_RDONLY); | 218 | open_dev_null(0, O_RDONLY); |
220 | (void) close (1); | 219 | (void)close(1); |
221 | open_dev_null (1, O_WRONLY); | 220 | open_dev_null(1, O_WRONLY); |
222 | (void) execv (file, cmd); | 221 | (void)execv(file, cmd); |
223 | /* can only get here on error */ | 222 | /* can only get here on error */ |
224 | fprintf (stderr, | 223 | fprintf(stderr, |
225 | "exec `%s' failed: %s\n", | 224 | "exec `%s' failed: %s\n", |
226 | file, | 225 | file, |
227 | strerror (errno)); | 226 | strerror(errno)); |
228 | _exit (1); | 227 | _exit(1); |
229 | } | 228 | } |
230 | /* keep running waitpid as long as the only error we get is 'EINTR' */ | 229 | /* keep running waitpid as long as the only error we get is 'EINTR' */ |
231 | while ( (-1 == (ret = waitpid (pid, &status, 0))) && | 230 | while ((-1 == (ret = waitpid(pid, &status, 0))) && |
232 | (errno == EINTR) ); | 231 | (errno == EINTR)) |
232 | ; | ||
233 | if (-1 == ret) | 233 | if (-1 == ret) |
234 | { | 234 | { |
235 | fprintf (stderr, | 235 | fprintf(stderr, |
236 | "waitpid failed: %s\n", | 236 | "waitpid failed: %s\n", |
237 | strerror (errno)); | 237 | strerror(errno)); |
238 | return 1; | 238 | return 1; |
239 | } | 239 | } |
240 | if (! (WIFEXITED (status) && (0 == WEXITSTATUS (status)))) | 240 | if (!(WIFEXITED(status) && (0 == WEXITSTATUS(status)))) |
241 | return 1; | 241 | return 1; |
242 | /* child process completed and returned success, we're happy */ | 242 | /* child process completed and returned success, we're happy */ |
243 | return 0; | 243 | return 0; |
@@ -252,45 +252,45 @@ fork_and_exec (const char *file, | |||
252 | * @return the fd to the tun or -1 on error | 252 | * @return the fd to the tun or -1 on error |
253 | */ | 253 | */ |
254 | static int | 254 | static int |
255 | init_tun (char *dev) | 255 | init_tun(char *dev) |
256 | { | 256 | { |
257 | struct ifreq ifr; | 257 | struct ifreq ifr; |
258 | int fd; | 258 | int fd; |
259 | 259 | ||
260 | if (NULL == dev) | 260 | if (NULL == dev) |
261 | { | 261 | { |
262 | errno = EINVAL; | 262 | errno = EINVAL; |
263 | return -1; | 263 | return -1; |
264 | } | 264 | } |
265 | 265 | ||
266 | if (-1 == (fd = open ("/dev/net/tun", O_RDWR))) | 266 | if (-1 == (fd = open("/dev/net/tun", O_RDWR))) |
267 | { | 267 | { |
268 | fprintf (stderr, "Error opening `%s': %s\n", "/dev/net/tun", | 268 | fprintf(stderr, "Error opening `%s': %s\n", "/dev/net/tun", |
269 | strerror (errno)); | 269 | strerror(errno)); |
270 | return -1; | 270 | return -1; |
271 | } | 271 | } |
272 | 272 | ||
273 | if (fd >= FD_SETSIZE) | 273 | if (fd >= FD_SETSIZE) |
274 | { | 274 | { |
275 | fprintf (stderr, "File descriptor to large: %d", fd); | 275 | fprintf(stderr, "File descriptor to large: %d", fd); |
276 | (void) close (fd); | 276 | (void)close(fd); |
277 | return -1; | 277 | return -1; |
278 | } | 278 | } |
279 | 279 | ||
280 | memset (&ifr, 0, sizeof (ifr)); | 280 | memset(&ifr, 0, sizeof(ifr)); |
281 | ifr.ifr_flags = IFF_TUN; | 281 | ifr.ifr_flags = IFF_TUN; |
282 | 282 | ||
283 | if ('\0' != *dev) | 283 | if ('\0' != *dev) |
284 | strncpy (ifr.ifr_name, dev, IFNAMSIZ); | 284 | strncpy(ifr.ifr_name, dev, IFNAMSIZ); |
285 | 285 | ||
286 | if (-1 == ioctl (fd, TUNSETIFF, (void *) &ifr)) | 286 | if (-1 == ioctl(fd, TUNSETIFF, (void *)&ifr)) |
287 | { | 287 | { |
288 | fprintf (stderr, "Error with ioctl on `%s': %s\n", "/dev/net/tun", | 288 | fprintf(stderr, "Error with ioctl on `%s': %s\n", "/dev/net/tun", |
289 | strerror (errno)); | 289 | strerror(errno)); |
290 | (void) close (fd); | 290 | (void)close(fd); |
291 | return -1; | 291 | return -1; |
292 | } | 292 | } |
293 | strcpy (dev, ifr.ifr_name); | 293 | strcpy(dev, ifr.ifr_name); |
294 | return fd; | 294 | return fd; |
295 | } | 295 | } |
296 | 296 | ||
@@ -303,7 +303,7 @@ init_tun (char *dev) | |||
303 | * @param prefix_len the length of the network-prefix | 303 | * @param prefix_len the length of the network-prefix |
304 | */ | 304 | */ |
305 | static void | 305 | static void |
306 | set_address6 (const char *dev, const char *address, unsigned long prefix_len) | 306 | set_address6(const char *dev, const char *address, unsigned long prefix_len) |
307 | { | 307 | { |
308 | struct ifreq ifr; | 308 | struct ifreq ifr; |
309 | struct in6_ifreq ifr6; | 309 | struct in6_ifreq ifr6; |
@@ -313,39 +313,39 @@ set_address6 (const char *dev, const char *address, unsigned long prefix_len) | |||
313 | /* | 313 | /* |
314 | * parse the new address | 314 | * parse the new address |
315 | */ | 315 | */ |
316 | memset (&sa6, 0, sizeof (struct sockaddr_in6)); | 316 | memset(&sa6, 0, sizeof(struct sockaddr_in6)); |
317 | sa6.sin6_family = AF_INET6; | 317 | sa6.sin6_family = AF_INET6; |
318 | if (1 != inet_pton (AF_INET6, address, sa6.sin6_addr.s6_addr)) | 318 | if (1 != inet_pton(AF_INET6, address, sa6.sin6_addr.s6_addr)) |
319 | { | 319 | { |
320 | fprintf (stderr, | 320 | fprintf(stderr, |
321 | "Failed to parse IPv6 address `%s': %s\n", | 321 | "Failed to parse IPv6 address `%s': %s\n", |
322 | address, | 322 | address, |
323 | strerror (errno)); | 323 | strerror(errno)); |
324 | exit (1); | 324 | exit(1); |
325 | } | 325 | } |
326 | 326 | ||
327 | if (-1 == (fd = socket (PF_INET6, SOCK_DGRAM, 0))) | 327 | if (-1 == (fd = socket(PF_INET6, SOCK_DGRAM, 0))) |
328 | { | 328 | { |
329 | fprintf (stderr, | 329 | fprintf(stderr, |
330 | "Error creating IPv6 socket: %s (ignored)\n", | 330 | "Error creating IPv6 socket: %s (ignored)\n", |
331 | strerror (errno)); | 331 | strerror(errno)); |
332 | /* ignore error, maybe only IPv4 works on this system! */ | 332 | /* ignore error, maybe only IPv4 works on this system! */ |
333 | return; | 333 | return; |
334 | } | 334 | } |
335 | 335 | ||
336 | memset (&ifr, 0, sizeof (struct ifreq)); | 336 | memset(&ifr, 0, sizeof(struct ifreq)); |
337 | /* | 337 | /* |
338 | * Get the index of the if | 338 | * Get the index of the if |
339 | */ | 339 | */ |
340 | strncpy (ifr.ifr_name, dev, IFNAMSIZ); | 340 | strncpy(ifr.ifr_name, dev, IFNAMSIZ); |
341 | if (-1 == ioctl (fd, SIOGIFINDEX, &ifr)) | 341 | if (-1 == ioctl(fd, SIOGIFINDEX, &ifr)) |
342 | { | 342 | { |
343 | fprintf (stderr, "ioctl failed at %d: %s\n", __LINE__, strerror (errno)); | 343 | fprintf(stderr, "ioctl failed at %d: %s\n", __LINE__, strerror(errno)); |
344 | (void) close (fd); | 344 | (void)close(fd); |
345 | exit (1); | 345 | exit(1); |
346 | } | 346 | } |
347 | 347 | ||
348 | memset (&ifr6, 0, sizeof (struct in6_ifreq)); | 348 | memset(&ifr6, 0, sizeof(struct in6_ifreq)); |
349 | ifr6.ifr6_addr = sa6.sin6_addr; | 349 | ifr6.ifr6_addr = sa6.sin6_addr; |
350 | ifr6.ifr6_ifindex = ifr.ifr_ifindex; | 350 | ifr6.ifr6_ifindex = ifr.ifr_ifindex; |
351 | ifr6.ifr6_prefixlen = prefix_len; | 351 | ifr6.ifr6_prefixlen = prefix_len; |
@@ -353,42 +353,42 @@ set_address6 (const char *dev, const char *address, unsigned long prefix_len) | |||
353 | /* | 353 | /* |
354 | * Set the address | 354 | * Set the address |
355 | */ | 355 | */ |
356 | if (-1 == ioctl (fd, SIOCSIFADDR, &ifr6)) | 356 | if (-1 == ioctl(fd, SIOCSIFADDR, &ifr6)) |
357 | { | 357 | { |
358 | fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__, | 358 | fprintf(stderr, "ioctl failed at line %d: %s\n", __LINE__, |
359 | strerror (errno)); | 359 | strerror(errno)); |
360 | (void) close (fd); | 360 | (void)close(fd); |
361 | exit (1); | 361 | exit(1); |
362 | } | 362 | } |
363 | 363 | ||
364 | /* | 364 | /* |
365 | * Get the flags | 365 | * Get the flags |
366 | */ | 366 | */ |
367 | if (-1 == ioctl (fd, SIOCGIFFLAGS, &ifr)) | 367 | if (-1 == ioctl(fd, SIOCGIFFLAGS, &ifr)) |
368 | { | 368 | { |
369 | fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__, | 369 | fprintf(stderr, "ioctl failed at line %d: %s\n", __LINE__, |
370 | strerror (errno)); | 370 | strerror(errno)); |
371 | (void) close (fd); | 371 | (void)close(fd); |
372 | exit (1); | 372 | exit(1); |
373 | } | 373 | } |
374 | 374 | ||
375 | /* | 375 | /* |
376 | * Add the UP and RUNNING flags | 376 | * Add the UP and RUNNING flags |
377 | */ | 377 | */ |
378 | ifr.ifr_flags |= IFF_UP | IFF_RUNNING; | 378 | ifr.ifr_flags |= IFF_UP | IFF_RUNNING; |
379 | if (-1 == ioctl (fd, SIOCSIFFLAGS, &ifr)) | 379 | if (-1 == ioctl(fd, SIOCSIFFLAGS, &ifr)) |
380 | { | 380 | { |
381 | fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__, | 381 | fprintf(stderr, "ioctl failed at line %d: %s\n", __LINE__, |
382 | strerror (errno)); | 382 | strerror(errno)); |
383 | (void) close (fd); | 383 | (void)close(fd); |
384 | exit (1); | 384 | exit(1); |
385 | } | 385 | } |
386 | 386 | ||
387 | if (0 != close (fd)) | 387 | if (0 != close(fd)) |
388 | { | 388 | { |
389 | fprintf (stderr, "close failed: %s\n", strerror (errno)); | 389 | fprintf(stderr, "close failed: %s\n", strerror(errno)); |
390 | exit (1); | 390 | exit(1); |
391 | } | 391 | } |
392 | } | 392 | } |
393 | 393 | ||
394 | 394 | ||
@@ -400,100 +400,100 @@ set_address6 (const char *dev, const char *address, unsigned long prefix_len) | |||
400 | * @param mask the netmask | 400 | * @param mask the netmask |
401 | */ | 401 | */ |
402 | static void | 402 | static void |
403 | set_address4 (const char *dev, const char *address, const char *mask) | 403 | set_address4(const char *dev, const char *address, const char *mask) |
404 | { | 404 | { |
405 | int fd; | 405 | int fd; |
406 | struct sockaddr_in *addr; | 406 | struct sockaddr_in *addr; |
407 | struct ifreq ifr; | 407 | struct ifreq ifr; |
408 | 408 | ||
409 | memset (&ifr, 0, sizeof (struct ifreq)); | 409 | memset(&ifr, 0, sizeof(struct ifreq)); |
410 | addr = (struct sockaddr_in *) &(ifr.ifr_addr); | 410 | addr = (struct sockaddr_in *)&(ifr.ifr_addr); |
411 | addr->sin_family = AF_INET; | 411 | addr->sin_family = AF_INET; |
412 | 412 | ||
413 | /* | 413 | /* |
414 | * Parse the address | 414 | * Parse the address |
415 | */ | 415 | */ |
416 | if (1 != inet_pton (AF_INET, address, &addr->sin_addr.s_addr)) | 416 | if (1 != inet_pton(AF_INET, address, &addr->sin_addr.s_addr)) |
417 | { | 417 | { |
418 | fprintf (stderr, | 418 | fprintf(stderr, |
419 | "Failed to parse IPv4 address `%s': %s\n", | 419 | "Failed to parse IPv4 address `%s': %s\n", |
420 | address, | 420 | address, |
421 | strerror (errno)); | 421 | strerror(errno)); |
422 | exit (1); | 422 | exit(1); |
423 | } | 423 | } |
424 | 424 | ||
425 | if (-1 == (fd = socket (PF_INET, SOCK_DGRAM, 0))) | 425 | if (-1 == (fd = socket(PF_INET, SOCK_DGRAM, 0))) |
426 | { | 426 | { |
427 | fprintf (stderr, | 427 | fprintf(stderr, |
428 | "Error creating IPv4 socket: %s\n", | 428 | "Error creating IPv4 socket: %s\n", |
429 | strerror (errno)); | 429 | strerror(errno)); |
430 | exit (1); | 430 | exit(1); |
431 | } | 431 | } |
432 | 432 | ||
433 | strncpy (ifr.ifr_name, dev, IFNAMSIZ); | 433 | strncpy(ifr.ifr_name, dev, IFNAMSIZ); |
434 | 434 | ||
435 | /* | 435 | /* |
436 | * Set the address | 436 | * Set the address |
437 | */ | 437 | */ |
438 | if (-1 == ioctl (fd, SIOCSIFADDR, &ifr)) | 438 | if (-1 == ioctl(fd, SIOCSIFADDR, &ifr)) |
439 | { | 439 | { |
440 | fprintf (stderr, "ioctl failed at %d: %s\n", __LINE__, strerror (errno)); | 440 | fprintf(stderr, "ioctl failed at %d: %s\n", __LINE__, strerror(errno)); |
441 | (void) close (fd); | 441 | (void)close(fd); |
442 | exit (1); | 442 | exit(1); |
443 | } | 443 | } |
444 | 444 | ||
445 | /* | 445 | /* |
446 | * Parse the netmask | 446 | * Parse the netmask |
447 | */ | 447 | */ |
448 | addr = (struct sockaddr_in *) &(ifr.ifr_netmask); | 448 | addr = (struct sockaddr_in *)&(ifr.ifr_netmask); |
449 | if (1 != inet_pton (AF_INET, mask, &addr->sin_addr.s_addr)) | 449 | if (1 != inet_pton(AF_INET, mask, &addr->sin_addr.s_addr)) |
450 | { | 450 | { |
451 | fprintf (stderr, "Failed to parse address `%s': %s\n", mask, | 451 | fprintf(stderr, "Failed to parse address `%s': %s\n", mask, |
452 | strerror (errno)); | 452 | strerror(errno)); |
453 | (void) close (fd); | 453 | (void)close(fd); |
454 | exit (1); | 454 | exit(1); |
455 | } | 455 | } |
456 | 456 | ||
457 | /* | 457 | /* |
458 | * Set the netmask | 458 | * Set the netmask |
459 | */ | 459 | */ |
460 | if (-1 == ioctl (fd, SIOCSIFNETMASK, &ifr)) | 460 | if (-1 == ioctl(fd, SIOCSIFNETMASK, &ifr)) |
461 | { | 461 | { |
462 | fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__, | 462 | fprintf(stderr, "ioctl failed at line %d: %s\n", __LINE__, |
463 | strerror (errno)); | 463 | strerror(errno)); |
464 | (void) close (fd); | 464 | (void)close(fd); |
465 | exit (1); | 465 | exit(1); |
466 | } | 466 | } |
467 | 467 | ||
468 | /* | 468 | /* |
469 | * Get the flags | 469 | * Get the flags |
470 | */ | 470 | */ |
471 | if (-1 == ioctl (fd, SIOCGIFFLAGS, &ifr)) | 471 | if (-1 == ioctl(fd, SIOCGIFFLAGS, &ifr)) |
472 | { | 472 | { |
473 | fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__, | 473 | fprintf(stderr, "ioctl failed at line %d: %s\n", __LINE__, |
474 | strerror (errno)); | 474 | strerror(errno)); |
475 | (void) close (fd); | 475 | (void)close(fd); |
476 | exit (1); | 476 | exit(1); |
477 | } | 477 | } |
478 | 478 | ||
479 | /* | 479 | /* |
480 | * Add the UP and RUNNING flags | 480 | * Add the UP and RUNNING flags |
481 | */ | 481 | */ |
482 | ifr.ifr_flags |= IFF_UP | IFF_RUNNING; | 482 | ifr.ifr_flags |= IFF_UP | IFF_RUNNING; |
483 | if (-1 == ioctl (fd, SIOCSIFFLAGS, &ifr)) | 483 | if (-1 == ioctl(fd, SIOCSIFFLAGS, &ifr)) |
484 | { | 484 | { |
485 | fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__, | 485 | fprintf(stderr, "ioctl failed at line %d: %s\n", __LINE__, |
486 | strerror (errno)); | 486 | strerror(errno)); |
487 | (void) close (fd); | 487 | (void)close(fd); |
488 | exit (1); | 488 | exit(1); |
489 | } | 489 | } |
490 | 490 | ||
491 | if (0 != close (fd)) | 491 | if (0 != close(fd)) |
492 | { | 492 | { |
493 | fprintf (stderr, "close failed: %s\n", strerror (errno)); | 493 | fprintf(stderr, "close failed: %s\n", strerror(errno)); |
494 | (void) close (fd); | 494 | (void)close(fd); |
495 | exit (1); | 495 | exit(1); |
496 | } | 496 | } |
497 | } | 497 | } |
498 | 498 | ||
499 | 499 | ||
@@ -505,7 +505,7 @@ set_address4 (const char *dev, const char *address, const char *mask) | |||
505 | * @param fd_tun tunnel FD | 505 | * @param fd_tun tunnel FD |
506 | */ | 506 | */ |
507 | static void | 507 | static void |
508 | run (int fd_tun) | 508 | run(int fd_tun) |
509 | { | 509 | { |
510 | /* | 510 | /* |
511 | * The buffer filled by reading from fd_tun | 511 | * The buffer filled by reading from fd_tun |
@@ -526,176 +526,176 @@ run (int fd_tun) | |||
526 | int max; | 526 | int max; |
527 | 527 | ||
528 | while (1) | 528 | while (1) |
529 | { | ||
530 | FD_ZERO (&fds_w); | ||
531 | FD_ZERO (&fds_r); | ||
532 | |||
533 | /* | ||
534 | * We are supposed to read and the buffer is empty | ||
535 | * -> select on read from tun | ||
536 | */ | ||
537 | if (0 == buftun_size) | ||
538 | FD_SET (fd_tun, &fds_r); | ||
539 | |||
540 | /* | ||
541 | * We are supposed to read and the buffer is not empty | ||
542 | * -> select on write to stdout | ||
543 | */ | ||
544 | if (0 < buftun_size) | ||
545 | FD_SET (1, &fds_w); | ||
546 | |||
547 | /* | ||
548 | * We are supposed to write and the buffer is empty | ||
549 | * -> select on read from stdin | ||
550 | */ | ||
551 | if (NULL == bufin_read) | ||
552 | FD_SET (0, &fds_r); | ||
553 | |||
554 | /* | ||
555 | * We are supposed to write and the buffer is not empty | ||
556 | * -> select on write to tun | ||
557 | */ | ||
558 | if (NULL != bufin_read) | ||
559 | FD_SET (fd_tun, &fds_w); | ||
560 | |||
561 | FD_SET (cpipe[0], &fds_r); | ||
562 | max = (fd_tun > cpipe[0]) ? fd_tun : cpipe[0]; | ||
563 | |||
564 | int r = select (max + 1, &fds_r, &fds_w, NULL, NULL); | ||
565 | |||
566 | if (-1 == r) | ||
567 | { | ||
568 | if (EINTR == errno) | ||
569 | continue; | ||
570 | fprintf (stderr, "select failed: %s\n", strerror (errno)); | ||
571 | return; | ||
572 | } | ||
573 | |||
574 | if (r > 0) | ||
575 | { | 529 | { |
576 | if (FD_ISSET (cpipe[0], &fds_r)) | 530 | FD_ZERO(&fds_w); |
577 | return; /* aborted by signal */ | 531 | FD_ZERO(&fds_r); |
578 | 532 | ||
579 | if (FD_ISSET (fd_tun, &fds_r)) | 533 | /* |
580 | { | 534 | * We are supposed to read and the buffer is empty |
581 | buftun_size = | 535 | * -> select on read from tun |
582 | read (fd_tun, buftun + sizeof (struct GNUNET_MessageHeader), | 536 | */ |
583 | MAX_SIZE - sizeof (struct GNUNET_MessageHeader)); | 537 | if (0 == buftun_size) |
584 | if (-1 == buftun_size) | 538 | FD_SET(fd_tun, &fds_r); |
539 | |||
540 | /* | ||
541 | * We are supposed to read and the buffer is not empty | ||
542 | * -> select on write to stdout | ||
543 | */ | ||
544 | if (0 < buftun_size) | ||
545 | FD_SET(1, &fds_w); | ||
546 | |||
547 | /* | ||
548 | * We are supposed to write and the buffer is empty | ||
549 | * -> select on read from stdin | ||
550 | */ | ||
551 | if (NULL == bufin_read) | ||
552 | FD_SET(0, &fds_r); | ||
553 | |||
554 | /* | ||
555 | * We are supposed to write and the buffer is not empty | ||
556 | * -> select on write to tun | ||
557 | */ | ||
558 | if (NULL != bufin_read) | ||
559 | FD_SET(fd_tun, &fds_w); | ||
560 | |||
561 | FD_SET(cpipe[0], &fds_r); | ||
562 | max = (fd_tun > cpipe[0]) ? fd_tun : cpipe[0]; | ||
563 | |||
564 | int r = select(max + 1, &fds_r, &fds_w, NULL, NULL); | ||
565 | |||
566 | if (-1 == r) | ||
585 | { | 567 | { |
586 | if ( (errno == EINTR) || | 568 | if (EINTR == errno) |
587 | (errno == EAGAIN) ) | 569 | continue; |
588 | { | 570 | fprintf(stderr, "select failed: %s\n", strerror(errno)); |
589 | buftun_size = 0; | ||
590 | continue; | ||
591 | } | ||
592 | fprintf (stderr, "read-error: %s\n", strerror (errno)); | ||
593 | return; | ||
594 | } | ||
595 | if (0 == buftun_size) | ||
596 | { | ||
597 | fprintf (stderr, "EOF on tun\n"); | ||
598 | return; | ||
599 | } | ||
600 | buftun_read = buftun; | ||
601 | { | ||
602 | struct GNUNET_MessageHeader *hdr = | ||
603 | (struct GNUNET_MessageHeader *) buftun; | ||
604 | buftun_size += sizeof (struct GNUNET_MessageHeader); | ||
605 | hdr->type = htons (GNUNET_MESSAGE_TYPE_DNS_HELPER); | ||
606 | hdr->size = htons (buftun_size); | ||
607 | } | ||
608 | } | ||
609 | else if (FD_ISSET (1, &fds_w)) | ||
610 | { | ||
611 | ssize_t written = write (1, buftun_read, buftun_size); | ||
612 | |||
613 | if (-1 == written) | ||
614 | { | ||
615 | if ( (errno == EINTR) || | ||
616 | (errno == EAGAIN) ) | ||
617 | continue; | ||
618 | fprintf (stderr, "write-error to stdout: %s\n", strerror (errno)); | ||
619 | return; | ||
620 | } | ||
621 | if (0 == written) | ||
622 | { | ||
623 | fprintf (stderr, "write returned 0\n"); | ||
624 | return; | 571 | return; |
625 | } | 572 | } |
626 | buftun_size -= written; | ||
627 | buftun_read += written; | ||
628 | } | ||
629 | 573 | ||
630 | if (FD_ISSET (0, &fds_r)) | 574 | if (r > 0) |
631 | { | ||
632 | bufin_size = read (0, bufin + bufin_rpos, MAX_SIZE - bufin_rpos); | ||
633 | if (-1 == bufin_size) | ||
634 | { | 575 | { |
635 | bufin_read = NULL; | 576 | if (FD_ISSET(cpipe[0], &fds_r)) |
636 | if ( (errno == EINTR) || | 577 | return; /* aborted by signal */ |
637 | (errno == EAGAIN) ) | 578 | |
638 | continue; | 579 | if (FD_ISSET(fd_tun, &fds_r)) |
639 | fprintf (stderr, "read-error: %s\n", strerror (errno)); | 580 | { |
640 | return; | 581 | buftun_size = |
641 | } | 582 | read(fd_tun, buftun + sizeof(struct GNUNET_MessageHeader), |
642 | if (0 == bufin_size) | 583 | MAX_SIZE - sizeof(struct GNUNET_MessageHeader)); |
643 | { | 584 | if (-1 == buftun_size) |
644 | bufin_read = NULL; | 585 | { |
645 | fprintf (stderr, "EOF on stdin\n"); | 586 | if ((errno == EINTR) || |
646 | return; | 587 | (errno == EAGAIN)) |
647 | } | 588 | { |
648 | { | 589 | buftun_size = 0; |
649 | struct GNUNET_MessageHeader *hdr; | 590 | continue; |
591 | } | ||
592 | fprintf(stderr, "read-error: %s\n", strerror(errno)); | ||
593 | return; | ||
594 | } | ||
595 | if (0 == buftun_size) | ||
596 | { | ||
597 | fprintf(stderr, "EOF on tun\n"); | ||
598 | return; | ||
599 | } | ||
600 | buftun_read = buftun; | ||
601 | { | ||
602 | struct GNUNET_MessageHeader *hdr = | ||
603 | (struct GNUNET_MessageHeader *)buftun; | ||
604 | buftun_size += sizeof(struct GNUNET_MessageHeader); | ||
605 | hdr->type = htons(GNUNET_MESSAGE_TYPE_DNS_HELPER); | ||
606 | hdr->size = htons(buftun_size); | ||
607 | } | ||
608 | } | ||
609 | else if (FD_ISSET(1, &fds_w)) | ||
610 | { | ||
611 | ssize_t written = write(1, buftun_read, buftun_size); | ||
612 | |||
613 | if (-1 == written) | ||
614 | { | ||
615 | if ((errno == EINTR) || | ||
616 | (errno == EAGAIN)) | ||
617 | continue; | ||
618 | fprintf(stderr, "write-error to stdout: %s\n", strerror(errno)); | ||
619 | return; | ||
620 | } | ||
621 | if (0 == written) | ||
622 | { | ||
623 | fprintf(stderr, "write returned 0\n"); | ||
624 | return; | ||
625 | } | ||
626 | buftun_size -= written; | ||
627 | buftun_read += written; | ||
628 | } | ||
629 | |||
630 | if (FD_ISSET(0, &fds_r)) | ||
631 | { | ||
632 | bufin_size = read(0, bufin + bufin_rpos, MAX_SIZE - bufin_rpos); | ||
633 | if (-1 == bufin_size) | ||
634 | { | ||
635 | bufin_read = NULL; | ||
636 | if ((errno == EINTR) || | ||
637 | (errno == EAGAIN)) | ||
638 | continue; | ||
639 | fprintf(stderr, "read-error: %s\n", strerror(errno)); | ||
640 | return; | ||
641 | } | ||
642 | if (0 == bufin_size) | ||
643 | { | ||
644 | bufin_read = NULL; | ||
645 | fprintf(stderr, "EOF on stdin\n"); | ||
646 | return; | ||
647 | } | ||
648 | { | ||
649 | struct GNUNET_MessageHeader *hdr; | ||
650 | 650 | ||
651 | PROCESS_BUFFER: | 651 | PROCESS_BUFFER: |
652 | bufin_rpos += bufin_size; | 652 | bufin_rpos += bufin_size; |
653 | if (bufin_rpos < sizeof (struct GNUNET_MessageHeader)) | 653 | if (bufin_rpos < sizeof(struct GNUNET_MessageHeader)) |
654 | continue; | 654 | continue; |
655 | hdr = (struct GNUNET_MessageHeader *) bufin; | 655 | hdr = (struct GNUNET_MessageHeader *)bufin; |
656 | if (ntohs (hdr->type) != GNUNET_MESSAGE_TYPE_DNS_HELPER) | 656 | if (ntohs(hdr->type) != GNUNET_MESSAGE_TYPE_DNS_HELPER) |
657 | { | 657 | { |
658 | fprintf (stderr, "protocol violation!\n"); | 658 | fprintf(stderr, "protocol violation!\n"); |
659 | return; | 659 | return; |
660 | } | 660 | } |
661 | if (ntohs (hdr->size) > bufin_rpos) | 661 | if (ntohs(hdr->size) > bufin_rpos) |
662 | continue; | 662 | continue; |
663 | bufin_read = bufin + sizeof (struct GNUNET_MessageHeader); | 663 | bufin_read = bufin + sizeof(struct GNUNET_MessageHeader); |
664 | bufin_size = ntohs (hdr->size) - sizeof (struct GNUNET_MessageHeader); | 664 | bufin_size = ntohs(hdr->size) - sizeof(struct GNUNET_MessageHeader); |
665 | bufin_rpos -= bufin_size + sizeof (struct GNUNET_MessageHeader); | 665 | bufin_rpos -= bufin_size + sizeof(struct GNUNET_MessageHeader); |
666 | } | 666 | } |
667 | } | 667 | } |
668 | else if (FD_ISSET (fd_tun, &fds_w)) | 668 | else if (FD_ISSET(fd_tun, &fds_w)) |
669 | { | 669 | { |
670 | ssize_t written = write (fd_tun, bufin_read, bufin_size); | 670 | ssize_t written = write(fd_tun, bufin_read, bufin_size); |
671 | 671 | ||
672 | if (-1 == written) | 672 | if (-1 == written) |
673 | { | 673 | { |
674 | if ( (errno == EINTR) || | 674 | if ((errno == EINTR) || |
675 | (errno == EAGAIN) ) | 675 | (errno == EAGAIN)) |
676 | continue; | 676 | continue; |
677 | fprintf (stderr, "write-error to tun: %s\n", strerror (errno)); | 677 | fprintf(stderr, "write-error to tun: %s\n", strerror(errno)); |
678 | return; | 678 | return; |
679 | } | 679 | } |
680 | if (0 == written) | 680 | if (0 == written) |
681 | { | 681 | { |
682 | fprintf (stderr, "write returned 0\n"); | 682 | fprintf(stderr, "write returned 0\n"); |
683 | return; | 683 | return; |
684 | } | ||
685 | { | ||
686 | bufin_size -= written; | ||
687 | bufin_read += written; | ||
688 | if (0 == bufin_size) | ||
689 | { | ||
690 | memmove(bufin, bufin_read, bufin_rpos); | ||
691 | bufin_read = NULL; /* start reading again */ | ||
692 | bufin_size = 0; | ||
693 | goto PROCESS_BUFFER; | ||
694 | } | ||
695 | } | ||
696 | } | ||
684 | } | 697 | } |
685 | { | ||
686 | bufin_size -= written; | ||
687 | bufin_read += written; | ||
688 | if (0 == bufin_size) | ||
689 | { | ||
690 | memmove (bufin, bufin_read, bufin_rpos); | ||
691 | bufin_read = NULL; /* start reading again */ | ||
692 | bufin_size = 0; | ||
693 | goto PROCESS_BUFFER; | ||
694 | } | ||
695 | } | ||
696 | } | ||
697 | } | 698 | } |
698 | } | ||
699 | } | 699 | } |
700 | 700 | ||
701 | 701 | ||
@@ -732,7 +732,7 @@ PROCESS_BUFFER: | |||
732 | * 255 failed to handle kill signal properly | 732 | * 255 failed to handle kill signal properly |
733 | */ | 733 | */ |
734 | int | 734 | int |
735 | main (int argc, char *const*argv) | 735 | main(int argc, char *const*argv) |
736 | { | 736 | { |
737 | int r; | 737 | int r; |
738 | char dev[IFNAMSIZ]; | 738 | char dev[IFNAMSIZ]; |
@@ -742,224 +742,224 @@ main (int argc, char *const*argv) | |||
742 | int nortsetup = 0; | 742 | int nortsetup = 0; |
743 | 743 | ||
744 | if (7 != argc) | 744 | if (7 != argc) |
745 | { | 745 | { |
746 | fprintf (stderr, "Fatal: must supply 6 arguments!\n"); | 746 | fprintf(stderr, "Fatal: must supply 6 arguments!\n"); |
747 | return 1; | 747 | return 1; |
748 | } | 748 | } |
749 | 749 | ||
750 | /* assert privs so we can modify the firewall rules! */ | 750 | /* assert privs so we can modify the firewall rules! */ |
751 | uid = getuid (); | 751 | uid = getuid(); |
752 | #ifdef HAVE_SETRESUID | 752 | #ifdef HAVE_SETRESUID |
753 | if (0 != setresuid (uid, 0, 0)) | 753 | if (0 != setresuid(uid, 0, 0)) |
754 | { | 754 | { |
755 | fprintf (stderr, "Failed to setresuid to root: %s\n", strerror (errno)); | 755 | fprintf(stderr, "Failed to setresuid to root: %s\n", strerror(errno)); |
756 | return 254; | 756 | return 254; |
757 | } | 757 | } |
758 | #else | 758 | #else |
759 | if (0 != seteuid (0)) | 759 | if (0 != seteuid(0)) |
760 | { | 760 | { |
761 | fprintf (stderr, "Failed to seteuid back to root: %s\n", strerror (errno)); | 761 | fprintf(stderr, "Failed to seteuid back to root: %s\n", strerror(errno)); |
762 | return 254; | 762 | return 254; |
763 | } | 763 | } |
764 | #endif | 764 | #endif |
765 | if (0 == strncmp (argv[6], "1", 2)) | 765 | if (0 == strncmp(argv[6], "1", 2)) |
766 | nortsetup = 1; | 766 | nortsetup = 1; |
767 | 767 | ||
768 | if (0 == nortsetup) | 768 | if (0 == nortsetup) |
769 | { | 769 | { |
770 | /* verify that the binaries we care about are executable */ | 770 | /* verify that the binaries we care about are executable */ |
771 | #ifdef IPTABLES | 771 | #ifdef IPTABLES |
772 | if (0 == access (IPTABLES, X_OK)) | 772 | if (0 == access(IPTABLES, X_OK)) |
773 | sbin_iptables = IPTABLES; | 773 | sbin_iptables = IPTABLES; |
774 | else | 774 | else |
775 | #endif | 775 | #endif |
776 | if (0 == access ("/sbin/iptables", X_OK)) | 776 | if (0 == access("/sbin/iptables", X_OK)) |
777 | sbin_iptables = "/sbin/iptables"; | 777 | sbin_iptables = "/sbin/iptables"; |
778 | else if (0 == access ("/usr/sbin/iptables", X_OK)) | 778 | else if (0 == access("/usr/sbin/iptables", X_OK)) |
779 | sbin_iptables = "/usr/sbin/iptables"; | 779 | sbin_iptables = "/usr/sbin/iptables"; |
780 | else | 780 | else |
781 | { | 781 | { |
782 | fprintf (stderr, | 782 | fprintf(stderr, |
783 | "Fatal: executable iptables not found in approved directories: %s\n", | 783 | "Fatal: executable iptables not found in approved directories: %s\n", |
784 | strerror (errno)); | 784 | strerror(errno)); |
785 | return 3; | 785 | return 3; |
786 | } | 786 | } |
787 | #ifdef IP6TABLES | 787 | #ifdef IP6TABLES |
788 | if (0 == access (IP6TABLES, X_OK)) | 788 | if (0 == access(IP6TABLES, X_OK)) |
789 | sbin_ip6tables = IP6TABLES; | 789 | sbin_ip6tables = IP6TABLES; |
790 | else | 790 | else |
791 | #endif | 791 | #endif |
792 | if (0 == access ("/sbin/ip6tables", X_OK)) | 792 | if (0 == access("/sbin/ip6tables", X_OK)) |
793 | sbin_ip6tables = "/sbin/ip6tables"; | 793 | sbin_ip6tables = "/sbin/ip6tables"; |
794 | else if (0 == access ("/usr/sbin/ip6tables", X_OK)) | 794 | else if (0 == access("/usr/sbin/ip6tables", X_OK)) |
795 | sbin_ip6tables = "/usr/sbin/ip6tables"; | 795 | sbin_ip6tables = "/usr/sbin/ip6tables"; |
796 | else | 796 | else |
797 | { | 797 | { |
798 | fprintf (stderr, | 798 | fprintf(stderr, |
799 | "Fatal: executable ip6tables not found in approved directories: %s\n", | 799 | "Fatal: executable ip6tables not found in approved directories: %s\n", |
800 | strerror (errno)); | 800 | strerror(errno)); |
801 | return 3; | 801 | return 3; |
802 | } | 802 | } |
803 | #ifdef PATH_TO_IP | 803 | #ifdef PATH_TO_IP |
804 | if (0 == access (PATH_TO_IP, X_OK)) | 804 | if (0 == access(PATH_TO_IP, X_OK)) |
805 | sbin_ip = PATH_TO_IP; | 805 | sbin_ip = PATH_TO_IP; |
806 | else | 806 | else |
807 | #endif | 807 | #endif |
808 | if (0 == access ("/sbin/ip", X_OK)) | 808 | if (0 == access("/sbin/ip", X_OK)) |
809 | sbin_ip = "/sbin/ip"; | 809 | sbin_ip = "/sbin/ip"; |
810 | else if (0 == access ("/usr/sbin/ip", X_OK)) | 810 | else if (0 == access("/usr/sbin/ip", X_OK)) |
811 | sbin_ip = "/usr/sbin/ip"; | 811 | sbin_ip = "/usr/sbin/ip"; |
812 | else if (0 == access ("/bin/ip", X_OK)) /* gentoo has it there */ | 812 | else if (0 == access("/bin/ip", X_OK)) /* gentoo has it there */ |
813 | sbin_ip = "/bin/ip"; | 813 | sbin_ip = "/bin/ip"; |
814 | else | 814 | else |
815 | { | 815 | { |
816 | fprintf (stderr, | 816 | fprintf(stderr, |
817 | "Fatal: executable ip not found in approved directories: %s\n", | 817 | "Fatal: executable ip not found in approved directories: %s\n", |
818 | strerror (errno)); | 818 | strerror(errno)); |
819 | return 4; | 819 | return 4; |
820 | } | 820 | } |
821 | #ifdef SYSCTL | 821 | #ifdef SYSCTL |
822 | if (0 == access (SYSCTL, X_OK)) | 822 | if (0 == access(SYSCTL, X_OK)) |
823 | sbin_sysctl = SYSCTL; | 823 | sbin_sysctl = SYSCTL; |
824 | else | 824 | else |
825 | #endif | 825 | #endif |
826 | if (0 == access ("/sbin/sysctl", X_OK)) | 826 | if (0 == access("/sbin/sysctl", X_OK)) |
827 | sbin_sysctl = "/sbin/sysctl"; | 827 | sbin_sysctl = "/sbin/sysctl"; |
828 | else if (0 == access ("/usr/sbin/sysctl", X_OK)) | 828 | else if (0 == access("/usr/sbin/sysctl", X_OK)) |
829 | sbin_sysctl = "/usr/sbin/sysctl"; | 829 | sbin_sysctl = "/usr/sbin/sysctl"; |
830 | else | 830 | else |
831 | { | 831 | { |
832 | fprintf (stderr, | 832 | fprintf(stderr, |
833 | "Fatal: executable sysctl not found in approved directories: %s\n", | 833 | "Fatal: executable sysctl not found in approved directories: %s\n", |
834 | strerror (errno)); | 834 | strerror(errno)); |
835 | return 5; | 835 | return 5; |
836 | } | ||
836 | } | 837 | } |
837 | } | ||
838 | 838 | ||
839 | /* setup 'mygid' string */ | 839 | /* setup 'mygid' string */ |
840 | snprintf (mygid, sizeof (mygid), "%d", (int) getegid()); | 840 | snprintf(mygid, sizeof(mygid), "%d", (int)getegid()); |
841 | 841 | ||
842 | /* do not die on SIGPIPE */ | 842 | /* do not die on SIGPIPE */ |
843 | if (SIG_ERR == signal (SIGPIPE, SIG_IGN)) | 843 | if (SIG_ERR == signal(SIGPIPE, SIG_IGN)) |
844 | { | 844 | { |
845 | fprintf (stderr, "Failed to protect against SIGPIPE: %s\n", | 845 | fprintf(stderr, "Failed to protect against SIGPIPE: %s\n", |
846 | strerror (errno)); | 846 | strerror(errno)); |
847 | return 7; | 847 | return 7; |
848 | } | 848 | } |
849 | 849 | ||
850 | /* setup pipe to shutdown nicely on SIGINT */ | 850 | /* setup pipe to shutdown nicely on SIGINT */ |
851 | if (0 != pipe (cpipe)) | 851 | if (0 != pipe(cpipe)) |
852 | { | ||
853 | fprintf (stderr, | ||
854 | "Fatal: could not setup control pipe: %s\n", | ||
855 | strerror (errno)); | ||
856 | return 6; | ||
857 | } | ||
858 | if (cpipe[0] >= FD_SETSIZE) | ||
859 | { | ||
860 | fprintf (stderr, "Pipe file descriptor to large: %d", cpipe[0]); | ||
861 | (void) close (cpipe[0]); | ||
862 | (void) close (cpipe[1]); | ||
863 | return 6; | ||
864 | } | ||
865 | { | ||
866 | /* make pipe non-blocking, as we theoretically could otherwise block | ||
867 | in the signal handler */ | ||
868 | int flags = fcntl (cpipe[1], F_GETFL); | ||
869 | if (-1 == flags) | ||
870 | { | 852 | { |
871 | fprintf (stderr, "Failed to read flags for pipe: %s", strerror (errno)); | 853 | fprintf(stderr, |
872 | (void) close (cpipe[0]); | 854 | "Fatal: could not setup control pipe: %s\n", |
873 | (void) close (cpipe[1]); | 855 | strerror(errno)); |
874 | return 6; | 856 | return 6; |
875 | } | 857 | } |
876 | flags |= O_NONBLOCK; | 858 | if (cpipe[0] >= FD_SETSIZE) |
877 | if (0 != fcntl (cpipe[1], F_SETFL, flags)) | ||
878 | { | 859 | { |
879 | fprintf (stderr, "Failed to make pipe non-blocking: %s", strerror (errno)); | 860 | fprintf(stderr, "Pipe file descriptor to large: %d", cpipe[0]); |
880 | (void) close (cpipe[0]); | 861 | (void)close(cpipe[0]); |
881 | (void) close (cpipe[1]); | 862 | (void)close(cpipe[1]); |
882 | return 6; | 863 | return 6; |
883 | } | 864 | } |
865 | { | ||
866 | /* make pipe non-blocking, as we theoretically could otherwise block | ||
867 | in the signal handler */ | ||
868 | int flags = fcntl(cpipe[1], F_GETFL); | ||
869 | if (-1 == flags) | ||
870 | { | ||
871 | fprintf(stderr, "Failed to read flags for pipe: %s", strerror(errno)); | ||
872 | (void)close(cpipe[0]); | ||
873 | (void)close(cpipe[1]); | ||
874 | return 6; | ||
875 | } | ||
876 | flags |= O_NONBLOCK; | ||
877 | if (0 != fcntl(cpipe[1], F_SETFL, flags)) | ||
878 | { | ||
879 | fprintf(stderr, "Failed to make pipe non-blocking: %s", strerror(errno)); | ||
880 | (void)close(cpipe[0]); | ||
881 | (void)close(cpipe[1]); | ||
882 | return 6; | ||
883 | } | ||
884 | } | 884 | } |
885 | if ( (SIG_ERR == signal (SIGTERM, &signal_handler)) || | 885 | if ((SIG_ERR == signal(SIGTERM, &signal_handler)) || |
886 | #if (SIGTERM != GNUNET_TERM_SIG) | 886 | #if (SIGTERM != GNUNET_TERM_SIG) |
887 | (SIG_ERR == signal (GNUNET_TERM_SIG, &signal_handler)) || | 887 | (SIG_ERR == signal(GNUNET_TERM_SIG, &signal_handler)) || |
888 | #endif | 888 | #endif |
889 | (SIG_ERR == signal (SIGINT, &signal_handler)) || | 889 | (SIG_ERR == signal(SIGINT, &signal_handler)) || |
890 | (SIG_ERR == signal (SIGHUP, &signal_handler)) ) | 890 | (SIG_ERR == signal(SIGHUP, &signal_handler))) |
891 | { | 891 | { |
892 | fprintf (stderr, | 892 | fprintf(stderr, |
893 | "Fatal: could not initialize signal handler: %s\n", | 893 | "Fatal: could not initialize signal handler: %s\n", |
894 | strerror (errno)); | 894 | strerror(errno)); |
895 | (void) close (cpipe[0]); | 895 | (void)close(cpipe[0]); |
896 | (void) close (cpipe[1]); | 896 | (void)close(cpipe[1]); |
897 | return 7; | 897 | return 7; |
898 | } | 898 | } |
899 | 899 | ||
900 | 900 | ||
901 | /* get interface name */ | 901 | /* get interface name */ |
902 | strncpy (dev, argv[1], IFNAMSIZ); | 902 | strncpy(dev, argv[1], IFNAMSIZ); |
903 | dev[IFNAMSIZ - 1] = '\0'; | 903 | dev[IFNAMSIZ - 1] = '\0'; |
904 | 904 | ||
905 | /* Disable rp filtering */ | 905 | /* Disable rp filtering */ |
906 | if (0 == nortsetup) | 906 | if (0 == nortsetup) |
907 | { | ||
908 | char *const sysctl_args[] = {"sysctl", "-w", | ||
909 | "net.ipv4.conf.all.rp_filter=0", NULL}; | ||
910 | char *const sysctl_args2[] = {"sysctl", "-w", | ||
911 | "net.ipv4.conf.default.rp_filter=0", NULL}; | ||
912 | if ((0 != fork_and_exec (sbin_sysctl, sysctl_args)) || | ||
913 | (0 != fork_and_exec (sbin_sysctl, sysctl_args2))) | ||
914 | { | 907 | { |
915 | fprintf (stderr, | 908 | char *const sysctl_args[] = { "sysctl", "-w", |
916 | "Failed to disable rp filtering.\n"); | 909 | "net.ipv4.conf.all.rp_filter=0", NULL }; |
917 | return 5; | 910 | char *const sysctl_args2[] = { "sysctl", "-w", |
911 | "net.ipv4.conf.default.rp_filter=0", NULL }; | ||
912 | if ((0 != fork_and_exec(sbin_sysctl, sysctl_args)) || | ||
913 | (0 != fork_and_exec(sbin_sysctl, sysctl_args2))) | ||
914 | { | ||
915 | fprintf(stderr, | ||
916 | "Failed to disable rp filtering.\n"); | ||
917 | return 5; | ||
918 | } | ||
918 | } | 919 | } |
919 | } | ||
920 | 920 | ||
921 | 921 | ||
922 | /* now open virtual interface (first part that requires root) */ | 922 | /* now open virtual interface (first part that requires root) */ |
923 | if (-1 == (fd_tun = init_tun (dev))) | 923 | if (-1 == (fd_tun = init_tun(dev))) |
924 | { | 924 | { |
925 | fprintf (stderr, "Fatal: could not initialize tun-interface\n"); | 925 | fprintf(stderr, "Fatal: could not initialize tun-interface\n"); |
926 | (void) signal (SIGTERM, SIG_IGN); | 926 | (void)signal(SIGTERM, SIG_IGN); |
927 | #if (SIGTERM != GNUNET_TERM_SIG) | 927 | #if (SIGTERM != GNUNET_TERM_SIG) |
928 | (void) signal (GNUNET_TERM_SIG, SIG_IGN); | 928 | (void)signal(GNUNET_TERM_SIG, SIG_IGN); |
929 | #endif | 929 | #endif |
930 | (void) signal (SIGINT, SIG_IGN); | 930 | (void)signal(SIGINT, SIG_IGN); |
931 | (void) signal (SIGHUP, SIG_IGN); | 931 | (void)signal(SIGHUP, SIG_IGN); |
932 | (void) close (cpipe[0]); | 932 | (void)close(cpipe[0]); |
933 | (void) close (cpipe[1]); | 933 | (void)close(cpipe[1]); |
934 | return 5; | 934 | return 5; |
935 | } | 935 | } |
936 | 936 | ||
937 | /* now set interface addresses */ | 937 | /* now set interface addresses */ |
938 | { | 938 | { |
939 | const char *address = argv[2]; | 939 | const char *address = argv[2]; |
940 | long prefix_len = atol (argv[3]); | 940 | long prefix_len = atol(argv[3]); |
941 | 941 | ||
942 | if ((prefix_len < 1) || (prefix_len > 127)) | 942 | if ((prefix_len < 1) || (prefix_len > 127)) |
943 | { | 943 | { |
944 | fprintf (stderr, "Fatal: prefix_len out of range\n"); | 944 | fprintf(stderr, "Fatal: prefix_len out of range\n"); |
945 | (void) signal (SIGTERM, SIG_IGN); | 945 | (void)signal(SIGTERM, SIG_IGN); |
946 | #if (SIGTERM != GNUNET_TERM_SIG) | 946 | #if (SIGTERM != GNUNET_TERM_SIG) |
947 | (void) signal (GNUNET_TERM_SIG, SIG_IGN); | 947 | (void)signal(GNUNET_TERM_SIG, SIG_IGN); |
948 | #endif | 948 | #endif |
949 | (void) signal (SIGINT, SIG_IGN); | 949 | (void)signal(SIGINT, SIG_IGN); |
950 | (void) signal (SIGHUP, SIG_IGN); | 950 | (void)signal(SIGHUP, SIG_IGN); |
951 | (void) close (cpipe[0]); | 951 | (void)close(cpipe[0]); |
952 | (void) close (cpipe[1]); | 952 | (void)close(cpipe[1]); |
953 | return 2; | 953 | return 2; |
954 | } | 954 | } |
955 | set_address6 (dev, address, prefix_len); | 955 | set_address6(dev, address, prefix_len); |
956 | } | 956 | } |
957 | 957 | ||
958 | { | 958 | { |
959 | const char *address = argv[4]; | 959 | const char *address = argv[4]; |
960 | const char *mask = argv[5]; | 960 | const char *mask = argv[5]; |
961 | 961 | ||
962 | set_address4 (dev, address, mask); | 962 | set_address4(dev, address, mask); |
963 | } | 963 | } |
964 | 964 | ||
965 | 965 | ||
@@ -968,237 +968,237 @@ main (int argc, char *const*argv) | |||
968 | by the 'gnunet-service-dns') and with destination | 968 | by the 'gnunet-service-dns') and with destination |
969 | to port 53 on UDP, without hijacking */ | 969 | to port 53 on UDP, without hijacking */ |
970 | if (0 == nortsetup) | 970 | if (0 == nortsetup) |
971 | { | ||
972 | r = 8; /* failed to fully setup routing table */ | ||
973 | { | 971 | { |
974 | char *const mangle_args[] = | 972 | r = 8; /* failed to fully setup routing table */ |
973 | { | ||
974 | char *const mangle_args[] = | ||
975 | { | 975 | { |
976 | "iptables", "-m", "owner", "-t", "mangle", "-I", "OUTPUT", "1", "-p", | 976 | "iptables", "-m", "owner", "-t", "mangle", "-I", "OUTPUT", "1", "-p", |
977 | "udp", "--gid-owner", mygid, "--dport", DNS_PORT, "-j", | 977 | "udp", "--gid-owner", mygid, "--dport", DNS_PORT, "-j", |
978 | "ACCEPT", NULL | 978 | "ACCEPT", NULL |
979 | }; | 979 | }; |
980 | if (0 != fork_and_exec (sbin_iptables, mangle_args)) | 980 | if (0 != fork_and_exec(sbin_iptables, mangle_args)) |
981 | goto cleanup_rest; | 981 | goto cleanup_rest; |
982 | } | 982 | } |
983 | { | 983 | { |
984 | char *const mangle_args[] = | 984 | char *const mangle_args[] = |
985 | { | 985 | { |
986 | "ip6tables", "-m", "owner", "-t", "mangle", "-I", "OUTPUT", "1", "-p", | 986 | "ip6tables", "-m", "owner", "-t", "mangle", "-I", "OUTPUT", "1", "-p", |
987 | "udp", "--gid-owner", mygid, "--dport", DNS_PORT, "-j", | 987 | "udp", "--gid-owner", mygid, "--dport", DNS_PORT, "-j", |
988 | "ACCEPT", NULL | 988 | "ACCEPT", NULL |
989 | }; | 989 | }; |
990 | if (0 != fork_and_exec (sbin_ip6tables, mangle_args)) | 990 | if (0 != fork_and_exec(sbin_ip6tables, mangle_args)) |
991 | goto cleanup_mangle_1b; | 991 | goto cleanup_mangle_1b; |
992 | } | 992 | } |
993 | /* Mark all of the other DNS traffic using our mark DNS_MARK, | 993 | /* Mark all of the other DNS traffic using our mark DNS_MARK, |
994 | unless it is on a link-local IPv6 address, which we cannot support. */ | 994 | unless it is on a link-local IPv6 address, which we cannot support. */ |
995 | { | 995 | { |
996 | char *const mark_args[] = | 996 | char *const mark_args[] = |
997 | { | 997 | { |
998 | "iptables", "-t", "mangle", "-I", "OUTPUT", "2", "-p", | 998 | "iptables", "-t", "mangle", "-I", "OUTPUT", "2", "-p", |
999 | "udp", "--dport", DNS_PORT, | 999 | "udp", "--dport", DNS_PORT, |
1000 | "-j", "MARK", "--set-mark", DNS_MARK, | 1000 | "-j", "MARK", "--set-mark", DNS_MARK, |
1001 | NULL | 1001 | NULL |
1002 | }; | 1002 | }; |
1003 | if (0 != fork_and_exec (sbin_iptables, mark_args)) | 1003 | if (0 != fork_and_exec(sbin_iptables, mark_args)) |
1004 | goto cleanup_mangle_1; | 1004 | goto cleanup_mangle_1; |
1005 | } | 1005 | } |
1006 | { | 1006 | { |
1007 | char *const mark_args[] = | 1007 | char *const mark_args[] = |
1008 | { | 1008 | { |
1009 | "ip6tables", "-t", "mangle", "-I", "OUTPUT", "2", "-p", | 1009 | "ip6tables", "-t", "mangle", "-I", "OUTPUT", "2", "-p", |
1010 | "udp", "--dport", DNS_PORT, | 1010 | "udp", "--dport", DNS_PORT, |
1011 | "!", "-s", "fe80::/10", /* this line excludes link-local traffic */ | 1011 | "!", "-s", "fe80::/10", /* this line excludes link-local traffic */ |
1012 | "-j", "MARK", "--set-mark", DNS_MARK, | 1012 | "-j", "MARK", "--set-mark", DNS_MARK, |
1013 | NULL | 1013 | NULL |
1014 | }; | 1014 | }; |
1015 | if (0 != fork_and_exec (sbin_ip6tables, mark_args)) | 1015 | if (0 != fork_and_exec(sbin_ip6tables, mark_args)) |
1016 | goto cleanup_mark_2b; | 1016 | goto cleanup_mark_2b; |
1017 | } | 1017 | } |
1018 | /* Forward all marked DNS traffic to our DNS_TABLE */ | 1018 | /* Forward all marked DNS traffic to our DNS_TABLE */ |
1019 | { | 1019 | { |
1020 | char *const forward_args[] = | 1020 | char *const forward_args[] = |
1021 | { | 1021 | { |
1022 | "ip", "rule", "add", "fwmark", DNS_MARK, "table", DNS_TABLE, NULL | 1022 | "ip", "rule", "add", "fwmark", DNS_MARK, "table", DNS_TABLE, NULL |
1023 | }; | 1023 | }; |
1024 | if (0 != fork_and_exec (sbin_ip, forward_args)) | 1024 | if (0 != fork_and_exec(sbin_ip, forward_args)) |
1025 | goto cleanup_mark_2; | 1025 | goto cleanup_mark_2; |
1026 | } | 1026 | } |
1027 | { | 1027 | { |
1028 | char *const forward_args[] = | 1028 | char *const forward_args[] = |
1029 | { | 1029 | { |
1030 | "ip", "-6", "rule", "add", "fwmark", DNS_MARK, "table", DNS_TABLE, NULL | 1030 | "ip", "-6", "rule", "add", "fwmark", DNS_MARK, "table", DNS_TABLE, NULL |
1031 | }; | 1031 | }; |
1032 | if (0 != fork_and_exec (sbin_ip, forward_args)) | 1032 | if (0 != fork_and_exec(sbin_ip, forward_args)) |
1033 | goto cleanup_forward_3b; | 1033 | goto cleanup_forward_3b; |
1034 | } | 1034 | } |
1035 | /* Finally, add rule in our forwarding table to pass to our virtual interface */ | 1035 | /* Finally, add rule in our forwarding table to pass to our virtual interface */ |
1036 | { | 1036 | { |
1037 | char *const route_args[] = | 1037 | char *const route_args[] = |
1038 | { | 1038 | { |
1039 | "ip", "route", "add", "default", "dev", dev, | 1039 | "ip", "route", "add", "default", "dev", dev, |
1040 | "table", DNS_TABLE, NULL | 1040 | "table", DNS_TABLE, NULL |
1041 | }; | 1041 | }; |
1042 | if (0 != fork_and_exec (sbin_ip, route_args)) | 1042 | if (0 != fork_and_exec(sbin_ip, route_args)) |
1043 | goto cleanup_forward_3; | 1043 | goto cleanup_forward_3; |
1044 | } | 1044 | } |
1045 | { | 1045 | { |
1046 | char *const route_args[] = | 1046 | char *const route_args[] = |
1047 | { | 1047 | { |
1048 | "ip", "-6", "route", "add", "default", "dev", dev, | 1048 | "ip", "-6", "route", "add", "default", "dev", dev, |
1049 | "table", DNS_TABLE, NULL | 1049 | "table", DNS_TABLE, NULL |
1050 | }; | 1050 | }; |
1051 | if (0 != fork_and_exec (sbin_ip, route_args)) | 1051 | if (0 != fork_and_exec(sbin_ip, route_args)) |
1052 | goto cleanup_route_4b; | 1052 | goto cleanup_route_4b; |
1053 | } | ||
1053 | } | 1054 | } |
1054 | } | ||
1055 | 1055 | ||
1056 | /* drop privs *except* for the saved UID; this is not perfect, but better | 1056 | /* drop privs *except* for the saved UID; this is not perfect, but better |
1057 | than doing nothing */ | 1057 | than doing nothing */ |
1058 | #ifdef HAVE_SETRESUID | 1058 | #ifdef HAVE_SETRESUID |
1059 | if (0 != setresuid (uid, uid, 0)) | 1059 | if (0 != setresuid(uid, uid, 0)) |
1060 | { | 1060 | { |
1061 | fprintf (stderr, "Failed to setresuid: %s\n", strerror (errno)); | 1061 | fprintf(stderr, "Failed to setresuid: %s\n", strerror(errno)); |
1062 | r = 24; | 1062 | r = 24; |
1063 | goto cleanup_route_4; | 1063 | goto cleanup_route_4; |
1064 | } | 1064 | } |
1065 | #else | 1065 | #else |
1066 | /* Note: no 'setuid' here as we must keep our saved UID as root */ | 1066 | /* Note: no 'setuid' here as we must keep our saved UID as root */ |
1067 | if (0 != seteuid (uid)) | 1067 | if (0 != seteuid(uid)) |
1068 | { | 1068 | { |
1069 | fprintf (stderr, "Failed to seteuid: %s\n", strerror (errno)); | 1069 | fprintf(stderr, "Failed to seteuid: %s\n", strerror(errno)); |
1070 | r = 24; | 1070 | r = 24; |
1071 | goto cleanup_route_4; | 1071 | goto cleanup_route_4; |
1072 | } | 1072 | } |
1073 | #endif | 1073 | #endif |
1074 | 1074 | ||
1075 | r = 0; /* did fully setup routing table (if nothing else happens, we were successful!) */ | 1075 | r = 0; /* did fully setup routing table (if nothing else happens, we were successful!) */ |
1076 | 1076 | ||
1077 | /* now forward until we hit a problem */ | 1077 | /* now forward until we hit a problem */ |
1078 | run (fd_tun); | 1078 | run(fd_tun); |
1079 | 1079 | ||
1080 | /* now need to regain privs so we can remove the firewall rules we added! */ | 1080 | /* now need to regain privs so we can remove the firewall rules we added! */ |
1081 | #ifdef HAVE_SETRESUID | 1081 | #ifdef HAVE_SETRESUID |
1082 | if (0 != setresuid (uid, 0, 0)) | 1082 | if (0 != setresuid(uid, 0, 0)) |
1083 | { | 1083 | { |
1084 | fprintf (stderr, "Failed to setresuid back to root: %s\n", strerror (errno)); | 1084 | fprintf(stderr, "Failed to setresuid back to root: %s\n", strerror(errno)); |
1085 | r = 40; | 1085 | r = 40; |
1086 | goto cleanup_route_4; | 1086 | goto cleanup_route_4; |
1087 | } | 1087 | } |
1088 | #else | 1088 | #else |
1089 | if (0 != seteuid (0)) | 1089 | if (0 != seteuid(0)) |
1090 | { | 1090 | { |
1091 | fprintf (stderr, "Failed to seteuid back to root: %s\n", strerror (errno)); | 1091 | fprintf(stderr, "Failed to seteuid back to root: %s\n", strerror(errno)); |
1092 | r = 40; | 1092 | r = 40; |
1093 | goto cleanup_route_4; | 1093 | goto cleanup_route_4; |
1094 | } | 1094 | } |
1095 | #endif | 1095 | #endif |
1096 | 1096 | ||
1097 | /* update routing tables again -- this is why we could not fully drop privs */ | 1097 | /* update routing tables again -- this is why we could not fully drop privs */ |
1098 | /* now undo updating of routing tables; normal exit or clean-up-on-error case */ | 1098 | /* now undo updating of routing tables; normal exit or clean-up-on-error case */ |
1099 | cleanup_route_4: | 1099 | cleanup_route_4: |
1100 | if (0 == nortsetup) | 1100 | if (0 == nortsetup) |
1101 | { | 1101 | { |
1102 | char *const route_clean_args[] = | 1102 | char *const route_clean_args[] = |
1103 | { | 1103 | { |
1104 | "ip", "-6", "route", "del", "default", "dev", dev, | 1104 | "ip", "-6", "route", "del", "default", "dev", dev, |
1105 | "table", DNS_TABLE, NULL | 1105 | "table", DNS_TABLE, NULL |
1106 | }; | 1106 | }; |
1107 | if (0 != fork_and_exec (sbin_ip, route_clean_args)) | 1107 | if (0 != fork_and_exec(sbin_ip, route_clean_args)) |
1108 | r += 1; | 1108 | r += 1; |
1109 | } | 1109 | } |
1110 | cleanup_route_4b: | 1110 | cleanup_route_4b: |
1111 | if (0 == nortsetup) | 1111 | if (0 == nortsetup) |
1112 | { | 1112 | { |
1113 | char *const route_clean_args[] = | 1113 | char *const route_clean_args[] = |
1114 | { | 1114 | { |
1115 | "ip", "route", "del", "default", "dev", dev, | 1115 | "ip", "route", "del", "default", "dev", dev, |
1116 | "table", DNS_TABLE, NULL | 1116 | "table", DNS_TABLE, NULL |
1117 | }; | 1117 | }; |
1118 | if (0 != fork_and_exec (sbin_ip, route_clean_args)) | 1118 | if (0 != fork_and_exec(sbin_ip, route_clean_args)) |
1119 | r += 1; | 1119 | r += 1; |
1120 | } | 1120 | } |
1121 | cleanup_forward_3: | 1121 | cleanup_forward_3: |
1122 | if (0 == nortsetup) | 1122 | if (0 == nortsetup) |
1123 | { | 1123 | { |
1124 | char *const forward_clean_args[] = | 1124 | char *const forward_clean_args[] = |
1125 | { | 1125 | { |
1126 | "ip", "-6", "rule", "del", "fwmark", DNS_MARK, "table", DNS_TABLE, NULL | 1126 | "ip", "-6", "rule", "del", "fwmark", DNS_MARK, "table", DNS_TABLE, NULL |
1127 | }; | 1127 | }; |
1128 | if (0 != fork_and_exec (sbin_ip, forward_clean_args)) | 1128 | if (0 != fork_and_exec(sbin_ip, forward_clean_args)) |
1129 | r += 2; | 1129 | r += 2; |
1130 | } | 1130 | } |
1131 | cleanup_forward_3b: | 1131 | cleanup_forward_3b: |
1132 | if (0 == nortsetup) | 1132 | if (0 == nortsetup) |
1133 | { | 1133 | { |
1134 | char *const forward_clean_args[] = | 1134 | char *const forward_clean_args[] = |
1135 | { | 1135 | { |
1136 | "ip", "rule", "del", "fwmark", DNS_MARK, "table", DNS_TABLE, NULL | 1136 | "ip", "rule", "del", "fwmark", DNS_MARK, "table", DNS_TABLE, NULL |
1137 | }; | 1137 | }; |
1138 | if (0 != fork_and_exec (sbin_ip, forward_clean_args)) | 1138 | if (0 != fork_and_exec(sbin_ip, forward_clean_args)) |
1139 | r += 2; | 1139 | r += 2; |
1140 | } | 1140 | } |
1141 | cleanup_mark_2: | 1141 | cleanup_mark_2: |
1142 | if (0 == nortsetup) | 1142 | if (0 == nortsetup) |
1143 | { | 1143 | { |
1144 | char *const mark_clean_args[] = | 1144 | char *const mark_clean_args[] = |
1145 | { | 1145 | { |
1146 | "ip6tables", "-t", "mangle", "-D", "OUTPUT", "-p", "udp", | 1146 | "ip6tables", "-t", "mangle", "-D", "OUTPUT", "-p", "udp", |
1147 | "--dport", DNS_PORT, | 1147 | "--dport", DNS_PORT, |
1148 | "!", "-s", "fe80::/10", /* this line excludes link-local traffic */ | 1148 | "!", "-s", "fe80::/10", /* this line excludes link-local traffic */ |
1149 | "-j", "MARK", "--set-mark", DNS_MARK, NULL | 1149 | "-j", "MARK", "--set-mark", DNS_MARK, NULL |
1150 | }; | 1150 | }; |
1151 | if (0 != fork_and_exec (sbin_ip6tables, mark_clean_args)) | 1151 | if (0 != fork_and_exec(sbin_ip6tables, mark_clean_args)) |
1152 | r += 4; | 1152 | r += 4; |
1153 | } | 1153 | } |
1154 | cleanup_mark_2b: | 1154 | cleanup_mark_2b: |
1155 | if (0 == nortsetup) | 1155 | if (0 == nortsetup) |
1156 | { | 1156 | { |
1157 | char *const mark_clean_args[] = | 1157 | char *const mark_clean_args[] = |
1158 | { | 1158 | { |
1159 | "iptables", "-t", "mangle", "-D", "OUTPUT", "-p", "udp", | 1159 | "iptables", "-t", "mangle", "-D", "OUTPUT", "-p", "udp", |
1160 | "--dport", DNS_PORT, "-j", "MARK", "--set-mark", DNS_MARK, NULL | 1160 | "--dport", DNS_PORT, "-j", "MARK", "--set-mark", DNS_MARK, NULL |
1161 | }; | 1161 | }; |
1162 | if (0 != fork_and_exec (sbin_iptables, mark_clean_args)) | 1162 | if (0 != fork_and_exec(sbin_iptables, mark_clean_args)) |
1163 | r += 4; | 1163 | r += 4; |
1164 | } | 1164 | } |
1165 | cleanup_mangle_1: | 1165 | cleanup_mangle_1: |
1166 | if (0 == nortsetup) | 1166 | if (0 == nortsetup) |
1167 | { | 1167 | { |
1168 | char *const mangle_clean_args[] = | 1168 | char *const mangle_clean_args[] = |
1169 | { | 1169 | { |
1170 | "ip6tables", "-m", "owner", "-t", "mangle", "-D", "OUTPUT", "-p", "udp", | 1170 | "ip6tables", "-m", "owner", "-t", "mangle", "-D", "OUTPUT", "-p", "udp", |
1171 | "--gid-owner", mygid, "--dport", DNS_PORT, "-j", "ACCEPT", | 1171 | "--gid-owner", mygid, "--dport", DNS_PORT, "-j", "ACCEPT", |
1172 | NULL | 1172 | NULL |
1173 | }; | 1173 | }; |
1174 | if (0 != fork_and_exec (sbin_ip6tables, mangle_clean_args)) | 1174 | if (0 != fork_and_exec(sbin_ip6tables, mangle_clean_args)) |
1175 | r += 8; | 1175 | r += 8; |
1176 | } | 1176 | } |
1177 | cleanup_mangle_1b: | 1177 | cleanup_mangle_1b: |
1178 | if (0 == nortsetup) | 1178 | if (0 == nortsetup) |
1179 | { | 1179 | { |
1180 | char *const mangle_clean_args[] = | 1180 | char *const mangle_clean_args[] = |
1181 | { | 1181 | { |
1182 | "iptables", "-m", "owner", "-t", "mangle", "-D", "OUTPUT", "-p", "udp", | 1182 | "iptables", "-m", "owner", "-t", "mangle", "-D", "OUTPUT", "-p", "udp", |
1183 | "--gid-owner", mygid, "--dport", DNS_PORT, "-j", "ACCEPT", | 1183 | "--gid-owner", mygid, "--dport", DNS_PORT, "-j", "ACCEPT", |
1184 | NULL | 1184 | NULL |
1185 | }; | 1185 | }; |
1186 | if (0 != fork_and_exec (sbin_iptables, mangle_clean_args)) | 1186 | if (0 != fork_and_exec(sbin_iptables, mangle_clean_args)) |
1187 | r += 8; | 1187 | r += 8; |
1188 | } | 1188 | } |
1189 | 1189 | ||
1190 | cleanup_rest: | 1190 | cleanup_rest: |
1191 | /* close virtual interface */ | 1191 | /* close virtual interface */ |
1192 | (void) close (fd_tun); | 1192 | (void)close(fd_tun); |
1193 | /* remove signal handler so we can close the pipes */ | 1193 | /* remove signal handler so we can close the pipes */ |
1194 | (void) signal (SIGTERM, SIG_IGN); | 1194 | (void)signal(SIGTERM, SIG_IGN); |
1195 | #if (SIGTERM != GNUNET_TERM_SIG) | 1195 | #if (SIGTERM != GNUNET_TERM_SIG) |
1196 | (void) signal (GNUNET_TERM_SIG, SIG_IGN); | 1196 | (void)signal(GNUNET_TERM_SIG, SIG_IGN); |
1197 | #endif | 1197 | #endif |
1198 | (void) signal (SIGINT, SIG_IGN); | 1198 | (void)signal(SIGINT, SIG_IGN); |
1199 | (void) signal (SIGHUP, SIG_IGN); | 1199 | (void)signal(SIGHUP, SIG_IGN); |
1200 | (void) close (cpipe[0]); | 1200 | (void)close(cpipe[0]); |
1201 | (void) close (cpipe[1]); | 1201 | (void)close(cpipe[1]); |
1202 | return r; | 1202 | return r; |
1203 | } | 1203 | } |
1204 | 1204 | ||
diff --git a/src/dns/gnunet-service-dns.c b/src/dns/gnunet-service-dns.c index 9c4f1f490..9a2293b2d 100644 --- a/src/dns/gnunet-service-dns.c +++ b/src/dns/gnunet-service-dns.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file dns/gnunet-service-dns.c | 22 | * @file dns/gnunet-service-dns.c |
@@ -59,14 +59,13 @@ | |||
59 | * Generic logging shorthand | 59 | * Generic logging shorthand |
60 | */ | 60 | */ |
61 | #define LOG(kind, ...) \ | 61 | #define LOG(kind, ...) \ |
62 | GNUNET_log_from (kind, "dns", __VA_ARGS__); | 62 | GNUNET_log_from(kind, "dns", __VA_ARGS__); |
63 | 63 | ||
64 | 64 | ||
65 | /** | 65 | /** |
66 | * Phases each request goes through. | 66 | * Phases each request goes through. |
67 | */ | 67 | */ |
68 | enum RequestPhase | 68 | enum RequestPhase { |
69 | { | ||
70 | /** | 69 | /** |
71 | * Request has just been received. | 70 | * Request has just been received. |
72 | */ | 71 | */ |
@@ -112,16 +111,15 @@ enum RequestPhase | |||
112 | /** | 111 | /** |
113 | * Entry we keep for each client. | 112 | * Entry we keep for each client. |
114 | */ | 113 | */ |
115 | struct ClientRecord | 114 | struct ClientRecord { |
116 | { | ||
117 | /** | 115 | /** |
118 | * Kept in doubly-linked list. | 116 | * Kept in doubly-linked list. |
119 | */ | 117 | */ |
120 | struct ClientRecord *next; | 118 | struct ClientRecord *next; |
121 | 119 | ||
122 | /** | 120 | /** |
123 | * Kept in doubly-linked list. | 121 | * Kept in doubly-linked list. |
124 | */ | 122 | */ |
125 | struct ClientRecord *prev; | 123 | struct ClientRecord *prev; |
126 | 124 | ||
127 | /** | 125 | /** |
@@ -138,16 +136,13 @@ struct ClientRecord | |||
138 | * Flags for the client. | 136 | * Flags for the client. |
139 | */ | 137 | */ |
140 | enum GNUNET_DNS_Flags flags; | 138 | enum GNUNET_DNS_Flags flags; |
141 | |||
142 | }; | 139 | }; |
143 | 140 | ||
144 | 141 | ||
145 | /** | 142 | /** |
146 | * Entry we keep for each active request. | 143 | * Entry we keep for each active request. |
147 | */ | 144 | */ |
148 | struct RequestRecord | 145 | struct RequestRecord { |
149 | { | ||
150 | |||
151 | /** | 146 | /** |
152 | * List of clients that still need to see this request (each entry | 147 | * List of clients that still need to see this request (each entry |
153 | * is set to NULL when the client is done). | 148 | * is set to NULL when the client is done). |
@@ -197,7 +192,6 @@ struct RequestRecord | |||
197 | * In which phase this this request? | 192 | * In which phase this this request? |
198 | */ | 193 | */ |
199 | enum RequestPhase phase; | 194 | enum RequestPhase phase; |
200 | |||
201 | }; | 195 | }; |
202 | 196 | ||
203 | 197 | ||
@@ -258,14 +252,14 @@ static struct GNUNET_DNSSTUB_Context *dnsstub; | |||
258 | * @param rr request to clean up | 252 | * @param rr request to clean up |
259 | */ | 253 | */ |
260 | static void | 254 | static void |
261 | cleanup_rr (struct RequestRecord *rr) | 255 | cleanup_rr(struct RequestRecord *rr) |
262 | { | 256 | { |
263 | GNUNET_free_non_null (rr->payload); | 257 | GNUNET_free_non_null(rr->payload); |
264 | rr->payload = NULL; | 258 | rr->payload = NULL; |
265 | rr->payload_length = 0; | 259 | rr->payload_length = 0; |
266 | GNUNET_array_grow (rr->client_wait_list, | 260 | GNUNET_array_grow(rr->client_wait_list, |
267 | rr->client_wait_list_length, | 261 | rr->client_wait_list_length, |
268 | 0); | 262 | 0); |
269 | } | 263 | } |
270 | 264 | ||
271 | 265 | ||
@@ -275,28 +269,28 @@ cleanup_rr (struct RequestRecord *rr) | |||
275 | * @param cls unused | 269 | * @param cls unused |
276 | */ | 270 | */ |
277 | static void | 271 | static void |
278 | cleanup_task (void *cls GNUNET_UNUSED) | 272 | cleanup_task(void *cls GNUNET_UNUSED) |
279 | { | 273 | { |
280 | if (NULL != hijacker) | 274 | if (NULL != hijacker) |
281 | { | 275 | { |
282 | GNUNET_HELPER_stop (hijacker, GNUNET_NO); | 276 | GNUNET_HELPER_stop(hijacker, GNUNET_NO); |
283 | hijacker = NULL; | 277 | hijacker = NULL; |
284 | } | 278 | } |
285 | for (unsigned int i=0;i<8;i++) | 279 | for (unsigned int i = 0; i < 8; i++) |
286 | GNUNET_free_non_null (helper_argv[i]); | 280 | GNUNET_free_non_null(helper_argv[i]); |
287 | for (unsigned int i=0;i<=UINT16_MAX;i++) | 281 | for (unsigned int i = 0; i <= UINT16_MAX; i++) |
288 | cleanup_rr (&requests[i]); | 282 | cleanup_rr(&requests[i]); |
289 | if (NULL != stats) | 283 | if (NULL != stats) |
290 | { | 284 | { |
291 | GNUNET_STATISTICS_destroy (stats, | 285 | GNUNET_STATISTICS_destroy(stats, |
292 | GNUNET_NO); | 286 | GNUNET_NO); |
293 | stats = NULL; | 287 | stats = NULL; |
294 | } | 288 | } |
295 | if (NULL != dnsstub) | 289 | if (NULL != dnsstub) |
296 | { | 290 | { |
297 | GNUNET_DNSSTUB_stop (dnsstub); | 291 | GNUNET_DNSSTUB_stop(dnsstub); |
298 | dnsstub = NULL; | 292 | dnsstub = NULL; |
299 | } | 293 | } |
300 | } | 294 | } |
301 | 295 | ||
302 | 296 | ||
@@ -306,54 +300,56 @@ cleanup_task (void *cls GNUNET_UNUSED) | |||
306 | * @param rr request send to the network or just clean up. | 300 | * @param rr request send to the network or just clean up. |
307 | */ | 301 | */ |
308 | static void | 302 | static void |
309 | request_done (struct RequestRecord *rr) | 303 | request_done(struct RequestRecord *rr) |
310 | { | 304 | { |
311 | struct GNUNET_MessageHeader *hdr; | 305 | struct GNUNET_MessageHeader *hdr; |
312 | size_t reply_len; | 306 | size_t reply_len; |
313 | uint16_t source_port; | 307 | uint16_t source_port; |
314 | uint16_t destination_port; | 308 | uint16_t destination_port; |
315 | 309 | ||
316 | GNUNET_array_grow (rr->client_wait_list, | 310 | GNUNET_array_grow(rr->client_wait_list, |
317 | rr->client_wait_list_length, | 311 | rr->client_wait_list_length, |
318 | 0); | 312 | 0); |
319 | if (RP_RESPONSE_MONITOR != rr->phase) | 313 | if (RP_RESPONSE_MONITOR != rr->phase) |
320 | { | 314 | { |
321 | /* no response, drop */ | 315 | /* no response, drop */ |
322 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 316 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
323 | "Got no response for request %llu, dropping\n", | 317 | "Got no response for request %llu, dropping\n", |
324 | (unsigned long long) rr->request_id); | 318 | (unsigned long long)rr->request_id); |
325 | cleanup_rr (rr); | 319 | cleanup_rr(rr); |
326 | return; | 320 | return; |
327 | } | 321 | } |
328 | 322 | ||
329 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 323 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
330 | "Transmitting response for request %llu\n", | 324 | "Transmitting response for request %llu\n", |
331 | (unsigned long long) rr->request_id); | 325 | (unsigned long long)rr->request_id); |
332 | /* send response via hijacker */ | 326 | /* send response via hijacker */ |
333 | reply_len = sizeof (struct GNUNET_MessageHeader); | 327 | reply_len = sizeof(struct GNUNET_MessageHeader); |
334 | reply_len += sizeof (struct GNUNET_TUN_Layer2PacketHeader); | 328 | reply_len += sizeof(struct GNUNET_TUN_Layer2PacketHeader); |
335 | switch (rr->src_addr.ss_family) | 329 | switch (rr->src_addr.ss_family) |
336 | { | 330 | { |
337 | case AF_INET: | 331 | case AF_INET: |
338 | reply_len += sizeof (struct GNUNET_TUN_IPv4Header); | 332 | reply_len += sizeof(struct GNUNET_TUN_IPv4Header); |
339 | break; | 333 | break; |
340 | case AF_INET6: | 334 | |
341 | reply_len += sizeof (struct GNUNET_TUN_IPv6Header); | 335 | case AF_INET6: |
342 | break; | 336 | reply_len += sizeof(struct GNUNET_TUN_IPv6Header); |
343 | default: | 337 | break; |
344 | GNUNET_break (0); | 338 | |
345 | cleanup_rr (rr); | 339 | default: |
346 | return; | 340 | GNUNET_break(0); |
347 | } | 341 | cleanup_rr(rr); |
348 | reply_len += sizeof (struct GNUNET_TUN_UdpHeader); | 342 | return; |
343 | } | ||
344 | reply_len += sizeof(struct GNUNET_TUN_UdpHeader); | ||
349 | reply_len += rr->payload_length; | 345 | reply_len += rr->payload_length; |
350 | if (reply_len >= GNUNET_MAX_MESSAGE_SIZE) | 346 | if (reply_len >= GNUNET_MAX_MESSAGE_SIZE) |
351 | { | 347 | { |
352 | /* response too big, drop */ | 348 | /* response too big, drop */ |
353 | GNUNET_break (0); /* how can this be? */ | 349 | GNUNET_break(0); /* how can this be? */ |
354 | cleanup_rr(rr); | 350 | cleanup_rr(rr); |
355 | return; | 351 | return; |
356 | } | 352 | } |
357 | { | 353 | { |
358 | char buf[reply_len] GNUNET_ALIGN; | 354 | char buf[reply_len] GNUNET_ALIGN; |
359 | size_t off; | 355 | size_t off; |
@@ -361,68 +357,70 @@ request_done (struct RequestRecord *rr) | |||
361 | struct GNUNET_TUN_IPv6Header ip6; | 357 | struct GNUNET_TUN_IPv6Header ip6; |
362 | 358 | ||
363 | /* first, GNUnet message header */ | 359 | /* first, GNUnet message header */ |
364 | hdr = (struct GNUNET_MessageHeader*) buf; | 360 | hdr = (struct GNUNET_MessageHeader*)buf; |
365 | hdr->type = htons (GNUNET_MESSAGE_TYPE_DNS_HELPER); | 361 | hdr->type = htons(GNUNET_MESSAGE_TYPE_DNS_HELPER); |
366 | hdr->size = htons ((uint16_t) reply_len); | 362 | hdr->size = htons((uint16_t)reply_len); |
367 | off = sizeof (struct GNUNET_MessageHeader); | 363 | off = sizeof(struct GNUNET_MessageHeader); |
368 | 364 | ||
369 | /* first, TUN header */ | 365 | /* first, TUN header */ |
370 | { | 366 | { |
371 | struct GNUNET_TUN_Layer2PacketHeader tun; | 367 | struct GNUNET_TUN_Layer2PacketHeader tun; |
372 | 368 | ||
373 | tun.flags = htons (0); | 369 | tun.flags = htons(0); |
374 | if (rr->src_addr.ss_family == AF_INET) | 370 | if (rr->src_addr.ss_family == AF_INET) |
375 | tun.proto = htons (ETH_P_IPV4); | 371 | tun.proto = htons(ETH_P_IPV4); |
376 | else | 372 | else |
377 | tun.proto = htons (ETH_P_IPV6); | 373 | tun.proto = htons(ETH_P_IPV6); |
378 | GNUNET_memcpy (&buf[off], | 374 | GNUNET_memcpy(&buf[off], |
379 | &tun, | 375 | &tun, |
380 | sizeof (struct GNUNET_TUN_Layer2PacketHeader)); | 376 | sizeof(struct GNUNET_TUN_Layer2PacketHeader)); |
381 | off += sizeof (struct GNUNET_TUN_Layer2PacketHeader); | 377 | off += sizeof(struct GNUNET_TUN_Layer2PacketHeader); |
382 | } | 378 | } |
383 | 379 | ||
384 | /* now IP header */ | 380 | /* now IP header */ |
385 | switch (rr->src_addr.ss_family) | 381 | switch (rr->src_addr.ss_family) |
386 | { | ||
387 | case AF_INET: | ||
388 | { | 382 | { |
389 | struct sockaddr_in *src = (struct sockaddr_in *) &rr->src_addr; | 383 | case AF_INET: |
390 | struct sockaddr_in *dst = (struct sockaddr_in *) &rr->dst_addr; | 384 | { |
391 | 385 | struct sockaddr_in *src = (struct sockaddr_in *)&rr->src_addr; | |
392 | source_port = dst->sin_port; | 386 | struct sockaddr_in *dst = (struct sockaddr_in *)&rr->dst_addr; |
393 | destination_port = src->sin_port; | 387 | |
394 | GNUNET_TUN_initialize_ipv4_header (&ip4, | 388 | source_port = dst->sin_port; |
395 | IPPROTO_UDP, | 389 | destination_port = src->sin_port; |
396 | reply_len - off - sizeof (struct GNUNET_TUN_IPv4Header), | 390 | GNUNET_TUN_initialize_ipv4_header(&ip4, |
397 | &dst->sin_addr, | 391 | IPPROTO_UDP, |
398 | &src->sin_addr); | 392 | reply_len - off - sizeof(struct GNUNET_TUN_IPv4Header), |
399 | GNUNET_memcpy (&buf[off], | 393 | &dst->sin_addr, |
400 | &ip4, | 394 | &src->sin_addr); |
401 | sizeof (ip4)); | 395 | GNUNET_memcpy(&buf[off], |
402 | off += sizeof (ip4); | 396 | &ip4, |
397 | sizeof(ip4)); | ||
398 | off += sizeof(ip4); | ||
403 | } | 399 | } |
404 | break; | 400 | break; |
405 | case AF_INET6: | 401 | |
402 | case AF_INET6: | ||
406 | { | 403 | { |
407 | struct sockaddr_in6 *src = (struct sockaddr_in6 *) &rr->src_addr; | 404 | struct sockaddr_in6 *src = (struct sockaddr_in6 *)&rr->src_addr; |
408 | struct sockaddr_in6 *dst = (struct sockaddr_in6 *) &rr->dst_addr; | 405 | struct sockaddr_in6 *dst = (struct sockaddr_in6 *)&rr->dst_addr; |
409 | 406 | ||
410 | source_port = dst->sin6_port; | 407 | source_port = dst->sin6_port; |
411 | destination_port = src->sin6_port; | 408 | destination_port = src->sin6_port; |
412 | GNUNET_TUN_initialize_ipv6_header (&ip6, | 409 | GNUNET_TUN_initialize_ipv6_header(&ip6, |
413 | IPPROTO_UDP, | 410 | IPPROTO_UDP, |
414 | reply_len - off - sizeof (struct GNUNET_TUN_IPv6Header), | 411 | reply_len - off - sizeof(struct GNUNET_TUN_IPv6Header), |
415 | &dst->sin6_addr, | 412 | &dst->sin6_addr, |
416 | &src->sin6_addr); | 413 | &src->sin6_addr); |
417 | GNUNET_memcpy (&buf[off], | 414 | GNUNET_memcpy(&buf[off], |
418 | &ip6, | 415 | &ip6, |
419 | sizeof (ip6)); | 416 | sizeof(ip6)); |
420 | off += sizeof (ip6); | 417 | off += sizeof(ip6); |
421 | } | 418 | } |
422 | break; | 419 | break; |
423 | default: | 420 | |
424 | GNUNET_assert (0); | 421 | default: |
425 | } | 422 | GNUNET_assert(0); |
423 | } | ||
426 | 424 | ||
427 | /* now UDP header */ | 425 | /* now UDP header */ |
428 | { | 426 | { |
@@ -430,40 +428,40 @@ request_done (struct RequestRecord *rr) | |||
430 | 428 | ||
431 | udp.source_port = source_port; | 429 | udp.source_port = source_port; |
432 | udp.destination_port = destination_port; | 430 | udp.destination_port = destination_port; |
433 | udp.len = htons (reply_len - off); | 431 | udp.len = htons(reply_len - off); |
434 | if (AF_INET == rr->src_addr.ss_family) | 432 | if (AF_INET == rr->src_addr.ss_family) |
435 | GNUNET_TUN_calculate_udp4_checksum (&ip4, | 433 | GNUNET_TUN_calculate_udp4_checksum(&ip4, |
436 | &udp, | 434 | &udp, |
437 | rr->payload, | 435 | rr->payload, |
438 | rr->payload_length); | 436 | rr->payload_length); |
439 | else | 437 | else |
440 | GNUNET_TUN_calculate_udp6_checksum (&ip6, | 438 | GNUNET_TUN_calculate_udp6_checksum(&ip6, |
441 | &udp, | 439 | &udp, |
442 | rr->payload, | 440 | rr->payload, |
443 | rr->payload_length); | 441 | rr->payload_length); |
444 | GNUNET_memcpy (&buf[off], | 442 | GNUNET_memcpy(&buf[off], |
445 | &udp, | 443 | &udp, |
446 | sizeof (udp)); | 444 | sizeof(udp)); |
447 | off += sizeof (udp); | 445 | off += sizeof(udp); |
448 | } | 446 | } |
449 | 447 | ||
450 | /* now DNS payload */ | 448 | /* now DNS payload */ |
451 | { | 449 | { |
452 | GNUNET_memcpy (&buf[off], rr->payload, rr->payload_length); | 450 | GNUNET_memcpy(&buf[off], rr->payload, rr->payload_length); |
453 | off += rr->payload_length; | 451 | off += rr->payload_length; |
454 | } | 452 | } |
455 | /* final checks & sending */ | 453 | /* final checks & sending */ |
456 | GNUNET_assert (off == reply_len); | 454 | GNUNET_assert(off == reply_len); |
457 | (void) GNUNET_HELPER_send (hijacker, | 455 | (void)GNUNET_HELPER_send(hijacker, |
458 | hdr, | 456 | hdr, |
459 | GNUNET_YES, | 457 | GNUNET_YES, |
460 | NULL, NULL); | 458 | NULL, NULL); |
461 | GNUNET_STATISTICS_update (stats, | 459 | GNUNET_STATISTICS_update(stats, |
462 | gettext_noop ("# DNS requests answered via TUN interface"), | 460 | gettext_noop("# DNS requests answered via TUN interface"), |
463 | 1, GNUNET_NO); | 461 | 1, GNUNET_NO); |
464 | } | 462 | } |
465 | /* clean up, we're done */ | 463 | /* clean up, we're done */ |
466 | cleanup_rr (rr); | 464 | cleanup_rr(rr); |
467 | } | 465 | } |
468 | 466 | ||
469 | 467 | ||
@@ -475,31 +473,31 @@ request_done (struct RequestRecord *rr) | |||
475 | * @param cr client to send the response to | 473 | * @param cr client to send the response to |
476 | */ | 474 | */ |
477 | static void | 475 | static void |
478 | send_request_to_client (struct RequestRecord *rr, | 476 | send_request_to_client(struct RequestRecord *rr, |
479 | struct ClientRecord *cr) | 477 | struct ClientRecord *cr) |
480 | { | 478 | { |
481 | struct GNUNET_MQ_Envelope *env; | 479 | struct GNUNET_MQ_Envelope *env; |
482 | struct GNUNET_DNS_Request *req; | 480 | struct GNUNET_DNS_Request *req; |
483 | 481 | ||
484 | if (sizeof (struct GNUNET_DNS_Request) + rr->payload_length >= GNUNET_MAX_MESSAGE_SIZE) | 482 | if (sizeof(struct GNUNET_DNS_Request) + rr->payload_length >= GNUNET_MAX_MESSAGE_SIZE) |
485 | { | 483 | { |
486 | GNUNET_break (0); | 484 | GNUNET_break(0); |
487 | cleanup_rr (rr); | 485 | cleanup_rr(rr); |
488 | return; | 486 | return; |
489 | } | 487 | } |
490 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 488 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
491 | "Sending information about request %llu to local client\n", | 489 | "Sending information about request %llu to local client\n", |
492 | (unsigned long long) rr->request_id); | 490 | (unsigned long long)rr->request_id); |
493 | env = GNUNET_MQ_msg_extra (req, | 491 | env = GNUNET_MQ_msg_extra(req, |
494 | rr->payload_length, | 492 | rr->payload_length, |
495 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_REQUEST); | 493 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_REQUEST); |
496 | req->reserved = htonl (0); | 494 | req->reserved = htonl(0); |
497 | req->request_id = rr->request_id; | 495 | req->request_id = rr->request_id; |
498 | GNUNET_memcpy (&req[1], | 496 | GNUNET_memcpy(&req[1], |
499 | rr->payload, | 497 | rr->payload, |
500 | rr->payload_length); | 498 | rr->payload_length); |
501 | GNUNET_MQ_send (cr->mq, | 499 | GNUNET_MQ_send(cr->mq, |
502 | env); | 500 | env); |
503 | } | 501 | } |
504 | 502 | ||
505 | 503 | ||
@@ -512,9 +510,9 @@ send_request_to_client (struct RequestRecord *rr, | |||
512 | * @param r number of bytes in dns | 510 | * @param r number of bytes in dns |
513 | */ | 511 | */ |
514 | static void | 512 | static void |
515 | process_dns_result (void *cls, | 513 | process_dns_result(void *cls, |
516 | const struct GNUNET_TUN_DnsHeader *dns, | 514 | const struct GNUNET_TUN_DnsHeader *dns, |
517 | size_t r); | 515 | size_t r); |
518 | 516 | ||
519 | 517 | ||
520 | /** | 518 | /** |
@@ -524,129 +522,138 @@ process_dns_result (void *cls, | |||
524 | * @param rr request to process further | 522 | * @param rr request to process further |
525 | */ | 523 | */ |
526 | static void | 524 | static void |
527 | next_phase (struct RequestRecord *rr) | 525 | next_phase(struct RequestRecord *rr) |
528 | { | 526 | { |
529 | struct ClientRecord *cr; | 527 | struct ClientRecord *cr; |
530 | int nz; | 528 | int nz; |
531 | 529 | ||
532 | if (rr->phase == RP_DROP) | 530 | if (rr->phase == RP_DROP) |
533 | { | 531 | { |
534 | cleanup_rr (rr); | 532 | cleanup_rr(rr); |
535 | return; | 533 | return; |
536 | } | 534 | } |
537 | nz = -1; | 535 | nz = -1; |
538 | for (unsigned int j=0;j<rr->client_wait_list_length;j++) | 536 | for (unsigned int j = 0; j < rr->client_wait_list_length; j++) |
539 | { | ||
540 | if (NULL != rr->client_wait_list[j]) | ||
541 | { | 537 | { |
542 | nz = (int) j; | 538 | if (NULL != rr->client_wait_list[j]) |
543 | break; | 539 | { |
540 | nz = (int)j; | ||
541 | break; | ||
542 | } | ||
544 | } | 543 | } |
545 | } | ||
546 | if (-1 != nz) | 544 | if (-1 != nz) |
547 | { | ||
548 | send_request_to_client (rr, | ||
549 | rr->client_wait_list[nz]); | ||
550 | return; | ||
551 | } | ||
552 | /* done with current phase, advance! */ | ||
553 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
554 | "Request %llu now in phase %d\n", | ||
555 | rr->request_id, | ||
556 | rr->phase); | ||
557 | switch (rr->phase) | ||
558 | { | ||
559 | case RP_INIT: | ||
560 | rr->phase = RP_REQUEST_MONITOR; | ||
561 | for (cr = clients_head; NULL != cr; cr = cr->next) | ||
562 | { | 545 | { |
563 | if (0 != (cr->flags & GNUNET_DNS_FLAG_REQUEST_MONITOR)) | 546 | send_request_to_client(rr, |
564 | GNUNET_array_append (rr->client_wait_list, | 547 | rr->client_wait_list[nz]); |
565 | rr->client_wait_list_length, | 548 | return; |
566 | cr); | ||
567 | } | 549 | } |
568 | next_phase (rr); | 550 | /* done with current phase, advance! */ |
569 | return; | 551 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
570 | case RP_REQUEST_MONITOR: | 552 | "Request %llu now in phase %d\n", |
571 | rr->phase = RP_QUERY; | 553 | rr->request_id, |
572 | for (cr = clients_head; NULL != cr; cr = cr->next) | 554 | rr->phase); |
555 | switch (rr->phase) | ||
573 | { | 556 | { |
574 | if (0 != (cr->flags & GNUNET_DNS_FLAG_PRE_RESOLUTION)) | 557 | case RP_INIT: |
575 | GNUNET_array_append (rr->client_wait_list, | 558 | rr->phase = RP_REQUEST_MONITOR; |
576 | rr->client_wait_list_length, | 559 | for (cr = clients_head; NULL != cr; cr = cr->next) |
577 | cr); | 560 | { |
578 | } | 561 | if (0 != (cr->flags & GNUNET_DNS_FLAG_REQUEST_MONITOR)) |
579 | next_phase (rr); | 562 | GNUNET_array_append(rr->client_wait_list, |
580 | return; | 563 | rr->client_wait_list_length, |
581 | case RP_QUERY: | 564 | cr); |
565 | } | ||
566 | next_phase(rr); | ||
567 | return; | ||
568 | |||
569 | case RP_REQUEST_MONITOR: | ||
570 | rr->phase = RP_QUERY; | ||
571 | for (cr = clients_head; NULL != cr; cr = cr->next) | ||
572 | { | ||
573 | if (0 != (cr->flags & GNUNET_DNS_FLAG_PRE_RESOLUTION)) | ||
574 | GNUNET_array_append(rr->client_wait_list, | ||
575 | rr->client_wait_list_length, | ||
576 | cr); | ||
577 | } | ||
578 | next_phase(rr); | ||
579 | return; | ||
580 | |||
581 | case RP_QUERY: | ||
582 | #if 0 | 582 | #if 0 |
583 | /* TODO: optionally, use this to forward DNS requests to the | 583 | /* TODO: optionally, use this to forward DNS requests to the |
584 | *original* DNS server instead of the one we have configured... | 584 | * original* DNS server instead of the one we have configured... |
585 | (but then we need to create a fresh dnsstub for each request | 585 | (but then we need to create a fresh dnsstub for each request |
586 | *and* manage the timeout) */ | 586 | * and* manage the timeout) */ |
587 | switch (rr->dst_addr.ss_family) | 587 | switch (rr->dst_addr.ss_family) |
588 | { | 588 | { |
589 | case AF_INET: | 589 | case AF_INET: |
590 | salen = sizeof (struct sockaddr_in); | 590 | salen = sizeof(struct sockaddr_in); |
591 | sa = (const struct sockaddr *) &rr->dst_addr; | 591 | sa = (const struct sockaddr *)&rr->dst_addr; |
592 | break; | ||
593 | |||
594 | case AF_INET6: | ||
595 | salen = sizeof(struct sockaddr_in6); | ||
596 | sa = (const struct sockaddr *)&rr->dst_addr; | ||
597 | break; | ||
598 | |||
599 | default: | ||
600 | GNUNET_assert(0); | ||
601 | } | ||
602 | #endif | ||
603 | rr->phase = RP_INTERNET_DNS; | ||
604 | rr->rs = GNUNET_DNSSTUB_resolve(dnsstub, | ||
605 | rr->payload, | ||
606 | rr->payload_length, | ||
607 | &process_dns_result, | ||
608 | NULL); | ||
609 | if (NULL == rr->rs) | ||
610 | { | ||
611 | GNUNET_STATISTICS_update(stats, | ||
612 | gettext_noop("# DNS exit failed (failed to open socket)"), | ||
613 | 1, | ||
614 | GNUNET_NO); | ||
615 | cleanup_rr(rr); | ||
616 | return; | ||
617 | } | ||
618 | return; | ||
619 | |||
620 | case RP_INTERNET_DNS: | ||
621 | rr->phase = RP_MODIFY; | ||
622 | for (cr = clients_head; NULL != cr; cr = cr->next) | ||
623 | { | ||
624 | if (0 != (cr->flags & GNUNET_DNS_FLAG_POST_RESOLUTION)) | ||
625 | GNUNET_array_append(rr->client_wait_list, | ||
626 | rr->client_wait_list_length, | ||
627 | cr); | ||
628 | } | ||
629 | next_phase(rr); | ||
630 | return; | ||
631 | |||
632 | case RP_MODIFY: | ||
633 | rr->phase = RP_RESPONSE_MONITOR; | ||
634 | for (cr = clients_head; NULL != cr; cr = cr->next) | ||
635 | { | ||
636 | if (0 != (cr->flags & GNUNET_DNS_FLAG_RESPONSE_MONITOR)) | ||
637 | GNUNET_array_append(rr->client_wait_list, | ||
638 | rr->client_wait_list_length, | ||
639 | cr); | ||
640 | } | ||
641 | next_phase(rr); | ||
642 | return; | ||
643 | |||
644 | case RP_RESPONSE_MONITOR: | ||
645 | request_done(rr); | ||
592 | break; | 646 | break; |
593 | case AF_INET6: | 647 | |
594 | salen = sizeof (struct sockaddr_in6); | 648 | case RP_DROP: |
595 | sa = (const struct sockaddr *) &rr->dst_addr; | 649 | cleanup_rr(rr); |
596 | break; | 650 | break; |
651 | |||
597 | default: | 652 | default: |
598 | GNUNET_assert (0); | 653 | GNUNET_break(0); |
599 | } | 654 | cleanup_rr(rr); |
600 | #endif | 655 | break; |
601 | rr->phase = RP_INTERNET_DNS; | ||
602 | rr->rs = GNUNET_DNSSTUB_resolve (dnsstub, | ||
603 | rr->payload, | ||
604 | rr->payload_length, | ||
605 | &process_dns_result, | ||
606 | NULL); | ||
607 | if (NULL == rr->rs) | ||
608 | { | ||
609 | GNUNET_STATISTICS_update (stats, | ||
610 | gettext_noop ("# DNS exit failed (failed to open socket)"), | ||
611 | 1, | ||
612 | GNUNET_NO); | ||
613 | cleanup_rr (rr); | ||
614 | return; | ||
615 | } | ||
616 | return; | ||
617 | case RP_INTERNET_DNS: | ||
618 | rr->phase = RP_MODIFY; | ||
619 | for (cr = clients_head; NULL != cr; cr = cr->next) | ||
620 | { | ||
621 | if (0 != (cr->flags & GNUNET_DNS_FLAG_POST_RESOLUTION)) | ||
622 | GNUNET_array_append (rr->client_wait_list, | ||
623 | rr->client_wait_list_length, | ||
624 | cr); | ||
625 | } | ||
626 | next_phase (rr); | ||
627 | return; | ||
628 | case RP_MODIFY: | ||
629 | rr->phase = RP_RESPONSE_MONITOR; | ||
630 | for (cr = clients_head; NULL != cr; cr = cr->next) | ||
631 | { | ||
632 | if (0 != (cr->flags & GNUNET_DNS_FLAG_RESPONSE_MONITOR)) | ||
633 | GNUNET_array_append (rr->client_wait_list, | ||
634 | rr->client_wait_list_length, | ||
635 | cr); | ||
636 | } | 656 | } |
637 | next_phase (rr); | ||
638 | return; | ||
639 | case RP_RESPONSE_MONITOR: | ||
640 | request_done (rr); | ||
641 | break; | ||
642 | case RP_DROP: | ||
643 | cleanup_rr (rr); | ||
644 | break; | ||
645 | default: | ||
646 | GNUNET_break (0); | ||
647 | cleanup_rr (rr); | ||
648 | break; | ||
649 | } | ||
650 | } | 657 | } |
651 | 658 | ||
652 | 659 | ||
@@ -659,18 +666,18 @@ next_phase (struct RequestRecord *rr) | |||
659 | * @return our `struct ClientRecord` | 666 | * @return our `struct ClientRecord` |
660 | */ | 667 | */ |
661 | static void * | 668 | static void * |
662 | client_connect_cb (void *cls, | 669 | client_connect_cb(void *cls, |
663 | struct GNUNET_SERVICE_Client *client, | 670 | struct GNUNET_SERVICE_Client *client, |
664 | struct GNUNET_MQ_Handle *mq) | 671 | struct GNUNET_MQ_Handle *mq) |
665 | { | 672 | { |
666 | struct ClientRecord *cr = cls; | 673 | struct ClientRecord *cr = cls; |
667 | 674 | ||
668 | cr = GNUNET_new (struct ClientRecord); | 675 | cr = GNUNET_new(struct ClientRecord); |
669 | cr->client = client; | 676 | cr->client = client; |
670 | cr->mq = mq; | 677 | cr->mq = mq; |
671 | GNUNET_CONTAINER_DLL_insert (clients_head, | 678 | GNUNET_CONTAINER_DLL_insert(clients_head, |
672 | clients_tail, | 679 | clients_tail, |
673 | cr); | 680 | cr); |
674 | return cr; | 681 | return cr; |
675 | } | 682 | } |
676 | 683 | ||
@@ -683,31 +690,31 @@ client_connect_cb (void *cls, | |||
683 | * @param app_ctx our `struct ClientRecord` | 690 | * @param app_ctx our `struct ClientRecord` |
684 | */ | 691 | */ |
685 | static void | 692 | static void |
686 | client_disconnect_cb (void *cls, | 693 | client_disconnect_cb(void *cls, |
687 | struct GNUNET_SERVICE_Client *client, | 694 | struct GNUNET_SERVICE_Client *client, |
688 | void *app_ctx) | 695 | void *app_ctx) |
689 | { | 696 | { |
690 | struct ClientRecord *cr = app_ctx; | 697 | struct ClientRecord *cr = app_ctx; |
691 | struct RequestRecord *rr; | 698 | struct RequestRecord *rr; |
692 | 699 | ||
693 | GNUNET_CONTAINER_DLL_remove (clients_head, | 700 | GNUNET_CONTAINER_DLL_remove(clients_head, |
694 | clients_tail, | 701 | clients_tail, |
695 | cr); | 702 | cr); |
696 | for (unsigned int i=0;i<UINT16_MAX;i++) | 703 | for (unsigned int i = 0; i < UINT16_MAX; i++) |
697 | { | ||
698 | rr = &requests[i]; | ||
699 | if (0 == rr->client_wait_list_length) | ||
700 | continue; /* not in use */ | ||
701 | for (unsigned int j=0;j<rr->client_wait_list_length;j++) | ||
702 | { | 704 | { |
703 | if (rr->client_wait_list[j] == cr) | 705 | rr = &requests[i]; |
704 | { | 706 | if (0 == rr->client_wait_list_length) |
705 | rr->client_wait_list[j] = NULL; | 707 | continue; /* not in use */ |
706 | next_phase (rr); | 708 | for (unsigned int j = 0; j < rr->client_wait_list_length; j++) |
707 | } | 709 | { |
710 | if (rr->client_wait_list[j] == cr) | ||
711 | { | ||
712 | rr->client_wait_list[j] = NULL; | ||
713 | next_phase(rr); | ||
714 | } | ||
715 | } | ||
708 | } | 716 | } |
709 | } | 717 | GNUNET_free(cr); |
710 | GNUNET_free (cr); | ||
711 | } | 718 | } |
712 | 719 | ||
713 | 720 | ||
@@ -720,39 +727,39 @@ client_disconnect_cb (void *cls, | |||
720 | * @param r number of bytes in dns | 727 | * @param r number of bytes in dns |
721 | */ | 728 | */ |
722 | static void | 729 | static void |
723 | process_dns_result (void *cls, | 730 | process_dns_result(void *cls, |
724 | const struct GNUNET_TUN_DnsHeader *dns, | 731 | const struct GNUNET_TUN_DnsHeader *dns, |
725 | size_t r) | 732 | size_t r) |
726 | { | 733 | { |
727 | struct RequestRecord *rr; | 734 | struct RequestRecord *rr; |
728 | 735 | ||
729 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 736 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
730 | "Processing DNS result from stub resolver\n"); | 737 | "Processing DNS result from stub resolver\n"); |
731 | GNUNET_assert (NULL == cls); | 738 | GNUNET_assert(NULL == cls); |
732 | if (NULL == dns) | 739 | if (NULL == dns) |
733 | return; /* ignore */ | 740 | return; /* ignore */ |
734 | 741 | ||
735 | rr = &requests[dns->id]; | 742 | rr = &requests[dns->id]; |
736 | if (rr->phase != RP_INTERNET_DNS) | 743 | if (rr->phase != RP_INTERNET_DNS) |
737 | { | 744 | { |
738 | /* unexpected / bogus reply */ | 745 | /* unexpected / bogus reply */ |
739 | GNUNET_STATISTICS_update (stats, | 746 | GNUNET_STATISTICS_update(stats, |
740 | gettext_noop ("# External DNS response discarded (no matching request)"), | 747 | gettext_noop("# External DNS response discarded (no matching request)"), |
741 | 1, GNUNET_NO); | 748 | 1, GNUNET_NO); |
742 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 749 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
743 | "Received DNS reply that does not match any pending request. Dropping.\n"); | 750 | "Received DNS reply that does not match any pending request. Dropping.\n"); |
744 | return; | 751 | return; |
745 | } | 752 | } |
746 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 753 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
747 | "Got a response from the stub resolver for DNS request %llu intercepted locally!\n", | 754 | "Got a response from the stub resolver for DNS request %llu intercepted locally!\n", |
748 | (unsigned long long) rr->request_id); | 755 | (unsigned long long)rr->request_id); |
749 | GNUNET_free_non_null (rr->payload); | 756 | GNUNET_free_non_null(rr->payload); |
750 | rr->payload = GNUNET_malloc (r); | 757 | rr->payload = GNUNET_malloc(r); |
751 | GNUNET_memcpy (rr->payload, | 758 | GNUNET_memcpy(rr->payload, |
752 | dns, | 759 | dns, |
753 | r); | 760 | r); |
754 | rr->payload_length = r; | 761 | rr->payload_length = r; |
755 | next_phase (rr); | 762 | next_phase(rr); |
756 | } | 763 | } |
757 | 764 | ||
758 | 765 | ||
@@ -763,13 +770,13 @@ process_dns_result (void *cls, | |||
763 | * @param reg the init message | 770 | * @param reg the init message |
764 | */ | 771 | */ |
765 | static void | 772 | static void |
766 | handle_client_init (void *cls, | 773 | handle_client_init(void *cls, |
767 | const struct GNUNET_DNS_Register *reg) | 774 | const struct GNUNET_DNS_Register *reg) |
768 | { | 775 | { |
769 | struct ClientRecord *cr = cls; | 776 | struct ClientRecord *cr = cls; |
770 | 777 | ||
771 | cr->flags = (enum GNUNET_DNS_Flags) ntohl (reg->flags); | 778 | cr->flags = (enum GNUNET_DNS_Flags)ntohl(reg->flags); |
772 | GNUNET_SERVICE_client_continue (cr->client); | 779 | GNUNET_SERVICE_client_continue(cr->client); |
773 | } | 780 | } |
774 | 781 | ||
775 | 782 | ||
@@ -781,8 +788,8 @@ handle_client_init (void *cls, | |||
781 | * @return #GNUNET_OK (always fine) | 788 | * @return #GNUNET_OK (always fine) |
782 | */ | 789 | */ |
783 | static int | 790 | static int |
784 | check_client_response (void *cls, | 791 | check_client_response(void *cls, |
785 | const struct GNUNET_DNS_Response *resp) | 792 | const struct GNUNET_DNS_Response *resp) |
786 | { | 793 | { |
787 | return GNUNET_OK; /* any payload is acceptable */ | 794 | return GNUNET_OK; /* any payload is acceptable */ |
788 | } | 795 | } |
@@ -795,87 +802,89 @@ check_client_response (void *cls, | |||
795 | * @param resp the response | 802 | * @param resp the response |
796 | */ | 803 | */ |
797 | static void | 804 | static void |
798 | handle_client_response (void *cls, | 805 | handle_client_response(void *cls, |
799 | const struct GNUNET_DNS_Response *resp) | 806 | const struct GNUNET_DNS_Response *resp) |
800 | { | 807 | { |
801 | struct ClientRecord *cr = cls; | 808 | struct ClientRecord *cr = cls; |
802 | struct RequestRecord *rr; | 809 | struct RequestRecord *rr; |
803 | uint16_t msize; | 810 | uint16_t msize; |
804 | uint16_t off; | 811 | uint16_t off; |
805 | 812 | ||
806 | msize = ntohs (resp->header.size); | 813 | msize = ntohs(resp->header.size); |
807 | off = (uint16_t) resp->request_id; | 814 | off = (uint16_t)resp->request_id; |
808 | rr = &requests[off]; | 815 | rr = &requests[off]; |
809 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 816 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
810 | "Received DNS response with ID %llu from local client!\n", | 817 | "Received DNS response with ID %llu from local client!\n", |
811 | (unsigned long long) resp->request_id); | 818 | (unsigned long long)resp->request_id); |
812 | if (rr->request_id != resp->request_id) | 819 | if (rr->request_id != resp->request_id) |
813 | { | ||
814 | GNUNET_STATISTICS_update (stats, | ||
815 | gettext_noop ("# Client response discarded (no matching request)"), | ||
816 | 1, | ||
817 | GNUNET_NO); | ||
818 | GNUNET_SERVICE_client_continue (cr->client); | ||
819 | return; | ||
820 | } | ||
821 | for (unsigned int i=0;i<rr->client_wait_list_length;i++) | ||
822 | { | ||
823 | if (NULL == rr->client_wait_list[i]) | ||
824 | continue; | ||
825 | if (rr->client_wait_list[i] != cr) | ||
826 | continue; | ||
827 | rr->client_wait_list[i] = NULL; | ||
828 | switch (ntohl (resp->drop_flag)) | ||
829 | { | 820 | { |
830 | case 0: /* drop */ | 821 | GNUNET_STATISTICS_update(stats, |
831 | rr->phase = RP_DROP; | 822 | gettext_noop("# Client response discarded (no matching request)"), |
832 | break; | 823 | 1, |
833 | case 1: /* no change */ | 824 | GNUNET_NO); |
834 | break; | 825 | GNUNET_SERVICE_client_continue(cr->client); |
835 | case 2: /* update */ | 826 | return; |
836 | msize -= sizeof (struct GNUNET_DNS_Response); | 827 | } |
837 | if ( (sizeof (struct GNUNET_TUN_DnsHeader) > msize) || | 828 | for (unsigned int i = 0; i < rr->client_wait_list_length; i++) |
838 | (RP_REQUEST_MONITOR == rr->phase) || | 829 | { |
839 | (RP_RESPONSE_MONITOR == rr->phase) ) | 830 | if (NULL == rr->client_wait_list[i]) |
840 | { | 831 | continue; |
841 | GNUNET_break (0); | 832 | if (rr->client_wait_list[i] != cr) |
842 | GNUNET_SERVICE_client_drop (cr->client); | 833 | continue; |
843 | next_phase (rr); | 834 | rr->client_wait_list[i] = NULL; |
844 | return; | 835 | switch (ntohl(resp->drop_flag)) |
845 | } | 836 | { |
846 | GNUNET_free_non_null (rr->payload); | 837 | case 0: /* drop */ |
847 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 838 | rr->phase = RP_DROP; |
848 | "Changing DNS reply according to client specifications\n"); | 839 | break; |
849 | rr->payload = GNUNET_malloc (msize); | 840 | |
850 | rr->payload_length = msize; | 841 | case 1: /* no change */ |
851 | GNUNET_memcpy (rr->payload, &resp[1], msize); | 842 | break; |
852 | if (rr->phase == RP_QUERY) | 843 | |
853 | { | 844 | case 2: /* update */ |
854 | /* clear wait list, we're moving to MODIFY phase next */ | 845 | msize -= sizeof(struct GNUNET_DNS_Response); |
855 | GNUNET_array_grow (rr->client_wait_list, | 846 | if ((sizeof(struct GNUNET_TUN_DnsHeader) > msize) || |
856 | rr->client_wait_list_length, | 847 | (RP_REQUEST_MONITOR == rr->phase) || |
857 | 0); | 848 | (RP_RESPONSE_MONITOR == rr->phase)) |
858 | } | 849 | { |
859 | /* if query changed to answer, move past DNS resolution phase... */ | 850 | GNUNET_break(0); |
860 | if ( (RP_QUERY == rr->phase) && | 851 | GNUNET_SERVICE_client_drop(cr->client); |
861 | (rr->payload_length > sizeof (struct GNUNET_TUN_DnsHeader)) && | 852 | next_phase(rr); |
862 | ((struct GNUNET_TUN_DnsFlags*)&(((struct GNUNET_TUN_DnsHeader*) rr->payload)->flags))->query_or_response == 1) | 853 | return; |
863 | { | 854 | } |
864 | rr->phase = RP_INTERNET_DNS; | 855 | GNUNET_free_non_null(rr->payload); |
865 | GNUNET_array_grow (rr->client_wait_list, | 856 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
866 | rr->client_wait_list_length, | 857 | "Changing DNS reply according to client specifications\n"); |
867 | 0); | 858 | rr->payload = GNUNET_malloc(msize); |
868 | } | 859 | rr->payload_length = msize; |
869 | break; | 860 | GNUNET_memcpy(rr->payload, &resp[1], msize); |
861 | if (rr->phase == RP_QUERY) | ||
862 | { | ||
863 | /* clear wait list, we're moving to MODIFY phase next */ | ||
864 | GNUNET_array_grow(rr->client_wait_list, | ||
865 | rr->client_wait_list_length, | ||
866 | 0); | ||
867 | } | ||
868 | /* if query changed to answer, move past DNS resolution phase... */ | ||
869 | if ((RP_QUERY == rr->phase) && | ||
870 | (rr->payload_length > sizeof(struct GNUNET_TUN_DnsHeader)) && | ||
871 | ((struct GNUNET_TUN_DnsFlags*)&(((struct GNUNET_TUN_DnsHeader*)rr->payload)->flags))->query_or_response == 1) | ||
872 | { | ||
873 | rr->phase = RP_INTERNET_DNS; | ||
874 | GNUNET_array_grow(rr->client_wait_list, | ||
875 | rr->client_wait_list_length, | ||
876 | 0); | ||
877 | } | ||
878 | break; | ||
879 | } | ||
880 | next_phase(rr); | ||
881 | GNUNET_SERVICE_client_continue(cr->client); | ||
882 | return; | ||
870 | } | 883 | } |
871 | next_phase (rr); | ||
872 | GNUNET_SERVICE_client_continue (cr->client); | ||
873 | return; | ||
874 | } | ||
875 | /* odd, client was not on our list for the request, that ought | 884 | /* odd, client was not on our list for the request, that ought |
876 | to be an error */ | 885 | to be an error */ |
877 | GNUNET_break (0); | 886 | GNUNET_break(0); |
878 | GNUNET_SERVICE_client_drop (cr->client); | 887 | GNUNET_SERVICE_client_drop(cr->client); |
879 | } | 888 | } |
880 | 889 | ||
881 | 890 | ||
@@ -887,8 +896,8 @@ handle_client_response (void *cls, | |||
887 | * @param message the actual message, a DNS request we should handle | 896 | * @param message the actual message, a DNS request we should handle |
888 | */ | 897 | */ |
889 | static int | 898 | static int |
890 | process_helper_messages (void *cls, | 899 | process_helper_messages(void *cls, |
891 | const struct GNUNET_MessageHeader *message) | 900 | const struct GNUNET_MessageHeader *message) |
892 | { | 901 | { |
893 | uint16_t msize; | 902 | uint16_t msize; |
894 | const struct GNUNET_TUN_Layer2PacketHeader *tun; | 903 | const struct GNUNET_TUN_Layer2PacketHeader *tun; |
@@ -902,93 +911,95 @@ process_helper_messages (void *cls, | |||
902 | struct sockaddr_in *dsta4; | 911 | struct sockaddr_in *dsta4; |
903 | struct sockaddr_in6 *dsta6; | 912 | struct sockaddr_in6 *dsta6; |
904 | 913 | ||
905 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 914 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
906 | "Intercepted message via DNS hijacker\n"); | 915 | "Intercepted message via DNS hijacker\n"); |
907 | msize = ntohs (message->size); | 916 | msize = ntohs(message->size); |
908 | if (msize < sizeof (struct GNUNET_MessageHeader) + sizeof (struct GNUNET_TUN_Layer2PacketHeader) + sizeof (struct GNUNET_TUN_IPv4Header)) | 917 | if (msize < sizeof(struct GNUNET_MessageHeader) + sizeof(struct GNUNET_TUN_Layer2PacketHeader) + sizeof(struct GNUNET_TUN_IPv4Header)) |
909 | { | ||
910 | /* non-IP packet received on TUN!? */ | ||
911 | GNUNET_break (0); | ||
912 | return GNUNET_OK; | ||
913 | } | ||
914 | msize -= sizeof (struct GNUNET_MessageHeader); | ||
915 | tun = (const struct GNUNET_TUN_Layer2PacketHeader *) &message[1]; | ||
916 | msize -= sizeof (struct GNUNET_TUN_Layer2PacketHeader); | ||
917 | switch (ntohs (tun->proto)) | ||
918 | { | ||
919 | case ETH_P_IPV4: | ||
920 | ip4 = (const struct GNUNET_TUN_IPv4Header *) &tun[1]; | ||
921 | ip6 = NULL; /* make compiler happy */ | ||
922 | if ( (msize < sizeof (struct GNUNET_TUN_IPv4Header)) || | ||
923 | (ip4->version != 4) || | ||
924 | (ip4->header_length != sizeof (struct GNUNET_TUN_IPv4Header) / 4) || | ||
925 | (ntohs(ip4->total_length) != msize) || | ||
926 | (ip4->protocol != IPPROTO_UDP) ) | ||
927 | { | 918 | { |
928 | /* non-IP/UDP packet received on TUN (or with options) */ | 919 | /* non-IP packet received on TUN!? */ |
929 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 920 | GNUNET_break(0); |
930 | _("Received malformed IPv4-UDP packet on TUN interface.\n")); | ||
931 | return GNUNET_OK; | 921 | return GNUNET_OK; |
932 | } | 922 | } |
933 | udp = (const struct GNUNET_TUN_UdpHeader*) &ip4[1]; | 923 | msize -= sizeof(struct GNUNET_MessageHeader); |
934 | msize -= sizeof (struct GNUNET_TUN_IPv4Header); | 924 | tun = (const struct GNUNET_TUN_Layer2PacketHeader *)&message[1]; |
935 | break; | 925 | msize -= sizeof(struct GNUNET_TUN_Layer2PacketHeader); |
936 | case ETH_P_IPV6: | 926 | switch (ntohs(tun->proto)) |
937 | ip4 = NULL; /* make compiler happy */ | ||
938 | ip6 = (const struct GNUNET_TUN_IPv6Header *) &tun[1]; | ||
939 | if ( (msize < sizeof (struct GNUNET_TUN_IPv6Header)) || | ||
940 | (ip6->version != 6) || | ||
941 | (ntohs (ip6->payload_length) != msize - sizeof (struct GNUNET_TUN_IPv6Header)) || | ||
942 | (ip6->next_header != IPPROTO_UDP) ) | ||
943 | { | 927 | { |
944 | /* non-IP/UDP packet received on TUN (or with extensions) */ | 928 | case ETH_P_IPV4: |
945 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 929 | ip4 = (const struct GNUNET_TUN_IPv4Header *)&tun[1]; |
946 | _("Received malformed IPv6-UDP packet on TUN interface.\n")); | 930 | ip6 = NULL; /* make compiler happy */ |
931 | if ((msize < sizeof(struct GNUNET_TUN_IPv4Header)) || | ||
932 | (ip4->version != 4) || | ||
933 | (ip4->header_length != sizeof(struct GNUNET_TUN_IPv4Header) / 4) || | ||
934 | (ntohs(ip4->total_length) != msize) || | ||
935 | (ip4->protocol != IPPROTO_UDP)) | ||
936 | { | ||
937 | /* non-IP/UDP packet received on TUN (or with options) */ | ||
938 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | ||
939 | _("Received malformed IPv4-UDP packet on TUN interface.\n")); | ||
940 | return GNUNET_OK; | ||
941 | } | ||
942 | udp = (const struct GNUNET_TUN_UdpHeader*)&ip4[1]; | ||
943 | msize -= sizeof(struct GNUNET_TUN_IPv4Header); | ||
944 | break; | ||
945 | |||
946 | case ETH_P_IPV6: | ||
947 | ip4 = NULL; /* make compiler happy */ | ||
948 | ip6 = (const struct GNUNET_TUN_IPv6Header *)&tun[1]; | ||
949 | if ((msize < sizeof(struct GNUNET_TUN_IPv6Header)) || | ||
950 | (ip6->version != 6) || | ||
951 | (ntohs(ip6->payload_length) != msize - sizeof(struct GNUNET_TUN_IPv6Header)) || | ||
952 | (ip6->next_header != IPPROTO_UDP)) | ||
953 | { | ||
954 | /* non-IP/UDP packet received on TUN (or with extensions) */ | ||
955 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | ||
956 | _("Received malformed IPv6-UDP packet on TUN interface.\n")); | ||
957 | return GNUNET_OK; | ||
958 | } | ||
959 | udp = (const struct GNUNET_TUN_UdpHeader *)&ip6[1]; | ||
960 | msize -= sizeof(struct GNUNET_TUN_IPv6Header); | ||
961 | break; | ||
962 | |||
963 | default: | ||
964 | /* non-IP packet received on TUN!? */ | ||
965 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | ||
966 | _("Got non-IP packet with %u bytes and protocol %u from TUN\n"), | ||
967 | (unsigned int)msize, | ||
968 | ntohs(tun->proto)); | ||
947 | return GNUNET_OK; | 969 | return GNUNET_OK; |
948 | } | 970 | } |
949 | udp = (const struct GNUNET_TUN_UdpHeader *) &ip6[1]; | 971 | if ((msize <= sizeof(struct GNUNET_TUN_UdpHeader) + sizeof(struct GNUNET_TUN_DnsHeader)) || |
950 | msize -= sizeof (struct GNUNET_TUN_IPv6Header); | 972 | (DNS_PORT != ntohs(udp->destination_port))) |
951 | break; | 973 | { |
952 | default: | 974 | /* non-DNS packet received on TUN, ignore */ |
953 | /* non-IP packet received on TUN!? */ | 975 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, |
954 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 976 | _("DNS interceptor got non-DNS packet (dropped)\n")); |
955 | _("Got non-IP packet with %u bytes and protocol %u from TUN\n"), | 977 | GNUNET_STATISTICS_update(stats, |
956 | (unsigned int) msize, | 978 | gettext_noop("# Non-DNS UDP packet received via TUN interface"), |
957 | ntohs (tun->proto)); | 979 | 1, GNUNET_NO); |
958 | return GNUNET_OK; | 980 | return GNUNET_OK; |
959 | } | 981 | } |
960 | if ( (msize <= sizeof (struct GNUNET_TUN_UdpHeader) + sizeof (struct GNUNET_TUN_DnsHeader)) || | 982 | msize -= sizeof(struct GNUNET_TUN_UdpHeader); |
961 | (DNS_PORT != ntohs (udp->destination_port)) ) | 983 | dns = (const struct GNUNET_TUN_DnsHeader*)&udp[1]; |
962 | { | ||
963 | /* non-DNS packet received on TUN, ignore */ | ||
964 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
965 | _("DNS interceptor got non-DNS packet (dropped)\n")); | ||
966 | GNUNET_STATISTICS_update (stats, | ||
967 | gettext_noop ("# Non-DNS UDP packet received via TUN interface"), | ||
968 | 1, GNUNET_NO); | ||
969 | return GNUNET_OK; | ||
970 | } | ||
971 | msize -= sizeof (struct GNUNET_TUN_UdpHeader); | ||
972 | dns = (const struct GNUNET_TUN_DnsHeader*) &udp[1]; | ||
973 | rr = &requests[dns->id]; | 984 | rr = &requests[dns->id]; |
974 | 985 | ||
975 | /* clean up from previous request */ | 986 | /* clean up from previous request */ |
976 | GNUNET_free_non_null (rr->payload); | 987 | GNUNET_free_non_null(rr->payload); |
977 | rr->payload = NULL; | 988 | rr->payload = NULL; |
978 | GNUNET_array_grow (rr->client_wait_list, | 989 | GNUNET_array_grow(rr->client_wait_list, |
979 | rr->client_wait_list_length, | 990 | rr->client_wait_list_length, |
980 | 0); | 991 | 0); |
981 | 992 | ||
982 | /* setup new request */ | 993 | /* setup new request */ |
983 | rr->phase = RP_INIT; | 994 | rr->phase = RP_INIT; |
984 | switch (ntohs (tun->proto)) | 995 | switch (ntohs(tun->proto)) |
985 | { | ||
986 | case ETH_P_IPV4: | ||
987 | { | 996 | { |
988 | srca4 = (struct sockaddr_in*) &rr->src_addr; | 997 | case ETH_P_IPV4: |
989 | dsta4 = (struct sockaddr_in*) &rr->dst_addr; | 998 | { |
990 | memset (srca4, 0, sizeof (struct sockaddr_in)); | 999 | srca4 = (struct sockaddr_in*)&rr->src_addr; |
991 | memset (dsta4, 0, sizeof (struct sockaddr_in)); | 1000 | dsta4 = (struct sockaddr_in*)&rr->dst_addr; |
1001 | memset(srca4, 0, sizeof(struct sockaddr_in)); | ||
1002 | memset(dsta4, 0, sizeof(struct sockaddr_in)); | ||
992 | srca4->sin_family = AF_INET; | 1003 | srca4->sin_family = AF_INET; |
993 | dsta4->sin_family = AF_INET; | 1004 | dsta4->sin_family = AF_INET; |
994 | srca4->sin_addr = ip4->source_address; | 1005 | srca4->sin_addr = ip4->source_address; |
@@ -996,17 +1007,18 @@ process_helper_messages (void *cls, | |||
996 | srca4->sin_port = udp->source_port; | 1007 | srca4->sin_port = udp->source_port; |
997 | dsta4->sin_port = udp->destination_port; | 1008 | dsta4->sin_port = udp->destination_port; |
998 | #if HAVE_SOCKADDR_IN_SIN_LEN | 1009 | #if HAVE_SOCKADDR_IN_SIN_LEN |
999 | srca4->sin_len = sizeof (struct sockaddr_in); | 1010 | srca4->sin_len = sizeof(struct sockaddr_in); |
1000 | dsta4->sin_len = sizeof (struct sockaddr_in); | 1011 | dsta4->sin_len = sizeof(struct sockaddr_in); |
1001 | #endif | 1012 | #endif |
1002 | } | 1013 | } |
1003 | break; | 1014 | break; |
1004 | case ETH_P_IPV6: | 1015 | |
1016 | case ETH_P_IPV6: | ||
1005 | { | 1017 | { |
1006 | srca6 = (struct sockaddr_in6*) &rr->src_addr; | 1018 | srca6 = (struct sockaddr_in6*)&rr->src_addr; |
1007 | dsta6 = (struct sockaddr_in6*) &rr->dst_addr; | 1019 | dsta6 = (struct sockaddr_in6*)&rr->dst_addr; |
1008 | memset (srca6, 0, sizeof (struct sockaddr_in6)); | 1020 | memset(srca6, 0, sizeof(struct sockaddr_in6)); |
1009 | memset (dsta6, 0, sizeof (struct sockaddr_in6)); | 1021 | memset(dsta6, 0, sizeof(struct sockaddr_in6)); |
1010 | srca6->sin6_family = AF_INET6; | 1022 | srca6->sin6_family = AF_INET6; |
1011 | dsta6->sin6_family = AF_INET6; | 1023 | dsta6->sin6_family = AF_INET6; |
1012 | srca6->sin6_addr = ip6->source_address; | 1024 | srca6->sin6_addr = ip6->source_address; |
@@ -1014,27 +1026,28 @@ process_helper_messages (void *cls, | |||
1014 | srca6->sin6_port = udp->source_port; | 1026 | srca6->sin6_port = udp->source_port; |
1015 | dsta6->sin6_port = udp->destination_port; | 1027 | dsta6->sin6_port = udp->destination_port; |
1016 | #if HAVE_SOCKADDR_IN_SIN_LEN | 1028 | #if HAVE_SOCKADDR_IN_SIN_LEN |
1017 | srca6->sin6_len = sizeof (struct sockaddr_in6); | 1029 | srca6->sin6_len = sizeof(struct sockaddr_in6); |
1018 | dsta6->sin6_len = sizeof (struct sockaddr_in6); | 1030 | dsta6->sin6_len = sizeof(struct sockaddr_in6); |
1019 | #endif | 1031 | #endif |
1020 | } | 1032 | } |
1021 | break; | 1033 | break; |
1022 | default: | 1034 | |
1023 | GNUNET_assert (0); | 1035 | default: |
1024 | } | 1036 | GNUNET_assert(0); |
1025 | rr->payload = GNUNET_malloc (msize); | 1037 | } |
1038 | rr->payload = GNUNET_malloc(msize); | ||
1026 | rr->payload_length = msize; | 1039 | rr->payload_length = msize; |
1027 | GNUNET_memcpy (rr->payload, dns, msize); | 1040 | GNUNET_memcpy(rr->payload, dns, msize); |
1028 | rr->request_id = dns->id | (request_id_gen << 16); | 1041 | rr->request_id = dns->id | (request_id_gen << 16); |
1029 | request_id_gen++; | 1042 | request_id_gen++; |
1030 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 1043 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
1031 | "Creating new DNS request %llu\n", | 1044 | "Creating new DNS request %llu\n", |
1032 | (unsigned long long) rr->request_id); | 1045 | (unsigned long long)rr->request_id); |
1033 | GNUNET_STATISTICS_update (stats, | 1046 | GNUNET_STATISTICS_update(stats, |
1034 | gettext_noop ("# DNS requests received via TUN interface"), | 1047 | gettext_noop("# DNS requests received via TUN interface"), |
1035 | 1, GNUNET_NO); | 1048 | 1, GNUNET_NO); |
1036 | /* start request processing state machine */ | 1049 | /* start request processing state machine */ |
1037 | next_phase (rr); | 1050 | next_phase(rr); |
1038 | return GNUNET_OK; | 1051 | return GNUNET_OK; |
1039 | } | 1052 | } |
1040 | 1053 | ||
@@ -1045,9 +1058,9 @@ process_helper_messages (void *cls, | |||
1045 | * @param service the initialized service | 1058 | * @param service the initialized service |
1046 | */ | 1059 | */ |
1047 | static void | 1060 | static void |
1048 | run (void *cls, | 1061 | run(void *cls, |
1049 | const struct GNUNET_CONFIGURATION_Handle *cfg_, | 1062 | const struct GNUNET_CONFIGURATION_Handle *cfg_, |
1050 | struct GNUNET_SERVICE_Handle *service) | 1063 | struct GNUNET_SERVICE_Handle *service) |
1051 | { | 1064 | { |
1052 | char *ifc_name; | 1065 | char *ifc_name; |
1053 | char *ipv4addr; | 1066 | char *ipv4addr; |
@@ -1059,126 +1072,126 @@ run (void *cls, | |||
1059 | int nortsetup; | 1072 | int nortsetup; |
1060 | 1073 | ||
1061 | cfg = cfg_; | 1074 | cfg = cfg_; |
1062 | stats = GNUNET_STATISTICS_create ("dns", cfg); | 1075 | stats = GNUNET_STATISTICS_create("dns", cfg); |
1063 | GNUNET_SCHEDULER_add_shutdown (&cleanup_task, | 1076 | GNUNET_SCHEDULER_add_shutdown(&cleanup_task, |
1064 | cls); | 1077 | cls); |
1065 | dnsstub = GNUNET_DNSSTUB_start (128); | 1078 | dnsstub = GNUNET_DNSSTUB_start(128); |
1066 | /* TODO: support multiple DNS_EXIT servers being configured */ | 1079 | /* TODO: support multiple DNS_EXIT servers being configured */ |
1067 | /* TODO: see above TODO on using DNS server from original packet. | 1080 | /* TODO: see above TODO on using DNS server from original packet. |
1068 | Not sure which is best... */ | 1081 | Not sure which is best... */ |
1069 | dns_exit = NULL; | 1082 | dns_exit = NULL; |
1070 | if ( (GNUNET_OK != | 1083 | if ((GNUNET_OK != |
1071 | GNUNET_CONFIGURATION_get_value_string (cfg, | 1084 | GNUNET_CONFIGURATION_get_value_string(cfg, |
1072 | "dns", | 1085 | "dns", |
1073 | "DNS_EXIT", | 1086 | "DNS_EXIT", |
1074 | &dns_exit)) || | 1087 | &dns_exit)) || |
1075 | (GNUNET_OK != | 1088 | (GNUNET_OK != |
1076 | GNUNET_DNSSTUB_add_dns_ip (dnsstub, | 1089 | GNUNET_DNSSTUB_add_dns_ip(dnsstub, |
1077 | dns_exit)) ) | 1090 | dns_exit))) |
1078 | { | 1091 | { |
1079 | GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, | 1092 | GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR, |
1080 | "dns", | 1093 | "dns", |
1081 | "DNS_EXIT", | 1094 | "DNS_EXIT", |
1082 | _("need a valid IPv4 or IPv6 address\n")); | 1095 | _("need a valid IPv4 or IPv6 address\n")); |
1083 | GNUNET_free_non_null (dns_exit); | 1096 | GNUNET_free_non_null(dns_exit); |
1084 | } | 1097 | } |
1085 | binary = GNUNET_OS_get_suid_binary_path (cfg, "gnunet-helper-dns"); | 1098 | binary = GNUNET_OS_get_suid_binary_path(cfg, "gnunet-helper-dns"); |
1086 | 1099 | ||
1087 | if (GNUNET_YES != | 1100 | if (GNUNET_YES != |
1088 | GNUNET_OS_check_helper_binary (binary, | 1101 | GNUNET_OS_check_helper_binary(binary, |
1089 | GNUNET_YES, | 1102 | GNUNET_YES, |
1090 | NULL)) // TODO: once we have a windows-testcase, add test parameters here | 1103 | NULL)) // TODO: once we have a windows-testcase, add test parameters here |
1091 | { | 1104 | { |
1092 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 1105 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, |
1093 | _("`%s' is not SUID or the path is invalid, " | 1106 | _("`%s' is not SUID or the path is invalid, " |
1094 | "will not run DNS interceptor\n"), | 1107 | "will not run DNS interceptor\n"), |
1095 | binary); | 1108 | binary); |
1096 | global_ret = 1; | 1109 | global_ret = 1; |
1097 | GNUNET_free (binary); | 1110 | GNUNET_free(binary); |
1098 | return; | 1111 | return; |
1099 | } | 1112 | } |
1100 | GNUNET_free (binary); | 1113 | GNUNET_free(binary); |
1101 | 1114 | ||
1102 | helper_argv[0] = GNUNET_strdup ("gnunet-dns"); | 1115 | helper_argv[0] = GNUNET_strdup("gnunet-dns"); |
1103 | if (GNUNET_SYSERR == | 1116 | if (GNUNET_SYSERR == |
1104 | GNUNET_CONFIGURATION_get_value_string (cfg, | 1117 | GNUNET_CONFIGURATION_get_value_string(cfg, |
1105 | "dns", | 1118 | "dns", |
1106 | "IFNAME", | 1119 | "IFNAME", |
1107 | &ifc_name)) | 1120 | &ifc_name)) |
1108 | { | 1121 | { |
1109 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 1122 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
1110 | "No entry 'IFNAME' in configuration!\n"); | 1123 | "No entry 'IFNAME' in configuration!\n"); |
1111 | GNUNET_free (binary); | 1124 | GNUNET_free(binary); |
1112 | GNUNET_SCHEDULER_shutdown (); | 1125 | GNUNET_SCHEDULER_shutdown(); |
1113 | return; | 1126 | return; |
1114 | } | 1127 | } |
1115 | helper_argv[1] = ifc_name; | 1128 | helper_argv[1] = ifc_name; |
1116 | if ( (GNUNET_SYSERR == | 1129 | if ((GNUNET_SYSERR == |
1117 | GNUNET_CONFIGURATION_get_value_string (cfg, | 1130 | GNUNET_CONFIGURATION_get_value_string(cfg, |
1118 | "dns", | 1131 | "dns", |
1119 | "IPV6ADDR", | 1132 | "IPV6ADDR", |
1120 | &ipv6addr)) ) | 1133 | &ipv6addr))) |
1121 | { | 1134 | { |
1122 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 1135 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
1123 | "No entry 'IPV6ADDR' in configuration!\n"); | 1136 | "No entry 'IPV6ADDR' in configuration!\n"); |
1124 | GNUNET_free (binary); | 1137 | GNUNET_free(binary); |
1125 | GNUNET_SCHEDULER_shutdown (); | 1138 | GNUNET_SCHEDULER_shutdown(); |
1126 | return; | 1139 | return; |
1127 | } | 1140 | } |
1128 | helper_argv[2] = ipv6addr; | 1141 | helper_argv[2] = ipv6addr; |
1129 | if (GNUNET_SYSERR == | 1142 | if (GNUNET_SYSERR == |
1130 | GNUNET_CONFIGURATION_get_value_string (cfg, | 1143 | GNUNET_CONFIGURATION_get_value_string(cfg, |
1131 | "dns", | 1144 | "dns", |
1132 | "IPV6PREFIX", | 1145 | "IPV6PREFIX", |
1133 | &ipv6prefix)) | 1146 | &ipv6prefix)) |
1134 | { | 1147 | { |
1135 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 1148 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
1136 | "No entry 'IPV6PREFIX' in configuration!\n"); | 1149 | "No entry 'IPV6PREFIX' in configuration!\n"); |
1137 | GNUNET_free (binary); | 1150 | GNUNET_free(binary); |
1138 | GNUNET_SCHEDULER_shutdown (); | 1151 | GNUNET_SCHEDULER_shutdown(); |
1139 | return; | 1152 | return; |
1140 | } | 1153 | } |
1141 | helper_argv[3] = ipv6prefix; | 1154 | helper_argv[3] = ipv6prefix; |
1142 | 1155 | ||
1143 | if (GNUNET_SYSERR == | 1156 | if (GNUNET_SYSERR == |
1144 | GNUNET_CONFIGURATION_get_value_string (cfg, | 1157 | GNUNET_CONFIGURATION_get_value_string(cfg, |
1145 | "dns", | 1158 | "dns", |
1146 | "IPV4ADDR", | 1159 | "IPV4ADDR", |
1147 | &ipv4addr)) | 1160 | &ipv4addr)) |
1148 | { | 1161 | { |
1149 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 1162 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
1150 | "No entry 'IPV4ADDR' in configuration!\n"); | 1163 | "No entry 'IPV4ADDR' in configuration!\n"); |
1151 | GNUNET_free (binary); | 1164 | GNUNET_free(binary); |
1152 | GNUNET_SCHEDULER_shutdown (); | 1165 | GNUNET_SCHEDULER_shutdown(); |
1153 | return; | 1166 | return; |
1154 | } | 1167 | } |
1155 | helper_argv[4] = ipv4addr; | 1168 | helper_argv[4] = ipv4addr; |
1156 | if (GNUNET_SYSERR == | 1169 | if (GNUNET_SYSERR == |
1157 | GNUNET_CONFIGURATION_get_value_string (cfg, "dns", "IPV4MASK", | 1170 | GNUNET_CONFIGURATION_get_value_string(cfg, "dns", "IPV4MASK", |
1158 | &ipv4mask)) | 1171 | &ipv4mask)) |
1159 | { | 1172 | { |
1160 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 1173 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
1161 | "No entry 'IPV4MASK' in configuration!\n"); | 1174 | "No entry 'IPV4MASK' in configuration!\n"); |
1162 | GNUNET_free (binary); | 1175 | GNUNET_free(binary); |
1163 | GNUNET_SCHEDULER_shutdown (); | 1176 | GNUNET_SCHEDULER_shutdown(); |
1164 | return; | 1177 | return; |
1165 | } | 1178 | } |
1166 | helper_argv[5] = ipv4mask; | 1179 | helper_argv[5] = ipv4mask; |
1167 | 1180 | ||
1168 | nortsetup = GNUNET_CONFIGURATION_get_value_yesno (cfg, "dns", | 1181 | nortsetup = GNUNET_CONFIGURATION_get_value_yesno(cfg, "dns", |
1169 | "SKIP_ROUTING_SETUP"); | 1182 | "SKIP_ROUTING_SETUP"); |
1170 | if (GNUNET_YES == nortsetup) | 1183 | if (GNUNET_YES == nortsetup) |
1171 | helper_argv[6] = GNUNET_strdup("1"); | 1184 | helper_argv[6] = GNUNET_strdup("1"); |
1172 | else | 1185 | else |
1173 | helper_argv[6] = GNUNET_strdup("0"); | 1186 | helper_argv[6] = GNUNET_strdup("0"); |
1174 | 1187 | ||
1175 | helper_argv[7] = NULL; | 1188 | helper_argv[7] = NULL; |
1176 | hijacker = GNUNET_HELPER_start (GNUNET_NO, | 1189 | hijacker = GNUNET_HELPER_start(GNUNET_NO, |
1177 | binary, | 1190 | binary, |
1178 | helper_argv, | 1191 | helper_argv, |
1179 | &process_helper_messages, | 1192 | &process_helper_messages, |
1180 | NULL, NULL); | 1193 | NULL, NULL); |
1181 | GNUNET_free (binary); | 1194 | GNUNET_free(binary); |
1182 | } | 1195 | } |
1183 | 1196 | ||
1184 | 1197 | ||
@@ -1186,21 +1199,21 @@ run (void *cls, | |||
1186 | * Define "main" method using service macro. | 1199 | * Define "main" method using service macro. |
1187 | */ | 1200 | */ |
1188 | GNUNET_SERVICE_MAIN | 1201 | GNUNET_SERVICE_MAIN |
1189 | ("dns", | 1202 | ("dns", |
1190 | GNUNET_SERVICE_OPTION_NONE, | 1203 | GNUNET_SERVICE_OPTION_NONE, |
1191 | &run, | 1204 | &run, |
1192 | &client_connect_cb, | 1205 | &client_connect_cb, |
1193 | &client_disconnect_cb, | 1206 | &client_disconnect_cb, |
1194 | NULL, | 1207 | NULL, |
1195 | GNUNET_MQ_hd_fixed_size (client_init, | 1208 | GNUNET_MQ_hd_fixed_size(client_init, |
1196 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_INIT, | 1209 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_INIT, |
1197 | struct GNUNET_DNS_Register, | 1210 | struct GNUNET_DNS_Register, |
1198 | NULL), | 1211 | NULL), |
1199 | GNUNET_MQ_hd_var_size (client_response, | 1212 | GNUNET_MQ_hd_var_size(client_response, |
1200 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE, | 1213 | GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE, |
1201 | struct GNUNET_DNS_Response, | 1214 | struct GNUNET_DNS_Response, |
1202 | NULL), | 1215 | NULL), |
1203 | GNUNET_MQ_handler_end ()); | 1216 | GNUNET_MQ_handler_end()); |
1204 | 1217 | ||
1205 | 1218 | ||
1206 | /* FIXME: this might need a port on systems without 'getresgid' */ | 1219 | /* FIXME: this might need a port on systems without 'getresgid' */ |
@@ -1209,28 +1222,28 @@ GNUNET_SERVICE_MAIN | |||
1209 | * Enable use of SGID capabilities on POSIX | 1222 | * Enable use of SGID capabilities on POSIX |
1210 | */ | 1223 | */ |
1211 | void __attribute__ ((constructor)) | 1224 | void __attribute__ ((constructor)) |
1212 | GNUNET_DNS_init () | 1225 | GNUNET_DNS_init() |
1213 | { | 1226 | { |
1214 | gid_t rgid; | 1227 | gid_t rgid; |
1215 | gid_t egid; | 1228 | gid_t egid; |
1216 | gid_t sgid; | 1229 | gid_t sgid; |
1217 | 1230 | ||
1218 | if (-1 == getresgid (&rgid, | 1231 | if (-1 == getresgid(&rgid, |
1219 | &egid, | 1232 | &egid, |
1220 | &sgid)) | 1233 | &sgid)) |
1221 | { | 1234 | { |
1222 | fprintf (stderr, | 1235 | fprintf(stderr, |
1223 | "getresgid failed: %s\n", | 1236 | "getresgid failed: %s\n", |
1224 | strerror (errno)); | 1237 | strerror(errno)); |
1225 | } | 1238 | } |
1226 | else if (sgid != rgid) | 1239 | else if (sgid != rgid) |
1227 | { | 1240 | { |
1228 | if (-1 == setregid (sgid, | 1241 | if (-1 == setregid(sgid, |
1229 | sgid)) | 1242 | sgid)) |
1230 | fprintf (stderr, | 1243 | fprintf(stderr, |
1231 | "setregid failed: %s\n", | 1244 | "setregid failed: %s\n", |
1232 | strerror (errno)); | 1245 | strerror(errno)); |
1233 | } | 1246 | } |
1234 | } | 1247 | } |
1235 | #endif | 1248 | #endif |
1236 | 1249 | ||
diff --git a/src/dns/gnunet-zonewalk.c b/src/dns/gnunet-zonewalk.c index 19fc5b78d..2968d0209 100644 --- a/src/dns/gnunet-zonewalk.c +++ b/src/dns/gnunet-zonewalk.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file src/dns/gnunet-zoneimport.c | 22 | * @file src/dns/gnunet-zoneimport.c |
@@ -31,8 +31,7 @@ | |||
31 | /** | 31 | /** |
32 | * Request we should make. | 32 | * Request we should make. |
33 | */ | 33 | */ |
34 | struct Request | 34 | struct Request { |
35 | { | ||
36 | /** | 35 | /** |
37 | * Requests are kept in a DLL. | 36 | * Requests are kept in a DLL. |
38 | */ | 37 | */ |
@@ -144,145 +143,155 @@ static struct GNUNET_SCHEDULER_Task *t; | |||
144 | * @param rec response | 143 | * @param rec response |
145 | */ | 144 | */ |
146 | static void | 145 | static void |
147 | process_record (struct Request *req, | 146 | process_record(struct Request *req, |
148 | struct GNUNET_DNSPARSER_Record *rec) | 147 | struct GNUNET_DNSPARSER_Record *rec) |
149 | { | 148 | { |
150 | char buf[INET6_ADDRSTRLEN]; | 149 | char buf[INET6_ADDRSTRLEN]; |
151 | 150 | ||
152 | records++; | 151 | records++; |
153 | switch (rec->type) | 152 | switch (rec->type) |
154 | { | 153 | { |
155 | case GNUNET_DNSPARSER_TYPE_A: | 154 | case GNUNET_DNSPARSER_TYPE_A: |
156 | fprintf (stdout, | 155 | fprintf(stdout, |
157 | "%s A %s\n", | 156 | "%s A %s\n", |
158 | req->hostname, | 157 | req->hostname, |
159 | inet_ntop (AF_INET, | 158 | inet_ntop(AF_INET, |
160 | rec->data.raw.data, | 159 | rec->data.raw.data, |
161 | buf, | 160 | buf, |
162 | sizeof (buf))); | 161 | sizeof(buf))); |
163 | break; | 162 | break; |
164 | case GNUNET_DNSPARSER_TYPE_AAAA: | 163 | |
165 | fprintf (stdout, | 164 | case GNUNET_DNSPARSER_TYPE_AAAA: |
166 | "%s AAAA %s\n", | 165 | fprintf(stdout, |
167 | req->hostname, | 166 | "%s AAAA %s\n", |
168 | inet_ntop (AF_INET6, | 167 | req->hostname, |
168 | inet_ntop(AF_INET6, | ||
169 | rec->data.raw.data, | 169 | rec->data.raw.data, |
170 | buf, | 170 | buf, |
171 | sizeof (buf))); | 171 | sizeof(buf))); |
172 | break; | 172 | break; |
173 | case GNUNET_DNSPARSER_TYPE_NS: | 173 | |
174 | fprintf (stdout, | 174 | case GNUNET_DNSPARSER_TYPE_NS: |
175 | "%s NS %s\n", | 175 | fprintf(stdout, |
176 | req->hostname, | 176 | "%s NS %s\n", |
177 | rec->data.hostname); | 177 | req->hostname, |
178 | break; | 178 | rec->data.hostname); |
179 | case GNUNET_DNSPARSER_TYPE_CNAME: | 179 | break; |
180 | fprintf (stdout, | 180 | |
181 | "%s CNAME %s\n", | 181 | case GNUNET_DNSPARSER_TYPE_CNAME: |
182 | req->hostname, | 182 | fprintf(stdout, |
183 | rec->data.hostname); | 183 | "%s CNAME %s\n", |
184 | break; | 184 | req->hostname, |
185 | case GNUNET_DNSPARSER_TYPE_MX: | 185 | rec->data.hostname); |
186 | fprintf (stdout, | 186 | break; |
187 | "%s MX %u %s\n", | 187 | |
188 | req->hostname, | 188 | case GNUNET_DNSPARSER_TYPE_MX: |
189 | (unsigned int) rec->data.mx->preference, | 189 | fprintf(stdout, |
190 | rec->data.mx->mxhost); | 190 | "%s MX %u %s\n", |
191 | break; | 191 | req->hostname, |
192 | case GNUNET_DNSPARSER_TYPE_SOA: | 192 | (unsigned int)rec->data.mx->preference, |
193 | fprintf (stdout, | 193 | rec->data.mx->mxhost); |
194 | "%s SOA %s %s %u %u %u %u %u\n", | 194 | break; |
195 | req->hostname, | 195 | |
196 | rec->data.soa->mname, | 196 | case GNUNET_DNSPARSER_TYPE_SOA: |
197 | rec->data.soa->rname, | 197 | fprintf(stdout, |
198 | (unsigned int) rec->data.soa->serial, | 198 | "%s SOA %s %s %u %u %u %u %u\n", |
199 | (unsigned int) rec->data.soa->refresh, | 199 | req->hostname, |
200 | (unsigned int) rec->data.soa->retry, | 200 | rec->data.soa->mname, |
201 | (unsigned int) rec->data.soa->expire, | 201 | rec->data.soa->rname, |
202 | (unsigned int) rec->data.soa->minimum_ttl); | 202 | (unsigned int)rec->data.soa->serial, |
203 | break; | 203 | (unsigned int)rec->data.soa->refresh, |
204 | case GNUNET_DNSPARSER_TYPE_SRV: | 204 | (unsigned int)rec->data.soa->retry, |
205 | fprintf (stdout, | 205 | (unsigned int)rec->data.soa->expire, |
206 | "%s SRV %s %u %u %u\n", | 206 | (unsigned int)rec->data.soa->minimum_ttl); |
207 | req->hostname, | 207 | break; |
208 | rec->data.srv->target, | 208 | |
209 | rec->data.srv->priority, | 209 | case GNUNET_DNSPARSER_TYPE_SRV: |
210 | rec->data.srv->weight, | 210 | fprintf(stdout, |
211 | rec->data.srv->port); | 211 | "%s SRV %s %u %u %u\n", |
212 | break; | 212 | req->hostname, |
213 | case GNUNET_DNSPARSER_TYPE_PTR: | 213 | rec->data.srv->target, |
214 | fprintf (stdout, | 214 | rec->data.srv->priority, |
215 | "%s PTR %s\n", | 215 | rec->data.srv->weight, |
216 | req->hostname, | 216 | rec->data.srv->port); |
217 | rec->data.hostname); | 217 | break; |
218 | break; | 218 | |
219 | case GNUNET_DNSPARSER_TYPE_TXT: | 219 | case GNUNET_DNSPARSER_TYPE_PTR: |
220 | fprintf (stdout, | 220 | fprintf(stdout, |
221 | "%s TXT %.*s\n", | 221 | "%s PTR %s\n", |
222 | req->hostname, | 222 | req->hostname, |
223 | (int) rec->data.raw.data_len, | 223 | rec->data.hostname); |
224 | (char *) rec->data.raw.data); | 224 | break; |
225 | break; | 225 | |
226 | case GNUNET_DNSPARSER_TYPE_DNAME: | 226 | case GNUNET_DNSPARSER_TYPE_TXT: |
227 | fprintf (stdout, | 227 | fprintf(stdout, |
228 | "%s DNAME %s\n", | 228 | "%s TXT %.*s\n", |
229 | req->hostname, | 229 | req->hostname, |
230 | rec->data.hostname); | 230 | (int)rec->data.raw.data_len, |
231 | break; | 231 | (char *)rec->data.raw.data); |
232 | break; | ||
233 | |||
234 | case GNUNET_DNSPARSER_TYPE_DNAME: | ||
235 | fprintf(stdout, | ||
236 | "%s DNAME %s\n", | ||
237 | req->hostname, | ||
238 | rec->data.hostname); | ||
239 | break; | ||
232 | 240 | ||
233 | /* obscure records */ | 241 | /* obscure records */ |
234 | case GNUNET_DNSPARSER_TYPE_AFSDB: | 242 | case GNUNET_DNSPARSER_TYPE_AFSDB: |
235 | case GNUNET_DNSPARSER_TYPE_NAPTR: | 243 | case GNUNET_DNSPARSER_TYPE_NAPTR: |
236 | case GNUNET_DNSPARSER_TYPE_APL: | 244 | case GNUNET_DNSPARSER_TYPE_APL: |
237 | case GNUNET_DNSPARSER_TYPE_DHCID: | 245 | case GNUNET_DNSPARSER_TYPE_DHCID: |
238 | case GNUNET_DNSPARSER_TYPE_HIP: | 246 | case GNUNET_DNSPARSER_TYPE_HIP: |
239 | case GNUNET_DNSPARSER_TYPE_LOC: | 247 | case GNUNET_DNSPARSER_TYPE_LOC: |
240 | case GNUNET_DNSPARSER_TYPE_RP: | 248 | case GNUNET_DNSPARSER_TYPE_RP: |
241 | case GNUNET_DNSPARSER_TYPE_TKEY: | 249 | case GNUNET_DNSPARSER_TYPE_TKEY: |
242 | case GNUNET_DNSPARSER_TYPE_TSIG: | 250 | case GNUNET_DNSPARSER_TYPE_TSIG: |
243 | case GNUNET_DNSPARSER_TYPE_URI: | 251 | case GNUNET_DNSPARSER_TYPE_URI: |
244 | case GNUNET_DNSPARSER_TYPE_TA: | 252 | case GNUNET_DNSPARSER_TYPE_TA: |
245 | 253 | ||
246 | /* DNSSEC */ | 254 | /* DNSSEC */ |
247 | case GNUNET_DNSPARSER_TYPE_DS: | 255 | case GNUNET_DNSPARSER_TYPE_DS: |
248 | case GNUNET_DNSPARSER_TYPE_RRSIG: | 256 | case GNUNET_DNSPARSER_TYPE_RRSIG: |
249 | case GNUNET_DNSPARSER_TYPE_NSEC: | 257 | case GNUNET_DNSPARSER_TYPE_NSEC: |
250 | case GNUNET_DNSPARSER_TYPE_DNSKEY: | 258 | case GNUNET_DNSPARSER_TYPE_DNSKEY: |
251 | case GNUNET_DNSPARSER_TYPE_NSEC3: | 259 | case GNUNET_DNSPARSER_TYPE_NSEC3: |
252 | case GNUNET_DNSPARSER_TYPE_NSEC3PARAM: | 260 | case GNUNET_DNSPARSER_TYPE_NSEC3PARAM: |
253 | case GNUNET_DNSPARSER_TYPE_CDS: | 261 | case GNUNET_DNSPARSER_TYPE_CDS: |
254 | case GNUNET_DNSPARSER_TYPE_CDNSKEY: | 262 | case GNUNET_DNSPARSER_TYPE_CDNSKEY: |
255 | 263 | ||
256 | /* DNSSEC payload */ | 264 | /* DNSSEC payload */ |
257 | case GNUNET_DNSPARSER_TYPE_CERT: | 265 | case GNUNET_DNSPARSER_TYPE_CERT: |
258 | case GNUNET_DNSPARSER_TYPE_SSHFP: | 266 | case GNUNET_DNSPARSER_TYPE_SSHFP: |
259 | case GNUNET_DNSPARSER_TYPE_IPSECKEY: | 267 | case GNUNET_DNSPARSER_TYPE_IPSECKEY: |
260 | case GNUNET_DNSPARSER_TYPE_TLSA: | 268 | case GNUNET_DNSPARSER_TYPE_TLSA: |
261 | case GNUNET_DNSPARSER_TYPE_OPENPGPKEY: | 269 | case GNUNET_DNSPARSER_TYPE_OPENPGPKEY: |
262 | 270 | ||
263 | /* obsolete records */ | 271 | /* obsolete records */ |
264 | case GNUNET_DNSPARSER_TYPE_SIG: | 272 | case GNUNET_DNSPARSER_TYPE_SIG: |
265 | case GNUNET_DNSPARSER_TYPE_KEY: | 273 | case GNUNET_DNSPARSER_TYPE_KEY: |
266 | case GNUNET_DNSPARSER_TYPE_KX: | 274 | case GNUNET_DNSPARSER_TYPE_KX: |
267 | { | 275 | { |
268 | char *base32; | 276 | char *base32; |
269 | 277 | ||
270 | base32 = GNUNET_STRINGS_data_to_string_alloc (rec->data.raw.data, | 278 | base32 = GNUNET_STRINGS_data_to_string_alloc(rec->data.raw.data, |
271 | rec->data.raw.data_len); | 279 | rec->data.raw.data_len); |
272 | fprintf (stdout, | 280 | fprintf(stdout, |
273 | "%s (%u) %s\n", | 281 | "%s (%u) %s\n", |
274 | req->hostname, | 282 | req->hostname, |
275 | rec->type, | 283 | rec->type, |
276 | base32); | 284 | base32); |
277 | GNUNET_free (base32); | 285 | GNUNET_free(base32); |
278 | } | 286 | } |
279 | break; | 287 | break; |
280 | default: | 288 | |
281 | fprintf (stderr, | 289 | default: |
282 | "Unsupported type %u\n", | 290 | fprintf(stderr, |
283 | (unsigned int) rec->type); | 291 | "Unsupported type %u\n", |
284 | break; | 292 | (unsigned int)rec->type); |
285 | } | 293 | break; |
294 | } | ||
286 | } | 295 | } |
287 | 296 | ||
288 | 297 | ||
@@ -294,90 +303,90 @@ process_record (struct Request *req, | |||
294 | * @param dns_len number of bytes in @a dns | 303 | * @param dns_len number of bytes in @a dns |
295 | */ | 304 | */ |
296 | static void | 305 | static void |
297 | process_result (void *cls, | 306 | process_result(void *cls, |
298 | const struct GNUNET_TUN_DnsHeader *dns, | 307 | const struct GNUNET_TUN_DnsHeader *dns, |
299 | size_t dns_len) | 308 | size_t dns_len) |
300 | { | 309 | { |
301 | struct Request *req = cls; | 310 | struct Request *req = cls; |
302 | struct GNUNET_DNSPARSER_Packet *p; | 311 | struct GNUNET_DNSPARSER_Packet *p; |
303 | 312 | ||
304 | if (NULL == dns) | 313 | if (NULL == dns) |
305 | { | ||
306 | /* stub gave up */ | ||
307 | pending--; | ||
308 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
309 | "Stub gave up on DNS reply for `%s'\n", | ||
310 | req->hostname); | ||
311 | GNUNET_CONTAINER_DLL_remove (req_head, | ||
312 | req_tail, | ||
313 | req); | ||
314 | if (req->issue_num > MAX_RETRIES) | ||
315 | { | 314 | { |
316 | failures++; | 315 | /* stub gave up */ |
317 | GNUNET_free (req->hostname); | 316 | pending--; |
318 | GNUNET_free (req->raw); | 317 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
319 | GNUNET_free (req); | 318 | "Stub gave up on DNS reply for `%s'\n", |
319 | req->hostname); | ||
320 | GNUNET_CONTAINER_DLL_remove(req_head, | ||
321 | req_tail, | ||
322 | req); | ||
323 | if (req->issue_num > MAX_RETRIES) | ||
324 | { | ||
325 | failures++; | ||
326 | GNUNET_free(req->hostname); | ||
327 | GNUNET_free(req->raw); | ||
328 | GNUNET_free(req); | ||
329 | return; | ||
330 | } | ||
331 | GNUNET_CONTAINER_DLL_insert_tail(req_head, | ||
332 | req_tail, | ||
333 | req); | ||
334 | req->rs = NULL; | ||
320 | return; | 335 | return; |
321 | } | 336 | } |
322 | GNUNET_CONTAINER_DLL_insert_tail (req_head, | ||
323 | req_tail, | ||
324 | req); | ||
325 | req->rs = NULL; | ||
326 | return; | ||
327 | } | ||
328 | if (req->id != dns->id) | 337 | if (req->id != dns->id) |
329 | return; | 338 | return; |
330 | pending--; | 339 | pending--; |
331 | GNUNET_DNSSTUB_resolve_cancel (req->rs); | 340 | GNUNET_DNSSTUB_resolve_cancel(req->rs); |
332 | req->rs = NULL; | 341 | req->rs = NULL; |
333 | GNUNET_CONTAINER_DLL_remove (req_head, | 342 | GNUNET_CONTAINER_DLL_remove(req_head, |
334 | req_tail, | 343 | req_tail, |
335 | req); | 344 | req); |
336 | p = GNUNET_DNSPARSER_parse ((const char *) dns, | 345 | p = GNUNET_DNSPARSER_parse((const char *)dns, |
337 | dns_len); | 346 | dns_len); |
338 | if (NULL == p) | 347 | if (NULL == p) |
339 | { | ||
340 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
341 | "Failed to parse DNS reply for `%s'\n", | ||
342 | req->hostname); | ||
343 | if (req->issue_num > MAX_RETRIES) | ||
344 | { | 348 | { |
345 | failures++; | 349 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
346 | GNUNET_free (req->hostname); | 350 | "Failed to parse DNS reply for `%s'\n", |
347 | GNUNET_free (req->raw); | 351 | req->hostname); |
348 | GNUNET_free (req); | 352 | if (req->issue_num > MAX_RETRIES) |
353 | { | ||
354 | failures++; | ||
355 | GNUNET_free(req->hostname); | ||
356 | GNUNET_free(req->raw); | ||
357 | GNUNET_free(req); | ||
358 | return; | ||
359 | } | ||
360 | GNUNET_CONTAINER_DLL_insert_tail(req_head, | ||
361 | req_tail, | ||
362 | req); | ||
349 | return; | 363 | return; |
350 | } | 364 | } |
351 | GNUNET_CONTAINER_DLL_insert_tail (req_head, | 365 | for (unsigned int i = 0; i < p->num_answers; i++) |
352 | req_tail, | 366 | { |
353 | req); | 367 | struct GNUNET_DNSPARSER_Record *rs = &p->answers[i]; |
354 | return; | 368 | |
355 | } | 369 | process_record(req, |
356 | for (unsigned int i=0;i<p->num_answers;i++) | 370 | rs); |
357 | { | 371 | } |
358 | struct GNUNET_DNSPARSER_Record *rs = &p->answers[i]; | 372 | for (unsigned int i = 0; i < p->num_authority_records; i++) |
359 | 373 | { | |
360 | process_record (req, | 374 | struct GNUNET_DNSPARSER_Record *rs = &p->authority_records[i]; |
361 | rs); | 375 | |
362 | } | 376 | process_record(req, |
363 | for (unsigned int i=0;i<p->num_authority_records;i++) | 377 | rs); |
364 | { | 378 | } |
365 | struct GNUNET_DNSPARSER_Record *rs = &p->authority_records[i]; | 379 | for (unsigned int i = 0; i < p->num_additional_records; i++) |
366 | 380 | { | |
367 | process_record (req, | 381 | struct GNUNET_DNSPARSER_Record *rs = &p->additional_records[i]; |
368 | rs); | 382 | |
369 | } | 383 | process_record(req, |
370 | for (unsigned int i=0;i<p->num_additional_records;i++) | 384 | rs); |
371 | { | 385 | } |
372 | struct GNUNET_DNSPARSER_Record *rs = &p->additional_records[i]; | 386 | GNUNET_DNSPARSER_free_packet(p); |
373 | 387 | GNUNET_free(req->hostname); | |
374 | process_record (req, | 388 | GNUNET_free(req->raw); |
375 | rs); | 389 | GNUNET_free(req); |
376 | } | ||
377 | GNUNET_DNSPARSER_free_packet (p); | ||
378 | GNUNET_free (req->hostname); | ||
379 | GNUNET_free (req->raw); | ||
380 | GNUNET_free (req); | ||
381 | } | 390 | } |
382 | 391 | ||
383 | 392 | ||
@@ -391,31 +400,31 @@ process_result (void *cls, | |||
391 | * #GNUNET_SYSERR if we are at the rate limit | 400 | * #GNUNET_SYSERR if we are at the rate limit |
392 | */ | 401 | */ |
393 | static int | 402 | static int |
394 | submit_req (struct Request *req) | 403 | submit_req(struct Request *req) |
395 | { | 404 | { |
396 | static struct timeval last_request; | 405 | static struct timeval last_request; |
397 | struct timeval now; | 406 | struct timeval now; |
398 | 407 | ||
399 | if (NULL != req->rs) | 408 | if (NULL != req->rs) |
400 | return GNUNET_NO; /* already submitted */ | 409 | return GNUNET_NO; /* already submitted */ |
401 | gettimeofday (&now, | 410 | gettimeofday(&now, |
402 | NULL); | 411 | NULL); |
403 | if ( ( ( (now.tv_sec - last_request.tv_sec) == 0) && | 412 | if ((((now.tv_sec - last_request.tv_sec) == 0) && |
404 | ( (now.tv_usec - last_request.tv_usec) < TIME_THRESH) ) || | 413 | ((now.tv_usec - last_request.tv_usec) < TIME_THRESH)) || |
405 | (pending >= THRESH) ) | 414 | (pending >= THRESH)) |
406 | return GNUNET_SYSERR; | 415 | return GNUNET_SYSERR; |
407 | GNUNET_assert (NULL == req->rs); | 416 | GNUNET_assert(NULL == req->rs); |
408 | req->rs = GNUNET_DNSSTUB_resolve (ctx, | 417 | req->rs = GNUNET_DNSSTUB_resolve(ctx, |
409 | req->raw, | 418 | req->raw, |
410 | req->raw_len, | 419 | req->raw_len, |
411 | &process_result, | 420 | &process_result, |
412 | req); | 421 | req); |
413 | GNUNET_assert (NULL != req->rs); | 422 | GNUNET_assert(NULL != req->rs); |
414 | req->issue_num++; | 423 | req->issue_num++; |
415 | last_request = now; | 424 | last_request = now; |
416 | lookups++; | 425 | lookups++; |
417 | pending++; | 426 | pending++; |
418 | req->time = time (NULL); | 427 | req->time = time(NULL); |
419 | return GNUNET_OK; | 428 | return GNUNET_OK; |
420 | } | 429 | } |
421 | 430 | ||
@@ -428,21 +437,21 @@ submit_req (struct Request *req) | |||
428 | static void | 437 | static void |
429 | process_queue(void *cls) | 438 | process_queue(void *cls) |
430 | { | 439 | { |
431 | (void) cls; | 440 | (void)cls; |
432 | t = NULL; | 441 | t = NULL; |
433 | for (struct Request *req = req_head; | 442 | for (struct Request *req = req_head; |
434 | NULL != req; | 443 | NULL != req; |
435 | req = req->next) | 444 | req = req->next) |
436 | { | 445 | { |
437 | if (GNUNET_SYSERR == submit_req (req)) | 446 | if (GNUNET_SYSERR == submit_req(req)) |
438 | break; | 447 | break; |
439 | } | 448 | } |
440 | if (NULL != req_head) | 449 | if (NULL != req_head) |
441 | t = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS, | 450 | t = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MILLISECONDS, |
442 | &process_queue, | 451 | &process_queue, |
443 | NULL); | 452 | NULL); |
444 | else | 453 | else |
445 | GNUNET_SCHEDULER_shutdown (); | 454 | GNUNET_SCHEDULER_shutdown(); |
446 | } | 455 | } |
447 | 456 | ||
448 | 457 | ||
@@ -452,15 +461,15 @@ process_queue(void *cls) | |||
452 | * @param cls NULL | 461 | * @param cls NULL |
453 | */ | 462 | */ |
454 | static void | 463 | static void |
455 | do_shutdown (void *cls) | 464 | do_shutdown(void *cls) |
456 | { | 465 | { |
457 | (void) cls; | 466 | (void)cls; |
458 | if (NULL != t) | 467 | if (NULL != t) |
459 | { | 468 | { |
460 | GNUNET_SCHEDULER_cancel (t); | 469 | GNUNET_SCHEDULER_cancel(t); |
461 | t = NULL; | 470 | t = NULL; |
462 | } | 471 | } |
463 | GNUNET_DNSSTUB_stop (ctx); | 472 | GNUNET_DNSSTUB_stop(ctx); |
464 | ctx = NULL; | 473 | ctx = NULL; |
465 | } | 474 | } |
466 | 475 | ||
@@ -472,14 +481,14 @@ do_shutdown (void *cls) | |||
472 | * @param cls NULL | 481 | * @param cls NULL |
473 | */ | 482 | */ |
474 | static void | 483 | static void |
475 | run (void *cls) | 484 | run(void *cls) |
476 | { | 485 | { |
477 | (void) cls; | 486 | (void)cls; |
478 | 487 | ||
479 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, | 488 | GNUNET_SCHEDULER_add_shutdown(&do_shutdown, |
480 | NULL); | ||
481 | t = GNUNET_SCHEDULER_add_now (&process_queue, | ||
482 | NULL); | 489 | NULL); |
490 | t = GNUNET_SCHEDULER_add_now(&process_queue, | ||
491 | NULL); | ||
483 | } | 492 | } |
484 | 493 | ||
485 | 494 | ||
@@ -489,7 +498,7 @@ run (void *cls) | |||
489 | * @param hostname name to resolve | 498 | * @param hostname name to resolve |
490 | */ | 499 | */ |
491 | static void | 500 | static void |
492 | queue (const char *hostname) | 501 | queue(const char *hostname) |
493 | { | 502 | { |
494 | struct GNUNET_DNSPARSER_Packet p; | 503 | struct GNUNET_DNSPARSER_Packet p; |
495 | struct GNUNET_DNSPARSER_Query q; | 504 | struct GNUNET_DNSPARSER_Query q; |
@@ -499,46 +508,46 @@ queue (const char *hostname) | |||
499 | int ret; | 508 | int ret; |
500 | 509 | ||
501 | if (GNUNET_OK != | 510 | if (GNUNET_OK != |
502 | GNUNET_DNSPARSER_check_name (hostname)) | 511 | GNUNET_DNSPARSER_check_name(hostname)) |
503 | { | 512 | { |
504 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 513 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
505 | "Refusing invalid hostname `%s'\n", | 514 | "Refusing invalid hostname `%s'\n", |
506 | hostname); | 515 | hostname); |
507 | return; | 516 | return; |
508 | } | 517 | } |
509 | q.name = (char *) hostname; | 518 | q.name = (char *)hostname; |
510 | q.type = GNUNET_DNSPARSER_TYPE_NS; | 519 | q.type = GNUNET_DNSPARSER_TYPE_NS; |
511 | q.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; | 520 | q.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; |
512 | 521 | ||
513 | memset (&p, | 522 | memset(&p, |
514 | 0, | 523 | 0, |
515 | sizeof (p)); | 524 | sizeof(p)); |
516 | p.num_queries = 1; | 525 | p.num_queries = 1; |
517 | p.queries = &q; | 526 | p.queries = &q; |
518 | p.id = (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, | 527 | p.id = (uint16_t)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, |
519 | UINT16_MAX); | 528 | UINT16_MAX); |
520 | ret = GNUNET_DNSPARSER_pack (&p, | 529 | ret = GNUNET_DNSPARSER_pack(&p, |
521 | UINT16_MAX, | 530 | UINT16_MAX, |
522 | &raw, | 531 | &raw, |
523 | &raw_size); | 532 | &raw_size); |
524 | if (GNUNET_OK != ret) | 533 | if (GNUNET_OK != ret) |
525 | { | 534 | { |
526 | if (GNUNET_NO == ret) | 535 | if (GNUNET_NO == ret) |
527 | GNUNET_free (raw); | 536 | GNUNET_free(raw); |
528 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 537 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
529 | "Failed to pack query for hostname `%s'\n", | 538 | "Failed to pack query for hostname `%s'\n", |
530 | hostname); | 539 | hostname); |
531 | return; | 540 | return; |
532 | } | 541 | } |
533 | 542 | ||
534 | req = GNUNET_new (struct Request); | 543 | req = GNUNET_new(struct Request); |
535 | req->hostname = strdup (hostname); | 544 | req->hostname = strdup(hostname); |
536 | req->raw = raw; | 545 | req->raw = raw; |
537 | req->raw_len = raw_size; | 546 | req->raw_len = raw_size; |
538 | req->id = p.id; | 547 | req->id = p.id; |
539 | GNUNET_CONTAINER_DLL_insert_tail (req_head, | 548 | GNUNET_CONTAINER_DLL_insert_tail(req_head, |
540 | req_tail, | 549 | req_tail, |
541 | req); | 550 | req); |
542 | } | 551 | } |
543 | 552 | ||
544 | 553 | ||
@@ -550,50 +559,50 @@ queue (const char *hostname) | |||
550 | * @return 0 on success | 559 | * @return 0 on success |
551 | */ | 560 | */ |
552 | int | 561 | int |
553 | main (int argc, | 562 | main(int argc, |
554 | char **argv) | 563 | char **argv) |
555 | { | 564 | { |
556 | char hn[256]; | 565 | char hn[256]; |
557 | 566 | ||
558 | if (2 != argc) | 567 | if (2 != argc) |
559 | { | 568 | { |
560 | fprintf (stderr, | 569 | fprintf(stderr, |
561 | "Missing required configuration argument\n"); | 570 | "Missing required configuration argument\n"); |
562 | return -1; | 571 | return -1; |
563 | } | 572 | } |
564 | ctx = GNUNET_DNSSTUB_start (256); | 573 | ctx = GNUNET_DNSSTUB_start(256); |
565 | if (NULL == ctx) | 574 | if (NULL == ctx) |
566 | { | 575 | { |
567 | fprintf (stderr, | 576 | fprintf(stderr, |
568 | "Failed to initialize GNUnet DNS STUB\n"); | 577 | "Failed to initialize GNUnet DNS STUB\n"); |
569 | return 1; | 578 | return 1; |
570 | } | 579 | } |
571 | if (GNUNET_OK != | 580 | if (GNUNET_OK != |
572 | GNUNET_DNSSTUB_add_dns_ip (ctx, | 581 | GNUNET_DNSSTUB_add_dns_ip(ctx, |
573 | argv[1])) | 582 | argv[1])) |
574 | { | 583 | { |
575 | fprintf (stderr, | 584 | fprintf(stderr, |
576 | "Failed to use `%s' for DNS resolver\n", | 585 | "Failed to use `%s' for DNS resolver\n", |
577 | argv[1]); | 586 | argv[1]); |
578 | return 1; | 587 | return 1; |
579 | } | 588 | } |
580 | 589 | ||
581 | while (NULL != | 590 | while (NULL != |
582 | fgets (hn, | 591 | fgets(hn, |
583 | sizeof (hn), | 592 | sizeof(hn), |
584 | stdin)) | 593 | stdin)) |
585 | { | 594 | { |
586 | if (strlen(hn) > 0) | 595 | if (strlen(hn) > 0) |
587 | hn[strlen(hn)-1] = '\0'; /* eat newline */ | 596 | hn[strlen(hn) - 1] = '\0'; /* eat newline */ |
588 | queue (hn); | 597 | queue(hn); |
589 | } | 598 | } |
590 | GNUNET_SCHEDULER_run (&run, | 599 | GNUNET_SCHEDULER_run(&run, |
591 | NULL); | 600 | NULL); |
592 | fprintf (stderr, | 601 | fprintf(stderr, |
593 | "Did %u lookups, found %u records, %u lookups failed, %u pending on shutdown\n", | 602 | "Did %u lookups, found %u records, %u lookups failed, %u pending on shutdown\n", |
594 | lookups, | 603 | lookups, |
595 | records, | 604 | records, |
596 | failures, | 605 | failures, |
597 | pending); | 606 | pending); |
598 | return 0; | 607 | return 0; |
599 | } | 608 | } |
diff --git a/src/dns/plugin_block_dns.c b/src/dns/plugin_block_dns.c index ed75ce2f3..fd4d844c5 100644 --- a/src/dns/plugin_block_dns.c +++ b/src/dns/plugin_block_dns.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file dns/plugin_block_dns.c | 22 | * @file dns/plugin_block_dns.c |
@@ -54,37 +54,37 @@ | |||
54 | * by this @a type of block (this is not an error) | 54 | * by this @a type of block (this is not an error) |
55 | */ | 55 | */ |
56 | static struct GNUNET_BLOCK_Group * | 56 | static struct GNUNET_BLOCK_Group * |
57 | block_plugin_dns_create_group (void *cls, | 57 | block_plugin_dns_create_group(void *cls, |
58 | enum GNUNET_BLOCK_Type type, | 58 | enum GNUNET_BLOCK_Type type, |
59 | uint32_t nonce, | 59 | uint32_t nonce, |
60 | const void *raw_data, | 60 | const void *raw_data, |
61 | size_t raw_data_size, | 61 | size_t raw_data_size, |
62 | va_list va) | 62 | va_list va) |
63 | { | 63 | { |
64 | unsigned int bf_size; | 64 | unsigned int bf_size; |
65 | const char *guard; | 65 | const char *guard; |
66 | 66 | ||
67 | guard = va_arg (va, const char *); | 67 | guard = va_arg(va, const char *); |
68 | if (0 == strcmp (guard, | 68 | if (0 == strcmp(guard, |
69 | "seen-set-size")) | 69 | "seen-set-size")) |
70 | bf_size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size (va_arg (va, unsigned int), | 70 | bf_size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size(va_arg(va, unsigned int), |
71 | BLOOMFILTER_K); | 71 | BLOOMFILTER_K); |
72 | else if (0 == strcmp (guard, | 72 | else if (0 == strcmp(guard, |
73 | "filter-size")) | 73 | "filter-size")) |
74 | bf_size = va_arg (va, unsigned int); | 74 | bf_size = va_arg(va, unsigned int); |
75 | else | 75 | else |
76 | { | 76 | { |
77 | GNUNET_break (0); | 77 | GNUNET_break(0); |
78 | bf_size = 8; | 78 | bf_size = 8; |
79 | } | 79 | } |
80 | GNUNET_break (NULL == va_arg (va, const char *)); | 80 | GNUNET_break(NULL == va_arg(va, const char *)); |
81 | return GNUNET_BLOCK_GROUP_bf_create (cls, | 81 | return GNUNET_BLOCK_GROUP_bf_create(cls, |
82 | bf_size, | 82 | bf_size, |
83 | BLOOMFILTER_K, | 83 | BLOOMFILTER_K, |
84 | type, | 84 | type, |
85 | nonce, | 85 | nonce, |
86 | raw_data, | 86 | raw_data, |
87 | raw_data_size); | 87 | raw_data_size); |
88 | } | 88 | } |
89 | 89 | ||
90 | 90 | ||
@@ -105,71 +105,72 @@ block_plugin_dns_create_group (void *cls, | |||
105 | * @return characterization of result | 105 | * @return characterization of result |
106 | */ | 106 | */ |
107 | static enum GNUNET_BLOCK_EvaluationResult | 107 | static enum GNUNET_BLOCK_EvaluationResult |
108 | block_plugin_dns_evaluate (void *cls, | 108 | block_plugin_dns_evaluate(void *cls, |
109 | struct GNUNET_BLOCK_Context *ctx, | 109 | struct GNUNET_BLOCK_Context *ctx, |
110 | enum GNUNET_BLOCK_Type type, | 110 | enum GNUNET_BLOCK_Type type, |
111 | struct GNUNET_BLOCK_Group *bg, | 111 | struct GNUNET_BLOCK_Group *bg, |
112 | enum GNUNET_BLOCK_EvaluationOptions eo, | 112 | enum GNUNET_BLOCK_EvaluationOptions eo, |
113 | const struct GNUNET_HashCode * query, | 113 | const struct GNUNET_HashCode * query, |
114 | const void *xquery, | 114 | const void *xquery, |
115 | size_t xquery_size, | 115 | size_t xquery_size, |
116 | const void *reply_block, | 116 | const void *reply_block, |
117 | size_t reply_block_size) | 117 | size_t reply_block_size) |
118 | { | 118 | { |
119 | const struct GNUNET_DNS_Advertisement *ad; | 119 | const struct GNUNET_DNS_Advertisement *ad; |
120 | struct GNUNET_HashCode phash; | 120 | struct GNUNET_HashCode phash; |
121 | 121 | ||
122 | switch (type) | 122 | switch (type) |
123 | { | ||
124 | case GNUNET_BLOCK_TYPE_DNS: | ||
125 | if (0 != xquery_size) | ||
126 | return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID; | ||
127 | |||
128 | if (NULL == reply_block) | ||
129 | return GNUNET_BLOCK_EVALUATION_REQUEST_VALID; | ||
130 | |||
131 | if (sizeof (struct GNUNET_DNS_Advertisement) != reply_block_size) | ||
132 | { | ||
133 | GNUNET_break_op (0); | ||
134 | return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; | ||
135 | } | ||
136 | ad = reply_block; | ||
137 | |||
138 | if (ntohl (ad->purpose.size) != | ||
139 | sizeof (struct GNUNET_DNS_Advertisement) - | ||
140 | sizeof (struct GNUNET_CRYPTO_EddsaSignature)) | ||
141 | { | ||
142 | GNUNET_break_op (0); | ||
143 | return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; | ||
144 | } | ||
145 | if (0 == | ||
146 | GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_ntoh | ||
147 | (ad->expiration_time)).rel_value_us) | ||
148 | { | ||
149 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
150 | "DNS advertisement has expired\n"); | ||
151 | return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; | ||
152 | } | ||
153 | if (GNUNET_OK != | ||
154 | GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_DNS_RECORD, | ||
155 | &ad->purpose, | ||
156 | &ad->signature, | ||
157 | &ad->peer.public_key)) | ||
158 | { | 123 | { |
159 | GNUNET_break_op (0); | 124 | case GNUNET_BLOCK_TYPE_DNS: |
160 | return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; | 125 | if (0 != xquery_size) |
126 | return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID; | ||
127 | |||
128 | if (NULL == reply_block) | ||
129 | return GNUNET_BLOCK_EVALUATION_REQUEST_VALID; | ||
130 | |||
131 | if (sizeof(struct GNUNET_DNS_Advertisement) != reply_block_size) | ||
132 | { | ||
133 | GNUNET_break_op(0); | ||
134 | return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; | ||
135 | } | ||
136 | ad = reply_block; | ||
137 | |||
138 | if (ntohl(ad->purpose.size) != | ||
139 | sizeof(struct GNUNET_DNS_Advertisement) - | ||
140 | sizeof(struct GNUNET_CRYPTO_EddsaSignature)) | ||
141 | { | ||
142 | GNUNET_break_op(0); | ||
143 | return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; | ||
144 | } | ||
145 | if (0 == | ||
146 | GNUNET_TIME_absolute_get_remaining(GNUNET_TIME_absolute_ntoh | ||
147 | (ad->expiration_time)).rel_value_us) | ||
148 | { | ||
149 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
150 | "DNS advertisement has expired\n"); | ||
151 | return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; | ||
152 | } | ||
153 | if (GNUNET_OK != | ||
154 | GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_PURPOSE_DNS_RECORD, | ||
155 | &ad->purpose, | ||
156 | &ad->signature, | ||
157 | &ad->peer.public_key)) | ||
158 | { | ||
159 | GNUNET_break_op(0); | ||
160 | return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; | ||
161 | } | ||
162 | GNUNET_CRYPTO_hash(reply_block, | ||
163 | reply_block_size, | ||
164 | &phash); | ||
165 | if (GNUNET_YES == | ||
166 | GNUNET_BLOCK_GROUP_bf_test_and_set(bg, | ||
167 | &phash)) | ||
168 | return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE; | ||
169 | return GNUNET_BLOCK_EVALUATION_OK_MORE; | ||
170 | |||
171 | default: | ||
172 | return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED; | ||
161 | } | 173 | } |
162 | GNUNET_CRYPTO_hash (reply_block, | ||
163 | reply_block_size, | ||
164 | &phash); | ||
165 | if (GNUNET_YES == | ||
166 | GNUNET_BLOCK_GROUP_bf_test_and_set (bg, | ||
167 | &phash)) | ||
168 | return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE; | ||
169 | return GNUNET_BLOCK_EVALUATION_OK_MORE; | ||
170 | default: | ||
171 | return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED; | ||
172 | } | ||
173 | } | 174 | } |
174 | 175 | ||
175 | 176 | ||
@@ -185,11 +186,11 @@ block_plugin_dns_evaluate (void *cls, | |||
185 | * (or if extracting a key from a block of this type does not work) | 186 | * (or if extracting a key from a block of this type does not work) |
186 | */ | 187 | */ |
187 | static int | 188 | static int |
188 | block_plugin_dns_get_key (void *cls, | 189 | block_plugin_dns_get_key(void *cls, |
189 | enum GNUNET_BLOCK_Type type, | 190 | enum GNUNET_BLOCK_Type type, |
190 | const void *block, | 191 | const void *block, |
191 | size_t block_size, | 192 | size_t block_size, |
192 | struct GNUNET_HashCode *key) | 193 | struct GNUNET_HashCode *key) |
193 | { | 194 | { |
194 | /* we cannot extract a key from a block of this type */ | 195 | /* we cannot extract a key from a block of this type */ |
195 | return GNUNET_SYSERR; | 196 | return GNUNET_SYSERR; |
@@ -200,7 +201,7 @@ block_plugin_dns_get_key (void *cls, | |||
200 | * Entry point for the plugin. | 201 | * Entry point for the plugin. |
201 | */ | 202 | */ |
202 | void * | 203 | void * |
203 | libgnunet_plugin_block_dns_init (void *cls) | 204 | libgnunet_plugin_block_dns_init(void *cls) |
204 | { | 205 | { |
205 | static enum GNUNET_BLOCK_Type types[] = | 206 | static enum GNUNET_BLOCK_Type types[] = |
206 | { | 207 | { |
@@ -209,7 +210,7 @@ libgnunet_plugin_block_dns_init (void *cls) | |||
209 | }; | 210 | }; |
210 | struct GNUNET_BLOCK_PluginFunctions *api; | 211 | struct GNUNET_BLOCK_PluginFunctions *api; |
211 | 212 | ||
212 | api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions); | 213 | api = GNUNET_new(struct GNUNET_BLOCK_PluginFunctions); |
213 | api->evaluate = &block_plugin_dns_evaluate; | 214 | api->evaluate = &block_plugin_dns_evaluate; |
214 | api->get_key = &block_plugin_dns_get_key; | 215 | api->get_key = &block_plugin_dns_get_key; |
215 | api->create_group = &block_plugin_dns_create_group; | 216 | api->create_group = &block_plugin_dns_create_group; |
@@ -222,11 +223,11 @@ libgnunet_plugin_block_dns_init (void *cls) | |||
222 | * Exit point from the plugin. | 223 | * Exit point from the plugin. |
223 | */ | 224 | */ |
224 | void * | 225 | void * |
225 | libgnunet_plugin_block_dns_done (void *cls) | 226 | libgnunet_plugin_block_dns_done(void *cls) |
226 | { | 227 | { |
227 | struct GNUNET_BLOCK_PluginFunctions *api = cls; | 228 | struct GNUNET_BLOCK_PluginFunctions *api = cls; |
228 | 229 | ||
229 | GNUNET_free (api); | 230 | GNUNET_free(api); |
230 | return NULL; | 231 | return NULL; |
231 | } | 232 | } |
232 | 233 | ||