s6-dns-2.3.1.1/0002755000000000000000000000000013553343654007671 5ustar s6-dns-2.3.1.1/README.solaris0000644000000000000000000000065312376372746012234 0ustar This package assumes the existence of a POSIX shell in /bin/sh. On Solaris, /bin/sh is not POSIX. Most versions of Solaris provide a POSIX shell in /usr/xpg4/bin/sh. To compile this package on Solaris, you will need to run ./patch-for-solaris before you run ./configure. This script will change the #! invocation of the configure script and various tools so that a POSIX shell is used for the compilation process. s6-dns-2.3.1.1/AUTHORS0000644000000000000000000000032013437213300010713 0ustar Main author: Laurent Bercot Thanks to: Dan J. Bernstein Vallo Kallaste A. Wilcox Andrew Ayer s6-dns-2.3.1.1/INSTALL0000644000000000000000000001456613553354723010733 0ustar Build Instructions ------------------ * Requirements ------------ - A POSIX-compliant C development environment - GNU make version 3.81 or later - skalibs version 2.9.1.0 or later: http://skarnet.org/software/skalibs/ This software will run on any operating system that implements POSIX.1-2008, available at: http://pubs.opengroup.org/onlinepubs/9699919799/ * Standard usage -------------- ./configure && make && sudo make install will work for most users. It will install the binaries in /bin and the static libraries in /usr/lib/s6-dns. Please note that static libraries in /usr/lib/s6-dns *will not* be found by a default linker invocation: you need -L/usr/lib/s6-dns. Other skarnet.org software automatically handles that case if the default configuration is used, but if you change the configuration, remember to use the appropriate --with-lib configure option. You can strip the binaries and libraries of their extra symbols via "make strip" before the "make install" phase. It will shave a few bytes off them. * Customization ------------- You can customize paths via flags given to configure. See ./configure --help for a list of all available configure options. * Environment variables --------------------- Controlling a build process via environment variables is a big and dangerous hammer. You should try and pass flags to configure instead; nevertheless, a few standard environment variables are recognized. If the CC environment variable is set, its value will override compiler detection by configure. The --host=HOST option will still add a HOST- prefix to the value of CC. The values of CFLAGS, CPPFLAGS and LDFLAGS will be appended to flags auto-detected by configure. To entirely override the flags set by configure instead, use make variables. * Make variables -------------- You can invoke make with a few variables for more configuration. CC, CFLAGS, CPPFLAGS, LDFLAGS, LDLIBS, AR, RANLIB, STRIP, INSTALL and CROSS_COMPILE can all be overridden on the make command line. This is an even bigger hammer than running ./configure with environment variables, so it is advised to only do this when it is the only way of obtaining the behaviour you want. DESTDIR can be given on the "make install" command line in order to install to a staging directory. * Shared libraries ---------------- Software from skarnet.org is small enough that shared libraries are generally not worth using. Static linking is simpler and incurs less runtime overhead and less points of failure: so by default, shared libraries are not built and binaries are linked against the static versions of the skarnet.org libraries. Nevertheless, you can: * build shared libraries: --enable-shared * link binaries against shared libraries: --disable-allstatic * Static binaries --------------- By default, binaries are linked against static versions of all the libraries they depend on, except for the libc. You can enforce linking against the static libc with --enable-static-libc. (If you are using a GNU/Linux system, be aware that the GNU libc behaves badly with static linking and produces huge executables, which is why it is not the default. Other libcs are better suited to static linking, for instance musl: http://musl-libc.org/) * Cross-compilation ----------------- skarnet.org packages centralize all the difficulty of cross-compilation in one place: skalibs. Once you have cross-compiled skalibs, the rest is easy. * Use the --host=HOST option to configure, HOST being the triplet for your target. * Make sure your cross-toolchain binaries (i.e. prefixed with HOST-) are accessible via your PATH environment variable. * Make sure to use the correct version of skalibs for your target, and the correct sysdeps directory, making use of the --with-include, --with-lib, --with-dynlib and --with-sysdeps options as necessary. * The slashpackage convention --------------------------- The slashpackage convention (http://cr.yp.to/slashpackage.html) is a package installation scheme that provides a few guarantees over other conventions such as the FHS, for instance fixed absolute pathnames. skarnet.org packages support it: use the --enable-slashpackage option to configure, or --enable-slashpackage=DIR for a prefixed DIR/package tree. This option will activate slashpackage support during the build and set slashpackage-compatible installation directories. If $package_home is the home of the package, defined as DIR/package/$category/$package-$version with the variables read from the package/info file, then: --dynlibdir is set to $package_home/library.so --bindir is set to $package_home/command --sbindir is also set to $package_home/command (slashpackage differentiates root-only binaries by their Unix rights, not their location in the filesystem) --libexecdir is also set to $package_home/command (slashpackage does not need a specific directory for internal binaries) --libdir is set to $package_home/library --includedir is set to $package_home/include --prefix is pretty much ignored when you use --enable-slashpackage. You should probably not use both --enable-slashpackage and --prefix. When using slashpackage, two additional Makefile targets are available after "make install": - "make update" changes the default version of the software to the freshly installed one. (This is useful when you have several installed versions of the same software, which slashpackage supports.) - "make -L global-links" adds links from /command and /library.so to the default version of the binaries and shared libraries. The "-L" option to make is necessary because targets are symbolic links, and the default make behaviour is to check the pointed file's timestamp and not the symlink's timestamp. * Absolute pathnames ------------------ You may want to use fixed absolute pathnames even if you're not following the slashpackage convention: for instance, the Nix packaging system prefers calling binaries with immutable paths rather than rely on PATH resolution. If you are in that case, use the --enable-absolute-paths option to configure. This will ensure that programs calling binaries from this package will call them with their full installation path (in bindir) without relying on a PATH search. * Out-of-tree builds ------------------ skarnet.org packages do not support out-of-tree builds. They are small, so it does not cost much to duplicate the entire source tree if parallel builds are needed. s6-dns-2.3.1.1/patch-for-solaris0000755000000000000000000000075112443715220013142 0ustar #!/usr/xpg4/bin/sh patchit () { echo '#!/usr/xpg4/bin/sh' > $1.tmp tail -n +2 $1 >> $1.tmp mv -f $1.tmp $1 chmod 755 $1 } # Solaris doesn't understand POSIX.1-2008 either. sed -e 's/XOPEN_SOURCE=700/XOPEN_SOURCE=600/' < configure > configure.tmp mv -f configure.tmp configure patchit ./configure patchit ./tools/install.sh patchit ./tools/gen-deps.sh echo 'SHELL := /usr/xpg4/bin/sh' > Makefile.tmp echo >> Makefile.tmp cat Makefile >> Makefile.tmp mv -f Makefile.tmp Makefile s6-dns-2.3.1.1/README0000644000000000000000000000107313553367227010552 0ustar s6-dns - a DNS client suite --------------------------- s6-dns is a suite of DNS client programs and libraries for Unix systems, as an alternative to the BIND, djbdns, or other DNS clients. It also comes with a clean, easy-to-use library to perform asynchronous DNS requests. See https://skarnet.org/software/s6-dns/ for details. * Installation ------------ See the INSTALL file. * Contact information ------------------- Laurent Bercot Please use the mailing-list for questions about s6-dns. s6-dns-2.3.1.1/src/0000755000000000000000000000000012441601664010447 5ustar s6-dns-2.3.1.1/src/libs6dns/0000755000000000000000000000000013541514163012172 5ustar s6-dns-2.3.1.1/src/libs6dns/s6dns_resolve_mpag.c0000644000000000000000000000112113061734325016132 0ustar /* ISC license. */ #include int s6dns_resolve_mpag_r (stralloc *sa, genalloc *offsets, char const *name, unsigned int len, uint16_t qtype, s6dns_message_rr_func_t_ref parsefunc, int qualif, s6dns_engine_t *dt, s6dns_rci_t const *rci, s6dns_debughook_t const *dbh, tain_t const *deadline, tain_t *stamp) { s6dns_mpag_t data ; int r ; data.sa = *sa ; data.offsets = *offsets ; data.rtype = qtype ; r = s6dns_resolve_r(name, len, qtype, parsefunc, &data, qualif, dt, rci, dbh, deadline, stamp) ; *sa = data.sa ; *offsets = data.offsets ; return r ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_parse_next.c0000644000000000000000000000051013061734325017324 0ustar /* ISC license. */ #include unsigned int s6dns_message_parse_next (s6dns_message_counts_t *counts, s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int *pos) { *pos += rr->rdlength ; (void)packet ; (void)packetlen ; return s6dns_message_counts_next(counts) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_parse_answer_srv.c0000644000000000000000000000132213433235124020535 0ustar /* ISC license. */ #include #include #include #include #include int s6dns_message_parse_answer_srv (s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos, unsigned int section, void *stuff) { if ((section == 2) && (rr->rtype == S6DNS_T_SRV)) { genalloc *data = stuff ; s6dns_message_rr_srv_t srv ; unsigned int start = pos ; if (!s6dns_message_get_srv(&srv, packet, packetlen, &pos)) return 0 ; if (rr->rdlength != pos - start) return (errno = EPROTO, 0) ; if (!genalloc_append(s6dns_message_rr_srv_t, data, &srv)) return -1 ; } return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_header_unpack.c0000644000000000000000000000075613061724241017755 0ustar /* ISC license. */ #include #include void s6dns_message_header_unpack (char const *s, s6dns_message_header_t *h) { uint16_unpack_big(s, &h->id) ; h->qr = ((unsigned char *)s)[2] & 0x80U ? 1 : 0 ; h->opcode = (s[2] >> 3) & 15 ; h->aa = s[2] & 4 ? 1 : 0 ; h->tc = s[2] & 2 ? 1 : 0 ; h->rd = s[2] & 1 ; h->ra = s[3] & 0x80U ? 1 : 0 ; h->z = (s[3] >> 4) & 7 ; h->rcode = s[3] & 15 ; s6dns_message_counts_unpack(s+4, &h->counts) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_rci_here.c0000644000000000000000000000014113061734325015230 0ustar /* ISC license. */ #include s6dns_rci_t s6dns_rci_here = S6DNS_RCI_ZERO ; s6-dns-2.3.1.1/src/libs6dns/s6dns_debughook_zero.c0000644000000000000000000000017412441717157016471 0ustar /* ISC license. */ #include s6dns_debughook_t const s6dns_debughook_zero = S6DNS_DEBUGHOOK_ZERO ; s6-dns-2.3.1.1/src/libs6dns/s6dns_engine_free.c0000644000000000000000000000033012441721646015721 0ustar /* ISC license. */ #include #include void s6dns_engine_free (s6dns_engine_t *dt) { s6dns_engine_recycle(dt) ; stralloc_free(&dt->sa) ; *dt = s6dns_engine_zero ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_analyze_record_hinfo.c0000644000000000000000000000134213433235103017631 0ustar /* ISC license. */ #include #include #include #include #include #include int s6dns_analyze_record_hinfo (genwrite_t *gp, s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int start) { s6dns_message_rr_hinfo_t hinfo ; size_t len ; unsigned int pos = start ; char buf[S6DNS_FMT_HINFO] ; if (!s6dns_message_get_hinfo(&hinfo, packet, packetlen, &pos)) return 0 ; if (rr->rdlength != pos - start) return (errno = EPROTO, 0) ; len = s6dns_fmt_hinfo(buf, S6DNS_FMT_HINFO, &hinfo) ; if (!len) return 0 ; if ((*gp->put)(gp->target, buf, len) < 0) return 0 ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_analyze_qtype_parse.c0000644000000000000000000000174513263515447017550 0ustar /* ISC license. */ #include #include #include #include typedef struct lookuptable_s lookuptable_t, *lookuptable_t_ref ; struct lookuptable_s { char const *text ; uint16_t qtype ; } ; static lookuptable_t const table[] = { { "ANY", S6DNS_T_ANY }, { "A", S6DNS_T_A }, { "NS", S6DNS_T_NS }, { "CNAME", S6DNS_T_CNAME }, { "SOA", S6DNS_T_SOA }, { "PTR", S6DNS_T_PTR }, { "HINFO", S6DNS_T_HINFO }, { "MX", S6DNS_T_MX }, { "TXT", S6DNS_T_TXT }, { "AAAA", S6DNS_T_AAAA }, { "SRV", S6DNS_T_SRV }, { "RP", S6DNS_T_RP }, { "SIG", S6DNS_T_SIG }, { "KEY", S6DNS_T_KEY }, { "AXFR", S6DNS_T_AXFR }, { "CAA", S6DNS_T_CAA }, { 0, 0 } } ; uint16_t s6dns_analyze_qtype_parse (char const *s) { { uint16_t u ; if (uint160_scan(s, &u)) return u ; } { lookuptable_t const *p = table ; for (; p->text ; p++) if (!strcasecmp(s, p->text)) return p->qtype ; } return 0 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_get_domain.c0000644000000000000000000000054012441734441017265 0ustar /* ISC license. */ #include #include #include "s6dns-message-internal.h" int s6dns_message_get_domain (s6dns_domain_t *d, char const *packet, unsigned int packetlen, unsigned int *pos) { return s6dns_message_get_domain_internal(d->s, 255, packet, packetlen, pos) && s6dns_domain_decode(d) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_fmt_soa.c0000644000000000000000000000254413061734325015111 0ustar /* ISC license. */ #include #include #include #include #include size_t s6dns_fmt_soa (char *s, size_t max, s6dns_message_rr_soa_t const *soa) { size_t len = 0 ; char fmt[UINT32_FMT] ; size_t r = s6dns_domain_tostring(s + len, max - len, &soa->mname) ; if (!r) return 0 ; len += r ; if (len >= max) return (errno = ENAMETOOLONG, 0) ; s[len++] = ' ' ; r = s6dns_domain_tostring(s + len, max - len, &soa->rname) ; if (!r) return 0 ; len += r ; if (len >= max) return (errno = ENAMETOOLONG, 0) ; s[len++] = ' ' ; r = uint32_fmt(fmt, soa->serial) ; if (len + r >= max) return (errno = ENAMETOOLONG, 0) ; memcpy(s + len, fmt, r) ; len += r ; s[len++] = ' ' ; r = uint32_fmt(fmt, soa->refresh) ; if (len + r >= max) return (errno = ENAMETOOLONG, 0) ; memcpy(s + len, fmt, r) ; len += r ; s[len++] = ' ' ; r = uint32_fmt(fmt, soa->retry) ; if (len + r >= max) return (errno = ENAMETOOLONG, 0) ; memcpy(s + len, fmt, r) ; len += r ; s[len++] = ' ' ; r = uint32_fmt(fmt, soa->expire) ; if (len + r >= max) return (errno = ENAMETOOLONG, 0) ; memcpy(s + len, fmt, r) ; len += r ; s[len++] = ' ' ; r = uint32_fmt(fmt, soa->minimum) ; if (len + r > max) return (errno = ENAMETOOLONG, 0) ; memcpy(s + len, fmt, r) ; len += r ; return len ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_parse_skipqd.c0000644000000000000000000000066513061734325017654 0ustar /* ISC license. */ #include #include "s6dns-message-internal.h" unsigned int s6dns_message_parse_skipqd (s6dns_message_counts_t *counts, char const *packet, unsigned int packetlen, unsigned int *pos) { for (;;) { unsigned int r = s6dns_message_counts_next(counts) ; if (r != 1) return r ; if (!s6dns_message_get_domain_internal(0, 255, packet, packetlen, pos)) return 0 ; *pos += 4 ; } } s6-dns-2.3.1.1/src/libs6dns/s6dns_resolven_parse.c0000644000000000000000000000236213061734325016506 0ustar /* ISC license. */ #include #include #include #include int s6dns_resolven_parse_r (s6dns_resolve_t *list, unsigned int n, s6dns_ip46list_t const *servers, s6dns_debughook_t const *dbh, tain_t const *deadline, tain_t *stamp) { s6dns_engine_t dtl[n] ; unsigned int i = 0 ; for (; i < n ; i++) list[i].status = ECONNABORTED ; for (i = 0 ; i < n ; i++) { dtl[i] = s6dns_engine_zero ; if (!s6dns_engine_init_r(dtl + i, servers, list[i].options, list[i].q.s, list[i].q.len, list[i].qtype, dbh, &list[i].deadline, stamp)) { list[i].status = errno ; s6dns_engine_freen(dtl, i) ; return 0 ; } list[i].status = EAGAIN ; } if (s6dns_resolven_loop(dtl, n, 0, deadline, stamp) < 0) goto err ; for (i = 0 ; i < n ; i++) { if (dtl[i].status) list[i].status = dtl[i].status ; else { s6dns_message_header_t h ; int r = s6dns_message_parse(&h, s6dns_engine_packet(dtl + i), s6dns_engine_packetlen(dtl + i), list[i].parsefunc, list[i].data) ; if (r < 0) goto err ; list[i].status = r ? 0 : errno ; } } s6dns_engine_freen(dtl, n) ; return 1 ; err: s6dns_engine_freen(dtl, n) ; return 0 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_domain_fromstring_noqualify_encode.c0000644000000000000000000000040713061734325022602 0ustar /* ISC license. */ #include int s6dns_domain_fromstring_noqualify_encode (s6dns_domain_t *d, char const *name, size_t len) { return s6dns_domain_fromstring(d, name, len) && s6dns_domain_noqualify(d) && s6dns_domain_encode(d) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_parse_getrr.c0000644000000000000000000000136213433235064017476 0ustar /* ISC license. */ #include #include #include #include #include int s6dns_message_parse_getrr (s6dns_message_rr_t_ref rr, char const *packet, unsigned int packetlen, unsigned int *pos) { if (!s6dns_message_get_domain(&rr->name, packet, packetlen, pos)) return 0 ; if (*pos + 10 > packetlen) return (errno = EPROTO, 0) ; uint16_unpack_big(packet + *pos, &rr->rtype) ; *pos += 2 ; uint16_unpack_big(packet + *pos, &rr->rclass) ; *pos += 2 ; uint32_unpack_big(packet + *pos, &rr->ttl) ; *pos += 4 ; uint16_unpack_big(packet + *pos, &rr->rdlength) ; *pos += 2 ; if (*pos + rr->rdlength > packetlen) return (errno = EPROTO, 0) ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_resolven_loop.c0000644000000000000000000000273513061734325016351 0ustar /* ISC license. */ #include #include #include #include #include /* This is basically a synchronous interface to s6dns_engine. It resolves n dts at the same time. */ int s6dns_resolven_loop (s6dns_engine_t *dt, unsigned int n, unsigned int or, tain_t const *deadline, tain_t *stamp) { iopause_fd x[n] ; unsigned int count = 0 ; for (;;) { tain_t localdeadline = *deadline ; int r ; unsigned int i = 0 ; unsigned int j = 0 ; for (; i < n ; i++) if (dt[i].status == EAGAIN) { s6dns_engine_nextdeadline(dt + i, &localdeadline) ; x[j].fd = dt[i].fd ; x[j].events = (s6dns_engine_isreadable(dt + i) ? IOPAUSE_READ : 0) | (s6dns_engine_iswritable(dt + i) ? IOPAUSE_WRITE : 0) ; j++ ; } if (!j) break ; r = iopause_stamp(x, j, &localdeadline, stamp) ; if (r < 0) return -1 ; else if (!r) { if (tain_less(deadline, stamp)) return (errno = ETIMEDOUT, -1) ; for (i = 0 ; i < n ; i++) if (dt[i].status == EAGAIN) if (s6dns_engine_timeout(dt + i, stamp) && (or >= 2)) return i ; } else { for (i = 0 ; i < n ; i++) if (dt[i].status == EAGAIN) { r = s6dns_engine_event(dt + i, stamp) ; if (or) { if (r && ((r > 0) || (or >= 2))) return i ; } else if (r > 0) count++ ; } } } return or ? (errno = ENOENT, -1) : count ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_domain_tostring.c0000644000000000000000000000067613061734325016665 0ustar /* ISC license. */ #include #include #include unsigned int s6dns_domain_tostring (char *s, size_t max, s6dns_domain_t const *d) { if ((size_t)d->len + 1 > max) return (errno = ENAMETOOLONG, 0) ; if (!d->len || (d->s[0] != '.')) return (errno = EINVAL, 0) ; if (d->len == 1) { s[0] = '.' ; return 1 ; } else { memcpy(s, d->s + 1, d->len - 1) ; return d->len - 1 ; } } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_get_domain_internal.c0000644000000000000000000000230613433234744021166 0ustar /* ISC license. */ #include #include #include #include "s6dns-message-internal.h" size_t s6dns_message_get_domain_internal (char *out, size_t outmax, char const *s, unsigned int len, unsigned int *pos) { size_t w = 0 ; /* writing head */ unsigned int r = *pos ; /* reading head */ unsigned int jumps = 0 ; int hasjumped = 0 ; for (;;) { unsigned char c ; if (r >= len) return (errno = EPROTO, 0) ; c = s[r] ; if (c < 64) /* normal label */ { if (r + ++c > len) return (errno = EPROTO, 0) ; if (out) { if (w + c > outmax) return (errno = ENAMETOOLONG, 0) ; memcpy(out + w, s + r, c) ; } w += c ; r += c ; if (!hasjumped) *pos += c ; if (c == 1) break ; } else if (c >= 192) /* pointer */ { if (r + 1 >= len) return (errno = EPROTO, 0) ; if (hasjumped) { if (++jumps > 1000) return (errno = EPROTO, 0) ; } else { *pos += 2 ; hasjumped = 1 ; } r = (((unsigned int)c & 63) << 8) | (unsigned char)(s[r + 1]) ; } else return (errno = EPROTONOSUPPORT, 0) ; /* unsupported extension */ } return w ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_get_caa.c0000644000000000000000000000146013433234712016542 0ustar /* ISC license. */ #include #include #include #include #include int s6dns_message_get_caa (s6dns_message_rr_caa_t *caa, char const *packet, unsigned int packetlen, unsigned int *pos, uint16_t rdlength) { unsigned char taglen ; if (rdlength < 4) return (errno = EPROTO, 0) ; if (*pos + rdlength > packetlen) return (errno = EPROTO, 0) ; caa->flags = packet[(*pos)++] ; taglen = packet[(*pos)++] ; if (rdlength < taglen + 3 || rdlength > taglen + 257) return (errno = EPROTO, 0) ; memcpy(caa->tag, packet + *pos, taglen) ; caa->tag[taglen] = 0 ; *pos += taglen ; memcpy(caa->value, packet + *pos, rdlength - taglen - 2) ; caa->value[rdlength - taglen - 1] = 0 ; *pos += rdlength - taglen - 2 ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_resolvenoq.c0000644000000000000000000000102113061734325015643 0ustar /* ISC license. */ #include #include int s6dns_resolvenoq_r (char const *name, size_t len, uint16_t qtype, s6dns_message_rr_func_t_ref parsefunc, void *data, s6dns_engine_t *dt, s6dns_ip46list_t const *servers, s6dns_debughook_t const *dbh, tain_t const *deadline, tain_t *stamp) { s6dns_domain_t d ; if (!s6dns_domain_fromstring_noqualify_encode(&d, name, len)) return -1 ; return s6dns_resolve_parse_r(&d, qtype, parsefunc, data, dt, servers, dbh, deadline, stamp) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_get_soa.c0000644000000000000000000000145113433234670016603 0ustar /* ISC license. */ #include #include #include #include int s6dns_message_get_soa (s6dns_message_rr_soa_t *soa, char const *packet, unsigned int packetlen, unsigned int *pos) { if (!s6dns_message_get_domain(&soa->mname, packet, packetlen, pos)) return 0 ; if (!s6dns_message_get_domain(&soa->rname, packet, packetlen, pos)) return 0 ; if (*pos + 20 > packetlen) return (errno = EPROTO, 0) ; uint32_unpack_big(packet + *pos, &soa->serial) ; *pos += 4 ; uint32_unpack_big(packet + *pos, &soa->refresh) ; *pos += 4 ; uint32_unpack_big(packet + *pos, &soa->retry) ; *pos += 4 ; uint32_unpack_big(packet + *pos, &soa->expire) ; *pos += 4 ; uint32_unpack_big(packet + *pos, &soa->minimum) ; *pos += 4 ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_fmt_domainlist.c0000644000000000000000000000115213061734325016464 0ustar /* ISC license. */ #include #include #include #include size_t s6dns_fmt_domainlist (char *s, size_t max, s6dns_domain_t const *list, unsigned int n, char const *delim, size_t delimlen) { size_t len = 0 ; unsigned int i = 0 ; for (; i < n ; i++) { unsigned int r = s6dns_domain_tostring(s + len, max - len, list + i) ; if (!r) return 0 ; len += r ; if (i+1 < n) { if (len + delimlen > max) return (errno = ENAMETOOLONG, 0) ; memcpy(s + len, delim, delimlen) ; len += delimlen ; } } return len ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_counts_unpack.c0000644000000000000000000000050613061723762020040 0ustar /* ISC license. */ #include #include void s6dns_message_counts_unpack (char const *s, s6dns_message_counts_t *counts) { uint16_unpack_big(s, &counts->qd) ; uint16_unpack_big(s+2, &counts->an) ; uint16_unpack_big(s+4, &counts->ns) ; uint16_unpack_big(s+6, &counts->nr) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_init.c0000644000000000000000000000037013061734325014417 0ustar /* ISC license. */ #include #include #include int s6dns_init (void) { if (!random_init()) return 0 ; if (!s6dns_rci_init(&s6dns_rci_here, "/etc/resolv.conf")) return 0 ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_get_strings.c0000644000000000000000000000076113061734325017514 0ustar /* ISC license. */ #include #include "s6dns-message-internal.h" int s6dns_message_get_strings (char *s, unsigned int rdlength, char const *packet, unsigned int packetlen, unsigned int *pos) { unsigned int max = rdlength, len = 0 ; while (rdlength) { unsigned int start = *pos ; int r = s6dns_message_get_string_internal(s + len, max - len, packet, packetlen, pos) ; if (r < 0) return -1 ; len += r ; rdlength -= *pos - start ; } return len ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_rci_zero.c0000644000000000000000000000014713061734325015272 0ustar /* ISC license. */ #include s6dns_rci_t const s6dns_rci_zero = S6DNS_RCI_ZERO ; s6-dns-2.3.1.1/src/libs6dns/s6dns_message_get_srv.c0000644000000000000000000000110413433234647016632 0ustar /* ISC license. */ #include #include #include #include int s6dns_message_get_srv (s6dns_message_rr_srv_t *srv, char const *packet, unsigned int packetlen, unsigned int *pos) { if (*pos + 7 > packetlen) return (errno = EPROTO, 0) ; uint16_unpack_big(packet + *pos, &srv->priority) ; *pos += 2 ; uint16_unpack_big(packet + *pos, &srv->weight) ; *pos += 2 ; uint16_unpack_big(packet + *pos, &srv->port) ; *pos += 2 ; return s6dns_message_get_domain(&srv->target, packet, packetlen, pos) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_analyze_record_unknown.c0000644000000000000000000000147713061734325020245 0ustar /* ISC license. */ #include #include #include #include int s6dns_analyze_record_unknown (genwrite_t *gp, s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos) { char fmt[UINT16_FMT] ; if ((*gp->put)(gp->target, "rtype ", 6) < 0) return 0 ; if ((*gp->put)(gp->target, fmt, uint16_fmt(fmt, rr->rtype)) < 0) return 0 ; if ((*gp->put)(gp->target, " length ", 8) < 0) return 0 ; if ((*gp->put)(gp->target, fmt, uint16_fmt(fmt, rr->rdlength)) < 0) return 0 ; if ((*gp->put)(gp->target, ": ", 2) < 0) return 0 ; { uint16_t i = 0 ; for (; i < rr->rdlength ; i++) if ((*gp->put)(gp->target, fmt, ucharn_fmt(fmt, packet + pos + i, 1)) < 0) return 0 ; } (void)packetlen ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_fmt_srv.c0000644000000000000000000000152513061734325015137 0ustar /* ISC license. */ #include #include #include #include #include size_t s6dns_fmt_srv (char *s, size_t max, s6dns_message_rr_srv_t const *srv) { size_t len = 0 ; char fmt[UINT16_FMT] ; size_t r = uint16_fmt(fmt, srv->priority) ; if (len + r >= max) return (errno = ENAMETOOLONG, 0) ; memcpy(s + len, fmt, r) ; len += r ; s[len++] = ' ' ; r = uint16_fmt(fmt, srv->weight) ; if (len + r >= max) return (errno = ENAMETOOLONG, 0) ; memcpy(s + len, fmt, r) ; len += r ; s[len++] = ' ' ; r = uint16_fmt(fmt, srv->port) ; if (len + r >= max) return (errno = ENAMETOOLONG, 0) ; memcpy(s + len, fmt, r) ; len += r ; s[len++] = ' ' ; r = s6dns_domain_tostring(s + len, max - len, &srv->target) ; if (!r) return 0 ; len += r ; return len ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_engine.c0000644000000000000000000003143213433234622014722 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "s6dns-message-internal.h" /* Utility functions */ static inline int qdomain_diff (char const *s1, size_t n1, char const *s2, size_t n2) { return (n1 < n2) ? -1 : (n1 > n2) ? 1 : strncasecmp(s1, s2, n1) ; } static int relevant (char const *q, unsigned int qlen, char const *ans, unsigned int anslen, int strict) { { s6dns_message_header_t h ; uint16_t id ; s6dns_message_header_unpack(ans, &h) ; if (!h.qr || h.opcode || h.z || (h.counts.qd != 1)) return 0 ; if (h.rd != (q[2] & 1)) return 0 ; if (strict && !h.aa && !(q[2] & 1)) return 0 ; uint16_unpack_big(q, &id) ; if (id != h.id) return 0 ; } { char buf[255] ; unsigned int pos = 12 ; unsigned int n = s6dns_message_get_domain_internal(buf, 255, ans, anslen, &pos) ; if (!n) return -1 ; if (pos + 4 > anslen) return (errno = EPROTO, -1) ; if (qdomain_diff(buf, n, q + 12, qlen - 16)) return 0 ; if (memcmp(q + qlen - 4, ans + pos, 4)) return 0 ; } return 1 ; } static int s6dns_mininetstring_read (int fd, stralloc *sa, uint32_t *w) { if (!*w) { char pack[2] ; switch (fd_read(fd, pack, 2)) { case -1 : return -1 ; case 0 : return 0 ; case 1 : *w = ((uint32_t)pack[0] << 8) | (1U << 31) ; break ; case 2 : *w = ((uint32_t)pack[0] << 8) | (uint32_t)pack[1] | (1U << 30) ; break ; default : return (errno = EDOM, -1) ; } } if (*w & (1U << 31)) { unsigned char c ; switch (fd_read(fd, (char *)&c, 1)) { case -1 : return -1 ; case 0 : return (errno = EPIPE, -1) ; case 1 : *w |= (uint32_t)c | (1U << 30) ; *w &= ~(1U << 31) ; break ; default : return (errno = EDOM, -1) ; } } if (*w & (1U << 30)) { if (!stralloc_readyplus(sa, *w & ~(1U << 30))) return -1 ; *w &= ~(1U << 30) ; } { size_t r = allread(fd, sa->s + sa->len, *w) ; sa->len += r ; *w -= r ; } return *w ? -1 : 1 ; } /* Network core functions: transport-dependent */ #ifdef SKALIBS_IPV6_ENABLED # define socketbind46(fd, ip, port, flag) ((flag) ? socket_bind6(fd, ip, port) : socket_bind4(fd, ip, port)) # define socketudp46(flag) ((flag) ? socket_udp6() : socket_udp4()) # define sockettcp46(flag) ((flag) ? socket_tcp6() : socket_tcp4()) # define socketconnect46(fd, ip, port, flag) ((flag) ? socket_connect6(fd, ip, port) : socket_connect4(fd, ip, port)) # define S6DNS_ENGINE_LOCAL0 IP6_ANY #else # define socketbind46(fd, ip, port, flag) ((void)(flag), socket_bind4(fd, ip, port)) # define socketudp46(flag) socket_udp4() # define sockettcp46(flag) socket_tcp4() # define socketconnect46(fd, ip, port, flag) socket_connect4(fd, ip, port) # define S6DNS_ENGINE_LOCAL0 "\0\0\0" #endif static int randombind (int fd, int flag) { unsigned int i = 0 ; for (; i < 10 ; i++) if (socketbind46(fd, S6DNS_ENGINE_LOCAL0, 1025 + random_uint32(64510), flag) >= 0) return 1 ; return (socketbind46(fd, S6DNS_ENGINE_LOCAL0, 0, flag) >= 0) ; } static int thisudp (s6dns_engine_t *dt, tain_t const *stamp) { for (;; dt->curserver++) { if (dt->curserver >= S6DNS_MAX_SERVERS) { dt->curserver = 0 ; if (++dt->protostate >= 4) return -2 ; } if (memcmp(s6dns_ip46list_ip(&dt->servers, dt->curserver), S6DNS_ENGINE_LOCAL0, SKALIBS_IP_SIZE)) break ; } random_string(dt->sa.s + 2, 2) ; /* random query id */ dt->fd = socketudp46(s6dns_ip46list_is6(&dt->servers, dt->curserver)) ; if (dt->fd < 0) return -1 ; if (!randombind(dt->fd, s6dns_ip46list_is6(&dt->servers, dt->curserver))) { fd_close(dt->fd) ; dt->fd = -1 ; return -1 ; } if ((socketconnect46(dt->fd, s6dns_ip46list_ip(&dt->servers, dt->curserver), 53, s6dns_ip46list_is6(&dt->servers, dt->curserver)) < 0) && (errno != EINPROGRESS)) { fd_close(dt->fd) ; dt->fd = -1 ; return 0 ; } tain_add(&dt->localdeadline, stamp, &tain_infinite_relative) ; dt->flagreading = 0 ; dt->flagwriting = 1 ; if (dt->debughook && dt->debughook->pre_send) (*dt->debughook->pre_send)(dt, dt->debughook->external) ; return 1 ; } static int thistcp (s6dns_engine_t *dt, tain_t const *stamp) { for (; dt->curserver < S6DNS_MAX_SERVERS ; dt->curserver++) if (memcmp(s6dns_ip46list_ip(&dt->servers, dt->curserver), S6DNS_ENGINE_LOCAL0, SKALIBS_IP_SIZE)) break ; if (dt->curserver >= S6DNS_MAX_SERVERS) return -2 ; random_string(dt->sa.s + 2, 2) ; dt->fd = sockettcp46(s6dns_ip46list_is6(&dt->servers, dt->curserver)) ; if (dt->fd < 0) return -1 ; if (!randombind(dt->fd, s6dns_ip46list_is6(&dt->servers, dt->curserver))) { fd_close(dt->fd) ; dt->fd = -1 ; return -1 ; } if ((socketconnect46(dt->fd, s6dns_ip46list_ip(&dt->servers, dt->curserver), 53, s6dns_ip46list_is6(&dt->servers, dt->curserver)) < 0) && (errno != EINPROGRESS)) { fd_close(dt->fd) ; dt->fd = -1 ; return 0 ; } tain_addsec(&dt->localdeadline, stamp, 10) ; dt->protostate = 0 ; dt->flagtcp = dt->flagconnecting = dt->flagwriting = 1 ; dt->flagreading = 0 ; if (dt->debughook && dt->debughook->pre_send) (*dt->debughook->pre_send)(dt, dt->debughook->external) ; return 1 ; } /* all the rest is transport-agnostic */ static int s6dns_engine_prepare (s6dns_engine_t *dt, tain_t const *stamp, int istcp) { for (;; dt->curserver++) switch (istcp ? thistcp(dt, stamp) : thisudp(dt, stamp)) { case -2 : return (errno = ENETUNREACH, 0) ; case -1 : return 0 ; case 0 : break ; case 1 : return 1 ; default : return (errno = EDOM, 0) ; /* can't happen */ } } static void prepare_next (s6dns_engine_t *dt, tain_t const *stamp, int istcp) { if (!error_isagain(errno)) { fd_close(dt->fd) ; dt->fd = -1 ; dt->curserver++ ; if (s6dns_engine_prepare(dt, stamp, istcp)) errno = EAGAIN ; } } static int s6dns_engine_write_udp (s6dns_engine_t *dt, tain_t const *stamp) { static unsigned int const s6dns_engine_udp_timeouts[4] = { 1, 3, 11, 45 } ; if (fd_send(dt->fd, dt->sa.s + 2, dt->querylen - 2, 0) < (ssize_t)(dt->querylen - 2)) return (prepare_next(dt, stamp, 0), 0) ; tain_addsec(&dt->localdeadline, stamp, s6dns_engine_udp_timeouts[dt->protostate]) ; dt->flagwriting = 0 ; dt->flagreading = 1 ; if (dt->debughook && dt->debughook->post_send) (*dt->debughook->post_send)(dt, dt->debughook->external) ; return (errno = EAGAIN, 1) ; } static int s6dns_engine_write_tcp (s6dns_engine_t *dt, tain_t const *stamp) { size_t r ; r = allwrite(dt->fd, dt->sa.s + dt->protostate, dt->querylen - dt->protostate) ; dt->protostate += r ; if (r) dt->flagconnecting = 0 ; if (dt->protostate < dt->sa.len) { if ((errno == ECONNRESET) && dt->flagconnecting) errno = EAGAIN ; prepare_next(dt, stamp, 1) ; return 0 ; } dt->protostate = 0 ; tain_addsec(&dt->localdeadline, stamp, 10) ; dt->flagwriting = 0 ; dt->flagreading = 1 ; if (dt->debughook && dt->debughook->post_send) (*dt->debughook->post_send)(dt, dt->debughook->external) ; return (errno = EAGAIN, 1) ; } static int s6dns_engine_read_udp (s6dns_engine_t *dt, tain_t const *stamp) { s6dns_message_header_t h ; char buf[513] ; ssize_t r = fd_recv(dt->fd, buf, 513, 0) ; if (r < 0) return (prepare_next(dt, stamp, 0), 0) ; if ((r > 512) || (r < 12)) return (errno = EAGAIN, 0) ; switch (relevant(dt->sa.s + 2, dt->querylen - 2, buf, r, dt->flagstrict)) { case -1 : if (!dt->flagstrict) prepare_next(dt, stamp, 0) ; return 0 ; case 0 : return (errno = EAGAIN, 0) ; case 1 : break ; default : return (errno = EDOM, 0) ; /* can't happen */ } if (dt->debughook && dt->debughook->post_recv) { if (!stralloc_catb(&dt->sa, buf, r)) return 0 ; (*dt->debughook->post_recv)(dt, dt->debughook->external) ; dt->sa.len = dt->querylen ; } s6dns_message_header_unpack(buf, &h) ; if (h.tc) { fd_close(dt->fd) ; dt->fd = -1 ; dt->curserver = 0 ; dt->protostate = 0 ; if (s6dns_engine_prepare(dt, stamp, 1)) errno = EAGAIN ; return 0 ; } switch (h.rcode) { case 0 : case 3 : break ; /* normal operation */ case 1 : case 4 : case 5 : memset(s6dns_ip46list_ip(&dt->servers, dt->curserver), 0, SKALIBS_IP_SIZE) ; /* do not query it again */ default : prepare_next(dt, stamp, 0) ; return 0 ; } if (!stralloc_copyb(&dt->sa, buf, r)) { fd_close(dt->fd) ; dt->fd = -1 ; return 0 ; } dt->querylen = 0 ; fd_close(dt->fd) ; dt->fd = -1 ; dt->flagreading = 0 ; return 1 ; } static int s6dns_engine_read_tcp (s6dns_engine_t *dt, tain_t const *stamp) { ssize_t r = sanitize_read(s6dns_mininetstring_read(dt->fd, &dt->sa, &dt->protostate)) ; if (r < 0) return (prepare_next(dt, stamp, 1), 0) ; else if (!r) return (errno = EAGAIN, 0) ; else if ((dt->sa.len - dt->querylen) < 12) { errno = EPROTO ; goto badanswer ; } else { s6dns_message_header_t h ; switch (relevant(dt->sa.s + 2, dt->querylen - 2, dt->sa.s + dt->querylen, dt->sa.len - dt->querylen, dt->flagstrict)) { case -1 : if (dt->flagstrict) { dt->sa.len = dt->querylen ; return 0 ; } case 0 : goto badanswer ; case 1 : break ; default : dt->sa.len = dt->querylen ; return (errno = EDOM, 0) ; /* can't happen */ } if (dt->debughook && dt->debughook->post_recv) (*dt->debughook->post_recv)(dt, dt->debughook->external) ; s6dns_message_header_unpack(dt->sa.s + dt->querylen, &h) ; if (h.tc) goto badanswer ; switch (h.rcode) { case 0 : case 3 : break ; /* normal operation */ case 1 : case 4 : case 5 : memset(s6dns_ip46list_ip(&dt->servers, dt->curserver), 0, SKALIBS_IP_SIZE) ; /* do not query it again */ default : goto badanswer ; } fd_close(dt->fd) ; dt->fd = -1 ; dt->flagreading = 0 ; return 1 ; } badanswer: dt->sa.len = dt->querylen ; prepare_next(dt, stamp, 1) ; return 0 ; } void s6dns_engine_recycle (s6dns_engine_t *dt) { dt->sa.len = 0 ; dt->querylen = 0 ; memset(&dt->servers, 0, sizeof(s6dns_ip46list_t)) ; if (dt->fd >= 0) { fd_close(dt->fd) ; dt->fd = -1 ; } dt->status = ECONNABORTED ; dt->flagstrict = dt->flagtcp = dt->flagconnecting = dt->flagreading = dt->flagwriting = 0 ; } int s6dns_engine_timeout (s6dns_engine_t *dt, tain_t const *stamp) { if (!error_isagain(dt->status)) return (errno = EINVAL, -1) ; else if (tain_less(&dt->deadline, stamp)) goto yes ; else if (!tain_less(&dt->localdeadline, stamp)) return 0 ; else if (dt->flagwriting) goto yes ; else if (!dt->flagreading) return 0 ; fd_close(dt->fd) ; dt->fd = -1 ; dt->curserver++ ; if (!s6dns_engine_prepare(dt, stamp, dt->flagtcp)) { s6dns_engine_recycle(dt) ; dt->status = errno ; return -1 ; } return 0 ; yes: s6dns_engine_recycle(dt) ; dt->status = ETIMEDOUT ; return 1 ; } int s6dns_engine_event (s6dns_engine_t *dt, tain_t const *stamp) { if (!error_isagain(dt->status)) return (errno = EINVAL, -1) ; if (dt->flagwriting) dt->flagtcp ? s6dns_engine_write_tcp(dt, stamp) : s6dns_engine_write_udp(dt, stamp) ; else if (dt->flagreading) { if ((dt->flagtcp) ? s6dns_engine_read_tcp(dt, stamp) : s6dns_engine_read_udp(dt, stamp)) { dt->status = 0 ; return 1 ; } } else return (errno = EINVAL, -1) ; if (error_isagain(errno)) return 0 ; s6dns_engine_recycle(dt) ; dt->status = errno ; return -1 ; } int s6dns_engine_init_r (s6dns_engine_t *dt, s6dns_ip46list_t const *servers, uint32_t options, char const *q, unsigned int qlen, uint16_t qtype, s6dns_debughook_t const *dbh, tain_t const *deadline, tain_t const *stamp) { s6dns_message_header_t h = S6DNS_MESSAGE_HEADER_ZERO ; if (!stralloc_ready(&dt->sa, qlen + 18)) return 0 ; dt->deadline = *deadline ; dt->localdeadline = *stamp ; dt->querylen = qlen + 18 ; dt->sa.len = dt->querylen ; dt->servers = *servers ; dt->debughook = dbh ; dt->status = EAGAIN ; dt->flagconnecting = dt->flagreading = dt->flagwriting = 0 ; dt->flagstrict = !!(options & S6DNS_O_STRICT) ; h.rd = !!(options & S6DNS_O_RECURSIVE) ; h.counts.qd = 1 ; uint16_pack_big(dt->sa.s, qlen + 16) ; s6dns_message_header_pack(dt->sa.s + 2, &h) ; memcpy(dt->sa.s + 14, q, qlen) ; uint16_pack_big(dt->sa.s + 14 + qlen, qtype) ; uint16_pack_big(dt->sa.s + 16 + qlen, S6DNS_C_IN) ; if (qlen > 496) dt->flagtcp = 1 ; else { dt->flagtcp = 0 ; dt->protostate = h.rd ; } if (!s6dns_engine_prepare(dt, stamp, dt->flagtcp)) { s6dns_engine_recycle(dt) ; return 0 ; } return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_parse_answer_aaaa.c0000644000000000000000000000076012441725024020614 0ustar /* ISC license. */ #include #include #include int s6dns_message_parse_answer_aaaa (s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos, unsigned int section, void *stuff) { if ((section == 2) && (rr->rtype == S6DNS_T_AAAA) && (rr->rdlength == 16)) { stralloc *data = stuff ; if (!stralloc_catb(data, packet + pos, 16)) return -1 ; } (void)packetlen ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_resolve_name4.c0000644000000000000000000000117113061734325016217 0ustar /* ISC license. */ #include #include #include int s6dns_resolve_name4_r (genalloc *list, char const *ip, s6dns_engine_t *dt, s6dns_ip46list_t const *servers, s6dns_debughook_t const *dbh, tain_t const *deadline, tain_t *stamp) { s6dns_dpag_t data ; s6dns_domain_t d ; int r ; s6dns_domain_arpafromip4(&d, ip) ; s6dns_domain_encode(&d) ; data.ds = *list ; data.rtype = S6DNS_T_PTR ; r = s6dns_resolve_parse_r(&d, data.rtype, &s6dns_message_parse_answer_domain, &data, dt, servers, dbh, deadline, stamp) ; *list = data.ds ; return r ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_domain_fromstring.c0000644000000000000000000000113713061734325017177 0ustar /* ISC license. */ #include #include #include #include int s6dns_domain_fromstring (s6dns_domain_t *d, char const *s, size_t len) { size_t j = 1 ; size_t i = 0 ; unsigned int lastdot = 0 ; d->s[0] = '.' ; for (; i < len ; i++) { if (lastdot) { if ((j >= 255) || (lastdot++ >= 64)) return (errno = ENAMETOOLONG, 0) ; d->s[j++] = s[i] ; } if (s[i] == '.') lastdot = 0 ; else if (!lastdot) { i-- ; lastdot = 1 ; } } case_lowerb(d->s + 1, j-1) ; d->len = j ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_debug_dumpdt_stdout.c0000644000000000000000000000027213061734325017522 0ustar /* ISC license */ #include #include s6dns_debughook_t const s6dns_debug_dumpdt_stdout = S6DNS_DEBUG_DUMPDT_INIT((void *)&genwrite_stdout) ; s6-dns-2.3.1.1/src/libs6dns/deps-exe/0000755000000000000000000000000012441720047013702 5ustar s6-dns-2.3.1.1/src/libs6dns/s6dns_engine_nextdeadline.c0000644000000000000000000000046312441721730017445 0ustar /* ISC license. */ #include #include void s6dns_engine_nextdeadline (s6dns_engine_t const *dt, tain_t *deadline) { if (tain_less(&dt->deadline, deadline)) *deadline = dt->deadline ; if (tain_less(&dt->localdeadline, deadline)) *deadline = dt->localdeadline ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_analyze_record_mx.c0000644000000000000000000000130713433234463017163 0ustar /* ISC license. */ #include #include #include #include #include #include int s6dns_analyze_record_mx (genwrite_t *gp, s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int start) { s6dns_message_rr_mx_t mx ; size_t len ; unsigned int pos = start ; char buf[S6DNS_FMT_MX] ; if (!s6dns_message_get_mx(&mx, packet, packetlen, &pos)) return 0 ; if (rr->rdlength != pos - start) return (errno = EPROTO, 0) ; len = s6dns_fmt_mx(buf, S6DNS_FMT_MX, &mx) ; if (!len) return 0 ; if ((*gp->put)(gp->target, buf, len) < 0) return 0 ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_fmt_mx.c0000644000000000000000000000074313061734325014752 0ustar /* ISC license. */ #include #include #include #include size_t s6dns_fmt_mx (char *s, size_t max, s6dns_message_rr_mx_t const *mx) { char fmt[UINT16_FMT] ; size_t len = uint16_fmt(fmt, mx->preference) ; unsigned int r ; if (len >= max) return 0 ; fmt[len++] = ' ' ; r = s6dns_domain_tostring(s + len, max - len, &mx->exchange) ; if (!r) return 0 ; memcpy(s, fmt, len) ; return len + r ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_engine_zero.c0000644000000000000000000000016312441721741015757 0ustar /* ISC license. */ #include s6dns_engine_t const s6dns_engine_zero = S6DNS_ENGINE_ZERO ; s6-dns-2.3.1.1/src/libs6dns/s6dns_constants_error_str.c0000644000000000000000000000050113061734325017565 0ustar /* ISC license. */ #include #include #include char const *s6dns_constants_error_str (int e) { s6dns_constants_error_message_t const *p = s6dns_constants_error ; while ((p->num != e) && (p->num != -1)) p++ ; return p->num == -1 ? strerror(e) : p->string ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_rci_free.c0000644000000000000000000000026512441717663015244 0ustar /* ISC license. */ #include #include void s6dns_rci_free (s6dns_rci_t *rci) { stralloc_free(&rci->rules) ; *rci = s6dns_rci_zero ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_parse_answer_a.c0000644000000000000000000000074612441724773020167 0ustar /* ISC license. */ #include #include #include int s6dns_message_parse_answer_a (s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos, unsigned int section, void *stuff) { if ((section == 2) && (rr->rtype == S6DNS_T_A) && (rr->rdlength == 4)) { stralloc *data = stuff ; if (!stralloc_catb(data, packet+pos, 4)) return -1 ; } (void)packetlen ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_get_hinfo.c0000644000000000000000000000050712441723232017120 0ustar /* ISC license. */ #include int s6dns_message_get_hinfo (s6dns_message_rr_hinfo_t_ref hinfo, char const *packet, unsigned int packetlen, unsigned int *pos) { return s6dns_message_get_string(&hinfo->cpu, packet, packetlen, pos) && s6dns_message_get_string(&hinfo->os, packet, packetlen, pos) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_fmt_caa.c0000644000000000000000000000122113263515132015037 0ustar /* ISC license. */ #include #include #include #include #include size_t s6dns_fmt_caa (char *s, size_t max, s6dns_message_rr_caa_t const *caa) { size_t len = 0, taglen = strlen(caa->tag), valuelen = strlen(caa->value) ; char fmt[UINT16_FMT] ; size_t r = uint16_fmt(fmt, (uint16_t)caa->flags) ; if (r + taglen + valuelen + 2 > max) return (errno = ENAMETOOLONG, 0) ; memcpy(s + len, fmt, r) ; len += r ; s[len++] = ' ' ; memcpy(s + len, caa->tag, taglen) ; len += taglen ; s[len++] = ' ' ; memcpy(s + len, caa->value, valuelen) ; len += valuelen ; return len ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_debug_dumpdt_post_recv.c0000644000000000000000000000055013061734325020203 0ustar /* ISC license */ #include #include int s6dns_debug_dumpdt_post_recv (s6dns_engine_t const *dt, void *data) { genwrite_t *gp = data ; (void)dt ; if ((*gp->put)(gp->target, "Received a packet\n", 19) < 19) return 0 ; if ((*gp->put)(gp->target, "\n", 1) < 1) return 0 ; return (*gp->flush)(gp->target) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_parse_answer_hinfo.c0000644000000000000000000000134213433234441021031 0ustar /* ISC license. */ #include #include #include #include #include int s6dns_message_parse_answer_hinfo (s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos, unsigned int section, void *stuff) { if ((section == 2) && (rr->rtype == S6DNS_T_HINFO)) { genalloc *data = stuff ; s6dns_message_rr_hinfo_t hinfo ; unsigned int start = pos ; if (!s6dns_message_get_hinfo(&hinfo, packet, packetlen, &pos)) return 0 ; if (rr->rdlength != pos - start) return (errno = EPROTO, 0) ; if (!genalloc_append(s6dns_message_rr_hinfo_t, data, &hinfo)) return -1 ; } return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_header_pack.c0000644000000000000000000000057013061724223017404 0ustar /* ISC license. */ #include #include void s6dns_message_header_pack (char *s, s6dns_message_header_t const *h) { uint16_pack_big(s, h->id) ; s[2] = (char)(unsigned char)((h->qr << 7) | (h->opcode << 3) | (h->aa << 2) | (h->tc << 1) | h->rd) ; s[3] = (h->z << 4) | h->rcode ; s6dns_message_counts_pack(s+4, &h->counts) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_debug_dumpdt_post_send.c0000644000000000000000000000163313061734325020200 0ustar /* ISC license */ #include #include #include #include #include #include int s6dns_debug_dumpdt_post_send (s6dns_engine_t const *dt, void *data) { genwrite_t *gp = data ; size_t len ; char buf[LOCALTMN_FMT] ; if ((*gp->put)(gp->target, "Sent query ", 11) < 11) return 0 ; { uint16_t id ; uint16_unpack_big(dt->sa.s + 2, &id) ; len = uint16_fmt(buf, id) ; } if ((*gp->put)(gp->target, buf, len) < (ssize_t)len) return 0 ; if ((*gp->put)(gp->target, " - next recv deadline is ", 25) < 25) return 0 ; { localtmn_t l ; if (!localtmn_from_tain(&l, &dt->localdeadline, 0)) return 0 ; len = localtmn_fmt(buf, &l) ; } if ((*gp->put)(gp->target, buf, len) < (ssize_t)len) return 0 ; if ((*gp->put)(gp->target, "\n\n", 2) < 2) return 0 ; return (*gp->flush)(gp->target) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_rci_init.c0000644000000000000000000001045513220062402015244 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include static size_t readit (char const *file, char *buf, size_t max) { ssize_t r = openreadnclose(file, buf, max - 1) ; if (r < 0) { if (errno != ENOENT) return 0 ; else r = 0 ; } buf[r++] = '\n' ; return r ; } static inline int s6dns_rci_init_servers (s6dns_rci_t *rci, char const *file, char *tmp, size_t max, size_t *size) { ip46_t tmplist[S6DNS_MAX_SERVERS] ; size_t num = 0 ; char const *x = getenv("DNSCACHEIP") ; if (x) ip46_scanlist(tmplist, S6DNS_MAX_SERVERS, x, &num) ; if (!num) { size_t i = 0 ; *size = readit(file, tmp, max) ; if (!*size) return 0 ; while ((i < *size) && (num < S6DNS_MAX_SERVERS)) { size_t j = byte_chr(tmp + i, *size - i, '\n') ; if ((i + j < *size) && (j > 13U) && !memcmp("nameserver", tmp + i, 10)) { size_t k = 0 ; while ((tmp[i+10+k] == ' ') || (tmp[i+10+k] == '\t')) k++ ; if (k && ip46_scan(tmp+i+10+k, tmplist + num)) num++ ; } i += j + 1 ; } } if (!num) { num = 1 ; memcpy(tmplist[0].ip, S6DNS_LOCALHOST_IP, SKALIBS_IP_SIZE) ; #ifdef SKALIBS_IPV6_ENABLED tmplist[0].is6 = 1 ; #endif } { unsigned int i = 0 ; memset(&rci->servers, 0, sizeof(s6dns_ip46list_t)) ; for (; i < num ; i++) { memcpy(rci->servers.ip + SKALIBS_IP_SIZE * i, tmplist[i].ip, SKALIBS_IP_SIZE) ; #ifdef SKALIBS_IPV6_ENABLED if (ip46_is6(tmplist+i)) bitarray_set(rci->servers.is6, i) ; #endif } } return 1 ; } static inline int stringrules (stralloc *rules, char const *s, unsigned int *num) { size_t base = rules->len ; int wasnull = !rules->s ; unsigned int n = 0 ; int crunching = 1 ; char c = ' ' ; while (c) { c = *s++ ; if (memchr(" \t\n\r", c, 5)) { if (!crunching) { if ((rules->s[rules->len - 1] != '.') && !stralloc_catb(rules, ".", 1)) goto err ; if (!stralloc_0(rules)) goto err ; n++ ; crunching = 1 ; } } else { if (crunching) crunching = 0 ; if (!stralloc_catb(rules, &c, 1)) goto err ; } } *num += n ; return 1 ; err: if (wasnull) stralloc_free(rules) ; else rules->len = base ; return 0 ; } static inline int s6dns_rci_init_rules (s6dns_rci_t_ref rci, char const *file, char *tmp, size_t max, size_t *size) { unsigned int num = 0 ; char const *x = getenv("DNSQUALIFY") ; if (x) { if (!stringrules(&rci->rules, x, &num)) return 0 ; } else { size_t i = 0 ; if (!*size) { *size = readit(file, tmp, max) ; if (!*size) return 0 ; } while (i < *size) { size_t j = byte_chr(tmp + i, *size - i, '\n') ; if ((i + j < *size) && (j > 8U) && (!memcmp("domain", tmp + i, 6) || !memcmp("search", tmp + i, 6)) && ((tmp[i+6] == ' ') || (tmp[i+6] == '\t') || (tmp[i+6] == '\r'))) { size_t k = 0 ; int copying = 0 ; int notsearching = (tmp[i] != 's') ; if (!stralloc_readyplus(&rci->rules, j)) return 0 ; for (; 6 + k < j ; k++) { char c = tmp[i+7+k] ; if ((c == ' ') || (c == '\t') || (c == '\r') || (c == '\n')) { if (copying) { copying = 0 ; if ((tmp[i+6+k] != '.') && !stralloc_catb(&rci->rules, ".", 1)) return 0 ; if (!stralloc_0(&rci->rules)) return 0 ; num++ ; if (notsearching) break ; } } else { copying = 1 ; if (!stralloc_catb(&rci->rules, &c, 1)) return 0 ; } } } i += j + 1 ; } } if (!stralloc_0(&rci->rules)) return 0 ; /* empty rule to finish */ num++ ; rci->rulesnum = num ; stralloc_shrink(&rci->rules) ; return 1 ; } int s6dns_rci_init (s6dns_rci_t *rci, char const *file) { char tmp[4096] ; size_t size = 0 ; if (!s6dns_rci_init_servers(rci, file, tmp, 4096, &size)) return 0 ; if (!s6dns_rci_init_rules(rci, file, tmp, 4096, &size)) return 0 ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_domain_decode.c0000644000000000000000000000123613433234407016227 0ustar /* ISC license. */ #include #include #include #include static inline unsigned int s6dns_domain_label_decode (char *s, unsigned int max) { unsigned int len = *(unsigned char *)s ; if ((len > 63) || (len >= max)) return (errno = EPROTO, 0) ; *s = '.' ; case_lowerb(s+1, len) ; return len + 1 ; } int s6dns_domain_decode (s6dns_domain_t *d) { unsigned int max = 255 ; unsigned int pos = 0 ; for (;;) { unsigned int r = s6dns_domain_label_decode(d->s + pos, max - pos) ; if (!r) return 0 ; pos += r ; if (r == 1) break ; } d->len = pos ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_parse_init.c0000644000000000000000000000063213433234366017321 0ustar /* ISC license. */ #include #include #include int s6dns_message_parse_init (s6dns_message_header_t *h, s6dns_message_counts_t *counts, char const *packet, unsigned int packetlen, unsigned int *pos) { if (packetlen < 12) return (errno = EPROTO, 0) ; s6dns_message_header_unpack(packet, h) ; *counts = h->counts ; *pos = 12 ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_counts_zero.c0000644000000000000000000000021412441722763017533 0ustar /* ISC license. */ #include s6dns_message_counts_t const s6dns_message_counts_zero = S6DNS_MESSAGE_COUNTS_ZERO ; s6-dns-2.3.1.1/src/libs6dns/s6dns_analyze_record.c0000644000000000000000000000224013061734325016453 0ustar /* ISC license. */ #include #include #include #include #include static s6dns_analyze_rtypetable_t const *rtypelookup (uint16_t rtype) { s6dns_analyze_rtypetable_t const *wut = s6dns_analyze_rtypetable ; while (wut->rtype && wut->rtype != rtype) wut++ ; return wut ; } int s6dns_analyze_record (genwrite_t *gp, s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos) { s6dns_analyze_rtypetable_t const *wut = rtypelookup(rr->rtype) ; { char buf[256] ; unsigned int n = s6dns_domain_tostring(buf, 256, &rr->name) ; if (!n) return 0 ; if ((*gp->put)(gp->target, buf, n) < 0) return 0 ; } { char fmt[UINT32_FMT+1] = " " ; if ((*gp->put)(gp->target, fmt, 1 + uint32_fmt(fmt+1, rr->ttl)) < 0) return 0 ; } if ((*gp->put)(gp->target, " ", 1) < 0) return 0 ; if ((*gp->put)(gp->target, wut->string, strlen(wut->string)) < 0) return 0 ; if ((*gp->put)(gp->target, " ", 1) < 0) return 0 ; if (!(*wut->f)(gp, rr, packet, packetlen, pos)) return 0 ; if ((*gp->put)(gp->target, "\n", 1) < 0) return 0 ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_analyze_rtypetable.c0000644000000000000000000000141013263520464017347 0ustar /* ISC license. */ #include static s6dns_analyze_rtypetable_t const s6dns_analyze_rtypetable_array[] = { { 1, "A", &s6dns_analyze_record_a }, { 2, "NS", &s6dns_analyze_record_domain }, { 5, "CNAME", &s6dns_analyze_record_domain }, { 6, "SOA", &s6dns_analyze_record_soa }, { 12, "PTR", &s6dns_analyze_record_domain }, { 13, "HINFO", &s6dns_analyze_record_hinfo }, { 15, "MX", &s6dns_analyze_record_mx }, { 16, "TXT", &s6dns_analyze_record_strings }, { 28, "AAAA", &s6dns_analyze_record_aaaa }, { 33, "SRV", &s6dns_analyze_record_srv }, { 257, "CAA", &s6dns_analyze_record_caa }, { 0, "unknown", &s6dns_analyze_record_unknown } } ; s6dns_analyze_rtypetable_t const *s6dns_analyze_rtypetable = s6dns_analyze_rtypetable_array ; s6-dns-2.3.1.1/src/libs6dns/s6dns_finish.c0000644000000000000000000000032513061734325014734 0ustar /* ISC license. */ #include #include #include void s6dns_finish () { s6dns_engine_free(&s6dns_engine_here) ; s6dns_rci_free(&s6dns_rci_here) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_resolve_dpag.c0000644000000000000000000000077013061734325016132 0ustar /* ISC license. */ #include int s6dns_resolve_dpag_r (genalloc *ds, char const *name, unsigned int len, uint16_t qtype, int qualif, s6dns_engine_t *dt, s6dns_rci_t const *rci, s6dns_debughook_t const *dbh, tain_t const *deadline, tain_t *stamp) { s6dns_dpag_t data ; int r ; data.ds = *ds ; data.rtype = qtype ; r = s6dns_resolve_r(name, len, qtype, &s6dns_message_parse_answer_domain, &data, qualif, dt, rci, dbh, deadline, stamp) ; *ds = data.ds ; return r ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_parse.c0000644000000000000000000000223613061734325016275 0ustar /* ISC license. */ #include #include #include #include int s6dns_message_parse (s6dns_message_header_t *h, char const *packet, unsigned int packetlen, s6dns_message_rr_func_t_ref f, void *data) { s6dns_message_counts_t counts ; unsigned int pos ; unsigned int section ; if (!s6dns_message_parse_init(h, &counts, packet, packetlen, &pos)) return 0 ; switch (h->rcode) { case 0 : break ; case 1 : return (errno = EILSEQ, 0) ; case 2 : return (errno = EBUSY, 0) ; case 3 : return (errno = ENOENT, 0) ; case 4 : return (errno = ENOTSUP, 0) ; case 5 : return (errno = ECONNREFUSED, 0) ; default: return (errno = EIO, 0) ; } section = s6dns_message_parse_skipqd(&counts, packet, packetlen, &pos) ; while (section) { s6dns_message_rr_t rr ; if (!s6dns_message_parse_getrr(&rr, packet, packetlen, &pos)) return 0 ; if (rr.rclass == S6DNS_C_IN) { int r = (*f)(&rr, packet, packetlen, pos, section, data) ; if (r < 1) return r ; } section = s6dns_message_parse_next(&counts, &rr, packet, packetlen, &pos) ; } return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_domain_arpafromip4.c0000644000000000000000000000070013061734325017224 0ustar /* ISC license. */ #include #include #include void s6dns_domain_arpafromip4 (s6dns_domain_t *d, char const *ip) { unsigned int i = 0 ; d->len = 0 ; d->s[d->len++] = '.' ; for (; i < 4 ; i++) { unsigned int u = ((unsigned char *)ip)[3-i] ; d->len += uint_fmt(d->s + d->len, u) ; d->s[d->len++] = '.' ; } memcpy(d->s + d->len, "in-addr.arpa.", 13) ; d->len += 13 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_domain_arpafromip6.c0000644000000000000000000000105613061734325017233 0ustar /* ISC license. */ #include #include #include void s6dns_domain_arpafromip6 (s6dns_domain_t *d, char const *ip6, unsigned int mask) { unsigned int i ; if (mask > 128) mask = 128 ; mask = mask ? 1 + ((mask-1) >> 2) : 0 ; d->len = 0 ; d->s[d->len++] = '.' ; for (i = 32 - mask ; i < 32 ; i++) { unsigned char c = ip6[15-(i>>1)] ; d->s[d->len++] = fmtscan_asc((i & 1) ? (c >> 4) : (c & 15)) ; d->s[d->len++] = '.' ; } memcpy(d->s + d->len, "ip6.arpa.", 9) ; d->len += 9 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_domain_fromstring_qualify_encode.c0000644000000000000000000000056613061723115022246 0ustar /* ISC license. */ #include unsigned int s6dns_domain_fromstring_qualify_encode (s6dns_domain_t *list, char const *name, size_t len, char const *rules, unsigned int rulesnum) { s6dns_domain_t d ; if (!s6dns_domain_fromstring(&d, name, len)) return 0 ; return s6dns_domain_encodelist(list, s6dns_domain_qualify(list, &d, rules, rulesnum)) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_get_mx.c0000644000000000000000000000070713433234345016447 0ustar /* ISC license. */ #include #include #include #include int s6dns_message_get_mx (s6dns_message_rr_mx_t *mx, char const *packet, unsigned int packetlen, unsigned int *pos) { if (*pos + 3 > packetlen) return (errno = EPROTO, 0) ; uint16_unpack_big(packet + *pos, &mx->preference) ; *pos += 2 ; return s6dns_message_get_domain(&mx->exchange, packet, packetlen, pos) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_counts_next.c0000644000000000000000000000054412441722710017530 0ustar /* ISC license. */ #include unsigned int s6dns_message_counts_next (s6dns_message_counts_t *counts) { if (counts->qd) { counts->qd-- ; return 1 ; } else if (counts->an) { counts->an-- ; return 2 ; } else if (counts->ns) { counts->ns-- ; return 3 ; } else if (counts->nr) { counts->nr-- ; return 4 ; } else return 0 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_resolveq_aaaaa.c0000644000000000000000000000545713061734325016433 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include int s6dns_resolveq_aaaaa_r (genalloc *ips, char const *name, size_t len, s6dns_rci_t const *rci, s6dns_debughook_t const *dbh, tain_t const *deadline, tain_t *stamp) { s6dns_engine_t dtl[rci->rulesnum << 1] ; stralloc data = STRALLOC_ZERO ; unsigned int best = 0 ; unsigned int n ; int e = 0 ; unsigned int i = 0 ; { s6dns_domain_t domains[rci->rulesnum] ; n = s6dns_domain_fromstring_qualify_encode(domains, name, len, rci->rules.s, rci->rulesnum) ; if (!n) return -1 ; for (; i < n ; i++) { dtl[i<<1] = s6dns_engine_zero ; if (!s6dns_engine_init_r(dtl + (i<<1), &rci->servers, S6DNS_O_RECURSIVE, domains[i].s, domains[i].len, S6DNS_T_AAAA, dbh, deadline, stamp)) { s6dns_engine_freen(dtl, i<<1) ; return -1 ; } dtl[(i<<1)+1] = s6dns_engine_zero ; if (!s6dns_engine_init_r(dtl + (i<<1) + 1, &rci->servers, S6DNS_O_RECURSIVE, domains[i].s, domains[i].len, S6DNS_T_A, dbh, deadline, stamp)) { s6dns_engine_freen(dtl, (i<<1)+1) ; return -1 ; } } } for (;;) { int k = s6dns_resolven_loop(dtl, n << 1, 1, deadline, stamp) ; if (k < 0) goto err ; if ((unsigned int)k == best) { for (;; best++) { s6dns_message_header_t h ; int r ; if (best >= n << 1) goto notfound ; if (error_isagain(dtl[best].status)) break ; if (dtl[best].status) { errno = dtl[best].status ; goto err ; } r = s6dns_message_parse(&h, s6dns_engine_packet(dtl + best), s6dns_engine_packetlen(dtl + best), (best & 1) ? &s6dns_message_parse_answer_a : s6dns_message_parse_answer_aaaa, &data) ; if (r < 0) goto err ; else if (r) goto found ; else switch (errno) { case EBUSY : case ENOENT : case ECONNREFUSED : case EIO : break ; default : goto err ; } if (!best) e = errno ; } } } found: s6dns_engine_freen(dtl, n<<1) ; { size_t len = data.len >> ((best & 1) ? 2 : 4) ; size_t i = 0 ; size_t base = genalloc_len(ip46_t, ips) ; if (!genalloc_readyplus(ip46_t, ips, len)) return -1 ; for (; i < len ; i++) ip46_from_ip(genalloc_s(ip46_t, ips) + base + i, data.s + (i << ((best & 1) ? 2 : 4)), !(best & 1)) ; genalloc_setlen(ip46_t, ips, base + len) ; } stralloc_free(&data) ; return 1 ; notfound: s6dns_engine_freen(dtl, n<<1) ; return (errno = e, 0) ; err: s6dns_engine_freen(dtl, n<<1) ; return -1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_parse_answer_caa.c0000644000000000000000000000111113263517453020454 0ustar /* ISC license. */ #include #include #include int s6dns_message_parse_answer_caa (s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos, unsigned int section, void *stuff) { if ((section == 2) && (rr->rtype == S6DNS_T_CAA)) { genalloc *data = stuff ; s6dns_message_rr_caa_t caa ; if (!s6dns_message_get_caa(&caa, packet, packetlen, &pos, rr->rdlength)) return 0 ; if (!genalloc_append(s6dns_message_rr_caa_t, data, &caa)) return -1 ; } return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_analyze_record_srv.c0000644000000000000000000000132013433234321017335 0ustar /* ISC license. */ #include #include #include #include #include #include int s6dns_analyze_record_srv (genwrite_t *gp, s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int start) { s6dns_message_rr_srv_t srv ; size_t len ; unsigned int pos = start ; char buf[S6DNS_FMT_SRV] ; if (!s6dns_message_get_srv(&srv, packet, packetlen, &pos)) return 0 ; if (rr->rdlength != pos - start) return (errno = EPROTO, 0) ; len = s6dns_fmt_srv(buf, S6DNS_FMT_SRV, &srv) ; if (!len) return 0 ; if ((*gp->put)(gp->target, buf, len) < 0) return 0 ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_domain_qualify.c0000644000000000000000000000125313061734325016456 0ustar /* ISC license. */ #include #include #include unsigned int s6dns_domain_qualify (s6dns_domain_t *list, s6dns_domain_t const *d, char const *rules, unsigned int rulesnum) { if (!d->len) return (errno = EINVAL, 0) ; if (d->s[d->len - 1] == '.') { list[0] = *d ; return 1 ; } else { unsigned int i = 0 ; for (; i < rulesnum ; i++) { size_t n = strlen(rules) ; if (d->len + n >= 254) return (errno = ENAMETOOLONG, 0) ; list[i] = *d ; list[i].s[d->len] = '.' ; memcpy(list[i].s + d->len + 1, rules, n) ; list[i].len += n+1 ; rules += n+1 ; } return i ; } } s6-dns-2.3.1.1/src/libs6dns/s6dns_resolveq.c0000644000000000000000000000460713061734325015323 0ustar /* ISC license. */ #include #include #include #include #include #include int s6dns_resolveq_r (char const *name, size_t len, uint16_t qtype, s6dns_message_rr_func_t_ref parsefunc, void *data, s6dns_rci_t const *rci, s6dns_debughook_t const *dbh, tain_t const *deadline, tain_t *stamp) { s6dns_engine_t dtl[rci->rulesnum] ; unsigned int best = 0 ; unsigned int n ; int e = 0 ; unsigned int i = 0 ; { s6dns_domain_t domains[rci->rulesnum] ; n = s6dns_domain_fromstring_qualify_encode(domains, name, len, rci->rules.s, rci->rulesnum) ; if (!n) return -1 ; for (; i < n ; i++) { dtl[i] = s6dns_engine_zero ; if (!s6dns_engine_init_r(dtl + i, &rci->servers, S6DNS_O_RECURSIVE, domains[i].s, domains[i].len, qtype, dbh, deadline, stamp)) { s6dns_engine_freen(dtl, i) ; return -1 ; } } } /* Wait until the "best" answer arrives, then scan until a positive answer is found. dtl[i].status == EAGAIN : query still pending other nonzero dtl[i].status : error, give up dtl[i].status == 0 : answer #i has arrived, in which case parse it; r < 0 : error, give up r > 0 : positive answer, return it r == 0 : negative answer. If it's non-fatal (i.e. NXDOMAIN), then move on to the next best FQDN. */ for (;;) { int k = s6dns_resolven_loop(dtl, n, 1, deadline, stamp) ; if (k < 0) goto err ; if ((unsigned int)k == best) { for (;; best++) { s6dns_message_header_t h ; int r ; if (best >= n) goto notfound ; if (error_isagain(dtl[best].status)) break ; if (dtl[best].status) { errno = dtl[best].status ; goto err ; } r = s6dns_message_parse(&h, s6dns_engine_packet(dtl + best), s6dns_engine_packetlen(dtl + best), parsefunc, data) ; if (r < 0) goto err ; else if (r) goto found ; else switch (errno) { case EBUSY : case ENOENT : case ECONNREFUSED : case EIO : break ; default : goto err ; } if (!best) e = errno ; } } } found: s6dns_engine_freen(dtl, n) ; return 1 ; notfound: s6dns_engine_freen(dtl, n) ; return (errno = e, 0) ; err: s6dns_engine_freen(dtl, n) ; return -1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_parse_answer_soa.c0000644000000000000000000000132213433234302020502 0ustar /* ISC license. */ #include #include #include #include #include int s6dns_message_parse_answer_soa (s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos, unsigned int section, void *stuff) { if ((section == 2) && (rr->rtype == S6DNS_T_SOA)) { genalloc *data = stuff ; s6dns_message_rr_soa_t soa ; unsigned int start = pos ; if (!s6dns_message_get_soa(&soa, packet, packetlen, &pos)) return 0 ; if (rr->rdlength != pos - start) return (errno = EPROTO, 0) ; if (!genalloc_append(s6dns_message_rr_soa_t, data, &soa)) return -1 ; } return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_engine_here.c0000644000000000000000000000017612441721704015726 0ustar /* ISC license. */ /* MT-unsafe */ #include s6dns_engine_t s6dns_engine_here = S6DNS_ENGINE_ZERO ; s6-dns-2.3.1.1/src/libs6dns/s6dns_analyze_record_a.c0000644000000000000000000000076513433234261016762 0ustar /* ISC license. */ #include #include #include #include int s6dns_analyze_record_a (genwrite_t *gp, s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos) { char fmt[IP4_FMT] ; if (rr->rdlength != 4) return (errno = EPROTO, 0) ; if (pos + 4 > packetlen) return (errno = EPROTO, 0) ; if ((*gp->put)(gp->target, fmt, ip4_fmt(fmt, packet + pos)) < 0) return 0 ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_get_string.c0000644000000000000000000000052413061734325017326 0ustar /* ISC license. */ #include #include "s6dns-message-internal.h" int s6dns_message_get_string (s6dns_domain_t *d, char const *packet, unsigned int packetlen, unsigned int *pos) { int r = s6dns_message_get_string_internal(d->s, 255, packet, packetlen, pos) ; if (r < 0) return 0 ; d->len = r ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_domain_encodelist.c0000644000000000000000000000036013061734325017133 0ustar /* ISC license. */ #include unsigned int s6dns_domain_encodelist (s6dns_domain_t *list, unsigned int n) { unsigned int i = 0 ; for (; i < n ; i++) if (!s6dns_domain_encode(list + i)) break ; return i ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_counts_pack.c0000644000000000000000000000047013061723750017472 0ustar /* ISC license. */ #include #include void s6dns_message_counts_pack (char *s, s6dns_message_counts_t const *counts) { uint16_pack_big(s, counts->qd) ; uint16_pack_big(s+2, counts->an) ; uint16_pack_big(s+4, counts->ns) ; uint16_pack_big(s+6, counts->nr) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_analyze_packet.c0000644000000000000000000000615513433234242016451 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #define add(s) if ((*gp->put)(gp->target, (s), strlen(s)) < 0) return 0 #define addfmt(n) if ((*gp->put)(gp->target, fmt, uint_fmt(fmt, (n))) < 0) return 0 #define addfmt16(n) if ((*gp->put)(gp->target, fmt, uint16_fmt(fmt, (n))) < 0) return 0 int s6dns_analyze_packet (genwrite_t *gp, char const *packet, unsigned int packetlen, int rec) { s6dns_message_header_t h ; s6dns_message_counts_t counts ; unsigned int pos ; unsigned int section ; char fmt[UINT_FMT] ; if (!s6dns_message_parse_init(&h, &counts, packet, packetlen, &pos)) return 0 ; addfmt(packetlen) ; add(" bytes, ") ; addfmt16(counts.qd) ; add("+") ; addfmt16(counts.an) ; add("+") ; addfmt16(counts.ns) ; add("+") ; addfmt16(counts.nr) ; add(" records") ; if (h.qr) add(", response") ; if (h.opcode) { add(", weird op (") ; addfmt(h.opcode) ; add(")") ; } if (h.aa) add(", authoritative") ; if (h.tc) add(", truncated") ; if (h.rd) { add(", ") ; if (!rec) add("weird ") ; add("rd") ; } if (h.ra) { add(", ") ; if (!rec) add("weird ") ; add("ra") ; } switch (h.rcode) { case 0 : add(", noerror") ; break ; case 1 : add(", fmterror") ; break ; case 2 : add(", servfail") ; break ; case 3 : add(", nxdomain") ; break ; case 4 : add(", notimpl") ; break ; case 5 : add(", refused") ; break ; default: { add(", weird rcode (") ; addfmt(h.rcode) ; add(")") ; } } if (h.z) { add(", weird z (") ; addfmt(h.z) ; add(")") ; } add("\n") ; for (;;) { s6dns_domain_t d ; char buf[257] ; unsigned int len ; uint16_t qtype ; uint16 qclass ; section = s6dns_message_counts_next(&counts) ; if (section != 1) break ; add("query: ") ; if (!s6dns_message_get_domain(&d, packet, packetlen, &pos)) return 0 ; len = s6dns_domain_tostring(buf, 255, &d) ; if (!len) return 0 ; buf[len++] = '\n' ; buf[len++] = 0 ; if (pos + 4 > packetlen) return (errno = EPROTO, 0) ; uint16_unpack_big(packet + pos, &qtype) ; pos += 2 ; uint16_unpack_big(packet + pos, &qclass) ; pos += 2 ; if (qclass != S6DNS_C_IN) { add("weird class (") ; addfmt16(qclass) ; add(") - ") ; } addfmt16(qtype) ; add(" ") ; add(buf) ; } while (section) { static char const *intro[3] = { "answer: ", "authority: ", "additional: " } ; s6dns_message_rr_t rr ; if (!s6dns_message_parse_getrr(&rr, packet, packetlen, &pos)) return 0 ; add(intro[section-2]) ; if (rr.rclass != S6DNS_C_IN) { add("weird class (") ; addfmt16(rr.rclass) ; add("), not attempting to analyze record\n") ; } else if (!s6dns_analyze_record(gp, &rr, packet, packetlen, pos)) return 0 ; section = s6dns_message_parse_next(&counts, &rr, packet, packetlen, &pos) ; } return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_engine_freen.c0000644000000000000000000000024312441721670016077 0ustar /* ISC license. */ #include void s6dns_engine_freen (s6dns_engine_t *dtl, unsigned int n) { while (n--) s6dns_engine_free(dtl + n) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_parse_answer_domain.c0000644000000000000000000000124513433234220021172 0ustar /* ISC license. */ #include #include #include #include int s6dns_message_parse_answer_domain (s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos, unsigned int section, void *stuff) { s6dns_dpag_t *data = stuff ; if ((section == 2) && (rr->rtype == data->rtype)) { s6dns_domain_t d ; unsigned int start = pos ; if (!s6dns_message_get_domain(&d, packet, packetlen, &pos)) return 0 ; if (rr->rdlength != pos - start) return (errno = EPROTO, 0) ; if (!genalloc_append(s6dns_domain_t, &data->ds, &d)) return -1 ; } return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_domain_noqualify.c0000644000000000000000000000040312441721541017004 0ustar /* ISC license. */ #include #include int s6dns_domain_noqualify (s6dns_domain_t *d) { if (d->s[d->len-1] != '.') { if (d->len == 255) return (errno = ENAMETOOLONG, 0) ; d->s[d->len++] = '.' ; } return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns-message-internal.h0000644000000000000000000000056313035704141016633 0ustar /* ISC license. */ #ifndef S6DNS_MESSAGE_INTERNAL_H #define S6DNS_MESSAGE_INTERNAL_H #include /* Low-level packet parsing */ extern int s6dns_message_get_string_internal (char *, size_t, char const *, unsigned int, unsigned int *) ; extern size_t s6dns_message_get_domain_internal (char *, size_t, char const *, unsigned int, unsigned int *) ; #endif s6-dns-2.3.1.1/src/libs6dns/s6dns_message_get_string_internal.c0000644000000000000000000000077613433234175021234 0ustar /* ISC license. */ #include #include #include #include "s6dns-message-internal.h" int s6dns_message_get_string_internal (char *s, size_t max, char const *packet, unsigned int packetlen, unsigned int *pos) { unsigned char len = ((unsigned char const *)packet)[*pos] ; if (*pos + len + 1 > packetlen) return (errno = EPROTO, -1) ; if (len > max) return (errno = ENAMETOOLONG, -1) ; memcpy(s, packet + *pos + 1, len) ; *pos += len + 1 ; return len ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_analyze_record_soa.c0000644000000000000000000000132013433234153017310 0ustar /* ISC license. */ #include #include #include #include #include #include int s6dns_analyze_record_soa (genwrite_t *gp, s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int start) { s6dns_message_rr_soa_t soa ; size_t len ; unsigned int pos = start ; char buf[S6DNS_FMT_SOA] ; if (!s6dns_message_get_soa(&soa, packet, packetlen, &pos)) return 0 ; if (rr->rdlength != pos - start) return (errno = EPROTO, 0) ; len = s6dns_fmt_soa(buf, S6DNS_FMT_SOA, &soa) ; if (!len) return 0 ; if ((*gp->put)(gp->target, buf, len) < 0) return 0 ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_analyze_record_strings.c0000644000000000000000000000134313433234125020223 0ustar /* ISC license. */ #include #include #include #include #include #include int s6dns_analyze_record_strings (genwrite_t *gp, s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int start) { stralloc sa = STRALLOC_ZERO ; char buf[rr->rdlength] ; unsigned int pos = start ; int r = s6dns_message_get_strings(buf, rr->rdlength, packet, packetlen, &pos) ; if (r < 0) return 0 ; if (rr->rdlength != pos - start) return (errno = EPROTO, 0) ; if (!string_quote(&sa, buf, r)) return 0 ; r = (*gp->put)(gp->target, sa.s, sa.len) >= 0 ; stralloc_free(&sa) ; return r ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_debug_dumpdt_pre_send.c0000644000000000000000000000423513061734325020002 0ustar /* ISC license */ /* For EOVERFLOW in OpenBSD */ #ifndef _BSD_SOURCE #define _BSD_SOURCE #endif #include #include #include #include #include #include #include #include #include #include #ifdef SKALIBS_IPV6_ENABLED # define s6dns_ipfmt(buf, ip, is6) ((is6) ? ip6_fmt(buf, ip) : ip4_fmt(buf, ip)) #else # define s6dns_ipfmt(buf, ip, is6) ip4_fmt(buf, ip) #endif int s6dns_debug_dumpdt_pre_send (s6dns_engine_t const *dt, void *data) { genwrite_t *gp = data ; size_t len ; char buf[LOCALTMN_FMT] ; if ((*gp->put)(gp->target, "Preparing to send via ", 22) < 22) return 0 ; if ((*gp->put)(gp->target, dt->flagtcp ? "TCP" : "UDP", 3) < 3) return 0 ; if ((*gp->put)(gp->target, " to ", 4) < 4) return 0 ; len = dt->sa.s[4] & 1 ; if ((*gp->put)(gp->target, len ? "cache" : "server", len ? 5 : 6) < (len ? 5 : 6)) return 0 ; if ((*gp->put)(gp->target, " ", 1) < 1) return 0 ; len = s6dns_ipfmt(buf, s6dns_ip46list_ip(&dt->servers, dt->curserver), s6dns_ip46list_is6(&dt->servers, dt->curserver)) ; if ((*gp->put)(gp->target, buf, len) < (ssize_t)len) return 0 ; if ((*gp->put)(gp->target, " with deadline ", 15) < 15) return 0 ; { localtmn_t l ; if (!localtmn_from_tain(&l, &dt->localdeadline, 0)) { if (errno != EOVERFLOW) return 0 ; memcpy(buf, "\"infinite\"", 10) ; len = 10 ; } else len = localtmn_fmt(buf, &l) ; } if ((*gp->put)(gp->target, buf, len) < (ssize_t)len) return 0 ; if ((*gp->put)(gp->target, ", ", 2) < 2) return 0 ; if (dt->flagstrict && (*gp->put)(gp->target, "strict, ", 8) < 8) return 0 ; if ((*gp->put)(gp->target, "query id ", 9) < 9) return 0 ; { uint16_t id ; uint16_unpack_big(dt->sa.s + 2, &id) ; len = uint16_fmt(buf, id) ; } if ((*gp->put)(gp->target, buf, len) < (ssize_t)len) return 0 ; if ((*gp->put)(gp->target, ":\n", 2) < 2) return 0 ; if (!s6dns_analyze_packet(gp, dt->sa.s + 2, dt->querylen - 2, 1)) return 0 ; if ((*gp->put)(gp->target, "\n", 1) < 1) return 0 ; return (*gp->flush)(gp->target) ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_resolve_parse.c0000644000000000000000000000121013061734325016317 0ustar /* ISC license. */ #include #include #include int s6dns_resolve_parse_r (s6dns_domain_t const *d, uint16_t qtype, s6dns_message_rr_func_t_ref parsefunc, void *data, s6dns_engine_t *dt, s6dns_ip46list_t const *servers, s6dns_debughook_t const *dbh, tain_t const *deadline, tain_t *stamp) { int r ; if (!s6dns_resolve_core_r(d, qtype, dt, servers, dbh, deadline, stamp)) return -1 ; { s6dns_message_header_t h ; r = s6dns_message_parse(&h, s6dns_engine_packet(dt), s6dns_engine_packetlen(dt), parsefunc, data) ; } s6dns_engine_recycle(dt) ; return r ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_resolve_core.c0000644000000000000000000000106713061734325016147 0ustar /* ISC license. */ #include #include #include #include int s6dns_resolve_core_r (s6dns_domain_t const *d, uint16_t qtype, s6dns_engine_t *dt, s6dns_ip46list_t const *servers, s6dns_debughook_t const *dbh, tain_t const *deadline, tain_t *stamp) { if (!s6dns_engine_init_r(dt, servers, S6DNS_O_RECURSIVE, d->s, d->len, qtype, dbh, deadline, stamp)) return 0 ; if (!s6dns_resolve_loop_r(dt, deadline, stamp)) { s6dns_engine_recycle(dt) ; return 0 ; } return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_debug_dumpdt_stderr.c0000644000000000000000000000027213061734325017503 0ustar /* ISC license */ #include #include s6dns_debughook_t const s6dns_debug_dumpdt_stderr = S6DNS_DEBUG_DUMPDT_INIT((void *)&genwrite_stderr) ; s6-dns-2.3.1.1/src/libs6dns/s6dns_constants_error.c0000644000000000000000000000132113433234103016666 0ustar /* ISC license. */ #include #include #include static s6dns_constants_error_message_t const array[] = { { ENETUNREACH, "no available DNS server" }, { EILSEQ, "server did not understand query" }, { EBUSY, "server failure" }, { ENOENT, "no such domain" }, { ENOTSUP, "not implemented in server" }, { ECONNREFUSED, "server refused" }, { EIO, "unknown network error" }, { EAGAIN, "query still processing" }, { ETIMEDOUT, "query timed out" }, { EPROTO, "malformed packet" }, { EDOM, "internal error (please submit a bug-report)" }, { -1, "unknown error" } } ; s6dns_constants_error_message_t const *const s6dns_constants_error = array ; s6-dns-2.3.1.1/src/libs6dns/s6dns_message_header_zero.c0000644000000000000000000000021412441723753017450 0ustar /* ISC license. */ #include s6dns_message_header_t const s6dns_message_header_zero = S6DNS_MESSAGE_HEADER_ZERO ; s6-dns-2.3.1.1/src/libs6dns/s6dns_domain_encode.c0000644000000000000000000000074213061734325016243 0ustar /* ISC license. */ #include #include #include int s6dns_domain_encode (s6dns_domain_t *d) { char *s = d->s ; unsigned int len = d->len ; if (!d->len || (*s != '.')) return (errno = EINVAL, 0) ; while (len > 1) { unsigned int n = byte_chr(s + 1, len - 1, '.') ; if (n > 63) return (errno = EINVAL, 0) ; *s = n++ ; s += n ; len -= n ; } if (!len) return (errno = EINVAL, 0) ; *s = 0 ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_parse_answer_mx.c0000644000000000000000000000131213433234022020342 0ustar /* ISC license. */ #include #include #include #include #include int s6dns_message_parse_answer_mx (s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos, unsigned int section, void *stuff) { if ((section == 2) && (rr->rtype == S6DNS_T_MX)) { genalloc *data = stuff ; s6dns_message_rr_mx_t mx ; unsigned int start = pos ; if (!s6dns_message_get_mx(&mx, packet, packetlen, &pos)) return 0 ; if (rr->rdlength != pos - start) return (errno = EPROTO, 0) ; if (!genalloc_append(s6dns_message_rr_mx_t, data, &mx)) return -1 ; } return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_analyze_record_domain.c0000644000000000000000000000134513433233776020016 0ustar /* ISC license. */ #include #include #include #include #include #include #include int s6dns_analyze_record_domain (genwrite_t *gp, s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int start) { s6dns_domain_t d ; size_t len ; unsigned int pos = start ; char buf[S6DNS_FMT_DOMAIN] ; if (!s6dns_message_get_domain(&d, packet, packetlen, &pos)) return 0 ; if (rr->rdlength != pos - start) return (errno = EPROTO, 0) ; len = s6dns_fmt_domain(buf, 256, &d) ; if (!len) return 0 ; if ((*gp->put)(gp->target, buf, len) < 0) return 0 ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_analyze_record_caa.c0000644000000000000000000000133613433233751017264 0ustar /* ISC license. */ #include #include #include #include #include #include int s6dns_analyze_record_caa (genwrite_t *gp, s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int start) { s6dns_message_rr_caa_t caa ; size_t len ; unsigned int pos = start ; char buf[S6DNS_FMT_CAA] ; if (!s6dns_message_get_caa(&caa, packet, packetlen, &pos, rr->rdlength)) return 0 ; if (rr->rdlength != pos - start) return (errno = EPROTO, 0) ; len = s6dns_fmt_caa(buf, S6DNS_FMT_CAA, &caa) ; if (!len) return 0 ; if ((*gp->put)(gp->target, buf, len) < 0) return 0 ; return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_message_parse_answer_strings.c0000644000000000000000000000220013433233653021415 0ustar /* ISC license. */ #include #include #include #include #include #include int s6dns_message_parse_answer_strings (s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos, unsigned int section, void *stuff) { s6dns_mpag_t *data = stuff ; if ((section == 2) && (rr->rtype == data->rtype)) { size_t base = data->sa.len ; int wasnull = !data->sa.s ; unsigned int start = pos ; int r ; if (!stralloc_readyplus(&data->sa, rr->rdlength + 1)) return -1 ; r = s6dns_message_get_strings(data->sa.s + data->sa.len, rr->rdlength, packet, packetlen, &pos) ; if ((r < 0) || (rr->rdlength != pos - start)) { if (wasnull) stralloc_free(&data->sa) ; else data->sa.len = base ; return (errno = EPROTO, 0) ; } if (!genalloc_append(size_t, &data->offsets, &data->sa.len)) { if (wasnull) stralloc_free(&data->sa) ; else data->sa.len = base ; return (errno = EPROTO, -1) ; } data->sa.len += r ; stralloc_0(&data->sa) ; } return 1 ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_resolvenoq_aaaaa.c0000644000000000000000000000334213061734325016757 0ustar /* ISC license. */ #include #include #include #include #include #include #include int s6dns_resolvenoq_aaaaa_r (genalloc *ips, char const *name, size_t len, s6dns_ip46list_t const *servers, s6dns_debughook_t const *dbh, tain_t const *deadline, tain_t *stamp) { stralloc sa[2] = { STRALLOC_ZERO, STRALLOC_ZERO } ; s6dns_resolve_t blob[2] ; if (!s6dns_domain_fromstring_noqualify_encode(&blob[0].q, name, len)) return -1 ; blob[0].qtype = S6DNS_T_AAAA ; blob[0].options = S6DNS_O_RECURSIVE ; blob[0].deadline = *deadline ; blob[0].parsefunc = &s6dns_message_parse_answer_aaaa ; blob[0].data = &sa[0] ; blob[1].q = blob[0].q ; blob[1].qtype = S6DNS_T_A ; blob[1].options = S6DNS_O_RECURSIVE ; blob[1].deadline = *deadline ; blob[1].parsefunc = &s6dns_message_parse_answer_a ; blob[1].data = &sa[1] ; if (!s6dns_resolven_parse_r(blob, 2, servers, dbh, deadline, stamp)) return -1 ; if (blob[0].status && blob[1].status) return (errno = blob[1].status, 0) ; if (!genalloc_readyplus(ip46_t, ips, (sa[0].len >> 4) + (sa[1].len >> 2))) { stralloc_free(&sa[0]) ; stralloc_free(&sa[1]) ; return -1 ; } { int e = (!!sa[0].len << 1) | !!sa[1].len ; size_t n = genalloc_len(ip46_t, ips) ; size_t i = 0 ; for (; i < (sa[0].len >> 4) ; i++) ip46_from_ip6(genalloc_s(ip46_t, ips) + n++, sa[0].s + (i << 4)) ; for (i = 0 ; i < (sa[1].len >> 2) ; i++) ip46_from_ip4(genalloc_s(ip46_t, ips) + n++, sa[1].s + (i << 2)) ; genalloc_setlen(ip46_t, ips, n) ; stralloc_free(&sa[0]) ; stralloc_free(&sa[1]) ; return e ; } } s6-dns-2.3.1.1/src/libs6dns/deps-lib/0000755000000000000000000000000012441601530013662 5ustar s6-dns-2.3.1.1/src/libs6dns/deps-lib/s6dns0000644000000000000000000000455713263515321014662 0ustar s6dns_constants_error.o s6dns_constants_error_str.o s6dns_debughook_zero.o s6dns_domain_arpafromip4.o s6dns_domain_arpafromip6.o s6dns_domain_decode.o s6dns_domain_encode.o s6dns_domain_encodelist.o s6dns_domain_fromstring.o s6dns_domain_fromstring_noqualify_encode.o s6dns_domain_fromstring_qualify_encode.o s6dns_domain_noqualify.o s6dns_domain_qualify.o s6dns_domain_tostring.o s6dns_engine.o s6dns_engine_free.o s6dns_engine_freen.o s6dns_engine_here.o s6dns_engine_nextdeadline.o s6dns_engine_zero.o s6dns_fmt_domainlist.o s6dns_fmt_hinfo.o s6dns_fmt_mx.o s6dns_fmt_soa.o s6dns_fmt_srv.o s6dns_fmt_caa.o s6dns_message_counts_next.o s6dns_message_counts_pack.o s6dns_message_counts_unpack.o s6dns_message_counts_zero.o s6dns_message_get_domain.o s6dns_message_get_domain_internal.o s6dns_message_get_hinfo.o s6dns_message_get_string.o s6dns_message_get_string_internal.o s6dns_message_get_strings.o s6dns_message_get_mx.o s6dns_message_get_soa.o s6dns_message_get_srv.o s6dns_message_get_caa.o s6dns_message_header_pack.o s6dns_message_header_unpack.o s6dns_message_header_zero.o s6dns_message_parse_answer_aaaa.o s6dns_message_parse_answer_a.o s6dns_message_parse_answer_domain.o s6dns_message_parse_answer_hinfo.o s6dns_message_parse_answer_mx.o s6dns_message_parse_answer_soa.o s6dns_message_parse_answer_srv.o s6dns_message_parse_answer_caa.o s6dns_message_parse_answer_strings.o s6dns_message_parse.o s6dns_message_parse_getrr.o s6dns_message_parse_init.o s6dns_message_parse_next.o s6dns_message_parse_skipqd.o s6dns_rci_free.o s6dns_rci_here.o s6dns_rci_init.o s6dns_rci_zero.o s6dns_resolve_core.o s6dns_resolve_parse.o s6dns_resolven_loop.o s6dns_resolven_parse.o s6dns_resolve_dpag.o s6dns_resolve_mpag.o s6dns_resolve_name4.o s6dns_resolve_name6.o s6dns_resolvenoq.o s6dns_resolveq.o s6dns_resolvenoq_aaaaa.o s6dns_resolveq_aaaaa.o s6dns_analyze_packet.o s6dns_analyze_qtype_parse.o s6dns_analyze_record.o s6dns_analyze_record_a.o s6dns_analyze_record_aaaa.o s6dns_analyze_record_hinfo.o s6dns_analyze_record_mx.o s6dns_analyze_record_soa.o s6dns_analyze_record_srv.o s6dns_analyze_record_caa.o s6dns_analyze_record_domain.o s6dns_analyze_record_strings.o s6dns_analyze_record_unknown.o s6dns_analyze_rtypetable.o s6dns_debug_dumpdt_stdout.o s6dns_debug_dumpdt_stderr.o s6dns_debug_dumpdt_post_recv.o s6dns_debug_dumpdt_pre_send.o s6dns_debug_dumpdt_post_send.o s6dns_init.o s6dns_finish.o -lskarnet s6-dns-2.3.1.1/src/libs6dns/s6dns_fmt_hinfo.c0000644000000000000000000000067213061734325015432 0ustar /* ISC license. */ #include #include #include size_t s6dns_fmt_hinfo (char *s, size_t max, s6dns_message_rr_hinfo_t const *hinfo) { if (hinfo->cpu.len + 1 + hinfo->os.len > max) return (errno = ENAMETOOLONG, 0) ; memcpy(s, hinfo->cpu.s, hinfo->cpu.len) ; s[hinfo->cpu.len] = ' ' ; memcpy(s + hinfo->cpu.len + 1, hinfo->os.s, hinfo->os.len) ; return hinfo->cpu.len + 1 + hinfo->os.len ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_resolve_name6.c0000644000000000000000000000117613061734325016226 0ustar /* ISC license. */ #include #include #include int s6dns_resolve_name6_r (genalloc *list, char const *ip, s6dns_engine_t *dt, s6dns_ip46list_t const *servers, s6dns_debughook_t const *dbh, tain_t const *deadline, tain_t *stamp) { s6dns_dpag_t data ; s6dns_domain_t d ; int r ; s6dns_domain_arpafromip6(&d, ip, 128) ; s6dns_domain_encode(&d) ; data.ds = *list ; data.rtype = S6DNS_T_PTR ; r = s6dns_resolve_parse_r(&d, data.rtype, &s6dns_message_parse_answer_domain, &data, dt, servers, dbh, deadline, stamp) ; *list = data.ds ; return r ; } s6-dns-2.3.1.1/src/libs6dns/s6dns_analyze_record_aaaa.c0000644000000000000000000000077213433233570017425 0ustar /* ISC license. */ #include #include #include #include int s6dns_analyze_record_aaaa (genwrite_t *gp, s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos) { char fmt[IP6_FMT] ; if (rr->rdlength != 16) return (errno = EPROTO, 0) ; if (pos + 16 > packetlen) return (errno = EPROTO, 0) ; if ((*gp->put)(gp->target, fmt, ip6_fmt(fmt, packet + pos)) < 0) return 0 ; return 1 ; } s6-dns-2.3.1.1/src/skadns/0000755000000000000000000000000013541514163011731 5ustar s6-dns-2.3.1.1/src/skadns/skadns_cancel.c0000644000000000000000000000140213217217631014662 0ustar /* ISC license. */ /* OpenBSD sucks. In other news, the sky is blue. */ #ifndef _BSD_SOURCE #define _BSD_SOURCE #endif #include #include #include #include #include #include int skadns_cancel (skadns_t *a, uint16_t id, tain_t const *deadline, tain_t *stamp) { int e = errno ; char pack[3] = "--q" ; skadnsanswer_t *p = GENSETDYN_P(skadnsanswer_t, &a->q, id) ; if (!error_isagain(p->status)) return skadns_release(a, id) ; uint16_pack_big(pack, id) ; if (textclient_command(&a->connection, pack, 3, deadline, stamp)) return gensetdyn_delete(&a->q, id) ; if (errno != ENOENT) return 0 ; p->status = ECANCELED ; errno = e ; return 1 ; } s6-dns-2.3.1.1/src/skadns/skadns_send.c0000644000000000000000000000217713217220056014373 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include int skadns_send (skadns_t *a, uint16_t *u, s6dns_domain_t const *d, uint16_t qtype, tain_t const *limit, tain_t const *deadline, tain_t *stamp) { static skadnsanswer_t const skadnsanswer_initial = { .status = EAGAIN, .data = 0, .len = 0 } ; uint32_t i ; char tmp[17] = "--Q" ; struct iovec v[2] = { { .iov_base = tmp, .iov_len = 17 }, { .iov_base = (void *)d->s, .iov_len = d->len } } ; if (!gensetdyn_new(&a->q, &i)) return 0 ; if (i > UINT16_MAX) { gensetdyn_delete(&a->q, i) ; return (errno = EMFILE, 0) ; } uint16_pack_big(tmp, (uint16_t)i) ; uint16_pack_big(tmp + 3, qtype) ; if (limit) tain_pack(tmp + 5, limit) ; else memset(tmp + 5, 0, 12) ; if (!textclient_commandv(&a->connection, v, 2, deadline, stamp)) { int e = errno ; gensetdyn_delete(&a->q, i) ; errno = e ; return 0 ; } *GENSETDYN_P(skadnsanswer_t, &a->q, i) = skadnsanswer_initial ; *u = i ; return 1 ; } s6-dns-2.3.1.1/src/skadns/skadnsd.c0000644000000000000000000001323413534434154013532 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include typedef struct dnsio_s dnsio_t, *dnsio_t_ref ; struct dnsio_s { unsigned int xindex ; s6dns_engine_t dt ; uint16_t id ; } ; #define DNSIO_ZERO { .xindex = SKADNS_MAXCONCURRENCY, .dt = S6DNS_ENGINE_ZERO, .id = 0 } static dnsio_t a[SKADNS_MAXCONCURRENCY] ; static unsigned int sp = 0 ; static void remove (unsigned int i) { dnsio_t tmp ; tmp = a[sp-1] ; a[--sp] = a[i] ; a[i] = tmp ; } static void fail (unsigned int i) { char pack[3] ; uint16_pack_big(pack, a[i].id) ; pack[2] = a[i].dt.status ; s6dns_engine_recycle(&a[i].dt) ; remove(i) ; if (!textmessage_put(textmessage_sender_x, pack, 3)) strerr_diefu1sys(111, "textmessage_put") ; } static void answer (char c) { if (!textmessage_put(textmessage_sender_1, &c, 1)) strerr_diefu1sys(111, "unixmessage_put") ; } static int parse_protocol (struct iovec const *v, void *context) { char const *s = v->iov_base ; uint16_t id ; if (v->iov_len < 3) strerr_dief1x(100, "invalid client request") ; uint16_unpack_big(s, &id) ; switch (s[2]) /* protocol parsing */ { case 'Q' : /* send a query */ { tain_t limit ; uint16_t qtype ; if (v->iov_len < 21) strerr_dief1x(100, "invalid client request") ; if (sp >= SKADNS_MAXCONCURRENCY) { answer(ENFILE) ; break ; } uint16_unpack_big(s + 3, &qtype) ; if (memcmp(s + 5, "\0\0\0\0\0\0\0\0\0\0\0", 12)) tain_unpack(s + 5, &limit) ; else tain_add_g(&limit, &tain_infinite_relative) ; if (!s6dns_engine_init_g(&a[sp].dt, &s6dns_rci_here.servers, 1, s + 17, v->iov_len - 17, qtype, &limit)) { answer(errno) ; break ; } a[sp++].id = id ; answer(0) ; break ; } case 'q' : /* cancel a query */ { unsigned int i = 0 ; for (; i < sp ; i++) if (a[i].id == id) break ; if (i >= sp) { answer(ENOENT) ; break ; } s6dns_engine_recycle(&a[i].dt) ; remove(i) ; answer(0) ; break ; } default : strerr_dief1x(100, "invalid client request") ; } (void)context ; return 1 ; } int main (void) { PROG = "skadnsd" ; if (ndelay_on(0) < 0) strerr_diefu2sys(111, "ndelay_on ", "0") ; if (ndelay_on(1) < 0) strerr_diefu2sys(111, "ndelay_on ", "1") ; if (sig_ignore(SIGPIPE) < 0) strerr_diefu1sys(111, "ignore SIGPIPE") ; tain_now_set_stopwatch_g() ; if (!s6dns_init()) strerr_diefu1sys(111, "s6dns_init") ; { tain_t deadline ; tain_addsec_g(&deadline, 2) ; if (!textclient_server_01x_init_g(SKADNS_BANNER1, SKADNS_BANNER1_LEN, SKADNS_BANNER2, SKADNS_BANNER2_LEN, &deadline)) strerr_diefu1sys(111, "sync with client") ; } { static dnsio_t const zero = DNSIO_ZERO ; unsigned int i = 0 ; for (; i < SKADNS_MAXCONCURRENCY ; i++) a[i] = zero ; } for (;;) { iopause_fd x[3 + sp] ; int r ; x[0].fd = 0 ; x[0].events = IOPAUSE_EXCEPT | IOPAUSE_READ ; x[1].fd = 1 ; x[1].events = IOPAUSE_EXCEPT | (textmessage_sender_isempty(textmessage_sender_1) ? 0 : IOPAUSE_WRITE) ; x[2].fd = textmessage_sender_fd(textmessage_sender_x) ; x[2].events = IOPAUSE_EXCEPT | (textmessage_sender_isempty(textmessage_sender_x) ? 0 : IOPAUSE_WRITE) ; { tain_t deadline = TAIN_INFINITE ; unsigned int i = 0 ; for (; i < sp ; i++) { unsigned int j = 3 + i ; s6dns_engine_nextdeadline(&a[i].dt, &deadline) ; x[j].fd = a[i].dt.fd ; x[j].events = 0 ; if (s6dns_engine_isreadable(&a[i].dt)) x[j].events |= IOPAUSE_READ ; if (s6dns_engine_iswritable(&a[i].dt)) x[j].events |= IOPAUSE_WRITE ; a[i].xindex = j ; } r = iopause_g(x, 3 + sp, &deadline) ; } if (r < 0) strerr_diefu1sys(111, "iopause") ; if (!r) { unsigned int i = 0 ; for (; i < sp ; i++) if (s6dns_engine_timeout_g(&a[i].dt)) fail(i--) ; continue ; } if (x[1].revents & IOPAUSE_WRITE) if (!textmessage_sender_flush(textmessage_sender_1) && !error_isagain(errno)) strerr_diefu1sys(111, "flush stdout") ; if (x[2].revents & IOPAUSE_WRITE) if (!textmessage_sender_flush(textmessage_sender_x) && !error_isagain(errno)) strerr_diefu1sys(111, "flush asyncout") ; { unsigned int i = 0 ; for (; i < sp ; i++) if (x[a[i].xindex].revents) { int r = s6dns_engine_event_g(&a[i].dt) ; if (r < 0) fail(i--) ; else if (r) { char pack[3] ; struct iovec v[2] = { { .iov_base = pack, .iov_len = 3 }, { .iov_base = s6dns_engine_packet(&a[i].dt), .iov_len = s6dns_engine_packetlen(&a[i].dt) } } ; uint16_pack_big(pack, a[i].id) ; pack[2] = 0 ; if (!textmessage_putv(textmessage_sender_x, v, 2)) strerr_diefu1sys(111, "textmessage_put") ; s6dns_engine_recycle(&a[i].dt) ; remove(i--) ; } } } if (!textmessage_receiver_isempty(textmessage_receiver_0) || x[0].revents & IOPAUSE_READ) { if (textmessage_handle(textmessage_receiver_0, &parse_protocol, 0) < 0) { if (errno == EPIPE) break ; /* normal exit */ strerr_diefu1sys(111, "handle messages from client") ; } } } return 0 ; } s6-dns-2.3.1.1/src/skadns/skadns_update.c0000644000000000000000000000237013433233544014725 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #include static int msghandler (struct iovec const *v, void *context) { skadns_t *a = (skadns_t *)context ; char const *s = v->iov_base ; skadnsanswer_t *p ; uint16_t id ; if (v->iov_len < 3) return (errno = EPROTO, 0) ; uint16_unpack_big(s, &id) ; p = GENSETDYN_P(skadnsanswer_t, &a->q, id) ; if (p->status == ECANCELED) { p->status = EINVAL ; return gensetdyn_delete(&a->q, id) ; } if (!error_isagain(p->status)) return (errno = EINVAL, 0) ; if (!genalloc_readyplus(uint16_t, &a->list, 1)) return 0 ; if (!s[2]) { p->data = alloc(v->iov_len-3) ; if (!p->data) return 0 ; memcpy(p->data, s+3, v->iov_len-3) ; p->len = v->iov_len-3 ; } p->status = s[2] ; genalloc_append(uint16_t, &a->list, &id) ; return 1 ; } int skadns_update (skadns_t *a) { genalloc_setlen(uint16_t, &a->list, 0) ; return textclient_update(&a->connection, &msghandler, a) ; } s6-dns-2.3.1.1/src/skadns/skadns_packet.c0000644000000000000000000000054513061734325014714 0ustar /* ISC license. */ #include #include #include char const *skadns_packet (skadns_t const *a, uint16_t id) { skadnsanswer_t *p = GENSETDYN_P(skadnsanswer_t, &a->q, id) ; switch (p->status) { case 0 : return (char const *)p->data ; default : return (errno = p->status, (char const *)0) ; } } s6-dns-2.3.1.1/src/skadns/skadns_end.c0000644000000000000000000000104413217217616014210 0ustar /* ISC license. */ #include #include #include #include #include #include static int skadnsanswer_free (char *p, void *stuff) { skadnsanswer_t *q = (skadnsanswer_t_ref)p ; alloc_free(&q->data) ; (void)stuff ; return 1 ; } void skadns_end (skadns_t *a) { textclient_end(&a->connection) ; genalloc_free(uint16_t, &a->list) ; gensetdyn_iter(&a->q, &skadnsanswer_free, 0) ; gensetdyn_free(&a->q) ; *a = skadns_zero ; } s6-dns-2.3.1.1/src/skadns/deps-exe/0000755000000000000000000000000013540723124013441 5ustar s6-dns-2.3.1.1/src/skadns/deps-exe/skadnsd0000755000000000000000000000006413540723124015016 0ustar ${LIBS6DNS} -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dns-2.3.1.1/src/skadns/skadns_start.c0000644000000000000000000000047213217222521014572 0ustar /* ISC license. */ #include #include int skadns_start (skadns_t *a, char const *path, tain_t const *deadline, tain_t *stamp) { return textclient_start(&a->connection, path, 0, SKADNS_BANNER1, SKADNS_BANNER1_LEN, SKADNS_BANNER2, SKADNS_BANNER2_LEN, deadline, stamp) ; } s6-dns-2.3.1.1/src/skadns/skadns_startf.c0000644000000000000000000000067313217222541014745 0ustar /* ISC license. */ #include #include #include int skadns_startf (skadns_t *a, tain_t const *deadline, tain_t *stamp) { static char const *const cargv[2] = { SKADNSD_PROG, 0 } ; return textclient_startf(&a->connection, cargv, (char const *const *)environ, TEXTCLIENT_OPTION_WAITPID, SKADNS_BANNER1, SKADNS_BANNER1_LEN, SKADNS_BANNER2, SKADNS_BANNER2_LEN, deadline, stamp) ; } s6-dns-2.3.1.1/src/skadns/skadns_release.c0000644000000000000000000000120513061734325015057 0ustar /* ISC license. */ /* OpenBSD sucks. More news at 11. */ #ifndef _BSD_SOURCE #define _BSD_SOURCE #endif #include #include #include #include int skadns_release (skadns_t *a, uint16_t id) { skadnsanswer_t *p = GENSETDYN_P(skadnsanswer_t, &a->q, id) ; switch (p->status) { case 0 : alloc_free(p->data) ; p->data = 0 ; p->len = 0 ; break ; case EAGAIN : case ECANCELED : return (errno = EBUSY, 0) ; case EINVAL : return (errno = EINVAL, 0) ; default : break ; } p->status = EINVAL ; return gensetdyn_delete(&a->q, id) ; } s6-dns-2.3.1.1/src/skadns/skadns_packetlen.c0000644000000000000000000000050413061734325015406 0ustar /* ISC license. */ #include #include #include int skadns_packetlen (skadns_t const *a, uint16_t id) { skadnsanswer_t *p = GENSETDYN_P(skadnsanswer_t, &a->q, id) ; switch (p->status) { case 0 : return p->len ; default : return (errno = p->status, -1) ; } } s6-dns-2.3.1.1/src/skadns/skadns_zero.c0000644000000000000000000000013312441603576014421 0ustar /* ISC license. */ #include skadns_t const skadns_zero = SKADNS_ZERO ; s6-dns-2.3.1.1/src/skadns/deps-lib/0000755000000000000000000000000011513326255013430 5ustar s6-dns-2.3.1.1/src/skadns/deps-lib/skadns0000644000000000000000000000024612562721327014644 0ustar skadns_cancel.o skadns_end.o skadns_packet.o skadns_packetlen.o skadns_release.o skadns_send.o skadns_start.o skadns_startf.o skadns_update.o skadns_zero.o -lskarnet s6-dns-2.3.1.1/src/clients/0000755000000000000000000000000013541514163012107 5ustar s6-dns-2.3.1.1/src/clients/s6-dnsname.c0000644000000000000000000000501613534434357014240 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-dnsname [ -4 | -6 ] [ -r ] [ -t timeout ] ip" #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv) { genalloc ds = GENALLOC_ZERO ; /* array of s6dns_domain_t */ tain_t deadline ; ip46full_t ip = IP46FULL_ZERO ; unsigned int t = 0 ; int flagunsort = 0 ; int do4 = 0 ; int do6 = 0 ; PROG = "s6-dnsname" ; for (;;) { int opt = subgetopt(argc, argv, "46rt:") ; if (opt == -1) break ; switch (opt) { case '4' : do4 = 1 ; break ; case '6' : do6 = 1 ; break ; case 'r' : flagunsort = 1 ; break ; case 't' : if (!uint0_scan(subgetopt_here.arg, &t)) dieusage() ; break ; default : dieusage() ; } } argc -= subgetopt_here.ind ; argv += subgetopt_here.ind ; if (argc < 1) dieusage() ; if (!do4 && !do6) do4 = do6 = 1 ; if (do4 && do6) { if (!ip46full_scan(argv[0], &ip)) dieusage() ; } else if (do6) { if (!ip6_scan(argv[0], ip.ip)) dieusage() ; ip.is6 = 1 ; } else if (!ip4_scan(argv[0], ip.ip)) dieusage() ; tain_now_set_stopwatch_g() ; if (t) tain_from_millisecs(&deadline, t) ; else deadline = tain_infinite_relative ; tain_add_g(&deadline, &deadline) ; if (!s6dns_init()) strerr_diefu1sys(111, "s6dns_init") ; { int r = ip.is6 ? s6dns_resolve_name6_g(&ds, ip.ip, &deadline) : s6dns_resolve_name4_g(&ds, ip.ip, &deadline) ; if (r < 0) strerr_diefu2sys((errno == ETIMEDOUT) ? 99 : 111, "resolve ", argv[0]) ; if (!r) strerr_diefu4x(2, "resolve ", argv[0], ": ", s6dns_constants_error_str(errno)) ; } if (!genalloc_len(s6dns_domain_t, &ds)) return 1 ; if (flagunsort) random_unsort(ds.s, genalloc_len(s6dns_domain_t, &ds), sizeof(s6dns_domain_t)) ; { char buf[S6DNS_FMT_DOMAINLIST(genalloc_len(s6dns_domain_t, &ds))] ; size_t len = s6dns_fmt_domainlist(buf, S6DNS_FMT_DOMAINLIST(genalloc_len(s6dns_domain_t, &ds)), genalloc_s(s6dns_domain_t, &ds), genalloc_len(s6dns_domain_t, &ds), "\n", 1) ; if (!len) strerr_diefu1sys(111, "format result") ; if (buffer_put(buffer_1, buf, len) < (ssize_t)len) goto err ; } if (buffer_putflush(buffer_1, "\n", 1) < 1) goto err ; return 0 ; err: strerr_diefu1sys(111, "write to stdout") ; } s6-dns-2.3.1.1/src/clients/s6-dnsname-filter.c0000644000000000000000000000433213433233437015515 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include "s6dns-generic-filter.h" #define USAGE "s6-dnsname-filter [ -4 ] [ -6 ] [ -l lines ] [ -c concurrency ] [ -t timeout ] [ -f format ] [ -e errorformat ]" static size_t ipscanner (s6dns_domain_t *d, char const *s) { char ip[16] ; size_t pos ; if (flag6) { pos = ip6_scan(s, ip) ; if (pos) { s6dns_domain_arpafromip6(d, ip, 128) ; goto yes ; } } if (flag4) { pos = ip4_scan(s, ip) ; if (pos) { s6dns_domain_arpafromip4(d, ip) ; goto yes ; } } return (errno = 0, 0) ; yes: if (!s6dns_domain_encode(d)) return 0 ; return pos ; } typedef struct s6dns_domain1_s s6dns_domain1_t, *s6dns_domain1_t_ref ; struct s6dns_domain1_s { s6dns_domain_t d ; unsigned int got : 1 ; } ; static int s6dns_message_parse_answer_domain1 (s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos, unsigned int section, void *stuff) { if ((section == 2) && (rr->rtype == S6DNS_T_PTR)) { s6dns_domain1_t *data = stuff ; unsigned int start = pos ; if (data->got) return 1 ; if (!s6dns_message_get_domain(&data->d, packet, packetlen, &pos)) return 0 ; if (rr->rdlength != pos - start) return (errno = EPROTO, 0) ; data->got = 1 ; } return 1 ; } static int domainformatter (stralloc *sa, char const *packet, unsigned int packetlen) { s6dns_domain1_t data ; s6dns_message_header_t h ; int r ; data.got = 0 ; r = s6dns_message_parse(&h, packet, packetlen, &s6dns_message_parse_answer_domain1, &data) ; if (r <= 0) return r ; if (!data.got) return 1 ; if (!stralloc_readyplus(sa, data.d.len + 1)) return -1 ; sa->len += s6dns_domain_tostring(sa->s + sa->len, data.d.len + 1, &data.d) ; stralloc_0(sa) ; return 1 ; } int main (int argc, char const *const *argv, char const *const *envp) { PROG = "s6-dnsname-filter" ; return s6dns_generic_filter_main(argc, argv, envp, S6DNS_T_PTR, &ipscanner, &domainformatter, USAGE) ; } s6-dns-2.3.1.1/src/clients/s6-dnsns.c0000644000000000000000000000420613534434440013731 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-dnsns [ -q ] [ -r ] [ -t timeout ] name" #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv) { genalloc ds = GENALLOC_ZERO ; /* array of s6dns_domain_t */ tain_t deadline ; unsigned int t = 0 ; int flagqualify = 0 ; int flagunsort = 0 ; PROG = "s6-dnsns" ; for (;;) { int opt = subgetopt(argc, argv, "qrt:") ; if (opt == -1) break ; switch (opt) { case 'q' : flagqualify = 1 ; break ; case 'r' : flagunsort = 1 ; break ; case 't' : if (!uint0_scan(subgetopt_here.arg, &t)) dieusage() ; break ; default : dieusage() ; } } argc -= subgetopt_here.ind ; argv += subgetopt_here.ind ; if (argc < 1) dieusage() ; tain_now_set_stopwatch_g() ; if (t) tain_from_millisecs(&deadline, t) ; else deadline = tain_infinite_relative ; tain_add_g(&deadline, &deadline) ; if (!s6dns_init()) strerr_diefu1sys(111, "s6dns_init") ; { int r = s6dns_resolve_ns_g(&ds, argv[0], strlen(argv[0]), flagqualify, &deadline) ; if (r < 0) strerr_diefu2sys((errno == ETIMEDOUT) ? 99 : 111, "resolve ", argv[0]) ; if (!r) strerr_diefu4x(2, "resolve ", argv[0], ": ", s6dns_constants_error_str(errno)) ; } if (!genalloc_len(s6dns_domain_t, &ds)) return 1 ; if (flagunsort) random_unsort(ds.s, genalloc_len(s6dns_domain_t, &ds), sizeof(s6dns_domain_t)) ; { char buf[S6DNS_FMT_DOMAINLIST(genalloc_len(s6dns_domain_t, &ds))] ; size_t len = s6dns_fmt_domainlist(buf, S6DNS_FMT_DOMAINLIST(genalloc_len(s6dns_domain_t, &ds)), genalloc_s(s6dns_domain_t, &ds), genalloc_len(s6dns_domain_t, &ds), "\n", 1) ; if (!len) strerr_diefu1sys(111, "format result") ; if (buffer_put(buffer_1, buf, len) < (ssize_t)len) goto err ; } if (buffer_putflush(buffer_1, "\n", 1) < 1) goto err ; return 0 ; err: strerr_diefu1sys(111, "write to stdout") ; } s6-dns-2.3.1.1/src/clients/s6-dnsmx.c0000644000000000000000000000421613534434320013733 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-dnsmx [ -q ] [ -r ] [ -t timeout ] name" #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv) { genalloc mxs = GENALLOC_ZERO ; /* array of s6dns_message_rr_mx_t */ tain_t deadline ; size_t i = 0 ; unsigned int t = 0 ; int flagqualify = 0 ; int flagunsort = 0 ; PROG = "s6-dnsmx" ; for (;;) { int opt = subgetopt(argc, argv, "qrt:") ; if (opt == -1) break ; switch (opt) { case 'q' : flagqualify = 1 ; break ; case 'r' : flagunsort = 1 ; break ; case 't' : if (!uint0_scan(subgetopt_here.arg, &t)) dieusage() ; break ; default : dieusage() ; } } argc -= subgetopt_here.ind ; argv += subgetopt_here.ind ; if (argc < 1) dieusage() ; tain_now_set_stopwatch_g() ; if (t) tain_from_millisecs(&deadline, t) ; else deadline = tain_infinite_relative ; tain_add_g(&deadline, &deadline) ; if (!s6dns_init()) strerr_diefu1sys(111, "s6dns_init") ; { int r = s6dns_resolve_mx_g(&mxs, argv[0], strlen(argv[0]), flagqualify, &deadline) ; if (r < 0) strerr_diefu2sys((errno == ETIMEDOUT) ? 99 : 111, "resolve ", argv[0]) ; if (!r) strerr_diefu4x(2, "resolve ", argv[0], ": ", s6dns_constants_error_str(errno)) ; } if (!genalloc_len(s6dns_message_rr_mx_t, &mxs)) return 1 ; if (flagunsort) random_unsort(mxs.s, genalloc_len(s6dns_message_rr_mx_t, &mxs), sizeof(s6dns_message_rr_mx_t)) ; for (i = 0 ; i < genalloc_len(s6dns_message_rr_mx_t, &mxs) ; i++) { char buf[S6DNS_FMT_MX] ; size_t len = s6dns_fmt_mx(buf, S6DNS_FMT_MX, genalloc_s(s6dns_message_rr_mx_t, &mxs) + i) ; if (!len) strerr_diefu1sys(111, "format result") ; if (buffer_put(buffer_1, buf, len) < (ssize_t)len) goto err ; if (buffer_put(buffer_1, "\n", 1) < 1) goto err ; } if (!buffer_flush(buffer_1)) goto err ; return 0 ; err: strerr_diefu1sys(111, "write to stdout") ; } s6-dns-2.3.1.1/src/clients/s6-dnssrv.c0000644000000000000000000000512313534434552014126 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-dnssrv [ -q ] [ -r ] [ -t timeout ] service protocol name" #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv) { genalloc srvs = GENALLOC_ZERO ; /* array of s6dns_message_rr_srv_t */ tain_t deadline ; size_t i = 0 ; unsigned int t = 0 ; int flagqualify = 0 ; int flagunsort = 0 ; PROG = "s6-dnssrv" ; for (;;) { int opt = subgetopt(argc, argv, "qt:") ; if (opt == -1) break ; switch (opt) { case 'q' : flagqualify = 1 ; break ; case 'r' : flagunsort = 1 ; break ; case 't' : if (!uint0_scan(subgetopt_here.arg, &t)) dieusage() ; break ; default : dieusage() ; } } argc -= subgetopt_here.ind ; argv += subgetopt_here.ind ; if (argc < 3) dieusage() ; tain_now_set_stopwatch_g() ; if (t) tain_from_millisecs(&deadline, t) ; else deadline = tain_infinite_relative ; tain_add_g(&deadline, &deadline) ; if (!s6dns_init()) strerr_diefu1sys(111, "s6dns_init") ; { size_t n0 = strlen(argv[0]) ; size_t n1 = strlen(argv[1]) ; size_t n2 = strlen(argv[2]) ; int r ; char name[n0 + n1 + n2 + 5] ; name[0] = '_' ; memcpy(name + 1, argv[0], n0) ; name[n0 + 1] = '.' ; name[n0 + 2] = '_' ; memcpy(name + n0 + 3, argv[1], n1) ; name[n0 + n1 + 3] = '.' ; memcpy(name + n0 + n1 + 4, argv[2], n2) ; name[n0 + n1 + n2 + 4] = 0 ; r = s6dns_resolve_srv_g(&srvs, name, n0 + n1 + n2 + 4, flagqualify, &deadline) ; if (r < 0) strerr_diefu2sys((errno == ETIMEDOUT) ? 99 : 111, "resolve ", argv[0]) ; if (!r) strerr_diefu4x(2, "resolve ", name, ": ", s6dns_constants_error_str(errno)) ; } if (!genalloc_len(s6dns_message_rr_srv_t, &srvs)) return 1 ; if (flagunsort) random_unsort(srvs.s, genalloc_len(s6dns_message_rr_srv_t, &srvs), sizeof(s6dns_message_rr_srv_t)) ; for (i = 0 ; i < genalloc_len(s6dns_message_rr_srv_t, &srvs) ; i++) { char buf[S6DNS_FMT_SRV] ; size_t len = s6dns_fmt_srv(buf, S6DNS_FMT_SRV, genalloc_s(s6dns_message_rr_srv_t, &srvs) + i) ; if (!len) strerr_diefu1sys(111, "format result") ; if (buffer_put(buffer_1, buf, len) < (ssize_t)len) goto err ; if (buffer_put(buffer_1, "\n", 1) < 1) goto err ; } if (!buffer_flush(buffer_1)) goto err ; return 0 ; err: strerr_diefu1sys(111, "write to stdout") ; } s6-dns-2.3.1.1/src/clients/s6-dnsqr.c0000644000000000000000000000511713534434501013733 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-dnsqr [ -1 | -2 ] [ -t timeout ] [ -D debuglevel ] qtype query" #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv) { tain_t deadline ; unsigned int debuglevel = 0 ; genwrite_t *where = &genwrite_stderr ; PROG = "s6-dnsqr" ; { subgetopt_t l = SUBGETOPT_ZERO ; unsigned int t = 0 ; for (;;) { int opt = subgetopt_r(argc, argv, "12t:D:", &l) ; if (opt == -1) break ; switch (opt) { case '1' : where = &genwrite_stdout ; break ; case '2' : where = &genwrite_stderr ; break ; case 't' : if (!uint0_scan(l.arg, &t)) dieusage() ; break ; case 'D' : if (!uint0_scan(l.arg, &debuglevel)) dieusage() ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; if (t) tain_from_millisecs(&deadline, t) ; else deadline = tain_infinite_relative ; } if (argc < 2) dieusage() ; { s6dns_debughook_t dbh = { .post_recv = 0, .pre_send = 0, .post_send = 0 } ; s6dns_domain_t d ; uint16_t qtype = s6dns_analyze_qtype_parse(argv[0]) ; if (!qtype) dieusage() ; if (!s6dns_domain_fromstring_noqualify_encode(&d, argv[1], strlen(argv[1]))) strerr_diefu2sys(100, "encode ", argv[1]) ; dbh.external = where ; if (debuglevel & 1) dbh.post_recv = &s6dns_debug_dumpdt_post_recv ; if (debuglevel & 2) { dbh.pre_send = &s6dns_debug_dumpdt_pre_send ; dbh.post_send = &s6dns_debug_dumpdt_post_send ; } tain_now_set_stopwatch_g() ; tain_add_g(&deadline, &deadline) ; if (!s6dns_init()) strerr_diefu1sys(111, "s6dns_init") ; if (!s6dns_resolve_core_r_g(&d, qtype, &s6dns_engine_here, &s6dns_rci_here.servers, &dbh, &deadline)) { char fmt[UINT16_FMT] ; fmt[uint16_fmt(fmt, qtype)] = 0 ; strerr_diefu6x((errno == ETIMEDOUT) ? 99 : 2, "resolve query ", argv[1], " of qtype ", fmt, ": ", s6dns_constants_error_str(errno)) ; } } if (!s6dns_analyze_packet(&genwrite_stdout, s6dns_engine_packet(&s6dns_engine_here), s6dns_engine_packetlen(&s6dns_engine_here), 1)) { int e = errno ; buffer_flush(buffer_1) ; errno = e ; strerr_diefu1sys(111, "analyze response") ; } if (!buffer_flush(buffer_1)) strerr_diefu1sys(111, "write to stdout") ; return 0 ; } s6-dns-2.3.1.1/src/clients/s6-dnsq.c0000644000000000000000000000654413534434465013567 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-dnsq [ -1 | -2 ] [ -t timeout ] [ -D debuglevel ] qtype query serverip..." #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv) { tain_t deadline ; unsigned int debuglevel = 0 ; uint16_t qtype ; genwrite_t *where = &genwrite_stderr ; PROG = "s6-dnsq" ; { subgetopt_t l = SUBGETOPT_ZERO ; unsigned int t = 0 ; for (;;) { int opt = subgetopt_r(argc, argv, "12t:D:", &l) ; if (opt == -1) break ; switch (opt) { case '1' : where = &genwrite_stdout ; break ; case '2' : where = &genwrite_stderr ; break ; case 't' : if (!uint0_scan(l.arg, &t)) dieusage() ; break ; case 'D' : if (!uint0_scan(l.arg, &debuglevel)) dieusage() ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; if (t) tain_from_millisecs(&deadline, t) ; else deadline = tain_infinite_relative ; } if (argc < 3) dieusage() ; { s6dns_debughook_t dbh = { .post_recv = 0, .pre_send = 0, .post_send = 0 } ; s6dns_ip46list_t servers ; s6dns_domain_t d ; unsigned int i = 0, j = 0 ; qtype = s6dns_analyze_qtype_parse(argv[0]) ; if (!qtype) dieusage() ; if (!s6dns_domain_fromstring_noqualify_encode(&d, argv[1], strlen(argv[1]))) strerr_diefu2sys(100, "encode ", argv[1]) ; dbh.external = where ; memset(&servers, 0, sizeof(s6dns_ip46list_t)) ; for (; (i < (unsigned int)(argc - 2)) && (j < S6DNS_MAX_SERVERS) ; i++) { ip46_t z[S6DNS_MAX_SERVERS] ; size_t n ; unsigned int k = 0 ; if (!*argv[2+i]) continue ; if (!ip46_scanlist(z, S6DNS_MAX_SERVERS - j, argv[2 + i], &n)) strerr_diefu2sys(100, "make an IP address list out of ", argv[2+i]) ; for (; k < n ; k++) { memcpy(s6dns_ip46list_ip(&servers, j + k), z[k].ip, SKALIBS_IP_SIZE) ; #ifdef SKALIBS_IPV6_ENABLED if (ip46_is6(z + k)) bitarray_set(servers.is6, j + k) ; #endif } j += n ; } if (debuglevel & 1) dbh.post_recv = &s6dns_debug_dumpdt_post_recv ; if (debuglevel & 2) { dbh.pre_send = &s6dns_debug_dumpdt_pre_send ; dbh.post_send = &s6dns_debug_dumpdt_post_send ; } tain_now_set_stopwatch_g() ; tain_add_g(&deadline, &deadline) ; if (!s6dns_engine_init_r_g(&s6dns_engine_here, &servers, 0, d.s, d.len, qtype, &dbh, &deadline)) strerr_diefu1sys(111, "initialize query") ; } if (!s6dns_resolve_loop_g(&deadline)) { char fmt[UINT16_FMT] ; fmt[uint16_fmt(fmt, qtype)] = 0 ; strerr_diefu6x((errno == ETIMEDOUT) ? 99 : 2, "resolve query ", argv[0], " of qtype ", fmt, ": ", s6dns_constants_error_str(errno)) ; } if (!s6dns_analyze_packet(&genwrite_stdout, s6dns_engine_packet(&s6dns_engine_here), s6dns_engine_packetlen(&s6dns_engine_here), 0)) { int e = errno ; buffer_flush(buffer_1) ; errno = e ; strerr_diefu1sys(111, "analyze response") ; } if (!buffer_flush(buffer_1)) strerr_diefu1sys(111, "write to stdout") ; return 0 ; } s6-dns-2.3.1.1/src/clients/s6-randomip.c0000644000000000000000000000300213061734325014406 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #define USAGE "s6-randomip [ -4 ] [ -6 ] [ -n number ]" #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv) { char fmt[IP6_FMT] ; char ip[16] ; unsigned int n ; unsigned int i = 0 ; size_t what = 0 ; int finite = 0 ; PROG = "s6-randomip" ; for (;;) { int opt = subgetopt(argc, argv, "46n:") ; if (opt == -1) break ; switch (opt) { case '4' : what |= 1 ; break ; case '6' : what |= 2 ; break ; case 'n' : if (!uint0_scan(subgetopt_here.arg, &n)) dieusage() ; finite = 1 ; break ; default : dieusage() ; } } argc -= subgetopt_here.ind ; argv += subgetopt_here.ind ; if (!what) what = 1 ; what = 1 << (1 << what) ; if (!random_init()) strerr_diefu1sys(111, "init random generator") ; for (i = 0 ; !finite || (i < n) ; i++) { size_t len = what ; if (len > 16) { unsigned char c = random_char() ; len = (c & 1) ? 16 : 4 ; } random_string(ip, len) ; len = (len == 16) ? ip6_fmt(fmt, ip) : ip4_fmt(fmt, ip) ; fmt[len++] = '\n' ; if (buffer_put(buffer_1, fmt, len) < (ssize_t)len) strerr_diefu1sys(111, "write to stdout") ; } if (!buffer_flush(buffer_1)) strerr_diefu1sys(111, "write to stdout") ; return 0 ; } s6-dns-2.3.1.1/src/clients/s6-dnsip4-filter.c0000644000000000000000000000276513061734325015300 0ustar /* ISC license. */ #include #include #include #include #include #include #include "s6dns-generic-filter.h" #define USAGE "s6-dnsip4-filter [ -l lines ] [ -c concurrency ] [ -t timeout ] [ -f format ] [ -e errorformat ]" typedef struct s6dns_a1_s s6dns_a1_t, *s6dns_a1_t_ref ; struct s6dns_a1_s { char ip[4] ; unsigned int got : 1 ; } ; static int s6dns_message_parse_answer_a1 (s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos, unsigned int section, void *stuff) { if ((section == 2) && (rr->rtype == S6DNS_T_A) && (rr->rdlength == 4)) { s6dns_a1_t *data = stuff ; if (data->got) return 1 ; memcpy(data->ip, packet+pos, 4) ; data->got = 1 ; } (void)packetlen ; return 1 ; } static int ipformatter (stralloc *sa, char const *packet, unsigned int packetlen) { s6dns_a1_t data ; s6dns_message_header_t h ; int r ; data.got = 0 ; r = s6dns_message_parse(&h, packet, packetlen, &s6dns_message_parse_answer_a1, &data) ; if (r <= 0) return r ; if (!data.got) return 1 ; if (!stralloc_readyplus(sa, IP4_FMT)) return -1 ; sa->len += ip4_fmt(sa->s + sa->len, data.ip) ; stralloc_0(sa) ; return 1 ; } int main (int argc, char const *const *argv, char const *const *envp) { PROG = "s6-dnsip4-filter" ; return s6dns_generic_filter_main(argc, argv, envp, S6DNS_T_A, &s6dns_namescanner, &ipformatter, USAGE) ; } s6-dns-2.3.1.1/src/clients/deps-exe/0000755000000000000000000000000013540723124013617 5ustar s6-dns-2.3.1.1/src/clients/deps-exe/s6-dnsip6-filter0000644000000000000000000000017613540723124016562 0ustar s6dns_generic_filter_main.o s6dns_namescanner.o ${LIBSKADNS} ${LIBS6DNS} -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} ${SPAWN_LIB} s6-dns-2.3.1.1/src/clients/deps-exe/s6-dnsip40000644000000000000000000000006413540723124015271 0ustar ${LIBS6DNS} -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dns-2.3.1.1/src/clients/deps-exe/s6-dnsmx0000644000000000000000000000006413540723124015221 0ustar ${LIBS6DNS} -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dns-2.3.1.1/src/clients/deps-exe/s6-dnssoa0000644000000000000000000000006413540723124015357 0ustar ${LIBS6DNS} -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dns-2.3.1.1/src/clients/deps-exe/s6-dnsns0000644000000000000000000000006413540723124015215 0ustar ${LIBS6DNS} -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dns-2.3.1.1/src/clients/deps-exe/s6-dnsip60000644000000000000000000000006413540723124015273 0ustar ${LIBS6DNS} -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dns-2.3.1.1/src/clients/deps-exe/s6-dnsq0000644000000000000000000000006413540723124015035 0ustar ${LIBS6DNS} -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dns-2.3.1.1/src/clients/deps-exe/s6-dnsname-filter0000644000000000000000000000015213540723124016776 0ustar s6dns_generic_filter_main.o ${LIBSKADNS} ${LIBS6DNS} -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} ${SPAWN_LIB} s6-dns-2.3.1.1/src/clients/deps-exe/s6-dnstxt0000644000000000000000000000006413540723124015414 0ustar ${LIBS6DNS} -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dns-2.3.1.1/src/clients/deps-exe/s6-randomip0000644000000000000000000000005013540723124015674 0ustar -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dns-2.3.1.1/src/clients/deps-exe/s6-dnsname0000644000000000000000000000006413540723124015515 0ustar ${LIBS6DNS} -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dns-2.3.1.1/src/clients/deps-exe/s6-dnsqualify0000644000000000000000000000002612455323730016250 0ustar ${LIBS6DNS} -lskarnet s6-dns-2.3.1.1/src/clients/deps-exe/s6-dnsqr0000644000000000000000000000006413540723124015217 0ustar ${LIBS6DNS} -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dns-2.3.1.1/src/clients/deps-exe/s6-dnssrv0000644000000000000000000000006413540723124015407 0ustar ${LIBS6DNS} -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dns-2.3.1.1/src/clients/deps-exe/s6-dnsip4-filter0000644000000000000000000000017613540723124016560 0ustar s6dns_generic_filter_main.o s6dns_namescanner.o ${LIBSKADNS} ${LIBS6DNS} -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} ${SPAWN_LIB} s6-dns-2.3.1.1/src/clients/s6dns_generic_filter_main.c0000644000000000000000000001627413534434230017365 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "s6dns-generic-filter.h" #define dieusage() strerr_dief1x(100, USAGE) ; typedef struct line_s line_t, *line_t_ref ; struct line_s { stralloc swrd ; size_t wpos ; ssize_t dpos ; char w[2] ; unsigned int pending : 1 ; } ; #define LINE_ZERO { .swrd = STRALLOC_ZERO, .wpos = 0, .dpos = 0, .w = "\0", .pending = 0 } static void line_recycle (line_t *l) { l->swrd.len = 0 ; l->pending = 0 ; } int flag4 = 0 ; int flag6 = 0 ; int s6dns_generic_filter_main (int argc, char const *const *argv, char const *const *envp, uint16_t qtype, scan_func_t_ref scanner, fmt_func_t_ref formatter, char const *USAGE) { skadns_t a = SKADNS_ZERO ; tain_t deadline, tto ; char const *normalformat = "%s=%d%w%r" ; char const *errorformat = "%s=<%e>%w%r" ; uint16_t maxlines = 256 ; uint16_t maxconn = 128 ; { subgetopt_t l = SUBGETOPT_ZERO ; unsigned int t = 0 ; for (;;) { int opt = subgetopt_r(argc, argv, (qtype == S6DNS_T_PTR) ? "46l:c:t:f:e:" : "l:c:t:f:e:", &l) ; if (opt == -1) break ; switch (opt) { case '4' : flag4 = 1 ; break ; case '6' : flag6 = 1 ; break ; case 'l' : if (!uint160_scan(l.arg, &maxlines)) dieusage() ; break ; case 'c' : if (!uint160_scan(l.arg, &maxconn)) dieusage() ; break ; case 't' : if (!uint0_scan(l.arg, &t)) dieusage() ; break ; case 'f' : normalformat = l.arg ; break ; case 'e' : errorformat = l.arg ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; if (t) tain_from_millisecs(&tto, t) ; else tto = tain_infinite_relative ; } if (!flag4 && !flag6) flag4 = 1 ; if (maxconn < 1) maxconn = 1 ; if (maxconn > SKADNS_MAXCONCURRENCY) maxconn = SKADNS_MAXCONCURRENCY ; if (maxlines < maxconn) maxlines = maxconn ; tain_now_set_stopwatch_g() ; tain_addsec_g(&deadline, 2) ; if (!skadns_startf_g(&a, &deadline)) strerr_diefu1sys(111, "establish skadns connection") ; if ((ndelay_on(0) < 0) || (ndelay_on(1) < 0)) strerr_diefu1sys(111, "ndelay_on") ; { iopause_fd x[3] = { { .fd = 0, .events = 0, .revents = 0 }, { .fd = 1, .events = 0, .revents = 0 }, { .fd = skadns_fd(&a), .events = 0, .revents = 0 } } ; uint16_t lhead = 0, ltail = 0, numlines = 0, pending = 0 ; line_t storage[maxlines+1] ; uint16_t lineindex[maxconn] ; { line_t line_zero = LINE_ZERO ; char const *args[4] = { "", "", "", "" } ; uint16_t i = 0 ; for (; i <= maxlines ; i++) storage[i] = line_zero ; if (!string_format(&storage[0].swrd, "sdwr", normalformat, args) || !string_format(&storage[0].swrd, "sewr", errorformat, args)) strerr_diefu1sys(111, "format a string") ; storage[0].swrd.len = 0 ; } for (;;) { x[0].events = !x[0].fd && (numlines < maxlines) && (pending < maxconn) ? IOPAUSE_READ : 0 ; x[1].events = bufalloc_len(bufalloc_1) ? IOPAUSE_WRITE : 0 ; x[2].events = pending ? IOPAUSE_READ : 0 ; if (!x[0].events && !x[1].events && !x[2].events) break ; tain_add_g(&deadline, &tain_infinite_relative) ; if (iopause_g(x + !(x[0].events & IOPAUSE_READ), 3 - !(x[0].events & IOPAUSE_READ), &deadline) < 0) strerr_diefu1sys(111, "iopause") ; /* Flush stdout */ if (x[1].revents) { if (!bufalloc_flush(bufalloc_1) && !error_isagain(errno)) strerr_diefu1sys(111, "write to stdout") ; } /* Get and format results from skadnsd */ if (x[2].revents) { int j = 0 ; uint16_t const *list ; int n = skadns_update(&a) ; if (n < 0) strerr_diefu1sys(111, "skadns_update") ; list = skadns_list(&a) ; for (; j < n ; j++) { uint16_t i = lineindex[list[j]] ; char const *packet = skadns_packet(&a, list[j]) ; if (packet) { int r ; r = (*formatter)(&storage[i].swrd, packet, skadns_packetlen(&a, list[j])) ; if (r < 0) strerr_diefu1sys(111, "format skadns answer") ; if (!r) storage[i].dpos = -errno ; } else storage[i].dpos = -errno ; storage[i].pending = 0 ; skadns_release(&a, list[j]) ; pending-- ; } skadns_clearlist(&a) ; } /* Scan stdin and send queries to skadnsd */ if (buffer_len(buffer_0) || (!x[0].fd && x[0].revents)) { for (; (numlines < maxlines) && (pending < maxconn) ; lhead = (lhead+1) % (maxlines+1), numlines++) { s6dns_domain_t d ; line_t *line = storage + lhead ; int r = skagetln(buffer_0, &line->swrd, '\n') ; if (r < 0) { if (error_isagain(errno)) break ; if (errno != EPIPE) strerr_diefu1sys(111, "read from stdin") ; if (!stralloc_catb(&line->swrd, "\n", 1)) strerr_diefu1sys(111, "stralloc_catb") ; fd_close(x[0].fd) ; x[0].fd = -1 ; break ; } else if (!r) { fd_close(x[0].fd) ; x[0].fd = -1 ; break ; } line->swrd.s[line->swrd.len-1] = 0 ; line->wpos = (*scanner)(&d, line->swrd.s) ; if (!line->wpos) { line->wpos = line->swrd.len - 1 ; line->w[0] = 0 ; line->dpos = -errno ; } else { tain_t sendlimit ; uint16_t id ; line->w[0] = line->swrd.s[line->wpos] ; line->swrd.s[line->wpos] = 0 ; tain_addsec_g(&sendlimit, 2) ; tain_add_g(&deadline, &tto) ; if (!skadns_send_g(&a, &id, &d, qtype, &deadline, &sendlimit)) line->dpos = -errno ; else { line->dpos = line->swrd.len ; lineindex[id] = lhead ; line->pending = 1 ; pending++ ; } } } } /* Send processed lines to stdout */ for (; ltail != lhead ; ltail = (ltail+1) % (maxlines+1), numlines--) { char *args[4] ; line_t *line = storage + ltail ; if (line->pending) break ; args[0] = line->swrd.s ; args[1] = line->dpos < 0 ? (char *)s6dns_constants_error_str(-line->dpos) : line->swrd.s + line->dpos ; args[2] = line->w ; args[3] = line->swrd.s + line->wpos + !!line->w[0] ; if (!string_format(&bufalloc_1->x, line->dpos < 0 ? "sewr" : "sdwr", line->dpos < 0 ? errorformat : normalformat, (char const **)args)) strerr_diefu1sys(111, "format output line") ; line_recycle(line) ; if (!bufalloc_put(bufalloc_1, "\n", 1)) strerr_diefu1sys(111, "bufalloc_put") ; } } } (void)envp ; return 0 ; } s6-dns-2.3.1.1/src/clients/s6-dnssoa.c0000644000000000000000000000427013534434534014100 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-dnssoa [ -q ] [ -r ] [ -t timeout ] name" #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv) { genalloc soas = GENALLOC_ZERO ; /* array of s6dns_message_rr_soa_t */ tain_t deadline ; size_t i = 0 ; unsigned int t = 0 ; int flagqualify = 0 ; int flagunsort = 0 ; PROG = "s6-dnssoa" ; for (;;) { int opt = subgetopt(argc, argv, "qrt:") ; if (opt == -1) break ; switch (opt) { case 'q' : flagqualify = 1 ; break ; case 'r' : flagunsort = 1 ; break ; case 't' : if (!uint0_scan(subgetopt_here.arg, &t)) dieusage() ; break ; default : dieusage() ; } } argc -= subgetopt_here.ind ; argv += subgetopt_here.ind ; if (argc < 1) dieusage() ; tain_now_set_stopwatch_g() ; if (t) tain_from_millisecs(&deadline, t) ; else deadline = tain_infinite_relative ; tain_add_g(&deadline, &deadline) ; if (!s6dns_init()) strerr_diefu1sys(111, "s6dns_init") ; { int r = s6dns_resolve_soa_g(&soas, argv[0], strlen(argv[0]), flagqualify, &deadline) ; if (r < 0) strerr_diefu2sys((errno == ETIMEDOUT) ? 99 : 111, "resolve ", argv[0]) ; if (!r) strerr_diefu4x(2, "resolve ", argv[0], ": ", s6dns_constants_error_str(errno)) ; } if (!genalloc_len(s6dns_message_rr_soa_t, &soas)) return 1 ; if (flagunsort) random_unsort(soas.s, genalloc_len(s6dns_message_rr_soa_t, &soas), sizeof(s6dns_message_rr_soa_t)) ; for (i = 0 ; i < genalloc_len(s6dns_message_rr_soa_t, &soas) ; i++) { char buf[S6DNS_FMT_SOA] ; size_t len = s6dns_fmt_soa(buf, S6DNS_FMT_SOA, genalloc_s(s6dns_message_rr_soa_t, &soas) + i) ; if (!len) strerr_diefu1sys(111, "format result") ; if (buffer_put(buffer_1, buf, len) < (ssize_t)len) goto err ; if (buffer_put(buffer_1, "\n", 1) < 1) goto err ; } if (!buffer_flush(buffer_1)) goto err ; return 0 ; err: strerr_diefu1sys(111, "write to stdout") ; } s6-dns-2.3.1.1/src/clients/s6-dnsip6.c0000644000000000000000000000361013534434304014004 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-dnsip6 [ -q ] [ -r ] [ -t timeout ] domain" #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv) { stralloc ips = STRALLOC_ZERO ; tain_t deadline ; size_t i = 0 ; unsigned int t = 0 ; int flagqualify = 0 ; int flagunsort = 0 ; PROG = "s6-dnsip6" ; for (;;) { int opt = subgetopt(argc, argv, "qrt:") ; if (opt == -1) break ; switch (opt) { case 'q' : flagqualify = 1 ; break ; case 'r' : flagunsort = 1 ; break ; case 't' : if (!uint0_scan(subgetopt_here.arg, &t)) dieusage() ; break ; default : dieusage() ; } } argc -= subgetopt_here.ind ; argv += subgetopt_here.ind ; if (argc < 1) dieusage() ; tain_now_set_stopwatch_g() ; if (t) tain_from_millisecs(&deadline, t) ; else deadline = tain_infinite_relative ; tain_add_g(&deadline, &deadline) ; if (!s6dns_init()) strerr_diefu1sys(111, "s6dns_init") ; { int r = s6dns_resolve_aaaa_g(&ips, argv[0], strlen(argv[0]), flagqualify, &deadline) ; if (r < 0) strerr_diefu2sys((errno == ETIMEDOUT) ? 99 : 111, "resolve ", argv[0]) ; if (!r) strerr_diefu4x(2, "resolve ", argv[0], ": ", s6dns_constants_error_str(errno)) ; } if (!ips.len) return 1 ; if (flagunsort) random_unsort(ips.s, ips.len / 16, 16) ; for (i = 0 ; i < ips.len / 16 ; i++) { char fmt[IP6_FMT] ; size_t n = ip6_fmt(fmt, ips.s + 16 * i) ; fmt[n++] = '\n' ; if (buffer_put(buffer_1small, fmt, n) < (ssize_t)n) strerr_diefu1sys(111, "write to stdout") ; } if (!buffer_flush(buffer_1small)) strerr_diefu1sys(111, "write to stdout") ; return 0 ; } s6-dns-2.3.1.1/src/clients/s6-dnstxt.c0000644000000000000000000000505413534434735014141 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-dnstxt [ -q ] [ -r ] [ -t timeout ] name" #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv) { stralloc quoted = STRALLOC_ZERO ; stralloc sa = STRALLOC_ZERO ; genalloc offsets = GENALLOC_ZERO ; /* array of size_t */ tain_t deadline ; size_t n ; size_t i = 0 ; unsigned int t = 0 ; int flagqualify = 0 ; int flagunsort = 0 ; PROG = "s6-dnstxt" ; for (;;) { int opt = subgetopt(argc, argv, "qrt:") ; if (opt == -1) break ; switch (opt) { case 'q' : flagqualify = 1 ; break ; case 'r' : flagunsort = 1 ; break ; case 't' : if (!uint0_scan(subgetopt_here.arg, &t)) dieusage() ; break ; default : dieusage() ; } } argc -= subgetopt_here.ind ; argv += subgetopt_here.ind ; if (argc < 1) dieusage() ; if (t) tain_from_millisecs(&deadline, t) ; else deadline = tain_infinite_relative ; tain_now_set_stopwatch_g() ; tain_add_g(&deadline, &deadline) ; if (!s6dns_init()) strerr_diefu1sys(111, "s6dns_init") ; { int r = s6dns_resolve_txt_g(&sa, &offsets, argv[0], strlen(argv[0]), flagqualify, &deadline) ; if (r < 0) strerr_diefu2sys((errno == ETIMEDOUT) ? 99 : 111, "resolve ", argv[0]) ; if (!r) strerr_diefu4x(2, "resolve ", argv[0], ": ", s6dns_constants_error_str(errno)) ; } n = genalloc_len(size_t, &offsets) ; if (!n) return 1 ; { size_t printable_offsets[n] ; for (i = 0 ; i < n ; i++) { size_t beg = genalloc_s(size_t, &offsets)[i] ; size_t end = (i < n-1 ? genalloc_s(size_t, &offsets)[i+1] : sa.len) - 1 ; printable_offsets[i] = quoted.len ; if (!string_quote("ed, sa.s + beg, end - beg) || !stralloc_0("ed)) strerr_diefu2sys(111, "quote ", sa.s + beg) ; } genalloc_free(size_t, &offsets) ; stralloc_free(&sa) ; if (flagunsort) random_unsort((char *)printable_offsets, n, sizeof(size_t)) ; for (i = 0 ; i < n ; i++) if ((buffer_puts(buffer_1small, quoted.s + printable_offsets[i]) < 0) || (buffer_put(buffer_1small, "\n", 1) < 1)) strerr_diefu1sys(111, "write to stdout") ; } stralloc_free("ed) ; if (!buffer_flush(buffer_1small)) strerr_diefu1sys(111, "write to stdout") ; return 0 ; } s6-dns-2.3.1.1/src/clients/s6-dnsip4.c0000644000000000000000000000360113534434270014004 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #define USAGE "s6-dnsip4 [ -q ] [ -r ] [ -t timeout ] domain" #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv) { stralloc ips = STRALLOC_ZERO ; tain_t deadline ; size_t i = 0 ; unsigned int t = 0 ; int flagqualify = 0 ; int flagunsort = 0 ; PROG = "s6-dnsip4" ; for (;;) { int opt = subgetopt(argc, argv, "qrt:") ; if (opt == -1) break ; switch (opt) { case 'q' : flagqualify = 1 ; break ; case 'r' : flagunsort = 1 ; break ; case 't' : if (!uint0_scan(subgetopt_here.arg, &t)) dieusage() ; break ; default : dieusage() ; } } argc -= subgetopt_here.ind ; argv += subgetopt_here.ind ; if (argc < 1) dieusage() ; tain_now_set_stopwatch_g() ; if (t) tain_from_millisecs(&deadline, t) ; else deadline = tain_infinite_relative ; tain_add_g(&deadline, &deadline) ; if (!s6dns_init()) strerr_diefu1sys(111, "s6dns_init") ; { int r = s6dns_resolve_a_g(&ips, argv[0], strlen(argv[0]), flagqualify, &deadline) ; if (r < 0) strerr_diefu2sys((errno == ETIMEDOUT) ? 99 : 111, "resolve ", argv[0]) ; if (!r) strerr_diefu4x(2, "resolve ", argv[0], ": ", s6dns_constants_error_str(errno)) ; } if (!ips.len) return 1 ; if (flagunsort) random_unsort(ips.s, ips.len / 4, 4) ; for (i = 0 ; i < ips.len / 4 ; i++) { char fmt[IP4_FMT] ; size_t n = ip4_fmt(fmt, ips.s + 4 * i) ; fmt[n++] = '\n' ; if (buffer_put(buffer_1small, fmt, n) < (ssize_t)n) strerr_diefu1sys(111, "write to stdout") ; } if (!buffer_flush(buffer_1small)) strerr_diefu1sys(111, "write to stdout") ; return 0 ; } s6-dns-2.3.1.1/src/clients/s6-dnsqualify.c0000644000000000000000000000210713061734325014761 0ustar /* ISC license. */ #include #include #include #include #include #define USAGE "s6-dnsqualify name" #define dieusage() strerr_dieusage(100, USAGE) int main (int argc, char const *const *argv) { s6dns_domain_t d ; PROG = "s6-dnsqualify" ; if (argc < 2) dieusage() ; if (!s6dns_domain_fromstring(&d, argv[1], strlen(argv[1]))) strerr_diefu2sys(100, "make a domain name from ", argv[1]) ; if (!s6dns_init()) strerr_diefu1sys(111, "s6dns_init") ; { s6dns_domain_t list[s6dns_rci_here.rulesnum] ; unsigned int n = s6dns_qualify(list, &d) ; if (!n) strerr_diefu2sys(111, "qualify ", argv[1]) ; { char buf[S6DNS_FMT_DOMAINLIST(n)] ; size_t len = s6dns_fmt_domainlist(buf, S6DNS_FMT_DOMAINLIST(n), list, n, "\n", 1) ; if (!len) strerr_diefu1sys(111, "format result") ; if (buffer_put(buffer_1, buf, len) < (ssize_t)len) goto err ; } } if (buffer_putflush(buffer_1, "\n", 1) < 1) goto err ; return 0 ; err: strerr_diefu1sys(111, "write to stdout") ; } s6-dns-2.3.1.1/src/clients/s6dns_namescanner.c0000644000000000000000000000074013061734325015664 0ustar /* ISC license. */ #include #include #include #include #include "s6dns-generic-filter.h" size_t s6dns_namescanner (s6dns_domain_t *d, char const *s) { size_t pos = 0 ; while (s[pos] && (s[pos] != ' ') && (s[pos] != '\t') && (s[pos] != '\r') && (s[pos] != '\n')) pos++ ; if (pos > UINT_MAX) return (errno = ENAMETOOLONG, 0) ; if (!s6dns_domain_fromstring_noqualify_encode(d, s, pos)) return 0 ; return pos ; } s6-dns-2.3.1.1/src/clients/s6-dnsip6-filter.c0000644000000000000000000000302613061734325015271 0ustar /* ISC license. */ #include #include #include #include #include #include #include "s6dns-generic-filter.h" #define USAGE "s6-dnsip6-filter [ -l lines ] [ -c concurrency ] [ -t timeout ] [ -f format ] [ -e errorformat ]" typedef struct s6dns_aaaa1_s s6dns_aaaa1_t, *s6dns_aaaa1_t_ref ; struct s6dns_aaaa1_s { char ip[16] ; unsigned int got : 1 ; } ; static int s6dns_message_parse_answer_aaaa1 (s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos, unsigned int section, void *stuff) { if ((section == 2) && (rr->rtype == S6DNS_T_AAAA) && (rr->rdlength == 16)) { s6dns_aaaa1_t *data = stuff ; if (data->got) return 1 ; memcpy(data->ip, packet+pos, 16) ; data->got = 1 ; } (void)packetlen ; return 1 ; } static int ipformatter (stralloc *sa, char const *packet, unsigned int packetlen) { s6dns_aaaa1_t data ; s6dns_message_header_t h ; int r ; data.got = 0 ; r = s6dns_message_parse(&h, packet, packetlen, &s6dns_message_parse_answer_aaaa1, &data) ; if (r <= 0) return r ; if (!data.got) return 1 ; if (!stralloc_readyplus(sa, IP6_FMT)) return -1 ; sa->len += ip6_fmt(sa->s + sa->len, data.ip) ; stralloc_0(sa) ; return 1 ; } int main (int argc, char const *const *argv, char const *const *envp) { PROG = "s6-dnsip6-filter" ; return s6dns_generic_filter_main(argc, argv, envp, S6DNS_T_AAAA, &s6dns_namescanner, &ipformatter, USAGE) ; } s6-dns-2.3.1.1/src/clients/s6dns-generic-filter.h0000644000000000000000000000133313060767302016213 0ustar /* ISC license. */ #ifndef SKADNS_GENERIC_FILTER_H #define SKADNS_GENERIC_FILTER_H #include #include #include #include typedef size_t scan_func_t (s6dns_domain_t *, char const *) ; typedef scan_func_t *scan_func_t_ref ; typedef int fmt_func_t (stralloc *, char const *, unsigned int) ; typedef fmt_func_t *fmt_func_t_ref ; extern size_t s6dns_namescanner (s6dns_domain_t *, char const *) ; extern int s6dns_domainformatter (stralloc *, char const *, unsigned int) ; extern int s6dns_generic_filter_main (int, char const *const *, char const *const *, uint16_t, scan_func_t_ref, fmt_func_t_ref, char const *) ; extern int flag4 ; extern int flag6 ; #endif s6-dns-2.3.1.1/src/clients/deps-lib/0000755000000000000000000000000012442016414013601 5ustar s6-dns-2.3.1.1/src/include-local/0000755000000000000000000000000012412615566013166 5ustar s6-dns-2.3.1.1/src/include/0000755000000000000000000000000012441445521012070 5ustar s6-dns-2.3.1.1/src/include/s6-dns/0000755000000000000000000000000013541514163013203 5ustar s6-dns-2.3.1.1/src/include/s6-dns/s6dns-analyze.h0000644000000000000000000000272013263507724016061 0ustar /* ISC license. */ #ifndef S6DNS_ANALYZE_H #define S6DNS_ANALYZE_H #include #include #include typedef int s6dns_analyze_record_func_t (genwrite_t *, s6dns_message_rr_t const *, char const *, unsigned int, unsigned int) ; typedef s6dns_analyze_record_func_t *s6dns_analyze_record_func_t_ref ; typedef struct s6dns_analyze_rtypetable_s s6dns_analyze_rtypetable_t, *s6dns_analyze_rtypetable_t_ref ; struct s6dns_analyze_rtypetable_s { uint16_t rtype ; char const *string ; s6dns_analyze_record_func_t_ref f ; } ; extern uint16_t s6dns_analyze_qtype_parse (char const *) ; extern s6dns_analyze_rtypetable_t const *s6dns_analyze_rtypetable ; extern s6dns_analyze_record_func_t s6dns_analyze_record_a ; extern s6dns_analyze_record_func_t s6dns_analyze_record_aaaa ; extern s6dns_analyze_record_func_t s6dns_analyze_record_hinfo ; extern s6dns_analyze_record_func_t s6dns_analyze_record_soa ; extern s6dns_analyze_record_func_t s6dns_analyze_record_mx ; extern s6dns_analyze_record_func_t s6dns_analyze_record_srv ; extern s6dns_analyze_record_func_t s6dns_analyze_record_caa ; extern s6dns_analyze_record_func_t s6dns_analyze_record_domain ; extern s6dns_analyze_record_func_t s6dns_analyze_record_strings ; extern s6dns_analyze_record_func_t s6dns_analyze_record_unknown ; extern s6dns_analyze_record_func_t s6dns_analyze_record ; extern int s6dns_analyze_packet (genwrite_t *, char const *, unsigned int, int) ; #endif s6-dns-2.3.1.1/src/include/s6-dns/s6dns-fmt.h0000644000000000000000000000207613263520133015175 0ustar /* ISC license. */ #ifndef S6DNS_FMT_H #define S6DNS_FMT_H #include #include #include #include #define S6DNS_FMT_DOMAIN 256 #define s6dns_fmt_domain(s, max, d) s6dns_domain_tostring(s, max, d) #define S6DNS_FMT_DOMAINLIST(n) ((n) * S6DNS_FMT_DOMAIN) extern size_t s6dns_fmt_domainlist (char *, size_t, s6dns_domain_t const *, unsigned int, char const *, size_t) ; #define S6DNS_FMT_HINFO 512 extern size_t s6dns_fmt_hinfo (char *, size_t, s6dns_message_rr_hinfo_t const *) ; #define S6DNS_FMT_MX (S6DNS_FMT_DOMAIN + UINT16_FMT) extern size_t s6dns_fmt_mx (char *, size_t, s6dns_message_rr_mx_t const *) ; #define S6DNS_FMT_SOA (S6DNS_FMT_DOMAIN * 2 + 5 * UINT32_FMT) extern size_t s6dns_fmt_soa (char *, size_t, s6dns_message_rr_soa_t const *) ; #define S6DNS_FMT_SRV (S6DNS_FMT_DOMAIN + 3 * UINT16_FMT) extern size_t s6dns_fmt_srv (char *, size_t, s6dns_message_rr_srv_t const *) ; #define S6DNS_FMT_CAA 517 extern size_t s6dns_fmt_caa (char *, size_t, s6dns_message_rr_caa_t const *) ; #endif s6-dns-2.3.1.1/src/include/s6-dns/s6dns.h0000644000000000000000000000060413000201736014376 0ustar /* ISC license. */ #ifndef S6DNS_H #define S6DNS_H #include #include #include #include #include #include #include #include extern int s6dns_init (void) ; extern void s6dns_finish (void) ; #endif s6-dns-2.3.1.1/src/include/s6-dns/s6dns-resolve.h0000644000000000000000000005006513263510167016075 0ustar /* ISC license. */ #ifndef S6DNS_RESOLVE_H #define S6DNS_RESOLVE_H #include #include #include #include #include #include #include #include #include #include #include #include /* Synchronous DNS resolution primitives. The non-reentrant functions are just wrappers around the reentrant ones, using globals for the parameters the user doesn't care about: s6dns_engine_here for the query storage (dt), s6dns_debughook_zero meaning no debugging needed, s6dns_rci_here for the resolv.conf information (qualification rules and initial cache IPs) */ /* The basic s6dns_engine wrapper loop: takes an initted dt and resolves it. */ #define s6dns_resolve_loop(deadline, stamp) s6dns_resolve_loop_r(&s6dns_engine_here, (deadline), stamp) #define s6dns_resolve_loop_g(deadline) s6dns_resolve_loop((deadline), &STAMP) #define s6dns_resolve_loop_r(dt, deadline, stamp) (s6dns_resolven_loop(dt, 1, 2, deadline, stamp) < 0 ? 0 : (dt)->status ? (errno = (dt)->status, 0) : 1) #define s6dns_resolve_loop_r_g(dt, deadline) s6dns_resolve_loop(dt, (deadline), &STAMP) /* QoL functions for single-domain synchronous resolution. */ /* The innermost one: Initializes the dt with the given data (d, qtype), then calls the loop. */ #define s6dns_resolve_core(d, qtype, deadline, stamp) s6dns_resolve_core_r(d, qtype, &s6dns_engine_here, &s6dns_rci_here.servers, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_core_g(d, qtype, deadline) s6dns_resolve_core(d, qtype, (deadline), &STAMP) extern int s6dns_resolve_core_r (s6dns_domain_t const *, uint16_t, s6dns_engine_t *, s6dns_ip46list_t const *, s6dns_debughook_t const *, tain_t const *, tain_t *) ; #define s6dns_resolve_core_r_g(d, qtype, dt, servers, dbh, deadline) s6dns_resolve_core_r(d, qtype, dt, servers, dbh, (deadline), &STAMP) /* Just above. Calls s6dns_resolve_core() then feeds the result to s6dns_message_parse(). Returns -1 if a resolving or parsing error occurs. Returns 0 if everything works but the result is empty for some reason (i.e. nxdomain). Returns 1 if everything works and there's an actual answer. */ #define s6dns_resolve_parse(d, qtype, parsefunc, parsedata, deadline, stamp) s6dns_resolve_parse_r(d, qtype, parsefunc, parsedata, &s6dns_engine_here, &s6dns_rci_here.servers, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_parse_g(d, qtype, parsefunc, parsedata, deadline) s6dns_resolve_parse(d, qtype, parsefunc, parsedata, (deadline), &STAMP) extern int s6dns_resolve_parse_r (s6dns_domain_t const *, uint16_t, s6dns_message_rr_func_t_ref, void *, s6dns_engine_t *, s6dns_ip46list_t const *, s6dns_debughook_t const *, tain_t const *, tain_t *) ; #define s6dns_resolve_parse_r_g(d, qtype, parsefunc, parsedata, dt, servers, dbh, deadline) s6dns_resolve_parse_r(d, qtype, parsefunc, parsedata, dt, servers, dbh, (deadline), &STAMP) /* Resolution without qualification. Encoding/decoding included. */ #define s6dns_resolvenoq(name, len, qtype, parsefunc, parsedata, deadline, stamp) s6dns_resolvenoq_r(name, len, qtype, parsefunc, parsedata, &s6dns_engine_here, &s6dns_rci_here.servers, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolvenoq_g(name, len, qtype, parsefunc, parsedata, deadline) s6dns_resolvenoq(name, len, qtype, parsefunc, parsedata, (deadline), &STAMP) extern int s6dns_resolvenoq_r (char const *, size_t, uint16_t, s6dns_message_rr_func_t_ref, void *, s6dns_engine_t *, s6dns_ip46list_t const *, s6dns_debughook_t const *, tain_t const *, tain_t *) ; #define s6dns_resolvenoq_r_g(name, len, qtype, parsefunc, parsedata, dt, servers, dbh, deadline) s6dns_resolvenoq_r(name, len, qtype, parsefunc, parsedata, dt, servers, dbh, (deadline), &STAMP) /* Resolution with qualification: Get a qualification list from a name, then resolve the list in parallel. */ #define s6dns_resolveq(name, len, qtype, parsefunc, parsedata, deadline, stamp) s6dns_resolveq_r(name, len, qtype, parsefunc, parsedata, &s6dns_rci_here, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolveq_g(name, len, qtype, parsefunc, parsedata, deadline) s6dns_resolveq(name, len, qtype, parsefunc, parsedata, (deadline), &STAMP) extern int s6dns_resolveq_r (char const *, size_t, uint16_t, s6dns_message_rr_func_t_ref, void *, s6dns_rci_t const *, s6dns_debughook_t const *, tain_t const *, tain_t *) ; #define s6dns_resolveq_r_g(name, len, qtype, parsefunc, parsedata, rci, dbh, deadline) s6dns_resolveq_r(name, len, qtype, parsefunc, parsedata, rci, dbh, (deadline), &STAMP) /* The resolution primitive that calls s6dns_resolvenoq() if the qualif flag is cleared and s6dns_resolveq() if it is set. */ #define s6dns_resolve(name, len, qtype, parsefunc, parsedata, qualif, deadline, stamp) s6dns_resolve_r(name, len, qtype, parsefunc, parsedata, qualif, &s6dns_engine_here, &s6dns_rci_here, &s6dns_debughook_t const *, deadline, stamp) #define s6dns_resolve_g(name, len, qtype, parsefunc, parsedata, qualif, deadline) s6dns_resolve(name, len, qtype, parsefunc, parsedata, qualif, (deadline), &STAMP) #define s6dns_resolve_r(name, len, qtype, parsefunc, parsedata, qualif, dt, rci, dbh, deadline, stamp) ((qualif) ? s6dns_resolveq_r(name, len, qtype, parsefunc, parsedata, rci, dbh, deadline, stamp) : s6dns_resolvenoq_r(name, len, qtype, parsefunc, parsedata, dt, &(rci)->servers, dbh, deadline, stamp)) #define s6dns_resolve_r_g(name, len, qtype, parsefunc, parsedata, qualif, dt, rci, dbh, deadline) s6dns_resolve_r(name, len, qtype, parsefunc, parsedata, qualif, dt, rci, dbh, (deadline), &STAMP) /* How to perform both AAAA and A queries at the same time */ #define s6dns_resolvenoq_aaaaa(ips, name, len, deadline, stamp) s6dns_resolvenoq_aaaaa_r(ips, name, len, &s6dns_rci_here.servers, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolvenoq_aaaaa_g(ips, name, len, deadline) s6dns_resolvenoq_aaaaa(ips, name, len, (deadline), &STAMP) extern int s6dns_resolvenoq_aaaaa_r(genalloc *, char const *, size_t, s6dns_ip46list_t const *, s6dns_debughook_t const *, tain_t const *, tain_t *) ; #define s6dns_resolvenoq_aaaaa_r_g(ips, name, len, servers, dbh, deadline) s6dns_resolvenoq_aaaaa_r(ips, name, len, servers, dbh, (deadline), &STAMP) #define s6dns_resolveq_aaaaa(ips, name, len, deadline, stamp) s6dns_resolveq_aaaaa_r(ips, name, len, &s6dns_rci_here, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolveq_aaaaa_g(ips, name, len, deadline) s6dns_resolveq_aaaaa(ips, name, len, (deadline), &STAMP) extern int s6dns_resolveq_aaaaa_r(genalloc *, char const *, size_t, s6dns_rci_t const *, s6dns_debughook_t const *, tain_t const *, tain_t *) ; #define s6dns_resolveq_aaaaa_r_g(ips, name, len, rci, dbh, deadline) s6dns_resolvenoq_aaaaa_r(ips, name, len, rci, dbh, (deadline), &STAMP) /* Some high-level functions. Queries are automatically translated to domain form and encoded. Domains returned in a stralloc are automatically decoded. Warning: decoded domains all start with '.' The int flag decides if qualification is needed or not. */ /* For A fields: the stralloc answer has 4 chars per IP4. For AAAA fields: the stralloc answer has 16 chars per IP6. For TXT fields (and other mpag stuff): the stralloc contains the strings and the genalloc contains a list of offsets into that stralloc. For other fields: the result is stored in a genalloc of the appropriate type. */ #define s6dns_resolve_a(ips, name, len, qualif, deadline, stamp) s6dns_resolve_a_r(ips, name, len, qualif, &s6dns_engine_here, &s6dns_rci_here, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_a_g(ips, name, len, qualif, deadline) s6dns_resolve_a(ips, name, len, qualif, (deadline), &STAMP) #define s6dns_resolve_a_r(ips, name, len, qualif, dt, rci, dbh, deadline, stamp) s6dns_resolve_r(name, len, S6DNS_T_A, &s6dns_message_parse_answer_a, (ips), qualif, dt, rci, dbh, deadline, stamp) #define s6dns_resolve_a_r_g(ips, name, len, qualif, dt, rci, dbh, deadline) s6dns_resolve_a_r(ips, name, len, qualif, dt, rci, dbh, (deadline), &STAMP) #define s6dns_resolve_aaaa(ip6s, name, len, qualif, deadline, stamp) s6dns_resolve_aaaa_r(ip6s, name, len, qualif, &s6dns_engine_here, &s6dns_rci_here, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_aaaa_g(ip6s, name, len, qualif, deadline) s6dns_resolve_aaaa(ip6s, name, len, qualif, (deadline), &STAMP) #define s6dns_resolve_aaaa_r(ip6s, name, len, qualif, dt, rci, dbh, deadline, stamp) s6dns_resolve_r(name, len, S6DNS_T_AAAA, &s6dns_message_parse_answer_aaaa, (ip6s), qualif, dt, rci, dbh, deadline, stamp) #define s6dns_resolve_aaaa_r_g(ip6s, name, len, qualif, dt, rci, dbh, deadline) s6dns_resolve_aaaa_r(ip6s, name, len, qualif, dt, rci, dbh, (deadline), &STAMP) #define s6dns_resolve_aaaaa(ips, name, len, qualif, deadline, stamp) s6dns_resolve_aaaaa_r(ips, name, len, qualif, &s6dns_rci_here, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_aaaaa_g(ips, name, len, qualif, deadline) s6dns_resolve_aaaaa(ips, name, len, qualif, (deadline), &STAMP) #define s6dns_resolve_aaaaa_r(ips, name, len, qualif, rci, dbh, deadline, stamp) ((qualif) ? s6dns_resolveq_aaaaa_r(ips, name, len, rci, dbh, deadline, stamp) : s6dns_resolvenoq_aaaaa_r(ips, name, len, &(rci)->servers, dbh, deadline, stamp)) #define s6dns_resolve_aaaaa_r_g(ips, name, len, qualif, rci, dbh, deadline) s6dns_resolve_aaaaa_r(ips, name, len, qualif, rci, dbh, (deadline), &STAMP) #define s6dns_resolve_ptr(ds, name, len, deadline, stamp) s6dns_resolve_ptr_r(ds, name, len, &s6dns_engine_here, &s6dns_rci_here.servers, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_ptr_g(ds, name, len, deadline) s6dns_resolve_ptr(ds, name, len, (deadline), &STAMP) #define s6dns_resolve_ptr_r(ds, name, len, dt, servers, dbh, deadline, stamp) s6dns_resolvenoq_r(name, len, S6DNS_T_PTR, &s6dns_message_parse_answer_domain, (ds), dt, servers, dbh, deadline, stamp) #define s6dns_resolve_ptr_r_g(ds, name, len, dt, servers, dbh, deadline) s6dns_resolve_ptr_r(ds, name, len, dt, servers, dbh, (deadline), &STAMP) #define s6dns_resolve_name4(ds, ip, deadline, stamp) s6dns_resolve_name4_r(ds, ip, &s6dns_engine_here, &s6dns_rci_here.servers, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_name4_g(ds, ip, deadline) s6dns_resolve_name4(ds, ip, (deadline), &STAMP) extern int s6dns_resolve_name4_r (genalloc *, char const *, s6dns_engine_t *, s6dns_ip46list_t const *, s6dns_debughook_t const *, tain_t const *, tain_t *) ; #define s6dns_resolve_name4_r_g(ds, ip, dt, servers, dbh, deadline) s6dns_resolve_name4_r(ds, ip, dt, servers, dbh, (deadline), &STAMP) #define s6dns_resolve_name6(ds, ip6, deadline, stamp) s6dns_resolve_name6_r(ds, ip6, &s6dns_engine_here, &s6dns_rci_here.servers, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_name6_g(ds, ip6, deadline) s6dns_resolve_name6(ds, ip6, (deadline), &STAMP) extern int s6dns_resolve_name6_r (genalloc *, char const *, s6dns_engine_t *, s6dns_ip46list_t const *, s6dns_debughook_t const *, tain_t const *, tain_t *) ; #define s6dns_resolve_name6_r_g(ds, ip6, dt, servers, dbh, deadline) s6dns_resolve_name6_r(ds, ip6, dt, servers, dbh, (deadline), &STAMP) #define s6dns_resolve_name46(ds, i, deadline, stamp) s6dns_resolve_name46_r(ds, i, &s6dns_engine_here, &s6dns_rci_here.servers, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_name46_g(ds, i, deadline) s6dns_resolve_name46(ds, i, (deadline), &STAMP) #define s6dns_resolve_name46_r(ds, i, dt, servers, dbh, deadline, stamp) (ip46_is6(i) ? s6dns_resolve_name6_r(ds, (i)->ip, dt, servers, dbh, deadline, stamp) : s6dns_resolve_name4_r(ds, (i)->ip, dt, servers, dbh, deadline, stamp)) #define s6dns_resolve_name46_r_g(ds, i, dt, servers, dbh, deadline) s6dns_resolve_name46_r(ds, i, dt, servers, dbh, (deadline), &STAMP) #define s6dns_resolve_txt(sa, offsets, name, len, qualif, deadline, stamp) s6dns_resolve_txt_r(sa, offsets, name, len, qualif, &s6dns_engine_here, &s6dns_rci_here, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_txt_g(sa, offsets, name, len, qualif, deadline) s6dns_resolve_txt(sa, offsets, name, len, qualif, (deadline), &STAMP) #define s6dns_resolve_txt_r(sa, offsets, name, len, qualif, dt, rci, dbh, deadline, stamp) s6dns_resolve_mpag_r(sa, offsets, name, len, S6DNS_T_TXT, &s6dns_message_parse_answer_strings, qualif, dt, rci, dbh, deadline, stamp) #define s6dns_resolve_txt_r_g(sa, offsets, name, len, qualif, dt, rci, dbh, deadline) s6dns_resolve_txt_r(sa, offsets, name, len, qualif, dt, rci, dbh, (deadline), &STAMP) #define s6dns_resolve_mx(mxs, name, len, qualif, deadline, stamp) s6dns_resolve_mx_r(mxs, name, len, qualif, &s6dns_engine_here, &s6dns_rci_here, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_mx_g(mxs, name, len, qualif, deadline) s6dns_resolve_mx(mxs, name, len, qualif, (deadline), &STAMP) #define s6dns_resolve_mx_r(mxs, name, len, qualif, dt, rci, dbh, deadline, stamp) s6dns_resolve_r(name, len, S6DNS_T_MX, &s6dns_message_parse_answer_mx, (mxs), qualif, dt, rci, dbh, deadline, stamp) #define s6dns_resolve_mx_r_g(mxs, name, len, qualif, dt, rci, dbh, deadline) s6dns_resolve_mx_r(mxs, name, len, qualif, dt, rci, dbh, (deadline), &STAMP) #define s6dns_resolve_ns(ds, name, len, qualif, deadline, stamp) s6dns_resolve_ns_r(ds, name, len, qualif, &s6dns_engine_here, &s6dns_rci_here, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_ns_g(ds, name, len, qualif, deadline) s6dns_resolve_ns(ds, name, len, qualif, (deadline), &STAMP) #define s6dns_resolve_ns_r(ds, name, len, qualif, dt, rci, dbh, deadline, stamp) s6dns_resolve_dpag_r(ds, name, len, S6DNS_T_NS, qualif, dt, rci, dbh, deadline, stamp) #define s6dns_resolve_ns_r_g(ds, name, len, qualif, dt, rci, dbh, deadline) s6dns_resolve_ns_r(ds, name, len, qualif, dt, rci, dbh, (deadline), &STAMP) #define s6dns_resolve_cname(ds, name, len, qualif, deadline, stamp) s6dns_resolve_cname_r(ds, name, len, qualif, &s6dns_engine_here, &s6dns_rci_here, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_cname_g(ds, name, len, qualif, deadline) s6dns_resolve_cname(ds, name, len, qualif, (deadline), &STAMP) #define s6dns_resolve_cname_r(ds, name, len, qualif, dt, rci, dbh, deadline, stamp) s6dns_resolve_dpag_r(ds, name, len, S6DNS_T_CNAME, qualif, dt, rci, dbh, deadline, stamp) #define s6dns_resolve_cname_r_g(ds, name, len, qualif, dt, rci, dbh, deadline) s6dns_resolve_cname_r(ds, name, len, qualif, dt, rci, dbh, (deadline), &STAMP) #define s6dns_resolve_hinfo(hinfos, name, len, qualif, deadline, stamp) s6dns_resolve_hinfo_r(hinfos, name, len, qualif, &s6dns_engine_here, &s6dns_rci_here, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_hinfo_g(hinfos, name, len, qualif, deadline) s6dns_resolve_hinfo(hinfos, name, len, qualif, (deadline), &STAMP) #define s6dns_resolve_hinfo_r(hinfos, name, len, qualif, dt, rci, dbh, deadline, stamp) s6dns_resolve_r(name, len, S6DNS_T_HINFO, &s6dns_message_parse_answer_hinfo, (hinfos), qualif, dt, rci, dbh, deadline, stamp) #define s6dns_resolve_hinfo_r_g(hinfos, name, len, qualif, dt, rci, dbh, deadline) s6dns_resolve_hinfo_r(hinfos, name, len, qualif, dt, rci, dbh, (deadline), &STAMP) #define s6dns_resolve_soa(soas, name, len, qualif, deadline, stamp) s6dns_resolve_soa_r(soas, name, len, qualif, &s6dns_engine_here, &s6dns_rci_here, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_soa_g(soas, name, len, qualif, deadline) s6dns_resolve_soa(soas, name, len, qualif, (deadline), &STAMP) #define s6dns_resolve_soa_r(soas, name, len, qualif, dt, rci, dbh, deadline, stamp) s6dns_resolve_r(name, len, S6DNS_T_SOA, &s6dns_message_parse_answer_soa, (soas), qualif, dt, rci, dbh, deadline, stamp) #define s6dns_resolve_soa_r_g(soas, name, len, qualif, dt, rci, dbh, deadline) s6dns_resolve_soa_r(soas, name, len, qualif, dt, rci, dbh, (deadline), &STAMP) #define s6dns_resolve_srv(srvs, name, len, qualif, deadline, stamp) s6dns_resolve_srv_r(srvs, name, len, qualif, &s6dns_engine_here, &s6dns_rci_here, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_srv_g(srvs, name, len, qualif, deadline) s6dns_resolve_srv(srvs, name, len, qualif, (deadline), &STAMP) #define s6dns_resolve_srv_r(srvs, name, len, qualif, dt, rci, dbh, deadline, stamp) s6dns_resolve_r(name, len, S6DNS_T_SRV, &s6dns_message_parse_answer_srv, (srvs), qualif, dt, rci, dbh, deadline, stamp) #define s6dns_resolve_srv_r_g(srvs, name, len, qualif, dt, rci, dbh, deadline) s6dns_resolve_srv_r(srvs, name, len, qualif, dt, rci, dbh, (deadline), &STAMP) #define s6dns_resolve_caa(caas, name, len, qualif, deadline, stamp) s6dns_resolve_caa_r(caas, name, len, qualif, &s6dns_engine_here, &s6dns_rci_here, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_caa_g(caas, name, len, qualif, deadline) s6dns_resolve_caa(caas, name, len, qualif, (deadline), &STAMP) #define s6dns_resolve_caa_r(caas, name, len, qualif, dt, rci, dbh, deadline, stamp) s6dns_resolve_r(name, len, S6DNS_T_CAA, &s6dns_message_parse_answer_caa, (caas), qualif, dt, rci, dbh, deadline, stamp) #define s6dns_resolve_caa_r_g(caas, name, len, qualif, dt, rci, dbh, deadline) s6dns_resolve_caa_r(caas, name, len, qualif, dt, rci, dbh, (deadline), &STAMP) /* Internals for the high-level functions. */ /* dpag: structure for generic domain lists + rtype */ /* mpag: encoding variable-length information into storage+offsets */ #define s6dns_resolve_dpag(ds, name, len, qtype, qualif, deadline, stamp) s6dns_resolve_dpag_r(ds, name, len, qtype, qualif, &s6dns_engine_here, &s6dns_rci_here, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_dpag_g(ds, name, len, qtype, qualif, deadline) s6dns_resolve_dpag(ds, name, len, qtype, qualif, (deadline), &STAMP) extern int s6dns_resolve_dpag_r (genalloc *, char const *, unsigned int, uint16_t, int, s6dns_engine_t *, s6dns_rci_t const *, s6dns_debughook_t const *, tain_t const *, tain_t *) ; #define s6dns_resolve_dpag_r_g(ds, name, len, qtype, qualif, dt, rci, dbh, deadline) s6dns_resolve_dpag_r(ds, name, len, qtype, qualif, dt, rci, dbh, (deadline), &STAMP) #define s6dns_resolve_mpag(sa, offsets, name, len, qtype, parsefunc, qualif, deadline, stamp) s6dns_resolve_mpag_r(sa, offsets, name, len, qtype, parsefunc, qualif, &s6dns_engine_here, &s6dns_rci_here, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolve_mpag_g(sa, offsets, name, len, qtype, parsefunc, qualif, deadline) s6dns_resolve_mpag(sa, offsets, name, len, qtype, parsefunc, qualif, (deadline), &STAMP) extern int s6dns_resolve_mpag_r (stralloc *, genalloc *, char const *, unsigned int, uint16_t, s6dns_message_rr_func_t_ref, int, s6dns_engine_t *, s6dns_rci_t const *, s6dns_debughook_t const *, tain_t const *, tain_t *) ; #define s6dns_resolve_mpag_r_g(sa, offsets, name, len, qtype, parsefunc, qualif, dt, rci, dbh, deadline) s6dns_resolve_mpag_r(sa, offsets, name, len, qtype, parsefunc, qualif, dt, rci, dbh, (deadline), &STAMP) /* Functions for n-domain parallel resolution. s6dns_resolven_loop() is the core primitive. s6dns_resolven_parse() is built upon it. This API is still very limited in what it can do; for full asynchronous resolution, use the skadns library. */ extern int s6dns_resolven_loop (s6dns_engine_t *, unsigned int, unsigned int, tain_t const *, tain_t *) ; #define s6dns_resolven_loop_g(list, n, zor, deadline) s6dns_resolven(list, n, zor, (deadline), &STAMP) typedef struct s6dns_resolve_s s6dns_resolve_t, *s6dns_resolve_t_ref ; struct s6dns_resolve_s { s6dns_domain_t q ; tain_t deadline ; s6dns_message_rr_func_t_ref parsefunc ; void *data ; uint32_t options ; int status ; uint16_t qtype ; } ; #define s6dns_resolven_parse(list, n, deadline, stamp) s6dns_resolven_parse_r(list, n, &s6dns_rci_here.servers, &s6dns_debughook_zero, deadline, stamp) #define s6dns_resolven_parse_g(list, n, deadline) s6dns_resolven_parse(list, n, (deadline), &STAMP) extern int s6dns_resolven_parse_r (s6dns_resolve_t *, unsigned int, s6dns_ip46list_t const *, s6dns_debughook_t const *, tain_t const *, tain_t *) ; #define s6dns_resolven_parse_r_g(list, n, servers, dbh, deadline) s6dns_resolven_parse_r(list, n, servers, dbh, (deadline), &STAMP) #endif s6-dns-2.3.1.1/src/include/s6-dns/skadns.h0000644000000000000000000000446613217222076014650 0ustar /* ISC license. */ #ifndef SKADNS_H #define SKADNS_H #include #include #include #include #include #include #include #include #define SKADNSD_PROG S6_DNS_BINPREFIX "skadnsd" #define SKADNS_BANNER1 "skadns v1.0 (b)\n" #define SKADNS_BANNER1_LEN (sizeof SKADNS_BANNER1 - 1) #define SKADNS_BANNER2 "skadns v1.0 (a)\n" #define SKADNS_BANNER2_LEN (sizeof SKADNS_BANNER2 - 1) #define SKADNS_MAXCONCURRENCY 1000 typedef struct skadnsanswer_s skadnsanswer_t, *skadnsanswer_t_ref ; struct skadnsanswer_s { int status ; char *data ; unsigned int len ; } ; #define SKADNSANSWER_ZERO { .status = EINVAL, .data = 0, .len = 0 } typedef struct skadns_s skadns_t, *skadns_t_ref ; struct skadns_s { textclient_t connection ; genalloc list ; /* array of uint16_t */ gensetdyn q ; /* set of skadnsanswer_t */ } ; #define SKADNS_ZERO { .connection = TEXTCLIENT_ZERO, .list = GENALLOC_ZERO, .q = GENSETDYN_INIT(skadnsanswer_t, 3, 3, 8) } extern skadns_t const skadns_zero ; /* Starting and ending a session */ extern int skadns_start (skadns_t *, char const *, tain_t const *, tain_t *) ; #define skadns_start_g(a, path, deadline) skadns_start(a, path, (deadline), &STAMP) extern int skadns_startf (skadns_t *, tain_t const *, tain_t *) ; #define skadns_startf_g(a, deadline) skadns_startf(a, (deadline), &STAMP) extern void skadns_end (skadns_t *) ; /* Synchronous functions */ extern int skadns_send (skadns_t *, uint16_t *, s6dns_domain_t const *, uint16_t, tain_t const *, tain_t const *, tain_t *) ; #define skadns_send_g(a, id, d, qtype, limit, deadline) skadns_send(a, id, d, qtype, limit, (deadline), &STAMP) extern int skadns_cancel (skadns_t *, uint16_t, tain_t const *, tain_t *) ; #define skadns_cancel_g(a, id, deadline) skadns_cancel(a, id, (deadline), &STAMP) /* Asynchronous functions */ #define skadns_fd(a) textclient_fd(&(a)->connection) extern int skadns_update (skadns_t *) ; #define skadns_list(a) genalloc_s(uint16_t const, &(a)->list) #define skadns_clearlist(a) ((a)->list.len = 0) extern int skadns_packetlen (skadns_t const *, uint16_t) ; extern char const *skadns_packet (skadns_t const *, uint16_t) ; extern int skadns_release (skadns_t *, uint16_t) ; #endif s6-dns-2.3.1.1/src/include/s6-dns/s6dns-debug.h0000644000000000000000000000104112441631704015470 0ustar /* ISC license. */ #ifndef S6DNS_DEBUG_H #define S6DNS_DEBUG_H #include extern s6dns_debughook_func_t s6dns_debug_dumpdt_post_recv ; extern s6dns_debughook_func_t s6dns_debug_dumpdt_pre_send ; extern s6dns_debughook_func_t s6dns_debug_dumpdt_post_send ; #define S6DNS_DEBUG_DUMPDT_INIT(gp) { &s6dns_debug_dumpdt_post_recv, &s6dns_debug_dumpdt_pre_send, &s6dns_debug_dumpdt_post_send, (gp) } extern s6dns_debughook_t const s6dns_debug_dumpdt_stdout ; extern s6dns_debughook_t const s6dns_debug_dumpdt_stderr ; #endif s6-dns-2.3.1.1/src/include/s6-dns/s6dns-rci.h0000644000000000000000000000142313035045201015152 0ustar /* ISC license. */ #ifndef S6DNS_RCI_H #define S6DNS_RCI_H #include #include #include #include /* rci: resolv.conf information */ typedef struct s6dns_rci_s s6dns_rci_t, *s6dns_rci_t_ref ; struct s6dns_rci_s { s6dns_ip46list_t servers ; stralloc rules ; unsigned int rulesnum ; } ; #define S6DNS_RCI_ZERO { .servers = S6DNS_IP46LIST_ZERO, .rules = STRALLOC_ZERO, .rulesnum = 0 } extern s6dns_rci_t const s6dns_rci_zero ; extern s6dns_rci_t s6dns_rci_here ; extern int s6dns_rci_init (s6dns_rci_t *, char const *) ; extern void s6dns_rci_free (s6dns_rci_t *) ; #define s6dns_qualify(list, d) s6dns_domain_qualify(list, (d), s6dns_rci_here.rules.s, s6dns_rci_here.rulesnum) #endif s6-dns-2.3.1.1/src/include/s6-dns/s6dns-domain.h0000644000000000000000000000267413061734325015670 0ustar /* ISC license. */ #ifndef S6DNS_DOMAIN_H #define S6DNS_DOMAIN_H #include #include typedef struct s6dns_domain_s s6dns_domain_t, *s6dns_domain_t_ref ; struct s6dns_domain_s { unsigned char len ; char s[255] ; } ; /* Conversions from/to user strings */ extern int s6dns_domain_fromstring (s6dns_domain_t *, char const *, size_t) ; extern unsigned int s6dns_domain_tostring (char *, size_t, s6dns_domain_t const *) ; /* Qualification */ extern int s6dns_domain_noqualify (s6dns_domain_t *) ; extern unsigned int s6dns_domain_qualify (s6dns_domain_t *, s6dns_domain_t const *, char const *, unsigned int) ; /* Internal coding/encoding to/from protocol form */ extern int s6dns_domain_encode (s6dns_domain_t *) ; extern unsigned int s6dns_domain_encodelist (s6dns_domain_t *, unsigned int) ; extern int s6dns_domain_decode (s6dns_domain_t *) ; /* Useful shortcuts */ extern int s6dns_domain_fromstring_noqualify_encode (s6dns_domain_t *, char const *, size_t) ; extern unsigned int s6dns_domain_fromstring_qualify_encode (s6dns_domain_t *, char const *, size_t, char const *, unsigned int) ; /* Helpers for PTR */ extern void s6dns_domain_arpafromip4 (s6dns_domain_t *, char const *) ; extern void s6dns_domain_arpafromip6 (s6dns_domain_t *, char const *, unsigned int) ; #define s6dns_domain_arpafromip46(d, i) (ip46_is6(i) ? s6dns_domain_arpafromip6(d, (i)->ip, 128) : s6dns_domain_arpafromip4(d, (i)->ip)) #endif s6-dns-2.3.1.1/src/include/s6-dns/s6dns-message.h0000644000000000000000000001336113263517411016037 0ustar /* ISC license. */ #ifndef S6DNS_MESSAGE_H #define S6DNS_MESSAGE_H #include #include #include #include /* Header */ typedef struct s6dns_message_counts_s s6dns_message_counts_t, *s6dns_message_counts_t_ref ; struct s6dns_message_counts_s { uint16_t qd ; uint16_t an ; uint16_t ns ; uint16_t nr ; } ; #define S6DNS_MESSAGE_COUNTS_ZERO { .qd = 0, .an = 0, .ns = 0, .nr = 0 } extern s6dns_message_counts_t const s6dns_message_counts_zero ; extern void s6dns_message_counts_pack (char *, s6dns_message_counts_t const *) ; extern void s6dns_message_counts_unpack (char const *, s6dns_message_counts_t *) ; extern unsigned int s6dns_message_counts_next (s6dns_message_counts_t *) ; typedef struct s6dns_message_header_s s6dns_message_header_t, *s6dns_message_header_t_ref ; struct s6dns_message_header_s { uint16_t id ; unsigned int qr : 1 ; unsigned int opcode : 4 ; unsigned int aa : 1 ; unsigned int tc : 1 ; unsigned int rd : 1 ; unsigned int ra : 1 ; unsigned int z : 3 ; unsigned int rcode : 4 ; s6dns_message_counts_t counts ; } ; #define S6DNS_MESSAGE_HEADER_ZERO { \ .id = 0, \ .qr = 0, \ .opcode = 0, \ .aa = 0, \ .tc = 0, \ .rd = 0, \ .ra = 0, \ .z = 0, \ .rcode = 0, \ .counts = S6DNS_MESSAGE_COUNTS_ZERO \ } extern s6dns_message_header_t const s6dns_message_header_zero ; extern void s6dns_message_header_pack (char *, s6dns_message_header_t const *) ; extern void s6dns_message_header_unpack (char const *, s6dns_message_header_t *) ; /* Specific RR helpers */ extern int s6dns_message_get_string (s6dns_domain_t *, char const *, unsigned int, unsigned int *) ; extern int s6dns_message_get_strings (char *, unsigned int, char const *, unsigned int, unsigned int *) ; extern int s6dns_message_get_domain (s6dns_domain_t *, char const *, unsigned int, unsigned int *) ; typedef struct s6dns_message_rr_hinfo_s s6dns_message_rr_hinfo_t, *s6dns_message_rr_hinfo_t_ref ; struct s6dns_message_rr_hinfo_s { s6dns_domain_t cpu ; s6dns_domain_t os ; } ; extern int s6dns_message_get_hinfo (s6dns_message_rr_hinfo_t *, char const *, unsigned int, unsigned int *) ; typedef struct s6dns_message_rr_mx_s s6dns_message_rr_mx_t, *s6dns_message_rr_mx_t_ref ; struct s6dns_message_rr_mx_s { uint16_t preference ; s6dns_domain_t exchange ; } ; extern int s6dns_message_get_mx (s6dns_message_rr_mx_t *, char const *, unsigned int, unsigned int *) ; typedef struct s6dns_message_rr_soa_s s6dns_message_rr_soa_t, *s6dns_message_rr_soa_t_ref ; struct s6dns_message_rr_soa_s { s6dns_domain_t mname ; s6dns_domain_t rname ; uint32_t serial ; uint32_t refresh ; uint32_t retry ; uint32_t expire ; uint32_t minimum ; } ; extern int s6dns_message_get_soa (s6dns_message_rr_soa_t *, char const *, unsigned int, unsigned int *) ; typedef struct s6dns_message_rr_srv_s s6dns_message_rr_srv_t, *s6dns_message_rr_srv_t_ref ; struct s6dns_message_rr_srv_s { uint16_t priority ; uint16_t weight ; uint16_t port ; s6dns_domain_t target ; } ; extern int s6dns_message_get_srv (s6dns_message_rr_srv_t *, char const *, unsigned int, unsigned int *) ; typedef struct s6dns_message_rr_caa_s s6dns_message_rr_caa_t, *s6dns_message_rr_caa_t_ref ; struct s6dns_message_rr_caa_s { uint8_t flags ; char tag[256] ; char value[256] ; } ; extern int s6dns_message_get_caa (s6dns_message_rr_caa_t *, char const *, unsigned int, unsigned int *, uint16_t) ; /* The callback function type: how to parse RRs */ typedef struct s6dns_message_rr_s s6dns_message_rr_t, *s6dns_message_rr_t_ref ; struct s6dns_message_rr_s { s6dns_domain_t name ; uint16_t rtype ; uint16_t rclass ; uint32_t ttl ; uint16_t rdlength ; } ; typedef int s6dns_message_rr_func_t (s6dns_message_rr_t const *, char const *, unsigned int, unsigned int, unsigned int, void *) ; typedef s6dns_message_rr_func_t *s6dns_message_rr_func_t_ref ; /* mpag: structure to encode several variable-length results */ typedef struct s6dns_mpag_s s6dns_mpag_t, *s6dns_mpag_t_ref ; struct s6dns_mpag_s { stralloc sa ; genalloc offsets ; /* array of size_t */ uint16_t rtype ; } ; #define S6DNS_MPAG_ZERO { .sa = STRALLOC_ZERO, .offsets = GENALLOC_ZERO, .rtype = 0 } /* dpag: structure for domain lists */ typedef struct s6dns_dpag_s s6dns_dpag_t, *s6dns_dpag_t_ref ; struct s6dns_dpag_s { genalloc ds ; /* array of s6dns_domain_t */ uint16_t rtype ; } ; #define S6DNS_DPAG_ZERO { .ds = GENALLOC_ZERO, .rtype = 0 } extern s6dns_message_rr_func_t s6dns_message_parse_answer_strings ; extern s6dns_message_rr_func_t s6dns_message_parse_answer_domain ; extern s6dns_message_rr_func_t s6dns_message_parse_answer_a ; extern s6dns_message_rr_func_t s6dns_message_parse_answer_aaaa ; extern s6dns_message_rr_func_t s6dns_message_parse_answer_mx ; extern s6dns_message_rr_func_t s6dns_message_parse_answer_hinfo ; extern s6dns_message_rr_func_t s6dns_message_parse_answer_soa ; extern s6dns_message_rr_func_t s6dns_message_parse_answer_srv ; extern s6dns_message_rr_func_t s6dns_message_parse_answer_caa ; /* The actual parsing function */ extern int s6dns_message_parse (s6dns_message_header_t_ref, char const *, unsigned int, s6dns_message_rr_func_t_ref, void *) ; /* Internals of this function, for lower level access */ extern int s6dns_message_parse_init (s6dns_message_header_t *, s6dns_message_counts_t_ref, char const *, unsigned int, unsigned int *) ; extern unsigned int s6dns_message_parse_skipqd (s6dns_message_counts_t *, char const *, unsigned int, unsigned int *) ; extern int s6dns_message_parse_getrr (s6dns_message_rr_t_ref, char const *, unsigned int, unsigned int *) ; extern unsigned int s6dns_message_parse_next (s6dns_message_counts_t *, s6dns_message_rr_t const *, char const *, unsigned int, unsigned int *) ; #endif s6-dns-2.3.1.1/src/include/s6-dns/s6dns-ip46.h0000644000000000000000000000137612441632746015206 0ustar /* ISC license. */ #ifndef S6DNS_IP46_H #define S6DNS_IP46_H #include #include #include typedef struct s6dns_ip46list_s s6dns_ip46list_t, *s6dns_ip46list_t_ref ; struct s6dns_ip46list_s { char ip[S6DNS_MAX_SERVERS * SKALIBS_IP_SIZE] ; #ifdef SKALIBS_IPV6_ENABLED unsigned char is6[bitarray_div8(S6DNS_MAX_SERVERS)] ; #endif } ; #define s6dns_ip46list_ip(list, i) ((list)->ip + SKALIBS_IP_SIZE * (i)) #ifdef SKALIBS_IPV6_ENABLED # define S6DNS_IP46LIST_ZERO { .ip = S6DNS_LOCALHOST_IP, .is6 = "\0" } # define s6dns_ip46list_is6(list, i) bitarray_peek((list)->is6, i) #else # define S6DNS_IP46LIST_ZERO { .ip = S6DNS_LOCALHOST_IP } # define s6dns_ip46list_is6(list, i) 0 #endif #endif s6-dns-2.3.1.1/src/include/s6-dns/s6dns-constants.h0000644000000000000000000000221313263505613016422 0ustar /* ISC license. */ #ifndef S6DNS_CONSTANTS_H #define S6DNS_CONSTANTS_H #include #define S6DNS_MAX_SERVERS 16U #define S6DNS_C_IN 0x0001U #define S6DNS_C_ANY 0x00ffU #define S6DNS_T_A 1U #define S6DNS_T_NS 2U #define S6DNS_T_CNAME 5U #define S6DNS_T_SOA 6U #define S6DNS_T_PTR 12U #define S6DNS_T_HINFO 13U #define S6DNS_T_MX 15U #define S6DNS_T_TXT 16U #define S6DNS_T_RP 17U #define S6DNS_T_SIG 24U #define S6DNS_T_KEY 25U #define S6DNS_T_AAAA 28U #define S6DNS_T_SRV 33U #define S6DNS_T_AXFR 252U #define S6DNS_T_ANY 255U #define S6DNS_T_CAA 257U #define S6DNS_O_RECURSIVE 0x0001U #define S6DNS_O_STRICT 0x0002U #define S6DNS_W_AND 0 #define S6DNS_W_OR 1 #define S6DNS_W_BEST 2 typedef struct s6dns_constants_error_message_s s6dns_constants_error_message_t, *s6dns_constants_error_message_t_ref ; struct s6dns_constants_error_message_s { int num ; char const *string ; } ; extern s6dns_constants_error_message_t const *const s6dns_constants_error ; extern char const *s6dns_constants_error_str (int) ; #ifdef SKALIBS_IPV6_ENABLED # define S6DNS_LOCALHOST_IP IP6_LOCAL #else # define S6DNS_LOCALHOST_IP "\177\0\0\1" #endif #endif s6-dns-2.3.1.1/src/include/s6-dns/s6dns-engine.h0000644000000000000000000000673213156041170015657 0ustar /* ISC license. */ #ifndef S6DNS_ENGINE_H #define S6DNS_ENGINE_H #include #include #include #include #include #include /* The dt structure: all the DNS q/r state information, transport-agnostic */ typedef struct s6dns_engine_s s6dns_engine_t, *s6dns_engine_t_ref ; /* Debug function hooks */ typedef int s6dns_debughook_func_t (s6dns_engine_t const *, void *) ; typedef s6dns_debughook_func_t *s6dns_debughook_func_t_ref ; typedef struct s6dns_debughook_s s6dns_debughook_t, *s6dns_debughook_t_ref ; struct s6dns_debughook_s { s6dns_debughook_func_t_ref post_recv ; s6dns_debughook_func_t_ref pre_send ; s6dns_debughook_func_t_ref post_send ; void *external ; } ; #define S6DNS_DEBUGHOOK_ZERO { .post_recv = 0, .pre_send = 0, .post_send = 0, .external = 0 } extern s6dns_debughook_t const s6dns_debughook_zero ; /* s6dns-engine: the asynchronous DNS resolution primitives. */ struct s6dns_engine_s { stralloc sa ; /* 2 bytes (qlen) + qlen bytes (query) + answers */ tain_t deadline ; tain_t localdeadline ; unsigned int querylen ; int fd ; uint32_t protostate ; s6dns_ip46list_t servers ; s6dns_debughook_t const *debughook ; unsigned int curserver ; int status ; unsigned int flagstrict : 1 ; unsigned int flagtcp : 1 ; unsigned int flagconnecting : 1 ; unsigned int flagreading : 1 ; unsigned int flagwriting : 1 ; } ; #define S6DNS_ENGINE_ZERO \ { \ .sa = STRALLOC_ZERO, \ .deadline = TAIN_ZERO, \ .localdeadline = TAIN_ZERO, \ .querylen = 0, \ .fd = -1, \ .protostate = 0, \ .servers = S6DNS_IP46LIST_ZERO, \ .debughook = 0, \ .curserver = 0, \ .status = ECONNABORTED, \ .flagstrict = 0, \ .flagtcp = 0, \ .flagconnecting = 0, \ .flagreading = 0, \ .flagwriting = 0 \ } extern s6dns_engine_t const s6dns_engine_zero ; extern s6dns_engine_t s6dns_engine_here ; extern void s6dns_engine_recycle (s6dns_engine_t *) ; extern void s6dns_engine_free (s6dns_engine_t *) ; extern void s6dns_engine_freen (s6dns_engine_t *, unsigned int) ; #define s6dns_engine_init(dt, servers, options, q, qlen, qtype, deadline, stamp) s6dns_engine_init_r(dt, servers, options, q, qlen, qtype, &s6dns_debughook_zero, deadline, stamp) #define s6dns_engine_init_g(dt, servers, options, q, qlen, qtype, deadline) s6dns_engine_init(dt, servers, options, q, qlen, qtype, (deadline), &STAMP) extern int s6dns_engine_init_r (s6dns_engine_t *, s6dns_ip46list_t const *, uint32_t, char const *, unsigned int, uint16_t, s6dns_debughook_t const *, tain_t const *, tain_t const *) ; #define s6dns_engine_init_r_g(dt, servers, options, q, qlen, qtype, dbh, deadline) s6dns_engine_init_r(dt, servers, options, q, qlen, qtype, dbh, (deadline), &STAMP) /* Call before iopause() */ extern void s6dns_engine_nextdeadline (s6dns_engine_t const *, tain_t *) ; #define s6dns_engine_isreadable(dt) ((dt)->flagreading) #define s6dns_engine_iswritable(dt) ((dt)->flagwriting) /* Call after iopause(): _timeout if iopause returns 0, _event otherwise */ extern int s6dns_engine_timeout (s6dns_engine_t *, tain_t const *) ; #define s6dns_engine_timeout_g(dt) s6dns_engine_timeout((dt), &STAMP) extern int s6dns_engine_event (s6dns_engine_t *, tain_t const *) ; #define s6dns_engine_event_g(dt) s6dns_engine_event((dt), &STAMP) #define s6dns_engine_packet(dt) ((dt)->sa.s + (dt)->querylen) #define s6dns_engine_packetlen(dt) ((unsigned int)((dt)->sa.len - (dt)->querylen)) #endif s6-dns-2.3.1.1/package/0002755000000000000000000000000013061734325011255 5ustar s6-dns-2.3.1.1/package/deps.mak0000644000000000000000000010604213553364325012710 0ustar # # This file has been generated by tools/gen-deps.sh # src/include/s6-dns/s6dns-analyze.h: src/include/s6-dns/s6dns-message.h src/include/s6-dns/s6dns-debug.h: src/include/s6-dns/s6dns-engine.h src/include/s6-dns/s6dns-engine.h: src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-ip46.h src/include/s6-dns/s6dns-fmt.h: src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-message.h src/include/s6-dns/s6dns-ip46.h: src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-message.h: src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-rci.h: src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-ip46.h src/include/s6-dns/s6dns-resolve.h: src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-engine.h src/include/s6-dns/s6dns-ip46.h src/include/s6-dns/s6dns-message.h src/include/s6-dns/s6dns-rci.h src/include/s6-dns/s6dns.h: src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-engine.h src/include/s6-dns/s6dns-fmt.h src/include/s6-dns/s6dns-ip46.h src/include/s6-dns/s6dns-message.h src/include/s6-dns/s6dns-rci.h src/include/s6-dns/s6dns-resolve.h src/include/s6-dns/skadns.h: src/include/s6-dns/config.h src/include/s6-dns/s6dns-domain.h src/clients/s6dns-generic-filter.h: src/include/s6-dns/s6dns-domain.h src/clients/s6-dnsip4-filter.o src/clients/s6-dnsip4-filter.lo: src/clients/s6-dnsip4-filter.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-message.h src/clients/s6dns-generic-filter.h src/clients/s6-dnsip4.o src/clients/s6-dnsip4.lo: src/clients/s6-dnsip4.c src/include/s6-dns/s6dns.h src/clients/s6-dnsip6-filter.o src/clients/s6-dnsip6-filter.lo: src/clients/s6-dnsip6-filter.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-message.h src/clients/s6dns-generic-filter.h src/clients/s6-dnsip6.o src/clients/s6-dnsip6.lo: src/clients/s6-dnsip6.c src/include/s6-dns/s6dns.h src/clients/s6-dnsmx.o src/clients/s6-dnsmx.lo: src/clients/s6-dnsmx.c src/include/s6-dns/s6dns.h src/clients/s6-dnsname-filter.o src/clients/s6-dnsname-filter.lo: src/clients/s6-dnsname-filter.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-message.h src/clients/s6dns-generic-filter.h src/clients/s6-dnsname.o src/clients/s6-dnsname.lo: src/clients/s6-dnsname.c src/include/s6-dns/s6dns.h src/clients/s6-dnsns.o src/clients/s6-dnsns.lo: src/clients/s6-dnsns.c src/include/s6-dns/s6dns.h src/clients/s6-dnsq.o src/clients/s6-dnsq.lo: src/clients/s6-dnsq.c src/include/s6-dns/s6dns-analyze.h src/include/s6-dns/s6dns-debug.h src/include/s6-dns/s6dns.h src/clients/s6-dnsqr.o src/clients/s6-dnsqr.lo: src/clients/s6-dnsqr.c src/include/s6-dns/s6dns-analyze.h src/include/s6-dns/s6dns-debug.h src/include/s6-dns/s6dns.h src/clients/s6-dnsqualify.o src/clients/s6-dnsqualify.lo: src/clients/s6-dnsqualify.c src/include/s6-dns/s6dns.h src/clients/s6-dnssoa.o src/clients/s6-dnssoa.lo: src/clients/s6-dnssoa.c src/include/s6-dns/s6dns.h src/clients/s6-dnssrv.o src/clients/s6-dnssrv.lo: src/clients/s6-dnssrv.c src/include/s6-dns/s6dns.h src/clients/s6-dnstxt.o src/clients/s6-dnstxt.lo: src/clients/s6-dnstxt.c src/include/s6-dns/s6dns.h src/clients/s6-randomip.o src/clients/s6-randomip.lo: src/clients/s6-randomip.c src/clients/s6dns_generic_filter_main.o src/clients/s6dns_generic_filter_main.lo: src/clients/s6dns_generic_filter_main.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-domain.h src/include/s6-dns/skadns.h src/clients/s6dns-generic-filter.h src/clients/s6dns_namescanner.o src/clients/s6dns_namescanner.lo: src/clients/s6dns_namescanner.c src/include/s6-dns/s6dns-domain.h src/clients/s6dns-generic-filter.h src/libs6dns/s6dns_analyze_packet.o src/libs6dns/s6dns_analyze_packet.lo: src/libs6dns/s6dns_analyze_packet.c src/include/s6-dns/s6dns-analyze.h src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_analyze_qtype_parse.o src/libs6dns/s6dns_analyze_qtype_parse.lo: src/libs6dns/s6dns_analyze_qtype_parse.c src/include/s6-dns/s6dns-analyze.h src/include/s6-dns/s6dns-constants.h src/libs6dns/s6dns_analyze_record.o src/libs6dns/s6dns_analyze_record.lo: src/libs6dns/s6dns_analyze_record.c src/include/s6-dns/s6dns-analyze.h src/include/s6-dns/s6dns-domain.h src/libs6dns/s6dns_analyze_record_a.o src/libs6dns/s6dns_analyze_record_a.lo: src/libs6dns/s6dns_analyze_record_a.c src/include/s6-dns/s6dns-analyze.h src/libs6dns/s6dns_analyze_record_aaaa.o src/libs6dns/s6dns_analyze_record_aaaa.lo: src/libs6dns/s6dns_analyze_record_aaaa.c src/include/s6-dns/s6dns-analyze.h src/libs6dns/s6dns_analyze_record_caa.o src/libs6dns/s6dns_analyze_record_caa.lo: src/libs6dns/s6dns_analyze_record_caa.c src/include/s6-dns/s6dns-analyze.h src/include/s6-dns/s6dns-fmt.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_analyze_record_domain.o src/libs6dns/s6dns_analyze_record_domain.lo: src/libs6dns/s6dns_analyze_record_domain.c src/include/s6-dns/s6dns-analyze.h src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-fmt.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_analyze_record_hinfo.o src/libs6dns/s6dns_analyze_record_hinfo.lo: src/libs6dns/s6dns_analyze_record_hinfo.c src/include/s6-dns/s6dns-analyze.h src/include/s6-dns/s6dns-fmt.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_analyze_record_mx.o src/libs6dns/s6dns_analyze_record_mx.lo: src/libs6dns/s6dns_analyze_record_mx.c src/include/s6-dns/s6dns-analyze.h src/include/s6-dns/s6dns-fmt.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_analyze_record_soa.o src/libs6dns/s6dns_analyze_record_soa.lo: src/libs6dns/s6dns_analyze_record_soa.c src/include/s6-dns/s6dns-analyze.h src/include/s6-dns/s6dns-fmt.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_analyze_record_srv.o src/libs6dns/s6dns_analyze_record_srv.lo: src/libs6dns/s6dns_analyze_record_srv.c src/include/s6-dns/s6dns-analyze.h src/include/s6-dns/s6dns-fmt.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_analyze_record_strings.o src/libs6dns/s6dns_analyze_record_strings.lo: src/libs6dns/s6dns_analyze_record_strings.c src/include/s6-dns/s6dns-analyze.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_analyze_record_unknown.o src/libs6dns/s6dns_analyze_record_unknown.lo: src/libs6dns/s6dns_analyze_record_unknown.c src/include/s6-dns/s6dns-analyze.h src/libs6dns/s6dns_analyze_rtypetable.o src/libs6dns/s6dns_analyze_rtypetable.lo: src/libs6dns/s6dns_analyze_rtypetable.c src/include/s6-dns/s6dns-analyze.h src/libs6dns/s6dns_constants_error.o src/libs6dns/s6dns_constants_error.lo: src/libs6dns/s6dns_constants_error.c src/include/s6-dns/s6dns-constants.h src/libs6dns/s6dns_constants_error_str.o src/libs6dns/s6dns_constants_error_str.lo: src/libs6dns/s6dns_constants_error_str.c src/include/s6-dns/s6dns-constants.h src/libs6dns/s6dns_debug_dumpdt_post_recv.o src/libs6dns/s6dns_debug_dumpdt_post_recv.lo: src/libs6dns/s6dns_debug_dumpdt_post_recv.c src/include/s6-dns/s6dns-debug.h src/libs6dns/s6dns_debug_dumpdt_post_send.o src/libs6dns/s6dns_debug_dumpdt_post_send.lo: src/libs6dns/s6dns_debug_dumpdt_post_send.c src/include/s6-dns/s6dns-debug.h src/libs6dns/s6dns_debug_dumpdt_pre_send.o src/libs6dns/s6dns_debug_dumpdt_pre_send.lo: src/libs6dns/s6dns_debug_dumpdt_pre_send.c src/include/s6-dns/s6dns-analyze.h src/include/s6-dns/s6dns-debug.h src/include/s6-dns/s6dns-ip46.h src/libs6dns/s6dns_debug_dumpdt_stderr.o src/libs6dns/s6dns_debug_dumpdt_stderr.lo: src/libs6dns/s6dns_debug_dumpdt_stderr.c src/include/s6-dns/s6dns-debug.h src/libs6dns/s6dns_debug_dumpdt_stdout.o src/libs6dns/s6dns_debug_dumpdt_stdout.lo: src/libs6dns/s6dns_debug_dumpdt_stdout.c src/include/s6-dns/s6dns-debug.h src/libs6dns/s6dns_debughook_zero.o src/libs6dns/s6dns_debughook_zero.lo: src/libs6dns/s6dns_debughook_zero.c src/include/s6-dns/s6dns-engine.h src/libs6dns/s6dns_domain_arpafromip4.o src/libs6dns/s6dns_domain_arpafromip4.lo: src/libs6dns/s6dns_domain_arpafromip4.c src/include/s6-dns/s6dns-domain.h src/libs6dns/s6dns_domain_arpafromip6.o src/libs6dns/s6dns_domain_arpafromip6.lo: src/libs6dns/s6dns_domain_arpafromip6.c src/include/s6-dns/s6dns-domain.h src/libs6dns/s6dns_domain_decode.o src/libs6dns/s6dns_domain_decode.lo: src/libs6dns/s6dns_domain_decode.c src/include/s6-dns/s6dns-domain.h src/libs6dns/s6dns_domain_encode.o src/libs6dns/s6dns_domain_encode.lo: src/libs6dns/s6dns_domain_encode.c src/include/s6-dns/s6dns-domain.h src/libs6dns/s6dns_domain_encodelist.o src/libs6dns/s6dns_domain_encodelist.lo: src/libs6dns/s6dns_domain_encodelist.c src/include/s6-dns/s6dns-domain.h src/libs6dns/s6dns_domain_fromstring.o src/libs6dns/s6dns_domain_fromstring.lo: src/libs6dns/s6dns_domain_fromstring.c src/include/s6-dns/s6dns-domain.h src/libs6dns/s6dns_domain_fromstring_noqualify_encode.o src/libs6dns/s6dns_domain_fromstring_noqualify_encode.lo: src/libs6dns/s6dns_domain_fromstring_noqualify_encode.c src/include/s6-dns/s6dns-domain.h src/libs6dns/s6dns_domain_fromstring_qualify_encode.o src/libs6dns/s6dns_domain_fromstring_qualify_encode.lo: src/libs6dns/s6dns_domain_fromstring_qualify_encode.c src/include/s6-dns/s6dns-domain.h src/libs6dns/s6dns_domain_noqualify.o src/libs6dns/s6dns_domain_noqualify.lo: src/libs6dns/s6dns_domain_noqualify.c src/include/s6-dns/s6dns-domain.h src/libs6dns/s6dns_domain_qualify.o src/libs6dns/s6dns_domain_qualify.lo: src/libs6dns/s6dns_domain_qualify.c src/include/s6-dns/s6dns-domain.h src/libs6dns/s6dns_domain_tostring.o src/libs6dns/s6dns_domain_tostring.lo: src/libs6dns/s6dns_domain_tostring.c src/include/s6-dns/s6dns-domain.h src/libs6dns/s6dns_engine.o src/libs6dns/s6dns_engine.lo: src/libs6dns/s6dns_engine.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-engine.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns-message-internal.h src/libs6dns/s6dns_engine_free.o src/libs6dns/s6dns_engine_free.lo: src/libs6dns/s6dns_engine_free.c src/include/s6-dns/s6dns-engine.h src/libs6dns/s6dns_engine_freen.o src/libs6dns/s6dns_engine_freen.lo: src/libs6dns/s6dns_engine_freen.c src/include/s6-dns/s6dns-engine.h src/libs6dns/s6dns_engine_here.o src/libs6dns/s6dns_engine_here.lo: src/libs6dns/s6dns_engine_here.c src/include/s6-dns/s6dns-engine.h src/libs6dns/s6dns_engine_nextdeadline.o src/libs6dns/s6dns_engine_nextdeadline.lo: src/libs6dns/s6dns_engine_nextdeadline.c src/include/s6-dns/s6dns-engine.h src/libs6dns/s6dns_engine_zero.o src/libs6dns/s6dns_engine_zero.lo: src/libs6dns/s6dns_engine_zero.c src/include/s6-dns/s6dns-engine.h src/libs6dns/s6dns_finish.o src/libs6dns/s6dns_finish.lo: src/libs6dns/s6dns_finish.c src/include/s6-dns/s6dns-engine.h src/include/s6-dns/s6dns-rci.h src/include/s6-dns/s6dns.h src/libs6dns/s6dns_fmt_caa.o src/libs6dns/s6dns_fmt_caa.lo: src/libs6dns/s6dns_fmt_caa.c src/include/s6-dns/s6dns-fmt.h src/libs6dns/s6dns_fmt_domainlist.o src/libs6dns/s6dns_fmt_domainlist.lo: src/libs6dns/s6dns_fmt_domainlist.c src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-fmt.h src/libs6dns/s6dns_fmt_hinfo.o src/libs6dns/s6dns_fmt_hinfo.lo: src/libs6dns/s6dns_fmt_hinfo.c src/include/s6-dns/s6dns-fmt.h src/libs6dns/s6dns_fmt_mx.o src/libs6dns/s6dns_fmt_mx.lo: src/libs6dns/s6dns_fmt_mx.c src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-fmt.h src/libs6dns/s6dns_fmt_soa.o src/libs6dns/s6dns_fmt_soa.lo: src/libs6dns/s6dns_fmt_soa.c src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-fmt.h src/libs6dns/s6dns_fmt_srv.o src/libs6dns/s6dns_fmt_srv.lo: src/libs6dns/s6dns_fmt_srv.c src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-fmt.h src/libs6dns/s6dns_init.o src/libs6dns/s6dns_init.lo: src/libs6dns/s6dns_init.c src/include/s6-dns/s6dns-rci.h src/include/s6-dns/s6dns.h src/libs6dns/s6dns_message_counts_next.o src/libs6dns/s6dns_message_counts_next.lo: src/libs6dns/s6dns_message_counts_next.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_counts_pack.o src/libs6dns/s6dns_message_counts_pack.lo: src/libs6dns/s6dns_message_counts_pack.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_counts_unpack.o src/libs6dns/s6dns_message_counts_unpack.lo: src/libs6dns/s6dns_message_counts_unpack.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_counts_zero.o src/libs6dns/s6dns_message_counts_zero.lo: src/libs6dns/s6dns_message_counts_zero.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_get_caa.o src/libs6dns/s6dns_message_get_caa.lo: src/libs6dns/s6dns_message_get_caa.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_get_domain.o src/libs6dns/s6dns_message_get_domain.lo: src/libs6dns/s6dns_message_get_domain.c src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns-message-internal.h src/libs6dns/s6dns_message_get_domain_internal.o src/libs6dns/s6dns_message_get_domain_internal.lo: src/libs6dns/s6dns_message_get_domain_internal.c src/libs6dns/s6dns-message-internal.h src/libs6dns/s6dns_message_get_hinfo.o src/libs6dns/s6dns_message_get_hinfo.lo: src/libs6dns/s6dns_message_get_hinfo.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_get_mx.o src/libs6dns/s6dns_message_get_mx.lo: src/libs6dns/s6dns_message_get_mx.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_get_soa.o src/libs6dns/s6dns_message_get_soa.lo: src/libs6dns/s6dns_message_get_soa.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_get_srv.o src/libs6dns/s6dns_message_get_srv.lo: src/libs6dns/s6dns_message_get_srv.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_get_string.o src/libs6dns/s6dns_message_get_string.lo: src/libs6dns/s6dns_message_get_string.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns-message-internal.h src/libs6dns/s6dns_message_get_string_internal.o src/libs6dns/s6dns_message_get_string_internal.lo: src/libs6dns/s6dns_message_get_string_internal.c src/libs6dns/s6dns-message-internal.h src/libs6dns/s6dns_message_get_strings.o src/libs6dns/s6dns_message_get_strings.lo: src/libs6dns/s6dns_message_get_strings.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns-message-internal.h src/libs6dns/s6dns_message_header_pack.o src/libs6dns/s6dns_message_header_pack.lo: src/libs6dns/s6dns_message_header_pack.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_header_unpack.o src/libs6dns/s6dns_message_header_unpack.lo: src/libs6dns/s6dns_message_header_unpack.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_header_zero.o src/libs6dns/s6dns_message_header_zero.lo: src/libs6dns/s6dns_message_header_zero.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_parse.o src/libs6dns/s6dns_message_parse.lo: src/libs6dns/s6dns_message_parse.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_parse_answer_a.o src/libs6dns/s6dns_message_parse_answer_a.lo: src/libs6dns/s6dns_message_parse_answer_a.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_parse_answer_aaaa.o src/libs6dns/s6dns_message_parse_answer_aaaa.lo: src/libs6dns/s6dns_message_parse_answer_aaaa.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_parse_answer_caa.o src/libs6dns/s6dns_message_parse_answer_caa.lo: src/libs6dns/s6dns_message_parse_answer_caa.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_parse_answer_domain.o src/libs6dns/s6dns_message_parse_answer_domain.lo: src/libs6dns/s6dns_message_parse_answer_domain.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_parse_answer_hinfo.o src/libs6dns/s6dns_message_parse_answer_hinfo.lo: src/libs6dns/s6dns_message_parse_answer_hinfo.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_parse_answer_mx.o src/libs6dns/s6dns_message_parse_answer_mx.lo: src/libs6dns/s6dns_message_parse_answer_mx.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_parse_answer_soa.o src/libs6dns/s6dns_message_parse_answer_soa.lo: src/libs6dns/s6dns_message_parse_answer_soa.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_parse_answer_srv.o src/libs6dns/s6dns_message_parse_answer_srv.lo: src/libs6dns/s6dns_message_parse_answer_srv.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_parse_answer_strings.o src/libs6dns/s6dns_message_parse_answer_strings.lo: src/libs6dns/s6dns_message_parse_answer_strings.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_parse_getrr.o src/libs6dns/s6dns_message_parse_getrr.lo: src/libs6dns/s6dns_message_parse_getrr.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_parse_init.o src/libs6dns/s6dns_message_parse_init.lo: src/libs6dns/s6dns_message_parse_init.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_parse_next.o src/libs6dns/s6dns_message_parse_next.lo: src/libs6dns/s6dns_message_parse_next.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns_message_parse_skipqd.o src/libs6dns/s6dns_message_parse_skipqd.lo: src/libs6dns/s6dns_message_parse_skipqd.c src/include/s6-dns/s6dns-message.h src/libs6dns/s6dns-message-internal.h src/libs6dns/s6dns_rci_free.o src/libs6dns/s6dns_rci_free.lo: src/libs6dns/s6dns_rci_free.c src/include/s6-dns/s6dns-rci.h src/libs6dns/s6dns_rci_here.o src/libs6dns/s6dns_rci_here.lo: src/libs6dns/s6dns_rci_here.c src/include/s6-dns/s6dns-rci.h src/libs6dns/s6dns_rci_init.o src/libs6dns/s6dns_rci_init.lo: src/libs6dns/s6dns_rci_init.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-rci.h src/libs6dns/s6dns_rci_zero.o src/libs6dns/s6dns_rci_zero.lo: src/libs6dns/s6dns_rci_zero.c src/include/s6-dns/s6dns-rci.h src/libs6dns/s6dns_resolve_core.o src/libs6dns/s6dns_resolve_core.lo: src/libs6dns/s6dns_resolve_core.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-engine.h src/include/s6-dns/s6dns-resolve.h src/libs6dns/s6dns_resolve_dpag.o src/libs6dns/s6dns_resolve_dpag.lo: src/libs6dns/s6dns_resolve_dpag.c src/include/s6-dns/s6dns-resolve.h src/libs6dns/s6dns_resolve_mpag.o src/libs6dns/s6dns_resolve_mpag.lo: src/libs6dns/s6dns_resolve_mpag.c src/include/s6-dns/s6dns-resolve.h src/libs6dns/s6dns_resolve_name4.o src/libs6dns/s6dns_resolve_name4.lo: src/libs6dns/s6dns_resolve_name4.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-resolve.h src/libs6dns/s6dns_resolve_name6.o src/libs6dns/s6dns_resolve_name6.lo: src/libs6dns/s6dns_resolve_name6.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-resolve.h src/libs6dns/s6dns_resolve_parse.o src/libs6dns/s6dns_resolve_parse.lo: src/libs6dns/s6dns_resolve_parse.c src/include/s6-dns/s6dns-engine.h src/include/s6-dns/s6dns-message.h src/include/s6-dns/s6dns-resolve.h src/libs6dns/s6dns_resolven_loop.o src/libs6dns/s6dns_resolven_loop.lo: src/libs6dns/s6dns_resolven_loop.c src/include/s6-dns/s6dns-engine.h src/include/s6-dns/s6dns-resolve.h src/libs6dns/s6dns_resolven_parse.o src/libs6dns/s6dns_resolven_parse.lo: src/libs6dns/s6dns_resolven_parse.c src/include/s6-dns/s6dns-engine.h src/include/s6-dns/s6dns-message.h src/include/s6-dns/s6dns-resolve.h src/libs6dns/s6dns_resolvenoq.o src/libs6dns/s6dns_resolvenoq.lo: src/libs6dns/s6dns_resolvenoq.c src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-resolve.h src/libs6dns/s6dns_resolvenoq_aaaaa.o src/libs6dns/s6dns_resolvenoq_aaaaa.lo: src/libs6dns/s6dns_resolvenoq_aaaaa.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-message.h src/include/s6-dns/s6dns-resolve.h src/libs6dns/s6dns_resolveq.o src/libs6dns/s6dns_resolveq.lo: src/libs6dns/s6dns_resolveq.c src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-engine.h src/include/s6-dns/s6dns-message.h src/include/s6-dns/s6dns-resolve.h src/libs6dns/s6dns_resolveq_aaaaa.o src/libs6dns/s6dns_resolveq_aaaaa.lo: src/libs6dns/s6dns_resolveq_aaaaa.c src/include/s6-dns/s6dns-constants.h src/include/s6-dns/s6dns-domain.h src/include/s6-dns/s6dns-engine.h src/include/s6-dns/s6dns-message.h src/include/s6-dns/s6dns-resolve.h src/skadns/skadns_cancel.o src/skadns/skadns_cancel.lo: src/skadns/skadns_cancel.c src/include/s6-dns/skadns.h src/skadns/skadns_end.o src/skadns/skadns_end.lo: src/skadns/skadns_end.c src/include/s6-dns/skadns.h src/skadns/skadns_packet.o src/skadns/skadns_packet.lo: src/skadns/skadns_packet.c src/include/s6-dns/skadns.h src/skadns/skadns_packetlen.o src/skadns/skadns_packetlen.lo: src/skadns/skadns_packetlen.c src/include/s6-dns/skadns.h src/skadns/skadns_release.o src/skadns/skadns_release.lo: src/skadns/skadns_release.c src/include/s6-dns/skadns.h src/skadns/skadns_send.o src/skadns/skadns_send.lo: src/skadns/skadns_send.c src/include/s6-dns/skadns.h src/skadns/skadns_start.o src/skadns/skadns_start.lo: src/skadns/skadns_start.c src/include/s6-dns/skadns.h src/skadns/skadns_startf.o src/skadns/skadns_startf.lo: src/skadns/skadns_startf.c src/include/s6-dns/skadns.h src/skadns/skadns_update.o src/skadns/skadns_update.lo: src/skadns/skadns_update.c src/include/s6-dns/skadns.h src/skadns/skadns_zero.o src/skadns/skadns_zero.lo: src/skadns/skadns_zero.c src/include/s6-dns/skadns.h src/skadns/skadnsd.o src/skadns/skadnsd.lo: src/skadns/skadnsd.c src/include/s6-dns/s6dns.h src/include/s6-dns/skadns.h s6-dnsip4: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dnsip4: src/clients/s6-dnsip4.o ${LIBS6DNS} s6-dnsip4-filter: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} ${SPAWN_LIB} s6-dnsip4-filter: src/clients/s6-dnsip4-filter.o src/clients/s6dns_generic_filter_main.o src/clients/s6dns_namescanner.o ${LIBSKADNS} ${LIBS6DNS} s6-dnsip6: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dnsip6: src/clients/s6-dnsip6.o ${LIBS6DNS} s6-dnsip6-filter: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} ${SPAWN_LIB} s6-dnsip6-filter: src/clients/s6-dnsip6-filter.o src/clients/s6dns_generic_filter_main.o src/clients/s6dns_namescanner.o ${LIBSKADNS} ${LIBS6DNS} s6-dnsmx: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dnsmx: src/clients/s6-dnsmx.o ${LIBS6DNS} s6-dnsname: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dnsname: src/clients/s6-dnsname.o ${LIBS6DNS} s6-dnsname-filter: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} ${SPAWN_LIB} s6-dnsname-filter: src/clients/s6-dnsname-filter.o src/clients/s6dns_generic_filter_main.o ${LIBSKADNS} ${LIBS6DNS} s6-dnsns: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dnsns: src/clients/s6-dnsns.o ${LIBS6DNS} s6-dnsq: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dnsq: src/clients/s6-dnsq.o ${LIBS6DNS} s6-dnsqr: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dnsqr: src/clients/s6-dnsqr.o ${LIBS6DNS} s6-dnsqualify: EXTRA_LIBS := -lskarnet s6-dnsqualify: src/clients/s6-dnsqualify.o ${LIBS6DNS} s6-dnssoa: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dnssoa: src/clients/s6-dnssoa.o ${LIBS6DNS} s6-dnssrv: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dnssrv: src/clients/s6-dnssrv.o ${LIBS6DNS} s6-dnstxt: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-dnstxt: src/clients/s6-dnstxt.o ${LIBS6DNS} s6-randomip: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} s6-randomip: src/clients/s6-randomip.o ifeq ($(strip $(STATIC_LIBS_ARE_PIC)),) libs6dns.a.xyzzy: src/libs6dns/s6dns_constants_error.o src/libs6dns/s6dns_constants_error_str.o src/libs6dns/s6dns_debughook_zero.o src/libs6dns/s6dns_domain_arpafromip4.o src/libs6dns/s6dns_domain_arpafromip6.o src/libs6dns/s6dns_domain_decode.o src/libs6dns/s6dns_domain_encode.o src/libs6dns/s6dns_domain_encodelist.o src/libs6dns/s6dns_domain_fromstring.o src/libs6dns/s6dns_domain_fromstring_noqualify_encode.o src/libs6dns/s6dns_domain_fromstring_qualify_encode.o src/libs6dns/s6dns_domain_noqualify.o src/libs6dns/s6dns_domain_qualify.o src/libs6dns/s6dns_domain_tostring.o src/libs6dns/s6dns_engine.o src/libs6dns/s6dns_engine_free.o src/libs6dns/s6dns_engine_freen.o src/libs6dns/s6dns_engine_here.o src/libs6dns/s6dns_engine_nextdeadline.o src/libs6dns/s6dns_engine_zero.o src/libs6dns/s6dns_fmt_domainlist.o src/libs6dns/s6dns_fmt_hinfo.o src/libs6dns/s6dns_fmt_mx.o src/libs6dns/s6dns_fmt_soa.o src/libs6dns/s6dns_fmt_srv.o src/libs6dns/s6dns_fmt_caa.o src/libs6dns/s6dns_message_counts_next.o src/libs6dns/s6dns_message_counts_pack.o src/libs6dns/s6dns_message_counts_unpack.o src/libs6dns/s6dns_message_counts_zero.o src/libs6dns/s6dns_message_get_domain.o src/libs6dns/s6dns_message_get_domain_internal.o src/libs6dns/s6dns_message_get_hinfo.o src/libs6dns/s6dns_message_get_string.o src/libs6dns/s6dns_message_get_string_internal.o src/libs6dns/s6dns_message_get_strings.o src/libs6dns/s6dns_message_get_mx.o src/libs6dns/s6dns_message_get_soa.o src/libs6dns/s6dns_message_get_srv.o src/libs6dns/s6dns_message_get_caa.o src/libs6dns/s6dns_message_header_pack.o src/libs6dns/s6dns_message_header_unpack.o src/libs6dns/s6dns_message_header_zero.o src/libs6dns/s6dns_message_parse_answer_aaaa.o src/libs6dns/s6dns_message_parse_answer_a.o src/libs6dns/s6dns_message_parse_answer_domain.o src/libs6dns/s6dns_message_parse_answer_hinfo.o src/libs6dns/s6dns_message_parse_answer_mx.o src/libs6dns/s6dns_message_parse_answer_soa.o src/libs6dns/s6dns_message_parse_answer_srv.o src/libs6dns/s6dns_message_parse_answer_caa.o src/libs6dns/s6dns_message_parse_answer_strings.o src/libs6dns/s6dns_message_parse.o src/libs6dns/s6dns_message_parse_getrr.o src/libs6dns/s6dns_message_parse_init.o src/libs6dns/s6dns_message_parse_next.o src/libs6dns/s6dns_message_parse_skipqd.o src/libs6dns/s6dns_rci_free.o src/libs6dns/s6dns_rci_here.o src/libs6dns/s6dns_rci_init.o src/libs6dns/s6dns_rci_zero.o src/libs6dns/s6dns_resolve_core.o src/libs6dns/s6dns_resolve_parse.o src/libs6dns/s6dns_resolven_loop.o src/libs6dns/s6dns_resolven_parse.o src/libs6dns/s6dns_resolve_dpag.o src/libs6dns/s6dns_resolve_mpag.o src/libs6dns/s6dns_resolve_name4.o src/libs6dns/s6dns_resolve_name6.o src/libs6dns/s6dns_resolvenoq.o src/libs6dns/s6dns_resolveq.o src/libs6dns/s6dns_resolvenoq_aaaaa.o src/libs6dns/s6dns_resolveq_aaaaa.o src/libs6dns/s6dns_analyze_packet.o src/libs6dns/s6dns_analyze_qtype_parse.o src/libs6dns/s6dns_analyze_record.o src/libs6dns/s6dns_analyze_record_a.o src/libs6dns/s6dns_analyze_record_aaaa.o src/libs6dns/s6dns_analyze_record_hinfo.o src/libs6dns/s6dns_analyze_record_mx.o src/libs6dns/s6dns_analyze_record_soa.o src/libs6dns/s6dns_analyze_record_srv.o src/libs6dns/s6dns_analyze_record_caa.o src/libs6dns/s6dns_analyze_record_domain.o src/libs6dns/s6dns_analyze_record_strings.o src/libs6dns/s6dns_analyze_record_unknown.o src/libs6dns/s6dns_analyze_rtypetable.o src/libs6dns/s6dns_debug_dumpdt_stdout.o src/libs6dns/s6dns_debug_dumpdt_stderr.o src/libs6dns/s6dns_debug_dumpdt_post_recv.o src/libs6dns/s6dns_debug_dumpdt_pre_send.o src/libs6dns/s6dns_debug_dumpdt_post_send.o src/libs6dns/s6dns_init.o src/libs6dns/s6dns_finish.o else libs6dns.a.xyzzy: src/libs6dns/s6dns_constants_error.lo src/libs6dns/s6dns_constants_error_str.lo src/libs6dns/s6dns_debughook_zero.lo src/libs6dns/s6dns_domain_arpafromip4.lo src/libs6dns/s6dns_domain_arpafromip6.lo src/libs6dns/s6dns_domain_decode.lo src/libs6dns/s6dns_domain_encode.lo src/libs6dns/s6dns_domain_encodelist.lo src/libs6dns/s6dns_domain_fromstring.lo src/libs6dns/s6dns_domain_fromstring_noqualify_encode.lo src/libs6dns/s6dns_domain_fromstring_qualify_encode.lo src/libs6dns/s6dns_domain_noqualify.lo src/libs6dns/s6dns_domain_qualify.lo src/libs6dns/s6dns_domain_tostring.lo src/libs6dns/s6dns_engine.lo src/libs6dns/s6dns_engine_free.lo src/libs6dns/s6dns_engine_freen.lo src/libs6dns/s6dns_engine_here.lo src/libs6dns/s6dns_engine_nextdeadline.lo src/libs6dns/s6dns_engine_zero.lo src/libs6dns/s6dns_fmt_domainlist.lo src/libs6dns/s6dns_fmt_hinfo.lo src/libs6dns/s6dns_fmt_mx.lo src/libs6dns/s6dns_fmt_soa.lo src/libs6dns/s6dns_fmt_srv.lo src/libs6dns/s6dns_fmt_caa.lo src/libs6dns/s6dns_message_counts_next.lo src/libs6dns/s6dns_message_counts_pack.lo src/libs6dns/s6dns_message_counts_unpack.lo src/libs6dns/s6dns_message_counts_zero.lo src/libs6dns/s6dns_message_get_domain.lo src/libs6dns/s6dns_message_get_domain_internal.lo src/libs6dns/s6dns_message_get_hinfo.lo src/libs6dns/s6dns_message_get_string.lo src/libs6dns/s6dns_message_get_string_internal.lo src/libs6dns/s6dns_message_get_strings.lo src/libs6dns/s6dns_message_get_mx.lo src/libs6dns/s6dns_message_get_soa.lo src/libs6dns/s6dns_message_get_srv.lo src/libs6dns/s6dns_message_get_caa.lo src/libs6dns/s6dns_message_header_pack.lo src/libs6dns/s6dns_message_header_unpack.lo src/libs6dns/s6dns_message_header_zero.lo src/libs6dns/s6dns_message_parse_answer_aaaa.lo src/libs6dns/s6dns_message_parse_answer_a.lo src/libs6dns/s6dns_message_parse_answer_domain.lo src/libs6dns/s6dns_message_parse_answer_hinfo.lo src/libs6dns/s6dns_message_parse_answer_mx.lo src/libs6dns/s6dns_message_parse_answer_soa.lo src/libs6dns/s6dns_message_parse_answer_srv.lo src/libs6dns/s6dns_message_parse_answer_caa.lo src/libs6dns/s6dns_message_parse_answer_strings.lo src/libs6dns/s6dns_message_parse.lo src/libs6dns/s6dns_message_parse_getrr.lo src/libs6dns/s6dns_message_parse_init.lo src/libs6dns/s6dns_message_parse_next.lo src/libs6dns/s6dns_message_parse_skipqd.lo src/libs6dns/s6dns_rci_free.lo src/libs6dns/s6dns_rci_here.lo src/libs6dns/s6dns_rci_init.lo src/libs6dns/s6dns_rci_zero.lo src/libs6dns/s6dns_resolve_core.lo src/libs6dns/s6dns_resolve_parse.lo src/libs6dns/s6dns_resolven_loop.lo src/libs6dns/s6dns_resolven_parse.lo src/libs6dns/s6dns_resolve_dpag.lo src/libs6dns/s6dns_resolve_mpag.lo src/libs6dns/s6dns_resolve_name4.lo src/libs6dns/s6dns_resolve_name6.lo src/libs6dns/s6dns_resolvenoq.lo src/libs6dns/s6dns_resolveq.lo src/libs6dns/s6dns_resolvenoq_aaaaa.lo src/libs6dns/s6dns_resolveq_aaaaa.lo src/libs6dns/s6dns_analyze_packet.lo src/libs6dns/s6dns_analyze_qtype_parse.lo src/libs6dns/s6dns_analyze_record.lo src/libs6dns/s6dns_analyze_record_a.lo src/libs6dns/s6dns_analyze_record_aaaa.lo src/libs6dns/s6dns_analyze_record_hinfo.lo src/libs6dns/s6dns_analyze_record_mx.lo src/libs6dns/s6dns_analyze_record_soa.lo src/libs6dns/s6dns_analyze_record_srv.lo src/libs6dns/s6dns_analyze_record_caa.lo src/libs6dns/s6dns_analyze_record_domain.lo src/libs6dns/s6dns_analyze_record_strings.lo src/libs6dns/s6dns_analyze_record_unknown.lo src/libs6dns/s6dns_analyze_rtypetable.lo src/libs6dns/s6dns_debug_dumpdt_stdout.lo src/libs6dns/s6dns_debug_dumpdt_stderr.lo src/libs6dns/s6dns_debug_dumpdt_post_recv.lo src/libs6dns/s6dns_debug_dumpdt_pre_send.lo src/libs6dns/s6dns_debug_dumpdt_post_send.lo src/libs6dns/s6dns_init.lo src/libs6dns/s6dns_finish.lo endif libs6dns.so.xyzzy: EXTRA_LIBS := -lskarnet libs6dns.so.xyzzy: src/libs6dns/s6dns_constants_error.lo src/libs6dns/s6dns_constants_error_str.lo src/libs6dns/s6dns_debughook_zero.lo src/libs6dns/s6dns_domain_arpafromip4.lo src/libs6dns/s6dns_domain_arpafromip6.lo src/libs6dns/s6dns_domain_decode.lo src/libs6dns/s6dns_domain_encode.lo src/libs6dns/s6dns_domain_encodelist.lo src/libs6dns/s6dns_domain_fromstring.lo src/libs6dns/s6dns_domain_fromstring_noqualify_encode.lo src/libs6dns/s6dns_domain_fromstring_qualify_encode.lo src/libs6dns/s6dns_domain_noqualify.lo src/libs6dns/s6dns_domain_qualify.lo src/libs6dns/s6dns_domain_tostring.lo src/libs6dns/s6dns_engine.lo src/libs6dns/s6dns_engine_free.lo src/libs6dns/s6dns_engine_freen.lo src/libs6dns/s6dns_engine_here.lo src/libs6dns/s6dns_engine_nextdeadline.lo src/libs6dns/s6dns_engine_zero.lo src/libs6dns/s6dns_fmt_domainlist.lo src/libs6dns/s6dns_fmt_hinfo.lo src/libs6dns/s6dns_fmt_mx.lo src/libs6dns/s6dns_fmt_soa.lo src/libs6dns/s6dns_fmt_srv.lo src/libs6dns/s6dns_fmt_caa.lo src/libs6dns/s6dns_message_counts_next.lo src/libs6dns/s6dns_message_counts_pack.lo src/libs6dns/s6dns_message_counts_unpack.lo src/libs6dns/s6dns_message_counts_zero.lo src/libs6dns/s6dns_message_get_domain.lo src/libs6dns/s6dns_message_get_domain_internal.lo src/libs6dns/s6dns_message_get_hinfo.lo src/libs6dns/s6dns_message_get_string.lo src/libs6dns/s6dns_message_get_string_internal.lo src/libs6dns/s6dns_message_get_strings.lo src/libs6dns/s6dns_message_get_mx.lo src/libs6dns/s6dns_message_get_soa.lo src/libs6dns/s6dns_message_get_srv.lo src/libs6dns/s6dns_message_get_caa.lo src/libs6dns/s6dns_message_header_pack.lo src/libs6dns/s6dns_message_header_unpack.lo src/libs6dns/s6dns_message_header_zero.lo src/libs6dns/s6dns_message_parse_answer_aaaa.lo src/libs6dns/s6dns_message_parse_answer_a.lo src/libs6dns/s6dns_message_parse_answer_domain.lo src/libs6dns/s6dns_message_parse_answer_hinfo.lo src/libs6dns/s6dns_message_parse_answer_mx.lo src/libs6dns/s6dns_message_parse_answer_soa.lo src/libs6dns/s6dns_message_parse_answer_srv.lo src/libs6dns/s6dns_message_parse_answer_caa.lo src/libs6dns/s6dns_message_parse_answer_strings.lo src/libs6dns/s6dns_message_parse.lo src/libs6dns/s6dns_message_parse_getrr.lo src/libs6dns/s6dns_message_parse_init.lo src/libs6dns/s6dns_message_parse_next.lo src/libs6dns/s6dns_message_parse_skipqd.lo src/libs6dns/s6dns_rci_free.lo src/libs6dns/s6dns_rci_here.lo src/libs6dns/s6dns_rci_init.lo src/libs6dns/s6dns_rci_zero.lo src/libs6dns/s6dns_resolve_core.lo src/libs6dns/s6dns_resolve_parse.lo src/libs6dns/s6dns_resolven_loop.lo src/libs6dns/s6dns_resolven_parse.lo src/libs6dns/s6dns_resolve_dpag.lo src/libs6dns/s6dns_resolve_mpag.lo src/libs6dns/s6dns_resolve_name4.lo src/libs6dns/s6dns_resolve_name6.lo src/libs6dns/s6dns_resolvenoq.lo src/libs6dns/s6dns_resolveq.lo src/libs6dns/s6dns_resolvenoq_aaaaa.lo src/libs6dns/s6dns_resolveq_aaaaa.lo src/libs6dns/s6dns_analyze_packet.lo src/libs6dns/s6dns_analyze_qtype_parse.lo src/libs6dns/s6dns_analyze_record.lo src/libs6dns/s6dns_analyze_record_a.lo src/libs6dns/s6dns_analyze_record_aaaa.lo src/libs6dns/s6dns_analyze_record_hinfo.lo src/libs6dns/s6dns_analyze_record_mx.lo src/libs6dns/s6dns_analyze_record_soa.lo src/libs6dns/s6dns_analyze_record_srv.lo src/libs6dns/s6dns_analyze_record_caa.lo src/libs6dns/s6dns_analyze_record_domain.lo src/libs6dns/s6dns_analyze_record_strings.lo src/libs6dns/s6dns_analyze_record_unknown.lo src/libs6dns/s6dns_analyze_rtypetable.lo src/libs6dns/s6dns_debug_dumpdt_stdout.lo src/libs6dns/s6dns_debug_dumpdt_stderr.lo src/libs6dns/s6dns_debug_dumpdt_post_recv.lo src/libs6dns/s6dns_debug_dumpdt_pre_send.lo src/libs6dns/s6dns_debug_dumpdt_post_send.lo src/libs6dns/s6dns_init.lo src/libs6dns/s6dns_finish.lo ifeq ($(strip $(STATIC_LIBS_ARE_PIC)),) libskadns.a.xyzzy: src/skadns/skadns_cancel.o src/skadns/skadns_end.o src/skadns/skadns_packet.o src/skadns/skadns_packetlen.o src/skadns/skadns_release.o src/skadns/skadns_send.o src/skadns/skadns_start.o src/skadns/skadns_startf.o src/skadns/skadns_update.o src/skadns/skadns_zero.o else libskadns.a.xyzzy: src/skadns/skadns_cancel.lo src/skadns/skadns_end.lo src/skadns/skadns_packet.lo src/skadns/skadns_packetlen.lo src/skadns/skadns_release.lo src/skadns/skadns_send.lo src/skadns/skadns_start.lo src/skadns/skadns_startf.lo src/skadns/skadns_update.lo src/skadns/skadns_zero.lo endif libskadns.so.xyzzy: EXTRA_LIBS := -lskarnet libskadns.so.xyzzy: src/skadns/skadns_cancel.lo src/skadns/skadns_end.lo src/skadns/skadns_packet.lo src/skadns/skadns_packetlen.lo src/skadns/skadns_release.lo src/skadns/skadns_send.lo src/skadns/skadns_start.lo src/skadns/skadns_startf.lo src/skadns/skadns_update.lo src/skadns/skadns_zero.lo skadnsd: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} skadnsd: src/skadns/skadnsd.o ${LIBS6DNS} s6-dns-2.3.1.1/package/deps-build0000644000000000000000000000002612441434230013215 0ustar /package/prog/skalibs s6-dns-2.3.1.1/package/targets.mak0000644000000000000000000000044012562634231013414 0ustar BIN_TARGETS := \ skadnsd \ s6-randomip \ s6-dnsqualify \ s6-dnsip4 \ s6-dnsip6 \ s6-dnsmx \ s6-dnsname \ s6-dnsns \ s6-dnssoa \ s6-dnssrv \ s6-dnstxt \ s6-dnsip4-filter \ s6-dnsip6-filter \ s6-dnsname-filter \ s6-dnsq \ s6-dnsqr LIBEXEC_TARGETS := LIB_DEFS := S6DNS=s6dns SKADNS=skadns s6-dns-2.3.1.1/package/modes0000644000000000000000000000042512441434414012303 0ustar skadnsd 0755 s6-randomip 0755 s6-dnsqualify 0755 s6-dnsip4 0755 s6-dnsip6 0755 s6-dnsmx 0755 s6-dnsname 0755 s6-dnsns 0755 s6-dnssoa 0755 s6-dnssrv 0755 s6-dnstxt 0755 s6-dnsip4-filter 0755 s6-dnsip6-filter 0755 s6-dnsname-filter 0755 s6-dnsq 0755 s6-dnsqr 0755 s6-dns-2.3.1.1/package/info0000644000000000000000000000010613553354673012140 0ustar package=s6-dns version=2.3.1.1 category=web package_macro_name=S6_DNS s6-dns-2.3.1.1/COPYING0000644000000000000000000000137013434602073010712 0ustar Copyright (c) 2011-2019 Laurent Bercot Permission to use, copy, modify, and distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. s6-dns-2.3.1.1/configure0000755000000000000000000003246113553343654011604 0ustar #!/bin/sh cd `dirname "$0"` . package/info usage () { cat </dev/null 2>&1 && { echo "$1" ; return 0 ; } $1 EOF echo "$1" | sed -e "s/'/'\\\\''/g" -e "1s/^/'/" -e "\$s/\$/'/" -e "s#^'\([-[:alnum:]_,./:]*\)=\(.*\)\$#\1='\2#" -e "s|\*/|* /|g" } fail () { echo "$*" exit 1 } fnmatch () { eval "case \"\$2\" in $1) return 0 ;; *) return 1 ;; esac" } cmdexists () { type "$1" >/dev/null 2>&1 } trycc () { test -z "$CC_AUTO" && cmdexists "$1" && CC_AUTO="$*" } stripdir () { while eval "fnmatch '*/' \"\${$1}\"" ; do eval "$1=\${$1%/}" done } tryflag () { echo "Checking whether compiler accepts $2 ..." echo "typedef int x;" > "$tmpc" if $CC_AUTO $CPPFLAGS_AUTO $CPPFLAGS $CPPFLAGS_POST $CFLAGS_AUTO $CFLAGS $CFLAGS_POST "$2" -c -o /dev/null "$tmpc" >/dev/null 2>&1 ; then echo " ... yes" eval "$1=\"\${$1} \$2\"" eval "$1=\${$1# }" return 0 else echo " ... no" return 1 fi } tryldflag () { echo "Checking whether linker accepts $2 ..." echo "typedef int x;" > "$tmpc" if $CC_AUTO $CFLAGS_AUTO $CFLAGS $CFLAGS_POST $LDFLAGS_AUTO $LDFLAGS $LDFLAGS_POST -nostdlib "$2" -o /dev/null "$tmpc" >/dev/null 2>&1 ; then echo " ... yes" eval "$1=\"\${$1} \$2\"" eval "$1=\${$1# }" return 0 else echo " ... no" return 1 fi } # Actual script CC_AUTO= CPPFLAGS_AUTO="-D_POSIX_C_SOURCE=200809L -D_XOPEN_SOURCE=700 -iquote src/include-local -Isrc/include" CPPFLAGS_POST="$CPPFLAGS" CPPFLAGS= CFLAGS_AUTO="-pipe -Wall" CFLAGS_POST="$CFLAGS" CFLAGS=-O2 LDFLAGS_AUTO= LDFLAGS_POST="$LDFLAGS" LDFLAGS= LDFLAGS_NOSHARED= LDFLAGS_SHARED=-shared prefix= exec_prefix='$prefix' dynlibdir='$prefix/lib' libexecdir='$exec_prefix/libexec' bindir='$exec_prefix/bin' libdir='$prefix/lib/$package' includedir='$prefix/include' sysdeps='$prefix/lib/skalibs/sysdeps' manualsysdeps=false shared=false static=true allpic=true slashpackage=false abspath=false sproot= home= exthome= allstatic=true evenmorestatic=false addincpath='' addlibspath='' addlibdpath='' vpaths='' vpathd='' build= for arg ; do case "$arg" in --help) usage ;; --prefix=*) prefix=${arg#*=} ;; --exec-prefix=*) exec_prefix=${arg#*=} ;; --dynlibdir=*) dynlibdir=${arg#*=} ;; --libexecdir=*) libexecdir=${arg#*=} ;; --bindir=*) bindir=${arg#*=} ;; --libdir=*) libdir=${arg#*=} ;; --includedir=*) includedir=${arg#*=} ;; --with-sysdeps=*) sysdeps=${arg#*=} manualsysdeps=true ;; --with-include=*) var=${arg#*=} ; stripdir var ; addincpath="$addincpath -I$var" ;; --with-lib=*) var=${arg#*=} ; stripdir var ; addlibspath="$addlibspath -L$var" ; vpaths="$vpaths $var" ;; --with-dynlib=*) var=${arg#*=} ; stripdir var ; addlibdpath="$addlibdpath -L$var" ; vpathd="$vpathd $var" ;; --enable-shared|--enable-shared=yes) shared=true ;; --disable-shared|--enable-shared=no) shared=false ;; --enable-static|--enable-static=yes) static=true ;; --disable-static|--enable-static=no) static=false ;; --enable-allstatic|--enable-allstatic=yes) allstatic=true ;; --disable-allstatic|--enable-allstatic=no) allstatic=false ; evenmorestatic=false ;; --enable-static-libc|--enable-static-libc=yes) allstatic=true ; evenmorestatic=true ;; --disable-static-libc|--enable-static-libc=no) evenmorestatic=false ;; --enable-all-pic|--enable-all-pic=yes) allpic=true ;; --disable-all-pic|--enable-all-pic=no) allpic=false ;; --enable-slashpackage=*) sproot=${arg#*=} ; slashpackage=true ; ;; --enable-slashpackage) sproot= ; slashpackage=true ;; --disable-slashpackage) sproot= ; slashpackage=false ;; --enable-absolute-paths|--enable-absolute-paths=yes) abspath=true ;; --disable-absolute-paths|--enable-absolute-paths=no) abspath=false ;; --enable-*|--disable-*|--with-*|--without-*|--*dir=*) ;; --host=*|--target=*) target=${arg#*=} ;; --build=*) build=${arg#*=} ;; -* ) echo "$0: unknown option $arg" ;; *=*) ;; *) target=$arg ;; esac done # Add /usr in the default default case if test -z "$prefix" ; then if test "$libdir" = '$prefix/lib/$package' ; then libdir=/usr/lib/$package fi if test "$includedir" = '$prefix/include' ; then includedir=/usr/include fi if test "$sysdeps" = '$prefix/lib/skalibs/sysdeps' ; then sysdeps=/usr/lib/skalibs/sysdeps fi fi # Expand installation directories stripdir prefix for i in exec_prefix dynlibdir libexecdir bindir libdir includedir sysdeps sproot ; do eval tmp=\${$i} eval $i=$tmp stripdir $i done # Get usable temp filenames i=0 set -C while : ; do i=$(($i+1)) tmpc="./tmp-configure-$$-$PPID-$i.c" tmpe="./tmp-configure-$$-$PPID-$i.tmp" 2>|/dev/null > "$tmpc" && break 2>|/dev/null > "$tmpe" && break test "$i" -gt 50 && fail "$0: cannot create temporary files" done set +C trap 'rm -f "$tmpc" "$tmpe"' EXIT ABRT INT QUIT TERM HUP # Set slashpackage values if $slashpackage ; then home=${sproot}/package/${category}/${package}-${version} exthome=${sproot}/package/${category}/${package} if $manualsysdeps ; then : else sysdeps=${sproot}/package/prog/skalibs/sysdeps fi extbinprefix=${exthome}/command dynlibdir=${home}/library.so bindir=${home}/command libdir=${home}/library libexecdir=$bindir includedir=${home}/include while read dep condvar ; do if test -n "$condvar" ; then eval "cond=$condvar" else cond=true fi if $cond ; then addincpath="$addincpath -I${sproot}${dep}/include" vpaths="$vpaths ${sproot}${dep}/library" addlibspath="$addlibspath -L${sproot}${dep}/library" vpathd="$vpathd ${sproot}${dep}/library.so" addlibdpath="$addlibdpath -L${sproot}${dep}/library.so" fi done < package/deps-build fi # Find a C compiler to use if test -n "$target" && test x${build} != x${target} ; then cross=${target}- else cross= fi echo "Checking for C compiler..." trycc ${CC} if test -n "$CC_AUTO" ; then b=`basename "$CC"` adjust_cross=false if test "$b" != "$CC" ; then adjust_cross=true echo "$0: warning: compiler $CC is declared with its own path. If it's not accessible via PATH, you will need to pass AR, RANLIB and STRIP make variables to the make invocation." 1>&2 fi if test -n "$cross" ; then if test "$b" = "${b##$cross}" ; then echo "$0: warning: compiler $CC is declared as a cross-compiler for target $target but does not start with prefix ${cross}" 1>&2 elif $adjust_cross ; then cross=`dirname "$CC"`/"$cross" fi fi fi trycc ${cross}gcc trycc ${cross}clang trycc ${cross}cc test -n "$CC_AUTO" || { echo "$0: cannot find a C compiler" ; exit 1 ; } echo " ... $CC_AUTO" echo "Checking whether C compiler works... " echo "typedef int x;" > "$tmpc" if $CC_AUTO $CPPFLAGS_AUTO $CPPFLAGS $CPPFLAGS_POST $CFLAGS_AUTO $CFLAGS $CFLAGS_POST -c -o /dev/null "$tmpc" 2>"$tmpe" ; then echo " ... yes" else echo " ... no. Compiler output follows:" cat < "$tmpe" exit 1 fi echo "Checking target system type..." if test -z "$target" ; then if test -n "$build" ; then target=$build ; else target=$($CC_AUTO -dumpmachine 2>/dev/null) || target=unknown fi fi echo " ... $target" if test ! -d $sysdeps || test ! -f $sysdeps/target ; then echo "$0: error: $sysdeps is not a valid sysdeps directory" exit 1 fi if [ "x$target" != "x$(cat $sysdeps/target)" ] ; then echo "$0: error: target $target does not match the contents of $sysdeps/target" exit 1 fi spawn_lib=$(cat $sysdeps/spawn.lib) socket_lib=$(cat $sysdeps/socket.lib) sysclock_lib=$(cat $sysdeps/sysclock.lib) timer_lib=$(cat $sysdeps/timer.lib) util_lib=$(cat $sysdeps/util.lib) if $allpic ; then tryflag CPPFLAGS_AUTO -fPIC fi tryflag CFLAGS_AUTO -std=c99 tryflag CFLAGS -fomit-frame-pointer tryflag CFLAGS_AUTO -fno-exceptions tryflag CFLAGS_AUTO -fno-unwind-tables tryflag CFLAGS_AUTO -fno-asynchronous-unwind-tables tryflag CFLAGS_AUTO -Wa,--noexecstack tryflag CFLAGS -fno-stack-protector tryflag CPPFLAGS_AUTO -Werror=implicit-function-declaration tryflag CPPFLAGS_AUTO -Werror=implicit-int tryflag CPPFLAGS_AUTO -Werror=pointer-sign tryflag CPPFLAGS_AUTO -Werror=pointer-arith tryflag CFLAGS_AUTO -ffunction-sections tryflag CFLAGS_AUTO -fdata-sections tryldflag LDFLAGS_AUTO -Wl,--sort-section=alignment tryldflag LDFLAGS_AUTO -Wl,--sort-common CPPFLAGS_AUTO="${CPPFLAGS_AUTO}${addincpath}" if $evenmorestatic ; then LDFLAGS_NOSHARED=-static fi if $shared ; then tryldflag LDFLAGS -Wl,--hash-style=both fi LDFLAGS_SHARED="${LDFLAGS_SHARED}${addlibdpath}" if $allstatic ; then LDFLAGS_NOSHARED="${LDFLAGS_NOSHARED}${addlibspath}" tryldflag LDFLAGS_NOSHARED -Wl,--gc-sections else LDFLAGS_NOSHARED="${LDFLAGS_NOSHARED}${addlibdpath}" fi if test -z "$vpaths" ; then while read dep ; do base=$(basename $dep) ; vpaths="$vpaths /usr/lib/$base" addlibspath="$addlibspath -L/usr/lib/$base" done < package/deps-build fi echo "Creating config.mak..." cmdline=$(quote "$0") for i ; do cmdline="$cmdline $(quote "$i")" ; done exec 3>&1 1>config.mak cat << EOF # This file was generated by: # $cmdline # Any changes made here will be lost if configure is re-run. target := $target package := $package prefix := $prefix exec_prefix := $exec_prefix dynlibdir := $dynlibdir libexecdir := $libexecdir bindir := $bindir libdir := $libdir includedir := $includedir sysdeps := $sysdeps slashpackage := $slashpackage sproot := $sproot version := $version home := $home exthome := $exthome SPAWN_LIB := ${spawn_lib} SOCKET_LIB := ${socket_lib} SYSCLOCK_LIB := ${sysclock_lib} TIMER_LIB := ${timer_lib} UTIL_LIB := ${util_lib} CC := $CC_AUTO CPPFLAGS_AUTO := $CPPFLAGS_AUTO CPPFLAGS := $CPPFLAGS $CPPFLAGS_POST CFLAGS_AUTO := $CFLAGS_AUTO CFLAGS := $CFLAGS $CFLAGS_POST LDFLAGS_AUTO := $LDFLAGS_AUTO LDFLAGS := $LDFLAGS $LDFLAGS_POST LDFLAGS_SHARED := $LDFLAGS_SHARED LDFLAGS_NOSHARED := $LDFLAGS_NOSHARED CROSS_COMPILE := $cross vpath lib%.a$vpaths vpath lib%.so$vpathd EOF if $allstatic ; then echo ".LIBPATTERNS := lib%.a" echo "DO_ALLSTATIC := 1" else echo ".LIBPATTERNS := lib%.so" fi if $static ; then echo "DO_STATIC := 1" else echo "DO_STATIC :=" fi if $shared ; then echo "DO_SHARED := 1" else echo "DO_SHARED :=" fi if $allpic ; then echo "STATIC_LIBS_ARE_PIC := 1" else echo "STATIC_LIBS_ARE_PIC :=" fi exec 1>&3 3>&- echo " ... done." echo "Creating src/include/${package}/config.h..." mkdir -p -m 0755 src/include/${package} exec 3>&1 1> src/include/${package}/config.h cat <&3 3>&- echo " ... done." s6-dns-2.3.1.1/tools/0002755000000000000000000000000013553363665011035 5ustar s6-dns-2.3.1.1/tools/install.sh0000755000000000000000000000167512365207173013040 0ustar #!/bin/sh usage() { echo "usage: $0 [-D] [-l] [-m mode] src dst" 1>&2 exit 1 } mkdirp=false symlink=false mode=0755 while getopts Dlm: name ; do case "$name" in D) mkdirp=true ;; l) symlink=true ;; m) mode=$OPTARG ;; ?) usage ;; esac done shift $(($OPTIND - 1)) test "$#" -eq 2 || usage src=$1 dst=$2 tmp="$dst.tmp.$$" case "$dst" in */) echo "$0: $dst ends in /" 1>&2 ; exit 1 ;; esac set -C set -e if $mkdirp ; then umask 022 case "$2" in */*) mkdir -p "${dst%/*}" ;; esac fi trap 'rm -f "$tmp"' EXIT INT QUIT TERM HUP umask 077 if $symlink ; then ln -s "$src" "$tmp" else cat < "$1" > "$tmp" chmod "$mode" "$tmp" fi mv -f "$tmp" "$dst" if test -d "$dst" ; then rm -f "$dst/$(basename $tmp)" if $symlink ; then mkdir "$tmp" ln -s "$src" "$tmp/$(basename $dst)" mv -f "$tmp/$(basename $dst)" "${dst%/*}" rmdir "$tmp" else echo "$0: $dst is a directory" 1>&2 exit 1 fi fi s6-dns-2.3.1.1/tools/gen-deps.sh0000755000000000000000000000474313553363665013104 0ustar #!/bin/sh -e . package/info echo '#' echo '# This file has been generated by tools/gen-deps.sh' echo '#' echo for dir in src/include/${package} src/* ; do for file in $(ls -1 $dir | grep -- \\.h$) ; do { grep -F -- "#include <${package}/" < ${dir}/$file | cut -d'<' -f2 | cut -d'>' -f1 ; grep -- '#include ".*\.h"' < ${dir}/$file | cut -d'"' -f2 } | sort -u | { deps= while read dep ; do if echo $dep | grep -q "^${package}/" ; then deps="$deps src/include/$dep" elif test -f "${dir}/$dep" ; then deps="$deps ${dir}/$dep" else deps="$deps src/include-local/$dep" fi done if test -n "$deps" ; then echo "${dir}/${file}:${deps}" fi } done done for dir in src/* ; do for file in $(ls -1 $dir | grep -- \\.c$) ; do { grep -F -- "#include <${package}/" < ${dir}/$file | cut -d'<' -f2 | cut -d'>' -f1 ; grep -- '#include ".*\.h"' < ${dir}/$file | cut -d'"' -f2 } | sort -u | { deps=" ${dir}/$file" while read dep ; do if echo $dep | grep -q "^${package}/" ; then deps="$deps src/include/$dep" elif test -f "${dir}/$dep" ; then deps="$deps ${dir}/$dep" else deps="$deps src/include-local/$dep" fi done o=$(echo $file | sed s/\\.c$/.o/) lo=$(echo $file | sed s/\\.c$/.lo/) echo "${dir}/${o} ${dir}/${lo}:${deps}" } done done echo for dir in $(ls -1 src | grep -v ^include) ; do for file in $(ls -1 src/$dir/deps-lib) ; do deps= libs= while read dep ; do if echo $dep | grep -q -e ^-l -e '^\${.*_LIB}' ; then libs="$libs $dep" else deps="$deps src/$dir/$dep" fi done < src/$dir/deps-lib/$file echo 'ifeq ($(strip $(STATIC_LIBS_ARE_PIC)),)' echo "lib${file}.a.xyzzy:$deps" echo else echo "lib${file}.a.xyzzy:$(echo "$deps" | sed 's/\.o/.lo/g')" echo endif echo "lib${file}.so.xyzzy: EXTRA_LIBS :=$libs" echo "lib${file}.so.xyzzy:$(echo "$deps" | sed 's/\.o/.lo/g')" done for file in $(ls -1 src/$dir/deps-exe) ; do deps= libs= while read dep ; do if echo $dep | grep -q -- \\.o$ ; then dep="src/$dir/$dep" fi if echo $dep | grep -q -e ^-l -e '^\${.*_LIB}' ; then libs="$libs $dep" else deps="$deps $dep" fi done < src/$dir/deps-exe/$file echo "$file: EXTRA_LIBS :=$libs" echo "$file: src/$dir/$file.o$deps" done done s6-dns-2.3.1.1/README.macosx0000644000000000000000000000025512376420466012041 0ustar This package will compile and run on Darwin (MacOS X), but the building of shared libraries is not supported. Make sure you use the --disable-shared option to configure. s6-dns-2.3.1.1/NEWS0000644000000000000000000000140613553354715010367 0ustar Changelog for s6-dns. In 2.3.1.1 ---------- - Bugfixes. In 2.3.1.0 ---------- - Adaptation to skalibs-2.9.0.0. In 2.3.0.2 ---------- - Adaptation to skalibs-2.8.0.0. - Everything now builds as PIC by default. In 2.3.0.1 ---------- - Adaptation to skalibs-2.7.0.0. In 2.3.0.0 ---------- - skadns now uses the textclient API/ABI instead of the skaclient one. The change is invisible, but it's leaner and faster. In 2.2.0.1 ---------- - Optimization release for skalibs-2.6.0.0. In 2.2.0.0 ---------- - Added this NEWS file. :) - Major types overhaul to make them more POSIXly correct: compatibility with skalibs-2.5.0.0. - Fixed a long-standing bug that sometimes prevented DNS reply headers from being correctly decoded on big-endian machines. s6-dns-2.3.1.1/Makefile0000644000000000000000000001125513515356574011336 0ustar # # This Makefile requires GNU make. # # Do not make changes here. # Use the included .mak files. # it: all make_need := 3.81 ifeq "" "$(strip $(filter $(make_need), $(firstword $(sort $(make_need) $(MAKE_VERSION)))))" fail := $(error Your make ($(MAKE_VERSION)) is too old. You need $(make_need) or newer) endif CC = $(error Please use ./configure first) STATIC_LIBS := SHARED_LIBS := INTERNAL_LIBS := EXTRA_TARGETS := LIB_DEFS := define library_definition LIB$(firstword $(subst =, ,$(1))) := lib$(lastword $(subst =, ,$(1))).$(if $(DO_ALLSTATIC),a,so).xyzzy ifdef DO_SHARED SHARED_LIBS += lib$(lastword $(subst =, ,$(1))).so.xyzzy endif ifdef DO_STATIC STATIC_LIBS += lib$(lastword $(subst =, ,$(1))).a.xyzzy endif endef -include config.mak include package/targets.mak $(foreach var,$(LIB_DEFS),$(eval $(call library_definition,$(var)))) include package/deps.mak version_m := $(basename $(version)) version_M := $(basename $(version_m)) version_l := $(basename $(version_M)) CPPFLAGS_ALL := $(CPPFLAGS_AUTO) $(CPPFLAGS) CFLAGS_ALL := $(CFLAGS_AUTO) $(CFLAGS) ifeq ($(strip $(STATIC_LIBS_ARE_PIC)),) CFLAGS_SHARED := -fPIC else CFLAGS_SHARED := endif LDFLAGS_ALL := $(LDFLAGS_AUTO) $(LDFLAGS) AR := $(CROSS_COMPILE)ar RANLIB := $(CROSS_COMPILE)ranlib STRIP := $(CROSS_COMPILE)strip INSTALL := ./tools/install.sh ALL_BINS := $(LIBEXEC_TARGETS) $(BIN_TARGETS) ALL_LIBS := $(SHARED_LIBS) $(STATIC_LIBS) $(INTERNAL_LIBS) ALL_INCLUDES := $(wildcard src/include/$(package)/*.h) all: $(ALL_LIBS) $(ALL_BINS) $(ALL_INCLUDES) clean: @exec rm -f $(ALL_LIBS) $(ALL_BINS) $(wildcard src/*/*.o src/*/*.lo) $(EXTRA_TARGETS) distclean: clean @exec rm -f config.mak src/include/$(package)/config.h tgz: distclean @. package/info && \ rm -rf /tmp/$$package-$$version && \ cp -a . /tmp/$$package-$$version && \ cd /tmp && \ tar -zpcv --owner=0 --group=0 --numeric-owner --exclude=.git* -f /tmp/$$package-$$version.tar.gz $$package-$$version && \ exec rm -rf /tmp/$$package-$$version strip: $(ALL_LIBS) $(ALL_BINS) ifneq ($(strip $(STATIC_LIBS)),) exec $(STRIP) -x -R .note -R .comment -R .note.GNU-stack $(STATIC_LIBS) endif ifneq ($(strip $(ALL_BINS)$(SHARED_LIBS)),) exec $(STRIP) -R .note -R .comment -R .note.GNU-stack $(ALL_BINS) $(SHARED_LIBS) endif install: install-dynlib install-libexec install-bin install-lib install-include install-dynlib: $(SHARED_LIBS:lib%.so.xyzzy=$(DESTDIR)$(dynlibdir)/lib%.so) install-libexec: $(LIBEXEC_TARGETS:%=$(DESTDIR)$(libexecdir)/%) install-bin: $(BIN_TARGETS:%=$(DESTDIR)$(bindir)/%) install-lib: $(STATIC_LIBS:lib%.a.xyzzy=$(DESTDIR)$(libdir)/lib%.a) install-include: $(ALL_INCLUDES:src/include/$(package)/%.h=$(DESTDIR)$(includedir)/$(package)/%.h) install-data: $(ALL_DATA:src/etc/%=$(DESTDIR)$(datadir)/%) ifneq ($(exthome),) $(DESTDIR)$(exthome): $(DESTDIR)$(home) exec $(INSTALL) -l $(notdir $(home)) $(DESTDIR)$(exthome) update: $(DESTDIR)$(exthome) global-links: $(DESTDIR)$(exthome) $(SHARED_LIBS:lib%.so.xyzzy=$(DESTDIR)$(sproot)/library.so/lib%.so.$(version_M)) $(BIN_TARGETS:%=$(DESTDIR)$(sproot)/command/%) $(DESTDIR)$(sproot)/command/%: $(DESTDIR)$(home)/command/% exec $(INSTALL) -D -l ..$(subst $(sproot),,$(exthome))/command/$( s6-dns: the problem with getaddrinfo()

s6-dns
Software
skarnet.org

The problem with getaddrinfo()

The standard C library provides an API to perform name resolution: getaddrinfo(), formerly gethostbyname(). However, for DNS resolution as well as implementation in the libc, this interface is very impractical, to the point of being unusable. Here are a few reasons why.

getaddrinfo() performs NSS resolution, not DNS resolution.

I explained this point in a message to the Busybox mailing-list. You can read the post here. (There is a mistake in that post about /etc/nsswitch.conf and /etc/host.conf syntax; the following two messages in the thread correct that mistake.)

TLDR: depending on the machine configuration, it is possible that getaddrinfo() will not use DNS at all.

It is unboundedly synchronous.

DNS resolution performs network I/O, which can take a non-negligible amount of time. getaddrinfo() is a blocking call and there is no way to specify a timeout to make it return early, so it may block indefinitely. This is bad design.

Also, network operations being asynchronous by nature, even a synchronous API should provide a way to perform several queries at once and return when one of them, or all of them, get an answer. getaddrinfo() does not even offer that.

It focuses on the wrong details.

Because it's generic, getaddrinfo() is cumbersome to use. The data structures are impractical, requiring the user to fill in information that is irrelevant to DNS resolution. The details of the network transport protocols are of no interest to the user who just wants answers to his DNS queries!

But at the same time, getaddrinfo() does not allow the user to provide the details he wants or refine his search. It's a very basic and monolithic entry point, with no DNS-specific knobs. For instance, only A and AAAA queries are supported, which is clearly insufficient.

Conclusion

getaddrinfo() is a toy interface. For any half-serious DNS work, another API must be used.

Most people who need a real DNS client library use BIND's libresolv. This page explains what is wrong with it, and what s6-dns tries to do better.

s6-dns-2.3.1.1/doc/libs6dns/0000755000000000000000000000000013111013151012130 5ustar s6-dns-2.3.1.1/doc/libs6dns/index.html0000644000000000000000000000723513541336140014151 0ustar s6-dns: the s6dns library interface

s6-dns
Software
skarnet.org

The s6dns library interface

General information

libs6dns is a DNS client library, designed for clarity and simplicity - which translates into smallness of the code.

A major focus of libs6dns is to avoid unnecessary use of heap memory. Memory is only allocated in the heap to store queries and response packets during a DNS resolution process, and to store the final answers into a user-provided stralloc; all the other operations use stack memory, and perform as few copies as possible.

Compiling

  • Make sure the s6-dns headers, as well as the skalibs headers, are visible in your header search path.
  • Use #include <s6-dns/s6dns.h>

Linking

  • Make sure the s6-dns libraries, as well as the skalibs libraries, are visible in your library search path.
  • Link against -ls6dns, -lskarnet,
    • `cat $SYSDEPS/socket.lib` and `cat $SYSDEPS/sysclock.lib`, $SYSDEPS being your skalibs sysdeps directory.

Programming

The s6-dns/s6dns.h header is actually a concatenation of other headers: the libs6dns is separated into several modules, each of them with its own header.

  • The s6-dns/s6dns-constants.h header provides constants used in other parts of the library.
  • The s6-dns/s6dns-ip46.h header provides an abstraction for IPv4 and IPv6 transports.
  • The s6-dns/s6dns-domain.h header provides basic string manipulation primitives for domain names.
  • The s6-dns/s6dns-message.h header provides function to parse a message following the DNS protocol.
  • The s6-dns/s6dns-engine.h header provides the low-level asynchronous networking functions.
  • The s6-dns/s6dns-rci.h header provides an interface to resolv.conf reading.
  • The s6-dns/s6dns-resolve.h header provides the user-level synchronous resolution functions.
  • The s6-dns/s6dns-fmt.h header provides formatting primitives to display RR contents.

(User-level asynchronous resolution functions are provided in the skadns library.)

Two functional macros are actually directly declared in the s6dns.h header:

  • Call s6dns_init() before all your s6dns operations. s6dns_init() calls s6dns_rci_init(), extracting resolv.conf information to an internal global variable. The function returns 1 on success, and 0 (and sets errno) on failure.
  • Call s6dns_finish() when you're done with the libs6dns. It frees the resources used.
s6-dns-2.3.1.1/doc/libs6dns/s6dns-domain.html0000644000000000000000000001273713111013151015332 0ustar s6-dns: the s6dns_domain library interface

libs6dns
s6-dns
Software
skarnet.org

The s6dns_domain library interface

The following functions and structures are declared in the s6-dns/s6dns-domain.h header, and implemented in the libs6dns.a or libs6dns.so library.

General information

s6dns_domain provides primitives to perform basic operations on domain names.

Data structures

A s6dns_domain_t is a structure that s6dns uses internally to represent a domain name. It can be in string form (or decoded form), which is close to the printable form seen by users, or in packet form (or encoded form), which is the format used in the DNS protocol.

A s6dns_domain_t is a flat structure and can be declared on the stack.

Functions

int s6dns_domain_fromstring (s6dns_domain_t *d, char const *s, size_t len)
Makes a (string form) domain from string s of length len, and stores it into *d. Returns 1 if it succeeds, otherwise it returns 0 and sets errno appropriately - most likely ENAMETOOLONG, i.e. the name in s is not a well-formed domain name.

unsigned int s6dns_domain_tostring (char *s, unsigned int max, s6dns_domain_t const *d)
Writes into string s the domain contained in *d (in string form). Returns the number of bytes written, or 0 in case of failure. If the output would be more than max bytes, 0 ENAMETOOLONG is returned.

int s6dns_domain_noqualify (s6dns_domain_t *d)
Makes sure that *d is fully qualified. This is done without using qualification: a trailing dot is simply appended if the domain doesn't already have one. Returns 1 if it succeeds, or 0 if it fails.

unsigned int s6dns_domain_qualify (s6dns_domain_t *list, s6dns_domain_t const *d, char const *rules, unsigned int rulesnum)
Performs qualification on domain *d according to the first rulesnum rules stored in string rules. Stores the output (at most rulesnum domains) into the array pointed to by list. Returns 0 on failure, or the number of written domains if it succeeds. This number can be lesser than rulesnum, for instance if *d is already fully qualified.
Valid rules and rulesnum can be obtained via functions declared in s6dns-rci.h.

int s6dns_domain_encode (s6dns_domain_t *d)
Encodes domain *d from string form to packet form. Returns 1 if it succeeds or 0 if it fails - for instance, *d is not a valid string form (EINVAL).

unsigned int s6dns_domain_encodelist (s6dns_domain_t *list, unsigned int n)
Encodes n domains pointed to by list from string form to packet form, stopping at the first failure. Returns the number of successfully encoded domains, normally n.

int s6dns_domain_decode (s6dns_domain_t *d)
Decodes domain *d from packet form to string form. Returns 1 if it succeeds or 0 if it fails - for instance, *d is not a valid packet form (EPROTO).

int s6dns_domain_fromstring_noqualify_encode (s6dns_domain_t *d, char const *s, size_t len)
Higher-level function wrapping some of the above. Makes an encoded, fully qualified (without resorting to qualification) domain from string s of length len. Returns 1 if it succeeds and 0 if it fails.

unsigned int s6dns_domain_fromstring_qualify_encode (s6dns_domain_t *list, char const *s, size_t len, char const *rules, unsigned int rulesnum)
Another wrapping function. It makes a list of encoded, fully qualified domains, from string s of length len using rulesnum qualification rules in rules. It writes at most rulesnum domains into the array pointed to by list and returns the number of written domains, or 0 on an error.

void s6dns_domain_arpafromip4 (s6dns_domain_t *d, char const *ip)
Writes into d the in-addr.arpa. domain corresponding to IPv4 address ip (4 bytes, in network byte order), in string form.

void s6dns_domain_arpafromip6 (s6dns_domain_t *d, char const *ip, unsigned int mask)
Writes into d the ip6.arpa. domain corresponding to the first mask bits of IPv6 address ip (16 bytes, in network byte order), in string form. Only multiples of 4 count for mask, i.e. the output will be the same if mask is (for instance) 125, 126, 127 or 128.

s6-dns-2.3.1.1/doc/libs6dns/s6dns-message.html0000644000000000000000000002656313263524252015532 0ustar s6-dns: the s6dns_message library interface

libs6dns
s6-dns
Software
skarnet.org

The s6dns_message library interface

The following functions are declared in the s6-dns/s6dns-message.h header, and implemented in the libs6dns.a or libs6dns.so library.

General information

s6dns_message provides functions to read and parse DNS messages sent by servers and caches and containing answers to queries.

Data structures

A s6dns_message_header_t is a structure containing the header of a received DNS packet, broken down for easy access to the bits.

A s6dns_message_rr_t is a structure containing the information about a resource record given by an answer packet - all of it, except the value of the answer itself, which is rtype-specific and has to be decoded by rtype-specific functions.

A s6dns_message_rr_func_t is the type of such a function. The prototype is
int f (s6dns_message_rr_t const *rr, char const *packet, unsigned int packetlen, unsigned int pos, unsigned int section, void *data)

  • *rr contains the header information of the resource record, including the domain to which it applies, the rtype, and the ttl.
  • packet points to the whole DNS packet the RR is a part of.
  • packetlen is the total length of said packet.
  • pos is the offset of the RR in the DNS packet, i.e. f should start parsing at packet + pos.
  • section is the section the RR belongs to: 2 for answer, 3 for authority, 4 for additional.
  • data is a user-specified pointer; it is typically used to write the decoded output, in a rtype-specific way.
  • f must return 1 or more if it succeeds in decoding the packet. Else it must set errno appropriately, and return -1 if the error is local, unrelated to the packet - for instance, it has run out of memory - or 0 if it cannot decode the RR because of the packet contents.

Various structures designed to store specific resource record types are also provided. The list includes:

  • s6dns_message_rr_hinfo for HINFO RRs
  • s6dns_message_rr_mx for MX RRs
  • s6dns_message_rr_soa for SOA RRs
  • s6dns_message_rr_srv for SRV RRs
  • s6dns_message_rr_caa for CAA RRs

Functions

Header management

void s6dns_message_header_pack (char *s, s6dns_message_header_t const *h)
Packs the header *h into the 12 bytes pointed to by s.

void s6dns_message_header_unpack (char const *s, s6dns_message_header_t *h)
Unpacks the 12 bytes pointed to by s into the structure *h.

Low-level RR decoding

The following primitives are used in the implementation of s6dns_message_rr_func_t-typed functions, to read and decode information stored in a DNS packet. Their arguments are:

  1. A pointer to the structure where the information is going to be stored
  2. A read-only pointer to the beginning of the DNS packet
  3. The length of the DNS packet
  4. A pointer to an integer containing the current position in the DNS packet, i.e. where the information is going to be read. If the functions succeed, they automatically update the position so information can be read sequentially.

int s6dns_message_get_string (s6dns_domain_t *d, char const *packet, unsigned int packetlen, unsigned int *pos)
Reads a character-string and stores it into *d. Returns 1 on success and 0 on failure. Note that *d does not contain a domain, but the s6dns_domain_t structure is adapted to store strings that do not exceed 255 characters. d→s can be used to access the string, and d→len its length.

int s6dns_message_get_strings (char *s, unsigned int rdlength, char const *packet, unsigned int packetlen, unsigned int *pos
This function takes an additional parameter rdlength. It reads a series of character-strings and stores their concatenation into the string s, which must be preallocated; it can never store more than rdlength bytes. It returns -1 if it fails; on success, it returns the number of bytes written. The rdlength parameter must be the length of the resource record containing the series of character-strings.

unsigned int s6dns_message_get_domain (s6dns_domain_t *d, char const *packet, unsigned int packetlen, unsigned int *pos)
Reads a domain and stores it, in string form, into *d. Returns 1 on success and 0 on failure, and sets errno:

  • EPROTO: there is no proper domain to be read in position *pos of packet. Either the packet is malformed or the function is being misused.
  • EPROTONOSUPPORT: the domain encoding uses an extension that the function does not recognize.

int s6dns_message_get_hinfo (s6dns_message_rr_hinfo_t *p, char const *packet, unsigned int packetlen, unsigned int *pos)
Reads a HINFO RR and stores it into *p. Returns 1 on success or 0 on failure.

int s6dns_message_get_mx (s6dns_message_rr_mx_t *p, char const *packet, unsigned int packetlen, unsigned int *pos)
Reads a MX RR and stores it into *p. Returns 1 on success or 0 on failure.

int s6dns_message_get_soa (s6dns_message_rr_soa_t *p, char const *packet, unsigned int packetlen, unsigned int *pos)
Reads a SOA RR and stores it into *p. Returns 1 on success or 0 on failure.

int s6dns_message_get_srv (s6dns_message_rr_srv_t *p, char const *packet, unsigned int packetlen, unsigned int *pos)
Reads a SRV RR and stores it into *p. Returns 1 on success or 0 on failure.

int s6dns_message_get_caa (s6dns_message_rr_caa_t *p, char const *packet, unsigned int packetlen, unsigned int *pos, uint16_t rdlength)
Reads a CAA RR and stores it into *p. Returns 1 on success or 0 on failure. rdlength is the length of the RDATA field of the record; this value is needed to properly parse a CAA record.

High-level RR-specific parsing functions

s6dns_message_func_t s6dns_message_parse_answer_strings
Parses character-strings located in the answer section of the packet. The data argument is interpreted as a pointer to a s6dns_mpag_t, which is a structure defined in the s6-dns/s6dns-message.h header and used to store multiple character-strings.

s6dns_message_func_t s6dns_message_parse_answer_domain
Parses domains located in the answer section of the packet. The data argument is interpreted as a pointer to a s6dns_dpag_t, which is a structure defined in the s6-dns/s6dns-message.h header and used to store multiple domains.

s6dns_message_func_t s6dns_message_parse_answer_a
Parses A RRs located in the answer section of the packet. The data argument is interpreted as a pointer to a stralloc, and 4 bytes are appended to this stralloc for every IPv4 address found.

s6dns_message_func_t s6dns_message_parse_answer_aaaa
Parses AAAA RRs located in the answer section of the packet. The data argument is interpreted as a pointer to a stralloc, and 16 bytes are appended to this stralloc for every IPv6 address found.

s6dns_message_func_t s6dns_message_parse_answer_hinfo
Parses HINFO RRs located in the answer section of the packet. The data argument is interpreted as a pointer to a genalloc containing s6dns_message_rr_hinfo_t structures.

s6dns_message_func_t s6dns_message_parse_answer_mx
Parses MX RRs located in the answer section of the packet. The data argument is interpreted as a pointer to a genalloc containing s6dns_message_rr_mx_t structures.

s6dns_message_func_t s6dns_message_parse_answer_soa
Parses SOA RRs located in the answer section of the packet. The data argument is interpreted as a pointer to a genalloc containing s6dns_message_rr_soa_t structures.

s6dns_message_func_t s6dns_message_parse_answer_srv
Parses SRV RRs located in the answer section of the packet. The data argument is interpreted as a pointer to a genalloc containing s6dns_message_rr_srv_t structures.

s6dns_message_func_t s6dns_message_parse_answer_caa
Parses CAA RRs located in the answer section of the packet. The data argument is interpreted as a pointer to a genalloc containing s6dns_message_rr_caa_t structures.

High-level packet parsing

int s6dns_message_parse (s6dns_message_header_t *h, char const *packet, unsigned int packetlen, s6dns_message_rr_func_t *f, void *data)
This function parses the DNS packet packet of length packetlen. It stores the packet header into *h. Then, for every RR in the answer, authority or additional section of the packet, it calls f with the relevant parameters. data is the extra pointer given to f to store information. The function returns 1 if the parsing succeeds. Otherwise it returns -1 if there is a local error unrelated to the packet, or 0 if no appropriate answer can be decoded from the packet. errno then contains one of the following values:

  • EPROTO: the packet is malformed, syntax error
  • EBADMSG: rcode 1, query format error
  • EBUSY: rcode 2, server failure
  • ENOENT: rcode 3, nxdomain
  • ENOTSUP: rcode 4, query type not implemented
  • ECONNREFUSED: rcode 5, operation refused by server
  • EIO: unknown rcode
  • any other value being set by f if it returns a failure code.
s6-dns-2.3.1.1/doc/libs6dns/s6dns-fmt.html0000644000000000000000000001075013263523776014675 0ustar s6-dns: the s6dns_fmt library interface

libs6dns
s6-dns
Software
skarnet.org

The s6dns_fmt library interface

The following functions and structures are declared in the s6-dns/s6dns-fmt.h header, and implemented in the libs6dns.a or libs6dns.so library.

General information

s6dns_fmt provides primitives to format RR contents into printable strings.

Functions

size_t s6dns_fmt_domain (char *s, size_t max, s6dns_domain_t const *d)
Writes into string s the domain contained in *d (in string form). Returns the number of bytes written, or 0 in case of failure. If the output would be more than max bytes, 0 ENAMETOOLONG is returned. To avoid that, S6DNS_FMT_DOMAIN is a suitable number of bytes to preallocate s. This function is actually an alias to s6dns_domain_tostring.

size_t s6dns_fmt_domainlist (char *s, size_t max, s6dns_domain_t const *list, unsigned int n, char const *delim, size_t delimlen)
Writes into string s the list of n domains (in string form) pointed to by list. Between each domain (and not after the last one), string delim of length delimlen is appended. The function returns the number of bytes written, or 0 in case of failure. If the output would be more than max bytes, 0 ENAMETOOLONG is returned. To avoid that, S6DNS_FMT_DOMAINLIST(n) is a suitable number of bytes to preallocate s.

size_t s6dns_fmt_hinfo (char *s, size_t max, s6dns_message_rr_hinfo_t const *p)
Writes into string s the HINFO contained in *p: cpu, then os, separated by a space. Returns the number of bytes written, or 0 in case of failure. If the output would be more than max bytes, 0 ENAMETOOLONG is returned. To avoid that, S6DNS_FMT_HINFO is a suitable number of bytes to preallocate s.

size_t s6dns_fmt_mx (char *s, size_t max, s6dns_message_rr_mx_t const *p)
Writes into string s the MX contained in *p: preference, then exchanger name, separated by a space. Returns the number of bytes written, or 0 in case of failure. If the output would be more than max bytes, 0 ENAMETOOLONG is returned. To avoid that, S6DNS_FMT_MX is a suitable number of bytes to preallocate s.

size_t s6dns_fmt_soa (char *s, size_t max, s6dns_message_rr_soa_t const *p)
Writes into string s the SOA contained in *p: mname, then rname, then serial number, refresh time, retry time, expiration time and minimum time, separated by spaces. Returns the number of bytes written, or 0 in case of failure. If the output would be more than max bytes, 0 ENAMETOOLONG is returned. To avoid that, S6DNS_FMT_SOA is a suitable number of bytes to preallocate s.

size_t s6dns_fmt_srv (char *s, size_t max, s6dns_message_rr_srv_t const *p)
Writes into string s the SRV contained in *p: priority, then weight, then port, then target, separated by spaces. Returns the number of bytes written, or 0 in case of failure. If the output would be more than max bytes, 0 ENAMETOOLONG is returned. To avoid that, S6DNS_FMT_SRV is a suitable number of bytes to preallocate s.

size_t s6dns_fmt_caa (char *s, size_t max, s6dns_message_rr_caa_t const *p)
Writes into string s the CAA contained in *p: flags, then tag, then value, separated by spaces. Returns the number of bytes written, or 0 in case of failure. If the output would be more than max bytes, 0 ENAMETOOLONG is returned. To avoid that, S6DNS_FMT_CAA is a suitable number of bytes to preallocate s.

s6-dns-2.3.1.1/doc/libs6dns/s6dns-ip46.html0000644000000000000000000000452513111013151014641 0ustar s6-dns: the s6dns_ip46 library interface

libs6dns
s6-dns
Software
skarnet.org

The s6dns_ip46 library interface

The following functions are declared in the s6-dns/s6dns-ip46.h header, and implemented as macros.

General information

s6dns_ip46 is the transport abstraction layer. It allows the functions declared in s6-dns/s6dns-engine.h and s6-dns/s6dns-rci.h to be transport-agnostic, i.e. to be able to work with both IPv4 and IPv6.

If the underlying skalibs has been compiled with the --disable-ipv6 configure option, or if it has detected at build time that the target host does not support IPv6, then the s6dns-ip46 abstraction will be totally transparent and use no resources at all.

Data structures

A s6dns_ip46list_t structure holds a list of S6DNS_MAX_SERVERS (16) IPv4 or IPv6 addresses. Such a mixed list can be constructed, for instance, if the /etc/resolv.conf file contains both v4 and v6 nameserver lines.

Functions

If list is a s6dns_ip46list_t and i an integer between 0 and DNS_MAX_SERVERS-1, then

  • s6dns_ip46list_is6(&list, i) is 1 if the ith address in list is IPv6 and 0 if it is IPv4.
  • s6dns_ip46list_ip(&list, i) is a char * pointer to 16 (if IPv6) or 4 (IPv4) bytes representing the ith address in list, in network byte order.
s6-dns-2.3.1.1/doc/libs6dns/s6dns-engine.html0000644000000000000000000002101313111013151015313 0ustar s6-dns: the s6dns_engine library interface

libs6dns
s6-dns
Software
skarnet.org

The s6dns_engine library interface

The following functions are declared in the s6-dns/s6dns-engine.h header, and implemented in the libs6dns.a or libs6dns.so library.

General information

s6dns_engine is the nitty-gritty of DNS query management. These are the low-level asynchronous primitives sending DNS queries over the network, and getting answers.

s6dns_engine has been inspired by Dan J. Bernstein's dns_transmit library, but does not borrow any code from it. Unlike dns_transmit, s6dns_engine does not assume that network send operations are instant successes; s6dns_engine descriptors can be selected for writing as well as for reading. Also, if the underlying skalibs has been compiled with IPv6 support, s6dns_engine supports native IPv6 transport.

The s6dns_engine functions are used in the implementation of the s6dns_resolven_loop function - which is nothing more than a simple event loop around the s6dns_engine primitives - and the skadnsd daemon. Both pieces of code are good examples of how to use s6dns_engine.

However, unless you're implementing a DNS cache, you probably should not call the s6dns_engine functions directly: they are very low-level. If you need synchronous resolution, use the s6dns_resolve functions. If you need asynchronous DNS operations, use the skadns functions, which are designed to provide a higher level interface to multiple asynchronous DNS queries.

Data structures

A s6dns_engine_t structure holds all the data necessary to manage a DNS query (and response). It must be initialized to S6DNS_ENGINE_ZERO when first declared, and recycled with s6dns_engine_recycle() after each use. It contains a stralloc, so it must be freed with s6dns_engine_free() before being discarded, to avoid memory leaks.

Functions

s6dns_engine_t life cycle

int s6dns_engine_init (s6dns_engine_t *dt, s6dns_ip46list_t const *servers, uint32_t options, char const *q, unsigned int qlen, uint16_t qtype, tain_t const *deadline, tain_t const *stamp)

Initializes dt with query q of length qlen and type qtype. If d is an encoded s6dns_domain_t, then d.s and d.len are appropriate candidates for arguments q and qlen respectively.

options can be 0 or an OR'ed combination of the following, defined in s6-dns/s6dns-constants.h:

  • S6DNS_O_RECURSIVE: the query will be recursive and assuming it is sent to a DNS cache, instead of iterative and assuming it is sent to a DNS server.
  • S6DNS_O_STRICT: the library will only accept authoritative answers to iterative queries. This is normally the sane behaviour, but badly configured DNS software around the world - notably, BIND when it's configured to be both a cache and a server - often serve non-authoritative data even when they could, so it breaks things, hence why the option isn't set by default.

servers must point to a list of IP addresses as defined in s6-dns/s6dns-ip46.h. Such a list can be obtained from the /etc/resolv.conf file via the s6dns_rci_fill() call when performing a recursive query, or it must be constructed from a list of relevant NS addresses when performing an iterative query.

stamp must be an accurate enough timestamp. deadline sets up a deadline for the query: if the query hasn't been satisfactorily answered by deadline - no matter how many round-trips to network servers the library performs internally - then it will be considered failed, and a timeout will be reported.

The function returns 1 if all went well, and 0 if an error occurred. It returns instantly; it does not perform any network operation, it just prepares dt to send a query. The actual data sending will take place on the next s6dns_engine_event() call.

void s6dns_engine_recycle (s6dns_engine_t *dt)

Recycles dt, making it ready for another use. This function does not deallocate the heap memory used by dt, so it's faster than s6dns_engine_free() and does not cause heap fragmentation.

void s6dns_engine_free (s6dns_engine_t *dt)

Frees the heap memory used by dt. Also makes dt ready for another use. It's advised to only use this function when certain that dt will not be reused.

Before the iopause()

The descriptor to select on is available as the fd field in the s6dns_engine_t structure. dt→fd should be read every iteration, because it can change between iterations even if no event or timeout is reported for dt.

void s6dns_engine_nextdeadline (s6dns_engine_t const *dt, tain_t *a)

If dt needs handling before the absolute date *a, then *a is updated so it contains the earlier date. This is useful to compute the next deadline in an iopause() loop.

int s6dns_engine_isreadable (s6dns_engine_t const *dt)

Returns nonzero iff dt→fd is to be selected for reading. Should be called in every iteration.

int s6dns_engine_iswritable (s6dns_engine_t const *dt)

Returns nonzero iff dt→fd is to be selected for writing. Should be called in every iteration.

After the iopause()

int s6dns_engine_timeout (s6dns_engine_t *dt, tain_t const *stamp)

This function should be called if your selecting function returned 0, which means that an event timed out. stamp should contain the current time. The function returns -1 if an error occurred, 1 if dt actually timed out, and 0 if nothing special happened to dt (and your iopause timeout was caused by something else). If the return value is not 0, dt is automatically recycled.

int s6dns_engine_event (s6dns_engine_t *dt, tain_t const *stamp)

This function should be called if your selecting function returned a positive number, which means that some event got triggered. stamp should contain the current time. The function returns -1 if an error occurred (and dt is automatically recycled). It returns 0 if no answer has arrived yet, and 1 if an answer is available.

The s6dns_engine_timeout() and s6dns_engine_event() functions, when returning -1, make use of the following error codes:

  • EINVAL: Invalid dt.
  • ENETUNREACH: All the servers in the servers list have been unsuccessfully tried.
  • EPROTO: An answer arrived, but it didn't follow the DNS protocol.
  • Other error codes reporting socket or system failures.

char *s6dns_engine_packet (s6dns_engine_t const *dt)

Points to the response packet received from the network, if s6dns_engine_event() returned 1.

unsigned int s6dns_engine_packetlen (s6dns_engine_t const *dt)

Gives the length of the response packet, if s6dns_engine_event() returned 1.

You should recycle or free dt after reading the response packet.

s6-dns-2.3.1.1/doc/libs6dns/s6dns-rci.html0000644000000000000000000000721213111013151014630 0ustar s6-dns: the s6dns_rci library interface

libs6dns
s6-dns
Software
skarnet.org

The s6dns_rci library interface

The following functions and structures are declared in the s6-dns/s6dns-rci.h header, and implemented in the libs6dns.a or libs6dns.so library.

General information

s6dns_rci provides functions to get information from the /etc/resolv.conf file.

Data structures

A s6dns_rci_t is a structure storing information provided by the /etc/resolv.conf file, i.e.

  • The list of "nameserver" addresses, i.e. IP addresses of DNS caches contacted by clients for recursive queries
  • The list of qualification rules provided by "domain" or "search" lines

Nameserver addresses are stored in a s6dns_ip46list_t. Qualification rules are stored in a stralloc with an additional integer storing the number of rules.

Most programs won't need more than one s6dns_rci_t, so the library provides the global variable s6dns_rci_here, used by default in simple resolution macros.

Functions

int s6dns_rci_init (s6dns_rci_t *rci, char const *file)
Extracts information from file, which must be in /etc/resolv.conf format, and stores it into *rci. rci must be previously initialized to the S6DNS_RCI_ZERO constant. The function returns 1 if it succeeds, or 0 (and sets errno) if it fails.

If the DNSCACHEIP environment variable is set, and contains a list of IP addresses separated by commas, semicolons, spaces, tabs, newlines or carriage returns, then this list overrides any nameserver information from file. If the variable is empty, file will be used as the source of the information.

If the DNSQUALIFY environment variable is set, a list of domain suffixes, separated by spaces, tabs, newlines or carriage returns, is read from it, and overrides any qualification information from file. If the variable is empty, it amounts to one rule saying "no qualification".

s6dns_init() is an alias to s6dns_rci_init(&s6dns_rci_here, "/etc/resolv.conf").

void s6dns_rci_free (s6dns_rci_t *rci)
Frees the memory used by *rci. rci is then suitable to be reused in a s6dns_rci_init call.

s6dns_finish() calls s6dns_rci_free(&s6dns_rci_here).

unsigned int s6dns_qualify (s6dns_domain_t *list, s6dns_domain_t const *d)
Qualifies domain *d into the list of domains pointed to by list according to the rules stored in s6dns_rci_here. Returns the number of written domains (0 if it fails); this number cannot exceed s6dns_rci_here.rulesnum.

s6-dns-2.3.1.1/doc/libs6dns/s6dns-resolve.html0000644000000000000000000004347213263524352015564 0ustar s6-dns: the s6dns_resolve library interface

libs6dns
s6-dns
Software
skarnet.org

The s6dns_resolve library interface

The following functions are declared in the s6-dns/s6dns-resolve.h header, and implemented in the libs6dns.a or libs6dns.so library.

General information

s6dns_resolve provides functions and macros - mostly macros - to perform high level synchronous DNS resolution.

All the functions declared here make synchronous calls to the network, so they can block for a non-negligible amount of time. To avoid unbounded waiting times, they always take 2 arguments at the end, deadline and stamp. deadline is the read-only address of a tain_t containing an absolute time which is the deadline for the function, and stamp is the read-write address of a tain_t being an accurate enough representation of the current absolute time. If the function has not returned by *deadline, then it immediately returns with a failure code and errno set to ETIMEDOUT. In every case, *stamp is automatically updated so it always represents the absolute time accurately enough.

In a single-threaded program, the STAMP global variable can be used to store the current time. Macros ending with _g use this variable automatically so you don't have to provide the stamp argument everytime. Additionally, several resolution functions make implicit use of global variables such as:

  • s6dns_engine_here: a global s6dns_engine_t storing the current query, for sequential queries.
  • s6dns_debughook_zero: a global s6dns_debughook_t meaning no debugging is needed.
  • s6dns_rci_here: a global s6dns_rci_t containing the current resolv.conf information.

Reentrant, non-global-using functions are also provided, with the _r suffix. In other words, if foobarfunc is a resolution function, the following prototypes are generally provided, from the simplest to the most complex:

  • foobarfunc_g: only the relevant parameters and a deadline must be given, the function uses the STAMP global and maybe DNS-specific globals
  • foobarfunc: a deadline and stamp must be given, the function uses all the DNS-specific globals
  • foobarfunc_r_g: No DNS-specific globals are used, the information must be given via parameters, but the STAMP global is used
  • foobarfunc_r: fully reentrant function using no globals at all

For each set of four functions, only one is documented here. The other prototypes can be found in the s6-dns/s6dns-resolve.h file.

Some errno codes reported by these functions do not have exactly the system meaning given by strerror(). To get a user-friendly error message, use s6dns_constants_error_str(errno) instead. The s6dns_constants_error_str function is declared in the s6dns-constants.h header.

Functions

Single query resolution

These functions are ordered from the lowest level to the highest level.

Basic wrapper around s6dns_engine

int s6dns_resolve_loop_r_g (s6dns_engine_t *dt, tain_t const *deadline)
Resolves the query stored in dt. Returns 1 on success or 0 on failure.

Generic resolution functions

int s6dns_resolve_core_g (s6dns_domain_t const *d, uint16_t qtype, tain_t const *deadline)
Resolves the query on domain *d (in packet form), of type qtype. Returns 0 on failure, or 1 on success, in which case s6dns_engine_here contains the answer.

int s6dns_resolve_parse_g (s6dns_domain_t const *d, uint16_t qtype, s6dns_message_rr_func_t *f, void *data, tain_t const *deadline)
Resolves the query on domain *d (in packet form), of type qtype, then parses the answer with function f and stores the result into data. Returns 1 if it succeeds, 0 if no data can be extracted from the answer, or -1 if an error occurs. Sets errno in the last two cases.

Note that the function can return 1 without appending anything to data. This means that the servers confirmed that the domain exists, but f has not been able to find any data relevant to the query in the answer. This is very different from NXDOMAIN, which means that the servers deny the actual existence of the domain, and which is reported here as a return code of 0 with errno set to ENOENT.

int s6dns_resolvenoq_g (char const *name, size_t len, uint16_t qtype, s6dns_message_rr_func_t *f, void *data, tain_t const *deadline)
Performs a query of type qtype on name name of length len, without qualifying it. Parses the answer with function f and stores the result into data. Returns 1 if it succeeds, 0 if no data can be extracted, or -1 if an error occurs. Sets errno in the last two cases.

int s6dns_resolveq_g (char const *name, size_t len, uint16_t qtype, s6dns_message_rr_func_t *f, void *data, tain_t const *deadline)
Performs a query of type qtype on name name of length len, qualifying it first. Parses the answer with function f and stores the result into data. Returns 1 if it succeeds, 0 if none of the FQDNs can get a positive answer, or -1 if an error occurs. Sets errno in the last two cases.

int s6dns_resolve_g (char const *name, size_t len, uint16_t qtype, s6dns_message_rr_func_t *f, void *data, int qualif, tain_t const *deadline)
Performs a query of type qtype on name name of length len. Qualifies name first if qualif is nonzero; else, does not qualify it. Parses the answer with function f and stores the result into data. Returns 1 if it succeeds, 0 if none of the FQDNs can get a positive answer, or -1 if an error occurs. Sets errno in the last two cases.

High-level type-specific functions

int s6dns_resolve_a_g (stralloc *ips, char const *name, size_t len, int qualif, tain_t const *deadline)
Performs an A query on name name of length len, qualifying it iff qualif is nonzero. Returns -1 if an error occurs, or 0 if no answer can be obtained from servers, or 1 if it succeeds, in which case the IPs are appended to the stralloc *ips, using 4 bytes per answer.

int s6dns_resolve_aaaa_g (stralloc *ips, char const *name, size_t len, int qualif, tain_t const *deadline)
Performs an AAAA query on name name of length len, qualifying it iff qualif is nonzero. Returns -1 if an error occurs, or 0 if no answer can be obtained from servers, or 1 if it succeeds, in which case the IPs are appended to the stralloc *ips, using 16 bytes per answer.

int s6dns_resolve_aaaaa_g (genalloc *ips, char const *name, size_t len, int qualif, tain_t const *deadline)
Performs an AAAA query and an A query at the same time on name name of length len, qualifying it first iff qualif is nonzero. Returns -1 if an error occurs, or 0 if no answer can be obtained from servers, or a positive number if it succeeds: 1 if IPv4 addresses were found, 2 if IPv6 addresses were found, and 3 if both were found. The IPs are appended to the genalloc *ips, which contains an array of ip46_t, the skalibs structure used to store IPv4 and IPv6 addresses indiscriminately.

int s6dns_resolve_ptr_g (genalloc *ds, char const *name, size_t len, int qualif, tain_t const *deadline)
Performs a PTR query on name name of length len, qualifying it iff qualif is nonzero. Returns -1 if an error occurs, or 0 if no answer can be obtained from servers, or 1 if it succeeds, in which case the domains are appended to the genalloc *ds, which contains an array of s6dns_domain_t.

int s6dns_resolve_name4_g (genalloc *ds, char const *ip, tain_t const *deadline)
Performs a PTR query on the in-addr.arpa. name representing the IPv4 address ip (4 network-order bytes). Returns -1 if an error occurs, or 0 if no answer can be obtained from servers, or 1 if it succeeds, in which case the domains are appended to the genalloc *ds, which contains an array of s6dns_domain_t.

int s6dns_resolve_name6_g (genalloc *ds, char const *ip, tain_t const *deadline)
Performs a PTR query on the ip6.arpa. name representing the IPv6 address ip (16 network-order bytes). Returns -1 if an error occurs, or 0 if no answer can be obtained from servers, or 1 if it succeeds, in which case the domains are appended to the genalloc *ds, which contains an array of s6dns_domain_t.

int s6dns_resolve_name46_g (genalloc *ds, ip46_t const *ip, tain_t const *deadline)
Calls s6dns_resolve_name6_g() or s6dns_resolve_name4_g() depending on which ip is an IPv6 or IPv4 address.

int s6dns_resolve_ns_g (genalloc *ds, char const *name, size_t len, int qualif, tain_t const *deadline)
Performs a NS query on name name of length len, qualifying it iff qualif is nonzero. Returns -1 if an error occurs, or 0 if no answer can be obtained from servers, or 1 if it succeeds, in which case the domains are appended to the genalloc *ds, which contains an array of s6dns_domain_t.

int s6dns_resolve_cname_g (genalloc *ds, char const *name, size_t len, int qualif, tain_t const *deadline)
Performs a CNAME query on name name of length len, qualifying it iff qualif is nonzero. Returns -1 if an error occurs, or 0 if no answer can be obtained from servers, or 1 if it succeeds, in which case the domains are appended to the genalloc *ds, which contains an array of s6dns_domain_t.

int s6dns_resolve_hinfo_g (genalloc *hinfos, char const *name, size_t len, int qualif, tain_t const *deadline)
Performs an HINFO query on name name of length len, qualifying it iff qualif is nonzero. Returns -1 if an error occurs, or 0 if no answer can be obtained from servers, or 1 if it succeeds, in which case the domains are appended to the genalloc *hinfos, which contains an array of s6dns_message_rr_hinfo_t.

int s6dns_resolve_mx_g (genalloc *mxs, char const *name, size_t len, int qualif, tain_t const *deadline)
Performs an MX query on name name of length len, qualifying it iff qualif is nonzero. Returns -1 if an error occurs, or 0 if no answer can be obtained from servers, or 1 if it succeeds, in which case the domains are appended to the genalloc *mxs, which contains an array of s6dns_message_rr_mx_t.

int s6dns_resolve_soa_g (genalloc *soas, char const *name, size_t len, int qualif, tain_t const *deadline)
Performs an SOA query on name name of length len, qualifying it iff qualif is nonzero. Returns -1 if an error occurs, or 0 if no answer can be obtained from servers, or 1 if it succeeds, in which case the domains are appended to the genalloc *soas, which contains an array of s6dns_message_rr_soa_t.

int s6dns_resolve_srv_g (genalloc *srvs, char const *name, size_t len, int qualif, tain_t const *deadline)
Performs an SRV query on name name of length len, qualifying it iff qualif is nonzero. Returns -1 if an error occurs, or 0 if no answer can be obtained from servers, or 1 if it succeeds, in which case the domains are appended to the genalloc *srvs, which contains an array of s6dns_message_rr_srv_t.

int s6dns_resolve_caa_g (genalloc *caas, char const *name, size_t len, int qualif, tain_t const *deadline)
Performs a CAA query on name name of length len, qualifying it iff qualif is nonzero. Returns -1 if an error occurs, or 0 if no answer can be obtained from servers, or 1 if it succeeds, in which case the domains are appended to the genalloc *caas, which contains an array of s6dns_message_rr_caa_t.

int s6dns_resolve_txt_g (stralloc *sa, genalloc *offsets, char const *name, unsigned int len, int qualif, tain_t const *deadline)
Performs an TXT query on name name of length len, qualifying it iff qualif is nonzero. Returns -1 if an error occurs, or 0 if no answer can be obtained from servers, or 1 if it succeeds, in which case:

  • The resulting strings are all stored into stralloc *sa. Every string is terminated by a null character.
  • A series of unsigned ints is appended to genalloc *offsets. Every integer represents the offset in *sa at which a string is stored. The number of appended integers is the total number of answers.

Parallel resolution

int s6dns_resolven_loop_g (s6dns_engine_t *dtl, unsigned int n, unsigned int or, tain_t const *deadline)
Resolves the n queries stored in the array pointed to by dtl, in parallel. If or is zero, it does not return before all answers have arrived. If or is 1, it returns when an answer arrives, but does not return if a query generates an error (unless all queries do so). If or is 2, it returns when an answer arrives or an error occurs. Other values of or are unspecified yet.

The return code is as follows:

  • If or is 0: -1 on a global error (i.e. not specific to a query), or a non-negative number which is the total of successful queries.
  • If or is 1 or 2: -1 on a global error, or a non-negative number which is the index of the query that triggered the event.

If or is 1, a return code of -1 with errno set to ENOENT means that all the queries failed.

After the function returns, the status field of each s6dns_engine_t contains the error code relative to the query. A status of 0 means that an answer has properly arrived; EAGAIN means that the query is still pending (and the s6dns_engine_t has not been recycled); ECONNABORTED means that the query has not been properly initialized. Other codes report various network problems.

int s6dns_resolven_parse_g (s6dns_resolve_t const *list, unsigned int n, tain_t const *deadline)
Performs n complete resolutions in parallel, parsing the results. Returns 1 in case of success or 0 if a global error occurred.

list is a pointer to an array of n s6dns_resolve_t, which is a structure containing at least the following fields:

  • q : a s6dns_domain_t containing the query. It must be in encoded form.
  • qtype : a uint16 containing the query type. A list of valid query types can be found in the s6dns-constants.h header.
  • options : a uint32 containing options passed to s6dns_engine_init().
  • deadline : a tain_t containing the deadline for this query, i.e. the query will fail with an ETIMEDOUT code if no answer has arrived by then. Note that the deadline argument given to s6dns_resolven_parse() is a global deadline that can make the function return with 0 ETIMEDOUT, but is independent from this field, which is local to every query.
  • parsefunc : a s6dns_message_rr_func_t function that will be used to parse the answer.
  • data : a void * that will be passed as an additional pointer to the parsefunc function; it is generally used to store the parsing result.
  • status : an int. It does not need to be initialized. It will contain the error code for the query after the function returns. ECONNABORTED means that the query could not be started at all; EAGAIN means that the query was still pending when an error happened; other codes report various network problems.

The s6dns_resolven_parse() function is a simple, convenient way to perform several resolutions in parallel to avoid the waiting time incurred by serial resolutions. However, it is still a synchronous function, and cannot replace a real asynchronous DNS library: for more complex parallel resolution needs, use the skadns library.

s6-dns-2.3.1.1/doc/s6-dnssrv.html0000644000000000000000000000517313111013151013145 0ustar s6-dns: the s6-dnssrv program

s6-dns
Software
skarnet.org

The s6-dnssrv program

s6-dnssrv finds the SRV information associated to a service name, protocol name and domain name.

Interface 

     s6-dnssrv [ -q ] [ -r ] [ -t timeout ] service proto domain
  • s6-dnssrv makes an SRV query for _service._proto.domain. It waits for the result and prints the obtained information line by line, then exits 0. It prints the priority, the weight, the port number and the target, in that order, separated by spaces.
  • If the domain exists but no relevant field has been found, it exits 1.
  • If the DNS answered but no answer is available, it prints a relevant error message and exits 2.
  • By default, s6-dnssrv looks for DNS cache addresses in the /etc/resolv.conf file. If the DNSCACHEIP environment variable is set and contains a list of IP (v4 or v6) addresses, separated by commas, semicolons, spaces, tabs, newlines or carriage returns, then this list is used instead.

Options

  • -q : qualify. Qualifies domain before resolution, according to suffixes found in /etc/resolv.conf. If the DNSQUALIFY environment variable is set and contains a list of suffixes separated by spaces, tabs, newlines or carriage returns, then this list is used instead. By default, no qualification is used: if domain is not a FQDN, a dot is just appended to it.
  • -r : random. By default, the program does not sort the result, but prints them in the order received from the DNS. With this option, it performs a random permutation on the results before printing them.
  • -t timeout : if the resolution takes more than timeout milliseconds, then it exits 99 right away with an error message. By default, timeout is 0, which means no timeout.
s6-dns-2.3.1.1/doc/s6-dnsns.html0000644000000000000000000000467513111013151012761 0ustar s6-dns: the s6-dnsns program

s6-dns
Software
skarnet.org

The s6-dnsns program

s6-dnsns finds the relevant nameservers providing data for a domain.

Interface 

     s6-dnsns [ -q ] [ -r ] [ -t timeout ] domain
  • s6-dnsns makes an NS query for the name domain. It waits for the result and prints the obtained information, one name per line, then exits 0.
  • If the domain exists but no relevant field has been found, it exits 1.
  • If the DNS answered but no answer is available, it prints a relevant error message and exits 2.
  • By default, s6-dnsns looks for DNS cache addresses in the /etc/resolv.conf file. If the DNSCACHEIP environment variable is set and contains a list of IP (v4 or v6) addresses, separated by commas, semicolons, spaces, tabs, newlines or carriage returns, then this list is used instead.

Options

  • -q : qualify. Qualifies domain before resolution, according to suffixes found in /etc/resolv.conf. If the DNSQUALIFY environment variable is set and contains a list of suffixes separated by spaces, tabs, newlines or carriage returns, then this list is used instead. By default, no qualification is used: if domain is not a FQDN, a dot is just appended to it.
  • -r : random. By default, the program does not sort the result, but prints them in the order received from the DNS. With this option, it performs a random permutation on the results before printing them.
  • -t timeout : if the resolution takes more than timeout milliseconds, then it exits 99 right away with an error message. By default, timeout is 0, which means no timeout.
s6-dns-2.3.1.1/doc/index.html0000644000000000000000000001210713553354744012434 0ustar s6-dns - a complete DNS client suite

Software
skarnet.org

s6-dns

What is it ?

s6-dns is a suite of DNS client programs and libraries for Unix systems, as an alternative to the BIND, djbdns or other DNS clients.

s6-dns may include its own series of DNS caches and servers at some point in the future.

Installation

Requirements

  • A POSIX-compliant system with a standard C development environment
  • GNU make, version 3.81 or later
  • skalibs version 2.9.1.0 or later

Licensing

s6-dns is free software. It is available under the ISC license.

Download

  • The current released version of s6-dns is 2.3.1.1.
  • Alternatively, you can checkout a copy of the s6-dns git repository: 
     git clone git://git.skarnet.org/s6-dns
  • There's also a GitHub mirror of the s6-dns git repository.

Compilation

  • See the enclosed INSTALL file for installation details.

Upgrade notes

  • This page lists the differences to be aware of between the previous versions of s6-dns and the current one.

Reference

Commands

All these commands exit 111 if they encounter a temporary error or hardware error, and 100 if they encounter a permanent error - such as a misuse. Short-lived commands exit 0 on success. Other exit codes are documented in the relevant page.

Command-line DNS clients programs

Filtering tools

Command-line qualification

DNS analysis and debug tools

Miscellaneous utilities

Libraries

Protocol implementation and synchronous resolution

Asynchronous resolution

Related resources

s6-dns discussion

Similar work

  • BIND is the most widely used DNS software suite on the Internet. It's also arguably the most buggy, convoluted and impossible to understand.
  • djbdns is DJB's DNS suite. It works very well, but is unfortunately unmaintained by the author. s6-dns follows the same design principles.
s6-dns-2.3.1.1/doc/s6-dnsqualify.html0000644000000000000000000000240713111013151014002 0ustar s6-dns: the s6-dnsqualify program

s6-dns
Software
skarnet.org

The s6-dnsqualify program

s6-dnsqualify qualifies a domain name.

Interface 

     s6-dnsqualify domain
  • s6-dnsqualify qualifies domain according to the "domain" and "search" rules in /etc/resolv.conf. It prints the result on stdout, one FQDN per line.
  • If the DNSQUALIFY environment variable is set and contains a list of suffixes separated by spaces, tabs, newlines or carriage returns, then this list is used instead of the /etc/resolv.conf rules.
s6-dns-2.3.1.1/doc/skadns/0000755000000000000000000000000013111013151011667 5ustar s6-dns-2.3.1.1/doc/skadns/index.html0000644000000000000000000002007413151114151013675 0ustar s6-dns: the skadns library interface

s6-dns
Software
skarnet.org

The skadns library interface

The skadns library provides an API for asynchronous DNS resolution.

Compiling

  • Make sure the s6-dns headers, as well as the skalibs headers, are visible in your header search path.
  • Use #include <s6-dns/skadns.h>
  • You might also want to include the s6-dns/s6dns.h header for the definition of the s6dns_domain_t type and the various qtype constants.

Linking

  • Make sure the s6 libraries, as well as the skalibs libraries, are visible in your library search path.
  • Link against -lskadns and -lskarnet.
  • If you're using a skadnsd service, also add `cat $sysdeps/socket.lib` to the end of your linking command line, $sysdeps standing for your skalibs sysdeps directory.

Programming

Check the s6-dns/skadns.h header for the exact function prototypes.

Make sure your application is not disturbed by children it doesn't know it has. This means paying some attention to the SIGCHLD handler, if any, and to the way you perform waitpid()s. The best practice is to use a self-pipe to handle SIGCHLD (as well as other signals the application needs to trap), and to always use wait_nohang() to reap children, simply ignoring pids you don't know.

If your (badly programmed) application has trouble handling unknown children, consider using a skadnsd service.

A programming example

The src/clients/s6dns_generic_filter_main.c file in the s6-dns package, used in the s6-dns*-filter programs, illustrates how to use the skadns library.

Starting and ending a session 

skadns_t a = SKADNS_ZERO ;
tain_t deadline, stamp ;

tain_now(&stamp) ;
tain_addsec(&deadline, &stamp, 2)

// char const *path = SKADNS_IPCPATH ;
// skadns_start(&a, path, &deadline, &stamp) ;
skadns_startf(&a, &deadline, &stamp) ;

skadns_start starts a session with a skadnsd service, listening on path.
skadns_startf starts a session with a skadnsd process as a child (which is the simplest usage).
a is a skadns_t structure that must be declared and initialized to SKADNS_ZERO. stamp must be an accurate enough timestamp.
If the session initialization fails, the function returns 0 and errno is set; else the function returns 1.

If the absolute time deadline is reached and the function has not returned yet, it immediately returns 0 with errno set to ETIMEDOUT. Only local interprocess communications are involved; unless your system is heavily overloaded, the function should return near-instantly. One or two seconds of delay between stamp and deadline should be enough: if the function takes more than that to return, then there is a problem with the underlying processes.

You can have more than one session open in parallel, by declaring several distinct skadns_t structures and calling skadns_startf (or skadns_start) more than once. However, this is only useful if you need to perform more than SKADNS_MAXCONCURRENCY, i.e. a thousand, concurrent requests. In most situations, a single skadns session will be enough. 

skadns_end(&a) ;

skadns_end frees all the resources used by the session. The a structure is then reusable for another session.

Sending a DNS query 

s6dns_domain_t d ;
uint16_t qtype ;
uint16_t id ;
tain_t limit, deadline, stamp ;

skadns_send(&a, &id, &d, qtype, &limit, &deadline, &stamp) ;

skadns_send starts the asynchronous resolution of domain d with query type qtype. d must be encoded in packet form. stamp must be an accurate enough timetamp. If the resolution hasn't completed by deadline limit, it will automatically fail with a status set to ETIMEDOUT.

Like skadns_startf(), the skadns_send() call is synchronous but should not be blocking; however, if it hasn't returned by deadline deadline, it then returns 0 with errno set to ETIMEDOUT. On failure, the call returns 0 and sets errno. On success, it returns 1 and id is set to a 16-bit number identifying the query.

Cancelling a query 

skadns_cancel(&a, id, &deadline, &stamp) ;

skadns_cancel cancels the resolution identified by id. stamp must be an accurate enough timestamp. The call returns 1 on success, or 0 (and sets errno) on failure. It is synchronous but should return almost-instantly; if it hasn't returned by deadline, it then returns 0 ETIMEDOUT.

After a query has been successfully canceled, its id can be discarded.

Asynchronously waiting for answers

(from now on, the functions are listed with their prototypes instead of usage examples.) 

int skadns_fd (skadns_t const *a)

Returns a file descriptor to select on for reading. Do not read() it though. 

int skadns_update (skadns_t *a)

Call this function whenever the fd checks readability: it will update a's internal structures with information from the skadnsd daemon. It returns -1 if an error occurs; in case of success, it returns the number of identifiers for which something happened.

When skadns_update returns, genalloc_s(uint16_t, &a->list) points to an array of genalloc_len(uint16_t, &a->list) 16-bit unsigned integers. Those integers are valid ids that can be used with the following functions. 

char const *skadns_packet (skadns_t *a, uint16_t id)
int skadns_packetlen (skadns_t *a, uint16_t id)

skadns_packet() returns a pointer to the DNS packet containing the answer to the query identified by id, and skadns_packetlen() returns its length. If an error has occurred, skadns_packet() returns NULL and skadns_packetlen() returns -1; either call sets errno to a value identifying the error. Some errno values have a special meaning:

  • EAGAIN: the result has not arrived yet.
  • ECANCELED: the query has been canceled.
  • EINVAL: id does not identify a valid query. Note that if you get EINVAL, then id is invalid, but the reverse is not true: using invalid ids is a programming error and may result in a crash. 
int skadns_release (skadns_t *a, uint16_t id)

skadns_release() frees the cell holding the result of query id. It returns 1 on success, then id can be discarded - further calls to skadns_send() may reuse the same number.

skadns_release() may fail, and return 0. This signals a programming error and shouldn't be relied on - however, if it happens, errno can help you identify the problem:

  • EBUSY: the query is still pending, cancelled or not.
  • EINVAL: id is invalid.
s6-dns-2.3.1.1/doc/skadns/skadnsd.html0000644000000000000000000001137513111013151014213 0ustar s6-dns: the skadnsd internal program libskadns
s6-dns
Software
skarnet.org

The skadnsd program

skadnsd is the skadns daemon. It reads a series of queries from the client its stdin socket, resolves them asynchronously, and sends the answers back to the client as soon as it gets them. It exits 0 when its stdin closes. It exits 111 on any serious error, writing the error message to stderr.

skadnsd is a stub resolver. It reads /etc/resolv.conf at start looking for a "nameserver" line containing the address of a DNS cache (aka full resolver). It will exit 111 if it cannot find any valid cache address in /etc/resolv.conf. If the DNSCACHEIP environment variable is set, its value overrides what /etc/resolv.conf says.

Interface

skadnsd does not fork, does not background itself automatically, and does not use syslog. It is not meant to be run directly by the user: it will be invoked and spawned by the skadns library calls.

There are 2 ways to use skadnsd:

  1. (preferred) Use the skadns_startf() library call. A skadnsd child will then be spawned from your calling process, and automatically reaped when you call skadns_end(). It requires care with applications that trap SIGCHLD.
  2. Use the skadns_start() library call, together with a skadnsd service.

Running skadnsd as a child process

This is the simplest and safest way of using skadns. Forget about skadnsd: just start your library calls with skadns_startf() and end them with skadns_end(). Be careful though: if you're using SIGCHLD handlers, make sure they do not interfere with the child processes your application has without knowing. This is a general Unix programming rule.

Running a skadnsd as a daemon: the skadnsd service

In this mode, you set up a daemon listening on a Unix domain socket, and clients connect to this socket to access the service. The advantage of this setup is that it works even with badly written clients that have trouble handling a child process; the drawback is that it requires support from the system administrator.

skadnsd has no "standalone" mode: it is designed to work with a Unix domain superserver, like s6-ipcserver. skadnsd follows the UCSPI interface, it can be directly executed from the superserver.

You should run skadnsd (and its Unix superserver) under a specific user and group, for elementary security reasons; and you should run its dedicated logger as another specific user. Do NOT run skadnsd as root; check your super-server documentation to find how to run it under a specific account.

Notes

  • Users should never invoke skadnsd directly. It's an internal program designed to be spawned by the skadns library. It follows skalibs' "skaclient" protocol and is unusable unless spawned by the right client library also using that protocol.
  • If a poorly designed client sends a lot of queries and never reads the answers, those will indefinitely queue up in the daemon, eating up memory. You should run your process (or your Unix superserver, if you're using a skadnsd service) under a program like s6-softlimit to set a memory limit to every skadnsd instance. If skadnsd runs out of allowed memory, it will simply die.
  • If you're using a skadnsd service: you should configure your Unix superserver to set a maximum number of concurrent skadnsd instances; most Unix superserver implementations provide the -c option for this. The s6-ipcserver program also allows you to specify a maximum number of concurrent daemon instances per client.
  • The only way to ensure absolute reliability of the skadnsd process is to run it as a child, not as a daemon: use skadnsd_startf() when possible.
s6-dns-2.3.1.1/doc/s6-dnstxt.html0000644000000000000000000000603413111013151013147 0ustar s6-dns: the s6-dnstxt program

s6-dns
Software
skarnet.org

The s6-dnstxt program

s6-dnstxt finds the TXT information associated to a domain name.

Interface 

     s6-dnstxt [ -q ] [ -r ] [ -t timeout ] domain
  • s6-dnstxt makes a TXT query for the name domain. It waits for the result and prints the obtained strings, one by line, in a quoted form similar to s6-quote's output. You can pipe s6-dnstxt's output through s6-unquote-filter to get unquoted TXT fields.
  • If the domain exists but no relevant field has been found, it exits 1.
  • If the DNS answered but no answer is available, it prints a relevant error message and exits 2.
  • By default, s6-dnstxt looks for DNS cache addresses in the /etc/resolv.conf file. If the DNSCACHEIP environment variable is set and contains a list of IP (v4 or v6) addresses, separated by commas, semicolons, spaces, tabs, newlines or carriage returns, then this list is used instead.

Options

  • -q : qualify. Qualifies domain before resolution, according to suffixes found in /etc/resolv.conf. If the DNSQUALIFY environment variable is set and contains a list of suffixes separated by spaces, tabs, newlines or carriage returns, then this list is used instead. By default, no qualification is used: if domain is not a FQDN, a dot is just appended to it.
  • -r : random. By default, the program does not sort the result, but prints them in the order received from the DNS. With this option, it performs a random permutation on the results before printing them.
  • -t timeout : if the resolution takes more than timeout milliseconds, then it exits 99 right away with an error message. By default, timeout is 0, which means no timeout.

Notes

There can be more than one character-string in a TXT RR, and there can be more than one TXT RR per domain. DNS clients usually concatenate all this and only give one string. s6-dnstxt concatenates all the character-strings in one TXT record, but separates different TXT records, printing each one on a separate line.

s6-dns-2.3.1.1/doc/s6-dnsip6-filter.html0000644000000000000000000001041213111013151014304 0ustar s6-dns: the s6-dnsip6-filter program

s6-dns
Software
skarnet.org

The s6-dnsip6-filter program

s6-dnsip6-filter reads domain names on its standard input and prints the corresponding IPv6 addresses on its standard output.

Interface 

     s6-dnsip6-filter [ -l maxlines ] [ -c maxconn ] [ -t timeout ] [ -f normalfmt ] [ -e errorfmt ]
  • s6-dnsip6-filter reads lines from its stdin, processes them, and prints the processed lines to its stdout, in the same order. It exits 0 when it reads EOF on stdin.
  • Every line starting with a domain name is processed. Lines not starting with a domain name are not, and the formatting rules treat them as a pure "remainder".
  • For every processed line, an AAAA query is made, and the result is printed according to the formatting rules. The domain is not qualified before being resolved.
  • By default, s6-dnsip6-filter looks for DNS cache addresses in the /etc/resolv.conf file. If the DNSCACHEIP environment variable is set and contains a list of IP (v4 or v6) addresses, separated by commas, semicolons, spaces, tabs, newlines or carriage returns, then this list is used instead.

Options

  • -l maxlines : maximum lines. s6-dnsip6-filter will keep at most maxlines lines in memory at the same time. If line n is still waiting for resolution and cannot be printed, then s6-dnsip6-filter will stop reading from stdin before line n+maxlines, until the result arrives for line n. By default, maxlines is 256.
  • -c maxconn : maximum concurrent resolutions. s6-dnsip6-filter will perform at most maxconn resolutions in parallel at the same time. maxlines cannot be lesser than maxconn. By default, maxconn is 128.
  • -t timeout : if any resolution takes more than timeout milliseconds, then it is aborted and printed as a timeout error. By default, timeout is 0, which means no timeout.
  • -f normalfmt : print the positive results according to the normalfmt format string. By default, normalfmt is %s=%d%w%r, which means: print the original domain name, then an equal sign, then the corresponding IPv6 address, then the remainder of the line.
  • -e errorfmt : print the negative results according to the errorfmt format string. By default, errorfmt is %s=<%e%>%w%r, which means: print the original domain name, then an equal sign, then the error message between angle brackets, then the remainder of the line.

Formatting rules

normalfmt and errorfmt are format strings, i.e. they tell the program how a line must be printed. The following sequences are recognized:

  • %% prints a single % character
  • %s prints the original domain name
  • %d prints the IP address, if any
  • %e prints the error message, if any
  • %w%r prints the remainder of the input line

Notes

s6-dnsip6-filter does not perform DNS resolutions itself. Instead, it forks a skadnsd child and sends it queries, getting the results asynchronously. The s6-dns filter programs have actually been written as example uses of the skadns library.

s6-dns-2.3.1.1/doc/s6-dnsq.html0000644000000000000000000000626013111013151012571 0ustar s6-dns: the s6-dnsq program

s6-dns
Software
skarnet.org

The s6-dnsq program

s6-dnsq is an analysis and debug tool. It performs a non-recursive DNS query to a given list of servers, then prints the contents of the answer packet, and optionally debug information during the resolution.

Interface 

     s6-dnsq [ -1 | -2 ] [ -t timeout ] [ -D level ] qtype domain serverlist
  • s6-dnsq makes an iterative DNS query of type qtype for the name domain to serverlist. It prints the answer packet, in human-readable form, to its standard output, then exits 0.
  • It does not qualify domain.
  • If the resolution fails for some reason, s6-dnsq exits 2.
  • serverlist is a list of IP addresses (v4 or v6), one or more addresses per argument on the command line (so you can use, for instance, `s6-dnsip4 ns.example.com` as argument, and get all the addresses for ns.example.com in your server list). Servers are tried in the order given, until a definitive answer is obtained or s6-dnsq runs out of server addresses.

Options

  • -1 : send debug information to stdout.
  • -2 : send debug information to stderr. This is the default. Note that those options only apply to debug output, not to the regular packet dump, which is always printed to stdout.
  • -t timeout : if the resolution takes more than timeout milliseconds, then it exits 99 right away with an error message. By default, timeout is 0, which means no timeout.
  • -D level : produce debug output during resolution. If level is:
    • 0: no debug output is produced
    • 1: information is printed when s6-dnsq receives a DNS packet from a server
    • 2: information is printed before and after s6-dnsq sends a DNS packet to a server
    • 3: both 1. and 2. apply

Notes

  • TXT records are printed in a quoted form similar to s6-quote's output.
  • If s6-dnsq finds a record it cannot print, such as an unknown RR type, it dumps its contents in the same quoted form.
  • The normal output format should be stable, so you can write programs that automatically parse it. However, the debug output format is undocumented and subject to change.
s6-dns-2.3.1.1/doc/s6-dnsip4-filter.html0000644000000000000000000001102713111013151014305 0ustar s6-dns: the s6-dnsip4-filter program

s6-dns
Software
skarnet.org

The s6-dnsip4-filter program

s6-dnsip4-filter reads domain names on its standard input and prints the corresponding IPv4 addresses on its standard output.

Interface 

     s6-dnsip4-filter [ -l maxlines ] [ -c maxconn ] [ -t timeout ] [ -f normalfmt ] [ -e errorfmt ]
  • s6-dnsip4-filter reads lines from its stdin, processes them, and prints the processed lines to its stdout, in the same order. It exits 0 when it reads EOF on stdin.
  • Every line starting with a domain name is processed. Lines not starting with a domain name are not, and the formatting rules treat them as a pure "remainder".
  • For every processed line, an A query is made, and the result is printed according to the formatting rules. The domain is not qualified before being resolved.
  • By default, s6-dnsip4-filter looks for DNS cache addresses in the /etc/resolv.conf file. If the DNSCACHEIP environment variable is set and contains a list of IP (v4 or v6) addresses, separated by commas, semicolons, spaces, tabs, newlines or carriage returns, then this list is used instead.

Options

  • -l maxlines : maximum lines. s6-dnsip4-filter will keep at most maxlines lines in memory at the same time. If line n is still waiting for resolution and cannot be printed, then s6-dnsip4-filter will stop reading from stdin before line n+maxlines, until the result arrives for line n. By default, maxlines is 256.
  • -c maxconn : maximum concurrent resolutions. s6-dnsip4-filter will perform at most maxconn resolutions in parallel at the same time. maxlines cannot be lesser than maxconn. By default, maxconn is 128.
  • -t timeout : if any resolution takes more than timeout milliseconds, then it is aborted and printed as a timeout error. By default, timeout is 0, which means no timeout.
  • -f normalfmt : print the positive results according to the normalfmt format string. By default, normalfmt is %s=%d%w%r, which means: print the original domain name, then an equal sign, then the corresponding IPv4 address, then the remainder of the line.
  • -e errorfmt : print the negative results according to the errorfmt format string. By default, errorfmt is %s=<%e%>%w%r, which means: print the original domain name, then an equal sign, then the error message between angle brackets, then the remainder of the line.

Formatting rules

normalfmt and errorfmt are format strings, i.e. they tell the program how a line must be printed. The following sequences are recognized:

  • %% prints a single % character
  • %s prints the original domain name
  • %d prints the IP address, if any
  • %e prints the error message, if any
  • %w%r prints the remainder of the input line

Example 

     s6-dnsns google.com | s6-dnsip4-filter -f "%d"

prints all the nameserver addresses for the google.com domain. This is useful, for instance, to give the result as an argument to s6-dnsq.

Notes

s6-dnsip4-filter does not perform DNS resolutions itself. Instead, it forks a skadnsd child and sends it queries, getting the results asynchronously. The s6-dns filter programs have actually been written as example uses of the skadns library.

s6-dns-2.3.1.1/doc/s6-dnssoa.html0000644000000000000000000000510613111013151013111 0ustar s6-dns: the s6-dnssoa program

s6-dns
Software
skarnet.org

The s6-dnssoa program

s6-dnssoa finds the SOA information associated to a domain.

Interface 

     s6-dnssoa [ -q ] [ -r ] [ -t timeout ] domain
  • s6-dnsmx makes an SOA query for the name domain. It waits for the result and prints the obtained information line by line, then exits 0. It prints the mname, the rname, the serial number, and the refresh, retry, expiration and minimum times, in that order, separated by spaces.
  • If the domain exists but no relevant field has been found, it exits 1.
  • If the DNS answered but no answer is available, it prints a relevant error message and exits 2.
  • By default, s6-dnssoa looks for DNS cache addresses in the /etc/resolv.conf file. If the DNSCACHEIP environment variable is set and contains a list of IP (v4 or v6) addresses, separated by commas, semicolons, spaces, tabs, newlines or carriage returns, then this list is used instead.

Options

  • -q : qualify. Qualifies domain before resolution, according to suffixes found in /etc/resolv.conf. If the DNSQUALIFY environment variable is set and contains a list of suffixes separated by spaces, tabs, newlines or carriage returns, then this list is used instead. By default, no qualification is used: if domain is not a FQDN, a dot is just appended to it.
  • -r : random. By default, the program does not sort the result, but prints them in the order received from the DNS. With this option, it performs a random permutation on the results before printing them.
  • -t timeout : if the resolution takes more than timeout milliseconds, then it exits 99 right away with an error message. By default, timeout is 0, which means no timeout.
s6-dns-2.3.1.1/doc/s6-dnsqr.html0000644000000000000000000000601513111013151012751 0ustar s6-dns: the s6-dnsqr program

s6-dns
Software
skarnet.org

The s6-dnsqr program

s6-dnsqr is an analysis and debug tool. It performs a DNS resolution, then prints the contents of the answer packet, and optionally debug information during the resolution.

Interface 

     s6-dnsqr [ -1 | -2 ] [ -t timeout ] [ -D level ] qtype domain
  • s6-dnsqr makes a recursive DNS query of type qtype for the name domain. It prints the answer packet, in human-readable form, to its standard output, then exits 0.
  • It does not qualify domain.
  • If the resolution fails for some reason, s6-dnsqr exits 2.
  • By default, s6-dnsqr looks for DNS cache addresses in the /etc/resolv.conf file. If the DNSCACHEIP environment variable is set and contains a list of IP (v4 or v6) addresses, separated by commas, semicolons, spaces, tabs, newlines or carriage returns, then this list is used instead.

Options

  • -1 : send debug information to stdout.
  • -2 : send debug information to stderr. This is the default. Note that those options only apply to debug output, not to the regular packet dump, which is always printed to stdout.
  • -t timeout : if the resolution takes more than timeout milliseconds, then it exits 99 right away with an error message. By default, timeout is 0, which means no timeout.
  • -D level : produce debug output during resolution. If level is:
    • 0: no debug output is produced
    • 1: information is printed when s6-dnsqr receives a DNS packet from a cache
    • 2: information is printed before and after s6-dnsqr sends a DNS packet to a cache
    • 3: both 1. and 2. apply

Notes

  • TXT records are printed in a quoted form similar to s6-quote's output.
  • If s6-dnsqr finds a record it cannot print, such as an unknown RR type, it dumps its content in the same quoted form.
  • The normal output format should be stable, so you can write programs that automatically parse it. However, the debug output format is undocumented and subject to change.
s6-dns-2.3.1.1/doc/s6-dnsip4.html0000644000000000000000000000467313111013151013033 0ustar s6-dns: the s6-dnsip4 program

s6-dns
Software
skarnet.org

The s6-dnsip4 program

s6-dnsip4 finds the IPv4 addresses associated to a domain name.

Interface 

     s6-dnsip4 [ -q ] [ -r ] [ -t timeout ] domain
  • s6-dnsip4 makes an A query for the name domain. It waits for the result and prints the obtained IPv4 addresses, one per line, then exits 0.
  • If the domain exists but no relevant field has been found, it exits 1.
  • If the DNS answered but no answer is available, it prints a relevant error message and exits 2.
  • By default, s6-dnsip4 looks for DNS cache addresses in the /etc/resolv.conf file. If the DNSCACHEIP environment variable is set and contains a list of IP (v4 or v6) addresses, separated by commas, semicolons, spaces, tabs, newlines or carriage returns, then this list is used instead.

Options

  • -q : qualify. Qualifies domain before resolution, according to suffixes found in /etc/resolv.conf. If the DNSQUALIFY environment variable is set and contains a list of suffixes separated by spaces, tabs, newlines or carriage returns, then this list is used instead. By default, no qualification is used: if domain is not a FQDN, a dot is just appended to it.
  • -r : random. By default, the program does not sort the result, but prints them in the order received from the DNS. With this option, it performs a random permutation on the results before printing them.
  • -t timeout : if the resolution takes more than timeout milliseconds, then it exits 99 right away with an error message. By default, timeout is 0, which means no timeout.
s6-dns-2.3.1.1/doc/upgrade.html0000644000000000000000000000574013553356771012763 0ustar s6-dns: how to upgrade

s6-dns
Software
skarnet.org

What has changed in s6-dns

in 2.3.1.1

  • skalibs dependency bumped to 2.9.1.0.

in 2.3.1.0

  • skalibs dependency bumped to 2.9.0.0.

in 2.3.0.2

  • skalibs dependency bumped to 2.8.0.0.
  • Everything now builds as PIC by default no matter the toolchain's settings. Use the --disable-all-pic configure option to build executables and static libraries as non-PIC.

in 2.3.0.1

  • skalibs dependency bumped to 2.7.0.0.

in 2.3.0.0

  • skalibs dependency bumped to 2.6.3.0.
  • skadns now uses the textclient API/ABI instead of the skaclient one. The change should not be externally visible.

in 2.2.0.1

  • skalibs dependency bumped to 2.6.0.0.

in 2.2.0.0

  • skalibs dependency bumped to 2.5.0.0.

in 2.1.0.0

  • skalibs dependency bumped to 2.4.0.0.
  • No visible changes, but the new librandom is used in all clients.

in 2.0.1.0

  • skalibs dependency bumped to 2.3.10.0.

in 2.0.0.7

  • GNU make dependency pushed back to 3.81.
  • skalibs dependency bumped to 2.3.8.0.

in 2.0.0.6

  • skalibs dependency bumped to 2.3.7.1.

in 2.0.0.5

  • skalibs dependency bumped to 2.3.6.1.

in 2.0.0.4

  • skalibs dependency bumped to 2.3.5.1.

in 2.0.0.3

  • skalibs dependency bumped to 2.3.3.0.

in 2.0.0.2

  • skalibs dependency bumped to 2.2.0.0.

in 2.0.0.1

  • skalibs dependency bumped to 2.1.0.0.

in 2.0.0.0

  • The build system has completely changed. It is now a standard ./configure && make && sudo make install build system. See the enclosed INSTALL file for details.
  • slashpackage is not activated by default.
  • shared libraries are not used by default.
  • skalibs dependency bumped to 2.0.0.0.
s6-dns-2.3.1.1/doc/s6-dnsmx.html0000644000000000000000000000477613111013151012767 0ustar s6-dns: the s6-dnsmx program

s6-dns
Software
skarnet.org

The s6-dnsmx program

s6-dnsmx finds the MX information associated to a domain name.

Interface 

     s6-dnsmx [ -q ] [ -r ] [ -t timeout ] domain
  • s6-dnsmx makes an MX query for the name domain. It waits for the result and prints the obtained information, one exchanger per line, then exits 0. It prints the preference, then a space, then the exchanger name.
  • If the domain exists but no relevant field has been found, it exits 1.
  • If the DNS answered but no answer is available, it prints a relevant error message and exits 2.
  • By default, s6-dnsmx looks for DNS cache addresses in the /etc/resolv.conf file. If the DNSCACHEIP environment variable is set and contains a list of IP (v4 or v6) addresses, separated by commas, semicolons, spaces, tabs, newlines or carriage returns, then this list is used instead.

Options

  • -q : qualify. Qualifies domain before resolution, according to suffixes found in /etc/resolv.conf. If the DNSQUALIFY environment variable is set and contains a list of suffixes separated by spaces, tabs, newlines or carriage returns, then this list is used instead. By default, no qualification is used: if domain is not a FQDN, a dot is just appended to it.
  • -r : random. By default, the program does not sort the result, but prints them in the order received from the DNS. With this option, it performs a random permutation on the results before printing them.
  • -t timeout : if the resolution takes more than timeout milliseconds, then it exits 99 right away with an error message. By default, timeout is 0, which means no timeout.
s6-dns-2.3.1.1/doc/s6-dnsip6.html0000644000000000000000000000546213111013151013032 0ustar s6-dns: the s6-dnsip6 program

s6-dns
Software
skarnet.org

The s6-dnsip6 program

s6-dnsip6 finds the IPv6 addresses associated to a domain name.

Interface 

     s6-dnsip6 [ -q ] [ -r ] [ -t timeout ] domain
  • s6-dnsip6 makes an AAAA query for the name domain. It waits for the result and prints the obtained IPv6 addresses, one per line, then exits 0.
  • If the domain exists but no relevant field has been found, it exits 1.
  • If the DNS answered but no answer is available, it prints a relevant error message and exits 2.
  • By default, s6-dnsip6 looks for DNS cache addresses in the /etc/resolv.conf file. If the DNSCACHEIP environment variable is set and contains a list of IP (v4 or v6) addresses, separated by commas, semicolons, spaces, tabs, newlines or carriage returns, then this list is used instead.

Options

  • -q : qualify. Qualifies domain before resolution, according to suffixes found in /etc/resolv.conf. If the DNSQUALIFY environment variable is set and contains a list of suffixes separated by spaces, tabs, newlines or carriage returns, then this list is used instead. By default, no qualification is used: if domain is not a FQDN, a dot is just appended to it.
  • -r : random. By default, the program does not sort the result, but prints them in the order received from the DNS. With this option, it performs a random permutation on the results before printing them.
  • -t timeout : if the resolution takes more than timeout milliseconds, then it exits 99 right away with an error message. By default, timeout is 0, which means no timeout.

Notes

Bear in mind that making AAAA queries is very different, and totally independent, from using IPv6 transport for the DNS queries. Even if the underlying skalibs has been compiled without IPv6 support, or IPv6 DNS transport is unavailable for any reason, you can still perform AAAA queries and s6-dnsip6 will answer correctly.

s6-dns-2.3.1.1/doc/s6-dnsname.html0000644000000000000000000000523113111013151013246 0ustar s6-dns: the s6-dnsname program

s6-dns
Software
skarnet.org

The s6-dnsname program

s6-dnsname finds the name associated to an IPv4 or IPv6 address.

Interface 

     s6-dnsname [ -4 | -6 ] [ -r ] [ -t timeout ] ip
  • s6-dnsname converts the IP address ip to a name ending in in-addr.arpa. or ip6.arpa. then makes a PTR query for this name. It waits for the result and prints the obtained names, one per line, then exits 0.
  • If the domain exists but no relevant field has been found, it exits 1.
  • If the DNS answered but no answer is available, it prints a relevant error message and exits 2.
  • By default, s6-dnsname looks for DNS cache addresses in the /etc/resolv.conf file. If the DNSCACHEIP environment variable is set and contains a list of IP (v4 or v6) addresses, separated by commas, semicolons, spaces, tabs, newlines or carriage returns, then this list is used instead.

Options

  • -4 : interpret ip as an IPv4 address.
  • -6 : interpret ip as an IPv6 address. If neither of the -4 and -6 is given, or if both are given, then ip will be interpreted as v4 or v6 depending on its syntax.
  • -r : random. By default, the program does not sort the result, but prints them in the order received from the DNS. With this option, it performs a random permutation on the results before printing them.
  • -t timeout : if the resolution takes more than timeout milliseconds, then it exits 99 right away with an error message. By default, timeout is 0, which means no timeout.

Notes

  • If the underlying skalibs has been compiled with IPv6 support disabled, s6-dnsname will not be able to use IPv6 transport for its resolution, but it will still accept and resolve IPv6 addresses.
s6-dns-2.3.1.1/doc/s6-randomip.html0000644000000000000000000000340213465455754013467 0ustar s6-dns: the s6-randomip program

s6-dns
Software
skarnet.org

The s6-randomip program

s6-randomip generates random IP addresses and prints them to its standard output, one per line.

Interface 

     s6-randomip [ -4 ] [ -6 ] [ -n max ]
  • s6-randomip makes up IP addresses and prints them to its stdout. It keeps running until it receives a signal.
  • IP addresses are not guaranteed to represent anything. They are totally random.

Options

  • -4 : generate IPv4 addresses.
  • -6 : generate IPv6 addresses. Both the -4 and -6 options may be given. If none is given, by default s6-randomip will only generate IPv4 addresses.
  • -n max : s6-randomip will only generate max addresses, then exit 0, instead of running forever.

Notes

s6-randomip can be used in conjunction with s6-dnsname-filter to stress-test your DNS architecture. Please use this responsibly and ethically.

s6-dns-2.3.1.1/doc/libresolv.html0000644000000000000000000001226213111013151013276 0ustar s6-dns: the problem with libresolv

s6-dns
Software
skarnet.org

The problem with libresolv

The BIND name server software comes with its own client library, named libresolv.

As can be expected from an ISC product, libresolv is not good software. Here are a few reasons why.

libresolv's security model is flawed.

The same people who wrote BIND wrote libresolv. That is the amount of trust you can place in libresolv. Ten years ago, the security status of libresolv looked like this. I am not confident that is has improved: bugs in the software may have been fixed, but new ones will appear, and most importantly, the security management policy at ISC is still the same: security holes will be denied instead of acknowledged and worked upon.

If you find a bug, and a fortiori a security hole, in s6-dns, you can be sure it will be fixed promptly with apologies from the author. skarnet.org doesn't do obfuscation, and never lets politics get in the way of technical quality.

libresolv is unboundedly synchronous.

You'd expect a real DNS client library to do better in this aspect than getaddrinfo(), but no: libresolv's function calls are still purely synchronous and may uncontrollably block if the network is unresponsive.

Additionally, libresolv only provides a synchronous interface to clients. Despite the fundamentally asynchronous nature of DNS, and the need to implement asynchronous primitives internally, only blocking calls are made available in the API. This forces users to stack yet another piece of software on top of their dependencies if they need asynchronous DNS resolution.

libs6dns provides several layers of asynchronous interfaces. The user has access to low-level packet sending and receiving, to synchronous resolution of several queries at once, and to a real high-level asynchronous DNS library.

It is too big for what it does.

The libresolv-2.13.so binary file compiled for an x86_64 Debian Linux system is roughly 79k bytes. The libs6dns.so.2.0 file, for the same system, is a little bit smaller, while offering more functionality: high-level answer parsing, user-friendly formatting, and in-depth tracing of the DNS resolution process. What is all that code in libresolv for ?

The API is cumbersome to use.

Some examples of less-than-ideal interfaces for the users:

  • There is a flag in libresolv's global state structure that determines if queries are to be sent recursive or iterative. Which means that a program that needs to make both recursive and iterative queries must duplicate this state structure and use one for recursive queries, one for iterative queries. Why this complexity ? The recursive flag should be given for every query, not be a part of the resolver state.
  • When a libresolv answer arrives but doesn't fit into the user-supplied buffer, the query is discarded and has to be retried. Does "network efficiency" ring a bell ? Also, the length of the original answer is returned by the first call, which is a good thing: the user can now provide a large enough buffer so the call succeeds the next time, right ? Wrong. The next answer can be different from the first, and in particular, longer, which means that the next query can still fail.

There is a reason why system calls and local functions take user-supplied buffers as arguments. They are relatively fast, it is not too costly to call them again if the buffer is too small the first time, and the result is consistent, i.e. after the first call, the right buffer length is known. But functions making network exchanges with variable-length results from one call to another ? Those need heap-allocated storage. It is good design to avoid using the heap whenever possible, but it is not good design to waste network round-trips to save a malloc().

Conclusion

Like many other "standards", and C library interfaces in particular, libresolv is at best a mediocre one, that people use because there has been nothing better so far.

s6-dns tries to be an alternative solution, based on solid design principles and a reliable code base. It just works, and it makes DNS resolution nice and easy for users.

s6-dns-2.3.1.1/doc/s6-dnsname-filter.html0000644000000000000000000001111413111013151014526 0ustar s6-dns: the s6-dnsname-filter program

s6-dns
Software
skarnet.org

The s6-dnsname-filter program

s6-dnsname-filter reads IP addresses on its standard input and prints the corresponding domain names on its standard output.

Interface 

     s6-dnsname-filter [ -4 ] [ -6 ] [ -l maxlines ] [ -c maxconn ] [ -t timeout ] [ -f normalfmt ] [ -e errorfmt ]
  • s6-dnsname-filter reads lines from its stdin, processes them, and prints the processed lines to its stdout, in the same order. It exits 0 when it reads EOF on stdin.
  • Every line starting with an IP address is processed. Lines not starting with an IP address are not, and the formatting rules treat them as a pure "remainder".
  • For every processed line, the read IP address is converted to an in-addr.arpa. or ip6.arpa. domain on which a PTR query is made, and the result is printed according to the formatting rules.
  • By default, s6-dnsname-filter looks for DNS cache addresses in the /etc/resolv.conf file. If the DNSCACHEIP environment variable is set and contains a list of IP (v4 or v6) addresses, separated by commas, semicolons, spaces, tabs, newlines or carriage returns, then this list is used instead.

Options

  • -4 : scan for IPv4 addresses.
  • -6 : scan for IPv6 addresses. Both the -4 and -6 options may be given. If none is given, by default s6-dnsname-filter will only scan for IPv4 addresses.
  • -l maxlines : maximum lines. s6-dnsname-filter will keep at most maxlines lines in memory at the same time. If line n is still waiting for resolution and cannot be printed, then s6-dnsname-filter will stop reading from stdin before line n+maxlines, until the result arrives for line n. By default, maxlines is 256.
  • -c maxconn : maximum concurrent resolutions. s6-dnsname-filter will perform at most maxconn resolutions in parallel at the same time. maxlines cannot be lesser than maxconn. By default, maxconn is 128.
  • -t timeout : if any resolution takes more than timeout milliseconds, then it is aborted and printed as a timeout error. By default, timeout is 0, which means no timeout.
  • -f normalfmt : print the positive results according to the normalfmt format string. By default, normalfmt is %s=%d%w%r, which means: print the original IP address, then an equal sign, then the corresponding domain name, then the remainder of the line.
  • -e errorfmt : print the negative results according to the errorfmt format string. By default, errorfmt is %s=<%e%>%w%r, which means: print the original IP address, then an equal sign, then the error message between angle brackets, then the remainder of the line.

Formatting rules

normalfmt and errorfmt are format strings, i.e. they tell the program how a line must be printed. The following sequences are recognized:

  • %% prints a single % character
  • %s prints the original IP address
  • %d prints the domain name, if any
  • %e prints the error message, if any
  • %w%r prints the remainder of the input line

Notes

s6-dnsname-filter does not perform DNS resolutions itself. Instead, it forks a skadnsd child and sends it queries, getting the results asynchronously. The s6-dns filter programs have actually been written as example uses of the skadns library.