git.oblomov.eu Git - wine/blob - dlls/dnsapi/ns_name.c

   1 /*
   2  * Copyright (c) 1996,1999 by Internet Software Consortium.
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
   9  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
  10  * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
  11  * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  12  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  13  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  14  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  15  * SOFTWARE.
  16  */
  17
  18 #include "config.h"
  19
  20 #include <sys/types.h>
  21
  22 #ifdef HAVE_NETINET_IN_H
  23 # include <netinet/in.h>
  24 #endif
  25 #ifdef HAVE_ARPA_NAMESER_H
  26 # include <arpa/nameser.h>
  27 #endif
  28
  29 #include <ctype.h>
  30 #include <errno.h>
  31 #ifdef HAVE_RESOLV_H
  32 # include <resolv.h>
  33 #endif
  34 #include <string.h>
  35 #include <ctype.h>
  36
  37 /* Data. */
  38
  39 static const char       digits[] = "0123456789";
  40
  41 /* Forward. */
  42
  43 static int              special(int);
  44 static int              printable(int);
  45
  46 /* Public. */
  47
  48 /*
  49  * dns_ns_name_ntop(src, dst, dstsiz)
  50  *      Convert an encoded domain name to printable ascii as per RFC1035.
  51  * return:
  52  *      Number of bytes written to buffer, or -1 (with errno set)
  53  * notes:
  54  *      The root is returned as "."
  55  *      All other domains are returned in non absolute form
  56  */
  57 int
  58 dns_ns_name_ntop(const u_char *src, char *dst, size_t dstsiz) {
  59         const u_char *cp;
  60         char *dn, *eom;
  61         u_char c;
  62         u_int n;
  63
  64         cp = src;
  65         dn = dst;
  66         eom = dst + dstsiz;
  67
  68         while ((n = *cp++) != 0) {
  69                 if ((n & NS_CMPRSFLGS) != 0 && n != 0x41) {
  70                         /* Some kind of compression pointer. */
  71                         return (-1);
  72                 }
  73                 if (dn != dst) {
  74                         if (dn >= eom) {
  75                                 return (-1);
  76                         }
  77                         *dn++ = '.';
  78                 }
  79
  80                 if (n == 0x41) {
  81                         n = *cp++ / 8;
  82                         if (dn + n * 2 + 4 >= eom) {
  83                                 return (-1);
  84                         }
  85                         *dn++ = '\\';
  86                         *dn++ = '[';
  87                         *dn++ = 'x';
  88
  89                         while (n-- > 0) {
  90                 unsigned u;
  91                                 c = *cp++;
  92                                 u = c >> 4;
  93                                 *dn++ = u > 9 ? 'a' + u - 10 : '0' + u;
  94                                 u = c & 0xf;
  95                                 *dn++ = u > 9 ? 'a' + u - 10 : '0' + u;
  96                         }
  97
  98                         *dn++ = ']';
  99                         continue;
 100                 }
 101
 102                 if (dn + n >= eom) {
 103                         return (-1);
 104                 }
 105                 for ((void)NULL; n > 0; n--) {
 106                         c = *cp++;
 107                         if (special(c)) {
 108                                 if (dn + 1 >= eom) {
 109                                         return (-1);
 110                                 }
 111                                 *dn++ = '\\';
 112                                 *dn++ = (char)c;
 113                         } else if (!printable(c)) {
 114                                 if (dn + 3 >= eom) {
 115                                         return (-1);
 116                                 }
 117                                 *dn++ = '\\';
 118                                 *dn++ = digits[c / 100];
 119                                 *dn++ = digits[(c % 100) / 10];
 120                                 *dn++ = digits[c % 10];
 121                         } else {
 122                                 if (dn >= eom) {
 123                                         return (-1);
 124                                 }
 125                                 *dn++ = (char)c;
 126                         }
 127                 }
 128         }
 129         if (dn == dst) {
 130                 if (dn >= eom) {
 131                         return (-1);
 132                 }
 133                 *dn++ = '.';
 134         }
 135         if (dn >= eom) {
 136                 return (-1);
 137         }
 138         *dn++ = '\0';
 139         return (dn - dst);
 140 }
 141
 142 /*
 143  * dns_ns_name_pton(src, dst, dstsiz)
 144  *      Convert a ascii string into an encoded domain name as per RFC1035.
 145  * return:
 146  *      -1 if it fails
 147  *      1 if string was fully qualified
 148  *      0 is string was not fully qualified
 149  * notes:
 150  *      Enforces label and domain length limits.
 151  */
 152
 153 int
 154 dns_ns_name_pton(const char *src, u_char *dst, size_t dstsiz) {
 155         u_char *label, *bp, *eom;
 156         int c, n, escaped;
 157         char *cp;
 158
 159         escaped = 0;
 160         bp = dst;
 161         eom = dst + dstsiz;
 162         label = bp++;
 163
 164         while ((c = *src++) != 0) {
 165                 if (escaped) {
 166                         if ((cp = strchr(digits, c)) != NULL) {
 167                                 n = (cp - digits) * 100;
 168                                 if ((c = *src++) == 0 ||
 169                                     (cp = strchr(digits, c)) == NULL) {
 170                                         return (-1);
 171                                 }
 172                                 n += (cp - digits) * 10;
 173                                 if ((c = *src++) == 0 ||
 174                                     (cp = strchr(digits, c)) == NULL) {
 175                                         return (-1);
 176                                 }
 177                                 n += (cp - digits);
 178                                 if (n > 255) {
 179                                         return (-1);
 180                                 }
 181                                 c = n;
 182                         } else if (c == '[' && label == bp - 1 && *src == 'x') {
 183                                 /* Theoretically we would have to handle \[o
 184                                    as well but we do not since we do not need
 185                                    it internally.  */
 186                                 *label = 0x41;
 187                                 label = bp++;
 188                                 ++src;
 189                                 while (isxdigit (*src)) {
 190                                         n = *src > '9' ? *src - 'a' + 10 : *src - '0';
 191                                         ++src;
 192                                         if (! isxdigit(*src)) {
 193                                                 return (-1);
 194                                         }
 195                                         n <<= 4;
 196                                         n += *src > '9' ? *src - 'a' + 10 : *src - '0';
 197                                         if (bp + 1 >= eom) {
 198                                                 return (-1);
 199                                         }
 200                                         *bp++ = n;
 201                                         ++src;
 202                                 }
 203                                 *label = (bp - label - 1) * 8;
 204                                 if (*src++ != ']' || *src++ != '.') {
 205                                         return (-1);
 206                                 }
 207                                 escaped = 0;
 208                                 label = bp++;
 209                                 if (bp >= eom) {
 210                                         return (-1);
 211                                 }
 212                                 continue;
 213                         }
 214                         escaped = 0;
 215                 } else if (c == '\\') {
 216                         escaped = 1;
 217                         continue;
 218                 } else if (c == '.') {
 219                         c = (bp - label - 1);
 220                         if ((c & NS_CMPRSFLGS) != 0) {  /* Label too big. */
 221                                 return (-1);
 222                         }
 223                         if (label >= eom) {
 224                                 return (-1);
 225                         }
 226                         *label = c;
 227                         /* Fully qualified ? */
 228                         if (*src == '\0') {
 229                                 if (c != 0) {
 230                                         if (bp >= eom) {
 231                                                 return (-1);
 232                                         }
 233                                         *bp++ = '\0';
 234                                 }
 235                                 if ((bp - dst) > NS_MAXCDNAME) {
 236                                         return (-1);
 237                                 }
 238                                 return (1);
 239                         }
 240                         if (c == 0 || *src == '.') {
 241                                 return (-1);
 242                         }
 243                         label = bp++;
 244                         continue;
 245                 }
 246                 if (bp >= eom) {
 247                         return (-1);
 248                 }
 249                 *bp++ = (u_char)c;
 250         }
 251         c = (bp - label - 1);
 252         if ((c & NS_CMPRSFLGS) != 0) {          /* Label too big. */
 253                 return (-1);
 254         }
 255         if (label >= eom) {
 256                 return (-1);
 257         }
 258         *label = c;
 259         if (c != 0) {
 260                 if (bp >= eom) {
 261                         return (-1);
 262                 }
 263                 *bp++ = 0;
 264         }
 265         if ((bp - dst) > NS_MAXCDNAME) {        /* src too big */
 266                 return (-1);
 267         }
 268         return (0);
 269 }
 270
 271
 272 /*
 273  * dns_ns_name_unpack(msg, eom, src, dst, dstsiz)
 274  *      Unpack a domain name from a message, source may be compressed.
 275  * return:
 276  *      -1 if it fails, or consumed octets if it succeeds.
 277  */
 278 int
 279 dns_ns_name_unpack(const u_char *msg, const u_char *eom, const u_char *src,
 280                u_char *dst, size_t dstsiz)
 281 {
 282         const u_char *srcp, *dstlim;
 283         u_char *dstp;
 284         int n, len, checked;
 285
 286         len = -1;
 287         checked = 0;
 288         dstp = dst;
 289         srcp = src;
 290         dstlim = dst + dstsiz;
 291         if (srcp < msg || srcp >= eom) {
 292                 return (-1);
 293         }
 294         /* Fetch next label in domain name. */
 295         while ((n = *srcp++) != 0) {
 296                 /* Check for indirection. */
 297                 switch (n & NS_CMPRSFLGS) {
 298                 case 0x40:
 299                         if (n == 0x41) {
 300                                 if (dstp + 1 >= dstlim) {
 301                                         return (-1);
 302                                 }
 303                                 *dstp++ = 0x41;
 304                                 n = *srcp++ / 8;
 305                                 ++checked;
 306                         } else {
 307                                 return (-1);            /* flag error */
 308                         }
 309                         /* FALLTHROUGH */
 310                 case 0:
 311                         /* Limit checks. */
 312                         if (dstp + n + 1 >= dstlim || srcp + n >= eom) {
 313                                 return (-1);
 314                         }
 315                         checked += n + 1;
 316                         dstp = memcpy(dstp, srcp - 1, n + 1);
 317                         dstp += n + 1;
 318                         srcp += n;
 319                         break;
 320
 321                 case NS_CMPRSFLGS:
 322                         if (srcp >= eom) {
 323                                 return (-1);
 324                         }
 325                         if (len < 0)
 326                                 len = srcp - src + 1;
 327                         srcp = msg + (((n & 0x3f) << 8) | (*srcp & 0xff));
 328                         if (srcp < msg || srcp >= eom) {  /* Out of range. */
 329                                 return (-1);
 330                         }
 331                         checked += 2;
 332                         /*
 333                          * Check for loops in the compressed name;
 334                          * if we've looked at the whole message,
 335                          * there must be a loop.
 336                          */
 337                         if (checked >= eom - msg) {
 338                                 return (-1);
 339                         }
 340                         break;
 341
 342                 default:
 343                         return (-1);                    /* flag error */
 344                 }
 345         }
 346         *dstp = '\0';
 347         if (len < 0)
 348                 len = srcp - src;
 349         return (len);
 350 }
 351
 352
 353 /*
 354  * dns_ns_name_uncompress(msg, eom, src, dst, dstsiz)
 355  *      Expand compressed domain name to presentation format.
 356  * return:
 357  *      Number of bytes read out of `src', or -1 (with errno set).
 358  * note:
 359  *      Root domain returns as "." not "".
 360  */
 361 int
 362 dns_ns_name_uncompress(const u_char *msg, const u_char *eom, const u_char *src,
 363                    char *dst, size_t dstsiz)
 364 {
 365         u_char tmp[NS_MAXCDNAME];
 366         int n;
 367
 368         if ((n = dns_ns_name_unpack(msg, eom, src, tmp, sizeof tmp)) == -1)
 369                 return (-1);
 370         if (dns_ns_name_ntop(tmp, dst, dstsiz) == -1)
 371                 return (-1);
 372         return (n);
 373 }
 374
 375
 376 /*
 377  * dns_ns_name_skip(ptrptr, eom)
 378  *      Advance *ptrptr to skip over the compressed name it points at.
 379  * return:
 380  *      0 on success, -1 (with errno set) on failure.
 381  */
 382 int
 383 dns_ns_name_skip(const u_char **ptrptr, const u_char *eom) {
 384         const u_char *cp;
 385         u_int n;
 386
 387         cp = *ptrptr;
 388         while (cp < eom && (n = *cp++) != 0) {
 389                 /* Check for indirection. */
 390                 switch (n & NS_CMPRSFLGS) {
 391                 case 0:                 /* normal case, n == len */
 392                         cp += n;
 393                         continue;
 394                 case NS_CMPRSFLGS:      /* indirection */
 395                         cp++;
 396                         break;
 397                 default:                /* illegal type */
 398                         return (-1);
 399                 }
 400                 break;
 401         }
 402         if (cp > eom) {
 403                 return (-1);
 404         }
 405         *ptrptr = cp;
 406         return (0);
 407 }
 408
 409 /* Private. */
 410
 411 /*
 412  * special(ch)
 413  *      Thinking in noninternationalized USASCII (per the DNS spec),
 414  *      is this characted special ("in need of quoting") ?
 415  * return:
 416  *      boolean.
 417  */
 418 static int
 419 special(int ch) {
 420         switch (ch) {
 421         case 0x22: /* '"' */
 422         case 0x2E: /* '.' */
 423         case 0x3B: /* ';' */
 424         case 0x5C: /* '\\' */
 425         /* Special modifiers in zone files. */
 426         case 0x40: /* '@' */
 427         case 0x24: /* '$' */
 428                 return (1);
 429         default:
 430                 return (0);
 431         }
 432 }
 433
 434 /*
 435  * printable(ch)
 436  *      Thinking in noninternationalized USASCII (per the DNS spec),
 437  *      is this character visible and not a space when printed ?
 438  * return:
 439  *      boolean.
 440  */
 441 static int
 442 printable(int ch) {
 443         return (ch > 0x20 && ch < 0x7f);
 444 }