[apple/xnu.git] / bsd / netat / ddp_usrreq.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 *	Copyright (c) 1998 Apple Computer, Inc. 
 */

/*	ddp_usrreq.c
 */

#include <sys/errno.h>
#include <sys/types.h>
#include <sys/param.h>
#include <machine/spl.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/proc.h>
#include <sys/filedesc.h>
#include <sys/fcntl.h>
#include <sys/mbuf.h>
#include <sys/ioctl.h>
#include <sys/malloc.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/protosw.h>

#include <net/if.h>

#include <netat/appletalk.h>
#include <netat/at_var.h>
#include <netat/sysglue.h>
#include <netat/ddp.h>
#include <netat/ep.h>
#include <netat/rtmp.h>
#include <netat/zip.h>
#include <netat/at_pcb.h>
#include <netat/routing_tables.h>
#include <netat/nbp.h>

extern int at_control(), at_memzone_init();
extern void  nbp_input(), ep_input(), zip_router_input(), 
  sip_input(), add_ddp_handler(), init_ddp_handler(), 
  ddp_start(), ddp_input(), appletalk_hack_start();
extern u_short ddp_checksum();
extern at_ifaddr_t *forUs();
extern struct mbuf *m_dup(struct mbuf *, int);

extern at_ifaddr_t *ifID_home;
extern int xpatcnt;

struct atpcb ddp_head;
u_long ddp_sendspace = 600,	/* *** what should this value be? *** */
  ddp_recvspace = 50 * (600 + sizeof(struct sockaddr_at));

int ddp_pru_control(struct socket *so, u_long cmd, caddr_t data,
		struct ifnet *ifp, struct proc *p)
{
	return(at_control(so, cmd, data, ifp));
}


int	ddp_pru_attach(struct socket *so, int proto,
		   struct proc *p)
{
	int s, error = 0;
	at_ddp_t *ddp = NULL;
	struct atpcb *pcb = (struct atpcb *)((so)->so_pcb);

	s = splnet();
	error = at_pcballoc(so, &ddp_head);
	splx(s);
	if (error)
		return error;
	error = soreserve(so, ddp_sendspace, ddp_recvspace);
	pcb = (struct atpcb *)((so)->so_pcb);
	pcb->pid = current_proc()->p_pid;
	pcb->ddptype = (u_char) proto;    /* set in socreate() */
	pcb->proto = ATPROTO_DDP;

	return error;
}


int  ddp_pru_disconnect(struct socket *so)
{

	int s, error = 0;
	at_ddp_t *ddp = NULL;
	struct atpcb *pcb = (struct atpcb *)((so)->so_pcb);

	if (pcb == NULL) 
		return (EINVAL);

	if ((so->so_state & SS_ISCONNECTED) == 0) 
		return ENOTCONN;

	soisdisconnected(so);
	s = splnet();
	at_pcbdetach(pcb);
	splx(s);

	return error;
}


int  ddp_pru_abort(struct socket *so)
{
	int s;
	struct atpcb *pcb = (struct atpcb *)((so)->so_pcb);

	if (pcb == NULL) 
		return (EINVAL);

	soisdisconnected(so);
	s = splnet();
	at_pcbdetach(pcb);
	splx(s);

	return 0;
}

int  ddp_pru_detach(struct socket *so)
{
	int s;
	struct atpcb *pcb = (struct atpcb *)((so)->so_pcb);

	if (pcb == NULL) 
		return (EINVAL);

	s = splnet();
	at_pcbdetach(pcb);
	splx(s);
	return 0;
}
					  
int	ddp_pru_shutdown(struct socket *so)
{
	struct atpcb *pcb = (struct atpcb *)((so)->so_pcb);

	if (pcb == NULL) 
		return (EINVAL);

	socantsendmore(so);
	return 0;
}
					  

int    ddp_pru_bind(struct socket *so, struct sockaddr *nam,
		struct proc *p)
{
	struct atpcb *pcb = (struct atpcb *)((so)->so_pcb);

	if (pcb == NULL) 
		return (EINVAL);

	return (at_pcbbind(pcb, nam));
}


int	ddp_pru_send(struct socket *so, int flags, struct mbuf *m, 
		     struct sockaddr *addr, struct mbuf *control,
		     struct proc *p)
{
	at_ddp_t *ddp = NULL;
	struct atpcb *pcb = (struct atpcb *)((so)->so_pcb);

	if (pcb == NULL)
		return (EINVAL);

	if (!(pcb->ddp_flags & DDPFLG_HDRINCL)) {
		/* prepend a DDP header */
		M_PREPEND(m, DDP_X_HDR_SIZE, M_WAIT);
		ddp = mtod(m, at_ddp_t *);
	}

	if (so->so_state & SS_ISCONNECTED) {
		if (addr) 
		        return EISCONN;

		if (ddp) {
			NET_ASSIGN(ddp->dst_net, pcb->raddr.s_net);
			ddp->dst_node = pcb->raddr.s_node;
			ddp->dst_socket = pcb->rport;
		}
	} else {
		if (addr == NULL) 
			return ENOTCONN;

		if (ddp) {
			struct sockaddr_at *dst =
				(struct sockaddr_at *) addr;
			NET_ASSIGN(ddp->dst_net, dst->sat_addr.s_net);
			ddp->dst_node = dst->sat_addr.s_node;
			ddp->dst_socket = dst->sat_port;
		}
	}
	if (ddp) {
		ddp->length = m->m_pkthdr.len;
		UAS_ASSIGN(ddp->checksum, 
			   (pcb->ddp_flags & DDPFLG_CHKSUM)? 1: 0);
		ddp->type = (pcb->ddptype)? pcb->ddptype: DEFAULT_OT_DDPTYPE;
#ifdef NOT_YET
		NET_ASSIGN(ddp->src_net, pcb->laddr.s_net);
		ddp->src_node = pcb->laddr.s_node;
		ddp->src_socket = pcb->lport;
#endif
	} else {
		ddp = mtod(m, at_ddp_t *);
	}
	if (NET_VALUE(ddp->dst_net) == ATADDR_ANYNET && 
	    ddp->dst_node == ATADDR_BCASTNODE &&
	    (pcb->ddp_flags & DDPFLG_SLFSND)) {
		struct mbuf *n;

		if ((n = m_dup(m, M_DONTWAIT))) {
			at_ifaddr_t 
			  *ifID = ifID_home, 
			  *ifIDTmp = (at_ifaddr_t *)NULL;

			/* as in ddp_output() loop processing, fill in the 
			   rest of the header */
			ddp = mtod(n, at_ddp_t *);
			if (MULTIHOME_MODE && (ifIDTmp = forUs(ddp)))
				ifID = ifIDTmp;
			NET_ASSIGN(ddp->src_net, ifID->ifThisNode.s_net);
			ddp->src_node = ifID->ifThisNode.s_node;
			ddp->src_socket = pcb->lport;
			if (UAS_VALUE(ddp->checksum))
				UAS_ASSIGN(ddp->checksum, ddp_checksum(m, 4));
			ddp_input(n, ifID);
		}
	}
	return(ddp_output(&m, pcb->lport, FALSE));
} /* ddp_pru_send */

int   ddp_pru_sockaddr(struct socket *so, 
		   struct sockaddr **nam)
{
        int s;
	struct atpcb *pcb;
	struct sockaddr_at *sat;

	MALLOC(sat, struct sockaddr_at *, sizeof *sat, M_SONAME, M_WAITOK);
	bzero((caddr_t)sat, sizeof(*sat));

	s = splnet();
	if ((pcb = sotoatpcb(so)) == NULL) {
		splx(s);
		FREE(sat, M_SONAME);
		return(EINVAL);
	}

	sat->sat_family = AF_APPLETALK;
	sat->sat_len = sizeof(*sat);
	sat->sat_port = pcb->lport;
	sat->sat_addr = pcb->laddr;
	splx(s);

	*nam = (struct sockaddr *)sat;
	return(0);
}


int  ddp_pru_peeraddr(struct socket *so, 
		  struct sockaddr **nam)
{
        int s;
	struct atpcb *pcb;
	struct sockaddr_at *sat;

	MALLOC(sat, struct sockaddr_at *, sizeof *sat, M_SONAME, M_WAITOK);
	bzero((caddr_t)sat, sizeof(*sat));

	s = splnet();
	if ((pcb = sotoatpcb(so)) == NULL) {
		splx(s);
		FREE(sat, M_SONAME);
		return(EINVAL);
	}

	sat->sat_family = AF_APPLETALK;
	sat->sat_len = sizeof(*sat);
	sat->sat_port = pcb->rport;
	sat->sat_addr = pcb->raddr;
	splx(s);

	*nam = (struct sockaddr *)sat;
	return(0);
}


int    ddp_pru_connect(struct socket *so, struct sockaddr *nam,
		   struct proc *p)
{
	struct atpcb *pcb = (struct atpcb *)((so)->so_pcb);
	struct sockaddr_at *faddr = (struct sockaddr_at *) nam;

	if (pcb != NULL) 
		return (EINVAL);

	if (xpatcnt == 0) 
		return (EADDRNOTAVAIL);

	if (faddr->sat_family != AF_APPLETALK) 
		return (EAFNOSUPPORT);

	pcb->raddr = faddr->sat_addr;
	soisconnected(so);
	return 0;
}


/*
 * One-time AppleTalk initialization
 */
void ddp_init()
{
	at_memzone_init();
	ddp_head.atpcb_next = ddp_head.atpcb_prev = &ddp_head;
	init_ddp_handler();

    /* Initialize protocols implemented in the kernel */
	add_ddp_handler(EP_SOCKET, ep_input);
	add_ddp_handler(ZIP_SOCKET, zip_router_input);
	add_ddp_handler(NBP_SOCKET, nbp_input);
	add_ddp_handler(DDP_SOCKET_1st_DYNAMIC, sip_input);

	ddp_start();

	appletalk_hack_start();
} /* ddp_init */
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* Copyright (c) 1998 Apple Computer, Inc.
	24	*/
	25
	26	/* ddp_usrreq.c
	27	*/
	28
	29	#include <sys/errno.h>
	30	#include <sys/types.h>
	31	#include <sys/param.h>
	32	#include <machine/spl.h>
	33	#include <sys/systm.h>
	34	#include <sys/kernel.h>
	35	#include <sys/proc.h>
	36	#include <sys/filedesc.h>
	37	#include <sys/fcntl.h>
	38	#include <sys/mbuf.h>
	39	#include <sys/ioctl.h>
	40	#include <sys/malloc.h>
	41	#include <sys/socket.h>
	42	#include <sys/socketvar.h>
	43	#include <sys/protosw.h>
	44
	45	#include <net/if.h>
	46
	47	#include <netat/appletalk.h>
	48	#include <netat/at_var.h>
	49	#include <netat/sysglue.h>
	50	#include <netat/ddp.h>
	51	#include <netat/ep.h>
	52	#include <netat/rtmp.h>
	53	#include <netat/zip.h>
	54	#include <netat/at_pcb.h>
	55	#include <netat/routing_tables.h>
	56	#include <netat/nbp.h>
	57
	58	extern int at_control(), at_memzone_init();
	59	extern void nbp_input(), ep_input(), zip_router_input(),
	60	sip_input(), add_ddp_handler(), init_ddp_handler(),
	61	ddp_start(), ddp_input(), appletalk_hack_start();
	62	extern u_short ddp_checksum();
	63	extern at_ifaddr_t *forUs();
	64	extern struct mbuf m_dup(struct mbuf , int);
65
66	extern at_ifaddr_t *ifID_home;
67	extern int xpatcnt;
68
69	struct atpcb ddp_head;
70	u_long ddp_sendspace = 600, /* * what should this value be? * */
71	ddp_recvspace = 50 * (600 + sizeof(struct sockaddr_at));
72
73	int ddp_pru_control(struct socket *so, u_long cmd, caddr_t data,
74	struct ifnet ifp, struct proc p)
75	{
76	return(at_control(so, cmd, data, ifp));
77	}
78
79
80	int ddp_pru_attach(struct socket *so, int proto,
81	struct proc *p)
82	{
83	int s, error = 0;
84	at_ddp_t *ddp = NULL;
85	struct atpcb pcb = (struct atpcb )((so)->so_pcb);
86
87	s = splnet();
88	error = at_pcballoc(so, &ddp_head);
89	splx(s);
90	if (error)
91	return error;
92	error = soreserve(so, ddp_sendspace, ddp_recvspace);
93	pcb = (struct atpcb *)((so)->so_pcb);
94	pcb->pid = current_proc()->p_pid;
95	pcb->ddptype = (u_char) proto; /* set in socreate() */
96	pcb->proto = ATPROTO_DDP;
97
98	return error;
99	}
100
101
102	int ddp_pru_disconnect(struct socket *so)
103	{
104
105	int s, error = 0;
106	at_ddp_t *ddp = NULL;
107	struct atpcb pcb = (struct atpcb )((so)->so_pcb);
108
109	if (pcb == NULL)
110	return (EINVAL);
111
112	if ((so->so_state & SS_ISCONNECTED) == 0)
113	return ENOTCONN;
114
115	soisdisconnected(so);
116	s = splnet();
117	at_pcbdetach(pcb);
118	splx(s);
119
120	return error;
121	}
122
123
124	int ddp_pru_abort(struct socket *so)
125	{
126	int s;
127	struct atpcb pcb = (struct atpcb )((so)->so_pcb);
128
129	if (pcb == NULL)
130	return (EINVAL);
131
132	soisdisconnected(so);
133	s = splnet();
134	at_pcbdetach(pcb);
135	splx(s);
136
137	return 0;
138	}
139
140	int ddp_pru_detach(struct socket *so)
141	{
142	int s;
143	struct atpcb pcb = (struct atpcb )((so)->so_pcb);
144
145	if (pcb == NULL)
146	return (EINVAL);
147
148	s = splnet();
149	at_pcbdetach(pcb);
150	splx(s);
151	return 0;
152	}
153
154	int ddp_pru_shutdown(struct socket *so)
155	{
156	struct atpcb pcb = (struct atpcb )((so)->so_pcb);
157
158	if (pcb == NULL)
159	return (EINVAL);
160
161	socantsendmore(so);
162	return 0;
163	}
164
165
166	int ddp_pru_bind(struct socket so, struct sockaddr nam,
167	struct proc *p)
168	{
169	struct atpcb pcb = (struct atpcb )((so)->so_pcb);
170
171	if (pcb == NULL)
172	return (EINVAL);
173
174	return (at_pcbbind(pcb, nam));
175	}
176
177
178	int ddp_pru_send(struct socket so, int flags, struct mbuf m,
179	struct sockaddr addr, struct mbuf control,
180	struct proc *p)
181	{
182	at_ddp_t *ddp = NULL;
183	struct atpcb pcb = (struct atpcb )((so)->so_pcb);
184
185	if (pcb == NULL)
186	return (EINVAL);
187
188	if (!(pcb->ddp_flags & DDPFLG_HDRINCL)) {
189	/* prepend a DDP header */
190	M_PREPEND(m, DDP_X_HDR_SIZE, M_WAIT);
191	ddp = mtod(m, at_ddp_t *);
192	}
193
194	if (so->so_state & SS_ISCONNECTED) {
195	if (addr)
196	return EISCONN;
197
198	if (ddp) {
199	NET_ASSIGN(ddp->dst_net, pcb->raddr.s_net);
200	ddp->dst_node = pcb->raddr.s_node;
201	ddp->dst_socket = pcb->rport;
202	}
203	} else {
204	if (addr == NULL)
205	return ENOTCONN;
206
207	if (ddp) {
208	struct sockaddr_at *dst =
209	(struct sockaddr_at *) addr;
210	NET_ASSIGN(ddp->dst_net, dst->sat_addr.s_net);
211	ddp->dst_node = dst->sat_addr.s_node;
212	ddp->dst_socket = dst->sat_port;
213	}
214	}
215	if (ddp) {
216	ddp->length = m->m_pkthdr.len;
217	UAS_ASSIGN(ddp->checksum,
218	(pcb->ddp_flags & DDPFLG_CHKSUM)? 1: 0);
219	ddp->type = (pcb->ddptype)? pcb->ddptype: DEFAULT_OT_DDPTYPE;
220	#ifdef NOT_YET
221	NET_ASSIGN(ddp->src_net, pcb->laddr.s_net);
222	ddp->src_node = pcb->laddr.s_node;
223	ddp->src_socket = pcb->lport;
224	#endif
225	} else {
226	ddp = mtod(m, at_ddp_t *);
227	}
228	if (NET_VALUE(ddp->dst_net) == ATADDR_ANYNET &&
229	ddp->dst_node == ATADDR_BCASTNODE &&
230	(pcb->ddp_flags & DDPFLG_SLFSND)) {
231	struct mbuf *n;
232
233	if ((n = m_dup(m, M_DONTWAIT))) {
234	at_ifaddr_t
235	*ifID = ifID_home,
236	ifIDTmp = (at_ifaddr_t )NULL;
237
238	/* as in ddp_output() loop processing, fill in the
239	rest of the header */
240	ddp = mtod(n, at_ddp_t *);
241	if (MULTIHOME_MODE && (ifIDTmp = forUs(ddp)))
242	ifID = ifIDTmp;
243	NET_ASSIGN(ddp->src_net, ifID->ifThisNode.s_net);
244	ddp->src_node = ifID->ifThisNode.s_node;
245	ddp->src_socket = pcb->lport;
246	if (UAS_VALUE(ddp->checksum))
247	UAS_ASSIGN(ddp->checksum, ddp_checksum(m, 4));
248	ddp_input(n, ifID);
249	}
250	}
251	return(ddp_output(&m, pcb->lport, FALSE));
252	} /* ddp_pru_send */
253
254	int ddp_pru_sockaddr(struct socket *so,
255	struct sockaddr **nam)
256	{
257	int s;
258	struct atpcb *pcb;
259	struct sockaddr_at *sat;
260
261	MALLOC(sat, struct sockaddr_at , sizeof sat, M_SONAME, M_WAITOK);
262	bzero((caddr_t)sat, sizeof(*sat));
263
264	s = splnet();
265	if ((pcb = sotoatpcb(so)) == NULL) {
266	splx(s);
267	FREE(sat, M_SONAME);
268	return(EINVAL);
269	}
270
271	sat->sat_family = AF_APPLETALK;
272	sat->sat_len = sizeof(*sat);
273	sat->sat_port = pcb->lport;
274	sat->sat_addr = pcb->laddr;
275	splx(s);
276
277	nam = (struct sockaddr )sat;
278	return(0);
279	}
280
281
282	int ddp_pru_peeraddr(struct socket *so,
283	struct sockaddr **nam)
284	{
285	int s;
286	struct atpcb *pcb;
287	struct sockaddr_at *sat;
288
289	MALLOC(sat, struct sockaddr_at , sizeof sat, M_SONAME, M_WAITOK);
290	bzero((caddr_t)sat, sizeof(*sat));
291
292	s = splnet();
293	if ((pcb = sotoatpcb(so)) == NULL) {
294	splx(s);
295	FREE(sat, M_SONAME);
296	return(EINVAL);
297	}
298
299	sat->sat_family = AF_APPLETALK;
300	sat->sat_len = sizeof(*sat);
301	sat->sat_port = pcb->rport;
302	sat->sat_addr = pcb->raddr;
303	splx(s);
304
305	nam = (struct sockaddr )sat;
306	return(0);
307	}
308
309
310	int ddp_pru_connect(struct socket so, struct sockaddr nam,
311	struct proc *p)
312	{
313	struct atpcb pcb = (struct atpcb )((so)->so_pcb);
314	struct sockaddr_at faddr = (struct sockaddr_at ) nam;
315
316	if (pcb != NULL)
317	return (EINVAL);
318
319	if (xpatcnt == 0)
320	return (EADDRNOTAVAIL);
321
322	if (faddr->sat_family != AF_APPLETALK)
323	return (EAFNOSUPPORT);
324
325	pcb->raddr = faddr->sat_addr;
326	soisconnected(so);
327	return 0;
328	}
329
330
331
332	/*
333	* One-time AppleTalk initialization
334	*/
335	void ddp_init()
336	{
337	at_memzone_init();
338	ddp_head.atpcb_next = ddp_head.atpcb_prev = &ddp_head;
339	init_ddp_handler();
340
341	/* Initialize protocols implemented in the kernel */
342	add_ddp_handler(EP_SOCKET, ep_input);
343	add_ddp_handler(ZIP_SOCKET, zip_router_input);
344	add_ddp_handler(NBP_SOCKET, nbp_input);
345	add_ddp_handler(DDP_SOCKET_1st_DYNAMIC, sip_input);
346
347	ddp_start();
348
349	appletalk_hack_start();
350	} /* ddp_init */
351