fix autoconf, move code to isa.c, remove debugging, drop redundant tlbflushes, macros...

[unix-history] / usr / src / sys / netinet / ip_output.c

diff --git a/usr/src/sys/netinet/ip_output.c b/usr/src/sys/netinet/ip_output.c
index 567b519..3177ef0 100644 (file)
--- a/usr/src/sys/netinet/ip_output.c
+++ b/usr/src/sys/netinet/ip_output.c
@@ -1,18 +1,14 @@
 /*
 /*

- * Copyright (c) 1982, 1986 Regents of the University of California.
+ * Copyright (c) 1982, 1986, 1988, 1990 Regents of the University of California.

  * All rights reserved.
  *
  * All rights reserved.
  *

- * Redistribution and use in source and binary forms are permitted
- * provided that this notice is preserved and that due credit is given
- * to the University of California at Berkeley. The name of the University
- * may not be used to endorse or promote products derived from this
- * software without specific prior written permission. This software
- * is provided ``as is'' without express or implied warranty.
+ * %sccs.include.redist.c%

  *
  *

- *     @(#)ip_output.c 7.7 (Berkeley) %G%
+ *     @(#)ip_output.c 7.23 (Berkeley) %G%

  */
 
 #include "param.h"
  */
 
 #include "param.h"

+#include "malloc.h"

 #include "mbuf.h"
 #include "errno.h"
 #include "protosw.h"
 #include "mbuf.h"
 #include "errno.h"
 #include "protosw.h"


@@ -23,14 +19,14 @@
 #include "../net/route.h"
 
 #include "in.h"
 #include "../net/route.h"
 
 #include "in.h"

-#include "in_pcb.h"

 #include "in_systm.h"
 #include "in_systm.h"

-#include "in_var.h"

 #include "ip.h"
 #include "ip.h"

+#include "in_pcb.h"
+#include "in_var.h"

 #include "ip_var.h"
 
 #ifdef vax
 #include "ip_var.h"
 
 #ifdef vax

-#include "../machine/mtpr.h"
+#include "machine/mtpr.h"

 #endif
 
 struct mbuf *ip_insertoptions();
 #endif
 
 struct mbuf *ip_insertoptions();


@@ -41,20 +37,29 @@ struct mbuf *ip_insertoptions();
  * The mbuf chain containing the packet will be freed.
  * The mbuf opt, if present, will not be freed.
  */
  * The mbuf chain containing the packet will be freed.
  * The mbuf opt, if present, will not be freed.
  */

-ip_output(m, opt, ro, flags)
-       struct mbuf *m;
+ip_output(m0, opt, ro, flags)
+       struct mbuf *m0;

        struct mbuf *opt;
        struct route *ro;
        int flags;
 {
        struct mbuf *opt;
        struct route *ro;
        int flags;
 {

-       register struct ip *ip;
+       register struct ip *ip, *mhip;

        register struct ifnet *ifp;
        register struct ifnet *ifp;

-       int len, hlen = sizeof (struct ip), off, error = 0;
+       register struct mbuf *m = m0;
+       register int hlen = sizeof (struct ip);
+       int len, off, error = 0;

        struct route iproute;
        struct sockaddr_in *dst;
        struct route iproute;
        struct sockaddr_in *dst;

+       struct in_ifaddr *ia;

 
 

-       if (opt)
-               m = ip_insertoptions(m, opt, &hlen);
+#ifdef DIAGNOSTIC
+       if ((m->m_flags & M_PKTHDR) == 0)
+               panic("ip_output no HDR");
+#endif
+       if (opt) {
+               m = ip_insertoptions(m, opt, &len);
+               hlen = len;
+       }

        ip = mtod(m, struct ip *);
        /*
         * Fill in IP header.
        ip = mtod(m, struct ip *);
        /*
         * Fill in IP header.


@@ -64,9 +69,10 @@ ip_output(m, opt, ro, flags)
                ip->ip_off &= IP_DF;
                ip->ip_id = htons(ip_id++);
                ip->ip_hl = hlen >> 2;
                ip->ip_off &= IP_DF;
                ip->ip_id = htons(ip_id++);
                ip->ip_hl = hlen >> 2;

-       } else
+       } else {

                hlen = ip->ip_hl << 2;
                hlen = ip->ip_hl << 2;

-
+               ipstat.ips_localout++;
+       }

        /*
         * Route packet.
         */
        /*
         * Route packet.
         */


@@ -87,6 +93,7 @@ ip_output(m, opt, ro, flags)
        }
        if (ro->ro_rt == 0) {
                dst->sin_family = AF_INET;
        }
        if (ro->ro_rt == 0) {
                dst->sin_family = AF_INET;

+               dst->sin_len = sizeof(*dst);

                dst->sin_addr = ip->ip_dst;
        }
        /*
                dst->sin_addr = ip->ip_dst;
        }
        /*


@@ -94,9 +101,8 @@ ip_output(m, opt, ro, flags)
         * short circuit routing lookup.
         */
        if (flags & IP_ROUTETOIF) {
         * short circuit routing lookup.
         */
        if (flags & IP_ROUTETOIF) {

-               struct in_ifaddr *ia;

 
 

-               ia = (struct in_ifaddr *)ifa_ifwithdstaddr(dst);
+               ia = (struct in_ifaddr *)ifa_ifwithdstaddr((struct sockaddr *)dst);

                if (ia == 0)
                        ia = in_iaonnetof(in_netof(ip->ip_dst));
                if (ia == 0) {
                if (ia == 0)
                        ia = in_iaonnetof(in_netof(ip->ip_dst));
                if (ia == 0) {


@@ -107,31 +113,23 @@ ip_output(m, opt, ro, flags)
        } else {
                if (ro->ro_rt == 0)
                        rtalloc(ro);
        } else {
                if (ro->ro_rt == 0)
                        rtalloc(ro);

-               if (ro->ro_rt == 0 || (ifp = ro->ro_rt->rt_ifp) == 0) {
-                       if (in_localaddr(ip->ip_dst))
-                               error = EHOSTUNREACH;
-                       else
-                               error = ENETUNREACH;
+               if (ro->ro_rt == 0) {
+                       error = EHOSTUNREACH;

                        goto bad;
                }
                        goto bad;
                }

+               ia = (struct in_ifaddr *)ro->ro_rt->rt_ifa;
+               ifp = ro->ro_rt->rt_ifp;

                ro->ro_rt->rt_use++;
                if (ro->ro_rt->rt_flags & RTF_GATEWAY)
                ro->ro_rt->rt_use++;
                if (ro->ro_rt->rt_flags & RTF_GATEWAY)

-                       dst = (struct sockaddr_in *)&ro->ro_rt->rt_gateway;
+                       dst = (struct sockaddr_in *)ro->ro_rt->rt_gateway;

        }
 #ifndef notdef
        /*
         * If source address not specified yet, use address
         * of outgoing interface.
         */
        }
 #ifndef notdef
        /*
         * If source address not specified yet, use address
         * of outgoing interface.
         */

-       if (ip->ip_src.s_addr == INADDR_ANY) {
-               register struct in_ifaddr *ia;
-
-               for (ia = in_ifaddr; ia; ia = ia->ia_next)
-                       if (ia->ia_ifp == ifp) {
-                               ip->ip_src = IA_SIN(ia)->sin_addr;
-                               break;
-                       }
-       }
+       if (ip->ip_src.s_addr == INADDR_ANY)
+               ip->ip_src = IA_SIN(ia)->sin_addr;

 #endif
        /*
         * Look for broadcast address and
 #endif
        /*
         * Look for broadcast address and


@@ -148,24 +146,26 @@ ip_output(m, opt, ro, flags)
                        goto bad;
                }
                /* don't allow broadcast messages to be fragmented */
                        goto bad;
                }
                /* don't allow broadcast messages to be fragmented */

-               if (ip->ip_len > ifp->if_mtu) {
+               if ((u_short)ip->ip_len > ifp->if_mtu) {

                        error = EMSGSIZE;
                        goto bad;
                }
                        error = EMSGSIZE;
                        goto bad;
                }

+               m->m_flags |= M_BCAST;

        }
 
        /*
         * If small enough for interface, can just send directly.
         */
        }
 
        /*
         * If small enough for interface, can just send directly.
         */

-       if (ip->ip_len <= ifp->if_mtu) {
+       if ((u_short)ip->ip_len <= ifp->if_mtu) {

                ip->ip_len = htons((u_short)ip->ip_len);
                ip->ip_off = htons((u_short)ip->ip_off);
                ip->ip_sum = 0;
                ip->ip_sum = in_cksum(m, hlen);
                ip->ip_len = htons((u_short)ip->ip_len);
                ip->ip_off = htons((u_short)ip->ip_off);
                ip->ip_sum = 0;
                ip->ip_sum = in_cksum(m, hlen);

-               error = (*ifp->if_output)(ifp, m, (struct sockaddr *)dst);
+               error = (*ifp->if_output)(ifp, m,
+                               (struct sockaddr *)dst, ro->ro_rt);

                goto done;
        }
                goto done;
        }

-
+       ipstat.ips_fragmented++;

        /*
         * Too large for interface; fragment if possible.
         * Must be able to put at least 8 bytes per fragment.
        /*
         * Too large for interface; fragment if possible.
         * Must be able to put at least 8 bytes per fragment.


@@ -180,58 +180,81 @@ ip_output(m, opt, ro, flags)
                goto bad;
        }
 
                goto bad;
        }
 

+    {
+       int mhlen, firstlen = len;
+       struct mbuf **mnext = &m->m_nextpkt;
+

        /*
        /*

-        * Discard IP header from logical mbuf for m_copy's sake.
-        * Loop through length of segment, make a copy of each
-        * part and output.
+        * Loop through length of segment after first fragment,
+        * make new header and copy data of each part and link onto chain.

         */
         */

-       m->m_len -= sizeof (struct ip);
-       m->m_off += sizeof (struct ip);
-       for (off = 0; off < ip->ip_len-hlen; off += len) {
-               struct mbuf *mh = m_get(M_DONTWAIT, MT_HEADER);
-               struct ip *mhip;
-
-               if (mh == 0) {
+       m0 = m;
+       mhlen = sizeof (struct ip);
+       for (off = hlen + len; off < (u_short)ip->ip_len; off += len) {
+               MGETHDR(m, M_DONTWAIT, MT_HEADER);
+               if (m == 0) {

                        error = ENOBUFS;
                        error = ENOBUFS;

-                       goto bad;
+                       goto sendorfree;

                }
                }

-               mh->m_off = MMAXOFF - hlen;
-               mhip = mtod(mh, struct ip *);
+               m->m_data += max_linkhdr;
+               mhip = mtod(m, struct ip *);

                *mhip = *ip;
                if (hlen > sizeof (struct ip)) {
                *mhip = *ip;
                if (hlen > sizeof (struct ip)) {

-                       int olen = ip_optcopy(ip, mhip, off);
-                       mh->m_len = sizeof (struct ip) + olen;
-               } else
-                       mh->m_len = sizeof (struct ip);
-               mhip->ip_off = (off >> 3) + (ip->ip_off & ~IP_MF);
+                       mhlen = ip_optcopy(ip, mhip) + sizeof (struct ip);
+                       mhip->ip_hl = mhlen >> 2;
+               }
+               m->m_len = mhlen;
+               mhip->ip_off = ((off - hlen) >> 3) + (ip->ip_off & ~IP_MF);

                if (ip->ip_off & IP_MF)
                        mhip->ip_off |= IP_MF;
                if (ip->ip_off & IP_MF)
                        mhip->ip_off |= IP_MF;

-               if (off + len >= ip->ip_len-hlen)
-                       len = mhip->ip_len = ip->ip_len - hlen - off;
-               else {
-                       mhip->ip_len = len;
+               if (off + len >= (u_short)ip->ip_len)
+                       len = (u_short)ip->ip_len - off;
+               else

                        mhip->ip_off |= IP_MF;
                        mhip->ip_off |= IP_MF;

-               }
-               mhip->ip_len += sizeof (struct ip);
-               mhip->ip_len = htons((u_short)mhip->ip_len);
-               mh->m_next = m_copy(m, off, len);
-               if (mh->m_next == 0) {
-                       (void) m_free(mh);
+               mhip->ip_len = htons((u_short)(len + mhlen));
+               m->m_next = m_copy(m0, off, len);
+               if (m->m_next == 0) {

                        error = ENOBUFS;        /* ??? */
                        error = ENOBUFS;        /* ??? */

-                       goto bad;
+                       goto sendorfree;

                }
                }

+               m->m_pkthdr.len = mhlen + len;
+               m->m_pkthdr.rcvif = (struct ifnet *)0;

                mhip->ip_off = htons((u_short)mhip->ip_off);
                mhip->ip_sum = 0;
                mhip->ip_off = htons((u_short)mhip->ip_off);
                mhip->ip_sum = 0;

-               mhip->ip_sum = in_cksum(mh, hlen);
-               if (error = (*ifp->if_output)(ifp, mh, (struct sockaddr *)dst))
-                       break;
+               mhip->ip_sum = in_cksum(m, mhlen);
+               *mnext = m;
+               mnext = &m->m_nextpkt;
+               ipstat.ips_ofragments++;

        }
        }

-bad:
-       m_freem(m);
+       /*
+        * Update first fragment by trimming what's been copied out
+        * and updating header, then send each fragment (in order).
+        */
+       m = m0;
+       m_adj(m, hlen + firstlen - (u_short)ip->ip_len);
+       m->m_pkthdr.len = hlen + firstlen;
+       ip->ip_len = htons((u_short)m->m_pkthdr.len);
+       ip->ip_off = htons((u_short)(ip->ip_off | IP_MF));
+       ip->ip_sum = 0;
+       ip->ip_sum = in_cksum(m, hlen);
+sendorfree:
+       for (m = m0; m; m = m0) {
+               m0 = m->m_nextpkt;
+               m->m_nextpkt = 0;
+               if (error == 0)
+                       error = (*ifp->if_output)(ifp, m,
+                           (struct sockaddr *)dst, ro->ro_rt);
+               else
+                       m_freem(m);
+       }
+    }

 done:
        if (ro == &iproute && (flags & IP_ROUTETOIF) == 0 && ro->ro_rt)
                RTFREE(ro->ro_rt);
        return (error);
 done:
        if (ro == &iproute && (flags & IP_ROUTETOIF) == 0 && ro->ro_rt)
                RTFREE(ro->ro_rt);
        return (error);

+bad:
+       m_freem(m0);
+       goto done;

 }
 
 /*
 }
 
 /*


@@ -251,22 +274,26 @@ ip_insertoptions(m, opt, phlen)
        unsigned optlen;
 
        optlen = opt->m_len - sizeof(p->ipopt_dst);
        unsigned optlen;
 
        optlen = opt->m_len - sizeof(p->ipopt_dst);

+       if (optlen + (u_short)ip->ip_len > IP_MAXPACKET)
+               return (m);             /* XXX should fail */

        if (p->ipopt_dst.s_addr)
                ip->ip_dst = p->ipopt_dst;
        if (p->ipopt_dst.s_addr)
                ip->ip_dst = p->ipopt_dst;

-       if (m->m_off >= MMAXOFF || MMINOFF + optlen > m->m_off) {
-               MGET(n, M_DONTWAIT, MT_HEADER);
+       if (m->m_flags & M_EXT || m->m_data - optlen < m->m_pktdat) {
+               MGETHDR(n, M_DONTWAIT, MT_HEADER);

                if (n == 0)
                        return (m);
                if (n == 0)
                        return (m);

+               n->m_pkthdr.len = m->m_pkthdr.len + optlen;

                m->m_len -= sizeof(struct ip);
                m->m_len -= sizeof(struct ip);

-               m->m_off += sizeof(struct ip);
+               m->m_data += sizeof(struct ip);

                n->m_next = m;
                m = n;
                n->m_next = m;
                m = n;

-               m->m_off = MMAXOFF - sizeof(struct ip) - optlen;

                m->m_len = optlen + sizeof(struct ip);
                m->m_len = optlen + sizeof(struct ip);

+               m->m_data += max_linkhdr;

                bcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
        } else {
                bcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
        } else {

-               m->m_off -= optlen;
+               m->m_data -= optlen;

                m->m_len += optlen;
                m->m_len += optlen;

+               m->m_pkthdr.len += optlen;

                ovbcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
        }
        ip = mtod(m, struct ip *);
                ovbcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
        }
        ip = mtod(m, struct ip *);


@@ -277,13 +304,11 @@ ip_insertoptions(m, opt, phlen)
 }
 
 /*
 }
 
 /*

- * Copy options from ip to jp.
- * If off is 0 all options are copied
- * otherwise copy selectively.
+ * Copy options from ip to jp,
+ * omitting those not copied during fragmentation.

  */
  */

-ip_optcopy(ip, jp, off)
+ip_optcopy(ip, jp)

        struct ip *ip, *jp;
        struct ip *ip, *jp;

-       int off;

 {
        register u_char *cp, *dp;
        int opt, optlen, cnt;
 {
        register u_char *cp, *dp;
        int opt, optlen, cnt;


@@ -299,9 +324,10 @@ ip_optcopy(ip, jp, off)
                        optlen = 1;
                else
                        optlen = cp[IPOPT_OLEN];
                        optlen = 1;
                else
                        optlen = cp[IPOPT_OLEN];

-               if (optlen > cnt)                       /* XXX */
-                       optlen = cnt;                   /* XXX */
-               if (off == 0 || IPOPT_COPIED(opt)) {
+               /* bogus lengths should have been caught by ip_dooptions */
+               if (optlen > cnt)
+                       optlen = cnt;
+               if (IPOPT_COPIED(opt)) {

                        bcopy((caddr_t)cp, (caddr_t)dp, (unsigned)optlen);
                        dp += optlen;
                }
                        bcopy((caddr_t)cp, (caddr_t)dp, (unsigned)optlen);
                        dp += optlen;
                }


@@ -314,14 +340,16 @@ ip_optcopy(ip, jp, off)
 /*
  * IP socket option processing.
  */
 /*
  * IP socket option processing.
  */

-ip_ctloutput(op, so, level, optname, m)
+ip_ctloutput(op, so, level, optname, mp)

        int op;
        struct socket *so;
        int level, optname;
        int op;
        struct socket *so;
        int level, optname;

-       struct mbuf **m;
+       struct mbuf **mp;

 {
 {

+       register struct inpcb *inp = sotoinpcb(so);
+       register struct mbuf *m = *mp;
+       register int optval;

        int error = 0;
        int error = 0;

-       struct inpcb *inp = sotoinpcb(so);

 
        if (level != IPPROTO_IP)
                error = EINVAL;
 
        if (level != IPPROTO_IP)
                error = EINVAL;


@@ -330,34 +358,114 @@ ip_ctloutput(op, so, level, optname, m)
        case PRCO_SETOPT:
                switch (optname) {
                case IP_OPTIONS:
        case PRCO_SETOPT:
                switch (optname) {
                case IP_OPTIONS:

-                       return (ip_pcbopts(&inp->inp_options, *m));
+#ifdef notyet
+               case IP_RETOPTS:
+                       return (ip_pcbopts(optname, &inp->inp_options, m));
+#else
+                       return (ip_pcbopts(&inp->inp_options, m));
+#endif
+
+               case IP_TOS:
+               case IP_TTL:
+               case IP_RECVOPTS:
+               case IP_RECVRETOPTS:
+               case IP_RECVDSTADDR:
+                       if (m->m_len != sizeof(int))
+                               error = EINVAL;
+                       else {
+                               optval = *mtod(m, int *);
+                               switch (optname) {
+
+                               case IP_TOS:
+                                       inp->inp_ip.ip_tos = optval;
+                                       break;
+
+                               case IP_TTL:
+                                       inp->inp_ip.ip_ttl = optval;
+                                       break;
+#define        OPTSET(bit) \
+       if (optval) \
+               inp->inp_flags |= bit; \
+       else \
+               inp->inp_flags &= ~bit;
+
+                               case IP_RECVOPTS:
+                                       OPTSET(INP_RECVOPTS);
+                                       break;
+
+                               case IP_RECVRETOPTS:
+                                       OPTSET(INP_RECVRETOPTS);
+                                       break;
+
+                               case IP_RECVDSTADDR:
+                                       OPTSET(INP_RECVDSTADDR);
+                                       break;
+                               }
+                       }
+                       break;
+#undef OPTSET

 
                default:
                        error = EINVAL;
                        break;
                }
 
                default:
                        error = EINVAL;
                        break;
                }

+               if (m)
+                       (void)m_free(m);

                break;
 
        case PRCO_GETOPT:
                switch (optname) {
                case IP_OPTIONS:
                break;
 
        case PRCO_GETOPT:
                switch (optname) {
                case IP_OPTIONS:

-                       *m = m_get(M_WAIT, MT_SOOPTS);
+               case IP_RETOPTS:
+                       *mp = m = m_get(M_WAIT, MT_SOOPTS);

                        if (inp->inp_options) {
                        if (inp->inp_options) {

-                               (*m)->m_off = inp->inp_options->m_off;
-                               (*m)->m_len = inp->inp_options->m_len;
+                               m->m_len = inp->inp_options->m_len;

                                bcopy(mtod(inp->inp_options, caddr_t),
                                bcopy(mtod(inp->inp_options, caddr_t),

-                                   mtod(*m, caddr_t), (unsigned)(*m)->m_len);
+                                   mtod(m, caddr_t), (unsigned)m->m_len);

                        } else
                        } else

-                               (*m)->m_len = 0;
+                               m->m_len = 0;

                        break;
                        break;

+
+               case IP_TOS:
+               case IP_TTL:
+               case IP_RECVOPTS:
+               case IP_RECVRETOPTS:
+               case IP_RECVDSTADDR:
+                       *mp = m = m_get(M_WAIT, MT_SOOPTS);
+                       m->m_len = sizeof(int);
+                       switch (optname) {
+
+                       case IP_TOS:
+                               optval = inp->inp_ip.ip_tos;
+                               break;
+
+                       case IP_TTL:
+                               optval = inp->inp_ip.ip_ttl;
+                               break;
+
+#define        OPTBIT(bit)     (inp->inp_flags & bit ? 1 : 0)
+
+                       case IP_RECVOPTS:
+                               optval = OPTBIT(INP_RECVOPTS);
+                               break;
+
+                       case IP_RECVRETOPTS:
+                               optval = OPTBIT(INP_RECVRETOPTS);
+                               break;
+
+                       case IP_RECVDSTADDR:
+                               optval = OPTBIT(INP_RECVDSTADDR);
+                               break;
+                       }
+                       *mtod(m, int *) = optval;
+                       break;
+

                default:
                        error = EINVAL;
                        break;
                }
                break;
        }
                default:
                        error = EINVAL;
                        break;
                }
                break;
        }

-       if (op == PRCO_SETOPT && *m)
-               (void)m_free(*m);

        return (error);
 }
 
        return (error);
 }
 


@@ -366,7 +474,12 @@ ip_ctloutput(op, so, level, optname, m)
  * Store in mbuf with pointer in pcbopt, adding pseudo-option
  * with destination address if source routed.
  */
  * Store in mbuf with pointer in pcbopt, adding pseudo-option
  * with destination address if source routed.
  */

+#ifdef notyet
+ip_pcbopts(optname, pcbopt, m)
+       int optname;
+#else

 ip_pcbopts(pcbopt, m)
 ip_pcbopts(pcbopt, m)

+#endif

        struct mbuf **pcbopt;
        register struct mbuf *m;
 {
        struct mbuf **pcbopt;
        register struct mbuf *m;
 {


@@ -396,13 +509,8 @@ ip_pcbopts(pcbopt, m)
         * actual options; move other options back
         * and clear it when none present.
         */
         * actual options; move other options back
         * and clear it when none present.
         */

-#if    MAX_IPOPTLEN >= MMAXOFF - MMINOFF
-       if (m->m_off + m->m_len + sizeof(struct in_addr) > MAX_IPOPTLEN)
+       if (m->m_data + m->m_len + sizeof(struct in_addr) >= &m->m_dat[MLEN])

                goto bad;
                goto bad;

-#else
-       if (m->m_off + m->m_len + sizeof(struct in_addr) > MMAXOFF)
-               goto bad;
-#endif

        cnt = m->m_len;
        m->m_len += sizeof(struct in_addr);
        cp = mtod(m, u_char *) + sizeof(struct in_addr);
        cnt = m->m_len;
        m->m_len += sizeof(struct in_addr);
        cp = mtod(m, u_char *) + sizeof(struct in_addr);


@@ -457,6 +565,8 @@ ip_pcbopts(pcbopt, m)
                        break;
                }
        }
                        break;
                }
        }

+       if (m->m_len > MAX_IPOPTLEN + sizeof(struct in_addr))
+               goto bad;

        *pcbopt = m;
        return (0);
 
        *pcbopt = m;
        return (0);