move net addresses from interface to protocol layer;

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

/*      ip_output.c     6.7     85/03/18        */

#include "param.h"
#include "mbuf.h"
#include "errno.h"
#include "socket.h"
#include "socketvar.h"

#include "../net/if.h"
#include "../net/route.h"

#include "in.h"
#include "in_systm.h"
#include "in_var.h"
#include "ip.h"
#include "ip_var.h"

#ifdef vax
#include "../vax/mtpr.h"
#endif

ip_output(m, opt, ro, flags)
       struct mbuf *m;
       struct mbuf *opt;
       struct route *ro;
       int flags;
{
       register struct ip *ip = mtod(m, struct ip *);
       register struct ifnet *ifp;
       int len, hlen = sizeof (struct ip), off, error = 0;
       struct route iproute;
       struct sockaddr_in *dst;

       if (opt)                                /* XXX */
               (void) m_free(opt);             /* XXX */
       /*
        * Fill in IP header.
        */
       if ((flags & IP_FORWARDING) == 0) {
               ip->ip_v = IPVERSION;
               ip->ip_off &= IP_DF;
               ip->ip_id = htons(ip_id++);
               ip->ip_hl = hlen >> 2;
       }

       /*
        * Route packet.
        */
       if (ro == 0) {
               ro = &iproute;
               bzero((caddr_t)ro, sizeof (*ro));
       }
       dst = (struct sockaddr_in *)&ro->ro_dst;
       if (ro->ro_rt == 0) {
               dst->sin_family = AF_INET;
               dst->sin_addr = ip->ip_dst;
               /*
                * If routing to interface only,
                * short circuit routing lookup.
                */
               if (flags & IP_ROUTETOIF) {
                       struct in_ifaddr *ia;
                       ia = in_iaonnetof(in_netof(ip->ip_dst));
                       if (ia == 0) {
                               error = ENETUNREACH;
                               goto bad;
                       }
                       ifp = ia->ia_ifp;
                       goto gotif;
               }
               rtalloc(ro);
       } else if ((ro->ro_rt->rt_flags & RTF_UP) == 0) {
               /*
                * The old route has gone away; try for a new one.
                */
               rtfree(ro->ro_rt);
               ro->ro_rt = NULL;
               rtalloc(ro);
       }
       if (ro->ro_rt == 0 || (ifp = ro->ro_rt->rt_ifp) == 0) {
               error = ENETUNREACH;
               goto bad;
       }
       ro->ro_rt->rt_use++;
       if (ro->ro_rt->rt_flags & (RTF_GATEWAY|RTF_HOST))
               dst = (struct sockaddr_in *)&ro->ro_rt->rt_gateway;
gotif:
       /*
        * Look for broadcast address and
        * and verify user is allowed to send
        * such a packet.
        */
       if (in_broadcast(dst->sin_addr)) {
               if ((ifp->if_flags & IFF_BROADCAST) == 0) {
                       error = EADDRNOTAVAIL;
                       goto bad;
               }
               if ((flags & IP_ALLOWBROADCAST) == 0) {
                       error = EACCES;
                       goto bad;
               }
               /* don't allow broadcast messages to be fragmented */
               if (ip->ip_len > ifp->if_mtu) {
                       error = EMSGSIZE;
                       goto bad;
               }
       }

       /*
        * If small enough for interface, can just send directly.
        */
       if (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);
               error = (*ifp->if_output)(ifp, m, (struct sockaddr *)dst);
               goto done;
       }

       /*
        * Too large for interface; fragment if possible.
        * Must be able to put at least 8 bytes per fragment.
        */
       if (ip->ip_off & IP_DF) {
               error = EMSGSIZE;
               goto bad;
       }
       len = (ifp->if_mtu - hlen) &~ 7;
       if (len < 8) {
               error = EMSGSIZE;
               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-hlen; off += len) {
               struct mbuf *mh = m_get(M_DONTWAIT, MT_HEADER);
               struct ip *mhip;

               if (mh == 0) {
                       error = ENOBUFS;
                       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 >> 3;
               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;
                       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);
                       error = ENOBUFS;        /* ??? */
                       goto bad;
               }
               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;
       }
bad:
       m_freem(m);
done:
       if (ro == &iproute && (flags & IP_ROUTETOIF) == 0 && ro->ro_rt)
               RTFREE(ro->ro_rt);
       return (error);
}

/*
* 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;

       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);
}