start rewrite

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

#define IMPLOOP
/*      ip_output.c     1.19    81/11/24        */

#include "../h/param.h"
#include "../h/mbuf.h"
#include "../h/mtpr.h"
#include "../h/socket.h"
#include "../h/socketvar.h"
#include "../net/inet.h"
#include "../net/inet_systm.h"
#include "../net/imp.h"
#include "../net/ip.h"
#include "../net/ip_var.h"

ip_output(m)
       struct mbuf *m;
{
       register struct ip *ip = mtod(m, struct ip *);
       int len, hlen = ip->ip_hl << 2, off;

COUNT(IP_OUTPUT);
       /*
        * Fill in IP header.
        */
       ip->ip_v = IPVERSION;
       ip->ip_hl = hlen >> 2;
       ip->ip_off &= IP_DF;
       ip->ip_id = ip_id++;

       /*
        * If small enough for interface, can just send directly.
        */
       if (ip->ip_len <= MTU) {
               ip_send(ip);
               return;
       }

       /*
        * Too large for interface; fragment if possible.
        * Must be able to put at least 8 bytes per fragment.
        */
       if (ip->ip_off & IP_DF)
               goto bad;
       len = (MTU-hlen) &~ 7;
       if (len < 8)
               goto bad;

       /*
        * Discard IP header from logical mbuf for m_copy's sake.
        * Loop through length of segment, make a copy of each
        * part and output.
        */
       m->m_len -= sizeof (struct ip);
       m->m_off += sizeof (struct ip);
       for (off = 0; off < ip->ip_len; off += len) {
               struct mbuf *mh = m_get(0);
               struct ip *mhip;

               if (mh == 0)
                       goto bad;
               mh->m_off = MMAXOFF - hlen;
               mhip = mtod(mh, 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;
               if (off + len >= ip->ip_len)
                       mhip->ip_len = ip->ip_len - off;
               else {
                       mhip->ip_len = len;
                       mhip->ip_off |= IP_MF;
               }
               mhip->ip_len += sizeof (struct ip);
               mh->m_next = m_copy(m, off, len);
               if (mh->m_next == 0) {
                       (void) m_free(mh);
                       goto bad;
               }
               ip_send(mhip);
       }
bad:
       m_freem(m);
}

/*
* Copy options from ip to jp.
* If off is 0 all options are copied
* otherwise copy selectively.
*/
ip_optcopy(ip, jp, off)
       struct ip *ip, *jp;
       int off;
{
       register u_char *cp, *dp;
       int opt, optlen, cnt;

COUNT(IP_OPTCOPY);
       cp = (u_char *)(ip + 1);
       dp = (u_char *)(jp + 1);
       cnt = (ip->ip_hl << 2) - sizeof (struct ip);
       for (; cnt > 0; cnt -= optlen, cp += optlen) {
               opt = cp[0];
               if (opt == IPOPT_EOL)
                       break;
               if (opt == IPOPT_NOP)
                       optlen = 1;
               else
                       optlen = cp[1];
               if (optlen > cnt)                       /* XXX */
                       optlen = cnt;                   /* XXX */
               if (off == 0 || IPOPT_COPIED(opt)) {
                       bcopy((caddr_t)cp, (caddr_t)dp, (unsigned)optlen);
                       dp += optlen;
               }
       }
       for (optlen = dp - (u_char *)(jp+1); optlen & 0x3; optlen++)
               *dp++ = IPOPT_EOL;
       return (optlen);
}

/* REST OF CODE HERE IS GARBAGE */

ip_send(ip)
       register struct ip *ip;
{
       register struct mbuf *m;
       register struct imp *l;
       int hlen = ip->ip_hl << 2;
       int s;
COUNT(IP_SEND);

       m = dtom(ip);
       l = (struct imp *)(mtod(m, caddr_t) - L1822);
       l->i_shost = ip->ip_src.s_host;
       l->i_dhost = ip->ip_dst.s_host;
       l->i_type = IPTYPE;
       ip->ip_sum = 0;
       ip->ip_len = htons((u_short)ip->ip_len);
       ip->ip_id = htons(ip->ip_id);
       ip->ip_off = htons((u_short)ip->ip_off);
       ip->ip_sum = inet_cksum(m, hlen);
       m->m_off -= L1822;
       m->m_len += L1822;
       m->m_act = NULL;
#ifndef IMPLOOP
       s = splimp();
       if (imp_stat.outq_head != NULL)
               imp_stat.outq_tail->m_act = m;
       else
               imp_stat.outq_head = m;
       imp_stat.outq_tail = m;
       splx(s);
       if (!imp_stat.outactive)
               enstart(0);
#else
       if (imp_stat.inq_head != NULL)
               imp_stat.inq_tail->m_act = m;
       else
               imp_stat.inq_head = m;
       imp_stat.inq_tail = m;
       setsoftnet();
#endif IMPLOOP
}

/* END GARBAGE */