1ae8c6e27Sflorian /** 2ae8c6e27Sflorian * str2wire.c - read txt presentation of RRs 3ae8c6e27Sflorian * 4ae8c6e27Sflorian * (c) NLnet Labs, 2005-2006 5ae8c6e27Sflorian * 6ae8c6e27Sflorian * See the file LICENSE for the license 7ae8c6e27Sflorian */ 8ae8c6e27Sflorian 9ae8c6e27Sflorian /** 10ae8c6e27Sflorian * \file 11ae8c6e27Sflorian * 12ae8c6e27Sflorian * Parses text to wireformat. 13ae8c6e27Sflorian */ 14ae8c6e27Sflorian #include "config.h" 15ae8c6e27Sflorian #include "sldns/str2wire.h" 16ae8c6e27Sflorian #include "sldns/wire2str.h" 17ae8c6e27Sflorian #include "sldns/sbuffer.h" 18ae8c6e27Sflorian #include "sldns/parse.h" 19ae8c6e27Sflorian #include "sldns/parseutil.h" 20ae8c6e27Sflorian #include <ctype.h> 21ae8c6e27Sflorian #ifdef HAVE_TIME_H 22ae8c6e27Sflorian #include <time.h> 23ae8c6e27Sflorian #endif 24ae8c6e27Sflorian #ifdef HAVE_NETDB_H 25ae8c6e27Sflorian #include <netdb.h> 26ae8c6e27Sflorian #endif 27ae8c6e27Sflorian 28ae8c6e27Sflorian /** return an error */ 29ae8c6e27Sflorian #define RET_ERR(e, off) ((int)((e)|((off)<<LDNS_WIREPARSE_SHIFT))) 30ae8c6e27Sflorian /** Move parse error but keep its ID */ 31ae8c6e27Sflorian #define RET_ERR_SHIFT(e, move) RET_ERR(LDNS_WIREPARSE_ERROR(e), LDNS_WIREPARSE_OFFSET(e)+(move)); 32ae8c6e27Sflorian #define LDNS_IP6ADDRLEN (128/8) 33ae8c6e27Sflorian 34ae8c6e27Sflorian /* 35ae8c6e27Sflorian * No special care is taken, all dots are translated into 36ae8c6e27Sflorian * label separators. 37ae8c6e27Sflorian * @param rel: true if the domain is not absolute (not terminated in .). 38ae8c6e27Sflorian * The output is then still terminated with a '0' rootlabel. 39ae8c6e27Sflorian */ 40ae8c6e27Sflorian static int sldns_str2wire_dname_buf_rel(const char* str, uint8_t* buf, 41ae8c6e27Sflorian size_t* olen, int* rel) 42ae8c6e27Sflorian { 43ae8c6e27Sflorian size_t len; 44ae8c6e27Sflorian 45ae8c6e27Sflorian const char *s; 46ae8c6e27Sflorian uint8_t *q, *pq, label_len; 47ae8c6e27Sflorian 48ae8c6e27Sflorian if(rel) *rel = 0; 49ae8c6e27Sflorian len = strlen((char*)str); 50ae8c6e27Sflorian /* octet representation can make strings a lot longer than actual length */ 51ae8c6e27Sflorian if (len > LDNS_MAX_DOMAINLEN * 4) { 52ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW, 0); 53ae8c6e27Sflorian } 54ae8c6e27Sflorian if (0 == len) { 55ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_DOMAINNAME_UNDERFLOW, 0); 56ae8c6e27Sflorian } 57ae8c6e27Sflorian 58ae8c6e27Sflorian /* root label */ 59ae8c6e27Sflorian if (1 == len && *str == '.') { 60ae8c6e27Sflorian if(*olen < 1) 61ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 0); 62ae8c6e27Sflorian buf[0] = 0; 63ae8c6e27Sflorian *olen = 1; 64ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 65ae8c6e27Sflorian } 66ae8c6e27Sflorian 67ae8c6e27Sflorian /* get on with the rest */ 68ae8c6e27Sflorian 69ae8c6e27Sflorian /* s is on the current character in the string 70ae8c6e27Sflorian * pq points to where the labellength is going to go 71ae8c6e27Sflorian * label_len keeps track of the current label's length 72ae8c6e27Sflorian * q builds the dname inside the buf array 73ae8c6e27Sflorian */ 74ae8c6e27Sflorian len = 0; 75ae8c6e27Sflorian if(*olen < 1) 76ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 0); 77ae8c6e27Sflorian q = buf+1; 78ae8c6e27Sflorian pq = buf; 79ae8c6e27Sflorian label_len = 0; 80ae8c6e27Sflorian for (s = str; *s; s++, q++) { 81ae8c6e27Sflorian if (q >= buf + *olen) 82ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, q-buf); 83*d32eb43cSflorian if (q >= buf + LDNS_MAX_DOMAINLEN) 84ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW, q-buf); 85ae8c6e27Sflorian switch (*s) { 86ae8c6e27Sflorian case '.': 87ae8c6e27Sflorian if (label_len > LDNS_MAX_LABELLEN) { 88ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_LABEL_OVERFLOW, q-buf); 89ae8c6e27Sflorian } 90ae8c6e27Sflorian if (label_len == 0) { 91ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_EMPTY_LABEL, q-buf); 92ae8c6e27Sflorian } 93ae8c6e27Sflorian len += label_len + 1; 94ae8c6e27Sflorian *q = 0; 95ae8c6e27Sflorian *pq = label_len; 96ae8c6e27Sflorian label_len = 0; 97ae8c6e27Sflorian pq = q; 98ae8c6e27Sflorian break; 99ae8c6e27Sflorian case '\\': 100ae8c6e27Sflorian /* octet value or literal char */ 101ae8c6e27Sflorian s += 1; 102ae8c6e27Sflorian if (!sldns_parse_escape(q, &s)) { 103ae8c6e27Sflorian *q = 0; 104ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_BAD_ESCAPE, q-buf); 105ae8c6e27Sflorian } 106ae8c6e27Sflorian s -= 1; 107ae8c6e27Sflorian label_len++; 108ae8c6e27Sflorian break; 109ae8c6e27Sflorian default: 110ae8c6e27Sflorian *q = (uint8_t)*s; 111ae8c6e27Sflorian label_len++; 112ae8c6e27Sflorian } 113ae8c6e27Sflorian } 114ae8c6e27Sflorian 115ae8c6e27Sflorian /* add root label if last char was not '.' */ 116ae8c6e27Sflorian if(label_len != 0) { 117ae8c6e27Sflorian if(rel) *rel = 1; 118ae8c6e27Sflorian if (q >= buf + *olen) 119ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, q-buf); 120*d32eb43cSflorian if (q >= buf + LDNS_MAX_DOMAINLEN) { 121ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW, q-buf); 122ae8c6e27Sflorian } 123ae8c6e27Sflorian if (label_len > LDNS_MAX_LABELLEN) { 124ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_LABEL_OVERFLOW, q-buf); 125ae8c6e27Sflorian } 126ae8c6e27Sflorian if (label_len == 0) { /* label_len 0 but not . at end? */ 127ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_EMPTY_LABEL, q-buf); 128ae8c6e27Sflorian } 129ae8c6e27Sflorian len += label_len + 1; 130ae8c6e27Sflorian *pq = label_len; 131ae8c6e27Sflorian *q = 0; 132ae8c6e27Sflorian } 133ae8c6e27Sflorian len++; 134ae8c6e27Sflorian *olen = len; 135ae8c6e27Sflorian 136ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 137ae8c6e27Sflorian } 138ae8c6e27Sflorian 139ae8c6e27Sflorian int sldns_str2wire_dname_buf(const char* str, uint8_t* buf, size_t* len) 140ae8c6e27Sflorian { 141ae8c6e27Sflorian return sldns_str2wire_dname_buf_rel(str, buf, len, NULL); 142ae8c6e27Sflorian } 143ae8c6e27Sflorian 144ae8c6e27Sflorian int sldns_str2wire_dname_buf_origin(const char* str, uint8_t* buf, size_t* len, 145ae8c6e27Sflorian uint8_t* origin, size_t origin_len) 146ae8c6e27Sflorian { 147ae8c6e27Sflorian size_t dlen = *len; 148ae8c6e27Sflorian int rel = 0; 149ae8c6e27Sflorian int s = sldns_str2wire_dname_buf_rel(str, buf, &dlen, &rel); 150ae8c6e27Sflorian if(s) return s; 151ae8c6e27Sflorian 152ae8c6e27Sflorian if(rel && origin && dlen > 0) { 15357403691Sflorian if((unsigned)dlen >= 0x00ffffffU || 15457403691Sflorian (unsigned)origin_len >= 0x00ffffffU) 15557403691Sflorian /* guard against integer overflow in addition */ 15657403691Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_GENERAL, *len); 157ae8c6e27Sflorian if(dlen + origin_len - 1 > LDNS_MAX_DOMAINLEN) 158ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW, 159ae8c6e27Sflorian LDNS_MAX_DOMAINLEN); 160ae8c6e27Sflorian if(dlen + origin_len - 1 > *len) 161ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 162ae8c6e27Sflorian *len); 163ae8c6e27Sflorian memmove(buf+dlen-1, origin, origin_len); 164ae8c6e27Sflorian *len = dlen + origin_len - 1; 165ae8c6e27Sflorian } else 166ae8c6e27Sflorian *len = dlen; 167ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 168ae8c6e27Sflorian } 169ae8c6e27Sflorian 170ae8c6e27Sflorian uint8_t* sldns_str2wire_dname(const char* str, size_t* len) 171ae8c6e27Sflorian { 172ae8c6e27Sflorian uint8_t dname[LDNS_MAX_DOMAINLEN+1]; 173ae8c6e27Sflorian *len = sizeof(dname); 174ae8c6e27Sflorian if(sldns_str2wire_dname_buf(str, dname, len) == 0) { 17557403691Sflorian uint8_t* r; 17657403691Sflorian if(*len > sizeof(dname)) return NULL; 17757403691Sflorian r = (uint8_t*)malloc(*len); 178ae8c6e27Sflorian if(r) return memcpy(r, dname, *len); 179ae8c6e27Sflorian } 180ae8c6e27Sflorian *len = 0; 181ae8c6e27Sflorian return NULL; 182ae8c6e27Sflorian } 183ae8c6e27Sflorian 184ae8c6e27Sflorian /** read owner name */ 185ae8c6e27Sflorian static int 186ae8c6e27Sflorian rrinternal_get_owner(sldns_buffer* strbuf, uint8_t* rr, size_t* len, 187ae8c6e27Sflorian size_t* dname_len, uint8_t* origin, size_t origin_len, uint8_t* prev, 188ae8c6e27Sflorian size_t prev_len, char* token, size_t token_len) 189ae8c6e27Sflorian { 190ae8c6e27Sflorian /* split the rr in its parts -1 signals trouble */ 191ae8c6e27Sflorian if(sldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) { 192ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX, 193ae8c6e27Sflorian sldns_buffer_position(strbuf)); 194ae8c6e27Sflorian } 195ae8c6e27Sflorian 19657403691Sflorian if(token_len < 2) /* make sure there is space to read "@" or "" */ 19757403691Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 19857403691Sflorian sldns_buffer_position(strbuf)); 199da8c8390Sflorian if(token[0]=='@' && token[1]=='\0') { 200ae8c6e27Sflorian uint8_t* tocopy; 201ae8c6e27Sflorian if (origin) { 202ae8c6e27Sflorian *dname_len = origin_len; 203ae8c6e27Sflorian tocopy = origin; 204ae8c6e27Sflorian } else if (prev) { 205ae8c6e27Sflorian *dname_len = prev_len; 206ae8c6e27Sflorian tocopy = prev; 207ae8c6e27Sflorian } else { 208ae8c6e27Sflorian /* default to root */ 209ae8c6e27Sflorian *dname_len = 1; 210ae8c6e27Sflorian tocopy = (uint8_t*)"\0"; 211ae8c6e27Sflorian } 212ae8c6e27Sflorian if(*len < *dname_len) 213ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 214ae8c6e27Sflorian sldns_buffer_position(strbuf)); 215ae8c6e27Sflorian memmove(rr, tocopy, *dname_len); 216ae8c6e27Sflorian } else if(*token == '\0') { 217ae8c6e27Sflorian /* no ownername was given, try prev, if that fails 218ae8c6e27Sflorian * origin, else default to root */ 219ae8c6e27Sflorian uint8_t* tocopy; 220ae8c6e27Sflorian if(prev) { 221ae8c6e27Sflorian *dname_len = prev_len; 222ae8c6e27Sflorian tocopy = prev; 223ae8c6e27Sflorian } else if(origin) { 224ae8c6e27Sflorian *dname_len = origin_len; 225ae8c6e27Sflorian tocopy = origin; 226ae8c6e27Sflorian } else { 227ae8c6e27Sflorian *dname_len = 1; 228ae8c6e27Sflorian tocopy = (uint8_t*)"\0"; 229ae8c6e27Sflorian } 230ae8c6e27Sflorian if(*len < *dname_len) 231ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 232ae8c6e27Sflorian sldns_buffer_position(strbuf)); 233ae8c6e27Sflorian memmove(rr, tocopy, *dname_len); 234ae8c6e27Sflorian } else { 235ae8c6e27Sflorian size_t dlen = *len; 236ae8c6e27Sflorian int s = sldns_str2wire_dname_buf_origin(token, rr, &dlen, 237ae8c6e27Sflorian origin, origin_len); 238ae8c6e27Sflorian if(s) return RET_ERR_SHIFT(s, 239ae8c6e27Sflorian sldns_buffer_position(strbuf)-strlen(token)); 240ae8c6e27Sflorian *dname_len = dlen; 241ae8c6e27Sflorian } 242ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 243ae8c6e27Sflorian } 244ae8c6e27Sflorian 245ae8c6e27Sflorian /** read ttl */ 246ae8c6e27Sflorian static int 247ae8c6e27Sflorian rrinternal_get_ttl(sldns_buffer* strbuf, char* token, size_t token_len, 248ae8c6e27Sflorian int* not_there, uint32_t* ttl, uint32_t default_ttl) 249ae8c6e27Sflorian { 250ae8c6e27Sflorian const char* endptr; 251ae8c6e27Sflorian if(sldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) { 252ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TTL, 253ae8c6e27Sflorian sldns_buffer_position(strbuf)); 254ae8c6e27Sflorian } 255ae8c6e27Sflorian *ttl = (uint32_t) sldns_str2period(token, &endptr); 256ae8c6e27Sflorian 257ae8c6e27Sflorian if (strlen(token) > 0 && !isdigit((unsigned char)token[0])) { 258ae8c6e27Sflorian *not_there = 1; 259ae8c6e27Sflorian /* ah, it's not there or something */ 260ae8c6e27Sflorian if (default_ttl == 0) { 261ae8c6e27Sflorian *ttl = LDNS_DEFAULT_TTL; 262ae8c6e27Sflorian } else { 263ae8c6e27Sflorian *ttl = default_ttl; 264ae8c6e27Sflorian } 265ae8c6e27Sflorian } 266ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 267ae8c6e27Sflorian } 268ae8c6e27Sflorian 269ae8c6e27Sflorian /** read class */ 270ae8c6e27Sflorian static int 271ae8c6e27Sflorian rrinternal_get_class(sldns_buffer* strbuf, char* token, size_t token_len, 272ae8c6e27Sflorian int* not_there, uint16_t* cl) 273ae8c6e27Sflorian { 274ae8c6e27Sflorian /* if 'not_there' then we got token from previous parse routine */ 275ae8c6e27Sflorian if(!*not_there) { 276ae8c6e27Sflorian /* parse new token for class */ 277ae8c6e27Sflorian if(sldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) { 278ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_CLASS, 279ae8c6e27Sflorian sldns_buffer_position(strbuf)); 280ae8c6e27Sflorian } 281ae8c6e27Sflorian } else *not_there = 0; 282ae8c6e27Sflorian *cl = sldns_get_rr_class_by_name(token); 283ae8c6e27Sflorian /* class can be left out too, assume IN, current token must be type */ 284ae8c6e27Sflorian if(*cl == 0 && strcmp(token, "CLASS0") != 0) { 285ae8c6e27Sflorian *not_there = 1; 286ae8c6e27Sflorian *cl = LDNS_RR_CLASS_IN; 287ae8c6e27Sflorian } 288ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 289ae8c6e27Sflorian } 290ae8c6e27Sflorian 291ae8c6e27Sflorian /** read type */ 292ae8c6e27Sflorian static int 293ae8c6e27Sflorian rrinternal_get_type(sldns_buffer* strbuf, char* token, size_t token_len, 294ae8c6e27Sflorian int* not_there, uint16_t* tp) 295ae8c6e27Sflorian { 296ae8c6e27Sflorian /* if 'not_there' then we got token from previous parse routine */ 297ae8c6e27Sflorian if(!*not_there) { 298ae8c6e27Sflorian /* parse new token for type */ 299ae8c6e27Sflorian if(sldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) { 300ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TYPE, 301ae8c6e27Sflorian sldns_buffer_position(strbuf)); 302ae8c6e27Sflorian } 303ae8c6e27Sflorian } 304ae8c6e27Sflorian *tp = sldns_get_rr_type_by_name(token); 305ae8c6e27Sflorian if(*tp == 0 && strcmp(token, "TYPE0") != 0) { 306ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TYPE, 307ae8c6e27Sflorian sldns_buffer_position(strbuf)); 308ae8c6e27Sflorian } 309ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 310ae8c6e27Sflorian } 311ae8c6e27Sflorian 312ae8c6e27Sflorian /** put type, class, ttl into rr buffer */ 313ae8c6e27Sflorian static int 314ae8c6e27Sflorian rrinternal_write_typeclassttl(sldns_buffer* strbuf, uint8_t* rr, size_t len, 315ae8c6e27Sflorian size_t dname_len, uint16_t tp, uint16_t cl, uint32_t ttl, int question) 316ae8c6e27Sflorian { 317ae8c6e27Sflorian if(question) { 318ae8c6e27Sflorian /* question is : name, type, class */ 319ae8c6e27Sflorian if(dname_len + 4 > len) 320ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 321ae8c6e27Sflorian sldns_buffer_position(strbuf)); 322ae8c6e27Sflorian sldns_write_uint16(rr+dname_len, tp); 323ae8c6e27Sflorian sldns_write_uint16(rr+dname_len+2, cl); 324ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 325ae8c6e27Sflorian } 326ae8c6e27Sflorian 327ae8c6e27Sflorian /* type(2), class(2), ttl(4), rdatalen(2 (later)) = 10 */ 328ae8c6e27Sflorian if(dname_len + 10 > len) 329ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 330ae8c6e27Sflorian sldns_buffer_position(strbuf)); 331ae8c6e27Sflorian sldns_write_uint16(rr+dname_len, tp); 332ae8c6e27Sflorian sldns_write_uint16(rr+dname_len+2, cl); 333ae8c6e27Sflorian sldns_write_uint32(rr+dname_len+4, ttl); 334ae8c6e27Sflorian sldns_write_uint16(rr+dname_len+8, 0); /* rdatalen placeholder */ 335ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 336ae8c6e27Sflorian } 337ae8c6e27Sflorian 338ae8c6e27Sflorian /** find delimiters for type */ 339ae8c6e27Sflorian static const char* 340ae8c6e27Sflorian rrinternal_get_delims(sldns_rdf_type rdftype, size_t r_cnt, size_t r_max) 341ae8c6e27Sflorian { 342ae8c6e27Sflorian switch(rdftype) { 343ae8c6e27Sflorian case LDNS_RDF_TYPE_B64 : 344ae8c6e27Sflorian case LDNS_RDF_TYPE_HEX : /* These rdf types may con- */ 345ae8c6e27Sflorian case LDNS_RDF_TYPE_LOC : /* tain whitespace, only if */ 346ae8c6e27Sflorian case LDNS_RDF_TYPE_WKS : /* it is the last rd field. */ 347ae8c6e27Sflorian case LDNS_RDF_TYPE_IPSECKEY : 348ae8c6e27Sflorian case LDNS_RDF_TYPE_NSEC : if (r_cnt == r_max - 1) { 349ae8c6e27Sflorian return "\n"; 350ae8c6e27Sflorian } 351ae8c6e27Sflorian break; 352ae8c6e27Sflorian default : break; 353ae8c6e27Sflorian } 354ae8c6e27Sflorian return "\n\t "; 355ae8c6e27Sflorian } 356ae8c6e27Sflorian 357ae8c6e27Sflorian /* Syntactic sugar for sldns_rr_new_frm_str_internal */ 358ae8c6e27Sflorian static int 359ae8c6e27Sflorian sldns_rdf_type_maybe_quoted(sldns_rdf_type rdf_type) 360ae8c6e27Sflorian { 361ae8c6e27Sflorian return rdf_type == LDNS_RDF_TYPE_STR || 362ae8c6e27Sflorian rdf_type == LDNS_RDF_TYPE_LONG_STR; 363ae8c6e27Sflorian } 364ae8c6e27Sflorian 365ae8c6e27Sflorian /** see if rdata is quoted */ 366ae8c6e27Sflorian static int 367ae8c6e27Sflorian rrinternal_get_quoted(sldns_buffer* strbuf, const char** delimiters, 368ae8c6e27Sflorian sldns_rdf_type rdftype) 369ae8c6e27Sflorian { 370ae8c6e27Sflorian if(sldns_rdf_type_maybe_quoted(rdftype) && 371ae8c6e27Sflorian sldns_buffer_remaining(strbuf) > 0) { 372ae8c6e27Sflorian 373ae8c6e27Sflorian /* skip spaces */ 374ae8c6e27Sflorian while(sldns_buffer_remaining(strbuf) > 0 && 375ae8c6e27Sflorian *(sldns_buffer_current(strbuf)) == ' ') { 376ae8c6e27Sflorian sldns_buffer_skip(strbuf, 1); 377ae8c6e27Sflorian } 378ae8c6e27Sflorian 379ae8c6e27Sflorian if(sldns_buffer_remaining(strbuf) > 0 && 380ae8c6e27Sflorian *(sldns_buffer_current(strbuf)) == '\"') { 381ae8c6e27Sflorian *delimiters = "\"\0"; 382ae8c6e27Sflorian sldns_buffer_skip(strbuf, 1); 383ae8c6e27Sflorian return 1; 384ae8c6e27Sflorian } 385ae8c6e27Sflorian } 386ae8c6e27Sflorian return 0; 387ae8c6e27Sflorian } 388ae8c6e27Sflorian 389ae8c6e27Sflorian /** spool hex data into rdata */ 390ae8c6e27Sflorian static int 391ae8c6e27Sflorian rrinternal_spool_hex(char* token, uint8_t* rr, size_t rr_len, 392ae8c6e27Sflorian size_t rr_cur_len, size_t* cur_hex_data_size, size_t hex_data_size) 393ae8c6e27Sflorian { 394ae8c6e27Sflorian char* p = token; 395ae8c6e27Sflorian while(*p) { 396ae8c6e27Sflorian if(isspace((unsigned char)*p)) { 397ae8c6e27Sflorian p++; 398ae8c6e27Sflorian continue; 399ae8c6e27Sflorian } 400ae8c6e27Sflorian if(!isxdigit((unsigned char)*p)) 401ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_RDATA, 402ae8c6e27Sflorian p-token); 403ae8c6e27Sflorian if(*cur_hex_data_size >= hex_data_size) 404ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_RDATA, 405ae8c6e27Sflorian p-token); 406ae8c6e27Sflorian /* extra robust check */ 407ae8c6e27Sflorian if(rr_cur_len+(*cur_hex_data_size)/2 >= rr_len) 408ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 409ae8c6e27Sflorian p-token); 410ae8c6e27Sflorian /* see if 16s or 1s */ 411ae8c6e27Sflorian if( ((*cur_hex_data_size)&1) == 0) { 412ae8c6e27Sflorian rr[rr_cur_len+(*cur_hex_data_size)/2] = 413ae8c6e27Sflorian (uint8_t)sldns_hexdigit_to_int(*p)*16; 414ae8c6e27Sflorian } else { 415ae8c6e27Sflorian rr[rr_cur_len+(*cur_hex_data_size)/2] += 416ae8c6e27Sflorian (uint8_t)sldns_hexdigit_to_int(*p); 417ae8c6e27Sflorian } 418ae8c6e27Sflorian p++; 419ae8c6e27Sflorian (*cur_hex_data_size)++; 420ae8c6e27Sflorian } 421ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 422ae8c6e27Sflorian } 423ae8c6e27Sflorian 424ae8c6e27Sflorian /** read unknown rr type format */ 425ae8c6e27Sflorian static int 426ae8c6e27Sflorian rrinternal_parse_unknown(sldns_buffer* strbuf, char* token, size_t token_len, 427ae8c6e27Sflorian uint8_t* rr, size_t* rr_len, size_t* rr_cur_len, size_t pre_data_pos) 428ae8c6e27Sflorian { 429ae8c6e27Sflorian const char* delim = "\n\t "; 430ae8c6e27Sflorian size_t hex_data_size, cur_hex_data_size; 431ae8c6e27Sflorian /* go back to before \# 432ae8c6e27Sflorian * and skip it while setting delimiters better 433ae8c6e27Sflorian */ 434ae8c6e27Sflorian sldns_buffer_set_position(strbuf, pre_data_pos); 435ae8c6e27Sflorian if(sldns_bget_token(strbuf, token, delim, token_len) == -1) 436ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_GENERAL; /* should not fail */ 437ae8c6e27Sflorian /* read rdata octet length */ 438ae8c6e27Sflorian if(sldns_bget_token(strbuf, token, delim, token_len) == -1) { 439ae8c6e27Sflorian /* something goes very wrong here */ 440ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_RDATA, 441ae8c6e27Sflorian sldns_buffer_position(strbuf)); 442ae8c6e27Sflorian } 443ae8c6e27Sflorian hex_data_size = (size_t)atoi(token); 444ae8c6e27Sflorian if(hex_data_size > LDNS_MAX_RDFLEN || 445ae8c6e27Sflorian *rr_cur_len + hex_data_size > *rr_len) { 446ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 447ae8c6e27Sflorian sldns_buffer_position(strbuf)); 448ae8c6e27Sflorian } 449ae8c6e27Sflorian /* copy hex chars into hex str (2 chars per byte) */ 450ae8c6e27Sflorian hex_data_size *= 2; 451ae8c6e27Sflorian cur_hex_data_size = 0; 452ae8c6e27Sflorian while(cur_hex_data_size < hex_data_size) { 453ae8c6e27Sflorian int status; 454ae8c6e27Sflorian ssize_t c = sldns_bget_token(strbuf, token, delim, token_len); 455ae8c6e27Sflorian if((status = rrinternal_spool_hex(token, rr, *rr_len, 456ae8c6e27Sflorian *rr_cur_len, &cur_hex_data_size, hex_data_size)) != 0) 457ae8c6e27Sflorian return RET_ERR_SHIFT(status, 458ae8c6e27Sflorian sldns_buffer_position(strbuf)-strlen(token)); 459ae8c6e27Sflorian if(c == -1) { 460ae8c6e27Sflorian if(cur_hex_data_size != hex_data_size) 461ae8c6e27Sflorian return RET_ERR( 462ae8c6e27Sflorian LDNS_WIREPARSE_ERR_SYNTAX_RDATA, 463ae8c6e27Sflorian sldns_buffer_position(strbuf)); 464ae8c6e27Sflorian break; 465ae8c6e27Sflorian } 466ae8c6e27Sflorian } 467ae8c6e27Sflorian *rr_cur_len += hex_data_size/2; 468ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 469ae8c6e27Sflorian } 470ae8c6e27Sflorian 471ae8c6e27Sflorian /** parse normal RR rdata element */ 472ae8c6e27Sflorian static int 473ae8c6e27Sflorian rrinternal_parse_rdf(sldns_buffer* strbuf, char* token, size_t token_len, 474ae8c6e27Sflorian uint8_t* rr, size_t rr_len, size_t* rr_cur_len, sldns_rdf_type rdftype, 475ae8c6e27Sflorian uint16_t rr_type, size_t r_cnt, size_t r_max, size_t dname_len, 476ae8c6e27Sflorian uint8_t* origin, size_t origin_len) 477ae8c6e27Sflorian { 478ae8c6e27Sflorian size_t len; 479ae8c6e27Sflorian int status; 480ae8c6e27Sflorian 481ae8c6e27Sflorian switch(rdftype) { 482ae8c6e27Sflorian case LDNS_RDF_TYPE_DNAME: 483ae8c6e27Sflorian /* check if the origin should be used or concatenated */ 484ae8c6e27Sflorian if(strcmp(token, "@") == 0) { 485ae8c6e27Sflorian uint8_t* tocopy; 486ae8c6e27Sflorian size_t copylen; 487ae8c6e27Sflorian if(origin) { 488ae8c6e27Sflorian copylen = origin_len; 489ae8c6e27Sflorian tocopy = origin; 490ae8c6e27Sflorian } else if(rr_type == LDNS_RR_TYPE_SOA) { 491ae8c6e27Sflorian copylen = dname_len; 492ae8c6e27Sflorian tocopy = rr; /* copy rr owner name */ 493ae8c6e27Sflorian } else { 494ae8c6e27Sflorian copylen = 1; 495ae8c6e27Sflorian tocopy = (uint8_t*)"\0"; 496ae8c6e27Sflorian } 497ae8c6e27Sflorian if((*rr_cur_len) + copylen > rr_len) 498ae8c6e27Sflorian return RET_ERR( 499ae8c6e27Sflorian LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 500ae8c6e27Sflorian sldns_buffer_position(strbuf)); 501ae8c6e27Sflorian memmove(rr+*rr_cur_len, tocopy, copylen); 502ae8c6e27Sflorian (*rr_cur_len) += copylen; 503ae8c6e27Sflorian } else { 504ae8c6e27Sflorian size_t dlen = rr_len - (*rr_cur_len); 505ae8c6e27Sflorian int s = sldns_str2wire_dname_buf_origin(token, 506ae8c6e27Sflorian rr+*rr_cur_len, &dlen, origin, origin_len); 507ae8c6e27Sflorian if(s) return RET_ERR_SHIFT(s, 508ae8c6e27Sflorian sldns_buffer_position(strbuf)-strlen(token)); 509ae8c6e27Sflorian (*rr_cur_len) += dlen; 510ae8c6e27Sflorian } 511ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 512ae8c6e27Sflorian 513ae8c6e27Sflorian case LDNS_RDF_TYPE_HEX: 514ae8c6e27Sflorian case LDNS_RDF_TYPE_B64: 515ae8c6e27Sflorian /* When this is the last rdata field, then the 516ae8c6e27Sflorian * rest should be read in (cause then these 517ae8c6e27Sflorian * rdf types may contain spaces). */ 518ae8c6e27Sflorian if(r_cnt == r_max - 1) { 519ae8c6e27Sflorian size_t tlen = strlen(token); 520ae8c6e27Sflorian (void)sldns_bget_token(strbuf, token+tlen, "\n", 521ae8c6e27Sflorian token_len - tlen); 522ae8c6e27Sflorian } 523ae8c6e27Sflorian break; 524ae8c6e27Sflorian default: 525ae8c6e27Sflorian break; 526ae8c6e27Sflorian } 527ae8c6e27Sflorian 528ae8c6e27Sflorian len = rr_len - (*rr_cur_len); 529ae8c6e27Sflorian if((status=sldns_str2wire_rdf_buf(token, rr+(*rr_cur_len), &len, 530ae8c6e27Sflorian rdftype)) != 0) 531ae8c6e27Sflorian return RET_ERR_SHIFT(status, 532ae8c6e27Sflorian sldns_buffer_position(strbuf)-strlen(token)); 533ae8c6e27Sflorian *rr_cur_len += len; 534ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 535ae8c6e27Sflorian } 536ae8c6e27Sflorian 537ae8c6e27Sflorian /** 538ae8c6e27Sflorian * Parse one rdf token. Takes care of quotes and parenthesis. 539ae8c6e27Sflorian */ 540ae8c6e27Sflorian static int 541ae8c6e27Sflorian sldns_parse_rdf_token(sldns_buffer* strbuf, char* token, size_t token_len, 542ae8c6e27Sflorian int* quoted, int* parens, size_t* pre_data_pos, 543ae8c6e27Sflorian const char* delimiters, sldns_rdf_type rdftype, size_t* token_strlen) 544ae8c6e27Sflorian { 545ae8c6e27Sflorian size_t slen; 546ae8c6e27Sflorian 547ae8c6e27Sflorian /* skip spaces */ 548ae8c6e27Sflorian while(sldns_buffer_remaining(strbuf) > 0 && !*quoted && 549ae8c6e27Sflorian *(sldns_buffer_current(strbuf)) == ' ') { 550ae8c6e27Sflorian sldns_buffer_skip(strbuf, 1); 551ae8c6e27Sflorian } 552ae8c6e27Sflorian 553ae8c6e27Sflorian *pre_data_pos = sldns_buffer_position(strbuf); 554ae8c6e27Sflorian if(sldns_bget_token_par(strbuf, token, (*quoted)?"\"":delimiters, 555ae8c6e27Sflorian token_len, parens, (*quoted)?NULL:" \t") == -1) { 556ae8c6e27Sflorian return 0; 557ae8c6e27Sflorian } 558ae8c6e27Sflorian slen = strlen(token); 559ae8c6e27Sflorian /* check if not quoted yet, and we have encountered quotes */ 560ae8c6e27Sflorian if(!*quoted && sldns_rdf_type_maybe_quoted(rdftype) && 561ae8c6e27Sflorian slen >= 2 && 562ae8c6e27Sflorian (token[0] == '"' || token[0] == '\'') && 563ae8c6e27Sflorian (token[slen-1] == '"' || token[slen-1] == '\'')) { 564ae8c6e27Sflorian /* move token two smaller (quotes) with endnull */ 565ae8c6e27Sflorian memmove(token, token+1, slen-2); 566ae8c6e27Sflorian token[slen-2] = 0; 567ae8c6e27Sflorian slen -= 2; 568ae8c6e27Sflorian *quoted = 1; 569ae8c6e27Sflorian } else if(!*quoted && sldns_rdf_type_maybe_quoted(rdftype) && 570ae8c6e27Sflorian slen >= 2 && 571ae8c6e27Sflorian (token[0] == '"' || token[0] == '\'')) { 572ae8c6e27Sflorian /* got the start quote (remove it) but read remainder 573ae8c6e27Sflorian * of quoted string as well into remainder of token */ 574ae8c6e27Sflorian memmove(token, token+1, slen-1); 575ae8c6e27Sflorian token[slen-1] = 0; 576ae8c6e27Sflorian slen -= 1; 577ae8c6e27Sflorian *quoted = 1; 578ae8c6e27Sflorian /* rewind buffer over skipped whitespace */ 579ae8c6e27Sflorian while(sldns_buffer_position(strbuf) > 0 && 580ae8c6e27Sflorian (sldns_buffer_current(strbuf)[-1] == ' ' || 581ae8c6e27Sflorian sldns_buffer_current(strbuf)[-1] == '\t')) { 582ae8c6e27Sflorian sldns_buffer_skip(strbuf, -1); 583ae8c6e27Sflorian } 584ae8c6e27Sflorian if(sldns_bget_token_par(strbuf, token+slen, 585ae8c6e27Sflorian "\"", token_len-slen, 586ae8c6e27Sflorian parens, NULL) == -1) { 587ae8c6e27Sflorian return 0; 588ae8c6e27Sflorian } 589ae8c6e27Sflorian slen = strlen(token); 590ae8c6e27Sflorian } 591ae8c6e27Sflorian *token_strlen = slen; 592ae8c6e27Sflorian return 1; 593ae8c6e27Sflorian } 594ae8c6e27Sflorian 595ae8c6e27Sflorian /** Add space and one more rdf token onto the existing token string. */ 596ae8c6e27Sflorian static int 597ae8c6e27Sflorian sldns_affix_token(sldns_buffer* strbuf, char* token, size_t* token_len, 598ae8c6e27Sflorian int* quoted, int* parens, size_t* pre_data_pos, 599ae8c6e27Sflorian const char* delimiters, sldns_rdf_type rdftype, size_t* token_strlen) 600ae8c6e27Sflorian { 601ae8c6e27Sflorian size_t addlen = *token_len - *token_strlen; 602ae8c6e27Sflorian size_t addstrlen = 0; 603ae8c6e27Sflorian 604ae8c6e27Sflorian /* add space */ 605ae8c6e27Sflorian if(addlen < 1) return 0; 606ae8c6e27Sflorian token[*token_strlen] = ' '; 607ae8c6e27Sflorian token[++(*token_strlen)] = 0; 608ae8c6e27Sflorian 609ae8c6e27Sflorian /* read another token */ 610ae8c6e27Sflorian addlen = *token_len - *token_strlen; 611ae8c6e27Sflorian if(!sldns_parse_rdf_token(strbuf, token+*token_strlen, addlen, quoted, 612ae8c6e27Sflorian parens, pre_data_pos, delimiters, rdftype, &addstrlen)) 613ae8c6e27Sflorian return 0; 614ae8c6e27Sflorian (*token_strlen) += addstrlen; 615ae8c6e27Sflorian return 1; 616ae8c6e27Sflorian } 617ae8c6e27Sflorian 618ae8c6e27Sflorian /** parse rdata from string into rr buffer(-remainder after dname). */ 619ae8c6e27Sflorian static int 620ae8c6e27Sflorian rrinternal_parse_rdata(sldns_buffer* strbuf, char* token, size_t token_len, 621ae8c6e27Sflorian uint8_t* rr, size_t* rr_len, size_t dname_len, uint16_t rr_type, 622ae8c6e27Sflorian uint8_t* origin, size_t origin_len) 623ae8c6e27Sflorian { 624ae8c6e27Sflorian const sldns_rr_descriptor *desc = sldns_rr_descript((uint16_t)rr_type); 625ae8c6e27Sflorian size_t r_cnt, r_min, r_max; 626ae8c6e27Sflorian size_t rr_cur_len = dname_len + 10, pre_data_pos, token_strlen; 627ae8c6e27Sflorian int was_unknown_rr_format = 0, parens = 0, status, quoted; 628ae8c6e27Sflorian const char* delimiters; 629ae8c6e27Sflorian sldns_rdf_type rdftype; 630ae8c6e27Sflorian /* a desc is always returned */ 631ae8c6e27Sflorian if(!desc) return LDNS_WIREPARSE_ERR_GENERAL; 632ae8c6e27Sflorian r_max = sldns_rr_descriptor_maximum(desc); 633ae8c6e27Sflorian r_min = sldns_rr_descriptor_minimum(desc); 634ae8c6e27Sflorian /* robust check */ 635ae8c6e27Sflorian if(rr_cur_len > *rr_len) 636ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 637ae8c6e27Sflorian sldns_buffer_position(strbuf)); 638ae8c6e27Sflorian 639ae8c6e27Sflorian /* because number of fields can be variable, we can't rely on 640ae8c6e27Sflorian * _maximum() only */ 641ae8c6e27Sflorian for(r_cnt=0; r_cnt < r_max; r_cnt++) { 642ae8c6e27Sflorian rdftype = sldns_rr_descriptor_field_type(desc, r_cnt); 643ae8c6e27Sflorian delimiters = rrinternal_get_delims(rdftype, r_cnt, r_max); 644ae8c6e27Sflorian quoted = rrinternal_get_quoted(strbuf, &delimiters, rdftype); 645ae8c6e27Sflorian 646ae8c6e27Sflorian if(!sldns_parse_rdf_token(strbuf, token, token_len, "ed, 647ae8c6e27Sflorian &parens, &pre_data_pos, delimiters, rdftype, 648ae8c6e27Sflorian &token_strlen)) 649ae8c6e27Sflorian break; 650ae8c6e27Sflorian 651ae8c6e27Sflorian /* rfc3597 specifies that any type can be represented 652ae8c6e27Sflorian * with \# method, which can contain spaces... 653ae8c6e27Sflorian * it does specify size though... */ 654ae8c6e27Sflorian 655ae8c6e27Sflorian /* unknown RR data */ 656ae8c6e27Sflorian if(token_strlen>=2 && strncmp(token, "\\#", 2) == 0 && 657ae8c6e27Sflorian !quoted && (token_strlen == 2 || token[2]==' ')) { 658ae8c6e27Sflorian was_unknown_rr_format = 1; 659ae8c6e27Sflorian if((status=rrinternal_parse_unknown(strbuf, token, 660ae8c6e27Sflorian token_len, rr, rr_len, &rr_cur_len, 661ae8c6e27Sflorian pre_data_pos)) != 0) 662ae8c6e27Sflorian return status; 663ae8c6e27Sflorian } else if(token_strlen > 0 || quoted) { 664ae8c6e27Sflorian if(rdftype == LDNS_RDF_TYPE_HIP) { 665ae8c6e27Sflorian /* affix the HIT and PK fields, with a space */ 666ae8c6e27Sflorian if(!sldns_affix_token(strbuf, token, 667ae8c6e27Sflorian &token_len, "ed, &parens, 668ae8c6e27Sflorian &pre_data_pos, delimiters, 669ae8c6e27Sflorian rdftype, &token_strlen)) 670ae8c6e27Sflorian break; 671ae8c6e27Sflorian if(!sldns_affix_token(strbuf, token, 672ae8c6e27Sflorian &token_len, "ed, &parens, 673ae8c6e27Sflorian &pre_data_pos, delimiters, 674ae8c6e27Sflorian rdftype, &token_strlen)) 675ae8c6e27Sflorian break; 676ae8c6e27Sflorian } else if(rdftype == LDNS_RDF_TYPE_INT16_DATA && 677ae8c6e27Sflorian strcmp(token, "0")!=0) { 678ae8c6e27Sflorian /* affix len and b64 fields */ 679ae8c6e27Sflorian if(!sldns_affix_token(strbuf, token, 680ae8c6e27Sflorian &token_len, "ed, &parens, 681ae8c6e27Sflorian &pre_data_pos, delimiters, 682ae8c6e27Sflorian rdftype, &token_strlen)) 683ae8c6e27Sflorian break; 684ae8c6e27Sflorian } 685ae8c6e27Sflorian 686ae8c6e27Sflorian /* normal RR */ 687ae8c6e27Sflorian if((status=rrinternal_parse_rdf(strbuf, token, 688ae8c6e27Sflorian token_len, rr, *rr_len, &rr_cur_len, rdftype, 689ae8c6e27Sflorian rr_type, r_cnt, r_max, dname_len, origin, 690ae8c6e27Sflorian origin_len)) != 0) { 691ae8c6e27Sflorian return status; 692ae8c6e27Sflorian } 693ae8c6e27Sflorian } 694ae8c6e27Sflorian } 695ae8c6e27Sflorian if(!was_unknown_rr_format && r_cnt+1 < r_min) { 696ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_MISSING_VALUE, 697ae8c6e27Sflorian sldns_buffer_position(strbuf)); 698ae8c6e27Sflorian } 699ae8c6e27Sflorian while(parens != 0) { 700ae8c6e27Sflorian /* read remainder, must be "" */ 701ae8c6e27Sflorian if(sldns_bget_token_par(strbuf, token, "\n", token_len, 702ae8c6e27Sflorian &parens, " \t") == -1) { 703ae8c6e27Sflorian if(parens != 0) 704ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_PARENTHESIS, 705ae8c6e27Sflorian sldns_buffer_position(strbuf)); 706ae8c6e27Sflorian break; 707ae8c6e27Sflorian } 708ae8c6e27Sflorian if(strcmp(token, "") != 0) 709ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_PARENTHESIS, 710ae8c6e27Sflorian sldns_buffer_position(strbuf)); 711ae8c6e27Sflorian } 712ae8c6e27Sflorian /* write rdata length */ 713ae8c6e27Sflorian sldns_write_uint16(rr+dname_len+8, (uint16_t)(rr_cur_len-dname_len-10)); 714ae8c6e27Sflorian *rr_len = rr_cur_len; 715ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 716ae8c6e27Sflorian } 717ae8c6e27Sflorian 718ae8c6e27Sflorian /* 719ae8c6e27Sflorian * trailing spaces are allowed 720ae8c6e27Sflorian * leading spaces are not allowed 721ae8c6e27Sflorian * allow ttl to be optional 722ae8c6e27Sflorian * class is optional too 723ae8c6e27Sflorian * if ttl is missing, and default_ttl is 0, use DEF_TTL 724ae8c6e27Sflorian * allow ttl to be written as 1d3h 725ae8c6e27Sflorian * So the RR should look like. e.g. 726ae8c6e27Sflorian * miek.nl. 3600 IN MX 10 elektron.atoom.net 727ae8c6e27Sflorian * or 728ae8c6e27Sflorian * miek.nl. 1h IN MX 10 elektron.atoom.net 729ae8c6e27Sflorian * or 730ae8c6e27Sflorian * miek.nl. IN MX 10 elektron.atoom.net 731ae8c6e27Sflorian */ 732ae8c6e27Sflorian static int 733ae8c6e27Sflorian sldns_str2wire_rr_buf_internal(const char* str, uint8_t* rr, size_t* len, 734ae8c6e27Sflorian size_t* dname_len, uint32_t default_ttl, uint8_t* origin, 735ae8c6e27Sflorian size_t origin_len, uint8_t* prev, size_t prev_len, int question) 736ae8c6e27Sflorian { 737ae8c6e27Sflorian int status; 738ae8c6e27Sflorian int not_there = 0; 739ae8c6e27Sflorian char token[LDNS_MAX_RDFLEN+1]; 740ae8c6e27Sflorian uint32_t ttl = 0; 741ae8c6e27Sflorian uint16_t tp = 0, cl = 0; 742ae8c6e27Sflorian size_t ddlen = 0; 743ae8c6e27Sflorian 744ae8c6e27Sflorian /* string in buffer */ 745ae8c6e27Sflorian sldns_buffer strbuf; 746ae8c6e27Sflorian sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str)); 747ae8c6e27Sflorian if(!dname_len) dname_len = &ddlen; 748ae8c6e27Sflorian 749ae8c6e27Sflorian /* parse the owner */ 750ae8c6e27Sflorian if((status=rrinternal_get_owner(&strbuf, rr, len, dname_len, origin, 751ae8c6e27Sflorian origin_len, prev, prev_len, token, sizeof(token))) != 0) 752ae8c6e27Sflorian return status; 753ae8c6e27Sflorian 754ae8c6e27Sflorian /* parse the [ttl] [class] <type> */ 755ae8c6e27Sflorian if((status=rrinternal_get_ttl(&strbuf, token, sizeof(token), 756ae8c6e27Sflorian ¬_there, &ttl, default_ttl)) != 0) 757ae8c6e27Sflorian return status; 758ae8c6e27Sflorian if((status=rrinternal_get_class(&strbuf, token, sizeof(token), 759ae8c6e27Sflorian ¬_there, &cl)) != 0) 760ae8c6e27Sflorian return status; 761ae8c6e27Sflorian if((status=rrinternal_get_type(&strbuf, token, sizeof(token), 762ae8c6e27Sflorian ¬_there, &tp)) != 0) 763ae8c6e27Sflorian return status; 764ae8c6e27Sflorian /* put ttl, class, type into the rr result */ 765ae8c6e27Sflorian if((status=rrinternal_write_typeclassttl(&strbuf, rr, *len, *dname_len, tp, cl, 766ae8c6e27Sflorian ttl, question)) != 0) 767ae8c6e27Sflorian return status; 768ae8c6e27Sflorian /* for a question-RR we are done, no rdata */ 769ae8c6e27Sflorian if(question) { 770ae8c6e27Sflorian *len = *dname_len + 4; 771ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 772ae8c6e27Sflorian } 773ae8c6e27Sflorian 774ae8c6e27Sflorian /* rdata */ 775ae8c6e27Sflorian if((status=rrinternal_parse_rdata(&strbuf, token, sizeof(token), 776ae8c6e27Sflorian rr, len, *dname_len, tp, origin, origin_len)) != 0) 777ae8c6e27Sflorian return status; 778ae8c6e27Sflorian 779ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 780ae8c6e27Sflorian } 781ae8c6e27Sflorian 782ae8c6e27Sflorian int sldns_str2wire_rr_buf(const char* str, uint8_t* rr, size_t* len, 783ae8c6e27Sflorian size_t* dname_len, uint32_t default_ttl, uint8_t* origin, 784ae8c6e27Sflorian size_t origin_len, uint8_t* prev, size_t prev_len) 785ae8c6e27Sflorian { 786ae8c6e27Sflorian return sldns_str2wire_rr_buf_internal(str, rr, len, dname_len, 787ae8c6e27Sflorian default_ttl, origin, origin_len, prev, prev_len, 0); 788ae8c6e27Sflorian } 789ae8c6e27Sflorian 790ae8c6e27Sflorian int sldns_str2wire_rr_question_buf(const char* str, uint8_t* rr, size_t* len, 791ae8c6e27Sflorian size_t* dname_len, uint8_t* origin, size_t origin_len, uint8_t* prev, 792ae8c6e27Sflorian size_t prev_len) 793ae8c6e27Sflorian { 794ae8c6e27Sflorian return sldns_str2wire_rr_buf_internal(str, rr, len, dname_len, 795ae8c6e27Sflorian 0, origin, origin_len, prev, prev_len, 1); 796ae8c6e27Sflorian } 797ae8c6e27Sflorian 798ae8c6e27Sflorian uint16_t sldns_wirerr_get_type(uint8_t* rr, size_t len, size_t dname_len) 799ae8c6e27Sflorian { 800ae8c6e27Sflorian if(len < dname_len+2) 801ae8c6e27Sflorian return 0; 802ae8c6e27Sflorian return sldns_read_uint16(rr+dname_len); 803ae8c6e27Sflorian } 804ae8c6e27Sflorian 805ae8c6e27Sflorian uint16_t sldns_wirerr_get_class(uint8_t* rr, size_t len, size_t dname_len) 806ae8c6e27Sflorian { 807ae8c6e27Sflorian if(len < dname_len+4) 808ae8c6e27Sflorian return 0; 809ae8c6e27Sflorian return sldns_read_uint16(rr+dname_len+2); 810ae8c6e27Sflorian } 811ae8c6e27Sflorian 812ae8c6e27Sflorian uint32_t sldns_wirerr_get_ttl(uint8_t* rr, size_t len, size_t dname_len) 813ae8c6e27Sflorian { 814ae8c6e27Sflorian if(len < dname_len+8) 815ae8c6e27Sflorian return 0; 816ae8c6e27Sflorian return sldns_read_uint32(rr+dname_len+4); 817ae8c6e27Sflorian } 818ae8c6e27Sflorian 819ae8c6e27Sflorian uint16_t sldns_wirerr_get_rdatalen(uint8_t* rr, size_t len, size_t dname_len) 820ae8c6e27Sflorian { 821ae8c6e27Sflorian if(len < dname_len+10) 822ae8c6e27Sflorian return 0; 823ae8c6e27Sflorian return sldns_read_uint16(rr+dname_len+8); 824ae8c6e27Sflorian } 825ae8c6e27Sflorian 826ae8c6e27Sflorian uint8_t* sldns_wirerr_get_rdata(uint8_t* rr, size_t len, size_t dname_len) 827ae8c6e27Sflorian { 828ae8c6e27Sflorian if(len < dname_len+10) 829ae8c6e27Sflorian return NULL; 830ae8c6e27Sflorian return rr+dname_len+10; 831ae8c6e27Sflorian } 832ae8c6e27Sflorian 833ae8c6e27Sflorian uint8_t* sldns_wirerr_get_rdatawl(uint8_t* rr, size_t len, size_t dname_len) 834ae8c6e27Sflorian { 835ae8c6e27Sflorian if(len < dname_len+10) 836ae8c6e27Sflorian return NULL; 837ae8c6e27Sflorian return rr+dname_len+8; 838ae8c6e27Sflorian } 839ae8c6e27Sflorian 840ae8c6e27Sflorian const char* sldns_get_errorstr_parse(int e) 841ae8c6e27Sflorian { 842ae8c6e27Sflorian sldns_lookup_table *lt; 843ae8c6e27Sflorian lt = sldns_lookup_by_id(sldns_wireparse_errors, LDNS_WIREPARSE_ERROR(e)); 844ae8c6e27Sflorian return lt?lt->name:"unknown error"; 845ae8c6e27Sflorian } 846ae8c6e27Sflorian 847ae8c6e27Sflorian /* Strip whitespace from the start and the end of <line>. */ 848ae8c6e27Sflorian char * 849ae8c6e27Sflorian sldns_strip_ws(char *line) 850ae8c6e27Sflorian { 851ae8c6e27Sflorian char *s = line, *e; 852ae8c6e27Sflorian 853ae8c6e27Sflorian for (s = line; *s && isspace((unsigned char)*s); s++) 854ae8c6e27Sflorian ; 855ae8c6e27Sflorian for (e = strchr(s, 0); e > s+2 && isspace((unsigned char)e[-1]) && e[-2] != '\\'; e--) 856ae8c6e27Sflorian ; 857ae8c6e27Sflorian *e = 0; 858ae8c6e27Sflorian return s; 859ae8c6e27Sflorian } 860ae8c6e27Sflorian 861ae8c6e27Sflorian int sldns_fp2wire_rr_buf(FILE* in, uint8_t* rr, size_t* len, size_t* dname_len, 862ae8c6e27Sflorian struct sldns_file_parse_state* parse_state) 863ae8c6e27Sflorian { 864ae8c6e27Sflorian char line[LDNS_RR_BUF_SIZE+1]; 865ae8c6e27Sflorian ssize_t size; 866ae8c6e27Sflorian 867ae8c6e27Sflorian /* read an entire line in from the file */ 868ae8c6e27Sflorian if((size = sldns_fget_token_l(in, line, LDNS_PARSE_SKIP_SPACE, 869ae8c6e27Sflorian LDNS_RR_BUF_SIZE, parse_state?&parse_state->lineno:NULL)) 870ae8c6e27Sflorian == -1) { 871ae8c6e27Sflorian /* if last line was empty, we are now at feof, which is not 872ae8c6e27Sflorian * always a parse error (happens when for instance last line 873ae8c6e27Sflorian * was a comment) 874ae8c6e27Sflorian */ 875ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX; 876ae8c6e27Sflorian } 877ae8c6e27Sflorian 878ae8c6e27Sflorian /* we can have the situation, where we've read ok, but still got 879ae8c6e27Sflorian * no bytes to play with, in this case size is 0 */ 880ae8c6e27Sflorian if(size == 0) { 881ae8c6e27Sflorian if(*len > 0) 882ae8c6e27Sflorian rr[0] = 0; 883ae8c6e27Sflorian *len = 0; 884ae8c6e27Sflorian *dname_len = 0; 885ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 886ae8c6e27Sflorian } 887ae8c6e27Sflorian 888ae8c6e27Sflorian if(strncmp(line, "$ORIGIN", 7) == 0 && isspace((unsigned char)line[7])) { 889ae8c6e27Sflorian int s; 890ae8c6e27Sflorian strlcpy((char*)rr, line, *len); 891ae8c6e27Sflorian *len = 0; 892ae8c6e27Sflorian *dname_len = 0; 893ae8c6e27Sflorian if(!parse_state) return LDNS_WIREPARSE_ERR_OK; 894ae8c6e27Sflorian parse_state->origin_len = sizeof(parse_state->origin); 895ae8c6e27Sflorian s = sldns_str2wire_dname_buf(sldns_strip_ws(line+8), 896ae8c6e27Sflorian parse_state->origin, &parse_state->origin_len); 897ae8c6e27Sflorian if(s) parse_state->origin_len = 0; 898ae8c6e27Sflorian return s; 899ae8c6e27Sflorian } else if(strncmp(line, "$TTL", 4) == 0 && isspace((unsigned char)line[4])) { 900ae8c6e27Sflorian const char* end = NULL; 901ae8c6e27Sflorian strlcpy((char*)rr, line, *len); 902ae8c6e27Sflorian *len = 0; 903ae8c6e27Sflorian *dname_len = 0; 904ae8c6e27Sflorian if(!parse_state) return LDNS_WIREPARSE_ERR_OK; 905ae8c6e27Sflorian parse_state->default_ttl = sldns_str2period( 906ae8c6e27Sflorian sldns_strip_ws(line+5), &end); 907ae8c6e27Sflorian } else if (strncmp(line, "$INCLUDE", 8) == 0) { 908ae8c6e27Sflorian strlcpy((char*)rr, line, *len); 909ae8c6e27Sflorian *len = 0; 910ae8c6e27Sflorian *dname_len = 0; 911ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INCLUDE; 912ae8c6e27Sflorian } else if (strncmp(line, "$", 1) == 0) { 913ae8c6e27Sflorian strlcpy((char*)rr, line, *len); 914ae8c6e27Sflorian *len = 0; 915ae8c6e27Sflorian *dname_len = 0; 916ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INCLUDE; 917ae8c6e27Sflorian } else { 918ae8c6e27Sflorian int r = sldns_str2wire_rr_buf(line, rr, len, dname_len, 919ae8c6e27Sflorian parse_state?parse_state->default_ttl:0, 920ae8c6e27Sflorian (parse_state&&parse_state->origin_len)? 921ae8c6e27Sflorian parse_state->origin:NULL, 922ae8c6e27Sflorian parse_state?parse_state->origin_len:0, 923ae8c6e27Sflorian (parse_state&&parse_state->prev_rr_len)? 924ae8c6e27Sflorian parse_state->prev_rr:NULL, 925ae8c6e27Sflorian parse_state?parse_state->prev_rr_len:0); 926ae8c6e27Sflorian if(r == LDNS_WIREPARSE_ERR_OK && (*dname_len) != 0 && 927ae8c6e27Sflorian parse_state && 928ae8c6e27Sflorian (*dname_len) <= sizeof(parse_state->prev_rr)) { 929ae8c6e27Sflorian memmove(parse_state->prev_rr, rr, *dname_len); 930ae8c6e27Sflorian parse_state->prev_rr_len = (*dname_len); 931ae8c6e27Sflorian } 932ae8c6e27Sflorian return r; 933ae8c6e27Sflorian } 934ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 935ae8c6e27Sflorian } 936ae8c6e27Sflorian 937ae8c6e27Sflorian int sldns_str2wire_rdf_buf(const char* str, uint8_t* rd, size_t* len, 938ae8c6e27Sflorian sldns_rdf_type rdftype) 939ae8c6e27Sflorian { 940ae8c6e27Sflorian switch (rdftype) { 941ae8c6e27Sflorian case LDNS_RDF_TYPE_DNAME: 942ae8c6e27Sflorian return sldns_str2wire_dname_buf(str, rd, len); 943ae8c6e27Sflorian case LDNS_RDF_TYPE_INT8: 944ae8c6e27Sflorian return sldns_str2wire_int8_buf(str, rd, len); 945ae8c6e27Sflorian case LDNS_RDF_TYPE_INT16: 946ae8c6e27Sflorian return sldns_str2wire_int16_buf(str, rd, len); 947ae8c6e27Sflorian case LDNS_RDF_TYPE_INT32: 948ae8c6e27Sflorian return sldns_str2wire_int32_buf(str, rd, len); 949ae8c6e27Sflorian case LDNS_RDF_TYPE_A: 950ae8c6e27Sflorian return sldns_str2wire_a_buf(str, rd, len); 951ae8c6e27Sflorian case LDNS_RDF_TYPE_AAAA: 952ae8c6e27Sflorian return sldns_str2wire_aaaa_buf(str, rd, len); 953ae8c6e27Sflorian case LDNS_RDF_TYPE_STR: 954ae8c6e27Sflorian return sldns_str2wire_str_buf(str, rd, len); 955ae8c6e27Sflorian case LDNS_RDF_TYPE_APL: 956ae8c6e27Sflorian return sldns_str2wire_apl_buf(str, rd, len); 957ae8c6e27Sflorian case LDNS_RDF_TYPE_B64: 958ae8c6e27Sflorian return sldns_str2wire_b64_buf(str, rd, len); 959ae8c6e27Sflorian case LDNS_RDF_TYPE_B32_EXT: 960ae8c6e27Sflorian return sldns_str2wire_b32_ext_buf(str, rd, len); 961ae8c6e27Sflorian case LDNS_RDF_TYPE_HEX: 962ae8c6e27Sflorian return sldns_str2wire_hex_buf(str, rd, len); 963ae8c6e27Sflorian case LDNS_RDF_TYPE_NSEC: 964ae8c6e27Sflorian return sldns_str2wire_nsec_buf(str, rd, len); 965ae8c6e27Sflorian case LDNS_RDF_TYPE_TYPE: 966ae8c6e27Sflorian return sldns_str2wire_type_buf(str, rd, len); 967ae8c6e27Sflorian case LDNS_RDF_TYPE_CLASS: 968ae8c6e27Sflorian return sldns_str2wire_class_buf(str, rd, len); 969ae8c6e27Sflorian case LDNS_RDF_TYPE_CERT_ALG: 970ae8c6e27Sflorian return sldns_str2wire_cert_alg_buf(str, rd, len); 971ae8c6e27Sflorian case LDNS_RDF_TYPE_ALG: 972ae8c6e27Sflorian return sldns_str2wire_alg_buf(str, rd, len); 973ae8c6e27Sflorian case LDNS_RDF_TYPE_TIME: 974ae8c6e27Sflorian return sldns_str2wire_time_buf(str, rd, len); 975ae8c6e27Sflorian case LDNS_RDF_TYPE_PERIOD: 976ae8c6e27Sflorian return sldns_str2wire_period_buf(str, rd, len); 977ae8c6e27Sflorian case LDNS_RDF_TYPE_TSIGTIME: 978ae8c6e27Sflorian return sldns_str2wire_tsigtime_buf(str, rd, len); 979ae8c6e27Sflorian case LDNS_RDF_TYPE_LOC: 980ae8c6e27Sflorian return sldns_str2wire_loc_buf(str, rd, len); 981ae8c6e27Sflorian case LDNS_RDF_TYPE_WKS: 982ae8c6e27Sflorian return sldns_str2wire_wks_buf(str, rd, len); 983ae8c6e27Sflorian case LDNS_RDF_TYPE_NSAP: 984ae8c6e27Sflorian return sldns_str2wire_nsap_buf(str, rd, len); 985ae8c6e27Sflorian case LDNS_RDF_TYPE_ATMA: 986ae8c6e27Sflorian return sldns_str2wire_atma_buf(str, rd, len); 987ae8c6e27Sflorian case LDNS_RDF_TYPE_IPSECKEY: 988ae8c6e27Sflorian return sldns_str2wire_ipseckey_buf(str, rd, len); 989ae8c6e27Sflorian case LDNS_RDF_TYPE_NSEC3_SALT: 990ae8c6e27Sflorian return sldns_str2wire_nsec3_salt_buf(str, rd, len); 991ae8c6e27Sflorian case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER: 992ae8c6e27Sflorian return sldns_str2wire_b32_ext_buf(str, rd, len); 993ae8c6e27Sflorian case LDNS_RDF_TYPE_ILNP64: 994ae8c6e27Sflorian return sldns_str2wire_ilnp64_buf(str, rd, len); 995ae8c6e27Sflorian case LDNS_RDF_TYPE_EUI48: 996ae8c6e27Sflorian return sldns_str2wire_eui48_buf(str, rd, len); 997ae8c6e27Sflorian case LDNS_RDF_TYPE_EUI64: 998ae8c6e27Sflorian return sldns_str2wire_eui64_buf(str, rd, len); 999ae8c6e27Sflorian case LDNS_RDF_TYPE_TAG: 1000ae8c6e27Sflorian return sldns_str2wire_tag_buf(str, rd, len); 1001ae8c6e27Sflorian case LDNS_RDF_TYPE_LONG_STR: 1002ae8c6e27Sflorian return sldns_str2wire_long_str_buf(str, rd, len); 1003ae8c6e27Sflorian case LDNS_RDF_TYPE_TSIGERROR: 1004ae8c6e27Sflorian return sldns_str2wire_tsigerror_buf(str, rd, len); 1005ae8c6e27Sflorian case LDNS_RDF_TYPE_HIP: 1006ae8c6e27Sflorian return sldns_str2wire_hip_buf(str, rd, len); 1007ae8c6e27Sflorian case LDNS_RDF_TYPE_INT16_DATA: 1008ae8c6e27Sflorian return sldns_str2wire_int16_data_buf(str, rd, len); 1009ae8c6e27Sflorian case LDNS_RDF_TYPE_UNKNOWN: 1010ae8c6e27Sflorian case LDNS_RDF_TYPE_SERVICE: 1011ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_NOT_IMPL; 1012ae8c6e27Sflorian case LDNS_RDF_TYPE_NONE: 1013ae8c6e27Sflorian default: 1014ae8c6e27Sflorian break; 1015ae8c6e27Sflorian } 1016ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_GENERAL; 1017ae8c6e27Sflorian } 1018ae8c6e27Sflorian 1019ae8c6e27Sflorian int sldns_str2wire_int8_buf(const char* str, uint8_t* rd, size_t* len) 1020ae8c6e27Sflorian { 1021ae8c6e27Sflorian char* end; 1022ae8c6e27Sflorian uint8_t r = (uint8_t)strtol((char*)str, &end, 10); 1023ae8c6e27Sflorian if(*end != 0) 1024ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INT, end-(char*)str); 1025ae8c6e27Sflorian if(*len < 1) 1026ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1027ae8c6e27Sflorian rd[0] = r; 1028ae8c6e27Sflorian *len = 1; 1029ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1030ae8c6e27Sflorian } 1031ae8c6e27Sflorian 1032ae8c6e27Sflorian int sldns_str2wire_int16_buf(const char* str, uint8_t* rd, size_t* len) 1033ae8c6e27Sflorian { 1034ae8c6e27Sflorian char* end; 1035ae8c6e27Sflorian uint16_t r = (uint16_t)strtol((char*)str, &end, 10); 1036ae8c6e27Sflorian if(*end != 0) 1037ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INT, end-(char*)str); 1038ae8c6e27Sflorian if(*len < 2) 1039ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1040ae8c6e27Sflorian sldns_write_uint16(rd, r); 1041ae8c6e27Sflorian *len = 2; 1042ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1043ae8c6e27Sflorian } 1044ae8c6e27Sflorian 1045ae8c6e27Sflorian int sldns_str2wire_int32_buf(const char* str, uint8_t* rd, size_t* len) 1046ae8c6e27Sflorian { 1047ae8c6e27Sflorian char* end; 1048ae8c6e27Sflorian uint32_t r; 1049ae8c6e27Sflorian errno = 0; /* must set to zero before call, 1050ae8c6e27Sflorian note race condition on errno */ 1051ae8c6e27Sflorian if(*str == '-') 1052ae8c6e27Sflorian r = (uint32_t)strtol((char*)str, &end, 10); 1053ae8c6e27Sflorian else r = (uint32_t)strtoul((char*)str, &end, 10); 1054ae8c6e27Sflorian if(*end != 0) 1055ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INT, end-(char*)str); 1056ae8c6e27Sflorian if(errno == ERANGE) 1057ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_INTEGER_OVERFLOW; 1058ae8c6e27Sflorian if(*len < 4) 1059ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1060ae8c6e27Sflorian sldns_write_uint32(rd, r); 1061ae8c6e27Sflorian *len = 4; 1062ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1063ae8c6e27Sflorian } 1064ae8c6e27Sflorian 1065ae8c6e27Sflorian int sldns_str2wire_a_buf(const char* str, uint8_t* rd, size_t* len) 1066ae8c6e27Sflorian { 1067ae8c6e27Sflorian struct in_addr address; 1068ae8c6e27Sflorian if(inet_pton(AF_INET, (char*)str, &address) != 1) 1069ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_IP4; 1070ae8c6e27Sflorian if(*len < sizeof(address)) 1071ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1072ae8c6e27Sflorian memmove(rd, &address, sizeof(address)); 1073ae8c6e27Sflorian *len = sizeof(address); 1074ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1075ae8c6e27Sflorian } 1076ae8c6e27Sflorian 1077ae8c6e27Sflorian int sldns_str2wire_aaaa_buf(const char* str, uint8_t* rd, size_t* len) 1078ae8c6e27Sflorian { 1079ae8c6e27Sflorian #ifdef AF_INET6 1080ae8c6e27Sflorian uint8_t address[LDNS_IP6ADDRLEN + 1]; 1081ae8c6e27Sflorian if(inet_pton(AF_INET6, (char*)str, address) != 1) 1082ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_IP6; 1083ae8c6e27Sflorian if(*len < LDNS_IP6ADDRLEN) 1084ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1085ae8c6e27Sflorian memmove(rd, address, LDNS_IP6ADDRLEN); 1086ae8c6e27Sflorian *len = LDNS_IP6ADDRLEN; 1087ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1088ae8c6e27Sflorian #else 1089ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_NOT_IMPL; 1090ae8c6e27Sflorian #endif 1091ae8c6e27Sflorian } 1092ae8c6e27Sflorian 1093ae8c6e27Sflorian int sldns_str2wire_str_buf(const char* str, uint8_t* rd, size_t* len) 1094ae8c6e27Sflorian { 1095ae8c6e27Sflorian uint8_t ch = 0; 1096ae8c6e27Sflorian size_t sl = 0; 1097ae8c6e27Sflorian const char* s = str; 1098ae8c6e27Sflorian /* skip length byte */ 1099ae8c6e27Sflorian if(*len < 1) 1100ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1101ae8c6e27Sflorian 1102ae8c6e27Sflorian /* read characters */ 1103ae8c6e27Sflorian while(sldns_parse_char(&ch, &s)) { 1104ae8c6e27Sflorian if(sl >= 255) 1105ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR, s-str); 110657403691Sflorian if(*len < sl+2) 1107ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 1108ae8c6e27Sflorian s-str); 1109ae8c6e27Sflorian rd[++sl] = ch; 1110ae8c6e27Sflorian } 1111ae8c6e27Sflorian if(!s) 1112ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_BAD_ESCAPE; 1113ae8c6e27Sflorian rd[0] = (uint8_t)sl; 1114ae8c6e27Sflorian *len = sl+1; 1115ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1116ae8c6e27Sflorian } 1117ae8c6e27Sflorian 1118ae8c6e27Sflorian int sldns_str2wire_apl_buf(const char* str, uint8_t* rd, size_t* len) 1119ae8c6e27Sflorian { 1120ae8c6e27Sflorian const char *my_str = str; 1121ae8c6e27Sflorian 1122ae8c6e27Sflorian char my_ip_str[64]; 1123ae8c6e27Sflorian size_t ip_str_len; 1124ae8c6e27Sflorian 1125ae8c6e27Sflorian uint16_t family; 1126ae8c6e27Sflorian int negation; 1127ae8c6e27Sflorian size_t adflength = 0; 1128ae8c6e27Sflorian uint8_t data[16+4]; 1129ae8c6e27Sflorian uint8_t prefix; 1130ae8c6e27Sflorian size_t i; 1131ae8c6e27Sflorian 1132ae8c6e27Sflorian if(*my_str == '\0') { 1133ae8c6e27Sflorian /* empty APL element, no data, no string */ 1134ae8c6e27Sflorian *len = 0; 1135ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1136ae8c6e27Sflorian } 1137ae8c6e27Sflorian 1138ae8c6e27Sflorian /* [!]afi:address/prefix */ 1139ae8c6e27Sflorian if (strlen(my_str) < 2 1140ae8c6e27Sflorian || strchr(my_str, ':') == NULL 1141ae8c6e27Sflorian || strchr(my_str, '/') == NULL 1142ae8c6e27Sflorian || strchr(my_str, ':') > strchr(my_str, '/')) { 1143ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INVALID_STR; 1144ae8c6e27Sflorian } 1145ae8c6e27Sflorian 1146ae8c6e27Sflorian if (my_str[0] == '!') { 1147ae8c6e27Sflorian negation = 1; 1148ae8c6e27Sflorian my_str += 1; 1149ae8c6e27Sflorian } else { 1150ae8c6e27Sflorian negation = 0; 1151ae8c6e27Sflorian } 1152ae8c6e27Sflorian 1153ae8c6e27Sflorian family = (uint16_t) atoi(my_str); 1154ae8c6e27Sflorian 1155ae8c6e27Sflorian my_str = strchr(my_str, ':') + 1; 1156ae8c6e27Sflorian 1157ae8c6e27Sflorian /* need ip addr and only ip addr for inet_pton */ 1158ae8c6e27Sflorian ip_str_len = (size_t) (strchr(my_str, '/') - my_str); 1159ae8c6e27Sflorian if(ip_str_len+1 > sizeof(my_ip_str)) 1160ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INVALID_STR; 1161ae8c6e27Sflorian (void)strlcpy(my_ip_str, my_str, sizeof(my_ip_str)); 1162ae8c6e27Sflorian my_ip_str[ip_str_len] = 0; 1163ae8c6e27Sflorian 1164ae8c6e27Sflorian if (family == 1) { 1165ae8c6e27Sflorian /* ipv4 */ 1166ae8c6e27Sflorian if(inet_pton(AF_INET, my_ip_str, data+4) == 0) 1167ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INVALID_STR; 1168ae8c6e27Sflorian for (i = 0; i < 4; i++) { 1169ae8c6e27Sflorian if (data[i+4] != 0) { 1170ae8c6e27Sflorian adflength = i + 1; 1171ae8c6e27Sflorian } 1172ae8c6e27Sflorian } 1173ae8c6e27Sflorian } else if (family == 2) { 1174ae8c6e27Sflorian /* ipv6 */ 1175ae8c6e27Sflorian if (inet_pton(AF_INET6, my_ip_str, data+4) == 0) 1176ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INVALID_STR; 1177ae8c6e27Sflorian for (i = 0; i < 16; i++) { 1178ae8c6e27Sflorian if (data[i+4] != 0) { 1179ae8c6e27Sflorian adflength = i + 1; 1180ae8c6e27Sflorian } 1181ae8c6e27Sflorian } 1182ae8c6e27Sflorian } else { 1183ae8c6e27Sflorian /* unknown family */ 1184ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INVALID_STR; 1185ae8c6e27Sflorian } 1186ae8c6e27Sflorian 1187ae8c6e27Sflorian my_str = strchr(my_str, '/') + 1; 1188ae8c6e27Sflorian prefix = (uint8_t) atoi(my_str); 1189ae8c6e27Sflorian 1190ae8c6e27Sflorian sldns_write_uint16(data, family); 1191ae8c6e27Sflorian data[2] = prefix; 1192ae8c6e27Sflorian data[3] = (uint8_t)adflength; 1193ae8c6e27Sflorian if (negation) { 1194ae8c6e27Sflorian /* set bit 1 of byte 3 */ 1195ae8c6e27Sflorian data[3] = data[3] | 0x80; 1196ae8c6e27Sflorian } 1197ae8c6e27Sflorian 1198ae8c6e27Sflorian if(*len < 4+adflength) 1199ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1200ae8c6e27Sflorian memmove(rd, data, 4+adflength); 1201ae8c6e27Sflorian *len = 4+adflength; 1202ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1203ae8c6e27Sflorian } 1204ae8c6e27Sflorian 1205ae8c6e27Sflorian int sldns_str2wire_b64_buf(const char* str, uint8_t* rd, size_t* len) 1206ae8c6e27Sflorian { 1207ae8c6e27Sflorian size_t sz = sldns_b64_pton_calculate_size(strlen(str)); 1208ae8c6e27Sflorian int n; 1209ae8c6e27Sflorian if(strcmp(str, "0") == 0) { 1210ae8c6e27Sflorian *len = 0; 1211ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1212ae8c6e27Sflorian } 1213ae8c6e27Sflorian if(*len < sz) 1214ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1215ae8c6e27Sflorian n = sldns_b64_pton(str, rd, *len); 1216ae8c6e27Sflorian if(n < 0) 1217ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_B64; 1218ae8c6e27Sflorian *len = (size_t)n; 1219ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1220ae8c6e27Sflorian } 1221ae8c6e27Sflorian 1222ae8c6e27Sflorian int sldns_str2wire_b32_ext_buf(const char* str, uint8_t* rd, size_t* len) 1223ae8c6e27Sflorian { 1224ae8c6e27Sflorian size_t slen = strlen(str); 1225ae8c6e27Sflorian size_t sz = sldns_b32_pton_calculate_size(slen); 1226ae8c6e27Sflorian int n; 1227ae8c6e27Sflorian if(*len < 1+sz) 1228ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1229ae8c6e27Sflorian rd[0] = (uint8_t)sz; 1230ae8c6e27Sflorian n = sldns_b32_pton_extended_hex(str, slen, rd+1, *len-1); 1231ae8c6e27Sflorian if(n < 0) 1232ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_B32_EXT; 1233ae8c6e27Sflorian *len = (size_t)n+1; 1234ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1235ae8c6e27Sflorian } 1236ae8c6e27Sflorian 1237ae8c6e27Sflorian /** see if the string ends, or ends in whitespace */ 1238ae8c6e27Sflorian static int 1239ae8c6e27Sflorian sldns_is_last_of_string(const char* str) 1240ae8c6e27Sflorian { 1241ae8c6e27Sflorian if(*str == 0) return 1; 1242ae8c6e27Sflorian while(isspace((unsigned char)*str)) 1243ae8c6e27Sflorian str++; 1244ae8c6e27Sflorian if(*str == 0) return 1; 1245ae8c6e27Sflorian return 0; 1246ae8c6e27Sflorian } 1247ae8c6e27Sflorian 1248ae8c6e27Sflorian int sldns_str2wire_hex_buf(const char* str, uint8_t* rd, size_t* len) 1249ae8c6e27Sflorian { 1250ae8c6e27Sflorian const char* s = str; 1251ae8c6e27Sflorian size_t dlen = 0; /* number of hexdigits parsed */ 1252ae8c6e27Sflorian while(*s) { 1253ae8c6e27Sflorian if(isspace((unsigned char)*s)) { 1254ae8c6e27Sflorian s++; 1255ae8c6e27Sflorian continue; 1256ae8c6e27Sflorian } 1257ae8c6e27Sflorian if(dlen == 0 && *s == '0' && sldns_is_last_of_string(s+1)) { 1258ae8c6e27Sflorian *len = 0; 1259ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1260ae8c6e27Sflorian } 1261ae8c6e27Sflorian if(!isxdigit((unsigned char)*s)) 1262ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str); 1263ae8c6e27Sflorian if(*len < dlen/2 + 1) 1264ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 1265ae8c6e27Sflorian s-str); 1266ae8c6e27Sflorian if((dlen&1)==0) 1267ae8c6e27Sflorian rd[dlen/2] = (uint8_t)sldns_hexdigit_to_int(*s++) * 16; 1268ae8c6e27Sflorian else rd[dlen/2] += (uint8_t)sldns_hexdigit_to_int(*s++); 1269ae8c6e27Sflorian dlen++; 1270ae8c6e27Sflorian } 1271ae8c6e27Sflorian if((dlen&1)!=0) 1272ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str); 1273ae8c6e27Sflorian *len = dlen/2; 1274ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1275ae8c6e27Sflorian } 1276ae8c6e27Sflorian 1277ae8c6e27Sflorian int sldns_str2wire_nsec_buf(const char* str, uint8_t* rd, size_t* len) 1278ae8c6e27Sflorian { 1279ae8c6e27Sflorian const char *delim = "\n\t "; 1280ae8c6e27Sflorian char token[64]; /* for a type name */ 1281ae8c6e27Sflorian size_t type_count = 0; 1282ae8c6e27Sflorian int block; 1283ae8c6e27Sflorian size_t used = 0; 1284ae8c6e27Sflorian uint16_t maxtype = 0; 1285ae8c6e27Sflorian uint8_t typebits[8192]; /* 65536 bits */ 1286ae8c6e27Sflorian uint8_t window_in_use[256]; 1287ae8c6e27Sflorian 1288ae8c6e27Sflorian /* string in buffer */ 1289ae8c6e27Sflorian sldns_buffer strbuf; 1290ae8c6e27Sflorian sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str)); 1291ae8c6e27Sflorian 1292ae8c6e27Sflorian /* parse the types */ 1293ae8c6e27Sflorian memset(typebits, 0, sizeof(typebits)); 1294ae8c6e27Sflorian memset(window_in_use, 0, sizeof(window_in_use)); 1295ae8c6e27Sflorian while(sldns_buffer_remaining(&strbuf) > 0 && 1296ae8c6e27Sflorian sldns_bget_token(&strbuf, token, delim, sizeof(token)) != -1) { 1297ae8c6e27Sflorian uint16_t t = sldns_get_rr_type_by_name(token); 1298ae8c6e27Sflorian if(token[0] == 0) 1299ae8c6e27Sflorian continue; 1300ae8c6e27Sflorian if(t == 0 && strcmp(token, "TYPE0") != 0) 1301ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TYPE, 1302ae8c6e27Sflorian sldns_buffer_position(&strbuf)); 1303ae8c6e27Sflorian typebits[t/8] |= (0x80>>(t%8)); 1304ae8c6e27Sflorian window_in_use[t/256] = 1; 1305ae8c6e27Sflorian type_count++; 1306ae8c6e27Sflorian if(t > maxtype) maxtype = t; 1307ae8c6e27Sflorian } 1308ae8c6e27Sflorian 1309ae8c6e27Sflorian /* empty NSEC bitmap */ 1310ae8c6e27Sflorian if(type_count == 0) { 1311ae8c6e27Sflorian *len = 0; 1312ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1313ae8c6e27Sflorian } 1314ae8c6e27Sflorian 1315ae8c6e27Sflorian /* encode windows {u8 windowblock, u8 bitmaplength, 0-32u8 bitmap}, 1316ae8c6e27Sflorian * block is 0-255 upper octet of types, length if 0-32. */ 1317ae8c6e27Sflorian for(block = 0; block <= (int)maxtype/256; block++) { 1318ae8c6e27Sflorian int i, blocklen = 0; 1319ae8c6e27Sflorian if(!window_in_use[block]) 1320ae8c6e27Sflorian continue; 1321ae8c6e27Sflorian for(i=0; i<32; i++) { 1322ae8c6e27Sflorian if(typebits[block*32+i] != 0) 1323ae8c6e27Sflorian blocklen = i+1; 1324ae8c6e27Sflorian } 1325ae8c6e27Sflorian if(blocklen == 0) 1326ae8c6e27Sflorian continue; /* empty window should have been !in_use */ 1327ae8c6e27Sflorian if(used+blocklen+2 > *len) 1328ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1329ae8c6e27Sflorian rd[used+0] = (uint8_t)block; 1330ae8c6e27Sflorian rd[used+1] = (uint8_t)blocklen; 1331ae8c6e27Sflorian for(i=0; i<blocklen; i++) { 1332ae8c6e27Sflorian rd[used+2+i] = typebits[block*32+i]; 1333ae8c6e27Sflorian } 1334ae8c6e27Sflorian used += blocklen+2; 1335ae8c6e27Sflorian } 1336ae8c6e27Sflorian *len = used; 1337ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1338ae8c6e27Sflorian } 1339ae8c6e27Sflorian 1340ae8c6e27Sflorian int sldns_str2wire_type_buf(const char* str, uint8_t* rd, size_t* len) 1341ae8c6e27Sflorian { 1342ae8c6e27Sflorian uint16_t t = sldns_get_rr_type_by_name(str); 1343ae8c6e27Sflorian if(t == 0 && strcmp(str, "TYPE0") != 0) 1344ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_TYPE; 1345ae8c6e27Sflorian if(*len < 2) 1346ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1347ae8c6e27Sflorian sldns_write_uint16(rd, t); 1348ae8c6e27Sflorian *len = 2; 1349ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1350ae8c6e27Sflorian } 1351ae8c6e27Sflorian 1352ae8c6e27Sflorian int sldns_str2wire_class_buf(const char* str, uint8_t* rd, size_t* len) 1353ae8c6e27Sflorian { 1354ae8c6e27Sflorian uint16_t c = sldns_get_rr_class_by_name(str); 1355ae8c6e27Sflorian if(c == 0 && strcmp(str, "CLASS0") != 0) 1356ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_CLASS; 1357ae8c6e27Sflorian if(*len < 2) 1358ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1359ae8c6e27Sflorian sldns_write_uint16(rd, c); 1360ae8c6e27Sflorian *len = 2; 1361ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1362ae8c6e27Sflorian } 1363ae8c6e27Sflorian 1364ae8c6e27Sflorian /* An certificate alg field can either be specified as a 8 bits number 1365ae8c6e27Sflorian * or by its symbolic name. Handle both */ 1366ae8c6e27Sflorian int sldns_str2wire_cert_alg_buf(const char* str, uint8_t* rd, size_t* len) 1367ae8c6e27Sflorian { 1368ae8c6e27Sflorian sldns_lookup_table *lt = sldns_lookup_by_name(sldns_cert_algorithms, 1369ae8c6e27Sflorian str); 1370ae8c6e27Sflorian if(*len < 2) 1371ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1372ae8c6e27Sflorian if(lt) { 1373ae8c6e27Sflorian sldns_write_uint16(rd, (uint16_t)lt->id); 1374ae8c6e27Sflorian } else { 1375ae8c6e27Sflorian int s = sldns_str2wire_int16_buf(str, rd, len); 1376ae8c6e27Sflorian if(s) return s; 1377ae8c6e27Sflorian if(sldns_read_uint16(rd) == 0) 1378ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_CERT_BAD_ALGORITHM; 1379ae8c6e27Sflorian } 1380ae8c6e27Sflorian *len = 2; 1381ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1382ae8c6e27Sflorian } 1383ae8c6e27Sflorian 1384ae8c6e27Sflorian /* An alg field can either be specified as a 8 bits number 1385ae8c6e27Sflorian * or by its symbolic name. Handle both */ 1386ae8c6e27Sflorian int sldns_str2wire_alg_buf(const char* str, uint8_t* rd, size_t* len) 1387ae8c6e27Sflorian { 1388ae8c6e27Sflorian sldns_lookup_table *lt = sldns_lookup_by_name(sldns_algorithms, str); 1389ae8c6e27Sflorian if(*len < 1) 1390ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1391ae8c6e27Sflorian if(lt) { 1392ae8c6e27Sflorian rd[0] = (uint8_t)lt->id; 1393ae8c6e27Sflorian *len = 1; 1394ae8c6e27Sflorian } else { 1395ae8c6e27Sflorian /* try as-is (a number) */ 1396ae8c6e27Sflorian return sldns_str2wire_int8_buf(str, rd, len); 1397ae8c6e27Sflorian } 1398ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1399ae8c6e27Sflorian } 1400ae8c6e27Sflorian 1401ae8c6e27Sflorian int sldns_str2wire_tsigerror_buf(const char* str, uint8_t* rd, size_t* len) 1402ae8c6e27Sflorian { 1403ae8c6e27Sflorian sldns_lookup_table *lt = sldns_lookup_by_name(sldns_tsig_errors, str); 1404ae8c6e27Sflorian if(*len < 2) 1405ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1406ae8c6e27Sflorian if(lt) { 1407ae8c6e27Sflorian sldns_write_uint16(rd, (uint16_t)lt->id); 1408ae8c6e27Sflorian *len = 2; 1409ae8c6e27Sflorian } else { 1410ae8c6e27Sflorian /* try as-is (a number) */ 1411ae8c6e27Sflorian return sldns_str2wire_int16_buf(str, rd, len); 1412ae8c6e27Sflorian } 1413ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1414ae8c6e27Sflorian } 1415ae8c6e27Sflorian 1416ae8c6e27Sflorian int sldns_str2wire_time_buf(const char* str, uint8_t* rd, size_t* len) 1417ae8c6e27Sflorian { 1418ae8c6e27Sflorian /* convert a time YYYYDDMMHHMMSS to wireformat */ 1419ae8c6e27Sflorian struct tm tm; 1420ae8c6e27Sflorian if(*len < 4) 1421ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1422ae8c6e27Sflorian 1423ae8c6e27Sflorian /* Try to scan the time... */ 1424ae8c6e27Sflorian memset(&tm, 0, sizeof(tm)); 1425ae8c6e27Sflorian if (strlen(str) == 14 && sscanf(str, "%4d%2d%2d%2d%2d%2d", 1426ae8c6e27Sflorian &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, 1427ae8c6e27Sflorian &tm.tm_min, &tm.tm_sec) == 6) { 1428ae8c6e27Sflorian tm.tm_year -= 1900; 1429ae8c6e27Sflorian tm.tm_mon--; 1430ae8c6e27Sflorian /* Check values */ 1431ae8c6e27Sflorian if (tm.tm_year < 70) 1432ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_TIME; 1433ae8c6e27Sflorian if (tm.tm_mon < 0 || tm.tm_mon > 11) 1434ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_TIME; 1435ae8c6e27Sflorian if (tm.tm_mday < 1 || tm.tm_mday > 31) 1436ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_TIME; 1437ae8c6e27Sflorian if (tm.tm_hour < 0 || tm.tm_hour > 23) 1438ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_TIME; 1439ae8c6e27Sflorian if (tm.tm_min < 0 || tm.tm_min > 59) 1440ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_TIME; 1441ae8c6e27Sflorian if (tm.tm_sec < 0 || tm.tm_sec > 59) 1442ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_TIME; 1443ae8c6e27Sflorian 1444ae8c6e27Sflorian sldns_write_uint32(rd, (uint32_t)sldns_mktime_from_utc(&tm)); 1445ae8c6e27Sflorian } else { 1446ae8c6e27Sflorian /* handle it as 32 bits timestamp */ 1447ae8c6e27Sflorian char *end; 1448ae8c6e27Sflorian uint32_t l = (uint32_t)strtol((char*)str, &end, 10); 1449ae8c6e27Sflorian if(*end != 0) 1450ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TIME, 1451ae8c6e27Sflorian end-(char*)str); 1452ae8c6e27Sflorian sldns_write_uint32(rd, l); 1453ae8c6e27Sflorian } 1454ae8c6e27Sflorian *len = 4; 1455ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1456ae8c6e27Sflorian } 1457ae8c6e27Sflorian 1458ae8c6e27Sflorian int sldns_str2wire_tsigtime_buf(const char* str, uint8_t* rd, size_t* len) 1459ae8c6e27Sflorian { 1460ae8c6e27Sflorian char* end; 1461ae8c6e27Sflorian uint64_t t = (uint64_t)strtol((char*)str, &end, 10); 1462ae8c6e27Sflorian uint16_t high; 1463ae8c6e27Sflorian uint32_t low; 1464ae8c6e27Sflorian if(*end != 0) 1465ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TIME, end-str); 1466ae8c6e27Sflorian if(*len < 6) 1467ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1468ae8c6e27Sflorian high = (uint16_t)(t>>32); 1469ae8c6e27Sflorian low = (uint32_t)(t); 1470ae8c6e27Sflorian sldns_write_uint16(rd, high); 1471ae8c6e27Sflorian sldns_write_uint32(rd+2, low); 1472ae8c6e27Sflorian *len = 6; 1473ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1474ae8c6e27Sflorian } 1475ae8c6e27Sflorian 1476ae8c6e27Sflorian int sldns_str2wire_period_buf(const char* str, uint8_t* rd, size_t* len) 1477ae8c6e27Sflorian { 1478ae8c6e27Sflorian const char* end; 1479ae8c6e27Sflorian uint32_t p = sldns_str2period(str, &end); 1480ae8c6e27Sflorian if(*end != 0) 1481ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_PERIOD, end-str); 1482ae8c6e27Sflorian if(*len < 4) 1483ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1484ae8c6e27Sflorian sldns_write_uint32(rd, p); 1485ae8c6e27Sflorian *len = 4; 1486ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1487ae8c6e27Sflorian } 1488ae8c6e27Sflorian 1489ae8c6e27Sflorian /** read "<digits>[.<digits>][mM]" into mantissa exponent format for LOC type */ 1490ae8c6e27Sflorian static int 1491ae8c6e27Sflorian loc_parse_cm(char* my_str, char** endstr, uint8_t* m, uint8_t* e) 1492ae8c6e27Sflorian { 1493ae8c6e27Sflorian uint32_t meters = 0, cm = 0, val; 1494ae8c6e27Sflorian while (isblank((unsigned char)*my_str)) { 1495ae8c6e27Sflorian my_str++; 1496ae8c6e27Sflorian } 1497ae8c6e27Sflorian meters = (uint32_t)strtol(my_str, &my_str, 10); 1498ae8c6e27Sflorian if (*my_str == '.') { 1499ae8c6e27Sflorian my_str++; 1500ae8c6e27Sflorian cm = (uint32_t)strtol(my_str, &my_str, 10); 1501ae8c6e27Sflorian } 1502ae8c6e27Sflorian if (meters >= 1) { 1503ae8c6e27Sflorian *e = 2; 1504ae8c6e27Sflorian val = meters; 1505ae8c6e27Sflorian } else { 1506ae8c6e27Sflorian *e = 0; 1507ae8c6e27Sflorian val = cm; 1508ae8c6e27Sflorian } 1509ae8c6e27Sflorian while(val >= 10) { 1510ae8c6e27Sflorian (*e)++; 1511ae8c6e27Sflorian val /= 10; 1512ae8c6e27Sflorian } 1513ae8c6e27Sflorian *m = (uint8_t)val; 1514ae8c6e27Sflorian 1515ae8c6e27Sflorian if (*e > 9) 1516ae8c6e27Sflorian return 0; 1517ae8c6e27Sflorian if (*my_str == 'm' || *my_str == 'M') { 1518ae8c6e27Sflorian my_str++; 1519ae8c6e27Sflorian } 1520ae8c6e27Sflorian *endstr = my_str; 1521ae8c6e27Sflorian return 1; 1522ae8c6e27Sflorian } 1523ae8c6e27Sflorian 1524ae8c6e27Sflorian int sldns_str2wire_loc_buf(const char* str, uint8_t* rd, size_t* len) 1525ae8c6e27Sflorian { 1526ae8c6e27Sflorian uint32_t latitude = 0; 1527ae8c6e27Sflorian uint32_t longitude = 0; 1528ae8c6e27Sflorian uint32_t altitude = 0; 1529ae8c6e27Sflorian 1530ae8c6e27Sflorian uint32_t equator = (uint32_t)1<<31; /* 2**31 */ 1531ae8c6e27Sflorian 1532ae8c6e27Sflorian /* only support version 0 */ 1533ae8c6e27Sflorian uint32_t h = 0; 1534ae8c6e27Sflorian uint32_t m = 0; 1535ae8c6e27Sflorian uint8_t size_b = 1, size_e = 2; 1536ae8c6e27Sflorian uint8_t horiz_pre_b = 1, horiz_pre_e = 6; 1537ae8c6e27Sflorian uint8_t vert_pre_b = 1, vert_pre_e = 3; 1538ae8c6e27Sflorian 1539ae8c6e27Sflorian double s = 0.0; 1540ae8c6e27Sflorian int northerness; 1541ae8c6e27Sflorian int easterness; 1542ae8c6e27Sflorian 1543ae8c6e27Sflorian char *my_str = (char *) str; 1544ae8c6e27Sflorian 1545ae8c6e27Sflorian if (isdigit((unsigned char) *my_str)) { 1546ae8c6e27Sflorian h = (uint32_t) strtol(my_str, &my_str, 10); 1547ae8c6e27Sflorian } else { 1548ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INVALID_STR; 1549ae8c6e27Sflorian } 1550ae8c6e27Sflorian 1551ae8c6e27Sflorian while (isblank((unsigned char) *my_str)) { 1552ae8c6e27Sflorian my_str++; 1553ae8c6e27Sflorian } 1554ae8c6e27Sflorian 1555ae8c6e27Sflorian if (isdigit((unsigned char) *my_str)) { 1556ae8c6e27Sflorian m = (uint32_t) strtol(my_str, &my_str, 10); 1557ae8c6e27Sflorian } else if (*my_str == 'N' || *my_str == 'S') { 1558ae8c6e27Sflorian goto north; 1559ae8c6e27Sflorian } else { 1560ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INVALID_STR; 1561ae8c6e27Sflorian } 1562ae8c6e27Sflorian 1563ae8c6e27Sflorian while (isblank((unsigned char) *my_str)) { 1564ae8c6e27Sflorian my_str++; 1565ae8c6e27Sflorian } 1566ae8c6e27Sflorian 1567ae8c6e27Sflorian if (isdigit((unsigned char) *my_str)) { 1568ae8c6e27Sflorian s = strtod(my_str, &my_str); 1569ae8c6e27Sflorian } 1570ae8c6e27Sflorian 1571ae8c6e27Sflorian /* skip blanks before northerness */ 1572ae8c6e27Sflorian while (isblank((unsigned char) *my_str)) { 1573ae8c6e27Sflorian my_str++; 1574ae8c6e27Sflorian } 1575ae8c6e27Sflorian 1576ae8c6e27Sflorian north: 1577ae8c6e27Sflorian if (*my_str == 'N') { 1578ae8c6e27Sflorian northerness = 1; 1579ae8c6e27Sflorian } else if (*my_str == 'S') { 1580ae8c6e27Sflorian northerness = 0; 1581ae8c6e27Sflorian } else { 1582ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INVALID_STR; 1583ae8c6e27Sflorian } 1584ae8c6e27Sflorian 1585ae8c6e27Sflorian my_str++; 1586ae8c6e27Sflorian 1587ae8c6e27Sflorian /* store number */ 1588ae8c6e27Sflorian s = 1000.0 * s; 1589ae8c6e27Sflorian /* add a little to make floor in conversion a round */ 1590ae8c6e27Sflorian s += 0.0005; 1591ae8c6e27Sflorian latitude = (uint32_t) s; 1592ae8c6e27Sflorian latitude += 1000 * 60 * m; 1593ae8c6e27Sflorian latitude += 1000 * 60 * 60 * h; 1594ae8c6e27Sflorian if (northerness) { 1595ae8c6e27Sflorian latitude = equator + latitude; 1596ae8c6e27Sflorian } else { 1597ae8c6e27Sflorian latitude = equator - latitude; 1598ae8c6e27Sflorian } 1599ae8c6e27Sflorian while (isblank((unsigned char)*my_str)) { 1600ae8c6e27Sflorian my_str++; 1601ae8c6e27Sflorian } 1602ae8c6e27Sflorian 1603ae8c6e27Sflorian if (isdigit((unsigned char) *my_str)) { 1604ae8c6e27Sflorian h = (uint32_t) strtol(my_str, &my_str, 10); 1605ae8c6e27Sflorian } else { 1606ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INVALID_STR; 1607ae8c6e27Sflorian } 1608ae8c6e27Sflorian 1609ae8c6e27Sflorian while (isblank((unsigned char) *my_str)) { 1610ae8c6e27Sflorian my_str++; 1611ae8c6e27Sflorian } 1612ae8c6e27Sflorian 1613ae8c6e27Sflorian if (isdigit((unsigned char) *my_str)) { 1614ae8c6e27Sflorian m = (uint32_t) strtol(my_str, &my_str, 10); 1615ae8c6e27Sflorian } else if (*my_str == 'E' || *my_str == 'W') { 1616ae8c6e27Sflorian goto east; 1617ae8c6e27Sflorian } else { 1618ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INVALID_STR; 1619ae8c6e27Sflorian } 1620ae8c6e27Sflorian 1621ae8c6e27Sflorian while (isblank((unsigned char)*my_str)) { 1622ae8c6e27Sflorian my_str++; 1623ae8c6e27Sflorian } 1624ae8c6e27Sflorian 1625ae8c6e27Sflorian if (isdigit((unsigned char) *my_str)) { 1626ae8c6e27Sflorian s = strtod(my_str, &my_str); 1627ae8c6e27Sflorian } 1628ae8c6e27Sflorian 1629ae8c6e27Sflorian /* skip blanks before easterness */ 1630ae8c6e27Sflorian while (isblank((unsigned char)*my_str)) { 1631ae8c6e27Sflorian my_str++; 1632ae8c6e27Sflorian } 1633ae8c6e27Sflorian 1634ae8c6e27Sflorian east: 1635ae8c6e27Sflorian if (*my_str == 'E') { 1636ae8c6e27Sflorian easterness = 1; 1637ae8c6e27Sflorian } else if (*my_str == 'W') { 1638ae8c6e27Sflorian easterness = 0; 1639ae8c6e27Sflorian } else { 1640ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INVALID_STR; 1641ae8c6e27Sflorian } 1642ae8c6e27Sflorian 1643ae8c6e27Sflorian my_str++; 1644ae8c6e27Sflorian 1645ae8c6e27Sflorian /* store number */ 1646ae8c6e27Sflorian s *= 1000.0; 1647ae8c6e27Sflorian /* add a little to make floor in conversion a round */ 1648ae8c6e27Sflorian s += 0.0005; 1649ae8c6e27Sflorian longitude = (uint32_t) s; 1650ae8c6e27Sflorian longitude += 1000 * 60 * m; 1651ae8c6e27Sflorian longitude += 1000 * 60 * 60 * h; 1652ae8c6e27Sflorian 1653ae8c6e27Sflorian if (easterness) { 1654ae8c6e27Sflorian longitude += equator; 1655ae8c6e27Sflorian } else { 1656ae8c6e27Sflorian longitude = equator - longitude; 1657ae8c6e27Sflorian } 1658ae8c6e27Sflorian 1659ae8c6e27Sflorian altitude = (uint32_t)(strtod(my_str, &my_str)*100.0 + 1660ae8c6e27Sflorian 10000000.0 + 0.5); 1661ae8c6e27Sflorian if (*my_str == 'm' || *my_str == 'M') { 1662ae8c6e27Sflorian my_str++; 1663ae8c6e27Sflorian } 1664ae8c6e27Sflorian 1665ae8c6e27Sflorian if (strlen(my_str) > 0) { 1666ae8c6e27Sflorian if(!loc_parse_cm(my_str, &my_str, &size_b, &size_e)) 1667ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INVALID_STR; 1668ae8c6e27Sflorian } 1669ae8c6e27Sflorian 1670ae8c6e27Sflorian if (strlen(my_str) > 0) { 1671ae8c6e27Sflorian if(!loc_parse_cm(my_str, &my_str, &horiz_pre_b, &horiz_pre_e)) 1672ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INVALID_STR; 1673ae8c6e27Sflorian } 1674ae8c6e27Sflorian 1675ae8c6e27Sflorian if (strlen(my_str) > 0) { 1676ae8c6e27Sflorian if(!loc_parse_cm(my_str, &my_str, &vert_pre_b, &vert_pre_e)) 1677ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INVALID_STR; 1678ae8c6e27Sflorian } 1679ae8c6e27Sflorian 1680ae8c6e27Sflorian if(*len < 16) 1681ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1682ae8c6e27Sflorian rd[0] = 0; 1683ae8c6e27Sflorian rd[1] = ((size_b << 4) & 0xf0) | (size_e & 0x0f); 1684ae8c6e27Sflorian rd[2] = ((horiz_pre_b << 4) & 0xf0) | (horiz_pre_e & 0x0f); 1685ae8c6e27Sflorian rd[3] = ((vert_pre_b << 4) & 0xf0) | (vert_pre_e & 0x0f); 1686ae8c6e27Sflorian sldns_write_uint32(rd + 4, latitude); 1687ae8c6e27Sflorian sldns_write_uint32(rd + 8, longitude); 1688ae8c6e27Sflorian sldns_write_uint32(rd + 12, altitude); 1689ae8c6e27Sflorian *len = 16; 1690ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1691ae8c6e27Sflorian } 1692ae8c6e27Sflorian 1693ae8c6e27Sflorian static void 1694ae8c6e27Sflorian ldns_tolower_str(char* s) 1695ae8c6e27Sflorian { 1696ae8c6e27Sflorian if(s) { 1697ae8c6e27Sflorian while(*s) { 1698ae8c6e27Sflorian *s = (char)tolower((unsigned char)*s); 1699ae8c6e27Sflorian s++; 1700ae8c6e27Sflorian } 1701ae8c6e27Sflorian } 1702ae8c6e27Sflorian } 1703ae8c6e27Sflorian 1704ae8c6e27Sflorian int sldns_str2wire_wks_buf(const char* str, uint8_t* rd, size_t* len) 1705ae8c6e27Sflorian { 1706ae8c6e27Sflorian int rd_len = 1; 1707ae8c6e27Sflorian int have_proto = 0; 1708ae8c6e27Sflorian char token[50], proto_str[50]; 1709ae8c6e27Sflorian sldns_buffer strbuf; 1710ae8c6e27Sflorian sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str)); 1711ae8c6e27Sflorian proto_str[0]=0; 1712ae8c6e27Sflorian 1713ae8c6e27Sflorian /* check we have one byte for proto */ 1714ae8c6e27Sflorian if(*len < 1) 1715ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1716ae8c6e27Sflorian 1717ae8c6e27Sflorian while(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) > 0) { 1718ae8c6e27Sflorian ldns_tolower_str(token); 1719ae8c6e27Sflorian if(!have_proto) { 1720ae8c6e27Sflorian struct protoent *p = getprotobyname(token); 1721ae8c6e27Sflorian have_proto = 1; 1722ae8c6e27Sflorian if(p) rd[0] = (uint8_t)p->p_proto; 1723ae8c6e27Sflorian else if(strcasecmp(token, "tcp")==0) rd[0]=6; 1724ae8c6e27Sflorian else if(strcasecmp(token, "udp")==0) rd[0]=17; 1725ae8c6e27Sflorian else rd[0] = (uint8_t)atoi(token); 1726ae8c6e27Sflorian (void)strlcpy(proto_str, token, sizeof(proto_str)); 1727ae8c6e27Sflorian } else { 1728ae8c6e27Sflorian int serv_port; 1729ae8c6e27Sflorian struct servent *serv = getservbyname(token, proto_str); 1730ae8c6e27Sflorian if(serv) serv_port=(int)ntohs((uint16_t)serv->s_port); 1731ae8c6e27Sflorian else if(strcasecmp(token, "domain")==0) serv_port=53; 1732ae8c6e27Sflorian else { 1733ae8c6e27Sflorian serv_port = atoi(token); 1734ae8c6e27Sflorian if(serv_port == 0 && strcmp(token, "0") != 0) { 1735ae8c6e27Sflorian #ifdef HAVE_ENDSERVENT 1736ae8c6e27Sflorian endservent(); 1737ae8c6e27Sflorian #endif 1738ae8c6e27Sflorian #ifdef HAVE_ENDPROTOENT 1739ae8c6e27Sflorian endprotoent(); 1740ae8c6e27Sflorian #endif 1741ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX, 1742ae8c6e27Sflorian sldns_buffer_position(&strbuf)); 1743ae8c6e27Sflorian } 1744ae8c6e27Sflorian if(serv_port < 0 || serv_port > 65535) { 1745ae8c6e27Sflorian #ifdef HAVE_ENDSERVENT 1746ae8c6e27Sflorian endservent(); 1747ae8c6e27Sflorian #endif 1748ae8c6e27Sflorian #ifdef HAVE_ENDPROTOENT 1749ae8c6e27Sflorian endprotoent(); 1750ae8c6e27Sflorian #endif 1751ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX, 1752ae8c6e27Sflorian sldns_buffer_position(&strbuf)); 1753ae8c6e27Sflorian } 1754ae8c6e27Sflorian } 1755ae8c6e27Sflorian if(rd_len < 1+serv_port/8+1) { 1756ae8c6e27Sflorian /* bitmap is larger, init new bytes at 0 */ 1757ae8c6e27Sflorian if(*len < 1+(size_t)serv_port/8+1) { 1758ae8c6e27Sflorian #ifdef HAVE_ENDSERVENT 1759ae8c6e27Sflorian endservent(); 1760ae8c6e27Sflorian #endif 1761ae8c6e27Sflorian #ifdef HAVE_ENDPROTOENT 1762ae8c6e27Sflorian endprotoent(); 1763ae8c6e27Sflorian #endif 1764ae8c6e27Sflorian return RET_ERR( 1765ae8c6e27Sflorian LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 1766ae8c6e27Sflorian sldns_buffer_position(&strbuf)); 1767ae8c6e27Sflorian } 1768ae8c6e27Sflorian memset(rd+rd_len, 0, 1+(size_t)serv_port/8+1-rd_len); 1769ae8c6e27Sflorian rd_len = 1+serv_port/8+1; 1770ae8c6e27Sflorian } 1771ae8c6e27Sflorian rd[1+ serv_port/8] |= (1 << (7 - serv_port % 8)); 1772ae8c6e27Sflorian } 1773ae8c6e27Sflorian } 1774ae8c6e27Sflorian *len = (size_t)rd_len; 1775ae8c6e27Sflorian 1776ae8c6e27Sflorian #ifdef HAVE_ENDSERVENT 1777ae8c6e27Sflorian endservent(); 1778ae8c6e27Sflorian #endif 1779ae8c6e27Sflorian #ifdef HAVE_ENDPROTOENT 1780ae8c6e27Sflorian endprotoent(); 1781ae8c6e27Sflorian #endif 1782ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1783ae8c6e27Sflorian } 1784ae8c6e27Sflorian 1785ae8c6e27Sflorian int sldns_str2wire_nsap_buf(const char* str, uint8_t* rd, size_t* len) 1786ae8c6e27Sflorian { 1787ae8c6e27Sflorian const char* s = str; 1788ae8c6e27Sflorian size_t slen; 1789ae8c6e27Sflorian size_t dlen = 0; /* number of hexdigits parsed */ 1790ae8c6e27Sflorian 1791ae8c6e27Sflorian /* just a hex string with optional dots? */ 1792ae8c6e27Sflorian if (s[0] != '0' || s[1] != 'x') 1793ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_INVALID_STR; 1794ae8c6e27Sflorian s += 2; 1795ae8c6e27Sflorian slen = strlen(s); 1796ae8c6e27Sflorian if(slen > LDNS_MAX_RDFLEN*2) 1797ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_LABEL_OVERFLOW; 1798ae8c6e27Sflorian while(*s) { 1799ae8c6e27Sflorian if(isspace((unsigned char)*s) || *s == '.') { 1800ae8c6e27Sflorian s++; 1801ae8c6e27Sflorian continue; 1802ae8c6e27Sflorian } 1803ae8c6e27Sflorian if(!isxdigit((unsigned char)*s)) 1804ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str); 1805ae8c6e27Sflorian if(*len < dlen/2 + 1) 1806ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 1807ae8c6e27Sflorian s-str); 1808ae8c6e27Sflorian if((dlen&1)==0) 1809ae8c6e27Sflorian rd[dlen/2] = (uint8_t)sldns_hexdigit_to_int(*s++) * 16; 1810ae8c6e27Sflorian else rd[dlen/2] += sldns_hexdigit_to_int(*s++); 1811ae8c6e27Sflorian dlen++; 1812ae8c6e27Sflorian } 1813ae8c6e27Sflorian if((dlen&1)!=0) 1814ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str); 1815ae8c6e27Sflorian *len = dlen/2; 1816ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1817ae8c6e27Sflorian } 1818ae8c6e27Sflorian 1819ae8c6e27Sflorian int sldns_str2wire_atma_buf(const char* str, uint8_t* rd, size_t* len) 1820ae8c6e27Sflorian { 1821ae8c6e27Sflorian const char* s = str; 1822ae8c6e27Sflorian size_t slen = strlen(str); 1823ae8c6e27Sflorian size_t dlen = 0; /* number of hexdigits parsed */ 1824ae8c6e27Sflorian 1825ae8c6e27Sflorian /* just a hex string with optional dots? */ 1826ae8c6e27Sflorian /* notimpl e.164 format */ 1827ae8c6e27Sflorian if(slen > LDNS_MAX_RDFLEN*2) 1828ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_LABEL_OVERFLOW; 1829ae8c6e27Sflorian while(*s) { 1830ae8c6e27Sflorian if(isspace((unsigned char)*s) || *s == '.') { 1831ae8c6e27Sflorian s++; 1832ae8c6e27Sflorian continue; 1833ae8c6e27Sflorian } 1834ae8c6e27Sflorian if(!isxdigit((unsigned char)*s)) 1835ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str); 1836ae8c6e27Sflorian if(*len < dlen/2 + 1) 1837ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 1838ae8c6e27Sflorian s-str); 1839ae8c6e27Sflorian if((dlen&1)==0) 1840ae8c6e27Sflorian rd[dlen/2] = (uint8_t)sldns_hexdigit_to_int(*s++) * 16; 1841ae8c6e27Sflorian else rd[dlen/2] += sldns_hexdigit_to_int(*s++); 1842ae8c6e27Sflorian dlen++; 1843ae8c6e27Sflorian } 1844ae8c6e27Sflorian if((dlen&1)!=0) 1845ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str); 1846ae8c6e27Sflorian *len = dlen/2; 1847ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1848ae8c6e27Sflorian } 1849ae8c6e27Sflorian 1850ae8c6e27Sflorian int sldns_str2wire_ipseckey_buf(const char* str, uint8_t* rd, size_t* len) 1851ae8c6e27Sflorian { 1852ae8c6e27Sflorian size_t gwlen = 0, keylen = 0; 1853ae8c6e27Sflorian int s; 1854ae8c6e27Sflorian uint8_t gwtype; 1855ae8c6e27Sflorian char token[512]; 1856ae8c6e27Sflorian sldns_buffer strbuf; 1857ae8c6e27Sflorian sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str)); 1858ae8c6e27Sflorian 1859ae8c6e27Sflorian if(*len < 3) 1860ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1861ae8c6e27Sflorian /* precedence */ 1862ae8c6e27Sflorian if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0) 1863ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR, 1864ae8c6e27Sflorian sldns_buffer_position(&strbuf)); 1865ae8c6e27Sflorian rd[0] = (uint8_t)atoi(token); 1866ae8c6e27Sflorian /* gateway_type */ 1867ae8c6e27Sflorian if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0) 1868ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR, 1869ae8c6e27Sflorian sldns_buffer_position(&strbuf)); 1870ae8c6e27Sflorian rd[1] = (uint8_t)atoi(token); 1871ae8c6e27Sflorian gwtype = rd[1]; 1872ae8c6e27Sflorian /* algorithm */ 1873ae8c6e27Sflorian if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0) 1874ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR, 1875ae8c6e27Sflorian sldns_buffer_position(&strbuf)); 1876ae8c6e27Sflorian rd[2] = (uint8_t)atoi(token); 1877ae8c6e27Sflorian 1878ae8c6e27Sflorian /* gateway */ 1879ae8c6e27Sflorian if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0) 1880ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR, 1881ae8c6e27Sflorian sldns_buffer_position(&strbuf)); 1882ae8c6e27Sflorian if(gwtype == 0) { 1883ae8c6e27Sflorian /* NOGATEWAY */ 1884ae8c6e27Sflorian if(strcmp(token, ".") != 0) 1885ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR, 1886ae8c6e27Sflorian sldns_buffer_position(&strbuf)); 1887ae8c6e27Sflorian gwlen = 0; 1888ae8c6e27Sflorian } else if(gwtype == 1) { 1889ae8c6e27Sflorian /* IP4 */ 1890ae8c6e27Sflorian gwlen = *len - 3; 1891ae8c6e27Sflorian s = sldns_str2wire_a_buf(token, rd+3, &gwlen); 1892ae8c6e27Sflorian if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf)); 1893ae8c6e27Sflorian } else if(gwtype == 2) { 1894ae8c6e27Sflorian /* IP6 */ 1895ae8c6e27Sflorian gwlen = *len - 3; 1896ae8c6e27Sflorian s = sldns_str2wire_aaaa_buf(token, rd+3, &gwlen); 1897ae8c6e27Sflorian if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf)); 1898ae8c6e27Sflorian } else if(gwtype == 3) { 1899ae8c6e27Sflorian /* DNAME */ 1900ae8c6e27Sflorian gwlen = *len - 3; 1901ae8c6e27Sflorian s = sldns_str2wire_dname_buf(token, rd+3, &gwlen); 1902ae8c6e27Sflorian if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf)); 1903ae8c6e27Sflorian } else { 1904ae8c6e27Sflorian /* unknown gateway type */ 1905ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR, 1906ae8c6e27Sflorian sldns_buffer_position(&strbuf)); 1907ae8c6e27Sflorian } 1908ae8c6e27Sflorian /* double check for size */ 1909ae8c6e27Sflorian if(*len < 3 + gwlen) 1910ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 1911ae8c6e27Sflorian sldns_buffer_position(&strbuf)); 1912ae8c6e27Sflorian 1913ae8c6e27Sflorian /* publickey in remainder of strbuf */ 1914ae8c6e27Sflorian keylen = *len - 3 - gwlen; 1915ae8c6e27Sflorian s = sldns_str2wire_b64_buf((const char*)sldns_buffer_current(&strbuf), 1916ae8c6e27Sflorian rd+3+gwlen, &keylen); 1917ae8c6e27Sflorian if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf)); 1918ae8c6e27Sflorian 1919ae8c6e27Sflorian *len = 3 + gwlen + keylen; 1920ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1921ae8c6e27Sflorian } 1922ae8c6e27Sflorian 1923ae8c6e27Sflorian int sldns_str2wire_nsec3_salt_buf(const char* str, uint8_t* rd, size_t* len) 1924ae8c6e27Sflorian { 1925ae8c6e27Sflorian int i, salt_length_str = (int)strlen(str); 1926ae8c6e27Sflorian if (salt_length_str == 1 && str[0] == '-') { 1927ae8c6e27Sflorian salt_length_str = 0; 1928ae8c6e27Sflorian } else if (salt_length_str % 2 != 0) { 1929ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_HEX; 1930ae8c6e27Sflorian } 1931ae8c6e27Sflorian if (salt_length_str > 512) 1932ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_HEX; 1933ae8c6e27Sflorian if(*len < 1+(size_t)salt_length_str / 2) 1934ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1935ae8c6e27Sflorian rd[0] = (uint8_t) (salt_length_str / 2); 1936ae8c6e27Sflorian for (i = 0; i < salt_length_str; i += 2) { 1937ae8c6e27Sflorian if (isxdigit((unsigned char)str[i]) && 1938ae8c6e27Sflorian isxdigit((unsigned char)str[i+1])) { 1939ae8c6e27Sflorian rd[1+i/2] = (uint8_t)(sldns_hexdigit_to_int(str[i])*16 1940ae8c6e27Sflorian + sldns_hexdigit_to_int(str[i+1])); 1941ae8c6e27Sflorian } else { 1942ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, i); 1943ae8c6e27Sflorian } 1944ae8c6e27Sflorian } 1945ae8c6e27Sflorian *len = 1 + (size_t)rd[0]; 1946ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1947ae8c6e27Sflorian } 1948ae8c6e27Sflorian 1949ae8c6e27Sflorian int sldns_str2wire_ilnp64_buf(const char* str, uint8_t* rd, size_t* len) 1950ae8c6e27Sflorian { 1951ae8c6e27Sflorian unsigned int a, b, c, d; 1952ae8c6e27Sflorian uint16_t shorts[4]; 1953ae8c6e27Sflorian int l; 1954ae8c6e27Sflorian if(*len < sizeof(shorts)) 1955ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1956ae8c6e27Sflorian 1957ae8c6e27Sflorian if (sscanf(str, "%4x:%4x:%4x:%4x%n", &a, &b, &c, &d, &l) != 4 || 1958ae8c6e27Sflorian l != (int)strlen(str) || /* more data to read */ 1959ae8c6e27Sflorian strpbrk(str, "+-") /* signed hexes */ 1960ae8c6e27Sflorian ) 1961ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_ILNP64; 1962ae8c6e27Sflorian shorts[0] = htons(a); 1963ae8c6e27Sflorian shorts[1] = htons(b); 1964ae8c6e27Sflorian shorts[2] = htons(c); 1965ae8c6e27Sflorian shorts[3] = htons(d); 1966ae8c6e27Sflorian memmove(rd, &shorts, sizeof(shorts)); 1967ae8c6e27Sflorian *len = sizeof(shorts); 1968ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1969ae8c6e27Sflorian } 1970ae8c6e27Sflorian 1971ae8c6e27Sflorian int sldns_str2wire_eui48_buf(const char* str, uint8_t* rd, size_t* len) 1972ae8c6e27Sflorian { 1973ae8c6e27Sflorian unsigned int a, b, c, d, e, f; 1974ae8c6e27Sflorian int l; 1975ae8c6e27Sflorian 1976ae8c6e27Sflorian if(*len < 6) 1977ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1978ae8c6e27Sflorian if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x%n", 1979ae8c6e27Sflorian &a, &b, &c, &d, &e, &f, &l) != 6 || 1980ae8c6e27Sflorian l != (int)strlen(str)) 1981ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_EUI48; 1982ae8c6e27Sflorian rd[0] = a; 1983ae8c6e27Sflorian rd[1] = b; 1984ae8c6e27Sflorian rd[2] = c; 1985ae8c6e27Sflorian rd[3] = d; 1986ae8c6e27Sflorian rd[4] = e; 1987ae8c6e27Sflorian rd[5] = f; 1988ae8c6e27Sflorian *len = 6; 1989ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 1990ae8c6e27Sflorian } 1991ae8c6e27Sflorian 1992ae8c6e27Sflorian int sldns_str2wire_eui64_buf(const char* str, uint8_t* rd, size_t* len) 1993ae8c6e27Sflorian { 1994ae8c6e27Sflorian unsigned int a, b, c, d, e, f, g, h; 1995ae8c6e27Sflorian int l; 1996ae8c6e27Sflorian 1997ae8c6e27Sflorian if(*len < 8) 1998ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1999ae8c6e27Sflorian if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x-%2x-%2x%n", 2000ae8c6e27Sflorian &a, &b, &c, &d, &e, &f, &g, &h, &l) != 8 || 2001ae8c6e27Sflorian l != (int)strlen(str)) 2002ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_EUI64; 2003ae8c6e27Sflorian rd[0] = a; 2004ae8c6e27Sflorian rd[1] = b; 2005ae8c6e27Sflorian rd[2] = c; 2006ae8c6e27Sflorian rd[3] = d; 2007ae8c6e27Sflorian rd[4] = e; 2008ae8c6e27Sflorian rd[5] = f; 2009ae8c6e27Sflorian rd[6] = g; 2010ae8c6e27Sflorian rd[7] = h; 2011ae8c6e27Sflorian *len = 8; 2012ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 2013ae8c6e27Sflorian } 2014ae8c6e27Sflorian 2015ae8c6e27Sflorian int sldns_str2wire_tag_buf(const char* str, uint8_t* rd, size_t* len) 2016ae8c6e27Sflorian { 2017ae8c6e27Sflorian size_t slen = strlen(str); 2018ae8c6e27Sflorian const char* ptr; 2019ae8c6e27Sflorian 2020ae8c6e27Sflorian if (slen > 255) 2021ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_TAG; 2022ae8c6e27Sflorian if(*len < slen+1) 2023ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 2024ae8c6e27Sflorian for (ptr = str; *ptr; ptr++) { 2025ae8c6e27Sflorian if(!isalnum((unsigned char)*ptr)) 2026ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TAG, ptr-str); 2027ae8c6e27Sflorian } 2028ae8c6e27Sflorian rd[0] = (uint8_t)slen; 2029ae8c6e27Sflorian memmove(rd+1, str, slen); 2030ae8c6e27Sflorian *len = slen+1; 2031ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 2032ae8c6e27Sflorian } 2033ae8c6e27Sflorian 2034ae8c6e27Sflorian int sldns_str2wire_long_str_buf(const char* str, uint8_t* rd, size_t* len) 2035ae8c6e27Sflorian { 2036ae8c6e27Sflorian uint8_t ch = 0; 2037ae8c6e27Sflorian const char* pstr = str; 2038ae8c6e27Sflorian size_t length = 0; 2039ae8c6e27Sflorian 2040ae8c6e27Sflorian /* Fill data with parsed bytes */ 2041ae8c6e27Sflorian while (sldns_parse_char(&ch, &pstr)) { 2042ae8c6e27Sflorian if(*len < length+1) 2043ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 2044ae8c6e27Sflorian rd[length++] = ch; 2045ae8c6e27Sflorian } 2046ae8c6e27Sflorian if(!pstr) 2047ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_BAD_ESCAPE; 2048ae8c6e27Sflorian *len = length; 2049ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 2050ae8c6e27Sflorian } 2051ae8c6e27Sflorian 2052ae8c6e27Sflorian int sldns_str2wire_hip_buf(const char* str, uint8_t* rd, size_t* len) 2053ae8c6e27Sflorian { 2054ae8c6e27Sflorian char* s, *end; 2055ae8c6e27Sflorian int e; 2056ae8c6e27Sflorian size_t hitlen, pklen = 0; 2057ae8c6e27Sflorian /* presentation format: 2058ae8c6e27Sflorian * pk-algo HIThex pubkeybase64 2059ae8c6e27Sflorian * wireformat: 2060ae8c6e27Sflorian * hitlen[1byte] pkalgo[1byte] pubkeylen[2byte] [hit] [pubkey] */ 2061ae8c6e27Sflorian if(*len < 4) 2062ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 2063ae8c6e27Sflorian 2064ae8c6e27Sflorian /* read PK algorithm */ 2065ae8c6e27Sflorian rd[1] = (uint8_t)strtol((char*)str, &s, 10); 2066ae8c6e27Sflorian if(*s != ' ') 2067ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INT, s-(char*)str); 2068ae8c6e27Sflorian s++; 2069ae8c6e27Sflorian while(*s == ' ') 2070ae8c6e27Sflorian s++; 2071ae8c6e27Sflorian 2072ae8c6e27Sflorian /* read HIT hex tag */ 2073ae8c6e27Sflorian /* zero terminate the tag (replace later) */ 2074ae8c6e27Sflorian end = strchr(s, ' '); 2075ae8c6e27Sflorian if(!end) return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX, s-(char*)str); 2076ae8c6e27Sflorian *end = 0; 2077ae8c6e27Sflorian hitlen = *len - 4; 2078ae8c6e27Sflorian if((e = sldns_str2wire_hex_buf(s, rd+4, &hitlen)) != 0) { 2079ae8c6e27Sflorian *end = ' '; 2080ae8c6e27Sflorian return RET_ERR_SHIFT(e, s-(char*)str); 2081ae8c6e27Sflorian } 2082ae8c6e27Sflorian if(hitlen > 255) { 2083ae8c6e27Sflorian *end = ' '; 2084ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_LABEL_OVERFLOW, s-(char*)str+255*2); 2085ae8c6e27Sflorian } 2086ae8c6e27Sflorian rd[0] = (uint8_t)hitlen; 2087ae8c6e27Sflorian *end = ' '; 2088ae8c6e27Sflorian s = end+1; 2089ae8c6e27Sflorian 2090ae8c6e27Sflorian /* read pubkey base64 sequence */ 2091ae8c6e27Sflorian pklen = *len - 4 - hitlen; 2092ae8c6e27Sflorian if((e = sldns_str2wire_b64_buf(s, rd+4+hitlen, &pklen)) != 0) 2093ae8c6e27Sflorian return RET_ERR_SHIFT(e, s-(char*)str); 2094ae8c6e27Sflorian if(pklen > 65535) 2095ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_LABEL_OVERFLOW, s-(char*)str+65535); 2096ae8c6e27Sflorian sldns_write_uint16(rd+2, (uint16_t)pklen); 2097ae8c6e27Sflorian 2098ae8c6e27Sflorian *len = 4 + hitlen + pklen; 2099ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 2100ae8c6e27Sflorian } 2101ae8c6e27Sflorian 2102ae8c6e27Sflorian int sldns_str2wire_int16_data_buf(const char* str, uint8_t* rd, size_t* len) 2103ae8c6e27Sflorian { 2104ae8c6e27Sflorian char* s; 2105ae8c6e27Sflorian int n; 2106ae8c6e27Sflorian n = strtol(str, &s, 10); 210757403691Sflorian if(n < 0) /* negative number not allowed */ 210857403691Sflorian return LDNS_WIREPARSE_ERR_SYNTAX; 2109ae8c6e27Sflorian if(*len < ((size_t)n)+2) 2110ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 2111ae8c6e27Sflorian if(n > 65535) 2112ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_LABEL_OVERFLOW; 2113ae8c6e27Sflorian 2114ae8c6e27Sflorian if(n == 0) { 2115ae8c6e27Sflorian sldns_write_uint16(rd, 0); 2116ae8c6e27Sflorian *len = 2; 2117ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 2118ae8c6e27Sflorian } 2119ae8c6e27Sflorian if(*s != ' ') 2120ae8c6e27Sflorian return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INT, s-(char*)str); 2121ae8c6e27Sflorian s++; 2122ae8c6e27Sflorian while(*s == ' ') 2123ae8c6e27Sflorian s++; 2124ae8c6e27Sflorian 2125ae8c6e27Sflorian n = sldns_b64_pton(s, rd+2, (*len)-2); 2126ae8c6e27Sflorian if(n < 0) 2127ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_SYNTAX_B64; 2128ae8c6e27Sflorian sldns_write_uint16(rd, (uint16_t)n); 2129ae8c6e27Sflorian *len = ((size_t)n)+2; 2130ae8c6e27Sflorian return LDNS_WIREPARSE_ERR_OK; 2131ae8c6e27Sflorian } 2132