usr/src/sys/deprecated/bbnnet/udp.c

#ifdef RCSIDENT
static char rcsident[] = "$Header: udp.c,v 1.18 85/07/31 09:44:10 walsh Exp $";
#endif


#include "../h/param.h"
#include "../h/systm.h"
#include "../h/dir.h"
#include "../h/user.h"
#include "../h/mbuf.h"
#include "../h/socket.h"
#include "../h/socketvar.h"
#include "../h/syslog.h"

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

#include "../bbnnet/in.h"
#include "../bbnnet/in_var.h"
#include "../bbnnet/net.h"
#include "../bbnnet/ip.h"
#include "../bbnnet/udp.h"
#include "../bbnnet/in_pcb.h"
#include "../bbnnet/icmp.h"
#ifdef HMPTRAPS
#include "../bbnnet/hmp_traps.h"
#endif

#ifdef RCSIDENT
static char rcsudphdr[] = RCSUDPHDR;
#endif

extern int nosum;

struct inpcb udp;
struct udp_stat udpstat;

/*
 *  Process incoming udp messages.  Called directly from ip_input.
 *  User sees udp header with pseudo-header which overlays ip header
 *  (defined in udp.h).
 */
udp_input(mp)
register struct mbuf *mp;
{
    register struct udp *p;
    register struct inpcb *inp;
    register u_short i, j, ulen;

    udpstat.u_total ++;
    /*
     * see ip_input()
     */
    if ((mp->m_off > MMAXOFF) || (mp->m_len < sizeof(struct udp)))
    {
        if ((mp = m_pullup(mp, sizeof(struct udp))) == NULL)
        {
            udpstat.u_tooshort ++;
            return;
        }
    }

    p = mtod(mp, struct udp *);
    ulen = ((struct ip *) p) ->ip_len; /* ip_input() set to amt IP data */
    mp->m_off += sizeof p->u_x;
    mp->m_len -= sizeof p->u_x;
    p->u_x1 = 0;

    if (ntohs(p->u_len) != ulen)
    {
        /*
         * u_ilen overlays IP checksum, which is now zero.
         * ulen is the actual number of bytes we got on input
         * from IP; u_len is what UDP says we should have
         * (sizeof(udp_specific) + datalen)
         */
        log(LOG_WARNING, "UDP len %d, but got %d\n", ntohs(p->u_len), ulen);
        netlog (mp);
        return;
    }
    p->u_ilen = p->u_len;

    /*
     * Do checksum calculation.  Assumes pseudo-header passed up from
     * IP level and finished above.
     * Zero checksum on send means no checksum was generated.
     */
    if ((i = p->u_sum) != 0)
    {
        p->u_sum = 0;
        j = (u_short) in_cksum(mp, (int) (ulen + UDPCKSIZE));
        /*
         * Remember that zero is special, and compensate for this.
         */
        if (j == 0)
            j = (~j);
        if (i != j)
        {
            udpstat.u_badsum++;
            if (! nosum)
            {
#ifdef HMPTRAPS
                /* hmp_trap(T_UDP_CKSUM, (caddr_t)0,0); */
#endif
                inet_cksum_err ("udp", (struct ip *) p, (u_long) i, (u_long) j);
                netlog(mp);
                return;
            }
        }
    }

    inp = in_pcblookup(&udp, p->u_s.s_addr, (u_short)0,
                             p->u_d.s_addr, p->u_dst, TRUE);

    /* if a user is found, queue the data, otherwise drop it */

    if (inp != NULL)
    {
        struct sockaddr_in udpsock;
        struct sockbuf *sorcv;

        /*
         * throw away entire IP and UDP leaders.
         * user gets address separately.
         */
        mp->m_off += sizeof (struct udp) - sizeof (p->u_x);
        mp->m_len -= sizeof (struct udp) - sizeof (p->u_x);

        udpsock.sin_family = AF_INET;
        udpsock.sin_port = p->u_src;
        udpsock.sin_addr = p->u_s;
        udpsock.sin_zero[0] = udpsock.sin_zero[1] = 0;

        sorcv = &inp->inp_socket->so_rcv;

        if (! sbappendaddr(sorcv, (struct sockaddr *)&udpsock, mp,
            (struct mbuf *) NULL))
        {
            m_freem(mp);
            if ((ulen - UDPSIZE + sizeof(struct sockaddr)) > sbspace(sorcv))
                udpstat.u_sonospace ++;
            else
                udpstat.u_nobuf ++;
        }
        else
            sorwakeup(inp->inp_socket);
    }
    else
    {
        /*
         * No one wants this packet.
         */
        if (!in_broadcast(p->u_s) && !in_broadcast(p->u_d))
            /*
             * Don't bother everyone on the net.  Someone else may
             * provide the service (port).
             */
            ic_errmsg (icmp_addr((struct ip *) p), p->u_s,
                ICMP_UNRCH, ICMP_UNRCH_PORT, 0,
                sizeof(struct ip) + ICMP_ERRLEN, (char *) p);

        udpstat.u_drops++;
        m_freem(mp);
    }
}

/*
 * Output a udp message.  Called from udp_usrreq().
 */
udp_output(inp, mp)
struct inpcb *inp;
register struct mbuf *mp;
{
    register struct udp *p;
    register struct mbuf *m;
    register int len;

    len = 0;
    for (m = mp; m; m = m->m_next)
        len += m->m_len;

    /*
     * find a place to put the IP/UDP headers.
     */
    m = m_get(M_WAIT, MT_HEADER);
    if (m == 0)
    {
        m_freem(mp);
        return (ENOBUFS);
    }
    m->m_next = mp;
    mp = m;

    /*
     * Compose header in first mbuf.  Get addresses and ports
     * from ucb, add in pseudo-header fields for checksum.
     * Ensure header is aligned for memory access speed...
     */
    mp->m_off = (MMAXOFF - sizeof(struct udp)) & ~(sizeof(long) -1);
    mp->m_len = sizeof(struct udp);
    p = mtod(mp, struct udp *);

    /* stuff UDP fields */
    p->u_src = inp->inp_lport;
    p->u_dst = inp->inp_fport;
    p->u_len = htons((u_short)len+UDPSIZE);

    /* and "IP" fields */
    ((struct ip *) p)->ip_tos = 0;      /* for ip_send() */
    p->u_x1 = 0;
    p->u_pr = IPPROTO_UDP;
    p->u_ilen = p->u_len;
    p->u_s = inp->inp_laddr;
    p->u_d = inp->inp_faddr;

    /* Do checksum.  Include pseudo header. */
    mp->m_off += sizeof p->u_x;
    mp->m_len -= sizeof p->u_x;
    p->u_sum = 0;
    p->u_sum = in_cksum(mp, len + sizeof(struct udp) - sizeof p->u_x);
    if (p->u_sum == 0)
        /* Zero is reserved for unsummed packets */
        p->u_sum = (~ p->u_sum);
    mp->m_off -= sizeof p->u_x;
    mp->m_len += sizeof p->u_x;

    /*
     * Now send the packet via IP.
     */
    return(ip_send(inp, mp, len+UDPSIZE, FALSE));
}