109a3aaf3SDag-Erling Smørgrav /** 209a3aaf3SDag-Erling Smørgrav * str2wire.c - read txt presentation of RRs 309a3aaf3SDag-Erling Smørgrav * 409a3aaf3SDag-Erling Smørgrav * (c) NLnet Labs, 2005-2006 509a3aaf3SDag-Erling Smørgrav * 609a3aaf3SDag-Erling Smørgrav * See the file LICENSE for the license 709a3aaf3SDag-Erling Smørgrav */ 809a3aaf3SDag-Erling Smørgrav 909a3aaf3SDag-Erling Smørgrav /** 1009a3aaf3SDag-Erling Smørgrav * \file 1109a3aaf3SDag-Erling Smørgrav * 1209a3aaf3SDag-Erling Smørgrav * Parses text to wireformat. 1309a3aaf3SDag-Erling Smørgrav */ 1409a3aaf3SDag-Erling Smørgrav #include "config.h" 1509a3aaf3SDag-Erling Smørgrav #include "sldns/str2wire.h" 1609a3aaf3SDag-Erling Smørgrav #include "sldns/wire2str.h" 1709a3aaf3SDag-Erling Smørgrav #include "sldns/sbuffer.h" 1809a3aaf3SDag-Erling Smørgrav #include "sldns/parse.h" 1909a3aaf3SDag-Erling Smørgrav #include "sldns/parseutil.h" 2009a3aaf3SDag-Erling Smørgrav #include <ctype.h> 2109a3aaf3SDag-Erling Smørgrav #ifdef HAVE_TIME_H 2209a3aaf3SDag-Erling Smørgrav #include <time.h> 2309a3aaf3SDag-Erling Smørgrav #endif 2409a3aaf3SDag-Erling Smørgrav #ifdef HAVE_NETDB_H 2509a3aaf3SDag-Erling Smørgrav #include <netdb.h> 2609a3aaf3SDag-Erling Smørgrav #endif 2709a3aaf3SDag-Erling Smørgrav 289cf5bc93SCy Schubert /** bits for the offset */ 299cf5bc93SCy Schubert #define RET_OFFSET_MASK (((unsigned)(~LDNS_WIREPARSE_MASK))>>LDNS_WIREPARSE_SHIFT) 3009a3aaf3SDag-Erling Smørgrav /** return an error */ 319cf5bc93SCy Schubert #define RET_ERR(e, off) ((int)(((e)&LDNS_WIREPARSE_MASK)|(((off)&RET_OFFSET_MASK)<<LDNS_WIREPARSE_SHIFT))) 3209a3aaf3SDag-Erling Smørgrav /** Move parse error but keep its ID */ 3309a3aaf3SDag-Erling Smørgrav #define RET_ERR_SHIFT(e, move) RET_ERR(LDNS_WIREPARSE_ERROR(e), LDNS_WIREPARSE_OFFSET(e)+(move)); 3409a3aaf3SDag-Erling Smørgrav 3509a3aaf3SDag-Erling Smørgrav /* 3609a3aaf3SDag-Erling Smørgrav * No special care is taken, all dots are translated into 3709a3aaf3SDag-Erling Smørgrav * label separators. 3809a3aaf3SDag-Erling Smørgrav * @param rel: true if the domain is not absolute (not terminated in .). 3909a3aaf3SDag-Erling Smørgrav * The output is then still terminated with a '0' rootlabel. 4009a3aaf3SDag-Erling Smørgrav */ 4109a3aaf3SDag-Erling Smørgrav static int sldns_str2wire_dname_buf_rel(const char* str, uint8_t* buf, 4209a3aaf3SDag-Erling Smørgrav size_t* olen, int* rel) 4309a3aaf3SDag-Erling Smørgrav { 4409a3aaf3SDag-Erling Smørgrav size_t len; 4509a3aaf3SDag-Erling Smørgrav 4609a3aaf3SDag-Erling Smørgrav const char *s; 4709a3aaf3SDag-Erling Smørgrav uint8_t *q, *pq, label_len; 4809a3aaf3SDag-Erling Smørgrav 4909a3aaf3SDag-Erling Smørgrav if(rel) *rel = 0; 5009a3aaf3SDag-Erling Smørgrav len = strlen((char*)str); 5109a3aaf3SDag-Erling Smørgrav /* octet representation can make strings a lot longer than actual length */ 5209a3aaf3SDag-Erling Smørgrav if (len > LDNS_MAX_DOMAINLEN * 4) { 5309a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW, 0); 5409a3aaf3SDag-Erling Smørgrav } 5509a3aaf3SDag-Erling Smørgrav if (0 == len) { 5609a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_DOMAINNAME_UNDERFLOW, 0); 5709a3aaf3SDag-Erling Smørgrav } 5809a3aaf3SDag-Erling Smørgrav 5909a3aaf3SDag-Erling Smørgrav /* root label */ 6009a3aaf3SDag-Erling Smørgrav if (1 == len && *str == '.') { 6109a3aaf3SDag-Erling Smørgrav if(*olen < 1) 6209a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 0); 6309a3aaf3SDag-Erling Smørgrav buf[0] = 0; 6409a3aaf3SDag-Erling Smørgrav *olen = 1; 6509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 6609a3aaf3SDag-Erling Smørgrav } 6709a3aaf3SDag-Erling Smørgrav 6809a3aaf3SDag-Erling Smørgrav /* get on with the rest */ 6909a3aaf3SDag-Erling Smørgrav 7009a3aaf3SDag-Erling Smørgrav /* s is on the current character in the string 7109a3aaf3SDag-Erling Smørgrav * pq points to where the labellength is going to go 7209a3aaf3SDag-Erling Smørgrav * label_len keeps track of the current label's length 7309a3aaf3SDag-Erling Smørgrav * q builds the dname inside the buf array 7409a3aaf3SDag-Erling Smørgrav */ 7509a3aaf3SDag-Erling Smørgrav len = 0; 7609a3aaf3SDag-Erling Smørgrav if(*olen < 1) 7709a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 0); 7809a3aaf3SDag-Erling Smørgrav q = buf+1; 7909a3aaf3SDag-Erling Smørgrav pq = buf; 8009a3aaf3SDag-Erling Smørgrav label_len = 0; 8109a3aaf3SDag-Erling Smørgrav for (s = str; *s; s++, q++) { 8209a3aaf3SDag-Erling Smørgrav if (q >= buf + *olen) 8309a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, q-buf); 84091e9e46SCy Schubert if (q >= buf + LDNS_MAX_DOMAINLEN) 8509a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW, q-buf); 8609a3aaf3SDag-Erling Smørgrav switch (*s) { 8709a3aaf3SDag-Erling Smørgrav case '.': 8809a3aaf3SDag-Erling Smørgrav if (label_len > LDNS_MAX_LABELLEN) { 8909a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_LABEL_OVERFLOW, q-buf); 9009a3aaf3SDag-Erling Smørgrav } 9109a3aaf3SDag-Erling Smørgrav if (label_len == 0) { 9209a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_EMPTY_LABEL, q-buf); 9309a3aaf3SDag-Erling Smørgrav } 9409a3aaf3SDag-Erling Smørgrav len += label_len + 1; 9509a3aaf3SDag-Erling Smørgrav *q = 0; 9609a3aaf3SDag-Erling Smørgrav *pq = label_len; 9709a3aaf3SDag-Erling Smørgrav label_len = 0; 9809a3aaf3SDag-Erling Smørgrav pq = q; 9909a3aaf3SDag-Erling Smørgrav break; 10009a3aaf3SDag-Erling Smørgrav case '\\': 10109a3aaf3SDag-Erling Smørgrav /* octet value or literal char */ 10209a3aaf3SDag-Erling Smørgrav s += 1; 10309a3aaf3SDag-Erling Smørgrav if (!sldns_parse_escape(q, &s)) { 10409a3aaf3SDag-Erling Smørgrav *q = 0; 10509a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_BAD_ESCAPE, q-buf); 10609a3aaf3SDag-Erling Smørgrav } 10709a3aaf3SDag-Erling Smørgrav s -= 1; 10809a3aaf3SDag-Erling Smørgrav label_len++; 10909a3aaf3SDag-Erling Smørgrav break; 11009a3aaf3SDag-Erling Smørgrav default: 11109a3aaf3SDag-Erling Smørgrav *q = (uint8_t)*s; 11209a3aaf3SDag-Erling Smørgrav label_len++; 11309a3aaf3SDag-Erling Smørgrav } 11409a3aaf3SDag-Erling Smørgrav } 11509a3aaf3SDag-Erling Smørgrav 11609a3aaf3SDag-Erling Smørgrav /* add root label if last char was not '.' */ 11709a3aaf3SDag-Erling Smørgrav if(label_len != 0) { 11809a3aaf3SDag-Erling Smørgrav if(rel) *rel = 1; 11909a3aaf3SDag-Erling Smørgrav if (q >= buf + *olen) 12009a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, q-buf); 121091e9e46SCy Schubert if (q >= buf + LDNS_MAX_DOMAINLEN) { 12209a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW, q-buf); 12309a3aaf3SDag-Erling Smørgrav } 12409a3aaf3SDag-Erling Smørgrav if (label_len > LDNS_MAX_LABELLEN) { 12509a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_LABEL_OVERFLOW, q-buf); 12609a3aaf3SDag-Erling Smørgrav } 12709a3aaf3SDag-Erling Smørgrav if (label_len == 0) { /* label_len 0 but not . at end? */ 12809a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_EMPTY_LABEL, q-buf); 12909a3aaf3SDag-Erling Smørgrav } 13009a3aaf3SDag-Erling Smørgrav len += label_len + 1; 13109a3aaf3SDag-Erling Smørgrav *pq = label_len; 13209a3aaf3SDag-Erling Smørgrav *q = 0; 13309a3aaf3SDag-Erling Smørgrav } 13409a3aaf3SDag-Erling Smørgrav len++; 13509a3aaf3SDag-Erling Smørgrav *olen = len; 13609a3aaf3SDag-Erling Smørgrav 13709a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 13809a3aaf3SDag-Erling Smørgrav } 13909a3aaf3SDag-Erling Smørgrav 14009a3aaf3SDag-Erling Smørgrav int sldns_str2wire_dname_buf(const char* str, uint8_t* buf, size_t* len) 14109a3aaf3SDag-Erling Smørgrav { 14209a3aaf3SDag-Erling Smørgrav return sldns_str2wire_dname_buf_rel(str, buf, len, NULL); 14309a3aaf3SDag-Erling Smørgrav } 14409a3aaf3SDag-Erling Smørgrav 14509a3aaf3SDag-Erling Smørgrav int sldns_str2wire_dname_buf_origin(const char* str, uint8_t* buf, size_t* len, 14609a3aaf3SDag-Erling Smørgrav uint8_t* origin, size_t origin_len) 14709a3aaf3SDag-Erling Smørgrav { 14809a3aaf3SDag-Erling Smørgrav size_t dlen = *len; 14909a3aaf3SDag-Erling Smørgrav int rel = 0; 15009a3aaf3SDag-Erling Smørgrav int s = sldns_str2wire_dname_buf_rel(str, buf, &dlen, &rel); 15109a3aaf3SDag-Erling Smørgrav if(s) return s; 15209a3aaf3SDag-Erling Smørgrav 15309a3aaf3SDag-Erling Smørgrav if(rel && origin && dlen > 0) { 1540eefd307SCy Schubert if((unsigned)dlen >= 0x00ffffffU || 1550eefd307SCy Schubert (unsigned)origin_len >= 0x00ffffffU) 1560eefd307SCy Schubert /* guard against integer overflow in addition */ 1570eefd307SCy Schubert return RET_ERR(LDNS_WIREPARSE_ERR_GENERAL, *len); 15809a3aaf3SDag-Erling Smørgrav if(dlen + origin_len - 1 > LDNS_MAX_DOMAINLEN) 15909a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_DOMAINNAME_OVERFLOW, 16009a3aaf3SDag-Erling Smørgrav LDNS_MAX_DOMAINLEN); 16109a3aaf3SDag-Erling Smørgrav if(dlen + origin_len - 1 > *len) 16209a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 16309a3aaf3SDag-Erling Smørgrav *len); 16409a3aaf3SDag-Erling Smørgrav memmove(buf+dlen-1, origin, origin_len); 16509a3aaf3SDag-Erling Smørgrav *len = dlen + origin_len - 1; 16609a3aaf3SDag-Erling Smørgrav } else 16709a3aaf3SDag-Erling Smørgrav *len = dlen; 16809a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 16909a3aaf3SDag-Erling Smørgrav } 17009a3aaf3SDag-Erling Smørgrav 17109a3aaf3SDag-Erling Smørgrav uint8_t* sldns_str2wire_dname(const char* str, size_t* len) 17209a3aaf3SDag-Erling Smørgrav { 17309a3aaf3SDag-Erling Smørgrav uint8_t dname[LDNS_MAX_DOMAINLEN+1]; 17409a3aaf3SDag-Erling Smørgrav *len = sizeof(dname); 17509a3aaf3SDag-Erling Smørgrav if(sldns_str2wire_dname_buf(str, dname, len) == 0) { 1760eefd307SCy Schubert uint8_t* r; 1770eefd307SCy Schubert if(*len > sizeof(dname)) return NULL; 1780eefd307SCy Schubert r = (uint8_t*)malloc(*len); 17909a3aaf3SDag-Erling Smørgrav if(r) return memcpy(r, dname, *len); 18009a3aaf3SDag-Erling Smørgrav } 18109a3aaf3SDag-Erling Smørgrav *len = 0; 18209a3aaf3SDag-Erling Smørgrav return NULL; 18309a3aaf3SDag-Erling Smørgrav } 18409a3aaf3SDag-Erling Smørgrav 18509a3aaf3SDag-Erling Smørgrav /** read owner name */ 18609a3aaf3SDag-Erling Smørgrav static int 18709a3aaf3SDag-Erling Smørgrav rrinternal_get_owner(sldns_buffer* strbuf, uint8_t* rr, size_t* len, 18809a3aaf3SDag-Erling Smørgrav size_t* dname_len, uint8_t* origin, size_t origin_len, uint8_t* prev, 18909a3aaf3SDag-Erling Smørgrav size_t prev_len, char* token, size_t token_len) 19009a3aaf3SDag-Erling Smørgrav { 19109a3aaf3SDag-Erling Smørgrav /* split the rr in its parts -1 signals trouble */ 19209a3aaf3SDag-Erling Smørgrav if(sldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) { 19309a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX, 19409a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 19509a3aaf3SDag-Erling Smørgrav } 19609a3aaf3SDag-Erling Smørgrav 1970eefd307SCy Schubert if(token_len < 2) /* make sure there is space to read "@" or "" */ 1980eefd307SCy Schubert return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 1990eefd307SCy Schubert sldns_buffer_position(strbuf)); 2000eefd307SCy Schubert if(token[0]=='@' && token[1]=='\0') { 20109a3aaf3SDag-Erling Smørgrav uint8_t* tocopy; 20209a3aaf3SDag-Erling Smørgrav if (origin) { 20309a3aaf3SDag-Erling Smørgrav *dname_len = origin_len; 20409a3aaf3SDag-Erling Smørgrav tocopy = origin; 20509a3aaf3SDag-Erling Smørgrav } else if (prev) { 20609a3aaf3SDag-Erling Smørgrav *dname_len = prev_len; 20709a3aaf3SDag-Erling Smørgrav tocopy = prev; 20809a3aaf3SDag-Erling Smørgrav } else { 20909a3aaf3SDag-Erling Smørgrav /* default to root */ 21009a3aaf3SDag-Erling Smørgrav *dname_len = 1; 21109a3aaf3SDag-Erling Smørgrav tocopy = (uint8_t*)"\0"; 21209a3aaf3SDag-Erling Smørgrav } 21309a3aaf3SDag-Erling Smørgrav if(*len < *dname_len) 21409a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 21509a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 21609a3aaf3SDag-Erling Smørgrav memmove(rr, tocopy, *dname_len); 217f61ef7f6SDag-Erling Smørgrav } else if(*token == '\0') { 21809a3aaf3SDag-Erling Smørgrav /* no ownername was given, try prev, if that fails 21909a3aaf3SDag-Erling Smørgrav * origin, else default to root */ 22009a3aaf3SDag-Erling Smørgrav uint8_t* tocopy; 22109a3aaf3SDag-Erling Smørgrav if(prev) { 22209a3aaf3SDag-Erling Smørgrav *dname_len = prev_len; 22309a3aaf3SDag-Erling Smørgrav tocopy = prev; 22409a3aaf3SDag-Erling Smørgrav } else if(origin) { 22509a3aaf3SDag-Erling Smørgrav *dname_len = origin_len; 22609a3aaf3SDag-Erling Smørgrav tocopy = origin; 22709a3aaf3SDag-Erling Smørgrav } else { 22809a3aaf3SDag-Erling Smørgrav *dname_len = 1; 22909a3aaf3SDag-Erling Smørgrav tocopy = (uint8_t*)"\0"; 23009a3aaf3SDag-Erling Smørgrav } 23109a3aaf3SDag-Erling Smørgrav if(*len < *dname_len) 23209a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 23309a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 23409a3aaf3SDag-Erling Smørgrav memmove(rr, tocopy, *dname_len); 23509a3aaf3SDag-Erling Smørgrav } else { 23609a3aaf3SDag-Erling Smørgrav size_t dlen = *len; 23709a3aaf3SDag-Erling Smørgrav int s = sldns_str2wire_dname_buf_origin(token, rr, &dlen, 23809a3aaf3SDag-Erling Smørgrav origin, origin_len); 23909a3aaf3SDag-Erling Smørgrav if(s) return RET_ERR_SHIFT(s, 24009a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)-strlen(token)); 24109a3aaf3SDag-Erling Smørgrav *dname_len = dlen; 24209a3aaf3SDag-Erling Smørgrav } 24309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 24409a3aaf3SDag-Erling Smørgrav } 24509a3aaf3SDag-Erling Smørgrav 24609a3aaf3SDag-Erling Smørgrav /** read ttl */ 24709a3aaf3SDag-Erling Smørgrav static int 24809a3aaf3SDag-Erling Smørgrav rrinternal_get_ttl(sldns_buffer* strbuf, char* token, size_t token_len, 24909a3aaf3SDag-Erling Smørgrav int* not_there, uint32_t* ttl, uint32_t default_ttl) 25009a3aaf3SDag-Erling Smørgrav { 25109a3aaf3SDag-Erling Smørgrav const char* endptr; 252a39a5a69SCy Schubert int overflow; 25309a3aaf3SDag-Erling Smørgrav if(sldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) { 25409a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TTL, 25509a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 25609a3aaf3SDag-Erling Smørgrav } 257a39a5a69SCy Schubert *ttl = (uint32_t) sldns_str2period(token, &endptr, &overflow); 258a39a5a69SCy Schubert if(overflow) { 259a39a5a69SCy Schubert return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INTEGER_OVERFLOW, 260a39a5a69SCy Schubert sldns_buffer_position(strbuf)); 261a39a5a69SCy Schubert } 26209a3aaf3SDag-Erling Smørgrav 26309a3aaf3SDag-Erling Smørgrav if (strlen(token) > 0 && !isdigit((unsigned char)token[0])) { 26409a3aaf3SDag-Erling Smørgrav *not_there = 1; 26509a3aaf3SDag-Erling Smørgrav /* ah, it's not there or something */ 26609a3aaf3SDag-Erling Smørgrav if (default_ttl == 0) { 26709a3aaf3SDag-Erling Smørgrav *ttl = LDNS_DEFAULT_TTL; 26809a3aaf3SDag-Erling Smørgrav } else { 26909a3aaf3SDag-Erling Smørgrav *ttl = default_ttl; 27009a3aaf3SDag-Erling Smørgrav } 27109a3aaf3SDag-Erling Smørgrav } 27209a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 27309a3aaf3SDag-Erling Smørgrav } 27409a3aaf3SDag-Erling Smørgrav 27509a3aaf3SDag-Erling Smørgrav /** read class */ 27609a3aaf3SDag-Erling Smørgrav static int 27709a3aaf3SDag-Erling Smørgrav rrinternal_get_class(sldns_buffer* strbuf, char* token, size_t token_len, 27809a3aaf3SDag-Erling Smørgrav int* not_there, uint16_t* cl) 27909a3aaf3SDag-Erling Smørgrav { 28009a3aaf3SDag-Erling Smørgrav /* if 'not_there' then we got token from previous parse routine */ 28109a3aaf3SDag-Erling Smørgrav if(!*not_there) { 28209a3aaf3SDag-Erling Smørgrav /* parse new token for class */ 28309a3aaf3SDag-Erling Smørgrav if(sldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) { 28409a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_CLASS, 28509a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 28609a3aaf3SDag-Erling Smørgrav } 28709a3aaf3SDag-Erling Smørgrav } else *not_there = 0; 28809a3aaf3SDag-Erling Smørgrav *cl = sldns_get_rr_class_by_name(token); 28909a3aaf3SDag-Erling Smørgrav /* class can be left out too, assume IN, current token must be type */ 29009a3aaf3SDag-Erling Smørgrav if(*cl == 0 && strcmp(token, "CLASS0") != 0) { 29109a3aaf3SDag-Erling Smørgrav *not_there = 1; 29209a3aaf3SDag-Erling Smørgrav *cl = LDNS_RR_CLASS_IN; 29309a3aaf3SDag-Erling Smørgrav } 29409a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 29509a3aaf3SDag-Erling Smørgrav } 29609a3aaf3SDag-Erling Smørgrav 29709a3aaf3SDag-Erling Smørgrav /** read type */ 29809a3aaf3SDag-Erling Smørgrav static int 29909a3aaf3SDag-Erling Smørgrav rrinternal_get_type(sldns_buffer* strbuf, char* token, size_t token_len, 30009a3aaf3SDag-Erling Smørgrav int* not_there, uint16_t* tp) 30109a3aaf3SDag-Erling Smørgrav { 30209a3aaf3SDag-Erling Smørgrav /* if 'not_there' then we got token from previous parse routine */ 30309a3aaf3SDag-Erling Smørgrav if(!*not_there) { 30409a3aaf3SDag-Erling Smørgrav /* parse new token for type */ 30509a3aaf3SDag-Erling Smørgrav if(sldns_bget_token(strbuf, token, "\t\n ", token_len) == -1) { 30609a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TYPE, 30709a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 30809a3aaf3SDag-Erling Smørgrav } 30909a3aaf3SDag-Erling Smørgrav } 31009a3aaf3SDag-Erling Smørgrav *tp = sldns_get_rr_type_by_name(token); 31109a3aaf3SDag-Erling Smørgrav if(*tp == 0 && strcmp(token, "TYPE0") != 0) { 31209a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TYPE, 31309a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 31409a3aaf3SDag-Erling Smørgrav } 31509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 31609a3aaf3SDag-Erling Smørgrav } 31709a3aaf3SDag-Erling Smørgrav 31809a3aaf3SDag-Erling Smørgrav /** put type, class, ttl into rr buffer */ 31909a3aaf3SDag-Erling Smørgrav static int 32009a3aaf3SDag-Erling Smørgrav rrinternal_write_typeclassttl(sldns_buffer* strbuf, uint8_t* rr, size_t len, 32109a3aaf3SDag-Erling Smørgrav size_t dname_len, uint16_t tp, uint16_t cl, uint32_t ttl, int question) 32209a3aaf3SDag-Erling Smørgrav { 32309a3aaf3SDag-Erling Smørgrav if(question) { 32409a3aaf3SDag-Erling Smørgrav /* question is : name, type, class */ 32509a3aaf3SDag-Erling Smørgrav if(dname_len + 4 > len) 32609a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 32709a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 32809a3aaf3SDag-Erling Smørgrav sldns_write_uint16(rr+dname_len, tp); 32909a3aaf3SDag-Erling Smørgrav sldns_write_uint16(rr+dname_len+2, cl); 33009a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 33109a3aaf3SDag-Erling Smørgrav } 33209a3aaf3SDag-Erling Smørgrav 33309a3aaf3SDag-Erling Smørgrav /* type(2), class(2), ttl(4), rdatalen(2 (later)) = 10 */ 33409a3aaf3SDag-Erling Smørgrav if(dname_len + 10 > len) 33509a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 33609a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 33709a3aaf3SDag-Erling Smørgrav sldns_write_uint16(rr+dname_len, tp); 33809a3aaf3SDag-Erling Smørgrav sldns_write_uint16(rr+dname_len+2, cl); 33909a3aaf3SDag-Erling Smørgrav sldns_write_uint32(rr+dname_len+4, ttl); 34009a3aaf3SDag-Erling Smørgrav sldns_write_uint16(rr+dname_len+8, 0); /* rdatalen placeholder */ 34109a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 34209a3aaf3SDag-Erling Smørgrav } 34309a3aaf3SDag-Erling Smørgrav 34409a3aaf3SDag-Erling Smørgrav /** find delimiters for type */ 34509a3aaf3SDag-Erling Smørgrav static const char* 346bc892140SDag-Erling Smørgrav rrinternal_get_delims(sldns_rdf_type rdftype, size_t r_cnt, size_t r_max) 34709a3aaf3SDag-Erling Smørgrav { 34809a3aaf3SDag-Erling Smørgrav switch(rdftype) { 34909a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_B64 : 35009a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_HEX : /* These rdf types may con- */ 35109a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_LOC : /* tain whitespace, only if */ 35209a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_WKS : /* it is the last rd field. */ 35309a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_IPSECKEY : 35409a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_NSEC : if (r_cnt == r_max - 1) { 35509a3aaf3SDag-Erling Smørgrav return "\n"; 35609a3aaf3SDag-Erling Smørgrav } 35709a3aaf3SDag-Erling Smørgrav break; 35809a3aaf3SDag-Erling Smørgrav default : break; 35909a3aaf3SDag-Erling Smørgrav } 36009a3aaf3SDag-Erling Smørgrav return "\n\t "; 36109a3aaf3SDag-Erling Smørgrav } 36209a3aaf3SDag-Erling Smørgrav 36309a3aaf3SDag-Erling Smørgrav /* Syntactic sugar for sldns_rr_new_frm_str_internal */ 36409a3aaf3SDag-Erling Smørgrav static int 36509a3aaf3SDag-Erling Smørgrav sldns_rdf_type_maybe_quoted(sldns_rdf_type rdf_type) 36609a3aaf3SDag-Erling Smørgrav { 36709a3aaf3SDag-Erling Smørgrav return rdf_type == LDNS_RDF_TYPE_STR || 36809a3aaf3SDag-Erling Smørgrav rdf_type == LDNS_RDF_TYPE_LONG_STR; 36909a3aaf3SDag-Erling Smørgrav } 37009a3aaf3SDag-Erling Smørgrav 37109a3aaf3SDag-Erling Smørgrav /** see if rdata is quoted */ 37209a3aaf3SDag-Erling Smørgrav static int 37309a3aaf3SDag-Erling Smørgrav rrinternal_get_quoted(sldns_buffer* strbuf, const char** delimiters, 37409a3aaf3SDag-Erling Smørgrav sldns_rdf_type rdftype) 37509a3aaf3SDag-Erling Smørgrav { 37609a3aaf3SDag-Erling Smørgrav if(sldns_rdf_type_maybe_quoted(rdftype) && 37709a3aaf3SDag-Erling Smørgrav sldns_buffer_remaining(strbuf) > 0) { 37809a3aaf3SDag-Erling Smørgrav 37909a3aaf3SDag-Erling Smørgrav /* skip spaces */ 38009a3aaf3SDag-Erling Smørgrav while(sldns_buffer_remaining(strbuf) > 0 && 381a39a5a69SCy Schubert (*(sldns_buffer_current(strbuf)) == ' ' || 382a39a5a69SCy Schubert *(sldns_buffer_current(strbuf)) == '\t')) { 38309a3aaf3SDag-Erling Smørgrav sldns_buffer_skip(strbuf, 1); 38409a3aaf3SDag-Erling Smørgrav } 38509a3aaf3SDag-Erling Smørgrav 38609a3aaf3SDag-Erling Smørgrav if(sldns_buffer_remaining(strbuf) > 0 && 38709a3aaf3SDag-Erling Smørgrav *(sldns_buffer_current(strbuf)) == '\"') { 38809a3aaf3SDag-Erling Smørgrav *delimiters = "\"\0"; 38909a3aaf3SDag-Erling Smørgrav sldns_buffer_skip(strbuf, 1); 39009a3aaf3SDag-Erling Smørgrav return 1; 39109a3aaf3SDag-Erling Smørgrav } 39209a3aaf3SDag-Erling Smørgrav } 39309a3aaf3SDag-Erling Smørgrav return 0; 39409a3aaf3SDag-Erling Smørgrav } 39509a3aaf3SDag-Erling Smørgrav 39609a3aaf3SDag-Erling Smørgrav /** spool hex data into rdata */ 39709a3aaf3SDag-Erling Smørgrav static int 39809a3aaf3SDag-Erling Smørgrav rrinternal_spool_hex(char* token, uint8_t* rr, size_t rr_len, 39909a3aaf3SDag-Erling Smørgrav size_t rr_cur_len, size_t* cur_hex_data_size, size_t hex_data_size) 40009a3aaf3SDag-Erling Smørgrav { 40109a3aaf3SDag-Erling Smørgrav char* p = token; 40209a3aaf3SDag-Erling Smørgrav while(*p) { 40309a3aaf3SDag-Erling Smørgrav if(isspace((unsigned char)*p)) { 40409a3aaf3SDag-Erling Smørgrav p++; 40509a3aaf3SDag-Erling Smørgrav continue; 40609a3aaf3SDag-Erling Smørgrav } 40709a3aaf3SDag-Erling Smørgrav if(!isxdigit((unsigned char)*p)) 40809a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_RDATA, 40909a3aaf3SDag-Erling Smørgrav p-token); 41009a3aaf3SDag-Erling Smørgrav if(*cur_hex_data_size >= hex_data_size) 41109a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_RDATA, 41209a3aaf3SDag-Erling Smørgrav p-token); 41309a3aaf3SDag-Erling Smørgrav /* extra robust check */ 41409a3aaf3SDag-Erling Smørgrav if(rr_cur_len+(*cur_hex_data_size)/2 >= rr_len) 41509a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 41609a3aaf3SDag-Erling Smørgrav p-token); 41709a3aaf3SDag-Erling Smørgrav /* see if 16s or 1s */ 41809a3aaf3SDag-Erling Smørgrav if( ((*cur_hex_data_size)&1) == 0) { 41909a3aaf3SDag-Erling Smørgrav rr[rr_cur_len+(*cur_hex_data_size)/2] = 42009a3aaf3SDag-Erling Smørgrav (uint8_t)sldns_hexdigit_to_int(*p)*16; 42109a3aaf3SDag-Erling Smørgrav } else { 42209a3aaf3SDag-Erling Smørgrav rr[rr_cur_len+(*cur_hex_data_size)/2] += 42309a3aaf3SDag-Erling Smørgrav (uint8_t)sldns_hexdigit_to_int(*p); 42409a3aaf3SDag-Erling Smørgrav } 42509a3aaf3SDag-Erling Smørgrav p++; 42609a3aaf3SDag-Erling Smørgrav (*cur_hex_data_size)++; 42709a3aaf3SDag-Erling Smørgrav } 42809a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 42909a3aaf3SDag-Erling Smørgrav } 43009a3aaf3SDag-Erling Smørgrav 43109a3aaf3SDag-Erling Smørgrav /** read unknown rr type format */ 43209a3aaf3SDag-Erling Smørgrav static int 43309a3aaf3SDag-Erling Smørgrav rrinternal_parse_unknown(sldns_buffer* strbuf, char* token, size_t token_len, 43409a3aaf3SDag-Erling Smørgrav uint8_t* rr, size_t* rr_len, size_t* rr_cur_len, size_t pre_data_pos) 43509a3aaf3SDag-Erling Smørgrav { 43609a3aaf3SDag-Erling Smørgrav const char* delim = "\n\t "; 43709a3aaf3SDag-Erling Smørgrav size_t hex_data_size, cur_hex_data_size; 43809a3aaf3SDag-Erling Smørgrav /* go back to before \# 43909a3aaf3SDag-Erling Smørgrav * and skip it while setting delimiters better 44009a3aaf3SDag-Erling Smørgrav */ 44109a3aaf3SDag-Erling Smørgrav sldns_buffer_set_position(strbuf, pre_data_pos); 44209a3aaf3SDag-Erling Smørgrav if(sldns_bget_token(strbuf, token, delim, token_len) == -1) 44309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_GENERAL; /* should not fail */ 44409a3aaf3SDag-Erling Smørgrav /* read rdata octet length */ 44509a3aaf3SDag-Erling Smørgrav if(sldns_bget_token(strbuf, token, delim, token_len) == -1) { 44609a3aaf3SDag-Erling Smørgrav /* something goes very wrong here */ 44709a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_RDATA, 44809a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 44909a3aaf3SDag-Erling Smørgrav } 45009a3aaf3SDag-Erling Smørgrav hex_data_size = (size_t)atoi(token); 45109a3aaf3SDag-Erling Smørgrav if(hex_data_size > LDNS_MAX_RDFLEN || 45209a3aaf3SDag-Erling Smørgrav *rr_cur_len + hex_data_size > *rr_len) { 45309a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 45409a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 45509a3aaf3SDag-Erling Smørgrav } 45609a3aaf3SDag-Erling Smørgrav /* copy hex chars into hex str (2 chars per byte) */ 45709a3aaf3SDag-Erling Smørgrav hex_data_size *= 2; 45809a3aaf3SDag-Erling Smørgrav cur_hex_data_size = 0; 45909a3aaf3SDag-Erling Smørgrav while(cur_hex_data_size < hex_data_size) { 46009a3aaf3SDag-Erling Smørgrav int status; 46109a3aaf3SDag-Erling Smørgrav ssize_t c = sldns_bget_token(strbuf, token, delim, token_len); 46209a3aaf3SDag-Erling Smørgrav if((status = rrinternal_spool_hex(token, rr, *rr_len, 46309a3aaf3SDag-Erling Smørgrav *rr_cur_len, &cur_hex_data_size, hex_data_size)) != 0) 46409a3aaf3SDag-Erling Smørgrav return RET_ERR_SHIFT(status, 46509a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)-strlen(token)); 46609a3aaf3SDag-Erling Smørgrav if(c == -1) { 46709a3aaf3SDag-Erling Smørgrav if(cur_hex_data_size != hex_data_size) 46809a3aaf3SDag-Erling Smørgrav return RET_ERR( 46909a3aaf3SDag-Erling Smørgrav LDNS_WIREPARSE_ERR_SYNTAX_RDATA, 47009a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 47109a3aaf3SDag-Erling Smørgrav break; 47209a3aaf3SDag-Erling Smørgrav } 47309a3aaf3SDag-Erling Smørgrav } 47409a3aaf3SDag-Erling Smørgrav *rr_cur_len += hex_data_size/2; 47509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 47609a3aaf3SDag-Erling Smørgrav } 47709a3aaf3SDag-Erling Smørgrav 47809a3aaf3SDag-Erling Smørgrav /** parse normal RR rdata element */ 47909a3aaf3SDag-Erling Smørgrav static int 48009a3aaf3SDag-Erling Smørgrav rrinternal_parse_rdf(sldns_buffer* strbuf, char* token, size_t token_len, 48109a3aaf3SDag-Erling Smørgrav uint8_t* rr, size_t rr_len, size_t* rr_cur_len, sldns_rdf_type rdftype, 482bc892140SDag-Erling Smørgrav uint16_t rr_type, size_t r_cnt, size_t r_max, size_t dname_len, 48309a3aaf3SDag-Erling Smørgrav uint8_t* origin, size_t origin_len) 48409a3aaf3SDag-Erling Smørgrav { 48509a3aaf3SDag-Erling Smørgrav size_t len; 48609a3aaf3SDag-Erling Smørgrav int status; 48709a3aaf3SDag-Erling Smørgrav 48809a3aaf3SDag-Erling Smørgrav switch(rdftype) { 48909a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_DNAME: 49009a3aaf3SDag-Erling Smørgrav /* check if the origin should be used or concatenated */ 49109a3aaf3SDag-Erling Smørgrav if(strcmp(token, "@") == 0) { 49209a3aaf3SDag-Erling Smørgrav uint8_t* tocopy; 49309a3aaf3SDag-Erling Smørgrav size_t copylen; 49409a3aaf3SDag-Erling Smørgrav if(origin) { 49509a3aaf3SDag-Erling Smørgrav copylen = origin_len; 49609a3aaf3SDag-Erling Smørgrav tocopy = origin; 49709a3aaf3SDag-Erling Smørgrav } else if(rr_type == LDNS_RR_TYPE_SOA) { 49809a3aaf3SDag-Erling Smørgrav copylen = dname_len; 49909a3aaf3SDag-Erling Smørgrav tocopy = rr; /* copy rr owner name */ 50009a3aaf3SDag-Erling Smørgrav } else { 50109a3aaf3SDag-Erling Smørgrav copylen = 1; 50209a3aaf3SDag-Erling Smørgrav tocopy = (uint8_t*)"\0"; 50309a3aaf3SDag-Erling Smørgrav } 50409a3aaf3SDag-Erling Smørgrav if((*rr_cur_len) + copylen > rr_len) 50509a3aaf3SDag-Erling Smørgrav return RET_ERR( 50609a3aaf3SDag-Erling Smørgrav LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 50709a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 50809a3aaf3SDag-Erling Smørgrav memmove(rr+*rr_cur_len, tocopy, copylen); 50909a3aaf3SDag-Erling Smørgrav (*rr_cur_len) += copylen; 51009a3aaf3SDag-Erling Smørgrav } else { 51109a3aaf3SDag-Erling Smørgrav size_t dlen = rr_len - (*rr_cur_len); 51209a3aaf3SDag-Erling Smørgrav int s = sldns_str2wire_dname_buf_origin(token, 51309a3aaf3SDag-Erling Smørgrav rr+*rr_cur_len, &dlen, origin, origin_len); 51409a3aaf3SDag-Erling Smørgrav if(s) return RET_ERR_SHIFT(s, 51509a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)-strlen(token)); 51609a3aaf3SDag-Erling Smørgrav (*rr_cur_len) += dlen; 51709a3aaf3SDag-Erling Smørgrav } 51809a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 51909a3aaf3SDag-Erling Smørgrav 52009a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_HEX: 52109a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_B64: 52209a3aaf3SDag-Erling Smørgrav /* When this is the last rdata field, then the 52309a3aaf3SDag-Erling Smørgrav * rest should be read in (cause then these 52409a3aaf3SDag-Erling Smørgrav * rdf types may contain spaces). */ 52509a3aaf3SDag-Erling Smørgrav if(r_cnt == r_max - 1) { 52609a3aaf3SDag-Erling Smørgrav size_t tlen = strlen(token); 52709a3aaf3SDag-Erling Smørgrav (void)sldns_bget_token(strbuf, token+tlen, "\n", 52809a3aaf3SDag-Erling Smørgrav token_len - tlen); 52909a3aaf3SDag-Erling Smørgrav } 53009a3aaf3SDag-Erling Smørgrav break; 53109a3aaf3SDag-Erling Smørgrav default: 53209a3aaf3SDag-Erling Smørgrav break; 53309a3aaf3SDag-Erling Smørgrav } 53409a3aaf3SDag-Erling Smørgrav 53509a3aaf3SDag-Erling Smørgrav len = rr_len - (*rr_cur_len); 53609a3aaf3SDag-Erling Smørgrav if((status=sldns_str2wire_rdf_buf(token, rr+(*rr_cur_len), &len, 53709a3aaf3SDag-Erling Smørgrav rdftype)) != 0) 53809a3aaf3SDag-Erling Smørgrav return RET_ERR_SHIFT(status, 53909a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)-strlen(token)); 54009a3aaf3SDag-Erling Smørgrav *rr_cur_len += len; 54109a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 54209a3aaf3SDag-Erling Smørgrav } 54309a3aaf3SDag-Erling Smørgrav 54409a3aaf3SDag-Erling Smørgrav /** 54509a3aaf3SDag-Erling Smørgrav * Parse one rdf token. Takes care of quotes and parenthesis. 54609a3aaf3SDag-Erling Smørgrav */ 54709a3aaf3SDag-Erling Smørgrav static int 54809a3aaf3SDag-Erling Smørgrav sldns_parse_rdf_token(sldns_buffer* strbuf, char* token, size_t token_len, 54909a3aaf3SDag-Erling Smørgrav int* quoted, int* parens, size_t* pre_data_pos, 55009a3aaf3SDag-Erling Smørgrav const char* delimiters, sldns_rdf_type rdftype, size_t* token_strlen) 55109a3aaf3SDag-Erling Smørgrav { 55209a3aaf3SDag-Erling Smørgrav size_t slen; 55309a3aaf3SDag-Erling Smørgrav 5549cf5bc93SCy Schubert /* skip spaces and tabs */ 55509a3aaf3SDag-Erling Smørgrav while(sldns_buffer_remaining(strbuf) > 0 && !*quoted && 5569cf5bc93SCy Schubert (*(sldns_buffer_current(strbuf)) == ' ' || 5579cf5bc93SCy Schubert *(sldns_buffer_current(strbuf)) == '\t')) { 55809a3aaf3SDag-Erling Smørgrav sldns_buffer_skip(strbuf, 1); 55909a3aaf3SDag-Erling Smørgrav } 56009a3aaf3SDag-Erling Smørgrav 56109a3aaf3SDag-Erling Smørgrav *pre_data_pos = sldns_buffer_position(strbuf); 56209a3aaf3SDag-Erling Smørgrav if(sldns_bget_token_par(strbuf, token, (*quoted)?"\"":delimiters, 56309a3aaf3SDag-Erling Smørgrav token_len, parens, (*quoted)?NULL:" \t") == -1) { 56409a3aaf3SDag-Erling Smørgrav return 0; 56509a3aaf3SDag-Erling Smørgrav } 56609a3aaf3SDag-Erling Smørgrav slen = strlen(token); 56709a3aaf3SDag-Erling Smørgrav /* check if not quoted yet, and we have encountered quotes */ 56809a3aaf3SDag-Erling Smørgrav if(!*quoted && sldns_rdf_type_maybe_quoted(rdftype) && 56909a3aaf3SDag-Erling Smørgrav slen >= 2 && 57009a3aaf3SDag-Erling Smørgrav (token[0] == '"' || token[0] == '\'') && 57109a3aaf3SDag-Erling Smørgrav (token[slen-1] == '"' || token[slen-1] == '\'')) { 57209a3aaf3SDag-Erling Smørgrav /* move token two smaller (quotes) with endnull */ 57309a3aaf3SDag-Erling Smørgrav memmove(token, token+1, slen-2); 57409a3aaf3SDag-Erling Smørgrav token[slen-2] = 0; 57509a3aaf3SDag-Erling Smørgrav slen -= 2; 57609a3aaf3SDag-Erling Smørgrav *quoted = 1; 57709a3aaf3SDag-Erling Smørgrav } else if(!*quoted && sldns_rdf_type_maybe_quoted(rdftype) && 57809a3aaf3SDag-Erling Smørgrav slen >= 2 && 57909a3aaf3SDag-Erling Smørgrav (token[0] == '"' || token[0] == '\'')) { 58009a3aaf3SDag-Erling Smørgrav /* got the start quote (remove it) but read remainder 58109a3aaf3SDag-Erling Smørgrav * of quoted string as well into remainder of token */ 58209a3aaf3SDag-Erling Smørgrav memmove(token, token+1, slen-1); 58309a3aaf3SDag-Erling Smørgrav token[slen-1] = 0; 58409a3aaf3SDag-Erling Smørgrav slen -= 1; 58509a3aaf3SDag-Erling Smørgrav *quoted = 1; 58609a3aaf3SDag-Erling Smørgrav /* rewind buffer over skipped whitespace */ 58709a3aaf3SDag-Erling Smørgrav while(sldns_buffer_position(strbuf) > 0 && 58809a3aaf3SDag-Erling Smørgrav (sldns_buffer_current(strbuf)[-1] == ' ' || 58909a3aaf3SDag-Erling Smørgrav sldns_buffer_current(strbuf)[-1] == '\t')) { 59009a3aaf3SDag-Erling Smørgrav sldns_buffer_skip(strbuf, -1); 59109a3aaf3SDag-Erling Smørgrav } 59209a3aaf3SDag-Erling Smørgrav if(sldns_bget_token_par(strbuf, token+slen, 59309a3aaf3SDag-Erling Smørgrav "\"", token_len-slen, 59409a3aaf3SDag-Erling Smørgrav parens, NULL) == -1) { 59509a3aaf3SDag-Erling Smørgrav return 0; 59609a3aaf3SDag-Erling Smørgrav } 59709a3aaf3SDag-Erling Smørgrav slen = strlen(token); 59809a3aaf3SDag-Erling Smørgrav } 59909a3aaf3SDag-Erling Smørgrav *token_strlen = slen; 60009a3aaf3SDag-Erling Smørgrav return 1; 60109a3aaf3SDag-Erling Smørgrav } 60209a3aaf3SDag-Erling Smørgrav 60309a3aaf3SDag-Erling Smørgrav /** Add space and one more rdf token onto the existing token string. */ 60409a3aaf3SDag-Erling Smørgrav static int 60509a3aaf3SDag-Erling Smørgrav sldns_affix_token(sldns_buffer* strbuf, char* token, size_t* token_len, 60609a3aaf3SDag-Erling Smørgrav int* quoted, int* parens, size_t* pre_data_pos, 60709a3aaf3SDag-Erling Smørgrav const char* delimiters, sldns_rdf_type rdftype, size_t* token_strlen) 60809a3aaf3SDag-Erling Smørgrav { 60909a3aaf3SDag-Erling Smørgrav size_t addlen = *token_len - *token_strlen; 61009a3aaf3SDag-Erling Smørgrav size_t addstrlen = 0; 61109a3aaf3SDag-Erling Smørgrav 61209a3aaf3SDag-Erling Smørgrav /* add space */ 6139cf5bc93SCy Schubert /* when addlen < 2, the token buffer is full considering the NULL byte 6149cf5bc93SCy Schubert * from strlen and will lead to buffer overflow with the second 615a39a5a69SCy Schubert * assignment below. */ 6169cf5bc93SCy Schubert if(addlen < 2) return 0; 61709a3aaf3SDag-Erling Smørgrav token[*token_strlen] = ' '; 61809a3aaf3SDag-Erling Smørgrav token[++(*token_strlen)] = 0; 61909a3aaf3SDag-Erling Smørgrav 62009a3aaf3SDag-Erling Smørgrav /* read another token */ 62109a3aaf3SDag-Erling Smørgrav addlen = *token_len - *token_strlen; 62209a3aaf3SDag-Erling Smørgrav if(!sldns_parse_rdf_token(strbuf, token+*token_strlen, addlen, quoted, 62309a3aaf3SDag-Erling Smørgrav parens, pre_data_pos, delimiters, rdftype, &addstrlen)) 62409a3aaf3SDag-Erling Smørgrav return 0; 62509a3aaf3SDag-Erling Smørgrav (*token_strlen) += addstrlen; 62609a3aaf3SDag-Erling Smørgrav return 1; 62709a3aaf3SDag-Erling Smørgrav } 62809a3aaf3SDag-Erling Smørgrav 6295469a995SCy Schubert static int sldns_str2wire_svcparam_key_cmp(const void *a, const void *b) 6305469a995SCy Schubert { 6315469a995SCy Schubert return sldns_read_uint16(*(uint8_t**) a) 6325469a995SCy Schubert - sldns_read_uint16(*(uint8_t**) b); 6335469a995SCy Schubert } 6345469a995SCy Schubert 6355469a995SCy Schubert /** 6365469a995SCy Schubert * Add constraints to the SVCB RRs which involve the whole set 6375469a995SCy Schubert */ 6385469a995SCy Schubert static int sldns_str2wire_check_svcbparams(uint8_t* rdata, uint16_t rdata_len) 6395469a995SCy Schubert { 6405469a995SCy Schubert size_t nparams = 0, i; 6415469a995SCy Schubert uint8_t new_rdata[LDNS_MAX_RDFLEN]; 6425469a995SCy Schubert uint8_t* new_rdata_ptr = new_rdata; 6435469a995SCy Schubert uint8_t* svcparams[MAX_NUMBER_OF_SVCPARAMS]; 6445469a995SCy Schubert uint8_t* rdata_ptr = rdata; 6455469a995SCy Schubert uint16_t rdata_remaining = rdata_len; 6465469a995SCy Schubert 6475469a995SCy Schubert /* find the SvcParams */ 6485469a995SCy Schubert while (rdata_remaining) { 6495469a995SCy Schubert uint16_t svcbparam_len; 6505469a995SCy Schubert 6515469a995SCy Schubert svcparams[nparams] = rdata_ptr; 6525469a995SCy Schubert if (rdata_remaining < 4) 6535469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCPARAM_BROKEN_RDATA; 6545469a995SCy Schubert svcbparam_len = sldns_read_uint16(rdata_ptr + 2); 6555469a995SCy Schubert rdata_remaining -= 4; 6565469a995SCy Schubert rdata_ptr += 4; 6575469a995SCy Schubert 6585469a995SCy Schubert if (rdata_remaining < svcbparam_len) 6595469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCPARAM_BROKEN_RDATA; 6605469a995SCy Schubert rdata_remaining -= svcbparam_len; 6615469a995SCy Schubert rdata_ptr += svcbparam_len; 6625469a995SCy Schubert 6635469a995SCy Schubert nparams += 1; 6645469a995SCy Schubert if (nparams >= MAX_NUMBER_OF_SVCPARAMS) 6655469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCB_TOO_MANY_PARAMS; 6665469a995SCy Schubert } 6675469a995SCy Schubert 6685469a995SCy Schubert /* In draft-ietf-dnsop-svcb-https-06 Section 7: 6695469a995SCy Schubert * 6705469a995SCy Schubert * In wire format, the keys are represented by their numeric 6715469a995SCy Schubert * values in network byte order, concatenated in ascending order. 6725469a995SCy Schubert */ 6735469a995SCy Schubert qsort((void *)svcparams 6745469a995SCy Schubert ,nparams 6755469a995SCy Schubert ,sizeof(uint8_t*) 6765469a995SCy Schubert ,sldns_str2wire_svcparam_key_cmp); 6775469a995SCy Schubert 6785469a995SCy Schubert 679a39a5a69SCy Schubert /* The code below revolves around semantic errors in the SVCParam set. 6805469a995SCy Schubert * So long as we do not distinguish between running Unbound as a primary 6815469a995SCy Schubert * or as a secondary, we default to secondary behavior and we ignore the 682a39a5a69SCy Schubert * semantic errors. */ 6835469a995SCy Schubert 6845469a995SCy Schubert #ifdef SVCB_SEMANTIC_ERRORS 6855469a995SCy Schubert { 6865469a995SCy Schubert uint8_t* mandatory = NULL; 6875469a995SCy Schubert /* In draft-ietf-dnsop-svcb-https-06 Section 7: 6885469a995SCy Schubert * 6895469a995SCy Schubert * Keys (...) MUST NOT appear more than once. 6905469a995SCy Schubert * 6915469a995SCy Schubert * If they key has already been seen, we have a duplicate 6925469a995SCy Schubert */ 6935469a995SCy Schubert for(i=0; i < nparams; i++) { 6945469a995SCy Schubert uint16_t key = sldns_read_uint16(svcparams[i]); 6955469a995SCy Schubert if(i + 1 < nparams && key == sldns_read_uint16(svcparams[i+1])) 6965469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCB_DUPLICATE_KEYS; 6975469a995SCy Schubert if(key == SVCB_KEY_MANDATORY) 6985469a995SCy Schubert mandatory = svcparams[i]; 6995469a995SCy Schubert } 7005469a995SCy Schubert 701*8f76bb7dSCy Schubert /* Verify that all the SvcParamKeys in mandatory are present */ 7025469a995SCy Schubert if(mandatory) { 7035469a995SCy Schubert /* Divide by sizeof(uint16_t)*/ 7045469a995SCy Schubert uint16_t mandatory_nkeys = sldns_read_uint16(mandatory + 2) / sizeof(uint16_t); 7055469a995SCy Schubert 7065469a995SCy Schubert /* Guaranteed by sldns_str2wire_svcparam_key_value */ 7075469a995SCy Schubert assert(mandatory_nkeys > 0); 7085469a995SCy Schubert 7095469a995SCy Schubert for(i=0; i < mandatory_nkeys; i++) { 7105469a995SCy Schubert uint16_t mandatory_key = sldns_read_uint16( 7115469a995SCy Schubert mandatory 7125469a995SCy Schubert + 2 * sizeof(uint16_t) 7135469a995SCy Schubert + i * sizeof(uint16_t)); 7145469a995SCy Schubert uint8_t found = 0; 7155469a995SCy Schubert size_t j; 7165469a995SCy Schubert 7175469a995SCy Schubert for(j=0; j < nparams; j++) { 7185469a995SCy Schubert if(mandatory_key == sldns_read_uint16(svcparams[j])) { 7195469a995SCy Schubert found = 1; 7205469a995SCy Schubert break; 7215469a995SCy Schubert } 7225469a995SCy Schubert } 7235469a995SCy Schubert 7245469a995SCy Schubert if(!found) 7255469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCB_MANDATORY_MISSING_PARAM; 7265469a995SCy Schubert } 7275469a995SCy Schubert } 7285469a995SCy Schubert } 7295469a995SCy Schubert #endif 7305469a995SCy Schubert /* Write rdata in correct order */ 7315469a995SCy Schubert for (i = 0; i < nparams; i++) { 7325469a995SCy Schubert uint16_t svcparam_len = sldns_read_uint16(svcparams[i] + 2) 7335469a995SCy Schubert + 2 * sizeof(uint16_t); 7345469a995SCy Schubert 7355469a995SCy Schubert if ((unsigned)(new_rdata_ptr - new_rdata) + svcparam_len > sizeof(new_rdata)) 7365469a995SCy Schubert return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 7375469a995SCy Schubert 7385469a995SCy Schubert memcpy(new_rdata_ptr, svcparams[i], svcparam_len); 7395469a995SCy Schubert new_rdata_ptr += svcparam_len; 7405469a995SCy Schubert } 7415469a995SCy Schubert memcpy(rdata, new_rdata, rdata_len); 7425469a995SCy Schubert return LDNS_WIREPARSE_ERR_OK; 7435469a995SCy Schubert } 7445469a995SCy Schubert 74509a3aaf3SDag-Erling Smørgrav /** parse rdata from string into rr buffer(-remainder after dname). */ 74609a3aaf3SDag-Erling Smørgrav static int 74709a3aaf3SDag-Erling Smørgrav rrinternal_parse_rdata(sldns_buffer* strbuf, char* token, size_t token_len, 74809a3aaf3SDag-Erling Smørgrav uint8_t* rr, size_t* rr_len, size_t dname_len, uint16_t rr_type, 74909a3aaf3SDag-Erling Smørgrav uint8_t* origin, size_t origin_len) 75009a3aaf3SDag-Erling Smørgrav { 75109a3aaf3SDag-Erling Smørgrav const sldns_rr_descriptor *desc = sldns_rr_descript((uint16_t)rr_type); 752bc892140SDag-Erling Smørgrav size_t r_cnt, r_min, r_max; 75309a3aaf3SDag-Erling Smørgrav size_t rr_cur_len = dname_len + 10, pre_data_pos, token_strlen; 75409a3aaf3SDag-Erling Smørgrav int was_unknown_rr_format = 0, parens = 0, status, quoted; 75509a3aaf3SDag-Erling Smørgrav const char* delimiters; 75609a3aaf3SDag-Erling Smørgrav sldns_rdf_type rdftype; 75709a3aaf3SDag-Erling Smørgrav /* a desc is always returned */ 75809a3aaf3SDag-Erling Smørgrav if(!desc) return LDNS_WIREPARSE_ERR_GENERAL; 75909a3aaf3SDag-Erling Smørgrav r_max = sldns_rr_descriptor_maximum(desc); 76009a3aaf3SDag-Erling Smørgrav r_min = sldns_rr_descriptor_minimum(desc); 76109a3aaf3SDag-Erling Smørgrav /* robust check */ 76209a3aaf3SDag-Erling Smørgrav if(rr_cur_len > *rr_len) 76309a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 76409a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 76509a3aaf3SDag-Erling Smørgrav 76609a3aaf3SDag-Erling Smørgrav /* because number of fields can be variable, we can't rely on 76709a3aaf3SDag-Erling Smørgrav * _maximum() only */ 76809a3aaf3SDag-Erling Smørgrav for(r_cnt=0; r_cnt < r_max; r_cnt++) { 76909a3aaf3SDag-Erling Smørgrav rdftype = sldns_rr_descriptor_field_type(desc, r_cnt); 77009a3aaf3SDag-Erling Smørgrav delimiters = rrinternal_get_delims(rdftype, r_cnt, r_max); 77109a3aaf3SDag-Erling Smørgrav quoted = rrinternal_get_quoted(strbuf, &delimiters, rdftype); 77209a3aaf3SDag-Erling Smørgrav 77309a3aaf3SDag-Erling Smørgrav if(!sldns_parse_rdf_token(strbuf, token, token_len, "ed, 77409a3aaf3SDag-Erling Smørgrav &parens, &pre_data_pos, delimiters, rdftype, 77509a3aaf3SDag-Erling Smørgrav &token_strlen)) 77609a3aaf3SDag-Erling Smørgrav break; 77709a3aaf3SDag-Erling Smørgrav 77809a3aaf3SDag-Erling Smørgrav /* rfc3597 specifies that any type can be represented 77909a3aaf3SDag-Erling Smørgrav * with \# method, which can contain spaces... 78009a3aaf3SDag-Erling Smørgrav * it does specify size though... */ 78109a3aaf3SDag-Erling Smørgrav 78209a3aaf3SDag-Erling Smørgrav /* unknown RR data */ 78309a3aaf3SDag-Erling Smørgrav if(token_strlen>=2 && strncmp(token, "\\#", 2) == 0 && 784a39a5a69SCy Schubert !quoted && (token_strlen == 2 || token[2]==' ' || 785a39a5a69SCy Schubert token[2]=='\t')) { 78609a3aaf3SDag-Erling Smørgrav was_unknown_rr_format = 1; 78709a3aaf3SDag-Erling Smørgrav if((status=rrinternal_parse_unknown(strbuf, token, 78809a3aaf3SDag-Erling Smørgrav token_len, rr, rr_len, &rr_cur_len, 78909a3aaf3SDag-Erling Smørgrav pre_data_pos)) != 0) 79009a3aaf3SDag-Erling Smørgrav return status; 79109a3aaf3SDag-Erling Smørgrav } else if(token_strlen > 0 || quoted) { 79209a3aaf3SDag-Erling Smørgrav if(rdftype == LDNS_RDF_TYPE_HIP) { 79309a3aaf3SDag-Erling Smørgrav /* affix the HIT and PK fields, with a space */ 79409a3aaf3SDag-Erling Smørgrav if(!sldns_affix_token(strbuf, token, 79509a3aaf3SDag-Erling Smørgrav &token_len, "ed, &parens, 79609a3aaf3SDag-Erling Smørgrav &pre_data_pos, delimiters, 79709a3aaf3SDag-Erling Smørgrav rdftype, &token_strlen)) 79809a3aaf3SDag-Erling Smørgrav break; 79909a3aaf3SDag-Erling Smørgrav if(!sldns_affix_token(strbuf, token, 80009a3aaf3SDag-Erling Smørgrav &token_len, "ed, &parens, 80109a3aaf3SDag-Erling Smørgrav &pre_data_pos, delimiters, 80209a3aaf3SDag-Erling Smørgrav rdftype, &token_strlen)) 80309a3aaf3SDag-Erling Smørgrav break; 804c7f4d7adSDag-Erling Smørgrav } else if(rdftype == LDNS_RDF_TYPE_INT16_DATA && 805c7f4d7adSDag-Erling Smørgrav strcmp(token, "0")!=0) { 806c7f4d7adSDag-Erling Smørgrav /* affix len and b64 fields */ 807c7f4d7adSDag-Erling Smørgrav if(!sldns_affix_token(strbuf, token, 808c7f4d7adSDag-Erling Smørgrav &token_len, "ed, &parens, 809c7f4d7adSDag-Erling Smørgrav &pre_data_pos, delimiters, 810c7f4d7adSDag-Erling Smørgrav rdftype, &token_strlen)) 811c7f4d7adSDag-Erling Smørgrav break; 81209a3aaf3SDag-Erling Smørgrav } 81309a3aaf3SDag-Erling Smørgrav 81409a3aaf3SDag-Erling Smørgrav /* normal RR */ 81509a3aaf3SDag-Erling Smørgrav if((status=rrinternal_parse_rdf(strbuf, token, 81609a3aaf3SDag-Erling Smørgrav token_len, rr, *rr_len, &rr_cur_len, rdftype, 81709a3aaf3SDag-Erling Smørgrav rr_type, r_cnt, r_max, dname_len, origin, 81809a3aaf3SDag-Erling Smørgrav origin_len)) != 0) { 81909a3aaf3SDag-Erling Smørgrav return status; 82009a3aaf3SDag-Erling Smørgrav } 82109a3aaf3SDag-Erling Smørgrav } 82209a3aaf3SDag-Erling Smørgrav } 82309a3aaf3SDag-Erling Smørgrav if(!was_unknown_rr_format && r_cnt+1 < r_min) { 82409a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_MISSING_VALUE, 82509a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 82609a3aaf3SDag-Erling Smørgrav } 82709a3aaf3SDag-Erling Smørgrav while(parens != 0) { 82809a3aaf3SDag-Erling Smørgrav /* read remainder, must be "" */ 82909a3aaf3SDag-Erling Smørgrav if(sldns_bget_token_par(strbuf, token, "\n", token_len, 83009a3aaf3SDag-Erling Smørgrav &parens, " \t") == -1) { 83109a3aaf3SDag-Erling Smørgrav if(parens != 0) 83209a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_PARENTHESIS, 83309a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 83409a3aaf3SDag-Erling Smørgrav break; 83509a3aaf3SDag-Erling Smørgrav } 83609a3aaf3SDag-Erling Smørgrav if(strcmp(token, "") != 0) 83709a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_PARENTHESIS, 83809a3aaf3SDag-Erling Smørgrav sldns_buffer_position(strbuf)); 83909a3aaf3SDag-Erling Smørgrav } 84009a3aaf3SDag-Erling Smørgrav /* write rdata length */ 841bc892140SDag-Erling Smørgrav sldns_write_uint16(rr+dname_len+8, (uint16_t)(rr_cur_len-dname_len-10)); 84209a3aaf3SDag-Erling Smørgrav *rr_len = rr_cur_len; 8435469a995SCy Schubert /* SVCB/HTTPS handling */ 8445469a995SCy Schubert if (rr_type == LDNS_RR_TYPE_SVCB || rr_type == LDNS_RR_TYPE_HTTPS) { 8455469a995SCy Schubert size_t rdata_len = rr_cur_len - dname_len - 10; 8465469a995SCy Schubert uint8_t *rdata = rr+dname_len + 10; 8475469a995SCy Schubert 8485469a995SCy Schubert /* skip 1st rdata field SvcPriority (uint16_t) */ 8495469a995SCy Schubert if (rdata_len < sizeof(uint16_t)) 8505469a995SCy Schubert return LDNS_WIREPARSE_ERR_OK; 8515469a995SCy Schubert 8525469a995SCy Schubert rdata_len -= sizeof(uint16_t); 8535469a995SCy Schubert rdata += sizeof(uint16_t); 8545469a995SCy Schubert 8555469a995SCy Schubert /* skip 2nd rdata field dname */ 8565469a995SCy Schubert while (rdata_len && *rdata != 0) { 8575469a995SCy Schubert uint8_t label_len; 8585469a995SCy Schubert 8595469a995SCy Schubert if (*rdata & 0xC0) 8605469a995SCy Schubert return LDNS_WIREPARSE_ERR_OK; 8615469a995SCy Schubert 8625469a995SCy Schubert label_len = *rdata + 1; 8635469a995SCy Schubert if (rdata_len < label_len) 8645469a995SCy Schubert return LDNS_WIREPARSE_ERR_OK; 8655469a995SCy Schubert 8665469a995SCy Schubert rdata_len -= label_len; 8675469a995SCy Schubert rdata += label_len; 8685469a995SCy Schubert } 8695469a995SCy Schubert /* The root label is one more character, so smaller 8705469a995SCy Schubert * than 1 + 1 means no Svcparam Keys */ 8715469a995SCy Schubert if (rdata_len < 2 || *rdata != 0) 8725469a995SCy Schubert return LDNS_WIREPARSE_ERR_OK; 8735469a995SCy Schubert 8745469a995SCy Schubert rdata_len -= 1; 8755469a995SCy Schubert rdata += 1; 8765469a995SCy Schubert return sldns_str2wire_check_svcbparams(rdata, rdata_len); 8775469a995SCy Schubert 8785469a995SCy Schubert } 87909a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 88009a3aaf3SDag-Erling Smørgrav } 88109a3aaf3SDag-Erling Smørgrav 88209a3aaf3SDag-Erling Smørgrav /* 88309a3aaf3SDag-Erling Smørgrav * trailing spaces are allowed 88409a3aaf3SDag-Erling Smørgrav * leading spaces are not allowed 88509a3aaf3SDag-Erling Smørgrav * allow ttl to be optional 88609a3aaf3SDag-Erling Smørgrav * class is optional too 88709a3aaf3SDag-Erling Smørgrav * if ttl is missing, and default_ttl is 0, use DEF_TTL 88809a3aaf3SDag-Erling Smørgrav * allow ttl to be written as 1d3h 88909a3aaf3SDag-Erling Smørgrav * So the RR should look like. e.g. 89009a3aaf3SDag-Erling Smørgrav * miek.nl. 3600 IN MX 10 elektron.atoom.net 89109a3aaf3SDag-Erling Smørgrav * or 89209a3aaf3SDag-Erling Smørgrav * miek.nl. 1h IN MX 10 elektron.atoom.net 89309a3aaf3SDag-Erling Smørgrav * or 89409a3aaf3SDag-Erling Smørgrav * miek.nl. IN MX 10 elektron.atoom.net 89509a3aaf3SDag-Erling Smørgrav */ 89609a3aaf3SDag-Erling Smørgrav static int 89709a3aaf3SDag-Erling Smørgrav sldns_str2wire_rr_buf_internal(const char* str, uint8_t* rr, size_t* len, 89809a3aaf3SDag-Erling Smørgrav size_t* dname_len, uint32_t default_ttl, uint8_t* origin, 89909a3aaf3SDag-Erling Smørgrav size_t origin_len, uint8_t* prev, size_t prev_len, int question) 90009a3aaf3SDag-Erling Smørgrav { 90109a3aaf3SDag-Erling Smørgrav int status; 90209a3aaf3SDag-Erling Smørgrav int not_there = 0; 90309a3aaf3SDag-Erling Smørgrav char token[LDNS_MAX_RDFLEN+1]; 90409a3aaf3SDag-Erling Smørgrav uint32_t ttl = 0; 90509a3aaf3SDag-Erling Smørgrav uint16_t tp = 0, cl = 0; 90609a3aaf3SDag-Erling Smørgrav size_t ddlen = 0; 90709a3aaf3SDag-Erling Smørgrav 90809a3aaf3SDag-Erling Smørgrav /* string in buffer */ 90909a3aaf3SDag-Erling Smørgrav sldns_buffer strbuf; 91009a3aaf3SDag-Erling Smørgrav sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str)); 91109a3aaf3SDag-Erling Smørgrav if(!dname_len) dname_len = &ddlen; 91209a3aaf3SDag-Erling Smørgrav 91309a3aaf3SDag-Erling Smørgrav /* parse the owner */ 91409a3aaf3SDag-Erling Smørgrav if((status=rrinternal_get_owner(&strbuf, rr, len, dname_len, origin, 91509a3aaf3SDag-Erling Smørgrav origin_len, prev, prev_len, token, sizeof(token))) != 0) 91609a3aaf3SDag-Erling Smørgrav return status; 91709a3aaf3SDag-Erling Smørgrav 91809a3aaf3SDag-Erling Smørgrav /* parse the [ttl] [class] <type> */ 91909a3aaf3SDag-Erling Smørgrav if((status=rrinternal_get_ttl(&strbuf, token, sizeof(token), 92009a3aaf3SDag-Erling Smørgrav ¬_there, &ttl, default_ttl)) != 0) 92109a3aaf3SDag-Erling Smørgrav return status; 92209a3aaf3SDag-Erling Smørgrav if((status=rrinternal_get_class(&strbuf, token, sizeof(token), 92309a3aaf3SDag-Erling Smørgrav ¬_there, &cl)) != 0) 92409a3aaf3SDag-Erling Smørgrav return status; 92509a3aaf3SDag-Erling Smørgrav if((status=rrinternal_get_type(&strbuf, token, sizeof(token), 92609a3aaf3SDag-Erling Smørgrav ¬_there, &tp)) != 0) 92709a3aaf3SDag-Erling Smørgrav return status; 92809a3aaf3SDag-Erling Smørgrav /* put ttl, class, type into the rr result */ 92909a3aaf3SDag-Erling Smørgrav if((status=rrinternal_write_typeclassttl(&strbuf, rr, *len, *dname_len, tp, cl, 93009a3aaf3SDag-Erling Smørgrav ttl, question)) != 0) 93109a3aaf3SDag-Erling Smørgrav return status; 93209a3aaf3SDag-Erling Smørgrav /* for a question-RR we are done, no rdata */ 93309a3aaf3SDag-Erling Smørgrav if(question) { 93409a3aaf3SDag-Erling Smørgrav *len = *dname_len + 4; 93509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 93609a3aaf3SDag-Erling Smørgrav } 93709a3aaf3SDag-Erling Smørgrav 93809a3aaf3SDag-Erling Smørgrav /* rdata */ 93909a3aaf3SDag-Erling Smørgrav if((status=rrinternal_parse_rdata(&strbuf, token, sizeof(token), 94009a3aaf3SDag-Erling Smørgrav rr, len, *dname_len, tp, origin, origin_len)) != 0) 94109a3aaf3SDag-Erling Smørgrav return status; 94209a3aaf3SDag-Erling Smørgrav 94309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 94409a3aaf3SDag-Erling Smørgrav } 94509a3aaf3SDag-Erling Smørgrav 94609a3aaf3SDag-Erling Smørgrav int sldns_str2wire_rr_buf(const char* str, uint8_t* rr, size_t* len, 94709a3aaf3SDag-Erling Smørgrav size_t* dname_len, uint32_t default_ttl, uint8_t* origin, 94809a3aaf3SDag-Erling Smørgrav size_t origin_len, uint8_t* prev, size_t prev_len) 94909a3aaf3SDag-Erling Smørgrav { 95009a3aaf3SDag-Erling Smørgrav return sldns_str2wire_rr_buf_internal(str, rr, len, dname_len, 95109a3aaf3SDag-Erling Smørgrav default_ttl, origin, origin_len, prev, prev_len, 0); 95209a3aaf3SDag-Erling Smørgrav } 95309a3aaf3SDag-Erling Smørgrav 95409a3aaf3SDag-Erling Smørgrav int sldns_str2wire_rr_question_buf(const char* str, uint8_t* rr, size_t* len, 95509a3aaf3SDag-Erling Smørgrav size_t* dname_len, uint8_t* origin, size_t origin_len, uint8_t* prev, 95609a3aaf3SDag-Erling Smørgrav size_t prev_len) 95709a3aaf3SDag-Erling Smørgrav { 95809a3aaf3SDag-Erling Smørgrav return sldns_str2wire_rr_buf_internal(str, rr, len, dname_len, 95909a3aaf3SDag-Erling Smørgrav 0, origin, origin_len, prev, prev_len, 1); 96009a3aaf3SDag-Erling Smørgrav } 96109a3aaf3SDag-Erling Smørgrav 96209a3aaf3SDag-Erling Smørgrav uint16_t sldns_wirerr_get_type(uint8_t* rr, size_t len, size_t dname_len) 96309a3aaf3SDag-Erling Smørgrav { 96409a3aaf3SDag-Erling Smørgrav if(len < dname_len+2) 96509a3aaf3SDag-Erling Smørgrav return 0; 96609a3aaf3SDag-Erling Smørgrav return sldns_read_uint16(rr+dname_len); 96709a3aaf3SDag-Erling Smørgrav } 96809a3aaf3SDag-Erling Smørgrav 96909a3aaf3SDag-Erling Smørgrav uint16_t sldns_wirerr_get_class(uint8_t* rr, size_t len, size_t dname_len) 97009a3aaf3SDag-Erling Smørgrav { 97109a3aaf3SDag-Erling Smørgrav if(len < dname_len+4) 97209a3aaf3SDag-Erling Smørgrav return 0; 97309a3aaf3SDag-Erling Smørgrav return sldns_read_uint16(rr+dname_len+2); 97409a3aaf3SDag-Erling Smørgrav } 97509a3aaf3SDag-Erling Smørgrav 97609a3aaf3SDag-Erling Smørgrav uint32_t sldns_wirerr_get_ttl(uint8_t* rr, size_t len, size_t dname_len) 97709a3aaf3SDag-Erling Smørgrav { 97809a3aaf3SDag-Erling Smørgrav if(len < dname_len+8) 97909a3aaf3SDag-Erling Smørgrav return 0; 98009a3aaf3SDag-Erling Smørgrav return sldns_read_uint32(rr+dname_len+4); 98109a3aaf3SDag-Erling Smørgrav } 98209a3aaf3SDag-Erling Smørgrav 98309a3aaf3SDag-Erling Smørgrav uint16_t sldns_wirerr_get_rdatalen(uint8_t* rr, size_t len, size_t dname_len) 98409a3aaf3SDag-Erling Smørgrav { 98509a3aaf3SDag-Erling Smørgrav if(len < dname_len+10) 98609a3aaf3SDag-Erling Smørgrav return 0; 98709a3aaf3SDag-Erling Smørgrav return sldns_read_uint16(rr+dname_len+8); 98809a3aaf3SDag-Erling Smørgrav } 98909a3aaf3SDag-Erling Smørgrav 99009a3aaf3SDag-Erling Smørgrav uint8_t* sldns_wirerr_get_rdata(uint8_t* rr, size_t len, size_t dname_len) 99109a3aaf3SDag-Erling Smørgrav { 99209a3aaf3SDag-Erling Smørgrav if(len < dname_len+10) 99309a3aaf3SDag-Erling Smørgrav return NULL; 99409a3aaf3SDag-Erling Smørgrav return rr+dname_len+10; 99509a3aaf3SDag-Erling Smørgrav } 99609a3aaf3SDag-Erling Smørgrav 99709a3aaf3SDag-Erling Smørgrav uint8_t* sldns_wirerr_get_rdatawl(uint8_t* rr, size_t len, size_t dname_len) 99809a3aaf3SDag-Erling Smørgrav { 99909a3aaf3SDag-Erling Smørgrav if(len < dname_len+10) 100009a3aaf3SDag-Erling Smørgrav return NULL; 100109a3aaf3SDag-Erling Smørgrav return rr+dname_len+8; 100209a3aaf3SDag-Erling Smørgrav } 100309a3aaf3SDag-Erling Smørgrav 100409a3aaf3SDag-Erling Smørgrav const char* sldns_get_errorstr_parse(int e) 100509a3aaf3SDag-Erling Smørgrav { 100609a3aaf3SDag-Erling Smørgrav sldns_lookup_table *lt; 100709a3aaf3SDag-Erling Smørgrav lt = sldns_lookup_by_id(sldns_wireparse_errors, LDNS_WIREPARSE_ERROR(e)); 100809a3aaf3SDag-Erling Smørgrav return lt?lt->name:"unknown error"; 100909a3aaf3SDag-Erling Smørgrav } 101009a3aaf3SDag-Erling Smørgrav 101109a3aaf3SDag-Erling Smørgrav /* Strip whitespace from the start and the end of <line>. */ 101257bddd21SDag-Erling Smørgrav char * 101309a3aaf3SDag-Erling Smørgrav sldns_strip_ws(char *line) 101409a3aaf3SDag-Erling Smørgrav { 101509a3aaf3SDag-Erling Smørgrav char *s = line, *e; 101609a3aaf3SDag-Erling Smørgrav 101709a3aaf3SDag-Erling Smørgrav for (s = line; *s && isspace((unsigned char)*s); s++) 101809a3aaf3SDag-Erling Smørgrav ; 101909a3aaf3SDag-Erling Smørgrav for (e = strchr(s, 0); e > s+2 && isspace((unsigned char)e[-1]) && e[-2] != '\\'; e--) 102009a3aaf3SDag-Erling Smørgrav ; 102109a3aaf3SDag-Erling Smørgrav *e = 0; 102209a3aaf3SDag-Erling Smørgrav return s; 102309a3aaf3SDag-Erling Smørgrav } 102409a3aaf3SDag-Erling Smørgrav 102509a3aaf3SDag-Erling Smørgrav int sldns_fp2wire_rr_buf(FILE* in, uint8_t* rr, size_t* len, size_t* dname_len, 102609a3aaf3SDag-Erling Smørgrav struct sldns_file_parse_state* parse_state) 102709a3aaf3SDag-Erling Smørgrav { 102809a3aaf3SDag-Erling Smørgrav char line[LDNS_RR_BUF_SIZE+1]; 102909a3aaf3SDag-Erling Smørgrav ssize_t size; 103009a3aaf3SDag-Erling Smørgrav 103109a3aaf3SDag-Erling Smørgrav /* read an entire line in from the file */ 103209a3aaf3SDag-Erling Smørgrav if((size = sldns_fget_token_l(in, line, LDNS_PARSE_SKIP_SPACE, 103309a3aaf3SDag-Erling Smørgrav LDNS_RR_BUF_SIZE, parse_state?&parse_state->lineno:NULL)) 103409a3aaf3SDag-Erling Smørgrav == -1) { 103509a3aaf3SDag-Erling Smørgrav /* if last line was empty, we are now at feof, which is not 103609a3aaf3SDag-Erling Smørgrav * always a parse error (happens when for instance last line 103709a3aaf3SDag-Erling Smørgrav * was a comment) 103809a3aaf3SDag-Erling Smørgrav */ 103909a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX; 104009a3aaf3SDag-Erling Smørgrav } 104109a3aaf3SDag-Erling Smørgrav 104209a3aaf3SDag-Erling Smørgrav /* we can have the situation, where we've read ok, but still got 104309a3aaf3SDag-Erling Smørgrav * no bytes to play with, in this case size is 0 */ 104409a3aaf3SDag-Erling Smørgrav if(size == 0) { 1045c7f4d7adSDag-Erling Smørgrav if(*len > 0) 1046c7f4d7adSDag-Erling Smørgrav rr[0] = 0; 104709a3aaf3SDag-Erling Smørgrav *len = 0; 104809a3aaf3SDag-Erling Smørgrav *dname_len = 0; 104909a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 105009a3aaf3SDag-Erling Smørgrav } 105109a3aaf3SDag-Erling Smørgrav 105209a3aaf3SDag-Erling Smørgrav if(strncmp(line, "$ORIGIN", 7) == 0 && isspace((unsigned char)line[7])) { 105309a3aaf3SDag-Erling Smørgrav int s; 1054c7f4d7adSDag-Erling Smørgrav strlcpy((char*)rr, line, *len); 105509a3aaf3SDag-Erling Smørgrav *len = 0; 105609a3aaf3SDag-Erling Smørgrav *dname_len = 0; 105709a3aaf3SDag-Erling Smørgrav if(!parse_state) return LDNS_WIREPARSE_ERR_OK; 105809a3aaf3SDag-Erling Smørgrav parse_state->origin_len = sizeof(parse_state->origin); 105909a3aaf3SDag-Erling Smørgrav s = sldns_str2wire_dname_buf(sldns_strip_ws(line+8), 106009a3aaf3SDag-Erling Smørgrav parse_state->origin, &parse_state->origin_len); 106109a3aaf3SDag-Erling Smørgrav if(s) parse_state->origin_len = 0; 106209a3aaf3SDag-Erling Smørgrav return s; 106309a3aaf3SDag-Erling Smørgrav } else if(strncmp(line, "$TTL", 4) == 0 && isspace((unsigned char)line[4])) { 106409a3aaf3SDag-Erling Smørgrav const char* end = NULL; 1065a39a5a69SCy Schubert int overflow = 0; 1066c7f4d7adSDag-Erling Smørgrav strlcpy((char*)rr, line, *len); 106709a3aaf3SDag-Erling Smørgrav *len = 0; 106809a3aaf3SDag-Erling Smørgrav *dname_len = 0; 106909a3aaf3SDag-Erling Smørgrav if(!parse_state) return LDNS_WIREPARSE_ERR_OK; 107009a3aaf3SDag-Erling Smørgrav parse_state->default_ttl = sldns_str2period( 1071a39a5a69SCy Schubert sldns_strip_ws(line+5), &end, &overflow); 1072a39a5a69SCy Schubert if(overflow) 1073a39a5a69SCy Schubert return LDNS_WIREPARSE_ERR_SYNTAX_INTEGER_OVERFLOW; 107409a3aaf3SDag-Erling Smørgrav } else if (strncmp(line, "$INCLUDE", 8) == 0) { 1075c7f4d7adSDag-Erling Smørgrav strlcpy((char*)rr, line, *len); 1076c7f4d7adSDag-Erling Smørgrav *len = 0; 1077c7f4d7adSDag-Erling Smørgrav *dname_len = 0; 1078c7f4d7adSDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INCLUDE; 1079c7f4d7adSDag-Erling Smørgrav } else if (strncmp(line, "$", 1) == 0) { 1080c7f4d7adSDag-Erling Smørgrav strlcpy((char*)rr, line, *len); 108109a3aaf3SDag-Erling Smørgrav *len = 0; 108209a3aaf3SDag-Erling Smørgrav *dname_len = 0; 108309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INCLUDE; 108409a3aaf3SDag-Erling Smørgrav } else { 108557bddd21SDag-Erling Smørgrav int r = sldns_str2wire_rr_buf(line, rr, len, dname_len, 108609a3aaf3SDag-Erling Smørgrav parse_state?parse_state->default_ttl:0, 108709a3aaf3SDag-Erling Smørgrav (parse_state&&parse_state->origin_len)? 108809a3aaf3SDag-Erling Smørgrav parse_state->origin:NULL, 1089e2d15004SDag-Erling Smørgrav parse_state?parse_state->origin_len:0, 109009a3aaf3SDag-Erling Smørgrav (parse_state&&parse_state->prev_rr_len)? 109109a3aaf3SDag-Erling Smørgrav parse_state->prev_rr:NULL, 1092e2d15004SDag-Erling Smørgrav parse_state?parse_state->prev_rr_len:0); 109357bddd21SDag-Erling Smørgrav if(r == LDNS_WIREPARSE_ERR_OK && (*dname_len) != 0 && 109457bddd21SDag-Erling Smørgrav parse_state && 109557bddd21SDag-Erling Smørgrav (*dname_len) <= sizeof(parse_state->prev_rr)) { 109657bddd21SDag-Erling Smørgrav memmove(parse_state->prev_rr, rr, *dname_len); 109757bddd21SDag-Erling Smørgrav parse_state->prev_rr_len = (*dname_len); 109857bddd21SDag-Erling Smørgrav } 10995469a995SCy Schubert if(r == LDNS_WIREPARSE_ERR_OK && parse_state) { 11005469a995SCy Schubert parse_state->default_ttl = sldns_wirerr_get_ttl( 11015469a995SCy Schubert rr, *len, *dname_len); 11025469a995SCy Schubert } 110357bddd21SDag-Erling Smørgrav return r; 110409a3aaf3SDag-Erling Smørgrav } 110509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 110609a3aaf3SDag-Erling Smørgrav } 110709a3aaf3SDag-Erling Smørgrav 11085469a995SCy Schubert static int 11095469a995SCy Schubert sldns_str2wire_svcparam_key_lookup(const char *key, size_t key_len) 11105469a995SCy Schubert { 11115469a995SCy Schubert char buf[64]; 11125469a995SCy Schubert char *endptr; 11135469a995SCy Schubert unsigned long int key_value; 11145469a995SCy Schubert 11155469a995SCy Schubert if (key_len >= 4 && key_len <= 8 && !strncmp(key, "key", 3)) { 11165469a995SCy Schubert memcpy(buf, key + 3, key_len - 3); 11175469a995SCy Schubert buf[key_len - 3] = 0; 11185469a995SCy Schubert key_value = strtoul(buf, &endptr, 10); 11195469a995SCy Schubert 11205469a995SCy Schubert if (endptr > buf /* digits seen */ 11215469a995SCy Schubert && *endptr == 0 /* no non-digit chars after digits */ 11225469a995SCy Schubert && key_value <= 65535) /* no overflow */ 11235469a995SCy Schubert return key_value; 11245469a995SCy Schubert 11255469a995SCy Schubert } else switch (key_len) { 1126*8f76bb7dSCy Schubert case 3: 1127*8f76bb7dSCy Schubert if (!strncmp(key, "ech", key_len)) 1128*8f76bb7dSCy Schubert return SVCB_KEY_ECH; 11295469a995SCy Schubert break; 11305469a995SCy Schubert 1131*8f76bb7dSCy Schubert case 4: 1132*8f76bb7dSCy Schubert if (!strncmp(key, "alpn", key_len)) 11335469a995SCy Schubert return SVCB_KEY_ALPN; 1134*8f76bb7dSCy Schubert if (!strncmp(key, "port", key_len)) 11355469a995SCy Schubert return SVCB_KEY_PORT; 11365469a995SCy Schubert break; 11375469a995SCy Schubert 1138*8f76bb7dSCy Schubert case 7: 1139*8f76bb7dSCy Schubert if (!strncmp(key, "dohpath", key_len)) 1140*8f76bb7dSCy Schubert return SVCB_KEY_DOHPATH; 11415469a995SCy Schubert break; 11425469a995SCy Schubert 1143*8f76bb7dSCy Schubert case 8: 1144*8f76bb7dSCy Schubert if (!strncmp(key, "ipv4hint", key_len)) 11455469a995SCy Schubert return SVCB_KEY_IPV4HINT; 1146*8f76bb7dSCy Schubert if (!strncmp(key, "ipv6hint", key_len)) 11475469a995SCy Schubert return SVCB_KEY_IPV6HINT; 11485469a995SCy Schubert break; 11495469a995SCy Schubert 1150*8f76bb7dSCy Schubert case 9: 1151*8f76bb7dSCy Schubert if (!strncmp(key, "mandatory", key_len)) 1152*8f76bb7dSCy Schubert return SVCB_KEY_MANDATORY; 1153*8f76bb7dSCy Schubert if (!strncmp(key, "echconfig", key_len)) 1154*8f76bb7dSCy Schubert return SVCB_KEY_ECH; /* allow "echconfig" as well as "ech" */ 1155*8f76bb7dSCy Schubert break; 1156*8f76bb7dSCy Schubert 1157*8f76bb7dSCy Schubert case 15: 1158*8f76bb7dSCy Schubert if (!strncmp(key, "no-default-alpn", key_len)) 1159*8f76bb7dSCy Schubert return SVCB_KEY_NO_DEFAULT_ALPN; 11605469a995SCy Schubert break; 11615469a995SCy Schubert 11625469a995SCy Schubert default: 11635469a995SCy Schubert break; 11645469a995SCy Schubert } 11655469a995SCy Schubert 11665469a995SCy Schubert /* Although the returned value might be used by the caller, 11675469a995SCy Schubert * the parser has erred, so the zone will not be loaded. 11685469a995SCy Schubert */ 11695469a995SCy Schubert return -1; 11705469a995SCy Schubert } 11715469a995SCy Schubert 11725469a995SCy Schubert static int 11735469a995SCy Schubert sldns_str2wire_svcparam_port(const char* val, uint8_t* rd, size_t* rd_len) 11745469a995SCy Schubert { 11755469a995SCy Schubert unsigned long int port; 11765469a995SCy Schubert char *endptr; 11775469a995SCy Schubert 11785469a995SCy Schubert if (*rd_len < 6) 11795469a995SCy Schubert return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 11805469a995SCy Schubert 11815469a995SCy Schubert port = strtoul(val, &endptr, 10); 11825469a995SCy Schubert 11835469a995SCy Schubert if (endptr > val /* digits seen */ 11845469a995SCy Schubert && *endptr == 0 /* no non-digit chars after digits */ 11855469a995SCy Schubert && port <= 65535) { /* no overflow */ 11865469a995SCy Schubert 11875469a995SCy Schubert sldns_write_uint16(rd, SVCB_KEY_PORT); 11885469a995SCy Schubert sldns_write_uint16(rd + 2, sizeof(uint16_t)); 11895469a995SCy Schubert sldns_write_uint16(rd + 4, port); 11905469a995SCy Schubert *rd_len = 6; 11915469a995SCy Schubert 11925469a995SCy Schubert return LDNS_WIREPARSE_ERR_OK; 11935469a995SCy Schubert } 11945469a995SCy Schubert 11955469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCB_PORT_VALUE_SYNTAX; 11965469a995SCy Schubert } 11975469a995SCy Schubert 11985469a995SCy Schubert static int 11995469a995SCy Schubert sldns_str2wire_svcbparam_ipv4hint(const char* val, uint8_t* rd, size_t* rd_len) 12005469a995SCy Schubert { 12015469a995SCy Schubert size_t count; 12025469a995SCy Schubert char ip_str[INET_ADDRSTRLEN+1]; 12035469a995SCy Schubert char *next_ip_str; 12045469a995SCy Schubert size_t i; 12055469a995SCy Schubert 12065469a995SCy Schubert for (i = 0, count = 1; val[i]; i++) { 12075469a995SCy Schubert if (val[i] == ',') 12085469a995SCy Schubert count += 1; 12095469a995SCy Schubert if (count > SVCB_MAX_COMMA_SEPARATED_VALUES) { 12105469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCB_IPV4_TOO_MANY_ADDRESSES; 12115469a995SCy Schubert } 12125469a995SCy Schubert } 12135469a995SCy Schubert 12145469a995SCy Schubert if (*rd_len < (LDNS_IP4ADDRLEN * count) + 4) 12155469a995SCy Schubert return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 12165469a995SCy Schubert 12175469a995SCy Schubert /* count is number of comma's in val + 1; so the actual number of IPv4 12185469a995SCy Schubert * addresses in val 12195469a995SCy Schubert */ 12205469a995SCy Schubert sldns_write_uint16(rd, SVCB_KEY_IPV4HINT); 12215469a995SCy Schubert sldns_write_uint16(rd + 2, LDNS_IP4ADDRLEN * count); 12225469a995SCy Schubert *rd_len = 4; 12235469a995SCy Schubert 12245469a995SCy Schubert while (count) { 12255469a995SCy Schubert if (!(next_ip_str = strchr(val, ','))) { 12265469a995SCy Schubert if (inet_pton(AF_INET, val, rd + *rd_len) != 1) 12275469a995SCy Schubert break; 12285469a995SCy Schubert *rd_len += LDNS_IP4ADDRLEN; 12295469a995SCy Schubert 12305469a995SCy Schubert assert(count == 1); 12315469a995SCy Schubert 12325469a995SCy Schubert } else if (next_ip_str - val >= (int)sizeof(ip_str)) 12335469a995SCy Schubert break; 12345469a995SCy Schubert 12355469a995SCy Schubert else { 12365469a995SCy Schubert memcpy(ip_str, val, next_ip_str - val); 12375469a995SCy Schubert ip_str[next_ip_str - val] = 0; 12385469a995SCy Schubert if (inet_pton(AF_INET, ip_str, rd + *rd_len) != 1) { 12395469a995SCy Schubert break; 12405469a995SCy Schubert } 12415469a995SCy Schubert *rd_len += LDNS_IP4ADDRLEN; 12425469a995SCy Schubert 12435469a995SCy Schubert val = next_ip_str + 1; 12445469a995SCy Schubert } 12455469a995SCy Schubert count--; 12465469a995SCy Schubert } 12475469a995SCy Schubert if (count) /* verify that we parsed all values */ 12485469a995SCy Schubert return LDNS_WIREPARSE_ERR_SYNTAX_IP4; 12495469a995SCy Schubert 12505469a995SCy Schubert return LDNS_WIREPARSE_ERR_OK; 12515469a995SCy Schubert } 12525469a995SCy Schubert 12535469a995SCy Schubert static int 12545469a995SCy Schubert sldns_str2wire_svcbparam_ipv6hint(const char* val, uint8_t* rd, size_t* rd_len) 12555469a995SCy Schubert { 12565469a995SCy Schubert size_t count; 12575469a995SCy Schubert char ip_str[INET6_ADDRSTRLEN+1]; 12585469a995SCy Schubert char *next_ip_str; 12595469a995SCy Schubert size_t i; 12605469a995SCy Schubert 12615469a995SCy Schubert for (i = 0, count = 1; val[i]; i++) { 12625469a995SCy Schubert if (val[i] == ',') 12635469a995SCy Schubert count += 1; 12645469a995SCy Schubert if (count > SVCB_MAX_COMMA_SEPARATED_VALUES) { 12655469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCB_IPV6_TOO_MANY_ADDRESSES; 12665469a995SCy Schubert } 12675469a995SCy Schubert } 12685469a995SCy Schubert 12695469a995SCy Schubert if (*rd_len < (LDNS_IP6ADDRLEN * count) + 4) 12705469a995SCy Schubert return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 12715469a995SCy Schubert 12725469a995SCy Schubert /* count is number of comma's in val + 1; so the actual number of IPv6 12735469a995SCy Schubert * addresses in val 12745469a995SCy Schubert */ 12755469a995SCy Schubert sldns_write_uint16(rd, SVCB_KEY_IPV6HINT); 12765469a995SCy Schubert sldns_write_uint16(rd + 2, LDNS_IP6ADDRLEN * count); 12775469a995SCy Schubert *rd_len = 4; 12785469a995SCy Schubert 12795469a995SCy Schubert while (count) { 12805469a995SCy Schubert if (!(next_ip_str = strchr(val, ','))) { 12815469a995SCy Schubert if (inet_pton(AF_INET6, val, rd + *rd_len) != 1) 12825469a995SCy Schubert break; 12835469a995SCy Schubert *rd_len += LDNS_IP6ADDRLEN; 12845469a995SCy Schubert 12855469a995SCy Schubert assert(count == 1); 12865469a995SCy Schubert 12875469a995SCy Schubert } else if (next_ip_str - val >= (int)sizeof(ip_str)) 12885469a995SCy Schubert break; 12895469a995SCy Schubert 12905469a995SCy Schubert else { 12915469a995SCy Schubert memcpy(ip_str, val, next_ip_str - val); 12925469a995SCy Schubert ip_str[next_ip_str - val] = 0; 12935469a995SCy Schubert if (inet_pton(AF_INET6, ip_str, rd + *rd_len) != 1) { 12945469a995SCy Schubert break; 12955469a995SCy Schubert } 12965469a995SCy Schubert *rd_len += LDNS_IP6ADDRLEN; 12975469a995SCy Schubert 12985469a995SCy Schubert val = next_ip_str + 1; 12995469a995SCy Schubert } 13005469a995SCy Schubert count--; 13015469a995SCy Schubert } 13025469a995SCy Schubert if (count) /* verify that we parsed all values */ 13035469a995SCy Schubert return LDNS_WIREPARSE_ERR_SYNTAX_IP6; 13045469a995SCy Schubert 13055469a995SCy Schubert return LDNS_WIREPARSE_ERR_OK; 13065469a995SCy Schubert } 13075469a995SCy Schubert 13085469a995SCy Schubert /* compare function used for sorting uint16_t's */ 13095469a995SCy Schubert static int 13105469a995SCy Schubert sldns_network_uint16_cmp(const void *a, const void *b) 13115469a995SCy Schubert { 13125469a995SCy Schubert return ((int)sldns_read_uint16(a)) - ((int)sldns_read_uint16(b)); 13135469a995SCy Schubert } 13145469a995SCy Schubert 13155469a995SCy Schubert static int 13165469a995SCy Schubert sldns_str2wire_svcbparam_mandatory(const char* val, uint8_t* rd, size_t* rd_len) 13175469a995SCy Schubert { 13185469a995SCy Schubert size_t i, count, val_len; 13195469a995SCy Schubert char* next_key; 13205469a995SCy Schubert 13215469a995SCy Schubert val_len = strlen(val); 13225469a995SCy Schubert 13235469a995SCy Schubert for (i = 0, count = 1; val[i]; i++) { 13245469a995SCy Schubert if (val[i] == ',') 13255469a995SCy Schubert count += 1; 13265469a995SCy Schubert if (count > SVCB_MAX_COMMA_SEPARATED_VALUES) { 13275469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCB_MANDATORY_TOO_MANY_KEYS; 13285469a995SCy Schubert } 13295469a995SCy Schubert } 13305469a995SCy Schubert if (sizeof(uint16_t) * (count + 2) > *rd_len) 13315469a995SCy Schubert return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 13325469a995SCy Schubert 13335469a995SCy Schubert sldns_write_uint16(rd, SVCB_KEY_MANDATORY); 13345469a995SCy Schubert sldns_write_uint16(rd + 2, sizeof(uint16_t) * count); 13355469a995SCy Schubert *rd_len = 4; 13365469a995SCy Schubert 13375469a995SCy Schubert while (1) { 13385469a995SCy Schubert int svcparamkey; 13395469a995SCy Schubert 13405469a995SCy Schubert if (!(next_key = strchr(val, ','))) { 13415469a995SCy Schubert svcparamkey = sldns_str2wire_svcparam_key_lookup(val, val_len); 13425469a995SCy Schubert 13435469a995SCy Schubert if (svcparamkey < 0) { 13445469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCB_UNKNOWN_KEY; 13455469a995SCy Schubert } 13465469a995SCy Schubert 13475469a995SCy Schubert sldns_write_uint16(rd + *rd_len, svcparamkey); 13485469a995SCy Schubert *rd_len += 2; 13495469a995SCy Schubert break; 13505469a995SCy Schubert } else { 13515469a995SCy Schubert svcparamkey = sldns_str2wire_svcparam_key_lookup(val, next_key - val); 13525469a995SCy Schubert 13535469a995SCy Schubert if (svcparamkey < 0) { 13545469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCB_UNKNOWN_KEY; 13555469a995SCy Schubert } 13565469a995SCy Schubert 13575469a995SCy Schubert sldns_write_uint16(rd + *rd_len, 13585469a995SCy Schubert svcparamkey); 13595469a995SCy Schubert *rd_len += 2; 13605469a995SCy Schubert } 13615469a995SCy Schubert 13625469a995SCy Schubert val_len -= next_key - val + 1; 13635469a995SCy Schubert val = next_key + 1; /* skip the comma */ 13645469a995SCy Schubert } 13655469a995SCy Schubert 13665469a995SCy Schubert /* In draft-ietf-dnsop-svcb-https-06 Section 7: 13675469a995SCy Schubert * 13685469a995SCy Schubert * "In wire format, the keys are represented by their numeric 13695469a995SCy Schubert * values in network byte order, concatenated in ascending order." 13705469a995SCy Schubert */ 13715469a995SCy Schubert qsort((void *)(rd + 4), count, sizeof(uint16_t), sldns_network_uint16_cmp); 13725469a995SCy Schubert 1373a39a5a69SCy Schubert /* The code below revolves around semantic errors in the SVCParam set. 13745469a995SCy Schubert * So long as we do not distinguish between running Unbound as a primary 13755469a995SCy Schubert * or as a secondary, we default to secondary behavior and we ignore the 13765469a995SCy Schubert * semantic errors. */ 13775469a995SCy Schubert #ifdef SVCB_SEMANTIC_ERRORS 13785469a995SCy Schubert /* In draft-ietf-dnsop-svcb-https-06 Section 8 13795469a995SCy Schubert * automatically mandatory MUST NOT appear in its own value-list 13805469a995SCy Schubert */ 13815469a995SCy Schubert if (sldns_read_uint16(rd + 4) == SVCB_KEY_MANDATORY) 13825469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCB_MANDATORY_IN_MANDATORY; 13835469a995SCy Schubert 13845469a995SCy Schubert /* Guarantee key uniqueness. After the sort we only need to 13855469a995SCy Schubert * compare neighbouring keys */ 13865469a995SCy Schubert if (count > 1) { 13875469a995SCy Schubert for (i = 0; i < count - 1; i++) { 13885469a995SCy Schubert uint8_t* current_pos = (rd + 4 + (sizeof(uint16_t) * i)); 13895469a995SCy Schubert uint16_t key = sldns_read_uint16(current_pos); 13905469a995SCy Schubert 13915469a995SCy Schubert if (key == sldns_read_uint16(current_pos + 2)) { 13925469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCB_MANDATORY_DUPLICATE_KEY; 13935469a995SCy Schubert } 13945469a995SCy Schubert } 13955469a995SCy Schubert } 13965469a995SCy Schubert #endif 13975469a995SCy Schubert return LDNS_WIREPARSE_ERR_OK; 13985469a995SCy Schubert } 13995469a995SCy Schubert 14005469a995SCy Schubert static int 14015469a995SCy Schubert sldns_str2wire_svcbparam_ech_value(const char* val, uint8_t* rd, size_t* rd_len) 14025469a995SCy Schubert { 14035469a995SCy Schubert uint8_t buffer[LDNS_MAX_RDFLEN]; 14045469a995SCy Schubert int wire_len; 14055469a995SCy Schubert 14065469a995SCy Schubert /* single 0 represents empty buffer */ 14075469a995SCy Schubert if(strcmp(val, "0") == 0) { 14085469a995SCy Schubert if (*rd_len < 4) 14095469a995SCy Schubert return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 14105469a995SCy Schubert sldns_write_uint16(rd, SVCB_KEY_ECH); 14115469a995SCy Schubert sldns_write_uint16(rd + 2, 0); 14125469a995SCy Schubert 14135469a995SCy Schubert return LDNS_WIREPARSE_ERR_OK; 14145469a995SCy Schubert } 14155469a995SCy Schubert 14165469a995SCy Schubert wire_len = sldns_b64_pton(val, buffer, LDNS_MAX_RDFLEN); 14175469a995SCy Schubert 14185469a995SCy Schubert if (wire_len <= 0) { 14195469a995SCy Schubert return LDNS_WIREPARSE_ERR_SYNTAX_B64; 14205469a995SCy Schubert } else if ((unsigned)wire_len + 4 > *rd_len) { 14215469a995SCy Schubert return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 14225469a995SCy Schubert } else { 14235469a995SCy Schubert sldns_write_uint16(rd, SVCB_KEY_ECH); 14245469a995SCy Schubert sldns_write_uint16(rd + 2, wire_len); 14255469a995SCy Schubert memcpy(rd + 4, buffer, wire_len); 14265469a995SCy Schubert *rd_len = 4 + wire_len; 14275469a995SCy Schubert 14285469a995SCy Schubert return LDNS_WIREPARSE_ERR_OK; 14295469a995SCy Schubert } 14305469a995SCy Schubert } 14315469a995SCy Schubert 14325469a995SCy Schubert static const char* 14335469a995SCy Schubert sldns_str2wire_svcbparam_parse_next_unescaped_comma(const char *val) 14345469a995SCy Schubert { 14355469a995SCy Schubert while (*val) { 14365469a995SCy Schubert /* Only return when the comma is not escaped*/ 14375469a995SCy Schubert if (*val == '\\'){ 14385469a995SCy Schubert ++val; 14395469a995SCy Schubert if (!*val) 14405469a995SCy Schubert break; 14415469a995SCy Schubert } else if (*val == ',') 14425469a995SCy Schubert return val; 14435469a995SCy Schubert 14445469a995SCy Schubert val++; 14455469a995SCy Schubert } 14465469a995SCy Schubert return NULL; 14475469a995SCy Schubert } 14485469a995SCy Schubert 14495469a995SCy Schubert /* The source is already properly unescaped, this double unescaping is purely to allow for 145024e36522SCy Schubert * comma's in comma separated alpn lists. 14515469a995SCy Schubert * 14525469a995SCy Schubert * In draft-ietf-dnsop-svcb-https-06 Section 7: 14535469a995SCy Schubert * To enable simpler parsing, this SvcParamValue MUST NOT contain escape sequences. 14545469a995SCy Schubert */ 14555469a995SCy Schubert static size_t 14565469a995SCy Schubert sldns_str2wire_svcbparam_parse_copy_unescaped(uint8_t *dst, 14575469a995SCy Schubert const char *src, size_t len) 14585469a995SCy Schubert { 14595469a995SCy Schubert uint8_t *orig_dst = dst; 14605469a995SCy Schubert 14615469a995SCy Schubert while (len) { 14625469a995SCy Schubert if (*src == '\\') { 14635469a995SCy Schubert src++; 14645469a995SCy Schubert len--; 14655469a995SCy Schubert if (!len) 14665469a995SCy Schubert break; 14675469a995SCy Schubert } 14685469a995SCy Schubert *dst++ = *src++; 14695469a995SCy Schubert len--; 14705469a995SCy Schubert } 14715469a995SCy Schubert return (size_t)(dst - orig_dst); 14725469a995SCy Schubert } 14735469a995SCy Schubert 14745469a995SCy Schubert static int 14755469a995SCy Schubert sldns_str2wire_svcbparam_alpn_value(const char* val, 14765469a995SCy Schubert uint8_t* rd, size_t* rd_len) 14775469a995SCy Schubert { 14785469a995SCy Schubert uint8_t unescaped_dst[LDNS_MAX_RDFLEN]; 14795469a995SCy Schubert uint8_t *dst = unescaped_dst; 14805469a995SCy Schubert const char *next_str; 14815469a995SCy Schubert size_t str_len; 14825469a995SCy Schubert size_t dst_len; 14835469a995SCy Schubert size_t val_len; 14845469a995SCy Schubert 14855469a995SCy Schubert val_len = strlen(val); 14865469a995SCy Schubert 14875469a995SCy Schubert if (val_len > sizeof(unescaped_dst)) { 14885469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCB_ALPN_KEY_TOO_LARGE; 14895469a995SCy Schubert } 14905469a995SCy Schubert while (val_len) { 14915469a995SCy Schubert size_t key_len; 14925469a995SCy Schubert 14935469a995SCy Schubert str_len = (next_str = sldns_str2wire_svcbparam_parse_next_unescaped_comma(val)) 14945469a995SCy Schubert ? (size_t)(next_str - val) : val_len; 14955469a995SCy Schubert 14965469a995SCy Schubert if (str_len > 255) { 14975469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCB_ALPN_KEY_TOO_LARGE; 14985469a995SCy Schubert } 14995469a995SCy Schubert 15005469a995SCy Schubert key_len = sldns_str2wire_svcbparam_parse_copy_unescaped(dst + 1, val, str_len); 15015469a995SCy Schubert *dst++ = key_len; 15025469a995SCy Schubert dst += key_len; 15035469a995SCy Schubert 15045469a995SCy Schubert if (!next_str) 15055469a995SCy Schubert break; 15065469a995SCy Schubert 15075469a995SCy Schubert /* skip the comma in the next iteration */ 15085469a995SCy Schubert val_len -= next_str - val + 1; 15095469a995SCy Schubert val = next_str + 1; 15105469a995SCy Schubert } 15115469a995SCy Schubert dst_len = dst - unescaped_dst; 15125469a995SCy Schubert if (*rd_len < 4 + dst_len) 15135469a995SCy Schubert return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 15145469a995SCy Schubert sldns_write_uint16(rd, SVCB_KEY_ALPN); 15155469a995SCy Schubert sldns_write_uint16(rd + 2, dst_len); 15165469a995SCy Schubert memcpy(rd + 4, unescaped_dst, dst_len); 15175469a995SCy Schubert *rd_len = 4 + dst_len; 15185469a995SCy Schubert 15195469a995SCy Schubert return LDNS_WIREPARSE_ERR_OK; 15205469a995SCy Schubert } 15215469a995SCy Schubert 15225469a995SCy Schubert static int 1523*8f76bb7dSCy Schubert sldns_str2wire_svcbparam_dohpath_value(const char* val, 1524*8f76bb7dSCy Schubert uint8_t* rd, size_t* rd_len) 1525*8f76bb7dSCy Schubert { 1526*8f76bb7dSCy Schubert size_t val_len; 1527*8f76bb7dSCy Schubert 1528*8f76bb7dSCy Schubert /* RFC6570#section-2.1 1529*8f76bb7dSCy Schubert * "The characters outside of expressions in a URI Template string are 1530*8f76bb7dSCy Schubert * intended to be copied literally" 1531*8f76bb7dSCy Schubert * Practically this means we do not have to look for "double escapes" 1532*8f76bb7dSCy Schubert * like in the alpn value list. 1533*8f76bb7dSCy Schubert */ 1534*8f76bb7dSCy Schubert 1535*8f76bb7dSCy Schubert val_len = strlen(val); 1536*8f76bb7dSCy Schubert 1537*8f76bb7dSCy Schubert if (*rd_len < 4 + val_len) { 1538*8f76bb7dSCy Schubert return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 1539*8f76bb7dSCy Schubert } 1540*8f76bb7dSCy Schubert 1541*8f76bb7dSCy Schubert sldns_write_uint16(rd, SVCB_KEY_DOHPATH); 1542*8f76bb7dSCy Schubert sldns_write_uint16(rd + 2, val_len); 1543*8f76bb7dSCy Schubert memcpy(rd + 4, val, val_len); 1544*8f76bb7dSCy Schubert *rd_len = 4 + val_len; 1545*8f76bb7dSCy Schubert 1546*8f76bb7dSCy Schubert return LDNS_WIREPARSE_ERR_OK; 1547*8f76bb7dSCy Schubert } 1548*8f76bb7dSCy Schubert 1549*8f76bb7dSCy Schubert static int 15505469a995SCy Schubert sldns_str2wire_svcparam_value(const char *key, size_t key_len, 15515469a995SCy Schubert const char *val, uint8_t* rd, size_t* rd_len) 15525469a995SCy Schubert { 15535469a995SCy Schubert size_t str_len; 15545469a995SCy Schubert int svcparamkey = sldns_str2wire_svcparam_key_lookup(key, key_len); 15555469a995SCy Schubert 15565469a995SCy Schubert if (svcparamkey < 0) { 15575469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCB_UNKNOWN_KEY; 15585469a995SCy Schubert } 15595469a995SCy Schubert 15605469a995SCy Schubert /* key without value */ 15615469a995SCy Schubert if (val == NULL) { 15625469a995SCy Schubert switch (svcparamkey) { 15635469a995SCy Schubert #ifdef SVCB_SEMANTIC_ERRORS 15645469a995SCy Schubert case SVCB_KEY_MANDATORY: 15655469a995SCy Schubert case SVCB_KEY_ALPN: 15665469a995SCy Schubert case SVCB_KEY_PORT: 15675469a995SCy Schubert case SVCB_KEY_IPV4HINT: 15685469a995SCy Schubert case SVCB_KEY_IPV6HINT: 1569*8f76bb7dSCy Schubert case SVCB_KEY_DOHPATH: 15705469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCB_MISSING_PARAM; 15715469a995SCy Schubert #endif 15725469a995SCy Schubert default: 15735469a995SCy Schubert if (*rd_len < 4) 15745469a995SCy Schubert return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 15755469a995SCy Schubert sldns_write_uint16(rd, svcparamkey); 15765469a995SCy Schubert sldns_write_uint16(rd + 2, 0); 15775469a995SCy Schubert *rd_len = 4; 15785469a995SCy Schubert 15795469a995SCy Schubert return LDNS_WIREPARSE_ERR_OK; 15805469a995SCy Schubert } 15815469a995SCy Schubert } 15825469a995SCy Schubert 15835469a995SCy Schubert /* value is non-empty */ 15845469a995SCy Schubert switch (svcparamkey) { 15855469a995SCy Schubert case SVCB_KEY_PORT: 15865469a995SCy Schubert return sldns_str2wire_svcparam_port(val, rd, rd_len); 15875469a995SCy Schubert case SVCB_KEY_IPV4HINT: 15885469a995SCy Schubert return sldns_str2wire_svcbparam_ipv4hint(val, rd, rd_len); 15895469a995SCy Schubert case SVCB_KEY_IPV6HINT: 15905469a995SCy Schubert return sldns_str2wire_svcbparam_ipv6hint(val, rd, rd_len); 15915469a995SCy Schubert case SVCB_KEY_MANDATORY: 15925469a995SCy Schubert return sldns_str2wire_svcbparam_mandatory(val, rd, rd_len); 15935469a995SCy Schubert #ifdef SVCB_SEMANTIC_ERRORS 15945469a995SCy Schubert case SVCB_KEY_NO_DEFAULT_ALPN: 15955469a995SCy Schubert return LDNS_WIREPARSE_ERR_SVCB_NO_DEFAULT_ALPN_VALUE; 15965469a995SCy Schubert #endif 15975469a995SCy Schubert case SVCB_KEY_ECH: 15985469a995SCy Schubert return sldns_str2wire_svcbparam_ech_value(val, rd, rd_len); 15995469a995SCy Schubert case SVCB_KEY_ALPN: 16005469a995SCy Schubert return sldns_str2wire_svcbparam_alpn_value(val, rd, rd_len); 1601*8f76bb7dSCy Schubert case SVCB_KEY_DOHPATH: 1602*8f76bb7dSCy Schubert return sldns_str2wire_svcbparam_dohpath_value(val, rd, rd_len); 16035469a995SCy Schubert default: 16045469a995SCy Schubert str_len = strlen(val); 16055469a995SCy Schubert if (*rd_len < 4 + str_len) 16065469a995SCy Schubert return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 16075469a995SCy Schubert sldns_write_uint16(rd, svcparamkey); 16085469a995SCy Schubert sldns_write_uint16(rd + 2, str_len); 16095469a995SCy Schubert memcpy(rd + 4, val, str_len); 16105469a995SCy Schubert *rd_len = 4 + str_len; 16115469a995SCy Schubert 16125469a995SCy Schubert return LDNS_WIREPARSE_ERR_OK; 16135469a995SCy Schubert } 16145469a995SCy Schubert 16155469a995SCy Schubert return LDNS_WIREPARSE_ERR_GENERAL; 16165469a995SCy Schubert } 16175469a995SCy Schubert 161824e36522SCy Schubert static int sldns_str2wire_svcparam_buf(const char* str, uint8_t* rd, size_t* rd_len) 16195469a995SCy Schubert { 16205469a995SCy Schubert const char* eq_pos; 16215469a995SCy Schubert char unescaped_val[LDNS_MAX_RDFLEN]; 16225469a995SCy Schubert char* val_out = unescaped_val; 16235469a995SCy Schubert const char* val_in; 16245469a995SCy Schubert 16255469a995SCy Schubert eq_pos = strchr(str, '='); 16265469a995SCy Schubert 16275469a995SCy Schubert /* case: key=value */ 16285469a995SCy Schubert if (eq_pos != NULL && eq_pos[1]) { 16295469a995SCy Schubert val_in = eq_pos + 1; 16305469a995SCy Schubert 16315469a995SCy Schubert /* unescape characters and "" blocks */ 16325469a995SCy Schubert if (*val_in == '"') { 16335469a995SCy Schubert val_in++; 16345469a995SCy Schubert while (*val_in != '"' 1635a39a5a69SCy Schubert && (size_t)(val_out - unescaped_val + 1) < sizeof(unescaped_val) 16365469a995SCy Schubert && sldns_parse_char( (uint8_t*) val_out, &val_in)) { 16375469a995SCy Schubert val_out++; 16385469a995SCy Schubert } 16395469a995SCy Schubert } else { 1640a39a5a69SCy Schubert while ((size_t)(val_out - unescaped_val + 1) < sizeof(unescaped_val) 16415469a995SCy Schubert && sldns_parse_char( (uint8_t*) val_out, &val_in)) { 16425469a995SCy Schubert val_out++; 16435469a995SCy Schubert } 16445469a995SCy Schubert } 16455469a995SCy Schubert *val_out = 0; 16465469a995SCy Schubert 16475469a995SCy Schubert return sldns_str2wire_svcparam_value(str, eq_pos - str, 16485469a995SCy Schubert unescaped_val[0] ? unescaped_val : NULL, rd, rd_len); 16495469a995SCy Schubert } 16505469a995SCy Schubert /* case: key= */ 16515469a995SCy Schubert else if (eq_pos != NULL && !(eq_pos[1])) { 16525469a995SCy Schubert return sldns_str2wire_svcparam_value(str, eq_pos - str, NULL, rd, rd_len); 16535469a995SCy Schubert } 16545469a995SCy Schubert /* case: key */ 16555469a995SCy Schubert else { 16565469a995SCy Schubert return sldns_str2wire_svcparam_value(str, strlen(str), NULL, rd, rd_len); 16575469a995SCy Schubert } 16585469a995SCy Schubert } 16595469a995SCy Schubert 166009a3aaf3SDag-Erling Smørgrav int sldns_str2wire_rdf_buf(const char* str, uint8_t* rd, size_t* len, 166109a3aaf3SDag-Erling Smørgrav sldns_rdf_type rdftype) 166209a3aaf3SDag-Erling Smørgrav { 166309a3aaf3SDag-Erling Smørgrav switch (rdftype) { 166409a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_DNAME: 166509a3aaf3SDag-Erling Smørgrav return sldns_str2wire_dname_buf(str, rd, len); 166609a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_INT8: 166709a3aaf3SDag-Erling Smørgrav return sldns_str2wire_int8_buf(str, rd, len); 166809a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_INT16: 166909a3aaf3SDag-Erling Smørgrav return sldns_str2wire_int16_buf(str, rd, len); 167009a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_INT32: 167109a3aaf3SDag-Erling Smørgrav return sldns_str2wire_int32_buf(str, rd, len); 167209a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_A: 167309a3aaf3SDag-Erling Smørgrav return sldns_str2wire_a_buf(str, rd, len); 167409a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_AAAA: 167509a3aaf3SDag-Erling Smørgrav return sldns_str2wire_aaaa_buf(str, rd, len); 167609a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_STR: 167709a3aaf3SDag-Erling Smørgrav return sldns_str2wire_str_buf(str, rd, len); 167809a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_APL: 167909a3aaf3SDag-Erling Smørgrav return sldns_str2wire_apl_buf(str, rd, len); 168009a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_B64: 168109a3aaf3SDag-Erling Smørgrav return sldns_str2wire_b64_buf(str, rd, len); 168209a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_B32_EXT: 168309a3aaf3SDag-Erling Smørgrav return sldns_str2wire_b32_ext_buf(str, rd, len); 168409a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_HEX: 168509a3aaf3SDag-Erling Smørgrav return sldns_str2wire_hex_buf(str, rd, len); 168609a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_NSEC: 168709a3aaf3SDag-Erling Smørgrav return sldns_str2wire_nsec_buf(str, rd, len); 168809a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_TYPE: 168909a3aaf3SDag-Erling Smørgrav return sldns_str2wire_type_buf(str, rd, len); 169009a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_CLASS: 169109a3aaf3SDag-Erling Smørgrav return sldns_str2wire_class_buf(str, rd, len); 169209a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_CERT_ALG: 169309a3aaf3SDag-Erling Smørgrav return sldns_str2wire_cert_alg_buf(str, rd, len); 169409a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_ALG: 169509a3aaf3SDag-Erling Smørgrav return sldns_str2wire_alg_buf(str, rd, len); 169609a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_TIME: 169709a3aaf3SDag-Erling Smørgrav return sldns_str2wire_time_buf(str, rd, len); 169809a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_PERIOD: 169909a3aaf3SDag-Erling Smørgrav return sldns_str2wire_period_buf(str, rd, len); 1700c7f4d7adSDag-Erling Smørgrav case LDNS_RDF_TYPE_TSIGTIME: 1701c7f4d7adSDag-Erling Smørgrav return sldns_str2wire_tsigtime_buf(str, rd, len); 170209a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_LOC: 170309a3aaf3SDag-Erling Smørgrav return sldns_str2wire_loc_buf(str, rd, len); 170409a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_WKS: 170509a3aaf3SDag-Erling Smørgrav return sldns_str2wire_wks_buf(str, rd, len); 170609a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_NSAP: 170709a3aaf3SDag-Erling Smørgrav return sldns_str2wire_nsap_buf(str, rd, len); 170809a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_ATMA: 170909a3aaf3SDag-Erling Smørgrav return sldns_str2wire_atma_buf(str, rd, len); 171009a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_IPSECKEY: 171109a3aaf3SDag-Erling Smørgrav return sldns_str2wire_ipseckey_buf(str, rd, len); 171209a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_NSEC3_SALT: 171309a3aaf3SDag-Erling Smørgrav return sldns_str2wire_nsec3_salt_buf(str, rd, len); 171409a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER: 171509a3aaf3SDag-Erling Smørgrav return sldns_str2wire_b32_ext_buf(str, rd, len); 171609a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_ILNP64: 171709a3aaf3SDag-Erling Smørgrav return sldns_str2wire_ilnp64_buf(str, rd, len); 171809a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_EUI48: 171909a3aaf3SDag-Erling Smørgrav return sldns_str2wire_eui48_buf(str, rd, len); 172009a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_EUI64: 172109a3aaf3SDag-Erling Smørgrav return sldns_str2wire_eui64_buf(str, rd, len); 172209a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_TAG: 172309a3aaf3SDag-Erling Smørgrav return sldns_str2wire_tag_buf(str, rd, len); 172409a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_LONG_STR: 172509a3aaf3SDag-Erling Smørgrav return sldns_str2wire_long_str_buf(str, rd, len); 1726c7f4d7adSDag-Erling Smørgrav case LDNS_RDF_TYPE_TSIGERROR: 1727c7f4d7adSDag-Erling Smørgrav return sldns_str2wire_tsigerror_buf(str, rd, len); 172809a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_HIP: 172909a3aaf3SDag-Erling Smørgrav return sldns_str2wire_hip_buf(str, rd, len); 173009a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_INT16_DATA: 173109a3aaf3SDag-Erling Smørgrav return sldns_str2wire_int16_data_buf(str, rd, len); 17325469a995SCy Schubert case LDNS_RDF_TYPE_SVCPARAM: 17335469a995SCy Schubert return sldns_str2wire_svcparam_buf(str, rd, len); 173409a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_UNKNOWN: 173509a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_SERVICE: 173609a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_NOT_IMPL; 173709a3aaf3SDag-Erling Smørgrav case LDNS_RDF_TYPE_NONE: 173809a3aaf3SDag-Erling Smørgrav default: 173909a3aaf3SDag-Erling Smørgrav break; 174009a3aaf3SDag-Erling Smørgrav } 174109a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_GENERAL; 174209a3aaf3SDag-Erling Smørgrav } 174309a3aaf3SDag-Erling Smørgrav 174409a3aaf3SDag-Erling Smørgrav int sldns_str2wire_int8_buf(const char* str, uint8_t* rd, size_t* len) 174509a3aaf3SDag-Erling Smørgrav { 174609a3aaf3SDag-Erling Smørgrav char* end; 174709a3aaf3SDag-Erling Smørgrav uint8_t r = (uint8_t)strtol((char*)str, &end, 10); 174809a3aaf3SDag-Erling Smørgrav if(*end != 0) 174909a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INT, end-(char*)str); 175009a3aaf3SDag-Erling Smørgrav if(*len < 1) 175109a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 175209a3aaf3SDag-Erling Smørgrav rd[0] = r; 175309a3aaf3SDag-Erling Smørgrav *len = 1; 175409a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 175509a3aaf3SDag-Erling Smørgrav } 175609a3aaf3SDag-Erling Smørgrav 175709a3aaf3SDag-Erling Smørgrav int sldns_str2wire_int16_buf(const char* str, uint8_t* rd, size_t* len) 175809a3aaf3SDag-Erling Smørgrav { 175909a3aaf3SDag-Erling Smørgrav char* end; 176009a3aaf3SDag-Erling Smørgrav uint16_t r = (uint16_t)strtol((char*)str, &end, 10); 176109a3aaf3SDag-Erling Smørgrav if(*end != 0) 176209a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INT, end-(char*)str); 176309a3aaf3SDag-Erling Smørgrav if(*len < 2) 176409a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 176509a3aaf3SDag-Erling Smørgrav sldns_write_uint16(rd, r); 176609a3aaf3SDag-Erling Smørgrav *len = 2; 176709a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 176809a3aaf3SDag-Erling Smørgrav } 176909a3aaf3SDag-Erling Smørgrav 177009a3aaf3SDag-Erling Smørgrav int sldns_str2wire_int32_buf(const char* str, uint8_t* rd, size_t* len) 177109a3aaf3SDag-Erling Smørgrav { 177209a3aaf3SDag-Erling Smørgrav char* end; 177309a3aaf3SDag-Erling Smørgrav uint32_t r; 177409a3aaf3SDag-Erling Smørgrav errno = 0; /* must set to zero before call, 177509a3aaf3SDag-Erling Smørgrav note race condition on errno */ 177609a3aaf3SDag-Erling Smørgrav if(*str == '-') 177709a3aaf3SDag-Erling Smørgrav r = (uint32_t)strtol((char*)str, &end, 10); 177809a3aaf3SDag-Erling Smørgrav else r = (uint32_t)strtoul((char*)str, &end, 10); 177909a3aaf3SDag-Erling Smørgrav if(*end != 0) 178009a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INT, end-(char*)str); 178109a3aaf3SDag-Erling Smørgrav if(errno == ERANGE) 178209a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_INTEGER_OVERFLOW; 178309a3aaf3SDag-Erling Smørgrav if(*len < 4) 178409a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 178509a3aaf3SDag-Erling Smørgrav sldns_write_uint32(rd, r); 178609a3aaf3SDag-Erling Smørgrav *len = 4; 178709a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 178809a3aaf3SDag-Erling Smørgrav } 178909a3aaf3SDag-Erling Smørgrav 179009a3aaf3SDag-Erling Smørgrav int sldns_str2wire_a_buf(const char* str, uint8_t* rd, size_t* len) 179109a3aaf3SDag-Erling Smørgrav { 179209a3aaf3SDag-Erling Smørgrav struct in_addr address; 179309a3aaf3SDag-Erling Smørgrav if(inet_pton(AF_INET, (char*)str, &address) != 1) 179409a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_IP4; 179509a3aaf3SDag-Erling Smørgrav if(*len < sizeof(address)) 179609a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 179709a3aaf3SDag-Erling Smørgrav memmove(rd, &address, sizeof(address)); 179809a3aaf3SDag-Erling Smørgrav *len = sizeof(address); 179909a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 180009a3aaf3SDag-Erling Smørgrav } 180109a3aaf3SDag-Erling Smørgrav 180209a3aaf3SDag-Erling Smørgrav int sldns_str2wire_aaaa_buf(const char* str, uint8_t* rd, size_t* len) 180309a3aaf3SDag-Erling Smørgrav { 180409a3aaf3SDag-Erling Smørgrav #ifdef AF_INET6 180509a3aaf3SDag-Erling Smørgrav uint8_t address[LDNS_IP6ADDRLEN + 1]; 180609a3aaf3SDag-Erling Smørgrav if(inet_pton(AF_INET6, (char*)str, address) != 1) 180709a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_IP6; 180809a3aaf3SDag-Erling Smørgrav if(*len < LDNS_IP6ADDRLEN) 180909a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 181009a3aaf3SDag-Erling Smørgrav memmove(rd, address, LDNS_IP6ADDRLEN); 181109a3aaf3SDag-Erling Smørgrav *len = LDNS_IP6ADDRLEN; 181209a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 181309a3aaf3SDag-Erling Smørgrav #else 181409a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_NOT_IMPL; 181509a3aaf3SDag-Erling Smørgrav #endif 181609a3aaf3SDag-Erling Smørgrav } 181709a3aaf3SDag-Erling Smørgrav 181809a3aaf3SDag-Erling Smørgrav int sldns_str2wire_str_buf(const char* str, uint8_t* rd, size_t* len) 181909a3aaf3SDag-Erling Smørgrav { 182009a3aaf3SDag-Erling Smørgrav uint8_t ch = 0; 182109a3aaf3SDag-Erling Smørgrav size_t sl = 0; 182209a3aaf3SDag-Erling Smørgrav const char* s = str; 182309a3aaf3SDag-Erling Smørgrav /* skip length byte */ 182409a3aaf3SDag-Erling Smørgrav if(*len < 1) 182509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 182609a3aaf3SDag-Erling Smørgrav 182709a3aaf3SDag-Erling Smørgrav /* read characters */ 182809a3aaf3SDag-Erling Smørgrav while(sldns_parse_char(&ch, &s)) { 182909a3aaf3SDag-Erling Smørgrav if(sl >= 255) 183009a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR, s-str); 18310eefd307SCy Schubert if(*len < sl+2) 183209a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 183309a3aaf3SDag-Erling Smørgrav s-str); 183409a3aaf3SDag-Erling Smørgrav rd[++sl] = ch; 183509a3aaf3SDag-Erling Smørgrav } 183609a3aaf3SDag-Erling Smørgrav if(!s) 183709a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_BAD_ESCAPE; 183809a3aaf3SDag-Erling Smørgrav rd[0] = (uint8_t)sl; 183909a3aaf3SDag-Erling Smørgrav *len = sl+1; 184009a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 184109a3aaf3SDag-Erling Smørgrav } 184209a3aaf3SDag-Erling Smørgrav 184309a3aaf3SDag-Erling Smørgrav int sldns_str2wire_apl_buf(const char* str, uint8_t* rd, size_t* len) 184409a3aaf3SDag-Erling Smørgrav { 184509a3aaf3SDag-Erling Smørgrav const char *my_str = str; 184609a3aaf3SDag-Erling Smørgrav 184709a3aaf3SDag-Erling Smørgrav char my_ip_str[64]; 184809a3aaf3SDag-Erling Smørgrav size_t ip_str_len; 184909a3aaf3SDag-Erling Smørgrav 185009a3aaf3SDag-Erling Smørgrav uint16_t family; 185109a3aaf3SDag-Erling Smørgrav int negation; 185209a3aaf3SDag-Erling Smørgrav size_t adflength = 0; 185309a3aaf3SDag-Erling Smørgrav uint8_t data[16+4]; 185409a3aaf3SDag-Erling Smørgrav uint8_t prefix; 185509a3aaf3SDag-Erling Smørgrav size_t i; 185609a3aaf3SDag-Erling Smørgrav 1857f61ef7f6SDag-Erling Smørgrav if(*my_str == '\0') { 185809a3aaf3SDag-Erling Smørgrav /* empty APL element, no data, no string */ 185909a3aaf3SDag-Erling Smørgrav *len = 0; 186009a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 186109a3aaf3SDag-Erling Smørgrav } 186209a3aaf3SDag-Erling Smørgrav 186309a3aaf3SDag-Erling Smørgrav /* [!]afi:address/prefix */ 186409a3aaf3SDag-Erling Smørgrav if (strlen(my_str) < 2 186509a3aaf3SDag-Erling Smørgrav || strchr(my_str, ':') == NULL 186609a3aaf3SDag-Erling Smørgrav || strchr(my_str, '/') == NULL 186709a3aaf3SDag-Erling Smørgrav || strchr(my_str, ':') > strchr(my_str, '/')) { 186809a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INVALID_STR; 186909a3aaf3SDag-Erling Smørgrav } 187009a3aaf3SDag-Erling Smørgrav 187109a3aaf3SDag-Erling Smørgrav if (my_str[0] == '!') { 187209a3aaf3SDag-Erling Smørgrav negation = 1; 187309a3aaf3SDag-Erling Smørgrav my_str += 1; 187409a3aaf3SDag-Erling Smørgrav } else { 187509a3aaf3SDag-Erling Smørgrav negation = 0; 187609a3aaf3SDag-Erling Smørgrav } 187709a3aaf3SDag-Erling Smørgrav 187809a3aaf3SDag-Erling Smørgrav family = (uint16_t) atoi(my_str); 187909a3aaf3SDag-Erling Smørgrav 188009a3aaf3SDag-Erling Smørgrav my_str = strchr(my_str, ':') + 1; 188109a3aaf3SDag-Erling Smørgrav 188209a3aaf3SDag-Erling Smørgrav /* need ip addr and only ip addr for inet_pton */ 188309a3aaf3SDag-Erling Smørgrav ip_str_len = (size_t) (strchr(my_str, '/') - my_str); 188409a3aaf3SDag-Erling Smørgrav if(ip_str_len+1 > sizeof(my_ip_str)) 188509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INVALID_STR; 188609a3aaf3SDag-Erling Smørgrav (void)strlcpy(my_ip_str, my_str, sizeof(my_ip_str)); 188709a3aaf3SDag-Erling Smørgrav my_ip_str[ip_str_len] = 0; 188809a3aaf3SDag-Erling Smørgrav 188909a3aaf3SDag-Erling Smørgrav if (family == 1) { 189009a3aaf3SDag-Erling Smørgrav /* ipv4 */ 189109a3aaf3SDag-Erling Smørgrav if(inet_pton(AF_INET, my_ip_str, data+4) == 0) 189209a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INVALID_STR; 189309a3aaf3SDag-Erling Smørgrav for (i = 0; i < 4; i++) { 189409a3aaf3SDag-Erling Smørgrav if (data[i+4] != 0) { 189509a3aaf3SDag-Erling Smørgrav adflength = i + 1; 189609a3aaf3SDag-Erling Smørgrav } 189709a3aaf3SDag-Erling Smørgrav } 189809a3aaf3SDag-Erling Smørgrav } else if (family == 2) { 189909a3aaf3SDag-Erling Smørgrav /* ipv6 */ 190009a3aaf3SDag-Erling Smørgrav if (inet_pton(AF_INET6, my_ip_str, data+4) == 0) 190109a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INVALID_STR; 190209a3aaf3SDag-Erling Smørgrav for (i = 0; i < 16; i++) { 190309a3aaf3SDag-Erling Smørgrav if (data[i+4] != 0) { 190409a3aaf3SDag-Erling Smørgrav adflength = i + 1; 190509a3aaf3SDag-Erling Smørgrav } 190609a3aaf3SDag-Erling Smørgrav } 190709a3aaf3SDag-Erling Smørgrav } else { 190809a3aaf3SDag-Erling Smørgrav /* unknown family */ 190909a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INVALID_STR; 191009a3aaf3SDag-Erling Smørgrav } 191109a3aaf3SDag-Erling Smørgrav 191209a3aaf3SDag-Erling Smørgrav my_str = strchr(my_str, '/') + 1; 191309a3aaf3SDag-Erling Smørgrav prefix = (uint8_t) atoi(my_str); 191409a3aaf3SDag-Erling Smørgrav 191509a3aaf3SDag-Erling Smørgrav sldns_write_uint16(data, family); 191609a3aaf3SDag-Erling Smørgrav data[2] = prefix; 191709a3aaf3SDag-Erling Smørgrav data[3] = (uint8_t)adflength; 191809a3aaf3SDag-Erling Smørgrav if (negation) { 191909a3aaf3SDag-Erling Smørgrav /* set bit 1 of byte 3 */ 192009a3aaf3SDag-Erling Smørgrav data[3] = data[3] | 0x80; 192109a3aaf3SDag-Erling Smørgrav } 192209a3aaf3SDag-Erling Smørgrav 192309a3aaf3SDag-Erling Smørgrav if(*len < 4+adflength) 192409a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 192509a3aaf3SDag-Erling Smørgrav memmove(rd, data, 4+adflength); 192609a3aaf3SDag-Erling Smørgrav *len = 4+adflength; 192709a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 192809a3aaf3SDag-Erling Smørgrav } 192909a3aaf3SDag-Erling Smørgrav 193009a3aaf3SDag-Erling Smørgrav int sldns_str2wire_b64_buf(const char* str, uint8_t* rd, size_t* len) 193109a3aaf3SDag-Erling Smørgrav { 193209a3aaf3SDag-Erling Smørgrav size_t sz = sldns_b64_pton_calculate_size(strlen(str)); 193309a3aaf3SDag-Erling Smørgrav int n; 1934971980c3SDag-Erling Smørgrav if(strcmp(str, "0") == 0) { 1935971980c3SDag-Erling Smørgrav *len = 0; 1936971980c3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 1937971980c3SDag-Erling Smørgrav } 193809a3aaf3SDag-Erling Smørgrav if(*len < sz) 193909a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 194009a3aaf3SDag-Erling Smørgrav n = sldns_b64_pton(str, rd, *len); 194109a3aaf3SDag-Erling Smørgrav if(n < 0) 194209a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_B64; 194309a3aaf3SDag-Erling Smørgrav *len = (size_t)n; 194409a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 194509a3aaf3SDag-Erling Smørgrav } 194609a3aaf3SDag-Erling Smørgrav 194709a3aaf3SDag-Erling Smørgrav int sldns_str2wire_b32_ext_buf(const char* str, uint8_t* rd, size_t* len) 194809a3aaf3SDag-Erling Smørgrav { 194909a3aaf3SDag-Erling Smørgrav size_t slen = strlen(str); 195009a3aaf3SDag-Erling Smørgrav size_t sz = sldns_b32_pton_calculate_size(slen); 195109a3aaf3SDag-Erling Smørgrav int n; 195209a3aaf3SDag-Erling Smørgrav if(*len < 1+sz) 195309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 195409a3aaf3SDag-Erling Smørgrav rd[0] = (uint8_t)sz; 195509a3aaf3SDag-Erling Smørgrav n = sldns_b32_pton_extended_hex(str, slen, rd+1, *len-1); 195609a3aaf3SDag-Erling Smørgrav if(n < 0) 195709a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_B32_EXT; 195809a3aaf3SDag-Erling Smørgrav *len = (size_t)n+1; 195909a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 196009a3aaf3SDag-Erling Smørgrav } 196109a3aaf3SDag-Erling Smørgrav 19620fb34990SDag-Erling Smørgrav /** see if the string ends, or ends in whitespace */ 19630fb34990SDag-Erling Smørgrav static int 19640fb34990SDag-Erling Smørgrav sldns_is_last_of_string(const char* str) 19650fb34990SDag-Erling Smørgrav { 19660fb34990SDag-Erling Smørgrav if(*str == 0) return 1; 19670fb34990SDag-Erling Smørgrav while(isspace((unsigned char)*str)) 19680fb34990SDag-Erling Smørgrav str++; 19690fb34990SDag-Erling Smørgrav if(*str == 0) return 1; 19700fb34990SDag-Erling Smørgrav return 0; 19710fb34990SDag-Erling Smørgrav } 19720fb34990SDag-Erling Smørgrav 197309a3aaf3SDag-Erling Smørgrav int sldns_str2wire_hex_buf(const char* str, uint8_t* rd, size_t* len) 197409a3aaf3SDag-Erling Smørgrav { 197509a3aaf3SDag-Erling Smørgrav const char* s = str; 197609a3aaf3SDag-Erling Smørgrav size_t dlen = 0; /* number of hexdigits parsed */ 197709a3aaf3SDag-Erling Smørgrav while(*s) { 197809a3aaf3SDag-Erling Smørgrav if(isspace((unsigned char)*s)) { 197909a3aaf3SDag-Erling Smørgrav s++; 198009a3aaf3SDag-Erling Smørgrav continue; 198109a3aaf3SDag-Erling Smørgrav } 19820fb34990SDag-Erling Smørgrav if(dlen == 0 && *s == '0' && sldns_is_last_of_string(s+1)) { 1983971980c3SDag-Erling Smørgrav *len = 0; 1984971980c3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 1985971980c3SDag-Erling Smørgrav } 198609a3aaf3SDag-Erling Smørgrav if(!isxdigit((unsigned char)*s)) 198709a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str); 198809a3aaf3SDag-Erling Smørgrav if(*len < dlen/2 + 1) 198909a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 199009a3aaf3SDag-Erling Smørgrav s-str); 199109a3aaf3SDag-Erling Smørgrav if((dlen&1)==0) 199209a3aaf3SDag-Erling Smørgrav rd[dlen/2] = (uint8_t)sldns_hexdigit_to_int(*s++) * 16; 199309a3aaf3SDag-Erling Smørgrav else rd[dlen/2] += (uint8_t)sldns_hexdigit_to_int(*s++); 199409a3aaf3SDag-Erling Smørgrav dlen++; 199509a3aaf3SDag-Erling Smørgrav } 199609a3aaf3SDag-Erling Smørgrav if((dlen&1)!=0) 199709a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str); 199809a3aaf3SDag-Erling Smørgrav *len = dlen/2; 199909a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 200009a3aaf3SDag-Erling Smørgrav } 200109a3aaf3SDag-Erling Smørgrav 200209a3aaf3SDag-Erling Smørgrav int sldns_str2wire_nsec_buf(const char* str, uint8_t* rd, size_t* len) 200309a3aaf3SDag-Erling Smørgrav { 200409a3aaf3SDag-Erling Smørgrav const char *delim = "\n\t "; 200509a3aaf3SDag-Erling Smørgrav char token[64]; /* for a type name */ 200609a3aaf3SDag-Erling Smørgrav size_t type_count = 0; 200709a3aaf3SDag-Erling Smørgrav int block; 200809a3aaf3SDag-Erling Smørgrav size_t used = 0; 200909a3aaf3SDag-Erling Smørgrav uint16_t maxtype = 0; 201009a3aaf3SDag-Erling Smørgrav uint8_t typebits[8192]; /* 65536 bits */ 201109a3aaf3SDag-Erling Smørgrav uint8_t window_in_use[256]; 201209a3aaf3SDag-Erling Smørgrav 201309a3aaf3SDag-Erling Smørgrav /* string in buffer */ 201409a3aaf3SDag-Erling Smørgrav sldns_buffer strbuf; 201509a3aaf3SDag-Erling Smørgrav sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str)); 201609a3aaf3SDag-Erling Smørgrav 201709a3aaf3SDag-Erling Smørgrav /* parse the types */ 201809a3aaf3SDag-Erling Smørgrav memset(typebits, 0, sizeof(typebits)); 201909a3aaf3SDag-Erling Smørgrav memset(window_in_use, 0, sizeof(window_in_use)); 202009a3aaf3SDag-Erling Smørgrav while(sldns_buffer_remaining(&strbuf) > 0 && 202109a3aaf3SDag-Erling Smørgrav sldns_bget_token(&strbuf, token, delim, sizeof(token)) != -1) { 202209a3aaf3SDag-Erling Smørgrav uint16_t t = sldns_get_rr_type_by_name(token); 202309a3aaf3SDag-Erling Smørgrav if(token[0] == 0) 202409a3aaf3SDag-Erling Smørgrav continue; 202509a3aaf3SDag-Erling Smørgrav if(t == 0 && strcmp(token, "TYPE0") != 0) 202609a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TYPE, 202709a3aaf3SDag-Erling Smørgrav sldns_buffer_position(&strbuf)); 202809a3aaf3SDag-Erling Smørgrav typebits[t/8] |= (0x80>>(t%8)); 202909a3aaf3SDag-Erling Smørgrav window_in_use[t/256] = 1; 203009a3aaf3SDag-Erling Smørgrav type_count++; 203109a3aaf3SDag-Erling Smørgrav if(t > maxtype) maxtype = t; 203209a3aaf3SDag-Erling Smørgrav } 203309a3aaf3SDag-Erling Smørgrav 203409a3aaf3SDag-Erling Smørgrav /* empty NSEC bitmap */ 203509a3aaf3SDag-Erling Smørgrav if(type_count == 0) { 203609a3aaf3SDag-Erling Smørgrav *len = 0; 203709a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 203809a3aaf3SDag-Erling Smørgrav } 203909a3aaf3SDag-Erling Smørgrav 204009a3aaf3SDag-Erling Smørgrav /* encode windows {u8 windowblock, u8 bitmaplength, 0-32u8 bitmap}, 204109a3aaf3SDag-Erling Smørgrav * block is 0-255 upper octet of types, length if 0-32. */ 204209a3aaf3SDag-Erling Smørgrav for(block = 0; block <= (int)maxtype/256; block++) { 204309a3aaf3SDag-Erling Smørgrav int i, blocklen = 0; 204409a3aaf3SDag-Erling Smørgrav if(!window_in_use[block]) 204509a3aaf3SDag-Erling Smørgrav continue; 204609a3aaf3SDag-Erling Smørgrav for(i=0; i<32; i++) { 204709a3aaf3SDag-Erling Smørgrav if(typebits[block*32+i] != 0) 204809a3aaf3SDag-Erling Smørgrav blocklen = i+1; 204909a3aaf3SDag-Erling Smørgrav } 205009a3aaf3SDag-Erling Smørgrav if(blocklen == 0) 205109a3aaf3SDag-Erling Smørgrav continue; /* empty window should have been !in_use */ 205209a3aaf3SDag-Erling Smørgrav if(used+blocklen+2 > *len) 205309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 205409a3aaf3SDag-Erling Smørgrav rd[used+0] = (uint8_t)block; 205509a3aaf3SDag-Erling Smørgrav rd[used+1] = (uint8_t)blocklen; 205609a3aaf3SDag-Erling Smørgrav for(i=0; i<blocklen; i++) { 205709a3aaf3SDag-Erling Smørgrav rd[used+2+i] = typebits[block*32+i]; 205809a3aaf3SDag-Erling Smørgrav } 205909a3aaf3SDag-Erling Smørgrav used += blocklen+2; 206009a3aaf3SDag-Erling Smørgrav } 206109a3aaf3SDag-Erling Smørgrav *len = used; 206209a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 206309a3aaf3SDag-Erling Smørgrav } 206409a3aaf3SDag-Erling Smørgrav 206509a3aaf3SDag-Erling Smørgrav int sldns_str2wire_type_buf(const char* str, uint8_t* rd, size_t* len) 206609a3aaf3SDag-Erling Smørgrav { 206709a3aaf3SDag-Erling Smørgrav uint16_t t = sldns_get_rr_type_by_name(str); 206809a3aaf3SDag-Erling Smørgrav if(t == 0 && strcmp(str, "TYPE0") != 0) 206909a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_TYPE; 207009a3aaf3SDag-Erling Smørgrav if(*len < 2) 207109a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 207209a3aaf3SDag-Erling Smørgrav sldns_write_uint16(rd, t); 207309a3aaf3SDag-Erling Smørgrav *len = 2; 207409a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 207509a3aaf3SDag-Erling Smørgrav } 207609a3aaf3SDag-Erling Smørgrav 207709a3aaf3SDag-Erling Smørgrav int sldns_str2wire_class_buf(const char* str, uint8_t* rd, size_t* len) 207809a3aaf3SDag-Erling Smørgrav { 207909a3aaf3SDag-Erling Smørgrav uint16_t c = sldns_get_rr_class_by_name(str); 208009a3aaf3SDag-Erling Smørgrav if(c == 0 && strcmp(str, "CLASS0") != 0) 208109a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_CLASS; 208209a3aaf3SDag-Erling Smørgrav if(*len < 2) 208309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 208409a3aaf3SDag-Erling Smørgrav sldns_write_uint16(rd, c); 208509a3aaf3SDag-Erling Smørgrav *len = 2; 208609a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 208709a3aaf3SDag-Erling Smørgrav } 208809a3aaf3SDag-Erling Smørgrav 208909a3aaf3SDag-Erling Smørgrav /* An certificate alg field can either be specified as a 8 bits number 209009a3aaf3SDag-Erling Smørgrav * or by its symbolic name. Handle both */ 209109a3aaf3SDag-Erling Smørgrav int sldns_str2wire_cert_alg_buf(const char* str, uint8_t* rd, size_t* len) 209209a3aaf3SDag-Erling Smørgrav { 209309a3aaf3SDag-Erling Smørgrav sldns_lookup_table *lt = sldns_lookup_by_name(sldns_cert_algorithms, 209409a3aaf3SDag-Erling Smørgrav str); 209509a3aaf3SDag-Erling Smørgrav if(*len < 2) 209609a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 209709a3aaf3SDag-Erling Smørgrav if(lt) { 209809a3aaf3SDag-Erling Smørgrav sldns_write_uint16(rd, (uint16_t)lt->id); 209909a3aaf3SDag-Erling Smørgrav } else { 210009a3aaf3SDag-Erling Smørgrav int s = sldns_str2wire_int16_buf(str, rd, len); 210109a3aaf3SDag-Erling Smørgrav if(s) return s; 210209a3aaf3SDag-Erling Smørgrav if(sldns_read_uint16(rd) == 0) 210309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_CERT_BAD_ALGORITHM; 210409a3aaf3SDag-Erling Smørgrav } 210509a3aaf3SDag-Erling Smørgrav *len = 2; 210609a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 210709a3aaf3SDag-Erling Smørgrav } 210809a3aaf3SDag-Erling Smørgrav 210909a3aaf3SDag-Erling Smørgrav /* An alg field can either be specified as a 8 bits number 211009a3aaf3SDag-Erling Smørgrav * or by its symbolic name. Handle both */ 211109a3aaf3SDag-Erling Smørgrav int sldns_str2wire_alg_buf(const char* str, uint8_t* rd, size_t* len) 211209a3aaf3SDag-Erling Smørgrav { 211309a3aaf3SDag-Erling Smørgrav sldns_lookup_table *lt = sldns_lookup_by_name(sldns_algorithms, str); 211409a3aaf3SDag-Erling Smørgrav if(*len < 1) 211509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 211609a3aaf3SDag-Erling Smørgrav if(lt) { 211709a3aaf3SDag-Erling Smørgrav rd[0] = (uint8_t)lt->id; 211809a3aaf3SDag-Erling Smørgrav *len = 1; 211909a3aaf3SDag-Erling Smørgrav } else { 212009a3aaf3SDag-Erling Smørgrav /* try as-is (a number) */ 212109a3aaf3SDag-Erling Smørgrav return sldns_str2wire_int8_buf(str, rd, len); 212209a3aaf3SDag-Erling Smørgrav } 212309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 212409a3aaf3SDag-Erling Smørgrav } 212509a3aaf3SDag-Erling Smørgrav 2126c7f4d7adSDag-Erling Smørgrav int sldns_str2wire_tsigerror_buf(const char* str, uint8_t* rd, size_t* len) 2127c7f4d7adSDag-Erling Smørgrav { 2128c7f4d7adSDag-Erling Smørgrav sldns_lookup_table *lt = sldns_lookup_by_name(sldns_tsig_errors, str); 2129c7f4d7adSDag-Erling Smørgrav if(*len < 2) 2130c7f4d7adSDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 2131c7f4d7adSDag-Erling Smørgrav if(lt) { 2132c7f4d7adSDag-Erling Smørgrav sldns_write_uint16(rd, (uint16_t)lt->id); 2133c7f4d7adSDag-Erling Smørgrav *len = 2; 2134c7f4d7adSDag-Erling Smørgrav } else { 2135c7f4d7adSDag-Erling Smørgrav /* try as-is (a number) */ 2136c7f4d7adSDag-Erling Smørgrav return sldns_str2wire_int16_buf(str, rd, len); 2137c7f4d7adSDag-Erling Smørgrav } 2138c7f4d7adSDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 2139c7f4d7adSDag-Erling Smørgrav } 2140c7f4d7adSDag-Erling Smørgrav 214109a3aaf3SDag-Erling Smørgrav int sldns_str2wire_time_buf(const char* str, uint8_t* rd, size_t* len) 214209a3aaf3SDag-Erling Smørgrav { 214309a3aaf3SDag-Erling Smørgrav /* convert a time YYYYDDMMHHMMSS to wireformat */ 214409a3aaf3SDag-Erling Smørgrav struct tm tm; 214509a3aaf3SDag-Erling Smørgrav if(*len < 4) 214609a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 214709a3aaf3SDag-Erling Smørgrav 214809a3aaf3SDag-Erling Smørgrav /* Try to scan the time... */ 214909a3aaf3SDag-Erling Smørgrav memset(&tm, 0, sizeof(tm)); 215009a3aaf3SDag-Erling Smørgrav if (strlen(str) == 14 && sscanf(str, "%4d%2d%2d%2d%2d%2d", 215109a3aaf3SDag-Erling Smørgrav &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, 215209a3aaf3SDag-Erling Smørgrav &tm.tm_min, &tm.tm_sec) == 6) { 215309a3aaf3SDag-Erling Smørgrav tm.tm_year -= 1900; 215409a3aaf3SDag-Erling Smørgrav tm.tm_mon--; 215509a3aaf3SDag-Erling Smørgrav /* Check values */ 215609a3aaf3SDag-Erling Smørgrav if (tm.tm_year < 70) 215709a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_TIME; 215809a3aaf3SDag-Erling Smørgrav if (tm.tm_mon < 0 || tm.tm_mon > 11) 215909a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_TIME; 216009a3aaf3SDag-Erling Smørgrav if (tm.tm_mday < 1 || tm.tm_mday > 31) 216109a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_TIME; 216209a3aaf3SDag-Erling Smørgrav if (tm.tm_hour < 0 || tm.tm_hour > 23) 216309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_TIME; 216409a3aaf3SDag-Erling Smørgrav if (tm.tm_min < 0 || tm.tm_min > 59) 216509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_TIME; 216609a3aaf3SDag-Erling Smørgrav if (tm.tm_sec < 0 || tm.tm_sec > 59) 216709a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_TIME; 216809a3aaf3SDag-Erling Smørgrav 2169bc892140SDag-Erling Smørgrav sldns_write_uint32(rd, (uint32_t)sldns_mktime_from_utc(&tm)); 217009a3aaf3SDag-Erling Smørgrav } else { 217109a3aaf3SDag-Erling Smørgrav /* handle it as 32 bits timestamp */ 217209a3aaf3SDag-Erling Smørgrav char *end; 217309a3aaf3SDag-Erling Smørgrav uint32_t l = (uint32_t)strtol((char*)str, &end, 10); 217409a3aaf3SDag-Erling Smørgrav if(*end != 0) 217509a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TIME, 217609a3aaf3SDag-Erling Smørgrav end-(char*)str); 217709a3aaf3SDag-Erling Smørgrav sldns_write_uint32(rd, l); 217809a3aaf3SDag-Erling Smørgrav } 217909a3aaf3SDag-Erling Smørgrav *len = 4; 218009a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 218109a3aaf3SDag-Erling Smørgrav } 218209a3aaf3SDag-Erling Smørgrav 2183c7f4d7adSDag-Erling Smørgrav int sldns_str2wire_tsigtime_buf(const char* str, uint8_t* rd, size_t* len) 2184c7f4d7adSDag-Erling Smørgrav { 2185c7f4d7adSDag-Erling Smørgrav char* end; 2186c7f4d7adSDag-Erling Smørgrav uint64_t t = (uint64_t)strtol((char*)str, &end, 10); 2187c7f4d7adSDag-Erling Smørgrav uint16_t high; 2188c7f4d7adSDag-Erling Smørgrav uint32_t low; 2189c7f4d7adSDag-Erling Smørgrav if(*end != 0) 2190c7f4d7adSDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TIME, end-str); 2191c7f4d7adSDag-Erling Smørgrav if(*len < 6) 2192c7f4d7adSDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 2193c7f4d7adSDag-Erling Smørgrav high = (uint16_t)(t>>32); 2194c7f4d7adSDag-Erling Smørgrav low = (uint32_t)(t); 2195c7f4d7adSDag-Erling Smørgrav sldns_write_uint16(rd, high); 2196c7f4d7adSDag-Erling Smørgrav sldns_write_uint32(rd+2, low); 2197c7f4d7adSDag-Erling Smørgrav *len = 6; 2198c7f4d7adSDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 2199c7f4d7adSDag-Erling Smørgrav } 2200c7f4d7adSDag-Erling Smørgrav 220109a3aaf3SDag-Erling Smørgrav int sldns_str2wire_period_buf(const char* str, uint8_t* rd, size_t* len) 220209a3aaf3SDag-Erling Smørgrav { 220309a3aaf3SDag-Erling Smørgrav const char* end; 2204a39a5a69SCy Schubert int overflow; 2205a39a5a69SCy Schubert uint32_t p = sldns_str2period(str, &end, &overflow); 220609a3aaf3SDag-Erling Smørgrav if(*end != 0) 220709a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_PERIOD, end-str); 2208a39a5a69SCy Schubert if(overflow) 2209a39a5a69SCy Schubert return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INTEGER_OVERFLOW, 2210a39a5a69SCy Schubert end-str); 221109a3aaf3SDag-Erling Smørgrav if(*len < 4) 221209a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 221309a3aaf3SDag-Erling Smørgrav sldns_write_uint32(rd, p); 221409a3aaf3SDag-Erling Smørgrav *len = 4; 221509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 221609a3aaf3SDag-Erling Smørgrav } 221709a3aaf3SDag-Erling Smørgrav 221809a3aaf3SDag-Erling Smørgrav /** read "<digits>[.<digits>][mM]" into mantissa exponent format for LOC type */ 221909a3aaf3SDag-Erling Smørgrav static int 222009a3aaf3SDag-Erling Smørgrav loc_parse_cm(char* my_str, char** endstr, uint8_t* m, uint8_t* e) 222109a3aaf3SDag-Erling Smørgrav { 222209a3aaf3SDag-Erling Smørgrav uint32_t meters = 0, cm = 0, val; 22235469a995SCy Schubert char* cm_endstr; 222409a3aaf3SDag-Erling Smørgrav while (isblank((unsigned char)*my_str)) { 222509a3aaf3SDag-Erling Smørgrav my_str++; 222609a3aaf3SDag-Erling Smørgrav } 222709a3aaf3SDag-Erling Smørgrav meters = (uint32_t)strtol(my_str, &my_str, 10); 222809a3aaf3SDag-Erling Smørgrav if (*my_str == '.') { 222909a3aaf3SDag-Erling Smørgrav my_str++; 22305469a995SCy Schubert cm = (uint32_t)strtol(my_str, &cm_endstr, 10); 22315469a995SCy Schubert if(cm_endstr == my_str + 1) 22325469a995SCy Schubert cm *= 10; 22335469a995SCy Schubert my_str = cm_endstr; 223409a3aaf3SDag-Erling Smørgrav } 223509a3aaf3SDag-Erling Smørgrav if (meters >= 1) { 223609a3aaf3SDag-Erling Smørgrav *e = 2; 223709a3aaf3SDag-Erling Smørgrav val = meters; 223809a3aaf3SDag-Erling Smørgrav } else { 223909a3aaf3SDag-Erling Smørgrav *e = 0; 224009a3aaf3SDag-Erling Smørgrav val = cm; 224109a3aaf3SDag-Erling Smørgrav } 224209a3aaf3SDag-Erling Smørgrav while(val >= 10) { 224309a3aaf3SDag-Erling Smørgrav (*e)++; 224409a3aaf3SDag-Erling Smørgrav val /= 10; 224509a3aaf3SDag-Erling Smørgrav } 224609a3aaf3SDag-Erling Smørgrav *m = (uint8_t)val; 224709a3aaf3SDag-Erling Smørgrav 224809a3aaf3SDag-Erling Smørgrav if (*e > 9) 224909a3aaf3SDag-Erling Smørgrav return 0; 225009a3aaf3SDag-Erling Smørgrav if (*my_str == 'm' || *my_str == 'M') { 225109a3aaf3SDag-Erling Smørgrav my_str++; 225209a3aaf3SDag-Erling Smørgrav } 225309a3aaf3SDag-Erling Smørgrav *endstr = my_str; 225409a3aaf3SDag-Erling Smørgrav return 1; 225509a3aaf3SDag-Erling Smørgrav } 225609a3aaf3SDag-Erling Smørgrav 225709a3aaf3SDag-Erling Smørgrav int sldns_str2wire_loc_buf(const char* str, uint8_t* rd, size_t* len) 225809a3aaf3SDag-Erling Smørgrav { 225909a3aaf3SDag-Erling Smørgrav uint32_t latitude = 0; 226009a3aaf3SDag-Erling Smørgrav uint32_t longitude = 0; 226109a3aaf3SDag-Erling Smørgrav uint32_t altitude = 0; 226209a3aaf3SDag-Erling Smørgrav 226309a3aaf3SDag-Erling Smørgrav uint32_t equator = (uint32_t)1<<31; /* 2**31 */ 226409a3aaf3SDag-Erling Smørgrav 226509a3aaf3SDag-Erling Smørgrav /* only support version 0 */ 226609a3aaf3SDag-Erling Smørgrav uint32_t h = 0; 226709a3aaf3SDag-Erling Smørgrav uint32_t m = 0; 226809a3aaf3SDag-Erling Smørgrav uint8_t size_b = 1, size_e = 2; 226909a3aaf3SDag-Erling Smørgrav uint8_t horiz_pre_b = 1, horiz_pre_e = 6; 227009a3aaf3SDag-Erling Smørgrav uint8_t vert_pre_b = 1, vert_pre_e = 3; 227109a3aaf3SDag-Erling Smørgrav 227209a3aaf3SDag-Erling Smørgrav double s = 0.0; 227309a3aaf3SDag-Erling Smørgrav int northerness; 227409a3aaf3SDag-Erling Smørgrav int easterness; 227509a3aaf3SDag-Erling Smørgrav 227609a3aaf3SDag-Erling Smørgrav char *my_str = (char *) str; 227709a3aaf3SDag-Erling Smørgrav 227809a3aaf3SDag-Erling Smørgrav if (isdigit((unsigned char) *my_str)) { 227909a3aaf3SDag-Erling Smørgrav h = (uint32_t) strtol(my_str, &my_str, 10); 228009a3aaf3SDag-Erling Smørgrav } else { 228109a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INVALID_STR; 228209a3aaf3SDag-Erling Smørgrav } 228309a3aaf3SDag-Erling Smørgrav 228409a3aaf3SDag-Erling Smørgrav while (isblank((unsigned char) *my_str)) { 228509a3aaf3SDag-Erling Smørgrav my_str++; 228609a3aaf3SDag-Erling Smørgrav } 228709a3aaf3SDag-Erling Smørgrav 228809a3aaf3SDag-Erling Smørgrav if (isdigit((unsigned char) *my_str)) { 228909a3aaf3SDag-Erling Smørgrav m = (uint32_t) strtol(my_str, &my_str, 10); 229009a3aaf3SDag-Erling Smørgrav } else if (*my_str == 'N' || *my_str == 'S') { 229109a3aaf3SDag-Erling Smørgrav goto north; 229209a3aaf3SDag-Erling Smørgrav } else { 229309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INVALID_STR; 229409a3aaf3SDag-Erling Smørgrav } 229509a3aaf3SDag-Erling Smørgrav 229609a3aaf3SDag-Erling Smørgrav while (isblank((unsigned char) *my_str)) { 229709a3aaf3SDag-Erling Smørgrav my_str++; 229809a3aaf3SDag-Erling Smørgrav } 229909a3aaf3SDag-Erling Smørgrav 230009a3aaf3SDag-Erling Smørgrav if (isdigit((unsigned char) *my_str)) { 230109a3aaf3SDag-Erling Smørgrav s = strtod(my_str, &my_str); 230209a3aaf3SDag-Erling Smørgrav } 230309a3aaf3SDag-Erling Smørgrav 23048a384985SDag-Erling Smørgrav /* skip blanks before northerness */ 230509a3aaf3SDag-Erling Smørgrav while (isblank((unsigned char) *my_str)) { 230609a3aaf3SDag-Erling Smørgrav my_str++; 230709a3aaf3SDag-Erling Smørgrav } 230809a3aaf3SDag-Erling Smørgrav 230909a3aaf3SDag-Erling Smørgrav north: 231009a3aaf3SDag-Erling Smørgrav if (*my_str == 'N') { 231109a3aaf3SDag-Erling Smørgrav northerness = 1; 231209a3aaf3SDag-Erling Smørgrav } else if (*my_str == 'S') { 231309a3aaf3SDag-Erling Smørgrav northerness = 0; 231409a3aaf3SDag-Erling Smørgrav } else { 231509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INVALID_STR; 231609a3aaf3SDag-Erling Smørgrav } 231709a3aaf3SDag-Erling Smørgrav 231809a3aaf3SDag-Erling Smørgrav my_str++; 231909a3aaf3SDag-Erling Smørgrav 232009a3aaf3SDag-Erling Smørgrav /* store number */ 232109a3aaf3SDag-Erling Smørgrav s = 1000.0 * s; 232209a3aaf3SDag-Erling Smørgrav /* add a little to make floor in conversion a round */ 232309a3aaf3SDag-Erling Smørgrav s += 0.0005; 232409a3aaf3SDag-Erling Smørgrav latitude = (uint32_t) s; 232509a3aaf3SDag-Erling Smørgrav latitude += 1000 * 60 * m; 232609a3aaf3SDag-Erling Smørgrav latitude += 1000 * 60 * 60 * h; 232709a3aaf3SDag-Erling Smørgrav if (northerness) { 232809a3aaf3SDag-Erling Smørgrav latitude = equator + latitude; 232909a3aaf3SDag-Erling Smørgrav } else { 233009a3aaf3SDag-Erling Smørgrav latitude = equator - latitude; 233109a3aaf3SDag-Erling Smørgrav } 233209a3aaf3SDag-Erling Smørgrav while (isblank((unsigned char)*my_str)) { 233309a3aaf3SDag-Erling Smørgrav my_str++; 233409a3aaf3SDag-Erling Smørgrav } 233509a3aaf3SDag-Erling Smørgrav 233609a3aaf3SDag-Erling Smørgrav if (isdigit((unsigned char) *my_str)) { 233709a3aaf3SDag-Erling Smørgrav h = (uint32_t) strtol(my_str, &my_str, 10); 233809a3aaf3SDag-Erling Smørgrav } else { 233909a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INVALID_STR; 234009a3aaf3SDag-Erling Smørgrav } 234109a3aaf3SDag-Erling Smørgrav 234209a3aaf3SDag-Erling Smørgrav while (isblank((unsigned char) *my_str)) { 234309a3aaf3SDag-Erling Smørgrav my_str++; 234409a3aaf3SDag-Erling Smørgrav } 234509a3aaf3SDag-Erling Smørgrav 234609a3aaf3SDag-Erling Smørgrav if (isdigit((unsigned char) *my_str)) { 234709a3aaf3SDag-Erling Smørgrav m = (uint32_t) strtol(my_str, &my_str, 10); 234809a3aaf3SDag-Erling Smørgrav } else if (*my_str == 'E' || *my_str == 'W') { 234909a3aaf3SDag-Erling Smørgrav goto east; 235009a3aaf3SDag-Erling Smørgrav } else { 235109a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INVALID_STR; 235209a3aaf3SDag-Erling Smørgrav } 235309a3aaf3SDag-Erling Smørgrav 235409a3aaf3SDag-Erling Smørgrav while (isblank((unsigned char)*my_str)) { 235509a3aaf3SDag-Erling Smørgrav my_str++; 235609a3aaf3SDag-Erling Smørgrav } 235709a3aaf3SDag-Erling Smørgrav 235809a3aaf3SDag-Erling Smørgrav if (isdigit((unsigned char) *my_str)) { 235909a3aaf3SDag-Erling Smørgrav s = strtod(my_str, &my_str); 236009a3aaf3SDag-Erling Smørgrav } 236109a3aaf3SDag-Erling Smørgrav 236209a3aaf3SDag-Erling Smørgrav /* skip blanks before easterness */ 236309a3aaf3SDag-Erling Smørgrav while (isblank((unsigned char)*my_str)) { 236409a3aaf3SDag-Erling Smørgrav my_str++; 236509a3aaf3SDag-Erling Smørgrav } 236609a3aaf3SDag-Erling Smørgrav 236709a3aaf3SDag-Erling Smørgrav east: 236809a3aaf3SDag-Erling Smørgrav if (*my_str == 'E') { 236909a3aaf3SDag-Erling Smørgrav easterness = 1; 237009a3aaf3SDag-Erling Smørgrav } else if (*my_str == 'W') { 237109a3aaf3SDag-Erling Smørgrav easterness = 0; 237209a3aaf3SDag-Erling Smørgrav } else { 237309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INVALID_STR; 237409a3aaf3SDag-Erling Smørgrav } 237509a3aaf3SDag-Erling Smørgrav 237609a3aaf3SDag-Erling Smørgrav my_str++; 237709a3aaf3SDag-Erling Smørgrav 237809a3aaf3SDag-Erling Smørgrav /* store number */ 237909a3aaf3SDag-Erling Smørgrav s *= 1000.0; 238009a3aaf3SDag-Erling Smørgrav /* add a little to make floor in conversion a round */ 238109a3aaf3SDag-Erling Smørgrav s += 0.0005; 238209a3aaf3SDag-Erling Smørgrav longitude = (uint32_t) s; 238309a3aaf3SDag-Erling Smørgrav longitude += 1000 * 60 * m; 238409a3aaf3SDag-Erling Smørgrav longitude += 1000 * 60 * 60 * h; 238509a3aaf3SDag-Erling Smørgrav 238609a3aaf3SDag-Erling Smørgrav if (easterness) { 238709a3aaf3SDag-Erling Smørgrav longitude += equator; 238809a3aaf3SDag-Erling Smørgrav } else { 238909a3aaf3SDag-Erling Smørgrav longitude = equator - longitude; 239009a3aaf3SDag-Erling Smørgrav } 239109a3aaf3SDag-Erling Smørgrav 239209a3aaf3SDag-Erling Smørgrav altitude = (uint32_t)(strtod(my_str, &my_str)*100.0 + 239309a3aaf3SDag-Erling Smørgrav 10000000.0 + 0.5); 239409a3aaf3SDag-Erling Smørgrav if (*my_str == 'm' || *my_str == 'M') { 239509a3aaf3SDag-Erling Smørgrav my_str++; 239609a3aaf3SDag-Erling Smørgrav } 239709a3aaf3SDag-Erling Smørgrav 239809a3aaf3SDag-Erling Smørgrav if (strlen(my_str) > 0) { 239909a3aaf3SDag-Erling Smørgrav if(!loc_parse_cm(my_str, &my_str, &size_b, &size_e)) 240009a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INVALID_STR; 240109a3aaf3SDag-Erling Smørgrav } 240209a3aaf3SDag-Erling Smørgrav 240309a3aaf3SDag-Erling Smørgrav if (strlen(my_str) > 0) { 240409a3aaf3SDag-Erling Smørgrav if(!loc_parse_cm(my_str, &my_str, &horiz_pre_b, &horiz_pre_e)) 240509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INVALID_STR; 240609a3aaf3SDag-Erling Smørgrav } 240709a3aaf3SDag-Erling Smørgrav 240809a3aaf3SDag-Erling Smørgrav if (strlen(my_str) > 0) { 240909a3aaf3SDag-Erling Smørgrav if(!loc_parse_cm(my_str, &my_str, &vert_pre_b, &vert_pre_e)) 241009a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INVALID_STR; 241109a3aaf3SDag-Erling Smørgrav } 241209a3aaf3SDag-Erling Smørgrav 241309a3aaf3SDag-Erling Smørgrav if(*len < 16) 241409a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 241509a3aaf3SDag-Erling Smørgrav rd[0] = 0; 241609a3aaf3SDag-Erling Smørgrav rd[1] = ((size_b << 4) & 0xf0) | (size_e & 0x0f); 241709a3aaf3SDag-Erling Smørgrav rd[2] = ((horiz_pre_b << 4) & 0xf0) | (horiz_pre_e & 0x0f); 241809a3aaf3SDag-Erling Smørgrav rd[3] = ((vert_pre_b << 4) & 0xf0) | (vert_pre_e & 0x0f); 241909a3aaf3SDag-Erling Smørgrav sldns_write_uint32(rd + 4, latitude); 242009a3aaf3SDag-Erling Smørgrav sldns_write_uint32(rd + 8, longitude); 242109a3aaf3SDag-Erling Smørgrav sldns_write_uint32(rd + 12, altitude); 242209a3aaf3SDag-Erling Smørgrav *len = 16; 242309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 242409a3aaf3SDag-Erling Smørgrav } 242509a3aaf3SDag-Erling Smørgrav 242609a3aaf3SDag-Erling Smørgrav static void 242709a3aaf3SDag-Erling Smørgrav ldns_tolower_str(char* s) 242809a3aaf3SDag-Erling Smørgrav { 242909a3aaf3SDag-Erling Smørgrav if(s) { 243009a3aaf3SDag-Erling Smørgrav while(*s) { 243109a3aaf3SDag-Erling Smørgrav *s = (char)tolower((unsigned char)*s); 243209a3aaf3SDag-Erling Smørgrav s++; 243309a3aaf3SDag-Erling Smørgrav } 243409a3aaf3SDag-Erling Smørgrav } 243509a3aaf3SDag-Erling Smørgrav } 243609a3aaf3SDag-Erling Smørgrav 243709a3aaf3SDag-Erling Smørgrav int sldns_str2wire_wks_buf(const char* str, uint8_t* rd, size_t* len) 243809a3aaf3SDag-Erling Smørgrav { 243909a3aaf3SDag-Erling Smørgrav int rd_len = 1; 244009a3aaf3SDag-Erling Smørgrav int have_proto = 0; 244109a3aaf3SDag-Erling Smørgrav char token[50], proto_str[50]; 244209a3aaf3SDag-Erling Smørgrav sldns_buffer strbuf; 244309a3aaf3SDag-Erling Smørgrav sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str)); 244409a3aaf3SDag-Erling Smørgrav proto_str[0]=0; 244509a3aaf3SDag-Erling Smørgrav 244609a3aaf3SDag-Erling Smørgrav /* check we have one byte for proto */ 244709a3aaf3SDag-Erling Smørgrav if(*len < 1) 244809a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 244909a3aaf3SDag-Erling Smørgrav 245009a3aaf3SDag-Erling Smørgrav while(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) > 0) { 245109a3aaf3SDag-Erling Smørgrav ldns_tolower_str(token); 245209a3aaf3SDag-Erling Smørgrav if(!have_proto) { 245309a3aaf3SDag-Erling Smørgrav struct protoent *p = getprotobyname(token); 245409a3aaf3SDag-Erling Smørgrav have_proto = 1; 245509a3aaf3SDag-Erling Smørgrav if(p) rd[0] = (uint8_t)p->p_proto; 2456971980c3SDag-Erling Smørgrav else if(strcasecmp(token, "tcp")==0) rd[0]=6; 2457971980c3SDag-Erling Smørgrav else if(strcasecmp(token, "udp")==0) rd[0]=17; 245809a3aaf3SDag-Erling Smørgrav else rd[0] = (uint8_t)atoi(token); 245909a3aaf3SDag-Erling Smørgrav (void)strlcpy(proto_str, token, sizeof(proto_str)); 246009a3aaf3SDag-Erling Smørgrav } else { 246109a3aaf3SDag-Erling Smørgrav int serv_port; 246209a3aaf3SDag-Erling Smørgrav struct servent *serv = getservbyname(token, proto_str); 246309a3aaf3SDag-Erling Smørgrav if(serv) serv_port=(int)ntohs((uint16_t)serv->s_port); 2464971980c3SDag-Erling Smørgrav else if(strcasecmp(token, "domain")==0) serv_port=53; 246509a3aaf3SDag-Erling Smørgrav else { 246609a3aaf3SDag-Erling Smørgrav serv_port = atoi(token); 246709a3aaf3SDag-Erling Smørgrav if(serv_port == 0 && strcmp(token, "0") != 0) { 246809a3aaf3SDag-Erling Smørgrav #ifdef HAVE_ENDSERVENT 246909a3aaf3SDag-Erling Smørgrav endservent(); 247009a3aaf3SDag-Erling Smørgrav #endif 247109a3aaf3SDag-Erling Smørgrav #ifdef HAVE_ENDPROTOENT 247209a3aaf3SDag-Erling Smørgrav endprotoent(); 247309a3aaf3SDag-Erling Smørgrav #endif 247409a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX, 247509a3aaf3SDag-Erling Smørgrav sldns_buffer_position(&strbuf)); 247609a3aaf3SDag-Erling Smørgrav } 247709a3aaf3SDag-Erling Smørgrav if(serv_port < 0 || serv_port > 65535) { 247809a3aaf3SDag-Erling Smørgrav #ifdef HAVE_ENDSERVENT 247909a3aaf3SDag-Erling Smørgrav endservent(); 248009a3aaf3SDag-Erling Smørgrav #endif 248109a3aaf3SDag-Erling Smørgrav #ifdef HAVE_ENDPROTOENT 248209a3aaf3SDag-Erling Smørgrav endprotoent(); 248309a3aaf3SDag-Erling Smørgrav #endif 248409a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX, 248509a3aaf3SDag-Erling Smørgrav sldns_buffer_position(&strbuf)); 248609a3aaf3SDag-Erling Smørgrav } 248709a3aaf3SDag-Erling Smørgrav } 248809a3aaf3SDag-Erling Smørgrav if(rd_len < 1+serv_port/8+1) { 248909a3aaf3SDag-Erling Smørgrav /* bitmap is larger, init new bytes at 0 */ 249009a3aaf3SDag-Erling Smørgrav if(*len < 1+(size_t)serv_port/8+1) { 249109a3aaf3SDag-Erling Smørgrav #ifdef HAVE_ENDSERVENT 249209a3aaf3SDag-Erling Smørgrav endservent(); 249309a3aaf3SDag-Erling Smørgrav #endif 249409a3aaf3SDag-Erling Smørgrav #ifdef HAVE_ENDPROTOENT 249509a3aaf3SDag-Erling Smørgrav endprotoent(); 249609a3aaf3SDag-Erling Smørgrav #endif 249709a3aaf3SDag-Erling Smørgrav return RET_ERR( 249809a3aaf3SDag-Erling Smørgrav LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 249909a3aaf3SDag-Erling Smørgrav sldns_buffer_position(&strbuf)); 250009a3aaf3SDag-Erling Smørgrav } 250109a3aaf3SDag-Erling Smørgrav memset(rd+rd_len, 0, 1+(size_t)serv_port/8+1-rd_len); 250209a3aaf3SDag-Erling Smørgrav rd_len = 1+serv_port/8+1; 250309a3aaf3SDag-Erling Smørgrav } 250409a3aaf3SDag-Erling Smørgrav rd[1+ serv_port/8] |= (1 << (7 - serv_port % 8)); 250509a3aaf3SDag-Erling Smørgrav } 250609a3aaf3SDag-Erling Smørgrav } 250709a3aaf3SDag-Erling Smørgrav *len = (size_t)rd_len; 250809a3aaf3SDag-Erling Smørgrav 250909a3aaf3SDag-Erling Smørgrav #ifdef HAVE_ENDSERVENT 251009a3aaf3SDag-Erling Smørgrav endservent(); 251109a3aaf3SDag-Erling Smørgrav #endif 251209a3aaf3SDag-Erling Smørgrav #ifdef HAVE_ENDPROTOENT 251309a3aaf3SDag-Erling Smørgrav endprotoent(); 251409a3aaf3SDag-Erling Smørgrav #endif 251509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 251609a3aaf3SDag-Erling Smørgrav } 251709a3aaf3SDag-Erling Smørgrav 251809a3aaf3SDag-Erling Smørgrav int sldns_str2wire_nsap_buf(const char* str, uint8_t* rd, size_t* len) 251909a3aaf3SDag-Erling Smørgrav { 252009a3aaf3SDag-Erling Smørgrav const char* s = str; 252109a3aaf3SDag-Erling Smørgrav size_t slen; 252209a3aaf3SDag-Erling Smørgrav size_t dlen = 0; /* number of hexdigits parsed */ 252309a3aaf3SDag-Erling Smørgrav 252409a3aaf3SDag-Erling Smørgrav /* just a hex string with optional dots? */ 252509a3aaf3SDag-Erling Smørgrav if (s[0] != '0' || s[1] != 'x') 252609a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_INVALID_STR; 252709a3aaf3SDag-Erling Smørgrav s += 2; 252809a3aaf3SDag-Erling Smørgrav slen = strlen(s); 252909a3aaf3SDag-Erling Smørgrav if(slen > LDNS_MAX_RDFLEN*2) 253009a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_LABEL_OVERFLOW; 253109a3aaf3SDag-Erling Smørgrav while(*s) { 253209a3aaf3SDag-Erling Smørgrav if(isspace((unsigned char)*s) || *s == '.') { 253309a3aaf3SDag-Erling Smørgrav s++; 253409a3aaf3SDag-Erling Smørgrav continue; 253509a3aaf3SDag-Erling Smørgrav } 253609a3aaf3SDag-Erling Smørgrav if(!isxdigit((unsigned char)*s)) 253709a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str); 253809a3aaf3SDag-Erling Smørgrav if(*len < dlen/2 + 1) 253909a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 254009a3aaf3SDag-Erling Smørgrav s-str); 254109a3aaf3SDag-Erling Smørgrav if((dlen&1)==0) 254209a3aaf3SDag-Erling Smørgrav rd[dlen/2] = (uint8_t)sldns_hexdigit_to_int(*s++) * 16; 254309a3aaf3SDag-Erling Smørgrav else rd[dlen/2] += sldns_hexdigit_to_int(*s++); 254409a3aaf3SDag-Erling Smørgrav dlen++; 254509a3aaf3SDag-Erling Smørgrav } 254609a3aaf3SDag-Erling Smørgrav if((dlen&1)!=0) 254709a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str); 254809a3aaf3SDag-Erling Smørgrav *len = dlen/2; 254909a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 255009a3aaf3SDag-Erling Smørgrav } 255109a3aaf3SDag-Erling Smørgrav 255209a3aaf3SDag-Erling Smørgrav int sldns_str2wire_atma_buf(const char* str, uint8_t* rd, size_t* len) 255309a3aaf3SDag-Erling Smørgrav { 255409a3aaf3SDag-Erling Smørgrav const char* s = str; 255509a3aaf3SDag-Erling Smørgrav size_t slen = strlen(str); 255609a3aaf3SDag-Erling Smørgrav size_t dlen = 0; /* number of hexdigits parsed */ 255709a3aaf3SDag-Erling Smørgrav 255809a3aaf3SDag-Erling Smørgrav /* just a hex string with optional dots? */ 255909a3aaf3SDag-Erling Smørgrav /* notimpl e.164 format */ 256009a3aaf3SDag-Erling Smørgrav if(slen > LDNS_MAX_RDFLEN*2) 256109a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_LABEL_OVERFLOW; 256209a3aaf3SDag-Erling Smørgrav while(*s) { 256309a3aaf3SDag-Erling Smørgrav if(isspace((unsigned char)*s) || *s == '.') { 256409a3aaf3SDag-Erling Smørgrav s++; 256509a3aaf3SDag-Erling Smørgrav continue; 256609a3aaf3SDag-Erling Smørgrav } 256709a3aaf3SDag-Erling Smørgrav if(!isxdigit((unsigned char)*s)) 256809a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str); 256909a3aaf3SDag-Erling Smørgrav if(*len < dlen/2 + 1) 257009a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 257109a3aaf3SDag-Erling Smørgrav s-str); 257209a3aaf3SDag-Erling Smørgrav if((dlen&1)==0) 257309a3aaf3SDag-Erling Smørgrav rd[dlen/2] = (uint8_t)sldns_hexdigit_to_int(*s++) * 16; 257409a3aaf3SDag-Erling Smørgrav else rd[dlen/2] += sldns_hexdigit_to_int(*s++); 257509a3aaf3SDag-Erling Smørgrav dlen++; 257609a3aaf3SDag-Erling Smørgrav } 257709a3aaf3SDag-Erling Smørgrav if((dlen&1)!=0) 257809a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, s-str); 257909a3aaf3SDag-Erling Smørgrav *len = dlen/2; 258009a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 258109a3aaf3SDag-Erling Smørgrav } 258209a3aaf3SDag-Erling Smørgrav 258309a3aaf3SDag-Erling Smørgrav int sldns_str2wire_ipseckey_buf(const char* str, uint8_t* rd, size_t* len) 258409a3aaf3SDag-Erling Smørgrav { 258509a3aaf3SDag-Erling Smørgrav size_t gwlen = 0, keylen = 0; 258609a3aaf3SDag-Erling Smørgrav int s; 258709a3aaf3SDag-Erling Smørgrav uint8_t gwtype; 258809a3aaf3SDag-Erling Smørgrav char token[512]; 258909a3aaf3SDag-Erling Smørgrav sldns_buffer strbuf; 259009a3aaf3SDag-Erling Smørgrav sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str)); 259109a3aaf3SDag-Erling Smørgrav 259209a3aaf3SDag-Erling Smørgrav if(*len < 3) 259309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 259409a3aaf3SDag-Erling Smørgrav /* precedence */ 259509a3aaf3SDag-Erling Smørgrav if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0) 259609a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR, 259709a3aaf3SDag-Erling Smørgrav sldns_buffer_position(&strbuf)); 259809a3aaf3SDag-Erling Smørgrav rd[0] = (uint8_t)atoi(token); 259909a3aaf3SDag-Erling Smørgrav /* gateway_type */ 260009a3aaf3SDag-Erling Smørgrav if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0) 260109a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR, 260209a3aaf3SDag-Erling Smørgrav sldns_buffer_position(&strbuf)); 260309a3aaf3SDag-Erling Smørgrav rd[1] = (uint8_t)atoi(token); 260409a3aaf3SDag-Erling Smørgrav gwtype = rd[1]; 260509a3aaf3SDag-Erling Smørgrav /* algorithm */ 260609a3aaf3SDag-Erling Smørgrav if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0) 260709a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR, 260809a3aaf3SDag-Erling Smørgrav sldns_buffer_position(&strbuf)); 260909a3aaf3SDag-Erling Smørgrav rd[2] = (uint8_t)atoi(token); 261009a3aaf3SDag-Erling Smørgrav 261109a3aaf3SDag-Erling Smørgrav /* gateway */ 261209a3aaf3SDag-Erling Smørgrav if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0) 261309a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR, 261409a3aaf3SDag-Erling Smørgrav sldns_buffer_position(&strbuf)); 261509a3aaf3SDag-Erling Smørgrav if(gwtype == 0) { 261609a3aaf3SDag-Erling Smørgrav /* NOGATEWAY */ 261709a3aaf3SDag-Erling Smørgrav if(strcmp(token, ".") != 0) 261809a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR, 261909a3aaf3SDag-Erling Smørgrav sldns_buffer_position(&strbuf)); 262009a3aaf3SDag-Erling Smørgrav gwlen = 0; 262109a3aaf3SDag-Erling Smørgrav } else if(gwtype == 1) { 262209a3aaf3SDag-Erling Smørgrav /* IP4 */ 262309a3aaf3SDag-Erling Smørgrav gwlen = *len - 3; 262409a3aaf3SDag-Erling Smørgrav s = sldns_str2wire_a_buf(token, rd+3, &gwlen); 262509a3aaf3SDag-Erling Smørgrav if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf)); 262609a3aaf3SDag-Erling Smørgrav } else if(gwtype == 2) { 262709a3aaf3SDag-Erling Smørgrav /* IP6 */ 262809a3aaf3SDag-Erling Smørgrav gwlen = *len - 3; 262909a3aaf3SDag-Erling Smørgrav s = sldns_str2wire_aaaa_buf(token, rd+3, &gwlen); 263009a3aaf3SDag-Erling Smørgrav if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf)); 263109a3aaf3SDag-Erling Smørgrav } else if(gwtype == 3) { 263209a3aaf3SDag-Erling Smørgrav /* DNAME */ 263309a3aaf3SDag-Erling Smørgrav gwlen = *len - 3; 263409a3aaf3SDag-Erling Smørgrav s = sldns_str2wire_dname_buf(token, rd+3, &gwlen); 263509a3aaf3SDag-Erling Smørgrav if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf)); 263609a3aaf3SDag-Erling Smørgrav } else { 263709a3aaf3SDag-Erling Smørgrav /* unknown gateway type */ 263809a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR, 263909a3aaf3SDag-Erling Smørgrav sldns_buffer_position(&strbuf)); 264009a3aaf3SDag-Erling Smørgrav } 264109a3aaf3SDag-Erling Smørgrav /* double check for size */ 264209a3aaf3SDag-Erling Smørgrav if(*len < 3 + gwlen) 264309a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL, 264409a3aaf3SDag-Erling Smørgrav sldns_buffer_position(&strbuf)); 264509a3aaf3SDag-Erling Smørgrav 264609a3aaf3SDag-Erling Smørgrav /* publickey in remainder of strbuf */ 264709a3aaf3SDag-Erling Smørgrav keylen = *len - 3 - gwlen; 264809a3aaf3SDag-Erling Smørgrav s = sldns_str2wire_b64_buf((const char*)sldns_buffer_current(&strbuf), 264909a3aaf3SDag-Erling Smørgrav rd+3+gwlen, &keylen); 265009a3aaf3SDag-Erling Smørgrav if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf)); 265109a3aaf3SDag-Erling Smørgrav 265209a3aaf3SDag-Erling Smørgrav *len = 3 + gwlen + keylen; 265309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 265409a3aaf3SDag-Erling Smørgrav } 265509a3aaf3SDag-Erling Smørgrav 265609a3aaf3SDag-Erling Smørgrav int sldns_str2wire_nsec3_salt_buf(const char* str, uint8_t* rd, size_t* len) 265709a3aaf3SDag-Erling Smørgrav { 265809a3aaf3SDag-Erling Smørgrav int i, salt_length_str = (int)strlen(str); 265909a3aaf3SDag-Erling Smørgrav if (salt_length_str == 1 && str[0] == '-') { 266009a3aaf3SDag-Erling Smørgrav salt_length_str = 0; 266109a3aaf3SDag-Erling Smørgrav } else if (salt_length_str % 2 != 0) { 266209a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_HEX; 266309a3aaf3SDag-Erling Smørgrav } 266409a3aaf3SDag-Erling Smørgrav if (salt_length_str > 512) 266509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_HEX; 266609a3aaf3SDag-Erling Smørgrav if(*len < 1+(size_t)salt_length_str / 2) 266709a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 266809a3aaf3SDag-Erling Smørgrav rd[0] = (uint8_t) (salt_length_str / 2); 266909a3aaf3SDag-Erling Smørgrav for (i = 0; i < salt_length_str; i += 2) { 267009a3aaf3SDag-Erling Smørgrav if (isxdigit((unsigned char)str[i]) && 267109a3aaf3SDag-Erling Smørgrav isxdigit((unsigned char)str[i+1])) { 267209a3aaf3SDag-Erling Smørgrav rd[1+i/2] = (uint8_t)(sldns_hexdigit_to_int(str[i])*16 267309a3aaf3SDag-Erling Smørgrav + sldns_hexdigit_to_int(str[i+1])); 267409a3aaf3SDag-Erling Smørgrav } else { 267509a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_HEX, i); 267609a3aaf3SDag-Erling Smørgrav } 267709a3aaf3SDag-Erling Smørgrav } 267809a3aaf3SDag-Erling Smørgrav *len = 1 + (size_t)rd[0]; 267909a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 268009a3aaf3SDag-Erling Smørgrav } 268109a3aaf3SDag-Erling Smørgrav 268209a3aaf3SDag-Erling Smørgrav int sldns_str2wire_ilnp64_buf(const char* str, uint8_t* rd, size_t* len) 268309a3aaf3SDag-Erling Smørgrav { 268409a3aaf3SDag-Erling Smørgrav unsigned int a, b, c, d; 268509a3aaf3SDag-Erling Smørgrav uint16_t shorts[4]; 268609a3aaf3SDag-Erling Smørgrav int l; 268709a3aaf3SDag-Erling Smørgrav if(*len < sizeof(shorts)) 268809a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 268909a3aaf3SDag-Erling Smørgrav 269009a3aaf3SDag-Erling Smørgrav if (sscanf(str, "%4x:%4x:%4x:%4x%n", &a, &b, &c, &d, &l) != 4 || 269109a3aaf3SDag-Erling Smørgrav l != (int)strlen(str) || /* more data to read */ 269209a3aaf3SDag-Erling Smørgrav strpbrk(str, "+-") /* signed hexes */ 269309a3aaf3SDag-Erling Smørgrav ) 269409a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_ILNP64; 269509a3aaf3SDag-Erling Smørgrav shorts[0] = htons(a); 269609a3aaf3SDag-Erling Smørgrav shorts[1] = htons(b); 269709a3aaf3SDag-Erling Smørgrav shorts[2] = htons(c); 269809a3aaf3SDag-Erling Smørgrav shorts[3] = htons(d); 269909a3aaf3SDag-Erling Smørgrav memmove(rd, &shorts, sizeof(shorts)); 270009a3aaf3SDag-Erling Smørgrav *len = sizeof(shorts); 270109a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 270209a3aaf3SDag-Erling Smørgrav } 270309a3aaf3SDag-Erling Smørgrav 270409a3aaf3SDag-Erling Smørgrav int sldns_str2wire_eui48_buf(const char* str, uint8_t* rd, size_t* len) 270509a3aaf3SDag-Erling Smørgrav { 270609a3aaf3SDag-Erling Smørgrav unsigned int a, b, c, d, e, f; 270709a3aaf3SDag-Erling Smørgrav int l; 270809a3aaf3SDag-Erling Smørgrav 270909a3aaf3SDag-Erling Smørgrav if(*len < 6) 271009a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 271109a3aaf3SDag-Erling Smørgrav if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x%n", 271209a3aaf3SDag-Erling Smørgrav &a, &b, &c, &d, &e, &f, &l) != 6 || 271309a3aaf3SDag-Erling Smørgrav l != (int)strlen(str)) 271409a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_EUI48; 271509a3aaf3SDag-Erling Smørgrav rd[0] = a; 271609a3aaf3SDag-Erling Smørgrav rd[1] = b; 271709a3aaf3SDag-Erling Smørgrav rd[2] = c; 271809a3aaf3SDag-Erling Smørgrav rd[3] = d; 271909a3aaf3SDag-Erling Smørgrav rd[4] = e; 272009a3aaf3SDag-Erling Smørgrav rd[5] = f; 272109a3aaf3SDag-Erling Smørgrav *len = 6; 272209a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 272309a3aaf3SDag-Erling Smørgrav } 272409a3aaf3SDag-Erling Smørgrav 272509a3aaf3SDag-Erling Smørgrav int sldns_str2wire_eui64_buf(const char* str, uint8_t* rd, size_t* len) 272609a3aaf3SDag-Erling Smørgrav { 272709a3aaf3SDag-Erling Smørgrav unsigned int a, b, c, d, e, f, g, h; 272809a3aaf3SDag-Erling Smørgrav int l; 272909a3aaf3SDag-Erling Smørgrav 273009a3aaf3SDag-Erling Smørgrav if(*len < 8) 273109a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 273209a3aaf3SDag-Erling Smørgrav if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x-%2x-%2x%n", 273309a3aaf3SDag-Erling Smørgrav &a, &b, &c, &d, &e, &f, &g, &h, &l) != 8 || 273409a3aaf3SDag-Erling Smørgrav l != (int)strlen(str)) 273509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_EUI64; 273609a3aaf3SDag-Erling Smørgrav rd[0] = a; 273709a3aaf3SDag-Erling Smørgrav rd[1] = b; 273809a3aaf3SDag-Erling Smørgrav rd[2] = c; 273909a3aaf3SDag-Erling Smørgrav rd[3] = d; 274009a3aaf3SDag-Erling Smørgrav rd[4] = e; 274109a3aaf3SDag-Erling Smørgrav rd[5] = f; 274209a3aaf3SDag-Erling Smørgrav rd[6] = g; 274309a3aaf3SDag-Erling Smørgrav rd[7] = h; 274409a3aaf3SDag-Erling Smørgrav *len = 8; 274509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 274609a3aaf3SDag-Erling Smørgrav } 274709a3aaf3SDag-Erling Smørgrav 274809a3aaf3SDag-Erling Smørgrav int sldns_str2wire_tag_buf(const char* str, uint8_t* rd, size_t* len) 274909a3aaf3SDag-Erling Smørgrav { 275009a3aaf3SDag-Erling Smørgrav size_t slen = strlen(str); 275109a3aaf3SDag-Erling Smørgrav const char* ptr; 275209a3aaf3SDag-Erling Smørgrav 275309a3aaf3SDag-Erling Smørgrav if (slen > 255) 275409a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_TAG; 275509a3aaf3SDag-Erling Smørgrav if(*len < slen+1) 275609a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 275709a3aaf3SDag-Erling Smørgrav for (ptr = str; *ptr; ptr++) { 275809a3aaf3SDag-Erling Smørgrav if(!isalnum((unsigned char)*ptr)) 275909a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_TAG, ptr-str); 276009a3aaf3SDag-Erling Smørgrav } 2761bc892140SDag-Erling Smørgrav rd[0] = (uint8_t)slen; 276209a3aaf3SDag-Erling Smørgrav memmove(rd+1, str, slen); 276309a3aaf3SDag-Erling Smørgrav *len = slen+1; 276409a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 276509a3aaf3SDag-Erling Smørgrav } 276609a3aaf3SDag-Erling Smørgrav 276709a3aaf3SDag-Erling Smørgrav int sldns_str2wire_long_str_buf(const char* str, uint8_t* rd, size_t* len) 276809a3aaf3SDag-Erling Smørgrav { 276909a3aaf3SDag-Erling Smørgrav uint8_t ch = 0; 277009a3aaf3SDag-Erling Smørgrav const char* pstr = str; 277109a3aaf3SDag-Erling Smørgrav size_t length = 0; 277209a3aaf3SDag-Erling Smørgrav 277309a3aaf3SDag-Erling Smørgrav /* Fill data with parsed bytes */ 277409a3aaf3SDag-Erling Smørgrav while (sldns_parse_char(&ch, &pstr)) { 277509a3aaf3SDag-Erling Smørgrav if(*len < length+1) 277609a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 277709a3aaf3SDag-Erling Smørgrav rd[length++] = ch; 277809a3aaf3SDag-Erling Smørgrav } 277909a3aaf3SDag-Erling Smørgrav if(!pstr) 278009a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_BAD_ESCAPE; 278109a3aaf3SDag-Erling Smørgrav *len = length; 278209a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 278309a3aaf3SDag-Erling Smørgrav } 278409a3aaf3SDag-Erling Smørgrav 278509a3aaf3SDag-Erling Smørgrav int sldns_str2wire_hip_buf(const char* str, uint8_t* rd, size_t* len) 278609a3aaf3SDag-Erling Smørgrav { 278709a3aaf3SDag-Erling Smørgrav char* s, *end; 278809a3aaf3SDag-Erling Smørgrav int e; 278909a3aaf3SDag-Erling Smørgrav size_t hitlen, pklen = 0; 279009a3aaf3SDag-Erling Smørgrav /* presentation format: 279109a3aaf3SDag-Erling Smørgrav * pk-algo HIThex pubkeybase64 279209a3aaf3SDag-Erling Smørgrav * wireformat: 279309a3aaf3SDag-Erling Smørgrav * hitlen[1byte] pkalgo[1byte] pubkeylen[2byte] [hit] [pubkey] */ 279409a3aaf3SDag-Erling Smørgrav if(*len < 4) 279509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 279609a3aaf3SDag-Erling Smørgrav 279709a3aaf3SDag-Erling Smørgrav /* read PK algorithm */ 279809a3aaf3SDag-Erling Smørgrav rd[1] = (uint8_t)strtol((char*)str, &s, 10); 279909a3aaf3SDag-Erling Smørgrav if(*s != ' ') 280009a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INT, s-(char*)str); 280109a3aaf3SDag-Erling Smørgrav s++; 280209a3aaf3SDag-Erling Smørgrav while(*s == ' ') 280309a3aaf3SDag-Erling Smørgrav s++; 280409a3aaf3SDag-Erling Smørgrav 280509a3aaf3SDag-Erling Smørgrav /* read HIT hex tag */ 280609a3aaf3SDag-Erling Smørgrav /* zero terminate the tag (replace later) */ 280709a3aaf3SDag-Erling Smørgrav end = strchr(s, ' '); 280809a3aaf3SDag-Erling Smørgrav if(!end) return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX, s-(char*)str); 280909a3aaf3SDag-Erling Smørgrav *end = 0; 281009a3aaf3SDag-Erling Smørgrav hitlen = *len - 4; 281109a3aaf3SDag-Erling Smørgrav if((e = sldns_str2wire_hex_buf(s, rd+4, &hitlen)) != 0) { 281209a3aaf3SDag-Erling Smørgrav *end = ' '; 281309a3aaf3SDag-Erling Smørgrav return RET_ERR_SHIFT(e, s-(char*)str); 281409a3aaf3SDag-Erling Smørgrav } 281509a3aaf3SDag-Erling Smørgrav if(hitlen > 255) { 281609a3aaf3SDag-Erling Smørgrav *end = ' '; 281709a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_LABEL_OVERFLOW, s-(char*)str+255*2); 281809a3aaf3SDag-Erling Smørgrav } 281909a3aaf3SDag-Erling Smørgrav rd[0] = (uint8_t)hitlen; 282009a3aaf3SDag-Erling Smørgrav *end = ' '; 282109a3aaf3SDag-Erling Smørgrav s = end+1; 282209a3aaf3SDag-Erling Smørgrav 282309a3aaf3SDag-Erling Smørgrav /* read pubkey base64 sequence */ 282409a3aaf3SDag-Erling Smørgrav pklen = *len - 4 - hitlen; 282509a3aaf3SDag-Erling Smørgrav if((e = sldns_str2wire_b64_buf(s, rd+4+hitlen, &pklen)) != 0) 282609a3aaf3SDag-Erling Smørgrav return RET_ERR_SHIFT(e, s-(char*)str); 282709a3aaf3SDag-Erling Smørgrav if(pklen > 65535) 282809a3aaf3SDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_LABEL_OVERFLOW, s-(char*)str+65535); 2829bc892140SDag-Erling Smørgrav sldns_write_uint16(rd+2, (uint16_t)pklen); 283009a3aaf3SDag-Erling Smørgrav 283109a3aaf3SDag-Erling Smørgrav *len = 4 + hitlen + pklen; 283209a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 283309a3aaf3SDag-Erling Smørgrav } 283409a3aaf3SDag-Erling Smørgrav 283509a3aaf3SDag-Erling Smørgrav int sldns_str2wire_int16_data_buf(const char* str, uint8_t* rd, size_t* len) 283609a3aaf3SDag-Erling Smørgrav { 2837c7f4d7adSDag-Erling Smørgrav char* s; 283809a3aaf3SDag-Erling Smørgrav int n; 2839c7f4d7adSDag-Erling Smørgrav n = strtol(str, &s, 10); 28400eefd307SCy Schubert if(n < 0) /* negative number not allowed */ 28410eefd307SCy Schubert return LDNS_WIREPARSE_ERR_SYNTAX; 2842c7f4d7adSDag-Erling Smørgrav if(*len < ((size_t)n)+2) 284309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL; 2844c7f4d7adSDag-Erling Smørgrav if(n > 65535) 284509a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_LABEL_OVERFLOW; 2846c7f4d7adSDag-Erling Smørgrav 2847c7f4d7adSDag-Erling Smørgrav if(n == 0) { 2848c7f4d7adSDag-Erling Smørgrav sldns_write_uint16(rd, 0); 2849c7f4d7adSDag-Erling Smørgrav *len = 2; 2850c7f4d7adSDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 2851c7f4d7adSDag-Erling Smørgrav } 2852c7f4d7adSDag-Erling Smørgrav if(*s != ' ') 2853c7f4d7adSDag-Erling Smørgrav return RET_ERR(LDNS_WIREPARSE_ERR_SYNTAX_INT, s-(char*)str); 2854c7f4d7adSDag-Erling Smørgrav s++; 2855c7f4d7adSDag-Erling Smørgrav while(*s == ' ') 2856c7f4d7adSDag-Erling Smørgrav s++; 2857c7f4d7adSDag-Erling Smørgrav 2858c7f4d7adSDag-Erling Smørgrav n = sldns_b64_pton(s, rd+2, (*len)-2); 285909a3aaf3SDag-Erling Smørgrav if(n < 0) 286009a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_SYNTAX_B64; 286109a3aaf3SDag-Erling Smørgrav sldns_write_uint16(rd, (uint16_t)n); 2862c7f4d7adSDag-Erling Smørgrav *len = ((size_t)n)+2; 286309a3aaf3SDag-Erling Smørgrav return LDNS_WIREPARSE_ERR_OK; 286409a3aaf3SDag-Erling Smørgrav } 2865