projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
branch for network release (byte order #ifdefs)
[unix-history] / usr / src / sys / netinet / udp_usrreq.c
diff --git a/usr/src/sys/netinet/udp_usrreq.c b/usr/src/sys/netinet/udp_usrreq.c
index 41f00db..9245aa3 100644 (file)
--- a/usr/src/sys/netinet/udp_usrreq.c
+++ b/usr/src/sys/netinet/udp_usrreq.c
@@ -1,25 +1,38 @@
-/*     udp_usrreq.c    6.3     83/11/14        */
+/*
+ * Copyright (c) 1982, 1986 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that this notice is preserved and that due credit is given
+ * to the University of California at Berkeley. The name of the University
+ * may not be used to endorse or promote products derived from this
+ * software without specific prior written permission. This software
+ * is provided ``as is'' without express or implied warranty.
+ *
+ *     @(#)udp_usrreq.c        7.5 (Berkeley) %G%
+ */
 
 
-#include "../h/param.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/mbuf.h"
-#include "../h/protosw.h"
-#include "../h/socket.h"
-#include "../h/socketvar.h"
-#include "../h/errno.h"
+#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 "../net/if.h"
 #include "../net/route.h"
 
-#include "../netinet/in.h"
-#include "../netinet/in_pcb.h"
-#include "../netinet/in_systm.h"
-#include "../netinet/ip.h"
-#include "../netinet/ip_var.h"
-#include "../netinet/ip_icmp.h"
-#include "../netinet/udp.h"
-#include "../netinet/udp_var.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.
 
 /*
  * UDP protocol implementation.
@@ -31,16 +44,24 @@ udp_init()
        udb.inp_next = udb.inp_prev = &udb;
 }
 
        udb.inp_next = udb.inp_prev = &udb;
 }
 
-int    udpcksum = 0;
+#ifndef        COMPAT_42
+int    udpcksum = 1;
+#else
+int    udpcksum = 0;           /* XXX */
+#endif
+int    udp_ttl = UDP_TTL;
+
 struct sockaddr_in udp_in = { AF_INET };
 
 struct sockaddr_in udp_in = { AF_INET };
 
-udp_input(m0)
+udp_input(m0, ifp)
        struct mbuf *m0;
        struct mbuf *m0;
+       struct ifnet *ifp;
 {
        register struct udpiphdr *ui;
        register struct inpcb *inp;
        register struct mbuf *m;
        int len;
 {
        register struct udpiphdr *ui;
        register struct inpcb *inp;
        register struct mbuf *m;
        int len;
+       struct ip ip;
 
        /*
         * Get IP and UDP header together in first mbuf.
 
        /*
         * Get IP and UDP header together in first mbuf.
@@ -66,8 +87,12 @@ udp_input(m0)
                        goto bad;
                }
                m_adj(m, len - ((struct ip *)ui)->ip_len);
                        goto bad;
                }
                m_adj(m, len - ((struct ip *)ui)->ip_len);
-               /* (struct ip *)ui->ip_len = len; */
+               /* ((struct ip *)ui)->ip_len = len; */
        }
        }
+       /*
+        * Save a copy of the IP header in case we want restore it for ICMP.
+        */
+       ip = *(struct ip*)ui;
 
        /*
         * Checksum extended UDP header and data.
 
        /*
         * Checksum extended UDP header and data.
@@ -75,7 +100,7 @@ udp_input(m0)
        if (udpcksum && ui->ui_sum) {
                ui->ui_next = ui->ui_prev = 0;
                ui->ui_x1 = 0;
        if (udpcksum && ui->ui_sum) {
                ui->ui_next = ui->ui_prev = 0;
                ui->ui_x1 = 0;
-               ui->ui_len = htons((u_short)len);
+               ui->ui_len = ui->ui_ulen;
                if (ui->ui_sum = in_cksum(m, len + sizeof (struct ip))) {
                        udpstat.udps_badsum++;
                        m_freem(m);
                if (ui->ui_sum = in_cksum(m, len + sizeof (struct ip))) {
                        udpstat.udps_badsum++;
                        m_freem(m);
@@ -91,9 +116,11 @@ udp_input(m0)
                INPLOOKUP_WILDCARD);
        if (inp == 0) {
                /* don't send ICMP response for broadcast packet */
                INPLOOKUP_WILDCARD);
        if (inp == 0) {
                /* don't send ICMP response for broadcast packet */
-               if (in_lnaof(ui->ui_dst) == INADDR_ANY)
+               if (in_broadcast(ui->ui_dst))
                        goto bad;
                        goto bad;
-               icmp_error((struct ip *)ui, ICMP_UNREACH, ICMP_UNREACH_PORT);
+               *(struct ip *)ui = ip;
+               icmp_error((struct ip *)ui, ICMP_UNREACH, ICMP_UNREACH_PORT,
+                   ifp);
                return;
        }
 
                return;
        }
 
@@ -114,53 +141,62 @@ bad:
        m_freem(m);
 }
 
        m_freem(m);
 }
 
-udp_abort(inp)
-       struct inpcb *inp;
+/*
+ * Notify a udp user of an asynchronous error;
+ * just wake up so that he can collect error status.
+ */
+udp_notify(inp)
+       register struct inpcb *inp;
 {
 {
-       struct socket *so = inp->inp_socket;
 
 
-       in_pcbdisconnect(inp);
-       soisdisconnected(so);
+       sorwakeup(inp->inp_socket);
+       sowwakeup(inp->inp_socket);
 }
 
 }
 
-udp_ctlinput(cmd, arg)
+udp_ctlinput(cmd, sa)
        int cmd;
        int cmd;
-       caddr_t arg;
+       struct sockaddr *sa;
 {
 {
-       struct in_addr *sin;
        extern u_char inetctlerrmap[];
        extern u_char inetctlerrmap[];
+       struct sockaddr_in *sin;
+       int in_rtchange();
 
 
-       if (cmd < 0 || cmd > PRC_NCMDS)
+       if ((unsigned)cmd > PRC_NCMDS)
+               return;
+       if (sa->sa_family != AF_INET && sa->sa_family != AF_IMPLINK)
+               return;
+       sin = (struct sockaddr_in *)sa;
+       if (sin->sin_addr.s_addr == INADDR_ANY)
                return;
                return;
-       switch (cmd) {
 
 
-       case PRC_ROUTEDEAD:
-               break;
+       switch (cmd) {
 
        case PRC_QUENCH:
                break;
 
 
        case PRC_QUENCH:
                break;
 
-       /* these are handled by ip */
-       case PRC_IFDOWN:
-       case PRC_HOSTDEAD:
-       case PRC_HOSTUNREACH:
+       case PRC_ROUTEDEAD:
+       case PRC_REDIRECT_NET:
+       case PRC_REDIRECT_HOST:
+       case PRC_REDIRECT_TOSNET:
+       case PRC_REDIRECT_TOSHOST:
+               in_pcbnotify(&udb, &sin->sin_addr, 0, in_rtchange);
                break;
 
        default:
                break;
 
        default:
-               sin = &((struct icmp *)arg)->icmp_ip.ip_dst;
-               in_pcbnotify(&udb, sin, (int)inetctlerrmap[cmd], udp_abort);
+               if (inetctlerrmap[cmd] == 0)
+                       return;         /* XXX */
+               in_pcbnotify(&udb, &sin->sin_addr, (int)inetctlerrmap[cmd],
+                       udp_notify);
        }
 }
 
 udp_output(inp, m0)
        }
 }
 
 udp_output(inp, m0)
-       struct inpcb *inp;
+       register struct inpcb *inp;
        struct mbuf *m0;
 {
        register struct mbuf *m;
        register struct udpiphdr *ui;
        struct mbuf *m0;
 {
        register struct mbuf *m;
        register struct udpiphdr *ui;
-       register struct socket *so;
        register int len = 0;
        register int len = 0;
-       int flags;
 
        /*
         * Calculate data length and get a mbuf
 
        /*
         * Calculate data length and get a mbuf
@@ -168,7 +204,7 @@ udp_output(inp, m0)
         */
        for (m = m0; m; m = m->m_next)
                len += m->m_len;
         */
        for (m = m0; m; m = m->m_next)
                len += m->m_len;
-       m = m_get(M_DONTWAIT, MT_HEADER);
+       MGET(m, M_DONTWAIT, MT_HEADER);
        if (m == 0) {
                m_freem(m0);
                return (ENOBUFS);
        if (m == 0) {
                m_freem(m0);
                return (ENOBUFS);
@@ -196,15 +232,19 @@ udp_output(inp, m0)
         * Stuff checksum and output datagram.
         */
        ui->ui_sum = 0;
         * Stuff checksum and output datagram.
         */
        ui->ui_sum = 0;
-       if ((ui->ui_sum = in_cksum(m, sizeof (struct udpiphdr) + len)) == 0)
-               ui->ui_sum = -1;
+       if (udpcksum) {
+           if ((ui->ui_sum = in_cksum(m, sizeof (struct udpiphdr) + len)) == 0)
+               ui->ui_sum = 0xffff;
+       }
        ((struct ip *)ui)->ip_len = sizeof (struct udpiphdr) + len;
        ((struct ip *)ui)->ip_len = sizeof (struct udpiphdr) + len;
-       ((struct ip *)ui)->ip_ttl = MAXTTL;
-       so = inp->inp_socket;
-       flags = (so->so_options & SO_DONTROUTE) | (so->so_state & SS_PRIV);
-       return (ip_output(m, (struct mbuf *)0, (struct route *)0, flags));
+       ((struct ip *)ui)->ip_ttl = udp_ttl;
+       return (ip_output(m, inp->inp_options, &inp->inp_route,
+           inp->inp_socket->so_options & (SO_DONTROUTE | 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;
 /*ARGSUSED*/
 udp_usrreq(so, req, m, nam, rights)
        struct socket *so;
@@ -214,6 +254,9 @@ udp_usrreq(so, req, m, nam, rights)
        struct inpcb *inp = sotoinpcb(so);
        int error = 0;
 
        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 (rights && rights->m_len) {
                error = EINVAL;
                goto release;
@@ -232,16 +275,12 @@ udp_usrreq(so, req, m, nam, rights)
                error = in_pcballoc(so, &udb);
                if (error)
                        break;
                error = in_pcballoc(so, &udb);
                if (error)
                        break;
-               error = soreserve(so, 2048, 2048);
+               error = soreserve(so, udp_sendspace, udp_recvspace);
                if (error)
                        break;
                break;
 
        case PRU_DETACH:
                if (error)
                        break;
                break;
 
        case PRU_DETACH:
-               if (inp == NULL) {
-                       error = ENOTCONN;
-                       break;
-               }
                in_pcbdetach(inp);
                break;
 
                in_pcbdetach(inp);
                break;
 
@@ -277,7 +316,7 @@ udp_usrreq(so, req, m, nam, rights)
                        break;
                }
                in_pcbdisconnect(inp);
                        break;
                }
                in_pcbdisconnect(inp);
-               soisdisconnected(so);
+               so->so_state &= ~SS_ISCONNECTED;                /* XXX */
                break;
 
        case PRU_SHUTDOWN:
                break;
 
        case PRU_SHUTDOWN:
@@ -286,6 +325,7 @@ udp_usrreq(so, req, m, nam, rights)
 
        case PRU_SEND: {
                struct in_addr laddr;
 
        case PRU_SEND: {
                struct in_addr laddr;
+               int s;
 
                if (nam) {
                        laddr = inp->inp_laddr;
 
                if (nam) {
                        laddr = inp->inp_laddr;
@@ -293,9 +333,15 @@ udp_usrreq(so, req, m, nam, rights)
                                error = EISCONN;
                                break;
                        }
                                error = EISCONN;
                                break;
                        }
+                       /*
+                        * Must block input while temporarily connected.
+                        */
+                       s = splnet();
                        error = in_pcbconnect(inp, nam);
                        error = in_pcbconnect(inp, nam);
-                       if (error)
+                       if (error) {
+                               splx(s);
                                break;
                                break;
+                       }
                } else {
                        if (inp->inp_faddr.s_addr == INADDR_ANY) {
                                error = ENOTCONN;
                } else {
                        if (inp->inp_faddr.s_addr == INADDR_ANY) {
                                error = ENOTCONN;
@@ -307,14 +353,14 @@ udp_usrreq(so, req, m, nam, rights)
                if (nam) {
                        in_pcbdisconnect(inp);
                        inp->inp_laddr = laddr;
                if (nam) {
                        in_pcbdisconnect(inp);
                        inp->inp_laddr = laddr;
+                       splx(s);
                }
                }
                break;
 
        case PRU_ABORT:
                }
                }
                break;
 
        case PRU_ABORT:
-               in_pcbdetach(inp);
-               sofree(so);
                soisdisconnected(so);
                soisdisconnected(so);
+               in_pcbdetach(inp);
                break;
 
        case PRU_SOCKADDR:
                break;
 
        case PRU_SOCKADDR:
@@ -325,17 +371,12 @@ udp_usrreq(so, req, m, nam, rights)
                in_setpeeraddr(inp, nam);
                break;
 
                in_setpeeraddr(inp, nam);
                break;
 
-       case PRU_CONTROL:
-               m = NULL;
-               error = EOPNOTSUPP;
-               break;
-
        case PRU_SENSE:
        case PRU_SENSE:
-               m = NULL;
-               /* fall thru... */
+               /*
+                * stat: don't bother with a blocksize.
+                */
+               return (0);
 
 
-       case PRU_RCVD:
-       case PRU_RCVOOB:
        case PRU_SENDOOB:
        case PRU_FASTTIMO:
        case PRU_SLOWTIMO:
        case PRU_SENDOOB:
        case PRU_FASTTIMO:
        case PRU_SLOWTIMO:
@@ -344,6 +385,10 @@ udp_usrreq(so, req, m, nam, rights)
                error =  EOPNOTSUPP;
                break;
 
                error =  EOPNOTSUPP;
                break;
 
+       case PRU_RCVD:
+       case PRU_RCVOOB:
+               return (EOPNOTSUPP);    /* do not free mbuf's */
+
        default:
                panic("udp_usrreq");
        }
        default:
                panic("udp_usrreq");
        }
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.