37e36e6c71f6609af530c18a7cc830af32b35fcd
[dragonfly.git] / contrib / ldns / rdata.c
1 /*
2  * rdata.c
3  *
4  * rdata implementation
5  *
6  * a Net::DNS like library for C
7  *
8  * (c) NLnet Labs, 2004-2006
9  *
10  * See the file LICENSE for the license
11  */
12
13 #include <ldns/config.h>
14
15 #include <ldns/ldns.h>
16
17 /*
18  * Access functions 
19  * do this as functions to get type checking
20  */
21
22 /* read */
23 size_t
24 ldns_rdf_size(const ldns_rdf *rd)
25 {
26         assert(rd != NULL);
27         return rd->_size;
28 }
29
30 ldns_rdf_type
31 ldns_rdf_get_type(const ldns_rdf *rd)
32 {
33         assert(rd != NULL);
34         return rd->_type;
35 }
36
37 uint8_t *
38 ldns_rdf_data(const ldns_rdf *rd)
39 {
40         assert(rd != NULL);
41         return rd->_data;
42 }
43
44 /* write */
45 void
46 ldns_rdf_set_size(ldns_rdf *rd, size_t size)
47 {
48         assert(rd != NULL);
49         rd->_size = size;
50 }
51
52 void
53 ldns_rdf_set_type(ldns_rdf *rd, ldns_rdf_type type)
54 {
55         assert(rd != NULL);
56         rd->_type = type;
57 }
58
59 void
60 ldns_rdf_set_data(ldns_rdf *rd, void *data)
61 {
62         /* only copy the pointer */
63         assert(rd != NULL);
64         rd->_data = data;
65 }
66
67 /* for types that allow it, return
68  * the native/host order type */
69 uint8_t
70 ldns_rdf2native_int8(const ldns_rdf *rd)
71 {
72         uint8_t data;
73
74         /* only allow 8 bit rdfs */
75         if (ldns_rdf_size(rd) != LDNS_RDF_SIZE_BYTE) {
76                 return 0;
77         }
78         
79         memcpy(&data, ldns_rdf_data(rd), sizeof(data));
80         return data;
81 }
82
83 uint16_t
84 ldns_rdf2native_int16(const ldns_rdf *rd)
85 {
86         uint16_t data;
87
88         /* only allow 16 bit rdfs */
89         if (ldns_rdf_size(rd) != LDNS_RDF_SIZE_WORD) {
90                 return 0;
91         }
92         
93         memcpy(&data, ldns_rdf_data(rd), sizeof(data));
94         return ntohs(data);
95 }
96
97 uint32_t
98 ldns_rdf2native_int32(const ldns_rdf *rd)
99 {
100         uint32_t data;
101
102         /* only allow 32 bit rdfs */
103         if (ldns_rdf_size(rd) != LDNS_RDF_SIZE_DOUBLEWORD) {
104                 return 0;
105         }
106         
107         memcpy(&data, ldns_rdf_data(rd), sizeof(data));
108         return ntohl(data);
109 }
110
111 time_t
112 ldns_rdf2native_time_t(const ldns_rdf *rd)
113 {
114         uint32_t data;
115         
116         switch(ldns_rdf_get_type(rd)) {
117                 case LDNS_RDF_TYPE_TIME:
118                         memcpy(&data, ldns_rdf_data(rd), sizeof(data));
119                         return (time_t)ntohl(data);
120                 default:
121                         return 0;
122         }
123 }
124
125 ldns_rdf *
126 ldns_native2rdf_int8(ldns_rdf_type type, uint8_t value)
127 {
128         return ldns_rdf_new_frm_data(type, LDNS_RDF_SIZE_BYTE, &value);
129 }
130
131 ldns_rdf *
132 ldns_native2rdf_int16(ldns_rdf_type type, uint16_t value)
133 {
134         uint16_t *rdf_data = LDNS_XMALLOC(uint16_t, 1);
135         ldns_rdf* rdf;
136         if (!rdf_data) {
137                 return NULL;
138         }
139         ldns_write_uint16(rdf_data, value);
140         rdf = ldns_rdf_new(type, LDNS_RDF_SIZE_WORD, rdf_data);
141         if(!rdf)
142                 LDNS_FREE(rdf_data);
143         return rdf;
144 }
145
146 ldns_rdf *
147 ldns_native2rdf_int32(ldns_rdf_type type, uint32_t value)
148 {
149         uint32_t *rdf_data = LDNS_XMALLOC(uint32_t, 1);
150         ldns_rdf* rdf;
151         if (!rdf_data) {
152                 return NULL;
153         }
154         ldns_write_uint32(rdf_data, value);
155         rdf = ldns_rdf_new(type, LDNS_RDF_SIZE_DOUBLEWORD, rdf_data);
156         if(!rdf)
157                 LDNS_FREE(rdf_data);
158         return rdf;
159 }
160
161 ldns_rdf *
162 ldns_native2rdf_int16_data(size_t size, uint8_t *data)
163 {
164         uint8_t *rdf_data = LDNS_XMALLOC(uint8_t, size + 2);
165         ldns_rdf* rdf;
166         if (!rdf_data) {
167                 return NULL;
168         }
169         ldns_write_uint16(rdf_data, size);
170         memcpy(rdf_data + 2, data, size);
171         rdf = ldns_rdf_new(LDNS_RDF_TYPE_INT16_DATA, size + 2, rdf_data);
172         if(!rdf)
173                 LDNS_FREE(rdf_data);
174         return rdf;
175 }
176
177 /* note: data must be allocated memory */
178 ldns_rdf *
179 ldns_rdf_new(ldns_rdf_type type, size_t size, void *data)
180 {
181         ldns_rdf *rd;
182         rd = LDNS_MALLOC(ldns_rdf);
183         if (!rd) {
184                 return NULL;
185         }
186         ldns_rdf_set_size(rd, size);
187         ldns_rdf_set_type(rd, type);
188         ldns_rdf_set_data(rd, data);
189         return rd;
190 }
191
192 ldns_rdf *
193 ldns_rdf_new_frm_data(ldns_rdf_type type, size_t size, const void *data)
194 {
195         ldns_rdf *rdf;
196
197         /* if the size is too big, fail */
198         if (size > LDNS_MAX_RDFLEN) {
199                 return NULL;
200         }
201
202         /* allocate space */
203         rdf = LDNS_MALLOC(ldns_rdf);
204         if (!rdf) {
205                 return NULL;
206         }
207         rdf->_data = LDNS_XMALLOC(uint8_t, size);
208         if (!rdf->_data) {
209                 LDNS_FREE(rdf);
210                 return NULL;
211         }
212         
213         /* set the values */
214         ldns_rdf_set_type(rdf, type);
215         ldns_rdf_set_size(rdf, size);
216         memcpy(rdf->_data, data, size);
217
218         return rdf;
219 }
220
221 ldns_rdf *
222 ldns_rdf_clone(const ldns_rdf *rd)
223 {
224         assert(rd != NULL);
225         return (ldns_rdf_new_frm_data( ldns_rdf_get_type(rd),
226                 ldns_rdf_size(rd), ldns_rdf_data(rd)));
227 }
228
229 void
230 ldns_rdf_deep_free(ldns_rdf *rd)
231 {
232         if (rd) {
233                 if (rd->_data) {
234                         LDNS_FREE(rd->_data);
235                 }
236                 LDNS_FREE(rd);
237         }
238 }
239
240 void 
241 ldns_rdf_free(ldns_rdf *rd)
242 {
243         if (rd) {
244                 LDNS_FREE(rd);
245         }
246 }
247
248 ldns_rdf *
249 ldns_rdf_new_frm_str(ldns_rdf_type type, const char *str)
250 {
251         ldns_rdf *rdf = NULL;
252         ldns_status status;
253
254         switch (type) {
255         case LDNS_RDF_TYPE_DNAME:
256                 status = ldns_str2rdf_dname(&rdf, str);
257                 break;
258         case LDNS_RDF_TYPE_INT8:
259                 status = ldns_str2rdf_int8(&rdf, str);
260                 break;
261         case LDNS_RDF_TYPE_INT16:
262                 status = ldns_str2rdf_int16(&rdf, str);
263                 break;
264         case LDNS_RDF_TYPE_INT32:
265                 status = ldns_str2rdf_int32(&rdf, str);
266                 break;
267         case LDNS_RDF_TYPE_A:
268                 status = ldns_str2rdf_a(&rdf, str);
269                 break;
270         case LDNS_RDF_TYPE_AAAA:
271                 status = ldns_str2rdf_aaaa(&rdf, str);
272                 break;
273         case LDNS_RDF_TYPE_STR:
274                 status = ldns_str2rdf_str(&rdf, str);
275                 break;
276         case LDNS_RDF_TYPE_APL:
277                 status = ldns_str2rdf_apl(&rdf, str);
278                 break;
279         case LDNS_RDF_TYPE_B64:
280                 status = ldns_str2rdf_b64(&rdf, str);
281                 break;
282         case LDNS_RDF_TYPE_B32_EXT:
283                 status = ldns_str2rdf_b32_ext(&rdf, str);
284                 break;
285         case LDNS_RDF_TYPE_HEX:
286                 status = ldns_str2rdf_hex(&rdf, str);
287                 break;
288         case LDNS_RDF_TYPE_NSEC:
289                 status = ldns_str2rdf_nsec(&rdf, str);
290                 break;
291         case LDNS_RDF_TYPE_TYPE:
292                 status = ldns_str2rdf_type(&rdf, str);
293                 break;
294         case LDNS_RDF_TYPE_CLASS:
295                 status = ldns_str2rdf_class(&rdf, str);
296                 break;
297         case LDNS_RDF_TYPE_CERT_ALG:
298                 status = ldns_str2rdf_cert_alg(&rdf, str);
299                 break;
300         case LDNS_RDF_TYPE_ALG:
301                 status = ldns_str2rdf_alg(&rdf, str);
302                 break;
303         case LDNS_RDF_TYPE_UNKNOWN:
304                 status = ldns_str2rdf_unknown(&rdf, str);
305                 break;
306         case LDNS_RDF_TYPE_TIME:
307                 status = ldns_str2rdf_time(&rdf, str);
308                 break;
309         case LDNS_RDF_TYPE_PERIOD:
310                 status = ldns_str2rdf_period(&rdf, str);
311                 break;
312         case LDNS_RDF_TYPE_TSIG:
313                 status = ldns_str2rdf_tsig(&rdf, str);
314                 break;
315         case LDNS_RDF_TYPE_SERVICE:
316                 status = ldns_str2rdf_service(&rdf, str);
317                 break;
318         case LDNS_RDF_TYPE_LOC:
319                 status = ldns_str2rdf_loc(&rdf, str);
320                 break;
321         case LDNS_RDF_TYPE_WKS:
322                 status = ldns_str2rdf_wks(&rdf, str);
323                 break;
324         case LDNS_RDF_TYPE_NSAP:
325                 status = ldns_str2rdf_nsap(&rdf, str);
326                 break;
327         case LDNS_RDF_TYPE_ATMA:
328                 status = ldns_str2rdf_atma(&rdf, str);
329                 break;
330         case LDNS_RDF_TYPE_IPSECKEY:
331                 status = ldns_str2rdf_ipseckey(&rdf, str);
332                 break;
333         case LDNS_RDF_TYPE_NSEC3_SALT:
334                 status = ldns_str2rdf_nsec3_salt(&rdf, str);
335                 break;
336         case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
337                 status = ldns_str2rdf_b32_ext(&rdf, str);
338                 break;
339         case LDNS_RDF_TYPE_NONE:
340         default:
341                 /* default default ??? */
342                 status = LDNS_STATUS_ERR;
343                 break;
344         }
345         if (LDNS_STATUS_OK == status) {
346                 ldns_rdf_set_type(rdf, type);
347                 return rdf;
348         }
349         if (rdf) {
350                 LDNS_FREE(rdf);
351         }
352         return NULL;
353 }
354
355 ldns_status
356 ldns_rdf_new_frm_fp(ldns_rdf **rdf, ldns_rdf_type type, FILE *fp)
357 {
358         return ldns_rdf_new_frm_fp_l(rdf, type, fp, NULL);
359 }
360
361 ldns_status
362 ldns_rdf_new_frm_fp_l(ldns_rdf **rdf, ldns_rdf_type type, FILE *fp, int *line_nr)
363 {
364         char *line;
365         ldns_rdf *r;
366         ssize_t t;
367
368         line = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
369         if (!line) {
370                 return LDNS_STATUS_MEM_ERR;
371         }
372
373         /* read an entire line in from the file */
374         if ((t = ldns_fget_token_l(fp, line, LDNS_PARSE_SKIP_SPACE, 0, line_nr)) == -1 || t == 0) {
375                 LDNS_FREE(line);
376                 return LDNS_STATUS_SYNTAX_RDATA_ERR;
377         }
378         r =  ldns_rdf_new_frm_str(type, (const char*) line);
379         LDNS_FREE(line);
380         if (rdf) {
381                 *rdf = r;
382                 return LDNS_STATUS_OK;
383         } else {
384                 return LDNS_STATUS_NULL;
385         }
386 }
387
388 ldns_rdf *
389 ldns_rdf_address_reverse(ldns_rdf *rd)
390 {
391         uint8_t buf_4[LDNS_IP4ADDRLEN];
392         uint8_t buf_6[LDNS_IP6ADDRLEN * 2];
393         ldns_rdf *rev;
394         ldns_rdf *in_addr;
395         ldns_rdf *ret_dname;
396         uint8_t octet;
397         uint8_t nnibble;
398         uint8_t nibble;
399         uint8_t i, j;
400
401         char *char_dname;
402         int nbit;
403
404         if (ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_A &&
405                         ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_AAAA) {
406                 return NULL;
407         }
408
409         in_addr = NULL;
410         ret_dname = NULL;
411
412         switch(ldns_rdf_get_type(rd)) {
413                 case LDNS_RDF_TYPE_A:
414                         /* the length of the buffer is 4 */
415                         buf_4[3] = ldns_rdf_data(rd)[0];
416                         buf_4[2] = ldns_rdf_data(rd)[1];
417                         buf_4[1] = ldns_rdf_data(rd)[2];
418                         buf_4[0] = ldns_rdf_data(rd)[3];
419                         in_addr = ldns_dname_new_frm_str("in-addr.arpa.");
420                         if (!in_addr) {
421                                 return NULL;
422                         }
423                         /* make a new rdf and convert that back  */
424                         rev = ldns_rdf_new_frm_data( LDNS_RDF_TYPE_A,
425                                 LDNS_IP4ADDRLEN, (void*)&buf_4);
426                         if (!rev) {
427                                 LDNS_FREE(in_addr);
428                                 return NULL;
429                         }
430
431                         /* convert rev to a string */
432                         char_dname = ldns_rdf2str(rev);
433                         if (!char_dname) {
434                                 LDNS_FREE(in_addr);
435                                 ldns_rdf_deep_free(rev);
436                                 return NULL;
437                         }
438                         /* transform back to rdf with type dname */
439                         ret_dname = ldns_dname_new_frm_str(char_dname);
440                         if (!ret_dname) {
441                                 LDNS_FREE(in_addr);
442                                 ldns_rdf_deep_free(rev);
443                                 LDNS_FREE(char_dname);
444                                 return NULL;
445                         }
446                         /* not needed anymore */
447                         ldns_rdf_deep_free(rev);
448                         LDNS_FREE(char_dname);
449                         break;
450                 case LDNS_RDF_TYPE_AAAA:
451                         /* some foo magic to reverse the nibbles ... */
452
453                         for (nbit = 127; nbit >= 0; nbit = nbit - 4) {
454                                 /* calculate octett (8 bit) */
455                                 octet = ( ((unsigned int) nbit) & 0x78) >> 3;
456                                 /* calculate nibble */
457                                 nnibble = ( ((unsigned int) nbit) & 0x04) >> 2;
458                                 /* extract nibble */
459                                 nibble = (ldns_rdf_data(rd)[octet] & ( 0xf << (4 * (1 -
460                                                  nnibble)) ) ) >> ( 4 * (1 - 
461                                                 nnibble));
462
463                                 buf_6[(LDNS_IP6ADDRLEN * 2 - 1) -
464                                         (octet * 2 + nnibble)] = 
465                                                 (uint8_t)ldns_int_to_hexdigit((int)nibble);
466                         }
467
468                         char_dname = LDNS_XMALLOC(char, (LDNS_IP6ADDRLEN * 4));
469                         if (!char_dname) {
470                                 return NULL;
471                         }
472                         char_dname[LDNS_IP6ADDRLEN * 4 - 1] = '\0'; /* closure */
473
474                         /* walk the string and add . 's */
475                         for (i = 0, j = 0; i < LDNS_IP6ADDRLEN * 2; i++, j = j + 2) {
476                                 char_dname[j] = (char)buf_6[i];
477                                 if (i != LDNS_IP6ADDRLEN * 2 - 1) {
478                                         char_dname[j + 1] = '.';
479                                 }
480                         }
481                         in_addr = ldns_dname_new_frm_str("ip6.arpa.");
482                         if (!in_addr) {
483                                 LDNS_FREE(char_dname);
484                                 return NULL;
485                         }
486                 
487                         /* convert rev to a string */
488                         ret_dname = ldns_dname_new_frm_str(char_dname);
489                         LDNS_FREE(char_dname);
490                         if (!ret_dname) {
491                                 ldns_rdf_deep_free(in_addr);
492                                 return NULL;
493                         }
494                         break;
495                 default:
496                         break;
497         }
498         /* add the suffix */
499         rev = ldns_dname_cat_clone(ret_dname, in_addr);
500         
501         ldns_rdf_deep_free(ret_dname);
502         ldns_rdf_deep_free(in_addr);
503         return rev;
504 }
505
506 ldns_status
507 ldns_octet(char *word, size_t *length)
508 {
509     char *s; 
510     char *p;
511     *length = 0;
512
513     for (s = p = word; *s != '\0'; s++,p++) {
514         switch (*s) {
515             case '.':
516                 if (s[1] == '.') {
517                     return LDNS_STATUS_EMPTY_LABEL;
518                 }
519                 *p = *s;
520                 (*length)++;
521                 break;
522             case '\\':
523                 if ('0' <= s[1] && s[1] <= '9' &&
524                     '0' <= s[2] && s[2] <= '9' &&
525                     '0' <= s[3] && s[3] <= '9') {
526                     /* \DDD seen */
527                     int val = ((s[1] - '0') * 100 +
528                            (s[2] - '0') * 10 + (s[3] - '0'));
529
530                     if (0 <= val && val <= 255) {
531                         /* this also handles \0 */
532                         s += 3;
533                         *p = val;
534                         (*length)++;
535                     } else {
536                         return LDNS_STATUS_DDD_OVERFLOW;
537                     }
538                 } else {
539                     /* an espaced character, like \<space> ? 
540                     * remove the '\' keep the rest */
541                     *p = *++s;
542                     (*length)++;
543                 }
544                 break;
545             case '\"':
546                 /* non quoted " Is either first or the last character in
547                  * the string */
548
549                 *p = *++s; /* skip it */
550                 (*length)++;
551                 /* I'm not sure if this is needed in libdns... MG */
552                 if ( *s == '\0' ) {
553                     /* ok, it was the last one */
554                     *p  = '\0'; 
555                     return LDNS_STATUS_OK;
556                 }
557                 break;
558             default:
559                 *p = *s;
560                 (*length)++;
561                 break;
562         }
563     }
564     *p = '\0';
565     return LDNS_STATUS_OK;
566 }
567
568 int
569 ldns_rdf_compare(const ldns_rdf *rd1, const ldns_rdf *rd2)
570 {
571         uint16_t i1, i2, i;
572         uint8_t *d1, *d2;
573
574         /* only when both are not NULL we can say anything about them */
575         if (!rd1 && !rd2) {
576                 return 0;
577         }
578         if (!rd1 || !rd2) {
579                 return -1;
580         }
581         i1 = ldns_rdf_size(rd1);
582         i2 = ldns_rdf_size(rd2);
583
584         if (i1 < i2) {
585                 return -1;
586         } else if (i1 > i2) {
587                 return +1;
588         } else {
589                 d1 = (uint8_t*)ldns_rdf_data(rd1);
590                 d2 = (uint8_t*)ldns_rdf_data(rd2);
591                 for(i = 0; i < i1; i++) {
592                         if (d1[i] < d2[i]) {
593                                 return -1;
594                         } else if (d1[i] > d2[i]) {
595                                 return +1;
596                         }
597                 }
598         }
599         return 0;
600 }
601
602 uint32_t
603 ldns_str2period(const char *nptr, const char **endptr)
604 {
605         int sign = 0;
606         uint32_t i = 0;
607         uint32_t seconds = 0;
608
609         for(*endptr = nptr; **endptr; (*endptr)++) {
610                 switch (**endptr) {
611                         case ' ':
612                         case '\t':
613                                 break;
614                         case '-':
615                                 if(sign == 0) {
616                                         sign = -1;
617                                 } else {
618                                         return seconds;
619                                 }
620                                 break;
621                         case '+':
622                                 if(sign == 0) {
623                                         sign = 1;
624                                 } else {
625                                         return seconds;
626                                 }
627                                 break;
628                         case 's':
629                         case 'S':
630                                 seconds += i;
631                                 i = 0;
632                                 break;
633                         case 'm':
634                         case 'M':
635                                 seconds += i * 60;
636                                 i = 0;
637                                 break;
638                         case 'h':
639                         case 'H':
640                                 seconds += i * 60 * 60;
641                                 i = 0;
642                                 break;
643                         case 'd':
644                         case 'D':
645                                 seconds += i * 60 * 60 * 24;
646                                 i = 0;
647                                 break;
648                         case 'w':
649                         case 'W':
650                                 seconds += i * 60 * 60 * 24 * 7;
651                                 i = 0;
652                                 break;
653                         case '0':
654                         case '1':
655                         case '2':
656                         case '3':
657                         case '4':
658                         case '5':
659                         case '6':
660                         case '7':
661                         case '8':
662                         case '9':
663                                 i *= 10;
664                                 i += (**endptr - '0');
665                                 break;
666                         default:
667                                 seconds += i;
668                                 /* disregard signedness */
669                                 return seconds;
670                 }
671         }
672         seconds += i;
673         /* disregard signedness */
674         return seconds;
675 }