[BACK]Return to ip6_output.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / netinet6

Annotation of src/sys/netinet6/ip6_output.c, Revision 1.15

1.15    ! darrenr     1: /*     $NetBSD: ip6_output.c,v 1.14 2000/02/06 12:49:46 itojun Exp $   */
1.3       thorpej     2:
1.2       itojun      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:
                     32: /*
                     33:  * Copyright (c) 1982, 1986, 1988, 1990, 1993
                     34:  *     The Regents of the University of California.  All rights reserved.
                     35:  *
                     36:  * Redistribution and use in source and binary forms, with or without
                     37:  * modification, are permitted provided that the following conditions
                     38:  * are met:
                     39:  * 1. Redistributions of source code must retain the above copyright
                     40:  *    notice, this list of conditions and the following disclaimer.
                     41:  * 2. Redistributions in binary form must reproduce the above copyright
                     42:  *    notice, this list of conditions and the following disclaimer in the
                     43:  *    documentation and/or other materials provided with the distribution.
                     44:  * 3. All advertising materials mentioning features or use of this software
                     45:  *    must display the following acknowledgement:
                     46:  *     This product includes software developed by the University of
                     47:  *     California, Berkeley and its contributors.
                     48:  * 4. Neither the name of the University nor the names of its contributors
                     49:  *    may be used to endorse or promote products derived from this software
                     50:  *    without specific prior written permission.
                     51:  *
                     52:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
                     53:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     54:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     55:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     56:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     57:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     58:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     59:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     60:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     61:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     62:  * SUCH DAMAGE.
                     63:  *
                     64:  *     @(#)ip_output.c 8.3 (Berkeley) 1/21/94
                     65:  */
                     66:
                     67: #include "opt_inet.h"
1.4       thorpej    68: #include "opt_ipsec.h"
1.15    ! darrenr    69: #include "opt_pfil_hooks.h"
1.2       itojun     70:
                     71: #include <sys/param.h>
                     72: #include <sys/malloc.h>
                     73: #include <sys/mbuf.h>
                     74: #include <sys/errno.h>
                     75: #include <sys/protosw.h>
                     76: #include <sys/socket.h>
                     77: #include <sys/socketvar.h>
                     78: #include <sys/systm.h>
                     79: #include <sys/proc.h>
                     80:
                     81: #include <net/if.h>
                     82: #include <net/route.h>
1.15    ! darrenr    83: #ifdef PFIL_HOOKS
        !            84: #include <net/pfil.h>
        !            85: #endif
1.2       itojun     86:
                     87: #include <netinet/in.h>
                     88: #include <netinet/in_var.h>
1.14      itojun     89: #include <netinet/ip6.h>
                     90: #include <netinet/icmp6.h>
1.10      itojun     91: #include <netinet6/ip6_var.h>
1.2       itojun     92: #include <netinet6/in6_pcb.h>
                     93: #include <netinet6/nd6.h>
                     94:
                     95: #ifdef IPSEC
                     96: #include <netinet6/ipsec.h>
                     97: #include <netkey/key.h>
                     98: #include <netkey/key_debug.h>
                     99: #endif /* IPSEC */
                    100:
                    101: #include "loop.h"
1.9       itojun    102:
                    103: #include <net/net_osdep.h>
                    104:
                    105: #ifdef IPV6FIREWALL
                    106: #include <netinet6/ip6_fw.h>
                    107: #endif
                    108:
1.2       itojun    109: struct ip6_exthdrs {
                    110:        struct mbuf *ip6e_ip6;
                    111:        struct mbuf *ip6e_hbh;
                    112:        struct mbuf *ip6e_dest1;
                    113:        struct mbuf *ip6e_rthdr;
                    114:        struct mbuf *ip6e_dest2;
                    115: };
                    116:
                    117: static int ip6_pcbopts __P((struct ip6_pktopts **, struct mbuf *,
                    118:                            struct socket *));
                    119: static int ip6_setmoptions __P((int, struct ip6_moptions **, struct mbuf *));
                    120: static int ip6_getmoptions __P((int, struct ip6_moptions *, struct mbuf **));
                    121: static int ip6_copyexthdr __P((struct mbuf **, caddr_t, int));
                    122: static int ip6_insertfraghdr __P((struct mbuf *, struct mbuf *, int,
                    123:                                  struct ip6_frag **));
                    124: static int ip6_insert_jumboopt __P((struct ip6_exthdrs *, u_int32_t));
                    125: static int ip6_splithdr __P((struct mbuf *, struct ip6_exthdrs *));
                    126:
                    127: extern struct ifnet **ifindex2ifnet;
                    128: extern struct ifnet loif[NLOOP];
                    129:
                    130: /*
                    131:  * IP6 output. The packet in mbuf chain m contains a skeletal IP6
                    132:  * header (with pri, len, nxt, hlim, src, dst).
                    133:  * This function may modify ver and hlim only.
                    134:  * The mbuf chain containing the packet will be freed.
                    135:  * The mbuf opt, if present, will not be freed.
                    136:  */
                    137: int
1.9       itojun    138: ip6_output(m0, opt, ro, flags, im6o, ifpp)
1.2       itojun    139:        struct mbuf *m0;
                    140:        struct ip6_pktopts *opt;
                    141:        struct route_in6 *ro;
                    142:        int flags;
                    143:        struct ip6_moptions *im6o;
1.9       itojun    144:        struct ifnet **ifpp;            /* XXX: just for statistics */
1.2       itojun    145: {
                    146:        struct ip6_hdr *ip6, *mhip6;
                    147:        struct ifnet *ifp;
                    148:        struct mbuf *m = m0;
                    149:        int hlen, tlen, len, off;
                    150:        struct route_in6 ip6route;
                    151:        struct sockaddr_in6 *dst;
                    152:        int error = 0;
                    153:        struct in6_ifaddr *ia;
                    154:        u_long mtu;
                    155:        u_int32_t optlen = 0, plen = 0, unfragpartlen = 0;
                    156:        struct ip6_exthdrs exthdrs;
                    157:        struct in6_addr finaldst;
                    158:        struct route_in6 *ro_pmtu = NULL;
                    159:        int hdrsplit = 0;
                    160:        int needipsec = 0;
1.15    ! darrenr   161: #ifdef PFIL_HOOKS
        !           162:        struct packet_filter_hook *pfh;
        !           163:        struct mbuf *m1;
        !           164:        int rv;
        !           165: #endif /* PFIL_HOOKS */
1.2       itojun    166: #ifdef IPSEC
                    167:        int needipsectun = 0;
                    168:        struct socket *so;
                    169:        struct secpolicy *sp = NULL;
                    170:
                    171:        /* for AH processing. stupid to have "socket" variable in IP layer... */
                    172:        so = (struct socket *)m->m_pkthdr.rcvif;
                    173:        m->m_pkthdr.rcvif = NULL;
                    174:        ip6 = mtod(m, struct ip6_hdr *);
                    175: #endif /* IPSEC */
                    176:
                    177: #define MAKE_EXTHDR(hp,mp)                                             \
                    178:     {                                                                  \
                    179:        if (hp) {                                                       \
                    180:                struct ip6_ext *eh = (struct ip6_ext *)(hp);            \
                    181:                error = ip6_copyexthdr((mp), (caddr_t)(hp),             \
                    182:                                       ((eh)->ip6e_len + 1) << 3);      \
                    183:                if (error)                                              \
                    184:                        goto freehdrs;                                  \
                    185:        }                                                               \
                    186:     }
                    187:
                    188:        bzero(&exthdrs, sizeof(exthdrs));
                    189:        if (opt) {
                    190:                /* Hop-by-Hop options header */
                    191:                MAKE_EXTHDR(opt->ip6po_hbh, &exthdrs.ip6e_hbh);
                    192:                /* Destination options header(1st part) */
                    193:                MAKE_EXTHDR(opt->ip6po_dest1, &exthdrs.ip6e_dest1);
                    194:                /* Routing header */
                    195:                MAKE_EXTHDR(opt->ip6po_rthdr, &exthdrs.ip6e_rthdr);
                    196:                /* Destination options header(2nd part) */
                    197:                MAKE_EXTHDR(opt->ip6po_dest2, &exthdrs.ip6e_dest2);
                    198:        }
                    199:
                    200: #ifdef IPSEC
                    201:        /* get a security policy for this packet */
                    202:        if (so == NULL)
1.13      itojun    203:                sp = ipsec6_getpolicybyaddr(m, IPSEC_DIR_OUTBOUND, 0, &error);
1.2       itojun    204:        else
1.13      itojun    205:                sp = ipsec6_getpolicybysock(m, IPSEC_DIR_OUTBOUND, so, &error);
1.2       itojun    206:
                    207:        if (sp == NULL) {
                    208:                ipsec6stat.out_inval++;
                    209:                goto bad;
                    210:        }
                    211:
                    212:        error = 0;
                    213:
                    214:        /* check policy */
                    215:        switch (sp->policy) {
                    216:        case IPSEC_POLICY_DISCARD:
                    217:                /*
                    218:                 * This packet is just discarded.
                    219:                 */
                    220:                ipsec6stat.out_polvio++;
                    221:                goto bad;
                    222:
                    223:        case IPSEC_POLICY_BYPASS:
                    224:        case IPSEC_POLICY_NONE:
                    225:                /* no need to do IPsec. */
                    226:                needipsec = 0;
                    227:                break;
                    228:
                    229:        case IPSEC_POLICY_IPSEC:
                    230:                if (sp->req == NULL) {
                    231:                        /* XXX should be panic ? */
                    232:                        printf("ip6_output: No IPsec request specified.\n");
                    233:                        error = EINVAL;
                    234:                        goto bad;
                    235:                }
                    236:                needipsec = 1;
                    237:                break;
                    238:
                    239:        case IPSEC_POLICY_ENTRUST:
                    240:        default:
                    241:                printf("ip6_output: Invalid policy found. %d\n", sp->policy);
                    242:        }
                    243: #endif /* IPSEC */
                    244:
                    245:        /*
                    246:         * Calculate the total length of the extension header chain.
                    247:         * Keep the length of the unfragmentable part for fragmentation.
                    248:         */
1.9       itojun    249:        optlen = 0;
1.2       itojun    250:        if (exthdrs.ip6e_hbh) optlen += exthdrs.ip6e_hbh->m_len;
                    251:        if (exthdrs.ip6e_dest1) optlen += exthdrs.ip6e_dest1->m_len;
                    252:        if (exthdrs.ip6e_rthdr) optlen += exthdrs.ip6e_rthdr->m_len;
1.9       itojun    253:        unfragpartlen = optlen + sizeof(struct ip6_hdr);
1.2       itojun    254:        /* NOTE: we don't add AH/ESP length here. do that later. */
                    255:        if (exthdrs.ip6e_dest2) optlen += exthdrs.ip6e_dest2->m_len;
                    256:
                    257:        /*
                    258:         * If we need IPsec, or there is at least one extension header,
                    259:         * separate IP6 header from the payload.
                    260:         */
                    261:        if ((needipsec || optlen) && !hdrsplit) {
                    262:                if ((error = ip6_splithdr(m, &exthdrs)) != 0) {
                    263:                        m = NULL;
                    264:                        goto freehdrs;
                    265:                }
                    266:                m = exthdrs.ip6e_ip6;
                    267:                hdrsplit++;
                    268:        }
                    269:
                    270:        /* adjust pointer */
                    271:        ip6 = mtod(m, struct ip6_hdr *);
                    272:
                    273:        /* adjust mbuf packet header length */
                    274:        m->m_pkthdr.len += optlen;
                    275:        plen = m->m_pkthdr.len - sizeof(*ip6);
                    276:
                    277:        /* If this is a jumbo payload, insert a jumbo payload option. */
                    278:        if (plen > IPV6_MAXPACKET) {
                    279:                if (!hdrsplit) {
                    280:                        if ((error = ip6_splithdr(m, &exthdrs)) != 0) {
                    281:                                m = NULL;
                    282:                                goto freehdrs;
                    283:                        }
                    284:                        m = exthdrs.ip6e_ip6;
                    285:                        hdrsplit++;
                    286:                }
                    287:                /* adjust pointer */
                    288:                ip6 = mtod(m, struct ip6_hdr *);
                    289:                if ((error = ip6_insert_jumboopt(&exthdrs, plen)) != 0)
                    290:                        goto freehdrs;
                    291:                ip6->ip6_plen = 0;
                    292:        } else
                    293:                ip6->ip6_plen = htons(plen);
                    294:
                    295:        /*
                    296:         * Concatenate headers and fill in next header fields.
                    297:         * Here we have, on "m"
1.9       itojun    298:         *      IPv6 payload
1.2       itojun    299:         * and we insert headers accordingly.  Finally, we should be getting:
                    300:         *      IPv6 hbh dest1 rthdr ah* [esp* dest2 payload]
1.9       itojun    301:         *
                    302:         * during the header composing process, "m" points to IPv6 header.
                    303:         * "mprev" points to an extension header prior to esp.
1.2       itojun    304:         */
                    305:        {
                    306:                u_char *nexthdrp = &ip6->ip6_nxt;
                    307:                struct mbuf *mprev = m;
                    308:
                    309:                /*
                    310:                 * we treat dest2 specially.  this makes IPsec processing
                    311:                 * much easier.
1.9       itojun    312:                 *
                    313:                 * result: IPv6 dest2 payload
                    314:                 * m and mprev will point to IPv6 header.
1.2       itojun    315:                 */
                    316:                if (exthdrs.ip6e_dest2) {
                    317:                        if (!hdrsplit)
                    318:                                panic("assumption failed: hdr not split");
1.9       itojun    319:                        exthdrs.ip6e_dest2->m_next = m->m_next;
                    320:                        m->m_next = exthdrs.ip6e_dest2;
1.2       itojun    321:                        *mtod(exthdrs.ip6e_dest2, u_char *) = ip6->ip6_nxt;
                    322:                        ip6->ip6_nxt = IPPROTO_DSTOPTS;
                    323:                }
                    324:
                    325: #define MAKE_CHAIN(m,mp,p,i)\
                    326:     {\
                    327:        if (m) {\
                    328:                if (!hdrsplit) \
                    329:                        panic("assumption failed: hdr not split"); \
                    330:                *mtod((m), u_char *) = *(p);\
                    331:                *(p) = (i);\
                    332:                p = mtod((m), u_char *);\
                    333:                (m)->m_next = (mp)->m_next;\
                    334:                (mp)->m_next = (m);\
                    335:                (mp) = (m);\
                    336:        }\
                    337:     }
1.9       itojun    338:                /*
                    339:                 * result: IPv6 hbh dest1 rthdr dest2 payload
                    340:                 * m will point to IPv6 header.  mprev will point to the
                    341:                 * extension header prior to dest2 (rthdr in the above case).
                    342:                 */
1.2       itojun    343:                MAKE_CHAIN(exthdrs.ip6e_hbh, mprev,
                    344:                           nexthdrp, IPPROTO_HOPOPTS);
                    345:                MAKE_CHAIN(exthdrs.ip6e_dest1, mprev,
                    346:                           nexthdrp, IPPROTO_DSTOPTS);
                    347:                MAKE_CHAIN(exthdrs.ip6e_rthdr, mprev,
                    348:                           nexthdrp, IPPROTO_ROUTING);
                    349:
                    350: #ifdef IPSEC
                    351:                if (!needipsec)
                    352:                        goto skip_ipsec2;
                    353:
                    354:                /*
                    355:                 * pointers after IPsec headers are not valid any more.
                    356:                 * other pointers need a great care too.
                    357:                 * (IPsec routines should not mangle mbufs prior to AH/ESP)
                    358:                 */
                    359:                exthdrs.ip6e_dest2 = NULL;
                    360:
                    361:            {
                    362:                struct ip6_rthdr *rh = NULL;
                    363:                int segleft_org = 0;
                    364:                struct ipsec_output_state state;
                    365:
                    366:                if (exthdrs.ip6e_rthdr) {
                    367:                        rh = mtod(exthdrs.ip6e_rthdr, struct ip6_rthdr *);
                    368:                        segleft_org = rh->ip6r_segleft;
                    369:                        rh->ip6r_segleft = 0;
                    370:                }
                    371:
                    372:                bzero(&state, sizeof(state));
                    373:                state.m = m;
                    374:                error = ipsec6_output_trans(&state, nexthdrp, mprev, sp, flags,
                    375:                        &needipsectun);
                    376:                m = state.m;
                    377:                if (error) {
                    378:                        /* mbuf is already reclaimed in ipsec6_output_trans. */
                    379:                        m = NULL;
                    380:                        switch (error) {
                    381:                        case EHOSTUNREACH:
                    382:                        case ENETUNREACH:
                    383:                        case EMSGSIZE:
                    384:                        case ENOBUFS:
                    385:                        case ENOMEM:
                    386:                                break;
                    387:                        default:
                    388:                                printf("ip6_output (ipsec): error code %d\n", error);
                    389:                                /*fall through*/
                    390:                        case ENOENT:
                    391:                                /* don't show these error codes to the user */
                    392:                                error = 0;
                    393:                                break;
                    394:                        }
                    395:                        goto bad;
                    396:                }
                    397:                if (exthdrs.ip6e_rthdr) {
                    398:                        /* ah6_output doesn't modify mbuf chain */
                    399:                        rh->ip6r_segleft = segleft_org;
                    400:                }
                    401:            }
                    402: skip_ipsec2:;
                    403: #endif
                    404:        }
                    405:
                    406:        /*
                    407:         * If there is a routing header, replace destination address field
                    408:         * with the first hop of the routing header.
                    409:         */
                    410:        if (exthdrs.ip6e_rthdr) {
                    411:                struct ip6_rthdr *rh =
                    412:                        (struct ip6_rthdr *)(mtod(exthdrs.ip6e_rthdr,
                    413:                                                  struct ip6_rthdr *));
                    414:                struct ip6_rthdr0 *rh0;
                    415:
                    416:                finaldst = ip6->ip6_dst;
                    417:                switch(rh->ip6r_type) {
                    418:                case IPV6_RTHDR_TYPE_0:
                    419:                         rh0 = (struct ip6_rthdr0 *)rh;
                    420:                         ip6->ip6_dst = rh0->ip6r0_addr[0];
                    421:                         bcopy((caddr_t)&rh0->ip6r0_addr[1],
                    422:                                 (caddr_t)&rh0->ip6r0_addr[0],
                    423:                                 sizeof(struct in6_addr)*(rh0->ip6r0_segleft - 1)
                    424:                                 );
                    425:                         rh0->ip6r0_addr[rh0->ip6r0_segleft - 1] = finaldst;
                    426:                         break;
                    427:                default:        /* is it possible? */
                    428:                         error = EINVAL;
                    429:                         goto bad;
                    430:                }
                    431:        }
                    432:
                    433:        /* Source address validation */
                    434:        if (IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src) &&
                    435:            (flags & IPV6_DADOUTPUT) == 0) {
                    436:                error = EOPNOTSUPP;
                    437:                ip6stat.ip6s_badscope++;
                    438:                goto bad;
                    439:        }
                    440:        if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_src)) {
                    441:                error = EOPNOTSUPP;
                    442:                ip6stat.ip6s_badscope++;
                    443:                goto bad;
                    444:        }
                    445:
                    446:        ip6stat.ip6s_localout++;
                    447:
                    448:        /*
                    449:         * Route packet.
                    450:         */
                    451:        if (ro == 0) {
                    452:                ro = &ip6route;
                    453:                bzero((caddr_t)ro, sizeof(*ro));
                    454:        }
                    455:        ro_pmtu = ro;
                    456:        if (opt && opt->ip6po_rthdr)
                    457:                ro = &opt->ip6po_route;
                    458:        dst = (struct sockaddr_in6 *)&ro->ro_dst;
                    459:        /*
                    460:         * If there is a cached route,
                    461:         * check that it is to the same destination
                    462:         * and is still up. If not, free it and try again.
                    463:         */
                    464:        if (ro->ro_rt && ((ro->ro_rt->rt_flags & RTF_UP) == 0 ||
                    465:                         !IN6_ARE_ADDR_EQUAL(&dst->sin6_addr, &ip6->ip6_dst))) {
                    466:                RTFREE(ro->ro_rt);
                    467:                ro->ro_rt = (struct rtentry *)0;
                    468:        }
                    469:        if (ro->ro_rt == 0) {
                    470:                bzero(dst, sizeof(*dst));
                    471:                dst->sin6_family = AF_INET6;
                    472:                dst->sin6_len = sizeof(struct sockaddr_in6);
                    473:                dst->sin6_addr = ip6->ip6_dst;
                    474:        }
                    475: #ifdef IPSEC
                    476:        if (needipsec && needipsectun) {
                    477:                struct ipsec_output_state state;
                    478:
                    479:                /*
                    480:                 * All the extension headers will become inaccessible
                    481:                 * (since they can be encrypted).
                    482:                 * Don't panic, we need no more updates to extension headers
                    483:                 * on inner IPv6 packet (since they are now encapsulated).
                    484:                 *
                    485:                 * IPv6 [ESP|AH] IPv6 [extension headers] payload
                    486:                 */
                    487:                bzero(&exthdrs, sizeof(exthdrs));
                    488:                exthdrs.ip6e_ip6 = m;
                    489:
                    490:                bzero(&state, sizeof(state));
                    491:                state.m = m;
                    492:                state.ro = (struct route *)ro;
                    493:                state.dst = (struct sockaddr *)dst;
                    494:
                    495:                error = ipsec6_output_tunnel(&state, sp, flags);
                    496:
                    497:                m = state.m;
                    498:                ro = (struct route_in6 *)state.ro;
                    499:                dst = (struct sockaddr_in6 *)state.dst;
                    500:                if (error) {
                    501:                        /* mbuf is already reclaimed in ipsec6_output_tunnel. */
                    502:                        m0 = m = NULL;
                    503:                        m = NULL;
                    504:                        switch (error) {
                    505:                        case EHOSTUNREACH:
                    506:                        case ENETUNREACH:
                    507:                        case EMSGSIZE:
                    508:                        case ENOBUFS:
                    509:                        case ENOMEM:
                    510:                                break;
                    511:                        default:
                    512:                                printf("ip6_output (ipsec): error code %d\n", error);
                    513:                                /*fall through*/
                    514:                        case ENOENT:
                    515:                                /* don't show these error codes to the user */
                    516:                                error = 0;
                    517:                                break;
                    518:                        }
                    519:                        goto bad;
                    520:                }
                    521:
                    522:                exthdrs.ip6e_ip6 = m;
                    523:        }
                    524: #endif /*IPESC*/
                    525:
                    526:        if (!IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst)) {
                    527:                /* Unicast */
                    528:
                    529: #define ifatoia6(ifa)  ((struct in6_ifaddr *)(ifa))
                    530: #define sin6tosa(sin6) ((struct sockaddr *)(sin6))
                    531:                /* xxx
                    532:                 * interface selection comes here
                    533:                 * if an interface is specified from an upper layer,
                    534:                 * ifp must point it.
                    535:                 */
                    536:                if (ro->ro_rt == 0) {
1.6       itojun    537:                        /*
1.9       itojun    538:                         * NetBSD/OpenBSD always clones routes, if parent is
1.6       itojun    539:                         * PRF_CLONING.
                    540:                         */
                    541:                        rtalloc((struct route *)ro);
1.2       itojun    542:                }
                    543:                if (ro->ro_rt == 0) {
                    544:                        ip6stat.ip6s_noroute++;
                    545:                        error = EHOSTUNREACH;
1.9       itojun    546:                        /* XXX in6_ifstat_inc(ifp, ifs6_out_discard); */
1.2       itojun    547:                        goto bad;
                    548:                }
                    549:                ia = ifatoia6(ro->ro_rt->rt_ifa);
                    550:                ifp = ro->ro_rt->rt_ifp;
                    551:                ro->ro_rt->rt_use++;
                    552:                if (ro->ro_rt->rt_flags & RTF_GATEWAY)
                    553:                        dst = (struct sockaddr_in6 *)ro->ro_rt->rt_gateway;
                    554:                m->m_flags &= ~(M_BCAST | M_MCAST);     /* just in case */
                    555:
1.9       itojun    556:                in6_ifstat_inc(ifp, ifs6_out_request);
                    557:
1.2       itojun    558:                /*
                    559:                 * Check if there is the outgoing interface conflicts with
                    560:                 * the interface specified by ifi6_ifindex(if specified).
                    561:                 * Note that loopback interface is always okay.
                    562:                 * (this happens when we are sending packet toward my
                    563:                 * interface)
                    564:                 */
                    565:                if (opt && opt->ip6po_pktinfo
                    566:                 && opt->ip6po_pktinfo->ipi6_ifindex) {
                    567:                        if (!(ifp->if_flags & IFF_LOOPBACK)
                    568:                         && ifp->if_index != opt->ip6po_pktinfo->ipi6_ifindex) {
                    569:                                ip6stat.ip6s_noroute++;
1.9       itojun    570:                                in6_ifstat_inc(ifp, ifs6_out_discard);
1.2       itojun    571:                                error = EHOSTUNREACH;
                    572:                                goto bad;
                    573:                        }
                    574:                }
                    575:
                    576:                if (opt && opt->ip6po_hlim != -1)
                    577:                        ip6->ip6_hlim = opt->ip6po_hlim & 0xff;
                    578:        } else {
                    579:                /* Multicast */
                    580:                struct  in6_multi *in6m;
                    581:
                    582:                m->m_flags = (m->m_flags & ~M_BCAST) | M_MCAST;
                    583:
                    584:                /*
                    585:                 * See if the caller provided any multicast options
                    586:                 */
                    587:                ifp = NULL;
                    588:                if (im6o != NULL) {
                    589:                        ip6->ip6_hlim = im6o->im6o_multicast_hlim;
                    590:                        if (im6o->im6o_multicast_ifp != NULL)
                    591:                                ifp = im6o->im6o_multicast_ifp;
                    592:                } else
                    593:                        ip6->ip6_hlim = ip6_defmcasthlim;
                    594:
                    595:                /*
                    596:                 * See if the caller provided the outgoing interface
                    597:                 * as an ancillary data.
                    598:                 * Boundary check for ifindex is assumed to be already done.
                    599:                 */
                    600:                if (opt && opt->ip6po_pktinfo && opt->ip6po_pktinfo->ipi6_ifindex)
                    601:                        ifp = ifindex2ifnet[opt->ip6po_pktinfo->ipi6_ifindex];
                    602:
                    603:                /*
                    604:                 * If the destination is a node-local scope multicast,
                    605:                 * the packet should be loop-backed only.
                    606:                 */
                    607:                if (IN6_IS_ADDR_MC_NODELOCAL(&ip6->ip6_dst)) {
                    608:                        /*
                    609:                         * If the outgoing interface is already specified,
                    610:                         * it should be a loopback interface.
                    611:                         */
                    612:                        if (ifp && (ifp->if_flags & IFF_LOOPBACK) == 0) {
                    613:                                ip6stat.ip6s_badscope++;
                    614:                                error = ENETUNREACH; /* XXX: better error? */
1.9       itojun    615:                                /* XXX correct ifp? */
                    616:                                in6_ifstat_inc(ifp, ifs6_out_discard);
1.2       itojun    617:                                goto bad;
                    618:                        }
                    619:                        else {
                    620:                                ifp = &loif[0];
                    621:                        }
                    622:                }
                    623:
                    624:                if (opt && opt->ip6po_hlim != -1)
                    625:                        ip6->ip6_hlim = opt->ip6po_hlim & 0xff;
                    626:
                    627:                /*
                    628:                 * If caller did not provide an interface lookup a
                    629:                 * default in the routing table.  This is either a
                    630:                 * default for the speicfied group (i.e. a host
                    631:                 * route), or a multicast default (a route for the
                    632:                 * ``net'' ff00::/8).
                    633:                 */
                    634:                if (ifp == NULL) {
                    635:                        if (ro->ro_rt == 0) {
1.9       itojun    636:                                ro->ro_rt = rtalloc1((struct sockaddr *)
                    637:                                                &ro->ro_dst, 0
                    638:                                                );
1.2       itojun    639:                        }
                    640:                        if (ro->ro_rt == 0) {
                    641:                                ip6stat.ip6s_noroute++;
                    642:                                error = EHOSTUNREACH;
1.9       itojun    643:                                /* XXX in6_ifstat_inc(ifp, ifs6_out_discard) */
1.2       itojun    644:                                goto bad;
                    645:                        }
                    646:                        ia = ifatoia6(ro->ro_rt->rt_ifa);
                    647:                        ifp = ro->ro_rt->rt_ifp;
                    648:                        ro->ro_rt->rt_use++;
                    649:                }
1.9       itojun    650:
                    651:                if ((flags & IPV6_FORWARDING) == 0)
                    652:                        in6_ifstat_inc(ifp, ifs6_out_request);
                    653:                in6_ifstat_inc(ifp, ifs6_out_mcast);
                    654:
1.2       itojun    655:                /*
                    656:                 * Confirm that the outgoing interface supports multicast.
                    657:                 */
                    658:                if ((ifp->if_flags & IFF_MULTICAST) == 0) {
                    659:                        ip6stat.ip6s_noroute++;
1.9       itojun    660:                        in6_ifstat_inc(ifp, ifs6_out_discard);
1.2       itojun    661:                        error = ENETUNREACH;
                    662:                        goto bad;
                    663:                }
                    664:                IN6_LOOKUP_MULTI(ip6->ip6_dst, ifp, in6m);
                    665:                if (in6m != NULL &&
                    666:                   (im6o == NULL || im6o->im6o_multicast_loop)) {
                    667:                        /*
                    668:                         * If we belong to the destination multicast group
                    669:                         * on the outgoing interface, and the caller did not
                    670:                         * forbid loopback, loop back a copy.
                    671:                         */
                    672:                        ip6_mloopback(ifp, m, dst);
                    673:                } else {
                    674:                        /*
                    675:                         * If we are acting as a multicast router, perform
                    676:                         * multicast forwarding as if the packet had just
                    677:                         * arrived on the interface to which we are about
                    678:                         * to send.  The multicast forwarding function
                    679:                         * recursively calls this function, using the
                    680:                         * IPV6_FORWARDING flag to prevent infinite recursion.
                    681:                         *
                    682:                         * Multicasts that are looped back by ip6_mloopback(),
                    683:                         * above, will be forwarded by the ip6_input() routine,
                    684:                         * if necessary.
                    685:                         */
                    686:                        if (ip6_mrouter && (flags & IPV6_FORWARDING) == 0) {
                    687:                                if (ip6_mforward(ip6, ifp, m) != NULL) {
                    688:                                        m_freem(m);
                    689:                                        goto done;
                    690:                                }
                    691:                        }
                    692:                }
                    693:                /*
                    694:                 * Multicasts with a hoplimit of zero may be looped back,
                    695:                 * above, but must not be transmitted on a network.
                    696:                 * Also, multicasts addressed to the loopback interface
                    697:                 * are not sent -- the above call to ip6_mloopback() will
                    698:                 * loop back a copy if this host actually belongs to the
                    699:                 * destination group on the loopback interface.
                    700:                 */
                    701:                if (ip6->ip6_hlim == 0 || (ifp->if_flags & IFF_LOOPBACK)) {
                    702:                        m_freem(m);
                    703:                        goto done;
                    704:                }
                    705:        }
                    706:
                    707:        /*
1.9       itojun    708:         * Fill the outgoing inteface to tell the upper layer
                    709:         * to increment per-interface statistics.
                    710:         */
                    711:        if (ifpp)
                    712:                *ifpp = ifp;
                    713:
                    714:        /*
1.2       itojun    715:         * Determine path MTU.
                    716:         */
                    717:        if (ro_pmtu != ro) {
                    718:                /* The first hop and the final destination may differ. */
                    719:                struct sockaddr_in6 *sin6_fin =
                    720:                        (struct sockaddr_in6 *)&ro_pmtu->ro_dst;
                    721:                if (ro_pmtu->ro_rt && ((ro->ro_rt->rt_flags & RTF_UP) == 0 ||
                    722:                                       !IN6_ARE_ADDR_EQUAL(&sin6_fin->sin6_addr,
                    723:                                                           &finaldst))) {
                    724:                        RTFREE(ro_pmtu->ro_rt);
                    725:                        ro_pmtu->ro_rt = (struct rtentry *)0;
                    726:                }
                    727:                if (ro_pmtu->ro_rt == 0) {
                    728:                        bzero(sin6_fin, sizeof(*sin6_fin));
                    729:                        sin6_fin->sin6_family = AF_INET6;
                    730:                        sin6_fin->sin6_len = sizeof(struct sockaddr_in6);
                    731:                        sin6_fin->sin6_addr = finaldst;
                    732:
                    733:                        rtalloc((struct route *)ro_pmtu);
                    734:                }
                    735:        }
                    736:        if (ro_pmtu->ro_rt != NULL) {
                    737:                u_int32_t ifmtu = nd_ifinfo[ifp->if_index].linkmtu;
                    738:
                    739:                mtu = ro_pmtu->ro_rt->rt_rmx.rmx_mtu;
                    740:                if (mtu > ifmtu) {
                    741:                        /*
                    742:                         * The MTU on the route is larger than the MTU on
                    743:                         * the interface!  This shouldn't happen, unless the
                    744:                         * MTU of the interface has been changed after the
                    745:                         * interface was brought up.  Change the MTU in the
                    746:                         * route to match the interface MTU (as long as the
                    747:                         * field isn't locked).
                    748:                         */
                    749:                         mtu = ifmtu;
                    750:                         if ((ro_pmtu->ro_rt->rt_rmx.rmx_locks & RTV_MTU) == 0)
                    751:                                 ro_pmtu->ro_rt->rt_rmx.rmx_mtu = mtu; /* XXX */
                    752:                }
                    753:        } else {
                    754:                mtu = nd_ifinfo[ifp->if_index].linkmtu;
                    755:        }
                    756:
                    757:        /*
                    758:         * Fake link-local scope-class addresses
                    759:         */
                    760:        if ((ifp->if_flags & IFF_LOOPBACK) == 0) {
                    761:                if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_src))
                    762:                        ip6->ip6_src.s6_addr16[1] = 0;
                    763:                if (IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_dst))
                    764:                        ip6->ip6_dst.s6_addr16[1] = 0;
                    765:        }
                    766:
                    767:        /*
                    768:         * If the outgoing packet contains a hop-by-hop options header,
                    769:         * it must be examined and processed even by the source node.
                    770:         * (RFC 2460, section 4.)
                    771:         */
                    772:        if (exthdrs.ip6e_hbh) {
                    773:                struct ip6_hbh *hbh = mtod(exthdrs.ip6e_hbh,
                    774:                                           struct ip6_hbh *);
1.5       itojun    775:                u_int32_t dummy1; /* XXX unused */
1.2       itojun    776:                u_int32_t dummy2; /* XXX unused */
                    777:
                    778:                /*
                    779:                 *  XXX: if we have to send an ICMPv6 error to the sender,
                    780:                 *       we need the M_LOOP flag since icmp6_error() expects
                    781:                 *       the IPv6 and the hop-by-hop options header are
                    782:                 *       continuous unless the flag is set.
                    783:                 */
                    784:                m->m_flags |= M_LOOP;
                    785:                m->m_pkthdr.rcvif = ifp;
                    786:                if (ip6_process_hopopts(m,
                    787:                                        (u_int8_t *)(hbh + 1),
                    788:                                        ((hbh->ip6h_len + 1) << 3) -
                    789:                                        sizeof(struct ip6_hbh),
                    790:                                        &dummy1, &dummy2) < 0) {
                    791:                        /* m was already freed at this point */
                    792:                        error = EINVAL;/* better error? */
                    793:                        goto done;
                    794:                }
                    795:                m->m_flags &= ~M_LOOP; /* XXX */
                    796:                m->m_pkthdr.rcvif = NULL;
                    797:        }
                    798:
1.15    ! darrenr   799: #ifdef PFIL_HOOKS
        !           800:        /*
        !           801:         * Run through list of hooks for output packets.
        !           802:         */
        !           803:        m1 = m;
        !           804:        pfh = pfil_hook_get(PFIL_OUT, &inetsw[ip_protox[IPPROTO_IPV6]]);
        !           805:        for (; pfh; pfh = pfh->pfil_link.tqe_next)
        !           806:                if (pfh->pfil_func) {
        !           807:                        rv = pfh->pfil_func(ip6, sizeof(*ip6), ifp, 1, &m1);
        !           808:                        if (rv) {
        !           809:                                error = EHOSTUNREACH;
        !           810:                                goto done;
        !           811:                        }
        !           812:                        m = m1;
        !           813:                        if (m == NULL)
        !           814:                                goto done;
        !           815:                        ip6 = mtod(m, struct ip6_hdr *);
        !           816:                }
        !           817: #endif /* PFIL_HOOKS */
1.2       itojun    818:        /*
                    819:         * Send the packet to the outgoing interface.
                    820:         * If necessary, do IPv6 fragmentation before sending.
                    821:         */
                    822:        tlen = m->m_pkthdr.len;
                    823:        if (tlen <= mtu
                    824: #ifdef notyet
                    825:            /*
                    826:             * On any link that cannot convey a 1280-octet packet in one piece,
                    827:             * link-specific fragmentation and reassembly must be provided at
                    828:             * a layer below IPv6. [RFC 2460, sec.5]
                    829:             * Thus if the interface has ability of link-level fragmentation,
                    830:             * we can just send the packet even if the packet size is
                    831:             * larger than the link's MTU.
                    832:             * XXX: IFF_FRAGMENTABLE (or such) flag has not been defined yet...
                    833:             */
                    834:
                    835:            || ifp->if_flags & IFF_FRAGMENTABLE
                    836: #endif
                    837:            )
                    838:        {
1.11      itojun    839: #ifdef IFA_STATS
1.9       itojun    840:                if (IFA_STATS) {
                    841:                        struct in6_ifaddr *ia6;
                    842:                        ip6 = mtod(m, struct ip6_hdr *);
                    843:                        ia6 = in6_ifawithifp(ifp, &ip6->ip6_src);
                    844:                        if (ia6) {
                    845:                                ia->ia_ifa.ifa_data.ifad_outbytes +=
                    846:                                        m->m_pkthdr.len;
                    847:                        }
                    848:                }
                    849: #endif
                    850: #ifdef OLDIP6OUTPUT
1.2       itojun    851:                error = (*ifp->if_output)(ifp, m, (struct sockaddr *)dst,
                    852:                                          ro->ro_rt);
1.9       itojun    853: #else
                    854:                error = nd6_output(ifp, m, dst, ro->ro_rt);
1.2       itojun    855: #endif
                    856:                goto done;
                    857:        } else if (mtu < IPV6_MMTU) {
                    858:                /*
                    859:                 * note that path MTU is never less than IPV6_MMTU
                    860:                 * (see icmp6_input).
                    861:                 */
                    862:                error = EMSGSIZE;
1.9       itojun    863:                in6_ifstat_inc(ifp, ifs6_out_fragfail);
1.2       itojun    864:                goto bad;
                    865:        } else if (ip6->ip6_plen == 0) { /* jumbo payload cannot be fragmented */
                    866:                error = EMSGSIZE;
1.9       itojun    867:                in6_ifstat_inc(ifp, ifs6_out_fragfail);
1.2       itojun    868:                goto bad;
                    869:        } else {
                    870:                struct mbuf **mnext, *m_frgpart;
                    871:                struct ip6_frag *ip6f;
1.5       itojun    872:                u_int32_t id = htonl(ip6_id++);
1.2       itojun    873:                u_char nextproto;
                    874:
                    875:                /*
                    876:                 * Too large for the destination or interface;
                    877:                 * fragment if possible.
                    878:                 * Must be able to put at least 8 bytes per fragment.
                    879:                 */
                    880:                hlen = unfragpartlen;
                    881:                if (mtu > IPV6_MAXPACKET)
                    882:                        mtu = IPV6_MAXPACKET;
                    883:                len = (mtu - hlen - sizeof(struct ip6_frag)) & ~7;
                    884:                if (len < 8) {
                    885:                        error = EMSGSIZE;
1.9       itojun    886:                        in6_ifstat_inc(ifp, ifs6_out_fragfail);
1.2       itojun    887:                        goto bad;
                    888:                }
                    889:
                    890:                mnext = &m->m_nextpkt;
                    891:
                    892:                /*
                    893:                 * Change the next header field of the last header in the
                    894:                 * unfragmentable part.
                    895:                 */
                    896:                if (exthdrs.ip6e_rthdr) {
                    897:                        nextproto = *mtod(exthdrs.ip6e_rthdr, u_char *);
                    898:                        *mtod(exthdrs.ip6e_rthdr, u_char *) = IPPROTO_FRAGMENT;
                    899:                }
                    900:                else if (exthdrs.ip6e_dest1) {
                    901:                        nextproto = *mtod(exthdrs.ip6e_dest1, u_char *);
                    902:                        *mtod(exthdrs.ip6e_dest1, u_char *) = IPPROTO_FRAGMENT;
                    903:                }
                    904:                else if (exthdrs.ip6e_hbh) {
                    905:                        nextproto = *mtod(exthdrs.ip6e_hbh, u_char *);
                    906:                        *mtod(exthdrs.ip6e_hbh, u_char *) = IPPROTO_FRAGMENT;
                    907:                }
                    908:                else {
                    909:                        nextproto = ip6->ip6_nxt;
                    910:                        ip6->ip6_nxt = IPPROTO_FRAGMENT;
                    911:                }
                    912:
                    913:                /*
                    914:                 * Loop through length of segment after first fragment,
                    915:                 * make new header and copy data of each part and link onto chain.
                    916:                 */
                    917:                m0 = m;
                    918:                for (off = hlen; off < tlen; off += len) {
                    919:                        MGETHDR(m, M_DONTWAIT, MT_HEADER);
                    920:                        if (!m) {
                    921:                                error = ENOBUFS;
                    922:                                ip6stat.ip6s_odropped++;
                    923:                                goto sendorfree;
                    924:                        }
                    925:                        m->m_flags = m0->m_flags & M_COPYFLAGS;
                    926:                        *mnext = m;
                    927:                        mnext = &m->m_nextpkt;
                    928:                        m->m_data += max_linkhdr;
                    929:                        mhip6 = mtod(m, struct ip6_hdr *);
                    930:                        *mhip6 = *ip6;
                    931:                        m->m_len = sizeof(*mhip6);
                    932:                        error = ip6_insertfraghdr(m0, m, hlen, &ip6f);
                    933:                        if (error) {
                    934:                                ip6stat.ip6s_odropped++;
                    935:                                goto sendorfree;
                    936:                        }
                    937:                        ip6f->ip6f_offlg = htons((u_short)((off - hlen) & ~7));
                    938:                        if (off + len >= tlen)
                    939:                                len = tlen - off;
                    940:                        else
                    941:                                ip6f->ip6f_offlg |= IP6F_MORE_FRAG;
                    942:                        mhip6->ip6_plen = htons((u_short)(len + hlen +
                    943:                                                          sizeof(*ip6f) -
                    944:                                                          sizeof(struct ip6_hdr)));
                    945:                        if ((m_frgpart = m_copy(m0, off, len)) == 0) {
                    946:                                error = ENOBUFS;
                    947:                                ip6stat.ip6s_odropped++;
                    948:                                goto sendorfree;
                    949:                        }
                    950:                        m_cat(m, m_frgpart);
                    951:                        m->m_pkthdr.len = len + hlen + sizeof(*ip6f);
                    952:                        m->m_pkthdr.rcvif = (struct ifnet *)0;
                    953:                        ip6f->ip6f_reserved = 0;
                    954:                        ip6f->ip6f_ident = id;
                    955:                        ip6f->ip6f_nxt = nextproto;
                    956:                        ip6stat.ip6s_ofragments++;
1.9       itojun    957:                        in6_ifstat_inc(ifp, ifs6_out_fragcreat);
1.2       itojun    958:                }
1.9       itojun    959:
                    960:                in6_ifstat_inc(ifp, ifs6_out_fragok);
1.2       itojun    961:        }
                    962:
                    963:        /*
                    964:         * Remove leading garbages.
                    965:         */
                    966: sendorfree:
                    967:        m = m0->m_nextpkt;
                    968:        m0->m_nextpkt = 0;
                    969:        m_freem(m0);
                    970:        for (m0 = m; m; m = m0) {
                    971:                m0 = m->m_nextpkt;
                    972:                m->m_nextpkt = 0;
                    973:                if (error == 0) {
1.11      itojun    974: #ifdef IFA_STATS
1.9       itojun    975:                        if (IFA_STATS) {
                    976:                                struct in6_ifaddr *ia6;
                    977:                                ip6 = mtod(m, struct ip6_hdr *);
                    978:                                ia6 = in6_ifawithifp(ifp, &ip6->ip6_src);
                    979:                                if (ia6) {
                    980:                                        ia->ia_ifa.ifa_data.ifad_outbytes +=
                    981:                                                m->m_pkthdr.len;
                    982:                                }
                    983:                        }
                    984: #endif
                    985: #ifdef OLDIP6OUTPUT
1.2       itojun    986:                        error = (*ifp->if_output)(ifp, m,
                    987:                                                  (struct sockaddr *)dst,
                    988:                                                  ro->ro_rt);
1.9       itojun    989: #else
                    990:                        error = nd6_output(ifp, m, dst, ro->ro_rt);
1.2       itojun    991: #endif
                    992:                }
                    993:                else
                    994:                        m_freem(m);
                    995:        }
                    996:
                    997:        if (error == 0)
                    998:                ip6stat.ip6s_fragmented++;
                    999:
                   1000: done:
                   1001:        if (ro == &ip6route && ro->ro_rt) { /* brace necessary for RTFREE */
                   1002:                RTFREE(ro->ro_rt);
                   1003:        } else if (ro_pmtu == &ip6route && ro_pmtu->ro_rt) {
                   1004:                RTFREE(ro_pmtu->ro_rt);
                   1005:        }
                   1006:
                   1007: #ifdef IPSEC
                   1008:        if (sp != NULL)
                   1009:                key_freesp(sp);
                   1010: #endif /* IPSEC */
                   1011:
                   1012:        return(error);
                   1013:
                   1014: freehdrs:
                   1015:        m_freem(exthdrs.ip6e_hbh);      /* m_freem will check if mbuf is 0 */
                   1016:        m_freem(exthdrs.ip6e_dest1);
                   1017:        m_freem(exthdrs.ip6e_rthdr);
                   1018:        m_freem(exthdrs.ip6e_dest2);
                   1019:        /* fall through */
                   1020: bad:
                   1021:        m_freem(m);
                   1022:        goto done;
                   1023: }
                   1024:
                   1025: static int
                   1026: ip6_copyexthdr(mp, hdr, hlen)
                   1027:        struct mbuf **mp;
                   1028:        caddr_t hdr;
                   1029:        int hlen;
                   1030: {
                   1031:        struct mbuf *m;
                   1032:
                   1033:        if (hlen > MCLBYTES)
                   1034:                return(ENOBUFS); /* XXX */
                   1035:
                   1036:        MGET(m, M_DONTWAIT, MT_DATA);
                   1037:        if (!m)
                   1038:                return(ENOBUFS);
                   1039:
                   1040:        if (hlen > MLEN) {
                   1041:                MCLGET(m, M_DONTWAIT);
                   1042:                if ((m->m_flags & M_EXT) == 0) {
                   1043:                        m_free(m);
                   1044:                        return(ENOBUFS);
                   1045:                }
                   1046:        }
                   1047:        m->m_len = hlen;
                   1048:        if (hdr)
                   1049:                bcopy(hdr, mtod(m, caddr_t), hlen);
                   1050:
                   1051:        *mp = m;
                   1052:        return(0);
                   1053: }
                   1054:
                   1055: /*
                   1056:  * Insert jumbo payload option.
                   1057:  */
                   1058: static int
                   1059: ip6_insert_jumboopt(exthdrs, plen)
                   1060:        struct ip6_exthdrs *exthdrs;
                   1061:        u_int32_t plen;
                   1062: {
                   1063:        struct mbuf *mopt;
                   1064:        u_char *optbuf;
                   1065:
                   1066: #define JUMBOOPTLEN    8       /* length of jumbo payload option and padding */
                   1067:
                   1068:        /*
                   1069:         * If there is no hop-by-hop options header, allocate new one.
                   1070:         * If there is one but it doesn't have enough space to store the
                   1071:         * jumbo payload option, allocate a cluster to store the whole options.
                   1072:         * Otherwise, use it to store the options.
                   1073:         */
                   1074:        if (exthdrs->ip6e_hbh == 0) {
                   1075:                MGET(mopt, M_DONTWAIT, MT_DATA);
                   1076:                if (mopt == 0)
                   1077:                        return(ENOBUFS);
                   1078:                mopt->m_len = JUMBOOPTLEN;
                   1079:                optbuf = mtod(mopt, u_char *);
                   1080:                optbuf[1] = 0;  /* = ((JUMBOOPTLEN) >> 3) - 1 */
                   1081:                exthdrs->ip6e_hbh = mopt;
                   1082:        }
                   1083:        else {
                   1084:                struct ip6_hbh *hbh;
                   1085:
                   1086:                mopt = exthdrs->ip6e_hbh;
                   1087:                if (M_TRAILINGSPACE(mopt) < JUMBOOPTLEN) {
                   1088:                        caddr_t oldoptp = mtod(mopt, caddr_t);
                   1089:                        int oldoptlen = mopt->m_len;
                   1090:
                   1091:                        if (mopt->m_flags & M_EXT)
                   1092:                                return(ENOBUFS); /* XXX */
                   1093:                        MCLGET(mopt, M_DONTWAIT);
                   1094:                        if ((mopt->m_flags & M_EXT) == 0)
                   1095:                                return(ENOBUFS);
                   1096:
                   1097:                        bcopy(oldoptp, mtod(mopt, caddr_t), oldoptlen);
                   1098:                        optbuf = mtod(mopt, caddr_t) + oldoptlen;
                   1099:                        mopt->m_len = oldoptlen + JUMBOOPTLEN;
                   1100:                }
                   1101:                else {
                   1102:                        optbuf = mtod(mopt, u_char *) + mopt->m_len;
                   1103:                        mopt->m_len += JUMBOOPTLEN;
                   1104:                }
                   1105:                optbuf[0] = IP6OPT_PADN;
                   1106:                optbuf[1] = 1;
                   1107:
                   1108:                /*
                   1109:                 * Adjust the header length according to the pad and
                   1110:                 * the jumbo payload option.
                   1111:                 */
                   1112:                hbh = mtod(mopt, struct ip6_hbh *);
                   1113:                hbh->ip6h_len += (JUMBOOPTLEN >> 3);
                   1114:        }
                   1115:
                   1116:        /* fill in the option. */
                   1117:        optbuf[2] = IP6OPT_JUMBO;
                   1118:        optbuf[3] = 4;
                   1119:        *(u_int32_t *)&optbuf[4] = htonl(plen + JUMBOOPTLEN);
                   1120:
                   1121:        /* finally, adjust the packet header length */
                   1122:        exthdrs->ip6e_ip6->m_pkthdr.len += JUMBOOPTLEN;
                   1123:
                   1124:        return(0);
                   1125: #undef JUMBOOPTLEN
                   1126: }
                   1127:
                   1128: /*
                   1129:  * Insert fragment header and copy unfragmentable header portions.
                   1130:  */
                   1131: static int
                   1132: ip6_insertfraghdr(m0, m, hlen, frghdrp)
                   1133:        struct mbuf *m0, *m;
                   1134:        int hlen;
                   1135:        struct ip6_frag **frghdrp;
                   1136: {
                   1137:        struct mbuf *n, *mlast;
                   1138:
                   1139:        if (hlen > sizeof(struct ip6_hdr)) {
                   1140:                n = m_copym(m0, sizeof(struct ip6_hdr),
                   1141:                            hlen - sizeof(struct ip6_hdr), M_DONTWAIT);
                   1142:                if (n == 0)
                   1143:                        return(ENOBUFS);
                   1144:                m->m_next = n;
                   1145:        }
                   1146:        else
                   1147:                n = m;
                   1148:
                   1149:        /* Search for the last mbuf of unfragmentable part. */
                   1150:        for (mlast = n; mlast->m_next; mlast = mlast->m_next)
                   1151:                ;
                   1152:
                   1153:        if ((mlast->m_flags & M_EXT) == 0 &&
                   1154:            M_TRAILINGSPACE(mlast) < sizeof(struct ip6_frag)) {
                   1155:                /* use the trailing space of the last mbuf for the fragment hdr */
                   1156:                *frghdrp =
                   1157:                        (struct ip6_frag *)(mtod(mlast, caddr_t) + mlast->m_len);
                   1158:                mlast->m_len += sizeof(struct ip6_frag);
                   1159:                m->m_pkthdr.len += sizeof(struct ip6_frag);
                   1160:        }
                   1161:        else {
                   1162:                /* allocate a new mbuf for the fragment header */
                   1163:                struct mbuf *mfrg;
                   1164:
                   1165:                MGET(mfrg, M_DONTWAIT, MT_DATA);
                   1166:                if (mfrg == 0)
                   1167:                        return(ENOBUFS);
                   1168:                mfrg->m_len = sizeof(struct ip6_frag);
                   1169:                *frghdrp = mtod(mfrg, struct ip6_frag *);
                   1170:                mlast->m_next = mfrg;
                   1171:        }
                   1172:
                   1173:        return(0);
                   1174: }
                   1175:
                   1176: /*
                   1177:  * IP6 socket option processing.
                   1178:  */
                   1179: int
                   1180: ip6_ctloutput(op, so, level, optname, mp)
                   1181:        int op;
                   1182:        struct socket *so;
                   1183:        int level, optname;
                   1184:        struct mbuf **mp;
                   1185: {
                   1186:        register struct in6pcb *in6p = sotoin6pcb(so);
                   1187:        register struct mbuf *m = *mp;
                   1188:        register int optval = 0;
                   1189:        int error = 0;
                   1190:        struct proc *p = curproc;       /* XXX */
                   1191:
                   1192:        if (level == IPPROTO_IPV6)
                   1193:                switch (op) {
                   1194:
                   1195:                case PRCO_SETOPT:
                   1196:                        switch (optname) {
                   1197:                        case IPV6_PKTOPTIONS:
                   1198:                                return(ip6_pcbopts(&in6p->in6p_outputopts,
                   1199:                                                   m, so));
                   1200:                        case IPV6_HOPOPTS:
                   1201:                        case IPV6_DSTOPTS:
                   1202:                                if (p == 0 || suser(p->p_ucred, &p->p_acflag)) {
                   1203:                                        error = EPERM;
                   1204:                                        break;
                   1205:                                }
                   1206:                                /* fall through */
                   1207:                        case IPV6_UNICAST_HOPS:
                   1208:                        case IPV6_RECVOPTS:
                   1209:                        case IPV6_RECVRETOPTS:
                   1210:                        case IPV6_RECVDSTADDR:
                   1211:                        case IPV6_PKTINFO:
                   1212:                        case IPV6_HOPLIMIT:
                   1213:                        case IPV6_RTHDR:
                   1214:                        case IPV6_CHECKSUM:
                   1215:                        case IPV6_FAITH:
1.10      itojun   1216: #ifndef INET6_BINDV6ONLY
                   1217:                        case IPV6_BINDV6ONLY:
                   1218: #endif
1.2       itojun   1219:                                if (!m || m->m_len != sizeof(int))
                   1220:                                        error = EINVAL;
                   1221:                                else {
                   1222:                                        optval = *mtod(m, int *);
                   1223:                                        switch (optname) {
                   1224:
                   1225:                                        case IPV6_UNICAST_HOPS:
                   1226:                                                if (optval < -1 || optval >= 256)
                   1227:                                                        error = EINVAL;
                   1228:                                                else {
                   1229:                                                        /* -1 = kernel default */
                   1230:                                                        in6p->in6p_hops = optval;
                   1231:                                                }
                   1232:                                                break;
                   1233: #define OPTSET(bit) \
                   1234:        if (optval) \
                   1235:                in6p->in6p_flags |= bit; \
                   1236:        else \
                   1237:                in6p->in6p_flags &= ~bit;
                   1238:
                   1239:                                        case IPV6_RECVOPTS:
                   1240:                                                OPTSET(IN6P_RECVOPTS);
                   1241:                                                break;
                   1242:
                   1243:                                        case IPV6_RECVRETOPTS:
                   1244:                                                OPTSET(IN6P_RECVRETOPTS);
                   1245:                                                break;
                   1246:
                   1247:                                        case IPV6_RECVDSTADDR:
                   1248:                                                OPTSET(IN6P_RECVDSTADDR);
                   1249:                                                break;
                   1250:
                   1251:                                        case IPV6_PKTINFO:
                   1252:                                                OPTSET(IN6P_PKTINFO);
                   1253:                                                break;
                   1254:
                   1255:                                        case IPV6_HOPLIMIT:
                   1256:                                                OPTSET(IN6P_HOPLIMIT);
                   1257:                                                break;
                   1258:
                   1259:                                        case IPV6_HOPOPTS:
                   1260:                                                OPTSET(IN6P_HOPOPTS);
                   1261:                                                break;
                   1262:
                   1263:                                        case IPV6_DSTOPTS:
                   1264:                                                OPTSET(IN6P_DSTOPTS);
                   1265:                                                break;
                   1266:
                   1267:                                        case IPV6_RTHDR:
                   1268:                                                OPTSET(IN6P_RTHDR);
                   1269:                                                break;
                   1270:
                   1271:                                        case IPV6_CHECKSUM:
                   1272:                                                in6p->in6p_cksum = optval;
                   1273:                                                break;
                   1274:
                   1275:                                        case IPV6_FAITH:
                   1276:                                                OPTSET(IN6P_FAITH);
                   1277:                                                break;
1.10      itojun   1278:
                   1279: #ifndef INET6_BINDV6ONLY
                   1280:                                        case IPV6_BINDV6ONLY:
                   1281:                                                OPTSET(IN6P_BINDV6ONLY);
                   1282:                                                break;
                   1283: #endif
1.2       itojun   1284:                                        }
                   1285:                                }
                   1286:                                break;
                   1287: #undef OPTSET
                   1288:
                   1289:                        case IPV6_MULTICAST_IF:
                   1290:                        case IPV6_MULTICAST_HOPS:
                   1291:                        case IPV6_MULTICAST_LOOP:
                   1292:                        case IPV6_JOIN_GROUP:
                   1293:                        case IPV6_LEAVE_GROUP:
                   1294:                                error = ip6_setmoptions(optname, &in6p->in6p_moptions, m);
                   1295:                                break;
                   1296:
1.12      itojun   1297:                        case IPV6_PORTRANGE:
                   1298:                                optval = *mtod(m, int *);
                   1299:
                   1300:                                switch (optval) {
                   1301:                                case IPV6_PORTRANGE_DEFAULT:
                   1302:                                        in6p->in6p_flags &= ~(IN6P_LOWPORT);
                   1303:                                        in6p->in6p_flags &= ~(IN6P_HIGHPORT);
                   1304:                                        break;
                   1305:
                   1306:                                case IPV6_PORTRANGE_HIGH:
                   1307:                                        in6p->in6p_flags &= ~(IN6P_LOWPORT);
                   1308:                                        in6p->in6p_flags |= IN6P_HIGHPORT;
                   1309:                                        break;
                   1310:
                   1311:                                case IPV6_PORTRANGE_LOW:
                   1312:                                        in6p->in6p_flags &= ~(IN6P_HIGHPORT);
                   1313:                                        in6p->in6p_flags |= IN6P_LOWPORT;
                   1314:                                        break;
                   1315:
                   1316:                                default:
                   1317:                                        error = EINVAL;
                   1318:                                        break;
                   1319:                                }
                   1320:                                break;
                   1321:
1.2       itojun   1322: #ifdef IPSEC
                   1323:                        case IPV6_IPSEC_POLICY:
                   1324:                            {
                   1325:                                caddr_t req = NULL;
1.13      itojun   1326:                                size_t len = 0;
                   1327:
1.2       itojun   1328:                                int priv = 0;
                   1329:                                if (p == 0 || suser(p->p_ucred, &p->p_acflag))
                   1330:                                        priv = 0;
                   1331:                                else
                   1332:                                        priv = 1;
1.13      itojun   1333:                                if (m) {
1.2       itojun   1334:                                        req = mtod(m, caddr_t);
                   1335:                                        len = m->m_len;
                   1336:                                }
1.13      itojun   1337:                                error = ipsec6_set_policy(in6p,
                   1338:                                                   optname, req, len, priv);
1.2       itojun   1339:                            }
                   1340:                                break;
                   1341: #endif /* IPSEC */
                   1342:
                   1343:                        default:
                   1344:                                error = ENOPROTOOPT;
                   1345:                                break;
                   1346:                        }
                   1347:                        if (m)
                   1348:                                (void)m_free(m);
                   1349:                        break;
                   1350:
                   1351:                case PRCO_GETOPT:
                   1352:                        switch (optname) {
                   1353:
                   1354:                        case IPV6_OPTIONS:
                   1355:                        case IPV6_RETOPTS:
                   1356: #if 0
                   1357:                                *mp = m = m_get(M_WAIT, MT_SOOPTS);
                   1358:                                if (in6p->in6p_options) {
                   1359:                                        m->m_len = in6p->in6p_options->m_len;
                   1360:                                        bcopy(mtod(in6p->in6p_options, caddr_t),
                   1361:                                              mtod(m, caddr_t),
                   1362:                                              (unsigned)m->m_len);
                   1363:                                } else
                   1364:                                        m->m_len = 0;
                   1365:                                break;
                   1366: #else
                   1367:                                error = ENOPROTOOPT;
                   1368:                                break;
                   1369: #endif
                   1370:
                   1371:                        case IPV6_PKTOPTIONS:
                   1372:                                if (in6p->in6p_options) {
                   1373:                                        *mp = m_copym(in6p->in6p_options, 0,
                   1374:                                                      M_COPYALL, M_WAIT);
                   1375:                                } else {
                   1376:                                        *mp = m_get(M_WAIT, MT_SOOPTS);
                   1377:                                        (*mp)->m_len = 0;
                   1378:                                }
                   1379:                                break;
                   1380:
                   1381:                        case IPV6_HOPOPTS:
                   1382:                        case IPV6_DSTOPTS:
                   1383:                                if (p == 0 || suser(p->p_ucred, &p->p_acflag)) {
                   1384:                                        error = EPERM;
                   1385:                                        break;
                   1386:                                }
                   1387:                                /* fall through */
                   1388:                        case IPV6_UNICAST_HOPS:
                   1389:                        case IPV6_RECVOPTS:
                   1390:                        case IPV6_RECVRETOPTS:
                   1391:                        case IPV6_RECVDSTADDR:
1.12      itojun   1392:                        case IPV6_PORTRANGE:
1.2       itojun   1393:                        case IPV6_PKTINFO:
                   1394:                        case IPV6_HOPLIMIT:
                   1395:                        case IPV6_RTHDR:
                   1396:                        case IPV6_CHECKSUM:
                   1397:                        case IPV6_FAITH:
1.10      itojun   1398: #ifndef INET6_BINDV6ONLY
                   1399:                        case IPV6_BINDV6ONLY:
                   1400: #endif
1.2       itojun   1401:                                *mp = m = m_get(M_WAIT, MT_SOOPTS);
                   1402:                                m->m_len = sizeof(int);
                   1403:                                switch (optname) {
                   1404:
                   1405:                                case IPV6_UNICAST_HOPS:
                   1406:                                        optval = in6p->in6p_hops;
                   1407:                                        break;
                   1408:
                   1409: #define OPTBIT(bit) (in6p->in6p_flags & bit ? 1 : 0)
                   1410:
                   1411:                                case IPV6_RECVOPTS:
                   1412:                                        optval = OPTBIT(IN6P_RECVOPTS);
                   1413:                                        break;
                   1414:
                   1415:                                case IPV6_RECVRETOPTS:
                   1416:                                        optval = OPTBIT(IN6P_RECVRETOPTS);
                   1417:                                        break;
                   1418:
                   1419:                                case IPV6_RECVDSTADDR:
                   1420:                                        optval = OPTBIT(IN6P_RECVDSTADDR);
                   1421:                                        break;
1.12      itojun   1422:
                   1423:                                case IPV6_PORTRANGE:
                   1424:                                    {
                   1425:                                        int flags;
                   1426:                                        flags = in6p->in6p_flags;
                   1427:                                        if (flags & IN6P_HIGHPORT)
                   1428:                                                optval = IPV6_PORTRANGE_HIGH;
                   1429:                                        else if (flags & IN6P_LOWPORT)
                   1430:                                                optval = IPV6_PORTRANGE_LOW;
                   1431:                                        else
                   1432:                                                optval = 0;
                   1433:                                        break;
                   1434:                                    }
1.2       itojun   1435:
                   1436:                                case IPV6_PKTINFO:
                   1437:                                        optval = OPTBIT(IN6P_PKTINFO);
                   1438:                                        break;
                   1439:
                   1440:                                case IPV6_HOPLIMIT:
                   1441:                                        optval = OPTBIT(IN6P_HOPLIMIT);
                   1442:                                        break;
                   1443:
                   1444:                                case IPV6_HOPOPTS:
                   1445:                                        optval = OPTBIT(IN6P_HOPOPTS);
                   1446:                                        break;
                   1447:
                   1448:                                case IPV6_DSTOPTS:
                   1449:                                        optval = OPTBIT(IN6P_DSTOPTS);
                   1450:                                        break;
                   1451:
                   1452:                                case IPV6_RTHDR:
                   1453:                                        optval = OPTBIT(IN6P_RTHDR);
                   1454:                                        break;
                   1455:
                   1456:                                case IPV6_CHECKSUM:
                   1457:                                        optval = in6p->in6p_cksum;
                   1458:                                        break;
                   1459:
                   1460:                                case IPV6_FAITH:
                   1461:                                        optval = OPTBIT(IN6P_FAITH);
                   1462:                                        break;
1.10      itojun   1463:
                   1464: #ifndef INET6_BINDV6ONLY
                   1465:                                case IPV6_BINDV6ONLY:
                   1466:                                        optval = OPTBIT(IN6P_BINDV6ONLY);
                   1467:                                        break;
                   1468: #endif
1.2       itojun   1469:                                }
                   1470:                                *mtod(m, int *) = optval;
                   1471:                                break;
                   1472:
                   1473:                        case IPV6_MULTICAST_IF:
                   1474:                        case IPV6_MULTICAST_HOPS:
                   1475:                        case IPV6_MULTICAST_LOOP:
                   1476:                        case IPV6_JOIN_GROUP:
                   1477:                        case IPV6_LEAVE_GROUP:
                   1478:                                error = ip6_getmoptions(optname, in6p->in6p_moptions, mp);
                   1479:                                break;
                   1480:
                   1481: #ifdef IPSEC
                   1482:                        case IPV6_IPSEC_POLICY:
1.13      itojun   1483:                        {
                   1484:                                caddr_t req = NULL;
                   1485:                                size_t len = 0;
                   1486:
                   1487:                                if (m) {
                   1488:                                        req = mtod(m, caddr_t);
                   1489:                                        len = m->m_len;
                   1490:                                }
                   1491:                                error = ipsec6_get_policy(in6p, req, len, mp);
1.2       itojun   1492:                                break;
1.13      itojun   1493:                        }
1.2       itojun   1494: #endif /* IPSEC */
                   1495:
                   1496:                        default:
                   1497:                                error = ENOPROTOOPT;
                   1498:                                break;
                   1499:                        }
                   1500:                        break;
                   1501:                }
                   1502:        else {
                   1503:                error = EINVAL;
                   1504:                if (op == PRCO_SETOPT && *mp)
                   1505:                        (void)m_free(*mp);
                   1506:        }
                   1507:        return(error);
                   1508: }
                   1509:
                   1510: /*
                   1511:  * Set up IP6 options in pcb for insertion in output packets.
                   1512:  * Store in mbuf with pointer in pcbopt, adding pseudo-option
                   1513:  * with destination address if source routed.
                   1514:  */
                   1515: static int
                   1516: ip6_pcbopts(pktopt, m, so)
                   1517:        struct ip6_pktopts **pktopt;
                   1518:        register struct mbuf *m;
                   1519:        struct socket *so;
                   1520: {
                   1521:        register struct ip6_pktopts *opt = *pktopt;
                   1522:        int error = 0;
                   1523:        struct proc *p = curproc;       /* XXX */
                   1524:        int priv = 0;
                   1525:
                   1526:        /* turn off any old options. */
                   1527:        if (opt) {
                   1528:                if (opt->ip6po_m)
                   1529:                        (void)m_free(opt->ip6po_m);
                   1530:        }
                   1531:        else
                   1532:                opt = malloc(sizeof(*opt), M_IP6OPT, M_WAITOK);
                   1533:        *pktopt = 0;
                   1534:
                   1535:        if (!m || m->m_len == 0) {
                   1536:                /*
                   1537:                 * Only turning off any previous options.
                   1538:                 */
                   1539:                if (opt)
                   1540:                        free(opt, M_IP6OPT);
                   1541:                if (m)
                   1542:                        (void)m_free(m);
                   1543:                return(0);
                   1544:        }
                   1545:
                   1546:        /*  set options specified by user. */
                   1547:        if (p && !suser(p->p_ucred, &p->p_acflag))
                   1548:                priv = 1;
                   1549:        if ((error = ip6_setpktoptions(m, opt, priv)) != 0) {
                   1550:                (void)m_free(m);
                   1551:                return(error);
                   1552:        }
                   1553:        *pktopt = opt;
                   1554:        return(0);
                   1555: }
                   1556:
                   1557: /*
                   1558:  * Set the IP6 multicast options in response to user setsockopt().
                   1559:  */
                   1560: static int
                   1561: ip6_setmoptions(optname, im6op, m)
                   1562:        int optname;
                   1563:        struct ip6_moptions **im6op;
                   1564:        struct mbuf *m;
                   1565: {
                   1566:        int error = 0;
                   1567:        u_int loop, ifindex;
                   1568:        struct ipv6_mreq *mreq;
                   1569:        struct ifnet *ifp;
                   1570:        struct ip6_moptions *im6o = *im6op;
                   1571:        struct route_in6 ro;
                   1572:        struct sockaddr_in6 *dst;
                   1573:        struct in6_multi_mship *imm;
                   1574:        struct proc *p = curproc;       /* XXX */
                   1575:
                   1576:        if (im6o == NULL) {
                   1577:                /*
                   1578:                 * No multicast option buffer attached to the pcb;
                   1579:                 * allocate one and initialize to default values.
                   1580:                 */
                   1581:                im6o = (struct ip6_moptions *)
                   1582:                        malloc(sizeof(*im6o), M_IPMOPTS, M_WAITOK);
                   1583:
                   1584:                if (im6o == NULL)
                   1585:                        return(ENOBUFS);
                   1586:                *im6op = im6o;
                   1587:                im6o->im6o_multicast_ifp = NULL;
                   1588:                im6o->im6o_multicast_hlim = ip6_defmcasthlim;
                   1589:                im6o->im6o_multicast_loop = IPV6_DEFAULT_MULTICAST_LOOP;
                   1590:                LIST_INIT(&im6o->im6o_memberships);
                   1591:        }
                   1592:
                   1593:        switch (optname) {
                   1594:
                   1595:        case IPV6_MULTICAST_IF:
                   1596:                /*
                   1597:                 * Select the interface for outgoing multicast packets.
                   1598:                 */
                   1599:                if (m == NULL || m->m_len != sizeof(u_int)) {
                   1600:                        error = EINVAL;
                   1601:                        break;
                   1602:                }
                   1603:                ifindex = *(mtod(m, u_int *));
                   1604:                if (ifindex < 0 || if_index < ifindex) {
                   1605:                        error = ENXIO;  /* XXX EINVAL? */
                   1606:                        break;
                   1607:                }
                   1608:                ifp = ifindex2ifnet[ifindex];
                   1609:                if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
                   1610:                        error = EADDRNOTAVAIL;
                   1611:                        break;
                   1612:                }
                   1613:                im6o->im6o_multicast_ifp = ifp;
                   1614:                break;
                   1615:
                   1616:        case IPV6_MULTICAST_HOPS:
                   1617:            {
                   1618:                /*
                   1619:                 * Set the IP6 hoplimit for outgoing multicast packets.
                   1620:                 */
                   1621:                int optval;
                   1622:                if (m == NULL || m->m_len != sizeof(int)) {
                   1623:                        error = EINVAL;
                   1624:                        break;
                   1625:                }
                   1626:                optval = *(mtod(m, u_int *));
                   1627:                if (optval < -1 || optval >= 256)
                   1628:                        error = EINVAL;
                   1629:                else if (optval == -1)
                   1630:                        im6o->im6o_multicast_hlim = ip6_defmcasthlim;
                   1631:                else
                   1632:                        im6o->im6o_multicast_hlim = optval;
                   1633:                break;
                   1634:            }
                   1635:
                   1636:        case IPV6_MULTICAST_LOOP:
                   1637:                /*
                   1638:                 * Set the loopback flag for outgoing multicast packets.
                   1639:                 * Must be zero or one.
                   1640:                 */
                   1641:                if (m == NULL || m->m_len != sizeof(u_int) ||
                   1642:                   (loop = *(mtod(m, u_int *))) > 1) {
                   1643:                        error = EINVAL;
                   1644:                        break;
                   1645:                }
                   1646:                im6o->im6o_multicast_loop = loop;
                   1647:                break;
                   1648:
                   1649:        case IPV6_JOIN_GROUP:
                   1650:                /*
                   1651:                 * Add a multicast group membership.
                   1652:                 * Group must be a valid IP6 multicast address.
                   1653:                 */
                   1654:                if (m == NULL || m->m_len != sizeof(struct ipv6_mreq)) {
                   1655:                        error = EINVAL;
                   1656:                        break;
                   1657:                }
                   1658:                mreq = mtod(m, struct ipv6_mreq *);
1.9       itojun   1659:                if (IN6_IS_ADDR_UNSPECIFIED(&mreq->ipv6mr_multiaddr)) {
1.2       itojun   1660:                        /*
                   1661:                         * We use the unspecified address to specify to accept
                   1662:                         * all multicast addresses. Only super user is allowed
                   1663:                         * to do this.
                   1664:                         */
                   1665:                        if (suser(p->p_ucred, &p->p_acflag)) {
                   1666:                                error = EACCES;
                   1667:                                break;
                   1668:                        }
                   1669:                } else if (!IN6_IS_ADDR_MULTICAST(&mreq->ipv6mr_multiaddr)) {
                   1670:                        error = EINVAL;
                   1671:                        break;
                   1672:                }
                   1673:
                   1674:                /*
                   1675:                 * If the interface is specified, validate it.
                   1676:                 */
                   1677:                if (mreq->ipv6mr_interface < 0
                   1678:                 || if_index < mreq->ipv6mr_interface) {
                   1679:                        error = ENXIO;  /* XXX EINVAL? */
                   1680:                        break;
                   1681:                }
                   1682:                /*
                   1683:                 * If no interface was explicitly specified, choose an
                   1684:                 * appropriate one according to the given multicast address.
                   1685:                 */
                   1686:                if (mreq->ipv6mr_interface == 0) {
                   1687:                        /*
                   1688:                         * If the multicast address is in node-local scope,
                   1689:                         * the interface should be a loopback interface.
                   1690:                         * Otherwise, look up the routing table for the
                   1691:                         * address, and choose the outgoing interface.
                   1692:                         *   XXX: is it a good approach?
                   1693:                         */
                   1694:                        if (IN6_IS_ADDR_MC_NODELOCAL(&mreq->ipv6mr_multiaddr)) {
                   1695:                                ifp = &loif[0];
                   1696:                        }
                   1697:                        else {
                   1698:                                ro.ro_rt = NULL;
                   1699:                                dst = (struct sockaddr_in6 *)&ro.ro_dst;
                   1700:                                bzero(dst, sizeof(*dst));
                   1701:                                dst->sin6_len = sizeof(struct sockaddr_in6);
                   1702:                                dst->sin6_family = AF_INET6;
                   1703:                                dst->sin6_addr = mreq->ipv6mr_multiaddr;
                   1704:                                rtalloc((struct route *)&ro);
                   1705:                                if (ro.ro_rt == NULL) {
                   1706:                                        error = EADDRNOTAVAIL;
                   1707:                                        break;
                   1708:                                }
                   1709:                                ifp = ro.ro_rt->rt_ifp;
                   1710:                                rtfree(ro.ro_rt);
                   1711:                        }
                   1712:                } else
                   1713:                        ifp = ifindex2ifnet[mreq->ipv6mr_interface];
                   1714:
                   1715:                /*
                   1716:                 * See if we found an interface, and confirm that it
                   1717:                 * supports multicast
                   1718:                 */
                   1719:                if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0) {
                   1720:                        error = EADDRNOTAVAIL;
                   1721:                        break;
                   1722:                }
                   1723:                /*
                   1724:                 * Put interface index into the multicast address,
                   1725:                 * if the address has link-local scope.
                   1726:                 */
                   1727:                if (IN6_IS_ADDR_MC_LINKLOCAL(&mreq->ipv6mr_multiaddr)) {
                   1728:                        mreq->ipv6mr_multiaddr.s6_addr16[1]
                   1729:                                = htons(mreq->ipv6mr_interface);
                   1730:                }
                   1731:                /*
                   1732:                 * See if the membership already exists.
                   1733:                 */
                   1734:                for (imm = im6o->im6o_memberships.lh_first;
                   1735:                     imm != NULL; imm = imm->i6mm_chain.le_next)
                   1736:                        if (imm->i6mm_maddr->in6m_ifp == ifp &&
                   1737:                            IN6_ARE_ADDR_EQUAL(&imm->i6mm_maddr->in6m_addr,
                   1738:                                               &mreq->ipv6mr_multiaddr))
                   1739:                                break;
                   1740:                if (imm != NULL) {
                   1741:                        error = EADDRINUSE;
                   1742:                        break;
                   1743:                }
                   1744:                /*
                   1745:                 * Everything looks good; add a new record to the multicast
                   1746:                 * address list for the given interface.
                   1747:                 */
                   1748:                imm = malloc(sizeof(*imm), M_IPMADDR, M_WAITOK);
                   1749:                if (imm == NULL) {
                   1750:                        error = ENOBUFS;
                   1751:                        break;
                   1752:                }
                   1753:                if ((imm->i6mm_maddr =
                   1754:                     in6_addmulti(&mreq->ipv6mr_multiaddr, ifp, &error)) == NULL) {
                   1755:                        free(imm, M_IPMADDR);
                   1756:                        break;
                   1757:                }
                   1758:                LIST_INSERT_HEAD(&im6o->im6o_memberships, imm, i6mm_chain);
                   1759:                break;
                   1760:
                   1761:        case IPV6_LEAVE_GROUP:
                   1762:                /*
                   1763:                 * Drop a multicast group membership.
                   1764:                 * Group must be a valid IP6 multicast address.
                   1765:                 */
                   1766:                if (m == NULL || m->m_len != sizeof(struct ipv6_mreq)) {
                   1767:                        error = EINVAL;
                   1768:                        break;
                   1769:                }
                   1770:                mreq = mtod(m, struct ipv6_mreq *);
1.9       itojun   1771:                if (IN6_IS_ADDR_UNSPECIFIED(&mreq->ipv6mr_multiaddr)) {
1.2       itojun   1772:                        if (suser(p->p_ucred, &p->p_acflag)) {
                   1773:                                error = EACCES;
                   1774:                                break;
                   1775:                        }
                   1776:                } else if (!IN6_IS_ADDR_MULTICAST(&mreq->ipv6mr_multiaddr)) {
                   1777:                        error = EINVAL;
                   1778:                        break;
                   1779:                }
                   1780:                /*
                   1781:                 * If an interface address was specified, get a pointer
                   1782:                 * to its ifnet structure.
                   1783:                 */
                   1784:                if (mreq->ipv6mr_interface < 0
                   1785:                 || if_index < mreq->ipv6mr_interface) {
                   1786:                        error = ENXIO;  /* XXX EINVAL? */
                   1787:                        break;
                   1788:                }
                   1789:                ifp = ifindex2ifnet[mreq->ipv6mr_interface];
                   1790:                /*
                   1791:                 * Put interface index into the multicast address,
                   1792:                 * if the address has link-local scope.
                   1793:                 */
                   1794:                if (IN6_IS_ADDR_MC_LINKLOCAL(&mreq->ipv6mr_multiaddr)) {
                   1795:                        mreq->ipv6mr_multiaddr.s6_addr16[1]
                   1796:                                = htons(mreq->ipv6mr_interface);
                   1797:                }
                   1798:                /*
                   1799:                 * Find the membership in the membership list.
                   1800:                 */
                   1801:                for (imm = im6o->im6o_memberships.lh_first;
                   1802:                     imm != NULL; imm = imm->i6mm_chain.le_next) {
                   1803:                        if ((ifp == NULL ||
                   1804:                             imm->i6mm_maddr->in6m_ifp == ifp) &&
                   1805:                            IN6_ARE_ADDR_EQUAL(&imm->i6mm_maddr->in6m_addr,
                   1806:                                               &mreq->ipv6mr_multiaddr))
                   1807:                                break;
                   1808:                }
                   1809:                if (imm == NULL) {
                   1810:                        /* Unable to resolve interface */
                   1811:                        error = EADDRNOTAVAIL;
                   1812:                        break;
                   1813:                }
                   1814:                /*
                   1815:                 * Give up the multicast address record to which the
                   1816:                 * membership points.
                   1817:                 */
                   1818:                LIST_REMOVE(imm, i6mm_chain);
                   1819:                in6_delmulti(imm->i6mm_maddr);
                   1820:                free(imm, M_IPMADDR);
                   1821:                break;
                   1822:
                   1823:        default:
                   1824:                error = EOPNOTSUPP;
                   1825:                break;
                   1826:        }
                   1827:
                   1828:        /*
                   1829:         * If all options have default values, no need to keep the mbuf.
                   1830:         */
                   1831:        if (im6o->im6o_multicast_ifp == NULL &&
                   1832:            im6o->im6o_multicast_hlim == ip6_defmcasthlim &&
                   1833:            im6o->im6o_multicast_loop == IPV6_DEFAULT_MULTICAST_LOOP &&
                   1834:            im6o->im6o_memberships.lh_first == NULL) {
                   1835:                free(*im6op, M_IPMOPTS);
                   1836:                *im6op = NULL;
                   1837:        }
                   1838:
                   1839:        return(error);
                   1840: }
                   1841:
                   1842: /*
                   1843:  * Return the IP6 multicast options in response to user getsockopt().
                   1844:  */
                   1845: static int
                   1846: ip6_getmoptions(optname, im6o, mp)
                   1847:        int optname;
                   1848:        register struct ip6_moptions *im6o;
                   1849:        register struct mbuf **mp;
                   1850: {
                   1851:        u_int *hlim, *loop, *ifindex;
                   1852:
                   1853:        *mp = m_get(M_WAIT, MT_SOOPTS);
                   1854:
                   1855:        switch (optname) {
                   1856:
                   1857:        case IPV6_MULTICAST_IF:
                   1858:                ifindex = mtod(*mp, u_int *);
                   1859:                (*mp)->m_len = sizeof(u_int);
                   1860:                if (im6o == NULL || im6o->im6o_multicast_ifp == NULL)
                   1861:                        *ifindex = 0;
                   1862:                else
                   1863:                        *ifindex = im6o->im6o_multicast_ifp->if_index;
                   1864:                return(0);
                   1865:
                   1866:        case IPV6_MULTICAST_HOPS:
                   1867:                hlim = mtod(*mp, u_int *);
                   1868:                (*mp)->m_len = sizeof(u_int);
                   1869:                if (im6o == NULL)
                   1870:                        *hlim = ip6_defmcasthlim;
                   1871:                else
                   1872:                        *hlim = im6o->im6o_multicast_hlim;
                   1873:                return(0);
                   1874:
                   1875:        case IPV6_MULTICAST_LOOP:
                   1876:                loop = mtod(*mp, u_int *);
                   1877:                (*mp)->m_len = sizeof(u_int);
                   1878:                if (im6o == NULL)
                   1879:                        *loop = ip6_defmcasthlim;
                   1880:                else
                   1881:                        *loop = im6o->im6o_multicast_loop;
                   1882:                return(0);
                   1883:
                   1884:        default:
                   1885:                return(EOPNOTSUPP);
                   1886:        }
                   1887: }
                   1888:
                   1889: /*
                   1890:  * Discard the IP6 multicast options.
                   1891:  */
                   1892: void
                   1893: ip6_freemoptions(im6o)
                   1894:        register struct ip6_moptions *im6o;
                   1895: {
                   1896:        struct in6_multi_mship *imm;
                   1897:
                   1898:        if (im6o == NULL)
                   1899:                return;
                   1900:
                   1901:        while ((imm = im6o->im6o_memberships.lh_first) != NULL) {
                   1902:                LIST_REMOVE(imm, i6mm_chain);
                   1903:                if (imm->i6mm_maddr)
                   1904:                        in6_delmulti(imm->i6mm_maddr);
                   1905:                free(imm, M_IPMADDR);
                   1906:        }
                   1907:        free(im6o, M_IPMOPTS);
                   1908: }
                   1909:
                   1910: /*
                   1911:  * Set IPv6 outgoing packet options based on advanced API.
                   1912:  */
                   1913: int
                   1914: ip6_setpktoptions(control, opt, priv)
                   1915:        struct mbuf *control;
                   1916:        struct ip6_pktopts *opt;
                   1917:        int priv;
                   1918: {
                   1919:        register struct cmsghdr *cm = 0;
                   1920:
                   1921:        if (control == 0 || opt == 0)
                   1922:                return(EINVAL);
                   1923:
                   1924:        bzero(opt, sizeof(*opt));
                   1925:        opt->ip6po_hlim = -1; /* -1 means to use default hop limit */
                   1926:
                   1927:        /*
                   1928:         * XXX: Currently, we assume all the optional information is stored
                   1929:         * in a single mbuf.
                   1930:         */
                   1931:        if (control->m_next)
                   1932:                return(EINVAL);
                   1933:
                   1934:        opt->ip6po_m = control;
                   1935:
                   1936:        for (; control->m_len; control->m_data += CMSG_ALIGN(cm->cmsg_len),
                   1937:                     control->m_len -= CMSG_ALIGN(cm->cmsg_len)) {
                   1938:                cm = mtod(control, struct cmsghdr *);
                   1939:                if (cm->cmsg_len == 0 || cm->cmsg_len > control->m_len)
                   1940:                        return(EINVAL);
                   1941:                if (cm->cmsg_level != IPPROTO_IPV6)
                   1942:                        continue;
                   1943:
                   1944:                switch(cm->cmsg_type) {
                   1945:                case IPV6_PKTINFO:
                   1946:                        if (cm->cmsg_len != CMSG_LEN(sizeof(struct in6_pktinfo)))
                   1947:                                return(EINVAL);
                   1948:                        opt->ip6po_pktinfo = (struct in6_pktinfo *)CMSG_DATA(cm);
                   1949:                        if (opt->ip6po_pktinfo->ipi6_ifindex &&
                   1950:                            IN6_IS_ADDR_LINKLOCAL(&opt->ip6po_pktinfo->ipi6_addr))
                   1951:                                opt->ip6po_pktinfo->ipi6_addr.s6_addr16[1] =
                   1952:                                        htons(opt->ip6po_pktinfo->ipi6_ifindex);
                   1953:
                   1954:                        if (opt->ip6po_pktinfo->ipi6_ifindex > if_index
                   1955:                         || opt->ip6po_pktinfo->ipi6_ifindex < 0) {
                   1956:                                return(ENXIO);
                   1957:                        }
                   1958:
1.9       itojun   1959:                        if (!IN6_IS_ADDR_UNSPECIFIED(&opt->ip6po_pktinfo->ipi6_addr)) {
1.2       itojun   1960:                                struct ifaddr *ia;
                   1961:                                struct sockaddr_in6 sin6;
                   1962:
                   1963:                                bzero(&sin6, sizeof(sin6));
                   1964:                                sin6.sin6_len = sizeof(sin6);
                   1965:                                sin6.sin6_family = AF_INET6;
                   1966:                                sin6.sin6_addr =
                   1967:                                        opt->ip6po_pktinfo->ipi6_addr;
                   1968:                                ia = ifa_ifwithaddr(sin6tosa(&sin6));
                   1969:                                if (ia == NULL ||
                   1970:                                    (opt->ip6po_pktinfo->ipi6_ifindex &&
                   1971:                                     (ia->ifa_ifp->if_index !=
                   1972:                                      opt->ip6po_pktinfo->ipi6_ifindex))) {
                   1973:                                        return(EADDRNOTAVAIL);
                   1974:                                }
                   1975:                                /*
                   1976:                                 * Check if the requested source address is
                   1977:                                 * indeed a unicast address assigned to the
                   1978:                                 * node.
                   1979:                                 */
                   1980:                                if (IN6_IS_ADDR_MULTICAST(&opt->ip6po_pktinfo->ipi6_addr))
                   1981:                                        return(EADDRNOTAVAIL);
                   1982:                        }
                   1983:                        break;
                   1984:
                   1985:                case IPV6_HOPLIMIT:
                   1986:                        if (cm->cmsg_len != CMSG_LEN(sizeof(int)))
                   1987:                                return(EINVAL);
                   1988:
                   1989:                        opt->ip6po_hlim = *(int *)CMSG_DATA(cm);
                   1990:                        if (opt->ip6po_hlim < -1 || opt->ip6po_hlim > 255)
                   1991:                                return(EINVAL);
                   1992:                        break;
                   1993:
                   1994:                case IPV6_NEXTHOP:
                   1995:                        if (!priv)
                   1996:                                return(EPERM);
                   1997:                        if (cm->cmsg_len < sizeof(u_char) ||
                   1998:                            cm->cmsg_len < CMSG_LEN(*CMSG_DATA(cm)))
                   1999:                                return(EINVAL);
                   2000:
                   2001:                        opt->ip6po_nexthop = (struct sockaddr *)CMSG_DATA(cm);
                   2002:
                   2003:                        break;
                   2004:
                   2005:                case IPV6_HOPOPTS:
                   2006:                        if (cm->cmsg_len < CMSG_LEN(sizeof(struct ip6_hbh)))
                   2007:                                return(EINVAL);
                   2008:                        opt->ip6po_hbh = (struct ip6_hbh *)CMSG_DATA(cm);
                   2009:                        if (cm->cmsg_len !=
                   2010:                            CMSG_LEN((opt->ip6po_hbh->ip6h_len + 1) << 3))
                   2011:                                return(EINVAL);
                   2012:                        break;
                   2013:
                   2014:                case IPV6_DSTOPTS:
                   2015:                        if (cm->cmsg_len < CMSG_LEN(sizeof(struct ip6_dest)))
                   2016:                                return(EINVAL);
                   2017:
                   2018:                        /*
                   2019:                         * If there is no routing header yet, the destination
                   2020:                         * options header should be put on the 1st part.
                   2021:                         * Otherwise, the header should be on the 2nd part.
                   2022:                         * (See RFC 2460, section 4.1)
                   2023:                         */
                   2024:                        if (opt->ip6po_rthdr == NULL) {
                   2025:                                opt->ip6po_dest1 =
                   2026:                                        (struct ip6_dest *)CMSG_DATA(cm);
                   2027:                                if (cm->cmsg_len !=
                   2028:                                    CMSG_LEN((opt->ip6po_dest1->ip6d_len + 1)
                   2029:                                             << 3))
                   2030:                                        return(EINVAL);
                   2031:                        }
                   2032:                        else {
                   2033:                                opt->ip6po_dest2 =
                   2034:                                        (struct ip6_dest *)CMSG_DATA(cm);
                   2035:                                if (cm->cmsg_len !=
                   2036:                                    CMSG_LEN((opt->ip6po_dest2->ip6d_len + 1)
                   2037:                                             << 3))
                   2038:                                        return(EINVAL);
                   2039:                        }
                   2040:                        break;
                   2041:
                   2042:                case IPV6_RTHDR:
                   2043:                        if (cm->cmsg_len < CMSG_LEN(sizeof(struct ip6_rthdr)))
                   2044:                                return(EINVAL);
                   2045:                        opt->ip6po_rthdr = (struct ip6_rthdr *)CMSG_DATA(cm);
                   2046:                        if (cm->cmsg_len !=
                   2047:                            CMSG_LEN((opt->ip6po_rthdr->ip6r_len + 1) << 3))
                   2048:                                return(EINVAL);
                   2049:                        switch(opt->ip6po_rthdr->ip6r_type) {
                   2050:                        case IPV6_RTHDR_TYPE_0:
                   2051:                                if (opt->ip6po_rthdr->ip6r_segleft == 0)
                   2052:                                        return(EINVAL);
                   2053:                                break;
                   2054:                        default:
                   2055:                                return(EINVAL);
                   2056:                        }
                   2057:                        break;
                   2058:
                   2059:                default:
                   2060:                        return(ENOPROTOOPT);
                   2061:                }
                   2062:        }
                   2063:
                   2064:        return(0);
                   2065: }
                   2066:
                   2067: /*
                   2068:  * Routine called from ip6_output() to loop back a copy of an IP6 multicast
                   2069:  * packet to the input queue of a specified interface.  Note that this
                   2070:  * calls the output routine of the loopback "driver", but with an interface
                   2071:  * pointer that might NOT be &loif -- easier than replicating that code here.
                   2072:  */
                   2073: void
                   2074: ip6_mloopback(ifp, m, dst)
                   2075:        struct ifnet *ifp;
                   2076:        register struct mbuf *m;
                   2077:        register struct sockaddr_in6 *dst;
                   2078: {
                   2079:        struct  mbuf *copym;
                   2080:
                   2081:        copym = m_copy(m, 0, M_COPYALL);
                   2082:        if (copym != NULL)
                   2083:                (void)looutput(ifp, copym, (struct sockaddr *)dst, NULL);
                   2084: }
                   2085:
                   2086: /*
                   2087:  * Chop IPv6 header off from the payload.
                   2088:  */
                   2089: static int
                   2090: ip6_splithdr(m, exthdrs)
                   2091:        struct mbuf *m;
                   2092:        struct ip6_exthdrs *exthdrs;
                   2093: {
                   2094:        struct mbuf *mh;
                   2095:        struct ip6_hdr *ip6;
                   2096:
                   2097:        ip6 = mtod(m, struct ip6_hdr *);
                   2098:        if (m->m_len > sizeof(*ip6)) {
                   2099:                MGETHDR(mh, M_DONTWAIT, MT_HEADER);
                   2100:                if (mh == 0) {
                   2101:                        m_freem(m);
                   2102:                        return ENOBUFS;
                   2103:                }
                   2104:                M_COPY_PKTHDR(mh, m);
                   2105:                MH_ALIGN(mh, sizeof(*ip6));
                   2106:                m->m_flags &= ~M_PKTHDR;
                   2107:                m->m_len -= sizeof(*ip6);
                   2108:                m->m_data += sizeof(*ip6);
                   2109:                mh->m_next = m;
                   2110:                m = mh;
                   2111:                m->m_len = sizeof(*ip6);
                   2112:                bcopy((caddr_t)ip6, mtod(m, caddr_t), sizeof(*ip6));
                   2113:        }
                   2114:        exthdrs->ip6e_ip6 = m;
                   2115:        return 0;
                   2116: }
                   2117:
                   2118: /*
                   2119:  * Compute IPv6 extension header length.
                   2120:  */
                   2121: int
                   2122: ip6_optlen(in6p)
                   2123:        struct in6pcb *in6p;
                   2124: {
                   2125:        int len;
                   2126:
                   2127:        if (!in6p->in6p_outputopts)
                   2128:                return 0;
                   2129:
                   2130:        len = 0;
                   2131: #define elen(x) \
                   2132:     (((struct ip6_ext *)(x)) ? (((struct ip6_ext *)(x))->ip6e_len + 1) << 3 : 0)
                   2133:
                   2134:        len += elen(in6p->in6p_outputopts->ip6po_hbh);
                   2135:        len += elen(in6p->in6p_outputopts->ip6po_dest1);
                   2136:        len += elen(in6p->in6p_outputopts->ip6po_rthdr);
                   2137:        len += elen(in6p->in6p_outputopts->ip6po_dest2);
                   2138:        return len;
                   2139: #undef elen
                   2140: }

CVSweb <webmaster@jp.NetBSD.org>