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/gns/gnunet-dns2gns.c | |
parent | a0fce305c565c0937d917a92712f15e9c5736260 (diff) | |
download | gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.tar.gz gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.zip |
uncrustify as demanded.
Diffstat (limited to 'src/gns/gnunet-dns2gns.c')
-rw-r--r-- | src/gns/gnunet-dns2gns.c | 791 |
1 files changed, 397 insertions, 394 deletions
diff --git a/src/gns/gnunet-dns2gns.c b/src/gns/gnunet-dns2gns.c index d2eabf02c..4058aba99 100644 --- a/src/gns/gnunet-dns2gns.c +++ b/src/gns/gnunet-dns2gns.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 | * @file gnunet-dns2gns.c | 21 | * @file gnunet-dns2gns.c |
22 | * @brief DNS server that translates DNS requests to GNS | 22 | * @brief DNS server that translates DNS requests to GNS |
@@ -37,8 +37,7 @@ | |||
37 | /** | 37 | /** |
38 | * Data kept per request. | 38 | * Data kept per request. |
39 | */ | 39 | */ |
40 | struct Request | 40 | struct Request { |
41 | { | ||
42 | /** | 41 | /** |
43 | * Socket to use for sending the reply. | 42 | * Socket to use for sending the reply. |
44 | */ | 43 | */ |
@@ -156,39 +155,39 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg; | |||
156 | * @param cls unused | 155 | * @param cls unused |
157 | */ | 156 | */ |
158 | static void | 157 | static void |
159 | do_shutdown (void *cls) | 158 | do_shutdown(void *cls) |
160 | { | 159 | { |
161 | (void) cls; | 160 | (void)cls; |
162 | if (NULL != t4) | 161 | if (NULL != t4) |
163 | { | 162 | { |
164 | GNUNET_SCHEDULER_cancel (t4); | 163 | GNUNET_SCHEDULER_cancel(t4); |
165 | t4 = NULL; | 164 | t4 = NULL; |
166 | } | 165 | } |
167 | if (NULL != t6) | 166 | if (NULL != t6) |
168 | { | 167 | { |
169 | GNUNET_SCHEDULER_cancel (t6); | 168 | GNUNET_SCHEDULER_cancel(t6); |
170 | t6 = NULL; | 169 | t6 = NULL; |
171 | } | 170 | } |
172 | if (NULL != listen_socket4) | 171 | if (NULL != listen_socket4) |
173 | { | 172 | { |
174 | GNUNET_NETWORK_socket_close (listen_socket4); | 173 | GNUNET_NETWORK_socket_close(listen_socket4); |
175 | listen_socket4 = NULL; | 174 | listen_socket4 = NULL; |
176 | } | 175 | } |
177 | if (NULL != listen_socket6) | 176 | if (NULL != listen_socket6) |
178 | { | 177 | { |
179 | GNUNET_NETWORK_socket_close (listen_socket6); | 178 | GNUNET_NETWORK_socket_close(listen_socket6); |
180 | listen_socket6 = NULL; | 179 | listen_socket6 = NULL; |
181 | } | 180 | } |
182 | if (NULL != gns) | 181 | if (NULL != gns) |
183 | { | 182 | { |
184 | GNUNET_GNS_disconnect (gns); | 183 | GNUNET_GNS_disconnect(gns); |
185 | gns = NULL; | 184 | gns = NULL; |
186 | } | 185 | } |
187 | if (NULL != dns_stub) | 186 | if (NULL != dns_stub) |
188 | { | 187 | { |
189 | GNUNET_DNSSTUB_stop (dns_stub); | 188 | GNUNET_DNSSTUB_stop(dns_stub); |
190 | dns_stub = NULL; | 189 | dns_stub = NULL; |
191 | } | 190 | } |
192 | } | 191 | } |
193 | 192 | ||
194 | 193 | ||
@@ -198,38 +197,38 @@ do_shutdown (void *cls) | |||
198 | * @param request context for the request. | 197 | * @param request context for the request. |
199 | */ | 198 | */ |
200 | static void | 199 | static void |
201 | send_response (struct Request *request) | 200 | send_response(struct Request *request) |
202 | { | 201 | { |
203 | char *buf; | 202 | char *buf; |
204 | size_t size; | 203 | size_t size; |
205 | ssize_t sret; | 204 | ssize_t sret; |
206 | 205 | ||
207 | if (GNUNET_SYSERR == | 206 | if (GNUNET_SYSERR == |
208 | GNUNET_DNSPARSER_pack (request->packet, | 207 | GNUNET_DNSPARSER_pack(request->packet, |
209 | UINT16_MAX /* is this not too much? */, | 208 | UINT16_MAX /* is this not too much? */, |
210 | &buf, | 209 | &buf, |
211 | &size)) | 210 | &size)) |
212 | { | 211 | { |
213 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 212 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, |
214 | _("Failed to pack DNS response into UDP packet!\n")); | 213 | _("Failed to pack DNS response into UDP packet!\n")); |
215 | } | 214 | } |
216 | else | 215 | else |
217 | { | 216 | { |
218 | sret = GNUNET_NETWORK_socket_sendto (request->lsock, | 217 | sret = GNUNET_NETWORK_socket_sendto(request->lsock, |
219 | buf, | 218 | buf, |
220 | size, | 219 | size, |
221 | request->addr, | 220 | request->addr, |
222 | request->addr_len); | 221 | request->addr_len); |
223 | if ( (sret < 0) || | 222 | if ((sret < 0) || |
224 | (size != (size_t) sret) ) | 223 | (size != (size_t)sret)) |
225 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, | 224 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, |
226 | "sendto"); | 225 | "sendto"); |
227 | GNUNET_free (buf); | 226 | GNUNET_free(buf); |
228 | } | 227 | } |
229 | GNUNET_SCHEDULER_cancel (request->timeout_task); | 228 | GNUNET_SCHEDULER_cancel(request->timeout_task); |
230 | GNUNET_DNSPARSER_free_packet (request->packet); | 229 | GNUNET_DNSPARSER_free_packet(request->packet); |
231 | GNUNET_free (request->udp_msg); | 230 | GNUNET_free(request->udp_msg); |
232 | GNUNET_free (request); | 231 | GNUNET_free(request); |
233 | } | 232 | } |
234 | 233 | ||
235 | 234 | ||
@@ -239,18 +238,18 @@ send_response (struct Request *request) | |||
239 | * @param cls `struct Request *` of the request to clean up | 238 | * @param cls `struct Request *` of the request to clean up |
240 | */ | 239 | */ |
241 | static void | 240 | static void |
242 | do_timeout (void *cls) | 241 | do_timeout(void *cls) |
243 | { | 242 | { |
244 | struct Request *request = cls; | 243 | struct Request *request = cls; |
245 | 244 | ||
246 | if (NULL != request->packet) | 245 | if (NULL != request->packet) |
247 | GNUNET_DNSPARSER_free_packet (request->packet); | 246 | GNUNET_DNSPARSER_free_packet(request->packet); |
248 | if (NULL != request->lookup) | 247 | if (NULL != request->lookup) |
249 | GNUNET_GNS_lookup_with_tld_cancel (request->lookup); | 248 | GNUNET_GNS_lookup_with_tld_cancel(request->lookup); |
250 | if (NULL != request->dns_lookup) | 249 | if (NULL != request->dns_lookup) |
251 | GNUNET_DNSSTUB_resolve_cancel (request->dns_lookup); | 250 | GNUNET_DNSSTUB_resolve_cancel(request->dns_lookup); |
252 | GNUNET_free (request->udp_msg); | 251 | GNUNET_free(request->udp_msg); |
253 | GNUNET_free (request); | 252 | GNUNET_free(request); |
254 | } | 253 | } |
255 | 254 | ||
256 | 255 | ||
@@ -262,28 +261,28 @@ do_timeout (void *cls) | |||
262 | * @param r size of the DNS payload | 261 | * @param r size of the DNS payload |
263 | */ | 262 | */ |
264 | static void | 263 | static void |
265 | dns_result_processor (void *cls, | 264 | dns_result_processor(void *cls, |
266 | const struct GNUNET_TUN_DnsHeader *dns, | 265 | const struct GNUNET_TUN_DnsHeader *dns, |
267 | size_t r) | 266 | size_t r) |
268 | { | 267 | { |
269 | struct Request *request = cls; | 268 | struct Request *request = cls; |
270 | 269 | ||
271 | if (NULL == dns) | 270 | if (NULL == dns) |
272 | { | 271 | { |
273 | /* DNSSTUB gave up, so we trigger timeout early */ | 272 | /* DNSSTUB gave up, so we trigger timeout early */ |
274 | GNUNET_SCHEDULER_cancel (request->timeout_task); | 273 | GNUNET_SCHEDULER_cancel(request->timeout_task); |
275 | do_timeout (request); | 274 | do_timeout(request); |
276 | return; | 275 | return; |
277 | } | 276 | } |
278 | if (request->original_request_id != dns->id) | 277 | if (request->original_request_id != dns->id) |
279 | { | 278 | { |
280 | /* for a another query, ignore */ | 279 | /* for a another query, ignore */ |
281 | return; | 280 | return; |
282 | } | 281 | } |
283 | request->packet = GNUNET_DNSPARSER_parse ((char*)dns, | 282 | request->packet = GNUNET_DNSPARSER_parse((char*)dns, |
284 | r); | 283 | r); |
285 | GNUNET_DNSSTUB_resolve_cancel (request->dns_lookup); | 284 | GNUNET_DNSSTUB_resolve_cancel(request->dns_lookup); |
286 | send_response (request); | 285 | send_response(request); |
287 | } | 286 | } |
288 | 287 | ||
289 | 288 | ||
@@ -296,10 +295,10 @@ dns_result_processor (void *cls, | |||
296 | * @param rd the records in reply | 295 | * @param rd the records in reply |
297 | */ | 296 | */ |
298 | static void | 297 | static void |
299 | result_processor (void *cls, | 298 | result_processor(void *cls, |
300 | int was_gns, | 299 | int was_gns, |
301 | uint32_t rd_count, | 300 | uint32_t rd_count, |
302 | const struct GNUNET_GNSRECORD_Data *rd) | 301 | const struct GNUNET_GNSRECORD_Data *rd) |
303 | { | 302 | { |
304 | struct Request *request = cls; | 303 | struct Request *request = cls; |
305 | struct GNUNET_DNSPARSER_Packet *packet; | 304 | struct GNUNET_DNSPARSER_Packet *packet; |
@@ -307,22 +306,22 @@ result_processor (void *cls, | |||
307 | 306 | ||
308 | request->lookup = NULL; | 307 | request->lookup = NULL; |
309 | if (GNUNET_NO == was_gns) | 308 | if (GNUNET_NO == was_gns) |
310 | { | 309 | { |
311 | /* TLD not configured for GNS, fall back to DNS */ | 310 | /* TLD not configured for GNS, fall back to DNS */ |
312 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 311 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
313 | "Using DNS resolver IP `%s' to resolve `%s'\n", | 312 | "Using DNS resolver IP `%s' to resolve `%s'\n", |
314 | dns_ip, | 313 | dns_ip, |
315 | request->packet->queries[0].name); | 314 | request->packet->queries[0].name); |
316 | request->original_request_id = request->packet->id; | 315 | request->original_request_id = request->packet->id; |
317 | GNUNET_DNSPARSER_free_packet (request->packet); | 316 | GNUNET_DNSPARSER_free_packet(request->packet); |
318 | request->packet = NULL; | 317 | request->packet = NULL; |
319 | request->dns_lookup = GNUNET_DNSSTUB_resolve (dns_stub, | 318 | request->dns_lookup = GNUNET_DNSSTUB_resolve(dns_stub, |
320 | request->udp_msg, | 319 | request->udp_msg, |
321 | request->udp_msg_size, | 320 | request->udp_msg_size, |
322 | &dns_result_processor, | 321 | &dns_result_processor, |
323 | request); | 322 | request); |
324 | return; | 323 | return; |
325 | } | 324 | } |
326 | packet = request->packet; | 325 | packet = request->packet; |
327 | packet->flags.query_or_response = 1; | 326 | packet->flags.query_or_response = 1; |
328 | packet->flags.return_code = GNUNET_TUN_DNS_RETURN_CODE_NO_ERROR; | 327 | packet->flags.return_code = GNUNET_TUN_DNS_RETURN_CODE_NO_ERROR; |
@@ -333,59 +332,62 @@ result_processor (void *cls, | |||
333 | packet->flags.message_truncated = 0; | 332 | packet->flags.message_truncated = 0; |
334 | packet->flags.authoritative_answer = 0; | 333 | packet->flags.authoritative_answer = 0; |
335 | //packet->flags.opcode = GNUNET_TUN_DNS_OPCODE_STATUS; // ??? | 334 | //packet->flags.opcode = GNUNET_TUN_DNS_OPCODE_STATUS; // ??? |
336 | for (uint32_t i=0;i<rd_count;i++) | 335 | for (uint32_t i = 0; i < rd_count; i++) |
337 | { | 336 | { |
338 | // FIXME: do we need to hanlde #GNUNET_GNSRECORD_RF_SHADOW_RECORD | 337 | // FIXME: do we need to hanlde #GNUNET_GNSRECORD_RF_SHADOW_RECORD |
339 | // here? Or should we do this in libgnunetgns? | 338 | // here? Or should we do this in libgnunetgns? |
340 | rec.expiration_time.abs_value_us = rd[i].expiration_time; | 339 | rec.expiration_time.abs_value_us = rd[i].expiration_time; |
341 | switch (rd[i].record_type) | 340 | switch (rd[i].record_type) |
342 | { | 341 | { |
343 | case GNUNET_DNSPARSER_TYPE_A: | 342 | case GNUNET_DNSPARSER_TYPE_A: |
344 | GNUNET_assert (sizeof (struct in_addr) == rd[i].data_size); | 343 | GNUNET_assert(sizeof(struct in_addr) == rd[i].data_size); |
345 | rec.name = GNUNET_strdup (packet->queries[0].name); | 344 | rec.name = GNUNET_strdup(packet->queries[0].name); |
346 | rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; | 345 | rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; |
347 | rec.type = GNUNET_DNSPARSER_TYPE_A; | 346 | rec.type = GNUNET_DNSPARSER_TYPE_A; |
348 | rec.data.raw.data = GNUNET_new (struct in_addr); | 347 | rec.data.raw.data = GNUNET_new(struct in_addr); |
349 | GNUNET_memcpy (rec.data.raw.data, | 348 | GNUNET_memcpy(rec.data.raw.data, |
350 | rd[i].data, | 349 | rd[i].data, |
351 | rd[i].data_size); | 350 | rd[i].data_size); |
352 | rec.data.raw.data_len = sizeof (struct in_addr); | 351 | rec.data.raw.data_len = sizeof(struct in_addr); |
353 | GNUNET_array_append (packet->answers, | 352 | GNUNET_array_append(packet->answers, |
354 | packet->num_answers, | 353 | packet->num_answers, |
355 | rec); | 354 | rec); |
356 | break; | 355 | break; |
357 | case GNUNET_DNSPARSER_TYPE_AAAA: | 356 | |
358 | GNUNET_assert (sizeof (struct in6_addr) == rd[i].data_size); | 357 | case GNUNET_DNSPARSER_TYPE_AAAA: |
359 | rec.name = GNUNET_strdup (packet->queries[0].name); | 358 | GNUNET_assert(sizeof(struct in6_addr) == rd[i].data_size); |
360 | rec.data.raw.data = GNUNET_new (struct in6_addr); | 359 | rec.name = GNUNET_strdup(packet->queries[0].name); |
361 | rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; | 360 | rec.data.raw.data = GNUNET_new(struct in6_addr); |
362 | rec.type = GNUNET_DNSPARSER_TYPE_AAAA; | 361 | rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; |
363 | GNUNET_memcpy (rec.data.raw.data, | 362 | rec.type = GNUNET_DNSPARSER_TYPE_AAAA; |
364 | rd[i].data, | 363 | GNUNET_memcpy(rec.data.raw.data, |
365 | rd[i].data_size); | 364 | rd[i].data, |
366 | rec.data.raw.data_len = sizeof (struct in6_addr); | 365 | rd[i].data_size); |
367 | GNUNET_array_append (packet->answers, | 366 | rec.data.raw.data_len = sizeof(struct in6_addr); |
368 | packet->num_answers, | 367 | GNUNET_array_append(packet->answers, |
369 | rec); | 368 | packet->num_answers, |
370 | break; | 369 | rec); |
371 | case GNUNET_DNSPARSER_TYPE_CNAME: | 370 | break; |
372 | rec.name = GNUNET_strdup (packet->queries[0].name); | 371 | |
373 | rec.data.hostname = GNUNET_strdup (rd[i].data); | 372 | case GNUNET_DNSPARSER_TYPE_CNAME: |
374 | rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; | 373 | rec.name = GNUNET_strdup(packet->queries[0].name); |
375 | rec.type = GNUNET_DNSPARSER_TYPE_CNAME; | 374 | rec.data.hostname = GNUNET_strdup(rd[i].data); |
376 | GNUNET_memcpy (rec.data.hostname, | 375 | rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; |
377 | rd[i].data, | 376 | rec.type = GNUNET_DNSPARSER_TYPE_CNAME; |
378 | rd[i].data_size); | 377 | GNUNET_memcpy(rec.data.hostname, |
379 | GNUNET_array_append (packet->answers, | 378 | rd[i].data, |
380 | packet->num_answers, | 379 | rd[i].data_size); |
381 | rec); | 380 | GNUNET_array_append(packet->answers, |
382 | break; | 381 | packet->num_answers, |
383 | default: | 382 | rec); |
384 | /* skip */ | 383 | break; |
385 | break; | 384 | |
386 | } | 385 | default: |
386 | /* skip */ | ||
387 | break; | ||
388 | } | ||
387 | } | 389 | } |
388 | send_response (request); | 390 | send_response(request); |
389 | } | 391 | } |
390 | 392 | ||
391 | 393 | ||
@@ -399,73 +401,73 @@ result_processor (void *cls, | |||
399 | * @param udp_msg_size number of bytes in @a udp_msg | 401 | * @param udp_msg_size number of bytes in @a udp_msg |
400 | */ | 402 | */ |
401 | static void | 403 | static void |
402 | handle_request (struct GNUNET_NETWORK_Handle *lsock, | 404 | handle_request(struct GNUNET_NETWORK_Handle *lsock, |
403 | const void *addr, | 405 | const void *addr, |
404 | size_t addr_len, | 406 | size_t addr_len, |
405 | const char *udp_msg, | 407 | const char *udp_msg, |
406 | size_t udp_msg_size) | 408 | size_t udp_msg_size) |
407 | { | 409 | { |
408 | struct Request *request; | 410 | struct Request *request; |
409 | struct GNUNET_DNSPARSER_Packet *packet; | 411 | struct GNUNET_DNSPARSER_Packet *packet; |
410 | 412 | ||
411 | packet = GNUNET_DNSPARSER_parse (udp_msg, | 413 | packet = GNUNET_DNSPARSER_parse(udp_msg, |
412 | udp_msg_size); | 414 | udp_msg_size); |
413 | if (NULL == packet) | 415 | if (NULL == packet) |
414 | { | 416 | { |
415 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 417 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, |
416 | _("Cannot parse DNS request from %s\n"), | 418 | _("Cannot parse DNS request from %s\n"), |
417 | GNUNET_a2s (addr, addr_len)); | 419 | GNUNET_a2s(addr, addr_len)); |
418 | return; | 420 | return; |
419 | } | 421 | } |
420 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 422 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
421 | "Received request for `%s' with flags %u, #answers %d, #auth %d, #additional %d\n", | 423 | "Received request for `%s' with flags %u, #answers %d, #auth %d, #additional %d\n", |
422 | packet->queries[0].name, | 424 | packet->queries[0].name, |
423 | (unsigned int) packet->flags.query_or_response, | 425 | (unsigned int)packet->flags.query_or_response, |
424 | (int) packet->num_answers, | 426 | (int)packet->num_answers, |
425 | (int) packet->num_authority_records, | 427 | (int)packet->num_authority_records, |
426 | (int) packet->num_additional_records); | 428 | (int)packet->num_additional_records); |
427 | if ( (0 != packet->flags.query_or_response) || | 429 | if ((0 != packet->flags.query_or_response) || |
428 | (0 != packet->num_answers) || | 430 | (0 != packet->num_answers) || |
429 | (0 != packet->num_authority_records)) | 431 | (0 != packet->num_authority_records)) |
430 | { | 432 | { |
431 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 433 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, |
432 | _("Received malformed DNS request from %s\n"), | 434 | _("Received malformed DNS request from %s\n"), |
433 | GNUNET_a2s (addr, addr_len)); | 435 | GNUNET_a2s(addr, addr_len)); |
434 | GNUNET_DNSPARSER_free_packet (packet); | 436 | GNUNET_DNSPARSER_free_packet(packet); |
435 | return; | 437 | return; |
436 | } | 438 | } |
437 | if ( (1 != packet->num_queries) ) | 439 | if ((1 != packet->num_queries)) |
438 | { | 440 | { |
439 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 441 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, |
440 | _("Received unsupported DNS request from %s\n"), | 442 | _("Received unsupported DNS request from %s\n"), |
441 | GNUNET_a2s (addr, | 443 | GNUNET_a2s(addr, |
442 | addr_len)); | 444 | addr_len)); |
443 | GNUNET_DNSPARSER_free_packet (packet); | 445 | GNUNET_DNSPARSER_free_packet(packet); |
444 | return; | 446 | return; |
445 | } | 447 | } |
446 | request = GNUNET_malloc (sizeof (struct Request) + addr_len); | 448 | request = GNUNET_malloc(sizeof(struct Request) + addr_len); |
447 | request->lsock = lsock; | 449 | request->lsock = lsock; |
448 | request->packet = packet; | 450 | request->packet = packet; |
449 | request->addr = &request[1]; | 451 | request->addr = &request[1]; |
450 | request->addr_len = addr_len; | 452 | request->addr_len = addr_len; |
451 | GNUNET_memcpy (&request[1], | 453 | GNUNET_memcpy(&request[1], |
452 | addr, | 454 | addr, |
453 | addr_len); | 455 | addr_len); |
454 | request->udp_msg_size = udp_msg_size; | 456 | request->udp_msg_size = udp_msg_size; |
455 | request->udp_msg = GNUNET_memdup (udp_msg, | 457 | request->udp_msg = GNUNET_memdup(udp_msg, |
456 | udp_msg_size); | 458 | udp_msg_size); |
457 | request->timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, | 459 | request->timeout_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT, |
458 | &do_timeout, | 460 | &do_timeout, |
459 | request); | 461 | request); |
460 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 462 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
461 | "Calling GNS on `%s'\n", | 463 | "Calling GNS on `%s'\n", |
462 | packet->queries[0].name); | 464 | packet->queries[0].name); |
463 | request->lookup = GNUNET_GNS_lookup_with_tld (gns, | 465 | request->lookup = GNUNET_GNS_lookup_with_tld(gns, |
464 | packet->queries[0].name, | 466 | packet->queries[0].name, |
465 | packet->queries[0].type, | 467 | packet->queries[0].type, |
466 | GNUNET_NO, | 468 | GNUNET_NO, |
467 | &result_processor, | 469 | &result_processor, |
468 | request); | 470 | request); |
469 | } | 471 | } |
470 | 472 | ||
471 | 473 | ||
@@ -475,49 +477,49 @@ handle_request (struct GNUNET_NETWORK_Handle *lsock, | |||
475 | * @param cls the 'listen_socket4' | 477 | * @param cls the 'listen_socket4' |
476 | */ | 478 | */ |
477 | static void | 479 | static void |
478 | read_dns4 (void *cls) | 480 | read_dns4(void *cls) |
479 | { | 481 | { |
480 | struct sockaddr_in v4; | 482 | struct sockaddr_in v4; |
481 | socklen_t addrlen; | 483 | socklen_t addrlen; |
482 | ssize_t size; | 484 | ssize_t size; |
483 | const struct GNUNET_SCHEDULER_TaskContext *tc; | 485 | const struct GNUNET_SCHEDULER_TaskContext *tc; |
484 | 486 | ||
485 | GNUNET_assert (listen_socket4 == cls); | 487 | GNUNET_assert(listen_socket4 == cls); |
486 | t4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 488 | t4 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, |
487 | listen_socket4, | 489 | listen_socket4, |
488 | &read_dns4, | 490 | &read_dns4, |
489 | listen_socket4); | 491 | listen_socket4); |
490 | tc = GNUNET_SCHEDULER_get_task_context (); | 492 | tc = GNUNET_SCHEDULER_get_task_context(); |
491 | if (0 == (GNUNET_SCHEDULER_REASON_READ_READY & tc->reason)) | 493 | if (0 == (GNUNET_SCHEDULER_REASON_READ_READY & tc->reason)) |
492 | return; /* shutdown? */ | 494 | return; /* shutdown? */ |
493 | size = GNUNET_NETWORK_socket_recvfrom_amount (listen_socket4); | 495 | size = GNUNET_NETWORK_socket_recvfrom_amount(listen_socket4); |
494 | if (0 > size) | 496 | if (0 > size) |
495 | { | 497 | { |
496 | GNUNET_break (0); | 498 | GNUNET_break(0); |
497 | return; /* read error!? */ | 499 | return; /* read error!? */ |
498 | } | 500 | } |
499 | { | 501 | { |
500 | char buf[size + 1]; | 502 | char buf[size + 1]; |
501 | ssize_t sret; | 503 | ssize_t sret; |
502 | 504 | ||
503 | addrlen = sizeof (v4); | 505 | addrlen = sizeof(v4); |
504 | sret = GNUNET_NETWORK_socket_recvfrom (listen_socket4, | 506 | sret = GNUNET_NETWORK_socket_recvfrom(listen_socket4, |
505 | buf, | 507 | buf, |
506 | size + 1, | 508 | size + 1, |
507 | (struct sockaddr *) &v4, | 509 | (struct sockaddr *)&v4, |
508 | &addrlen); | 510 | &addrlen); |
509 | if (0 > sret) | 511 | if (0 > sret) |
510 | { | 512 | { |
511 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, | 513 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, |
512 | "recvfrom"); | 514 | "recvfrom"); |
513 | return; | 515 | return; |
514 | } | 516 | } |
515 | GNUNET_break (size == sret); | 517 | GNUNET_break(size == sret); |
516 | handle_request (listen_socket4, | 518 | handle_request(listen_socket4, |
517 | &v4, | 519 | &v4, |
518 | addrlen, | 520 | addrlen, |
519 | buf, | 521 | buf, |
520 | size); | 522 | size); |
521 | } | 523 | } |
522 | } | 524 | } |
523 | 525 | ||
@@ -528,49 +530,49 @@ read_dns4 (void *cls) | |||
528 | * @param cls the 'listen_socket6' | 530 | * @param cls the 'listen_socket6' |
529 | */ | 531 | */ |
530 | static void | 532 | static void |
531 | read_dns6 (void *cls) | 533 | read_dns6(void *cls) |
532 | { | 534 | { |
533 | struct sockaddr_in6 v6; | 535 | struct sockaddr_in6 v6; |
534 | socklen_t addrlen; | 536 | socklen_t addrlen; |
535 | ssize_t size; | 537 | ssize_t size; |
536 | const struct GNUNET_SCHEDULER_TaskContext *tc; | 538 | const struct GNUNET_SCHEDULER_TaskContext *tc; |
537 | 539 | ||
538 | GNUNET_assert (listen_socket6 == cls); | 540 | GNUNET_assert(listen_socket6 == cls); |
539 | t6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 541 | t6 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, |
540 | listen_socket6, | 542 | listen_socket6, |
541 | &read_dns6, | 543 | &read_dns6, |
542 | listen_socket6); | 544 | listen_socket6); |
543 | tc = GNUNET_SCHEDULER_get_task_context (); | 545 | tc = GNUNET_SCHEDULER_get_task_context(); |
544 | if (0 == (GNUNET_SCHEDULER_REASON_READ_READY & tc->reason)) | 546 | if (0 == (GNUNET_SCHEDULER_REASON_READ_READY & tc->reason)) |
545 | return; /* shutdown? */ | 547 | return; /* shutdown? */ |
546 | size = GNUNET_NETWORK_socket_recvfrom_amount (listen_socket6); | 548 | size = GNUNET_NETWORK_socket_recvfrom_amount(listen_socket6); |
547 | if (0 > size) | 549 | if (0 > size) |
548 | { | 550 | { |
549 | GNUNET_break (0); | 551 | GNUNET_break(0); |
550 | return; /* read error!? */ | 552 | return; /* read error!? */ |
551 | } | 553 | } |
552 | { | 554 | { |
553 | char buf[size]; | 555 | char buf[size]; |
554 | ssize_t sret; | 556 | ssize_t sret; |
555 | 557 | ||
556 | addrlen = sizeof (v6); | 558 | addrlen = sizeof(v6); |
557 | sret = GNUNET_NETWORK_socket_recvfrom (listen_socket6, | 559 | sret = GNUNET_NETWORK_socket_recvfrom(listen_socket6, |
558 | buf, | 560 | buf, |
559 | size, | 561 | size, |
560 | (struct sockaddr *) &v6, | 562 | (struct sockaddr *)&v6, |
561 | &addrlen); | 563 | &addrlen); |
562 | if (0 > sret) | 564 | if (0 > sret) |
563 | { | 565 | { |
564 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, | 566 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, |
565 | "recvfrom"); | 567 | "recvfrom"); |
566 | return; | 568 | return; |
567 | } | 569 | } |
568 | GNUNET_break (size == sret); | 570 | GNUNET_break(size == sret); |
569 | handle_request (listen_socket6, | 571 | handle_request(listen_socket6, |
570 | &v6, | 572 | &v6, |
571 | addrlen, | 573 | addrlen, |
572 | buf, | 574 | buf, |
573 | size); | 575 | size); |
574 | } | 576 | } |
575 | } | 577 | } |
576 | 578 | ||
@@ -584,149 +586,150 @@ read_dns6 (void *cls) | |||
584 | * @param c configuration | 586 | * @param c configuration |
585 | */ | 587 | */ |
586 | static void | 588 | static void |
587 | run (void *cls, | 589 | run(void *cls, |
588 | char *const *args, | 590 | char *const *args, |
589 | const char *cfgfile, | 591 | const char *cfgfile, |
590 | const struct GNUNET_CONFIGURATION_Handle *c) | 592 | const struct GNUNET_CONFIGURATION_Handle *c) |
591 | { | 593 | { |
592 | char *addr_str; | 594 | char *addr_str; |
593 | (void) cls; | 595 | |
594 | (void) args; | 596 | (void)cls; |
595 | (void) cfgfile; | 597 | (void)args; |
598 | (void)cfgfile; | ||
596 | cfg = c; | 599 | cfg = c; |
597 | if (NULL == dns_ip) | 600 | if (NULL == dns_ip) |
598 | { | 601 | { |
599 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 602 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
600 | _("No DNS server specified!\n")); | 603 | _("No DNS server specified!\n")); |
601 | return; | 604 | return; |
602 | } | 605 | } |
603 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, | 606 | GNUNET_SCHEDULER_add_shutdown(&do_shutdown, |
604 | NULL); | 607 | NULL); |
605 | if (NULL == (gns = GNUNET_GNS_connect (cfg))) | 608 | if (NULL == (gns = GNUNET_GNS_connect(cfg))) |
606 | return; | 609 | return; |
607 | GNUNET_assert (NULL != (dns_stub = GNUNET_DNSSTUB_start (128))); | 610 | GNUNET_assert(NULL != (dns_stub = GNUNET_DNSSTUB_start(128))); |
608 | if (GNUNET_OK != | 611 | if (GNUNET_OK != |
609 | GNUNET_DNSSTUB_add_dns_ip (dns_stub, | 612 | GNUNET_DNSSTUB_add_dns_ip(dns_stub, |
610 | dns_ip)) | 613 | dns_ip)) |
611 | { | 614 | { |
612 | GNUNET_DNSSTUB_stop (dns_stub); | 615 | GNUNET_DNSSTUB_stop(dns_stub); |
613 | GNUNET_GNS_disconnect (gns); | 616 | GNUNET_GNS_disconnect(gns); |
614 | gns = NULL; | 617 | gns = NULL; |
615 | return; | 618 | return; |
616 | } | 619 | } |
617 | 620 | ||
618 | /* Get address to bind to */ | 621 | /* Get address to bind to */ |
619 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (c, "dns2gns", | 622 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(c, "dns2gns", |
620 | "BIND_TO", | 623 | "BIND_TO", |
621 | &addr_str)) | 624 | &addr_str)) |
622 | { | 625 | { |
623 | //No address specified | 626 | //No address specified |
624 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 627 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
625 | "Don't know what to bind to...\n"); | 628 | "Don't know what to bind to...\n"); |
626 | GNUNET_free (addr_str); | 629 | GNUNET_free(addr_str); |
627 | GNUNET_SCHEDULER_shutdown (); | 630 | GNUNET_SCHEDULER_shutdown(); |
628 | return; | 631 | return; |
629 | } | 632 | } |
630 | if (1 != inet_pton (AF_INET, addr_str, &address)) | 633 | if (1 != inet_pton(AF_INET, addr_str, &address)) |
631 | { | 634 | { |
632 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 635 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
633 | "Unable to parse address %s\n", | 636 | "Unable to parse address %s\n", |
634 | addr_str); | 637 | addr_str); |
635 | GNUNET_free (addr_str); | 638 | GNUNET_free(addr_str); |
636 | GNUNET_SCHEDULER_shutdown (); | 639 | GNUNET_SCHEDULER_shutdown(); |
637 | return; | 640 | return; |
638 | } | 641 | } |
639 | GNUNET_free (addr_str); | 642 | GNUNET_free(addr_str); |
640 | /* Get address to bind to */ | 643 | /* Get address to bind to */ |
641 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (c, "dns2gns", | 644 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(c, "dns2gns", |
642 | "BIND_TO6", | 645 | "BIND_TO6", |
643 | &addr_str)) | 646 | &addr_str)) |
644 | { | 647 | { |
645 | //No address specified | 648 | //No address specified |
646 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 649 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
647 | "Don't know what to bind6 to...\n"); | 650 | "Don't know what to bind6 to...\n"); |
648 | GNUNET_free (addr_str); | 651 | GNUNET_free(addr_str); |
649 | GNUNET_SCHEDULER_shutdown (); | 652 | GNUNET_SCHEDULER_shutdown(); |
650 | return; | 653 | return; |
651 | } | 654 | } |
652 | if (1 != inet_pton (AF_INET6, addr_str, &address6)) | 655 | if (1 != inet_pton(AF_INET6, addr_str, &address6)) |
653 | { | 656 | { |
654 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 657 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
655 | "Unable to parse IPv6 address %s\n", | 658 | "Unable to parse IPv6 address %s\n", |
656 | addr_str); | 659 | addr_str); |
657 | GNUNET_free (addr_str); | 660 | GNUNET_free(addr_str); |
658 | GNUNET_SCHEDULER_shutdown (); | 661 | GNUNET_SCHEDULER_shutdown(); |
659 | return; | 662 | return; |
660 | } | 663 | } |
661 | GNUNET_free (addr_str); | 664 | GNUNET_free(addr_str); |
662 | 665 | ||
663 | listen_socket4 = GNUNET_NETWORK_socket_create (PF_INET, | 666 | listen_socket4 = GNUNET_NETWORK_socket_create(PF_INET, |
664 | SOCK_DGRAM, | 667 | SOCK_DGRAM, |
665 | IPPROTO_UDP); | 668 | IPPROTO_UDP); |
666 | if (NULL != listen_socket4) | 669 | if (NULL != listen_socket4) |
667 | { | 670 | { |
668 | struct sockaddr_in v4; | 671 | struct sockaddr_in v4; |
669 | 672 | ||
670 | memset (&v4, 0, sizeof (v4)); | 673 | memset(&v4, 0, sizeof(v4)); |
671 | v4.sin_family = AF_INET; | 674 | v4.sin_family = AF_INET; |
672 | v4.sin_addr.s_addr = address; | 675 | v4.sin_addr.s_addr = address; |
673 | #if HAVE_SOCKADDR_IN_SIN_LEN | 676 | #if HAVE_SOCKADDR_IN_SIN_LEN |
674 | v4.sin_len = sizeof (v4); | 677 | v4.sin_len = sizeof(v4); |
675 | #endif | 678 | #endif |
676 | v4.sin_port = htons (listen_port); | 679 | v4.sin_port = htons(listen_port); |
677 | if (GNUNET_OK != | 680 | if (GNUNET_OK != |
678 | GNUNET_NETWORK_socket_bind (listen_socket4, | 681 | GNUNET_NETWORK_socket_bind(listen_socket4, |
679 | (struct sockaddr *) &v4, | 682 | (struct sockaddr *)&v4, |
680 | sizeof (v4))) | 683 | sizeof(v4))) |
681 | { | 684 | { |
682 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind"); | 685 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "bind"); |
683 | GNUNET_NETWORK_socket_close (listen_socket4); | 686 | GNUNET_NETWORK_socket_close(listen_socket4); |
684 | listen_socket4 = NULL; | 687 | listen_socket4 = NULL; |
688 | } | ||
685 | } | 689 | } |
686 | } | 690 | listen_socket6 = GNUNET_NETWORK_socket_create(PF_INET6, |
687 | listen_socket6 = GNUNET_NETWORK_socket_create (PF_INET6, | 691 | SOCK_DGRAM, |
688 | SOCK_DGRAM, | 692 | IPPROTO_UDP); |
689 | IPPROTO_UDP); | ||
690 | if (NULL != listen_socket6) | 693 | if (NULL != listen_socket6) |
691 | { | 694 | { |
692 | struct sockaddr_in6 v6; | 695 | struct sockaddr_in6 v6; |
693 | 696 | ||
694 | memset (&v6, 0, sizeof (v6)); | 697 | memset(&v6, 0, sizeof(v6)); |
695 | v6.sin6_family = AF_INET6; | 698 | v6.sin6_family = AF_INET6; |
696 | v6.sin6_addr = address6; | 699 | v6.sin6_addr = address6; |
697 | #if HAVE_SOCKADDR_IN_SIN_LEN | 700 | #if HAVE_SOCKADDR_IN_SIN_LEN |
698 | v6.sin6_len = sizeof (v6); | 701 | v6.sin6_len = sizeof(v6); |
699 | #endif | 702 | #endif |
700 | v6.sin6_port = htons (listen_port); | 703 | v6.sin6_port = htons(listen_port); |
701 | if (GNUNET_OK != | 704 | if (GNUNET_OK != |
702 | GNUNET_NETWORK_socket_bind (listen_socket6, | 705 | GNUNET_NETWORK_socket_bind(listen_socket6, |
703 | (struct sockaddr *) &v6, | 706 | (struct sockaddr *)&v6, |
704 | sizeof (v6))) | 707 | sizeof(v6))) |
708 | { | ||
709 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "bind"); | ||
710 | GNUNET_NETWORK_socket_close(listen_socket6); | ||
711 | listen_socket6 = NULL; | ||
712 | } | ||
713 | } | ||
714 | if ((NULL == listen_socket4) && | ||
715 | (NULL == listen_socket6)) | ||
705 | { | 716 | { |
706 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind"); | 717 | GNUNET_GNS_disconnect(gns); |
707 | GNUNET_NETWORK_socket_close (listen_socket6); | 718 | gns = NULL; |
708 | listen_socket6 = NULL; | 719 | GNUNET_DNSSTUB_stop(dns_stub); |
720 | dns_stub = NULL; | ||
721 | return; | ||
709 | } | 722 | } |
710 | } | ||
711 | if ( (NULL == listen_socket4) && | ||
712 | (NULL == listen_socket6) ) | ||
713 | { | ||
714 | GNUNET_GNS_disconnect (gns); | ||
715 | gns = NULL; | ||
716 | GNUNET_DNSSTUB_stop (dns_stub); | ||
717 | dns_stub = NULL; | ||
718 | return; | ||
719 | } | ||
720 | if (NULL != listen_socket4) | 723 | if (NULL != listen_socket4) |
721 | t4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 724 | t4 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, |
722 | listen_socket4, | 725 | listen_socket4, |
723 | &read_dns4, | 726 | &read_dns4, |
724 | listen_socket4); | 727 | listen_socket4); |
725 | if (NULL != listen_socket6) | 728 | if (NULL != listen_socket6) |
726 | t6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 729 | t6 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, |
727 | listen_socket6, | 730 | listen_socket6, |
728 | &read_dns6, | 731 | &read_dns6, |
729 | listen_socket6); | 732 | listen_socket6); |
730 | } | 733 | } |
731 | 734 | ||
732 | 735 | ||
@@ -738,39 +741,39 @@ run (void *cls, | |||
738 | * @return 0 ok, 1 on error | 741 | * @return 0 ok, 1 on error |
739 | */ | 742 | */ |
740 | int | 743 | int |
741 | main (int argc, | 744 | main(int argc, |
742 | char *const *argv) | 745 | char *const *argv) |
743 | { | 746 | { |
744 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 747 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
745 | GNUNET_GETOPT_option_string ('d', | 748 | GNUNET_GETOPT_option_string('d', |
746 | "dns", | 749 | "dns", |
747 | "IP", | 750 | "IP", |
748 | gettext_noop ("IP of recursive DNS resolver to use (required)"), | 751 | gettext_noop("IP of recursive DNS resolver to use (required)"), |
749 | &dns_ip), | 752 | &dns_ip), |
750 | GNUNET_GETOPT_option_uint ('p', | 753 | GNUNET_GETOPT_option_uint('p', |
751 | "port", | 754 | "port", |
752 | "UDPPORT", | 755 | "UDPPORT", |
753 | gettext_noop ("UDP port to listen on for inbound DNS requests; default: 2853"), | 756 | gettext_noop("UDP port to listen on for inbound DNS requests; default: 2853"), |
754 | &listen_port), | 757 | &listen_port), |
755 | GNUNET_GETOPT_OPTION_END | 758 | GNUNET_GETOPT_OPTION_END |
756 | }; | 759 | }; |
757 | int ret; | 760 | int ret; |
758 | 761 | ||
759 | if (GNUNET_OK != | 762 | if (GNUNET_OK != |
760 | GNUNET_STRINGS_get_utf8_args (argc, argv, | 763 | GNUNET_STRINGS_get_utf8_args(argc, argv, |
761 | &argc, &argv)) | 764 | &argc, &argv)) |
762 | return 2; | 765 | return 2; |
763 | GNUNET_log_setup ("gnunet-dns2gns", | 766 | GNUNET_log_setup("gnunet-dns2gns", |
764 | "WARNING", | 767 | "WARNING", |
765 | NULL); | 768 | NULL); |
766 | ret = | 769 | ret = |
767 | (GNUNET_OK == | 770 | (GNUNET_OK == |
768 | GNUNET_PROGRAM_run (argc, argv, | 771 | GNUNET_PROGRAM_run(argc, argv, |
769 | "gnunet-dns2gns", | 772 | "gnunet-dns2gns", |
770 | _("GNUnet DNS-to-GNS proxy (a DNS server)"), | 773 | _("GNUnet DNS-to-GNS proxy (a DNS server)"), |
771 | options, | 774 | options, |
772 | &run, NULL)) ? 0 : 1; | 775 | &run, NULL)) ? 0 : 1; |
773 | GNUNET_free ((void*) argv); | 776 | GNUNET_free((void*)argv); |
774 | return ret; | 777 | return ret; |
775 | } | 778 | } |
776 | 779 | ||