properly free mbuf space

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

/*      ip_icmp.c       4.13    82/04/07        */

#include "../h/param.h"
#include "../h/systm.h"
#include "../h/mbuf.h"
#include "../h/protosw.h"
#include "../h/clock.h"
#include "../net/in.h"
#include "../net/in_systm.h"
#include "../net/ip.h"
#include "../net/ip_icmp.h"

/*
* ICMP routines: error generation, receive packet processing, and
* routines to turnaround packets back to the originator, and
* host table maintenance routines.
*/

/*
* Generate an error packet of type error in response to bad packet ip.
*/
icmp_error(oip, type, code)
       struct ip *oip;
       int type;
{
       unsigned oiplen = oip->ip_hl << 2;
       struct icmp *icp = (struct icmp *)((int)oip + oiplen);
       struct mbuf *m;
       struct ip *nip;
COUNT(ICMP_ERROR);

       /*
        * Make sure that the old IP packet had 8 bytes of data to return;
        * if not, don't bother.  Also don't EVER error if the old
        * packet protocol was ICMP.
        */
       if (oip->ip_len - oiplen < 8 || oip->ip_p == IPPROTO_ICMP)
               goto free;

       /*
        * Get a new mbuf, and fill in a ICMP header at the bottom
        * of the mbuf, followed by the old IP header and 8 bytes
        * of its data.
        */
       m = m_get(M_DONTWAIT);
       if (m == 0)
               goto free;
       m->m_off = MMAXOFF - (oiplen + 8);
       icp->icmp_type = type;
       if (type == ICMP_PARAMPROB) {
               icp->icmp_code = 0;
               icp->icmp_pptr = code;
       } else
               icp->icmp_code = code;
       bcopy((caddr_t)oip, (caddr_t)&icp->icmp_ip, oiplen + 8);

       /*
        * Now prepend an IP header and reflect this packet back to
        * the source.
        */
       m->m_off -= sizeof (struct ip);
       m->m_len += sizeof (struct ip);
       nip = (struct ip *)mtod(m, struct ip *);
       *nip = *oip;
       icmp_reflect(nip);

free:
       /*
        * Discard mbufs of original datagram
        */
       m_freem(dtom(oip));
}

/*
* Process a received ICMP message.
*/
icmp_input(m)
       struct mbuf *m;
{
       register struct icmp *icp;
       register struct ip *ip = mtod(m, struct ip *);
       int hlen = ip->ip_hl << 2;
       int icmplen = ip->ip_len - hlen;
       int i;
       extern u_char ip_protox[];
COUNT(ICMP_INPUT);

       /*
        * Locate icmp structure in mbuf, and check
        * that not corrupted and of at least minimum length.
        */
       m->m_len -= hlen;
       m->m_off += hlen;
       /* need routine to make sure header is in this mbuf here */
       icp = (struct icmp *)mtod(m, struct icmp *);
       i = icp->icmp_cksum;
       icp->icmp_cksum = 0;
       if (i != in_cksum(m, icmplen) || icmplen < ICMP_MINLEN)
               goto free;

       /*
        * Message type specific processing.
        */
       switch (icp->icmp_type) {

       case ICMP_UNREACH:
       case ICMP_TIMXCEED:
       case ICMP_PARAMPROB:
       case ICMP_SOURCEQUENCH:
       case ICMP_REDIRECT:
               /*
                * Problem with previous datagram; advise
                * higher level routines.
                */
               if (icmplen < ICMP_ADVLENMIN || icmplen < ICMP_ADVLEN(icp))
                       goto free;
               (*protosw[ip_protox[ip->ip_p]].pr_ctlinput)(m);
               goto free;

       case ICMP_ECHO:
               icp->icmp_type = ICMP_ECHOREPLY;
               goto reflect;

       case ICMP_TSTAMP:
               if (icmplen < ICMP_TSLEN)
                       goto free;
               icp->icmp_type = ICMP_TSTAMPREPLY;
               icp->icmp_rtime = iptime();
               icp->icmp_ttime = icp->icmp_rtime;      /* bogus, do later! */
               goto reflect;
               
       case ICMP_IREQ:
               /* fill in source address zero fields! */
               goto reflect;

       case ICMP_ECHOREPLY:
       case ICMP_TSTAMPREPLY:
       case ICMP_IREQREPLY:
               if (icmplen < ICMP_ADVLENMIN || icmplen < ICMP_ADVLEN(icp))
                       goto free;
               icmp_gotreply(icp);
               goto free;

       default:
               goto free;
       }
reflect:
       icmp_reflect(ip);
free:
       m_freem(dtom(ip));
}

/*
* Reflect the ip packet back to the source
*/
icmp_reflect(ip)
       struct ip *ip;
{
       struct in_addr t;
COUNT(ICMP_REFLECT);

       t = ip->ip_src; ip->ip_dst = ip->ip_src; ip->ip_src = t;
       /*
        * This is a little naive... do we have to munge the options
        * to reverse source routing?
        */
       icmp_send(ip);
}

/*
* Send an icmp packet back to the ip level, after
* supplying a checksum.
*/
icmp_send(ip)
       struct ip *ip;
{
COUNT(ICMP_SEND);

       m_freem(dtom(ip));
}

icmp_ctlinput(m)
       struct mbuf *m;
{
COUNT(ICMP_CTLINPUT);

       m_freem(m);
}

/*
* Got a reply, e.g. to an echo message or a timestamp
* message; nothing is done with these yet.
*/
/*ARGSUSED*/
icmp_gotreply(icp)
       struct icmp *icp;
{

COUNT(ICMP_GOTREPLY);
}

icmp_drain()
{

COUNT(ICMP_DRAIN);
}

n_time
iptime()
{
       int s = spl6();
       u_long t;

COUNT(IPTIME);
       t = (time % SECDAY) * 1000 + lbolt * hz;
       splx(s);
       return (htonl(t));
}