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

/*
 * Copyright (c) 1982, 1986, 1988 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, 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'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *	@(#)udp_usrreq.c	7.12 (Berkeley) %G%
 */

#include "param.h"
#include "user.h"
#include "malloc.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;
}

#ifndef	COMPAT_42
int	udpcksum = 1;
#else
int	udpcksum = 0;		/* XXX */
#endif
int	udp_ttl = UDP_TTL;

struct	sockaddr_in udp_in = { sizeof(udp_in), AF_INET };

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

	/*
	 * Get IP and UDP header together in first mbuf.
	 * Note: IP leaves IP header in first mbuf.
	 */
	ui = mtod(m, struct udpiphdr *);
	if (iphlen > sizeof (struct ip))
		ip_stripoptions(m, (struct mbuf *)0);
	if (m->m_len < sizeof (struct udpiphdr)) {
		if ((m = m_pullup(m, sizeof (struct udpiphdr))) == 0) {
			udpstat.udps_hdrops++;
			return;
		}
		ui = mtod(m, struct udpiphdr *);
	}

	/*
	 * 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; */
	}
	/*
	 * 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.
	 */
	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 (m->m_flags & M_BCAST)
			goto bad;
		*(struct ip *)ui = ip;
		icmp_error(m, 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_pkthdr.len -= sizeof (struct udpiphdr);
	m->m_data += 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);
}

/*
 * 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;
{

	sorwakeup(inp->inp_socket);
	sowwakeup(inp->inp_socket);
}

udp_ctlinput(cmd, sa)
	int cmd;
	struct sockaddr *sa;
{
	extern u_char inetctlerrmap[];
	struct sockaddr_in *sin;
	int in_rtchange();

	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;

	switch (cmd) {

	case PRC_QUENCH:
		break;

	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:
		if (inetctlerrmap[cmd] == 0)
			return;		/* XXX */
		in_pcbnotify(&udb, &sin->sin_addr, (int)inetctlerrmap[cmd],
			udp_notify);
	}
}

udp_output(inp, m)
	register struct inpcb *inp;
	register struct mbuf *m;
{
	register struct udpiphdr *ui;
	register int len = m->m_pkthdr.len;

	/*
	 * Calculate data length and get a mbuf
	 * for UDP and IP headers.
	 */
	M_PREPEND(m, sizeof(struct udpiphdr), M_WAIT);

	/*
	 * Fill in mbuf with extended UDP header
	 * and addresses and length put into network format.
	 */
	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 = 0xffff;
	}
	((struct ip *)ui)->ip_len = sizeof (struct udpiphdr) + len;
	((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)));
}

u_long	udp_sendspace = 9216;		/* really max datagram size */
u_long	udp_recvspace = 40 * (1024 + sizeof(struct sockaddr_in));
					/* 40 1K datagrams */

/*ARGSUSED*/
udp_usrreq(so, req, m, nam, rights, control)
	struct socket *so;
	int req;
	struct mbuf *m, *nam, *rights, *control;
{
	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:
		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);
		so->so_state &= ~SS_ISCONNECTED;		/* XXX */
		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:
		soisdisconnected(so);
		in_pcbdetach(inp);
		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);
}
Commit	Line	Data
8ae0e4b4	1	/*
9d91b170	2	* Copyright (c) 1982, 1986, 1988 Regents of the University of California.
2b6b6284	3	* All rights reserved.
8ae0e4b4	4	*
2b6b6284	5	* Redistribution and use in source and binary forms are permitted
616d42db KB	6	* provided that the above copyright notice and this paragraph are
	7	* duplicated in all such forms and that any documentation,
	8	* advertising materials, and other materials related to such
	9	* distribution and use acknowledge that the software was developed
	10	* by the University of California, Berkeley. The name of the
	11	* University may not be used to endorse or promote products derived
	12	* from this software without specific prior written permission.
	13	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
	14	* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
	15	* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
2b6b6284	16	*
c9209cff	17	* @(#)udp_usrreq.c 7.12 (Berkeley) %G%
8ae0e4b4	18	*/
20666ad3 JB	19
20666ad3 JB	20	#include "param.h"
20666ad3	21	#include "user.h"
9d91b170	22	#include "malloc.h"
20666ad3 JB	23	#include "mbuf.h"
	24	#include "protosw.h"
	25	#include "socket.h"
	26	#include "socketvar.h"
	27	#include "errno.h"
	28	#include "stat.h"
f4d55810	29
72e4f44e	30	#include "../net/if.h"
c124e997	31	#include "../net/route.h"
f4d55810	32
20666ad3 JB	33	#include "in.h"
	34	#include "in_pcb.h"
	35	#include "in_systm.h"
	36	#include "ip.h"
	37	#include "ip_var.h"
	38	#include "ip_icmp.h"
	39	#include "udp.h"
	40	#include "udp_var.h"
d52566dd	41
2b4b57cd BJ	42	/*
	43	* UDP protocol implementation.
	44	* Per RFC 768, August, 1980.
	45	*/
d52566dd BJ	46	udp_init()
	47	{
	48
eb44bfb2	49	udb.inp_next = udb.inp_prev = &udb;
d52566dd	50	}
1bd53abe	51
c50542f3	52	#ifndef COMPAT_42
dd8707ae	53	int udpcksum = 1;
c50542f3 MK	54	#else
	55	int udpcksum = 0; /* XXX */
	56	#endif
0eda4f11	57	int udp_ttl = UDP_TTL;
c50542f3	58
5328bc49	59	struct sockaddr_in udp_in = { sizeof(udp_in), AF_INET };
eb44bfb2	60
9d91b170 MK	61	udp_input(m, iphlen)
	62	register struct mbuf *m;
	63	int iphlen;
1bd53abe	64	{
eb44bfb2	65	register struct udpiphdr *ui;
53a5409e	66	register struct inpcb *inp;
e199a8a5	67	int len;
dcea2497	68	struct ip ip;
eb44bfb2	69
2b4b57cd	70	/*
4aed14e3	71	* Get IP and UDP header together in first mbuf.
7212ba67	72	* Note: IP leaves IP header in first mbuf.
2b4b57cd	73	*/
4e60622a	74	ui = mtod(m, struct udpiphdr *);
9d91b170 MK	75	if (iphlen > sizeof (struct ip))
	76	ip_stripoptions(m, (struct mbuf *)0);
	77	if (m->m_len < sizeof (struct udpiphdr)) {
7212ba67 MK	78	if ((m = m_pullup(m, sizeof (struct udpiphdr))) == 0) {
	79	udpstat.udps_hdrops++;
	80	return;
	81	}
	82	ui = mtod(m, struct udpiphdr *);
	83	}
2b4b57cd BJ	84
2b4b57cd BJ	85	/*
4aed14e3 BJ	86	* Make mbuf data length reflect UDP length.
4aed14e3 BJ	87	* If not enough data to reflect UDP length, drop.
2b4b57cd	88	*/
e199a8a5	89	len = ntohs((u_short)ui->ui_ulen);
2b4b57cd BJ	90	if (((struct ip *)ui)->ip_len != len) {
	91	if (len > ((struct ip *)ui)->ip_len) {
	92	udpstat.udps_badlen++;
	93	goto bad;
	94	}
4828da7c	95	m_adj(m, len - ((struct ip *)ui)->ip_len);
dcea2497	96	/* ((struct ip )ui)->ip_len = len; /
2b4b57cd	97	}
dcea2497 MK	98	/*
	99	* Save a copy of the IP header in case we want restore it for ICMP.
	100	*/
9d91b170	101	ip = (struct ip )ui;
2b4b57cd BJ	102
2b4b57cd BJ	103	/*
4aed14e3	104	* Checksum extended UDP header and data.
2b4b57cd	105	*/
4828da7c	106	if (udpcksum && ui->ui_sum) {
2b4b57cd BJ	107	ui->ui_next = ui->ui_prev = 0;
2b4b57cd BJ	108	ui->ui_x1 = 0;
ee09448f	109	ui->ui_len = ui->ui_ulen;
e199a8a5	110	if (ui->ui_sum = in_cksum(m, len + sizeof (struct ip))) {
2b4b57cd	111	udpstat.udps_badsum++;
eb44bfb2 BJ	112	m_freem(m);
	113	return;
	114	}
	115	}
2b4b57cd BJ	116
2b4b57cd BJ	117	/*
e199a8a5	118	* Locate pcb for datagram.
2b4b57cd	119	*/
2b4b57cd	120	inp = in_pcblookup(&udb,
ebcadd38 BJ	121	ui->ui_src, ui->ui_sport, ui->ui_dst, ui->ui_dport,
ebcadd38 BJ	122	INPLOOKUP_WILDCARD);
72e4f44e	123	if (inp == 0) {
5cdc4d65	124	/* don't send ICMP response for broadcast packet */
9d91b170	125	if (m->m_flags & M_BCAST)
72e4f44e	126	goto bad;
dcea2497	127	(struct ip )ui = ip;
9d91b170	128	icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_PORT);
72e4f44e SL	129	return;
72e4f44e SL	130	}
2b4b57cd BJ	131
	132	/*
	133	* Construct sockaddr format source address.
	134	* Stuff source address and datagram in user buffer.
	135	*/
	136	udp_in.sin_port = ui->ui_sport;
	137	udp_in.sin_addr = ui->ui_src;
4e60622a	138	m->m_len -= sizeof (struct udpiphdr);
9d91b170 MK	139	m->m_pkthdr.len -= sizeof (struct udpiphdr);
9d91b170 MK	140	m->m_data += sizeof (struct udpiphdr);
ab85b059 SL	141	if (sbappendaddr(&inp->inp_socket->so_rcv, (struct sockaddr *)&udp_in,
ab85b059 SL	142	m, (struct mbuf *)0) == 0)
2b4b57cd	143	goto bad;
4e60622a	144	sorwakeup(inp->inp_socket);
53a5409e	145	return;
2b4b57cd	146	bad:
53a5409e	147	m_freem(m);
1bd53abe BJ	148	}
1bd53abe BJ	149
41715710 MK	150	/*
	151	* Notify a udp user of an asynchronous error;
	152	* just wake up so that he can collect error status.
	153	*/
	154	udp_notify(inp)
	155	register struct inpcb *inp;
	156	{
	157
	158	sorwakeup(inp->inp_socket);
	159	sowwakeup(inp->inp_socket);
	160	}
	161
dcea2497	162	udp_ctlinput(cmd, sa)
39674d5f	163	int cmd;
dcea2497	164	struct sockaddr *sa;
39674d5f	165	{
39674d5f	166	extern u_char inetctlerrmap[];
dcea2497	167	struct sockaddr_in *sin;
336240bf	168	int in_rtchange();
39674d5f	169
dcea2497	170	if ((unsigned)cmd > PRC_NCMDS)
39674d5f	171	return;
dcea2497 MK	172	if (sa->sa_family != AF_INET && sa->sa_family != AF_IMPLINK)
	173	return;
	174	sin = (struct sockaddr_in *)sa;
	175	if (sin->sin_addr.s_addr == INADDR_ANY)
	176	return;
	177
39674d5f SL	178	switch (cmd) {
39674d5f SL	179
dcea2497	180	case PRC_QUENCH:
39674d5f SL	181	break;
39674d5f SL	182
dcea2497	183	case PRC_ROUTEDEAD:
336240bf MK	184	case PRC_REDIRECT_NET:
336240bf MK	185	case PRC_REDIRECT_HOST:
dcea2497 MK	186	case PRC_REDIRECT_TOSNET:
	187	case PRC_REDIRECT_TOSHOST:
	188	in_pcbnotify(&udb, &sin->sin_addr, 0, in_rtchange);
39674d5f SL	189	break;
39674d5f SL	190
39674d5f	191	default:
336240bf MK	192	if (inetctlerrmap[cmd] == 0)
336240bf MK	193	return; /* XXX */
dcea2497	194	in_pcbnotify(&udb, &sin->sin_addr, (int)inetctlerrmap[cmd],
41715710	195	udp_notify);
39674d5f SL	196	}
	197	}
	198
9d91b170	199	udp_output(inp, m)
d55475b1	200	register struct inpcb *inp;
2b4b57cd	201	register struct mbuf *m;
9d91b170	202	{
2b4b57cd	203	register struct udpiphdr *ui;
9d91b170	204	register int len = m->m_pkthdr.len;
2b4b57cd BJ	205
	206	/*
	207	* Calculate data length and get a mbuf
4aed14e3	208	* for UDP and IP headers.
2b4b57cd	209	*/
9d91b170	210	M_PREPEND(m, sizeof(struct udpiphdr), M_WAIT);
2b4b57cd BJ	211
2b4b57cd BJ	212	/*
4aed14e3	213	* Fill in mbuf with extended UDP header
2b4b57cd BJ	214	* and addresses and length put into network format.
2b4b57cd BJ	215	*/
2b4b57cd BJ	216	ui = mtod(m, struct udpiphdr *);
	217	ui->ui_next = ui->ui_prev = 0;
	218	ui->ui_x1 = 0;
	219	ui->ui_pr = IPPROTO_UDP;
ee847abd	220	ui->ui_len = htons((u_short)len + sizeof (struct udphdr));
4e60622a BJ	221	ui->ui_src = inp->inp_laddr;
	222	ui->ui_dst = inp->inp_faddr;
	223	ui->ui_sport = inp->inp_lport;
	224	ui->ui_dport = inp->inp_fport;
ee847abd	225	ui->ui_ulen = ui->ui_len;
2b4b57cd BJ	226
	227	/*
	228	* Stuff checksum and output datagram.
	229	*/
	230	ui->ui_sum = 0;
dd8707ae MK	231	if (udpcksum) {
dd8707ae MK	232	if ((ui->ui_sum = in_cksum(m, sizeof (struct udpiphdr) + len)) == 0)
890024da	233	ui->ui_sum = 0xffff;
ee09448f	234	}
4e60622a	235	((struct ip *)ui)->ip_len = sizeof (struct udpiphdr) + len;
0eda4f11	236	((struct ip *)ui)->ip_ttl = udp_ttl;
d55475b1 MK	237	return (ip_output(m, inp->inp_options, &inp->inp_route,
d55475b1 MK	238	inp->inp_socket->so_options & (SO_DONTROUTE \| SO_BROADCAST)));
1bd53abe BJ	239	}
1bd53abe BJ	240
c9209cff KM	241	u_long udp_sendspace = 9216; /* really max datagram size */
	242	u_long udp_recvspace = 40 * (1024 + sizeof(struct sockaddr_in));
	243	/* 40 1K datagrams */
1d14d351	244
a8d3bf7f	245	/ARGSUSED/
9d91b170	246	udp_usrreq(so, req, m, nam, rights, control)
53a5409e	247	struct socket *so;
1bd53abe	248	int req;
9d91b170	249	struct mbuf m, nam, rights, control;
1bd53abe	250	{
53a5409e	251	struct inpcb *inp = sotoinpcb(so);
8a2f82db	252	int error = 0;
1bd53abe	253
1d14d351 MK	254	if (req == PRU_CONTROL)
	255	return (in_control(so, (int)m, (caddr_t)nam,
	256	(struct ifnet *)rights));
ab85b059 SL	257	if (rights && rights->m_len) {
	258	error = EINVAL;
	259	goto release;
	260	}
a3fa431a SL	261	if (inp == NULL && req != PRU_ATTACH) {
	262	error = EINVAL;
	263	goto release;
	264	}
1bd53abe BJ	265	switch (req) {
	266
	267	case PRU_ATTACH:
a3fa431a SL	268	if (inp != NULL) {
	269	error = EINVAL;
	270	break;
	271	}
8075bb0e BJ	272	error = in_pcballoc(so, &udb);
	273	if (error)
	274	break;
1d14d351	275	error = soreserve(so, udp_sendspace, udp_recvspace);
8075bb0e BJ	276	if (error)
8075bb0e BJ	277	break;
53a5409e	278	break;
1bd53abe BJ	279
1bd53abe BJ	280	case PRU_DETACH:
405c9168	281	in_pcbdetach(inp);
53a5409e	282	break;
1bd53abe	283
8075bb0e BJ	284	case PRU_BIND:
	285	error = in_pcbbind(inp, nam);
	286	break;
	287
	288	case PRU_LISTEN:
	289	error = EOPNOTSUPP;
	290	break;
	291
1bd53abe	292	case PRU_CONNECT:
a3fa431a SL	293	if (inp->inp_faddr.s_addr != INADDR_ANY) {
	294	error = EISCONN;
	295	break;
	296	}
8075bb0e	297	error = in_pcbconnect(inp, nam);
8a2f82db SL	298	if (error == 0)
8a2f82db SL	299	soisconnected(so);
1bd53abe BJ	300	break;
1bd53abe BJ	301
4945768c SL	302	case PRU_CONNECT2:
	303	error = EOPNOTSUPP;
	304	break;
	305
2b4b57cd	306	case PRU_ACCEPT:
a3fa431a SL	307	error = EOPNOTSUPP;
a3fa431a SL	308	break;
2b4b57cd	309
53a5409e	310	case PRU_DISCONNECT:
a3fa431a SL	311	if (inp->inp_faddr.s_addr == INADDR_ANY) {
	312	error = ENOTCONN;
	313	break;
	314	}
405c9168	315	in_pcbdisconnect(inp);
f96a0781	316	so->so_state &= ~SS_ISCONNECTED; /* XXX */
1bd53abe BJ	317	break;
1bd53abe BJ	318
cdad2eb1 BJ	319	case PRU_SHUTDOWN:
	320	socantsendmore(so);
	321	break;
	322
1aa87517 BJ	323	case PRU_SEND: {
1aa87517 BJ	324	struct in_addr laddr;
5f55b8b5	325	int s;
1aa87517	326
8075bb0e	327	if (nam) {
1aa87517	328	laddr = inp->inp_laddr;
a3fa431a SL	329	if (inp->inp_faddr.s_addr != INADDR_ANY) {
	330	error = EISCONN;
	331	break;
	332	}
5f55b8b5 MK	333	/*
	334	* Must block input while temporarily connected.
	335	*/
	336	s = splnet();
8075bb0e	337	error = in_pcbconnect(inp, nam);
5f55b8b5 MK	338	if (error) {
5f55b8b5 MK	339	splx(s);
8a2f82db	340	break;
5f55b8b5	341	}
4ad99bae	342	} else {
a3fa431a SL	343	if (inp->inp_faddr.s_addr == INADDR_ANY) {
	344	error = ENOTCONN;
	345	break;
	346	}
4ad99bae	347	}
8a2f82db	348	error = udp_output(inp, m);
a3fa431a	349	m = NULL;
8075bb0e	350	if (nam) {
405c9168	351	in_pcbdisconnect(inp);
1aa87517	352	inp->inp_laddr = laddr;
1d14d351	353	splx(s);
1aa87517 BJ	354	}
1aa87517 BJ	355	}
1bd53abe BJ	356	break;
	357
	358	case PRU_ABORT:
53a5409e	359	soisdisconnected(so);
97f3441b	360	in_pcbdetach(inp);
1bd53abe BJ	361	break;
1bd53abe BJ	362
126472ab	363	case PRU_SOCKADDR:
8075bb0e	364	in_setsockaddr(inp, nam);
126472ab SL	365	break;
126472ab SL	366
a7343092 SL	367	case PRU_PEERADDR:
	368	in_setpeeraddr(inp, nam);
	369	break;
	370
74040e68 MK	371	case PRU_SENSE:
	372	/*
	373	* stat: don't bother with a blocksize.
	374	*/
	375	return (0);
	376
11d2a668 SL	377	case PRU_SENDOOB:
	378	case PRU_FASTTIMO:
	379	case PRU_SLOWTIMO:
	380	case PRU_PROTORCV:
	381	case PRU_PROTOSEND:
	382	error = EOPNOTSUPP;
	383	break;
4945768c	384
5f55b8b5 MK	385	case PRU_RCVD:
	386	case PRU_RCVOOB:
	387	return (EOPNOTSUPP); /* do not free mbuf's */
	388
4945768c SL	389	default:
4945768c SL	390	panic("udp_usrreq");
d52566dd	391	}
a3fa431a SL	392	release:
	393	if (m != NULL)
	394	m_freem(m);
8a2f82db	395	return (error);
d52566dd	396	}