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