resolv/ns_name.c

   1 /*
   2  * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (c) 1996,1999 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
  18 #include <sys/types.h>
  19
  20 #include <netinet/in.h>
  21 #include <arpa/nameser.h>
  22
  23 #include <errno.h>
  24 #include <resolv.h>
  25 #include <string.h>
  26 #include <ctype.h>
  27 #include <stdlib.h>
  28 #include <limits.h>
  29
  30 # define SPRINTF(x) ((size_t)sprintf x)
  31
  32 /* Data. */
  33
  34 static const char       digits[] = "0123456789";
  35
  36 /* Forward. */
  37
  38 static int              special(int);
  39 static int              printable(int);
  40 static int              dn_find(const u_char *, const u_char *,
  41                                 const u_char * const *,
  42                                 const u_char * const *);
  43 static int              labellen(const u_char *);
  44
  45 /* Public. */
  46
  47 /*%
  48  *      Convert an encoded domain name to printable ascii as per RFC1035.
  49
  50  * return:
  51  *\li   Number of bytes written to buffer, or -1 (with errno set)
  52  *
  53  * notes:
  54  *\li   The root is returned as "."
  55  *\li   All other domains are returned in non absolute form
  56  */
  57 int
  58 ns_name_ntop(const u_char *src, char *dst, size_t dstsiz)
  59 {
  60         const u_char *cp;
  61         char *dn, *eom;
  62         u_char c;
  63         u_int n;
  64         int l;
  65
  66         cp = src;
  67         dn = dst;
  68         eom = dst + dstsiz;
  69
  70         while ((n = *cp++) != 0) {
  71                 if ((n & NS_CMPRSFLGS) == NS_CMPRSFLGS) {
  72                         /* Some kind of compression pointer. */
  73                         __set_errno (EMSGSIZE);
  74                         return (-1);
  75                 }
  76                 if (dn != dst) {
  77                         if (dn >= eom) {
  78                                 __set_errno (EMSGSIZE);
  79                                 return (-1);
  80                         }
  81                         *dn++ = '.';
  82                 }
  83                 if ((l = labellen(cp - 1)) < 0) {
  84                         __set_errno (EMSGSIZE);
  85                         return(-1);
  86                 }
  87                 if (dn + l >= eom) {
  88                         __set_errno (EMSGSIZE);
  89                         return (-1);
  90                 }
  91                 for ((void)NULL; l > 0; l--) {
  92                         c = *cp++;
  93                         if (special(c)) {
  94                                 if (dn + 1 >= eom) {
  95                                         __set_errno (EMSGSIZE);
  96                                         return (-1);
  97                                 }
  98                                 *dn++ = '\\';
  99                                 *dn++ = (char)c;
 100                         } else if (!printable(c)) {
 101                                 if (dn + 3 >= eom) {
 102                                         __set_errno (EMSGSIZE);
 103                                         return (-1);
 104                                 }
 105                                 *dn++ = '\\';
 106                                 *dn++ = digits[c / 100];
 107                                 *dn++ = digits[(c % 100) / 10];
 108                                 *dn++ = digits[c % 10];
 109                         } else {
 110                                 if (dn >= eom) {
 111                                         __set_errno (EMSGSIZE);
 112                                         return (-1);
 113                                 }
 114                                 *dn++ = (char)c;
 115                         }
 116                 }
 117         }
 118         if (dn == dst) {
 119                 if (dn >= eom) {
 120                         __set_errno (EMSGSIZE);
 121                         return (-1);
 122                 }
 123                 *dn++ = '.';
 124         }
 125         if (dn >= eom) {
 126                 __set_errno (EMSGSIZE);
 127                 return (-1);
 128         }
 129         *dn++ = '\0';
 130         return (dn - dst);
 131 }
 132 libresolv_hidden_def (ns_name_ntop)
 133 strong_alias (ns_name_ntop, __ns_name_ntop)
 134
 135 /*%
 136  *      Convert an ascii string into an encoded domain name as per RFC1035.
 137  *
 138  * return:
 139  *
 140  *\li   -1 if it fails
 141  *\li   1 if string was fully qualified
 142  *\li   0 is string was not fully qualified
 143  *
 144  * notes:
 145  *\li   Enforces label and domain length limits.
 146  */
 147
 148 int
 149 ns_name_pton(const char *src, u_char *dst, size_t dstsiz)
 150 {
 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                                         __set_errno (EMSGSIZE);
 167                                         return (-1);
 168                                 }
 169                                 n += (cp - digits) * 10;
 170                                 if ((c = *src++) == 0 ||
 171                                     (cp = strchr(digits, c)) == NULL) {
 172                                         __set_errno (EMSGSIZE);
 173                                         return (-1);
 174                                 }
 175                                 n += (cp - digits);
 176                                 if (n > 255) {
 177                                         __set_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                                 __set_errno (EMSGSIZE);
 190                                 return (-1);
 191                         }
 192                         if (label >= eom) {
 193                                 __set_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                                                 __set_errno (EMSGSIZE);
 202                                                 return (-1);
 203                                         }
 204                                         *bp++ = '\0';
 205                                 }
 206                                 if ((bp - dst) > MAXCDNAME) {
 207                                         __set_errno (EMSGSIZE);
 208                                         return (-1);
 209                                 }
 210                                 return (1);
 211                         }
 212                         if (c == 0 || *src == '.') {
 213                                 __set_errno (EMSGSIZE);
 214                                 return (-1);
 215                         }
 216                         label = bp++;
 217                         continue;
 218                 }
 219                 if (bp >= eom) {
 220                         __set_errno (EMSGSIZE);
 221                         return (-1);
 222                 }
 223                 *bp++ = (u_char)c;
 224         }
 225         if (escaped) {
 226                 /* Trailing backslash.  */
 227                 __set_errno (EMSGSIZE);
 228                 return -1;
 229         }
 230         c = (bp - label - 1);
 231         if ((c & NS_CMPRSFLGS) != 0) {          /*%< Label too big. */
 232                 __set_errno (EMSGSIZE);
 233                 return (-1);
 234         }
 235         if (label >= eom) {
 236                 __set_errno (EMSGSIZE);
 237                 return (-1);
 238         }
 239         *label = c;
 240         if (c != 0) {
 241                 if (bp >= eom) {
 242                         __set_errno (EMSGSIZE);
 243                         return (-1);
 244                 }
 245                 *bp++ = 0;
 246         }
 247         if ((bp - dst) > MAXCDNAME) {   /*%< src too big */
 248                 __set_errno (EMSGSIZE);
 249                 return (-1);
 250         }
 251         return (0);
 252 }
 253 libresolv_hidden_def (ns_name_pton)
 254
 255 /*%
 256  *      Convert a network strings labels into all lowercase.
 257  *
 258  * return:
 259  *\li   Number of bytes written to buffer, or -1 (with errno set)
 260  *
 261  * notes:
 262  *\li   Enforces label and domain length limits.
 263  */
 264
 265 int
 266 ns_name_ntol(const u_char *src, u_char *dst, size_t dstsiz)
 267 {
 268         const u_char *cp;
 269         u_char *dn, *eom;
 270         u_char c;
 271         u_int n;
 272         int l;
 273
 274         cp = src;
 275         dn = dst;
 276         eom = dst + dstsiz;
 277
 278         if (dn >= eom) {
 279                 __set_errno (EMSGSIZE);
 280                 return (-1);
 281         }
 282         while ((n = *cp++) != 0) {
 283                 if ((n & NS_CMPRSFLGS) == NS_CMPRSFLGS) {
 284                         /* Some kind of compression pointer. */
 285                         __set_errno (EMSGSIZE);
 286                         return (-1);
 287                 }
 288                 *dn++ = n;
 289                 if ((l = labellen(cp - 1)) < 0) {
 290                         __set_errno (EMSGSIZE);
 291                         return (-1);
 292                 }
 293                 if (dn + l >= eom) {
 294                         __set_errno (EMSGSIZE);
 295                         return (-1);
 296                 }
 297                 for ((void)NULL; l > 0; l--) {
 298                         c = *cp++;
 299                         if (isupper(c))
 300                                 *dn++ = tolower(c);
 301                         else
 302                                 *dn++ = c;
 303                 }
 304         }
 305         *dn++ = '\0';
 306         return (dn - dst);
 307 }
 308
 309 /*%
 310  *      Unpack a domain name from a message, source may be compressed.
 311  *
 312  * return:
 313  *\li   -1 if it fails, or consumed octets if it succeeds.
 314  */
 315 int
 316 ns_name_unpack(const u_char *msg, const u_char *eom, const u_char *src,
 317                u_char *dst, size_t dstsiz)
 318 {
 319         const u_char *srcp, *dstlim;
 320         u_char *dstp;
 321         int n, len, checked, l;
 322
 323         len = -1;
 324         checked = 0;
 325         dstp = dst;
 326         srcp = src;
 327         dstlim = dst + dstsiz;
 328         if (srcp < msg || srcp >= eom) {
 329                 __set_errno (EMSGSIZE);
 330                 return (-1);
 331         }
 332         /* Fetch next label in domain name. */
 333         while ((n = *srcp++) != 0) {
 334                 /* Check for indirection. */
 335                 switch (n & NS_CMPRSFLGS) {
 336                 case 0:
 337                         /* Limit checks. */
 338                         if ((l = labellen(srcp - 1)) < 0) {
 339                                 __set_errno (EMSGSIZE);
 340                                 return(-1);
 341                         }
 342                         if (dstp + l + 1 >= dstlim || srcp + l >= eom) {
 343                                 __set_errno (EMSGSIZE);
 344                                 return (-1);
 345                         }
 346                         checked += l + 1;
 347                         *dstp++ = n;
 348                         memcpy(dstp, srcp, l);
 349                         dstp += l;
 350                         srcp += l;
 351                         break;
 352
 353                 case NS_CMPRSFLGS:
 354                         if (srcp >= eom) {
 355                                 __set_errno (EMSGSIZE);
 356                                 return (-1);
 357                         }
 358                         if (len < 0)
 359                                 len = srcp - src + 1;
 360                         srcp = msg + (((n & 0x3f) << 8) | (*srcp & 0xff));
 361                         if (srcp < msg || srcp >= eom) {  /*%< Out of range. */
 362                                 __set_errno (EMSGSIZE);
 363                                 return (-1);
 364                         }
 365                         checked += 2;
 366                         /*
 367                          * Check for loops in the compressed name;
 368                          * if we've looked at the whole message,
 369                          * there must be a loop.
 370                          */
 371                         if (checked >= eom - msg) {
 372                                 __set_errno (EMSGSIZE);
 373                                 return (-1);
 374                         }
 375                         break;
 376
 377                 default:
 378                         __set_errno (EMSGSIZE);
 379                         return (-1);                    /*%< flag error */
 380                 }
 381         }
 382         *dstp = '\0';
 383         if (len < 0)
 384                 len = srcp - src;
 385         return (len);
 386 }
 387 libresolv_hidden_def (ns_name_unpack)
 388 strong_alias (ns_name_unpack, __ns_name_unpack)
 389
 390 /*%
 391  *      Pack domain name 'domain' into 'comp_dn'.
 392  *
 393  * return:
 394  *\li   Size of the compressed name, or -1.
 395  *
 396  * notes:
 397  *\li   'dnptrs' is an array of pointers to previous compressed names.
 398  *\li   dnptrs[0] is a pointer to the beginning of the message. The array
 399  *      ends with NULL.
 400  *\li   'lastdnptr' is a pointer to the end of the array pointed to
 401  *      by 'dnptrs'.
 402  *
 403  * Side effects:
 404  *\li   The list of pointers in dnptrs is updated for labels inserted into
 405  *      the message as we compress the name.  If 'dnptr' is NULL, we don't
 406  *      try to compress names. If 'lastdnptr' is NULL, we don't update the
 407  *      list.
 408  */
 409 int
 410 ns_name_pack(const u_char *src, u_char *dst, int dstsiz,
 411              const u_char **dnptrs, const u_char **lastdnptr)
 412 {
 413         u_char *dstp;
 414         const u_char **cpp, **lpp, *eob, *msg;
 415         const u_char *srcp;
 416         int n, l, first = 1;
 417
 418         srcp = src;
 419         dstp = dst;
 420         eob = dstp + dstsiz;
 421         lpp = cpp = NULL;
 422         if (dnptrs != NULL) {
 423                 if ((msg = *dnptrs++) != NULL) {
 424                         for (cpp = dnptrs; *cpp != NULL; cpp++)
 425                                 (void)NULL;
 426                         lpp = cpp;      /*%< end of list to search */
 427                 }
 428         } else
 429                 msg = NULL;
 430
 431         /* make sure the domain we are about to add is legal */
 432         l = 0;
 433         do {
 434                 int l0;
 435
 436                 n = *srcp;
 437                 if ((n & NS_CMPRSFLGS) == NS_CMPRSFLGS) {
 438                         __set_errno (EMSGSIZE);
 439                         return (-1);
 440                 }
 441                 if ((l0 = labellen(srcp)) < 0) {
 442                         __set_errno (EINVAL);
 443                         return(-1);
 444                 }
 445                 l += l0 + 1;
 446                 if (l > MAXCDNAME) {
 447                         __set_errno (EMSGSIZE);
 448                         return (-1);
 449                 }
 450                 srcp += l0 + 1;
 451         } while (n != 0);
 452
 453         /* from here on we need to reset compression pointer array on error */
 454         srcp = src;
 455         do {
 456                 /* Look to see if we can use pointers. */
 457                 n = *srcp;
 458                 if (n != 0 && msg != NULL) {
 459                         l = dn_find(srcp, msg, (const u_char * const *)dnptrs,
 460                                     (const u_char * const *)lpp);
 461                         if (l >= 0) {
 462                                 if (dstp + 1 >= eob) {
 463                                         goto cleanup;
 464                                 }
 465                                 *dstp++ = (l >> 8) | NS_CMPRSFLGS;
 466                                 *dstp++ = l % 256;
 467                                 return (dstp - dst);
 468                         }
 469                         /* Not found, save it. */
 470                         if (lastdnptr != NULL && cpp < lastdnptr - 1 &&
 471                             (dstp - msg) < 0x4000 && first) {
 472                                 *cpp++ = dstp;
 473                                 *cpp = NULL;
 474                                 first = 0;
 475                         }
 476                 }
 477                 /* copy label to buffer */
 478                 if ((n & NS_CMPRSFLGS) == NS_CMPRSFLGS) {
 479                         /* Should not happen. */
 480                         goto cleanup;
 481                 }
 482                 n = labellen(srcp);
 483                 if (n + 1 > eob - dstp) {
 484                         goto cleanup;
 485                 }
 486                 memcpy(dstp, srcp, n + 1);
 487                 srcp += n + 1;
 488                 dstp += n + 1;
 489         } while (n != 0);
 490
 491         if (dstp > eob) {
 492 cleanup:
 493                 if (msg != NULL)
 494                         *lpp = NULL;
 495                 __set_errno (EMSGSIZE);
 496                 return (-1);
 497         }
 498         return (dstp - dst);
 499 }
 500 libresolv_hidden_def (ns_name_pack)
 501
 502 /*%
 503  *      Expand compressed domain name to presentation format.
 504  *
 505  * return:
 506  *\li   Number of bytes read out of `src', or -1 (with errno set).
 507  *
 508  * note:
 509  *\li   Root domain returns as "." not "".
 510  */
 511 int
 512 ns_name_uncompress(const u_char *msg, const u_char *eom, const u_char *src,
 513                    char *dst, size_t dstsiz)
 514 {
 515         u_char tmp[NS_MAXCDNAME];
 516         int n;
 517
 518         if ((n = ns_name_unpack(msg, eom, src, tmp, sizeof tmp)) == -1)
 519                 return (-1);
 520         if (ns_name_ntop(tmp, dst, dstsiz) == -1)
 521                 return (-1);
 522         return (n);
 523 }
 524 libresolv_hidden_def (ns_name_uncompress)
 525
 526 /*%
 527  *      Compress a domain name into wire format, using compression pointers.
 528  *
 529  * return:
 530  *\li   Number of bytes consumed in `dst' or -1 (with errno set).
 531  *
 532  * notes:
 533  *\li   'dnptrs' is an array of pointers to previous compressed names.
 534  *\li   dnptrs[0] is a pointer to the beginning of the message.
 535  *\li   The list ends with NULL.  'lastdnptr' is a pointer to the end of the
 536  *      array pointed to by 'dnptrs'. Side effect is to update the list of
 537  *      pointers for labels inserted into the message as we compress the name.
 538  *\li   If 'dnptr' is NULL, we don't try to compress names. If 'lastdnptr'
 539  *      is NULL, we don't update the list.
 540  */
 541 int
 542 ns_name_compress(const char *src, u_char *dst, size_t dstsiz,
 543                  const u_char **dnptrs, const u_char **lastdnptr)
 544 {
 545         u_char tmp[NS_MAXCDNAME];
 546
 547         if (ns_name_pton(src, tmp, sizeof tmp) == -1)
 548                 return (-1);
 549         return (ns_name_pack(tmp, dst, dstsiz, dnptrs, lastdnptr));
 550 }
 551 libresolv_hidden_def (ns_name_compress)
 552
 553 /*%
 554  * Reset dnptrs so that there are no active references to pointers at or
 555  * after src.
 556  */
 557 void
 558 ns_name_rollback(const u_char *src, const u_char **dnptrs,
 559                  const u_char **lastdnptr)
 560 {
 561         while (dnptrs < lastdnptr && *dnptrs != NULL) {
 562                 if (*dnptrs >= src) {
 563                         *dnptrs = NULL;
 564                         break;
 565                 }
 566                 dnptrs++;
 567         }
 568 }
 569
 570 /*%
 571  *      Advance *ptrptr to skip over the compressed name it points at.
 572  *
 573  * return:
 574  *\li   0 on success, -1 (with errno set) on failure.
 575  */
 576 int
 577 ns_name_skip(const u_char **ptrptr, const u_char *eom)
 578 {
 579         const u_char *cp;
 580         u_int n;
 581
 582         cp = *ptrptr;
 583         while (cp < eom && (n = *cp++) != 0) {
 584                 /* Check for indirection. */
 585                 switch (n & NS_CMPRSFLGS) {
 586                 case 0:                 /*%< normal case, n == len */
 587                         cp += n;
 588                         continue;
 589                 case NS_CMPRSFLGS:      /*%< indirection */
 590                         cp++;
 591                         break;
 592                 default:                /*%< illegal type */
 593                         __set_errno (EMSGSIZE);
 594                         return (-1);
 595                 }
 596                 break;
 597         }
 598         if (cp > eom) {
 599                 __set_errno (EMSGSIZE);
 600                 return (-1);
 601         }
 602         *ptrptr = cp;
 603         return (0);
 604 }
 605 libresolv_hidden_def (ns_name_skip)
 606
 607 /* Private. */
 608
 609 /*%
 610  *      Thinking in noninternationalized USASCII (per the DNS spec),
 611  *      is this character special ("in need of quoting") ?
 612  *
 613  * return:
 614  *\li   boolean.
 615  */
 616 static int
 617 special(int ch) {
 618         switch (ch) {
 619         case 0x22: /*%< '"' */
 620         case 0x2E: /*%< '.' */
 621         case 0x3B: /*%< ';' */
 622         case 0x5C: /*%< '\\' */
 623         case 0x28: /*%< '(' */
 624         case 0x29: /*%< ')' */
 625         /* Special modifiers in zone files. */
 626         case 0x40: /*%< '@' */
 627         case 0x24: /*%< '$' */
 628                 return (1);
 629         default:
 630                 return (0);
 631         }
 632 }
 633
 634 /*%
 635  *      Thinking in noninternationalized USASCII (per the DNS spec),
 636  *      is this character visible and not a space when printed ?
 637  *
 638  * return:
 639  *\li   boolean.
 640  */
 641 static int
 642 printable(int ch) {
 643         return (ch > 0x20 && ch < 0x7f);
 644 }
 645
 646 /*%
 647  *      Thinking in noninternationalized USASCII (per the DNS spec),
 648  *      convert this character to lower case if it's upper case.
 649  */
 650 static int
 651 mklower(int ch) {
 652         if (ch >= 0x41 && ch <= 0x5A)
 653                 return (ch + 0x20);
 654         return (ch);
 655 }
 656
 657 /*%
 658  *      Search for the counted-label name in an array of compressed names.
 659  *
 660  * return:
 661  *\li   offset from msg if found, or -1.
 662  *
 663  * notes:
 664  *\li   dnptrs is the pointer to the first name on the list,
 665  *\li   not the pointer to the start of the message.
 666  */
 667 static int
 668 dn_find(const u_char *domain, const u_char *msg,
 669         const u_char * const *dnptrs,
 670         const u_char * const *lastdnptr)
 671 {
 672         const u_char *dn, *cp, *sp;
 673         const u_char * const *cpp;
 674         u_int n;
 675
 676         for (cpp = dnptrs; cpp < lastdnptr; cpp++) {
 677                 sp = *cpp;
 678                 /*
 679                  * terminate search on:
 680                  * root label
 681                  * compression pointer
 682                  * unusable offset
 683                  */
 684                 while (*sp != 0 && (*sp & NS_CMPRSFLGS) == 0 &&
 685                        (sp - msg) < 0x4000) {
 686                         dn = domain;
 687                         cp = sp;
 688                         while ((n = *cp++) != 0) {
 689                                 /*
 690                                  * check for indirection
 691                                  */
 692                                 switch (n & NS_CMPRSFLGS) {
 693                                 case 0:         /*%< normal case, n == len */
 694                                         n = labellen(cp - 1); /*%< XXX */
 695                                         if (n != *dn++)
 696                                                 goto next;
 697
 698                                         for ((void)NULL; n > 0; n--)
 699                                                 if (mklower(*dn++) !=
 700                                                     mklower(*cp++))
 701                                                         goto next;
 702                                         /* Is next root for both ? */
 703                                         if (*dn == '\0' && *cp == '\0')
 704                                                 return (sp - msg);
 705                                         if (*dn)
 706                                                 continue;
 707                                         goto next;
 708                                 case NS_CMPRSFLGS:      /*%< indirection */
 709                                         cp = msg + (((n & 0x3f) << 8) | *cp);
 710                                         break;
 711
 712                                 default:        /*%< illegal type */
 713                                         __set_errno (EMSGSIZE);
 714                                         return (-1);
 715                                 }
 716                         }
 717   next: ;
 718                         sp += *sp + 1;
 719                 }
 720         }
 721         __set_errno (ENOENT);
 722         return (-1);
 723 }
 724
 725 /* Return the length of the encoded label starting at LP, or -1 for
 726    compression references and extended label types.  */
 727 static int
 728 labellen (const unsigned char *lp)
 729 {
 730   if (*lp <= 63)
 731     return *lp;
 732   return -1;
 733 }
 734
 735 /*! \file */