lib/libc/net/ip6opt.c

   1 /*      $KAME: ip6opt.c,v 1.13 2003/06/06 10:08:20 suz Exp $    */
   2
   3 /*
   4  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the project nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  * $FreeBSD: src/lib/libc/net/ip6opt.c,v 1.8 2005/07/19 18:13:58 ume Exp $
  32  */
  33
  34 #include <sys/param.h>
  35 #include <sys/types.h>
  36 #include <sys/socket.h>
  37
  38 #include <netinet/in.h>
  39 #include <netinet/ip6.h>
  40
  41 #include <string.h>
  42 #include <stdio.h>
  43
  44 static int ip6optlen(u_int8_t *opt, u_int8_t *lim);
  45 static void inet6_insert_padopt(u_char *p, int len);
  46
  47 /*
  48  * This function returns the number of bytes required to hold an option
  49  * when it is stored as ancillary data, including the cmsghdr structure
  50  * at the beginning, and any padding at the end (to make its size a
  51  * multiple of 8 bytes).  The argument is the size of the structure
  52  * defining the option, which must include any pad bytes at the
  53  * beginning (the value y in the alignment term "xn + y"), the type
  54  * byte, the length byte, and the option data.
  55  */
  56 int
  57 inet6_option_space(int nbytes)
  58 {
  59         nbytes += 2;    /* we need space for nxt-hdr and length fields */
  60         return(CMSG_SPACE((nbytes + 7) & ~7));
  61 }
  62
  63 /*
  64  * This function is called once per ancillary data object that will
  65  * contain either Hop-by-Hop or Destination options.  It returns 0 on
  66  * success or -1 on an error.
  67  */
  68 int
  69 inet6_option_init(void *bp, struct cmsghdr **cmsgp, int type)
  70 {
  71         struct cmsghdr *ch = (struct cmsghdr *)bp;
  72
  73         /* argument validation */
  74         if (type != IPV6_HOPOPTS && type != IPV6_DSTOPTS)
  75                 return(-1);
  76
  77         ch->cmsg_level = IPPROTO_IPV6;
  78         ch->cmsg_type = type;
  79         ch->cmsg_len = CMSG_LEN(0);
  80
  81         *cmsgp = ch;
  82         return(0);
  83 }
  84
  85 /*
  86  * This function appends a Hop-by-Hop option or a Destination option
  87  * into an ancillary data object that has been initialized by
  88  * inet6_option_init().  This function returns 0 if it succeeds or -1 on
  89  * an error.
  90  * multx is the value x in the alignment term "xn + y" described
  91  * earlier.  It must have a value of 1, 2, 4, or 8.
  92  * plusy is the value y in the alignment term "xn + y" described
  93  * earlier.  It must have a value between 0 and 7, inclusive.
  94  */
  95 int
  96 inet6_option_append(struct cmsghdr *cmsg, const u_int8_t *typep, int multx,
  97                     int plusy)
  98 {
  99         int padlen, optlen, off;
 100         u_char *bp = (u_char *)cmsg + cmsg->cmsg_len;
 101         struct ip6_ext *eh = (struct ip6_ext *)CMSG_DATA(cmsg);
 102
 103         /* argument validation */
 104         if (multx != 1 && multx != 2 && multx != 4 && multx != 8)
 105                 return(-1);
 106         if (plusy < 0 || plusy > 7)
 107                 return(-1);
 108
 109         /*
 110          * If this is the first option, allocate space for the
 111          * first 2 bytes(for next header and length fields) of
 112          * the option header.
 113          */
 114         if (bp == (u_char *)eh) {
 115                 bp += 2;
 116                 cmsg->cmsg_len += 2;
 117         }
 118
 119         /* calculate pad length before the option. */
 120         off = bp - (u_char *)eh;
 121         padlen = (((off % multx) + (multx - 1)) & ~(multx - 1)) -
 122                 (off % multx);
 123         padlen += plusy;
 124         padlen %= multx;        /* keep the pad as short as possible */
 125         /* insert padding */
 126         inet6_insert_padopt(bp, padlen);
 127         cmsg->cmsg_len += padlen;
 128         bp += padlen;
 129
 130         /* copy the option */
 131         if (typep[0] == IP6OPT_PAD1)
 132                 optlen = 1;
 133         else
 134                 optlen = typep[1] + 2;
 135         memcpy(bp, typep, optlen);
 136         bp += optlen;
 137         cmsg->cmsg_len += optlen;
 138
 139         /* calculate pad length after the option and insert the padding */
 140         off = bp - (u_char *)eh;
 141         padlen = ((off + 7) & ~7) - off;
 142         inet6_insert_padopt(bp, padlen);
 143         bp += padlen;
 144         cmsg->cmsg_len += padlen;
 145
 146         /* update the length field of the ip6 option header */
 147         eh->ip6e_len = ((bp - (u_char *)eh) >> 3) - 1;
 148
 149         return(0);
 150 }
 151
 152 /*
 153  * This function appends a Hop-by-Hop option or a Destination option
 154  * into an ancillary data object that has been initialized by
 155  * inet6_option_init().  This function returns a pointer to the 8-bit
 156  * option type field that starts the option on success, or NULL on an
 157  * error.
 158  * The difference between this function and inet6_option_append() is
 159  * that the latter copies the contents of a previously built option into
 160  * the ancillary data object while the current function returns a
 161  * pointer to the space in the data object where the option's TLV must
 162  * then be built by the caller.
 163  *
 164  */
 165 u_int8_t *
 166 inet6_option_alloc(struct cmsghdr *cmsg, int datalen, int multx, int plusy)
 167 {
 168         int padlen, off;
 169         u_int8_t *bp = (u_char *)cmsg + cmsg->cmsg_len;
 170         u_int8_t *retval;
 171         struct ip6_ext *eh = (struct ip6_ext *)CMSG_DATA(cmsg);
 172
 173         /* argument validation */
 174         if (multx != 1 && multx != 2 && multx != 4 && multx != 8)
 175                 return(NULL);
 176         if (plusy < 0 || plusy > 7)
 177                 return(NULL);
 178
 179         /*
 180          * If this is the first option, allocate space for the
 181          * first 2 bytes(for next header and length fields) of
 182          * the option header.
 183          */
 184         if (bp == (u_char *)eh) {
 185                 bp += 2;
 186                 cmsg->cmsg_len += 2;
 187         }
 188
 189         /* calculate pad length before the option. */
 190         off = bp - (u_char *)eh;
 191         padlen = (((off % multx) + (multx - 1)) & ~(multx - 1)) -
 192                 (off % multx);
 193         padlen += plusy;
 194         padlen %= multx;        /* keep the pad as short as possible */
 195         /* insert padding */
 196         inet6_insert_padopt(bp, padlen);
 197         cmsg->cmsg_len += padlen;
 198         bp += padlen;
 199
 200         /* keep space to store specified length of data */
 201         retval = bp;
 202         bp += datalen;
 203         cmsg->cmsg_len += datalen;
 204
 205         /* calculate pad length after the option and insert the padding */
 206         off = bp - (u_char *)eh;
 207         padlen = ((off + 7) & ~7) - off;
 208         inet6_insert_padopt(bp, padlen);
 209         bp += padlen;
 210         cmsg->cmsg_len += padlen;
 211
 212         /* update the length field of the ip6 option header */
 213         eh->ip6e_len = ((bp - (u_char *)eh) >> 3) - 1;
 214
 215         return(retval);
 216 }
 217
 218 /*
 219  * This function processes the next Hop-by-Hop option or Destination
 220  * option in an ancillary data object.  If another option remains to be
 221  * processed, the return value of the function is 0 and *tptrp points to
 222  * the 8-bit option type field (which is followed by the 8-bit option
 223  * data length, followed by the option data).  If no more options remain
 224  * to be processed, the return value is -1 and *tptrp is NULL.  If an
 225  * error occurs, the return value is -1 and *tptrp is not NULL.
 226  * (RFC 2292, 6.3.5)
 227  */
 228 int
 229 inet6_option_next(const struct cmsghdr *cmsg, u_int8_t **tptrp)
 230 {
 231         struct ip6_ext *ip6e;
 232         int hdrlen, optlen;
 233         u_int8_t *lim;
 234
 235         if (cmsg->cmsg_level != IPPROTO_IPV6 ||
 236             (cmsg->cmsg_type != IPV6_HOPOPTS &&
 237              cmsg->cmsg_type != IPV6_DSTOPTS))
 238                 return(-1);
 239
 240         /* message length validation */
 241         if (cmsg->cmsg_len < CMSG_SPACE(sizeof(struct ip6_ext)))
 242                 return(-1);
 243         ip6e = (struct ip6_ext *)CMSG_DATA(cmsg);
 244         hdrlen = (ip6e->ip6e_len + 1) << 3;
 245         if (cmsg->cmsg_len < CMSG_SPACE(hdrlen))
 246                 return(-1);
 247
 248         /*
 249          * If the caller does not specify the starting point,
 250          * simply return the 1st option.
 251          * Otherwise, search the option list for the next option.
 252          */
 253         lim = (u_int8_t *)ip6e + hdrlen;
 254         if (*tptrp == NULL)
 255                 *tptrp = (u_int8_t *)(ip6e + 1);
 256         else {
 257                 if ((optlen = ip6optlen(*tptrp, lim)) == 0)
 258                         return(-1);
 259
 260                 *tptrp = *tptrp + optlen;
 261         }
 262         if (*tptrp >= lim) {    /* there is no option */
 263                 *tptrp = NULL;
 264                 return(-1);
 265         }
 266         /*
 267          * Finally, checks if the next option is safely stored in the
 268          * cmsg data.
 269          */
 270         if (ip6optlen(*tptrp, lim) == 0)
 271                 return(-1);
 272         else
 273                 return(0);
 274 }
 275
 276 /*
 277  * This function is similar to the inet6_option_next() function,
 278  * except this function lets the caller specify the option type to be
 279  * searched for, instead of always returning the next option in the
 280  * ancillary data object.
 281  * Note: RFC 2292 says the type of tptrp is u_int8_t *, but we think
 282  *       it's a typo. The variable should be type of u_int8_t **.
 283  */
 284 int
 285 inet6_option_find(const struct cmsghdr *cmsg, u_int8_t **tptrp, int type)
 286 {
 287         struct ip6_ext *ip6e;
 288         int hdrlen, optlen;
 289         u_int8_t *optp, *lim;
 290
 291         if (cmsg->cmsg_level != IPPROTO_IPV6 ||
 292             (cmsg->cmsg_type != IPV6_HOPOPTS &&
 293              cmsg->cmsg_type != IPV6_DSTOPTS))
 294                 return(-1);
 295
 296         /* message length validation */
 297         if (cmsg->cmsg_len < CMSG_SPACE(sizeof(struct ip6_ext)))
 298                 return(-1);
 299         ip6e = (struct ip6_ext *)CMSG_DATA(cmsg);
 300         hdrlen = (ip6e->ip6e_len + 1) << 3;
 301         if (cmsg->cmsg_len < CMSG_SPACE(hdrlen))
 302                 return(-1);
 303
 304         /*
 305          * If the caller does not specify the starting point,
 306          * search from the beginning of the option list.
 307          * Otherwise, search from *the next option* of the specified point.
 308          */
 309         lim = (u_int8_t *)ip6e + hdrlen;
 310         if (*tptrp == NULL)
 311                 *tptrp = (u_int8_t *)(ip6e + 1);
 312         else {
 313                 if ((optlen = ip6optlen(*tptrp, lim)) == 0)
 314                         return(-1);
 315
 316                 *tptrp = *tptrp + optlen;
 317         }
 318         for (optp = *tptrp; optp < lim; optp += optlen) {
 319                 if (*optp == type) {
 320                         *tptrp = optp;
 321                         return(0);
 322                 }
 323                 if ((optlen = ip6optlen(optp, lim)) == 0)
 324                         return(-1);
 325         }
 326
 327         /* search failed */
 328         *tptrp = NULL;
 329         return(-1);
 330 }
 331
 332 /*
 333  * Calculate the length of a given IPv6 option. Also checks
 334  * if the option is safely stored in user's buffer according to the
 335  * calculated length and the limitation of the buffer.
 336  */
 337 static int
 338 ip6optlen(u_int8_t *opt, u_int8_t *lim)
 339 {
 340         int optlen;
 341
 342         if (*opt == IP6OPT_PAD1)
 343                 optlen = 1;
 344         else {
 345                 /* is there enough space to store type and len? */
 346                 if (opt + 2 > lim)
 347                         return(0);
 348                 optlen = *(opt + 1) + 2;
 349         }
 350         if (opt + optlen <= lim)
 351                 return(optlen);
 352
 353         return(0);
 354 }
 355
 356 static void
 357 inet6_insert_padopt(u_char *p, int len)
 358 {
 359         switch(len) {
 360         case 0:
 361                 return;
 362         case 1:
 363                 p[0] = IP6OPT_PAD1;
 364                 return;
 365         default:
 366                 p[0] = IP6OPT_PADN;
 367                 p[1] = len - 2;
 368                 memset(&p[2], 0, len - 2);
 369                 return;
 370         }
 371 }
 372
 373 /*
 374  * The following functions are defined in RFC3542, which is a successor
 375  * of RFC2292.
 376  */
 377
 378 int
 379 inet6_opt_init(void *extbuf, socklen_t extlen)
 380 {
 381         struct ip6_ext *ext = (struct ip6_ext *)extbuf;
 382
 383         if (ext) {
 384                 if (extlen <= 0 || (extlen % 8))
 385                         return(-1);
 386                 ext->ip6e_len = (extlen >> 3) - 1;
 387         }
 388
 389         return(2);              /* sizeof the next and the length fields */
 390 }
 391
 392 int
 393 inet6_opt_append(void *extbuf, socklen_t extlen, int offset, u_int8_t type,
 394                  socklen_t len, u_int8_t align, void **databufp)
 395 {
 396         int currentlen = offset, padlen = 0;
 397
 398         /*
 399          * The option type must have a value from 2 to 255, inclusive.
 400          * (0 and 1 are reserved for the Pad1 and PadN options, respectively.)
 401          */
 402         if (type < 2)
 403                 return(-1);
 404
 405         /*
 406          * The option data length must have a value between 0 and 255,
 407          * inclusive, and is the length of the option data that follows.
 408          */
 409         if (len > 255)
 410                 return(-1);
 411
 412         /*
 413          * The align parameter must have a value of 1, 2, 4, or 8.
 414          * The align value can not exceed the value of len.
 415          */
 416         if (align != 1 && align != 2 && align != 4 && align != 8)
 417                 return(-1);
 418         if (align > len)
 419                 return(-1);
 420
 421         /* Calculate the padding length. */
 422         currentlen += 2 + len;  /* 2 means "type + len" */
 423         if (currentlen % align)
 424                 padlen = align - (currentlen % align);
 425
 426         /* The option must fit in the extension header buffer. */
 427         currentlen += padlen;
 428         if (extlen &&           /* XXX: right? */
 429             currentlen > extlen)
 430                 return(-1);
 431
 432         if (extbuf) {
 433                 u_int8_t *optp = (u_int8_t *)extbuf + offset;
 434
 435                 if (padlen == 1) {
 436                         /* insert a Pad1 option */
 437                         *optp = IP6OPT_PAD1;
 438                         optp++;
 439                 } else if (padlen > 0) {
 440                         /* insert a PadN option for alignment */
 441                         *optp++ = IP6OPT_PADN;
 442                         *optp++ = padlen - 2;
 443                         memset(optp, 0, padlen - 2);
 444                         optp += (padlen - 2);
 445                 }
 446
 447                 *optp++ = type;
 448                 *optp++ = len;
 449
 450                 *databufp = optp;
 451         }
 452
 453         return(currentlen);
 454 }
 455
 456 int
 457 inet6_opt_finish(void *extbuf, socklen_t extlen, int offset)
 458 {
 459         int updatelen = offset > 0 ? (1 + ((offset - 1) | 7)) : 0;
 460
 461         if (extbuf) {
 462                 u_int8_t *padp;
 463                 int padlen = updatelen - offset;
 464
 465                 if (updatelen > extlen)
 466                         return(-1);
 467
 468                 padp = (u_int8_t *)extbuf + offset;
 469                 if (padlen == 1)
 470                         *padp = IP6OPT_PAD1;
 471                 else if (padlen > 0) {
 472                         *padp++ = IP6OPT_PADN;
 473                         *padp++ = (padlen - 2);
 474                         memset(padp, 0, padlen - 2);
 475                 }
 476         }
 477
 478         return(updatelen);
 479 }
 480
 481 int
 482 inet6_opt_set_val(void *databuf, int offset, void *val, socklen_t vallen)
 483 {
 484
 485         memcpy((u_int8_t *)databuf + offset, val, vallen);
 486         return(offset + vallen);
 487 }
 488
 489 int
 490 inet6_opt_next(void *extbuf, socklen_t extlen, int offset, u_int8_t *typep,
 491                socklen_t *lenp, void **databufp)
 492 {
 493         u_int8_t *optp, *lim;
 494         int optlen;
 495
 496         /* Validate extlen. XXX: is the variable really necessary?? */
 497         if (extlen == 0 || (extlen % 8))
 498                 return(-1);
 499         lim = (u_int8_t *)extbuf + extlen;
 500
 501         /*
 502          * If this is the first time this function called for this options
 503          * header, simply return the 1st option.
 504          * Otherwise, search the option list for the next option.
 505          */
 506         if (offset == 0)
 507                 optp = (u_int8_t *)((struct ip6_hbh *)extbuf + 1);
 508         else
 509                 optp = (u_int8_t *)extbuf + offset;
 510
 511         /* Find the next option skipping any padding options. */
 512         while (optp < lim) {
 513                 switch (*optp) {
 514                 case IP6OPT_PAD1:
 515                         optp++;
 516                         break;
 517                 case IP6OPT_PADN:
 518                         if ((optlen = ip6optlen(optp, lim)) == 0)
 519                                 goto optend;
 520                         optp += optlen;
 521                         break;
 522                 default:        /* found */
 523                         if ((optlen = ip6optlen(optp, lim)) == 0)
 524                                 goto optend;
 525                         *typep = *optp;
 526                         *lenp = optlen - 2;
 527                         *databufp = optp + 2;
 528                         return(optp + optlen - (u_int8_t *)extbuf);
 529                 }
 530         }
 531
 532   optend:
 533         *databufp = NULL; /* for safety */
 534         return(-1);
 535 }
 536
 537 int
 538 inet6_opt_find(void *extbuf, socklen_t extlen, int offset, u_int8_t type,
 539                socklen_t *lenp, void **databufp)
 540 {
 541         u_int8_t *optp, *lim;
 542         int optlen;
 543
 544         /* Validate extlen. XXX: is the variable really necessary?? */
 545         if (extlen == 0 || (extlen % 8))
 546                 return(-1);
 547         lim = (u_int8_t *)extbuf + extlen;
 548
 549         /*
 550          * If this is the first time this function called for this options
 551          * header, simply return the 1st option.
 552          * Otherwise, search the option list for the next option.
 553          */
 554         if (offset == 0)
 555                 optp = (u_int8_t *)((struct ip6_hbh *)extbuf + 1);
 556         else
 557                 optp = (u_int8_t *)extbuf + offset;
 558
 559         /* Find the specified option */
 560         while (optp < lim) {
 561                 if ((optlen = ip6optlen(optp, lim)) == 0)
 562                         goto optend;
 563
 564                 if (*optp == type) { /* found */
 565                         *lenp = optlen - 2;
 566                         *databufp = optp + 2;
 567                         return(optp + optlen - (u_int8_t *)extbuf);
 568                 }
 569
 570                 optp += optlen;
 571         }
 572
 573   optend:
 574         *databufp = NULL; /* for safety */
 575         return(-1);
 576 }
 577
 578 int
 579 inet6_opt_get_val(void *databuf, int offset, void *val, socklen_t vallen)
 580 {
 581
 582         /* we can't assume alignment here */
 583         memcpy(val, (u_int8_t *)databuf + offset, vallen);
 584
 585         return(offset + vallen);
 586 }