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 26d0b82..cd844b8 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.10 (Berkeley) %G%
+ *     @(#)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"


@@ -23,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();


@@ -54,7 +60,10 @@ ip_output(m0, opt, ro, flags)
        int len, off, error = 0;
        struct route iproute;
        struct sockaddr_in *dst;
        int len, off, error = 0;
        struct route iproute;
        struct sockaddr_in *dst;

+       struct in_ifaddr *ia;

 
 

+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 +77,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 +101,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;
        }
        /*


@@ -98,9 +109,8 @@ ip_output(m0, 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) {


@@ -118,24 +128,18 @@ ip_output(m0, 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


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

+               m->m_flags |= M_BCAST;

        }
 
        /*
        }
 
        /*


@@ -166,10 +171,11 @@ ip_output(m0, 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.


@@ -186,7 +192,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 +201,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,28 +227,33 @@ 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).
         */
        }
        /*
         * 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 = htons((u_short)(hlen + firstlen));
+       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_off = htons((u_short)(ip->ip_off | IP_MF));
        ip->ip_sum = 0;

-       ip->ip_sum = in_cksum(m0, hlen);
+       ip->ip_sum = in_cksum(m, hlen);

 sendorfree:
        for (m = m0; m; m = m0) {
 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,
                if (error == 0)
                        error = (*ifp->if_output)(ifp, m,

-                           (struct sockaddr *)dst);
+                           (struct sockaddr *)dst, ro->ro_rt);

                else
                        m_freem(m);
        }
                else
                        m_freem(m);
        }


@@ -275,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 *);


@@ -364,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);


@@ -417,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);


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