v_count => v_usecount; v_lastr is being used; v_mounton is gone;

[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 4c406e6..75331ff 100644 (file)
--- a/usr/src/sys/netinet/ip_output.c
+++ b/usr/src/sys/netinet/ip_output.c
@@ -1,18 +1,24 @@
 /*
 /*

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

  * All rights reserved.
  *
  * Redistribution and use in source and binary forms are permitted
  * 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.
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, 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'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

  *
  *

- *     @(#)ip_output.c 7.9 (Berkeley) %G%
+ *     @(#)ip_output.c 7.16 (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"


@@ -30,7 +36,7 @@
 #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();


@@ -55,6 +61,8 @@ ip_output(m0, opt, ro, flags)
        struct route iproute;
        struct sockaddr_in *dst;
 
        struct route iproute;
        struct sockaddr_in *dst;
 

+if ((m->m_flags & M_PKTHDR) == 0)
+panic("ip_output no HDR");

        if (opt) {
                m = ip_insertoptions(m, opt, &len);
                hlen = len;
        if (opt) {
                m = ip_insertoptions(m, opt, &len);
                hlen = len;


@@ -68,9 +76,10 @@ ip_output(m0, 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.
         */


@@ -91,6 +100,7 @@ ip_output(m0, 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;
        }
        /*


@@ -100,7 +110,7 @@ ip_output(m0, opt, ro, flags)
        if (flags & IP_ROUTETOIF) {
                struct in_ifaddr *ia;
 
        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) {


@@ -120,7 +130,7 @@ ip_output(m0, opt, ro, flags)
                }
                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
        /*
        }
 #ifndef notdef
        /*


@@ -156,6 +166,7 @@ ip_output(m0, opt, ro, flags)
                        error = EMSGSIZE;
                        goto bad;
                }
                        error = EMSGSIZE;
                        goto bad;
                }

+               m->m_flags |= M_BCAST;

        }
 
        /*
        }
 
        /*


@@ -169,7 +180,7 @@ ip_output(m0, opt, ro, flags)
                error = (*ifp->if_output)(ifp, m, (struct sockaddr *)dst);
                goto done;
        }
                error = (*ifp->if_output)(ifp, m, (struct sockaddr *)dst);
                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.


@@ -186,7 +197,7 @@ ip_output(m0, opt, ro, flags)
 
     {
        int mhlen, firstlen = len;
 
     {
        int mhlen, firstlen = len;

-       struct mbuf **mnext = &m->m_act;
+       struct mbuf **mnext = &m->m_nextpkt;

 
        /*
         * Loop through length of segment after first fragment,
 
        /*
         * Loop through length of segment after first fragment,


@@ -195,12 +206,12 @@ ip_output(m0, opt, ro, flags)
        m0 = m;
        mhlen = sizeof (struct ip);
        for (off = hlen + len; off < ip->ip_len; off += len) {
        m0 = m;
        mhlen = sizeof (struct ip);
        for (off = hlen + len; off < ip->ip_len; off += len) {

-               MGET(m, M_DONTWAIT, MT_HEADER);
+               MGETHDR(m, M_DONTWAIT, MT_HEADER);

                if (m == 0) {
                        error = ENOBUFS;
                if (m == 0) {
                        error = ENOBUFS;

-                       goto bad;
+                       goto sendorfree;

                }
                }

-               m->m_off = MMAXOFF - hlen;
+               m->m_data += max_linkhdr;

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


@@ -221,25 +232,29 @@ ip_output(m0, opt, ro, flags)
                        error = ENOBUFS;        /* ??? */
                        goto sendorfree;
                }
                        error = ENOBUFS;        /* ??? */
                        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_sum = in_cksum(m, mhlen);
                *mnext = m;
                mhip->ip_off = htons((u_short)mhip->ip_off);
                mhip->ip_sum = 0;
                mhip->ip_sum = in_cksum(m, mhlen);
                *mnext = m;

-               mnext = &m->m_act;
+               mnext = &m->m_nextpkt;
+               ipstat.ips_ofragments++;

        }
        /*
         * Update first fragment by trimming what's been copied out
         * and updating header, then send each fragment (in order).
         */
        m_adj(m0, hlen + firstlen - ip->ip_len);
        }
        /*
         * Update first fragment by trimming what's been copied out
         * and updating header, then send each fragment (in order).
         */
        m_adj(m0, hlen + firstlen - ip->ip_len);

-       ip->ip_len = hlen + firstlen;
-       ip->ip_off |= IP_MF;
+       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(m0, hlen);
 sendorfree:
        for (m = m0; m; m = m0) {
        ip->ip_sum = 0;
        ip->ip_sum = in_cksum(m0, hlen);
 sendorfree:
        for (m = m0; m; m = m0) {

-               m0 = m->m_act;
-               m->m_act = 0;
+               m0 = m->m_nextpkt;
+               m->m_nextpkt = 0;

                if (error == 0)
                        error = (*ifp->if_output)(ifp, m,
                            (struct sockaddr *)dst);
                if (error == 0)
                        error = (*ifp->if_output)(ifp, m,
                            (struct sockaddr *)dst);


@@ -275,20 +290,22 @@ ip_insertoptions(m, opt, phlen)
        optlen = opt->m_len - sizeof(p->ipopt_dst);
        if (p->ipopt_dst.s_addr)
                ip->ip_dst = p->ipopt_dst;
        optlen = opt->m_len - sizeof(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 *);


@@ -364,7 +381,6 @@ ip_ctloutput(op, so, level, optname, m)
                case IP_OPTIONS:
                        *m = m_get(M_WAIT, MT_SOOPTS);
                        if (inp->inp_options) {
                case IP_OPTIONS:
                        *m = m_get(M_WAIT, MT_SOOPTS);
                        if (inp->inp_options) {

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

                                (*m)->m_len = inp->inp_options->m_len;
                                bcopy(mtod(inp->inp_options, caddr_t),
                                    mtod(*m, caddr_t), (unsigned)(*m)->m_len);
                                (*m)->m_len = inp->inp_options->m_len;
                                bcopy(mtod(inp->inp_options, caddr_t),
                                    mtod(*m, caddr_t), (unsigned)(*m)->m_len);


@@ -417,13 +433,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)
-               goto bad;
-#else
-       if (m->m_off + m->m_len + sizeof(struct in_addr) > MMAXOFF)
+       if (m->m_data + m->m_len + sizeof(struct in_addr) >= &m->m_dat[MLEN])

                goto bad;
                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);


@@ -478,6 +489,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);