Return to ip_output.c CVS log

Up to [CSRG BSD Unix] / 43BSD / sys / netinet

Annotation of 43BSD/sys/netinet/ip_output.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1982, 1986 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  *
        !             6:  *     @(#)ip_output.c 7.1 (Berkeley) 6/5/86
        !             7:  */
        !             8: 
        !             9: #include "param.h"
        !            10: #include "mbuf.h"
        !            11: #include "errno.h"
        !            12: #include "protosw.h"
        !            13: #include "socket.h"
        !            14: #include "socketvar.h"
        !            15: 
        !            16: #include "../net/if.h"
        !            17: #include "../net/route.h"
        !            18: 
        !            19: #include "in.h"
        !            20: #include "in_pcb.h"
        !            21: #include "in_systm.h"
        !            22: #include "in_var.h"
        !            23: #include "ip.h"
        !            24: #include "ip_var.h"
        !            25: 
        !            26: #ifdef vax
        !            27: #include "../vax/mtpr.h"
        !            28: #endif
        !            29: 
        !            30: struct mbuf *ip_insertoptions();
        !            31: 
        !            32: /*
        !            33:  * IP output.  The packet in mbuf chain m contains a skeletal IP
        !            34:  * header (as ipovly).  The mbuf chain containing the packet will
        !            35:  * be freed.  The mbuf opt, if present, will not be freed.
        !            36:  */
        !            37: ip_output(m, opt, ro, flags)
        !            38:        struct mbuf *m;
        !            39:        struct mbuf *opt;
        !            40:        struct route *ro;
        !            41:        int flags;
        !            42: {
        !            43:        register struct ip *ip;
        !            44:        register struct ifnet *ifp;
        !            45:        int len, hlen = sizeof (struct ip), off, error = 0;
        !            46:        struct route iproute;
        !            47:        struct sockaddr_in *dst;
        !            48: 
        !            49:        if (opt)
        !            50:                m = ip_insertoptions(m, opt, &hlen);
        !            51:        ip = mtod(m, struct ip *);
        !            52:        /*
        !            53:         * Fill in IP header.
        !            54:         */
        !            55:        if ((flags & IP_FORWARDING) == 0) {
        !            56:                ip->ip_v = IPVERSION;
        !            57:                ip->ip_off &= IP_DF;
        !            58:                ip->ip_id = htons(ip_id++);
        !            59:                ip->ip_hl = hlen >> 2;
        !            60:        } else
        !            61:                hlen = ip->ip_hl << 2;
        !            62: 
        !            63:        /*
        !            64:         * Route packet.
        !            65:         */
        !            66:        if (ro == 0) {
        !            67:                ro = &iproute;
        !            68:                bzero((caddr_t)ro, sizeof (*ro));
        !            69:        }
        !            70:        dst = (struct sockaddr_in *)&ro->ro_dst;
        !            71:        /*
        !            72:         * If there is a cached route,
        !            73:         * check that it is to the same destination
        !            74:         * and is still up.  If not, free it and try again.
        !            75:         */
        !            76:        if (ro->ro_rt && ((ro->ro_rt->rt_flags & RTF_UP) == 0 ||
        !            77:           dst->sin_addr.s_addr != ip->ip_dst.s_addr)) {
        !            78:                RTFREE(ro->ro_rt);
        !            79:                ro->ro_rt = (struct rtentry *)0;
        !            80:        }
        !            81:        if (ro->ro_rt == 0) {
        !            82:                dst->sin_family = AF_INET;
        !            83:                dst->sin_addr = ip->ip_dst;
        !            84:        }
        !            85:        /*
        !            86:         * If routing to interface only,
        !            87:         * short circuit routing lookup.
        !            88:         */
        !            89:        if (flags & IP_ROUTETOIF) {
        !            90:                struct in_ifaddr *ia;
        !            91: 
        !            92:                ia = (struct in_ifaddr *)ifa_ifwithdstaddr(dst);
        !            93:                if (ia == 0)
        !            94:                        ia = in_iaonnetof(in_netof(ip->ip_dst));
        !            95:                if (ia == 0) {
        !            96:                        error = ENETUNREACH;
        !            97:                        goto bad;
        !            98:                }
        !            99:                ifp = ia->ia_ifp;
        !           100:        } else {
        !           101:                if (ro->ro_rt == 0)
        !           102:                        rtalloc(ro);
        !           103:                if (ro->ro_rt == 0 || (ifp = ro->ro_rt->rt_ifp) == 0) {
        !           104:                        error = ENETUNREACH;
        !           105:                        goto bad;
        !           106:                }
        !           107:                ro->ro_rt->rt_use++;
        !           108:                if (ro->ro_rt->rt_flags & (RTF_GATEWAY|RTF_HOST))
        !           109:                        dst = (struct sockaddr_in *)&ro->ro_rt->rt_gateway;
        !           110:        }
        !           111: #ifndef notdef
        !           112:        /*
        !           113:         * If source address not specified yet, use address
        !           114:         * of outgoing interface.
        !           115:         */
        !           116:        if (ip->ip_src.s_addr == INADDR_ANY) {
        !           117:                register struct in_ifaddr *ia;
        !           118: 
        !           119:                for (ia = in_ifaddr; ia; ia = ia->ia_next)
        !           120:                        if (ia->ia_ifp == ifp) {
        !           121:                                ip->ip_src = IA_SIN(ia)->sin_addr;
        !           122:                                break;
        !           123:                        }
        !           124:        }
        !           125: #endif
        !           126:        /*
        !           127:         * Look for broadcast address and
        !           128:         * and verify user is allowed to send
        !           129:         * such a packet.
        !           130:         */
        !           131:        if (in_broadcast(dst->sin_addr)) {
        !           132:                if ((ifp->if_flags & IFF_BROADCAST) == 0) {
        !           133:                        error = EADDRNOTAVAIL;
        !           134:                        goto bad;
        !           135:                }
        !           136:                if ((flags & IP_ALLOWBROADCAST) == 0) {
        !           137:                        error = EACCES;
        !           138:                        goto bad;
        !           139:                }
        !           140:                /* don't allow broadcast messages to be fragmented */
        !           141:                if (ip->ip_len > ifp->if_mtu) {
        !           142:                        error = EMSGSIZE;
        !           143:                        goto bad;
        !           144:                }
        !           145:        }
        !           146: 
        !           147:        /*
        !           148:         * If small enough for interface, can just send directly.
        !           149:         */
        !           150:        if (ip->ip_len <= ifp->if_mtu) {
        !           151:                ip->ip_len = htons((u_short)ip->ip_len);
        !           152:                ip->ip_off = htons((u_short)ip->ip_off);
        !           153:                ip->ip_sum = 0;
        !           154:                ip->ip_sum = in_cksum(m, hlen);
        !           155:                error = (*ifp->if_output)(ifp, m, (struct sockaddr *)dst);
        !           156:                goto done;
        !           157:        }
        !           158: 
        !           159:        /*
        !           160:         * Too large for interface; fragment if possible.
        !           161:         * Must be able to put at least 8 bytes per fragment.
        !           162:         */
        !           163:        if (ip->ip_off & IP_DF) {
        !           164:                error = EMSGSIZE;
        !           165:                goto bad;
        !           166:        }
        !           167:        len = (ifp->if_mtu - hlen) &~ 7;
        !           168:        if (len < 8) {
        !           169:                error = EMSGSIZE;
        !           170:                goto bad;
        !           171:        }
        !           172: 
        !           173:        /*
        !           174:         * Discard IP header from logical mbuf for m_copy's sake.
        !           175:         * Loop through length of segment, make a copy of each
        !           176:         * part and output.
        !           177:         */
        !           178:        m->m_len -= sizeof (struct ip);
        !           179:        m->m_off += sizeof (struct ip);
        !           180:        for (off = 0; off < ip->ip_len-hlen; off += len) {
        !           181:                struct mbuf *mh = m_get(M_DONTWAIT, MT_HEADER);
        !           182:                struct ip *mhip;
        !           183: 
        !           184:                if (mh == 0) {
        !           185:                        error = ENOBUFS;
        !           186:                        goto bad;
        !           187:                }
        !           188:                mh->m_off = MMAXOFF - hlen;
        !           189:                mhip = mtod(mh, struct ip *);
        !           190:                *mhip = *ip;
        !           191:                if (hlen > sizeof (struct ip)) {
        !           192:                        int olen = ip_optcopy(ip, mhip, off);
        !           193:                        mh->m_len = sizeof (struct ip) + olen;
        !           194:                } else
        !           195:                        mh->m_len = sizeof (struct ip);
        !           196:                mhip->ip_off = (off >> 3) + (ip->ip_off & ~IP_MF);
        !           197:                if (ip->ip_off & IP_MF)
        !           198:                        mhip->ip_off |= IP_MF;
        !           199:                if (off + len >= ip->ip_len-hlen)
        !           200:                        len = mhip->ip_len = ip->ip_len - hlen - off;
        !           201:                else {
        !           202:                        mhip->ip_len = len;
        !           203:                        mhip->ip_off |= IP_MF;
        !           204:                }
        !           205:                mhip->ip_len += sizeof (struct ip);
        !           206:                mhip->ip_len = htons((u_short)mhip->ip_len);
        !           207:                mh->m_next = m_copy(m, off, len);
        !           208:                if (mh->m_next == 0) {
        !           209:                        (void) m_free(mh);
        !           210:                        error = ENOBUFS;        /* ??? */
        !           211:                        goto bad;
        !           212:                }
        !           213:                mhip->ip_off = htons((u_short)mhip->ip_off);
        !           214:                mhip->ip_sum = 0;
        !           215:                mhip->ip_sum = in_cksum(mh, hlen);
        !           216:                if (error = (*ifp->if_output)(ifp, mh, (struct sockaddr *)dst))
        !           217:                        break;
        !           218:        }
        !           219: bad:
        !           220:        m_freem(m);
        !           221: done:
        !           222:        if (ro == &iproute && (flags & IP_ROUTETOIF) == 0 && ro->ro_rt)
        !           223:                RTFREE(ro->ro_rt);
        !           224:        return (error);
        !           225: }
        !           226: 
        !           227: /*
        !           228:  * Insert IP options into preformed packet.
        !           229:  * Adjust IP destination as required for IP source routing,
        !           230:  * as indicated by a non-zero in_addr at the start of the options.
        !           231:  */
        !           232: struct mbuf *
        !           233: ip_insertoptions(m, opt, phlen)
        !           234:        register struct mbuf *m;
        !           235:        struct mbuf *opt;
        !           236:        int *phlen;
        !           237: {
        !           238:        register struct ipoption *p = mtod(opt, struct ipoption *);
        !           239:        struct mbuf *n;
        !           240:        register struct ip *ip = mtod(m, struct ip *);
        !           241:        unsigned optlen;
        !           242: 
        !           243:        optlen = opt->m_len - sizeof(p->ipopt_dst);
        !           244:        if (p->ipopt_dst.s_addr)
        !           245:                ip->ip_dst = p->ipopt_dst;
        !           246:        if (m->m_off >= MMAXOFF || MMINOFF + optlen > m->m_off) {
        !           247:                MGET(n, M_DONTWAIT, MT_HEADER);
        !           248:                if (n == 0)
        !           249:                        return (m);
        !           250:                m->m_len -= sizeof(struct ip);
        !           251:                m->m_off += sizeof(struct ip);
        !           252:                n->m_next = m;
        !           253:                m = n;
        !           254:                m->m_off = MMAXOFF - sizeof(struct ip) - optlen;
        !           255:                m->m_len = optlen + sizeof(struct ip);
        !           256:                bcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
        !           257:        } else {
        !           258:                m->m_off -= optlen;
        !           259:                m->m_len += optlen;
        !           260:                ovbcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
        !           261:        }
        !           262:        ip = mtod(m, struct ip *);
        !           263:        bcopy((caddr_t)p->ipopt_list, (caddr_t)(ip + 1), (unsigned)optlen);
        !           264:        *phlen = sizeof(struct ip) + optlen;
        !           265:        ip->ip_len += optlen;
        !           266:        return (m);
        !           267: }
        !           268: 
        !           269: /*
        !           270:  * Copy options from ip to jp.
        !           271:  * If off is 0 all options are copied
        !           272:  * otherwise copy selectively.
        !           273:  */
        !           274: ip_optcopy(ip, jp, off)
        !           275:        struct ip *ip, *jp;
        !           276:        int off;
        !           277: {
        !           278:        register u_char *cp, *dp;
        !           279:        int opt, optlen, cnt;
        !           280: 
        !           281:        cp = (u_char *)(ip + 1);
        !           282:        dp = (u_char *)(jp + 1);
        !           283:        cnt = (ip->ip_hl << 2) - sizeof (struct ip);
        !           284:        for (; cnt > 0; cnt -= optlen, cp += optlen) {
        !           285:                opt = cp[0];
        !           286:                if (opt == IPOPT_EOL)
        !           287:                        break;
        !           288:                if (opt == IPOPT_NOP)
        !           289:                        optlen = 1;
        !           290:                else
        !           291:                        optlen = cp[IPOPT_OLEN];
        !           292:                if (optlen > cnt)                       /* XXX */
        !           293:                        optlen = cnt;                   /* XXX */
        !           294:                if (off == 0 || IPOPT_COPIED(opt)) {
        !           295:                        bcopy((caddr_t)cp, (caddr_t)dp, (unsigned)optlen);
        !           296:                        dp += optlen;
        !           297:                }
        !           298:        }
        !           299:        for (optlen = dp - (u_char *)(jp+1); optlen & 0x3; optlen++)
        !           300:                *dp++ = IPOPT_EOL;
        !           301:        return (optlen);
        !           302: }
        !           303: 
        !           304: /*
        !           305:  * IP socket option processing.
        !           306:  */
        !           307: ip_ctloutput(op, so, level, optname, m)
        !           308:        int op;
        !           309:        struct socket *so;
        !           310:        int level, optname;
        !           311:        struct mbuf **m;
        !           312: {
        !           313:        int error = 0;
        !           314:        struct inpcb *inp = sotoinpcb(so);
        !           315: 
        !           316:        if (level != IPPROTO_IP)
        !           317:                error = EINVAL;
        !           318:        else switch (op) {
        !           319: 
        !           320:        case PRCO_SETOPT:
        !           321:                switch (optname) {
        !           322:                case IP_OPTIONS:
        !           323:                        return (ip_pcbopts(&inp->inp_options, *m));
        !           324: 
        !           325:                default:
        !           326:                        error = EINVAL;
        !           327:                        break;
        !           328:                }
        !           329:                break;
        !           330: 
        !           331:        case PRCO_GETOPT:
        !           332:                switch (optname) {
        !           333:                case IP_OPTIONS:
        !           334:                        *m = m_get(M_WAIT, MT_SOOPTS);
        !           335:                        if (inp->inp_options) {
        !           336:                                (*m)->m_off = inp->inp_options->m_off;
        !           337:                                (*m)->m_len = inp->inp_options->m_len;
        !           338:                                bcopy(mtod(inp->inp_options, caddr_t),
        !           339:                                    mtod(*m, caddr_t), (unsigned)(*m)->m_len);
        !           340:                        } else
        !           341:                                (*m)->m_len = 0;
        !           342:                        break;
        !           343:                default:
        !           344:                        error = EINVAL;
        !           345:                        break;
        !           346:                }
        !           347:                break;
        !           348:        }
        !           349:        if (op == PRCO_SETOPT)
        !           350:                (void)m_free(*m);
        !           351:        return (error);
        !           352: }
        !           353: 
        !           354: /*
        !           355:  * Set up IP options in pcb for insertion in output packets.
        !           356:  * Store in mbuf with pointer in pcbopt, adding pseudo-option
        !           357:  * with destination address if source routed.
        !           358:  */
        !           359: ip_pcbopts(pcbopt, m)
        !           360:        struct mbuf **pcbopt;
        !           361:        register struct mbuf *m;
        !           362: {
        !           363:        register cnt, optlen;
        !           364:        register u_char *cp;
        !           365:        u_char opt;
        !           366: 
        !           367:        /* turn off any old options */
        !           368:        if (*pcbopt)
        !           369:                (void)m_free(*pcbopt);
        !           370:        *pcbopt = 0;
        !           371:        if (m == (struct mbuf *)0 || m->m_len == 0) {
        !           372:                /*
        !           373:                 * Only turning off any previous options.
        !           374:                 */
        !           375:                if (m)
        !           376:                        (void)m_free(m);
        !           377:                return (0);
        !           378:        }
        !           379: 
        !           380: #ifndef        vax
        !           381:        if (m->m_len % sizeof(long))
        !           382:                goto bad;
        !           383: #endif
        !           384:        /*
        !           385:         * IP first-hop destination address will be stored before
        !           386:         * actual options; move other options back
        !           387:         * and clear it when none present.
        !           388:         */
        !           389: #if    MAX_IPOPTLEN >= MMAXOFF - MMINOFF
        !           390:        if (m->m_off + m->m_len + sizeof(struct in_addr) > MAX_IPOPTLEN)
        !           391:                goto bad;
        !           392: #else
        !           393:        if (m->m_off + m->m_len + sizeof(struct in_addr) > MMAXOFF)
        !           394:                goto bad;
        !           395: #endif
        !           396:        cnt = m->m_len;
        !           397:        m->m_len += sizeof(struct in_addr);
        !           398:        cp = mtod(m, u_char *) + sizeof(struct in_addr);
        !           399:        ovbcopy(mtod(m, caddr_t), (caddr_t)cp, (unsigned)cnt);
        !           400:        bzero(mtod(m, caddr_t), sizeof(struct in_addr));
        !           401: 
        !           402:        for (; cnt > 0; cnt -= optlen, cp += optlen) {
        !           403:                opt = cp[IPOPT_OPTVAL];
        !           404:                if (opt == IPOPT_EOL)
        !           405:                        break;
        !           406:                if (opt == IPOPT_NOP)
        !           407:                        optlen = 1;
        !           408:                else {
        !           409:                        optlen = cp[IPOPT_OLEN];
        !           410:                        if (optlen <= IPOPT_OLEN || optlen > cnt)
        !           411:                                goto bad;
        !           412:                }
        !           413:                switch (opt) {
        !           414: 
        !           415:                default:
        !           416:                        break;
        !           417: 
        !           418:                case IPOPT_LSRR:
        !           419:                case IPOPT_SSRR:
        !           420:                        /*
        !           421:                         * user process specifies route as:
        !           422:                         *      ->A->B->C->D
        !           423:                         * D must be our final destination (but we can't
        !           424:                         * check that since we may not have connected yet).
        !           425:                         * A is first hop destination, which doesn't appear in
        !           426:                         * actual IP option, but is stored before the options.
        !           427:                         */
        !           428:                        if (optlen < IPOPT_MINOFF - 1 + sizeof(struct in_addr))
        !           429:                                goto bad;
        !           430:                        m->m_len -= sizeof(struct in_addr);
        !           431:                        cnt -= sizeof(struct in_addr);
        !           432:                        optlen -= sizeof(struct in_addr);
        !           433:                        cp[IPOPT_OLEN] = optlen;
        !           434:                        /*
        !           435:                         * Move first hop before start of options.
        !           436:                         */
        !           437:                        bcopy((caddr_t)&cp[IPOPT_OFFSET+1], mtod(m, caddr_t),
        !           438:                            sizeof(struct in_addr));
        !           439:                        /*
        !           440:                         * Then copy rest of options back
        !           441:                         * to close up the deleted entry.
        !           442:                         */
        !           443:                        ovbcopy((caddr_t)(&cp[IPOPT_OFFSET+1] +
        !           444:                            sizeof(struct in_addr)),
        !           445:                            (caddr_t)&cp[IPOPT_OFFSET+1],
        !           446:                            (unsigned)cnt + sizeof(struct in_addr));
        !           447:                        break;
        !           448:                }
        !           449:        }
        !           450:        *pcbopt = m;
        !           451:        return (0);
        !           452: 
        !           453: bad:
        !           454:        (void)m_free(m);
        !           455:        return (EINVAL);
        !           456: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.