1: /*
2: * Copyright (c) 2004,2009 by Internet Systems Consortium, Inc. ("ISC")
3: * Copyright (c) 1996-2003 by Internet Software Consortium
4: *
5: * Permission to use, copy, modify, and distribute this software for any
6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice and this permission notice appear in all copies.
8: *
9: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
15: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16: *
17: * Internet Systems Consortium, Inc.
18: * 950 Charter Street
19: * Redwood City, CA 94063
20: * <info@isc.org>
21: * https://www.isc.org/
22: */
23:
24: #ifndef lint
25: static const char rcsid[] = "$Id: ns_name.c,v 1.1.1.1 2012/10/09 09:06:54 misho Exp $";
26: #endif
27:
28: #include <sys/types.h>
29:
30: #include <netinet/in.h>
31: #include <sys/socket.h>
32:
33: #include <errno.h>
34: #include <string.h>
35: #include <ctype.h>
36:
37: #include "minires/minires.h"
38: #include "arpa/nameser.h"
39:
40: /* Data. */
41:
42: static const char digits[] = "0123456789";
43:
44: /* Forward. */
45:
46: static int special(int);
47: static int printable(int);
48: static int dn_find(const u_char *, const u_char *,
49: const u_char * const *,
50: const u_char * const *);
51:
52: /* Public. */
53:
54: /*
55: * ns_name_ntop(src, dst, dstsiz)
56: * Convert an encoded domain name to printable ascii as per RFC1035.
57: * return:
58: * Number of bytes written to buffer, or -1 (with errno set)
59: * notes:
60: * The root is returned as "."
61: * All other domains are returned in non absolute form
62: */
63: int
64: ns_name_ntop(const u_char *src, char *dst, size_t dstsiz) {
65: const u_char *cp;
66: char *dn, *eom;
67: u_char c;
68: u_int n;
69:
70: cp = src;
71: dn = dst;
72: eom = dst + dstsiz;
73:
74: if (dn >= eom) {
75: errno = EMSGSIZE;
76: return (-1);
77: }
78:
79: while ((n = *cp++) != 0) {
80: if ((n & NS_CMPRSFLGS) != 0) {
81: /* Some kind of compression pointer. */
82: errno = EMSGSIZE;
83: return (-1);
84: }
85: if (dn != dst) {
86: if (dn >= eom) {
87: errno = EMSGSIZE;
88: return (-1);
89: }
90: *dn++ = '.';
91: }
92: if (dn + n >= eom) {
93: errno = EMSGSIZE;
94: return (-1);
95: }
96: for ((void)NULL; n > 0; n--) {
97: c = *cp++;
98: if (special(c)) {
99: if (dn + 1 >= eom) {
100: errno = EMSGSIZE;
101: return (-1);
102: }
103: *dn++ = '\\';
104: *dn++ = (char)c;
105: } else if (!printable(c)) {
106: if (dn + 3 >= eom) {
107: errno = EMSGSIZE;
108: return (-1);
109: }
110: *dn++ = '\\';
111: *dn++ = digits[c / 100];
112: *dn++ = digits[(c % 100) / 10];
113: *dn++ = digits[c % 10];
114: } else {
115: if (dn >= eom) {
116: errno = EMSGSIZE;
117: return (-1);
118: }
119: *dn++ = (char)c;
120: }
121: }
122: }
123: if (dn == dst) {
124: if (dn >= eom) {
125: errno = EMSGSIZE;
126: return (-1);
127: }
128: *dn++ = '.';
129: }
130: if (dn >= eom) {
131: errno = EMSGSIZE;
132: return (-1);
133: }
134: *dn++ = '\0';
135: return (dn - dst);
136: }
137:
138: /*
139: * ns_name_pton(src, dst, dstsiz)
140: * Convert a ascii string into an encoded domain name as per RFC1035.
141: * return:
142: * -1 if it fails
143: * 1 if string was fully qualified
144: * 0 is string was not fully qualified
145: * notes:
146: * Enforces label and domain length limits.
147: */
148:
149: int
150: ns_name_pton(const char *src, u_char *dst, size_t dstsiz) {
151: u_char *label, *bp, *eom;
152: int c, n, escaped;
153: char *cp;
154:
155: escaped = 0;
156: bp = dst;
157: eom = dst + dstsiz;
158: label = bp++;
159:
160: while ((c = *src++) != 0) {
161: if (escaped) {
162: if ((cp = strchr(digits, c)) != NULL) {
163: n = (cp - digits) * 100;
164: if ((c = *src++) == 0 ||
165: (cp = strchr(digits, c)) == NULL) {
166: errno = EMSGSIZE;
167: return (-1);
168: }
169: n += (cp - digits) * 10;
170: if ((c = *src++) == 0 ||
171: (cp = strchr(digits, c)) == NULL) {
172: errno = EMSGSIZE;
173: return (-1);
174: }
175: n += (cp - digits);
176: if (n > 255) {
177: errno = EMSGSIZE;
178: return (-1);
179: }
180: c = n;
181: }
182: escaped = 0;
183: } else if (c == '\\') {
184: escaped = 1;
185: continue;
186: } else if (c == '.') {
187: c = (bp - label - 1);
188: if ((c & NS_CMPRSFLGS) != 0) { /* Label too big. */
189: errno = EMSGSIZE;
190: return (-1);
191: }
192: if (label >= eom) {
193: errno = EMSGSIZE;
194: return (-1);
195: }
196: *label = c;
197: /* Fully qualified ? */
198: if (*src == '\0') {
199: if (c != 0) {
200: if (bp >= eom) {
201: errno = EMSGSIZE;
202: return (-1);
203: }
204: *bp++ = '\0';
205: }
206: if ((bp - dst) > MAXCDNAME) {
207: errno = EMSGSIZE;
208: return (-1);
209: }
210: return (1);
211: }
212: if (c == 0 || *src == '.') {
213: errno = EMSGSIZE;
214: return (-1);
215: }
216: label = bp++;
217: continue;
218: }
219: if (bp >= eom) {
220: errno = EMSGSIZE;
221: return (-1);
222: }
223: *bp++ = (u_char)c;
224: }
225: c = (bp - label - 1);
226: if ((c & NS_CMPRSFLGS) != 0) { /* Label too big. */
227: errno = EMSGSIZE;
228: return (-1);
229: }
230: if (label >= eom) {
231: errno = EMSGSIZE;
232: return (-1);
233: }
234: *label = c;
235: if (c != 0) {
236: if (bp >= eom) {
237: errno = EMSGSIZE;
238: return (-1);
239: }
240: *bp++ = 0;
241: }
242: if ((bp - dst) > MAXCDNAME) { /* src too big */
243: errno = EMSGSIZE;
244: return (-1);
245: }
246: return (0);
247: }
248:
249: /*
250: * ns_name_ntol(src, dst, dstsiz)
251: * Convert a network strings labels into all lowercase.
252: * return:
253: * Number of bytes written to buffer, or -1 (with errno set)
254: * notes:
255: * Enforces label and domain length limits.
256: */
257:
258: int
259: ns_name_ntol(const u_char *src, u_char *dst, size_t dstsiz) {
260: const u_char *cp;
261: u_char *dn, *eom;
262: u_char c;
263: u_int n;
264:
265: cp = src;
266: dn = dst;
267: eom = dst + dstsiz;
268:
269: if (dn >= eom) {
270: errno = EMSGSIZE;
271: return (-1);
272: }
273: while ((n = *cp++) != 0) {
274: if ((n & NS_CMPRSFLGS) != 0) {
275: /* Some kind of compression pointer. */
276: errno = EMSGSIZE;
277: return (-1);
278: }
279: *dn++ = n;
280: if (dn + n >= eom) {
281: errno = EMSGSIZE;
282: return (-1);
283: }
284: for ((void)NULL; n > 0; n--) {
285: c = *cp++;
286: if (isupper(c))
287: *dn++ = tolower(c);
288: else
289: *dn++ = c;
290: }
291: }
292: *dn++ = '\0';
293: return (dn - dst);
294: }
295:
296: /*
297: * ns_name_unpack(msg, eom, src, dst, dstsiz)
298: * Unpack a domain name from a message, source may be compressed.
299: * return:
300: * -1 if it fails, or consumed octets if it succeeds.
301: */
302: int
303: ns_name_unpack(const u_char *msg, const u_char *eom, const u_char *src,
304: u_char *dst, size_t dstsiz)
305: {
306: const u_char *srcp, *dstlim;
307: u_char *dstp;
308: unsigned n;
309: int len;
310: int checked;
311:
312: len = -1;
313: checked = 0;
314: dstp = dst;
315: srcp = src;
316: dstlim = dst + dstsiz;
317: if (srcp < msg || srcp >= eom) {
318: errno = EMSGSIZE;
319: return (-1);
320: }
321: /* Fetch next label in domain name. */
322: while ((n = *srcp++) != 0) {
323: /* Check for indirection. */
324: switch (n & NS_CMPRSFLGS) {
325: case 0:
326: /* Limit checks. */
327: if (dstp + n + 1 >= dstlim || srcp + n >= eom) {
328: errno = EMSGSIZE;
329: return (-1);
330: }
331: checked += n + 1;
332: *dstp++ = n;
333: memcpy(dstp, srcp, n);
334: dstp += n;
335: srcp += n;
336: break;
337:
338: case NS_CMPRSFLGS:
339: if (srcp >= eom) {
340: errno = EMSGSIZE;
341: return (-1);
342: }
343: if (len < 0)
344: len = srcp - src + 1;
345: srcp = msg + (((n & 0x3f) << 8) | (*srcp & 0xff));
346: if (srcp < msg || srcp >= eom) { /* Out of range. */
347: errno = EMSGSIZE;
348: return (-1);
349: }
350: checked += 2;
351: /*
352: * Check for loops in the compressed name;
353: * if we've looked at the whole message,
354: * there must be a loop.
355: */
356: if (checked >= eom - msg) {
357: errno = EMSGSIZE;
358: return (-1);
359: }
360: break;
361:
362: default:
363: errno = EMSGSIZE;
364: return (-1); /* flag error */
365: }
366: }
367: *dstp = '\0';
368: if (len < 0)
369: len = srcp - src;
370: return (len);
371: }
372:
373: /*
374: * ns_name_pack(src, dst, dstsiz, dnptrs, lastdnptr)
375: * Pack domain name 'domain' into 'comp_dn'.
376: * return:
377: * Size of the compressed name, or -1.
378: * notes:
379: * 'dnptrs' is an array of pointers to previous compressed names.
380: * dnptrs[0] is a pointer to the beginning of the message. The array
381: * ends with NULL.
382: * 'lastdnptr' is a pointer to the end of the array pointed to
383: * by 'dnptrs'.
384: * Side effects:
385: * The list of pointers in dnptrs is updated for labels inserted into
386: * the message as we compress the name. If 'dnptr' is NULL, we don't
387: * try to compress names. If 'lastdnptr' is NULL, we don't update the
388: * list.
389: */
390: int
391: ns_name_pack(const u_char *src, u_char *dst, unsigned dstsiz,
392: const u_char **dnptrs, const u_char **lastdnptr)
393: {
394: u_char *dstp;
395: const u_char **cpp, **lpp, *eob, *msg;
396: const u_char *srcp;
397: unsigned n;
398: int l;
399:
400: srcp = src;
401: dstp = dst;
402: eob = dstp + dstsiz;
403: lpp = cpp = NULL;
404: if (dnptrs != NULL) {
405: if ((msg = *dnptrs++) != NULL) {
406: for (cpp = dnptrs; *cpp != NULL; cpp++)
407: (void)NULL;
408: lpp = cpp; /* end of list to search */
409: }
410: } else
411: msg = NULL;
412:
413: /* make sure the domain we are about to add is legal */
414: l = 0;
415: do {
416: n = *srcp;
417: if ((n & NS_CMPRSFLGS) != 0) {
418: errno = EMSGSIZE;
419: return (-1);
420: }
421: l += n + 1;
422: if (l > MAXCDNAME) {
423: errno = EMSGSIZE;
424: return (-1);
425: }
426: srcp += n + 1;
427: } while (n != 0);
428:
429: /* from here on we need to reset compression pointer array on error */
430: srcp = src;
431: do {
432: /* Look to see if we can use pointers. */
433: n = *srcp;
434: if (n != 0 && msg != NULL) {
435: l = dn_find(srcp, msg, (const u_char * const *)dnptrs,
436: (const u_char * const *)lpp);
437: if (l >= 0) {
438: if (dstp + 1 >= eob) {
439: goto cleanup;
440: }
441: *dstp++ = (l >> 8) | NS_CMPRSFLGS;
442: *dstp++ = l % 256;
443: return (dstp - dst);
444: }
445: /* Not found, save it. */
446: if (lastdnptr != NULL && cpp < lastdnptr - 1 &&
447: (dstp - msg) < 0x4000) {
448: *cpp++ = dstp;
449: *cpp = NULL;
450: }
451: }
452: /* copy label to buffer */
453: if (n & NS_CMPRSFLGS) { /* Should not happen. */
454: goto cleanup;
455: }
456: if (dstp + 1 + n >= eob) {
457: goto cleanup;
458: }
459: memcpy(dstp, srcp, n + 1);
460: srcp += n + 1;
461: dstp += n + 1;
462: } while (n != 0);
463:
464: if (dstp > eob) {
465: cleanup:
466: if (msg != NULL)
467: *lpp = NULL;
468: errno = EMSGSIZE;
469: return (-1);
470: }
471: return (dstp - dst);
472: }
473:
474: /*
475: * ns_name_uncompress(msg, eom, src, dst, dstsiz)
476: * Expand compressed domain name to presentation format.
477: * return:
478: * Number of bytes read out of `src', or -1 (with errno set).
479: * note:
480: * Root domain returns as "." not "".
481: */
482: int
483: ns_name_uncompress(const u_char *msg, const u_char *eom, const u_char *src,
484: char *dst, size_t dstsiz)
485: {
486: u_char tmp[NS_MAXCDNAME];
487: int n;
488:
489: if ((n = ns_name_unpack(msg, eom, src, tmp, sizeof tmp)) == -1)
490: return (-1);
491: if (ns_name_ntop(tmp, dst, dstsiz) == -1)
492: return (-1);
493: return (n);
494: }
495:
496: /*
497: * ns_name_compress(src, dst, dstsiz, dnptrs, lastdnptr)
498: * Compress a domain name into wire format, using compression pointers.
499: * return:
500: * Number of bytes consumed in `dst' or -1 (with errno set).
501: * notes:
502: * 'dnptrs' is an array of pointers to previous compressed names.
503: * dnptrs[0] is a pointer to the beginning of the message.
504: * The list ends with NULL. 'lastdnptr' is a pointer to the end of the
505: * array pointed to by 'dnptrs'. Side effect is to update the list of
506: * pointers for labels inserted into the message as we compress the name.
507: * If 'dnptr' is NULL, we don't try to compress names. If 'lastdnptr'
508: * is NULL, we don't update the list.
509: */
510: int
511: ns_name_compress(const char *src, u_char *dst, size_t dstsiz,
512: const u_char **dnptrs, const u_char **lastdnptr)
513: {
514: u_char tmp[NS_MAXCDNAME];
515:
516: if (ns_name_pton(src, tmp, sizeof tmp) == -1)
517: return (-1);
518: return (ns_name_pack(tmp, dst, dstsiz, dnptrs, lastdnptr));
519: }
520:
521: /*
522: * ns_name_skip(ptrptr, eom)
523: * Advance *ptrptr to skip over the compressed name it points at.
524: * return:
525: * 0 on success, -1 (with errno set) on failure.
526: */
527: int
528: ns_name_skip(const u_char **ptrptr, const u_char *eom) {
529: const u_char *cp;
530: u_int n;
531:
532: cp = *ptrptr;
533: while (cp < eom && (n = *cp++) != 0) {
534: /* Check for indirection. */
535: switch (n & NS_CMPRSFLGS) {
536: case 0: /* normal case, n == len */
537: cp += n;
538: continue;
539: case NS_CMPRSFLGS: /* indirection */
540: cp++;
541: break;
542: default: /* illegal type */
543: errno = EMSGSIZE;
544: return (-1);
545: }
546: break;
547: }
548: if (cp > eom) {
549: errno = EMSGSIZE;
550: return (-1);
551: }
552: *ptrptr = cp;
553: return (0);
554: }
555:
556: /* Private. */
557:
558: /*
559: * special(ch)
560: * Thinking in noninternationalized USASCII (per the DNS spec),
561: * is this characted special ("in need of quoting") ?
562: * return:
563: * boolean.
564: */
565: static int
566: special(int ch) {
567: switch (ch) {
568: case 0x22: /* '"' */
569: case 0x2E: /* '.' */
570: case 0x3B: /* ';' */
571: case 0x5C: /* '\\' */
572: /* Special modifiers in zone files. */
573: case 0x40: /* '@' */
574: case 0x24: /* '$' */
575: return (1);
576: default:
577: return (0);
578: }
579: }
580:
581: /*
582: * printable(ch)
583: * Thinking in noninternationalized USASCII (per the DNS spec),
584: * is this character visible and not a space when printed ?
585: * return:
586: * boolean.
587: */
588: static int
589: printable(int ch) {
590: return (ch > 0x20 && ch < 0x7f);
591: }
592:
593: /*
594: * Thinking in noninternationalized USASCII (per the DNS spec),
595: * convert this character to lower case if it's upper case.
596: */
597: static int
598: mklower(int ch) {
599: if (ch >= 0x41 && ch <= 0x5A)
600: return (ch + 0x20);
601: return (ch);
602: }
603:
604: /*
605: * dn_find(domain, msg, dnptrs, lastdnptr)
606: * Search for the counted-label name in an array of compressed names.
607: * return:
608: * offset from msg if found, or -1.
609: * notes:
610: * dnptrs is the pointer to the first name on the list,
611: * not the pointer to the start of the message.
612: */
613: static int
614: dn_find(const u_char *domain, const u_char *msg,
615: const u_char * const *dnptrs,
616: const u_char * const *lastdnptr)
617: {
618: const u_char *dn, *cp, *sp;
619: const u_char * const *cpp;
620: u_int n;
621:
622: for (cpp = dnptrs; cpp < lastdnptr; cpp++) {
623: dn = domain;
624: sp = cp = *cpp;
625: while ((n = *cp++) != 0) {
626: /*
627: * check for indirection
628: */
629: switch (n & NS_CMPRSFLGS) {
630: case 0: /* normal case, n == len */
631: if (n != *dn++)
632: goto next;
633: for ((void)NULL; n > 0; n--)
634: if (mklower(*dn++) != mklower(*cp++))
635: goto next;
636: /* Is next root for both ? */
637: if (*dn == '\0' && *cp == '\0')
638: return (sp - msg);
639: if (*dn)
640: continue;
641: goto next;
642:
643: case NS_CMPRSFLGS: /* indirection */
644: cp = msg + (((n & 0x3f) << 8) | *cp);
645: break;
646:
647: default: /* illegal type */
648: errno = EMSGSIZE;
649: return (-1);
650: }
651: }
652: next: ;
653: }
654: errno = ENOENT;
655: return (-1);
656: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ns_name.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcp / minires