libdns: Avoid using compound literals (3).
[gnupg.git] / dirmngr / dns.h
1 /* ==========================================================================
2  * dns.h - Recursive, Reentrant DNS Resolver.
3  * --------------------------------------------------------------------------
4  * Copyright (c) 2009, 2010, 2012-2015  William Ahern
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a
7  * copy of this software and associated documentation files (the
8  * "Software"), to deal in the Software without restriction, including
9  * without limitation the rights to use, copy, modify, merge, publish,
10  * distribute, sublicense, and/or sell copies of the Software, and to permit
11  * persons to whom the Software is furnished to do so, subject to the
12  * following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included
15  * in all copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
20  * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
21  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
22  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
23  * USE OR OTHER DEALINGS IN THE SOFTWARE.
24  * ==========================================================================
25  */
26 #ifndef DNS_H
27 #define DNS_H
28
29 #include <stddef.h>             /* size_t offsetof() */
30 #include <stdint.h>             /* uint64_t */
31 #include <stdio.h>              /* FILE */
32 #include <string.h>             /* strlen(3) */
33 #include <time.h>               /* struct timespec time_t */
34
35 #if _WIN32
36 #include <winsock2.h>
37 #include <ws2tcpip.h>
38 #else
39 #include <sys/param.h>          /* BYTE_ORDER BIG_ENDIAN _BIG_ENDIAN */
40 #include <sys/types.h>          /* socklen_t */
41 #include <sys/socket.h>         /* struct socket */
42 #include <poll.h>               /* POLLIN POLLOUT */
43 #include <netinet/in.h>         /* struct in_addr struct in6_addr */
44 #include <netdb.h>              /* struct addrinfo */
45 #endif
46
47
48 /*
49  * V I S I B I L I T Y
50  *
51  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
52
53 #ifndef DNS_PUBLIC
54 #define DNS_PUBLIC
55 #endif
56
57
58 /*
59  * V E R S I O N
60  *
61  * Vendor: Entity for which versions numbers are relevant. (If forking
62  * change DNS_VENDOR to avoid confusion.)
63  *
64  * Three versions:
65  *
66  * REL  Official "release"--bug fixes, new features, etc.
67  * ABI  Changes to existing object sizes or parameter types
68  * API  Changes that might effect application source.
69  *
70  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
71
72 #define DNS_VENDOR "william@25thandClement.com"
73
74 #define DNS_V_REL  0x20160809
75 #define DNS_V_ABI  0x20160608
76 #define DNS_V_API  0x20160809
77
78
79 DNS_PUBLIC const char *dns_vendor(void);
80
81 DNS_PUBLIC int dns_v_rel(void);
82 DNS_PUBLIC int dns_v_abi(void);
83 DNS_PUBLIC int dns_v_api(void);
84
85
86 /*
87  * E R R O R S
88  *
89  * Errors and exceptions are always returned through an int. This should
90  * hopefully make integration easier in the majority of circumstances, and
91  * also cut down on useless compiler warnings.
92  *
93  * System and library errors are returned together. POSIX guarantees that
94  * all system errors are positive integers. Library errors are always
95  * negative integers in the range DNS_EBASE to DNS_ELAST, with the high bits
96  * set to the three magic ASCII characters "dns".
97  *
98  * dns_strerror() returns static English string descriptions of all known
99  * errors, and punts the remainder to strerror(3).
100  *
101  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
102
103 #define DNS_EBASE -(('d' << 24) | ('n' << 16) | ('s' << 8) | 64)
104
105 #define dns_error_t int /* for documentation only */
106
107 enum dns_errno {
108         DNS_ENOBUFS = DNS_EBASE,
109         DNS_EILLEGAL,
110         DNS_EORDER,
111         DNS_ESECTION,
112         DNS_EUNKNOWN,
113         DNS_EADDRESS,
114         DNS_ENOQUERY,
115         DNS_ENOANSWER,
116         DNS_EFETCHED,
117         DNS_ESERVICE, /* EAI_SERVICE */
118         DNS_ENONAME,  /* EAI_NONAME */
119         DNS_EFAIL,    /* EAI_FAIL */
120         DNS_ECONNFIN,
121         DNS_EVERIFY,
122         DNS_ELAST,
123 }; /* dns_errno */
124
125 DNS_PUBLIC const char *dns_strerror(dns_error_t);
126
127 DNS_PUBLIC int *dns_debug_p(void);
128
129 #define dns_debug (*dns_debug_p()) /* was extern int dns_debug before 20160523 API */
130
131
132 /*
133  * C O M P I L E R  A N N O T A T I O N S
134  *
135  * GCC with -Wextra, and clang by default, complain about overrides in
136  * initializer lists. Overriding previous member initializers is well
137  * defined behavior in C. dns.c relies on this behavior to define default,
138  * overrideable member values when instantiating configuration objects.
139  *
140  * dns_quietinit() guards a compound literal expression with pragmas to
141  * silence these shrill warnings. This alleviates the burden of requiring
142  * third-party projects to adjust their compiler flags.
143  *
144  * NOTE: If you take the address of the compound literal, take the address
145  * of the transformed expression, otherwise the compound literal lifetime is
146  * tied to the scope of the GCC statement expression.
147  *
148  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
149
150 #if defined __clang__
151 #define DNS_PRAGMA_PUSH _Pragma("clang diagnostic push")
152 #define DNS_PRAGMA_QUIET _Pragma("clang diagnostic ignored \"-Winitializer-overrides\"")
153 #define DNS_PRAGMA_POP _Pragma("clang diagnostic pop")
154
155 #define dns_quietinit(...) \
156         DNS_PRAGMA_PUSH DNS_PRAGMA_QUIET __VA_ARGS__ DNS_PRAGMA_POP
157 #elif (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) || __GNUC__ > 4
158 #define DNS_PRAGMA_PUSH _Pragma("GCC diagnostic push")
159 #define DNS_PRAGMA_QUIET _Pragma("GCC diagnostic ignored \"-Woverride-init\"")
160 #define DNS_PRAGMA_POP _Pragma("GCC diagnostic pop")
161
162 /* GCC parses the _Pragma operator less elegantly than clang. */
163 #define dns_quietinit(...) \
164         __extension__ ({ DNS_PRAGMA_PUSH DNS_PRAGMA_QUIET __VA_ARGS__; DNS_PRAGMA_POP })
165 #else
166 #define DNS_PRAGMA_PUSH
167 #define DNS_PRAGMA_QUIET
168 #define DNS_PRAGMA_POP
169 #define dns_quietinit(...) __VA_ARGS__
170 #endif
171
172 #if defined __GNUC__
173 #define DNS_PRAGMA_EXTENSION __extension__
174 #else
175 #define DNS_PRAGMA_EXTENSION
176 #endif
177
178
179 /*
180  * E V E N T S  I N T E R F A C E S
181  *
182  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
183
184 #if defined(POLLIN)
185 #define DNS_POLLIN POLLIN
186 #else
187 #define DNS_POLLIN  1
188 #endif
189
190 #if defined(POLLOUT)
191 #define DNS_POLLOUT POLLOUT
192 #else
193 #define DNS_POLLOUT 2
194 #endif
195
196
197 /*
198  * See Application Interface below for configuring libevent bitmasks instead
199  * of poll(2) bitmasks.
200  */
201 #define DNS_EVREAD  2
202 #define DNS_EVWRITE 4
203
204
205 #define DNS_POLL2EV(set) \
206         (((set) & DNS_POLLIN)? DNS_EVREAD : 0) | (((set) & DNS_POLLOUT)? DNS_EVWRITE : 0)
207
208 #define DNS_EV2POLL(set) \
209         (((set) & DNS_EVREAD)? DNS_POLLIN : 0) | (((set) & DNS_EVWRITE)? DNS_POLLOUT : 0)
210
211
212 /*
213  * E N U M E R A T I O N  I N T E R F A C E S
214  *
215  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
216
217 enum dns_section {
218         DNS_S_QD                = 0x01,
219 #define DNS_S_QUESTION          DNS_S_QD
220
221         DNS_S_AN                = 0x02,
222 #define DNS_S_ANSWER            DNS_S_AN
223
224         DNS_S_NS                = 0x04,
225 #define DNS_S_AUTHORITY         DNS_S_NS
226
227         DNS_S_AR                = 0x08,
228 #define DNS_S_ADDITIONAL        DNS_S_AR
229
230         DNS_S_ALL               = 0x0f
231 }; /* enum dns_section */
232
233
234 enum dns_class {
235         DNS_C_IN        = 1,
236
237         DNS_C_ANY       = 255
238 }; /* enum dns_class */
239
240
241 enum dns_type {
242         DNS_T_A         = 1,
243         DNS_T_NS        = 2,
244         DNS_T_CNAME     = 5,
245         DNS_T_SOA       = 6,
246         DNS_T_PTR       = 12,
247         DNS_T_MX        = 15,
248         DNS_T_TXT       = 16,
249         DNS_T_AAAA      = 28,
250         DNS_T_SRV       = 33,
251         DNS_T_OPT       = 41,
252         DNS_T_SSHFP     = 44,
253         DNS_T_SPF       = 99,
254         DNS_T_AXFR      = 252,
255
256         DNS_T_ALL       = 255
257 }; /* enum dns_type */
258
259
260 enum dns_opcode {
261         DNS_OP_QUERY    = 0,
262         DNS_OP_IQUERY   = 1,
263         DNS_OP_STATUS   = 2,
264         DNS_OP_NOTIFY   = 4,
265         DNS_OP_UPDATE   = 5,
266 }; /* dns_opcode */
267
268
269 enum dns_rcode {
270         DNS_RC_NOERROR  = 0,
271         DNS_RC_FORMERR  = 1,
272         DNS_RC_SERVFAIL = 2,
273         DNS_RC_NXDOMAIN = 3,
274         DNS_RC_NOTIMP   = 4,
275         DNS_RC_REFUSED  = 5,
276         DNS_RC_YXDOMAIN = 6,
277         DNS_RC_YXRRSET  = 7,
278         DNS_RC_NXRRSET  = 8,
279         DNS_RC_NOTAUTH  = 9,
280         DNS_RC_NOTZONE  = 10,
281
282         /* EDNS(0) extended RCODEs */
283         DNS_RC_BADVERS = 16,
284 }; /* dns_rcode */
285
286
287 /*
288  * NOTE: These string functions need a small buffer in case the literal
289  * integer value needs to be printed and returned. UNLESS this buffer is
290  * SPECIFIED, the returned string has ONLY BLOCK SCOPE.
291  */
292 #define DNS_STRMAXLEN 47 /* "QUESTION|ANSWER|AUTHORITY|ADDITIONAL" */
293
294 DNS_PUBLIC const char *dns_strsection(enum dns_section);
295
296 DNS_PUBLIC enum dns_section dns_isection(const char *);
297
298 DNS_PUBLIC const char *dns_strclass(enum dns_class);
299
300 DNS_PUBLIC enum dns_class dns_iclass(const char *);
301
302 DNS_PUBLIC const char *dns_strtype(enum dns_type);
303
304 DNS_PUBLIC enum dns_type dns_itype(const char *);
305
306 DNS_PUBLIC const char *dns_stropcode(enum dns_opcode);
307
308 DNS_PUBLIC enum dns_opcode dns_iopcode(const char *);
309
310 DNS_PUBLIC const char *dns_strrcode(enum dns_rcode);
311
312 DNS_PUBLIC enum dns_rcode dns_ircode(const char *);
313
314
315 /*
316  * A T O M I C  I N T E R F A C E S
317  *
318  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
319
320 typedef unsigned long dns_atomic_t;
321
322 typedef unsigned long dns_refcount_t; /* must be same value type as dns_atomic_t */
323
324
325 /*
326  * C R Y P T O  I N T E R F A C E S
327  *
328  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
329
330 typedef unsigned dns_random_f(void);
331
332 DNS_PUBLIC dns_random_f **dns_random_p(void);
333
334 #define dns_random (*dns_random_p()) /* was extern unsigned (*dns_random)(void) before 20160523 API */
335
336
337 /*
338  * P A C K E T  I N T E R F A C E
339  *
340  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
341
342 struct dns_header {
343                 unsigned qid:16;
344
345 #if (defined BYTE_ORDER && BYTE_ORDER == BIG_ENDIAN) || (defined __sun && defined _BIG_ENDIAN)
346                 unsigned qr:1;
347                 unsigned opcode:4;
348                 unsigned aa:1;
349                 unsigned tc:1;
350                 unsigned rd:1;
351
352                 unsigned ra:1;
353                 unsigned unused:3;
354                 unsigned rcode:4;
355 #else
356                 unsigned rd:1;
357                 unsigned tc:1;
358                 unsigned aa:1;
359                 unsigned opcode:4;
360                 unsigned qr:1;
361
362                 unsigned rcode:4;
363                 unsigned unused:3;
364                 unsigned ra:1;
365 #endif
366
367                 unsigned qdcount:16;
368                 unsigned ancount:16;
369                 unsigned nscount:16;
370                 unsigned arcount:16;
371 }; /* struct dns_header */
372
373 #define dns_header(p)   (&(p)->header)
374
375
376 #ifndef DNS_P_QBUFSIZ
377 #define DNS_P_QBUFSIZ   dns_p_calcsize(256 + 4)
378 #endif
379
380 #ifndef DNS_P_DICTSIZE
381 #define DNS_P_DICTSIZE  16
382 #endif
383
384 struct dns_packet {
385         unsigned short dict[DNS_P_DICTSIZE];
386
387         struct dns_p_memo {
388                 struct dns_s_memo {
389                         unsigned short base, end;
390                 } qd, an, ns, ar;
391
392                 struct {
393                         unsigned short p;
394                         unsigned short maxudp;
395                         unsigned ttl;
396                 } opt;
397         } memo;
398
399         struct { struct dns_packet *cqe_next, *cqe_prev; } cqe;
400
401         size_t size, end;
402
403         int:16; /* tcp padding */
404
405         DNS_PRAGMA_EXTENSION union {
406                 struct dns_header header;
407                 unsigned char data[1];
408         };
409 }; /* struct dns_packet */
410
411 #define dns_p_calcsize(n)       (offsetof(struct dns_packet, data) + DNS_PP_MAX(12, (n)))
412
413 #define dns_p_sizeof(P)         dns_p_calcsize((P)->end)
414
415 /** takes size of entire packet structure as allocated */
416 DNS_PUBLIC struct dns_packet *dns_p_init(struct dns_packet *, size_t);
417
418 /** takes size of maximum desired payload */
419 DNS_PUBLIC struct dns_packet *dns_p_make(size_t, int *);
420
421 DNS_PUBLIC int dns_p_grow(struct dns_packet **);
422
423 DNS_PUBLIC struct dns_packet *dns_p_copy(struct dns_packet *, const struct dns_packet *);
424
425 #define dns_p_opcode(P)         (dns_header(P)->opcode)
426
427 DNS_PUBLIC enum dns_rcode dns_p_rcode(struct dns_packet *);
428
429 DNS_PUBLIC unsigned dns_p_count(struct dns_packet *, enum dns_section);
430
431 DNS_PUBLIC int dns_p_push(struct dns_packet *, enum dns_section, const void *, size_t, enum dns_type, enum dns_class, unsigned, const void *);
432
433 DNS_PUBLIC void dns_p_dictadd(struct dns_packet *, unsigned short);
434
435 DNS_PUBLIC struct dns_packet *dns_p_merge(struct dns_packet *, enum dns_section, struct dns_packet *, enum dns_section, int *);
436
437 DNS_PUBLIC void dns_p_dump(struct dns_packet *, FILE *);
438
439 DNS_PUBLIC int dns_p_study(struct dns_packet *);
440
441
442 /*
443  * D O M A I N  N A M E  I N T E R F A C E S
444  *
445  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
446
447 #define DNS_D_MAXLABEL  63      /* + 1 '\0' */
448 #define DNS_D_MAXNAME   255     /* + 1 '\0' */
449
450 #define DNS_D_ANCHOR    1       /* anchor domain w/ root "." */
451 #define DNS_D_CLEAVE    2       /* cleave sub-domain */
452 #define DNS_D_TRIM      4       /* remove superfluous dots */
453
454 #define dns_d_new3(a, b, f)     dns_d_init(&(char[DNS_D_MAXNAME + 1]){ 0 }, DNS_D_MAXNAME + 1, (a), (b), (f))
455 #define dns_d_new2(a, f)        dns_d_new3((a), strlen((a)), (f))
456 #define dns_d_new1(a)           dns_d_new3((a), strlen((a)), DNS_D_ANCHOR)
457 #define dns_d_new(...)          DNS_PP_CALL(DNS_PP_XPASTE(dns_d_new, DNS_PP_NARG(__VA_ARGS__)), __VA_ARGS__)
458
459 DNS_PUBLIC char *dns_d_init(void *, size_t, const void *, size_t, int);
460
461 DNS_PUBLIC size_t dns_d_anchor(void *, size_t, const void *, size_t);
462
463 DNS_PUBLIC size_t dns_d_cleave(void *, size_t, const void *, size_t);
464
465 DNS_PUBLIC size_t dns_d_comp(void *, size_t, const void *, size_t, struct dns_packet *, int *);
466
467 DNS_PUBLIC size_t dns_d_expand(void *, size_t, unsigned short, struct dns_packet *, int *);
468
469 DNS_PUBLIC unsigned short dns_d_skip(unsigned short, struct dns_packet *);
470
471 DNS_PUBLIC int dns_d_push(struct dns_packet *, const void *, size_t);
472
473 DNS_PUBLIC size_t dns_d_cname(void *, size_t, const void *, size_t, struct dns_packet *, int *error);
474
475
476 /*
477  * R E S O U R C E  R E C O R D  I N T E R F A C E S
478  *
479  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
480
481 struct dns_rr {
482         enum dns_section section;
483
484         struct {
485                 unsigned short p;
486                 unsigned short len;
487         } dn;
488
489         enum dns_type type;
490         enum dns_class class;
491         unsigned ttl;
492
493         struct {
494                 unsigned short p;
495                 unsigned short len;
496         } rd;
497 }; /* struct dns_rr */
498
499
500 DNS_PUBLIC int dns_rr_copy(struct dns_packet *, struct dns_rr *, struct dns_packet *);
501
502 DNS_PUBLIC int dns_rr_parse(struct dns_rr *, unsigned short, struct dns_packet *);
503
504 DNS_PUBLIC unsigned short dns_rr_skip(unsigned short, struct dns_packet *);
505
506 DNS_PUBLIC int dns_rr_cmp(struct dns_rr *, struct dns_packet *, struct dns_rr *, struct dns_packet *);
507
508 DNS_PUBLIC size_t dns_rr_print(void *, size_t, struct dns_rr *, struct dns_packet *, int *);
509
510
511 #define dns_rr_i_new(P, ...) \
512         dns_rr_i_init(&dns_quietinit((struct dns_rr_i){ 0, __VA_ARGS__ }), (P))
513
514 struct dns_rr_i {
515         enum dns_section section;
516         const void *name;
517         enum dns_type type;
518         enum dns_class class;
519         const void *data;
520
521         int follow;
522
523         int (*sort)(struct dns_rr *, struct dns_rr *, struct dns_rr_i *, struct dns_packet *);
524         unsigned args[2];
525
526         struct {
527                 unsigned short next;
528                 unsigned short count;
529
530                 unsigned exec;
531                 unsigned regs[2];
532         } state, saved;
533 }; /* struct dns_rr_i */
534
535 DNS_PUBLIC int dns_rr_i_packet(struct dns_rr *, struct dns_rr *, struct dns_rr_i *, struct dns_packet *);
536
537 DNS_PUBLIC int dns_rr_i_order(struct dns_rr *, struct dns_rr *, struct dns_rr_i *, struct dns_packet *);
538
539 DNS_PUBLIC int dns_rr_i_shuffle(struct dns_rr *, struct dns_rr *, struct dns_rr_i *, struct dns_packet *);
540
541 DNS_PUBLIC struct dns_rr_i *dns_rr_i_init(struct dns_rr_i *, struct dns_packet *);
542
543 #define dns_rr_i_save(i)        ((i)->saved = (i)->state)
544 #define dns_rr_i_rewind(i)      ((i)->state = (i)->saved)
545 #define dns_rr_i_count(i)       ((i)->state.count)
546
547 DNS_PUBLIC unsigned dns_rr_grep(struct dns_rr *, unsigned, struct dns_rr_i *, struct dns_packet *, int *);
548
549 #define dns_rr_foreach_(rr, P, ...)     \
550         for (struct dns_rr_i DNS_PP_XPASTE(i, __LINE__) = *dns_rr_i_new((P), __VA_ARGS__); dns_rr_grep((rr), 1, &DNS_PP_XPASTE(i, __LINE__), (P), &(int){ 0 }); )
551
552 #define dns_rr_foreach(...)     dns_rr_foreach_(__VA_ARGS__)
553
554
555 /*
556  * A  R E S O U R C E  R E C O R D
557  */
558
559 struct dns_a {
560         struct in_addr addr;
561 }; /* struct dns_a */
562
563 DNS_PUBLIC int dns_a_parse(struct dns_a *, struct dns_rr *, struct dns_packet *);
564
565 DNS_PUBLIC int dns_a_push(struct dns_packet *, struct dns_a *);
566
567 DNS_PUBLIC int dns_a_cmp(const struct dns_a *, const struct dns_a *);
568
569 DNS_PUBLIC size_t dns_a_print(void *, size_t, struct dns_a *);
570
571 DNS_PUBLIC size_t dns_a_arpa(void *, size_t, const struct dns_a *);
572
573
574 /*
575  * AAAA  R E S O U R C E  R E C O R D
576  */
577
578 struct dns_aaaa {
579         struct in6_addr addr;
580 }; /* struct dns_aaaa */
581
582 DNS_PUBLIC int dns_aaaa_parse(struct dns_aaaa *, struct dns_rr *, struct dns_packet *);
583
584 DNS_PUBLIC int dns_aaaa_push(struct dns_packet *, struct dns_aaaa *);
585
586 DNS_PUBLIC int dns_aaaa_cmp(const struct dns_aaaa *, const struct dns_aaaa *);
587
588 DNS_PUBLIC size_t dns_aaaa_print(void *, size_t, struct dns_aaaa *);
589
590 DNS_PUBLIC size_t dns_aaaa_arpa(void *, size_t, const struct dns_aaaa *);
591
592
593 /*
594  * MX  R E S O U R C E  R E C O R D
595  */
596
597 struct dns_mx {
598         unsigned short preference;
599         char host[DNS_D_MAXNAME + 1];
600 }; /* struct dns_mx */
601
602 DNS_PUBLIC int dns_mx_parse(struct dns_mx *, struct dns_rr *, struct dns_packet *);
603
604 DNS_PUBLIC int dns_mx_push(struct dns_packet *, struct dns_mx *);
605
606 DNS_PUBLIC int dns_mx_cmp(const struct dns_mx *, const struct dns_mx *);
607
608 DNS_PUBLIC size_t dns_mx_print(void *, size_t, struct dns_mx *);
609
610 DNS_PUBLIC size_t dns_mx_cname(void *, size_t, struct dns_mx *);
611
612
613 /*
614  * NS  R E S O U R C E  R E C O R D
615  */
616
617 struct dns_ns {
618         char host[DNS_D_MAXNAME + 1];
619 }; /* struct dns_ns */
620
621 DNS_PUBLIC int dns_ns_parse(struct dns_ns *, struct dns_rr *, struct dns_packet *);
622
623 DNS_PUBLIC int dns_ns_push(struct dns_packet *, struct dns_ns *);
624
625 DNS_PUBLIC int dns_ns_cmp(const struct dns_ns *, const struct dns_ns *);
626
627 DNS_PUBLIC size_t dns_ns_print(void *, size_t, struct dns_ns *);
628
629 DNS_PUBLIC size_t dns_ns_cname(void *, size_t, struct dns_ns *);
630
631
632 /*
633  * CNAME  R E S O U R C E  R E C O R D
634  */
635
636 struct dns_cname {
637         char host[DNS_D_MAXNAME + 1];
638 }; /* struct dns_cname */
639
640 DNS_PUBLIC int dns_cname_parse(struct dns_cname *, struct dns_rr *, struct dns_packet *);
641
642 DNS_PUBLIC int dns_cname_push(struct dns_packet *, struct dns_cname *);
643
644 DNS_PUBLIC int dns_cname_cmp(const struct dns_cname *, const struct dns_cname *);
645
646 DNS_PUBLIC size_t dns_cname_print(void *, size_t, struct dns_cname *);
647
648 DNS_PUBLIC size_t dns_cname_cname(void *, size_t, struct dns_cname *);
649
650
651 /*
652  * SOA  R E S O U R C E  R E C O R D
653  */
654
655 struct dns_soa {
656         char mname[DNS_D_MAXNAME + 1];
657         char rname[DNS_D_MAXNAME + 1];
658         unsigned serial, refresh, retry, expire, minimum;
659 }; /* struct dns_soa */
660
661 DNS_PUBLIC int dns_soa_parse(struct dns_soa *, struct dns_rr *, struct dns_packet *);
662
663 DNS_PUBLIC int dns_soa_push(struct dns_packet *, struct dns_soa *);
664
665 DNS_PUBLIC int dns_soa_cmp(const struct dns_soa *, const struct dns_soa *);
666
667 DNS_PUBLIC size_t dns_soa_print(void *, size_t, struct dns_soa *);
668
669
670 /*
671  * PTR  R E S O U R C E  R E C O R D
672  */
673
674 struct dns_ptr {
675         char host[DNS_D_MAXNAME + 1];
676 }; /* struct dns_ptr */
677
678 DNS_PUBLIC int dns_ptr_parse(struct dns_ptr *, struct dns_rr *, struct dns_packet *);
679
680 DNS_PUBLIC int dns_ptr_push(struct dns_packet *, struct dns_ptr *);
681
682 DNS_PUBLIC int dns_ptr_cmp(const struct dns_ptr *, const struct dns_ptr *);
683
684 DNS_PUBLIC size_t dns_ptr_print(void *, size_t, struct dns_ptr *);
685
686 DNS_PUBLIC size_t dns_ptr_cname(void *, size_t, struct dns_ptr *);
687
688 DNS_PUBLIC size_t dns_ptr_qname(void *, size_t, int, void *);
689
690
691 /*
692  * SRV  R E S O U R C E  R E C O R D
693  */
694
695 struct dns_srv {
696         unsigned short priority;
697         unsigned short weight;
698         unsigned short port;
699         char target[DNS_D_MAXNAME + 1];
700 }; /* struct dns_srv */
701
702 DNS_PUBLIC int dns_srv_parse(struct dns_srv *, struct dns_rr *, struct dns_packet *);
703
704 DNS_PUBLIC int dns_srv_push(struct dns_packet *, struct dns_srv *);
705
706 DNS_PUBLIC int dns_srv_cmp(const struct dns_srv *, const struct dns_srv *);
707
708 DNS_PUBLIC size_t dns_srv_print(void *, size_t, struct dns_srv *);
709
710 DNS_PUBLIC size_t dns_srv_cname(void *, size_t, struct dns_srv *);
711
712
713 /*
714  * OPT  R E S O U R C E  R E C O R D
715  */
716
717 #ifndef DNS_OPT_MINDATA
718 #define DNS_OPT_MINDATA 256
719 #endif
720
721 #define DNS_OPT_DNSSEC  0x8000
722
723 struct dns_opt {
724         enum dns_rcode rcode;
725         unsigned char version;
726         unsigned short flags;
727
728         union {
729                 unsigned short maxsize; /* deprecated as confusing */
730                 unsigned short maxudp; /* maximum UDP payload size */
731         };
732
733         size_t size, len;
734         unsigned char data[DNS_OPT_MINDATA];
735 }; /* struct dns_opt */
736
737 #define DNS_OPT_INIT(opt) { .size = sizeof (*opt) - offsetof(struct dns_opt, data) }
738
739 DNS_PUBLIC struct dns_opt *dns_opt_init(struct dns_opt *, size_t);
740
741 DNS_PUBLIC int dns_opt_parse(struct dns_opt *, struct dns_rr *, struct dns_packet *);
742
743 DNS_PUBLIC int dns_opt_push(struct dns_packet *, struct dns_opt *);
744
745 DNS_PUBLIC int dns_opt_cmp(const struct dns_opt *, const struct dns_opt *);
746
747 DNS_PUBLIC size_t dns_opt_print(void *, size_t, struct dns_opt *);
748
749 DNS_PUBLIC unsigned int dns_opt_ttl(const struct dns_opt *);
750
751 DNS_PUBLIC unsigned short dns_opt_class(const struct dns_opt *);
752
753 DNS_PUBLIC dns_error_t dns_opt_data_push(struct dns_opt *, unsigned char, unsigned short, const void *);
754
755
756 /*
757  * SSHFP  R E S O U R C E  R E C O R D
758  */
759
760 struct dns_sshfp {
761         enum dns_sshfp_key {
762                 DNS_SSHFP_RSA = 1,
763                 DNS_SSHFP_DSA = 2,
764         } algo;
765
766         enum dns_sshfp_digest {
767                 DNS_SSHFP_SHA1 = 1,
768         } type;
769
770         union {
771                 unsigned char sha1[20];
772         } digest;
773 }; /* struct dns_sshfp */
774
775 DNS_PUBLIC int dns_sshfp_parse(struct dns_sshfp *, struct dns_rr *, struct dns_packet *);
776
777 DNS_PUBLIC int dns_sshfp_push(struct dns_packet *, struct dns_sshfp *);
778
779 DNS_PUBLIC int dns_sshfp_cmp(const struct dns_sshfp *, const struct dns_sshfp *);
780
781 DNS_PUBLIC size_t dns_sshfp_print(void *, size_t, struct dns_sshfp *);
782
783
784 /*
785  * TXT  R E S O U R C E  R E C O R D
786  */
787
788 #ifndef DNS_TXT_MINDATA
789 #define DNS_TXT_MINDATA 1024
790 #endif
791
792 struct dns_txt {
793         size_t size, len;
794         unsigned char data[DNS_TXT_MINDATA];
795 }; /* struct dns_txt */
796
797 DNS_PUBLIC struct dns_txt *dns_txt_init(struct dns_txt *, size_t);
798
799 DNS_PUBLIC int dns_txt_parse(struct dns_txt *, struct dns_rr *, struct dns_packet *);
800
801 DNS_PUBLIC int dns_txt_push(struct dns_packet *, struct dns_txt *);
802
803 DNS_PUBLIC int dns_txt_cmp(const struct dns_txt *, const struct dns_txt *);
804
805 DNS_PUBLIC size_t dns_txt_print(void *, size_t, struct dns_txt *);
806
807
808 /*
809  * ANY  R E S O U R C E  R E C O R D
810  */
811
812 union dns_any {
813         struct dns_a a;
814         struct dns_aaaa aaaa;
815         struct dns_mx mx;
816         struct dns_ns ns;
817         struct dns_cname cname;
818         struct dns_soa soa;
819         struct dns_ptr ptr;
820         struct dns_srv srv;
821         struct dns_opt opt;
822         struct dns_sshfp sshfp;
823         struct dns_txt txt, spf, rdata;
824 }; /* union dns_any */
825
826 #define DNS_ANY_INIT(any) { .rdata = { .size = sizeof *(any) - offsetof(struct dns_txt, data) } }
827
828 DNS_PUBLIC union dns_any *dns_any_init(union dns_any *, size_t);
829
830 DNS_PUBLIC int dns_any_parse(union dns_any *, struct dns_rr *, struct dns_packet *);
831
832 DNS_PUBLIC int dns_any_push(struct dns_packet *, union dns_any *, enum dns_type);
833
834 DNS_PUBLIC int dns_any_cmp(const union dns_any *, enum dns_type, const union dns_any *, enum dns_type);
835
836 DNS_PUBLIC size_t dns_any_print(void *, size_t, union dns_any *, enum dns_type);
837
838 DNS_PUBLIC size_t dns_any_cname(void *, size_t, union dns_any *, enum dns_type);
839
840
841 /*
842  * H O S T S  I N T E R F A C E
843  *
844  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
845
846 struct dns_hosts;
847
848 DNS_PUBLIC struct dns_hosts *dns_hosts_open(int *);
849
850 DNS_PUBLIC void dns_hosts_close(struct dns_hosts *);
851
852 DNS_PUBLIC dns_refcount_t dns_hosts_acquire(struct dns_hosts *);
853
854 DNS_PUBLIC dns_refcount_t dns_hosts_release(struct dns_hosts *);
855
856 DNS_PUBLIC struct dns_hosts *dns_hosts_mortal(struct dns_hosts *);
857
858 DNS_PUBLIC struct dns_hosts *dns_hosts_local(int *);
859
860 DNS_PUBLIC int dns_hosts_loadfile(struct dns_hosts *, FILE *);
861
862 DNS_PUBLIC int dns_hosts_loadpath(struct dns_hosts *, const char *);
863
864 DNS_PUBLIC int dns_hosts_dump(struct dns_hosts *, FILE *);
865
866 DNS_PUBLIC int dns_hosts_insert(struct dns_hosts *, int, const void *, const void *, _Bool);
867
868 DNS_PUBLIC struct dns_packet *dns_hosts_query(struct dns_hosts *, struct dns_packet *, int *);
869
870
871 /*
872  * R E S O L V . C O N F  I N T E R F A C E
873  *
874  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
875
876 struct dns_resolv_conf {
877         struct sockaddr_storage nameserver[3];
878
879         char search[4][DNS_D_MAXNAME + 1];
880
881         /* (f)ile, (b)ind, (c)ache */
882         char lookup[4 * (1 + (4 * 2))];
883
884         /* getaddrinfo family by preference order ("inet4", "inet6") */
885         int family[3];
886
887         struct {
888                 _Bool edns0;
889
890                 unsigned ndots;
891
892                 unsigned timeout;
893
894                 unsigned attempts;
895
896                 _Bool rotate;
897
898                 _Bool recurse;
899
900                 _Bool smart;
901
902                 enum {
903                         DNS_RESCONF_TCP_ENABLE,
904                         DNS_RESCONF_TCP_ONLY,
905                         DNS_RESCONF_TCP_SOCKS,
906                         DNS_RESCONF_TCP_DISABLE,
907                 } tcp;
908         } options;
909
910         struct sockaddr_storage iface;
911
912         struct { /* PRIVATE */
913                 dns_atomic_t refcount;
914         } _;
915 }; /* struct dns_resolv_conf */
916
917 DNS_PUBLIC struct dns_resolv_conf *dns_resconf_open(int *);
918
919 DNS_PUBLIC void dns_resconf_close(struct dns_resolv_conf *);
920
921 DNS_PUBLIC dns_refcount_t dns_resconf_acquire(struct dns_resolv_conf *);
922
923 DNS_PUBLIC dns_refcount_t dns_resconf_release(struct dns_resolv_conf *);
924
925 DNS_PUBLIC struct dns_resolv_conf *dns_resconf_mortal(struct dns_resolv_conf *);
926
927 DNS_PUBLIC struct dns_resolv_conf *dns_resconf_local(int *);
928
929 DNS_PUBLIC struct dns_resolv_conf *dns_resconf_root(int *);
930
931 DNS_PUBLIC int dns_resconf_pton(struct sockaddr_storage *, const char *);
932
933 DNS_PUBLIC int dns_resconf_loadfile(struct dns_resolv_conf *, FILE *);
934
935 DNS_PUBLIC int dns_resconf_loadpath(struct dns_resolv_conf *, const char *);
936
937 DNS_PUBLIC int dns_nssconf_loadfile(struct dns_resolv_conf *, FILE *);
938
939 DNS_PUBLIC int dns_nssconf_loadpath(struct dns_resolv_conf *, const char *);
940
941 DNS_PUBLIC int dns_resconf_dump(struct dns_resolv_conf *, FILE *);
942
943 DNS_PUBLIC int dns_nssconf_dump(struct dns_resolv_conf *, FILE *);
944
945 DNS_PUBLIC int dns_resconf_setiface(struct dns_resolv_conf *, const char *, unsigned short);
946
947 typedef unsigned long dns_resconf_i_t;
948
949 DNS_PUBLIC size_t dns_resconf_search(void *, size_t, const void *, size_t, struct dns_resolv_conf *, dns_resconf_i_t *);
950
951
952 /*
953  * H I N T  S E R V E R  I N T E R F A C E
954  *
955  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
956
957 struct dns_hints;
958
959 DNS_PUBLIC struct dns_hints *dns_hints_open(struct dns_resolv_conf *, int *);
960
961 DNS_PUBLIC void dns_hints_close(struct dns_hints *);
962
963 DNS_PUBLIC dns_refcount_t dns_hints_acquire(struct dns_hints *);
964
965 DNS_PUBLIC dns_refcount_t dns_hints_release(struct dns_hints *);
966
967 DNS_PUBLIC struct dns_hints *dns_hints_mortal(struct dns_hints *);
968
969 DNS_PUBLIC int dns_hints_insert(struct dns_hints *, const char *, const struct sockaddr *, unsigned);
970
971 DNS_PUBLIC unsigned dns_hints_insert_resconf(struct dns_hints *, const char *, const struct dns_resolv_conf *, int *);
972
973 DNS_PUBLIC struct dns_hints *dns_hints_local(struct dns_resolv_conf *, int *);
974
975 DNS_PUBLIC struct dns_hints *dns_hints_root(struct dns_resolv_conf *, int *);
976
977 DNS_PUBLIC struct dns_packet *dns_hints_query(struct dns_hints *, struct dns_packet *, int *);
978
979 DNS_PUBLIC int dns_hints_dump(struct dns_hints *, FILE *);
980
981
982 struct dns_hints_i {
983         const char *zone;
984
985         struct {
986                 unsigned next;
987                 unsigned seed;
988         } state;
989 }; /* struct dns_hints_i */
990
991 #define dns_hints_i_new(...)    (&(struct dns_hints_i){ __VA_ARGS__ })
992
993 DNS_PUBLIC unsigned dns_hints_grep(struct sockaddr **, socklen_t *, unsigned, struct dns_hints_i *, struct dns_hints *);
994
995
996 /*
997  * C A C H E  I N T E R F A C E
998  *
999  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1000
1001 struct dns_cache {
1002         void *state;
1003
1004         dns_refcount_t (*acquire)(struct dns_cache *);
1005         dns_refcount_t (*release)(struct dns_cache *);
1006
1007         struct dns_packet *(*query)(struct dns_packet *, struct dns_cache *, int *);
1008
1009         int (*submit)(struct dns_packet *, struct dns_cache *);
1010         int (*check)(struct dns_cache *);
1011         struct dns_packet *(*fetch)(struct dns_cache *, int *);
1012
1013         int (*pollfd)(struct dns_cache *);
1014         short (*events)(struct dns_cache *);
1015         void (*clear)(struct dns_cache *);
1016
1017         union {
1018                 long i;
1019                 void *p;
1020         } arg[3];
1021
1022         struct { /* PRIVATE */
1023                 dns_atomic_t refcount;
1024         } _;
1025 }; /* struct dns_cache */
1026
1027
1028 DNS_PUBLIC struct dns_cache *dns_cache_init(struct dns_cache *);
1029
1030 DNS_PUBLIC void dns_cache_close(struct dns_cache *);
1031
1032
1033 /*
1034  * A P P L I C A T I O N  I N T E R F A C E
1035  *
1036  * Options to change the behavior of the API. Applies across all the
1037  * different components.
1038  *
1039  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1040
1041 #define DNS_OPTS_INITIALIZER_ { 0, 0 }, 0, 0
1042 #define DNS_OPTS_INITIALIZER  { DNS_OPTS_INITIALIZER_ }
1043 #define DNS_OPTS_INIT(...)    { DNS_OPTS_INITIALIZER_, __VA_ARGS__ }
1044
1045 #define dns_opts(...) (&dns_quietinit((struct dns_options)DNS_OPTS_INIT(__VA_ARGS__)))
1046
1047 struct dns_options {
1048         /*
1049          * If the callback closes *fd, it must set it to -1. Otherwise, the
1050          * descriptor is queued and lazily closed at object destruction or
1051          * by an explicit call to _clear(). This allows safe use of
1052          * kqueue(2), epoll(2), et al -style persistent events.
1053          */
1054         struct {
1055                 void *arg;
1056                 int (*cb)(int *fd, void *arg);
1057         } closefd;
1058
1059         /* bitmask for _events() routines */
1060         enum dns_events {
1061                 DNS_SYSPOLL,
1062                 DNS_LIBEVENT,
1063         } events;
1064
1065         /* Use this SOCKS server.  */
1066         const struct sockaddr_storage *socks_host;
1067
1068         /* Credentials for the SOCKS server (optional).  */
1069         const char *socks_user;
1070         const char *socks_password;
1071 }; /* struct dns_options */
1072
1073
1074 /*
1075  * S T A T S  I N T E R F A C E S
1076  *
1077  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1078
1079 struct dns_stat {
1080         size_t queries;
1081
1082         struct {
1083                 struct {
1084                         size_t count, bytes;
1085                 } sent, rcvd;
1086         } udp, tcp;
1087 }; /* struct dns_stat */
1088
1089
1090 /*
1091  * S O C K E T  I N T E R F A C E
1092  *
1093  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1094
1095 struct dns_socket;
1096
1097 DNS_PUBLIC struct dns_socket *dns_so_open(const struct sockaddr *, int, const struct dns_options *, int *error);
1098
1099 DNS_PUBLIC void dns_so_close(struct dns_socket *);
1100
1101 DNS_PUBLIC void dns_so_reset(struct dns_socket *);
1102
1103 DNS_PUBLIC unsigned short dns_so_mkqid(struct dns_socket *so);
1104
1105 DNS_PUBLIC struct dns_packet *dns_so_query(struct dns_socket *, struct dns_packet *, struct sockaddr *, int *);
1106
1107 DNS_PUBLIC int dns_so_submit(struct dns_socket *, struct dns_packet *, struct sockaddr *);
1108
1109 DNS_PUBLIC int dns_so_check(struct dns_socket *);
1110
1111 DNS_PUBLIC struct dns_packet *dns_so_fetch(struct dns_socket *, int *);
1112
1113 DNS_PUBLIC time_t dns_so_elapsed(struct dns_socket *);
1114
1115 DNS_PUBLIC void dns_so_clear(struct dns_socket *);
1116
1117 DNS_PUBLIC int dns_so_events(struct dns_socket *);
1118
1119 DNS_PUBLIC int dns_so_pollfd(struct dns_socket *);
1120
1121 DNS_PUBLIC int dns_so_poll(struct dns_socket *, int);
1122
1123 DNS_PUBLIC const struct dns_stat *dns_so_stat(struct dns_socket *);
1124
1125 DNS_PUBLIC struct dns_trace *dns_so_trace(struct dns_socket *);
1126
1127 DNS_PUBLIC void dns_so_settrace(struct dns_socket *, struct dns_trace *);
1128
1129
1130 /*
1131  * R E S O L V E R  I N T E R F A C E
1132  *
1133  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1134
1135 struct dns_resolver;
1136
1137 DNS_PUBLIC struct dns_resolver *dns_res_open(struct dns_resolv_conf *, struct dns_hosts *hosts, struct dns_hints *, struct dns_cache *, const struct dns_options *, int *);
1138
1139 DNS_PUBLIC struct dns_resolver *dns_res_stub(const struct dns_options *, int *);
1140
1141 DNS_PUBLIC void dns_res_reset(struct dns_resolver *);
1142
1143 DNS_PUBLIC void dns_res_close(struct dns_resolver *);
1144
1145 DNS_PUBLIC dns_refcount_t dns_res_acquire(struct dns_resolver *);
1146
1147 DNS_PUBLIC dns_refcount_t dns_res_release(struct dns_resolver *);
1148
1149 DNS_PUBLIC struct dns_resolver *dns_res_mortal(struct dns_resolver *);
1150
1151 DNS_PUBLIC int dns_res_submit(struct dns_resolver *, const char *, enum dns_type, enum dns_class);
1152
1153 DNS_PUBLIC int dns_res_submit2(struct dns_resolver *, const char *, size_t, enum dns_type, enum dns_class);
1154
1155 DNS_PUBLIC int dns_res_check(struct dns_resolver *);
1156
1157 DNS_PUBLIC struct dns_packet *dns_res_fetch(struct dns_resolver *, int *);
1158
1159 DNS_PUBLIC time_t dns_res_elapsed(struct dns_resolver *);
1160
1161 DNS_PUBLIC void dns_res_clear(struct dns_resolver *);
1162
1163 DNS_PUBLIC int dns_res_events(struct dns_resolver *);
1164
1165 DNS_PUBLIC int dns_res_pollfd(struct dns_resolver *);
1166
1167 DNS_PUBLIC time_t dns_res_timeout(struct dns_resolver *);
1168
1169 DNS_PUBLIC int dns_res_poll(struct dns_resolver *, int);
1170
1171 DNS_PUBLIC struct dns_packet *dns_res_query(struct dns_resolver *, const char *, enum dns_type, enum dns_class, int, int *);
1172
1173 DNS_PUBLIC const struct dns_stat *dns_res_stat(struct dns_resolver *);
1174
1175 DNS_PUBLIC void dns_res_sethints(struct dns_resolver *, struct dns_hints *);
1176
1177 DNS_PUBLIC struct dns_trace *dns_res_trace(struct dns_resolver *);
1178
1179 DNS_PUBLIC void dns_res_settrace(struct dns_resolver *, struct dns_trace *);
1180
1181
1182 /*
1183  * A D D R I N F O  I N T E R F A C E
1184  *
1185  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1186
1187 struct dns_addrinfo;
1188
1189 DNS_PUBLIC struct dns_addrinfo *dns_ai_open(const char *, const char *, enum dns_type, const struct addrinfo *, struct dns_resolver *, int *);
1190
1191 DNS_PUBLIC void dns_ai_close(struct dns_addrinfo *);
1192
1193 DNS_PUBLIC int dns_ai_nextent(struct addrinfo **, struct dns_addrinfo *);
1194
1195 DNS_PUBLIC size_t dns_ai_print(void *, size_t, struct addrinfo *, struct dns_addrinfo *);
1196
1197 DNS_PUBLIC time_t dns_ai_elapsed(struct dns_addrinfo *);
1198
1199 DNS_PUBLIC void dns_ai_clear(struct dns_addrinfo *);
1200
1201 DNS_PUBLIC int dns_ai_events(struct dns_addrinfo *);
1202
1203 DNS_PUBLIC int dns_ai_pollfd(struct dns_addrinfo *);
1204
1205 DNS_PUBLIC time_t dns_ai_timeout(struct dns_addrinfo *);
1206
1207 DNS_PUBLIC int dns_ai_poll(struct dns_addrinfo *, int);
1208
1209 DNS_PUBLIC const struct dns_stat *dns_ai_stat(struct dns_addrinfo *);
1210
1211 DNS_PUBLIC struct dns_trace *dns_ai_trace(struct dns_addrinfo *);
1212
1213 DNS_PUBLIC void dns_ai_settrace(struct dns_addrinfo *, struct dns_trace *);
1214
1215
1216 /*
1217  * Q U E R Y  T R A C I N G  I N T E R F A C E
1218  *
1219  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1220
1221 #define DNS_TRACE_ID_C(n) UINT64_C(n)
1222 typedef uint64_t dns_trace_id_t;
1223
1224 #define DNS_TRACE_ABI 0x20160803
1225
1226 struct dns_trace_event {
1227         enum {
1228                 DNS_TE_RES_SUBMIT = 1,
1229                 DNS_TE_RES_FETCH = 99,
1230
1231                 DNS_TE_SO_SUBMIT = 100,
1232                 DNS_TE_SO_VERIFY,
1233                 DNS_TE_SO_FETCH = 199,
1234
1235                 DNS_TE_SYS_CONNECT = 200,
1236                 DNS_TE_SYS_SEND,
1237                 DNS_TE_SYS_RECV,
1238         } type;
1239
1240         size_t size;
1241         dns_trace_id_t id;
1242         struct timespec ts;
1243         int abi;
1244
1245         union {
1246                 struct {
1247                         char qname[DNS_D_MAXNAME + 1];
1248                         enum dns_type qtype;
1249                         enum dns_class qclass;
1250                         int error;
1251                 } res_submit;
1252
1253                 struct {
1254                         int error;
1255                 } res_fetch;
1256
1257                 struct {
1258                         struct sockaddr_storage haddr;
1259                         char hname[DNS_D_MAXNAME + 1];
1260                         int error;
1261                 } so_submit;
1262
1263                 struct {
1264                         int error;
1265                 } so_verify;
1266
1267                 struct {
1268                         int error;
1269                 } so_fetch;
1270
1271                 struct {
1272                         struct sockaddr_storage src, dst;
1273                         int socktype;
1274                         dns_error_t error;
1275                 } sys_connect, sys_send, sys_recv;
1276         };
1277
1278         unsigned char data[];
1279 };
1280
1281 static inline size_t dns_te_datasize(const struct dns_trace_event *te) {
1282         size_t n = offsetof(struct dns_trace_event, data);
1283         return (n <= te->size)? te->size - n : 0;
1284 }
1285
1286 struct dns_trace;
1287
1288 DNS_PUBLIC int dns_trace_abi(void);
1289
1290 DNS_PUBLIC struct dns_trace *dns_trace_open(FILE *, dns_error_t *);
1291
1292 DNS_PUBLIC void dns_trace_close(struct dns_trace *);
1293
1294 DNS_PUBLIC dns_refcount_t dns_trace_acquire(struct dns_trace *);
1295
1296 DNS_PUBLIC dns_refcount_t dns_trace_release(struct dns_trace *);
1297
1298 DNS_PUBLIC dns_trace_id_t dns_trace_id(struct dns_trace *);
1299
1300 DNS_PUBLIC dns_trace_id_t dns_trace_setid(struct dns_trace *, dns_trace_id_t);
1301
1302 DNS_PUBLIC struct dns_trace_event *dns_trace_get(struct dns_trace *, struct dns_trace_event **, dns_error_t *);
1303
1304 DNS_PUBLIC struct dns_trace_event *dns_trace_tag(struct dns_trace *, struct dns_trace_event *);
1305
1306 DNS_PUBLIC dns_error_t dns_trace_put(struct dns_trace *, const struct dns_trace_event *, const void *, size_t);
1307
1308 DNS_PUBLIC dns_error_t dns_trace_dump(struct dns_trace *, FILE *);
1309
1310 DNS_PUBLIC struct dns_trace_event *dns_trace_fget(struct dns_trace_event **, FILE *, dns_error_t *);
1311
1312 DNS_PUBLIC dns_error_t dns_trace_fput(const struct dns_trace_event *, const void *, size_t, FILE *);
1313
1314
1315 /*
1316  * U T I L I T Y  I N T E R F A C E S
1317  *
1318  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1319
1320 DNS_PUBLIC size_t dns_strlcpy(char *, const char *, size_t);
1321
1322 DNS_PUBLIC size_t dns_strlcat(char *, const char *, size_t);
1323
1324
1325 /*
1326  * M A C R O  M A G I C S
1327  *
1328  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1329
1330 #define DNS_PP_MIN(a, b) (((a) < (b))? (a) : (b))
1331 #define DNS_PP_MAX(a, b) (((a) > (b))? (a) : (b))
1332 #define DNS_PP_NARG_(a, b, c, d, e, f, g, h, i, j, k, N,...) N
1333 #define DNS_PP_NARG(...)        DNS_PP_NARG_(__VA_ARGS__, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
1334 #define DNS_PP_CALL(F, ...)     F(__VA_ARGS__)
1335 #define DNS_PP_PASTE(x, y)      x##y
1336 #define DNS_PP_XPASTE(x, y)     DNS_PP_PASTE(x, y)
1337 #define DNS_PP_STRINGIFY_(s)    #s
1338 #define DNS_PP_STRINGIFY(s)     DNS_PP_STRINGIFY_(s)
1339 #define DNS_PP_D1  0
1340 #define DNS_PP_D2  1
1341 #define DNS_PP_D3  2
1342 #define DNS_PP_D4  3
1343 #define DNS_PP_D5  4
1344 #define DNS_PP_D6  5
1345 #define DNS_PP_D7  6
1346 #define DNS_PP_D8  7
1347 #define DNS_PP_D9  8
1348 #define DNS_PP_D10 9
1349 #define DNS_PP_D11 10
1350 #define DNS_PP_DEC(N) DNS_PP_XPASTE(DNS_PP_D, N)
1351
1352 #endif /* DNS_H */