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

/*      udp_usrreq.c    6.13    85/05/27        */

#include "param.h"
#include "dir.h"
#include "user.h"
#include "mbuf.h"
#include "protosw.h"
#include "socket.h"
#include "socketvar.h"
#include "errno.h"
#include "stat.h"

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

#include "in.h"
#include "in_pcb.h"
#include "in_systm.h"
#include "ip.h"
#include "ip_var.h"
#include "ip_icmp.h"
#include "udp.h"
#include "udp_var.h"

/*
* UDP protocol implementation.
* Per RFC 768, August, 1980.
*/
udp_init()
{

       udb.inp_next = udb.inp_prev = &udb;
}

int     udpcksum = 1;
struct  sockaddr_in udp_in = { AF_INET };

udp_input(m0)
       struct mbuf *m0;
{
       register struct udpiphdr *ui;
       register struct inpcb *inp;
       register struct mbuf *m;
       int len;

       /*
        * Get IP and UDP header together in first mbuf.
        */
       m = m0;
       if ((m->m_off > MMAXOFF || m->m_len < sizeof (struct udpiphdr)) &&
           (m = m_pullup(m, sizeof (struct udpiphdr))) == 0) {
               udpstat.udps_hdrops++;
               return;
       }
       ui = mtod(m, struct udpiphdr *);
       if (((struct ip *)ui)->ip_hl > (sizeof (struct ip) >> 2))
               ip_stripoptions((struct ip *)ui, (struct mbuf *)0);

       /*
        * Make mbuf data length reflect UDP length.
        * If not enough data to reflect UDP length, drop.
        */
       len = ntohs((u_short)ui->ui_ulen);
       if (((struct ip *)ui)->ip_len != len) {
               if (len > ((struct ip *)ui)->ip_len) {
                       udpstat.udps_badlen++;
                       goto bad;
               }
               m_adj(m, len - ((struct ip *)ui)->ip_len);
               /* (struct ip *)ui->ip_len = len; */
       }

       /*
        * Checksum extended UDP header and data.
        */
       if (udpcksum && ui->ui_sum) {
               ui->ui_next = ui->ui_prev = 0;
               ui->ui_x1 = 0;
               ui->ui_len = ui->ui_ulen;
               if (ui->ui_sum = in_cksum(m, len + sizeof (struct ip))) {
                       udpstat.udps_badsum++;
                       m_freem(m);
                       return;
               }
       }

       /*
        * Locate pcb for datagram.
        */
       inp = in_pcblookup(&udb,
           ui->ui_src, ui->ui_sport, ui->ui_dst, ui->ui_dport,
               INPLOOKUP_WILDCARD);
       if (inp == 0) {
               /* don't send ICMP response for broadcast packet */
               if (in_broadcast(ui->ui_dst))
                       goto bad;
               icmp_error((struct ip *)ui, ICMP_UNREACH, ICMP_UNREACH_PORT);
               return;
       }

       /*
        * Construct sockaddr format source address.
        * Stuff source address and datagram in user buffer.
        */
       udp_in.sin_port = ui->ui_sport;
       udp_in.sin_addr = ui->ui_src;
       m->m_len -= sizeof (struct udpiphdr);
       m->m_off += sizeof (struct udpiphdr);
       if (sbappendaddr(&inp->inp_socket->so_rcv, (struct sockaddr *)&udp_in,
           m, (struct mbuf *)0) == 0)
               goto bad;
       sorwakeup(inp->inp_socket);
       return;
bad:
       m_freem(m);
}

udp_abort(inp)
       struct inpcb *inp;
{
       struct socket *so = inp->inp_socket;

       in_pcbdisconnect(inp);
       soisdisconnected(so);
}

udp_ctlinput(cmd, arg)
       int cmd;
       caddr_t arg;
{
       struct in_addr *sin;
       extern u_char inetctlerrmap[];

       if (cmd < 0 || cmd > PRC_NCMDS)
               return;
       switch (cmd) {

       case PRC_ROUTEDEAD:
               break;

       case PRC_QUENCH:
               break;

       /* these are handled by ip */
       case PRC_IFDOWN:
       case PRC_HOSTDEAD:
       case PRC_HOSTUNREACH:
               break;

       default:
               sin = &((struct icmp *)arg)->icmp_ip.ip_dst;
               in_pcbnotify(&udb, sin, (int)inetctlerrmap[cmd], udp_abort);
       }
}

udp_output(inp, m0)
       struct inpcb *inp;
       struct mbuf *m0;
{
       register struct mbuf *m;
       register struct udpiphdr *ui;
       register struct socket *so;
       register int len = 0;
       register struct route *ro;

       /*
        * Calculate data length and get a mbuf
        * for UDP and IP headers.
        */
       for (m = m0; m; m = m->m_next)
               len += m->m_len;
       MGET(m, M_DONTWAIT, MT_HEADER);
       if (m == 0) {
               m_freem(m0);
               return (ENOBUFS);
       }

       /*
        * Fill in mbuf with extended UDP header
        * and addresses and length put into network format.
        */
       m->m_off = MMAXOFF - sizeof (struct udpiphdr);
       m->m_len = sizeof (struct udpiphdr);
       m->m_next = m0;
       ui = mtod(m, struct udpiphdr *);
       ui->ui_next = ui->ui_prev = 0;
       ui->ui_x1 = 0;
       ui->ui_pr = IPPROTO_UDP;
       ui->ui_len = htons((u_short)len + sizeof (struct udphdr));
       ui->ui_src = inp->inp_laddr;
       ui->ui_dst = inp->inp_faddr;
       ui->ui_sport = inp->inp_lport;
       ui->ui_dport = inp->inp_fport;
       ui->ui_ulen = ui->ui_len;

       /*
        * Stuff checksum and output datagram.
        */
       ui->ui_sum = 0;
       if (udpcksum) {
           if ((ui->ui_sum = in_cksum(m, sizeof (struct udpiphdr) + len)) == 0)
               ui->ui_sum = -1;
       }
       ((struct ip *)ui)->ip_len = sizeof (struct udpiphdr) + len;
       ((struct ip *)ui)->ip_ttl = MAXTTL;
       so = inp->inp_socket;
       if (so->so_options & SO_DONTROUTE)
               return (ip_output(m, (struct mbuf *)0, (struct route *)0,
                   (so->so_options & SO_BROADCAST) | IP_ROUTETOIF));
       /*
        * Use cached route for previous datagram if
        * this is also to the same destination. 
        *
        * NB: We don't handle broadcasts because that
        *     would require 3 subroutine calls.
        */
       ro = &inp->inp_route;
#define satosin(sa)     ((struct sockaddr_in *)(sa))
       if (ro->ro_rt &&
           satosin(&ro->ro_dst)->sin_addr.s_addr != ui->ui_dst.s_addr) {
               RTFREE(ro->ro_rt);
               ro->ro_rt = (struct rtentry *)0;
       }
       return (ip_output(m, (struct mbuf *)0, ro, 
           so->so_options & SO_BROADCAST));
}

int     udp_sendspace = 2048;           /* really max datagram size */
int     udp_recvspace = 4 * (1024+sizeof(struct sockaddr_in)); /* 4 1K dgrams */

/*ARGSUSED*/
udp_usrreq(so, req, m, nam, rights)
       struct socket *so;
       int req;
       struct mbuf *m, *nam, *rights;
{
       struct inpcb *inp = sotoinpcb(so);
       int error = 0;

       if (req == PRU_CONTROL)
               return (in_control(so, (int)m, (caddr_t)nam,
                       (struct ifnet *)rights));
       if (rights && rights->m_len) {
               error = EINVAL;
               goto release;
       }
       if (inp == NULL && req != PRU_ATTACH) {
               error = EINVAL;
               goto release;
       }
       switch (req) {

       case PRU_ATTACH:
               if (inp != NULL) {
                       error = EINVAL;
                       break;
               }
               error = in_pcballoc(so, &udb);
               if (error)
                       break;
               error = soreserve(so, udp_sendspace, udp_recvspace);
               if (error)
                       break;
               break;

       case PRU_DETACH:
               if (inp == NULL) {
                       error = ENOTCONN;
                       break;
               }
               in_pcbdetach(inp);
               break;

       case PRU_BIND:
               error = in_pcbbind(inp, nam);
               break;

       case PRU_LISTEN:
               error = EOPNOTSUPP;
               break;

       case PRU_CONNECT:
               if (inp->inp_faddr.s_addr != INADDR_ANY) {
                       error = EISCONN;
                       break;
               }
               error = in_pcbconnect(inp, nam);
               if (error == 0)
                       soisconnected(so);
               break;

       case PRU_CONNECT2:
               error = EOPNOTSUPP;
               break;

       case PRU_ACCEPT:
               error = EOPNOTSUPP;
               break;

       case PRU_DISCONNECT:
               if (inp->inp_faddr.s_addr == INADDR_ANY) {
                       error = ENOTCONN;
                       break;
               }
               in_pcbdisconnect(inp);
               soisdisconnected(so);
               break;

       case PRU_SHUTDOWN:
               socantsendmore(so);
               break;

       case PRU_SEND: {
               struct in_addr laddr;
               int s;

               if (nam) {
                       laddr = inp->inp_laddr;
                       if (inp->inp_faddr.s_addr != INADDR_ANY) {
                               error = EISCONN;
                               break;
                       }
                       /*
                        * Must block input while temporarily connected.
                        */
                       s = splnet();
                       error = in_pcbconnect(inp, nam);
                       if (error) {
                               splx(s);
                               break;
                       }
               } else {
                       if (inp->inp_faddr.s_addr == INADDR_ANY) {
                               error = ENOTCONN;
                               break;
                       }
               }
               error = udp_output(inp, m);
               m = NULL;
               if (nam) {
                       in_pcbdisconnect(inp);
                       inp->inp_laddr = laddr;
                       splx(s);
               }
               }
               break;

       case PRU_ABORT:
               in_pcbdetach(inp);
               sofree(so);
               soisdisconnected(so);
               break;

       case PRU_SOCKADDR:
               in_setsockaddr(inp, nam);
               break;

       case PRU_PEERADDR:
               in_setpeeraddr(inp, nam);
               break;

       case PRU_SENSE:
               /*
                * stat: don't bother with a blocksize.
                */
               return (0);

       case PRU_SENDOOB:
       case PRU_FASTTIMO:
       case PRU_SLOWTIMO:
       case PRU_PROTORCV:
       case PRU_PROTOSEND:
               error =  EOPNOTSUPP;
               break;

       case PRU_RCVD:
       case PRU_RCVOOB:
               return (EOPNOTSUPP);    /* do not free mbuf's */

       default:
               panic("udp_usrreq");
       }
release:
       if (m != NULL)
               m_freem(m);
       return (error);
}