1825eb42bSJan Lentfer /*
2825eb42bSJan Lentfer * str2host.c
3825eb42bSJan Lentfer *
4825eb42bSJan Lentfer * conversion routines from the presentation format
5825eb42bSJan Lentfer * to the host format
6825eb42bSJan Lentfer *
7825eb42bSJan Lentfer * a Net::DNS like library for C
8825eb42bSJan Lentfer *
9825eb42bSJan Lentfer * (c) NLnet Labs, 2004-2006
10825eb42bSJan Lentfer *
11825eb42bSJan Lentfer * See the file LICENSE for the license
12825eb42bSJan Lentfer */
13825eb42bSJan Lentfer #include <ldns/config.h>
14825eb42bSJan Lentfer
15825eb42bSJan Lentfer #include <ldns/ldns.h>
16825eb42bSJan Lentfer
17825eb42bSJan Lentfer #ifdef HAVE_SYS_SOCKET_H
18825eb42bSJan Lentfer #include <sys/socket.h>
19825eb42bSJan Lentfer #endif
20825eb42bSJan Lentfer #ifdef HAVE_ARPA_INET_H
21825eb42bSJan Lentfer #include <arpa/inet.h>
22825eb42bSJan Lentfer #endif
23825eb42bSJan Lentfer #include <time.h>
24825eb42bSJan Lentfer
25825eb42bSJan Lentfer #include <errno.h>
26825eb42bSJan Lentfer #ifdef HAVE_NETDB_H
27825eb42bSJan Lentfer #include <netdb.h>
28825eb42bSJan Lentfer #endif
29825eb42bSJan Lentfer
30825eb42bSJan Lentfer #include <limits.h>
31825eb42bSJan Lentfer #ifdef HAVE_SYS_PARAM_H
32825eb42bSJan Lentfer #include <sys/param.h>
33825eb42bSJan Lentfer #endif
34825eb42bSJan Lentfer
35825eb42bSJan Lentfer ldns_status
ldns_str2rdf_int16(ldns_rdf ** rd,const char * shortstr)36825eb42bSJan Lentfer ldns_str2rdf_int16(ldns_rdf **rd, const char *shortstr)
37825eb42bSJan Lentfer {
38825eb42bSJan Lentfer char *end = NULL;
39825eb42bSJan Lentfer uint16_t *r;
40825eb42bSJan Lentfer r = LDNS_MALLOC(uint16_t);
41fd185f4dSJan Lentfer if(!r) return LDNS_STATUS_MEM_ERR;
42825eb42bSJan Lentfer
43825eb42bSJan Lentfer *r = htons((uint16_t)strtol((char *)shortstr, &end, 10));
44825eb42bSJan Lentfer
45825eb42bSJan Lentfer if(*end != 0) {
46825eb42bSJan Lentfer LDNS_FREE(r);
47825eb42bSJan Lentfer return LDNS_STATUS_INVALID_INT;
48825eb42bSJan Lentfer } else {
49825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(
50825eb42bSJan Lentfer LDNS_RDF_TYPE_INT16, sizeof(uint16_t), r);
51825eb42bSJan Lentfer LDNS_FREE(r);
52fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
53825eb42bSJan Lentfer }
54825eb42bSJan Lentfer }
55825eb42bSJan Lentfer
56825eb42bSJan Lentfer ldns_status
ldns_str2rdf_time(ldns_rdf ** rd,const char * time)57825eb42bSJan Lentfer ldns_str2rdf_time(ldns_rdf **rd, const char *time)
58825eb42bSJan Lentfer {
59825eb42bSJan Lentfer /* convert a time YYYYDDMMHHMMSS to wireformat */
60819dec71SDaniel Fojt uint32_t *r = NULL;
61825eb42bSJan Lentfer struct tm tm;
62825eb42bSJan Lentfer uint32_t l;
63825eb42bSJan Lentfer char *end;
64825eb42bSJan Lentfer
65825eb42bSJan Lentfer /* Try to scan the time... */
66819dec71SDaniel Fojt r = (uint32_t *)LDNS_MALLOC(uint32_t);
67fd185f4dSJan Lentfer if(!r) return LDNS_STATUS_MEM_ERR;
68825eb42bSJan Lentfer
69825eb42bSJan Lentfer memset(&tm, 0, sizeof(tm));
70825eb42bSJan Lentfer
71825eb42bSJan Lentfer if (strlen(time) == 14 &&
72825eb42bSJan Lentfer sscanf(time, "%4d%2d%2d%2d%2d%2d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec) == 6
73825eb42bSJan Lentfer ) {
74825eb42bSJan Lentfer tm.tm_year -= 1900;
75825eb42bSJan Lentfer tm.tm_mon--;
76825eb42bSJan Lentfer /* Check values */
77825eb42bSJan Lentfer if (tm.tm_year < 70) {
78825eb42bSJan Lentfer goto bad_format;
79825eb42bSJan Lentfer }
80825eb42bSJan Lentfer if (tm.tm_mon < 0 || tm.tm_mon > 11) {
81825eb42bSJan Lentfer goto bad_format;
82825eb42bSJan Lentfer }
83825eb42bSJan Lentfer if (tm.tm_mday < 1 || tm.tm_mday > 31) {
84825eb42bSJan Lentfer goto bad_format;
85825eb42bSJan Lentfer }
86825eb42bSJan Lentfer
87825eb42bSJan Lentfer if (tm.tm_hour < 0 || tm.tm_hour > 23) {
88825eb42bSJan Lentfer goto bad_format;
89825eb42bSJan Lentfer }
90825eb42bSJan Lentfer
91825eb42bSJan Lentfer if (tm.tm_min < 0 || tm.tm_min > 59) {
92825eb42bSJan Lentfer goto bad_format;
93825eb42bSJan Lentfer }
94825eb42bSJan Lentfer
95825eb42bSJan Lentfer if (tm.tm_sec < 0 || tm.tm_sec > 59) {
96825eb42bSJan Lentfer goto bad_format;
97825eb42bSJan Lentfer }
98825eb42bSJan Lentfer
99d1b2b5caSJohn Marino l = htonl(ldns_mktime_from_utc(&tm));
100825eb42bSJan Lentfer memcpy(r, &l, sizeof(uint32_t));
101825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(
102825eb42bSJan Lentfer LDNS_RDF_TYPE_TIME, sizeof(uint32_t), r);
103825eb42bSJan Lentfer LDNS_FREE(r);
104fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
105825eb42bSJan Lentfer } else {
106825eb42bSJan Lentfer /* handle it as 32 bits timestamp */
107825eb42bSJan Lentfer l = htonl((uint32_t)strtol((char*)time, &end, 10));
108825eb42bSJan Lentfer if(*end != 0) {
109825eb42bSJan Lentfer LDNS_FREE(r);
110825eb42bSJan Lentfer return LDNS_STATUS_ERR;
111825eb42bSJan Lentfer } else {
112825eb42bSJan Lentfer memcpy(r, &l, sizeof(uint32_t));
113825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(
114825eb42bSJan Lentfer LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r);
115825eb42bSJan Lentfer LDNS_FREE(r);
116fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
117825eb42bSJan Lentfer }
118825eb42bSJan Lentfer }
119825eb42bSJan Lentfer
120825eb42bSJan Lentfer bad_format:
121825eb42bSJan Lentfer LDNS_FREE(r);
122825eb42bSJan Lentfer return LDNS_STATUS_INVALID_TIME;
123825eb42bSJan Lentfer }
124825eb42bSJan Lentfer
125825eb42bSJan Lentfer ldns_status
ldns_str2rdf_nsec3_salt(ldns_rdf ** rd,const char * salt_str)126825eb42bSJan Lentfer ldns_str2rdf_nsec3_salt(ldns_rdf **rd, const char *salt_str)
127825eb42bSJan Lentfer {
128825eb42bSJan Lentfer uint8_t salt_length;
129825eb42bSJan Lentfer int c;
130825eb42bSJan Lentfer int salt_length_str;
131825eb42bSJan Lentfer
132825eb42bSJan Lentfer uint8_t *salt;
133825eb42bSJan Lentfer uint8_t *data;
134fd185f4dSJan Lentfer if(rd == NULL) {
135fd185f4dSJan Lentfer return LDNS_STATUS_NULL;
136fd185f4dSJan Lentfer }
137825eb42bSJan Lentfer
138fd185f4dSJan Lentfer salt_length_str = (int)strlen(salt_str);
139825eb42bSJan Lentfer if (salt_length_str == 1 && salt_str[0] == '-') {
140825eb42bSJan Lentfer salt_length_str = 0;
141825eb42bSJan Lentfer } else if (salt_length_str % 2 != 0) {
142825eb42bSJan Lentfer return LDNS_STATUS_INVALID_HEX;
143825eb42bSJan Lentfer }
144825eb42bSJan Lentfer if (salt_length_str > 512) {
145825eb42bSJan Lentfer return LDNS_STATUS_INVALID_HEX;
146825eb42bSJan Lentfer }
147825eb42bSJan Lentfer
148825eb42bSJan Lentfer salt = LDNS_XMALLOC(uint8_t, salt_length_str / 2);
149fd185f4dSJan Lentfer if(!salt) {
150fd185f4dSJan Lentfer return LDNS_STATUS_MEM_ERR;
151fd185f4dSJan Lentfer }
152825eb42bSJan Lentfer for (c = 0; c < salt_length_str; c += 2) {
153825eb42bSJan Lentfer if (isxdigit((int) salt_str[c]) && isxdigit((int) salt_str[c+1])) {
154825eb42bSJan Lentfer salt[c/2] = (uint8_t) ldns_hexdigit_to_int(salt_str[c]) * 16 +
155825eb42bSJan Lentfer ldns_hexdigit_to_int(salt_str[c+1]);
156825eb42bSJan Lentfer } else {
157825eb42bSJan Lentfer LDNS_FREE(salt);
158825eb42bSJan Lentfer return LDNS_STATUS_INVALID_HEX;
159825eb42bSJan Lentfer }
160825eb42bSJan Lentfer }
161825eb42bSJan Lentfer salt_length = (uint8_t) (salt_length_str / 2);
162825eb42bSJan Lentfer
163825eb42bSJan Lentfer data = LDNS_XMALLOC(uint8_t, 1 + salt_length);
164fd185f4dSJan Lentfer if(!data) {
165fd185f4dSJan Lentfer LDNS_FREE(salt);
166fd185f4dSJan Lentfer return LDNS_STATUS_MEM_ERR;
167fd185f4dSJan Lentfer }
168825eb42bSJan Lentfer data[0] = salt_length;
169825eb42bSJan Lentfer memcpy(&data[1], salt, salt_length);
170825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_NSEC3_SALT, 1 + salt_length, data);
171825eb42bSJan Lentfer LDNS_FREE(data);
172825eb42bSJan Lentfer LDNS_FREE(salt);
173825eb42bSJan Lentfer
174fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
175825eb42bSJan Lentfer }
176825eb42bSJan Lentfer
177825eb42bSJan Lentfer ldns_status
ldns_str2rdf_period(ldns_rdf ** rd,const char * period)178825eb42bSJan Lentfer ldns_str2rdf_period(ldns_rdf **rd,const char *period)
179825eb42bSJan Lentfer {
180825eb42bSJan Lentfer uint32_t p;
181825eb42bSJan Lentfer const char *end;
182825eb42bSJan Lentfer
183825eb42bSJan Lentfer /* Allocate required space... */
184825eb42bSJan Lentfer p = ldns_str2period(period, &end);
185825eb42bSJan Lentfer
186825eb42bSJan Lentfer if (*end != 0) {
187825eb42bSJan Lentfer return LDNS_STATUS_ERR;
188825eb42bSJan Lentfer } else {
189825eb42bSJan Lentfer p = (uint32_t) htonl(p);
190825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(
191825eb42bSJan Lentfer LDNS_RDF_TYPE_PERIOD, sizeof(uint32_t), &p);
192825eb42bSJan Lentfer }
193fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
194825eb42bSJan Lentfer }
195825eb42bSJan Lentfer
196825eb42bSJan Lentfer ldns_status
ldns_str2rdf_int32(ldns_rdf ** rd,const char * longstr)197825eb42bSJan Lentfer ldns_str2rdf_int32(ldns_rdf **rd, const char *longstr)
198825eb42bSJan Lentfer {
199825eb42bSJan Lentfer char *end;
200819dec71SDaniel Fojt uint32_t *r = NULL;
201825eb42bSJan Lentfer uint32_t l;
202825eb42bSJan Lentfer
203819dec71SDaniel Fojt r = (uint32_t*)LDNS_MALLOC(uint32_t);
204fd185f4dSJan Lentfer if(!r) return LDNS_STATUS_MEM_ERR;
205825eb42bSJan Lentfer errno = 0; /* must set to zero before call,
206825eb42bSJan Lentfer note race condition on errno */
207825eb42bSJan Lentfer if(*longstr == '-')
208825eb42bSJan Lentfer l = htonl((uint32_t)strtol((char*)longstr, &end, 10));
209825eb42bSJan Lentfer else l = htonl((uint32_t)strtoul((char*)longstr, &end, 10));
210825eb42bSJan Lentfer
211825eb42bSJan Lentfer if(*end != 0) {
212825eb42bSJan Lentfer LDNS_FREE(r);
213825eb42bSJan Lentfer return LDNS_STATUS_ERR;
214825eb42bSJan Lentfer } else {
215825eb42bSJan Lentfer if (errno == ERANGE) {
216825eb42bSJan Lentfer LDNS_FREE(r);
217825eb42bSJan Lentfer return LDNS_STATUS_SYNTAX_INTEGER_OVERFLOW;
218825eb42bSJan Lentfer }
219825eb42bSJan Lentfer memcpy(r, &l, sizeof(uint32_t));
220825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(
221825eb42bSJan Lentfer LDNS_RDF_TYPE_INT32, sizeof(uint32_t), r);
222825eb42bSJan Lentfer LDNS_FREE(r);
223fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
224825eb42bSJan Lentfer }
225825eb42bSJan Lentfer }
226825eb42bSJan Lentfer
227825eb42bSJan Lentfer ldns_status
ldns_str2rdf_int8(ldns_rdf ** rd,const char * bytestr)228825eb42bSJan Lentfer ldns_str2rdf_int8(ldns_rdf **rd, const char *bytestr)
229825eb42bSJan Lentfer {
230825eb42bSJan Lentfer char *end;
231825eb42bSJan Lentfer uint8_t *r = NULL;
232825eb42bSJan Lentfer
233825eb42bSJan Lentfer r = LDNS_MALLOC(uint8_t);
234fd185f4dSJan Lentfer if(!r) return LDNS_STATUS_MEM_ERR;
235825eb42bSJan Lentfer
236825eb42bSJan Lentfer *r = (uint8_t)strtol((char*)bytestr, &end, 10);
237825eb42bSJan Lentfer
238825eb42bSJan Lentfer if(*end != 0) {
239825eb42bSJan Lentfer LDNS_FREE(r);
240825eb42bSJan Lentfer return LDNS_STATUS_ERR;
241825eb42bSJan Lentfer } else {
242825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(
243825eb42bSJan Lentfer LDNS_RDF_TYPE_INT8, sizeof(uint8_t), r);
244825eb42bSJan Lentfer LDNS_FREE(r);
245fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
246825eb42bSJan Lentfer }
247825eb42bSJan Lentfer }
248825eb42bSJan Lentfer
249825eb42bSJan Lentfer
250825eb42bSJan Lentfer /*
2515340022aSzrj * Checks whether the escaped value at **s is an decimal value or
252825eb42bSJan Lentfer * a 'normally' escaped character (and not eos)
253825eb42bSJan Lentfer *
254825eb42bSJan Lentfer * The string pointer at *s is increased by either 0 (on error), 1 (on
2555340022aSzrj * normal escapes), or 3 (on decimals)
256825eb42bSJan Lentfer *
257825eb42bSJan Lentfer * Returns the number of bytes read from the escaped string, or
258825eb42bSJan Lentfer * 0 on error
259825eb42bSJan Lentfer */
2605340022aSzrj INLINE bool
parse_escape(uint8_t * ch_p,const char ** str_p)2615340022aSzrj parse_escape(uint8_t *ch_p, const char** str_p)
2625340022aSzrj {
263d1b2b5caSJohn Marino uint16_t val;
2645340022aSzrj
2655340022aSzrj if ((*str_p)[0] && isdigit((unsigned char)(*str_p)[0]) &&
2665340022aSzrj (*str_p)[1] && isdigit((unsigned char)(*str_p)[1]) &&
2675340022aSzrj (*str_p)[2] && isdigit((unsigned char)(*str_p)[2])) {
2685340022aSzrj
2695340022aSzrj val = (uint16_t)(((*str_p)[0] - '0') * 100 +
2705340022aSzrj ((*str_p)[1] - '0') * 10 +
2715340022aSzrj ((*str_p)[2] - '0'));
2725340022aSzrj
273d1b2b5caSJohn Marino if (val > 255) {
2745340022aSzrj goto error;
275d1b2b5caSJohn Marino }
2765340022aSzrj *ch_p = (uint8_t)val;
2775340022aSzrj *str_p += 3;
2785340022aSzrj return true;
2795340022aSzrj
2805340022aSzrj } else if ((*str_p)[0] && !isdigit((unsigned char)(*str_p)[0])) {
2815340022aSzrj
2825340022aSzrj *ch_p = (uint8_t)*(*str_p)++;
2835340022aSzrj return true;
284825eb42bSJan Lentfer }
2855340022aSzrj error:
2865340022aSzrj *str_p = NULL;
2875340022aSzrj return false; /* LDNS_STATUS_SYNTAX_BAD_ESCAPE */
2885340022aSzrj }
2895340022aSzrj
2905340022aSzrj INLINE bool
parse_char(uint8_t * ch_p,const char ** str_p)2915340022aSzrj parse_char(uint8_t *ch_p, const char** str_p)
2925340022aSzrj {
2935340022aSzrj switch (**str_p) {
2945340022aSzrj
2955340022aSzrj case '\0': return false;
2965340022aSzrj
2975340022aSzrj case '\\': *str_p += 1;
2985340022aSzrj return parse_escape(ch_p, str_p);
2995340022aSzrj
3005340022aSzrj default: *ch_p = (uint8_t)*(*str_p)++;
3015340022aSzrj return true;
302825eb42bSJan Lentfer }
303825eb42bSJan Lentfer }
304825eb42bSJan Lentfer
305825eb42bSJan Lentfer /*
306825eb42bSJan Lentfer * No special care is taken, all dots are translated into
307*ee791febSAntonio Huete Jimenez * label separators.
308825eb42bSJan Lentfer * Could be made more efficient....we do 3 memcpy's in total...
309825eb42bSJan Lentfer */
310825eb42bSJan Lentfer ldns_status
ldns_str2rdf_dname(ldns_rdf ** d,const char * str)311825eb42bSJan Lentfer ldns_str2rdf_dname(ldns_rdf **d, const char *str)
312825eb42bSJan Lentfer {
313825eb42bSJan Lentfer size_t len;
314825eb42bSJan Lentfer
3155340022aSzrj const char *s;
3165340022aSzrj uint8_t *q, *pq, label_len;
317825eb42bSJan Lentfer uint8_t buf[LDNS_MAX_DOMAINLEN + 1];
318825eb42bSJan Lentfer *d = NULL;
319825eb42bSJan Lentfer
320825eb42bSJan Lentfer len = strlen((char*)str);
321825eb42bSJan Lentfer /* octet representation can make strings a lot longer than actual length */
322825eb42bSJan Lentfer if (len > LDNS_MAX_DOMAINLEN * 4) {
323825eb42bSJan Lentfer return LDNS_STATUS_DOMAINNAME_OVERFLOW;
324825eb42bSJan Lentfer }
325825eb42bSJan Lentfer if (0 == len) {
326825eb42bSJan Lentfer return LDNS_STATUS_DOMAINNAME_UNDERFLOW;
327825eb42bSJan Lentfer }
328825eb42bSJan Lentfer
329825eb42bSJan Lentfer /* root label */
330825eb42bSJan Lentfer if (1 == len && *str == '.') {
331825eb42bSJan Lentfer *d = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, 1, "\0");
332825eb42bSJan Lentfer return LDNS_STATUS_OK;
333825eb42bSJan Lentfer }
334825eb42bSJan Lentfer
335825eb42bSJan Lentfer /* get on with the rest */
336825eb42bSJan Lentfer
337ac996e71SJan Lentfer /* s is on the current character in the string
338ac996e71SJan Lentfer * pq points to where the labellength is going to go
339ac996e71SJan Lentfer * label_len keeps track of the current label's length
340ac996e71SJan Lentfer * q builds the dname inside the buf array
341825eb42bSJan Lentfer */
342825eb42bSJan Lentfer len = 0;
343825eb42bSJan Lentfer q = buf+1;
344825eb42bSJan Lentfer pq = buf;
345825eb42bSJan Lentfer label_len = 0;
3465340022aSzrj for (s = str; *s; s++, q++) {
347*ee791febSAntonio Huete Jimenez if (q >= buf + LDNS_MAX_DOMAINLEN) {
348825eb42bSJan Lentfer return LDNS_STATUS_DOMAINNAME_OVERFLOW;
349825eb42bSJan Lentfer }
350825eb42bSJan Lentfer *q = 0;
351825eb42bSJan Lentfer switch (*s) {
352825eb42bSJan Lentfer case '.':
353825eb42bSJan Lentfer if (label_len > LDNS_MAX_LABELLEN) {
354825eb42bSJan Lentfer return LDNS_STATUS_LABEL_OVERFLOW;
355825eb42bSJan Lentfer }
356825eb42bSJan Lentfer if (label_len == 0) {
357825eb42bSJan Lentfer return LDNS_STATUS_EMPTY_LABEL;
358825eb42bSJan Lentfer }
359825eb42bSJan Lentfer len += label_len + 1;
360825eb42bSJan Lentfer *pq = label_len;
361825eb42bSJan Lentfer label_len = 0;
362825eb42bSJan Lentfer pq = q;
363825eb42bSJan Lentfer break;
364825eb42bSJan Lentfer case '\\':
365825eb42bSJan Lentfer /* octet value or literal char */
3665340022aSzrj s += 1;
3675340022aSzrj if (! parse_escape(q, &s)) {
368825eb42bSJan Lentfer return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
369825eb42bSJan Lentfer }
3705340022aSzrj s -= 1;
3715340022aSzrj label_len++;
372825eb42bSJan Lentfer break;
373825eb42bSJan Lentfer default:
3745340022aSzrj *q = (uint8_t)*s;
375825eb42bSJan Lentfer label_len++;
376825eb42bSJan Lentfer }
377825eb42bSJan Lentfer }
378825eb42bSJan Lentfer
379825eb42bSJan Lentfer /* add root label if last char was not '.' */
380825eb42bSJan Lentfer if (!ldns_dname_str_absolute(str)) {
381*ee791febSAntonio Huete Jimenez if (q >= buf + LDNS_MAX_DOMAINLEN) {
382825eb42bSJan Lentfer return LDNS_STATUS_DOMAINNAME_OVERFLOW;
383825eb42bSJan Lentfer }
384ac996e71SJan Lentfer if (label_len > LDNS_MAX_LABELLEN) {
385ac996e71SJan Lentfer return LDNS_STATUS_LABEL_OVERFLOW;
386ac996e71SJan Lentfer }
387ac996e71SJan Lentfer if (label_len == 0) { /* label_len 0 but not . at end? */
388ac996e71SJan Lentfer return LDNS_STATUS_EMPTY_LABEL;
389ac996e71SJan Lentfer }
390825eb42bSJan Lentfer len += label_len + 1;
391825eb42bSJan Lentfer *pq = label_len;
392825eb42bSJan Lentfer *q = 0;
393825eb42bSJan Lentfer }
394825eb42bSJan Lentfer len++;
395825eb42bSJan Lentfer
396825eb42bSJan Lentfer *d = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME, len, buf);
397825eb42bSJan Lentfer return LDNS_STATUS_OK;
398825eb42bSJan Lentfer }
399825eb42bSJan Lentfer
400825eb42bSJan Lentfer ldns_status
ldns_str2rdf_a(ldns_rdf ** rd,const char * str)401825eb42bSJan Lentfer ldns_str2rdf_a(ldns_rdf **rd, const char *str)
402825eb42bSJan Lentfer {
403825eb42bSJan Lentfer in_addr_t address;
404825eb42bSJan Lentfer if (inet_pton(AF_INET, (char*)str, &address) != 1) {
405825eb42bSJan Lentfer return LDNS_STATUS_INVALID_IP4;
406825eb42bSJan Lentfer } else {
407825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(
408825eb42bSJan Lentfer LDNS_RDF_TYPE_A, sizeof(address), &address);
409825eb42bSJan Lentfer }
410fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
411825eb42bSJan Lentfer }
412825eb42bSJan Lentfer
413825eb42bSJan Lentfer ldns_status
ldns_str2rdf_aaaa(ldns_rdf ** rd,const char * str)414825eb42bSJan Lentfer ldns_str2rdf_aaaa(ldns_rdf **rd, const char *str)
415825eb42bSJan Lentfer {
416825eb42bSJan Lentfer uint8_t address[LDNS_IP6ADDRLEN + 1];
417825eb42bSJan Lentfer
418825eb42bSJan Lentfer if (inet_pton(AF_INET6, (char*)str, address) != 1) {
419825eb42bSJan Lentfer return LDNS_STATUS_INVALID_IP6;
420825eb42bSJan Lentfer } else {
421825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(
422825eb42bSJan Lentfer LDNS_RDF_TYPE_AAAA, sizeof(address) - 1, &address);
423825eb42bSJan Lentfer }
424fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
425825eb42bSJan Lentfer }
426825eb42bSJan Lentfer
427825eb42bSJan Lentfer ldns_status
ldns_str2rdf_str(ldns_rdf ** rd,const char * str)428825eb42bSJan Lentfer ldns_str2rdf_str(ldns_rdf **rd, const char *str)
429825eb42bSJan Lentfer {
4305340022aSzrj uint8_t *data, *dp, ch = 0;
4315340022aSzrj size_t length;
432825eb42bSJan Lentfer
4335340022aSzrj /* Worst case space requirement. We'll realloc to actual size later. */
4345340022aSzrj dp = data = LDNS_XMALLOC(uint8_t, strlen(str) > 255 ? 256 : (strlen(str) + 1));
4355340022aSzrj if (! data) {
4365340022aSzrj return LDNS_STATUS_MEM_ERR;
4375340022aSzrj }
4385340022aSzrj
4395340022aSzrj /* Fill data (up to 255 characters) */
4405340022aSzrj while (parse_char(&ch, &str)) {
4415340022aSzrj if (dp - data >= 255) {
4425340022aSzrj LDNS_FREE(data);
443825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
444825eb42bSJan Lentfer }
4455340022aSzrj *++dp = ch;
4465340022aSzrj }
4475340022aSzrj if (! str) {
448819dec71SDaniel Fojt LDNS_FREE(data);
449ac996e71SJan Lentfer return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
450ac996e71SJan Lentfer }
4515340022aSzrj length = (size_t)(dp - data);
4525340022aSzrj /* Fix last length byte */
4535340022aSzrj data[0] = (uint8_t)length;
454fd185f4dSJan Lentfer
4555340022aSzrj /* Lose the overmeasure */
4565340022aSzrj data = LDNS_XREALLOC(dp = data, uint8_t, length + 1);
4575340022aSzrj if (! data) {
4585340022aSzrj LDNS_FREE(dp);
4595340022aSzrj return LDNS_STATUS_MEM_ERR;
4605340022aSzrj }
4615340022aSzrj
4625340022aSzrj /* Create rdf */
4635340022aSzrj *rd = ldns_rdf_new(LDNS_RDF_TYPE_STR, length + 1, data);
4645340022aSzrj if (! *rd) {
465825eb42bSJan Lentfer LDNS_FREE(data);
4665340022aSzrj return LDNS_STATUS_MEM_ERR;
4675340022aSzrj }
4685340022aSzrj return LDNS_STATUS_OK;
469825eb42bSJan Lentfer }
470825eb42bSJan Lentfer
471825eb42bSJan Lentfer ldns_status
ldns_str2rdf_apl(ldns_rdf ** rd,const char * str)472825eb42bSJan Lentfer ldns_str2rdf_apl(ldns_rdf **rd, const char *str)
473825eb42bSJan Lentfer {
474825eb42bSJan Lentfer const char *my_str = str;
475825eb42bSJan Lentfer
476825eb42bSJan Lentfer char *my_ip_str;
477825eb42bSJan Lentfer size_t ip_str_len;
478825eb42bSJan Lentfer
479825eb42bSJan Lentfer uint16_t family;
480825eb42bSJan Lentfer bool negation;
481825eb42bSJan Lentfer uint8_t afdlength = 0;
482825eb42bSJan Lentfer uint8_t *afdpart;
483825eb42bSJan Lentfer uint8_t prefix;
484825eb42bSJan Lentfer
485825eb42bSJan Lentfer uint8_t *data;
486825eb42bSJan Lentfer
487825eb42bSJan Lentfer size_t i = 0;
488825eb42bSJan Lentfer
489825eb42bSJan Lentfer /* [!]afi:address/prefix */
490b5dedccaSJan Lentfer if (strlen(my_str) < 2
491b5dedccaSJan Lentfer || strchr(my_str, ':') == NULL
492b5dedccaSJan Lentfer || strchr(my_str, '/') == NULL
493b5dedccaSJan Lentfer || strchr(my_str, ':') > strchr(my_str, '/')) {
494825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
495825eb42bSJan Lentfer }
496825eb42bSJan Lentfer
497825eb42bSJan Lentfer if (my_str[0] == '!') {
498825eb42bSJan Lentfer negation = true;
499825eb42bSJan Lentfer my_str += 1;
500825eb42bSJan Lentfer } else {
501825eb42bSJan Lentfer negation = false;
502825eb42bSJan Lentfer }
503825eb42bSJan Lentfer
504825eb42bSJan Lentfer family = (uint16_t) atoi(my_str);
505825eb42bSJan Lentfer
506825eb42bSJan Lentfer my_str = strchr(my_str, ':') + 1;
507825eb42bSJan Lentfer
508825eb42bSJan Lentfer /* need ip addr and only ip addr for inet_pton */
509825eb42bSJan Lentfer ip_str_len = (size_t) (strchr(my_str, '/') - my_str);
510825eb42bSJan Lentfer my_ip_str = LDNS_XMALLOC(char, ip_str_len + 1);
511fd185f4dSJan Lentfer if(!my_ip_str) return LDNS_STATUS_MEM_ERR;
512825eb42bSJan Lentfer strncpy(my_ip_str, my_str, ip_str_len + 1);
513825eb42bSJan Lentfer my_ip_str[ip_str_len] = '\0';
514825eb42bSJan Lentfer
515825eb42bSJan Lentfer if (family == 1) {
516825eb42bSJan Lentfer /* ipv4 */
517825eb42bSJan Lentfer afdpart = LDNS_XMALLOC(uint8_t, 4);
518fd185f4dSJan Lentfer if(!afdpart) {
519fd185f4dSJan Lentfer LDNS_FREE(my_ip_str);
520fd185f4dSJan Lentfer return LDNS_STATUS_MEM_ERR;
521fd185f4dSJan Lentfer }
522825eb42bSJan Lentfer if (inet_pton(AF_INET, my_ip_str, afdpart) == 0) {
523fd185f4dSJan Lentfer LDNS_FREE(my_ip_str);
524fd185f4dSJan Lentfer LDNS_FREE(afdpart);
525825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
526825eb42bSJan Lentfer }
527825eb42bSJan Lentfer for (i = 0; i < 4; i++) {
528825eb42bSJan Lentfer if (afdpart[i] != 0) {
529825eb42bSJan Lentfer afdlength = i + 1;
530825eb42bSJan Lentfer }
531825eb42bSJan Lentfer }
532825eb42bSJan Lentfer } else if (family == 2) {
533825eb42bSJan Lentfer /* ipv6 */
534825eb42bSJan Lentfer afdpart = LDNS_XMALLOC(uint8_t, 16);
535fd185f4dSJan Lentfer if(!afdpart) {
536fd185f4dSJan Lentfer LDNS_FREE(my_ip_str);
537fd185f4dSJan Lentfer return LDNS_STATUS_MEM_ERR;
538fd185f4dSJan Lentfer }
539825eb42bSJan Lentfer if (inet_pton(AF_INET6, my_ip_str, afdpart) == 0) {
540fd185f4dSJan Lentfer LDNS_FREE(my_ip_str);
541fd185f4dSJan Lentfer LDNS_FREE(afdpart);
542825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
543825eb42bSJan Lentfer }
544825eb42bSJan Lentfer for (i = 0; i < 16; i++) {
545825eb42bSJan Lentfer if (afdpart[i] != 0) {
546825eb42bSJan Lentfer afdlength = i + 1;
547825eb42bSJan Lentfer }
548825eb42bSJan Lentfer }
549825eb42bSJan Lentfer } else {
550825eb42bSJan Lentfer /* unknown family */
551825eb42bSJan Lentfer LDNS_FREE(my_ip_str);
552825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
553825eb42bSJan Lentfer }
554825eb42bSJan Lentfer
555825eb42bSJan Lentfer my_str = strchr(my_str, '/') + 1;
556825eb42bSJan Lentfer prefix = (uint8_t) atoi(my_str);
557825eb42bSJan Lentfer
558825eb42bSJan Lentfer data = LDNS_XMALLOC(uint8_t, 4 + afdlength);
559fd185f4dSJan Lentfer if(!data) {
560d1b2b5caSJohn Marino LDNS_FREE(afdpart);
561fd185f4dSJan Lentfer LDNS_FREE(my_ip_str);
562fd185f4dSJan Lentfer return LDNS_STATUS_INVALID_STR;
563fd185f4dSJan Lentfer }
564825eb42bSJan Lentfer ldns_write_uint16(data, family);
565825eb42bSJan Lentfer data[2] = prefix;
566825eb42bSJan Lentfer data[3] = afdlength;
567825eb42bSJan Lentfer if (negation) {
568825eb42bSJan Lentfer /* set bit 1 of byte 3 */
569825eb42bSJan Lentfer data[3] = data[3] | 0x80;
570825eb42bSJan Lentfer }
571825eb42bSJan Lentfer
572825eb42bSJan Lentfer memcpy(data + 4, afdpart, afdlength);
573825eb42bSJan Lentfer
574825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_APL, afdlength + 4, data);
575825eb42bSJan Lentfer LDNS_FREE(afdpart);
576825eb42bSJan Lentfer LDNS_FREE(data);
577825eb42bSJan Lentfer LDNS_FREE(my_ip_str);
578825eb42bSJan Lentfer
579fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
580825eb42bSJan Lentfer }
581825eb42bSJan Lentfer
582825eb42bSJan Lentfer ldns_status
ldns_str2rdf_b64(ldns_rdf ** rd,const char * str)583825eb42bSJan Lentfer ldns_str2rdf_b64(ldns_rdf **rd, const char *str)
584825eb42bSJan Lentfer {
585825eb42bSJan Lentfer uint8_t *buffer;
586825eb42bSJan Lentfer int16_t i;
587825eb42bSJan Lentfer
588819dec71SDaniel Fojt if ((*str == '-' || *str == '0') && str[1] == '\0') {
589819dec71SDaniel Fojt *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, 0, NULL);
590819dec71SDaniel Fojt return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
591819dec71SDaniel Fojt }
592819dec71SDaniel Fojt
593825eb42bSJan Lentfer buffer = LDNS_XMALLOC(uint8_t, ldns_b64_ntop_calculate_size(strlen(str)));
594fd185f4dSJan Lentfer if(!buffer) {
595fd185f4dSJan Lentfer return LDNS_STATUS_MEM_ERR;
596fd185f4dSJan Lentfer }
597825eb42bSJan Lentfer
598825eb42bSJan Lentfer i = (uint16_t)ldns_b64_pton((const char*)str, buffer,
599825eb42bSJan Lentfer ldns_b64_ntop_calculate_size(strlen(str)));
600825eb42bSJan Lentfer if (-1 == i) {
601825eb42bSJan Lentfer LDNS_FREE(buffer);
602825eb42bSJan Lentfer return LDNS_STATUS_INVALID_B64;
603825eb42bSJan Lentfer } else {
604825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(
605825eb42bSJan Lentfer LDNS_RDF_TYPE_B64, (uint16_t) i, buffer);
606825eb42bSJan Lentfer }
607825eb42bSJan Lentfer LDNS_FREE(buffer);
608825eb42bSJan Lentfer
609fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
610825eb42bSJan Lentfer }
611825eb42bSJan Lentfer
612825eb42bSJan Lentfer ldns_status
ldns_str2rdf_b32_ext(ldns_rdf ** rd,const char * str)613825eb42bSJan Lentfer ldns_str2rdf_b32_ext(ldns_rdf **rd, const char *str)
614825eb42bSJan Lentfer {
615825eb42bSJan Lentfer uint8_t *buffer;
616825eb42bSJan Lentfer int i;
617825eb42bSJan Lentfer /* first byte contains length of actual b32 data */
618819dec71SDaniel Fojt size_t slen = strlen(str);
619819dec71SDaniel Fojt size_t len = ldns_b32_pton_calculate_size(slen);
620819dec71SDaniel Fojt if (len > 255) {
621819dec71SDaniel Fojt return LDNS_STATUS_INVALID_B32_EXT;
622819dec71SDaniel Fojt }
623825eb42bSJan Lentfer buffer = LDNS_XMALLOC(uint8_t, len + 1);
624fd185f4dSJan Lentfer if(!buffer) {
625fd185f4dSJan Lentfer return LDNS_STATUS_MEM_ERR;
626fd185f4dSJan Lentfer }
627825eb42bSJan Lentfer buffer[0] = len;
628825eb42bSJan Lentfer
629819dec71SDaniel Fojt i = ldns_b32_pton_extended_hex((const char*)str, slen, buffer + 1,
630819dec71SDaniel Fojt ldns_b32_ntop_calculate_size(slen));
631825eb42bSJan Lentfer if (i < 0) {
632fd185f4dSJan Lentfer LDNS_FREE(buffer);
633825eb42bSJan Lentfer return LDNS_STATUS_INVALID_B32_EXT;
634825eb42bSJan Lentfer } else {
635825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(
636825eb42bSJan Lentfer LDNS_RDF_TYPE_B32_EXT, (uint16_t) i + 1, buffer);
637825eb42bSJan Lentfer }
638825eb42bSJan Lentfer LDNS_FREE(buffer);
639825eb42bSJan Lentfer
640fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
641825eb42bSJan Lentfer }
642825eb42bSJan Lentfer
643825eb42bSJan Lentfer ldns_status
ldns_str2rdf_hex(ldns_rdf ** rd,const char * str)644825eb42bSJan Lentfer ldns_str2rdf_hex(ldns_rdf **rd, const char *str)
645825eb42bSJan Lentfer {
646825eb42bSJan Lentfer uint8_t *t, *t_orig;
647825eb42bSJan Lentfer int i;
648825eb42bSJan Lentfer size_t len;
649825eb42bSJan Lentfer
650825eb42bSJan Lentfer len = strlen(str);
651825eb42bSJan Lentfer
652825eb42bSJan Lentfer if (len > LDNS_MAX_RDFLEN * 2) {
653825eb42bSJan Lentfer return LDNS_STATUS_LABEL_OVERFLOW;
654825eb42bSJan Lentfer } else {
655825eb42bSJan Lentfer t = LDNS_XMALLOC(uint8_t, (len / 2) + 1);
656fd185f4dSJan Lentfer if(!t) {
657fd185f4dSJan Lentfer return LDNS_STATUS_MEM_ERR;
658fd185f4dSJan Lentfer }
659825eb42bSJan Lentfer t_orig = t;
660825eb42bSJan Lentfer /* Now process octet by octet... */
661825eb42bSJan Lentfer while (*str) {
662825eb42bSJan Lentfer *t = 0;
663825eb42bSJan Lentfer if (isspace((int) *str)) {
664825eb42bSJan Lentfer str++;
665825eb42bSJan Lentfer } else {
666825eb42bSJan Lentfer for (i = 16; i >= 1; i -= 15) {
667825eb42bSJan Lentfer while (*str && isspace((int) *str)) { str++; }
668825eb42bSJan Lentfer if (*str) {
669825eb42bSJan Lentfer if (isxdigit((int) *str)) {
670825eb42bSJan Lentfer *t += ldns_hexdigit_to_int(*str) * i;
671825eb42bSJan Lentfer } else {
672fd185f4dSJan Lentfer LDNS_FREE(t_orig);
673825eb42bSJan Lentfer return LDNS_STATUS_ERR;
674825eb42bSJan Lentfer }
675825eb42bSJan Lentfer ++str;
676825eb42bSJan Lentfer }
677825eb42bSJan Lentfer }
678825eb42bSJan Lentfer ++t;
679825eb42bSJan Lentfer }
680825eb42bSJan Lentfer }
681825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_HEX,
682825eb42bSJan Lentfer (size_t) (t - t_orig),
683825eb42bSJan Lentfer t_orig);
684825eb42bSJan Lentfer LDNS_FREE(t_orig);
685825eb42bSJan Lentfer }
686fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
687825eb42bSJan Lentfer }
688825eb42bSJan Lentfer
689825eb42bSJan Lentfer ldns_status
ldns_str2rdf_nsec(ldns_rdf ** rd,const char * str)690825eb42bSJan Lentfer ldns_str2rdf_nsec(ldns_rdf **rd, const char *str)
691825eb42bSJan Lentfer {
692825eb42bSJan Lentfer const char *delimiters = "\n\t ";
693825eb42bSJan Lentfer char *token = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
694825eb42bSJan Lentfer ldns_buffer *str_buf;
695825eb42bSJan Lentfer ssize_t c;
696825eb42bSJan Lentfer uint16_t cur_type;
697825eb42bSJan Lentfer size_t type_count = 0;
698fd185f4dSJan Lentfer ldns_rr_type type_list[65536];
699ac996e71SJan Lentfer if(!token) return LDNS_STATUS_MEM_ERR;
700ac996e71SJan Lentfer if(rd == NULL) {
701ac996e71SJan Lentfer LDNS_FREE(token);
702ac996e71SJan Lentfer return LDNS_STATUS_NULL;
703ac996e71SJan Lentfer }
704825eb42bSJan Lentfer
705825eb42bSJan Lentfer str_buf = LDNS_MALLOC(ldns_buffer);
706ac996e71SJan Lentfer if(!str_buf) {
707ac996e71SJan Lentfer LDNS_FREE(token);
708ac996e71SJan Lentfer return LDNS_STATUS_MEM_ERR;
709ac996e71SJan Lentfer }
710825eb42bSJan Lentfer ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
711ac996e71SJan Lentfer if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
712ac996e71SJan Lentfer LDNS_FREE(str_buf);
713ac996e71SJan Lentfer LDNS_FREE(token);
714ac996e71SJan Lentfer return LDNS_STATUS_MEM_ERR;
715ac996e71SJan Lentfer }
716825eb42bSJan Lentfer
717ac996e71SJan Lentfer while ((c = ldns_bget_token(str_buf, token, delimiters, LDNS_MAX_RDFLEN)) != -1 && c != 0) {
718fd185f4dSJan Lentfer if(type_count >= sizeof(type_list)) {
719fd185f4dSJan Lentfer LDNS_FREE(str_buf);
720fd185f4dSJan Lentfer LDNS_FREE(token);
721fd185f4dSJan Lentfer return LDNS_STATUS_ERR;
722fd185f4dSJan Lentfer }
723825eb42bSJan Lentfer cur_type = ldns_get_rr_type_by_name(token);
724825eb42bSJan Lentfer type_list[type_count] = cur_type;
725825eb42bSJan Lentfer type_count++;
726825eb42bSJan Lentfer }
727825eb42bSJan Lentfer
728825eb42bSJan Lentfer *rd = ldns_dnssec_create_nsec_bitmap(type_list,
729825eb42bSJan Lentfer type_count,
730825eb42bSJan Lentfer LDNS_RR_TYPE_NSEC);
731825eb42bSJan Lentfer
732825eb42bSJan Lentfer LDNS_FREE(token);
733825eb42bSJan Lentfer ldns_buffer_free(str_buf);
734fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
735825eb42bSJan Lentfer }
736825eb42bSJan Lentfer
737825eb42bSJan Lentfer ldns_status
ldns_str2rdf_type(ldns_rdf ** rd,const char * str)738825eb42bSJan Lentfer ldns_str2rdf_type(ldns_rdf **rd, const char *str)
739825eb42bSJan Lentfer {
740825eb42bSJan Lentfer uint16_t type;
741825eb42bSJan Lentfer type = htons(ldns_get_rr_type_by_name(str));
742825eb42bSJan Lentfer /* ldns_rr_type is a 16 bit value */
743825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(
744825eb42bSJan Lentfer LDNS_RDF_TYPE_TYPE, sizeof(uint16_t), &type);
745fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
746825eb42bSJan Lentfer }
747825eb42bSJan Lentfer
748825eb42bSJan Lentfer ldns_status
ldns_str2rdf_class(ldns_rdf ** rd,const char * str)749825eb42bSJan Lentfer ldns_str2rdf_class(ldns_rdf **rd, const char *str)
750825eb42bSJan Lentfer {
751825eb42bSJan Lentfer uint16_t klass;
752825eb42bSJan Lentfer klass = htons(ldns_get_rr_class_by_name(str));
753825eb42bSJan Lentfer /* class is 16 bit */
754825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(
755825eb42bSJan Lentfer LDNS_RDF_TYPE_CLASS, sizeof(uint16_t), &klass);
756fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
757825eb42bSJan Lentfer }
758825eb42bSJan Lentfer
759825eb42bSJan Lentfer /* An certificate alg field can either be specified as a 8 bits number
760825eb42bSJan Lentfer * or by its symbolic name. Handle both
761825eb42bSJan Lentfer */
762825eb42bSJan Lentfer ldns_status
ldns_str2rdf_cert_alg(ldns_rdf ** rd,const char * str)763825eb42bSJan Lentfer ldns_str2rdf_cert_alg(ldns_rdf **rd, const char *str)
764825eb42bSJan Lentfer {
765825eb42bSJan Lentfer ldns_lookup_table *lt;
766825eb42bSJan Lentfer ldns_status st;
767825eb42bSJan Lentfer uint8_t idd[2];
768825eb42bSJan Lentfer lt = ldns_lookup_by_name(ldns_cert_algorithms, str);
769825eb42bSJan Lentfer st = LDNS_STATUS_OK;
770825eb42bSJan Lentfer
771825eb42bSJan Lentfer if (lt) {
772825eb42bSJan Lentfer ldns_write_uint16(idd, (uint16_t) lt->id);
773825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(
774825eb42bSJan Lentfer LDNS_RDF_TYPE_INT16, sizeof(uint16_t), idd);
775825eb42bSJan Lentfer if (!*rd) {
776825eb42bSJan Lentfer st = LDNS_STATUS_ERR;
777825eb42bSJan Lentfer }
778825eb42bSJan Lentfer } else {
779825eb42bSJan Lentfer /* try as-is (a number) */
780825eb42bSJan Lentfer st = ldns_str2rdf_int16(rd, str);
781825eb42bSJan Lentfer if (st == LDNS_STATUS_OK &&
782825eb42bSJan Lentfer ldns_rdf2native_int16(*rd) == 0) {
783825eb42bSJan Lentfer st = LDNS_STATUS_CERT_BAD_ALGORITHM;
784825eb42bSJan Lentfer }
785825eb42bSJan Lentfer }
786825eb42bSJan Lentfer
787825eb42bSJan Lentfer return st;
788825eb42bSJan Lentfer }
789825eb42bSJan Lentfer
7905340022aSzrj static ldns_lookup_table ldns_tlsa_certificate_usages[] = {
7915340022aSzrj { LDNS_TLSA_USAGE_PKIX_TA , "PKIX-TA" },
7925340022aSzrj { LDNS_TLSA_USAGE_PKIX_EE , "PKIX-EE" },
7935340022aSzrj { LDNS_TLSA_USAGE_DANE_TA , "DANE-TA" },
7945340022aSzrj { LDNS_TLSA_USAGE_DANE_EE , "DANE-EE" },
7955340022aSzrj { LDNS_TLSA_USAGE_PRIVCERT , "PrivCert" },
7965340022aSzrj { 0, NULL }
7975340022aSzrj };
7985340022aSzrj
7995340022aSzrj static ldns_lookup_table ldns_tlsa_selectors[] = {
8005340022aSzrj { LDNS_TLSA_SELECTOR_CERT , "Cert" },
8015340022aSzrj { LDNS_TLSA_SELECTOR_SPKI , "SPKI" },
8025340022aSzrj { LDNS_TLSA_SELECTOR_PRIVSEL , "PrivSel" },
8035340022aSzrj { 0, NULL }
8045340022aSzrj };
8055340022aSzrj
8065340022aSzrj static ldns_lookup_table ldns_tlsa_matching_types[] = {
8075340022aSzrj { LDNS_TLSA_MATCHING_TYPE_FULL , "Full" },
8085340022aSzrj { LDNS_TLSA_MATCHING_TYPE_SHA2_256 , "SHA2-256" },
8095340022aSzrj { LDNS_TLSA_MATCHING_TYPE_SHA2_512 , "SHA2-512" },
8105340022aSzrj { LDNS_TLSA_MATCHING_TYPE_PRIVMATCH , "PrivMatch" },
8115340022aSzrj { 0, NULL }
8125340022aSzrj };
8135340022aSzrj
8145340022aSzrj static ldns_status
ldns_str2rdf_mnemonic4int8(ldns_lookup_table * lt,ldns_rdf ** rd,const char * str)8155340022aSzrj ldns_str2rdf_mnemonic4int8(ldns_lookup_table *lt,
8165340022aSzrj ldns_rdf **rd, const char *str)
8175340022aSzrj {
8185340022aSzrj if ((lt = ldns_lookup_by_name(lt, str))) {
8195340022aSzrj /* it was given as a integer */
8205340022aSzrj *rd = ldns_native2rdf_int8(LDNS_RDF_TYPE_INT8, (uint8_t) lt->id);
8215340022aSzrj if (!*rd)
8225340022aSzrj return LDNS_STATUS_ERR;
8235340022aSzrj else
8245340022aSzrj return LDNS_STATUS_OK;
8255340022aSzrj }
8265340022aSzrj return ldns_str2rdf_int8(rd, str);
8275340022aSzrj }
8285340022aSzrj
829825eb42bSJan Lentfer /* An alg field can either be specified as a 8 bits number
830825eb42bSJan Lentfer * or by its symbolic name. Handle both
831825eb42bSJan Lentfer */
832825eb42bSJan Lentfer ldns_status
ldns_str2rdf_alg(ldns_rdf ** rd,const char * str)833825eb42bSJan Lentfer ldns_str2rdf_alg(ldns_rdf **rd, const char *str)
834825eb42bSJan Lentfer {
8355340022aSzrj return ldns_str2rdf_mnemonic4int8(ldns_algorithms, rd, str);
836825eb42bSJan Lentfer }
8375340022aSzrj
8385340022aSzrj ldns_status
ldns_str2rdf_certificate_usage(ldns_rdf ** rd,const char * str)8395340022aSzrj ldns_str2rdf_certificate_usage(ldns_rdf **rd, const char *str)
8405340022aSzrj {
8415340022aSzrj return ldns_str2rdf_mnemonic4int8(
8425340022aSzrj ldns_tlsa_certificate_usages, rd, str);
843825eb42bSJan Lentfer }
8445340022aSzrj
8455340022aSzrj ldns_status
ldns_str2rdf_selector(ldns_rdf ** rd,const char * str)8465340022aSzrj ldns_str2rdf_selector(ldns_rdf **rd, const char *str)
8475340022aSzrj {
8485340022aSzrj return ldns_str2rdf_mnemonic4int8(ldns_tlsa_selectors, rd, str);
8495340022aSzrj }
8505340022aSzrj
8515340022aSzrj ldns_status
ldns_str2rdf_matching_type(ldns_rdf ** rd,const char * str)8525340022aSzrj ldns_str2rdf_matching_type(ldns_rdf **rd, const char *str)
8535340022aSzrj {
8545340022aSzrj return ldns_str2rdf_mnemonic4int8(ldns_tlsa_matching_types, rd, str);
855825eb42bSJan Lentfer }
856825eb42bSJan Lentfer
857825eb42bSJan Lentfer ldns_status
ldns_str2rdf_unknown(ATTR_UNUSED (ldns_rdf ** rd),ATTR_UNUSED (const char * str))858d1b2b5caSJohn Marino ldns_str2rdf_unknown( ATTR_UNUSED(ldns_rdf **rd)
859d1b2b5caSJohn Marino , ATTR_UNUSED(const char *str)
860d1b2b5caSJohn Marino )
861825eb42bSJan Lentfer {
862825eb42bSJan Lentfer /* this should be caught in an earlier time (general str2host for
863825eb42bSJan Lentfer rr's */
864825eb42bSJan Lentfer return LDNS_STATUS_NOT_IMPL;
865825eb42bSJan Lentfer }
866825eb42bSJan Lentfer
867825eb42bSJan Lentfer ldns_status
ldns_str2rdf_service(ATTR_UNUSED (ldns_rdf ** rd),ATTR_UNUSED (const char * str))868d1b2b5caSJohn Marino ldns_str2rdf_service( ATTR_UNUSED(ldns_rdf **rd)
869d1b2b5caSJohn Marino , ATTR_UNUSED(const char *str)
870d1b2b5caSJohn Marino )
871825eb42bSJan Lentfer {
872825eb42bSJan Lentfer /* is this used? is this actually WKS? or SRV? */
873825eb42bSJan Lentfer return LDNS_STATUS_NOT_IMPL;
874825eb42bSJan Lentfer }
875825eb42bSJan Lentfer
876825eb42bSJan Lentfer static int
loc_parse_cm(char * my_str,char ** endstr,uint8_t * m,uint8_t * e)877825eb42bSJan Lentfer loc_parse_cm(char* my_str, char** endstr, uint8_t* m, uint8_t* e)
878825eb42bSJan Lentfer {
879825eb42bSJan Lentfer /* read <digits>[.<digits>][mM] */
880825eb42bSJan Lentfer /* into mantissa exponent format for LOC type */
881825eb42bSJan Lentfer uint32_t meters = 0, cm = 0, val;
882*ee791febSAntonio Huete Jimenez char* cm_endstr;
8835340022aSzrj while (isblank((unsigned char)*my_str)) {
884825eb42bSJan Lentfer my_str++;
885825eb42bSJan Lentfer }
886825eb42bSJan Lentfer meters = (uint32_t)strtol(my_str, &my_str, 10);
887825eb42bSJan Lentfer if (*my_str == '.') {
888825eb42bSJan Lentfer my_str++;
889*ee791febSAntonio Huete Jimenez cm = (uint32_t)strtol(my_str, &cm_endstr, 10);
890*ee791febSAntonio Huete Jimenez if (cm_endstr - my_str == 1) cm *= 10;
891*ee791febSAntonio Huete Jimenez my_str = cm_endstr;
892825eb42bSJan Lentfer }
893825eb42bSJan Lentfer if (meters >= 1) {
894825eb42bSJan Lentfer *e = 2;
895825eb42bSJan Lentfer val = meters;
896825eb42bSJan Lentfer } else {
897825eb42bSJan Lentfer *e = 0;
898825eb42bSJan Lentfer val = cm;
899825eb42bSJan Lentfer }
900825eb42bSJan Lentfer while(val >= 10) {
901825eb42bSJan Lentfer (*e)++;
902825eb42bSJan Lentfer val /= 10;
903825eb42bSJan Lentfer }
904825eb42bSJan Lentfer *m = (uint8_t)val;
905825eb42bSJan Lentfer
906825eb42bSJan Lentfer if (*e > 9)
907825eb42bSJan Lentfer return 0;
908825eb42bSJan Lentfer if (*my_str == 'm' || *my_str == 'M') {
909825eb42bSJan Lentfer my_str++;
910825eb42bSJan Lentfer }
911825eb42bSJan Lentfer *endstr = my_str;
912825eb42bSJan Lentfer return 1;
913825eb42bSJan Lentfer }
914825eb42bSJan Lentfer
915825eb42bSJan Lentfer ldns_status
ldns_str2rdf_loc(ldns_rdf ** rd,const char * str)916825eb42bSJan Lentfer ldns_str2rdf_loc(ldns_rdf **rd, const char *str)
917825eb42bSJan Lentfer {
918825eb42bSJan Lentfer uint32_t latitude = 0;
919825eb42bSJan Lentfer uint32_t longitude = 0;
920825eb42bSJan Lentfer uint32_t altitude = 0;
921825eb42bSJan Lentfer
922825eb42bSJan Lentfer uint8_t *data;
923825eb42bSJan Lentfer uint32_t equator = (uint32_t) ldns_power(2, 31);
924825eb42bSJan Lentfer
925825eb42bSJan Lentfer uint32_t h = 0;
926825eb42bSJan Lentfer uint32_t m = 0;
927825eb42bSJan Lentfer uint8_t size_b = 1, size_e = 2;
928825eb42bSJan Lentfer uint8_t horiz_pre_b = 1, horiz_pre_e = 6;
929825eb42bSJan Lentfer uint8_t vert_pre_b = 1, vert_pre_e = 3;
930825eb42bSJan Lentfer
931825eb42bSJan Lentfer double s = 0.0;
932*ee791febSAntonio Huete Jimenez bool northern_hemisphere;
933*ee791febSAntonio Huete Jimenez bool eastern_hemisphere;
934825eb42bSJan Lentfer
935825eb42bSJan Lentfer char *my_str = (char *) str;
936825eb42bSJan Lentfer
937825eb42bSJan Lentfer /* only support version 0 */
938825eb42bSJan Lentfer if (isdigit((int) *my_str)) {
939825eb42bSJan Lentfer h = (uint32_t) strtol(my_str, &my_str, 10);
940825eb42bSJan Lentfer } else {
941825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
942825eb42bSJan Lentfer }
943825eb42bSJan Lentfer
944825eb42bSJan Lentfer while (isblank((int) *my_str)) {
945825eb42bSJan Lentfer my_str++;
946825eb42bSJan Lentfer }
947825eb42bSJan Lentfer
948825eb42bSJan Lentfer if (isdigit((int) *my_str)) {
949825eb42bSJan Lentfer m = (uint32_t) strtol(my_str, &my_str, 10);
950825eb42bSJan Lentfer } else if (*my_str == 'N' || *my_str == 'S') {
951825eb42bSJan Lentfer goto north;
952825eb42bSJan Lentfer } else {
953825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
954825eb42bSJan Lentfer }
955825eb42bSJan Lentfer
956825eb42bSJan Lentfer while (isblank((int) *my_str)) {
957825eb42bSJan Lentfer my_str++;
958825eb42bSJan Lentfer }
959825eb42bSJan Lentfer
960825eb42bSJan Lentfer if (isdigit((int) *my_str)) {
961825eb42bSJan Lentfer s = strtod(my_str, &my_str);
962825eb42bSJan Lentfer }
963825eb42bSJan Lentfer north:
964825eb42bSJan Lentfer while (isblank((int) *my_str)) {
965825eb42bSJan Lentfer my_str++;
966825eb42bSJan Lentfer }
967825eb42bSJan Lentfer
968825eb42bSJan Lentfer if (*my_str == 'N') {
969*ee791febSAntonio Huete Jimenez northern_hemisphere = true;
970825eb42bSJan Lentfer } else if (*my_str == 'S') {
971*ee791febSAntonio Huete Jimenez northern_hemisphere = false;
972825eb42bSJan Lentfer } else {
973825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
974825eb42bSJan Lentfer }
975825eb42bSJan Lentfer
976825eb42bSJan Lentfer my_str++;
977825eb42bSJan Lentfer
978825eb42bSJan Lentfer /* store number */
979825eb42bSJan Lentfer s = 1000.0 * s;
980825eb42bSJan Lentfer /* add a little to make floor in conversion a round */
981825eb42bSJan Lentfer s += 0.0005;
982825eb42bSJan Lentfer latitude = (uint32_t) s;
983825eb42bSJan Lentfer latitude += 1000 * 60 * m;
984825eb42bSJan Lentfer latitude += 1000 * 60 * 60 * h;
985*ee791febSAntonio Huete Jimenez if (northern_hemisphere) {
986825eb42bSJan Lentfer latitude = equator + latitude;
987825eb42bSJan Lentfer } else {
988825eb42bSJan Lentfer latitude = equator - latitude;
989825eb42bSJan Lentfer }
9905340022aSzrj while (isblank((unsigned char)*my_str)) {
991825eb42bSJan Lentfer my_str++;
992825eb42bSJan Lentfer }
993825eb42bSJan Lentfer
994825eb42bSJan Lentfer if (isdigit((int) *my_str)) {
995825eb42bSJan Lentfer h = (uint32_t) strtol(my_str, &my_str, 10);
996825eb42bSJan Lentfer } else {
997825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
998825eb42bSJan Lentfer }
999825eb42bSJan Lentfer
1000825eb42bSJan Lentfer while (isblank((int) *my_str)) {
1001825eb42bSJan Lentfer my_str++;
1002825eb42bSJan Lentfer }
1003825eb42bSJan Lentfer
1004825eb42bSJan Lentfer if (isdigit((int) *my_str)) {
1005825eb42bSJan Lentfer m = (uint32_t) strtol(my_str, &my_str, 10);
1006825eb42bSJan Lentfer } else if (*my_str == 'E' || *my_str == 'W') {
1007825eb42bSJan Lentfer goto east;
1008825eb42bSJan Lentfer } else {
1009825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
1010825eb42bSJan Lentfer }
1011825eb42bSJan Lentfer
10125340022aSzrj while (isblank((unsigned char)*my_str)) {
1013825eb42bSJan Lentfer my_str++;
1014825eb42bSJan Lentfer }
1015825eb42bSJan Lentfer
1016825eb42bSJan Lentfer if (isdigit((int) *my_str)) {
1017825eb42bSJan Lentfer s = strtod(my_str, &my_str);
1018825eb42bSJan Lentfer }
1019825eb42bSJan Lentfer
1020825eb42bSJan Lentfer east:
10215340022aSzrj while (isblank((unsigned char)*my_str)) {
1022825eb42bSJan Lentfer my_str++;
1023825eb42bSJan Lentfer }
1024825eb42bSJan Lentfer
1025825eb42bSJan Lentfer if (*my_str == 'E') {
1026*ee791febSAntonio Huete Jimenez eastern_hemisphere = true;
1027825eb42bSJan Lentfer } else if (*my_str == 'W') {
1028*ee791febSAntonio Huete Jimenez eastern_hemisphere = false;
1029825eb42bSJan Lentfer } else {
1030825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
1031825eb42bSJan Lentfer }
1032825eb42bSJan Lentfer
1033825eb42bSJan Lentfer my_str++;
1034825eb42bSJan Lentfer
1035825eb42bSJan Lentfer /* store number */
1036825eb42bSJan Lentfer s *= 1000.0;
1037825eb42bSJan Lentfer /* add a little to make floor in conversion a round */
1038825eb42bSJan Lentfer s += 0.0005;
1039825eb42bSJan Lentfer longitude = (uint32_t) s;
1040825eb42bSJan Lentfer longitude += 1000 * 60 * m;
1041825eb42bSJan Lentfer longitude += 1000 * 60 * 60 * h;
1042825eb42bSJan Lentfer
1043*ee791febSAntonio Huete Jimenez if (eastern_hemisphere) {
1044825eb42bSJan Lentfer longitude += equator;
1045825eb42bSJan Lentfer } else {
1046825eb42bSJan Lentfer longitude = equator - longitude;
1047825eb42bSJan Lentfer }
1048825eb42bSJan Lentfer
1049825eb42bSJan Lentfer altitude = (uint32_t)(strtod(my_str, &my_str)*100.0 +
1050825eb42bSJan Lentfer 10000000.0 + 0.5);
1051825eb42bSJan Lentfer if (*my_str == 'm' || *my_str == 'M') {
1052825eb42bSJan Lentfer my_str++;
1053825eb42bSJan Lentfer }
1054825eb42bSJan Lentfer
1055825eb42bSJan Lentfer if (strlen(my_str) > 0) {
1056825eb42bSJan Lentfer if(!loc_parse_cm(my_str, &my_str, &size_b, &size_e))
1057825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
1058825eb42bSJan Lentfer }
1059825eb42bSJan Lentfer
1060825eb42bSJan Lentfer if (strlen(my_str) > 0) {
1061825eb42bSJan Lentfer if(!loc_parse_cm(my_str, &my_str, &horiz_pre_b, &horiz_pre_e))
1062825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
1063825eb42bSJan Lentfer }
1064825eb42bSJan Lentfer
1065825eb42bSJan Lentfer if (strlen(my_str) > 0) {
1066825eb42bSJan Lentfer if(!loc_parse_cm(my_str, &my_str, &vert_pre_b, &vert_pre_e))
1067825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
1068825eb42bSJan Lentfer }
1069825eb42bSJan Lentfer
1070825eb42bSJan Lentfer data = LDNS_XMALLOC(uint8_t, 16);
1071fd185f4dSJan Lentfer if(!data) {
1072fd185f4dSJan Lentfer return LDNS_STATUS_MEM_ERR;
1073fd185f4dSJan Lentfer }
1074825eb42bSJan Lentfer data[0] = 0;
1075825eb42bSJan Lentfer data[1] = 0;
1076825eb42bSJan Lentfer data[1] = ((size_b << 4) & 0xf0) | (size_e & 0x0f);
1077825eb42bSJan Lentfer data[2] = ((horiz_pre_b << 4) & 0xf0) | (horiz_pre_e & 0x0f);
1078825eb42bSJan Lentfer data[3] = ((vert_pre_b << 4) & 0xf0) | (vert_pre_e & 0x0f);
1079825eb42bSJan Lentfer ldns_write_uint32(data + 4, latitude);
1080825eb42bSJan Lentfer ldns_write_uint32(data + 8, longitude);
1081825eb42bSJan Lentfer ldns_write_uint32(data + 12, altitude);
1082825eb42bSJan Lentfer
1083825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(
1084825eb42bSJan Lentfer LDNS_RDF_TYPE_LOC, 16, data);
1085825eb42bSJan Lentfer
1086825eb42bSJan Lentfer LDNS_FREE(data);
1087fd185f4dSJan Lentfer return *rd?LDNS_STATUS_OK:LDNS_STATUS_MEM_ERR;
1088825eb42bSJan Lentfer }
1089825eb42bSJan Lentfer
1090825eb42bSJan Lentfer ldns_status
ldns_str2rdf_wks(ldns_rdf ** rd,const char * str)1091825eb42bSJan Lentfer ldns_str2rdf_wks(ldns_rdf **rd, const char *str)
1092825eb42bSJan Lentfer {
1093825eb42bSJan Lentfer uint8_t *bitmap = NULL;
1094825eb42bSJan Lentfer uint8_t *data;
1095825eb42bSJan Lentfer int bm_len = 0;
1096825eb42bSJan Lentfer
1097825eb42bSJan Lentfer struct protoent *proto = NULL;
1098825eb42bSJan Lentfer struct servent *serv = NULL;
1099825eb42bSJan Lentfer int serv_port;
1100825eb42bSJan Lentfer
1101825eb42bSJan Lentfer ldns_buffer *str_buf;
1102825eb42bSJan Lentfer
1103825eb42bSJan Lentfer char *proto_str = NULL;
1104819dec71SDaniel Fojt char *lc_proto_str = NULL;
1105ac996e71SJan Lentfer char *token;
1106819dec71SDaniel Fojt char *lc_token;
1107819dec71SDaniel Fojt char *c;
1108ac996e71SJan Lentfer if(strlen(str) == 0)
1109ac996e71SJan Lentfer token = LDNS_XMALLOC(char, 50);
1110ac996e71SJan Lentfer else token = LDNS_XMALLOC(char, strlen(str)+2);
1111ac996e71SJan Lentfer if(!token) return LDNS_STATUS_MEM_ERR;
1112825eb42bSJan Lentfer
1113825eb42bSJan Lentfer str_buf = LDNS_MALLOC(ldns_buffer);
1114ac996e71SJan Lentfer if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
1115825eb42bSJan Lentfer ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
1116ac996e71SJan Lentfer if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
1117ac996e71SJan Lentfer LDNS_FREE(str_buf);
1118ac996e71SJan Lentfer LDNS_FREE(token);
1119ac996e71SJan Lentfer return LDNS_STATUS_MEM_ERR;
1120ac996e71SJan Lentfer }
1121825eb42bSJan Lentfer
1122825eb42bSJan Lentfer while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
1123825eb42bSJan Lentfer if (!proto_str) {
1124825eb42bSJan Lentfer proto_str = strdup(token);
1125819dec71SDaniel Fojt lc_proto_str = strdup(token);
1126819dec71SDaniel Fojt for (c = lc_proto_str; *c; c++) {
1127819dec71SDaniel Fojt *c = tolower((unsigned char)*c);
1128819dec71SDaniel Fojt }
1129819dec71SDaniel Fojt if (!proto_str || !lc_proto_str) {
1130819dec71SDaniel Fojt free(proto_str);
1131819dec71SDaniel Fojt free(lc_proto_str);
1132ac996e71SJan Lentfer LDNS_FREE(bitmap);
1133825eb42bSJan Lentfer LDNS_FREE(token);
1134ac996e71SJan Lentfer ldns_buffer_free(str_buf);
1135825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
1136825eb42bSJan Lentfer }
1137825eb42bSJan Lentfer } else {
1138825eb42bSJan Lentfer serv = getservbyname(token, proto_str);
1139819dec71SDaniel Fojt if (!serv) {
1140819dec71SDaniel Fojt serv = getservbyname(token, lc_proto_str);
1141819dec71SDaniel Fojt }
1142819dec71SDaniel Fojt if (!serv && (lc_token = strdup(token))) {
1143819dec71SDaniel Fojt for (c = lc_token; *c; c++) {
1144819dec71SDaniel Fojt *c = tolower((unsigned char)*c);
1145819dec71SDaniel Fojt }
1146819dec71SDaniel Fojt serv = getservbyname(lc_token, proto_str);
1147819dec71SDaniel Fojt if (!serv) {
1148819dec71SDaniel Fojt serv = getservbyname(lc_token, lc_proto_str);
1149819dec71SDaniel Fojt }
1150819dec71SDaniel Fojt free(lc_token);
1151819dec71SDaniel Fojt }
1152825eb42bSJan Lentfer if (serv) {
1153825eb42bSJan Lentfer serv_port = (int) ntohs((uint16_t) serv->s_port);
1154825eb42bSJan Lentfer } else {
1155825eb42bSJan Lentfer serv_port = atoi(token);
1156825eb42bSJan Lentfer }
1157819dec71SDaniel Fojt if (serv_port < 0 || serv_port > 65535) {
1158819dec71SDaniel Fojt LDNS_FREE(bitmap);
1159819dec71SDaniel Fojt LDNS_FREE(token);
1160819dec71SDaniel Fojt ldns_buffer_free(str_buf);
1161819dec71SDaniel Fojt free(proto_str);
1162819dec71SDaniel Fojt free(lc_proto_str);
1163819dec71SDaniel Fojt return LDNS_STATUS_INVALID_STR;
1164819dec71SDaniel Fojt }
1165825eb42bSJan Lentfer if (serv_port / 8 >= bm_len) {
1166ac996e71SJan Lentfer uint8_t *b2 = LDNS_XREALLOC(bitmap, uint8_t, (serv_port / 8) + 1);
1167ac996e71SJan Lentfer if(!b2) {
1168ac996e71SJan Lentfer LDNS_FREE(bitmap);
1169ac996e71SJan Lentfer LDNS_FREE(token);
1170ac996e71SJan Lentfer ldns_buffer_free(str_buf);
1171ac996e71SJan Lentfer free(proto_str);
1172819dec71SDaniel Fojt free(lc_proto_str);
1173ac996e71SJan Lentfer return LDNS_STATUS_INVALID_STR;
1174ac996e71SJan Lentfer }
1175ac996e71SJan Lentfer bitmap = b2;
1176825eb42bSJan Lentfer /* set to zero to be sure */
1177825eb42bSJan Lentfer for (; bm_len <= serv_port / 8; bm_len++) {
1178825eb42bSJan Lentfer bitmap[bm_len] = 0;
1179825eb42bSJan Lentfer }
1180825eb42bSJan Lentfer }
1181825eb42bSJan Lentfer ldns_set_bit(bitmap + (serv_port / 8), 7 - (serv_port % 8), true);
1182825eb42bSJan Lentfer }
1183825eb42bSJan Lentfer }
1184825eb42bSJan Lentfer
1185ac996e71SJan Lentfer if (!proto_str || !bitmap) {
1186ac996e71SJan Lentfer LDNS_FREE(bitmap);
1187825eb42bSJan Lentfer LDNS_FREE(token);
1188ac996e71SJan Lentfer ldns_buffer_free(str_buf);
1189ac996e71SJan Lentfer free(proto_str);
1190819dec71SDaniel Fojt free(lc_proto_str);
1191825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
1192825eb42bSJan Lentfer }
1193825eb42bSJan Lentfer
1194825eb42bSJan Lentfer data = LDNS_XMALLOC(uint8_t, bm_len + 1);
1195ac996e71SJan Lentfer if(!data) {
1196ac996e71SJan Lentfer LDNS_FREE(token);
1197ac996e71SJan Lentfer ldns_buffer_free(str_buf);
1198ac996e71SJan Lentfer LDNS_FREE(bitmap);
1199ac996e71SJan Lentfer free(proto_str);
1200819dec71SDaniel Fojt free(lc_proto_str);
1201ac996e71SJan Lentfer return LDNS_STATUS_INVALID_STR;
1202ac996e71SJan Lentfer }
1203825eb42bSJan Lentfer if (proto_str)
1204825eb42bSJan Lentfer proto = getprotobyname(proto_str);
1205819dec71SDaniel Fojt if (!proto) {
1206819dec71SDaniel Fojt proto = getprotobyname(lc_proto_str);
1207819dec71SDaniel Fojt }
1208825eb42bSJan Lentfer if (proto) {
1209825eb42bSJan Lentfer data[0] = (uint8_t) proto->p_proto;
1210825eb42bSJan Lentfer } else if (proto_str) {
1211825eb42bSJan Lentfer data[0] = (uint8_t) atoi(proto_str);
1212825eb42bSJan Lentfer }
1213825eb42bSJan Lentfer memcpy(data + 1, bitmap, (size_t) bm_len);
1214825eb42bSJan Lentfer
1215825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_WKS, (uint16_t) (bm_len + 1), data);
1216825eb42bSJan Lentfer
1217825eb42bSJan Lentfer LDNS_FREE(data);
1218825eb42bSJan Lentfer LDNS_FREE(token);
1219825eb42bSJan Lentfer ldns_buffer_free(str_buf);
1220825eb42bSJan Lentfer LDNS_FREE(bitmap);
1221825eb42bSJan Lentfer free(proto_str);
1222819dec71SDaniel Fojt free(lc_proto_str);
1223825eb42bSJan Lentfer #ifdef HAVE_ENDSERVENT
1224825eb42bSJan Lentfer endservent();
1225825eb42bSJan Lentfer #endif
1226825eb42bSJan Lentfer #ifdef HAVE_ENDPROTOENT
1227825eb42bSJan Lentfer endprotoent();
1228825eb42bSJan Lentfer #endif
1229825eb42bSJan Lentfer
1230ac996e71SJan Lentfer if(!*rd) return LDNS_STATUS_MEM_ERR;
1231ac996e71SJan Lentfer
1232825eb42bSJan Lentfer return LDNS_STATUS_OK;
1233825eb42bSJan Lentfer }
1234825eb42bSJan Lentfer
1235825eb42bSJan Lentfer ldns_status
ldns_str2rdf_nsap(ldns_rdf ** rd,const char * str)1236825eb42bSJan Lentfer ldns_str2rdf_nsap(ldns_rdf **rd, const char *str)
1237825eb42bSJan Lentfer {
1238825eb42bSJan Lentfer size_t len, i;
1239825eb42bSJan Lentfer char* nsap_str = (char*) str;
1240825eb42bSJan Lentfer
1241825eb42bSJan Lentfer /* just a hex string with optional dots? */
1242825eb42bSJan Lentfer if (str[0] != '0' || str[1] != 'x') {
1243825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
1244825eb42bSJan Lentfer } else {
1245825eb42bSJan Lentfer len = strlen(str);
1246825eb42bSJan Lentfer for (i=0; i < len; i++) {
1247825eb42bSJan Lentfer if (nsap_str[i] == '.')
1248825eb42bSJan Lentfer nsap_str[i] = ' ';
1249825eb42bSJan Lentfer }
1250825eb42bSJan Lentfer return ldns_str2rdf_hex(rd, str+2);
1251825eb42bSJan Lentfer }
1252825eb42bSJan Lentfer }
1253825eb42bSJan Lentfer
1254825eb42bSJan Lentfer ldns_status
ldns_str2rdf_atma(ldns_rdf ** rd,const char * str)1255825eb42bSJan Lentfer ldns_str2rdf_atma(ldns_rdf **rd, const char *str)
1256825eb42bSJan Lentfer {
1257825eb42bSJan Lentfer size_t len, i;
1258825eb42bSJan Lentfer char* atma_str = (char*) str;
1259825eb42bSJan Lentfer ldns_status status;
1260825eb42bSJan Lentfer
1261825eb42bSJan Lentfer /* just a hex string with optional dots? */
1262825eb42bSJan Lentfer len = strlen(str);
1263825eb42bSJan Lentfer for (i=0; i < len; i++) {
1264825eb42bSJan Lentfer if (atma_str[i] == '.')
1265825eb42bSJan Lentfer atma_str[i] = ' ';
1266825eb42bSJan Lentfer }
1267825eb42bSJan Lentfer status = ldns_str2rdf_hex(rd, str);
1268825eb42bSJan Lentfer if (status != LDNS_STATUS_OK) {
1269825eb42bSJan Lentfer ; /* probably in e.164 format than */
1270825eb42bSJan Lentfer }
1271825eb42bSJan Lentfer return status;
1272825eb42bSJan Lentfer }
1273825eb42bSJan Lentfer
1274825eb42bSJan Lentfer ldns_status
ldns_str2rdf_ipseckey(ldns_rdf ** rd,const char * str)1275825eb42bSJan Lentfer ldns_str2rdf_ipseckey(ldns_rdf **rd, const char *str)
1276825eb42bSJan Lentfer {
1277825eb42bSJan Lentfer uint8_t precedence = 0;
1278825eb42bSJan Lentfer uint8_t gateway_type = 0;
1279825eb42bSJan Lentfer uint8_t algorithm = 0;
1280825eb42bSJan Lentfer char* gateway = NULL;
1281825eb42bSJan Lentfer char* publickey = NULL;
1282825eb42bSJan Lentfer uint8_t *data;
1283825eb42bSJan Lentfer ldns_buffer *str_buf;
1284ac996e71SJan Lentfer char *token;
1285825eb42bSJan Lentfer int token_count = 0;
1286825eb42bSJan Lentfer int ipseckey_len = 0;
1287825eb42bSJan Lentfer ldns_rdf* gateway_rdf = NULL;
1288825eb42bSJan Lentfer ldns_rdf* publickey_rdf = NULL;
1289825eb42bSJan Lentfer ldns_status status = LDNS_STATUS_OK;
1290825eb42bSJan Lentfer
1291ac996e71SJan Lentfer if(strlen(str) == 0)
1292ac996e71SJan Lentfer token = LDNS_XMALLOC(char, 256);
1293ac996e71SJan Lentfer else token = LDNS_XMALLOC(char, strlen(str)+2);
1294ac996e71SJan Lentfer if(!token) return LDNS_STATUS_MEM_ERR;
1295ac996e71SJan Lentfer
1296825eb42bSJan Lentfer str_buf = LDNS_MALLOC(ldns_buffer);
1297ac996e71SJan Lentfer if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
1298825eb42bSJan Lentfer ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
1299ac996e71SJan Lentfer if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
1300ac996e71SJan Lentfer LDNS_FREE(str_buf);
1301ac996e71SJan Lentfer LDNS_FREE(token);
1302ac996e71SJan Lentfer return LDNS_STATUS_MEM_ERR;
1303ac996e71SJan Lentfer }
1304825eb42bSJan Lentfer while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
1305825eb42bSJan Lentfer switch (token_count) {
1306825eb42bSJan Lentfer case 0:
1307fd185f4dSJan Lentfer precedence = (uint8_t)atoi(token);
1308825eb42bSJan Lentfer break;
1309825eb42bSJan Lentfer case 1:
1310fd185f4dSJan Lentfer gateway_type = (uint8_t)atoi(token);
1311825eb42bSJan Lentfer break;
1312825eb42bSJan Lentfer case 2:
1313fd185f4dSJan Lentfer algorithm = (uint8_t)atoi(token);
1314825eb42bSJan Lentfer break;
1315825eb42bSJan Lentfer case 3:
1316825eb42bSJan Lentfer gateway = strdup(token);
1317825eb42bSJan Lentfer if (!gateway || (gateway_type == 0 &&
1318825eb42bSJan Lentfer (token[0] != '.' || token[1] != '\0'))) {
1319825eb42bSJan Lentfer LDNS_FREE(gateway);
1320825eb42bSJan Lentfer LDNS_FREE(token);
1321ac996e71SJan Lentfer ldns_buffer_free(str_buf);
1322825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
1323825eb42bSJan Lentfer }
1324825eb42bSJan Lentfer break;
1325825eb42bSJan Lentfer case 4:
1326825eb42bSJan Lentfer publickey = strdup(token);
1327825eb42bSJan Lentfer break;
1328825eb42bSJan Lentfer default:
1329825eb42bSJan Lentfer LDNS_FREE(token);
1330ac996e71SJan Lentfer ldns_buffer_free(str_buf);
1331825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
1332825eb42bSJan Lentfer break;
1333825eb42bSJan Lentfer }
1334825eb42bSJan Lentfer token_count++;
1335825eb42bSJan Lentfer }
1336825eb42bSJan Lentfer
1337825eb42bSJan Lentfer if (!gateway || !publickey) {
1338825eb42bSJan Lentfer if (gateway)
1339825eb42bSJan Lentfer LDNS_FREE(gateway);
1340825eb42bSJan Lentfer if (publickey)
1341825eb42bSJan Lentfer LDNS_FREE(publickey);
1342825eb42bSJan Lentfer LDNS_FREE(token);
1343ac996e71SJan Lentfer ldns_buffer_free(str_buf);
1344825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
1345825eb42bSJan Lentfer }
1346825eb42bSJan Lentfer
1347825eb42bSJan Lentfer if (gateway_type == 1) {
1348825eb42bSJan Lentfer status = ldns_str2rdf_a(&gateway_rdf, gateway);
1349825eb42bSJan Lentfer } else if (gateway_type == 2) {
1350825eb42bSJan Lentfer status = ldns_str2rdf_aaaa(&gateway_rdf, gateway);
1351825eb42bSJan Lentfer } else if (gateway_type == 3) {
1352825eb42bSJan Lentfer status = ldns_str2rdf_dname(&gateway_rdf, gateway);
1353819dec71SDaniel Fojt } else if (gateway_type > 3) {
1354819dec71SDaniel Fojt status = LDNS_STATUS_INVALID_STR;
1355825eb42bSJan Lentfer }
1356825eb42bSJan Lentfer
1357825eb42bSJan Lentfer if (status != LDNS_STATUS_OK) {
1358825eb42bSJan Lentfer if (gateway)
1359825eb42bSJan Lentfer LDNS_FREE(gateway);
1360825eb42bSJan Lentfer if (publickey)
1361825eb42bSJan Lentfer LDNS_FREE(publickey);
1362825eb42bSJan Lentfer LDNS_FREE(token);
1363ac996e71SJan Lentfer ldns_buffer_free(str_buf);
1364825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
1365825eb42bSJan Lentfer }
1366825eb42bSJan Lentfer
1367825eb42bSJan Lentfer status = ldns_str2rdf_b64(&publickey_rdf, publickey);
1368825eb42bSJan Lentfer
1369825eb42bSJan Lentfer if (status != LDNS_STATUS_OK) {
1370825eb42bSJan Lentfer if (gateway)
1371825eb42bSJan Lentfer LDNS_FREE(gateway);
1372825eb42bSJan Lentfer if (publickey)
1373825eb42bSJan Lentfer LDNS_FREE(publickey);
1374825eb42bSJan Lentfer LDNS_FREE(token);
1375ac996e71SJan Lentfer ldns_buffer_free(str_buf);
1376ac996e71SJan Lentfer if (gateway_rdf) ldns_rdf_free(gateway_rdf);
1377825eb42bSJan Lentfer return LDNS_STATUS_INVALID_STR;
1378825eb42bSJan Lentfer }
1379825eb42bSJan Lentfer
1380825eb42bSJan Lentfer /* now copy all into one ipseckey rdf */
1381825eb42bSJan Lentfer if (gateway_type)
1382fd185f4dSJan Lentfer ipseckey_len = 3 + (int)ldns_rdf_size(gateway_rdf) + (int)ldns_rdf_size(publickey_rdf);
1383825eb42bSJan Lentfer else
1384fd185f4dSJan Lentfer ipseckey_len = 3 + (int)ldns_rdf_size(publickey_rdf);
1385825eb42bSJan Lentfer
1386825eb42bSJan Lentfer data = LDNS_XMALLOC(uint8_t, ipseckey_len);
1387ac996e71SJan Lentfer if(!data) {
1388ac996e71SJan Lentfer if (gateway)
1389ac996e71SJan Lentfer LDNS_FREE(gateway);
1390ac996e71SJan Lentfer if (publickey)
1391ac996e71SJan Lentfer LDNS_FREE(publickey);
1392ac996e71SJan Lentfer LDNS_FREE(token);
1393ac996e71SJan Lentfer ldns_buffer_free(str_buf);
1394ac996e71SJan Lentfer if (gateway_rdf) ldns_rdf_free(gateway_rdf);
1395ac996e71SJan Lentfer if (publickey_rdf) ldns_rdf_free(publickey_rdf);
1396ac996e71SJan Lentfer return LDNS_STATUS_MEM_ERR;
1397ac996e71SJan Lentfer }
1398825eb42bSJan Lentfer
1399825eb42bSJan Lentfer data[0] = precedence;
1400825eb42bSJan Lentfer data[1] = gateway_type;
1401825eb42bSJan Lentfer data[2] = algorithm;
1402825eb42bSJan Lentfer
1403825eb42bSJan Lentfer if (gateway_type) {
1404825eb42bSJan Lentfer memcpy(data + 3,
1405825eb42bSJan Lentfer ldns_rdf_data(gateway_rdf), ldns_rdf_size(gateway_rdf));
1406825eb42bSJan Lentfer memcpy(data + 3 + ldns_rdf_size(gateway_rdf),
1407825eb42bSJan Lentfer ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf));
1408825eb42bSJan Lentfer } else {
1409825eb42bSJan Lentfer memcpy(data + 3,
1410825eb42bSJan Lentfer ldns_rdf_data(publickey_rdf), ldns_rdf_size(publickey_rdf));
1411825eb42bSJan Lentfer }
1412825eb42bSJan Lentfer
1413825eb42bSJan Lentfer *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_IPSECKEY, (uint16_t) ipseckey_len, data);
1414825eb42bSJan Lentfer
1415825eb42bSJan Lentfer if (gateway)
1416825eb42bSJan Lentfer LDNS_FREE(gateway);
1417825eb42bSJan Lentfer if (publickey)
1418825eb42bSJan Lentfer LDNS_FREE(publickey);
1419825eb42bSJan Lentfer LDNS_FREE(token);
1420825eb42bSJan Lentfer ldns_buffer_free(str_buf);
1421*ee791febSAntonio Huete Jimenez ldns_rdf_deep_free(gateway_rdf);
1422*ee791febSAntonio Huete Jimenez ldns_rdf_deep_free(publickey_rdf);
1423825eb42bSJan Lentfer LDNS_FREE(data);
1424ac996e71SJan Lentfer if(!*rd) return LDNS_STATUS_MEM_ERR;
1425825eb42bSJan Lentfer return LDNS_STATUS_OK;
1426825eb42bSJan Lentfer }
14275340022aSzrj
14285340022aSzrj ldns_status
ldns_str2rdf_ilnp64(ldns_rdf ** rd,const char * str)14295340022aSzrj ldns_str2rdf_ilnp64(ldns_rdf **rd, const char *str)
14305340022aSzrj {
14315340022aSzrj unsigned int a, b, c, d;
14325340022aSzrj uint16_t shorts[4];
14335340022aSzrj int l;
14345340022aSzrj
14355340022aSzrj if (sscanf(str, "%4x:%4x:%4x:%4x%n", &a, &b, &c, &d, &l) != 4 ||
14365340022aSzrj l != (int)strlen(str) || /* more data to read */
14375340022aSzrj strpbrk(str, "+-") /* signed hexes */
14385340022aSzrj ) {
14395340022aSzrj return LDNS_STATUS_INVALID_ILNP64;
14405340022aSzrj } else {
14415340022aSzrj shorts[0] = htons(a);
14425340022aSzrj shorts[1] = htons(b);
14435340022aSzrj shorts[2] = htons(c);
14445340022aSzrj shorts[3] = htons(d);
14455340022aSzrj *rd = ldns_rdf_new_frm_data(
14465340022aSzrj LDNS_RDF_TYPE_ILNP64, 4 * sizeof(uint16_t), &shorts);
14475340022aSzrj }
14485340022aSzrj return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
14495340022aSzrj }
14505340022aSzrj
14515340022aSzrj ldns_status
ldns_str2rdf_eui48(ldns_rdf ** rd,const char * str)14525340022aSzrj ldns_str2rdf_eui48(ldns_rdf **rd, const char *str)
14535340022aSzrj {
14545340022aSzrj unsigned int a, b, c, d, e, f;
14555340022aSzrj uint8_t bytes[6];
14565340022aSzrj int l;
14575340022aSzrj
14585340022aSzrj if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x%n",
14595340022aSzrj &a, &b, &c, &d, &e, &f, &l) != 6 ||
14605340022aSzrj l != (int)strlen(str)) {
14615340022aSzrj return LDNS_STATUS_INVALID_EUI48;
14625340022aSzrj } else {
14635340022aSzrj bytes[0] = a;
14645340022aSzrj bytes[1] = b;
14655340022aSzrj bytes[2] = c;
14665340022aSzrj bytes[3] = d;
14675340022aSzrj bytes[4] = e;
14685340022aSzrj bytes[5] = f;
14695340022aSzrj *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_EUI48, 6, &bytes);
14705340022aSzrj }
14715340022aSzrj return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
14725340022aSzrj }
14735340022aSzrj
14745340022aSzrj ldns_status
ldns_str2rdf_eui64(ldns_rdf ** rd,const char * str)14755340022aSzrj ldns_str2rdf_eui64(ldns_rdf **rd, const char *str)
14765340022aSzrj {
14775340022aSzrj unsigned int a, b, c, d, e, f, g, h;
14785340022aSzrj uint8_t bytes[8];
14795340022aSzrj int l;
14805340022aSzrj
14815340022aSzrj if (sscanf(str, "%2x-%2x-%2x-%2x-%2x-%2x-%2x-%2x%n",
14825340022aSzrj &a, &b, &c, &d, &e, &f, &g, &h, &l) != 8 ||
14835340022aSzrj l != (int)strlen(str)) {
14845340022aSzrj return LDNS_STATUS_INVALID_EUI64;
14855340022aSzrj } else {
14865340022aSzrj bytes[0] = a;
14875340022aSzrj bytes[1] = b;
14885340022aSzrj bytes[2] = c;
14895340022aSzrj bytes[3] = d;
14905340022aSzrj bytes[4] = e;
14915340022aSzrj bytes[5] = f;
14925340022aSzrj bytes[6] = g;
14935340022aSzrj bytes[7] = h;
14945340022aSzrj *rd = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_EUI64, 8, &bytes);
14955340022aSzrj }
14965340022aSzrj return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
14975340022aSzrj }
14985340022aSzrj
14995340022aSzrj ldns_status
ldns_str2rdf_tag(ldns_rdf ** rd,const char * str)15005340022aSzrj ldns_str2rdf_tag(ldns_rdf **rd, const char *str)
15015340022aSzrj {
15025340022aSzrj uint8_t *data;
15035340022aSzrj const char* ptr;
15045340022aSzrj
15055340022aSzrj if (strlen(str) > 255) {
15065340022aSzrj return LDNS_STATUS_INVALID_TAG;
15075340022aSzrj }
15085340022aSzrj for (ptr = str; *ptr; ptr++) {
15095340022aSzrj if (! isalnum((unsigned char)*ptr)) {
15105340022aSzrj return LDNS_STATUS_INVALID_TAG;
15115340022aSzrj }
15125340022aSzrj }
15135340022aSzrj data = LDNS_XMALLOC(uint8_t, strlen(str) + 1);
15145340022aSzrj if (!data) {
15155340022aSzrj return LDNS_STATUS_MEM_ERR;
15165340022aSzrj }
15175340022aSzrj data[0] = strlen(str);
15185340022aSzrj memcpy(data + 1, str, strlen(str));
15195340022aSzrj
15205340022aSzrj *rd = ldns_rdf_new(LDNS_RDF_TYPE_TAG, strlen(str) + 1, data);
15215340022aSzrj if (!*rd) {
15225340022aSzrj LDNS_FREE(data);
15235340022aSzrj return LDNS_STATUS_MEM_ERR;
15245340022aSzrj }
15255340022aSzrj return LDNS_STATUS_OK;
15265340022aSzrj }
15275340022aSzrj
15285340022aSzrj ldns_status
ldns_str2rdf_long_str(ldns_rdf ** rd,const char * str)15295340022aSzrj ldns_str2rdf_long_str(ldns_rdf **rd, const char *str)
15305340022aSzrj {
15315340022aSzrj uint8_t *data, *dp, ch = 0;
15325340022aSzrj size_t length;
15335340022aSzrj
15345340022aSzrj /* Worst case space requirement. We'll realloc to actual size later. */
15355340022aSzrj dp = data = LDNS_XMALLOC(uint8_t, strlen(str));
15365340022aSzrj if (! data) {
15375340022aSzrj return LDNS_STATUS_MEM_ERR;
15385340022aSzrj }
15395340022aSzrj
15405340022aSzrj /* Fill data with parsed bytes */
15415340022aSzrj while (parse_char(&ch, &str)) {
15425340022aSzrj *dp++ = ch;
15435340022aSzrj if (dp - data > LDNS_MAX_RDFLEN) {
15445340022aSzrj LDNS_FREE(data);
15455340022aSzrj return LDNS_STATUS_INVALID_STR;
15465340022aSzrj }
15475340022aSzrj }
15485340022aSzrj if (! str) {
1549819dec71SDaniel Fojt LDNS_FREE(data);
15505340022aSzrj return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
15515340022aSzrj }
1552819dec71SDaniel Fojt if (!(length = (size_t)(dp - data))) {
1553*ee791febSAntonio Huete Jimenez /* An empty string is a data buffer of 0 bytes. The rdf for
1554*ee791febSAntonio Huete Jimenez * this long string has to have length 0 and point to NULL.
1555*ee791febSAntonio Huete Jimenez */
1556819dec71SDaniel Fojt LDNS_FREE(data);
1557*ee791febSAntonio Huete Jimenez data = NULL;
1558*ee791febSAntonio Huete Jimenez } else {
15595340022aSzrj /* Lose the overmeasure */
15605340022aSzrj data = LDNS_XREALLOC(dp = data, uint8_t, length);
15615340022aSzrj if (! data) {
15625340022aSzrj LDNS_FREE(dp);
15635340022aSzrj return LDNS_STATUS_MEM_ERR;
15645340022aSzrj }
1565*ee791febSAntonio Huete Jimenez }
15665340022aSzrj /* Create rdf */
15675340022aSzrj *rd = ldns_rdf_new(LDNS_RDF_TYPE_LONG_STR, length, data);
15685340022aSzrj if (! *rd) {
15695340022aSzrj LDNS_FREE(data);
15705340022aSzrj return LDNS_STATUS_MEM_ERR;
15715340022aSzrj }
15725340022aSzrj return LDNS_STATUS_OK;
15735340022aSzrj }
15745340022aSzrj
15755340022aSzrj ldns_status
ldns_str2rdf_hip(ldns_rdf ** rd,const char * str)15765340022aSzrj ldns_str2rdf_hip(ldns_rdf **rd, const char *str)
15775340022aSzrj {
1578819dec71SDaniel Fojt const char *hit = str == NULL ? NULL : strchr(str, ' ');
1579819dec71SDaniel Fojt const char *pk = hit == NULL ? NULL : strchr(hit + 1, ' ');
15805340022aSzrj size_t hit_size = hit == NULL ? 0
1581819dec71SDaniel Fojt : pk == NULL ? strlen(hit + 1) : (size_t) (pk - hit) - 1;
1582819dec71SDaniel Fojt size_t pk_size = pk == NULL ? 0 : strlen(pk + 1);
15835340022aSzrj size_t hit_wire_size = (hit_size + 1) / 2;
15845340022aSzrj size_t pk_wire_size = ldns_b64_pton_calculate_size(pk_size);
15855340022aSzrj size_t rdf_size = 4 + hit_wire_size + pk_wire_size;
15865340022aSzrj
15875340022aSzrj char *endptr; /* utility var for strtol usage */
1588819dec71SDaniel Fojt int algorithm = str == NULL ? 0 : strtol(str, &endptr, 10);
15895340022aSzrj
15905340022aSzrj uint8_t *data, *dp;
15915340022aSzrj int hi, lo, written;
15925340022aSzrj
15935340022aSzrj if (hit_size == 0 || pk_size == 0 || (hit_size + 1) / 2 > 255
15945340022aSzrj || rdf_size > LDNS_MAX_RDFLEN
15955340022aSzrj || algorithm < 0 || algorithm > 255
15965340022aSzrj || (errno != 0 && algorithm == 0) /* out of range */
15975340022aSzrj || endptr == str /* no digits */) {
15985340022aSzrj
15995340022aSzrj return LDNS_STATUS_SYNTAX_ERR;
16005340022aSzrj }
1601819dec71SDaniel Fojt hit += 1;
1602819dec71SDaniel Fojt pk += 1;
16035340022aSzrj if ((data = LDNS_XMALLOC(uint8_t, rdf_size)) == NULL) {
16045340022aSzrj
16055340022aSzrj return LDNS_STATUS_MEM_ERR;
16065340022aSzrj }
16075340022aSzrj /* From RFC 5205 section 5. HIP RR Storage Format:
16085340022aSzrj *************************************************
16095340022aSzrj
16105340022aSzrj 0 1 2 3
16115340022aSzrj 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
16125340022aSzrj +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
16135340022aSzrj | HIT length | PK algorithm | PK length |
16145340022aSzrj +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
16155340022aSzrj | |
16165340022aSzrj ~ HIT ~
16175340022aSzrj | |
16185340022aSzrj + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
16195340022aSzrj | | |
16205340022aSzrj +-+-+-+-+-+-+-+-+-+-+-+ +
16215340022aSzrj | Public Key |
16225340022aSzrj ~ ~
16235340022aSzrj | |
16245340022aSzrj + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
16255340022aSzrj | | |
16265340022aSzrj +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +
16275340022aSzrj | |
16285340022aSzrj ~ Rendezvous Servers ~
16295340022aSzrj | |
16305340022aSzrj + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
16315340022aSzrj | |
16325340022aSzrj +-+-+-+-+-+-+-+ */
16335340022aSzrj
16345340022aSzrj data[0] = (uint8_t) hit_wire_size;
16355340022aSzrj data[1] = (uint8_t) algorithm;
16365340022aSzrj
16375340022aSzrj for (dp = data + 4; *hit && *hit != ' '; dp++) {
16385340022aSzrj
16395340022aSzrj if ((hi = ldns_hexdigit_to_int(*hit++)) == -1 ||
16405340022aSzrj (lo = ldns_hexdigit_to_int(*hit++)) == -1) {
16415340022aSzrj
16425340022aSzrj LDNS_FREE(data);
16435340022aSzrj return LDNS_STATUS_INVALID_HEX;
16445340022aSzrj }
16455340022aSzrj *dp = (uint8_t) hi << 4 | lo;
16465340022aSzrj }
16475340022aSzrj if ((written = ldns_b64_pton(pk, dp, pk_wire_size)) <= 0) {
16485340022aSzrj
16495340022aSzrj LDNS_FREE(data);
16505340022aSzrj return LDNS_STATUS_INVALID_B64;
16515340022aSzrj }
16525340022aSzrj
16535340022aSzrj /* Because ldns_b64_pton_calculate_size isn't always correct:
16545340022aSzrj * (we have to fix it at some point)
16555340022aSzrj */
16565340022aSzrj pk_wire_size = (uint16_t) written;
16575340022aSzrj ldns_write_uint16(data + 2, pk_wire_size);
16585340022aSzrj rdf_size = 4 + hit_wire_size + pk_wire_size;
16595340022aSzrj
16605340022aSzrj /* Create rdf */
16615340022aSzrj if (! (*rd = ldns_rdf_new(LDNS_RDF_TYPE_HIP, rdf_size, data))) {
16625340022aSzrj
16635340022aSzrj LDNS_FREE(data);
16645340022aSzrj return LDNS_STATUS_MEM_ERR;
16655340022aSzrj }
16665340022aSzrj return LDNS_STATUS_OK;
16675340022aSzrj }
1668819dec71SDaniel Fojt
1669819dec71SDaniel Fojt
1670819dec71SDaniel Fojt /* Implementation mimics ldns_str2rdf_ipseckey */
1671819dec71SDaniel Fojt ldns_status
ldns_str2rdf_amtrelay(ldns_rdf ** rd,const char * str)1672819dec71SDaniel Fojt ldns_str2rdf_amtrelay(ldns_rdf **rd, const char *str)
1673819dec71SDaniel Fojt {
1674819dec71SDaniel Fojt /* From draft-ietf-mboned-driad-amt-discovery
1675819dec71SDaniel Fojt * Section 4.2. AMTRELAY RData Format
1676819dec71SDaniel Fojt *************************************************
1677819dec71SDaniel Fojt
1678819dec71SDaniel Fojt 0 1 2 3
1679819dec71SDaniel Fojt 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1680819dec71SDaniel Fojt +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1681819dec71SDaniel Fojt | precedence |D| type | |
1682819dec71SDaniel Fojt +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +
1683819dec71SDaniel Fojt ~ relay ~
1684819dec71SDaniel Fojt +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */
1685819dec71SDaniel Fojt
1686819dec71SDaniel Fojt uint8_t precedence = 0;
1687819dec71SDaniel Fojt uint8_t relay_type = 0;
1688819dec71SDaniel Fojt uint8_t discovery_optional = 0;
1689819dec71SDaniel Fojt char* relay = NULL;
1690819dec71SDaniel Fojt uint8_t *data;
1691819dec71SDaniel Fojt ldns_buffer *str_buf;
1692819dec71SDaniel Fojt char *token;
1693819dec71SDaniel Fojt int token_count = 0;
1694819dec71SDaniel Fojt int amtrelay_len = 0;
1695819dec71SDaniel Fojt ldns_rdf* relay_rdf = NULL;
1696819dec71SDaniel Fojt ldns_status status = LDNS_STATUS_OK;
1697819dec71SDaniel Fojt
1698819dec71SDaniel Fojt if(strlen(str) == 0)
1699819dec71SDaniel Fojt token = LDNS_XMALLOC(char, 256);
1700819dec71SDaniel Fojt else token = LDNS_XMALLOC(char, strlen(str)+2);
1701819dec71SDaniel Fojt if(!token) return LDNS_STATUS_MEM_ERR;
1702819dec71SDaniel Fojt
1703819dec71SDaniel Fojt str_buf = LDNS_MALLOC(ldns_buffer);
1704819dec71SDaniel Fojt if(!str_buf) {LDNS_FREE(token); return LDNS_STATUS_MEM_ERR;}
1705819dec71SDaniel Fojt ldns_buffer_new_frm_data(str_buf, (char *)str, strlen(str));
1706819dec71SDaniel Fojt if(ldns_buffer_status(str_buf) != LDNS_STATUS_OK) {
1707819dec71SDaniel Fojt LDNS_FREE(str_buf);
1708819dec71SDaniel Fojt LDNS_FREE(token);
1709819dec71SDaniel Fojt return LDNS_STATUS_MEM_ERR;
1710819dec71SDaniel Fojt }
1711819dec71SDaniel Fojt while(ldns_bget_token(str_buf, token, "\t\n ", strlen(str)) > 0) {
1712819dec71SDaniel Fojt switch (token_count) {
1713819dec71SDaniel Fojt case 0:
1714819dec71SDaniel Fojt precedence = (uint8_t)atoi(token);
1715819dec71SDaniel Fojt break;
1716819dec71SDaniel Fojt case 1:
1717819dec71SDaniel Fojt discovery_optional = (uint8_t)atoi(token);
1718819dec71SDaniel Fojt if (discovery_optional != 0 &&
1719819dec71SDaniel Fojt discovery_optional != 1) {
1720819dec71SDaniel Fojt LDNS_FREE(relay);
1721819dec71SDaniel Fojt LDNS_FREE(token);
1722819dec71SDaniel Fojt ldns_buffer_free(str_buf);
1723819dec71SDaniel Fojt return LDNS_STATUS_INVALID_STR;
1724819dec71SDaniel Fojt }
1725819dec71SDaniel Fojt break;
1726819dec71SDaniel Fojt case 2:
1727819dec71SDaniel Fojt relay_type = (uint8_t)atoi(token);
1728819dec71SDaniel Fojt break;
1729819dec71SDaniel Fojt case 3:
1730819dec71SDaniel Fojt relay = strdup(token);
1731819dec71SDaniel Fojt if (!relay || (relay_type == 0 &&
1732819dec71SDaniel Fojt (token[0] != '.' || token[1] != '\0'))) {
1733819dec71SDaniel Fojt LDNS_FREE(relay);
1734819dec71SDaniel Fojt LDNS_FREE(token);
1735819dec71SDaniel Fojt ldns_buffer_free(str_buf);
1736819dec71SDaniel Fojt return LDNS_STATUS_INVALID_STR;
1737819dec71SDaniel Fojt }
1738819dec71SDaniel Fojt break;
1739819dec71SDaniel Fojt default:
1740819dec71SDaniel Fojt LDNS_FREE(token);
1741819dec71SDaniel Fojt ldns_buffer_free(str_buf);
1742819dec71SDaniel Fojt return LDNS_STATUS_INVALID_STR;
1743819dec71SDaniel Fojt break;
1744819dec71SDaniel Fojt }
1745819dec71SDaniel Fojt token_count++;
1746819dec71SDaniel Fojt }
1747819dec71SDaniel Fojt if (!relay && relay_type > 0) {
1748819dec71SDaniel Fojt if (relay)
1749819dec71SDaniel Fojt LDNS_FREE(relay);
1750819dec71SDaniel Fojt LDNS_FREE(token);
1751819dec71SDaniel Fojt ldns_buffer_free(str_buf);
1752819dec71SDaniel Fojt return LDNS_STATUS_INVALID_STR;
1753819dec71SDaniel Fojt }
1754819dec71SDaniel Fojt
1755819dec71SDaniel Fojt if (relay_type == 1) {
1756819dec71SDaniel Fojt status = ldns_str2rdf_a(&relay_rdf, relay);
1757819dec71SDaniel Fojt } else if (relay_type == 2) {
1758819dec71SDaniel Fojt status = ldns_str2rdf_aaaa(&relay_rdf, relay);
1759819dec71SDaniel Fojt } else if (relay_type == 3) {
1760819dec71SDaniel Fojt status = ldns_str2rdf_dname(&relay_rdf, relay);
1761819dec71SDaniel Fojt } else if (relay_type > 3) {
1762819dec71SDaniel Fojt status = LDNS_STATUS_INVALID_STR;
1763819dec71SDaniel Fojt }
1764819dec71SDaniel Fojt
1765819dec71SDaniel Fojt if (status != LDNS_STATUS_OK) {
1766819dec71SDaniel Fojt if (relay)
1767819dec71SDaniel Fojt LDNS_FREE(relay);
1768819dec71SDaniel Fojt LDNS_FREE(token);
1769819dec71SDaniel Fojt ldns_buffer_free(str_buf);
1770819dec71SDaniel Fojt return LDNS_STATUS_INVALID_STR;
1771819dec71SDaniel Fojt }
1772819dec71SDaniel Fojt
1773819dec71SDaniel Fojt /* now copy all into one amtrelay rdf */
1774819dec71SDaniel Fojt if (relay_type)
1775819dec71SDaniel Fojt amtrelay_len = 2 + (int)ldns_rdf_size(relay_rdf);
1776819dec71SDaniel Fojt else
1777819dec71SDaniel Fojt amtrelay_len = 2;
1778819dec71SDaniel Fojt
1779819dec71SDaniel Fojt data = LDNS_XMALLOC(uint8_t, amtrelay_len);
1780819dec71SDaniel Fojt if(!data) {
1781819dec71SDaniel Fojt if (relay)
1782819dec71SDaniel Fojt LDNS_FREE(relay);
1783819dec71SDaniel Fojt LDNS_FREE(token);
1784819dec71SDaniel Fojt ldns_buffer_free(str_buf);
1785819dec71SDaniel Fojt if (relay_rdf) ldns_rdf_free(relay_rdf);
1786819dec71SDaniel Fojt return LDNS_STATUS_MEM_ERR;
1787819dec71SDaniel Fojt }
1788819dec71SDaniel Fojt
1789819dec71SDaniel Fojt data[0] = precedence;
1790819dec71SDaniel Fojt data[1] = relay_type;
1791819dec71SDaniel Fojt data[1] |= (discovery_optional << 7);
1792819dec71SDaniel Fojt
1793819dec71SDaniel Fojt if (relay_type) {
1794819dec71SDaniel Fojt memcpy(data + 2,
1795819dec71SDaniel Fojt ldns_rdf_data(relay_rdf), ldns_rdf_size(relay_rdf));
1796819dec71SDaniel Fojt }
1797819dec71SDaniel Fojt *rd = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_AMTRELAY
1798819dec71SDaniel Fojt , (uint16_t) amtrelay_len, data);
1799819dec71SDaniel Fojt
1800819dec71SDaniel Fojt if (relay)
1801819dec71SDaniel Fojt LDNS_FREE(relay);
1802819dec71SDaniel Fojt LDNS_FREE(token);
1803819dec71SDaniel Fojt ldns_buffer_free(str_buf);
1804819dec71SDaniel Fojt ldns_rdf_free(relay_rdf);
1805819dec71SDaniel Fojt LDNS_FREE(data);
1806819dec71SDaniel Fojt if(!*rd) return LDNS_STATUS_MEM_ERR;
1807819dec71SDaniel Fojt return LDNS_STATUS_OK;
1808819dec71SDaniel Fojt }
1809*ee791febSAntonio Huete Jimenez
1810*ee791febSAntonio Huete Jimenez #ifdef RRTYPE_SVCB_HTTPS
1811*ee791febSAntonio Huete Jimenez static int
network_uint16_cmp(const void * a,const void * b)1812*ee791febSAntonio Huete Jimenez network_uint16_cmp(const void *a, const void *b)
1813*ee791febSAntonio Huete Jimenez {
1814*ee791febSAntonio Huete Jimenez return ((int)ldns_read_uint16(a)) - ((int)ldns_read_uint16(b));
1815*ee791febSAntonio Huete Jimenez }
1816*ee791febSAntonio Huete Jimenez
1817*ee791febSAntonio Huete Jimenez static ldns_status parse_svcparam_key(const char **s, ldns_svcparam_key *key);
1818*ee791febSAntonio Huete Jimenez static ldns_status
parse_svcparam_mandatory(const char ** s,uint8_t ** dp,uint8_t * eod)1819*ee791febSAntonio Huete Jimenez parse_svcparam_mandatory(const char **s, uint8_t **dp, uint8_t *eod)
1820*ee791febSAntonio Huete Jimenez {
1821*ee791febSAntonio Huete Jimenez bool quoted = false;
1822*ee791febSAntonio Huete Jimenez uint8_t *keys = *dp;
1823*ee791febSAntonio Huete Jimenez int prev_key;
1824*ee791febSAntonio Huete Jimenez
1825*ee791febSAntonio Huete Jimenez if (**s == '"') {
1826*ee791febSAntonio Huete Jimenez *s += 1;
1827*ee791febSAntonio Huete Jimenez quoted = true;
1828*ee791febSAntonio Huete Jimenez }
1829*ee791febSAntonio Huete Jimenez for (;;) {
1830*ee791febSAntonio Huete Jimenez ldns_status st;
1831*ee791febSAntonio Huete Jimenez ldns_svcparam_key key;
1832*ee791febSAntonio Huete Jimenez
1833*ee791febSAntonio Huete Jimenez if ((st = parse_svcparam_key(s, &key)))
1834*ee791febSAntonio Huete Jimenez return st;
1835*ee791febSAntonio Huete Jimenez
1836*ee791febSAntonio Huete Jimenez if (*dp + 2 > eod)
1837*ee791febSAntonio Huete Jimenez return LDNS_STATUS_RDATA_OVERFLOW;
1838*ee791febSAntonio Huete Jimenez
1839*ee791febSAntonio Huete Jimenez ldns_write_uint16(*dp, key);
1840*ee791febSAntonio Huete Jimenez *dp += 2;
1841*ee791febSAntonio Huete Jimenez
1842*ee791febSAntonio Huete Jimenez if (**s == ',')
1843*ee791febSAntonio Huete Jimenez *s += 1;
1844*ee791febSAntonio Huete Jimenez else
1845*ee791febSAntonio Huete Jimenez break;
1846*ee791febSAntonio Huete Jimenez }
1847*ee791febSAntonio Huete Jimenez if (quoted) {
1848*ee791febSAntonio Huete Jimenez if (**s != '"')
1849*ee791febSAntonio Huete Jimenez return LDNS_STATUS_INVALID_STR;
1850*ee791febSAntonio Huete Jimenez *s += 1;
1851*ee791febSAntonio Huete Jimenez }
1852*ee791febSAntonio Huete Jimenez if (*dp - keys == 0)
1853*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
1854*ee791febSAntonio Huete Jimenez
1855*ee791febSAntonio Huete Jimenez if (**s && !isspace((unsigned char)**s))
1856*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
1857*ee791febSAntonio Huete Jimenez
1858*ee791febSAntonio Huete Jimenez /* In draft-ietf-dnsop-svcb-https-02 Section 7:
1859*ee791febSAntonio Huete Jimenez *
1860*ee791febSAntonio Huete Jimenez * In wire format, the keys are represented by their numeric
1861*ee791febSAntonio Huete Jimenez * values in network byte order, concatenated in ascending order.
1862*ee791febSAntonio Huete Jimenez */
1863*ee791febSAntonio Huete Jimenez qsort(keys, (*dp - keys) / 2, 2, network_uint16_cmp);
1864*ee791febSAntonio Huete Jimenez
1865*ee791febSAntonio Huete Jimenez /* In draft-ietf-dnsop-svcb-https-02 Section 7:
1866*ee791febSAntonio Huete Jimenez *
1867*ee791febSAntonio Huete Jimenez * Keys ...<snip>... MUST NOT appear more than once.
1868*ee791febSAntonio Huete Jimenez */
1869*ee791febSAntonio Huete Jimenez prev_key = -1;
1870*ee791febSAntonio Huete Jimenez while (keys < *dp) {
1871*ee791febSAntonio Huete Jimenez uint16_t key = ldns_read_uint16(keys);
1872*ee791febSAntonio Huete Jimenez
1873*ee791febSAntonio Huete Jimenez if (key == prev_key) {
1874*ee791febSAntonio Huete Jimenez /* "Be conservative in what you send,
1875*ee791febSAntonio Huete Jimenez * be liberal in what you accept"
1876*ee791febSAntonio Huete Jimenez *
1877*ee791febSAntonio Huete Jimenez * Instead of
1878*ee791febSAntonio Huete Jimenez * `return LDNS_STATUS_SVCPARAM_KEY_MORE_THAN_ONCE;`,
1879*ee791febSAntonio Huete Jimenez *
1880*ee791febSAntonio Huete Jimenez * we eliminate the double occurrence.
1881*ee791febSAntonio Huete Jimenez */
1882*ee791febSAntonio Huete Jimenez memmove(keys - 2, keys, *dp - keys);
1883*ee791febSAntonio Huete Jimenez *dp -= 2;
1884*ee791febSAntonio Huete Jimenez } else {
1885*ee791febSAntonio Huete Jimenez prev_key = key;
1886*ee791febSAntonio Huete Jimenez keys += 2;
1887*ee791febSAntonio Huete Jimenez }
1888*ee791febSAntonio Huete Jimenez }
1889*ee791febSAntonio Huete Jimenez return LDNS_STATUS_OK;
1890*ee791febSAntonio Huete Jimenez }
1891*ee791febSAntonio Huete Jimenez
parse_escape2(uint8_t * ch_p,const char ** str_p)1892*ee791febSAntonio Huete Jimenez INLINE bool parse_escape2(uint8_t *ch_p, const char** str_p)
1893*ee791febSAntonio Huete Jimenez { *str_p += 1; return parse_escape(ch_p, str_p); }
1894*ee791febSAntonio Huete Jimenez
1895*ee791febSAntonio Huete Jimenez static ldns_status
parse_svcparam_alpn(const char ** s,uint8_t ** dp,uint8_t * eod)1896*ee791febSAntonio Huete Jimenez parse_svcparam_alpn(const char **s, uint8_t **dp, uint8_t *eod)
1897*ee791febSAntonio Huete Jimenez {
1898*ee791febSAntonio Huete Jimenez uint8_t *val;
1899*ee791febSAntonio Huete Jimenez size_t len;
1900*ee791febSAntonio Huete Jimenez
1901*ee791febSAntonio Huete Jimenez if (*dp + 1 > eod)
1902*ee791febSAntonio Huete Jimenez return LDNS_STATUS_RDATA_OVERFLOW;
1903*ee791febSAntonio Huete Jimenez *dp += 1;
1904*ee791febSAntonio Huete Jimenez val = *dp;
1905*ee791febSAntonio Huete Jimenez if (**s == '"') {
1906*ee791febSAntonio Huete Jimenez *s += 1;
1907*ee791febSAntonio Huete Jimenez while (**s != '"') {
1908*ee791febSAntonio Huete Jimenez if (**s == 0)
1909*ee791febSAntonio Huete Jimenez return LDNS_STATUS_INVALID_STR;
1910*ee791febSAntonio Huete Jimenez
1911*ee791febSAntonio Huete Jimenez else if (**s == ',') {
1912*ee791febSAntonio Huete Jimenez len = *dp - val;
1913*ee791febSAntonio Huete Jimenez if (len == 0 || len > 255)
1914*ee791febSAntonio Huete Jimenez return LDNS_STATUS_INVALID_STR;
1915*ee791febSAntonio Huete Jimenez val[-1] = len;
1916*ee791febSAntonio Huete Jimenez if (*dp + 1 > eod)
1917*ee791febSAntonio Huete Jimenez return LDNS_STATUS_RDATA_OVERFLOW;
1918*ee791febSAntonio Huete Jimenez *dp += 1;
1919*ee791febSAntonio Huete Jimenez val = *dp;
1920*ee791febSAntonio Huete Jimenez *s += 1;
1921*ee791febSAntonio Huete Jimenez
1922*ee791febSAntonio Huete Jimenez } else if (*dp + 1 > eod)
1923*ee791febSAntonio Huete Jimenez return LDNS_STATUS_RDATA_OVERFLOW;
1924*ee791febSAntonio Huete Jimenez
1925*ee791febSAntonio Huete Jimenez else if (**s != '\\')
1926*ee791febSAntonio Huete Jimenez *(*dp)++ = (uint8_t)*(*s)++;
1927*ee791febSAntonio Huete Jimenez
1928*ee791febSAntonio Huete Jimenez else if (!parse_escape2(*dp, s))
1929*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
1930*ee791febSAntonio Huete Jimenez else
1931*ee791febSAntonio Huete Jimenez *dp += 1;
1932*ee791febSAntonio Huete Jimenez }
1933*ee791febSAntonio Huete Jimenez *s += 1;
1934*ee791febSAntonio Huete Jimenez
1935*ee791febSAntonio Huete Jimenez } else while (**s && !isspace((unsigned char)**s)) {
1936*ee791febSAntonio Huete Jimenez if (**s == ',') {
1937*ee791febSAntonio Huete Jimenez len = *dp - val;
1938*ee791febSAntonio Huete Jimenez if (len == 0 || len > 255)
1939*ee791febSAntonio Huete Jimenez return LDNS_STATUS_INVALID_STR;
1940*ee791febSAntonio Huete Jimenez val[-1] = len;
1941*ee791febSAntonio Huete Jimenez if (*dp + 1 > eod)
1942*ee791febSAntonio Huete Jimenez return LDNS_STATUS_RDATA_OVERFLOW;
1943*ee791febSAntonio Huete Jimenez *dp += 1;
1944*ee791febSAntonio Huete Jimenez val = *dp;
1945*ee791febSAntonio Huete Jimenez *s += 1;
1946*ee791febSAntonio Huete Jimenez
1947*ee791febSAntonio Huete Jimenez } else if (*dp + 1 > eod)
1948*ee791febSAntonio Huete Jimenez return LDNS_STATUS_RDATA_OVERFLOW;
1949*ee791febSAntonio Huete Jimenez
1950*ee791febSAntonio Huete Jimenez else if (**s != '\\')
1951*ee791febSAntonio Huete Jimenez *(*dp)++ = (uint8_t)*(*s)++;
1952*ee791febSAntonio Huete Jimenez
1953*ee791febSAntonio Huete Jimenez else if (!parse_escape2(*dp, s))
1954*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
1955*ee791febSAntonio Huete Jimenez else
1956*ee791febSAntonio Huete Jimenez *dp += 1;
1957*ee791febSAntonio Huete Jimenez }
1958*ee791febSAntonio Huete Jimenez len = *dp - val;
1959*ee791febSAntonio Huete Jimenez if (len == 0 || len > 255)
1960*ee791febSAntonio Huete Jimenez return LDNS_STATUS_INVALID_STR;
1961*ee791febSAntonio Huete Jimenez val[-1] = len;
1962*ee791febSAntonio Huete Jimenez return **s && !isspace((unsigned char)**s)
1963*ee791febSAntonio Huete Jimenez ? LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR
1964*ee791febSAntonio Huete Jimenez : LDNS_STATUS_OK;
1965*ee791febSAntonio Huete Jimenez }
1966*ee791febSAntonio Huete Jimenez
1967*ee791febSAntonio Huete Jimenez static ldns_status
parse_svcparam_value(const char ** s,uint8_t ** dp,uint8_t * eod)1968*ee791febSAntonio Huete Jimenez parse_svcparam_value(const char **s, uint8_t **dp, uint8_t *eod)
1969*ee791febSAntonio Huete Jimenez {
1970*ee791febSAntonio Huete Jimenez if (**s == '"') {
1971*ee791febSAntonio Huete Jimenez *s += 1;
1972*ee791febSAntonio Huete Jimenez while (**s != '"') {
1973*ee791febSAntonio Huete Jimenez if (**s == 0)
1974*ee791febSAntonio Huete Jimenez return LDNS_STATUS_INVALID_STR;
1975*ee791febSAntonio Huete Jimenez
1976*ee791febSAntonio Huete Jimenez else if (*dp + 1 > eod)
1977*ee791febSAntonio Huete Jimenez return LDNS_STATUS_RDATA_OVERFLOW;
1978*ee791febSAntonio Huete Jimenez
1979*ee791febSAntonio Huete Jimenez else if (**s != '\\')
1980*ee791febSAntonio Huete Jimenez *(*dp)++ = (uint8_t)*(*s)++;
1981*ee791febSAntonio Huete Jimenez
1982*ee791febSAntonio Huete Jimenez else if (!parse_escape2(*dp, s))
1983*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
1984*ee791febSAntonio Huete Jimenez else
1985*ee791febSAntonio Huete Jimenez *dp += 1;
1986*ee791febSAntonio Huete Jimenez }
1987*ee791febSAntonio Huete Jimenez *s += 1;
1988*ee791febSAntonio Huete Jimenez
1989*ee791febSAntonio Huete Jimenez } else while (**s && !isspace((unsigned char)**s)) {
1990*ee791febSAntonio Huete Jimenez if (*dp + 1 > eod)
1991*ee791febSAntonio Huete Jimenez return LDNS_STATUS_RDATA_OVERFLOW;
1992*ee791febSAntonio Huete Jimenez
1993*ee791febSAntonio Huete Jimenez else if (**s != '\\')
1994*ee791febSAntonio Huete Jimenez *(*dp)++ = (uint8_t)*(*s)++;
1995*ee791febSAntonio Huete Jimenez
1996*ee791febSAntonio Huete Jimenez else if (!parse_escape2(*dp, s))
1997*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_BAD_ESCAPE;
1998*ee791febSAntonio Huete Jimenez else
1999*ee791febSAntonio Huete Jimenez *dp += 1;
2000*ee791febSAntonio Huete Jimenez }
2001*ee791febSAntonio Huete Jimenez return **s && !isspace((unsigned char)**s)
2002*ee791febSAntonio Huete Jimenez ? LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR
2003*ee791febSAntonio Huete Jimenez : LDNS_STATUS_OK;
2004*ee791febSAntonio Huete Jimenez }
2005*ee791febSAntonio Huete Jimenez
2006*ee791febSAntonio Huete Jimenez static ldns_status
parse_svcparam_port(const char ** s,uint8_t ** dp,uint8_t * eod)2007*ee791febSAntonio Huete Jimenez parse_svcparam_port(const char **s, uint8_t **dp, uint8_t *eod)
2008*ee791febSAntonio Huete Jimenez {
2009*ee791febSAntonio Huete Jimenez uint8_t *val = *dp;
2010*ee791febSAntonio Huete Jimenez ldns_status st;
2011*ee791febSAntonio Huete Jimenez size_t len;
2012*ee791febSAntonio Huete Jimenez char num_str[6];
2013*ee791febSAntonio Huete Jimenez char *endptr;
2014*ee791febSAntonio Huete Jimenez unsigned long int num;
2015*ee791febSAntonio Huete Jimenez
2016*ee791febSAntonio Huete Jimenez if ((st = parse_svcparam_value(s, dp, eod)))
2017*ee791febSAntonio Huete Jimenez return st;
2018*ee791febSAntonio Huete Jimenez len = *dp - val;
2019*ee791febSAntonio Huete Jimenez if (len == 0 || len > 5)
2020*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2021*ee791febSAntonio Huete Jimenez
2022*ee791febSAntonio Huete Jimenez memcpy(num_str, val, len);
2023*ee791febSAntonio Huete Jimenez num_str[len] = 0;
2024*ee791febSAntonio Huete Jimenez num = strtoul(num_str, &endptr, 10);
2025*ee791febSAntonio Huete Jimenez if (*endptr)
2026*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2027*ee791febSAntonio Huete Jimenez
2028*ee791febSAntonio Huete Jimenez ldns_write_uint16(val, num);
2029*ee791febSAntonio Huete Jimenez *dp = val + 2;
2030*ee791febSAntonio Huete Jimenez return LDNS_STATUS_OK;
2031*ee791febSAntonio Huete Jimenez }
2032*ee791febSAntonio Huete Jimenez
2033*ee791febSAntonio Huete Jimenez static ldns_status
parse_svcparam_ipv4hint(const char ** s,uint8_t ** dp,uint8_t * eod)2034*ee791febSAntonio Huete Jimenez parse_svcparam_ipv4hint(const char **s, uint8_t **dp, uint8_t *eod)
2035*ee791febSAntonio Huete Jimenez {
2036*ee791febSAntonio Huete Jimenez bool quoted = false;
2037*ee791febSAntonio Huete Jimenez
2038*ee791febSAntonio Huete Jimenez if (**s == '"') {
2039*ee791febSAntonio Huete Jimenez *s += 1;
2040*ee791febSAntonio Huete Jimenez quoted = true;
2041*ee791febSAntonio Huete Jimenez }
2042*ee791febSAntonio Huete Jimenez for (;;) {
2043*ee791febSAntonio Huete Jimenez const char *ipv4_start = *s;
2044*ee791febSAntonio Huete Jimenez char ipv4_str[16];
2045*ee791febSAntonio Huete Jimenez size_t len;
2046*ee791febSAntonio Huete Jimenez
2047*ee791febSAntonio Huete Jimenez while (isdigit((unsigned char)**s) || **s == '.')
2048*ee791febSAntonio Huete Jimenez *s += 1;
2049*ee791febSAntonio Huete Jimenez
2050*ee791febSAntonio Huete Jimenez len = *s - ipv4_start;
2051*ee791febSAntonio Huete Jimenez if (len == 0 || len > 15)
2052*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2053*ee791febSAntonio Huete Jimenez
2054*ee791febSAntonio Huete Jimenez if (*dp + 4 > eod)
2055*ee791febSAntonio Huete Jimenez return LDNS_STATUS_RDATA_OVERFLOW;
2056*ee791febSAntonio Huete Jimenez
2057*ee791febSAntonio Huete Jimenez memcpy(ipv4_str, ipv4_start, len);
2058*ee791febSAntonio Huete Jimenez ipv4_str[len] = 0;
2059*ee791febSAntonio Huete Jimenez if (inet_pton(AF_INET, ipv4_str, *dp) != 1)
2060*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2061*ee791febSAntonio Huete Jimenez
2062*ee791febSAntonio Huete Jimenez *dp += 4;
2063*ee791febSAntonio Huete Jimenez if (**s == ',')
2064*ee791febSAntonio Huete Jimenez *s += 1;
2065*ee791febSAntonio Huete Jimenez else
2066*ee791febSAntonio Huete Jimenez break;
2067*ee791febSAntonio Huete Jimenez }
2068*ee791febSAntonio Huete Jimenez if (quoted) {
2069*ee791febSAntonio Huete Jimenez if (**s != '"')
2070*ee791febSAntonio Huete Jimenez return LDNS_STATUS_INVALID_STR;
2071*ee791febSAntonio Huete Jimenez *s += 1;
2072*ee791febSAntonio Huete Jimenez }
2073*ee791febSAntonio Huete Jimenez return **s && !isspace((unsigned char)**s)
2074*ee791febSAntonio Huete Jimenez ? LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR
2075*ee791febSAntonio Huete Jimenez : LDNS_STATUS_OK;
2076*ee791febSAntonio Huete Jimenez }
2077*ee791febSAntonio Huete Jimenez
2078*ee791febSAntonio Huete Jimenez static ldns_status
parse_svcparam_ech(const char ** s,uint8_t ** dp,uint8_t * eod)2079*ee791febSAntonio Huete Jimenez parse_svcparam_ech(const char **s, uint8_t **dp, uint8_t *eod)
2080*ee791febSAntonio Huete Jimenez {
2081*ee791febSAntonio Huete Jimenez bool quoted = false;
2082*ee791febSAntonio Huete Jimenez const char *b64_str;
2083*ee791febSAntonio Huete Jimenez size_t len, pad, out_len;
2084*ee791febSAntonio Huete Jimenez char in_buf[4096];
2085*ee791febSAntonio Huete Jimenez char *in = in_buf;
2086*ee791febSAntonio Huete Jimenez int out;
2087*ee791febSAntonio Huete Jimenez
2088*ee791febSAntonio Huete Jimenez if (**s == '"') {
2089*ee791febSAntonio Huete Jimenez *s += 1;
2090*ee791febSAntonio Huete Jimenez quoted = true;
2091*ee791febSAntonio Huete Jimenez }
2092*ee791febSAntonio Huete Jimenez b64_str = *s;
2093*ee791febSAntonio Huete Jimenez while (isalnum((unsigned char)**s) || **s == '+'
2094*ee791febSAntonio Huete Jimenez || **s == '/'
2095*ee791febSAntonio Huete Jimenez || **s == '=')
2096*ee791febSAntonio Huete Jimenez *s += 1;
2097*ee791febSAntonio Huete Jimenez
2098*ee791febSAntonio Huete Jimenez len = *s - b64_str;
2099*ee791febSAntonio Huete Jimenez pad = len % 4;
2100*ee791febSAntonio Huete Jimenez pad = pad ? 4 - pad : 0;
2101*ee791febSAntonio Huete Jimenez if (len == 0 || pad == 3)
2102*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2103*ee791febSAntonio Huete Jimenez
2104*ee791febSAntonio Huete Jimenez if (quoted) {
2105*ee791febSAntonio Huete Jimenez if (**s != '"')
2106*ee791febSAntonio Huete Jimenez return LDNS_STATUS_INVALID_STR;
2107*ee791febSAntonio Huete Jimenez *s += 1;
2108*ee791febSAntonio Huete Jimenez }
2109*ee791febSAntonio Huete Jimenez if (**s && !isspace((unsigned char)**s))
2110*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2111*ee791febSAntonio Huete Jimenez
2112*ee791febSAntonio Huete Jimenez out_len = ldns_b64_pton_calculate_size(len);
2113*ee791febSAntonio Huete Jimenez if (*dp + out_len > eod)
2114*ee791febSAntonio Huete Jimenez return LDNS_STATUS_RDATA_OVERFLOW;
2115*ee791febSAntonio Huete Jimenez
2116*ee791febSAntonio Huete Jimenez if (len + pad > sizeof(in_buf) - 1
2117*ee791febSAntonio Huete Jimenez && !(in = LDNS_XMALLOC(char, len + pad + 1)))
2118*ee791febSAntonio Huete Jimenez return LDNS_STATUS_MEM_ERR;
2119*ee791febSAntonio Huete Jimenez
2120*ee791febSAntonio Huete Jimenez memcpy(in, b64_str, len);
2121*ee791febSAntonio Huete Jimenez while (pad--)
2122*ee791febSAntonio Huete Jimenez in[len++] = '=';
2123*ee791febSAntonio Huete Jimenez in[len] = 0;
2124*ee791febSAntonio Huete Jimenez out = ldns_b64_pton(in, *dp, out_len);
2125*ee791febSAntonio Huete Jimenez if (in != in_buf)
2126*ee791febSAntonio Huete Jimenez LDNS_FREE(in);
2127*ee791febSAntonio Huete Jimenez
2128*ee791febSAntonio Huete Jimenez if (out <= 0)
2129*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2130*ee791febSAntonio Huete Jimenez
2131*ee791febSAntonio Huete Jimenez *dp += out;
2132*ee791febSAntonio Huete Jimenez return LDNS_STATUS_OK;
2133*ee791febSAntonio Huete Jimenez }
2134*ee791febSAntonio Huete Jimenez
2135*ee791febSAntonio Huete Jimenez static ldns_status
parse_svcparam_ipv6hint(const char ** s,uint8_t ** dp,uint8_t * eod)2136*ee791febSAntonio Huete Jimenez parse_svcparam_ipv6hint(const char **s, uint8_t **dp, uint8_t *eod)
2137*ee791febSAntonio Huete Jimenez {
2138*ee791febSAntonio Huete Jimenez bool quoted = false;
2139*ee791febSAntonio Huete Jimenez
2140*ee791febSAntonio Huete Jimenez if (**s == '"') {
2141*ee791febSAntonio Huete Jimenez *s += 1;
2142*ee791febSAntonio Huete Jimenez quoted = true;
2143*ee791febSAntonio Huete Jimenez }
2144*ee791febSAntonio Huete Jimenez for (;;) {
2145*ee791febSAntonio Huete Jimenez const char *ipv6_start = *s;
2146*ee791febSAntonio Huete Jimenez char ipv6_str[INET6_ADDRSTRLEN];
2147*ee791febSAntonio Huete Jimenez size_t len;
2148*ee791febSAntonio Huete Jimenez
2149*ee791febSAntonio Huete Jimenez while (isxdigit((unsigned char)**s) || **s == ':' || **s == '.')
2150*ee791febSAntonio Huete Jimenez *s += 1;
2151*ee791febSAntonio Huete Jimenez
2152*ee791febSAntonio Huete Jimenez len = *s - ipv6_start;
2153*ee791febSAntonio Huete Jimenez if (len == 0 || len > INET6_ADDRSTRLEN)
2154*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2155*ee791febSAntonio Huete Jimenez
2156*ee791febSAntonio Huete Jimenez if (*dp + 16 > eod)
2157*ee791febSAntonio Huete Jimenez return LDNS_STATUS_RDATA_OVERFLOW;
2158*ee791febSAntonio Huete Jimenez
2159*ee791febSAntonio Huete Jimenez memcpy(ipv6_str, ipv6_start, len);
2160*ee791febSAntonio Huete Jimenez ipv6_str[len] = 0;
2161*ee791febSAntonio Huete Jimenez if (inet_pton(AF_INET6, ipv6_str, *dp) != 1)
2162*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR;
2163*ee791febSAntonio Huete Jimenez
2164*ee791febSAntonio Huete Jimenez *dp += 16;
2165*ee791febSAntonio Huete Jimenez if (**s == ',')
2166*ee791febSAntonio Huete Jimenez *s += 1;
2167*ee791febSAntonio Huete Jimenez else
2168*ee791febSAntonio Huete Jimenez break;
2169*ee791febSAntonio Huete Jimenez }
2170*ee791febSAntonio Huete Jimenez if (quoted) {
2171*ee791febSAntonio Huete Jimenez if (**s != '"')
2172*ee791febSAntonio Huete Jimenez return LDNS_STATUS_INVALID_STR;
2173*ee791febSAntonio Huete Jimenez *s += 1;
2174*ee791febSAntonio Huete Jimenez }
2175*ee791febSAntonio Huete Jimenez return **s && !isspace((unsigned char)**s)
2176*ee791febSAntonio Huete Jimenez ? LDNS_STATUS_SYNTAX_SVCPARAM_VALUE_ERR
2177*ee791febSAntonio Huete Jimenez : LDNS_STATUS_OK;
2178*ee791febSAntonio Huete Jimenez }
2179*ee791febSAntonio Huete Jimenez
2180*ee791febSAntonio Huete Jimenez struct struct_svcparam_key_def {
2181*ee791febSAntonio Huete Jimenez const char *str;
2182*ee791febSAntonio Huete Jimenez size_t len;
2183*ee791febSAntonio Huete Jimenez };
2184*ee791febSAntonio Huete Jimenez typedef struct struct_svcparam_key_def svcparam_key_def;
2185*ee791febSAntonio Huete Jimenez
2186*ee791febSAntonio Huete Jimenez static svcparam_key_def svcparam_key_defs[] = { { "mandatory" , 9 }
2187*ee791febSAntonio Huete Jimenez , { "alpn" , 4 }
2188*ee791febSAntonio Huete Jimenez , { "no-default-alpn", 15 }
2189*ee791febSAntonio Huete Jimenez , { "port" , 4 }
2190*ee791febSAntonio Huete Jimenez , { "ipv4hint" , 8 }
2191*ee791febSAntonio Huete Jimenez , { "ech" , 3 }
2192*ee791febSAntonio Huete Jimenez , { "ipv6hint" , 8 }
2193*ee791febSAntonio Huete Jimenez , { "dohpath" , 7 } };
2194*ee791febSAntonio Huete Jimenez
2195*ee791febSAntonio Huete Jimenez static const size_t svcparam_key_defs_len = sizeof(svcparam_key_defs)
2196*ee791febSAntonio Huete Jimenez / sizeof(svcparam_key_def);
2197*ee791febSAntonio Huete Jimenez
2198*ee791febSAntonio Huete Jimenez /* svcparam_key2buffer_str() should actually be in host2str.c, but we need the
2199*ee791febSAntonio Huete Jimenez * svcparam_key_defs for it and it is not an exposed symbol anyway.
2200*ee791febSAntonio Huete Jimenez */
svcparam_key2buffer_str(ldns_buffer * output,uint16_t key)2201*ee791febSAntonio Huete Jimenez ldns_status svcparam_key2buffer_str(ldns_buffer *output, uint16_t key)
2202*ee791febSAntonio Huete Jimenez {
2203*ee791febSAntonio Huete Jimenez if (key <= LDNS_SVCPARAM_KEY_LAST_KEY)
2204*ee791febSAntonio Huete Jimenez ldns_buffer_write_string(output, svcparam_key_defs[key].str);
2205*ee791febSAntonio Huete Jimenez else
2206*ee791febSAntonio Huete Jimenez ldns_buffer_printf(output, "key%d", (int)key);
2207*ee791febSAntonio Huete Jimenez return ldns_buffer_status(output);
2208*ee791febSAntonio Huete Jimenez }
2209*ee791febSAntonio Huete Jimenez
2210*ee791febSAntonio Huete Jimenez static ldns_status
parse_svcparam_key(const char ** s,ldns_svcparam_key * key)2211*ee791febSAntonio Huete Jimenez parse_svcparam_key(const char **s, ldns_svcparam_key *key)
2212*ee791febSAntonio Huete Jimenez {
2213*ee791febSAntonio Huete Jimenez size_t i, len;
2214*ee791febSAntonio Huete Jimenez const char *key_str = *s;
2215*ee791febSAntonio Huete Jimenez char num_str[6];
2216*ee791febSAntonio Huete Jimenez char *endptr;
2217*ee791febSAntonio Huete Jimenez unsigned long int num;
2218*ee791febSAntonio Huete Jimenez
2219*ee791febSAntonio Huete Jimenez /* parse key */
2220*ee791febSAntonio Huete Jimenez while (islower((unsigned char)**s) || isdigit((unsigned char)**s)
2221*ee791febSAntonio Huete Jimenez || **s == '-')
2222*ee791febSAntonio Huete Jimenez *s += 1;
2223*ee791febSAntonio Huete Jimenez
2224*ee791febSAntonio Huete Jimenez len = *s - key_str;
2225*ee791febSAntonio Huete Jimenez for (i = 0; i < svcparam_key_defs_len; i++) {
2226*ee791febSAntonio Huete Jimenez if (len == svcparam_key_defs[i].len
2227*ee791febSAntonio Huete Jimenez && !strncmp(key_str, svcparam_key_defs[i].str, len)) {
2228*ee791febSAntonio Huete Jimenez *key = i;
2229*ee791febSAntonio Huete Jimenez return LDNS_STATUS_OK;
2230*ee791febSAntonio Huete Jimenez }
2231*ee791febSAntonio Huete Jimenez }
2232*ee791febSAntonio Huete Jimenez /* Also allow "echconfig" from earlier draft versions. */
2233*ee791febSAntonio Huete Jimenez if (len == 9 && !strncmp(key_str, "echconfig", 9)) {
2234*ee791febSAntonio Huete Jimenez *key = LDNS_SVCPARAM_KEY_ECH;
2235*ee791febSAntonio Huete Jimenez return LDNS_STATUS_OK;
2236*ee791febSAntonio Huete Jimenez }
2237*ee791febSAntonio Huete Jimenez if (len < 4 || len > 8 || strncmp(key_str, "key", 3))
2238*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_SVCPARAM_KEY_ERR;
2239*ee791febSAntonio Huete Jimenez
2240*ee791febSAntonio Huete Jimenez memcpy(num_str, key_str + 3, len - 3);
2241*ee791febSAntonio Huete Jimenez num_str[len - 3] = 0;
2242*ee791febSAntonio Huete Jimenez num = strtoul(num_str, &endptr, 10);
2243*ee791febSAntonio Huete Jimenez if (*endptr || num > 65535)
2244*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_SVCPARAM_KEY_ERR;
2245*ee791febSAntonio Huete Jimenez
2246*ee791febSAntonio Huete Jimenez /* key65535 is Reserved to be an ("Invalid key"), though there is no
2247*ee791febSAntonio Huete Jimenez * physiological reason to deny usage. We restrict ourselves to the
2248*ee791febSAntonio Huete Jimenez * anatomical limitations only to maximize serviceability.
2249*ee791febSAntonio Huete Jimenez * ```
2250*ee791febSAntonio Huete Jimenez * if (num == 65535)
2251*ee791febSAntonio Huete Jimenez * return LDNS_STATUS_RESERVED_SVCPARAM_KEY;
2252*ee791febSAntonio Huete Jimenez * ```
2253*ee791febSAntonio Huete Jimenez */
2254*ee791febSAntonio Huete Jimenez *key = num;
2255*ee791febSAntonio Huete Jimenez return LDNS_STATUS_OK;
2256*ee791febSAntonio Huete Jimenez }
2257*ee791febSAntonio Huete Jimenez
2258*ee791febSAntonio Huete Jimenez static ldns_status
parse_svcparam(const char ** s,uint8_t ** dp,uint8_t * eod)2259*ee791febSAntonio Huete Jimenez parse_svcparam(const char **s, uint8_t **dp, uint8_t *eod)
2260*ee791febSAntonio Huete Jimenez {
2261*ee791febSAntonio Huete Jimenez ldns_svcparam_key key;
2262*ee791febSAntonio Huete Jimenez ldns_status st;
2263*ee791febSAntonio Huete Jimenez uint8_t *val;
2264*ee791febSAntonio Huete Jimenez
2265*ee791febSAntonio Huete Jimenez if (*dp + 4 > eod)
2266*ee791febSAntonio Huete Jimenez return LDNS_STATUS_RDATA_OVERFLOW;
2267*ee791febSAntonio Huete Jimenez
2268*ee791febSAntonio Huete Jimenez if ((st = parse_svcparam_key(s, &key)))
2269*ee791febSAntonio Huete Jimenez return st;
2270*ee791febSAntonio Huete Jimenez
2271*ee791febSAntonio Huete Jimenez ldns_write_uint16(*dp, key);
2272*ee791febSAntonio Huete Jimenez ldns_write_uint16(*dp + 2, 0);
2273*ee791febSAntonio Huete Jimenez *dp += 4;
2274*ee791febSAntonio Huete Jimenez if (isspace((unsigned char)**s) || !**s)
2275*ee791febSAntonio Huete Jimenez return LDNS_STATUS_OK;
2276*ee791febSAntonio Huete Jimenez
2277*ee791febSAntonio Huete Jimenez else if (**s != '=')
2278*ee791febSAntonio Huete Jimenez return LDNS_STATUS_SYNTAX_ERR;
2279*ee791febSAntonio Huete Jimenez *s += 1;
2280*ee791febSAntonio Huete Jimenez val = *dp;
2281*ee791febSAntonio Huete Jimenez switch(key) {
2282*ee791febSAntonio Huete Jimenez case LDNS_SVCPARAM_KEY_MANDATORY:
2283*ee791febSAntonio Huete Jimenez st = parse_svcparam_mandatory(s, dp, eod);
2284*ee791febSAntonio Huete Jimenez break;
2285*ee791febSAntonio Huete Jimenez case LDNS_SVCPARAM_KEY_ALPN:
2286*ee791febSAntonio Huete Jimenez st = parse_svcparam_alpn(s, dp, eod);
2287*ee791febSAntonio Huete Jimenez break;
2288*ee791febSAntonio Huete Jimenez case LDNS_SVCPARAM_KEY_NO_DEFAULT_ALPN:
2289*ee791febSAntonio Huete Jimenez return LDNS_STATUS_NO_SVCPARAM_VALUE_EXPECTED;
2290*ee791febSAntonio Huete Jimenez case LDNS_SVCPARAM_KEY_PORT:
2291*ee791febSAntonio Huete Jimenez st = parse_svcparam_port(s, dp, eod);
2292*ee791febSAntonio Huete Jimenez break;
2293*ee791febSAntonio Huete Jimenez case LDNS_SVCPARAM_KEY_IPV4HINT:
2294*ee791febSAntonio Huete Jimenez st = parse_svcparam_ipv4hint(s, dp, eod);
2295*ee791febSAntonio Huete Jimenez break;
2296*ee791febSAntonio Huete Jimenez case LDNS_SVCPARAM_KEY_ECH:
2297*ee791febSAntonio Huete Jimenez st = parse_svcparam_ech(s, dp, eod);
2298*ee791febSAntonio Huete Jimenez break;
2299*ee791febSAntonio Huete Jimenez case LDNS_SVCPARAM_KEY_IPV6HINT:
2300*ee791febSAntonio Huete Jimenez st = parse_svcparam_ipv6hint(s, dp, eod);
2301*ee791febSAntonio Huete Jimenez break;
2302*ee791febSAntonio Huete Jimenez default:
2303*ee791febSAntonio Huete Jimenez st = parse_svcparam_value(s, dp, eod);
2304*ee791febSAntonio Huete Jimenez break;
2305*ee791febSAntonio Huete Jimenez }
2306*ee791febSAntonio Huete Jimenez if (st)
2307*ee791febSAntonio Huete Jimenez return st;
2308*ee791febSAntonio Huete Jimenez ldns_write_uint16(val - 2, *dp - val);
2309*ee791febSAntonio Huete Jimenez return LDNS_STATUS_OK;
2310*ee791febSAntonio Huete Jimenez }
2311*ee791febSAntonio Huete Jimenez
2312*ee791febSAntonio Huete Jimenez static int
svcparam_ptr_cmp(const void * a,const void * b)2313*ee791febSAntonio Huete Jimenez svcparam_ptr_cmp(const void *a, const void *b)
2314*ee791febSAntonio Huete Jimenez {
2315*ee791febSAntonio Huete Jimenez uint8_t *x = *(uint8_t **)a , *y = *(uint8_t **)b;
2316*ee791febSAntonio Huete Jimenez uint16_t x_type = ldns_read_uint16(x), y_type = ldns_read_uint16(y);
2317*ee791febSAntonio Huete Jimenez uint16_t x_len , y_len;
2318*ee791febSAntonio Huete Jimenez
2319*ee791febSAntonio Huete Jimenez if (x_type != y_type)
2320*ee791febSAntonio Huete Jimenez return x_type > y_type ? 1 : -1;
2321*ee791febSAntonio Huete Jimenez
2322*ee791febSAntonio Huete Jimenez x_len = ldns_read_uint16(x + 2);
2323*ee791febSAntonio Huete Jimenez y_len = ldns_read_uint16(y + 2);
2324*ee791febSAntonio Huete Jimenez
2325*ee791febSAntonio Huete Jimenez return x_len != y_len
2326*ee791febSAntonio Huete Jimenez ? (x_len > y_len ? 1 : -1)
2327*ee791febSAntonio Huete Jimenez : (x_len == 0 ? 0 : memcmp(x + 4, y + 4, x_len));
2328*ee791febSAntonio Huete Jimenez }
2329*ee791febSAntonio Huete Jimenez
2330*ee791febSAntonio Huete Jimenez ldns_status
ldns_str2rdf_svcparams(ldns_rdf ** rd,const char * str)2331*ee791febSAntonio Huete Jimenez ldns_str2rdf_svcparams(ldns_rdf **rd, const char *str)
2332*ee791febSAntonio Huete Jimenez {
2333*ee791febSAntonio Huete Jimenez uint8_t *data, *dp, *eod, *p, *new_data;
2334*ee791febSAntonio Huete Jimenez ldns_status st = LDNS_STATUS_OK;
2335*ee791febSAntonio Huete Jimenez size_t length, i;
2336*ee791febSAntonio Huete Jimenez size_t nparams = 0;
2337*ee791febSAntonio Huete Jimenez uint8_t **svcparams;
2338*ee791febSAntonio Huete Jimenez int prev_key;
2339*ee791febSAntonio Huete Jimenez
2340*ee791febSAntonio Huete Jimenez if (!rd || !str)
2341*ee791febSAntonio Huete Jimenez return LDNS_STATUS_NULL;
2342*ee791febSAntonio Huete Jimenez
2343*ee791febSAntonio Huete Jimenez length = strlen(str);
2344*ee791febSAntonio Huete Jimenez /* Worst case space requirement. We'll realloc to actual size later. */
2345*ee791febSAntonio Huete Jimenez if (!(dp = data = LDNS_XMALLOC(uint8_t, length * 4)))
2346*ee791febSAntonio Huete Jimenez return LDNS_STATUS_MEM_ERR;
2347*ee791febSAntonio Huete Jimenez eod = data + length * 4;
2348*ee791febSAntonio Huete Jimenez
2349*ee791febSAntonio Huete Jimenez /* Fill data with parsed bytes */
2350*ee791febSAntonio Huete Jimenez for (;;) {
2351*ee791febSAntonio Huete Jimenez while (isspace((unsigned char)*str))
2352*ee791febSAntonio Huete Jimenez str += 1;
2353*ee791febSAntonio Huete Jimenez if(!*str)
2354*ee791febSAntonio Huete Jimenez break;
2355*ee791febSAntonio Huete Jimenez if ((st = parse_svcparam(&str, &dp, eod))) {
2356*ee791febSAntonio Huete Jimenez LDNS_FREE(data);
2357*ee791febSAntonio Huete Jimenez return st;
2358*ee791febSAntonio Huete Jimenez }
2359*ee791febSAntonio Huete Jimenez nparams += 1;
2360*ee791febSAntonio Huete Jimenez }
2361*ee791febSAntonio Huete Jimenez
2362*ee791febSAntonio Huete Jimenez /* draft-ietf-dnsop-svcb-https-02 in Section 2.2:
2363*ee791febSAntonio Huete Jimenez *
2364*ee791febSAntonio Huete Jimenez * SvcParamKeys SHALL appear in increasing numeric order
2365*ee791febSAntonio Huete Jimenez *
2366*ee791febSAntonio Huete Jimenez * A svcparams array (with pointers to the individual key, value pairs)
2367*ee791febSAntonio Huete Jimenez * is created to qsort the pairs in increasing numeric order.
2368*ee791febSAntonio Huete Jimenez */
2369*ee791febSAntonio Huete Jimenez if (!(svcparams = LDNS_XMALLOC(uint8_t *, nparams))) {
2370*ee791febSAntonio Huete Jimenez LDNS_FREE(data);
2371*ee791febSAntonio Huete Jimenez return LDNS_STATUS_MEM_ERR;
2372*ee791febSAntonio Huete Jimenez }
2373*ee791febSAntonio Huete Jimenez for ( p = data, i = 0
2374*ee791febSAntonio Huete Jimenez ; p < dp && i < nparams
2375*ee791febSAntonio Huete Jimenez ; p += 4 + ldns_read_uint16(p + 2))
2376*ee791febSAntonio Huete Jimenez svcparams[i++] = p;
2377*ee791febSAntonio Huete Jimenez
2378*ee791febSAntonio Huete Jimenez qsort(svcparams, i, sizeof(uint8_t *), svcparam_ptr_cmp);
2379*ee791febSAntonio Huete Jimenez
2380*ee791febSAntonio Huete Jimenez /* Write out the (key, value) pairs to a newly allocated data in
2381*ee791febSAntonio Huete Jimenez * sorted order.
2382*ee791febSAntonio Huete Jimenez */
2383*ee791febSAntonio Huete Jimenez length = dp - data;
2384*ee791febSAntonio Huete Jimenez if (!(new_data = LDNS_XMALLOC(uint8_t, length))) {
2385*ee791febSAntonio Huete Jimenez LDNS_FREE(data);
2386*ee791febSAntonio Huete Jimenez LDNS_FREE(svcparams);
2387*ee791febSAntonio Huete Jimenez return LDNS_STATUS_MEM_ERR;
2388*ee791febSAntonio Huete Jimenez }
2389*ee791febSAntonio Huete Jimenez prev_key = -1;
2390*ee791febSAntonio Huete Jimenez for ( p = new_data, i = 0
2391*ee791febSAntonio Huete Jimenez ; p < new_data + length && i < nparams
2392*ee791febSAntonio Huete Jimenez ; p += 4 + ldns_read_uint16(p + 2), i += 1) {
2393*ee791febSAntonio Huete Jimenez uint16_t key = ldns_read_uint16(svcparams[i]);
2394*ee791febSAntonio Huete Jimenez
2395*ee791febSAntonio Huete Jimenez /* In draft-ietf-dnsop-svcb-https-02 Section 2.1:
2396*ee791febSAntonio Huete Jimenez *
2397*ee791febSAntonio Huete Jimenez * SvcParams ...<snip>... keys MUST NOT be repeated.
2398*ee791febSAntonio Huete Jimenez *
2399*ee791febSAntonio Huete Jimenez * ldns will not impose this limitation on the library user,
2400*ee791febSAntonio Huete Jimenez * but we can merge completely equal repetitions into one.
2401*ee791febSAntonio Huete Jimenez * So, not doing
2402*ee791febSAntonio Huete Jimenez * ```
2403*ee791febSAntonio Huete Jimenez * if (key == prev_key)
2404*ee791febSAntonio Huete Jimenez * return LDNS_STATUS_SVCPARAM_KEY_MORE_THAN_ONCE;
2405*ee791febSAntonio Huete Jimenez * ```
2406*ee791febSAntonio Huete Jimenez * but instead:
2407*ee791febSAntonio Huete Jimenez */
2408*ee791febSAntonio Huete Jimenez if (key == prev_key && ldns_read_uint16(svcparams[i] + 2)
2409*ee791febSAntonio Huete Jimenez == ldns_read_uint16(svcparams[i - 1] + 2)
2410*ee791febSAntonio Huete Jimenez && 0 == memcmp( svcparams[i ] + 4
2411*ee791febSAntonio Huete Jimenez , svcparams[i - 1] + 4
2412*ee791febSAntonio Huete Jimenez , ldns_read_uint16(svcparams[i] + 2))) {
2413*ee791febSAntonio Huete Jimenez p -= 4 + ldns_read_uint16(svcparams[i] + 2);
2414*ee791febSAntonio Huete Jimenez continue;
2415*ee791febSAntonio Huete Jimenez }
2416*ee791febSAntonio Huete Jimenez memcpy(p, svcparams[i], 4 + ldns_read_uint16(svcparams[i] + 2));
2417*ee791febSAntonio Huete Jimenez prev_key = key;
2418*ee791febSAntonio Huete Jimenez }
2419*ee791febSAntonio Huete Jimenez LDNS_FREE(data);
2420*ee791febSAntonio Huete Jimenez LDNS_FREE(svcparams);
2421*ee791febSAntonio Huete Jimenez
2422*ee791febSAntonio Huete Jimenez /* Create rdf */
2423*ee791febSAntonio Huete Jimenez *rd = ldns_rdf_new(LDNS_RDF_TYPE_SVCPARAMS, p - new_data, new_data);
2424*ee791febSAntonio Huete Jimenez if (! *rd) {
2425*ee791febSAntonio Huete Jimenez LDNS_FREE(new_data);
2426*ee791febSAntonio Huete Jimenez return LDNS_STATUS_MEM_ERR;
2427*ee791febSAntonio Huete Jimenez }
2428*ee791febSAntonio Huete Jimenez return LDNS_STATUS_OK;
2429*ee791febSAntonio Huete Jimenez }
2430*ee791febSAntonio Huete Jimenez #else /* #ifdef RRTYPE_SVCB_HTTPS */
2431*ee791febSAntonio Huete Jimenez ldns_status
ldns_str2rdf_svcparams(ldns_rdf ** rd,const char * str)2432*ee791febSAntonio Huete Jimenez ldns_str2rdf_svcparams(ldns_rdf **rd, const char *str)
2433*ee791febSAntonio Huete Jimenez {
2434*ee791febSAntonio Huete Jimenez (void)rd; (void)str;
2435*ee791febSAntonio Huete Jimenez return LDNS_STATUS_NOT_IMPL;
2436*ee791febSAntonio Huete Jimenez }
2437*ee791febSAntonio Huete Jimenez #endif /* #ifdef RRTYPE_SVCB_HTTPS */
2438