-/* udp_usrreq.c 4.30 82/06/20 */
-
-#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 "../net/in.h"
+/* 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 "../net/in_pcb.h"
-#include "../net/in_systm.h"
-#include "../net/ip.h"
-#include "../net/ip_var.h"
-#include "../net/ip_icmp.h"
-#include "../net/udp.h"
-#include "../net/udp_var.h"
-#include <errno.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.
udb.inp_next = udb.inp_prev = &udb;
}
-int udpcksum;
+int udpcksum = 1;
struct sockaddr_in udp_in = { AF_INET };
udp_input(m0)
register struct udpiphdr *ui;
register struct inpcb *inp;
register struct mbuf *m;
- int len, ulen;
+ int len;
/*
* Get IP and UDP header together in first mbuf.
* Make mbuf data length reflect UDP length.
* If not enough data to reflect UDP length, drop.
*/
- ulen = ntohs((u_short)ui->ui_ulen);
- len = sizeof (struct udphdr) + ulen;
+ 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, ((struct ip *)ui)->ip_len - len);
+ m_adj(m, len - ((struct ip *)ui)->ip_len);
/* (struct ip *)ui->ip_len = len; */
}
/*
* Checksum extended UDP header and data.
*/
- if (udpcksum) {
+ if (udpcksum && ui->ui_sum) {
ui->ui_next = ui->ui_prev = 0;
ui->ui_x1 = 0;
- ui->ui_len = htons((u_short)(sizeof (struct udphdr) + ulen));
- if (ui->ui_sum = in_cksum(m, len)) {
+ ui->ui_len = ui->ui_ulen;
+ if (ui->ui_sum = in_cksum(m, len + sizeof (struct ip))) {
udpstat.udps_badsum++;
- printf("udp cksum %x\n", ui->ui_sum);
m_freem(m);
return;
}
}
/*
- * Locate pcb for datagram. On wildcard match, update
- * control block to anchor network and host address.
+ * 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) {
- struct in_addr broadcastaddr;
-
- broadcastaddr = if_makeaddr(ui->ui_dst.s_net, INADDR_ANY);
- if (ui->ui_dst.s_addr == broadcastaddr.s_addr)
+ /* 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;
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) == 0)
+ if (sbappendaddr(&inp->inp_socket->so_rcv, (struct sockaddr *)&udp_in,
+ m, (struct mbuf *)0) == 0)
goto bad;
sorwakeup(inp->inp_socket);
return;
default:
sin = &((struct icmp *)arg)->icmp_ip.ip_dst;
- in_pcbnotify(&udb, sin, inetctlerrmap[cmd], udp_abort);
+ in_pcbnotify(&udb, sin, (int)inetctlerrmap[cmd], udp_abort);
}
}
register struct udpiphdr *ui;
register struct socket *so;
register int len = 0;
+ register struct route *ro;
/*
* Calculate data length and get a mbuf
*/
for (m = m0; m; m = m->m_next)
len += m->m_len;
- m = m_get(M_DONTWAIT);
+ MGET(m, M_DONTWAIT, MT_HEADER);
if (m == 0) {
m_freem(m0);
return (ENOBUFS);
ui->ui_next = ui->ui_prev = 0;
ui->ui_x1 = 0;
ui->ui_pr = IPPROTO_UDP;
- ui->ui_len = sizeof (struct udpiphdr) + len;
+ 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 = len;
-#if vax
- ui->ui_ulen = htons(ui->ui_ulen);
-#endif
+ ui->ui_ulen = ui->ui_len;
/*
* Stuff checksum and output datagram.
*/
ui->ui_sum = 0;
- ui->ui_sum = in_cksum(m, sizeof (struct udpiphdr) + len);
+ 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;
- return (ip_output(m, (struct mbuf *)0,
- (so->so_options & SO_DONTROUTE) ? &routetoif : (struct route *)0,
- so->so_state & SS_PRIV));
+ 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));
}
-udp_usrreq(so, req, m, addr)
+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;
- caddr_t addr;
+ struct mbuf *m, *nam, *rights;
{
struct inpcb *inp = sotoinpcb(so);
int error = 0;
- if (inp == 0 && req != PRU_ATTACH)
- return (EINVAL);
+ 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 != 0)
- return (EINVAL);
- error = in_pcbattach(so, &udb, 2048, 2048,
- (struct sockaddr_in *)addr);
+ 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 == 0)
- return (ENOTCONN);
+ 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)
- return (EISCONN);
- error = in_pcbconnect(inp, (struct sockaddr_in *)addr);
+ 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:
- return (EOPNOTSUPP);
+ error = EOPNOTSUPP;
+ break;
case PRU_DISCONNECT:
- if (inp->inp_faddr.s_addr == 0)
- return (ENOTCONN);
+ if (inp->inp_faddr.s_addr == INADDR_ANY) {
+ error = ENOTCONN;
+ break;
+ }
in_pcbdisconnect(inp);
soisdisconnected(so);
break;
case PRU_SEND: {
struct in_addr laddr;
+ int s;
- if (addr) {
+ if (nam) {
laddr = inp->inp_laddr;
- if (inp->inp_faddr.s_addr)
- return (EISCONN);
- error = in_pcbconnect(inp, (struct sockaddr_in *)addr);
- if (error)
+ 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 == 0)
- return (ENOTCONN);
+ if (inp->inp_faddr.s_addr == INADDR_ANY) {
+ error = ENOTCONN;
+ break;
+ }
}
error = udp_output(inp, m);
- if (addr) {
+ m = NULL;
+ if (nam) {
in_pcbdisconnect(inp);
inp->inp_laddr = laddr;
+ splx(s);
}
}
break;
soisdisconnected(so);
break;
- case PRU_CONTROL:
- return (EOPNOTSUPP);
-
case PRU_SOCKADDR:
- in_setsockaddr((struct sockaddr_in *)addr, inp);
+ 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);
}