master
1/***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
9 *
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at https://curl.se/docs/copyright.html.
13 *
14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 * copies of the Software, and permit persons to whom the Software is
16 * furnished to do so, under the terms of the COPYING file.
17 *
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
20 *
21 * SPDX-License-Identifier: curl
22 *
23 ***************************************************************************/
24#include "first.h"
26#ifndef __AMIGA__
28static int dnsd_wrotepidfile = 0;
29static int dnsd_wroteportfile = 0;
31#ifdef HAVE_SYS_SELECT_H
32#include <sys/select.h>
33#endif
35static uint16_t get16bit(const unsigned char **pkt, size_t *size)
36{
37 const unsigned char *p = *pkt;
38 (*pkt) += 2;
39 *size -= 2;
40 return (uint16_t)((p[0] << 8) | p[1]);
41}
43#define BLOB_MAX_LEN 4096
45struct blob {
46 uint8_t data[BLOB_MAX_LEN];
47 size_t dlen;
48};
50static void blob_reset(struct blob *b)
51{
52 memset(b->data, 0, sizeof(b->data));
53 b->dlen = 0;
54}
56static int blob_add(struct blob *b, uint8_t n)
57{
58 if(b->dlen + 1 > BLOB_MAX_LEN)
59 return 1;
60 b->data[b->dlen] = n;
61 b->dlen += 1;
62 return 0;
63}
65static int blob_addn(struct blob *b, const uint8_t *data, size_t n)
66{
67 if(b->dlen + n > BLOB_MAX_LEN)
68 return 1;
69 memcpy(&b->data[b->dlen], data, n);
70 b->dlen += n;
71 return 0;
72}
74static int blob_add_uint16(struct blob *b, uint16_t n)
75{
76 if(b->dlen + 2 > BLOB_MAX_LEN)
77 return 1;
78 b->data[b->dlen] = (n >> 8) & 0xffU;
79 b->data[b->dlen + 1] = n & 0xffU;
80 b->dlen += 2;
81 return 0;
82}
84static int blob_addchars(struct blob *b, const char *data, size_t n)
85{
86 return blob_addn(b, (const uint8_t *)data, n);
87}
89static int qname2str(const unsigned char **pkt, size_t *size,
90 char *name, size_t name_max)
91{
92 unsigned char length;
93 size_t o = 0;
94 const unsigned char *p = *pkt;
96 do {
97 int i;
98 length = *p++;
99 if(*size < length)
100 /* too long */
101 return 1;
102 if(length && o)
103 name[o++] = '.';
104 if(o + length >= name_max - 1)
105 return 1;
106 for(i = 0; i < length; i++) {
107 name[o++] = *p++;
108 }
109 } while(length);
110 *size -= (p - *pkt);
111 *pkt = p;
112 name[o] = '\0';
113 return 0;
114}
116static int blob_add_qname_part(struct blob *b, struct Curl_str *str)
117{
118 size_t dot, skip;
120 for(dot = 0; dot < str->len; ++dot) {
121 if(str->str[dot] == '.')
122 break;
123 }
124 if(!dot || (dot > 63)) /* RFC 1035, ch. 3.1 */
125 return 1;
126 if(blob_add(b, (uint8_t)dot) ||
127 (dot && blob_addchars(b, str->str, dot)))
128 return 1;
130 skip = dot;
131 if(dot < str->len)
132 skip += 1;
133 str->str += skip;
134 str->len -= skip;
135 return 0;
136}
138static int blob_add_qname(struct blob *b, const struct Curl_str *str)
139{
140 struct Curl_str s = *str;
142 while(s.len) {
143 if(s.str[0] == '.') {
144 if(s.len != 1)
145 return 1;
146 break;
147 }
148 else {
149 if(blob_add_qname_part(b, &s))
150 return 1;
151 }
152 }
153 return blob_add(b, 0);
154}
156#define QTYPE_A 1
157#define QTYPE_AAAA 28
158#define QTYPE_HTTPS 0x41
160#if 0
161#define HTTPS_RR_CODE_MANDATORY 0x00
162#endif
163#define HTTPS_RR_CODE_ALPN 0x01
164#define HTTPS_RR_CODE_NO_DEF_ALPN 0x02
165#if 0
166#define HTTPS_RR_CODE_PORT 0x03
167#define HTTPS_RR_CODE_IPV4 0x04
168#define HTTPS_RR_CODE_ECH 0x05
169#define HTTPS_RR_CODE_IPV6 0x06
170#endif
172static const char *type2string(uint16_t qtype)
173{
174 switch(qtype) {
175 case QTYPE_A:
176 return "A";
177 case QTYPE_AAAA:
178 return "AAAA";
179 case QTYPE_HTTPS:
180 return "HTTPS";
181 }
182 return "<unknown>";
183}
185/*
186 * Handle initial connection protocol.
187 *
188 * Return query (qname + type + class), type and id.
189 */
190static int store_incoming(const char *source, int query_id,
191 const unsigned char *data, size_t datalen,
192 unsigned char *qbuf, size_t qbuflen, size_t *qlen,
193 uint16_t *qtype, uint16_t *idp)
194{
195 FILE *server;
196 char dumpfile[256];
197#if 0
198 size_t i;
199#endif
200 uint16_t qd;
201 const uint8_t *qptr;
202 char name[256];
203 size_t qsize, size;
205 *qlen = 0;
206 *qtype = 0;
207 *idp = 0;
209 size = datalen;
210 if(datalen < 16) {
211 logmsg("query data size is too small: %ld", (long)datalen);
212 return -1;
213 }
215 snprintf(dumpfile, sizeof(dumpfile), "%s/dnsd.input", logdir);
217 /* Open request dump file. */
218 server = curlx_fopen(dumpfile, "ab");
219 if(!server) {
220 char errbuf[STRERROR_LEN];
221 int error = errno;
222 logmsg("fopen() failed with error (%d) %s",
223 error, curlx_strerror(error, errbuf, sizeof(errbuf)));
224 logmsg("[%s] Error opening file '%s'", source, dumpfile);
225 return -1;
226 }
228 /*
229 1 1 1 1 1 1
230 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
231 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
232 | ID |
233 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
234 |QR| Opcode |AA|TC|RD|RA| Z | RCODE |
235 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
236 | QDCOUNT |
237 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
238 | ANCOUNT |
239 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
240 | NSCOUNT |
241 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
242 | ARCOUNT |
243 +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
244 */
245 *idp = get16bit(&data, &size);
246 data += 2; /* skip the next 16 bits */
247 size -= 2;
248#if 0
249 fprintf(server, "[%s] QR: %x\n", source, (*idp & 0x8000) > 15);
250 fprintf(server, "[%s] OPCODE: %x\n", source, (*idp & 0x7800) >> 11);
251 fprintf(server, "[%s] TC: %x\n", source, (*idp & 0x200) >> 9);
252 fprintf(server, "[%s] RD: %x\n", source, (*idp & 0x100) >> 8);
253 fprintf(server, "[%s] Z: %x\n", source, (*idp & 0x70) >> 4);
254 fprintf(server, "[%s] RCODE: %x\n", source, (*idp & 0x0f));
255#endif
256 (void)get16bit(&data, &size);
258 data += 6; /* skip ANCOUNT, NSCOUNT and ARCOUNT */
259 size -= 6;
261 /* store pointer and size at the QD point */
262 qsize = size;
263 qptr = data;
265 if(!qname2str(&data, &size, name, sizeof(name))) {
266 qd = get16bit(&data, &size);
267 fprintf(server, "QNAME %s QTYPE %s\n", name, type2string(qd));
268 *qtype = qd;
269 logmsg("[%d] [%s] Question for '%s' type %x / %s",
270 query_id, source, name, qd, type2string(qd));
272 (void)get16bit(&data, &size);
274 *qlen = qsize - size; /* total size of the query */
275 if(*qlen > qbuflen) {
276 logmsg("dnsd: query too large: %lu > %lu",
277 (unsigned long)*qlen, (unsigned long)qbuflen);
278 curlx_fclose(server);
279 return -1;
280 }
281 memcpy(qbuf, qptr, *qlen);
282 }
283 else
284 logmsg("Bad input qname");
285#if 0
286 for(i = 0; i < size; i++) {
287 fprintf(server, "%02d", (unsigned int)data[i]);
288 }
289 fprintf(server, "\n");
290#endif
292 curlx_fclose(server);
294 return 0;
295}
297static int add_answer(struct blob *body,
298 const unsigned char *a, size_t alen,
299 uint16_t qtype)
300{
301 uint8_t prefix[10] = {
302 0xc0, 0x0c, /* points to the query at this fixed packet index */
303 0x00, 0x00,
304 0x00, 0x01, /* QCLASS IN */
305 0x00, 0x00,
306 0x0a, 0x14, /* TTL, Time to live: 2580 (43 minutes) */
307 };
309 /* QTYPE */
310 prefix[2] = (unsigned char)(qtype >> 8);
311 prefix[3] = (unsigned char)(qtype & 0xff);
313 if(blob_addn(body, prefix, sizeof(prefix)))
314 return 1;
315 if((alen > UINT16_MAX) || blob_add_uint16(body, (uint16_t)alen))
316 return 1;
317 return blob_addn(body, a, alen);
318}
320static void fdset_add_sock(fd_set *fds, curl_socket_t sock, int *pmaxfd)
321{
322 FD_SET(sock, fds);
323 if((int)sock > *pmaxfd)
324 *pmaxfd = (int)sock;
325}
327static struct curltime now_plus(timediff_t delta_ms)
328{
329 struct curltime ts = curlx_now();
330 if(delta_ms > 0) {
331 int usec = (int)((delta_ms % 1000) * 1000);
332 ts.tv_sec += (time_t)(delta_ms / 1000);
333 ts.tv_usec += usec;
334 if(ts.tv_usec >= 1000000) {
335 ts.tv_sec++;
336 ts.tv_usec -= 1000000;
337 }
338 }
339 return ts;
340}
342static int read_https_alpn_part(struct blob *b, struct Curl_str *str)
343{
344 size_t i, skip;
346 for(i = 0; i < str->len; ++i) {
347 if(str->str[i] == ',')
348 break;
349 }
350 if(i >= 256)
351 return 1;
352 if(blob_add(b, (uint8_t)i) || blob_addchars(b, str->str, i))
353 return 1;
354 skip = i + ((i < str->len) ? 1 : 0);
355 str->str += skip;
356 str->len -= skip;
357 return 0;
358}
360#ifdef _WIN32
361#define SENDTO3 int
362#else
363#define SENDTO3 size_t
364#endif
366#define INSTRUCTIONS "dnsd.cmd"
368static curlx_struct_stat finfo_last;
369static unsigned char ipv4_pref[4];
370static unsigned char ipv6_pref[16];
371static unsigned char ancount_a;
372static unsigned char ancount_aaaa;
374static timediff_t a_delay_ms;
375static timediff_t aaaa_delay_ms;
376static timediff_t https_delay_ms;
377static unsigned char rcode_a;
378static unsigned char rcode_aaaa;
379static struct blob httpsrr;
381static int read_https_alpn(struct blob *b, const char **ps)
382{
383 struct Curl_str word;
384 struct blob tmp;
386 blob_reset(&tmp);
387 if(curlx_str_word(ps, &word, UINT16_MAX))
388 return 1;
389 while(word.len) {
390 if(read_https_alpn_part(&tmp, &word))
391 return 1;
392 }
394 if(tmp.dlen > UINT16_MAX)
395 return 1;
397 if(blob_add_uint16(b, HTTPS_RR_CODE_ALPN) ||
398 blob_add_uint16(b, (uint16_t)tmp.dlen) ||
399 blob_addn(b, tmp.data, tmp.dlen))
400 return 1;
401 return 0;
402}
404static int read_https(struct blob *b, const char *s)
405{
406 struct Curl_str word;
407 curl_off_t n;
409 blob_reset(b);
410 /* Parse a HTTPS textual representation inspired by RFC 9460 */
411 curlx_str_passblanks(&s);
412 if(curlx_str_number(&s, &n, UINT16_MAX))
413 return 1;
414 if(blob_add_uint16(b, (uint16_t)n))
415 return 1;
417 curlx_str_passblanks(&s);
418 if(curlx_str_word(&s, &word, UINT16_MAX)) {
419 logmsg("[CONFIG] https: unable to read target qname, input=%s", s);
420 return 1;
421 }
422 if(blob_add_qname(b, &word))
423 return 1;
425 while(*s) {
426 curlx_str_passblanks(&s);
427 if(!*s)
428 break;
429 if(!strncmp("alpn=", s, 5)) {
430 s += 5;
431 if(read_https_alpn(b, &s))
432 return 1;
433 }
434 else if(!strncmp("no-default-alpn", s, 15)) {
435 s += 15;
436 if(blob_add_uint16(b, HTTPS_RR_CODE_NO_DEF_ALPN) ||
437 blob_add_uint16(b, 0))
438 return 1;
439 }
440 else
441 return 1;
442 }
443 return 0;
444}
446static void read_instructions(void)
447{
448 char file[256];
449 FILE *f;
450 curlx_struct_stat finfo;
452 snprintf(file, sizeof(file), "%s/" INSTRUCTIONS, logdir);
453 if((curlx_stat(file, &finfo) == 0) &&
454 (finfo.st_mtime == finfo_last.st_mtime) &&
455 (finfo.st_size == finfo_last.st_size)
456#ifndef _WIN32
457 && (finfo.st_ino == finfo_last.st_ino)
458#endif
459#ifdef __APPLE__
460 && (finfo.st_mtimespec.tv_nsec == finfo_last.st_mtimespec.tv_nsec)
461#elif defined(_POSIX_C_SOURCE)
462#if _POSIX_C_SOURCE >= 200809L
463 && (finfo.st_mtim.tv_nsec == finfo_last.st_mtim.tv_nsec)
464#endif
465#endif
466 ) {
467 /* looks the same as before, skip reading it again */
468 return;
469 }
470 /* reset defaults */
471 a_delay_ms = aaaa_delay_ms = https_delay_ms = 0;
472 rcode_a = rcode_aaaa = 0;
473 blob_reset(&httpsrr);
474 finfo_last = finfo;
476 logmsg("[CONFIG] reading from %s", file);
477 f = curlx_fopen(file, FOPEN_READTEXT);
478 if(f) {
479 char buf[256];
480 ancount_aaaa = ancount_a = 0;
481 while(fgets(buf, sizeof(buf), f)) {
482 const char *rtype = NULL;
483 char *p = strchr(buf, '\n');
484 if(p) {
485 int rc;
486 *p = 0;
487 if(!strncmp("A: ", buf, 3)) {
488 rc = curlx_inet_pton(AF_INET, &buf[3], ipv4_pref);
489 ancount_a = (rc == 1);
490 rtype = "A";
491 }
492 else if(!strncmp("AAAA: ", buf, 6)) {
493 char *p6 = &buf[6];
494 if(*p6 == '[') {
495 char *pt = strchr(p6, ']');
496 if(pt)
497 *pt = 0;
498 p6++;
499 }
500 rc = curlx_inet_pton(AF_INET6, p6, ipv6_pref);
501 ancount_aaaa = (rc == 1);
502 rtype = "AAAA";
503 }
504 else if(!strncmp("HTTPS: ", buf, 7)) {
505 rc = read_https(&httpsrr, &buf[7]) ? 0 : 1;
506 rtype = "HTTPS";
507 }
508 else if(!strncmp("Delay-A: ", buf, 9)) {
509 curl_off_t ms;
510 const char *pms = &buf[9];
511 rc = 0;
512 if(!curlx_str_number(&pms, &ms, 100000)) {
513 a_delay_ms = (timediff_t)ms;
514 rc = 1;
515 }
516 }
517 else if(!strncmp("Delay-AAAA: ", buf, 12)) {
518 curl_off_t ms;
519 const char *pms = &buf[12];
520 rc = 0;
521 if(!curlx_str_number(&pms, &ms, 100000)) {
522 aaaa_delay_ms = (timediff_t)ms;
523 rc = 1;
524 }
525 }
526 else if(!strncmp("Delay-HTTPS: ", buf, 13)) {
527 curl_off_t ms;
528 const char *pms = &buf[13];
529 rc = 0;
530 if(!curlx_str_number(&pms, &ms, 100000)) {
531 https_delay_ms = (timediff_t)ms;
532 rc = 1;
533 }
534 }
535 else if(!strncmp("Rcode-A: ", buf, 9)) {
536 curl_off_t code;
537 const char *pc = &buf[9];
538 rc = 0;
539 if(!curlx_str_number(&pc, &code, 15)) {
540 rcode_a = (unsigned char)code;
541 rc = 1;
542 }
543 }
544 else if(!strncmp("Rcode-AAAA: ", buf, 12)) {
545 curl_off_t code;
546 const char *pc = &buf[12];
547 rc = 0;
548 if(!curlx_str_number(&pc, &code, 15)) {
549 rcode_aaaa = (unsigned char)code;
550 rc = 1;
551 }
552 }
553 else {
554 /* accept empty line */
555 rc = buf[0] ? 0 : 1;
556 }
557 if(rc != 1) {
558 logmsg("[CONFIG] Bad line in %s: '%s'", file, buf);
559 }
560 else if(rtype) {
561 logmsg("[CONFIG] added %s record via '%s'", rtype, buf);
562 }
563 }
564 }
565 logmsg("[CONFIG] set delays: A=%" FMT_TIMEDIFF_T "ms AAAA=%"
566 FMT_TIMEDIFF_T "ms HTTPS=%" FMT_TIMEDIFF_T "ms",
567 a_delay_ms, aaaa_delay_ms, https_delay_ms);
568 curlx_fclose(f);
569 }
570 else
571 logmsg("[CONFIG] Error opening file '%s'", file);
572}
574static int last_query_id = -1;
576static int dnsd_make_answer(struct blob *blob, int query_id,
577 const uint8_t *qbuf, size_t qlen,
578 uint16_t qtype, uint16_t id,
579 timediff_t *pdelay_ms)
580{
581 int a;
582 char addrbuf[128]; /* IP address buffer */
583 uint8_t header[12] = {
584 0x80, 0xea, /* ID, overwrite */
585 0x81, 0x80,
586 /* Flags: 0x8180 Standard query response, No error
588 1... .... .... .... = Response: Message is a response
589 .000 0... .... .... = Opcode: Standard query (0)
590 .... .0.. .... .... = Authoritative: Server is not an authority for
591 domain
592 .... ..0. .... .... = Truncated: Message is not truncated
593 .... ...1 .... .... = Recursion desired: Do query recursively
594 .... .... 1... .... = Recursion available: Server can do recursive
595 queries
596 .... .... .0.. .... = Z: reserved (0)
597 .... .... ..0. .... = Answer authenticated: Answer/authority portion
598 was not authenticated by the server
599 .... .... ...0 .... = Non-authenticated data: Unacceptable
600 .... .... .... 0000 = Reply code: No error (0)
601 */
602 0x0, 0x1, /* QDCOUNT a single question */
603 0x0, 0x0, /* ANCOUNT number of answers */
604 0x0, 0x0, /* NSCOUNT */
605 0x0, 0x0 /* ARCOUNT */
606 };
607 uint16_t ancount = 0;
608 unsigned char rcode = 0;
609 CURLcode result;
611 /* read once per incoming query, which is probably more than one
612 per test case */
613 read_instructions();
615 switch(qtype) {
616 case QTYPE_A:
617 ancount = ancount_a;
618 *pdelay_ms = a_delay_ms;
619 rcode = rcode_a;
620 break;
621 case QTYPE_AAAA:
622 ancount = ancount_aaaa;
623 *pdelay_ms = aaaa_delay_ms;
624 rcode = rcode_aaaa;
625 break;
626 case QTYPE_HTTPS:
627 if(httpsrr.dlen)
628 ancount = 1;
629 *pdelay_ms = https_delay_ms;
630 break;
631 default:
632 *pdelay_ms = 0;
633 }
634 if(rcode)
635 ancount = 0;
637 header[0] = (uint8_t)(id >> 8);
638 header[1] = (uint8_t)(id & 0xff);
640 if(rcode) {
641 header[3] = (uint8_t)((header[3] & 0xf0) | (rcode & 0x0f));
642 logmsg("[%d] response rcode %u", query_id, (unsigned int)rcode);
643 }
645 header[6] = (uint8_t)(ancount >> 8);
646 header[7] = (uint8_t)(ancount & 0xff);
648 if(blob_addn(blob, header, sizeof(header)))
649 return 1;
651 if(blob_addn(blob, qbuf, qlen)) {
652 logmsg("unable to handle query of length %lu", (unsigned long)qlen);
653 return 1;
654 }
656 switch(qtype) {
657 case QTYPE_A:
658 for(a = 0; !rcode && (a < ancount_a); a++) {
659 const unsigned char *store = ipv4_pref;
660 if(add_answer(blob, store, sizeof(ipv4_pref), QTYPE_A))
661 return 1;
662 result = curlx_inet_ntop(AF_INET, store, addrbuf, sizeof(addrbuf));
663 logmsg("[%d] response A (%x) '%s' (%d)", query_id,
664 (unsigned int)QTYPE_A, result ? "?" : addrbuf, (int)result);
665 }
666 if(!ancount_a)
667 logmsg("[%d] response A empty", query_id);
668 break;
669 case QTYPE_AAAA:
670 for(a = 0; !rcode && (a < ancount_aaaa); a++) {
671 const unsigned char *store = ipv6_pref;
672 if(add_answer(blob, store, sizeof(ipv6_pref), QTYPE_AAAA))
673 return 1;
674 result = curlx_inet_ntop(AF_INET6, store, addrbuf, sizeof(addrbuf));
675 logmsg("[%d] response AAAA (%x) '%s' (%d)", query_id,
676 (unsigned int)QTYPE_AAAA, result ? "?" : addrbuf, (int)result);
677 }
678 if(!ancount_aaaa)
679 logmsg("[%d] response AAAA empty", query_id);
680 break;
681 case QTYPE_HTTPS:
682 if(httpsrr.dlen) {
683 if(add_answer(blob, httpsrr.data, httpsrr.dlen, QTYPE_HTTPS)) {
684 logmsg("[%d] error adding https %lu response bytes", query_id,
685 (unsigned long)httpsrr.dlen);
686 return 1;
687 }
688 logmsg("[%d] response HTTPS (%x), %lu bytes", query_id,
689 (unsigned int)QTYPE_HTTPS, (unsigned long)httpsrr.dlen);
690 }
691 else
692 logmsg("[%d] response HTTPS, no record", query_id);
693 break;
694 }
696 return 0;
697}
699struct udp_resp {
700 struct udp_resp *next;
701 int query_id;
702 struct curltime send_ts;
703 struct sockaddr addr;
704 curl_socklen_t addrlen;
705 struct blob body;
706};
708static struct udp_resp *udp_resp_queue;
710static CURLcode send_udp_resp(curl_socket_t sock, struct udp_resp *resp)
711{
712 ssize_t rc;
713 int sockerr = 0;
715 do {
716 rc = sendto(sock, (const void *)resp->body.data, (SENDTO3)resp->body.dlen,
717 0, &resp->addr, resp->addrlen);
718 } while((rc < 0) && ((sockerr = SOCKERRNO) == SOCKEINTR));
719 if(rc < 0) {
720 char errbuf[STRERROR_LEN];
721 logmsg("[%d-UDP] failed sending %lu bytes, error: (%d) %s",
722 resp->query_id, (unsigned long)resp->body.dlen,
723 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
724 return CURLE_SEND_ERROR;
725 }
726 else if(rc != (ssize_t)resp->body.dlen) {
727 logmsg("[%d-UDP] failed sending %lu bytes, sent: %ld",
728 resp->query_id, (unsigned long)resp->body.dlen, (long)rc);
729 return CURLE_SEND_ERROR;
730 }
731 logmsg("[%d-UDP] sent response", resp->query_id);
732 return CURLE_OK;
733}
735static void queue_udp_resp(struct udp_resp *resp)
736{
737 struct udp_resp **panchor = &udp_resp_queue;
738 while(*panchor) {
739 timediff_t ms = curlx_ptimediff_ms(&(*panchor)->send_ts, &resp->send_ts);
740 if(ms > 0) /* resp is to be sent before *panchor */
741 break;
742 panchor = &(*panchor)->next;
743 }
744 resp->next = *panchor;
745 *panchor = resp;
746}
748static timediff_t queue_udp_next_ms(struct curltime *pnow)
749{
750 timediff_t next_ms = 1000;
751 struct udp_resp *r;
753 for(r = udp_resp_queue; r; r = r->next) {
754 timediff_t ms = curlx_ptimediff_ms(&r->send_ts, pnow);
755 if((ms > 0) && (ms < next_ms))
756 next_ms = ms;
757 else if(ms <= 0)
758 return 0;
759 }
760 return next_ms;
761}
763static void queue_udp_send(curl_socket_t sock, struct curltime *pnow)
764{
765 struct udp_resp **panchor = &udp_resp_queue;
767 while(*panchor) {
768 struct udp_resp *resp = *panchor;
769 timediff_t ms = curlx_ptimediff_ms(&resp->send_ts, pnow);
771 /* if not due yet, break as response queue is time sorted */
772 if(ms > 0)
773 break;
774 *panchor = resp->next;
775 send_udp_resp(sock, resp);
776 curlx_free(resp);
777 }
778}
780static void queue_udp_clear(void)
781{
782 while(udp_resp_queue) {
783 struct udp_resp *resp = udp_resp_queue;
784 udp_resp_queue = resp->next;
785 curlx_free(resp);
786 }
787}
789/* this is an answer to a question */
790static struct udp_resp *udp_resp_create(int query_id,
791 const struct sockaddr *addr,
792 curl_socklen_t addrlen,
793 const unsigned char *qbuf, size_t qlen,
794 uint16_t qtype, uint16_t id)
795{
796 struct udp_resp *resp;
797 timediff_t delay_ms = 0;
799 resp = curlx_calloc(1, sizeof(*resp));
800 if(!resp)
801 goto error;
803 resp->query_id = query_id;
804 /* on some platforms `curl_socklen_t` is an `int`. Casting might
805 * wrap this, but then it still has to fit our record size. */
806 if((size_t)addrlen > sizeof(resp->addr)) {
807 logmsg("[%d-UDP] unable to handle addrlen of %lu",
808 query_id, (unsigned long)addrlen);
809 goto error;
810 }
811 memcpy(&resp->addr, CURL_UNCONST(addr), addrlen);
812 resp->addrlen = addrlen;
814 if(dnsd_make_answer(&resp->body, query_id, qbuf, qlen, qtype, id, &delay_ms))
815 goto error;
817 resp->send_ts = now_plus(delay_ms);
818 if(delay_ms > 0)
819 logmsg("[%d-UDP] delay response by %" FMT_TIMEDIFF_T "ms",
820 query_id, delay_ms);
821 return resp;
823error:
824 logmsg("[%d-UDP] failed to create response", query_id);
825 curlx_free(resp);
826 return NULL;
827}
829static int udp_recv_req(curl_socket_t sock)
830{
831 srvr_sockaddr_union_t from;
832 curl_socklen_t fromlen;
833 uint8_t inbuffer[1500];
834 uint8_t qbuf[256]; /* query storage */
835 size_t qlen = 0; /* query size */
836 struct udp_resp *resp;
837 uint16_t qtype = 0, id;
838 ssize_t n;
839 int result = 0;
841 fromlen = sizeof(from);
842#ifdef USE_IPV6
843 if(socket_domain == AF_INET6)
844 fromlen = sizeof(from.sa6);
845 else
846#endif
847 fromlen = sizeof(from.sa4);
849 n = (ssize_t)recvfrom(sock, (char *)inbuffer, sizeof(inbuffer), 0,
850 &from.sa, &fromlen);
851 if(got_exit_signal)
852 goto out;
853 if(n < 0) {
854 logmsg("UDP, recvfrom error");
855 result = 3;
856 goto out;
857 }
859 ++last_query_id;
860 store_incoming("UDP", last_query_id, inbuffer, n,
861 qbuf, sizeof(qbuf), &qlen, &qtype, &id);
863 set_advisor_read_lock(loglockfile);
864 serverlogslocked = 1;
866 resp = udp_resp_create(last_query_id, &from.sa, fromlen, qbuf,
867 qlen, qtype, id);
868 if(!resp)
869 logmsg("[%d-UDP] error creating response", last_query_id);
870 else
871 queue_udp_resp(resp);
873out:
874 return result;
875}
877#define MAX_DOH_CONNS 512
878#define MAX_DOH_INBUF_LEN (8 * 1024)
879#define MAX_DOH_OUTBUF_LEN (8 * 1024)
881struct doh_conn {
882 curl_socket_t sock;
883 int index;
884 int query_id;
885 char inbuf[MAX_DOH_INBUF_LEN];
886 size_t inblen;
887 size_t inbody_offset;
888 size_t inbody_len;
889 char outbuf[MAX_DOH_OUTBUF_LEN];
890 size_t outblen;
891 struct curltime send_ts;
892 BIT(want_recv);
893 BIT(want_send);
894 BIT(close_pending);
895};
897static struct doh_conn doh_conns[MAX_DOH_CONNS];
899static void doh_conns_init(void)
900{
901 int i;
902 for(i = 0; i < MAX_DOH_CONNS; ++i) {
903 doh_conns[i].sock = CURL_SOCKET_BAD;
904 doh_conns[i].index = i;
905 }
906}
908static int doh_conns_add(curl_socket_t sock)
909{
910 int i;
911 for(i = 0; i < MAX_DOH_CONNS; ++i) {
912 if(doh_conns[i].sock == CURL_SOCKET_BAD) {
913 doh_conns[i].sock = sock;
914 doh_conns[i].want_recv = TRUE;
915 logmsg("[x-%d-DOH] accepted new connection, fd=%ld", i, (long)sock);
916 return 0;
917 }
918 }
919 logmsg("Too many open DoH connections, closing incoming.");
920 sclose(sock);
921 return 1;
922}
924static void doh_conn_close(size_t i)
925{
926 if(i >= MAX_DOH_CONNS)
927 return;
928 if(doh_conns[i].sock != CURL_SOCKET_BAD)
929 sclose(doh_conns[i].sock);
930 doh_conns[i].sock = CURL_SOCKET_BAD;
931 doh_conns[i].want_recv = FALSE;
932 doh_conns[i].want_send = FALSE;
933 logmsg("[x-%d-DOH] connection closed", (int)i);
934}
936static void doh_conns_close_all(void)
937{
938 size_t i;
939 for(i = 0; i < MAX_DOH_CONNS; ++i) {
940 doh_conn_close(i);
941 }
942}
944static void doh_conns_fdsets(fd_set *readfds, fd_set *writefds,
945 struct curltime *pnow,
946 int *pmaxfd,
947 timediff_t *ptimeout_ms)
948{
949 size_t i;
950 for(i = 0; i < MAX_DOH_CONNS; ++i) {
951 struct doh_conn *c = &doh_conns[i];
952 if((c->sock != CURL_SOCKET_BAD)) {
953 if(!c->want_send && c->outblen) { /* check delayed send */
954 timediff_t ms = curlx_ptimediff_ms(&c->send_ts, pnow);
955 if(ms <= 0)
956 c->want_send = TRUE;
957 else if((ms < *ptimeout_ms) || !*ptimeout_ms)
958 *ptimeout_ms = ms;
959 }
960 if(c->want_send)
961 FD_SET(c->sock, writefds);
962 if(c->want_recv)
963 FD_SET(c->sock, readfds);
965 if((FD_ISSET(c->sock, readfds) || FD_ISSET(c->sock, writefds)) &&
966 (int)c->sock > *pmaxfd)
967 *pmaxfd = (int)c->sock;
968 }
969 }
970}
972static int doh_conn_send(struct doh_conn *c, struct curltime *pnow)
973{
974 char errbuf[STRERROR_LEN];
975 ssize_t rc;
976 int sockerr;
978 if(c->outblen) {
979 timediff_t ms = curlx_ptimediff_ms(&c->send_ts, pnow);
980 size_t n;
982 if(ms > 0) { /* not due yet */
983 c->want_send = FALSE;
984 goto out;
985 }
987 rc = swrite(c->sock, c->outbuf, c->outblen);
988 if(rc < 0) {
989 sockerr = SOCKERRNO;
990 if((sockerr == SOCKEINPROGRESS) || SOCK_EAGAIN(sockerr))
991 return 0;
992 sockerr = SOCKERRNO;
993 logmsg("[%d-%d-DOH] swrite(%ld) failed with error (%d) %s",
994 c->query_id, c->index, (long)c->sock,
995 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
996 return 1;
997 }
998 n = (size_t)rc;
999 if(n >= c->outblen) { /* all sent */
1000 c->outblen = 0;
1001 logmsg("[%d-%d-DOH] last response byte sent", c->query_id, c->index);
1002 }
1003 else {
1004 c->outblen -= n;
1005 memmove(c->outbuf, c->outbuf + n, c->outblen);
1006 }
1007 }
1009out:
1010 if(!c->outblen) {
1011 c->want_send = FALSE;
1012 if(c->close_pending)
1013 return 1;
1014 else {
1015 logmsg("[x-%d-DOH] switching to recv", c->index);
1016 c->want_recv = TRUE;
1017 }
1018 }
1019 return 0;
1020}
1022static const char *http_status_descr(int http_status)
1023{
1024 switch(http_status) {
1025 case 200:
1026 return "Ok";
1027 case 400:
1028 return "Bad Request";
1029 case 404:
1030 return "Not Found";
1031 case 405:
1032 return "Method Not Allowed";
1033 default:
1034 if(http_status < 100)
1035 return "This is wrong";
1036 if(http_status < 200)
1037 return "Just Kidding";
1038 if(http_status < 300)
1039 return "Lgtm";
1040 if(http_status < 400)
1041 return "Follow Me For More Requests";
1042 if(http_status < 500)
1043 return "You were wrong";
1044 return "We did something wrong";
1045 }
1046}
1048static int doh_conn_send_err(struct doh_conn *c, int http_status)
1049{
1050 c->inblen = 0;
1051 c->close_pending = TRUE;
1052 c->want_recv = FALSE;
1053 if(c->outblen) {
1054 logmsg("[%d-%d-DOH] error sending response with %lu bytes still outgoing",
1055 c->query_id, c->index, (unsigned long)c->outblen);
1056 return 1;
1057 }
1059 memset(c->outbuf, 0, sizeof(c->outbuf));
1060 snprintf(c->outbuf, sizeof(c->outbuf) - 1,
1061 "HTTP/1.1 %d %s\r\n"
1062 "Content-Length: 0\r\n"
1063 "Connection: close\r\n"
1064 "\r\n",
1065 http_status, http_status_descr(http_status));
1066 c->outblen = strlen(c->outbuf);
1067 c->want_send = TRUE;
1068 logmsg("[%d-%d-DOH] sending HTTP response %d",
1069 c->query_id, c->index, http_status);
1070 return 0;
1071}
1073static int doh_conn_send_answer(struct doh_conn *c, struct blob *body,
1074 timediff_t delay_ms)
1075{
1076 if(c->outblen) { /* Should not happen */
1077 logmsg("[%d-%d-DOH] trying to send an answer with outbuf still having "
1078 "%lu bytes", c->query_id, c->index, (unsigned long)c->outblen);
1079 return 1;
1080 }
1081 memset(c->outbuf, 0, sizeof(c->outbuf));
1082 snprintf(c->outbuf, sizeof(c->outbuf) - 1,
1083 "HTTP/1.1 200 %s\r\n"
1084 "Server: curl/test-dnsd\r\n"
1085 "Date: Thu, 06 Aug 2026 08:42:00 GMT\r\n"
1086 "Content-Type: application/dns-message\r\n"
1087 "Content-Length: %ld\r\n"
1088 "\r\n",
1089 http_status_descr(200), (long)body->dlen);
1090 c->outblen = strlen(c->outbuf);
1091 if((c->outblen + body->dlen) > sizeof(c->outbuf)) {
1092 logmsg("[%d-%d-DOH] response size of %lu too large for outbuf",
1093 c->query_id, c->index, (unsigned long)(c->outblen + body->dlen));
1094 c->outblen = 0;
1095 return 1;
1096 }
1097 memcpy(c->outbuf + c->outblen, body->data, body->dlen);
1098 c->outblen += body->dlen;
1099 c->send_ts = now_plus(delay_ms);
1100 if(delay_ms > 0)
1101 logmsg("[%d-%d-DOH] delay response by %" FMT_TIMEDIFF_T "ms",
1102 c->query_id, c->index, delay_ms);
1103 else
1104 c->want_send = TRUE;
1105 c->want_recv = FALSE;
1106 logmsg("[%d-%d-DOH] sending HTTP response 200",
1107 c->query_id, c->index);
1108 return 0;
1109}
1111static int doh_req_parse_headers(const char **pstr,
1112 size_t *pcontent_length,
1113 bool *pcomplete)
1114{
1115 static const struct Curl_str HD_content_length = {
1116 STRCONST("Content-Length:")
1117 };
1118 static const struct Curl_str HD_content_type = {
1119 STRCONST("Content-Type:")
1120 };
1121 static const struct Curl_str HD_wanted_type = {
1122 STRCONST("application/dns-message")
1123 };
1124 const char *p = *pstr;
1125 bool ct_ok = FALSE;
1126 bool cl_ok = FALSE;
1127 bool eoh = FALSE;
1129 *pcomplete = FALSE;
1130 *pcontent_length = 0;
1131 while(p[0]) {
1132 const char *nl, *start = p;
1133 struct Curl_str hd_name, hd_val;
1135 if((p[0] == '\r') && (p[1] == '\n')) {
1136 p += 2;
1137 eoh = TRUE;
1138 break;
1139 }
1140 nl = strchr(p, '\n');
1141 if(!nl) /* incomplete */
1142 break;
1143 if(curlx_str_word(&p, &hd_name, 1024) ||
1144 curlx_str_singlespace(&p) ||
1145 curlx_str_untilnl(&p, &hd_val, 1024) ||
1146 curlx_str_newline(&p) ||
1147 curlx_str_newline(&p)) {
1148 logmsg("unrecognized request header '%.*s'",
1149 (int)(nl - start), start);
1150 return 1;
1151 }
1152 if(curlx_str_case_equal(&HD_content_type, &hd_name)) {
1153 if(!curlx_str_case_equal(&HD_wanted_type, &hd_val)) {
1154 logmsg("wrong content-type: '%.*s'", (int)hd_val.len, hd_val.str);
1155 return 1;
1156 }
1157 ct_ok = TRUE;
1158 }
1159 else if(curlx_str_case_equal(&HD_content_length, &hd_name)) {
1160 const char *s = hd_val.str;
1161 curl_off_t offt;
1162 if(curlx_str_number(&s, &offt, 4096)) {
1163 logmsg("wrong content-length: '%.*s'", (int)hd_val.len, hd_val.str);
1164 return 1;
1165 }
1166 *pcontent_length = (size_t)offt;
1167 cl_ok = TRUE;
1168 }
1169 else {
1170 /* ignore this header */
1171 }
1172 }
1174 *pstr = p;
1175 if(!eoh)
1176 return 0; /* need more */
1177 if(!ct_ok) {
1178 logmsg("request missing Content-Type");
1179 return 1;
1180 }
1181 if(!cl_ok) {
1182 logmsg("request missing Content-Length");
1183 return 1;
1184 }
1185 *pcomplete = TRUE;
1186 return 0;
1187}
1189static int doh_conn_do_req(struct doh_conn *c, bool eos)
1190{
1191 static const struct Curl_str DOH_PROTO = { STRCONST("HTTP/1.1") };
1192 static const struct Curl_str DOH_METHOD = { STRCONST("POST") };
1193 static const struct Curl_str DOH_PATH = { STRCONST("/") };
1194 const char *first_nl;
1195 bool complete = FALSE;
1197 if(!c->inblen && eos)
1198 return 1;
1200 if(!c->inbody_offset) {
1201 first_nl = strchr(c->inbuf, '\n');
1202 if(first_nl) {
1203 /* This is a poor man's HTTP/1.1 parser and we should rather have
1204 * one in curlx that we can share. */
1205 const char *p = c->inbuf;
1206 struct Curl_str method, path, proto;
1208 if(curlx_str_word(&p, &method, 1024) || curlx_str_singlespace(&p)) {
1209 logmsg("[x-%d-DOH] unrecognized first request line method '%.*s'",
1210 c->index, (int)(first_nl - c->inbuf), c->inbuf);
1211 return 1;
1212 }
1213 if(curlx_str_word(&p, &path, 1024) || curlx_str_singlespace(&p)) {
1214 logmsg("[x-%d-DOH] unrecognized first request line path '%.*s'",
1215 c->index, (int)(first_nl - c->inbuf), c->inbuf);
1216 return 1;
1217 }
1218 if(curlx_str_untilnl(&p, &proto, 1024) ||
1219 curlx_str_newline(&p) ||
1220 curlx_str_newline(&p)) {
1221 logmsg("[x-%d-DOH] unrecognized first request line proto '%.*s'",
1222 c->index, (int)(first_nl - c->inbuf), c->inbuf);
1223 return 1;
1224 }
1225 if(!curlx_str_case_equal(&DOH_PROTO, &proto)) {
1226 logmsg("[x-%d-DOH] unrecognized request protocol '%.*s'",
1227 c->index, (int)proto.len, proto.str);
1228 return 1;
1229 }
1230 if(!curlx_str_case_equal(&DOH_METHOD, &method)) {
1231 logmsg("[x-%d-DOH] unsupported request method '%.*s'",
1232 c->index, (int)method.len, method.str);
1233 return doh_conn_send_err(c, 405);
1234 }
1235 if(!curlx_str_case_equal(&DOH_PATH, &path)) {
1236 logmsg("[x-%d-DOH] request path not fond '%.*s'",
1237 c->index, (int)path.len, path.str);
1238 return doh_conn_send_err(c, 404);
1239 }
1240 if(doh_req_parse_headers(&p, &c->inbody_len, &complete)) {
1241 return doh_conn_send_err(c, 400);
1242 }
1243 /* Looks ok, remember the start of the body bytes */
1244 c->inbody_offset = (p - c->inbuf);
1245 }
1246 if(!complete)
1247 return eos ? 1 : 0; /* want more, error if client close */
1248 }
1250 if(c->inblen >= (c->inbody_offset + c->inbody_len)) {
1251 /* We have all bytes for processing the request */
1252 uint8_t qbuf[256]; /* query storage */
1253 size_t qlen = 0; /* query size */
1254 size_t rlen = c->inbody_offset + c->inbody_len; /* request size */
1255 uint16_t qtype = 0, id;
1256 struct blob blob;
1257 timediff_t delay_ms;
1259 c->query_id = ++last_query_id;
1260 if(store_incoming("DoH", c->query_id, (const uint8_t *)c->inbuf +
1261 c->inbody_offset, c->inbody_len,
1262 qbuf, sizeof(qbuf), &qlen, &qtype, &id)) {
1263 logmsg("[%d-%d-DOH] error storing incoming request",
1264 c->query_id, c->index);
1265 return doh_conn_send_err(c, 400);
1266 }
1268 /* remove handled request from inbuf */
1269 if(rlen >= c->inblen)
1270 c->inblen = 0;
1271 else {
1272 memmove(c->inbuf, c->inbuf + rlen, c->inblen - rlen);
1273 c->inblen -= rlen;
1274 }
1275 c->inbody_len = c->inbody_offset = 0;
1277 memset(&blob, 0, sizeof(blob));
1278 if(dnsd_make_answer(&blob, c->query_id, qbuf, qlen, qtype, id,
1279 &delay_ms)) {
1280 return doh_conn_send_err(c, 500);
1281 }
1282 return doh_conn_send_answer(c, &blob, delay_ms);
1283 }
1284 return 0;
1285}
1287static int doh_conn_recv(struct doh_conn *c)
1288{
1289 char errbuf[STRERROR_LEN];
1290 ssize_t n;
1291 int sockerr;
1293 n = sread(c->sock, c->inbuf + c->inblen, sizeof(c->inbuf) - 1 - c->inblen);
1294 if(n < 0) {
1295 sockerr = SOCKERRNO;
1296 if((sockerr == SOCKEINPROGRESS) || SOCK_EAGAIN(sockerr))
1297 return 0;
1298 sockerr = SOCKERRNO;
1299 logmsg("[x-%d-DOH] sread() failed with error (%d) %s", c->index,
1300 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
1301 return 1;
1302 }
1303 else if(n == 0) {
1304 logmsg("[x-%d-DOH] sread() == 0, client closed connection", c->index);
1305 return doh_conn_do_req(c, TRUE);
1306 }
1307 else {
1308 c->inblen += (size_t)n;
1309 c->inbuf[c->inblen] = 0;
1310 logmsg("[x-%d-DOH] sread() == %ld, processing", c->index, (long)n);
1311 return doh_conn_do_req(c, FALSE);
1312 }
1313}
1315static int doh_conns_serve(fd_set *readfds, fd_set *writefds)
1316{
1317 struct curltime now;
1318 size_t i;
1320 for(i = 0; i < MAX_DOH_CONNS; ++i) {
1321 struct doh_conn *c = &doh_conns[i];
1322 if(c->sock != CURL_SOCKET_BAD) {
1323 if(c->want_send && FD_ISSET(c->sock, writefds)) {
1324 now = curlx_now();
1325 if(doh_conn_send(c, &now)) {
1326 doh_conn_close(i);
1327 continue;
1328 }
1329 }
1330 if(c->want_recv && FD_ISSET(c->sock, readfds)) {
1331 if(doh_conn_recv(c)) {
1332 doh_conn_close(i);
1333 continue;
1334 }
1335 }
1336 }
1337 }
1338 return 0;
1339}
1341static int test_dnsd(int argc, const char **argv)
1342{
1343 int arg = 1;
1344 curl_socket_t sock_udp = CURL_SOCKET_BAD;
1345 curl_socket_t sock_tcp_listen = CURL_SOCKET_BAD;
1346 char errbuf[STRERROR_LEN];
1347 int rc, sockerr;
1348 int result = 0;
1350 pidname = ".dnsd.pid";
1351 serverlogfile = "log/dnsd.log";
1352 serverlogslocked = 0;
1353 server_port = 9123; /* UDP */
1354 socket_domain = AF_INET;
1356 while(argc > arg) {
1357 const char *opt;
1358 curl_off_t num;
1359 if(!strcmp("--verbose", argv[arg])) {
1360 arg++;
1361 /* nothing yet */
1362 }
1363 else if(!strcmp("--version", argv[arg])) {
1364 printf("dnsd IPv4%s\n",
1365#ifdef USE_IPV6
1366 "/IPv6"
1367#else
1368 ""
1369#endif
1370 );
1371 return 0;
1372 }
1373 else if(!strcmp("--pidfile", argv[arg])) {
1374 arg++;
1375 if(argc > arg)
1376 pidname = argv[arg++];
1377 }
1378 else if(!strcmp("--portfile", argv[arg])) {
1379 arg++;
1380 if(argc > arg)
1381 portname = argv[arg++];
1382 }
1383 else if(!strcmp("--logfile", argv[arg])) {
1384 arg++;
1385 if(argc > arg)
1386 serverlogfile = argv[arg++];
1387 }
1388 else if(!strcmp("--logdir", argv[arg])) {
1389 arg++;
1390 if(argc > arg)
1391 logdir = argv[arg++];
1392 }
1393 else if(!strcmp("--ipv4", argv[arg])) {
1394 socket_type = "IPv4";
1395 socket_domain = AF_INET;
1396 arg++;
1397 }
1398 else if(!strcmp("--ipv6", argv[arg])) {
1399#ifdef USE_IPV6
1400 socket_type = "IPv6";
1401 socket_domain = AF_INET6;
1402#endif
1403 arg++;
1404 }
1405 else if(!strcmp("--port", argv[arg])) {
1406 arg++;
1407 if(argc > arg) {
1408 opt = argv[arg];
1409 if(!curlx_str_number(&opt, &num, 0xffff))
1410 server_port = (uint16_t)num;
1411 arg++;
1412 }
1413 }
1414 else {
1415 if(argv[arg])
1416 fprintf(stderr, "unknown option: %s\n", argv[arg]);
1417 puts("Usage: dnsd [option]\n"
1418 " --version\n"
1419 " --logfile [file]\n"
1420 " --logdir [directory]\n"
1421 " --pidfile [file]\n"
1422 " --portfile [file]\n"
1423 " --ipv4\n"
1424 " --ipv6\n"
1425 " --port [port]\n");
1426 return 0;
1427 }
1428 }
1430 snprintf(loglockfile, sizeof(loglockfile), "%s/%s/dnsd-%s.lock",
1431 logdir, SERVERLOGS_LOCKDIR, socket_type);
1433 install_signal_handlers(FALSE);
1435 result = open_stream_sock(&sock_tcp_listen, &server_port);
1436 if(result)
1437 goto dnsd_cleanup;
1438 doh_conns_init();
1440 result = open_udp_sock(&sock_udp, &server_port);
1441 if(result)
1442 goto dnsd_cleanup;
1444 dnsd_wrotepidfile = write_pidfile(pidname);
1445 if(!dnsd_wrotepidfile) {
1446 result = 1;
1447 goto dnsd_cleanup;
1448 }
1450 if(portname) {
1451 dnsd_wroteportfile = write_portfile(portname, server_port);
1452 if(!dnsd_wroteportfile) {
1453 result = 1;
1454 goto dnsd_cleanup;
1455 }
1456 }
1458 /* start accepting connections */
1459 if(listen(sock_tcp_listen, 50)) {
1460 sockerr = SOCKERRNO;
1461 logmsg("listen() failed with error (%d) %s",
1462 sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
1463 result = 1;
1464 goto dnsd_cleanup;
1465 }
1467 logmsg("Running %s on port UDP+TCP/%u", socket_type, server_port);
1468 curlx_nonblock(sock_udp, TRUE);
1469 curlx_nonblock(sock_tcp_listen, TRUE);
1471 for(;;) {
1472 timediff_t timeout_ms = 0;
1473 fd_set readfds, writefds;
1474 struct timeval tv;
1475 int maxfd = 0;
1476 struct curltime now = curlx_now();
1478 FD_ZERO(&readfds);
1479 fdset_add_sock(&readfds, sock_udp, &maxfd);
1480 fdset_add_sock(&readfds, sock_tcp_listen, &maxfd);
1482 FD_ZERO(&writefds);
1483 timeout_ms = queue_udp_next_ms(&now);
1484 if(!timeout_ms)
1485 fdset_add_sock(&writefds, sock_udp, &maxfd);
1487 doh_conns_fdsets(&readfds, &writefds, &now, &maxfd, &timeout_ms);
1489 if(!timeout_ms || (timeout_ms > 100))
1490 timeout_ms = 100;
1492 rc = select(maxfd + 1, &readfds, &writefds, NULL,
1493 curlx_mstotv(&tv, timeout_ms));
1495 if(rc == -1) {
1496 logmsg("error %d returned by select()", SOCKERRNO);
1497 }
1498 else if(!rc) { /* timeout */
1499 continue;
1500 }
1502 if(FD_ISSET(sock_udp, &writefds)) {
1503 now = curlx_now();
1504 queue_udp_send(sock_udp, &now);
1505 }
1506 if(FD_ISSET(sock_udp, &readfds)) {
1507 result = udp_recv_req(sock_udp);
1508 if(result)
1509 break;
1510 }
1512 result = doh_conns_serve(&readfds, &writefds);
1513 if(result)
1514 break;
1516 if(FD_ISSET(sock_tcp_listen, &readfds)) {
1517 /* Service all queued connections */
1518 curl_socket_t sock_conn;
1519 while(TRUE) {
1520 sock_conn = accept_connection(sock_tcp_listen);
1521 if(!sock_conn) /* no more connections to accept */
1522 break;
1523 if(sock_conn == CURL_SOCKET_BAD)
1524 goto dnsd_cleanup;
1525 doh_conns_add(sock_conn);
1526 }
1527 }
1529 if(got_exit_signal)
1530 break;
1532 if(serverlogslocked) {
1533 serverlogslocked = 0;
1534 clear_advisor_read_lock(loglockfile);
1535 }
1536 }
1538dnsd_cleanup:
1539 if(sock_udp != CURL_SOCKET_BAD)
1540 sclose(sock_udp);
1541 if(sock_tcp_listen != CURL_SOCKET_BAD)
1542 sclose(sock_tcp_listen);
1544 doh_conns_close_all();
1546 if(got_exit_signal)
1547 logmsg("signalled to die");
1549 if(dnsd_wrotepidfile)
1550 unlink(pidname);
1551 if(dnsd_wroteportfile)
1552 unlink(portname);
1554 if(serverlogslocked) {
1555 serverlogslocked = 0;
1556 clear_advisor_read_lock(loglockfile);
1557 }
1559 queue_udp_clear();
1561 restore_signal_handlers(FALSE);
1563 return result;
1564}
1565#else
1566static int test_dnsd(int argc, const char **argv)
1567{
1568 (void)argc;
1569 (void)argv;
1570 fprintf(stderr, "dnsd on AmigaOS is unsupported\n");
1571 return 1;
1572}
1573#endif
Diagnostics4 git calls · 314 ms
CallStatusSizeTime0314 ms
discover200152 B19 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=12 git.response.bytes=152 git.server.agent=gitty/1.0 git.server.object_format=sha1 git.server.caps=agent ls-refs fetch object-format git.server.fetch=shallow filter sideband-all git.protocol.version=2 git.pkt.frames=8 git.pkt.data=6 git.pkt.flush=2 git.pkt.delim=0 git.pkt.bytes=152 git.pkt.payload.max=34
ls-refs200149 B · hit19 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=19 git.response.bytes=149 git.response.cache=HIT git.response.duration_ms=19 git.protocol.version=2 git.pkt.frames=3 git.pkt.data=2 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=149 git.pkt.payload.max=78 git.ls_refs.count=2 git.ls_refs.head=refs/heads/master
fetchblob:none · deepen 10200287 KiB · hit12 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=283 git.response.bytes=293470 git.response.cache=HIT git.response.duration_ms=12 git.fetch.filter=blob:none git.fetch.filter.requested=tree:0 git.fetch.filter.fallback=blob:none git.fetch.filter.learned=false git.fetch.wants=31c911efe5652725e930f4d2e60c9060e5f6646d git.fetch.haves.count=0 git.fetch.deepen=10 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=10 git.pkt.data=8 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=293470 git.pkt.payload.max=65516 git.sideband.band1.bytes=293354 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=87 git.pack.bytes=293354 git.pack.ofs_delta=0 git.pack.ref_delta=1 git.pack.chain.max=1 git.pack.trailer=6a646bcda6740bab42e321b51998b52ea15146c0 git.pack.full=86Open pack map
fetch20012 KiB283 ms
git.upload-pack fetch http.response.status_code=200 git.response.bytes=12276 git.response.cache=MISS git.response.duration_ms=283 git.fetch.wants=ae51141cc1e7f84d7fe6c716e9cfc93167b8295d git.fetch.haves.count=0 git.fetch.deepen=0 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=3 git.pkt.data=2 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=12276 git.pkt.payload.max=12255 git.sideband.band1.bytes=12254 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0
Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.
- Remote
- https://5ad2236b39de4c8bd8f6270ea63f3ea9.artifacts.cloudflare.net/git/public-v0/curl.git
- Ref
- refs/heads/master
- Commit
- 31c911efe5652725e930f4d2e60c9060e5f6646d
- cf-ray
- a5e2ddca488f2308
- Request
- 9395e0b2…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format