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 
__atalk_insert_socket(struct sock * sk)76 static inline void __atalk_insert_socket(struct sock *sk)
77 {
78 	sk_add_node(sk, &atalk_sockets);
79 }
80 
atalk_remove_socket(struct sock * sk)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 
atalk_search_socket(struct sockaddr_at * to,struct atalk_iface * atif)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(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  */
atalk_find_or_insert_socket(struct sock * sk,struct sockaddr_at * sat)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(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 
atalk_destroy_timer(struct timer_list * t)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(&sk->sk_timer);
164 	} else
165 		sock_put(sk);
166 }
167 
atalk_destroy_socket(struct sock * sk)168 static inline void atalk_destroy_socket(struct sock *sk)
169 {
170 	atalk_remove_socket(sk);
171 	skb_queue_purge(&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(&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  */
atif_drop_device(struct net_device * dev)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(tmp);
213 			dev->atalk_ptr = NULL;
214 		} else
215 			iface = &tmp->next;
216 	}
217 	write_unlock_bh(&atalk_interfaces_lock);
218 }
219 
atif_add_device(struct net_device * dev,struct atalk_addr * sa)220 static struct atalk_iface *atif_add_device(struct net_device *dev,
221 					   struct atalk_addr *sa)
222 {
223 	struct atalk_iface *iface = kzalloc(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 */
atif_probe_device(struct atalk_iface * atif)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 */
atif_proxy_probe_device(struct atalk_iface * atif,struct atalk_addr * proxy_addr)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 								    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 
atalk_find_dev_addr(struct net_device * dev)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 
atalk_find_primary(void)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  */
atalk_find_anynet(int node,struct net_device * dev)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 */
atalk_find_interface(__be16 net,int node)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  */
atrtr_find(struct atalk_addr * target)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  */
atrtr_get_dev(struct atalk_addr * sa)476 struct net_device *atrtr_get_dev(struct atalk_addr *sa)
477 {
478 	struct atalk_route *atr = atrtr_find(sa);
479 	return atr ? atr->dev : NULL;
480 }
481 
482 /* Set up a default router */
atrtr_set_default(struct net_device * dev)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  */
atrtr_create(struct rtentry * r,struct net_device * devhint)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(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(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 */
atrtr_delete(struct atalk_addr * addr)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(tmp->dev);
592 			kfree(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  */
atrtr_device_down(struct net_device * dev)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(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 */
atalk_dev_down(struct net_device * dev)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  */
ddp_device_event(struct notifier_block * this,unsigned long event,void * ptr)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(ptr);
643 
644 	if (!net_eq(dev_net(dev), &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 */
atif_ioctl(int cmd,void __user * arg)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(&atreq, NULL, arg))
670 		return -EFAULT;
671 
672 	dev = __dev_get_by_name(&init_net, 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(sa->sat_addr.s_net,
701 					 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->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(&rtdef, 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(&rtdef, dev);
775 				}
776 		}
777 		dev_mc_add_global(dev, 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, &(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(atif->dev, &(sa->sat_addr));
865 		return 0;
866 	}
867 
868 	return put_user_ifreq(&atreq, arg);
869 }
870 
atrtr_ioctl_addrt(struct rtentry * rt)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(name, rt->rt_dev, IFNAMSIZ-1))
879 			return -EFAULT;
880 		name[IFNAMSIZ-1] = '\0';
881 
882 		dev = __dev_get_by_name(&init_net, name);
883 		if (!dev)
884 			return -ENODEV;
885 	}
886 	return atrtr_create(rt, dev);
887 }
888 
889 /* Routing ioctl() calls */
atrtr_ioctl(unsigned int cmd,void __user * arg)890 static int atrtr_ioctl(unsigned int cmd, void __user *arg)
891 {
892 	struct rtentry rt;
893 
894 	if (copy_from_user(&rt, arg, 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(&((struct sockaddr_at *)
902 				      &rt.rt_dst)->sat_addr);
903 
904 	case SIOCADDRT:
905 		return atrtr_ioctl_addrt(&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  */
atalk_sum_partial(const unsigned char * data,int len,unsigned long sum)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(sum, 1);
928 	}
929 	return sum;
930 }
931 
932 /*  Checksum skb data --  similar to skb_checksum  */
atalk_sum_skb(const struct sk_buff * skb,int offset,int len,unsigned long sum)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(skb->data + offset, 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(skb_frag_page(frag));
964 			sum = atalk_sum_partial(vaddr + skb_frag_off(frag) +
965 						offset - start, 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(frag_iter, offset - start,
985 					    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 
atalk_checksum(const struct sk_buff * skb,int len)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, 4, len-4, 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  */
atalk_create(struct net * net,struct socket * sock,int protocol,int kern)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(net, &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, &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, SOCK_ZAPPED);
1049 out:
1050 	return rc;
1051 }
1052 
1053 /* Free a socket. No work needed */
atalk_release(struct socket * sock)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  */
atalk_pick_and_bind_port(struct sock * sk,struct sockaddr_at * sat)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(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 
atalk_autobind(struct sock * sk)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);
1131 	if (!n)
1132 		sock_reset_flag(sk, SOCK_ZAPPED);
1133 out:
1134 	return n;
1135 }
1136 
1137 /* Set the address 'our end' of the connection */
atalk_bind(struct socket * sock,struct sockaddr * uaddr,int addr_len)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, 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(addr->sat_addr.s_net,
1165 					  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, 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, addr))
1182 			goto out;
1183 	}
1184 
1185 	sock_reset_flag(sk, SOCK_ZAPPED);
1186 	err = 0;
1187 out:
1188 	release_sock(sk);
1189 	return err;
1190 }
1191 
1192 /* Set the address we talk to */
atalk_connect(struct socket * sock,struct sockaddr * uaddr,int addr_len,int flags)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, 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, SOCK_ZAPPED))
1225 		if (atalk_autobind(sk) < 0)
1226 			goto out;
1227 
1228 	err = -ENETUNREACH;
1229 	if (!atrtr_get_dev(&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  */
atalk_getname(struct socket * sock,struct sockaddr * uaddr,int peer)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, 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 #if IS_ENABLED(CONFIG_IPDDP)
is_ip_over_ddp(struct sk_buff * skb)1288 static __inline__ int is_ip_over_ddp(struct sk_buff *skb)
1289 {
1290 	return skb->data[12] == 22;
1291 }
1292 
handle_ip_over_ddp(struct sk_buff * skb)1293 static int handle_ip_over_ddp(struct sk_buff *skb)
1294 {
1295 	struct net_device *dev = __dev_get_by_name(&init_net, "ipddp0");
1296 	struct net_device_stats *stats;
1297 
1298 	/* This needs to be able to handle ipddp"N" devices */
1299 	if (!dev) {
1300 		kfree_skb(skb);
1301 		return NET_RX_DROP;
1302 	}
1303 
1304 	skb->protocol = htons(ETH_P_IP);
1305 	skb_pull(skb, 13);
1306 	skb->dev   = dev;
1307 	skb_reset_transport_header(skb);
1308 
1309 	stats = netdev_priv(dev);
1310 	stats->rx_packets++;
1311 	stats->rx_bytes += skb->len + 13;
1312 	return netif_rx(skb);  /* Send the SKB up to a higher place. */
1313 }
1314 #else
1315 /* make it easy for gcc to optimize this test out, i.e. kill the code */
1316 #define is_ip_over_ddp(skb) 0
1317 #define handle_ip_over_ddp(skb) 0
1318 #endif
1319 
atalk_route_packet(struct sk_buff * skb,struct net_device * dev,struct ddpehdr * ddp,__u16 len_hops,int origlen)1320 static int atalk_route_packet(struct sk_buff *skb, struct net_device *dev,
1321 			      struct ddpehdr *ddp, __u16 len_hops, int origlen)
1322 {
1323 	struct atalk_route *rt;
1324 	struct atalk_addr ta;
1325 
1326 	/*
1327 	 * Don't route multicast, etc., packets, or packets sent to "this
1328 	 * network"
1329 	 */
1330 	if (skb->pkt_type != PACKET_HOST || !ddp->deh_dnet) {
1331 		/*
1332 		 * FIXME:
1333 		 *
1334 		 * Can it ever happen that a packet is from a PPP iface and
1335 		 * needs to be broadcast onto the default network?
1336 		 */
1337 		if (dev->type == ARPHRD_PPP)
1338 			printk(KERN_DEBUG "AppleTalk: didn't forward broadcast "
1339 					  "packet received from PPP iface\n");
1340 		goto free_it;
1341 	}
1342 
1343 	ta.s_net  = ddp->deh_dnet;
1344 	ta.s_node = ddp->deh_dnode;
1345 
1346 	/* Route the packet */
1347 	rt = atrtr_find(&ta);
1348 	/* increment hops count */
1349 	len_hops += 1 << 10;
1350 	if (!rt || !(len_hops & (15 << 10)))
1351 		goto free_it;
1352 
1353 	/* FIXME: use skb->cb to be able to use shared skbs */
1354 
1355 	/*
1356 	 * Route goes through another gateway, so set the target to the
1357 	 * gateway instead.
1358 	 */
1359 
1360 	if (rt->flags & RTF_GATEWAY) {
1361 		ta.s_net  = rt->gateway.s_net;
1362 		ta.s_node = rt->gateway.s_node;
1363 	}
1364 
1365 	/* Fix up skb->len field */
1366 	skb_trim(skb, min_t(unsigned int, origlen,
1367 			    (rt->dev->hard_header_len +
1368 			     ddp_dl->header_length + (len_hops & 1023))));
1369 
1370 	/* FIXME: use skb->cb to be able to use shared skbs */
1371 	ddp->deh_len_hops = htons(len_hops);
1372 
1373 	/*
1374 	 * Send the buffer onwards
1375 	 *
1376 	 * Now we must always be careful. If it's come from LocalTalk to
1377 	 * EtherTalk it might not fit
1378 	 *
1379 	 * Order matters here: If a packet has to be copied to make a new
1380 	 * headroom (rare hopefully) then it won't need unsharing.
1381 	 *
1382 	 * Note. ddp-> becomes invalid at the realloc.
1383 	 */
1384 	if (skb_headroom(skb) < 22) {
1385 		/* 22 bytes - 12 ether, 2 len, 3 802.2 5 snap */
1386 		struct sk_buff *nskb = skb_realloc_headroom(skb, 32);
1387 		kfree_skb(skb);
1388 		skb = nskb;
1389 	} else
1390 		skb = skb_unshare(skb, GFP_ATOMIC);
1391 
1392 	/*
1393 	 * If the buffer didn't vanish into the lack of space bitbucket we can
1394 	 * send it.
1395 	 */
1396 	if (skb == NULL)
1397 		goto drop;
1398 
1399 	if (aarp_send_ddp(rt->dev, skb, &ta, NULL) == NET_XMIT_DROP)
1400 		return NET_RX_DROP;
1401 	return NET_RX_SUCCESS;
1402 free_it:
1403 	kfree_skb(skb);
1404 drop:
1405 	return NET_RX_DROP;
1406 }
1407 
1408 /**
1409  *	atalk_rcv - Receive a packet (in skb) from device dev
1410  *	@skb: packet received
1411  *	@dev: network device where the packet comes from
1412  *	@pt: packet type
1413  *	@orig_dev: the original receive net device
1414  *
1415  *	Receive a packet (in skb) from device dev. This has come from the SNAP
1416  *	decoder, and on entry skb->transport_header is the DDP header, skb->len
1417  *	is the DDP header, skb->len is the DDP length. The physical headers
1418  *	have been extracted. PPP should probably pass frames marked as for this
1419  *	layer.  [ie ARPHRD_ETHERTALK]
1420  */
atalk_rcv(struct sk_buff * skb,struct net_device * dev,struct packet_type * pt,struct net_device * orig_dev)1421 static int atalk_rcv(struct sk_buff *skb, struct net_device *dev,
1422 		     struct packet_type *pt, struct net_device *orig_dev)
1423 {
1424 	struct ddpehdr *ddp;
1425 	struct sock *sock;
1426 	struct atalk_iface *atif;
1427 	struct sockaddr_at tosat;
1428 	int origlen;
1429 	__u16 len_hops;
1430 
1431 	if (!net_eq(dev_net(dev), &init_net))
1432 		goto drop;
1433 
1434 	/* Don't mangle buffer if shared */
1435 	if (!(skb = skb_share_check(skb, GFP_ATOMIC)))
1436 		goto out;
1437 
1438 	/* Size check and make sure header is contiguous */
1439 	if (!pskb_may_pull(skb, sizeof(*ddp)))
1440 		goto drop;
1441 
1442 	ddp = ddp_hdr(skb);
1443 
1444 	len_hops = ntohs(ddp->deh_len_hops);
1445 
1446 	/* Trim buffer in case of stray trailing data */
1447 	origlen = skb->len;
1448 	skb_trim(skb, min_t(unsigned int, skb->len, len_hops & 1023));
1449 
1450 	/*
1451 	 * Size check to see if ddp->deh_len was crap
1452 	 * (Otherwise we'll detonate most spectacularly
1453 	 * in the middle of atalk_checksum() or recvmsg()).
1454 	 */
1455 	if (skb->len < sizeof(*ddp) || skb->len < (len_hops & 1023)) {
1456 		pr_debug("AppleTalk: dropping corrupted frame (deh_len=%u, "
1457 			 "skb->len=%u)\n", len_hops & 1023, skb->len);
1458 		goto drop;
1459 	}
1460 
1461 	/*
1462 	 * Any checksums. Note we don't do htons() on this == is assumed to be
1463 	 * valid for net byte orders all over the networking code...
1464 	 */
1465 	if (ddp->deh_sum &&
1466 	    atalk_checksum(skb, len_hops & 1023) != ddp->deh_sum)
1467 		/* Not a valid AppleTalk frame - dustbin time */
1468 		goto drop;
1469 
1470 	/* Check the packet is aimed at us */
1471 	if (!ddp->deh_dnet)	/* Net 0 is 'this network' */
1472 		atif = atalk_find_anynet(ddp->deh_dnode, dev);
1473 	else
1474 		atif = atalk_find_interface(ddp->deh_dnet, ddp->deh_dnode);
1475 
1476 	if (!atif) {
1477 		/* Not ours, so we route the packet via the correct
1478 		 * AppleTalk iface
1479 		 */
1480 		return atalk_route_packet(skb, dev, ddp, len_hops, origlen);
1481 	}
1482 
1483 	/* if IP over DDP is not selected this code will be optimized out */
1484 	if (is_ip_over_ddp(skb))
1485 		return handle_ip_over_ddp(skb);
1486 	/*
1487 	 * Which socket - atalk_search_socket() looks for a *full match*
1488 	 * of the <net, node, port> tuple.
1489 	 */
1490 	tosat.sat_addr.s_net  = ddp->deh_dnet;
1491 	tosat.sat_addr.s_node = ddp->deh_dnode;
1492 	tosat.sat_port	      = ddp->deh_dport;
1493 
1494 	sock = atalk_search_socket(&tosat, atif);
1495 	if (!sock) /* But not one of our sockets */
1496 		goto drop;
1497 
1498 	/* Queue packet (standard) */
1499 	if (sock_queue_rcv_skb(sock, skb) < 0)
1500 		goto drop;
1501 
1502 	return NET_RX_SUCCESS;
1503 
1504 drop:
1505 	kfree_skb(skb);
1506 out:
1507 	return NET_RX_DROP;
1508 
1509 }
1510 
1511 /*
1512  * Receive a LocalTalk frame. We make some demands on the caller here.
1513  * Caller must provide enough headroom on the packet to pull the short
1514  * header and append a long one.
1515  */
ltalk_rcv(struct sk_buff * skb,struct net_device * dev,struct packet_type * pt,struct net_device * orig_dev)1516 static int ltalk_rcv(struct sk_buff *skb, struct net_device *dev,
1517 		     struct packet_type *pt, struct net_device *orig_dev)
1518 {
1519 	if (!net_eq(dev_net(dev), &init_net))
1520 		goto freeit;
1521 
1522 	/* Expand any short form frames */
1523 	if (skb_mac_header(skb)[2] == 1) {
1524 		struct ddpehdr *ddp;
1525 		/* Find our address */
1526 		struct atalk_addr *ap = atalk_find_dev_addr(dev);
1527 
1528 		if (!ap || skb->len < sizeof(__be16) || skb->len > 1023)
1529 			goto freeit;
1530 
1531 		/* Don't mangle buffer if shared */
1532 		if (!(skb = skb_share_check(skb, GFP_ATOMIC)))
1533 			return 0;
1534 
1535 		/*
1536 		 * The push leaves us with a ddephdr not an shdr, and
1537 		 * handily the port bytes in the right place preset.
1538 		 */
1539 		ddp = skb_push(skb, sizeof(*ddp) - 4);
1540 
1541 		/* Now fill in the long header */
1542 
1543 		/*
1544 		 * These two first. The mac overlays the new source/dest
1545 		 * network information so we MUST copy these before
1546 		 * we write the network numbers !
1547 		 */
1548 
1549 		ddp->deh_dnode = skb_mac_header(skb)[0];     /* From physical header */
1550 		ddp->deh_snode = skb_mac_header(skb)[1];     /* From physical header */
1551 
1552 		ddp->deh_dnet  = ap->s_net;	/* Network number */
1553 		ddp->deh_snet  = ap->s_net;
1554 		ddp->deh_sum   = 0;		/* No checksum */
1555 		/*
1556 		 * Not sure about this bit...
1557 		 */
1558 		/* Non routable, so force a drop if we slip up later */
1559 		ddp->deh_len_hops = htons(skb->len + (DDP_MAXHOPS << 10));
1560 	}
1561 	skb_reset_transport_header(skb);
1562 
1563 	return atalk_rcv(skb, dev, pt, orig_dev);
1564 freeit:
1565 	kfree_skb(skb);
1566 	return 0;
1567 }
1568 
atalk_sendmsg(struct socket * sock,struct msghdr * msg,size_t len)1569 static int atalk_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1570 {
1571 	struct sock *sk = sock->sk;
1572 	struct atalk_sock *at = at_sk(sk);
1573 	DECLARE_SOCKADDR(struct sockaddr_at *, usat, msg->msg_name);
1574 	int flags = msg->msg_flags;
1575 	int loopback = 0;
1576 	struct sockaddr_at local_satalk, gsat;
1577 	struct sk_buff *skb;
1578 	struct net_device *dev;
1579 	struct ddpehdr *ddp;
1580 	int size, hard_header_len;
1581 	struct atalk_route *rt, *rt_lo = NULL;
1582 	int err;
1583 
1584 	if (flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
1585 		return -EINVAL;
1586 
1587 	if (len > DDP_MAXSZ)
1588 		return -EMSGSIZE;
1589 
1590 	lock_sock(sk);
1591 	if (usat) {
1592 		err = -EBUSY;
1593 		if (sock_flag(sk, SOCK_ZAPPED))
1594 			if (atalk_autobind(sk) < 0)
1595 				goto out;
1596 
1597 		err = -EINVAL;
1598 		if (msg->msg_namelen < sizeof(*usat) ||
1599 		    usat->sat_family != AF_APPLETALK)
1600 			goto out;
1601 
1602 		err = -EPERM;
1603 		/* netatalk didn't implement this check */
1604 		if (usat->sat_addr.s_node == ATADDR_BCAST &&
1605 		    !sock_flag(sk, SOCK_BROADCAST)) {
1606 			goto out;
1607 		}
1608 	} else {
1609 		err = -ENOTCONN;
1610 		if (sk->sk_state != TCP_ESTABLISHED)
1611 			goto out;
1612 		usat = &local_satalk;
1613 		usat->sat_family      = AF_APPLETALK;
1614 		usat->sat_port	      = at->dest_port;
1615 		usat->sat_addr.s_node = at->dest_node;
1616 		usat->sat_addr.s_net  = at->dest_net;
1617 	}
1618 
1619 	/* Build a packet */
1620 	SOCK_DEBUG(sk, "SK %p: Got address.\n", sk);
1621 
1622 	/* For headers */
1623 	size = sizeof(struct ddpehdr) + len + ddp_dl->header_length;
1624 
1625 	if (usat->sat_addr.s_net || usat->sat_addr.s_node == ATADDR_ANYNODE) {
1626 		rt = atrtr_find(&usat->sat_addr);
1627 	} else {
1628 		struct atalk_addr at_hint;
1629 
1630 		at_hint.s_node = 0;
1631 		at_hint.s_net  = at->src_net;
1632 
1633 		rt = atrtr_find(&at_hint);
1634 	}
1635 	err = -ENETUNREACH;
1636 	if (!rt)
1637 		goto out;
1638 
1639 	dev = rt->dev;
1640 
1641 	SOCK_DEBUG(sk, "SK %p: Size needed %d, device %s\n",
1642 			sk, size, dev->name);
1643 
1644 	hard_header_len = dev->hard_header_len;
1645 	/* Leave room for loopback hardware header if necessary */
1646 	if (usat->sat_addr.s_node == ATADDR_BCAST &&
1647 	    (dev->flags & IFF_LOOPBACK || !(rt->flags & RTF_GATEWAY))) {
1648 		struct atalk_addr at_lo;
1649 
1650 		at_lo.s_node = 0;
1651 		at_lo.s_net  = 0;
1652 
1653 		rt_lo = atrtr_find(&at_lo);
1654 
1655 		if (rt_lo && rt_lo->dev->hard_header_len > hard_header_len)
1656 			hard_header_len = rt_lo->dev->hard_header_len;
1657 	}
1658 
1659 	size += hard_header_len;
1660 	release_sock(sk);
1661 	skb = sock_alloc_send_skb(sk, size, (flags & MSG_DONTWAIT), &err);
1662 	lock_sock(sk);
1663 	if (!skb)
1664 		goto out;
1665 
1666 	skb_reserve(skb, ddp_dl->header_length);
1667 	skb_reserve(skb, hard_header_len);
1668 	skb->dev = dev;
1669 
1670 	SOCK_DEBUG(sk, "SK %p: Begin build.\n", sk);
1671 
1672 	ddp = skb_put(skb, sizeof(struct ddpehdr));
1673 	ddp->deh_len_hops  = htons(len + sizeof(*ddp));
1674 	ddp->deh_dnet  = usat->sat_addr.s_net;
1675 	ddp->deh_snet  = at->src_net;
1676 	ddp->deh_dnode = usat->sat_addr.s_node;
1677 	ddp->deh_snode = at->src_node;
1678 	ddp->deh_dport = usat->sat_port;
1679 	ddp->deh_sport = at->src_port;
1680 
1681 	SOCK_DEBUG(sk, "SK %p: Copy user data (%zd bytes).\n", sk, len);
1682 
1683 	err = memcpy_from_msg(skb_put(skb, len), msg, len);
1684 	if (err) {
1685 		kfree_skb(skb);
1686 		err = -EFAULT;
1687 		goto out;
1688 	}
1689 
1690 	if (sk->sk_no_check_tx)
1691 		ddp->deh_sum = 0;
1692 	else
1693 		ddp->deh_sum = atalk_checksum(skb, len + sizeof(*ddp));
1694 
1695 	/*
1696 	 * Loopback broadcast packets to non gateway targets (ie routes
1697 	 * to group we are in)
1698 	 */
1699 	if (ddp->deh_dnode == ATADDR_BCAST &&
1700 	    !(rt->flags & RTF_GATEWAY) && !(dev->flags & IFF_LOOPBACK)) {
1701 		struct sk_buff *skb2 = skb_copy(skb, GFP_KERNEL);
1702 
1703 		if (skb2) {
1704 			loopback = 1;
1705 			SOCK_DEBUG(sk, "SK %p: send out(copy).\n", sk);
1706 			/*
1707 			 * If it fails it is queued/sent above in the aarp queue
1708 			 */
1709 			aarp_send_ddp(dev, skb2, &usat->sat_addr, NULL);
1710 		}
1711 	}
1712 
1713 	if (dev->flags & IFF_LOOPBACK || loopback) {
1714 		SOCK_DEBUG(sk, "SK %p: Loop back.\n", sk);
1715 		/* loop back */
1716 		skb_orphan(skb);
1717 		if (ddp->deh_dnode == ATADDR_BCAST) {
1718 			if (!rt_lo) {
1719 				kfree_skb(skb);
1720 				err = -ENETUNREACH;
1721 				goto out;
1722 			}
1723 			dev = rt_lo->dev;
1724 			skb->dev = dev;
1725 		}
1726 		ddp_dl->request(ddp_dl, skb, dev->dev_addr);
1727 	} else {
1728 		SOCK_DEBUG(sk, "SK %p: send out.\n", sk);
1729 		if (rt->flags & RTF_GATEWAY) {
1730 		    gsat.sat_addr = rt->gateway;
1731 		    usat = &gsat;
1732 		}
1733 
1734 		/*
1735 		 * If it fails it is queued/sent above in the aarp queue
1736 		 */
1737 		aarp_send_ddp(dev, skb, &usat->sat_addr, NULL);
1738 	}
1739 	SOCK_DEBUG(sk, "SK %p: Done write (%zd).\n", sk, len);
1740 
1741 out:
1742 	release_sock(sk);
1743 	return err ? : len;
1744 }
1745 
atalk_recvmsg(struct socket * sock,struct msghdr * msg,size_t size,int flags)1746 static int atalk_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1747 			 int flags)
1748 {
1749 	struct sock *sk = sock->sk;
1750 	struct ddpehdr *ddp;
1751 	int copied = 0;
1752 	int offset = 0;
1753 	int err = 0;
1754 	struct sk_buff *skb;
1755 
1756 	skb = skb_recv_datagram(sk, flags, &err);
1757 	lock_sock(sk);
1758 
1759 	if (!skb)
1760 		goto out;
1761 
1762 	/* FIXME: use skb->cb to be able to use shared skbs */
1763 	ddp = ddp_hdr(skb);
1764 	copied = ntohs(ddp->deh_len_hops) & 1023;
1765 
1766 	if (sk->sk_type != SOCK_RAW) {
1767 		offset = sizeof(*ddp);
1768 		copied -= offset;
1769 	}
1770 
1771 	if (copied > size) {
1772 		copied = size;
1773 		msg->msg_flags |= MSG_TRUNC;
1774 	}
1775 	err = skb_copy_datagram_msg(skb, offset, msg, copied);
1776 
1777 	if (!err && msg->msg_name) {
1778 		DECLARE_SOCKADDR(struct sockaddr_at *, sat, msg->msg_name);
1779 		sat->sat_family      = AF_APPLETALK;
1780 		sat->sat_port        = ddp->deh_sport;
1781 		sat->sat_addr.s_node = ddp->deh_snode;
1782 		sat->sat_addr.s_net  = ddp->deh_snet;
1783 		msg->msg_namelen     = sizeof(*sat);
1784 	}
1785 
1786 	skb_free_datagram(sk, skb);	/* Free the datagram. */
1787 
1788 out:
1789 	release_sock(sk);
1790 	return err ? : copied;
1791 }
1792 
1793 
1794 /*
1795  * AppleTalk ioctl calls.
1796  */
atalk_ioctl(struct socket * sock,unsigned int cmd,unsigned long arg)1797 static int atalk_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1798 {
1799 	int rc = -ENOIOCTLCMD;
1800 	struct sock *sk = sock->sk;
1801 	void __user *argp = (void __user *)arg;
1802 
1803 	switch (cmd) {
1804 	/* Protocol layer */
1805 	case TIOCOUTQ: {
1806 		long amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1807 
1808 		if (amount < 0)
1809 			amount = 0;
1810 		rc = put_user(amount, (int __user *)argp);
1811 		break;
1812 	}
1813 	case TIOCINQ: {
1814 		/*
1815 		 * These two are safe on a single CPU system as only
1816 		 * user tasks fiddle here
1817 		 */
1818 		struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
1819 		long amount = 0;
1820 
1821 		if (skb)
1822 			amount = skb->len - sizeof(struct ddpehdr);
1823 		rc = put_user(amount, (int __user *)argp);
1824 		break;
1825 	}
1826 	/* Routing */
1827 	case SIOCADDRT:
1828 	case SIOCDELRT:
1829 		rc = -EPERM;
1830 		if (capable(CAP_NET_ADMIN))
1831 			rc = atrtr_ioctl(cmd, argp);
1832 		break;
1833 	/* Interface */
1834 	case SIOCGIFADDR:
1835 	case SIOCSIFADDR:
1836 	case SIOCGIFBRDADDR:
1837 	case SIOCATALKDIFADDR:
1838 	case SIOCDIFADDR:
1839 	case SIOCSARP:		/* proxy AARP */
1840 	case SIOCDARP:		/* proxy AARP */
1841 		rtnl_lock();
1842 		rc = atif_ioctl(cmd, argp);
1843 		rtnl_unlock();
1844 		break;
1845 	}
1846 
1847 	return rc;
1848 }
1849 
1850 
1851 #ifdef CONFIG_COMPAT
atalk_compat_routing_ioctl(struct sock * sk,unsigned int cmd,struct compat_rtentry __user * ur)1852 static int atalk_compat_routing_ioctl(struct sock *sk, unsigned int cmd,
1853 		struct compat_rtentry __user *ur)
1854 {
1855 	compat_uptr_t rtdev;
1856 	struct rtentry rt;
1857 
1858 	if (copy_from_user(&rt.rt_dst, &ur->rt_dst,
1859 			3 * sizeof(struct sockaddr)) ||
1860 	    get_user(rt.rt_flags, &ur->rt_flags) ||
1861 	    get_user(rt.rt_metric, &ur->rt_metric) ||
1862 	    get_user(rt.rt_mtu, &ur->rt_mtu) ||
1863 	    get_user(rt.rt_window, &ur->rt_window) ||
1864 	    get_user(rt.rt_irtt, &ur->rt_irtt) ||
1865 	    get_user(rtdev, &ur->rt_dev))
1866 		return -EFAULT;
1867 
1868 	switch (cmd) {
1869 	case SIOCDELRT:
1870 		if (rt.rt_dst.sa_family != AF_APPLETALK)
1871 			return -EINVAL;
1872 		return atrtr_delete(&((struct sockaddr_at *)
1873 				      &rt.rt_dst)->sat_addr);
1874 
1875 	case SIOCADDRT:
1876 		rt.rt_dev = compat_ptr(rtdev);
1877 		return atrtr_ioctl_addrt(&rt);
1878 	default:
1879 		return -EINVAL;
1880 	}
1881 }
atalk_compat_ioctl(struct socket * sock,unsigned int cmd,unsigned long arg)1882 static int atalk_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1883 {
1884 	void __user *argp = compat_ptr(arg);
1885 	struct sock *sk = sock->sk;
1886 
1887 	switch (cmd) {
1888 	case SIOCADDRT:
1889 	case SIOCDELRT:
1890 		return atalk_compat_routing_ioctl(sk, cmd, argp);
1891 	/*
1892 	 * SIOCATALKDIFADDR is a SIOCPROTOPRIVATE ioctl number, so we
1893 	 * cannot handle it in common code. The data we access if ifreq
1894 	 * here is compatible, so we can simply call the native
1895 	 * handler.
1896 	 */
1897 	case SIOCATALKDIFADDR:
1898 		return atalk_ioctl(sock, cmd, (unsigned long)argp);
1899 	default:
1900 		return -ENOIOCTLCMD;
1901 	}
1902 }
1903 #endif /* CONFIG_COMPAT */
1904 
1905 
1906 static const struct net_proto_family atalk_family_ops = {
1907 	.family		= PF_APPLETALK,
1908 	.create		= atalk_create,
1909 	.owner		= THIS_MODULE,
1910 };
1911 
1912 static const struct proto_ops atalk_dgram_ops = {
1913 	.family		= PF_APPLETALK,
1914 	.owner		= THIS_MODULE,
1915 	.release	= atalk_release,
1916 	.bind		= atalk_bind,
1917 	.connect	= atalk_connect,
1918 	.socketpair	= sock_no_socketpair,
1919 	.accept		= sock_no_accept,
1920 	.getname	= atalk_getname,
1921 	.poll		= datagram_poll,
1922 	.ioctl		= atalk_ioctl,
1923 	.gettstamp	= sock_gettstamp,
1924 #ifdef CONFIG_COMPAT
1925 	.compat_ioctl	= atalk_compat_ioctl,
1926 #endif
1927 	.listen		= sock_no_listen,
1928 	.shutdown	= sock_no_shutdown,
1929 	.sendmsg	= atalk_sendmsg,
1930 	.recvmsg	= atalk_recvmsg,
1931 	.mmap		= sock_no_mmap,
1932 };
1933 
1934 static struct notifier_block ddp_notifier = {
1935 	.notifier_call	= ddp_device_event,
1936 };
1937 
1938 static struct packet_type ltalk_packet_type __read_mostly = {
1939 	.type		= cpu_to_be16(ETH_P_LOCALTALK),
1940 	.func		= ltalk_rcv,
1941 };
1942 
1943 static struct packet_type ppptalk_packet_type __read_mostly = {
1944 	.type		= cpu_to_be16(ETH_P_PPPTALK),
1945 	.func		= atalk_rcv,
1946 };
1947 
1948 static unsigned char ddp_snap_id[] = { 0x08, 0x00, 0x07, 0x80, 0x9B };
1949 
1950 /* Export symbols for use by drivers when AppleTalk is a module */
1951 EXPORT_SYMBOL(atrtr_get_dev);
1952 EXPORT_SYMBOL(atalk_find_dev_addr);
1953 
1954 /* Called by proto.c on kernel start up */
atalk_init(void)1955 static int __init atalk_init(void)
1956 {
1957 	int rc;
1958 
1959 	rc = proto_register(&ddp_proto, 0);
1960 	if (rc)
1961 		goto out;
1962 
1963 	rc = sock_register(&atalk_family_ops);
1964 	if (rc)
1965 		goto out_proto;
1966 
1967 	ddp_dl = register_snap_client(ddp_snap_id, atalk_rcv);
1968 	if (!ddp_dl) {
1969 		pr_crit("Unable to register DDP with SNAP.\n");
1970 		rc = -ENOMEM;
1971 		goto out_sock;
1972 	}
1973 
1974 	dev_add_pack(&ltalk_packet_type);
1975 	dev_add_pack(&ppptalk_packet_type);
1976 
1977 	rc = register_netdevice_notifier(&ddp_notifier);
1978 	if (rc)
1979 		goto out_snap;
1980 
1981 	rc = aarp_proto_init();
1982 	if (rc)
1983 		goto out_dev;
1984 
1985 	rc = atalk_proc_init();
1986 	if (rc)
1987 		goto out_aarp;
1988 
1989 	rc = atalk_register_sysctl();
1990 	if (rc)
1991 		goto out_proc;
1992 out:
1993 	return rc;
1994 out_proc:
1995 	atalk_proc_exit();
1996 out_aarp:
1997 	aarp_cleanup_module();
1998 out_dev:
1999 	unregister_netdevice_notifier(&ddp_notifier);
2000 out_snap:
2001 	dev_remove_pack(&ppptalk_packet_type);
2002 	dev_remove_pack(&ltalk_packet_type);
2003 	unregister_snap_client(ddp_dl);
2004 out_sock:
2005 	sock_unregister(PF_APPLETALK);
2006 out_proto:
2007 	proto_unregister(&ddp_proto);
2008 	goto out;
2009 }
2010 module_init(atalk_init);
2011 
2012 /*
2013  * No explicit module reference count manipulation is needed in the
2014  * protocol. Socket layer sets module reference count for us
2015  * and interfaces reference counting is done
2016  * by the network device layer.
2017  *
2018  * Ergo, before the AppleTalk module can be removed, all AppleTalk
2019  * sockets should be closed from user space.
2020  */
atalk_exit(void)2021 static void __exit atalk_exit(void)
2022 {
2023 #ifdef CONFIG_SYSCTL
2024 	atalk_unregister_sysctl();
2025 #endif /* CONFIG_SYSCTL */
2026 	atalk_proc_exit();
2027 	aarp_cleanup_module();	/* General aarp clean-up. */
2028 	unregister_netdevice_notifier(&ddp_notifier);
2029 	dev_remove_pack(&ltalk_packet_type);
2030 	dev_remove_pack(&ppptalk_packet_type);
2031 	unregister_snap_client(ddp_dl);
2032 	sock_unregister(PF_APPLETALK);
2033 	proto_unregister(&ddp_proto);
2034 }
2035 module_exit(atalk_exit);
2036 
2037 MODULE_LICENSE("GPL");
2038 MODULE_AUTHOR("Alan Cox <alan@lxorguk.ukuu.org.uk>");
2039 MODULE_DESCRIPTION("AppleTalk 0.20\n");
2040 MODULE_ALIAS_NETPROTO(PF_APPLETALK);
2041