2 * DDP: An implementation of the AppleTalk DDP protocol for
5 * Alan Cox <alan@lxorguk.ukuu.org.uk>
7 * With more than a little assistance from
9 * Wesley Craig <netatalk@umich.edu>
12 * Neil Horman : Added missing device ioctls
13 * Michael Callahan : Made routing work
14 * Wesley Craig : Fix probing to listen to a
16 * Alan Cox : Added send/recvmsg support
17 * Alan Cox : Moved at. to protinfo in
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
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
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
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,
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.
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 <linux/compat.h>
59 #include <linux/slab.h>
60 #include <net/datalink.h>
61 #include <net/psnap.h>
63 #include <net/tcp_states.h>
64 #include <net/route.h>
65 #include <linux/atalk.h>
66 #include <linux/highmem.h>
68 struct datalink_proto
*ddp_dl
, *aarp_dl
;
69 static const struct proto_ops atalk_dgram_ops
;
71 /**************************************************************************\
73 * Handlers for the socket list. *
75 \**************************************************************************/
77 HLIST_HEAD(atalk_sockets
);
78 DEFINE_RWLOCK(atalk_sockets_lock
);
80 static inline void __atalk_insert_socket(struct sock
*sk
)
82 sk_add_node(sk
, &atalk_sockets
);
85 static inline void atalk_remove_socket(struct sock
*sk
)
87 write_lock_bh(&atalk_sockets_lock
);
89 write_unlock_bh(&atalk_sockets_lock
);
92 static struct sock
*atalk_search_socket(struct sockaddr_at
*to
,
93 struct atalk_iface
*atif
)
97 read_lock_bh(&atalk_sockets_lock
);
98 sk_for_each(s
, &atalk_sockets
) {
99 struct atalk_sock
*at
= at_sk(s
);
101 if (to
->sat_port
!= at
->src_port
)
104 if (to
->sat_addr
.s_net
== ATADDR_ANYNET
&&
105 to
->sat_addr
.s_node
== ATADDR_BCAST
)
108 if (to
->sat_addr
.s_net
== at
->src_net
&&
109 (to
->sat_addr
.s_node
== at
->src_node
||
110 to
->sat_addr
.s_node
== ATADDR_BCAST
||
111 to
->sat_addr
.s_node
== ATADDR_ANYNODE
))
114 /* XXXX.0 -- we got a request for this router. make sure
115 * that the node is appropriately set. */
116 if (to
->sat_addr
.s_node
== ATADDR_ANYNODE
&&
117 to
->sat_addr
.s_net
!= ATADDR_ANYNET
&&
118 atif
->address
.s_node
== at
->src_node
) {
119 to
->sat_addr
.s_node
= atif
->address
.s_node
;
125 read_unlock_bh(&atalk_sockets_lock
);
130 * atalk_find_or_insert_socket - Try to find a socket matching ADDR
131 * @sk: socket to insert in the list if it is not there already
132 * @sat: address to search for
134 * Try to find a socket matching ADDR in the socket list, if found then return
135 * it. If not, insert SK into the socket list.
137 * This entire operation must execute atomically.
139 static struct sock
*atalk_find_or_insert_socket(struct sock
*sk
,
140 struct sockaddr_at
*sat
)
143 struct atalk_sock
*at
;
145 write_lock_bh(&atalk_sockets_lock
);
146 sk_for_each(s
, &atalk_sockets
) {
149 if (at
->src_net
== sat
->sat_addr
.s_net
&&
150 at
->src_node
== sat
->sat_addr
.s_node
&&
151 at
->src_port
== sat
->sat_port
)
155 __atalk_insert_socket(sk
); /* Wheee, it's free, assign and insert. */
157 write_unlock_bh(&atalk_sockets_lock
);
161 static void atalk_destroy_timer(struct timer_list
*t
)
163 struct sock
*sk
= from_timer(sk
, t
, sk_timer
);
165 if (sk_has_allocations(sk
)) {
166 sk
->sk_timer
.expires
= jiffies
+ SOCK_DESTROY_TIME
;
167 add_timer(&sk
->sk_timer
);
172 static inline void atalk_destroy_socket(struct sock
*sk
)
174 atalk_remove_socket(sk
);
175 skb_queue_purge(&sk
->sk_receive_queue
);
177 if (sk_has_allocations(sk
)) {
178 timer_setup(&sk
->sk_timer
, atalk_destroy_timer
, 0);
179 sk
->sk_timer
.expires
= jiffies
+ SOCK_DESTROY_TIME
;
180 add_timer(&sk
->sk_timer
);
185 /**************************************************************************\
187 * Routing tables for the AppleTalk socket layer. *
189 \**************************************************************************/
191 /* Anti-deadlock ordering is atalk_routes_lock --> iface_lock -DaveM */
192 struct atalk_route
*atalk_routes
;
193 DEFINE_RWLOCK(atalk_routes_lock
);
195 struct atalk_iface
*atalk_interfaces
;
196 DEFINE_RWLOCK(atalk_interfaces_lock
);
198 /* For probing devices or in a routerless network */
199 struct atalk_route atrtr_default
;
201 /* AppleTalk interface control */
203 * Drop a device. Doesn't drop any of its routes - that is the caller's
204 * problem. Called when we down the interface or delete the address.
206 static void atif_drop_device(struct net_device
*dev
)
208 struct atalk_iface
**iface
= &atalk_interfaces
;
209 struct atalk_iface
*tmp
;
211 write_lock_bh(&atalk_interfaces_lock
);
212 while ((tmp
= *iface
) != NULL
) {
213 if (tmp
->dev
== dev
) {
217 dev
->atalk_ptr
= NULL
;
221 write_unlock_bh(&atalk_interfaces_lock
);
224 static struct atalk_iface
*atif_add_device(struct net_device
*dev
,
225 struct atalk_addr
*sa
)
227 struct atalk_iface
*iface
= kzalloc(sizeof(*iface
), GFP_KERNEL
);
234 dev
->atalk_ptr
= iface
;
235 iface
->address
= *sa
;
238 write_lock_bh(&atalk_interfaces_lock
);
239 iface
->next
= atalk_interfaces
;
240 atalk_interfaces
= iface
;
241 write_unlock_bh(&atalk_interfaces_lock
);
246 /* Perform phase 2 AARP probing on our tentative address */
247 static int atif_probe_device(struct atalk_iface
*atif
)
249 int netrange
= ntohs(atif
->nets
.nr_lastnet
) -
250 ntohs(atif
->nets
.nr_firstnet
) + 1;
251 int probe_net
= ntohs(atif
->address
.s_net
);
252 int probe_node
= atif
->address
.s_node
;
255 /* Offset the network we start probing with */
256 if (probe_net
== ATADDR_ANYNET
) {
257 probe_net
= ntohs(atif
->nets
.nr_firstnet
);
259 probe_net
+= jiffies
% netrange
;
261 if (probe_node
== ATADDR_ANYNODE
)
262 probe_node
= jiffies
& 0xFF;
264 /* Scan the networks */
265 atif
->status
|= ATIF_PROBE
;
266 for (netct
= 0; netct
<= netrange
; netct
++) {
267 /* Sweep the available nodes from a given start */
268 atif
->address
.s_net
= htons(probe_net
);
269 for (nodect
= 0; nodect
< 256; nodect
++) {
270 atif
->address
.s_node
= (nodect
+ probe_node
) & 0xFF;
271 if (atif
->address
.s_node
> 0 &&
272 atif
->address
.s_node
< 254) {
273 /* Probe a proposed address */
274 aarp_probe_network(atif
);
276 if (!(atif
->status
& ATIF_PROBE_FAIL
)) {
277 atif
->status
&= ~ATIF_PROBE
;
281 atif
->status
&= ~ATIF_PROBE_FAIL
;
284 if (probe_net
> ntohs(atif
->nets
.nr_lastnet
))
285 probe_net
= ntohs(atif
->nets
.nr_firstnet
);
287 atif
->status
&= ~ATIF_PROBE
;
289 return -EADDRINUSE
; /* Network is full... */
293 /* Perform AARP probing for a proxy address */
294 static int atif_proxy_probe_device(struct atalk_iface
*atif
,
295 struct atalk_addr
*proxy_addr
)
297 int netrange
= ntohs(atif
->nets
.nr_lastnet
) -
298 ntohs(atif
->nets
.nr_firstnet
) + 1;
299 /* we probe the interface's network */
300 int probe_net
= ntohs(atif
->address
.s_net
);
301 int probe_node
= ATADDR_ANYNODE
; /* we'll take anything */
304 /* Offset the network we start probing with */
305 if (probe_net
== ATADDR_ANYNET
) {
306 probe_net
= ntohs(atif
->nets
.nr_firstnet
);
308 probe_net
+= jiffies
% netrange
;
311 if (probe_node
== ATADDR_ANYNODE
)
312 probe_node
= jiffies
& 0xFF;
314 /* Scan the networks */
315 for (netct
= 0; netct
<= netrange
; netct
++) {
316 /* Sweep the available nodes from a given start */
317 proxy_addr
->s_net
= htons(probe_net
);
318 for (nodect
= 0; nodect
< 256; nodect
++) {
319 proxy_addr
->s_node
= (nodect
+ probe_node
) & 0xFF;
320 if (proxy_addr
->s_node
> 0 &&
321 proxy_addr
->s_node
< 254) {
322 /* Tell AARP to probe a proposed address */
323 int ret
= aarp_proxy_probe_network(atif
,
326 if (ret
!= -EADDRINUSE
)
331 if (probe_net
> ntohs(atif
->nets
.nr_lastnet
))
332 probe_net
= ntohs(atif
->nets
.nr_firstnet
);
335 return -EADDRINUSE
; /* Network is full... */
339 struct atalk_addr
*atalk_find_dev_addr(struct net_device
*dev
)
341 struct atalk_iface
*iface
= dev
->atalk_ptr
;
342 return iface
? &iface
->address
: NULL
;
345 static struct atalk_addr
*atalk_find_primary(void)
347 struct atalk_iface
*fiface
= NULL
;
348 struct atalk_addr
*retval
;
349 struct atalk_iface
*iface
;
352 * Return a point-to-point interface only if
353 * there is no non-ptp interface available.
355 read_lock_bh(&atalk_interfaces_lock
);
356 for (iface
= atalk_interfaces
; iface
; iface
= iface
->next
) {
357 if (!fiface
&& !(iface
->dev
->flags
& IFF_LOOPBACK
))
359 if (!(iface
->dev
->flags
& (IFF_LOOPBACK
| IFF_POINTOPOINT
))) {
360 retval
= &iface
->address
;
366 retval
= &fiface
->address
;
367 else if (atalk_interfaces
)
368 retval
= &atalk_interfaces
->address
;
372 read_unlock_bh(&atalk_interfaces_lock
);
377 * Find a match for 'any network' - ie any of our interfaces with that
378 * node number will do just nicely.
380 static struct atalk_iface
*atalk_find_anynet(int node
, struct net_device
*dev
)
382 struct atalk_iface
*iface
= dev
->atalk_ptr
;
384 if (!iface
|| iface
->status
& ATIF_PROBE
)
387 if (node
!= ATADDR_BCAST
&&
388 iface
->address
.s_node
!= node
&&
389 node
!= ATADDR_ANYNODE
)
398 /* Find a match for a specific network:node pair */
399 static struct atalk_iface
*atalk_find_interface(__be16 net
, int node
)
401 struct atalk_iface
*iface
;
403 read_lock_bh(&atalk_interfaces_lock
);
404 for (iface
= atalk_interfaces
; iface
; iface
= iface
->next
) {
405 if ((node
== ATADDR_BCAST
||
406 node
== ATADDR_ANYNODE
||
407 iface
->address
.s_node
== node
) &&
408 iface
->address
.s_net
== net
&&
409 !(iface
->status
& ATIF_PROBE
))
412 /* XXXX.0 -- net.0 returns the iface associated with net */
413 if (node
== ATADDR_ANYNODE
&& net
!= ATADDR_ANYNET
&&
414 ntohs(iface
->nets
.nr_firstnet
) <= ntohs(net
) &&
415 ntohs(net
) <= ntohs(iface
->nets
.nr_lastnet
))
418 read_unlock_bh(&atalk_interfaces_lock
);
424 * Find a route for an AppleTalk packet. This ought to get cached in
425 * the socket (later on...). We know about host routes and the fact
426 * that a route must be direct to broadcast.
428 static struct atalk_route
*atrtr_find(struct atalk_addr
*target
)
431 * we must search through all routes unless we find a
432 * host route, because some host routes might overlap
435 struct atalk_route
*net_route
= NULL
;
436 struct atalk_route
*r
;
438 read_lock_bh(&atalk_routes_lock
);
439 for (r
= atalk_routes
; r
; r
= r
->next
) {
440 if (!(r
->flags
& RTF_UP
))
443 if (r
->target
.s_net
== target
->s_net
) {
444 if (r
->flags
& RTF_HOST
) {
446 * if this host route is for the target,
449 if (r
->target
.s_node
== target
->s_node
)
453 * this route will work if there isn't a
454 * direct host route, so cache it
461 * if we found a network route but not a direct host
462 * route, then return it
466 else if (atrtr_default
.dev
)
468 else /* No route can be found */
471 read_unlock_bh(&atalk_routes_lock
);
477 * Given an AppleTalk network, find the device to use. This can be
480 struct net_device
*atrtr_get_dev(struct atalk_addr
*sa
)
482 struct atalk_route
*atr
= atrtr_find(sa
);
483 return atr
? atr
->dev
: NULL
;
486 /* Set up a default router */
487 static void atrtr_set_default(struct net_device
*dev
)
489 atrtr_default
.dev
= dev
;
490 atrtr_default
.flags
= RTF_UP
;
491 atrtr_default
.gateway
.s_net
= htons(0);
492 atrtr_default
.gateway
.s_node
= 0;
496 * Add a router. Basically make sure it looks valid and stuff the
497 * entry in the list. While it uses netranges we always set them to one
498 * entry to work like netatalk.
500 static int atrtr_create(struct rtentry
*r
, struct net_device
*devhint
)
502 struct sockaddr_at
*ta
= (struct sockaddr_at
*)&r
->rt_dst
;
503 struct sockaddr_at
*ga
= (struct sockaddr_at
*)&r
->rt_gateway
;
504 struct atalk_route
*rt
;
505 struct atalk_iface
*iface
, *riface
;
506 int retval
= -EINVAL
;
509 * Fixme: Raise/Lower a routing change semaphore for these
513 /* Validate the request */
514 if (ta
->sat_family
!= AF_APPLETALK
||
515 (!devhint
&& ga
->sat_family
!= AF_APPLETALK
))
518 /* Now walk the routing table and make our decisions */
519 write_lock_bh(&atalk_routes_lock
);
520 for (rt
= atalk_routes
; rt
; rt
= rt
->next
) {
521 if (r
->rt_flags
!= rt
->flags
)
524 if (ta
->sat_addr
.s_net
== rt
->target
.s_net
) {
525 if (!(rt
->flags
& RTF_HOST
))
527 if (ta
->sat_addr
.s_node
== rt
->target
.s_node
)
535 read_lock_bh(&atalk_interfaces_lock
);
536 for (iface
= atalk_interfaces
; iface
; iface
= iface
->next
) {
538 ntohs(ga
->sat_addr
.s_net
) >=
539 ntohs(iface
->nets
.nr_firstnet
) &&
540 ntohs(ga
->sat_addr
.s_net
) <=
541 ntohs(iface
->nets
.nr_lastnet
))
544 if (ga
->sat_addr
.s_net
== iface
->address
.s_net
&&
545 ga
->sat_addr
.s_node
== iface
->address
.s_node
)
548 read_unlock_bh(&atalk_interfaces_lock
);
550 retval
= -ENETUNREACH
;
554 devhint
= riface
->dev
;
558 rt
= kzalloc(sizeof(*rt
), GFP_ATOMIC
);
564 rt
->next
= atalk_routes
;
568 /* Fill in the routing entry */
569 rt
->target
= ta
->sat_addr
;
572 rt
->flags
= r
->rt_flags
;
573 rt
->gateway
= ga
->sat_addr
;
577 write_unlock_bh(&atalk_routes_lock
);
582 /* Delete a route. Find it and discard it */
583 static int atrtr_delete(struct atalk_addr
*addr
)
585 struct atalk_route
**r
= &atalk_routes
;
587 struct atalk_route
*tmp
;
589 write_lock_bh(&atalk_routes_lock
);
590 while ((tmp
= *r
) != NULL
) {
591 if (tmp
->target
.s_net
== addr
->s_net
&&
592 (!(tmp
->flags
&RTF_GATEWAY
) ||
593 tmp
->target
.s_node
== addr
->s_node
)) {
603 write_unlock_bh(&atalk_routes_lock
);
608 * Called when a device is downed. Just throw away any routes
611 static void atrtr_device_down(struct net_device
*dev
)
613 struct atalk_route
**r
= &atalk_routes
;
614 struct atalk_route
*tmp
;
616 write_lock_bh(&atalk_routes_lock
);
617 while ((tmp
= *r
) != NULL
) {
618 if (tmp
->dev
== dev
) {
625 write_unlock_bh(&atalk_routes_lock
);
627 if (atrtr_default
.dev
== dev
)
628 atrtr_set_default(NULL
);
631 /* Actually down the interface */
632 static inline void atalk_dev_down(struct net_device
*dev
)
634 atrtr_device_down(dev
); /* Remove all routes for the device */
635 aarp_device_down(dev
); /* Remove AARP entries for the device */
636 atif_drop_device(dev
); /* Remove the device */
640 * A device event has occurred. Watch for devices going down and
641 * delete our use of them (iface and route).
643 static int ddp_device_event(struct notifier_block
*this, unsigned long event
,
646 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
648 if (!net_eq(dev_net(dev
), &init_net
))
651 if (event
== NETDEV_DOWN
)
652 /* Discard any use of this */
658 /* ioctl calls. Shouldn't even need touching */
659 /* Device configuration ioctl calls */
660 static int atif_ioctl(int cmd
, void __user
*arg
)
662 static char aarp_mcast
[6] = { 0x09, 0x00, 0x00, 0xFF, 0xFF, 0xFF };
664 struct atalk_netrange
*nr
;
665 struct sockaddr_at
*sa
;
666 struct net_device
*dev
;
667 struct atalk_iface
*atif
;
670 struct rtentry rtdef
;
673 if (copy_from_user(&atreq
, arg
, sizeof(atreq
)))
676 dev
= __dev_get_by_name(&init_net
, atreq
.ifr_name
);
680 sa
= (struct sockaddr_at
*)&atreq
.ifr_addr
;
681 atif
= atalk_find_dev(dev
);
685 if (!capable(CAP_NET_ADMIN
))
687 if (sa
->sat_family
!= AF_APPLETALK
)
689 if (dev
->type
!= ARPHRD_ETHER
&&
690 dev
->type
!= ARPHRD_LOOPBACK
&&
691 dev
->type
!= ARPHRD_LOCALTLK
&&
692 dev
->type
!= ARPHRD_PPP
)
693 return -EPROTONOSUPPORT
;
695 nr
= (struct atalk_netrange
*)&sa
->sat_zero
[0];
699 * if this is a point-to-point iface, and we already
700 * have an iface for this AppleTalk address, then we
701 * should not add a route
703 if ((dev
->flags
& IFF_POINTOPOINT
) &&
704 atalk_find_interface(sa
->sat_addr
.s_net
,
705 sa
->sat_addr
.s_node
)) {
706 printk(KERN_DEBUG
"AppleTalk: point-to-point "
707 "interface added with "
708 "existing address\n");
713 * Phase 1 is fine on LocalTalk but we don't do
714 * EtherTalk phase 1. Anyone wanting to add it go ahead.
716 if (dev
->type
== ARPHRD_ETHER
&& nr
->nr_phase
!= 2)
717 return -EPROTONOSUPPORT
;
718 if (sa
->sat_addr
.s_node
== ATADDR_BCAST
||
719 sa
->sat_addr
.s_node
== 254)
722 /* Already setting address */
723 if (atif
->status
& ATIF_PROBE
)
726 atif
->address
.s_net
= sa
->sat_addr
.s_net
;
727 atif
->address
.s_node
= sa
->sat_addr
.s_node
;
728 atrtr_device_down(dev
); /* Flush old routes */
730 atif
= atif_add_device(dev
, &sa
->sat_addr
);
737 * Check if the chosen address is used. If so we
738 * error and atalkd will try another.
741 if (!(dev
->flags
& IFF_LOOPBACK
) &&
742 !(dev
->flags
& IFF_POINTOPOINT
) &&
743 atif_probe_device(atif
) < 0) {
744 atif_drop_device(dev
);
748 /* Hey it worked - add the direct routes */
749 sa
= (struct sockaddr_at
*)&rtdef
.rt_gateway
;
750 sa
->sat_family
= AF_APPLETALK
;
751 sa
->sat_addr
.s_net
= atif
->address
.s_net
;
752 sa
->sat_addr
.s_node
= atif
->address
.s_node
;
753 sa
= (struct sockaddr_at
*)&rtdef
.rt_dst
;
754 rtdef
.rt_flags
= RTF_UP
;
755 sa
->sat_family
= AF_APPLETALK
;
756 sa
->sat_addr
.s_node
= ATADDR_ANYNODE
;
757 if (dev
->flags
& IFF_LOOPBACK
||
758 dev
->flags
& IFF_POINTOPOINT
)
759 rtdef
.rt_flags
|= RTF_HOST
;
761 /* Routerless initial state */
762 if (nr
->nr_firstnet
== htons(0) &&
763 nr
->nr_lastnet
== htons(0xFFFE)) {
764 sa
->sat_addr
.s_net
= atif
->address
.s_net
;
765 atrtr_create(&rtdef
, dev
);
766 atrtr_set_default(dev
);
768 limit
= ntohs(nr
->nr_lastnet
);
769 if (limit
- ntohs(nr
->nr_firstnet
) > 4096) {
770 printk(KERN_WARNING
"Too many routes/"
775 for (ct
= ntohs(nr
->nr_firstnet
);
777 sa
->sat_addr
.s_net
= htons(ct
);
778 atrtr_create(&rtdef
, dev
);
781 dev_mc_add_global(dev
, aarp_mcast
);
786 return -EADDRNOTAVAIL
;
788 sa
->sat_family
= AF_APPLETALK
;
789 sa
->sat_addr
= atif
->address
;
794 return -EADDRNOTAVAIL
;
796 sa
->sat_family
= AF_APPLETALK
;
797 sa
->sat_addr
.s_net
= atif
->address
.s_net
;
798 sa
->sat_addr
.s_node
= ATADDR_BCAST
;
801 case SIOCATALKDIFADDR
:
803 if (!capable(CAP_NET_ADMIN
))
805 if (sa
->sat_family
!= AF_APPLETALK
)
811 if (!capable(CAP_NET_ADMIN
))
813 if (sa
->sat_family
!= AF_APPLETALK
)
816 * for now, we only support proxy AARP on ELAP;
817 * we should be able to do it for LocalTalk, too.
819 if (dev
->type
!= ARPHRD_ETHER
)
820 return -EPROTONOSUPPORT
;
823 * atif points to the current interface on this network;
824 * we aren't concerned about its current status (at
825 * least for now), but it has all the settings about
826 * the network we're going to probe. Consequently, it
830 return -EADDRNOTAVAIL
;
832 nr
= (struct atalk_netrange
*)&(atif
->nets
);
834 * Phase 1 is fine on Localtalk but we don't do
835 * Ethertalk phase 1. Anyone wanting to add it go ahead.
837 if (dev
->type
== ARPHRD_ETHER
&& nr
->nr_phase
!= 2)
838 return -EPROTONOSUPPORT
;
840 if (sa
->sat_addr
.s_node
== ATADDR_BCAST
||
841 sa
->sat_addr
.s_node
== 254)
845 * Check if the chosen address is used. If so we
846 * error and ATCP will try another.
848 if (atif_proxy_probe_device(atif
, &(sa
->sat_addr
)) < 0)
852 * We now have an address on the local network, and
853 * the AARP code will defend it for us until we take it
854 * down. We don't set up any routes right now, because
855 * ATCP will install them manually via SIOCADDRT.
860 if (!capable(CAP_NET_ADMIN
))
862 if (sa
->sat_family
!= AF_APPLETALK
)
865 return -EADDRNOTAVAIL
;
867 /* give to aarp module to remove proxy entry */
868 aarp_proxy_remove(atif
->dev
, &(sa
->sat_addr
));
872 return copy_to_user(arg
, &atreq
, sizeof(atreq
)) ? -EFAULT
: 0;
875 /* Routing ioctl() calls */
876 static int atrtr_ioctl(unsigned int cmd
, void __user
*arg
)
880 if (copy_from_user(&rt
, arg
, sizeof(rt
)))
885 if (rt
.rt_dst
.sa_family
!= AF_APPLETALK
)
887 return atrtr_delete(&((struct sockaddr_at
*)
888 &rt
.rt_dst
)->sat_addr
);
891 struct net_device
*dev
= NULL
;
894 if (copy_from_user(name
, rt
.rt_dev
, IFNAMSIZ
-1))
896 name
[IFNAMSIZ
-1] = '\0';
897 dev
= __dev_get_by_name(&init_net
, name
);
901 return atrtr_create(&rt
, dev
);
907 /**************************************************************************\
909 * Handling for system calls applied via the various interfaces to an *
910 * AppleTalk socket object. *
912 \**************************************************************************/
915 * Checksum: This is 'optional'. It's quite likely also a good
916 * candidate for assembler hackery 8)
918 static unsigned long atalk_sum_partial(const unsigned char *data
,
919 int len
, unsigned long sum
)
921 /* This ought to be unwrapped neatly. I'll trust gcc for now */
929 /* Checksum skb data -- similar to skb_checksum */
930 static unsigned long atalk_sum_skb(const struct sk_buff
*skb
, int offset
,
931 int len
, unsigned long sum
)
933 int start
= skb_headlen(skb
);
934 struct sk_buff
*frag_iter
;
937 /* checksum stuff in header space */
938 if ((copy
= start
- offset
) > 0) {
941 sum
= atalk_sum_partial(skb
->data
+ offset
, copy
, sum
);
942 if ((len
-= copy
) == 0)
948 /* checksum stuff in frags */
949 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++) {
951 const skb_frag_t
*frag
= &skb_shinfo(skb
)->frags
[i
];
952 WARN_ON(start
> offset
+ len
);
954 end
= start
+ skb_frag_size(frag
);
955 if ((copy
= end
- offset
) > 0) {
960 vaddr
= kmap_atomic(skb_frag_page(frag
));
961 sum
= atalk_sum_partial(vaddr
+ frag
->page_offset
+
962 offset
- start
, copy
, sum
);
963 kunmap_atomic(vaddr
);
972 skb_walk_frags(skb
, frag_iter
) {
975 WARN_ON(start
> offset
+ len
);
977 end
= start
+ frag_iter
->len
;
978 if ((copy
= end
- offset
) > 0) {
981 sum
= atalk_sum_skb(frag_iter
, offset
- start
,
983 if ((len
-= copy
) == 0)
995 static __be16
atalk_checksum(const struct sk_buff
*skb
, int len
)
999 /* skip header 4 bytes */
1000 sum
= atalk_sum_skb(skb
, 4, len
-4, 0);
1002 /* Use 0xFFFF for 0. 0 itself means none */
1003 return sum
? htons((unsigned short)sum
) : htons(0xFFFF);
1006 static struct proto ddp_proto
= {
1008 .owner
= THIS_MODULE
,
1009 .obj_size
= sizeof(struct atalk_sock
),
1013 * Create a socket. Initialise the socket, blank the addresses
1016 static int atalk_create(struct net
*net
, struct socket
*sock
, int protocol
,
1020 int rc
= -ESOCKTNOSUPPORT
;
1022 if (!net_eq(net
, &init_net
))
1023 return -EAFNOSUPPORT
;
1026 * We permit SOCK_DGRAM and RAW is an extension. It is trivial to do
1027 * and gives you the full ELAP frame. Should be handy for CAP 8)
1029 if (sock
->type
!= SOCK_RAW
&& sock
->type
!= SOCK_DGRAM
)
1032 sk
= sk_alloc(net
, PF_APPLETALK
, GFP_KERNEL
, &ddp_proto
, kern
);
1036 sock
->ops
= &atalk_dgram_ops
;
1037 sock_init_data(sock
, sk
);
1039 /* Checksums on by default */
1040 sock_set_flag(sk
, SOCK_ZAPPED
);
1045 /* Free a socket. No work needed */
1046 static int atalk_release(struct socket
*sock
)
1048 struct sock
*sk
= sock
->sk
;
1056 atalk_destroy_socket(sk
);
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
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.
1072 * This whole operation must be atomic.
1074 static int atalk_pick_and_bind_port(struct sock
*sk
, struct sockaddr_at
*sat
)
1078 write_lock_bh(&atalk_sockets_lock
);
1080 for (sat
->sat_port
= ATPORT_RESERVED
;
1081 sat
->sat_port
< ATPORT_LAST
;
1085 sk_for_each(s
, &atalk_sockets
) {
1086 struct atalk_sock
*at
= at_sk(s
);
1088 if (at
->src_net
== sat
->sat_addr
.s_net
&&
1089 at
->src_node
== sat
->sat_addr
.s_node
&&
1090 at
->src_port
== sat
->sat_port
)
1094 /* Wheee, it's free, assign and insert. */
1095 __atalk_insert_socket(sk
);
1096 at_sk(sk
)->src_port
= sat
->sat_port
;
1105 write_unlock_bh(&atalk_sockets_lock
);
1109 static int atalk_autobind(struct sock
*sk
)
1111 struct atalk_sock
*at
= at_sk(sk
);
1112 struct sockaddr_at sat
;
1113 struct atalk_addr
*ap
= atalk_find_primary();
1114 int n
= -EADDRNOTAVAIL
;
1116 if (!ap
|| ap
->s_net
== htons(ATADDR_ANYNET
))
1119 at
->src_net
= sat
.sat_addr
.s_net
= ap
->s_net
;
1120 at
->src_node
= sat
.sat_addr
.s_node
= ap
->s_node
;
1122 n
= atalk_pick_and_bind_port(sk
, &sat
);
1124 sock_reset_flag(sk
, SOCK_ZAPPED
);
1129 /* Set the address 'our end' of the connection */
1130 static int atalk_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int addr_len
)
1132 struct sockaddr_at
*addr
= (struct sockaddr_at
*)uaddr
;
1133 struct sock
*sk
= sock
->sk
;
1134 struct atalk_sock
*at
= at_sk(sk
);
1137 if (!sock_flag(sk
, SOCK_ZAPPED
) ||
1138 addr_len
!= sizeof(struct sockaddr_at
))
1141 if (addr
->sat_family
!= AF_APPLETALK
)
1142 return -EAFNOSUPPORT
;
1145 if (addr
->sat_addr
.s_net
== htons(ATADDR_ANYNET
)) {
1146 struct atalk_addr
*ap
= atalk_find_primary();
1148 err
= -EADDRNOTAVAIL
;
1152 at
->src_net
= addr
->sat_addr
.s_net
= ap
->s_net
;
1153 at
->src_node
= addr
->sat_addr
.s_node
= ap
->s_node
;
1155 err
= -EADDRNOTAVAIL
;
1156 if (!atalk_find_interface(addr
->sat_addr
.s_net
,
1157 addr
->sat_addr
.s_node
))
1160 at
->src_net
= addr
->sat_addr
.s_net
;
1161 at
->src_node
= addr
->sat_addr
.s_node
;
1164 if (addr
->sat_port
== ATADDR_ANYPORT
) {
1165 err
= atalk_pick_and_bind_port(sk
, addr
);
1170 at
->src_port
= addr
->sat_port
;
1173 if (atalk_find_or_insert_socket(sk
, addr
))
1177 sock_reset_flag(sk
, SOCK_ZAPPED
);
1184 /* Set the address we talk to */
1185 static int atalk_connect(struct socket
*sock
, struct sockaddr
*uaddr
,
1186 int addr_len
, int flags
)
1188 struct sock
*sk
= sock
->sk
;
1189 struct atalk_sock
*at
= at_sk(sk
);
1190 struct sockaddr_at
*addr
;
1193 sk
->sk_state
= TCP_CLOSE
;
1194 sock
->state
= SS_UNCONNECTED
;
1196 if (addr_len
!= sizeof(*addr
))
1199 addr
= (struct sockaddr_at
*)uaddr
;
1201 if (addr
->sat_family
!= AF_APPLETALK
)
1202 return -EAFNOSUPPORT
;
1204 if (addr
->sat_addr
.s_node
== ATADDR_BCAST
&&
1205 !sock_flag(sk
, SOCK_BROADCAST
)) {
1207 pr_warn("atalk_connect: %s is broken and did not set SO_BROADCAST.\n",
1216 if (sock_flag(sk
, SOCK_ZAPPED
))
1217 if (atalk_autobind(sk
) < 0)
1221 if (!atrtr_get_dev(&addr
->sat_addr
))
1224 at
->dest_port
= addr
->sat_port
;
1225 at
->dest_net
= addr
->sat_addr
.s_net
;
1226 at
->dest_node
= addr
->sat_addr
.s_node
;
1228 sock
->state
= SS_CONNECTED
;
1229 sk
->sk_state
= TCP_ESTABLISHED
;
1237 * Find the name of an AppleTalk socket. Just copy the right
1238 * fields into the sockaddr.
1240 static int atalk_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
1243 struct sockaddr_at sat
;
1244 struct sock
*sk
= sock
->sk
;
1245 struct atalk_sock
*at
= at_sk(sk
);
1250 if (sock_flag(sk
, SOCK_ZAPPED
))
1251 if (atalk_autobind(sk
) < 0)
1254 memset(&sat
, 0, sizeof(sat
));
1258 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1261 sat
.sat_addr
.s_net
= at
->dest_net
;
1262 sat
.sat_addr
.s_node
= at
->dest_node
;
1263 sat
.sat_port
= at
->dest_port
;
1265 sat
.sat_addr
.s_net
= at
->src_net
;
1266 sat
.sat_addr
.s_node
= at
->src_node
;
1267 sat
.sat_port
= at
->src_port
;
1270 sat
.sat_family
= AF_APPLETALK
;
1271 memcpy(uaddr
, &sat
, sizeof(sat
));
1272 err
= sizeof(struct sockaddr_at
);
1279 #if IS_ENABLED(CONFIG_IPDDP)
1280 static __inline__
int is_ip_over_ddp(struct sk_buff
*skb
)
1282 return skb
->data
[12] == 22;
1285 static int handle_ip_over_ddp(struct sk_buff
*skb
)
1287 struct net_device
*dev
= __dev_get_by_name(&init_net
, "ipddp0");
1288 struct net_device_stats
*stats
;
1290 /* This needs to be able to handle ipddp"N" devices */
1296 skb
->protocol
= htons(ETH_P_IP
);
1299 skb_reset_transport_header(skb
);
1301 stats
= netdev_priv(dev
);
1302 stats
->rx_packets
++;
1303 stats
->rx_bytes
+= skb
->len
+ 13;
1304 return netif_rx(skb
); /* Send the SKB up to a higher place. */
1307 /* make it easy for gcc to optimize this test out, i.e. kill the code */
1308 #define is_ip_over_ddp(skb) 0
1309 #define handle_ip_over_ddp(skb) 0
1312 static int atalk_route_packet(struct sk_buff
*skb
, struct net_device
*dev
,
1313 struct ddpehdr
*ddp
, __u16 len_hops
, int origlen
)
1315 struct atalk_route
*rt
;
1316 struct atalk_addr ta
;
1319 * Don't route multicast, etc., packets, or packets sent to "this
1322 if (skb
->pkt_type
!= PACKET_HOST
|| !ddp
->deh_dnet
) {
1326 * Can it ever happen that a packet is from a PPP iface and
1327 * needs to be broadcast onto the default network?
1329 if (dev
->type
== ARPHRD_PPP
)
1330 printk(KERN_DEBUG
"AppleTalk: didn't forward broadcast "
1331 "packet received from PPP iface\n");
1335 ta
.s_net
= ddp
->deh_dnet
;
1336 ta
.s_node
= ddp
->deh_dnode
;
1338 /* Route the packet */
1339 rt
= atrtr_find(&ta
);
1340 /* increment hops count */
1341 len_hops
+= 1 << 10;
1342 if (!rt
|| !(len_hops
& (15 << 10)))
1345 /* FIXME: use skb->cb to be able to use shared skbs */
1348 * Route goes through another gateway, so set the target to the
1352 if (rt
->flags
& RTF_GATEWAY
) {
1353 ta
.s_net
= rt
->gateway
.s_net
;
1354 ta
.s_node
= rt
->gateway
.s_node
;
1357 /* Fix up skb->len field */
1358 skb_trim(skb
, min_t(unsigned int, origlen
,
1359 (rt
->dev
->hard_header_len
+
1360 ddp_dl
->header_length
+ (len_hops
& 1023))));
1362 /* FIXME: use skb->cb to be able to use shared skbs */
1363 ddp
->deh_len_hops
= htons(len_hops
);
1366 * Send the buffer onwards
1368 * Now we must always be careful. If it's come from LocalTalk to
1369 * EtherTalk it might not fit
1371 * Order matters here: If a packet has to be copied to make a new
1372 * headroom (rare hopefully) then it won't need unsharing.
1374 * Note. ddp-> becomes invalid at the realloc.
1376 if (skb_headroom(skb
) < 22) {
1377 /* 22 bytes - 12 ether, 2 len, 3 802.2 5 snap */
1378 struct sk_buff
*nskb
= skb_realloc_headroom(skb
, 32);
1382 skb
= skb_unshare(skb
, GFP_ATOMIC
);
1385 * If the buffer didn't vanish into the lack of space bitbucket we can
1391 if (aarp_send_ddp(rt
->dev
, skb
, &ta
, NULL
) == NET_XMIT_DROP
)
1393 return NET_RX_SUCCESS
;
1401 * atalk_rcv - Receive a packet (in skb) from device dev
1402 * @skb - packet received
1403 * @dev - network device where the packet comes from
1406 * Receive a packet (in skb) from device dev. This has come from the SNAP
1407 * decoder, and on entry skb->transport_header is the DDP header, skb->len
1408 * is the DDP header, skb->len is the DDP length. The physical headers
1409 * have been extracted. PPP should probably pass frames marked as for this
1410 * layer. [ie ARPHRD_ETHERTALK]
1412 static int atalk_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
1413 struct packet_type
*pt
, struct net_device
*orig_dev
)
1415 struct ddpehdr
*ddp
;
1417 struct atalk_iface
*atif
;
1418 struct sockaddr_at tosat
;
1422 if (!net_eq(dev_net(dev
), &init_net
))
1425 /* Don't mangle buffer if shared */
1426 if (!(skb
= skb_share_check(skb
, GFP_ATOMIC
)))
1429 /* Size check and make sure header is contiguous */
1430 if (!pskb_may_pull(skb
, sizeof(*ddp
)))
1435 len_hops
= ntohs(ddp
->deh_len_hops
);
1437 /* Trim buffer in case of stray trailing data */
1439 skb_trim(skb
, min_t(unsigned int, skb
->len
, len_hops
& 1023));
1442 * Size check to see if ddp->deh_len was crap
1443 * (Otherwise we'll detonate most spectacularly
1444 * in the middle of atalk_checksum() or recvmsg()).
1446 if (skb
->len
< sizeof(*ddp
) || skb
->len
< (len_hops
& 1023)) {
1447 pr_debug("AppleTalk: dropping corrupted frame (deh_len=%u, "
1448 "skb->len=%u)\n", len_hops
& 1023, skb
->len
);
1453 * Any checksums. Note we don't do htons() on this == is assumed to be
1454 * valid for net byte orders all over the networking code...
1457 atalk_checksum(skb
, len_hops
& 1023) != ddp
->deh_sum
)
1458 /* Not a valid AppleTalk frame - dustbin time */
1461 /* Check the packet is aimed at us */
1462 if (!ddp
->deh_dnet
) /* Net 0 is 'this network' */
1463 atif
= atalk_find_anynet(ddp
->deh_dnode
, dev
);
1465 atif
= atalk_find_interface(ddp
->deh_dnet
, ddp
->deh_dnode
);
1468 /* Not ours, so we route the packet via the correct
1471 return atalk_route_packet(skb
, dev
, ddp
, len_hops
, origlen
);
1474 /* if IP over DDP is not selected this code will be optimized out */
1475 if (is_ip_over_ddp(skb
))
1476 return handle_ip_over_ddp(skb
);
1478 * Which socket - atalk_search_socket() looks for a *full match*
1479 * of the <net, node, port> tuple.
1481 tosat
.sat_addr
.s_net
= ddp
->deh_dnet
;
1482 tosat
.sat_addr
.s_node
= ddp
->deh_dnode
;
1483 tosat
.sat_port
= ddp
->deh_dport
;
1485 sock
= atalk_search_socket(&tosat
, atif
);
1486 if (!sock
) /* But not one of our sockets */
1489 /* Queue packet (standard) */
1490 if (sock_queue_rcv_skb(sock
, skb
) < 0)
1493 return NET_RX_SUCCESS
;
1503 * Receive a LocalTalk frame. We make some demands on the caller here.
1504 * Caller must provide enough headroom on the packet to pull the short
1505 * header and append a long one.
1507 static int ltalk_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
1508 struct packet_type
*pt
, struct net_device
*orig_dev
)
1510 if (!net_eq(dev_net(dev
), &init_net
))
1513 /* Expand any short form frames */
1514 if (skb_mac_header(skb
)[2] == 1) {
1515 struct ddpehdr
*ddp
;
1516 /* Find our address */
1517 struct atalk_addr
*ap
= atalk_find_dev_addr(dev
);
1519 if (!ap
|| skb
->len
< sizeof(__be16
) || skb
->len
> 1023)
1522 /* Don't mangle buffer if shared */
1523 if (!(skb
= skb_share_check(skb
, GFP_ATOMIC
)))
1527 * The push leaves us with a ddephdr not an shdr, and
1528 * handily the port bytes in the right place preset.
1530 ddp
= skb_push(skb
, sizeof(*ddp
) - 4);
1532 /* Now fill in the long header */
1535 * These two first. The mac overlays the new source/dest
1536 * network information so we MUST copy these before
1537 * we write the network numbers !
1540 ddp
->deh_dnode
= skb_mac_header(skb
)[0]; /* From physical header */
1541 ddp
->deh_snode
= skb_mac_header(skb
)[1]; /* From physical header */
1543 ddp
->deh_dnet
= ap
->s_net
; /* Network number */
1544 ddp
->deh_snet
= ap
->s_net
;
1545 ddp
->deh_sum
= 0; /* No checksum */
1547 * Not sure about this bit...
1549 /* Non routable, so force a drop if we slip up later */
1550 ddp
->deh_len_hops
= htons(skb
->len
+ (DDP_MAXHOPS
<< 10));
1552 skb_reset_transport_header(skb
);
1554 return atalk_rcv(skb
, dev
, pt
, orig_dev
);
1560 static int atalk_sendmsg(struct socket
*sock
, struct msghdr
*msg
, size_t len
)
1562 struct sock
*sk
= sock
->sk
;
1563 struct atalk_sock
*at
= at_sk(sk
);
1564 DECLARE_SOCKADDR(struct sockaddr_at
*, usat
, msg
->msg_name
);
1565 int flags
= msg
->msg_flags
;
1567 struct sockaddr_at local_satalk
, gsat
;
1568 struct sk_buff
*skb
;
1569 struct net_device
*dev
;
1570 struct ddpehdr
*ddp
;
1572 struct atalk_route
*rt
;
1575 if (flags
& ~(MSG_DONTWAIT
|MSG_CMSG_COMPAT
))
1578 if (len
> DDP_MAXSZ
)
1584 if (sock_flag(sk
, SOCK_ZAPPED
))
1585 if (atalk_autobind(sk
) < 0)
1589 if (msg
->msg_namelen
< sizeof(*usat
) ||
1590 usat
->sat_family
!= AF_APPLETALK
)
1594 /* netatalk didn't implement this check */
1595 if (usat
->sat_addr
.s_node
== ATADDR_BCAST
&&
1596 !sock_flag(sk
, SOCK_BROADCAST
)) {
1601 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1603 usat
= &local_satalk
;
1604 usat
->sat_family
= AF_APPLETALK
;
1605 usat
->sat_port
= at
->dest_port
;
1606 usat
->sat_addr
.s_node
= at
->dest_node
;
1607 usat
->sat_addr
.s_net
= at
->dest_net
;
1610 /* Build a packet */
1611 SOCK_DEBUG(sk
, "SK %p: Got address.\n", sk
);
1614 size
= sizeof(struct ddpehdr
) + len
+ ddp_dl
->header_length
;
1616 if (usat
->sat_addr
.s_net
|| usat
->sat_addr
.s_node
== ATADDR_ANYNODE
) {
1617 rt
= atrtr_find(&usat
->sat_addr
);
1619 struct atalk_addr at_hint
;
1622 at_hint
.s_net
= at
->src_net
;
1624 rt
= atrtr_find(&at_hint
);
1632 SOCK_DEBUG(sk
, "SK %p: Size needed %d, device %s\n",
1633 sk
, size
, dev
->name
);
1635 size
+= dev
->hard_header_len
;
1637 skb
= sock_alloc_send_skb(sk
, size
, (flags
& MSG_DONTWAIT
), &err
);
1642 skb_reserve(skb
, ddp_dl
->header_length
);
1643 skb_reserve(skb
, dev
->hard_header_len
);
1646 SOCK_DEBUG(sk
, "SK %p: Begin build.\n", sk
);
1648 ddp
= skb_put(skb
, sizeof(struct ddpehdr
));
1649 ddp
->deh_len_hops
= htons(len
+ sizeof(*ddp
));
1650 ddp
->deh_dnet
= usat
->sat_addr
.s_net
;
1651 ddp
->deh_snet
= at
->src_net
;
1652 ddp
->deh_dnode
= usat
->sat_addr
.s_node
;
1653 ddp
->deh_snode
= at
->src_node
;
1654 ddp
->deh_dport
= usat
->sat_port
;
1655 ddp
->deh_sport
= at
->src_port
;
1657 SOCK_DEBUG(sk
, "SK %p: Copy user data (%zd bytes).\n", sk
, len
);
1659 err
= memcpy_from_msg(skb_put(skb
, len
), msg
, len
);
1666 if (sk
->sk_no_check_tx
)
1669 ddp
->deh_sum
= atalk_checksum(skb
, len
+ sizeof(*ddp
));
1672 * Loopback broadcast packets to non gateway targets (ie routes
1673 * to group we are in)
1675 if (ddp
->deh_dnode
== ATADDR_BCAST
&&
1676 !(rt
->flags
& RTF_GATEWAY
) && !(dev
->flags
& IFF_LOOPBACK
)) {
1677 struct sk_buff
*skb2
= skb_copy(skb
, GFP_KERNEL
);
1681 SOCK_DEBUG(sk
, "SK %p: send out(copy).\n", sk
);
1683 * If it fails it is queued/sent above in the aarp queue
1685 aarp_send_ddp(dev
, skb2
, &usat
->sat_addr
, NULL
);
1689 if (dev
->flags
& IFF_LOOPBACK
|| loopback
) {
1690 SOCK_DEBUG(sk
, "SK %p: Loop back.\n", sk
);
1693 if (ddp
->deh_dnode
== ATADDR_BCAST
) {
1694 struct atalk_addr at_lo
;
1699 rt
= atrtr_find(&at_lo
);
1708 ddp_dl
->request(ddp_dl
, skb
, dev
->dev_addr
);
1710 SOCK_DEBUG(sk
, "SK %p: send out.\n", sk
);
1711 if (rt
->flags
& RTF_GATEWAY
) {
1712 gsat
.sat_addr
= rt
->gateway
;
1717 * If it fails it is queued/sent above in the aarp queue
1719 aarp_send_ddp(dev
, skb
, &usat
->sat_addr
, NULL
);
1721 SOCK_DEBUG(sk
, "SK %p: Done write (%zd).\n", sk
, len
);
1728 static int atalk_recvmsg(struct socket
*sock
, struct msghdr
*msg
, size_t size
,
1731 struct sock
*sk
= sock
->sk
;
1732 struct ddpehdr
*ddp
;
1736 struct sk_buff
*skb
;
1738 skb
= skb_recv_datagram(sk
, flags
& ~MSG_DONTWAIT
,
1739 flags
& MSG_DONTWAIT
, &err
);
1745 /* FIXME: use skb->cb to be able to use shared skbs */
1747 copied
= ntohs(ddp
->deh_len_hops
) & 1023;
1749 if (sk
->sk_type
!= SOCK_RAW
) {
1750 offset
= sizeof(*ddp
);
1754 if (copied
> size
) {
1756 msg
->msg_flags
|= MSG_TRUNC
;
1758 err
= skb_copy_datagram_msg(skb
, offset
, msg
, copied
);
1760 if (!err
&& msg
->msg_name
) {
1761 DECLARE_SOCKADDR(struct sockaddr_at
*, sat
, msg
->msg_name
);
1762 sat
->sat_family
= AF_APPLETALK
;
1763 sat
->sat_port
= ddp
->deh_sport
;
1764 sat
->sat_addr
.s_node
= ddp
->deh_snode
;
1765 sat
->sat_addr
.s_net
= ddp
->deh_snet
;
1766 msg
->msg_namelen
= sizeof(*sat
);
1769 skb_free_datagram(sk
, skb
); /* Free the datagram. */
1773 return err
? : copied
;
1778 * AppleTalk ioctl calls.
1780 static int atalk_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1782 int rc
= -ENOIOCTLCMD
;
1783 struct sock
*sk
= sock
->sk
;
1784 void __user
*argp
= (void __user
*)arg
;
1787 /* Protocol layer */
1789 long amount
= sk
->sk_sndbuf
- sk_wmem_alloc_get(sk
);
1793 rc
= put_user(amount
, (int __user
*)argp
);
1798 * These two are safe on a single CPU system as only
1799 * user tasks fiddle here
1801 struct sk_buff
*skb
= skb_peek(&sk
->sk_receive_queue
);
1805 amount
= skb
->len
- sizeof(struct ddpehdr
);
1806 rc
= put_user(amount
, (int __user
*)argp
);
1810 rc
= sock_get_timestamp(sk
, argp
);
1813 rc
= sock_get_timestampns(sk
, argp
);
1819 if (capable(CAP_NET_ADMIN
))
1820 rc
= atrtr_ioctl(cmd
, argp
);
1825 case SIOCGIFBRDADDR
:
1826 case SIOCATALKDIFADDR
:
1828 case SIOCSARP
: /* proxy AARP */
1829 case SIOCDARP
: /* proxy AARP */
1831 rc
= atif_ioctl(cmd
, argp
);
1840 #ifdef CONFIG_COMPAT
1841 static int atalk_compat_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1844 * SIOCATALKDIFADDR is a SIOCPROTOPRIVATE ioctl number, so we
1845 * cannot handle it in common code. The data we access if ifreq
1846 * here is compatible, so we can simply call the native
1849 if (cmd
== SIOCATALKDIFADDR
)
1850 return atalk_ioctl(sock
, cmd
, (unsigned long)compat_ptr(arg
));
1852 return -ENOIOCTLCMD
;
1857 static const struct net_proto_family atalk_family_ops
= {
1858 .family
= PF_APPLETALK
,
1859 .create
= atalk_create
,
1860 .owner
= THIS_MODULE
,
1863 static const struct proto_ops atalk_dgram_ops
= {
1864 .family
= PF_APPLETALK
,
1865 .owner
= THIS_MODULE
,
1866 .release
= atalk_release
,
1868 .connect
= atalk_connect
,
1869 .socketpair
= sock_no_socketpair
,
1870 .accept
= sock_no_accept
,
1871 .getname
= atalk_getname
,
1872 .poll
= datagram_poll
,
1873 .ioctl
= atalk_ioctl
,
1874 #ifdef CONFIG_COMPAT
1875 .compat_ioctl
= atalk_compat_ioctl
,
1877 .listen
= sock_no_listen
,
1878 .shutdown
= sock_no_shutdown
,
1879 .setsockopt
= sock_no_setsockopt
,
1880 .getsockopt
= sock_no_getsockopt
,
1881 .sendmsg
= atalk_sendmsg
,
1882 .recvmsg
= atalk_recvmsg
,
1883 .mmap
= sock_no_mmap
,
1884 .sendpage
= sock_no_sendpage
,
1887 static struct notifier_block ddp_notifier
= {
1888 .notifier_call
= ddp_device_event
,
1891 static struct packet_type ltalk_packet_type __read_mostly
= {
1892 .type
= cpu_to_be16(ETH_P_LOCALTALK
),
1896 static struct packet_type ppptalk_packet_type __read_mostly
= {
1897 .type
= cpu_to_be16(ETH_P_PPPTALK
),
1901 static unsigned char ddp_snap_id
[] = { 0x08, 0x00, 0x07, 0x80, 0x9B };
1903 /* Export symbols for use by drivers when AppleTalk is a module */
1904 EXPORT_SYMBOL(atrtr_get_dev
);
1905 EXPORT_SYMBOL(atalk_find_dev_addr
);
1907 static const char atalk_err_snap
[] __initconst
=
1908 KERN_CRIT
"Unable to register DDP with SNAP.\n";
1910 /* Called by proto.c on kernel start up */
1911 static int __init
atalk_init(void)
1913 int rc
= proto_register(&ddp_proto
, 0);
1918 (void)sock_register(&atalk_family_ops
);
1919 ddp_dl
= register_snap_client(ddp_snap_id
, atalk_rcv
);
1921 printk(atalk_err_snap
);
1923 dev_add_pack(<alk_packet_type
);
1924 dev_add_pack(&ppptalk_packet_type
);
1926 register_netdevice_notifier(&ddp_notifier
);
1929 atalk_register_sysctl();
1933 module_init(atalk_init
);
1936 * No explicit module reference count manipulation is needed in the
1937 * protocol. Socket layer sets module reference count for us
1938 * and interfaces reference counting is done
1939 * by the network device layer.
1941 * Ergo, before the AppleTalk module can be removed, all AppleTalk
1942 * sockets be closed from user space.
1944 static void __exit
atalk_exit(void)
1946 #ifdef CONFIG_SYSCTL
1947 atalk_unregister_sysctl();
1948 #endif /* CONFIG_SYSCTL */
1950 aarp_cleanup_module(); /* General aarp clean-up. */
1951 unregister_netdevice_notifier(&ddp_notifier
);
1952 dev_remove_pack(<alk_packet_type
);
1953 dev_remove_pack(&ppptalk_packet_type
);
1954 unregister_snap_client(ddp_dl
);
1955 sock_unregister(PF_APPLETALK
);
1956 proto_unregister(&ddp_proto
);
1958 module_exit(atalk_exit
);
1960 MODULE_LICENSE("GPL");
1961 MODULE_AUTHOR("Alan Cox <alan@lxorguk.ukuu.org.uk>");
1962 MODULE_DESCRIPTION("AppleTalk 0.20\n");
1963 MODULE_ALIAS_NETPROTO(PF_APPLETALK
);