Ultrix-3.1/sys/net/udp_usrreq.c
/**********************************************************************
* Copyright (c) Digital Equipment Corporation 1984, 1985, 1986. *
* All Rights Reserved. *
* Reference "/usr/src/COPYRIGHT" for applicable restrictions. *
**********************************************************************/
/*
* Copyright (c) 1982 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*
* SCCSID: @(#)udp_usrreq.c 3.0 4/21/86
* Based on: @(#)udp_usrreq.c 6.14 (Berkeley) 6/8/85
*/
#include <sys/param.h>
#include <sys/dir.h>
#include <sys/user.h>
#include <sys/mbuf.h>
#include <sys/protosw.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <errno.h>
#include <sys/stat.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>
/*
* 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;
}
#ifdef pdp11
#define return goto finishup
MAPSAVE();
#endif pdp11
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;
#ifdef pdp11
ui->ui_pad = 0;
#endif pdp11
ui->ui_x1 = 0;
ui->ui_len = ui->ui_ulen;
if (ui->ui_sum = in_cksum(m, len + sizeof (struct ip))) {
udpstat.udps_badsum++;
#ifdef vax
m_freem(m);
return;
#else pdp11
goto bad;
#endif
}
}
/*
* 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);
#ifdef pdp11
#undef return
finishup:
MAPREST();
#endif pdp11
}
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 *in;
extern u_char inetctlerrmap[];
int in_rtchange();
if (cmd < 0 || cmd > PRC_NCMDS)
return;
switch (cmd) {
case PRC_ROUTEDEAD:
break;
case PRC_REDIRECT_NET:
case PRC_REDIRECT_HOST:
in = &((struct icmp *)arg)->icmp_ip.ip_dst;
in_pcbnotify(&udb, in, 0, in_rtchange);
break;
case PRC_IFDOWN:
in = &((struct sockaddr_in *)arg)->sin_addr;
goto notify;
case PRC_HOSTDEAD:
case PRC_HOSTUNREACH:
in = (struct in_addr *)arg;
goto notify;
default:
if (inetctlerrmap[cmd] == 0)
return; /* XXX */
in = &((struct icmp *)arg)->icmp_ip.ip_dst;
notify:
in_pcbnotify(&udb, in, (int)inetctlerrmap[cmd], udp_abort);
}
}
static
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;
#ifdef pdp11
segm map;
#endif pdp11
/*
* Calculate data length and get a mbuf
* for UDP and IP headers.
*/
for (m = m0; m; m = m->m_next)
len += m->m_len;
#ifdef vax
m = m_get(M_DONTWAIT, MT_HEADER);
#else pdp11
MGET(m, M_DONTWAIT, MT_HEADER);
#endif
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;
#ifdef pdp11
saveseg5(map);
#endif pdp11
ui = mtod(m, struct udpiphdr *);
ui->ui_next = ui->ui_prev = 0;
#ifdef pdp11
ui->ui_pad = 0;
#endif pdp11
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) {
#ifdef pdp11
restorseg5(map);
#endif pdp11
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;
}
#ifdef pdp11
restorseg5(map);
#endif pdp11
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;
}
#ifndef pdp11
error = in_pcbconnect(inp, nam);
#else pdp11
MAPSAVE();
error = in_pcbconnect(inp, mtod(nam, caddr_t));
MAPREST();
#endif pdp11
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();
#ifndef pdp11
error = in_pcbconnect(inp, nam);
#else pdp11
MAPSAVE();
error = in_pcbconnect(inp, mtod(nam, caddr_t));
MAPREST();
#endif pdp11
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);
}