contrib/unbound/sldns/wire2str.c

   1 /*
   2  * wire2str.c
   3  *
   4  * conversion routines from the wire format
   5  * to the presentation format (strings)
   6  *
   7  * (c) NLnet Labs, 2004-2006
   8  *
   9  * See the file LICENSE for the license
  10  */
  11 /**
  12  * \file
  13  *
  14  * Contains functions to translate the wireformat to text
  15  * representation, as well as functions to print them.
  16  */
  17 #include "config.h"
  18 #include "sldns/wire2str.h"
  19 #include "sldns/str2wire.h"
  20 #include "sldns/rrdef.h"
  21 #include "sldns/pkthdr.h"
  22 #include "sldns/parseutil.h"
  23 #include "sldns/sbuffer.h"
  24 #include "sldns/keyraw.h"
  25 #ifdef HAVE_TIME_H
  26 #include <time.h>
  27 #endif
  28 #include <sys/time.h>
  29 #include <stdarg.h>
  30 #include <ctype.h>
  31 #ifdef HAVE_NETDB_H
  32 #include <netdb.h>
  33 #endif
  34
  35 /* lookup tables for standard DNS stuff  */
  36 /* Taken from RFC 2535, section 7.  */
  37 static sldns_lookup_table sldns_algorithms_data[] = {
  38         { LDNS_RSAMD5, "RSAMD5" },
  39         { LDNS_DH, "DH" },
  40         { LDNS_DSA, "DSA" },
  41         { LDNS_ECC, "ECC" },
  42         { LDNS_RSASHA1, "RSASHA1" },
  43         { LDNS_DSA_NSEC3, "DSA-NSEC3-SHA1" },
  44         { LDNS_RSASHA1_NSEC3, "RSASHA1-NSEC3-SHA1" },
  45         { LDNS_RSASHA256, "RSASHA256"},
  46         { LDNS_RSASHA512, "RSASHA512"},
  47         { LDNS_ECC_GOST, "ECC-GOST"},
  48         { LDNS_ECDSAP256SHA256, "ECDSAP256SHA256"},
  49         { LDNS_ECDSAP384SHA384, "ECDSAP384SHA384"},
  50         { LDNS_INDIRECT, "INDIRECT" },
  51         { LDNS_PRIVATEDNS, "PRIVATEDNS" },
  52         { LDNS_PRIVATEOID, "PRIVATEOID" },
  53         { 0, NULL }
  54 };
  55 sldns_lookup_table* sldns_algorithms = sldns_algorithms_data;
  56
  57 /* hash algorithms in DS record */
  58 static sldns_lookup_table sldns_hashes_data[] = {
  59         { LDNS_SHA1, "SHA1" },
  60         { LDNS_SHA256, "SHA256" },
  61         { LDNS_HASH_GOST, "HASH-GOST" },
  62         { LDNS_SHA384, "SHA384" },
  63         { 0, NULL }
  64 };
  65 sldns_lookup_table* sldns_hashes = sldns_hashes_data;
  66
  67 /* Taken from RFC 4398  */
  68 static sldns_lookup_table sldns_cert_algorithms_data[] = {
  69         { LDNS_CERT_PKIX, "PKIX" },
  70         { LDNS_CERT_SPKI, "SPKI" },
  71         { LDNS_CERT_PGP, "PGP" },
  72         { LDNS_CERT_IPKIX, "IPKIX" },
  73         { LDNS_CERT_ISPKI, "ISPKI" },
  74         { LDNS_CERT_IPGP, "IPGP" },
  75         { LDNS_CERT_ACPKIX, "ACPKIX" },
  76         { LDNS_CERT_IACPKIX, "IACPKIX" },
  77         { LDNS_CERT_URI, "URI" },
  78         { LDNS_CERT_OID, "OID" },
  79         { 0, NULL }
  80 };
  81 sldns_lookup_table* sldns_cert_algorithms = sldns_cert_algorithms_data;
  82
  83 /* if these are used elsewhere */
  84 static sldns_lookup_table sldns_rcodes_data[] = {
  85         { LDNS_RCODE_NOERROR, "NOERROR" },
  86         { LDNS_RCODE_FORMERR, "FORMERR" },
  87         { LDNS_RCODE_SERVFAIL, "SERVFAIL" },
  88         { LDNS_RCODE_NXDOMAIN, "NXDOMAIN" },
  89         { LDNS_RCODE_NOTIMPL, "NOTIMPL" },
  90         { LDNS_RCODE_REFUSED, "REFUSED" },
  91         { LDNS_RCODE_YXDOMAIN, "YXDOMAIN" },
  92         { LDNS_RCODE_YXRRSET, "YXRRSET" },
  93         { LDNS_RCODE_NXRRSET, "NXRRSET" },
  94         { LDNS_RCODE_NOTAUTH, "NOTAUTH" },
  95         { LDNS_RCODE_NOTZONE, "NOTZONE" },
  96         { 0, NULL }
  97 };
  98 sldns_lookup_table* sldns_rcodes = sldns_rcodes_data;
  99
 100 static sldns_lookup_table sldns_opcodes_data[] = {
 101         { LDNS_PACKET_QUERY, "QUERY" },
 102         { LDNS_PACKET_IQUERY, "IQUERY" },
 103         { LDNS_PACKET_STATUS, "STATUS" },
 104         { LDNS_PACKET_NOTIFY, "NOTIFY" },
 105         { LDNS_PACKET_UPDATE, "UPDATE" },
 106         { 0, NULL }
 107 };
 108 sldns_lookup_table* sldns_opcodes = sldns_opcodes_data;
 109
 110 static sldns_lookup_table sldns_wireparse_errors_data[] = {
 111         { LDNS_WIREPARSE_ERR_OK, "no parse error" },
 112         { LDNS_WIREPARSE_ERR_GENERAL, "parse error" },
 113         { LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW, "Domainname length overflow" },
 114         { LDNS_WIREPARSE_ERR_DOMAINNAME_UNDERFLOW, "Domainname length underflow (zero length)" },
 115         { LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, "buffer too small" },
 116         { LDNS_WIREPARSE_ERR_LABEL_OVERFLOW, "Label length overflow" },
 117         { LDNS_WIREPARSE_ERR_EMPTY_LABEL, "Empty label" },
 118         { LDNS_WIREPARSE_ERR_SYNTAX_BAD_ESCAPE, "Syntax error, bad escape sequence" },
 119         { LDNS_WIREPARSE_ERR_SYNTAX, "Syntax error, could not parse the RR" },
 120         { LDNS_WIREPARSE_ERR_SYNTAX_TTL, "Syntax error, could not parse the RR's TTL" },
 121         { LDNS_WIREPARSE_ERR_SYNTAX_TYPE, "Syntax error, could not parse the RR's type" },
 122         { LDNS_WIREPARSE_ERR_SYNTAX_CLASS, "Syntax error, could not parse the RR's class" },
 123         { LDNS_WIREPARSE_ERR_SYNTAX_RDATA, "Syntax error, could not parse the RR's rdata" },
 124         { LDNS_WIREPARSE_ERR_SYNTAX_MISSING_VALUE, "Syntax error, value expected" },
 125         { LDNS_WIREPARSE_ERR_INVALID_STR, "Conversion error, string expected" },
 126         { LDNS_WIREPARSE_ERR_SYNTAX_B64, "Conversion error, b64 encoding expected" },
 127         { LDNS_WIREPARSE_ERR_SYNTAX_B32_EXT, "Conversion error, b32 ext encoding expected" },
 128         { LDNS_WIREPARSE_ERR_SYNTAX_HEX, "Conversion error, hex encoding expected" },
 129         { LDNS_WIREPARSE_ERR_CERT_BAD_ALGORITHM, "Bad algorithm type for CERT record" },
 130         { LDNS_WIREPARSE_ERR_SYNTAX_TIME, "Conversion error, time encoding expected" },
 131         { LDNS_WIREPARSE_ERR_SYNTAX_PERIOD, "Conversion error, time period encoding expected" },
 132         { LDNS_WIREPARSE_ERR_SYNTAX_ILNP64, "Conversion error, 4 colon separated hex numbers expected" },
 133         { LDNS_WIREPARSE_ERR_SYNTAX_EUI48,
 134                 "Conversion error, 6 two character hex numbers "
 135                 "separated by dashes expected (i.e. xx-xx-xx-xx-xx-xx" },
 136         { LDNS_WIREPARSE_ERR_SYNTAX_EUI64,
 137                 "Conversion error, 8 two character hex numbers "
 138                 "separated by dashes expected (i.e. xx-xx-xx-xx-xx-xx-xx-xx" },
 139         { LDNS_WIREPARSE_ERR_SYNTAX_TAG,
 140                 "Conversion error, a non-zero sequence of US-ASCII letters "
 141                 "and numbers in lower case expected" },
 142         { LDNS_WIREPARSE_ERR_NOT_IMPL, "not implemented" },
 143         { LDNS_WIREPARSE_ERR_SYNTAX_INT, "Conversion error, integer expected" },
 144         { LDNS_WIREPARSE_ERR_SYNTAX_IP4, "Conversion error, ip4 addr expected" },
 145         { LDNS_WIREPARSE_ERR_SYNTAX_IP6, "Conversion error, ip6 addr expected" },
 146         { LDNS_WIREPARSE_ERR_SYNTAX_INTEGER_OVERFLOW, "Syntax error, integer overflow" },
 147         { LDNS_WIREPARSE_ERR_INCLUDE, "$INCLUDE directive was seen in the zone" },
 148         { LDNS_WIREPARSE_ERR_PARENTHESIS, "Parse error, parenthesis mismatch" },
 149         { 0, NULL }
 150 };
 151 sldns_lookup_table* sldns_wireparse_errors = sldns_wireparse_errors_data;
 152
 153 static sldns_lookup_table sldns_edns_flags_data[] = {
 154         { 3600, "do"},
 155         { 0, NULL}
 156 };
 157 sldns_lookup_table* sldns_edns_flags = sldns_edns_flags_data;
 158
 159 static sldns_lookup_table sldns_edns_options_data[] = {
 160         { 1, "LLQ" },
 161         { 2, "UL" },
 162         { 3, "NSID" },
 163         /* 4 draft-cheshire-edns0-owner-option */
 164         { 5, "DAU" },
 165         { 6, "DHU" },
 166         { 7, "N3U" },
 167         { 8, "edns-client-subnet" },
 168         { 12, "Padding" },
 169         { 0, NULL}
 170 };
 171 sldns_lookup_table* sldns_edns_options = sldns_edns_options_data;
 172
 173 char* sldns_wire2str_pkt(uint8_t* data, size_t len)
 174 {
 175         size_t slen = (size_t)sldns_wire2str_pkt_buf(data, len, NULL, 0);
 176         char* result = (char*)malloc(slen+1);
 177         if(!result) return NULL;
 178         sldns_wire2str_pkt_buf(data, len, result, slen+1);
 179         return result;
 180 }
 181
 182 char* sldns_wire2str_rr(uint8_t* rr, size_t len)
 183 {
 184         size_t slen = (size_t)sldns_wire2str_rr_buf(rr, len, NULL, 0);
 185         char* result = (char*)malloc(slen+1);
 186         if(!result) return NULL;
 187         sldns_wire2str_rr_buf(rr, len, result, slen+1);
 188         return result;
 189 }
 190
 191 char* sldns_wire2str_type(uint16_t rrtype)
 192 {
 193         char buf[16];
 194         sldns_wire2str_type_buf(rrtype, buf, sizeof(buf));
 195         return strdup(buf);
 196 }
 197
 198 char* sldns_wire2str_class(uint16_t rrclass)
 199 {
 200         char buf[16];
 201         sldns_wire2str_class_buf(rrclass, buf, sizeof(buf));
 202         return strdup(buf);
 203 }
 204
 205 char* sldns_wire2str_dname(uint8_t* dname, size_t dname_len)
 206 {
 207         size_t slen=(size_t)sldns_wire2str_dname_buf(dname, dname_len, NULL, 0);
 208         char* result = (char*)malloc(slen+1);
 209         if(!result) return NULL;
 210         sldns_wire2str_dname_buf(dname, dname_len, result, slen+1);
 211         return result;
 212 }
 213
 214 char* sldns_wire2str_rcode(int rcode)
 215 {
 216         char buf[16];
 217         sldns_wire2str_rcode_buf(rcode, buf, sizeof(buf));
 218         return strdup(buf);
 219 }
 220
 221 int sldns_wire2str_pkt_buf(uint8_t* d, size_t dlen, char* s, size_t slen)
 222 {
 223         /* use arguments as temporary variables */
 224         return sldns_wire2str_pkt_scan(&d, &dlen, &s, &slen);
 225 }
 226
 227 int sldns_wire2str_rr_buf(uint8_t* d, size_t dlen, char* s, size_t slen)
 228 {
 229         /* use arguments as temporary variables */
 230         return sldns_wire2str_rr_scan(&d, &dlen, &s, &slen, NULL, 0);
 231 }
 232
 233 int sldns_wire2str_rdata_buf(uint8_t* rdata, size_t rdata_len, char* str,
 234         size_t str_len, uint16_t rrtype)
 235 {
 236         /* use arguments as temporary variables */
 237         return sldns_wire2str_rdata_scan(&rdata, &rdata_len, &str, &str_len,
 238                 rrtype, NULL, 0);
 239 }
 240
 241 int sldns_wire2str_rr_unknown_buf(uint8_t* d, size_t dlen, char* s, size_t slen)
 242 {
 243         /* use arguments as temporary variables */
 244         return sldns_wire2str_rr_unknown_scan(&d, &dlen, &s, &slen, NULL, 0);
 245 }
 246
 247 int sldns_wire2str_rr_comment_buf(uint8_t* rr, size_t rrlen, size_t dname_len,
 248         char* s, size_t slen)
 249 {
 250         uint16_t rrtype = sldns_wirerr_get_type(rr, rrlen, dname_len);
 251         return sldns_wire2str_rr_comment_print(&s, &slen, rr, rrlen, dname_len,
 252                 rrtype);
 253 }
 254
 255 int sldns_wire2str_type_buf(uint16_t rrtype, char* s, size_t slen)
 256 {
 257         /* use arguments as temporary variables */
 258         return sldns_wire2str_type_print(&s, &slen, rrtype);
 259 }
 260
 261 int sldns_wire2str_class_buf(uint16_t rrclass, char* s, size_t slen)
 262 {
 263         /* use arguments as temporary variables */
 264         return sldns_wire2str_class_print(&s, &slen, rrclass);
 265 }
 266
 267 int sldns_wire2str_rcode_buf(int rcode, char* s, size_t slen)
 268 {
 269         /* use arguments as temporary variables */
 270         return sldns_wire2str_rcode_print(&s, &slen, rcode);
 271 }
 272
 273 int sldns_wire2str_dname_buf(uint8_t* d, size_t dlen, char* s, size_t slen)
 274 {
 275         /* use arguments as temporary variables */
 276         return sldns_wire2str_dname_scan(&d, &dlen, &s, &slen, NULL, 0);
 277 }
 278
 279 int sldns_str_vprint(char** str, size_t* slen, const char* format, va_list args)
 280 {
 281         int w = vsnprintf(*str, *slen, format, args);
 282         if(w < 0) {
 283                 /* error in printout */
 284                 return 0;
 285         } else if((size_t)w >= *slen) {
 286                 *str = NULL; /* we do not want str to point outside of buffer*/
 287                 *slen = 0;
 288         } else {
 289                 *str += w;
 290                 *slen -= w;
 291         }
 292         return w;
 293 }
 294
 295 int sldns_str_print(char** str, size_t* slen, const char* format, ...)
 296 {
 297         int w;
 298         va_list args;
 299         va_start(args, format);
 300         w = sldns_str_vprint(str, slen, format, args);
 301         va_end(args);
 302         return w;
 303 }
 304
 305 /** print hex format into text buffer for specified length */
 306 static int print_hex_buf(char** s, size_t* slen, uint8_t* buf, size_t len)
 307 {
 308         const char* hex = "0123456789ABCDEF";
 309         size_t i;
 310         for(i=0; i<len; i++) {
 311                 (void)sldns_str_print(s, slen, "%c%c", hex[(buf[i]&0xf0)>>4],
 312                         hex[buf[i]&0x0f]);
 313         }
 314         return (int)len*2;
 315 }
 316
 317 /** print remainder of buffer in hex format with prefixed text */
 318 static int print_remainder_hex(const char* pref, uint8_t** d, size_t* dlen,
 319         char** s, size_t* slen)
 320 {
 321         int w = 0;
 322         w += sldns_str_print(s, slen, "%s", pref);
 323         w += print_hex_buf(s, slen, *d, *dlen);
 324         *d += *dlen;
 325         *dlen = 0;
 326         return w;
 327 }
 328
 329 int sldns_wire2str_pkt_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen)
 330 {
 331         int w = 0;
 332         unsigned qdcount, ancount, nscount, arcount, i;
 333         uint8_t* pkt = *d;
 334         size_t pktlen = *dlen;
 335         if(*dlen >= LDNS_HEADER_SIZE) {
 336                 qdcount = (unsigned)LDNS_QDCOUNT(*d);
 337                 ancount = (unsigned)LDNS_ANCOUNT(*d);
 338                 nscount = (unsigned)LDNS_NSCOUNT(*d);
 339                 arcount = (unsigned)LDNS_ARCOUNT(*d);
 340         } else {
 341                 qdcount = ancount = nscount = arcount = 0;
 342         }
 343         w += sldns_wire2str_header_scan(d, dlen, s, slen);
 344         w += sldns_str_print(s, slen, "\n");
 345         w += sldns_str_print(s, slen, ";; QUESTION SECTION:\n");
 346         for(i=0; i<qdcount; i++) {
 347                 w += sldns_wire2str_rrquestion_scan(d, dlen, s, slen,
 348                         pkt, pktlen);
 349                 if(!*dlen) break;
 350         }
 351         w += sldns_str_print(s, slen, "\n");
 352         w += sldns_str_print(s, slen, ";; ANSWER SECTION:\n");
 353         for(i=0; i<ancount; i++) {
 354                 w += sldns_wire2str_rr_scan(d, dlen, s, slen, pkt, pktlen);
 355                 if(!*dlen) break;
 356         }
 357         w += sldns_str_print(s, slen, "\n");
 358         w += sldns_str_print(s, slen, ";; AUTHORITY SECTION:\n");
 359         for(i=0; i<nscount; i++) {
 360                 w += sldns_wire2str_rr_scan(d, dlen, s, slen, pkt, pktlen);
 361                 if(!*dlen) break;
 362         }
 363         w += sldns_str_print(s, slen, "\n");
 364         w += sldns_str_print(s, slen, ";; ADDITIONAL SECTION:\n");
 365         for(i=0; i<arcount; i++) {
 366                 w += sldns_wire2str_rr_scan(d, dlen, s, slen, pkt, pktlen);
 367                 if(!*dlen) break;
 368         }
 369         /* other fields: WHEN(time), SERVER(IP) not available here. */
 370         w += sldns_str_print(s, slen, ";; MSG SIZE  rcvd: %d\n", (int)pktlen);
 371         if(*dlen > 0) {
 372                 w += print_remainder_hex(";; trailing garbage 0x",
 373                         d, dlen, s, slen);
 374                 w += sldns_str_print(s, slen, "\n");
 375         }
 376         return w;
 377 }
 378
 379 /** scan type, class and ttl and printout, for rr */
 380 static int sldns_rr_tcttl_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 381 {
 382         int w = 0;
 383         uint16_t t, c;
 384         uint32_t ttl;
 385         if(*dl < 8) {
 386                 if(*dl < 4)
 387                         return w + print_remainder_hex("; Error malformed 0x",
 388                                 d, dl, s, sl);
 389                 /* these print values or 0x.. if none left */
 390                 t = sldns_read_uint16(*d);
 391                 c = sldns_read_uint16((*d)+2);
 392                 (*d)+=4;
 393                 (*dl)-=4;
 394                 w += sldns_wire2str_class_print(s, sl, c);
 395                 w += sldns_str_print(s, sl, "\t");
 396                 w += sldns_wire2str_type_print(s, sl, t);
 397                 if(*dl == 0)
 398                         return w + sldns_str_print(s, sl, "; Error no ttl");
 399                 return w + print_remainder_hex(
 400                         "; Error malformed ttl 0x", d, dl, s, sl);
 401         }
 402         t = sldns_read_uint16(*d);
 403         c = sldns_read_uint16((*d)+2);
 404         ttl = sldns_read_uint32((*d)+4);
 405         (*d)+=8;
 406         (*dl)-=8;
 407         w += sldns_str_print(s, sl, "%lu\t", (unsigned long)ttl);
 408         w += sldns_wire2str_class_print(s, sl, c);
 409         w += sldns_str_print(s, sl, "\t");
 410         w += sldns_wire2str_type_print(s, sl, t);
 411         return w;
 412 }
 413
 414 int sldns_wire2str_rr_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen,
 415         uint8_t* pkt, size_t pktlen)
 416 {
 417         int w = 0;
 418         uint8_t* rr = *d;
 419         size_t rrlen = *dlen, dname_off, rdlen, ordlen;
 420         uint16_t rrtype = 0;
 421
 422         if(*dlen >= 3 && (*d)[0]==0 &&
 423                 sldns_read_uint16((*d)+1)==LDNS_RR_TYPE_OPT) {
 424                 /* perform EDNS OPT processing */
 425                 return sldns_wire2str_edns_scan(d, dlen, s, slen, pkt, pktlen);
 426         }
 427
 428         /* try to scan the rdata with pretty-printing, but if that fails, then
 429          * scan the rdata as an unknown RR type */
 430         w += sldns_wire2str_dname_scan(d, dlen, s, slen, pkt, pktlen);
 431         w += sldns_str_print(s, slen, "\t");
 432         dname_off = rrlen-(*dlen);
 433         if(*dlen == 4) {
 434                 /* like a question-RR */
 435                 uint16_t t = sldns_read_uint16(*d);
 436                 uint16_t c = sldns_read_uint16((*d)+2);
 437                 (*d)+=4;
 438                 (*dlen)-=4;
 439                 w += sldns_wire2str_class_print(s, slen, c);
 440                 w += sldns_str_print(s, slen, "\t");
 441                 w += sldns_wire2str_type_print(s, slen, t);
 442                 w += sldns_str_print(s, slen, " ; Error no ttl,rdata\n");
 443                 return w;
 444         }
 445         if(*dlen < 8) {
 446                 if(*dlen == 0)
 447                         return w + sldns_str_print(s, slen, ";Error missing RR\n");
 448                 w += print_remainder_hex(";Error partial RR 0x", d, dlen, s, slen);
 449                 return w + sldns_str_print(s, slen, "\n");
 450         }
 451         rrtype = sldns_read_uint16(*d);
 452         w += sldns_rr_tcttl_scan(d, dlen, s, slen);
 453         w += sldns_str_print(s, slen, "\t");
 454
 455         /* rdata */
 456         if(*dlen < 2) {
 457                 if(*dlen == 0)
 458                         return w + sldns_str_print(s, slen, ";Error missing rdatalen\n");
 459                 w += print_remainder_hex(";Error missing rdatalen 0x",
 460                         d, dlen, s, slen);
 461                 return w + sldns_str_print(s, slen, "\n");
 462         }
 463         rdlen = sldns_read_uint16(*d);
 464         ordlen = rdlen;
 465         (*d)+=2;
 466         (*dlen)-=2;
 467         if(*dlen < rdlen) {
 468                 w += sldns_str_print(s, slen, "\\# %u ", (unsigned)rdlen);
 469                 if(*dlen == 0)
 470                         return w + sldns_str_print(s, slen, ";Error missing rdata\n");
 471                 w += print_remainder_hex(";Error partial rdata 0x", d, dlen, s, slen);
 472                 return w + sldns_str_print(s, slen, "\n");
 473         }
 474         w += sldns_wire2str_rdata_scan(d, &rdlen, s, slen, rrtype, pkt, pktlen);
 475         (*dlen) -= (ordlen-rdlen);
 476
 477         /* default comment */
 478         w += sldns_wire2str_rr_comment_print(s, slen, rr, rrlen, dname_off,
 479                 rrtype);
 480         w += sldns_str_print(s, slen, "\n");
 481         return w;
 482 }
 483
 484 int sldns_wire2str_rrquestion_scan(uint8_t** d, size_t* dlen, char** s,
 485         size_t* slen, uint8_t* pkt, size_t pktlen)
 486 {
 487         int w = 0;
 488         uint16_t t, c;
 489         w += sldns_wire2str_dname_scan(d, dlen, s, slen, pkt, pktlen);
 490         w += sldns_str_print(s, slen, "\t");
 491         if(*dlen < 4) {
 492                 if(*dlen == 0)
 493                         return w + sldns_str_print(s, slen, "Error malformed\n");
 494                 w += print_remainder_hex("Error malformed 0x", d, dlen, s, slen);
 495                 return w + sldns_str_print(s, slen, "\n");
 496         }
 497         t = sldns_read_uint16(*d);
 498         c = sldns_read_uint16((*d)+2);
 499         (*d)+=4;
 500         (*dlen)-=4;
 501         w += sldns_wire2str_class_print(s, slen, c);
 502         w += sldns_str_print(s, slen, "\t");
 503         w += sldns_wire2str_type_print(s, slen, t);
 504         w += sldns_str_print(s, slen, "\n");
 505         return w;
 506 }
 507
 508 int sldns_wire2str_rr_unknown_scan(uint8_t** d, size_t* dlen, char** s,
 509         size_t* slen, uint8_t* pkt, size_t pktlen)
 510 {
 511         size_t rdlen, ordlen;
 512         int w = 0;
 513         w += sldns_wire2str_dname_scan(d, dlen, s, slen, pkt, pktlen);
 514         w += sldns_str_print(s, slen, "\t");
 515         w += sldns_rr_tcttl_scan(d, dlen, s, slen);
 516         w += sldns_str_print(s, slen, "\t");
 517         if(*dlen < 2) {
 518                 if(*dlen == 0)
 519                         return w + sldns_str_print(s, slen, ";Error missing rdatalen\n");
 520                 w += print_remainder_hex(";Error missing rdatalen 0x",
 521                         d, dlen, s, slen);
 522                 return w + sldns_str_print(s, slen, "\n");
 523         }
 524         rdlen = sldns_read_uint16(*d);
 525         ordlen = rdlen;
 526         (*d) += 2;
 527         (*dlen) -= 2;
 528         if(*dlen < rdlen) {
 529                 w += sldns_str_print(s, slen, "\\# %u ", (unsigned)rdlen);
 530                 if(*dlen == 0)
 531                         return w + sldns_str_print(s, slen, ";Error missing rdata\n");
 532                 w += print_remainder_hex(";Error partial rdata 0x", d, dlen, s, slen);
 533                 return w + sldns_str_print(s, slen, "\n");
 534         }
 535         w += sldns_wire2str_rdata_unknown_scan(d, &rdlen, s, slen);
 536         (*dlen) -= (ordlen-rdlen);
 537         w += sldns_str_print(s, slen, "\n");
 538         return w;
 539 }
 540
 541 /** print rr comment for type DNSKEY */
 542 static int rr_comment_dnskey(char** s, size_t* slen, uint8_t* rr,
 543         size_t rrlen, size_t dname_off)
 544 {
 545         size_t rdlen;
 546         uint8_t* rdata;
 547         int flags, w = 0;
 548         if(rrlen < dname_off + 10) return 0;
 549         rdlen = sldns_read_uint16(rr+dname_off+8);
 550         if(rrlen < dname_off + 10 + rdlen) return 0;
 551         rdata = rr + dname_off + 10;
 552         flags = (int)sldns_read_uint16(rdata);
 553         w += sldns_str_print(s, slen, " ;{");
 554
 555         /* id */
 556         w += sldns_str_print(s, slen, "id = %u",
 557                 sldns_calc_keytag_raw(rdata, rdlen));
 558
 559         /* flags */
 560         if((flags&LDNS_KEY_ZONE_KEY)) {
 561                 if((flags&LDNS_KEY_SEP_KEY))
 562                         w += sldns_str_print(s, slen, " (ksk)");
 563                 else    w += sldns_str_print(s, slen, " (zsk)");
 564         }
 565
 566         /* keysize */
 567         if(rdlen > 4) {
 568                 w += sldns_str_print(s, slen, ", ");
 569                 w += sldns_str_print(s, slen, "size = %db",
 570                         (int)sldns_rr_dnskey_key_size_raw(
 571                         (unsigned char*)rdata+4, rdlen-4, (int)(rdata[3])));
 572         }
 573
 574         w += sldns_str_print(s, slen, "}");
 575         return w;
 576 }
 577
 578 /** print rr comment for type RRSIG */
 579 static int rr_comment_rrsig(char** s, size_t* slen, uint8_t* rr,
 580         size_t rrlen, size_t dname_off)
 581 {
 582         size_t rdlen;
 583         uint8_t* rdata;
 584         if(rrlen < dname_off + 10) return 0;
 585         rdlen = sldns_read_uint16(rr+dname_off+8);
 586         if(rrlen < dname_off + 10 + rdlen) return 0;
 587         rdata = rr + dname_off + 10;
 588         if(rdlen < 18) return 0;
 589         return sldns_str_print(s, slen, " ;{id = %d}",
 590                 (int)sldns_read_uint16(rdata+16));
 591 }
 592
 593 /** print rr comment for type NSEC3 */
 594 static int rr_comment_nsec3(char** s, size_t* slen, uint8_t* rr,
 595         size_t rrlen, size_t dname_off)
 596 {
 597         size_t rdlen;
 598         uint8_t* rdata;
 599         int w = 0;
 600         if(rrlen < dname_off + 10) return 0;
 601         rdlen = sldns_read_uint16(rr+dname_off+8);
 602         if(rrlen < dname_off + 10 + rdlen) return 0;
 603         rdata = rr + dname_off + 10;
 604         if(rdlen < 2) return 0;
 605         if((rdata[1] & LDNS_NSEC3_VARS_OPTOUT_MASK))
 606                 w += sldns_str_print(s, slen, " ;{flags: optout}");
 607         return w;
 608 }
 609
 610 int sldns_wire2str_rr_comment_print(char** s, size_t* slen, uint8_t* rr,
 611         size_t rrlen, size_t dname_off, uint16_t rrtype)
 612 {
 613         if(rrtype == LDNS_RR_TYPE_DNSKEY) {
 614                 return rr_comment_dnskey(s, slen, rr, rrlen, dname_off);
 615         } else if(rrtype == LDNS_RR_TYPE_RRSIG) {
 616                 return rr_comment_rrsig(s, slen, rr, rrlen, dname_off);
 617         } else if(rrtype == LDNS_RR_TYPE_NSEC3) {
 618                 return rr_comment_nsec3(s, slen, rr, rrlen, dname_off);
 619         }
 620         return 0;
 621 }
 622
 623 int sldns_wire2str_header_scan(uint8_t** d, size_t* dlen, char** s,
 624         size_t* slen)
 625 {
 626         int w = 0;
 627         int opcode, rcode;
 628         w += sldns_str_print(s, slen, ";; ->>HEADER<<- ");
 629         if(*dlen == 0)
 630                 return w+sldns_str_print(s, slen, "Error empty packet");
 631         if(*dlen < 4)
 632                 return w+print_remainder_hex("Error header too short 0x", d, dlen, s, slen);
 633         opcode = (int)LDNS_OPCODE_WIRE(*d);
 634         rcode = (int)LDNS_RCODE_WIRE(*d);
 635         w += sldns_str_print(s, slen, "opcode: ");
 636         w += sldns_wire2str_opcode_print(s, slen, opcode);
 637         w += sldns_str_print(s, slen, ", ");
 638         w += sldns_str_print(s, slen, "rcode: ");
 639         w += sldns_wire2str_rcode_print(s, slen, rcode);
 640         w += sldns_str_print(s, slen, ", ");
 641         w += sldns_str_print(s, slen, "id: %d\n", (int)LDNS_ID_WIRE(*d));
 642         w += sldns_str_print(s, slen, ";; flags:");
 643         if(LDNS_QR_WIRE(*d)) w += sldns_str_print(s, slen, " qr");
 644         if(LDNS_AA_WIRE(*d)) w += sldns_str_print(s, slen, " aa");
 645         if(LDNS_TC_WIRE(*d)) w += sldns_str_print(s, slen, " tc");
 646         if(LDNS_RD_WIRE(*d)) w += sldns_str_print(s, slen, " rd");
 647         if(LDNS_CD_WIRE(*d)) w += sldns_str_print(s, slen, " cd");
 648         if(LDNS_RA_WIRE(*d)) w += sldns_str_print(s, slen, " ra");
 649         if(LDNS_AD_WIRE(*d)) w += sldns_str_print(s, slen, " ad");
 650         if(LDNS_Z_WIRE(*d))  w += sldns_str_print(s, slen, " z");
 651         w += sldns_str_print(s, slen, " ; ");
 652         if(*dlen < LDNS_HEADER_SIZE)
 653                 return w+print_remainder_hex("Error header too short 0x", d, dlen, s, slen);
 654         w += sldns_str_print(s, slen, "QUERY: %d, ", (int)LDNS_QDCOUNT(*d));
 655         w += sldns_str_print(s, slen, "ANSWER: %d, ", (int)LDNS_ANCOUNT(*d));
 656         w += sldns_str_print(s, slen, "AUTHORITY: %d, ", (int)LDNS_NSCOUNT(*d));
 657         w += sldns_str_print(s, slen, "ADDITIONAL: %d ", (int)LDNS_ARCOUNT(*d));
 658         *d += LDNS_HEADER_SIZE;
 659         *dlen -= LDNS_HEADER_SIZE;
 660         return w;
 661 }
 662
 663 int sldns_wire2str_rdata_scan(uint8_t** d, size_t* dlen, char** s,
 664         size_t* slen, uint16_t rrtype, uint8_t* pkt, size_t pktlen)
 665 {
 666         /* try to prettyprint, but if that fails, use unknown format */
 667         uint8_t* origd = *d;
 668         char* origs = *s;
 669         size_t origdlen = *dlen, origslen = *slen;
 670         size_t r_cnt, r_max;
 671         sldns_rdf_type rdftype;
 672         int w = 0, n;
 673
 674         const sldns_rr_descriptor *desc = sldns_rr_descript(rrtype);
 675         if(!desc) /* unknown format */
 676                 return sldns_wire2str_rdata_unknown_scan(d, dlen, s, slen);
 677         /* dlen equals the rdatalen for the rdata */
 678
 679         r_max = sldns_rr_descriptor_maximum(desc);
 680         for(r_cnt=0; r_cnt < r_max; r_cnt++) {
 681                 if(*dlen == 0) {
 682                         if(r_cnt < sldns_rr_descriptor_minimum(desc))
 683                                 goto failed;
 684                         break; /* nothing more to print */
 685                 }
 686                 rdftype = sldns_rr_descriptor_field_type(desc, r_cnt);
 687                 if(r_cnt != 0)
 688                         w += sldns_str_print(s, slen, " ");
 689                 n = sldns_wire2str_rdf_scan(d, dlen, s, slen, rdftype,
 690                         pkt, pktlen);
 691                 if(n == -1) {
 692                 failed:
 693                         /* failed, use unknown format */
 694                         *d = origd; *s = origs;
 695                         *dlen = origdlen; *slen = origslen;
 696                         return sldns_wire2str_rdata_unknown_scan(d, dlen,
 697                                 s, slen);
 698                 }
 699                 w += n;
 700         }
 701         if(*dlen != 0) {
 702                 goto failed;
 703         }
 704         return w;
 705 }
 706
 707 int sldns_wire2str_rdata_unknown_scan(uint8_t** d, size_t* dlen, char** s,
 708         size_t* slen)
 709 {
 710         int w = 0;
 711
 712         /* print length */
 713         w += sldns_str_print(s, slen, "\\# %u", (unsigned)*dlen);
 714
 715         /* print rdlen in hex */
 716         if(*dlen != 0)
 717                 w += sldns_str_print(s, slen, " ");
 718         w += print_hex_buf(s, slen, *d, *dlen);
 719         (*d) += *dlen;
 720         (*dlen) = 0;
 721         return w;
 722 }
 723
 724 /** print and escape one character for a domain dname */
 725 static int dname_char_print(char** s, size_t* slen, uint8_t c)
 726 {
 727         if(c == '.' || c == ';' || c == '(' || c == ')' || c == '\\')
 728                 return sldns_str_print(s, slen, "\\%c", c);
 729         else if(!(isascii((unsigned char)c) && isgraph((unsigned char)c)))
 730                 return sldns_str_print(s, slen, "\\%03u", (unsigned)c);
 731         /* plain printout */
 732         if(*slen) {
 733                 **s = (char)c;
 734                 (*s)++;
 735                 (*slen)--;
 736         }
 737         return 1;
 738 }
 739
 740 int sldns_wire2str_dname_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen,
 741         uint8_t* pkt, size_t pktlen)
 742 {
 743         int w = 0;
 744         /* spool labels onto the string, use compression if its there */
 745         uint8_t* pos = *d;
 746         unsigned i, counter=0;
 747         const unsigned maxcompr = 1000; /* loop detection, max compr ptrs */
 748         int in_buf = 1;
 749         if(*dlen == 0) return sldns_str_print(s, slen, "ErrorMissingDname");
 750         if(*pos == 0) {
 751                 (*d)++;
 752                 (*dlen)--;
 753                 return sldns_str_print(s, slen, ".");
 754         }
 755         while(*pos) {
 756                 /* read label length */
 757                 uint8_t labellen = *pos++;
 758                 if(in_buf) { (*d)++; (*dlen)--; }
 759
 760                 /* find out what sort of label we have */
 761                 if((labellen&0xc0) == 0xc0) {
 762                         /* compressed */
 763                         uint16_t target = 0;
 764                         if(in_buf && *dlen == 0)
 765                                 return w + sldns_str_print(s, slen,
 766                                         "ErrorPartialDname");
 767                         else if(!in_buf && pos+1 > pkt+pktlen)
 768                                 return w + sldns_str_print(s, slen,
 769                                         "ErrorPartialDname");
 770                         target = ((labellen&0x3f)<<8) | *pos;
 771                         if(in_buf) { (*d)++; (*dlen)--; }
 772                         /* move to target, if possible */
 773                         if(!pkt || target >= pktlen)
 774                                 return w + sldns_str_print(s, slen,
 775                                         "ErrorComprPtrOutOfBounds");
 776                         if(counter++ > maxcompr)
 777                                 return w + sldns_str_print(s, slen,
 778                                         "ErrorComprPtrLooped");
 779                         in_buf = 0;
 780                         pos = pkt+target;
 781                         continue;
 782                 } else if((labellen&0xc0)) {
 783                         /* notimpl label type */
 784                         w += sldns_str_print(s, slen,
 785                                 "ErrorLABELTYPE%xIsUnknown",
 786                                 (int)(labellen&0xc0));
 787                         return w;
 788                 }
 789
 790                 /* spool label characters, end with '.' */
 791                 if(in_buf && *dlen < (size_t)labellen)
 792                         labellen = (uint8_t)*dlen;
 793                 else if(!in_buf && pos+(size_t)labellen > pkt+pktlen)
 794                         labellen = (uint8_t)(pkt + pktlen - pos);
 795                 for(i=0; i<(unsigned)labellen; i++) {
 796                         w += dname_char_print(s, slen, *pos++);
 797                 }
 798                 if(in_buf) {
 799                         (*d) += labellen;
 800                         (*dlen) -= labellen;
 801                         if(*dlen == 0) break;
 802                 }
 803                 w += sldns_str_print(s, slen, ".");
 804         }
 805         /* skip over final root label */
 806         if(in_buf && *dlen > 0) { (*d)++; (*dlen)--; }
 807         /* in case we printed no labels, terminate dname */
 808         if(w == 0) w += sldns_str_print(s, slen, ".");
 809         return w;
 810 }
 811
 812 int sldns_wire2str_opcode_print(char** s, size_t* slen, int opcode)
 813 {
 814         sldns_lookup_table *lt = sldns_lookup_by_id(sldns_opcodes, opcode);
 815         if (lt && lt->name) {
 816                 return sldns_str_print(s, slen, "%s", lt->name);
 817         }
 818         return sldns_str_print(s, slen, "OPCODE%u", (unsigned)opcode);
 819 }
 820
 821 int sldns_wire2str_rcode_print(char** s, size_t* slen, int rcode)
 822 {
 823         sldns_lookup_table *lt = sldns_lookup_by_id(sldns_rcodes, rcode);
 824         if (lt && lt->name) {
 825                 return sldns_str_print(s, slen, "%s", lt->name);
 826         }
 827         return sldns_str_print(s, slen, "RCODE%u", (unsigned)rcode);
 828 }
 829
 830 int sldns_wire2str_class_print(char** s, size_t* slen, uint16_t rrclass)
 831 {
 832         sldns_lookup_table *lt = sldns_lookup_by_id(sldns_rr_classes,
 833                 (int)rrclass);
 834         if (lt && lt->name) {
 835                 return sldns_str_print(s, slen, "%s", lt->name);
 836         }
 837         return sldns_str_print(s, slen, "CLASS%u", (unsigned)rrclass);
 838 }
 839
 840 int sldns_wire2str_type_print(char** s, size_t* slen, uint16_t rrtype)
 841 {
 842         const sldns_rr_descriptor *descriptor = sldns_rr_descript(rrtype);
 843         if (descriptor && descriptor->_name) {
 844                 return sldns_str_print(s, slen, "%s", descriptor->_name);
 845         }
 846         return sldns_str_print(s, slen, "TYPE%u", (unsigned)rrtype);
 847 }
 848
 849 int sldns_wire2str_edns_option_code_print(char** s, size_t* slen,
 850         uint16_t opcode)
 851 {
 852         sldns_lookup_table *lt = sldns_lookup_by_id(sldns_edns_options,
 853                 (int)opcode);
 854         if (lt && lt->name) {
 855                 return sldns_str_print(s, slen, "%s", lt->name);
 856         }
 857         return sldns_str_print(s, slen, "OPT%u", (unsigned)opcode);
 858 }
 859
 860 int sldns_wire2str_class_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen)
 861 {
 862         uint16_t c;
 863         if(*dlen == 0) return 0;
 864         if(*dlen < 2) return print_remainder_hex("Error malformed 0x", d, dlen, s, slen);
 865         c = sldns_read_uint16(*d);
 866         (*d)+=2;
 867         (*dlen)-=2;
 868         return sldns_wire2str_class_print(s, slen, c);
 869 }
 870
 871 int sldns_wire2str_type_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen)
 872 {
 873         uint16_t t;
 874         if(*dlen == 0) return 0;
 875         if(*dlen < 2) return print_remainder_hex("Error malformed 0x", d, dlen, s, slen);
 876         t = sldns_read_uint16(*d);
 877         (*d)+=2;
 878         (*dlen)-=2;
 879         return sldns_wire2str_type_print(s, slen, t);
 880 }
 881
 882 int sldns_wire2str_ttl_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen)
 883 {
 884         uint32_t ttl;
 885         if(*dlen == 0) return 0;
 886         if(*dlen < 4) return print_remainder_hex("Error malformed 0x", d, dlen, s, slen);
 887         ttl = sldns_read_uint32(*d);
 888         (*d)+=4;
 889         (*dlen)-=4;
 890         return sldns_str_print(s, slen, "%u", (unsigned)ttl);
 891 }
 892
 893 int sldns_wire2str_rdf_scan(uint8_t** d, size_t* dlen, char** s, size_t* slen,
 894         int rdftype, uint8_t* pkt, size_t pktlen)
 895 {
 896         if(*dlen == 0) return 0;
 897         switch(rdftype) {
 898         case LDNS_RDF_TYPE_NONE:
 899                 return 0;
 900         case LDNS_RDF_TYPE_DNAME:
 901                 return sldns_wire2str_dname_scan(d, dlen, s, slen, pkt, pktlen);
 902         case LDNS_RDF_TYPE_INT8:
 903                 return sldns_wire2str_int8_scan(d, dlen, s, slen);
 904         case LDNS_RDF_TYPE_INT16:
 905                 return sldns_wire2str_int16_scan(d, dlen, s, slen);
 906         case LDNS_RDF_TYPE_INT32:
 907                 return sldns_wire2str_int32_scan(d, dlen, s, slen);
 908         case LDNS_RDF_TYPE_PERIOD:
 909                 return sldns_wire2str_period_scan(d, dlen, s, slen);
 910         case LDNS_RDF_TYPE_TSIGTIME:
 911                 return sldns_wire2str_tsigtime_scan(d, dlen, s, slen);
 912         case LDNS_RDF_TYPE_A:
 913                 return sldns_wire2str_a_scan(d, dlen, s, slen);
 914         case LDNS_RDF_TYPE_AAAA:
 915                 return sldns_wire2str_aaaa_scan(d, dlen, s, slen);
 916         case LDNS_RDF_TYPE_STR:
 917                 return sldns_wire2str_str_scan(d, dlen, s, slen);
 918         case LDNS_RDF_TYPE_APL:
 919                 return sldns_wire2str_apl_scan(d, dlen, s, slen);
 920         case LDNS_RDF_TYPE_B32_EXT:
 921                 return sldns_wire2str_b32_ext_scan(d, dlen, s, slen);
 922         case LDNS_RDF_TYPE_B64:
 923                 return sldns_wire2str_b64_scan(d, dlen, s, slen);
 924         case LDNS_RDF_TYPE_HEX:
 925                 return sldns_wire2str_hex_scan(d, dlen, s, slen);
 926         case LDNS_RDF_TYPE_NSEC:
 927                 return sldns_wire2str_nsec_scan(d, dlen, s, slen);
 928         case LDNS_RDF_TYPE_NSEC3_SALT:
 929                 return sldns_wire2str_nsec3_salt_scan(d, dlen, s, slen);
 930         case LDNS_RDF_TYPE_TYPE:
 931                 return sldns_wire2str_type_scan(d, dlen, s, slen);
 932         case LDNS_RDF_TYPE_CLASS:
 933                 return sldns_wire2str_class_scan(d, dlen, s, slen);
 934         case LDNS_RDF_TYPE_CERT_ALG:
 935                 return sldns_wire2str_cert_alg_scan(d, dlen, s, slen);
 936         case LDNS_RDF_TYPE_ALG:
 937                 return sldns_wire2str_alg_scan(d, dlen, s, slen);
 938         case LDNS_RDF_TYPE_UNKNOWN:
 939                 return sldns_wire2str_unknown_scan(d, dlen, s, slen);
 940         case LDNS_RDF_TYPE_TIME:
 941                 return sldns_wire2str_time_scan(d, dlen, s, slen);
 942         case LDNS_RDF_TYPE_LOC:
 943                 return sldns_wire2str_loc_scan(d, dlen, s, slen);
 944         case LDNS_RDF_TYPE_WKS:
 945         case LDNS_RDF_TYPE_SERVICE:
 946                 return sldns_wire2str_wks_scan(d, dlen, s, slen);
 947         case LDNS_RDF_TYPE_NSAP:
 948                 return sldns_wire2str_nsap_scan(d, dlen, s, slen);
 949         case LDNS_RDF_TYPE_ATMA:
 950                 return sldns_wire2str_atma_scan(d, dlen, s, slen);
 951         case LDNS_RDF_TYPE_IPSECKEY:
 952                 return sldns_wire2str_ipseckey_scan(d, dlen, s, slen, pkt,
 953                         pktlen);
 954         case LDNS_RDF_TYPE_HIP:
 955                 return sldns_wire2str_hip_scan(d, dlen, s, slen);
 956         case LDNS_RDF_TYPE_INT16_DATA:
 957                 return sldns_wire2str_int16_data_scan(d, dlen, s, slen);
 958         case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
 959                 return sldns_wire2str_b32_ext_scan(d, dlen, s, slen);
 960         case LDNS_RDF_TYPE_ILNP64:
 961                 return sldns_wire2str_ilnp64_scan(d, dlen, s, slen);
 962         case LDNS_RDF_TYPE_EUI48:
 963                 return sldns_wire2str_eui48_scan(d, dlen, s, slen);
 964         case LDNS_RDF_TYPE_EUI64:
 965                 return sldns_wire2str_eui64_scan(d, dlen, s, slen);
 966         case LDNS_RDF_TYPE_TAG:
 967                 return sldns_wire2str_tag_scan(d, dlen, s, slen);
 968         case LDNS_RDF_TYPE_LONG_STR:
 969                 return sldns_wire2str_long_str_scan(d, dlen, s, slen);
 970         }
 971         /* unknown rdf type */
 972         return -1;
 973 }
 974
 975 int sldns_wire2str_int8_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 976 {
 977         int w;
 978         if(*dl < 1) return -1;
 979         w = sldns_str_print(s, sl, "%u", (unsigned)**d);
 980         (*d)++;
 981         (*dl)--;
 982         return w;
 983 }
 984
 985 int sldns_wire2str_int16_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 986 {
 987         int w;
 988         if(*dl < 2) return -1;
 989         w = sldns_str_print(s, sl, "%lu", (unsigned long)sldns_read_uint16(*d));
 990         (*d)+=2;
 991         (*dl)-=2;
 992         return w;
 993 }
 994
 995 int sldns_wire2str_int32_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
 996 {
 997         int w;
 998         if(*dl < 4) return -1;
 999         w = sldns_str_print(s, sl, "%lu", (unsigned long)sldns_read_uint32(*d));
1000         (*d)+=4;
1001         (*dl)-=4;
1002         return w;
1003 }
1004
1005 int sldns_wire2str_period_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1006 {
1007         int w;
1008         if(*dl < 4) return -1;
1009         w = sldns_str_print(s, sl, "%u", (unsigned)sldns_read_uint32(*d));
1010         (*d)+=4;
1011         (*dl)-=4;
1012         return w;
1013 }
1014
1015 int sldns_wire2str_tsigtime_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1016 {
1017         /* tsigtime is 48 bits network order unsigned integer */
1018         int w;
1019         uint64_t tsigtime = 0;
1020         uint64_t d0, d1, d2, d3, d4, d5;
1021         if(*dl < 6) return -1;
1022         d0 = (*d)[0]; /* cast to uint64 for shift operations */
1023         d1 = (*d)[1];
1024         d2 = (*d)[2];
1025         d3 = (*d)[3];
1026         d4 = (*d)[4];
1027         d5 = (*d)[5];
1028         tsigtime = (d0<<40) | (d1<<32) | (d2<<24) | (d3<<16) | (d4<<8) | d5;
1029 #ifndef USE_WINSOCK
1030         w = sldns_str_print(s, sl, "%llu", (long long)tsigtime);
1031 #else
1032         w = sldns_str_print(s, sl, "%I64u", (long long)tsigtime);
1033 #endif
1034         (*d)+=6;
1035         (*dl)-=6;
1036         return w;
1037 }
1038
1039 int sldns_wire2str_a_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1040 {
1041         char buf[32];
1042         int w;
1043         if(*dl < 4) return -1;
1044         if(!inet_ntop(AF_INET, *d, buf, (socklen_t)sizeof(buf)))
1045                 return -1;
1046         w = sldns_str_print(s, sl, "%s", buf);
1047         (*d)+=4;
1048         (*dl)-=4;
1049         return w;
1050 }
1051
1052 int sldns_wire2str_aaaa_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1053 {
1054 #ifdef AF_INET6
1055         char buf[64];
1056         int w;
1057         if(*dl < 16) return -1;
1058         if(!inet_ntop(AF_INET6, *d, buf, (socklen_t)sizeof(buf)))
1059                 return -1;
1060         w = sldns_str_print(s, sl, "%s", buf);
1061         (*d)+=16;
1062         (*dl)-=16;
1063         return w;
1064 #else
1065         return -1;
1066 #endif
1067 }
1068
1069 /** printout escaped TYPE_STR character */
1070 static int str_char_print(char** s, size_t* sl, uint8_t c)
1071 {
1072         if(isprint((unsigned char)c) || c == '\t') {
1073                 if(c == '\"' || c == '\\')
1074                         return sldns_str_print(s, sl, "\\%c", c);
1075                 if(*sl) {
1076                         **s = (char)c;
1077                         (*s)++;
1078                         (*sl)--;
1079                 }
1080                 return 1;
1081         }
1082         return sldns_str_print(s, sl, "\\%03u", (unsigned)c);
1083 }
1084
1085 int sldns_wire2str_str_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1086 {
1087         int w = 0;
1088         size_t i, len;
1089         if(*dl < 1) return -1;
1090         len = **d;
1091         if(*dl < 1+len) return -1;
1092         (*d)++;
1093         (*dl)--;
1094         w += sldns_str_print(s, sl, "\"");
1095         for(i=0; i<len; i++)
1096                 w += str_char_print(s, sl, (*d)[i]);
1097         w += sldns_str_print(s, sl, "\"");
1098         (*d)+=len;
1099         (*dl)-=len;
1100         return w;
1101 }
1102
1103 int sldns_wire2str_apl_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1104 {
1105         int i, w = 0;
1106         uint16_t family;
1107         uint8_t negation, prefix, adflength;
1108         if(*dl < 4) return -1;
1109         family = sldns_read_uint16(*d);
1110         prefix = (*d)[2];
1111         negation = ((*d)[3] & LDNS_APL_NEGATION);
1112         adflength = ((*d)[3] & LDNS_APL_MASK);
1113         if(*dl < 4+(size_t)adflength) return -1;
1114         if(family != LDNS_APL_IP4 && family != LDNS_APL_IP6)
1115                 return -1; /* unknown address family */
1116         if(negation)
1117                 w += sldns_str_print(s, sl, "!");
1118         w += sldns_str_print(s, sl, "%u:", (unsigned)family);
1119         if(family == LDNS_APL_IP4) {
1120                 /* check if prefix <32 ? */
1121                 /* address is variable length 0 - 4 */
1122                 for(i=0; i<4; i++) {
1123                         if(i > 0)
1124                                 w += sldns_str_print(s, sl, ".");
1125                         if(i < (int)adflength)
1126                                 w += sldns_str_print(s, sl, "%d", (*d)[4+i]);
1127                         else    w += sldns_str_print(s, sl, "0");
1128                 }
1129         } else if(family == LDNS_APL_IP6) {
1130                 /* check if prefix <128 ? */
1131                 /* address is variable length 0 - 16 */
1132                 for(i=0; i<16; i++) {
1133                         if(i%2 == 0 && i>0)
1134                                 w += sldns_str_print(s, sl, ":");
1135                         if(i < (int)adflength)
1136                                 w += sldns_str_print(s, sl, "%02x", (*d)[4+i]);
1137                         else    w += sldns_str_print(s, sl, "00");
1138                 }
1139         }
1140         w += sldns_str_print(s, sl, "/%u", (unsigned)prefix);
1141         (*d) += 4+adflength;
1142         (*dl) -= 4+adflength;
1143         return w;
1144 }
1145
1146 int sldns_wire2str_b32_ext_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1147 {
1148         size_t datalen;
1149         size_t sz;
1150         if(*dl < 1) return -1;
1151         datalen = (*d)[0];
1152         if(*dl < 1+datalen) return -1;
1153         sz = sldns_b32_ntop_calculate_size(datalen);
1154         if(*sl < sz+1) {
1155                 (*d) += datalen+1;
1156                 (*dl) -= (datalen+1);
1157                 return (int)sz; /* out of space really, but would need buffer
1158                         in order to truncate the output */
1159         }
1160         sldns_b32_ntop_extended_hex((*d)+1, datalen, *s, *sl);
1161         (*d) += datalen+1;
1162         (*dl) -= (datalen+1);
1163         (*s) += sz;
1164         (*sl) -= sz;
1165         return (int)sz;
1166 }
1167
1168 /** scan number of bytes from wire into b64 presentation format */
1169 static int sldns_wire2str_b64_scan_num(uint8_t** d, size_t* dl, char** s,
1170         size_t* sl, size_t num)
1171 {
1172         /* b64_ntop_calculate size includes null at the end */
1173         size_t sz = sldns_b64_ntop_calculate_size(num)-1;
1174         if(*sl < sz+1) {
1175                 (*d) += num;
1176                 (*dl) -= num;
1177                 return (int)sz; /* out of space really, but would need buffer
1178                         in order to truncate the output */
1179         }
1180         sldns_b64_ntop(*d, num, *s, *sl);
1181         (*d) += num;
1182         (*dl) -= num;
1183         (*s) += sz;
1184         (*sl) -= sz;
1185         return (int)sz;
1186 }
1187
1188 int sldns_wire2str_b64_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1189 {
1190         return sldns_wire2str_b64_scan_num(d, dl, s, sl, *dl);
1191 }
1192
1193 int sldns_wire2str_hex_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1194 {
1195         return print_remainder_hex("", d, dl, s, sl);
1196 }
1197
1198 int sldns_wire2str_nsec_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1199 {
1200         uint8_t* p = *d;
1201         size_t pl = *dl;
1202         unsigned i, bit, window, block_len;
1203         uint16_t t;
1204         int w = 0;
1205
1206         /* check for errors */
1207         while(pl) {
1208                 if(pl < 2) return -1;
1209                 block_len = (unsigned)p[1];
1210                 if(pl < 2+block_len) return -1;
1211                 p += block_len+2;
1212                 pl -= block_len+2;
1213         }
1214
1215         /* do it */
1216         p = *d;
1217         pl = *dl;
1218         while(pl) {
1219                 if(pl < 2) return -1; /* cannot happen */
1220                 window = (unsigned)p[0];
1221                 block_len = (unsigned)p[1];
1222                 if(pl < 2+block_len) return -1; /* cannot happen */
1223                 p += 2;
1224                 for(i=0; i<block_len; i++) {
1225                         if(p[i] == 0) continue;
1226                         /* base type number for this octet */
1227                         t = ((window)<<8) | (i << 3);
1228                         for(bit=0; bit<8; bit++) {
1229                                 if((p[i]&(0x80>>bit))) {
1230                                         if(w) w += sldns_str_print(s, sl, " ");
1231                                         w += sldns_wire2str_type_print(s, sl,
1232                                                 t+bit);
1233                                 }
1234                         }
1235                 }
1236                 p += block_len;
1237                 pl -= block_len+2;
1238         }
1239         (*d) += *dl;
1240         (*dl) = 0;
1241         return w;
1242 }
1243
1244 int sldns_wire2str_nsec3_salt_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1245 {
1246         size_t salt_len;
1247         int w;
1248         if(*dl < 1) return -1;
1249         salt_len = (size_t)(*d)[0];
1250         if(*dl < 1+salt_len) return -1;
1251         (*d)++;
1252         (*dl)--;
1253         if(salt_len == 0) {
1254                 return sldns_str_print(s, sl, "-");
1255         }
1256         w = print_hex_buf(s, sl, *d, salt_len);
1257         (*dl)-=salt_len;
1258         (*d)+=salt_len;
1259         return w;
1260 }
1261
1262 int sldns_wire2str_cert_alg_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1263 {
1264         sldns_lookup_table *lt;
1265         int data, w;
1266         if(*dl < 2) return -1;
1267         data = (int)sldns_read_uint16(*d);
1268         lt = sldns_lookup_by_id(sldns_cert_algorithms, data);
1269         if(lt && lt->name)
1270                 w = sldns_str_print(s, sl, "%s", lt->name);
1271         else    w = sldns_str_print(s, sl, "%d", data);
1272         (*dl)-=2;
1273         (*d)+=2;
1274         return w;
1275 }
1276
1277 int sldns_wire2str_alg_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1278 {
1279         /* don't use algorithm mnemonics in the presentation format
1280          * this kind of got sneaked into the rfc's */
1281         return sldns_wire2str_int8_scan(d, dl, s, sl);
1282 }
1283
1284 int sldns_wire2str_unknown_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1285 {
1286         return sldns_wire2str_rdata_unknown_scan(d, dl, s, sl);
1287 }
1288
1289 int sldns_wire2str_time_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1290 {
1291         /* create a YYYYMMDDHHMMSS string if possible */
1292         struct tm tm;
1293         char date_buf[16];
1294         uint32_t t;
1295         memset(&tm, 0, sizeof(tm));
1296         if(*dl < 4) return -1;
1297         t = sldns_read_uint32(*d);
1298         date_buf[15]=0;
1299         if(sldns_serial_arithmitics_gmtime_r(t, time(NULL), &tm) &&
1300                 strftime(date_buf, 15, "%Y%m%d%H%M%S", &tm)) {
1301                 (*d) += 4;
1302                 (*dl) -= 4;
1303                 return sldns_str_print(s, sl, "%s", date_buf);
1304         }
1305         return -1;
1306 }
1307
1308 static int
1309 loc_cm_print(char** str, size_t* sl, uint8_t mantissa, uint8_t exponent)
1310 {
1311         int w = 0;
1312         uint8_t i;
1313         /* is it 0.<two digits> ? */
1314         if(exponent < 2) {
1315                 if(exponent == 1)
1316                         mantissa *= 10;
1317                 return sldns_str_print(str, sl, "0.%02ld", (long)mantissa);
1318         }
1319         /* always <digit><string of zeros> */
1320         w += sldns_str_print(str, sl, "%d", (int)mantissa);
1321         for(i=0; i<exponent-2; i++)
1322                 w += sldns_str_print(str, sl, "0");
1323         return w;
1324 }
1325
1326 int sldns_wire2str_loc_scan(uint8_t** d, size_t* dl, char** str, size_t* sl)
1327 {
1328         /* we could do checking (ie degrees < 90 etc)? */
1329         uint8_t version;
1330         uint8_t size;
1331         uint8_t horizontal_precision;
1332         uint8_t vertical_precision;
1333         uint32_t longitude;
1334         uint32_t latitude;
1335         uint32_t altitude;
1336         char northerness;
1337         char easterness;
1338         uint32_t h;
1339         uint32_t m;
1340         double s;
1341         uint32_t equator = (uint32_t)1 << 31; /* 2**31 */
1342         int w = 0;
1343
1344         if(*dl < 16) return -1;
1345         version = (*d)[0];
1346         if(version != 0)
1347                 return sldns_wire2str_hex_scan(d, dl, str, sl);
1348         size = (*d)[1];
1349         horizontal_precision = (*d)[2];
1350         vertical_precision = (*d)[3];
1351
1352         latitude = sldns_read_uint32((*d)+4);
1353         longitude = sldns_read_uint32((*d)+8);
1354         altitude = sldns_read_uint32((*d)+12);
1355
1356         if (latitude > equator) {
1357                 northerness = 'N';
1358                 latitude = latitude - equator;
1359         } else {
1360                 northerness = 'S';
1361                 latitude = equator - latitude;
1362         }
1363         h = latitude / (1000 * 60 * 60);
1364         latitude = latitude % (1000 * 60 * 60);
1365         m = latitude / (1000 * 60);
1366         latitude = latitude % (1000 * 60);
1367         s = (double) latitude / 1000.0;
1368         w += sldns_str_print(str, sl, "%02u %02u %06.3f %c ",
1369                 h, m, s, northerness);
1370
1371         if (longitude > equator) {
1372                 easterness = 'E';
1373                 longitude = longitude - equator;
1374         } else {
1375                 easterness = 'W';
1376                 longitude = equator - longitude;
1377         }
1378         h = longitude / (1000 * 60 * 60);
1379         longitude = longitude % (1000 * 60 * 60);
1380         m = longitude / (1000 * 60);
1381         longitude = longitude % (1000 * 60);
1382         s = (double) longitude / (1000.0);
1383         w += sldns_str_print(str, sl, "%02u %02u %06.3f %c ",
1384                 h, m, s, easterness);
1385
1386         s = ((double) altitude) / 100;
1387         s -= 100000;
1388
1389         if(altitude%100 != 0)
1390                 w += sldns_str_print(str, sl, "%.2f", s);
1391         else
1392                 w += sldns_str_print(str, sl, "%.0f", s);
1393
1394         w += sldns_str_print(str, sl, "m ");
1395
1396         w += loc_cm_print(str, sl, (size & 0xf0) >> 4, size & 0x0f);
1397         w += sldns_str_print(str, sl, "m ");
1398
1399         w += loc_cm_print(str, sl, (horizontal_precision & 0xf0) >> 4,
1400                 horizontal_precision & 0x0f);
1401         w += sldns_str_print(str, sl, "m ");
1402
1403         w += loc_cm_print(str, sl, (vertical_precision & 0xf0) >> 4,
1404                 vertical_precision & 0x0f);
1405         w += sldns_str_print(str, sl, "m");
1406
1407         (*d)+=16;
1408         (*dl)-=16;
1409         return w;
1410 }
1411
1412 int sldns_wire2str_wks_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1413 {
1414         /* protocol, followed by bitmap of services */
1415         const char* proto_name = NULL;
1416         struct protoent *protocol;
1417         struct servent *service;
1418         uint8_t protocol_nr;
1419         int bit, port, w = 0;
1420         size_t i;
1421         /* we cannot print with strings because they
1422          * are not portable, the presentation format may
1423          * not be able to be read in on another computer.  */
1424         int print_symbols = 0;
1425
1426         /* protocol */
1427         if(*dl < 1) return -1;
1428         protocol_nr = (*d)[0];
1429         (*d)++;
1430         (*dl)--;
1431         protocol = getprotobynumber((int)protocol_nr);
1432         if(protocol && (protocol->p_name != NULL)) {
1433                 w += sldns_str_print(s, sl, "%s", protocol->p_name);
1434                 proto_name = protocol->p_name;
1435         } else  {
1436                 w += sldns_str_print(s, sl, "%u", (unsigned)protocol_nr);
1437         }
1438
1439         for(i=0; i<*dl; i++) {
1440                 if((*d)[i] == 0)
1441                         continue;
1442                 for(bit=0; bit<8; bit++) {
1443                         if(!(((*d)[i])&(0x80>>bit)))
1444                                 continue;
1445                         port = (int)i*8 + bit;
1446
1447                         if(!print_symbols)
1448                                 service = NULL;
1449                         else
1450                                 service = getservbyport(
1451                                         (int)htons((uint16_t)port), proto_name);
1452                         if(service && service->s_name)
1453                                 w += sldns_str_print(s, sl, " %s",
1454                                         service->s_name);
1455                         else    w += sldns_str_print(s, sl, " %u",
1456                                         (unsigned)port);
1457                 }
1458         }
1459
1460 #ifdef HAVE_ENDSERVENT
1461         endservent();
1462 #endif
1463 #ifdef HAVE_ENDPROTOENT
1464         endprotoent();
1465 #endif
1466         (*d) += *dl;
1467         (*dl) = 0;
1468         return w;
1469 }
1470
1471 int sldns_wire2str_nsap_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1472 {
1473         return print_remainder_hex("0x", d, dl, s, sl);
1474 }
1475
1476 int sldns_wire2str_atma_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1477 {
1478         return print_remainder_hex("", d, dl, s, sl);
1479 }
1480
1481 /* internal scan routine that can modify arguments on failure */
1482 static int sldns_wire2str_ipseckey_scan_internal(uint8_t** d, size_t* dl,
1483         char** s, size_t* sl, uint8_t* pkt, size_t pktlen)
1484 {
1485         /* http://www.ietf.org/internet-drafts/draft-ietf-ipseckey-rr-12.txt*/
1486         uint8_t precedence, gateway_type, algorithm;
1487         int w = 0;
1488
1489         if(*dl < 3) return -1;
1490         precedence = (*d)[0];
1491         gateway_type = (*d)[1];
1492         algorithm = (*d)[2];
1493         if(gateway_type > 3)
1494                 return -1; /* unknown */
1495         (*d)+=3;
1496         (*dl)-=3;
1497         w += sldns_str_print(s, sl, "%d %d %d ",
1498                 (int)precedence, (int)gateway_type, (int)algorithm);
1499
1500         switch(gateway_type) {
1501         case 0: /* no gateway */
1502                 w += sldns_str_print(s, sl, ".");
1503                 break;
1504         case 1: /* ip4 */
1505                 w += sldns_wire2str_a_scan(d, dl, s, sl);
1506                 break;
1507         case 2: /* ip6 */
1508                 w += sldns_wire2str_aaaa_scan(d, dl, s, sl);
1509                 break;
1510         case 3: /* dname */
1511                 w += sldns_wire2str_dname_scan(d, dl, s, sl, pkt, pktlen);
1512                 break;
1513         default: /* unknown */
1514                 return -1;
1515         }
1516
1517         if(*dl < 1)
1518                 return -1;
1519         w += sldns_str_print(s, sl, " ");
1520         w += sldns_wire2str_b64_scan_num(d, dl, s, sl, *dl);
1521         return w;
1522 }
1523
1524 int sldns_wire2str_ipseckey_scan(uint8_t** d, size_t* dl, char** s, size_t* sl,
1525         uint8_t* pkt, size_t pktlen)
1526 {
1527         uint8_t* od = *d;
1528         char* os = *s;
1529         size_t odl = *dl, osl = *sl;
1530         int w=sldns_wire2str_ipseckey_scan_internal(d, dl, s, sl, pkt, pktlen);
1531         if(w == -1) {
1532                 *d = od;
1533                 *s = os;
1534                 *dl = odl;
1535                 *sl = osl;
1536                 return -1;
1537         }
1538         return w;
1539 }
1540
1541 int sldns_wire2str_hip_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1542 {
1543         int w;
1544         uint8_t algo, hitlen;
1545         uint16_t pklen;
1546
1547         /* read lengths */
1548         if(*dl < 4)
1549                 return -1;
1550         hitlen = (*d)[0];
1551         algo = (*d)[1];
1552         pklen = sldns_read_uint16((*d)+2);
1553         if(*dl < (size_t)4 + (size_t)hitlen + (size_t)pklen)
1554                 return -1;
1555
1556         /* write: algo hit pubkey */
1557         w = sldns_str_print(s, sl, "%u ", (unsigned)algo);
1558         w += print_hex_buf(s, sl, (*d)+4, hitlen);
1559         w += sldns_str_print(s, sl, " ");
1560         (*d)+=4+hitlen;
1561         (*dl)-= (4+hitlen);
1562         w += sldns_wire2str_b64_scan_num(d, dl, s, sl, pklen);
1563         return w;
1564 }
1565
1566 int sldns_wire2str_int16_data_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1567 {
1568         uint16_t n;
1569         if(*dl < 2)
1570                 return -1;
1571         n = sldns_read_uint16(*d);
1572         if(*dl < 2+(size_t)n)
1573                 return -1;
1574         (*d)+=2;
1575         (*dl)-=2;
1576         return sldns_wire2str_b64_scan_num(d, dl, s, sl, n);
1577 }
1578
1579 int sldns_wire2str_nsec3_next_owner_scan(uint8_t** d, size_t* dl, char** s,
1580         size_t* sl)
1581 {
1582         return sldns_wire2str_b32_ext_scan(d, dl, s, sl);
1583 }
1584
1585 int sldns_wire2str_ilnp64_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1586 {
1587         int w;
1588         if(*dl < 8)
1589                 return -1;
1590         w = sldns_str_print(s, sl, "%.4x:%.4x:%.4x:%.4x",
1591                 sldns_read_uint16(*d), sldns_read_uint16((*d)+2),
1592                 sldns_read_uint16((*d)+4), sldns_read_uint16((*d)+6));
1593         (*d)+=8;
1594         (*dl)-=8;
1595         return w;
1596 }
1597
1598 int sldns_wire2str_eui48_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1599 {
1600         int w;
1601         if(*dl < 6)
1602                 return -1;
1603         w = sldns_str_print(s, sl, "%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
1604                 (*d)[0], (*d)[1], (*d)[2], (*d)[3], (*d)[4], (*d)[5]);
1605         (*d)+=6;
1606         (*dl)-=6;
1607         return w;
1608 }
1609
1610 int sldns_wire2str_eui64_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1611 {
1612         int w;
1613         if(*dl < 8)
1614                 return -1;
1615         w = sldns_str_print(s, sl, "%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
1616                 (*d)[0], (*d)[1], (*d)[2], (*d)[3], (*d)[4], (*d)[5],
1617                 (*d)[6], (*d)[7]);
1618         (*d)+=8;
1619         (*dl)-=8;
1620         return w;
1621 }
1622
1623 int sldns_wire2str_tag_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1624 {
1625         size_t i, n;
1626         int w = 0;
1627         if(*dl < 1)
1628                 return -1;
1629         n = (size_t)((*d)[0]);
1630         if(*dl < 1+n)
1631                 return -1;
1632         for(i=0; i<n; i++)
1633                 if(!isalnum((unsigned char)(*d)[i]))
1634                         return -1;
1635         for(i=0; i<n; i++)
1636                 w += sldns_str_print(s, sl, "%c", (char)(*d)[i]);
1637         (*d)+=n+1;
1638         (*dl)-=(n+1);
1639         return w;
1640 }
1641
1642 int sldns_wire2str_long_str_scan(uint8_t** d, size_t* dl, char** s, size_t* sl)
1643 {
1644         size_t i;
1645         int w = 0;
1646         w += sldns_str_print(s, sl, "\"");
1647         for(i=0; i<*dl; i++)
1648                 w += str_char_print(s, sl, (*d)[i]);
1649         w += sldns_str_print(s, sl, "\"");
1650         (*d)+=*dl;
1651         (*dl)=0;
1652         return w;
1653 }
1654
1655 int sldns_wire2str_edns_llq_print(char** s, size_t* sl, uint8_t* data,
1656         size_t len)
1657 {
1658         /* LLQ constants */
1659         const char* llq_errors[] = {"NO-ERROR", "SERV-FULL", "STATIC",
1660                 "FORMAT-ERR", "NO-SUCH-LLQ", "BAD-VERS", "UNKNOWN_ERR"};
1661         const unsigned int llq_errors_num = 7;
1662         const char* llq_opcodes[] = {"LLQ-SETUP", "LLQ-REFRESH", "LLQ-EVENT"};
1663         const unsigned int llq_opcodes_num = 3;
1664         uint16_t version, llq_opcode, error_code;
1665         uint64_t llq_id;
1666         uint32_t lease_life; /* Requested or granted life of LLQ, in seconds */
1667         int w = 0;
1668
1669         /* read the record */
1670         if(len != 18) {
1671                 w += sldns_str_print(s, sl, "malformed LLQ ");
1672                 w += print_hex_buf(s, sl, data, len);
1673                 return w;
1674         }
1675         version = sldns_read_uint16(data);
1676         llq_opcode = sldns_read_uint16(data+2);
1677         error_code = sldns_read_uint16(data+4);
1678         memmove(&llq_id, data+6, sizeof(llq_id));
1679         lease_life = sldns_read_uint32(data+14);
1680
1681         /* print it */
1682         w += sldns_str_print(s, sl, "v%d ", (int)version);
1683         if(llq_opcode < llq_opcodes_num)
1684                 w += sldns_str_print(s, sl, "%s", llq_opcodes[llq_opcode]);
1685         else    w += sldns_str_print(s, sl, "opcode %d", (int)llq_opcode);
1686         if(error_code < llq_errors_num)
1687                 w += sldns_str_print(s, sl, " %s", llq_errors[error_code]);
1688         else    w += sldns_str_print(s, sl, " error %d", (int)error_code);
1689 #ifndef USE_WINSOCK
1690         w += sldns_str_print(s, sl, " id %llx lease-life %lu",
1691                 (unsigned long long)llq_id, (unsigned long)lease_life);
1692 #else
1693         w += sldns_str_print(s, sl, " id %I64x lease-life %lu",
1694                 (unsigned long long)llq_id, (unsigned long)lease_life);
1695 #endif
1696         return w;
1697 }
1698
1699 int sldns_wire2str_edns_ul_print(char** s, size_t* sl, uint8_t* data,
1700         size_t len)
1701 {
1702         uint32_t lease;
1703         int w = 0;
1704         if(len != 4) {
1705                 w += sldns_str_print(s, sl, "malformed UL ");
1706                 w += print_hex_buf(s, sl, data, len);
1707                 return w;
1708         }
1709         lease = sldns_read_uint32(data);
1710         w += sldns_str_print(s, sl, "lease %lu", (unsigned long)lease);
1711         return w;
1712 }
1713
1714 int sldns_wire2str_edns_nsid_print(char** s, size_t* sl, uint8_t* data,
1715         size_t len)
1716 {
1717         int w = 0;
1718         size_t i, printed=0;
1719         w += print_hex_buf(s, sl, data, len);
1720         for(i=0; i<len; i++) {
1721                 if(isprint((unsigned char)data[i]) || data[i] == '\t') {
1722                         if(!printed) {
1723                                 w += sldns_str_print(s, sl, " (");
1724                                 printed = 1;
1725                         }
1726                         w += sldns_str_print(s, sl, "%c", (char)data[i]);
1727                 }
1728         }
1729         if(printed)
1730                 w += sldns_str_print(s, sl, ")");
1731         return w;
1732 }
1733
1734 int sldns_wire2str_edns_dau_print(char** s, size_t* sl, uint8_t* data,
1735         size_t len)
1736 {
1737         sldns_lookup_table *lt;
1738         size_t i;
1739         int w = 0;
1740         for(i=0; i<len; i++) {
1741                 lt = sldns_lookup_by_id(sldns_algorithms, (int)data[i]);
1742                 if(lt && lt->name)
1743                         w += sldns_str_print(s, sl, " %s", lt->name);
1744                 else    w += sldns_str_print(s, sl, " %d", (int)data[i]);
1745         }
1746         return w;
1747 }
1748
1749 int sldns_wire2str_edns_dhu_print(char** s, size_t* sl, uint8_t* data,
1750         size_t len)
1751 {
1752         sldns_lookup_table *lt;
1753         size_t i;
1754         int w = 0;
1755         for(i=0; i<len; i++) {
1756                 lt = sldns_lookup_by_id(sldns_hashes, (int)data[i]);
1757                 if(lt && lt->name)
1758                         w += sldns_str_print(s, sl, " %s", lt->name);
1759                 else    w += sldns_str_print(s, sl, " %d", (int)data[i]);
1760         }
1761         return w;
1762 }
1763
1764 int sldns_wire2str_edns_n3u_print(char** s, size_t* sl, uint8_t* data,
1765         size_t len)
1766 {
1767         size_t i;
1768         int w = 0;
1769         for(i=0; i<len; i++) {
1770                 if(data[i] == 1)
1771                         w += sldns_str_print(s, sl, " SHA1");
1772                 else    w += sldns_str_print(s, sl, " %d", (int)data[i]);
1773         }
1774         return w;
1775 }
1776
1777 int sldns_wire2str_edns_subnet_print(char** s, size_t* sl, uint8_t* data,
1778         size_t len)
1779 {
1780         int w = 0;
1781         uint16_t family;
1782         uint8_t source, scope;
1783         if(len < 4) {
1784                 w += sldns_str_print(s, sl, "malformed subnet ");
1785                 w += print_hex_buf(s, sl, data, len);
1786                 return w;
1787         }
1788         family = sldns_read_uint16(data);
1789         source = data[2];
1790         scope = data[3];
1791         if(family == 1) {
1792                 /* IP4 */
1793                 char buf[64];
1794                 uint8_t ip4[4];
1795                 memset(ip4, 0, sizeof(ip4));
1796                 if(len-4 > 4) {
1797                         w += sldns_str_print(s, sl, "trailingdata:");
1798                         w += print_hex_buf(s, sl, data+4+4, len-4-4);
1799                         w += sldns_str_print(s, sl, " ");
1800                         len = 4+4;
1801                 }
1802                 memmove(ip4, data+4, len-4);
1803                 if(!inet_ntop(AF_INET, ip4, buf, (socklen_t)sizeof(buf))) {
1804                         w += sldns_str_print(s, sl, "ip4ntoperror ");
1805                         w += print_hex_buf(s, sl, data+4+4, len-4-4);
1806                 } else {
1807                         w += sldns_str_print(s, sl, "%s", buf);
1808                 }
1809         } else if(family == 2) {
1810                 /* IP6 */
1811                 char buf[64];
1812                 uint8_t ip6[16];
1813                 memset(ip6, 0, sizeof(ip6));
1814                 if(len-4 > 16) {
1815                         w += sldns_str_print(s, sl, "trailingdata:");
1816                         w += print_hex_buf(s, sl, data+4+16, len-4-16);
1817                         w += sldns_str_print(s, sl, " ");
1818                         len = 4+16;
1819                 }
1820                 memmove(ip6, data+4, len-4);
1821 #ifdef AF_INET6
1822                 if(!inet_ntop(AF_INET6, ip6, buf, (socklen_t)sizeof(buf))) {
1823                         w += sldns_str_print(s, sl, "ip6ntoperror ");
1824                         w += print_hex_buf(s, sl, data+4+4, len-4-4);
1825                 } else {
1826                         w += sldns_str_print(s, sl, "%s", buf);
1827                 }
1828 #else
1829                 w += print_hex_buf(s, sl, data+4+4, len-4-4);
1830 #endif
1831         } else {
1832                 /* unknown */
1833                 w += sldns_str_print(s, sl, "family %d ",
1834                         (int)family);
1835                 w += print_hex_buf(s, sl, data, len);
1836         }
1837         w += sldns_str_print(s, sl, "/%d scope /%d", (int)source, (int)scope);
1838         return w;
1839 }
1840
1841 int sldns_wire2str_edns_option_print(char** s, size_t* sl,
1842         uint16_t option_code, uint8_t* optdata, size_t optlen)
1843 {
1844         int w = 0;
1845         w += sldns_wire2str_edns_option_code_print(s, sl, option_code);
1846         w += sldns_str_print(s, sl, ": ");
1847         switch(option_code) {
1848         case LDNS_EDNS_LLQ:
1849                 w += sldns_wire2str_edns_llq_print(s, sl, optdata, optlen);
1850                 break;
1851         case LDNS_EDNS_UL:
1852                 w += sldns_wire2str_edns_ul_print(s, sl, optdata, optlen);
1853                 break;
1854         case LDNS_EDNS_NSID:
1855                 w += sldns_wire2str_edns_nsid_print(s, sl, optdata, optlen);
1856                 break;
1857         case LDNS_EDNS_DAU:
1858                 w += sldns_wire2str_edns_dau_print(s, sl, optdata, optlen);
1859                 break;
1860         case LDNS_EDNS_DHU:
1861                 w += sldns_wire2str_edns_dhu_print(s, sl, optdata, optlen);
1862                 break;
1863         case LDNS_EDNS_N3U:
1864                 w += sldns_wire2str_edns_n3u_print(s, sl, optdata, optlen);
1865                 break;
1866         case LDNS_EDNS_CLIENT_SUBNET:
1867                 w += sldns_wire2str_edns_subnet_print(s, sl, optdata, optlen);
1868                 break;
1869         case LDNS_EDNS_PADDING:
1870                 w += print_hex_buf(s, sl, optdata, optlen);
1871                 break;
1872         default:
1873                 /* unknown option code */
1874                 w += print_hex_buf(s, sl, optdata, optlen);
1875                 break;
1876         }
1877         return w;
1878 }
1879
1880 /** print the edns options to string */
1881 static int
1882 print_edns_opts(char** s, size_t* sl, uint8_t* rdata, size_t rdatalen)
1883 {
1884         uint16_t option_code, option_len;
1885         int w = 0;
1886         while(rdatalen > 0) {
1887                 /* option name */
1888                 if(rdatalen < 4) {
1889                         w += sldns_str_print(s, sl, " ; malformed: ");
1890                         w += print_hex_buf(s, sl, rdata, rdatalen);
1891                         return w;
1892                 }
1893                 option_code = sldns_read_uint16(rdata);
1894                 option_len = sldns_read_uint16(rdata+2);
1895                 rdata += 4;
1896                 rdatalen -= 4;
1897
1898                 /* option value */
1899                 if(rdatalen < (size_t)option_len) {
1900                         w += sldns_str_print(s, sl, " ; malformed ");
1901                         w += sldns_wire2str_edns_option_code_print(s, sl,
1902                                 option_code);
1903                         w += sldns_str_print(s, sl, ": ");
1904                         w += print_hex_buf(s, sl, rdata, rdatalen);
1905                         return w;
1906                 }
1907                 w += sldns_str_print(s, sl, " ; ");
1908                 w += sldns_wire2str_edns_option_print(s, sl, option_code,
1909                         rdata, option_len);
1910                 rdata += option_len;
1911                 rdatalen -= option_len;
1912         }
1913         return w;
1914 }
1915
1916 int sldns_wire2str_edns_scan(uint8_t** data, size_t* data_len, char** str,
1917         size_t* str_len, uint8_t* pkt, size_t pktlen)
1918 {
1919         int w = 0;
1920         uint8_t ext_rcode, edns_version;
1921         uint16_t udpsize, edns_bits, rdatalen;
1922         w += sldns_str_print(str, str_len, "; EDNS:");
1923
1924         /* some input checks, domain name */
1925         if(*data_len < 1+10)
1926                 return w + print_remainder_hex("Error malformed 0x",
1927                         data, data_len, str, str_len);
1928         if(*data[0] != 0) {
1929                 return w + print_remainder_hex("Error nonrootdname 0x",
1930                         data, data_len, str, str_len);
1931         }
1932         (*data)++;
1933         (*data_len)--;
1934
1935         /* check type and read fixed contents */
1936         if(sldns_read_uint16((*data)) != LDNS_RR_TYPE_OPT) {
1937                 return w + print_remainder_hex("Error nottypeOPT 0x",
1938                         data, data_len, str, str_len);
1939         }
1940         udpsize = sldns_read_uint16((*data)+2);
1941         ext_rcode = (*data)[4];
1942         edns_version = (*data)[5];
1943         edns_bits = sldns_read_uint16((*data)+6);
1944         rdatalen = sldns_read_uint16((*data)+8);
1945         (*data)+=10;
1946         (*data_len)-=10;
1947
1948         w += sldns_str_print(str, str_len, " version: %u;",
1949                 (unsigned)edns_version);
1950         w += sldns_str_print(str, str_len, " flags:");
1951         if((edns_bits & LDNS_EDNS_MASK_DO_BIT))
1952                 w += sldns_str_print(str, str_len, " do");
1953         /* the extended rcode is the value set, shifted four bits,
1954          * and or'd with the original rcode */
1955         if(ext_rcode) {
1956                 int rc = ((int)ext_rcode)<<4;
1957                 if(pkt && pktlen >= LDNS_HEADER_SIZE)
1958                         rc |= LDNS_RCODE_WIRE(pkt);
1959                 w += sldns_str_print(str, str_len, " ; ext-rcode: %d", rc);
1960         }
1961         w += sldns_str_print(str, str_len, " ; udp: %u", (unsigned)udpsize);
1962
1963         if(rdatalen) {
1964                 if((size_t)*data_len < rdatalen) {
1965                         w += sldns_str_print(str, str_len,
1966                                 " ; Error EDNS rdata too short; ");
1967                         rdatalen = (uint16_t)*data_len;
1968                 }
1969                 w += print_edns_opts(str, str_len, *data, rdatalen);
1970                 (*data) += rdatalen;
1971                 (*data_len) -= rdatalen;
1972         }
1973         w += sldns_str_print(str, str_len, "\n");
1974         return w;
1975 }