1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	* DDP: An implementation of the AppleTalk DDP protocol for
4	* Ethernet 'ELAP'.
5	*
6	* Alan Cox <alan@lxorguk.ukuu.org.uk>
7	*
8	* With more than a little assistance from
9	*
10	* Wesley Craig <netatalk@umich.edu>
11	*
12	* Fixes:
13	* Neil Horman : Added missing device ioctls
14	* Michael Callahan : Made routing work
15	* Wesley Craig : Fix probing to listen to a
16	* passed node id.
17	* Alan Cox : Added send/recvmsg support
18	* Alan Cox : Moved at. to protinfo in
19	* socket.
20	* Alan Cox : Added firewall hooks.
21	* Alan Cox : Supports new ARPHRD_LOOPBACK
22	* Christer Weinigel : Routing and /proc fixes.
23	* Bradford Johnson : LocalTalk.
24	* Tom Dyas : Module support.
25	* Alan Cox : Hooks for PPP (based on the
26	* LocalTalk hook).
27	* Alan Cox : Posix bits
28	* Alan Cox/Mike Freeman : Possible fix to NBP problems
29	* Bradford Johnson : IP-over-DDP (experimental)
30	* Jay Schulist : Moved IP-over-DDP to its own
31	* driver file. (ipddp.c & ipddp.h)
32	* Jay Schulist : Made work as module with
33	* AppleTalk drivers, cleaned it.
34	* Rob Newberry : Added proxy AARP and AARP
35	* procfs, moved probing to AARP
36	* module.
37	* Adrian Sun/
38	* Michael Zuelsdorff : fix for net.0 packets. don't
39	* allow illegal ether/tokentalk
40	* port assignment. we lose a
41	* valid localtalk port as a
42	* result.
43	* Arnaldo C. de Melo : Cleanup, in preparation for
44	* shared skb support 8)
45	* Arnaldo C. de Melo : Move proc stuff to atalk_proc.c,
46	* use seq_file
47	*/
48
49	#include <linux/capability.h>
50	#include <linux/module.h>
51	#include <linux/if_arp.h>
52	#include <linux/termios.h> /* For TIOCOUTQ/INQ */
53	#include <linux/compat.h>
54	#include <linux/slab.h>
55	#include <net/datalink.h>
56	#include <net/psnap.h>
57	#include <net/sock.h>
58	#include <net/tcp_states.h>
59	#include <net/route.h>
60	#include <net/compat.h>
61	#include <linux/atalk.h>
62	#include <linux/highmem.h>
63
64	struct datalink_proto *ddp_dl, *aarp_dl;
65	static const struct proto_ops atalk_dgram_ops;
66
67	/**************************************************************************\
68	* *
69	* Handlers for the socket list. *
70	* *
71	\**************************************************************************/
72
73	HLIST_HEAD(atalk_sockets);
74	DEFINE_RWLOCK(atalk_sockets_lock);
75
76	static inline void __atalk_insert_socket(struct sock *sk)
77	{
78	sk_add_node(sk, list: &atalk_sockets);
79	}
80
81	static inline void atalk_remove_socket(struct sock *sk)
82	{
83	write_lock_bh(&atalk_sockets_lock);
84	sk_del_node_init(sk);
85	write_unlock_bh(&atalk_sockets_lock);
86	}
87
88	static struct sock *atalk_search_socket(struct sockaddr_at *to,
89	struct atalk_iface *atif)
90	{
91	struct sock *s;
92
93	read_lock_bh(&atalk_sockets_lock);
94	sk_for_each(s, &atalk_sockets) {
95	struct atalk_sock *at = at_sk(sk: s);
96
97	if (to->sat_port != at->src_port)
98	continue;
99
100	if (to->sat_addr.s_net == ATADDR_ANYNET &&
101	to->sat_addr.s_node == ATADDR_BCAST)
102	goto found;
103
104	if (to->sat_addr.s_net == at->src_net &&
105	(to->sat_addr.s_node == at->src_node ||
106	to->sat_addr.s_node == ATADDR_BCAST ||
107	to->sat_addr.s_node == ATADDR_ANYNODE))
108	goto found;
109
110	/* XXXX.0 -- we got a request for this router. make sure
111	* that the node is appropriately set. */
112	if (to->sat_addr.s_node == ATADDR_ANYNODE &&
113	to->sat_addr.s_net != ATADDR_ANYNET &&
114	atif->address.s_node == at->src_node) {
115	to->sat_addr.s_node = atif->address.s_node;
116	goto found;
117	}
118	}
119	s = NULL;
120	found:
121	read_unlock_bh(&atalk_sockets_lock);
122	return s;
123	}
124
125	/**
126	* atalk_find_or_insert_socket - Try to find a socket matching ADDR
127	* @sk: socket to insert in the list if it is not there already
128	* @sat: address to search for
129	*
130	* Try to find a socket matching ADDR in the socket list, if found then return
131	* it. If not, insert SK into the socket list.
132	*
133	* This entire operation must execute atomically.
134	*/
135	static struct sock *atalk_find_or_insert_socket(struct sock *sk,
136	struct sockaddr_at *sat)
137	{
138	struct sock *s;
139	struct atalk_sock *at;
140
141	write_lock_bh(&atalk_sockets_lock);
142	sk_for_each(s, &atalk_sockets) {
143	at = at_sk(sk: s);
144
145	if (at->src_net == sat->sat_addr.s_net &&
146	at->src_node == sat->sat_addr.s_node &&
147	at->src_port == sat->sat_port)
148	goto found;
149	}
150	s = NULL;
151	__atalk_insert_socket(sk); /* Wheee, it's free, assign and insert. */
152	found:
153	write_unlock_bh(&atalk_sockets_lock);
154	return s;
155	}
156
157	static void atalk_destroy_timer(struct timer_list *t)
158	{
159	struct sock *sk = from_timer(sk, t, sk_timer);
160
161	if (sk_has_allocations(sk)) {
162	sk->sk_timer.expires = jiffies + SOCK_DESTROY_TIME;
163	add_timer(timer: &sk->sk_timer);
164	} else
165	sock_put(sk);
166	}
167
168	static inline void atalk_destroy_socket(struct sock *sk)
169	{
170	atalk_remove_socket(sk);
171	skb_queue_purge(list: &sk->sk_receive_queue);
172
173	if (sk_has_allocations(sk)) {
174	timer_setup(&sk->sk_timer, atalk_destroy_timer, 0);
175	sk->sk_timer.expires = jiffies + SOCK_DESTROY_TIME;
176	add_timer(timer: &sk->sk_timer);
177	} else
178	sock_put(sk);
179	}
180
181	/**************************************************************************\
182	* *
183	* Routing tables for the AppleTalk socket layer. *
184	* *
185	\**************************************************************************/
186
187	/* Anti-deadlock ordering is atalk_routes_lock --> iface_lock -DaveM */
188	struct atalk_route *atalk_routes;
189	DEFINE_RWLOCK(atalk_routes_lock);
190
191	struct atalk_iface *atalk_interfaces;
192	DEFINE_RWLOCK(atalk_interfaces_lock);
193
194	/* For probing devices or in a routerless network */
195	struct atalk_route atrtr_default;
196
197	/* AppleTalk interface control */
198	/*
199	* Drop a device. Doesn't drop any of its routes - that is the caller's
200	* problem. Called when we down the interface or delete the address.
201	*/
202	static void atif_drop_device(struct net_device *dev)
203	{
204	struct atalk_iface **iface = &atalk_interfaces;
205	struct atalk_iface *tmp;
206
207	write_lock_bh(&atalk_interfaces_lock);
208	while ((tmp = *iface) != NULL) {
209	if (tmp->dev == dev) {
210	*iface = tmp->next;
211	dev_put(dev);
212	kfree(objp: tmp);
213	dev->atalk_ptr = NULL;
214	} else
215	iface = &tmp->next;
216	}
217	write_unlock_bh(&atalk_interfaces_lock);
218	}
219
220	static struct atalk_iface *atif_add_device(struct net_device *dev,
221	struct atalk_addr *sa)
222	{
223	struct atalk_iface *iface = kzalloc(size: sizeof(*iface), GFP_KERNEL);
224
225	if (!iface)
226	goto out;
227
228	dev_hold(dev);
229	iface->dev = dev;
230	dev->atalk_ptr = iface;
231	iface->address = *sa;
232	iface->status = 0;
233
234	write_lock_bh(&atalk_interfaces_lock);
235	iface->next = atalk_interfaces;
236	atalk_interfaces = iface;
237	write_unlock_bh(&atalk_interfaces_lock);
238	out:
239	return iface;
240	}
241
242	/* Perform phase 2 AARP probing on our tentative address */
243	static int atif_probe_device(struct atalk_iface *atif)
244	{
245	int netrange = ntohs(atif->nets.nr_lastnet) -
246	ntohs(atif->nets.nr_firstnet) + 1;
247	int probe_net = ntohs(atif->address.s_net);
248	int probe_node = atif->address.s_node;
249	int netct, nodect;
250
251	/* Offset the network we start probing with */
252	if (probe_net == ATADDR_ANYNET) {
253	probe_net = ntohs(atif->nets.nr_firstnet);
254	if (netrange)
255	probe_net += jiffies % netrange;
256	}
257	if (probe_node == ATADDR_ANYNODE)
258	probe_node = jiffies & 0xFF;
259
260	/* Scan the networks */
261	atif->status |= ATIF_PROBE;
262	for (netct = 0; netct <= netrange; netct++) {
263	/* Sweep the available nodes from a given start */
264	atif->address.s_net = htons(probe_net);
265	for (nodect = 0; nodect < 256; nodect++) {
266	atif->address.s_node = (nodect + probe_node) & 0xFF;
267	if (atif->address.s_node > 0 &&
268	atif->address.s_node < 254) {
269	/* Probe a proposed address */
270	aarp_probe_network(atif);
271
272	if (!(atif->status & ATIF_PROBE_FAIL)) {
273	atif->status &= ~ATIF_PROBE;
274	return 0;
275	}
276	}
277	atif->status &= ~ATIF_PROBE_FAIL;
278	}
279	probe_net++;
280	if (probe_net > ntohs(atif->nets.nr_lastnet))
281	probe_net = ntohs(atif->nets.nr_firstnet);
282	}
283	atif->status &= ~ATIF_PROBE;
284
285	return -EADDRINUSE; /* Network is full... */
286	}
287
288
289	/* Perform AARP probing for a proxy address */
290	static int atif_proxy_probe_device(struct atalk_iface *atif,
291	struct atalk_addr *proxy_addr)
292	{
293	int netrange = ntohs(atif->nets.nr_lastnet) -
294	ntohs(atif->nets.nr_firstnet) + 1;
295	/* we probe the interface's network */
296	int probe_net = ntohs(atif->address.s_net);
297	int probe_node = ATADDR_ANYNODE; /* we'll take anything */
298	int netct, nodect;
299
300	/* Offset the network we start probing with */
301	if (probe_net == ATADDR_ANYNET) {
302	probe_net = ntohs(atif->nets.nr_firstnet);
303	if (netrange)
304	probe_net += jiffies % netrange;
305	}
306
307	if (probe_node == ATADDR_ANYNODE)
308	probe_node = jiffies & 0xFF;
309
310	/* Scan the networks */
311	for (netct = 0; netct <= netrange; netct++) {
312	/* Sweep the available nodes from a given start */
313	proxy_addr->s_net = htons(probe_net);
314	for (nodect = 0; nodect < 256; nodect++) {
315	proxy_addr->s_node = (nodect + probe_node) & 0xFF;
316	if (proxy_addr->s_node > 0 &&
317	proxy_addr->s_node < 254) {
318	/* Tell AARP to probe a proposed address */
319	int ret = aarp_proxy_probe_network(atif,
320	sa: proxy_addr);
321
322	if (ret != -EADDRINUSE)
323	return ret;
324	}
325	}
326	probe_net++;
327	if (probe_net > ntohs(atif->nets.nr_lastnet))
328	probe_net = ntohs(atif->nets.nr_firstnet);
329	}
330
331	return -EADDRINUSE; /* Network is full... */
332	}
333
334
335	struct atalk_addr *atalk_find_dev_addr(struct net_device *dev)
336	{
337	struct atalk_iface *iface = dev->atalk_ptr;
338	return iface ? &iface->address : NULL;
339	}
340
341	static struct atalk_addr *atalk_find_primary(void)
342	{
343	struct atalk_iface *fiface = NULL;
344	struct atalk_addr *retval;
345	struct atalk_iface *iface;
346
347	/*
348	* Return a point-to-point interface only if
349	* there is no non-ptp interface available.
350	*/
351	read_lock_bh(&atalk_interfaces_lock);
352	for (iface = atalk_interfaces; iface; iface = iface->next) {
353	if (!fiface && !(iface->dev->flags & IFF_LOOPBACK))
354	fiface = iface;
355	if (!(iface->dev->flags & (IFF_LOOPBACK | IFF_POINTOPOINT))) {
356	retval = &iface->address;
357	goto out;
358	}
359	}
360
361	if (fiface)
362	retval = &fiface->address;
363	else if (atalk_interfaces)
364	retval = &atalk_interfaces->address;
365	else
366	retval = NULL;
367	out:
368	read_unlock_bh(&atalk_interfaces_lock);
369	return retval;
370	}
371
372	/*
373	* Find a match for 'any network' - ie any of our interfaces with that
374	* node number will do just nicely.
375	*/
376	static struct atalk_iface *atalk_find_anynet(int node, struct net_device *dev)
377	{
378	struct atalk_iface *iface = dev->atalk_ptr;
379
380	if (!iface || iface->status & ATIF_PROBE)
381	goto out_err;
382
383	if (node != ATADDR_BCAST &&
384	iface->address.s_node != node &&
385	node != ATADDR_ANYNODE)
386	goto out_err;
387	out:
388	return iface;
389	out_err:
390	iface = NULL;
391	goto out;
392	}
393
394	/* Find a match for a specific network:node pair */
395	static struct atalk_iface *atalk_find_interface(__be16 net, int node)
396	{
397	struct atalk_iface *iface;
398
399	read_lock_bh(&atalk_interfaces_lock);
400	for (iface = atalk_interfaces; iface; iface = iface->next) {
401	if ((node == ATADDR_BCAST ||
402	node == ATADDR_ANYNODE ||
403	iface->address.s_node == node) &&
404	iface->address.s_net == net &&
405	!(iface->status & ATIF_PROBE))
406	break;
407
408	/* XXXX.0 -- net.0 returns the iface associated with net */
409	if (node == ATADDR_ANYNODE && net != ATADDR_ANYNET &&
410	ntohs(iface->nets.nr_firstnet) <= ntohs(net) &&
411	ntohs(net) <= ntohs(iface->nets.nr_lastnet))
412	break;
413	}
414	read_unlock_bh(&atalk_interfaces_lock);
415	return iface;
416	}
417
418
419	/*
420	* Find a route for an AppleTalk packet. This ought to get cached in
421	* the socket (later on...). We know about host routes and the fact
422	* that a route must be direct to broadcast.
423	*/
424	static struct atalk_route *atrtr_find(struct atalk_addr *target)
425	{
426	/*
427	* we must search through all routes unless we find a
428	* host route, because some host routes might overlap
429	* network routes
430	*/
431	struct atalk_route *net_route = NULL;
432	struct atalk_route *r;
433
434	read_lock_bh(&atalk_routes_lock);
435	for (r = atalk_routes; r; r = r->next) {
436	if (!(r->flags & RTF_UP))
437	continue;
438
439	if (r->target.s_net == target->s_net) {
440	if (r->flags & RTF_HOST) {
441	/*
442	* if this host route is for the target,
443	* the we're done
444	*/
445	if (r->target.s_node == target->s_node)
446	goto out;
447	} else
448	/*
449	* this route will work if there isn't a
450	* direct host route, so cache it
451	*/
452	net_route = r;
453	}
454	}
455
456	/*
457	* if we found a network route but not a direct host
458	* route, then return it
459	*/
460	if (net_route)
461	r = net_route;
462	else if (atrtr_default.dev)
463	r = &atrtr_default;
464	else /* No route can be found */
465	r = NULL;
466	out:
467	read_unlock_bh(&atalk_routes_lock);
468	return r;
469	}
470
471
472	/*
473	* Given an AppleTalk network, find the device to use. This can be
474	* a simple lookup.
475	*/
476	struct net_device *atrtr_get_dev(struct atalk_addr *sa)
477	{
478	struct atalk_route *atr = atrtr_find(target: sa);
479	return atr ? atr->dev : NULL;
480	}
481
482	/* Set up a default router */
483	static void atrtr_set_default(struct net_device *dev)
484	{
485	atrtr_default.dev = dev;
486	atrtr_default.flags = RTF_UP;
487	atrtr_default.gateway.s_net = htons(0);
488	atrtr_default.gateway.s_node = 0;
489	}
490
491	/*
492	* Add a router. Basically make sure it looks valid and stuff the
493	* entry in the list. While it uses netranges we always set them to one
494	* entry to work like netatalk.
495	*/
496	static int atrtr_create(struct rtentry *r, struct net_device *devhint)
497	{
498	struct sockaddr_at *ta = (struct sockaddr_at *)&r->rt_dst;
499	struct sockaddr_at *ga = (struct sockaddr_at *)&r->rt_gateway;
500	struct atalk_route *rt;
501	struct atalk_iface *iface, *riface;
502	int retval = -EINVAL;
503
504	/*
505	* Fixme: Raise/Lower a routing change semaphore for these
506	* operations.
507	*/
508
509	/* Validate the request */
510	if (ta->sat_family != AF_APPLETALK ||
511	(!devhint && ga->sat_family != AF_APPLETALK))
512	goto out;
513
514	/* Now walk the routing table and make our decisions */
515	write_lock_bh(&atalk_routes_lock);
516	for (rt = atalk_routes; rt; rt = rt->next) {
517	if (r->rt_flags != rt->flags)
518	continue;
519
520	if (ta->sat_addr.s_net == rt->target.s_net) {
521	if (!(rt->flags & RTF_HOST))
522	break;
523	if (ta->sat_addr.s_node == rt->target.s_node)
524	break;
525	}
526	}
527
528	if (!devhint) {
529	riface = NULL;
530
531	read_lock_bh(&atalk_interfaces_lock);
532	for (iface = atalk_interfaces; iface; iface = iface->next) {
533	if (!riface &&
534	ntohs(ga->sat_addr.s_net) >=
535	ntohs(iface->nets.nr_firstnet) &&
536	ntohs(ga->sat_addr.s_net) <=
537	ntohs(iface->nets.nr_lastnet))
538	riface = iface;
539
540	if (ga->sat_addr.s_net == iface->address.s_net &&
541	ga->sat_addr.s_node == iface->address.s_node)
542	riface = iface;
543	}
544	read_unlock_bh(&atalk_interfaces_lock);
545
546	retval = -ENETUNREACH;
547	if (!riface)
548	goto out_unlock;
549
550	devhint = riface->dev;
551	}
552
553	if (!rt) {
554	rt = kzalloc(size: sizeof(*rt), GFP_ATOMIC);
555
556	retval = -ENOBUFS;
557	if (!rt)
558	goto out_unlock;
559
560	rt->next = atalk_routes;
561	atalk_routes = rt;
562	}
563
564	/* Fill in the routing entry */
565	rt->target = ta->sat_addr;
566	dev_hold(dev: devhint);
567	rt->dev = devhint;
568	rt->flags = r->rt_flags;
569	rt->gateway = ga->sat_addr;
570
571	retval = 0;
572	out_unlock:
573	write_unlock_bh(&atalk_routes_lock);
574	out:
575	return retval;
576	}
577
578	/* Delete a route. Find it and discard it */
579	static int atrtr_delete(struct atalk_addr *addr)
580	{
581	struct atalk_route **r = &atalk_routes;
582	int retval = 0;
583	struct atalk_route *tmp;
584
585	write_lock_bh(&atalk_routes_lock);
586	while ((tmp = *r) != NULL) {
587	if (tmp->target.s_net == addr->s_net &&
588	(!(tmp->flags&RTF_GATEWAY) ||
589	tmp->target.s_node == addr->s_node)) {
590	*r = tmp->next;
591	dev_put(dev: tmp->dev);
592	kfree(objp: tmp);
593	goto out;
594	}
595	r = &tmp->next;
596	}
597	retval = -ENOENT;
598	out:
599	write_unlock_bh(&atalk_routes_lock);
600	return retval;
601	}
602
603	/*
604	* Called when a device is downed. Just throw away any routes
605	* via it.
606	*/
607	static void atrtr_device_down(struct net_device *dev)
608	{
609	struct atalk_route **r = &atalk_routes;
610	struct atalk_route *tmp;
611
612	write_lock_bh(&atalk_routes_lock);
613	while ((tmp = *r) != NULL) {
614	if (tmp->dev == dev) {
615	*r = tmp->next;
616	dev_put(dev);
617	kfree(objp: tmp);
618	} else
619	r = &tmp->next;
620	}
621	write_unlock_bh(&atalk_routes_lock);
622
623	if (atrtr_default.dev == dev)
624	atrtr_set_default(NULL);
625	}
626
627	/* Actually down the interface */
628	static inline void atalk_dev_down(struct net_device *dev)
629	{
630	atrtr_device_down(dev); /* Remove all routes for the device */
631	aarp_device_down(dev); /* Remove AARP entries for the device */
632	atif_drop_device(dev); /* Remove the device */
633	}
634
635	/*
636	* A device event has occurred. Watch for devices going down and
637	* delete our use of them (iface and route).
638	*/
639	static int ddp_device_event(struct notifier_block *this, unsigned long event,
640	void *ptr)
641	{
642	struct net_device *dev = netdev_notifier_info_to_dev(info: ptr);
643
644	if (!net_eq(net1: dev_net(dev), net2: &init_net))
645	return NOTIFY_DONE;
646
647	if (event == NETDEV_DOWN)
648	/* Discard any use of this */
649	atalk_dev_down(dev);
650
651	return NOTIFY_DONE;
652	}
653
654	/* ioctl calls. Shouldn't even need touching */
655	/* Device configuration ioctl calls */
656	static int atif_ioctl(int cmd, void __user *arg)
657	{
658	static char aarp_mcast[6] = { 0x09, 0x00, 0x00, 0xFF, 0xFF, 0xFF };
659	struct ifreq atreq;
660	struct atalk_netrange *nr;
661	struct sockaddr_at *sa;
662	struct net_device *dev;
663	struct atalk_iface *atif;
664	int ct;
665	int limit;
666	struct rtentry rtdef;
667	int add_route;
668
669	if (get_user_ifreq(ifr: &atreq, NULL, arg))
670	return -EFAULT;
671
672	dev = __dev_get_by_name(net: &init_net, name: atreq.ifr_name);
673	if (!dev)
674	return -ENODEV;
675
676	sa = (struct sockaddr_at *)&atreq.ifr_addr;
677	atif = atalk_find_dev(dev);
678
679	switch (cmd) {
680	case SIOCSIFADDR:
681	if (!capable(CAP_NET_ADMIN))
682	return -EPERM;
683	if (sa->sat_family != AF_APPLETALK)
684	return -EINVAL;
685	if (dev->type != ARPHRD_ETHER &&
686	dev->type != ARPHRD_LOOPBACK &&
687	dev->type != ARPHRD_LOCALTLK &&
688	dev->type != ARPHRD_PPP)
689	return -EPROTONOSUPPORT;
690
691	nr = (struct atalk_netrange *)&sa->sat_zero[0];
692	add_route = 1;
693
694	/*
695	* if this is a point-to-point iface, and we already
696	* have an iface for this AppleTalk address, then we
697	* should not add a route
698	*/
699	if ((dev->flags & IFF_POINTOPOINT) &&
700	atalk_find_interface(net: sa->sat_addr.s_net,
701	node: sa->sat_addr.s_node)) {
702	printk(KERN_DEBUG "AppleTalk: point-to-point "
703	"interface added with "
704	"existing address\n");
705	add_route = 0;
706	}
707
708	/*
709	* Phase 1 is fine on LocalTalk but we don't do
710	* EtherTalk phase 1. Anyone wanting to add it, go ahead.
711	*/
712	if (dev->type == ARPHRD_ETHER && nr->nr_phase != 2)
713	return -EPROTONOSUPPORT;
714	if (sa->sat_addr.s_node == ATADDR_BCAST ||
715	sa->sat_addr.s_node == 254)
716	return -EINVAL;
717	if (atif) {
718	/* Already setting address */
719	if (atif->status & ATIF_PROBE)
720	return -EBUSY;
721
722	atif->address.s_net = sa->sat_addr.s_net;
723	atif->address.s_node = sa->sat_addr.s_node;
724	atrtr_device_down(dev); /* Flush old routes */
725	} else {
726	atif = atif_add_device(dev, sa: &sa->sat_addr);
727	if (!atif)
728	return -ENOMEM;
729	}
730	atif->nets = *nr;
731
732	/*
733	* Check if the chosen address is used. If so we
734	* error and atalkd will try another.
735	*/
736
737	if (!(dev->flags & IFF_LOOPBACK) &&
738	!(dev->flags & IFF_POINTOPOINT) &&
739	atif_probe_device(atif) < 0) {
740	atif_drop_device(dev);
741	return -EADDRINUSE;
742	}
743
744	/* Hey it worked - add the direct routes */
745	sa = (struct sockaddr_at *)&rtdef.rt_gateway;
746	sa->sat_family = AF_APPLETALK;
747	sa->sat_addr.s_net = atif->address.s_net;
748	sa->sat_addr.s_node = atif->address.s_node;
749	sa = (struct sockaddr_at *)&rtdef.rt_dst;
750	rtdef.rt_flags = RTF_UP;
751	sa->sat_family = AF_APPLETALK;
752	sa->sat_addr.s_node = ATADDR_ANYNODE;
753	if (dev->flags & IFF_LOOPBACK ||
754	dev->flags & IFF_POINTOPOINT)
755	rtdef.rt_flags |= RTF_HOST;
756
757	/* Routerless initial state */
758	if (nr->nr_firstnet == htons(0) &&
759	nr->nr_lastnet == htons(0xFFFE)) {
760	sa->sat_addr.s_net = atif->address.s_net;
761	atrtr_create(r: &rtdef, devhint: dev);
762	atrtr_set_default(dev);
763	} else {
764	limit = ntohs(nr->nr_lastnet);
765	if (limit - ntohs(nr->nr_firstnet) > 4096) {
766	printk(KERN_WARNING "Too many routes/"
767	"iface.\n");
768	return -EINVAL;
769	}
770	if (add_route)
771	for (ct = ntohs(nr->nr_firstnet);
772	ct <= limit; ct++) {
773	sa->sat_addr.s_net = htons(ct);
774	atrtr_create(r: &rtdef, devhint: dev);
775	}
776	}
777	dev_mc_add_global(dev, addr: aarp_mcast);
778	return 0;
779
780	case SIOCGIFADDR:
781	if (!atif)
782	return -EADDRNOTAVAIL;
783
784	sa->sat_family = AF_APPLETALK;
785	sa->sat_addr = atif->address;
786	break;
787
788	case SIOCGIFBRDADDR:
789	if (!atif)
790	return -EADDRNOTAVAIL;
791
792	sa->sat_family = AF_APPLETALK;
793	sa->sat_addr.s_net = atif->address.s_net;
794	sa->sat_addr.s_node = ATADDR_BCAST;
795	break;
796
797	case SIOCATALKDIFADDR:
798	case SIOCDIFADDR:
799	if (!capable(CAP_NET_ADMIN))
800	return -EPERM;
801	if (sa->sat_family != AF_APPLETALK)
802	return -EINVAL;
803	atalk_dev_down(dev);
804	break;
805
806	case SIOCSARP:
807	if (!capable(CAP_NET_ADMIN))
808	return -EPERM;
809	if (sa->sat_family != AF_APPLETALK)
810	return -EINVAL;
811	/*
812	* for now, we only support proxy AARP on ELAP;
813	* we should be able to do it for LocalTalk, too.
814	*/
815	if (dev->type != ARPHRD_ETHER)
816	return -EPROTONOSUPPORT;
817
818	/*
819	* atif points to the current interface on this network;
820	* we aren't concerned about its current status (at
821	* least for now), but it has all the settings about
822	* the network we're going to probe. Consequently, it
823	* must exist.
824	*/
825	if (!atif)
826	return -EADDRNOTAVAIL;
827
828	nr = (struct atalk_netrange *)&(atif->nets);
829	/*
830	* Phase 1 is fine on Localtalk but we don't do
831	* Ethertalk phase 1. Anyone wanting to add it, go ahead.
832	*/
833	if (dev->type == ARPHRD_ETHER && nr->nr_phase != 2)
834	return -EPROTONOSUPPORT;
835
836	if (sa->sat_addr.s_node == ATADDR_BCAST ||
837	sa->sat_addr.s_node == 254)
838	return -EINVAL;
839
840	/*
841	* Check if the chosen address is used. If so we
842	* error and ATCP will try another.
843	*/
844	if (atif_proxy_probe_device(atif, proxy_addr: &(sa->sat_addr)) < 0)
845	return -EADDRINUSE;
846
847	/*
848	* We now have an address on the local network, and
849	* the AARP code will defend it for us until we take it
850	* down. We don't set up any routes right now, because
851	* ATCP will install them manually via SIOCADDRT.
852	*/
853	break;
854
855	case SIOCDARP:
856	if (!capable(CAP_NET_ADMIN))
857	return -EPERM;
858	if (sa->sat_family != AF_APPLETALK)
859	return -EINVAL;
860	if (!atif)
861	return -EADDRNOTAVAIL;
862
863	/* give to aarp module to remove proxy entry */
864	aarp_proxy_remove(dev: atif->dev, sa: &(sa->sat_addr));
865	return 0;
866	}
867
868	return put_user_ifreq(ifr: &atreq, arg);
869	}
870
871	static int atrtr_ioctl_addrt(struct rtentry *rt)
872	{
873	struct net_device *dev = NULL;
874
875	if (rt->rt_dev) {
876	char name[IFNAMSIZ];
877
878	if (copy_from_user(to: name, from: rt->rt_dev, IFNAMSIZ-1))
879	return -EFAULT;
880	name[IFNAMSIZ-1] = '\0';
881
882	dev = __dev_get_by_name(net: &init_net, name);
883	if (!dev)
884	return -ENODEV;
885	}
886	return atrtr_create(r: rt, devhint: dev);
887	}
888
889	/* Routing ioctl() calls */
890	static int atrtr_ioctl(unsigned int cmd, void __user *arg)
891	{
892	struct rtentry rt;
893
894	if (copy_from_user(to: &rt, from: arg, n: sizeof(rt)))
895	return -EFAULT;
896
897	switch (cmd) {
898	case SIOCDELRT:
899	if (rt.rt_dst.sa_family != AF_APPLETALK)
900	return -EINVAL;
901	return atrtr_delete(addr: &((struct sockaddr_at *)
902	&rt.rt_dst)->sat_addr);
903
904	case SIOCADDRT:
905	return atrtr_ioctl_addrt(rt: &rt);
906	}
907	return -EINVAL;
908	}
909
910	/**************************************************************************\
911	* *
912	* Handling for system calls applied via the various interfaces to an *
913	* AppleTalk socket object. *
914	* *
915	\**************************************************************************/
916
917	/*
918	* Checksum: This is 'optional'. It's quite likely also a good
919	* candidate for assembler hackery 8)
920	*/
921	static unsigned long atalk_sum_partial(const unsigned char *data,
922	int len, unsigned long sum)
923	{
924	/* This ought to be unwrapped neatly. I'll trust gcc for now */
925	while (len--) {
926	sum += *data++;
927	sum = rol16(word: sum, shift: 1);
928	}
929	return sum;
930	}
931
932	/* Checksum skb data -- similar to skb_checksum */
933	static unsigned long atalk_sum_skb(const struct sk_buff *skb, int offset,
934	int len, unsigned long sum)
935	{
936	int start = skb_headlen(skb);
937	struct sk_buff *frag_iter;
938	int i, copy;
939
940	/* checksum stuff in header space */
941	if ((copy = start - offset) > 0) {
942	if (copy > len)
943	copy = len;
944	sum = atalk_sum_partial(data: skb->data + offset, len: copy, sum);
945	if ((len -= copy) == 0)
946	return sum;
947
948	offset += copy;
949	}
950
951	/* checksum stuff in frags */
952	for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
953	int end;
954	const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
955	WARN_ON(start > offset + len);
956
957	end = start + skb_frag_size(frag);
958	if ((copy = end - offset) > 0) {
959	u8 *vaddr;
960
961	if (copy > len)
962	copy = len;
963	vaddr = kmap_atomic(page: skb_frag_page(frag));
964	sum = atalk_sum_partial(data: vaddr + skb_frag_off(frag) +
965	offset - start, len: copy, sum);
966	kunmap_atomic(vaddr);
967
968	if (!(len -= copy))
969	return sum;
970	offset += copy;
971	}
972	start = end;
973	}
974
975	skb_walk_frags(skb, frag_iter) {
976	int end;
977
978	WARN_ON(start > offset + len);
979
980	end = start + frag_iter->len;
981	if ((copy = end - offset) > 0) {
982	if (copy > len)
983	copy = len;
984	sum = atalk_sum_skb(skb: frag_iter, offset: offset - start,
985	len: copy, sum);
986	if ((len -= copy) == 0)
987	return sum;
988	offset += copy;
989	}
990	start = end;
991	}
992
993	BUG_ON(len > 0);
994
995	return sum;
996	}
997
998	static __be16 atalk_checksum(const struct sk_buff *skb, int len)
999	{
1000	unsigned long sum;
1001
1002	/* skip header 4 bytes */
1003	sum = atalk_sum_skb(skb, offset: 4, len: len-4, sum: 0);
1004
1005	/* Use 0xFFFF for 0. 0 itself means none */
1006	return sum ? htons((unsigned short)sum) : htons(0xFFFF);
1007	}
1008
1009	static struct proto ddp_proto = {
1010	.name = "DDP",
1011	.owner = THIS_MODULE,
1012	.obj_size = sizeof(struct atalk_sock),
1013	};
1014
1015	/*
1016	* Create a socket. Initialise the socket, blank the addresses
1017	* set the state.
1018	*/
1019	static int atalk_create(struct net *net, struct socket *sock, int protocol,
1020	int kern)
1021	{
1022	struct sock *sk;
1023	int rc = -ESOCKTNOSUPPORT;
1024
1025	if (!net_eq(net1: net, net2: &init_net))
1026	return -EAFNOSUPPORT;
1027
1028	/*
1029	* We permit SOCK_DGRAM and RAW is an extension. It is trivial to do
1030	* and gives you the full ELAP frame. Should be handy for CAP 8)
1031	*/
1032	if (sock->type != SOCK_RAW && sock->type != SOCK_DGRAM)
1033	goto out;
1034
1035	rc = -EPERM;
1036	if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1037	goto out;
1038
1039	rc = -ENOMEM;
1040	sk = sk_alloc(net, PF_APPLETALK, GFP_KERNEL, prot: &ddp_proto, kern);
1041	if (!sk)
1042	goto out;
1043	rc = 0;
1044	sock->ops = &atalk_dgram_ops;
1045	sock_init_data(sock, sk);
1046
1047	/* Checksums on by default */
1048	sock_set_flag(sk, flag: SOCK_ZAPPED);
1049	out:
1050	return rc;
1051	}
1052
1053	/* Free a socket. No work needed */
1054	static int atalk_release(struct socket *sock)
1055	{
1056	struct sock *sk = sock->sk;
1057
1058	if (sk) {
1059	sock_hold(sk);
1060	lock_sock(sk);
1061
1062	sock_orphan(sk);
1063	sock->sk = NULL;
1064	atalk_destroy_socket(sk);
1065
1066	release_sock(sk);
1067	sock_put(sk);
1068	}
1069	return 0;
1070	}
1071
1072	/**
1073	* atalk_pick_and_bind_port - Pick a source port when one is not given
1074	* @sk: socket to insert into the tables
1075	* @sat: address to search for
1076	*
1077	* Pick a source port when one is not given. If we can find a suitable free
1078	* one, we insert the socket into the tables using it.
1079	*
1080	* This whole operation must be atomic.
1081	*/
1082	static int atalk_pick_and_bind_port(struct sock *sk, struct sockaddr_at *sat)
1083	{
1084	int retval;
1085
1086	write_lock_bh(&atalk_sockets_lock);
1087
1088	for (sat->sat_port = ATPORT_RESERVED;
1089	sat->sat_port < ATPORT_LAST;
1090	sat->sat_port++) {
1091	struct sock *s;
1092
1093	sk_for_each(s, &atalk_sockets) {
1094	struct atalk_sock *at = at_sk(sk: s);
1095
1096	if (at->src_net == sat->sat_addr.s_net &&
1097	at->src_node == sat->sat_addr.s_node &&
1098	at->src_port == sat->sat_port)
1099	goto try_next_port;
1100	}
1101
1102	/* Wheee, it's free, assign and insert. */
1103	__atalk_insert_socket(sk);
1104	at_sk(sk)->src_port = sat->sat_port;
1105	retval = 0;
1106	goto out;
1107
1108	try_next_port:;
1109	}
1110
1111	retval = -EBUSY;
1112	out:
1113	write_unlock_bh(&atalk_sockets_lock);
1114	return retval;
1115	}
1116
1117	static int atalk_autobind(struct sock *sk)
1118	{
1119	struct atalk_sock *at = at_sk(sk);
1120	struct sockaddr_at sat;
1121	struct atalk_addr *ap = atalk_find_primary();
1122	int n = -EADDRNOTAVAIL;
1123
1124	if (!ap || ap->s_net == htons(ATADDR_ANYNET))
1125	goto out;
1126
1127	at->src_net = sat.sat_addr.s_net = ap->s_net;
1128	at->src_node = sat.sat_addr.s_node = ap->s_node;
1129
1130	n = atalk_pick_and_bind_port(sk, sat: &sat);
1131	if (!n)
1132	sock_reset_flag(sk, flag: SOCK_ZAPPED);
1133	out:
1134	return n;
1135	}
1136
1137	/* Set the address 'our end' of the connection */
1138	static int atalk_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1139	{
1140	struct sockaddr_at *addr = (struct sockaddr_at *)uaddr;
1141	struct sock *sk = sock->sk;
1142	struct atalk_sock *at = at_sk(sk);
1143	int err;
1144
1145	if (!sock_flag(sk, flag: SOCK_ZAPPED) ||
1146	addr_len != sizeof(struct sockaddr_at))
1147	return -EINVAL;
1148
1149	if (addr->sat_family != AF_APPLETALK)
1150	return -EAFNOSUPPORT;
1151
1152	lock_sock(sk);
1153	if (addr->sat_addr.s_net == htons(ATADDR_ANYNET)) {
1154	struct atalk_addr *ap = atalk_find_primary();
1155
1156	err = -EADDRNOTAVAIL;
1157	if (!ap)
1158	goto out;
1159
1160	at->src_net = addr->sat_addr.s_net = ap->s_net;
1161	at->src_node = addr->sat_addr.s_node = ap->s_node;
1162	} else {
1163	err = -EADDRNOTAVAIL;
1164	if (!atalk_find_interface(net: addr->sat_addr.s_net,
1165	node: addr->sat_addr.s_node))
1166	goto out;
1167
1168	at->src_net = addr->sat_addr.s_net;
1169	at->src_node = addr->sat_addr.s_node;
1170	}
1171
1172	if (addr->sat_port == ATADDR_ANYPORT) {
1173	err = atalk_pick_and_bind_port(sk, sat: addr);
1174
1175	if (err < 0)
1176	goto out;
1177	} else {
1178	at->src_port = addr->sat_port;
1179
1180	err = -EADDRINUSE;
1181	if (atalk_find_or_insert_socket(sk, sat: addr))
1182	goto out;
1183	}
1184
1185	sock_reset_flag(sk, flag: SOCK_ZAPPED);
1186	err = 0;
1187	out:
1188	release_sock(sk);
1189	return err;
1190	}
1191
1192	/* Set the address we talk to */
1193	static int atalk_connect(struct socket *sock, struct sockaddr *uaddr,
1194	int addr_len, int flags)
1195	{
1196	struct sock *sk = sock->sk;
1197	struct atalk_sock *at = at_sk(sk);
1198	struct sockaddr_at *addr;
1199	int err;
1200
1201	sk->sk_state = TCP_CLOSE;
1202	sock->state = SS_UNCONNECTED;
1203
1204	if (addr_len != sizeof(*addr))
1205	return -EINVAL;
1206
1207	addr = (struct sockaddr_at *)uaddr;
1208
1209	if (addr->sat_family != AF_APPLETALK)
1210	return -EAFNOSUPPORT;
1211
1212	if (addr->sat_addr.s_node == ATADDR_BCAST &&
1213	!sock_flag(sk, flag: SOCK_BROADCAST)) {
1214	#if 1
1215	pr_warn("atalk_connect: %s is broken and did not set SO_BROADCAST.\n",
1216	current->comm);
1217	#else
1218	return -EACCES;
1219	#endif
1220	}
1221
1222	lock_sock(sk);
1223	err = -EBUSY;
1224	if (sock_flag(sk, flag: SOCK_ZAPPED))
1225	if (atalk_autobind(sk) < 0)
1226	goto out;
1227
1228	err = -ENETUNREACH;
1229	if (!atrtr_get_dev(sa: &addr->sat_addr))
1230	goto out;
1231
1232	at->dest_port = addr->sat_port;
1233	at->dest_net = addr->sat_addr.s_net;
1234	at->dest_node = addr->sat_addr.s_node;
1235
1236	sock->state = SS_CONNECTED;
1237	sk->sk_state = TCP_ESTABLISHED;
1238	err = 0;
1239	out:
1240	release_sock(sk);
1241	return err;
1242	}
1243
1244	/*
1245	* Find the name of an AppleTalk socket. Just copy the right
1246	* fields into the sockaddr.
1247	*/
1248	static int atalk_getname(struct socket *sock, struct sockaddr *uaddr,
1249	int peer)
1250	{
1251	struct sockaddr_at sat;
1252	struct sock *sk = sock->sk;
1253	struct atalk_sock *at = at_sk(sk);
1254	int err;
1255
1256	lock_sock(sk);
1257	err = -ENOBUFS;
1258	if (sock_flag(sk, flag: SOCK_ZAPPED))
1259	if (atalk_autobind(sk) < 0)
1260	goto out;
1261
1262	memset(&sat, 0, sizeof(sat));
1263
1264	if (peer) {
1265	err = -ENOTCONN;
1266	if (sk->sk_state != TCP_ESTABLISHED)
1267	goto out;
1268
1269	sat.sat_addr.s_net = at->dest_net;
1270	sat.sat_addr.s_node = at->dest_node;
1271	sat.sat_port = at->dest_port;
1272	} else {
1273	sat.sat_addr.s_net = at->src_net;
1274	sat.sat_addr.s_node = at->src_node;
1275	sat.sat_port = at->src_port;
1276	}
1277
1278	sat.sat_family = AF_APPLETALK;
1279	memcpy(uaddr, &sat, sizeof(sat));
1280	err = sizeof(struct sockaddr_at);
1281
1282	out:
1283	release_sock(sk);
1284	return err;
1285	}
1286
1287	static int atalk_route_packet(struct sk_buff *skb, struct net_device *dev,
1288	struct ddpehdr *ddp, __u16 len_hops, int origlen)
1289	{
1290	struct atalk_route *rt;
1291	struct atalk_addr ta;
1292
1293	/*
1294	* Don't route multicast, etc., packets, or packets sent to "this
1295	* network"
1296	*/
1297	if (skb->pkt_type != PACKET_HOST || !ddp->deh_dnet) {
1298	/*
1299	* FIXME:
1300	*
1301	* Can it ever happen that a packet is from a PPP iface and
1302	* needs to be broadcast onto the default network?
1303	*/
1304	if (dev->type == ARPHRD_PPP)
1305	printk(KERN_DEBUG "AppleTalk: didn't forward broadcast "
1306	"packet received from PPP iface\n");
1307	goto free_it;
1308	}
1309
1310	ta.s_net = ddp->deh_dnet;
1311	ta.s_node = ddp->deh_dnode;
1312
1313	/* Route the packet */
1314	rt = atrtr_find(target: &ta);
1315	/* increment hops count */
1316	len_hops += 1 << 10;
1317	if (!rt || !(len_hops & (15 << 10)))
1318	goto free_it;
1319
1320	/* FIXME: use skb->cb to be able to use shared skbs */
1321
1322	/*
1323	* Route goes through another gateway, so set the target to the
1324	* gateway instead.
1325	*/
1326
1327	if (rt->flags & RTF_GATEWAY) {
1328	ta.s_net = rt->gateway.s_net;
1329	ta.s_node = rt->gateway.s_node;
1330	}
1331
1332	/* Fix up skb->len field */
1333	skb_trim(skb, min_t(unsigned int, origlen,
1334	(rt->dev->hard_header_len +
1335	ddp_dl->header_length + (len_hops & 1023))));
1336
1337	/* FIXME: use skb->cb to be able to use shared skbs */
1338	ddp->deh_len_hops = htons(len_hops);
1339
1340	/*
1341	* Send the buffer onwards
1342	*
1343	* Now we must always be careful. If it's come from LocalTalk to
1344	* EtherTalk it might not fit
1345	*
1346	* Order matters here: If a packet has to be copied to make a new
1347	* headroom (rare hopefully) then it won't need unsharing.
1348	*
1349	* Note. ddp-> becomes invalid at the realloc.
1350	*/
1351	if (skb_headroom(skb) < 22) {
1352	/* 22 bytes - 12 ether, 2 len, 3 802.2 5 snap */
1353	struct sk_buff *nskb = skb_realloc_headroom(skb, headroom: 32);
1354	kfree_skb(skb);
1355	skb = nskb;
1356	} else
1357	skb = skb_unshare(skb, GFP_ATOMIC);
1358
1359	/*
1360	* If the buffer didn't vanish into the lack of space bitbucket we can
1361	* send it.
1362	*/
1363	if (skb == NULL)
1364	goto drop;
1365
1366	if (aarp_send_ddp(dev: rt->dev, skb, sa: &ta, NULL) == NET_XMIT_DROP)
1367	return NET_RX_DROP;
1368	return NET_RX_SUCCESS;
1369	free_it:
1370	kfree_skb(skb);
1371	drop:
1372	return NET_RX_DROP;
1373	}
1374
1375	/**
1376	* atalk_rcv - Receive a packet (in skb) from device dev
1377	* @skb: packet received
1378	* @dev: network device where the packet comes from
1379	* @pt: packet type
1380	* @orig_dev: the original receive net device
1381	*
1382	* Receive a packet (in skb) from device dev. This has come from the SNAP
1383	* decoder, and on entry skb->transport_header is the DDP header, skb->len
1384	* is the DDP header, skb->len is the DDP length. The physical headers
1385	* have been extracted. PPP should probably pass frames marked as for this
1386	* layer. [ie ARPHRD_ETHERTALK]
1387	*/
1388	static int atalk_rcv(struct sk_buff *skb, struct net_device *dev,
1389	struct packet_type *pt, struct net_device *orig_dev)
1390	{
1391	struct ddpehdr *ddp;
1392	struct sock *sock;
1393	struct atalk_iface *atif;
1394	struct sockaddr_at tosat;
1395	int origlen;
1396	__u16 len_hops;
1397
1398	if (!net_eq(net1: dev_net(dev), net2: &init_net))
1399	goto drop;
1400
1401	/* Don't mangle buffer if shared */
1402	if (!(skb = skb_share_check(skb, GFP_ATOMIC)))
1403	goto out;
1404
1405	/* Size check and make sure header is contiguous */
1406	if (!pskb_may_pull(skb, len: sizeof(*ddp)))
1407	goto drop;
1408
1409	ddp = ddp_hdr(skb);
1410
1411	len_hops = ntohs(ddp->deh_len_hops);
1412
1413	/* Trim buffer in case of stray trailing data */
1414	origlen = skb->len;
1415	skb_trim(skb, min_t(unsigned int, skb->len, len_hops & 1023));
1416
1417	/*
1418	* Size check to see if ddp->deh_len was crap
1419	* (Otherwise we'll detonate most spectacularly
1420	* in the middle of atalk_checksum() or recvmsg()).
1421	*/
1422	if (skb->len < sizeof(*ddp) || skb->len < (len_hops & 1023)) {
1423	pr_debug("AppleTalk: dropping corrupted frame (deh_len=%u, "
1424	"skb->len=%u)\n", len_hops & 1023, skb->len);
1425	goto drop;
1426	}
1427
1428	/*
1429	* Any checksums. Note we don't do htons() on this == is assumed to be
1430	* valid for net byte orders all over the networking code...
1431	*/
1432	if (ddp->deh_sum &&
1433	atalk_checksum(skb, len: len_hops & 1023) != ddp->deh_sum)
1434	/* Not a valid AppleTalk frame - dustbin time */
1435	goto drop;
1436
1437	/* Check the packet is aimed at us */
1438	if (!ddp->deh_dnet) /* Net 0 is 'this network' */
1439	atif = atalk_find_anynet(node: ddp->deh_dnode, dev);
1440	else
1441	atif = atalk_find_interface(net: ddp->deh_dnet, node: ddp->deh_dnode);
1442
1443	if (!atif) {
1444	/* Not ours, so we route the packet via the correct
1445	* AppleTalk iface
1446	*/
1447	return atalk_route_packet(skb, dev, ddp, len_hops, origlen);
1448	}
1449
1450	/*
1451	* Which socket - atalk_search_socket() looks for a *full match*
1452	* of the <net, node, port> tuple.
1453	*/
1454	tosat.sat_addr.s_net = ddp->deh_dnet;
1455	tosat.sat_addr.s_node = ddp->deh_dnode;
1456	tosat.sat_port = ddp->deh_dport;
1457
1458	sock = atalk_search_socket(to: &tosat, atif);
1459	if (!sock) /* But not one of our sockets */
1460	goto drop;
1461
1462	/* Queue packet (standard) */
1463	if (sock_queue_rcv_skb(sk: sock, skb) < 0)
1464	goto drop;
1465
1466	return NET_RX_SUCCESS;
1467
1468	drop:
1469	kfree_skb(skb);
1470	out:
1471	return NET_RX_DROP;
1472
1473	}
1474
1475	/*
1476	* Receive a LocalTalk frame. We make some demands on the caller here.
1477	* Caller must provide enough headroom on the packet to pull the short
1478	* header and append a long one.
1479	*/
1480	static int ltalk_rcv(struct sk_buff *skb, struct net_device *dev,
1481	struct packet_type *pt, struct net_device *orig_dev)
1482	{
1483	if (!net_eq(net1: dev_net(dev), net2: &init_net))
1484	goto freeit;
1485
1486	/* Expand any short form frames */
1487	if (skb_mac_header(skb)[2] == 1) {
1488	struct ddpehdr *ddp;
1489	/* Find our address */
1490	struct atalk_addr *ap = atalk_find_dev_addr(dev);
1491
1492	if (!ap || skb->len < sizeof(__be16) || skb->len > 1023)
1493	goto freeit;
1494
1495	/* Don't mangle buffer if shared */
1496	if (!(skb = skb_share_check(skb, GFP_ATOMIC)))
1497	return 0;
1498
1499	/*
1500	* The push leaves us with a ddephdr not an shdr, and
1501	* handily the port bytes in the right place preset.
1502	*/
1503	ddp = skb_push(skb, len: sizeof(*ddp) - 4);
1504
1505	/* Now fill in the long header */
1506
1507	/*
1508	* These two first. The mac overlays the new source/dest
1509	* network information so we MUST copy these before
1510	* we write the network numbers !
1511	*/
1512
1513	ddp->deh_dnode = skb_mac_header(skb)[0]; /* From physical header */
1514	ddp->deh_snode = skb_mac_header(skb)[1]; /* From physical header */
1515
1516	ddp->deh_dnet = ap->s_net; /* Network number */
1517	ddp->deh_snet = ap->s_net;
1518	ddp->deh_sum = 0; /* No checksum */
1519	/*
1520	* Not sure about this bit...
1521	*/
1522	/* Non routable, so force a drop if we slip up later */
1523	ddp->deh_len_hops = htons(skb->len + (DDP_MAXHOPS << 10));
1524	}
1525	skb_reset_transport_header(skb);
1526
1527	return atalk_rcv(skb, dev, pt, orig_dev);
1528	freeit:
1529	kfree_skb(skb);
1530	return 0;
1531	}
1532
1533	static int atalk_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1534	{
1535	struct sock *sk = sock->sk;
1536	struct atalk_sock *at = at_sk(sk);
1537	DECLARE_SOCKADDR(struct sockaddr_at *, usat, msg->msg_name);
1538	int flags = msg->msg_flags;
1539	int loopback = 0;
1540	struct sockaddr_at local_satalk, gsat;
1541	struct sk_buff *skb;
1542	struct net_device *dev;
1543	struct ddpehdr *ddp;
1544	int size, hard_header_len;
1545	struct atalk_route *rt, *rt_lo = NULL;
1546	int err;
1547
1548	if (flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
1549	return -EINVAL;
1550
1551	if (len > DDP_MAXSZ)
1552	return -EMSGSIZE;
1553
1554	lock_sock(sk);
1555	if (usat) {
1556	err = -EBUSY;
1557	if (sock_flag(sk, flag: SOCK_ZAPPED))
1558	if (atalk_autobind(sk) < 0)
1559	goto out;
1560
1561	err = -EINVAL;
1562	if (msg->msg_namelen < sizeof(*usat) ||
1563	usat->sat_family != AF_APPLETALK)
1564	goto out;
1565
1566	err = -EPERM;
1567	/* netatalk didn't implement this check */
1568	if (usat->sat_addr.s_node == ATADDR_BCAST &&
1569	!sock_flag(sk, flag: SOCK_BROADCAST)) {
1570	goto out;
1571	}
1572	} else {
1573	err = -ENOTCONN;
1574	if (sk->sk_state != TCP_ESTABLISHED)
1575	goto out;
1576	usat = &local_satalk;
1577	usat->sat_family = AF_APPLETALK;
1578	usat->sat_port = at->dest_port;
1579	usat->sat_addr.s_node = at->dest_node;
1580	usat->sat_addr.s_net = at->dest_net;
1581	}
1582
1583	/* Build a packet */
1584	net_dbg_ratelimited("SK %p: Got address.\n", sk);
1585
1586	/* For headers */
1587	size = sizeof(struct ddpehdr) + len + ddp_dl->header_length;
1588
1589	if (usat->sat_addr.s_net || usat->sat_addr.s_node == ATADDR_ANYNODE) {
1590	rt = atrtr_find(target: &usat->sat_addr);
1591	} else {
1592	struct atalk_addr at_hint;
1593
1594	at_hint.s_node = 0;
1595	at_hint.s_net = at->src_net;
1596
1597	rt = atrtr_find(target: &at_hint);
1598	}
1599	err = -ENETUNREACH;
1600	if (!rt)
1601	goto out;
1602
1603	dev = rt->dev;
1604
1605	net_dbg_ratelimited("SK %p: Size needed %d, device %s\n",
1606	sk, size, dev->name);
1607
1608	hard_header_len = dev->hard_header_len;
1609	/* Leave room for loopback hardware header if necessary */
1610	if (usat->sat_addr.s_node == ATADDR_BCAST &&
1611	(dev->flags & IFF_LOOPBACK || !(rt->flags & RTF_GATEWAY))) {
1612	struct atalk_addr at_lo;
1613
1614	at_lo.s_node = 0;
1615	at_lo.s_net = 0;
1616
1617	rt_lo = atrtr_find(target: &at_lo);
1618
1619	if (rt_lo && rt_lo->dev->hard_header_len > hard_header_len)
1620	hard_header_len = rt_lo->dev->hard_header_len;
1621	}
1622
1623	size += hard_header_len;
1624	release_sock(sk);
1625	skb = sock_alloc_send_skb(sk, size, noblock: (flags & MSG_DONTWAIT), errcode: &err);
1626	lock_sock(sk);
1627	if (!skb)
1628	goto out;
1629
1630	skb_reserve(skb, len: ddp_dl->header_length);
1631	skb_reserve(skb, len: hard_header_len);
1632	skb->dev = dev;
1633
1634	net_dbg_ratelimited("SK %p: Begin build.\n", sk);
1635
1636	ddp = skb_put(skb, len: sizeof(struct ddpehdr));
1637	ddp->deh_len_hops = htons(len + sizeof(*ddp));
1638	ddp->deh_dnet = usat->sat_addr.s_net;
1639	ddp->deh_snet = at->src_net;
1640	ddp->deh_dnode = usat->sat_addr.s_node;
1641	ddp->deh_snode = at->src_node;
1642	ddp->deh_dport = usat->sat_port;
1643	ddp->deh_sport = at->src_port;
1644
1645	net_dbg_ratelimited("SK %p: Copy user data (%zd bytes).\n", sk, len);
1646
1647	err = memcpy_from_msg(data: skb_put(skb, len), msg, len);
1648	if (err) {
1649	kfree_skb(skb);
1650	err = -EFAULT;
1651	goto out;
1652	}
1653
1654	if (sk->sk_no_check_tx)
1655	ddp->deh_sum = 0;
1656	else
1657	ddp->deh_sum = atalk_checksum(skb, len: len + sizeof(*ddp));
1658
1659	/*
1660	* Loopback broadcast packets to non gateway targets (ie routes
1661	* to group we are in)
1662	*/
1663	if (ddp->deh_dnode == ATADDR_BCAST &&
1664	!(rt->flags & RTF_GATEWAY) && !(dev->flags & IFF_LOOPBACK)) {
1665	struct sk_buff *skb2 = skb_copy(skb, GFP_KERNEL);
1666
1667	if (skb2) {
1668	loopback = 1;
1669	net_dbg_ratelimited("SK %p: send out(copy).\n", sk);
1670	/*
1671	* If it fails it is queued/sent above in the aarp queue
1672	*/
1673	aarp_send_ddp(dev, skb: skb2, sa: &usat->sat_addr, NULL);
1674	}
1675	}
1676
1677	if (dev->flags & IFF_LOOPBACK || loopback) {
1678	net_dbg_ratelimited("SK %p: Loop back.\n", sk);
1679	/* loop back */
1680	skb_orphan(skb);
1681	if (ddp->deh_dnode == ATADDR_BCAST) {
1682	if (!rt_lo) {
1683	kfree_skb(skb);
1684	err = -ENETUNREACH;
1685	goto out;
1686	}
1687	dev = rt_lo->dev;
1688	skb->dev = dev;
1689	}
1690	ddp_dl->request(ddp_dl, skb, dev->dev_addr);
1691	} else {
1692	net_dbg_ratelimited("SK %p: send out.\n", sk);
1693	if (rt->flags & RTF_GATEWAY) {
1694	gsat.sat_addr = rt->gateway;
1695	usat = &gsat;
1696	}
1697
1698	/*
1699	* If it fails it is queued/sent above in the aarp queue
1700	*/
1701	aarp_send_ddp(dev, skb, sa: &usat->sat_addr, NULL);
1702	}
1703	net_dbg_ratelimited("SK %p: Done write (%zd).\n", sk, len);
1704
1705	out:
1706	release_sock(sk);
1707	return err ? : len;
1708	}
1709
1710	static int atalk_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1711	int flags)
1712	{
1713	struct sock *sk = sock->sk;
1714	struct ddpehdr *ddp;
1715	int copied = 0;
1716	int offset = 0;
1717	int err = 0;
1718	struct sk_buff *skb;
1719
1720	skb = skb_recv_datagram(sk, flags, err: &err);
1721	lock_sock(sk);
1722
1723	if (!skb)
1724	goto out;
1725
1726	/* FIXME: use skb->cb to be able to use shared skbs */
1727	ddp = ddp_hdr(skb);
1728	copied = ntohs(ddp->deh_len_hops) & 1023;
1729
1730	if (sk->sk_type != SOCK_RAW) {
1731	offset = sizeof(*ddp);
1732	copied -= offset;
1733	}
1734
1735	if (copied > size) {
1736	copied = size;
1737	msg->msg_flags |= MSG_TRUNC;
1738	}
1739	err = skb_copy_datagram_msg(from: skb, offset, msg, size: copied);
1740
1741	if (!err && msg->msg_name) {
1742	DECLARE_SOCKADDR(struct sockaddr_at *, sat, msg->msg_name);
1743	sat->sat_family = AF_APPLETALK;
1744	sat->sat_port = ddp->deh_sport;
1745	sat->sat_addr.s_node = ddp->deh_snode;
1746	sat->sat_addr.s_net = ddp->deh_snet;
1747	msg->msg_namelen = sizeof(*sat);
1748	}
1749
1750	skb_free_datagram(sk, skb); /* Free the datagram. */
1751
1752	out:
1753	release_sock(sk);
1754	return err ? : copied;
1755	}
1756
1757
1758	/*
1759	* AppleTalk ioctl calls.
1760	*/
1761	static int atalk_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1762	{
1763	int rc = -ENOIOCTLCMD;
1764	struct sock *sk = sock->sk;
1765	void __user *argp = (void __user *)arg;
1766
1767	switch (cmd) {
1768	/* Protocol layer */
1769	case TIOCOUTQ: {
1770	long amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1771
1772	if (amount < 0)
1773	amount = 0;
1774	rc = put_user(amount, (int __user *)argp);
1775	break;
1776	}
1777	case TIOCINQ: {
1778	struct sk_buff *skb;
1779	long amount = 0;
1780
1781	spin_lock_irq(lock: &sk->sk_receive_queue.lock);
1782	skb = skb_peek(list_: &sk->sk_receive_queue);
1783	if (skb)
1784	amount = skb->len - sizeof(struct ddpehdr);
1785	spin_unlock_irq(lock: &sk->sk_receive_queue.lock);
1786	rc = put_user(amount, (int __user *)argp);
1787	break;
1788	}
1789	/* Routing */
1790	case SIOCADDRT:
1791	case SIOCDELRT:
1792	rc = -EPERM;
1793	if (capable(CAP_NET_ADMIN))
1794	rc = atrtr_ioctl(cmd, arg: argp);
1795	break;
1796	/* Interface */
1797	case SIOCGIFADDR:
1798	case SIOCSIFADDR:
1799	case SIOCGIFBRDADDR:
1800	case SIOCATALKDIFADDR:
1801	case SIOCDIFADDR:
1802	case SIOCSARP: /* proxy AARP */
1803	case SIOCDARP: /* proxy AARP */
1804	rtnl_lock();
1805	rc = atif_ioctl(cmd, arg: argp);
1806	rtnl_unlock();
1807	break;
1808	}
1809
1810	return rc;
1811	}
1812
1813
1814	#ifdef CONFIG_COMPAT
1815	static int atalk_compat_routing_ioctl(struct sock *sk, unsigned int cmd,
1816	struct compat_rtentry __user *ur)
1817	{
1818	compat_uptr_t rtdev;
1819	struct rtentry rt;
1820
1821	if (copy_from_user(to: &rt.rt_dst, from: &ur->rt_dst,
1822	n: 3 * sizeof(struct sockaddr)) ||
1823	get_user(rt.rt_flags, &ur->rt_flags) ||
1824	get_user(rt.rt_metric, &ur->rt_metric) ||
1825	get_user(rt.rt_mtu, &ur->rt_mtu) ||
1826	get_user(rt.rt_window, &ur->rt_window) ||
1827	get_user(rt.rt_irtt, &ur->rt_irtt) ||
1828	get_user(rtdev, &ur->rt_dev))
1829	return -EFAULT;
1830
1831	switch (cmd) {
1832	case SIOCDELRT:
1833	if (rt.rt_dst.sa_family != AF_APPLETALK)
1834	return -EINVAL;
1835	return atrtr_delete(addr: &((struct sockaddr_at *)
1836	&rt.rt_dst)->sat_addr);
1837
1838	case SIOCADDRT:
1839	rt.rt_dev = compat_ptr(uptr: rtdev);
1840	return atrtr_ioctl_addrt(rt: &rt);
1841	default:
1842	return -EINVAL;
1843	}
1844	}
1845	static int atalk_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1846	{
1847	void __user *argp = compat_ptr(uptr: arg);
1848	struct sock *sk = sock->sk;
1849
1850	switch (cmd) {
1851	case SIOCADDRT:
1852	case SIOCDELRT:
1853	return atalk_compat_routing_ioctl(sk, cmd, ur: argp);
1854	/*
1855	* SIOCATALKDIFADDR is a SIOCPROTOPRIVATE ioctl number, so we
1856	* cannot handle it in common code. The data we access if ifreq
1857	* here is compatible, so we can simply call the native
1858	* handler.
1859	*/
1860	case SIOCATALKDIFADDR:
1861	return atalk_ioctl(sock, cmd, arg: (unsigned long)argp);
1862	default:
1863	return -ENOIOCTLCMD;
1864	}
1865	}
1866	#endif /* CONFIG_COMPAT */
1867
1868
1869	static const struct net_proto_family atalk_family_ops = {
1870	.family = PF_APPLETALK,
1871	.create = atalk_create,
1872	.owner = THIS_MODULE,
1873	};
1874
1875	static const struct proto_ops atalk_dgram_ops = {
1876	.family = PF_APPLETALK,
1877	.owner = THIS_MODULE,
1878	.release = atalk_release,
1879	.bind = atalk_bind,
1880	.connect = atalk_connect,
1881	.socketpair = sock_no_socketpair,
1882	.accept = sock_no_accept,
1883	.getname = atalk_getname,
1884	.poll = datagram_poll,
1885	.ioctl = atalk_ioctl,
1886	.gettstamp = sock_gettstamp,
1887	#ifdef CONFIG_COMPAT
1888	.compat_ioctl = atalk_compat_ioctl,
1889	#endif
1890	.listen = sock_no_listen,
1891	.shutdown = sock_no_shutdown,
1892	.sendmsg = atalk_sendmsg,
1893	.recvmsg = atalk_recvmsg,
1894	.mmap = sock_no_mmap,
1895	};
1896
1897	static struct notifier_block ddp_notifier = {
1898	.notifier_call = ddp_device_event,
1899	};
1900
1901	static struct packet_type ltalk_packet_type __read_mostly = {
1902	.type = cpu_to_be16(ETH_P_LOCALTALK),
1903	.func = ltalk_rcv,
1904	};
1905
1906	static struct packet_type ppptalk_packet_type __read_mostly = {
1907	.type = cpu_to_be16(ETH_P_PPPTALK),
1908	.func = atalk_rcv,
1909	};
1910
1911	static unsigned char ddp_snap_id[] = { 0x08, 0x00, 0x07, 0x80, 0x9B };
1912
1913	/* Export symbols for use by drivers when AppleTalk is a module */
1914	EXPORT_SYMBOL(atrtr_get_dev);
1915	EXPORT_SYMBOL(atalk_find_dev_addr);
1916
1917	/* Called by proto.c on kernel start up */
1918	static int __init atalk_init(void)
1919	{
1920	int rc;
1921
1922	rc = proto_register(prot: &ddp_proto, alloc_slab: 0);
1923	if (rc)
1924	goto out;
1925
1926	rc = sock_register(fam: &atalk_family_ops);
1927	if (rc)
1928	goto out_proto;
1929
1930	ddp_dl = register_snap_client(desc: ddp_snap_id, rcvfunc: atalk_rcv);
1931	if (!ddp_dl) {
1932	pr_crit("Unable to register DDP with SNAP.\n");
1933	rc = -ENOMEM;
1934	goto out_sock;
1935	}
1936
1937	dev_add_pack(pt: &ltalk_packet_type);
1938	dev_add_pack(pt: &ppptalk_packet_type);
1939
1940	rc = register_netdevice_notifier(nb: &ddp_notifier);
1941	if (rc)
1942	goto out_snap;
1943
1944	rc = aarp_proto_init();
1945	if (rc)
1946	goto out_dev;
1947
1948	rc = atalk_proc_init();
1949	if (rc)
1950	goto out_aarp;
1951
1952	rc = atalk_register_sysctl();
1953	if (rc)
1954	goto out_proc;
1955	out:
1956	return rc;
1957	out_proc:
1958	atalk_proc_exit();
1959	out_aarp:
1960	aarp_cleanup_module();
1961	out_dev:
1962	unregister_netdevice_notifier(nb: &ddp_notifier);
1963	out_snap:
1964	dev_remove_pack(pt: &ppptalk_packet_type);
1965	dev_remove_pack(pt: &ltalk_packet_type);
1966	unregister_snap_client(proto: ddp_dl);
1967	out_sock:
1968	sock_unregister(PF_APPLETALK);
1969	out_proto:
1970	proto_unregister(prot: &ddp_proto);
1971	goto out;
1972	}
1973	module_init(atalk_init);
1974
1975	/*
1976	* No explicit module reference count manipulation is needed in the
1977	* protocol. Socket layer sets module reference count for us
1978	* and interfaces reference counting is done
1979	* by the network device layer.
1980	*
1981	* Ergo, before the AppleTalk module can be removed, all AppleTalk
1982	* sockets should be closed from user space.
1983	*/
1984	static void __exit atalk_exit(void)
1985	{
1986	#ifdef CONFIG_SYSCTL
1987	atalk_unregister_sysctl();
1988	#endif /* CONFIG_SYSCTL */
1989	atalk_proc_exit();
1990	aarp_cleanup_module(); /* General aarp clean-up. */
1991	unregister_netdevice_notifier(nb: &ddp_notifier);
1992	dev_remove_pack(pt: &ltalk_packet_type);
1993	dev_remove_pack(pt: &ppptalk_packet_type);
1994	unregister_snap_client(proto: ddp_dl);
1995	sock_unregister(PF_APPLETALK);
1996	proto_unregister(prot: &ddp_proto);
1997	}
1998	module_exit(atalk_exit);
1999
2000	MODULE_LICENSE("GPL");
2001	MODULE_AUTHOR("Alan Cox <alan@lxorguk.ukuu.org.uk>");
2002	MODULE_DESCRIPTION("AppleTalk 0.20\n");
2003	MODULE_ALIAS_NETPROTO(PF_APPLETALK);
2004