duplicate TIOCGPGRP for controller - minus the check for controlling terminal

[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 0e18353..cd844b8 100644 (file)
--- a/usr/src/sys/netinet/ip_output.c
+++ b/usr/src/sys/netinet/ip_output.c
@@ -1,12 +1,24 @@
 /*
 /*

- * Copyright (c) 1982, 1986 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+ * Copyright (c) 1982, 1986, 1988 Regents of the University of California.
+ * All rights reserved.

  *
  *

- *     @(#)ip_output.c 7.6 (Berkeley) %G%
+ * Redistribution and use in source and binary forms are permitted
+ * 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.18 (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"


@@ -17,14 +29,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();


@@ -35,20 +47,27 @@ 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);
+if ((m->m_flags & M_PKTHDR) == 0)
+panic("ip_output no HDR");
+       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.


@@ -58,9 +77,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.
         */


@@ -81,6 +101,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;
        }
        /*


@@ -88,9 +109,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) {


@@ -108,24 +128,18 @@ ip_output(m, opt, ro, flags)
                                error = ENETUNREACH;
                        goto bad;
                }
                                error = ENETUNREACH;
                        goto bad;
                }

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

                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


@@ -146,6 +160,7 @@ ip_output(m, opt, ro, flags)
                        error = EMSGSIZE;
                        goto bad;
                }
                        error = EMSGSIZE;
                        goto bad;
                }

+               m->m_flags |= M_BCAST;

        }
 
        /*
        }
 
        /*


@@ -156,10 +171,11 @@ ip_output(m, opt, ro, flags)
                ip->ip_off = htons((u_short)ip->ip_off);
                ip->ip_sum = 0;
                ip->ip_sum = in_cksum(m, hlen);
                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.


@@ -174,58 +190,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 < 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 >= ip->ip_len)
+                       len = 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 - 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;

 }
 
 /*
 }
 
 /*


@@ -247,20 +286,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 *);


@@ -271,13 +312,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;


@@ -293,9 +332,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;
                }


@@ -337,7 +377,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);


@@ -390,13 +429,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);


@@ -451,6 +485,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);