2 * DDP: An implementation of the AppleTalk DDP protocol for
5 * Alan Cox <Alan.Cox@linux.org>
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 <net/datalink.h>
59 #include <net/psnap.h>
61 #include <net/tcp_states.h>
62 #include <net/route.h>
63 #include <linux/atalk.h>
64 #include "../core/kmap_skb.h"
66 struct datalink_proto
*ddp_dl
, *aarp_dl
;
67 static const struct proto_ops atalk_dgram_ops
;
69 /**************************************************************************\
71 * Handlers for the socket list. *
73 \**************************************************************************/
75 HLIST_HEAD(atalk_sockets
);
76 DEFINE_RWLOCK(atalk_sockets_lock
);
78 static inline void __atalk_insert_socket(struct sock
*sk
)
80 sk_add_node(sk
, &atalk_sockets
);
83 static inline void atalk_remove_socket(struct sock
*sk
)
85 write_lock_bh(&atalk_sockets_lock
);
87 write_unlock_bh(&atalk_sockets_lock
);
90 static struct sock
*atalk_search_socket(struct sockaddr_at
*to
,
91 struct atalk_iface
*atif
)
94 struct hlist_node
*node
;
96 read_lock_bh(&atalk_sockets_lock
);
97 sk_for_each(s
, node
, &atalk_sockets
) {
98 struct atalk_sock
*at
= at_sk(s
);
100 if (to
->sat_port
!= at
->src_port
)
103 if (to
->sat_addr
.s_net
== ATADDR_ANYNET
&&
104 to
->sat_addr
.s_node
== ATADDR_BCAST
)
107 if (to
->sat_addr
.s_net
== at
->src_net
&&
108 (to
->sat_addr
.s_node
== at
->src_node
||
109 to
->sat_addr
.s_node
== ATADDR_BCAST
||
110 to
->sat_addr
.s_node
== ATADDR_ANYNODE
))
113 /* XXXX.0 -- we got a request for this router. make sure
114 * that the node is appropriately set. */
115 if (to
->sat_addr
.s_node
== ATADDR_ANYNODE
&&
116 to
->sat_addr
.s_net
!= ATADDR_ANYNET
&&
117 atif
->address
.s_node
== at
->src_node
) {
118 to
->sat_addr
.s_node
= atif
->address
.s_node
;
124 read_unlock_bh(&atalk_sockets_lock
);
129 * atalk_find_or_insert_socket - Try to find a socket matching ADDR
130 * @sk - socket to insert in the list if it is not there already
131 * @sat - address to search for
133 * Try to find a socket matching ADDR in the socket list, if found then return
134 * it. If not, insert SK into the socket list.
136 * This entire operation must execute atomically.
138 static struct sock
*atalk_find_or_insert_socket(struct sock
*sk
,
139 struct sockaddr_at
*sat
)
142 struct hlist_node
*node
;
143 struct atalk_sock
*at
;
145 write_lock_bh(&atalk_sockets_lock
);
146 sk_for_each(s
, node
, &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(unsigned long data
)
163 struct sock
*sk
= (struct sock
*)data
;
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 init_timer(&sk
->sk_timer
);
179 sk
->sk_timer
.expires
= jiffies
+ SOCK_DESTROY_TIME
;
180 sk
->sk_timer
.function
= atalk_destroy_timer
;
181 sk
->sk_timer
.data
= (unsigned long)sk
;
182 add_timer(&sk
->sk_timer
);
187 /**************************************************************************\
189 * Routing tables for the AppleTalk socket layer. *
191 \**************************************************************************/
193 /* Anti-deadlock ordering is atalk_routes_lock --> iface_lock -DaveM */
194 struct atalk_route
*atalk_routes
;
195 DEFINE_RWLOCK(atalk_routes_lock
);
197 struct atalk_iface
*atalk_interfaces
;
198 DEFINE_RWLOCK(atalk_interfaces_lock
);
200 /* For probing devices or in a routerless network */
201 struct atalk_route atrtr_default
;
203 /* AppleTalk interface control */
205 * Drop a device. Doesn't drop any of its routes - that is the caller's
206 * problem. Called when we down the interface or delete the address.
208 static void atif_drop_device(struct net_device
*dev
)
210 struct atalk_iface
**iface
= &atalk_interfaces
;
211 struct atalk_iface
*tmp
;
213 write_lock_bh(&atalk_interfaces_lock
);
214 while ((tmp
= *iface
) != NULL
) {
215 if (tmp
->dev
== dev
) {
219 dev
->atalk_ptr
= NULL
;
223 write_unlock_bh(&atalk_interfaces_lock
);
226 static struct atalk_iface
*atif_add_device(struct net_device
*dev
,
227 struct atalk_addr
*sa
)
229 struct atalk_iface
*iface
= kzalloc(sizeof(*iface
), GFP_KERNEL
);
236 dev
->atalk_ptr
= iface
;
237 iface
->address
= *sa
;
240 write_lock_bh(&atalk_interfaces_lock
);
241 iface
->next
= atalk_interfaces
;
242 atalk_interfaces
= iface
;
243 write_unlock_bh(&atalk_interfaces_lock
);
248 /* Perform phase 2 AARP probing on our tentative address */
249 static int atif_probe_device(struct atalk_iface
*atif
)
251 int netrange
= ntohs(atif
->nets
.nr_lastnet
) -
252 ntohs(atif
->nets
.nr_firstnet
) + 1;
253 int probe_net
= ntohs(atif
->address
.s_net
);
254 int probe_node
= atif
->address
.s_node
;
257 /* Offset the network we start probing with */
258 if (probe_net
== ATADDR_ANYNET
) {
259 probe_net
= ntohs(atif
->nets
.nr_firstnet
);
261 probe_net
+= jiffies
% netrange
;
263 if (probe_node
== ATADDR_ANYNODE
)
264 probe_node
= jiffies
& 0xFF;
266 /* Scan the networks */
267 atif
->status
|= ATIF_PROBE
;
268 for (netct
= 0; netct
<= netrange
; netct
++) {
269 /* Sweep the available nodes from a given start */
270 atif
->address
.s_net
= htons(probe_net
);
271 for (nodect
= 0; nodect
< 256; nodect
++) {
272 atif
->address
.s_node
= (nodect
+ probe_node
) & 0xFF;
273 if (atif
->address
.s_node
> 0 &&
274 atif
->address
.s_node
< 254) {
275 /* Probe a proposed address */
276 aarp_probe_network(atif
);
278 if (!(atif
->status
& ATIF_PROBE_FAIL
)) {
279 atif
->status
&= ~ATIF_PROBE
;
283 atif
->status
&= ~ATIF_PROBE_FAIL
;
286 if (probe_net
> ntohs(atif
->nets
.nr_lastnet
))
287 probe_net
= ntohs(atif
->nets
.nr_firstnet
);
289 atif
->status
&= ~ATIF_PROBE
;
291 return -EADDRINUSE
; /* Network is full... */
295 /* Perform AARP probing for a proxy address */
296 static int atif_proxy_probe_device(struct atalk_iface
*atif
,
297 struct atalk_addr
* proxy_addr
)
299 int netrange
= ntohs(atif
->nets
.nr_lastnet
) -
300 ntohs(atif
->nets
.nr_firstnet
) + 1;
301 /* we probe the interface's network */
302 int probe_net
= ntohs(atif
->address
.s_net
);
303 int probe_node
= ATADDR_ANYNODE
; /* we'll take anything */
306 /* Offset the network we start probing with */
307 if (probe_net
== ATADDR_ANYNET
) {
308 probe_net
= ntohs(atif
->nets
.nr_firstnet
);
310 probe_net
+= jiffies
% netrange
;
313 if (probe_node
== ATADDR_ANYNODE
)
314 probe_node
= jiffies
& 0xFF;
316 /* Scan the networks */
317 for (netct
= 0; netct
<= netrange
; netct
++) {
318 /* Sweep the available nodes from a given start */
319 proxy_addr
->s_net
= htons(probe_net
);
320 for (nodect
= 0; nodect
< 256; nodect
++) {
321 proxy_addr
->s_node
= (nodect
+ probe_node
) & 0xFF;
322 if (proxy_addr
->s_node
> 0 &&
323 proxy_addr
->s_node
< 254) {
324 /* Tell AARP to probe a proposed address */
325 int ret
= aarp_proxy_probe_network(atif
,
328 if (ret
!= -EADDRINUSE
)
333 if (probe_net
> ntohs(atif
->nets
.nr_lastnet
))
334 probe_net
= ntohs(atif
->nets
.nr_firstnet
);
337 return -EADDRINUSE
; /* Network is full... */
341 struct atalk_addr
*atalk_find_dev_addr(struct net_device
*dev
)
343 struct atalk_iface
*iface
= dev
->atalk_ptr
;
344 return iface
? &iface
->address
: NULL
;
347 static struct atalk_addr
*atalk_find_primary(void)
349 struct atalk_iface
*fiface
= NULL
;
350 struct atalk_addr
*retval
;
351 struct atalk_iface
*iface
;
354 * Return a point-to-point interface only if
355 * there is no non-ptp interface available.
357 read_lock_bh(&atalk_interfaces_lock
);
358 for (iface
= atalk_interfaces
; iface
; iface
= iface
->next
) {
359 if (!fiface
&& !(iface
->dev
->flags
& IFF_LOOPBACK
))
361 if (!(iface
->dev
->flags
& (IFF_LOOPBACK
| IFF_POINTOPOINT
))) {
362 retval
= &iface
->address
;
368 retval
= &fiface
->address
;
369 else if (atalk_interfaces
)
370 retval
= &atalk_interfaces
->address
;
374 read_unlock_bh(&atalk_interfaces_lock
);
379 * Find a match for 'any network' - ie any of our interfaces with that
380 * node number will do just nicely.
382 static struct atalk_iface
*atalk_find_anynet(int node
, struct net_device
*dev
)
384 struct atalk_iface
*iface
= dev
->atalk_ptr
;
386 if (!iface
|| iface
->status
& ATIF_PROBE
)
389 if (node
!= ATADDR_BCAST
&&
390 iface
->address
.s_node
!= node
&&
391 node
!= ATADDR_ANYNODE
)
400 /* Find a match for a specific network:node pair */
401 static struct atalk_iface
*atalk_find_interface(__be16 net
, int node
)
403 struct atalk_iface
*iface
;
405 read_lock_bh(&atalk_interfaces_lock
);
406 for (iface
= atalk_interfaces
; iface
; iface
= iface
->next
) {
407 if ((node
== ATADDR_BCAST
||
408 node
== ATADDR_ANYNODE
||
409 iface
->address
.s_node
== node
) &&
410 iface
->address
.s_net
== net
&&
411 !(iface
->status
& ATIF_PROBE
))
414 /* XXXX.0 -- net.0 returns the iface associated with net */
415 if (node
== ATADDR_ANYNODE
&& net
!= ATADDR_ANYNET
&&
416 ntohs(iface
->nets
.nr_firstnet
) <= ntohs(net
) &&
417 ntohs(net
) <= ntohs(iface
->nets
.nr_lastnet
))
420 read_unlock_bh(&atalk_interfaces_lock
);
426 * Find a route for an AppleTalk packet. This ought to get cached in
427 * the socket (later on...). We know about host routes and the fact
428 * that a route must be direct to broadcast.
430 static struct atalk_route
*atrtr_find(struct atalk_addr
*target
)
433 * we must search through all routes unless we find a
434 * host route, because some host routes might overlap
437 struct atalk_route
*net_route
= NULL
;
438 struct atalk_route
*r
;
440 read_lock_bh(&atalk_routes_lock
);
441 for (r
= atalk_routes
; r
; r
= r
->next
) {
442 if (!(r
->flags
& RTF_UP
))
445 if (r
->target
.s_net
== target
->s_net
) {
446 if (r
->flags
& RTF_HOST
) {
448 * if this host route is for the target,
451 if (r
->target
.s_node
== target
->s_node
)
455 * this route will work if there isn't a
456 * direct host route, so cache it
463 * if we found a network route but not a direct host
464 * route, then return it
468 else if (atrtr_default
.dev
)
470 else /* No route can be found */
473 read_unlock_bh(&atalk_routes_lock
);
479 * Given an AppleTalk network, find the device to use. This can be
482 struct net_device
*atrtr_get_dev(struct atalk_addr
*sa
)
484 struct atalk_route
*atr
= atrtr_find(sa
);
485 return atr
? atr
->dev
: NULL
;
488 /* Set up a default router */
489 static void atrtr_set_default(struct net_device
*dev
)
491 atrtr_default
.dev
= dev
;
492 atrtr_default
.flags
= RTF_UP
;
493 atrtr_default
.gateway
.s_net
= htons(0);
494 atrtr_default
.gateway
.s_node
= 0;
498 * Add a router. Basically make sure it looks valid and stuff the
499 * entry in the list. While it uses netranges we always set them to one
500 * entry to work like netatalk.
502 static int atrtr_create(struct rtentry
*r
, struct net_device
*devhint
)
504 struct sockaddr_at
*ta
= (struct sockaddr_at
*)&r
->rt_dst
;
505 struct sockaddr_at
*ga
= (struct sockaddr_at
*)&r
->rt_gateway
;
506 struct atalk_route
*rt
;
507 struct atalk_iface
*iface
, *riface
;
508 int retval
= -EINVAL
;
511 * Fixme: Raise/Lower a routing change semaphore for these
515 /* Validate the request */
516 if (ta
->sat_family
!= AF_APPLETALK
||
517 (!devhint
&& ga
->sat_family
!= AF_APPLETALK
))
520 /* Now walk the routing table and make our decisions */
521 write_lock_bh(&atalk_routes_lock
);
522 for (rt
= atalk_routes
; rt
; rt
= rt
->next
) {
523 if (r
->rt_flags
!= rt
->flags
)
526 if (ta
->sat_addr
.s_net
== rt
->target
.s_net
) {
527 if (!(rt
->flags
& RTF_HOST
))
529 if (ta
->sat_addr
.s_node
== rt
->target
.s_node
)
537 read_lock_bh(&atalk_interfaces_lock
);
538 for (iface
= atalk_interfaces
; iface
; iface
= iface
->next
) {
540 ntohs(ga
->sat_addr
.s_net
) >=
541 ntohs(iface
->nets
.nr_firstnet
) &&
542 ntohs(ga
->sat_addr
.s_net
) <=
543 ntohs(iface
->nets
.nr_lastnet
))
546 if (ga
->sat_addr
.s_net
== iface
->address
.s_net
&&
547 ga
->sat_addr
.s_node
== iface
->address
.s_node
)
550 read_unlock_bh(&atalk_interfaces_lock
);
552 retval
= -ENETUNREACH
;
556 devhint
= riface
->dev
;
560 rt
= kzalloc(sizeof(*rt
), GFP_ATOMIC
);
566 rt
->next
= atalk_routes
;
570 /* Fill in the routing entry */
571 rt
->target
= ta
->sat_addr
;
574 rt
->flags
= r
->rt_flags
;
575 rt
->gateway
= ga
->sat_addr
;
579 write_unlock_bh(&atalk_routes_lock
);
584 /* Delete a route. Find it and discard it */
585 static int atrtr_delete(struct atalk_addr
* addr
)
587 struct atalk_route
**r
= &atalk_routes
;
589 struct atalk_route
*tmp
;
591 write_lock_bh(&atalk_routes_lock
);
592 while ((tmp
= *r
) != NULL
) {
593 if (tmp
->target
.s_net
== addr
->s_net
&&
594 (!(tmp
->flags
&RTF_GATEWAY
) ||
595 tmp
->target
.s_node
== addr
->s_node
)) {
605 write_unlock_bh(&atalk_routes_lock
);
610 * Called when a device is downed. Just throw away any routes
613 static void atrtr_device_down(struct net_device
*dev
)
615 struct atalk_route
**r
= &atalk_routes
;
616 struct atalk_route
*tmp
;
618 write_lock_bh(&atalk_routes_lock
);
619 while ((tmp
= *r
) != NULL
) {
620 if (tmp
->dev
== dev
) {
627 write_unlock_bh(&atalk_routes_lock
);
629 if (atrtr_default
.dev
== dev
)
630 atrtr_set_default(NULL
);
633 /* Actually down the interface */
634 static inline void atalk_dev_down(struct net_device
*dev
)
636 atrtr_device_down(dev
); /* Remove all routes for the device */
637 aarp_device_down(dev
); /* Remove AARP entries for the device */
638 atif_drop_device(dev
); /* Remove the device */
642 * A device event has occurred. Watch for devices going down and
643 * delete our use of them (iface and route).
645 static int ddp_device_event(struct notifier_block
*this, unsigned long event
,
648 if (event
== NETDEV_DOWN
)
649 /* Discard any use of this */
655 /* ioctl calls. Shouldn't even need touching */
656 /* Device configuration ioctl calls */
657 static int atif_ioctl(int cmd
, void __user
*arg
)
659 static char aarp_mcast
[6] = { 0x09, 0x00, 0x00, 0xFF, 0xFF, 0xFF };
661 struct atalk_netrange
*nr
;
662 struct sockaddr_at
*sa
;
663 struct net_device
*dev
;
664 struct atalk_iface
*atif
;
667 struct rtentry rtdef
;
670 if (copy_from_user(&atreq
, arg
, sizeof(atreq
)))
673 dev
= __dev_get_by_name(atreq
.ifr_name
);
677 sa
= (struct sockaddr_at
*)&atreq
.ifr_addr
;
678 atif
= atalk_find_dev(dev
);
682 if (!capable(CAP_NET_ADMIN
))
684 if (sa
->sat_family
!= AF_APPLETALK
)
686 if (dev
->type
!= ARPHRD_ETHER
&&
687 dev
->type
!= ARPHRD_LOOPBACK
&&
688 dev
->type
!= ARPHRD_LOCALTLK
&&
689 dev
->type
!= ARPHRD_PPP
)
690 return -EPROTONOSUPPORT
;
692 nr
= (struct atalk_netrange
*)&sa
->sat_zero
[0];
696 * if this is a point-to-point iface, and we already
697 * have an iface for this AppleTalk address, then we
698 * should not add a route
700 if ((dev
->flags
& IFF_POINTOPOINT
) &&
701 atalk_find_interface(sa
->sat_addr
.s_net
,
702 sa
->sat_addr
.s_node
)) {
703 printk(KERN_DEBUG
"AppleTalk: point-to-point "
704 "interface added with "
705 "existing address\n");
710 * Phase 1 is fine on LocalTalk but we don't do
711 * EtherTalk phase 1. Anyone wanting to add it go ahead.
713 if (dev
->type
== ARPHRD_ETHER
&& nr
->nr_phase
!= 2)
714 return -EPROTONOSUPPORT
;
715 if (sa
->sat_addr
.s_node
== ATADDR_BCAST
||
716 sa
->sat_addr
.s_node
== 254)
719 /* Already setting address */
720 if (atif
->status
& ATIF_PROBE
)
723 atif
->address
.s_net
= sa
->sat_addr
.s_net
;
724 atif
->address
.s_node
= sa
->sat_addr
.s_node
;
725 atrtr_device_down(dev
); /* Flush old routes */
727 atif
= atif_add_device(dev
, &sa
->sat_addr
);
734 * Check if the chosen address is used. If so we
735 * error and atalkd will try another.
738 if (!(dev
->flags
& IFF_LOOPBACK
) &&
739 !(dev
->flags
& IFF_POINTOPOINT
) &&
740 atif_probe_device(atif
) < 0) {
741 atif_drop_device(dev
);
745 /* Hey it worked - add the direct routes */
746 sa
= (struct sockaddr_at
*)&rtdef
.rt_gateway
;
747 sa
->sat_family
= AF_APPLETALK
;
748 sa
->sat_addr
.s_net
= atif
->address
.s_net
;
749 sa
->sat_addr
.s_node
= atif
->address
.s_node
;
750 sa
= (struct sockaddr_at
*)&rtdef
.rt_dst
;
751 rtdef
.rt_flags
= RTF_UP
;
752 sa
->sat_family
= AF_APPLETALK
;
753 sa
->sat_addr
.s_node
= ATADDR_ANYNODE
;
754 if (dev
->flags
& IFF_LOOPBACK
||
755 dev
->flags
& IFF_POINTOPOINT
)
756 rtdef
.rt_flags
|= RTF_HOST
;
758 /* Routerless initial state */
759 if (nr
->nr_firstnet
== htons(0) &&
760 nr
->nr_lastnet
== htons(0xFFFE)) {
761 sa
->sat_addr
.s_net
= atif
->address
.s_net
;
762 atrtr_create(&rtdef
, dev
);
763 atrtr_set_default(dev
);
765 limit
= ntohs(nr
->nr_lastnet
);
766 if (limit
- ntohs(nr
->nr_firstnet
) > 4096) {
767 printk(KERN_WARNING
"Too many routes/"
772 for (ct
= ntohs(nr
->nr_firstnet
);
774 sa
->sat_addr
.s_net
= htons(ct
);
775 atrtr_create(&rtdef
, dev
);
778 dev_mc_add(dev
, aarp_mcast
, 6, 1);
783 return -EADDRNOTAVAIL
;
785 sa
->sat_family
= AF_APPLETALK
;
786 sa
->sat_addr
= atif
->address
;
791 return -EADDRNOTAVAIL
;
793 sa
->sat_family
= AF_APPLETALK
;
794 sa
->sat_addr
.s_net
= atif
->address
.s_net
;
795 sa
->sat_addr
.s_node
= ATADDR_BCAST
;
798 case SIOCATALKDIFADDR
:
800 if (!capable(CAP_NET_ADMIN
))
802 if (sa
->sat_family
!= AF_APPLETALK
)
808 if (!capable(CAP_NET_ADMIN
))
810 if (sa
->sat_family
!= AF_APPLETALK
)
813 return -EADDRNOTAVAIL
;
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(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 */
934 /* Checksum skb data -- similar to skb_checksum */
935 static unsigned long atalk_sum_skb(const struct sk_buff
*skb
, int offset
,
936 int len
, unsigned long sum
)
938 int start
= skb_headlen(skb
);
941 /* checksum stuff in header space */
942 if ( (copy
= start
- offset
) > 0) {
945 sum
= atalk_sum_partial(skb
->data
+ offset
, copy
, sum
);
946 if ( (len
-= copy
) == 0)
952 /* checksum stuff in frags */
953 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++) {
956 BUG_TRAP(start
<= offset
+ len
);
958 end
= start
+ skb_shinfo(skb
)->frags
[i
].size
;
959 if ((copy
= end
- offset
) > 0) {
961 skb_frag_t
*frag
= &skb_shinfo(skb
)->frags
[i
];
965 vaddr
= kmap_skb_frag(frag
);
966 sum
= atalk_sum_partial(vaddr
+ frag
->page_offset
+
967 offset
- start
, copy
, sum
);
968 kunmap_skb_frag(vaddr
);
977 if (skb_shinfo(skb
)->frag_list
) {
978 struct sk_buff
*list
= skb_shinfo(skb
)->frag_list
;
980 for (; list
; list
= list
->next
) {
983 BUG_TRAP(start
<= offset
+ len
);
985 end
= start
+ list
->len
;
986 if ((copy
= end
- offset
) > 0) {
989 sum
= atalk_sum_skb(list
, offset
- start
,
991 if ((len
-= copy
) == 0)
1004 static __be16
atalk_checksum(const struct sk_buff
*skb
, int len
)
1008 /* skip header 4 bytes */
1009 sum
= atalk_sum_skb(skb
, 4, len
-4, 0);
1011 /* Use 0xFFFF for 0. 0 itself means none */
1012 return sum
? htons((unsigned short)sum
) : htons(0xFFFF);
1015 static struct proto ddp_proto
= {
1017 .owner
= THIS_MODULE
,
1018 .obj_size
= sizeof(struct atalk_sock
),
1022 * Create a socket. Initialise the socket, blank the addresses
1025 static int atalk_create(struct socket
*sock
, int protocol
)
1028 int rc
= -ESOCKTNOSUPPORT
;
1031 * We permit SOCK_DGRAM and RAW is an extension. It is trivial to do
1032 * and gives you the full ELAP frame. Should be handy for CAP 8)
1034 if (sock
->type
!= SOCK_RAW
&& sock
->type
!= SOCK_DGRAM
)
1037 sk
= sk_alloc(PF_APPLETALK
, GFP_KERNEL
, &ddp_proto
, 1);
1041 sock
->ops
= &atalk_dgram_ops
;
1042 sock_init_data(sock
, sk
);
1044 /* Checksums on by default */
1045 sock_set_flag(sk
, SOCK_ZAPPED
);
1050 /* Free a socket. No work needed */
1051 static int atalk_release(struct socket
*sock
)
1053 struct sock
*sk
= sock
->sk
;
1058 atalk_destroy_socket(sk
);
1064 * atalk_pick_and_bind_port - Pick a source port when one is not given
1065 * @sk - socket to insert into the tables
1066 * @sat - address to search for
1068 * Pick a source port when one is not given. If we can find a suitable free
1069 * one, we insert the socket into the tables using it.
1071 * This whole operation must be atomic.
1073 static int atalk_pick_and_bind_port(struct sock
*sk
, struct sockaddr_at
*sat
)
1077 write_lock_bh(&atalk_sockets_lock
);
1079 for (sat
->sat_port
= ATPORT_RESERVED
;
1080 sat
->sat_port
< ATPORT_LAST
;
1083 struct hlist_node
*node
;
1085 sk_for_each(s
, node
, &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
);
1136 if (!sock_flag(sk
, SOCK_ZAPPED
) ||
1137 addr_len
!= sizeof(struct sockaddr_at
))
1140 if (addr
->sat_family
!= AF_APPLETALK
)
1141 return -EAFNOSUPPORT
;
1143 if (addr
->sat_addr
.s_net
== htons(ATADDR_ANYNET
)) {
1144 struct atalk_addr
*ap
= atalk_find_primary();
1147 return -EADDRNOTAVAIL
;
1149 at
->src_net
= addr
->sat_addr
.s_net
= ap
->s_net
;
1150 at
->src_node
= addr
->sat_addr
.s_node
= ap
->s_node
;
1152 if (!atalk_find_interface(addr
->sat_addr
.s_net
,
1153 addr
->sat_addr
.s_node
))
1154 return -EADDRNOTAVAIL
;
1156 at
->src_net
= addr
->sat_addr
.s_net
;
1157 at
->src_node
= addr
->sat_addr
.s_node
;
1160 if (addr
->sat_port
== ATADDR_ANYPORT
) {
1161 int n
= atalk_pick_and_bind_port(sk
, addr
);
1166 at
->src_port
= addr
->sat_port
;
1168 if (atalk_find_or_insert_socket(sk
, addr
))
1172 sock_reset_flag(sk
, SOCK_ZAPPED
);
1176 /* Set the address we talk to */
1177 static int atalk_connect(struct socket
*sock
, struct sockaddr
*uaddr
,
1178 int addr_len
, int flags
)
1180 struct sock
*sk
= sock
->sk
;
1181 struct atalk_sock
*at
= at_sk(sk
);
1182 struct sockaddr_at
*addr
;
1184 sk
->sk_state
= TCP_CLOSE
;
1185 sock
->state
= SS_UNCONNECTED
;
1187 if (addr_len
!= sizeof(*addr
))
1190 addr
= (struct sockaddr_at
*)uaddr
;
1192 if (addr
->sat_family
!= AF_APPLETALK
)
1193 return -EAFNOSUPPORT
;
1195 if (addr
->sat_addr
.s_node
== ATADDR_BCAST
&&
1196 !sock_flag(sk
, SOCK_BROADCAST
)) {
1198 printk(KERN_WARNING
"%s is broken and did not set "
1199 "SO_BROADCAST. It will break when 2.2 is "
1207 if (sock_flag(sk
, SOCK_ZAPPED
))
1208 if (atalk_autobind(sk
) < 0)
1211 if (!atrtr_get_dev(&addr
->sat_addr
))
1212 return -ENETUNREACH
;
1214 at
->dest_port
= addr
->sat_port
;
1215 at
->dest_net
= addr
->sat_addr
.s_net
;
1216 at
->dest_node
= addr
->sat_addr
.s_node
;
1218 sock
->state
= SS_CONNECTED
;
1219 sk
->sk_state
= TCP_ESTABLISHED
;
1224 * Find the name of an AppleTalk socket. Just copy the right
1225 * fields into the sockaddr.
1227 static int atalk_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
1228 int *uaddr_len
, int peer
)
1230 struct sockaddr_at sat
;
1231 struct sock
*sk
= sock
->sk
;
1232 struct atalk_sock
*at
= at_sk(sk
);
1234 if (sock_flag(sk
, SOCK_ZAPPED
))
1235 if (atalk_autobind(sk
) < 0)
1238 *uaddr_len
= sizeof(struct sockaddr_at
);
1241 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1244 sat
.sat_addr
.s_net
= at
->dest_net
;
1245 sat
.sat_addr
.s_node
= at
->dest_node
;
1246 sat
.sat_port
= at
->dest_port
;
1248 sat
.sat_addr
.s_net
= at
->src_net
;
1249 sat
.sat_addr
.s_node
= at
->src_node
;
1250 sat
.sat_port
= at
->src_port
;
1253 sat
.sat_family
= AF_APPLETALK
;
1254 memcpy(uaddr
, &sat
, sizeof(sat
));
1258 #if defined(CONFIG_IPDDP) || defined(CONFIG_IPDDP_MODULE)
1259 static __inline__
int is_ip_over_ddp(struct sk_buff
*skb
)
1261 return skb
->data
[12] == 22;
1264 static int handle_ip_over_ddp(struct sk_buff
*skb
)
1266 struct net_device
*dev
= __dev_get_by_name("ipddp0");
1267 struct net_device_stats
*stats
;
1269 /* This needs to be able to handle ipddp"N" devices */
1273 skb
->protocol
= htons(ETH_P_IP
);
1276 skb_reset_transport_header(skb
);
1279 stats
->rx_packets
++;
1280 stats
->rx_bytes
+= skb
->len
+ 13;
1281 netif_rx(skb
); /* Send the SKB up to a higher place. */
1285 /* make it easy for gcc to optimize this test out, i.e. kill the code */
1286 #define is_ip_over_ddp(skb) 0
1287 #define handle_ip_over_ddp(skb) 0
1290 static void atalk_route_packet(struct sk_buff
*skb
, struct net_device
*dev
,
1291 struct ddpehdr
*ddp
, __u16 len_hops
,
1294 struct atalk_route
*rt
;
1295 struct atalk_addr ta
;
1298 * Don't route multicast, etc., packets, or packets sent to "this
1301 if (skb
->pkt_type
!= PACKET_HOST
|| !ddp
->deh_dnet
) {
1305 * Can it ever happen that a packet is from a PPP iface and
1306 * needs to be broadcast onto the default network?
1308 if (dev
->type
== ARPHRD_PPP
)
1309 printk(KERN_DEBUG
"AppleTalk: didn't forward broadcast "
1310 "packet received from PPP iface\n");
1314 ta
.s_net
= ddp
->deh_dnet
;
1315 ta
.s_node
= ddp
->deh_dnode
;
1317 /* Route the packet */
1318 rt
= atrtr_find(&ta
);
1319 /* increment hops count */
1320 len_hops
+= 1 << 10;
1321 if (!rt
|| !(len_hops
& (15 << 10)))
1324 /* FIXME: use skb->cb to be able to use shared skbs */
1327 * Route goes through another gateway, so set the target to the
1331 if (rt
->flags
& RTF_GATEWAY
) {
1332 ta
.s_net
= rt
->gateway
.s_net
;
1333 ta
.s_node
= rt
->gateway
.s_node
;
1336 /* Fix up skb->len field */
1337 skb_trim(skb
, min_t(unsigned int, origlen
,
1338 (rt
->dev
->hard_header_len
+
1339 ddp_dl
->header_length
+ (len_hops
& 1023))));
1341 /* FIXME: use skb->cb to be able to use shared skbs */
1342 ddp
->deh_len_hops
= htons(len_hops
);
1345 * Send the buffer onwards
1347 * Now we must always be careful. If it's come from LocalTalk to
1348 * EtherTalk it might not fit
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.
1353 * Note. ddp-> becomes invalid at the realloc.
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);
1363 skb
= skb_unshare(skb
, GFP_ATOMIC
);
1366 * If the buffer didn't vanish into the lack of space bitbucket we can
1369 if (skb
&& aarp_send_ddp(rt
->dev
, skb
, &ta
, NULL
) == -1)
1378 * atalk_rcv - Receive a packet (in skb) from device dev
1379 * @skb - packet received
1380 * @dev - network device where the packet comes from
1383 * Receive a packet (in skb) from device dev. This has come from the SNAP
1384 * decoder, and on entry skb->transport_header is the DDP header, skb->len
1385 * is the DDP header, skb->len is the DDP length. The physical headers
1386 * have been extracted. PPP should probably pass frames marked as for this
1387 * layer. [ie ARPHRD_ETHERTALK]
1389 static int atalk_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
1390 struct packet_type
*pt
, struct net_device
*orig_dev
)
1392 struct ddpehdr
*ddp
;
1394 struct atalk_iface
*atif
;
1395 struct sockaddr_at tosat
;
1399 /* Don't mangle buffer if shared */
1400 if (!(skb
= skb_share_check(skb
, GFP_ATOMIC
)))
1403 /* Size check and make sure header is contiguous */
1404 if (!pskb_may_pull(skb
, sizeof(*ddp
)))
1409 len_hops
= ntohs(ddp
->deh_len_hops
);
1411 /* Trim buffer in case of stray trailing data */
1413 skb_trim(skb
, min_t(unsigned int, skb
->len
, len_hops
& 1023));
1416 * Size check to see if ddp->deh_len was crap
1417 * (Otherwise we'll detonate most spectacularly
1418 * in the middle of atalk_checksum() or recvmsg()).
1420 if (skb
->len
< sizeof(*ddp
) || skb
->len
< (len_hops
& 1023)) {
1421 pr_debug("AppleTalk: dropping corrupted frame (deh_len=%u, "
1422 "skb->len=%u)\n", len_hops
& 1023, skb
->len
);
1427 * Any checksums. Note we don't do htons() on this == is assumed to be
1428 * valid for net byte orders all over the networking code...
1431 atalk_checksum(skb
, len_hops
& 1023) != ddp
->deh_sum
)
1432 /* Not a valid AppleTalk frame - dustbin time */
1435 /* Check the packet is aimed at us */
1436 if (!ddp
->deh_dnet
) /* Net 0 is 'this network' */
1437 atif
= atalk_find_anynet(ddp
->deh_dnode
, dev
);
1439 atif
= atalk_find_interface(ddp
->deh_dnet
, ddp
->deh_dnode
);
1442 /* Not ours, so we route the packet via the correct
1445 atalk_route_packet(skb
, dev
, ddp
, len_hops
, origlen
);
1449 /* if IP over DDP is not selected this code will be optimized out */
1450 if (is_ip_over_ddp(skb
))
1451 return handle_ip_over_ddp(skb
);
1453 * Which socket - atalk_search_socket() looks for a *full match*
1454 * of the <net, node, port> tuple.
1456 tosat
.sat_addr
.s_net
= ddp
->deh_dnet
;
1457 tosat
.sat_addr
.s_node
= ddp
->deh_dnode
;
1458 tosat
.sat_port
= ddp
->deh_dport
;
1460 sock
= atalk_search_socket(&tosat
, atif
);
1461 if (!sock
) /* But not one of our sockets */
1464 /* Queue packet (standard) */
1467 if (sock_queue_rcv_skb(sock
, skb
) < 0)
1477 * Receive a LocalTalk frame. We make some demands on the caller here.
1478 * Caller must provide enough headroom on the packet to pull the short
1479 * header and append a long one.
1481 static int ltalk_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
1482 struct packet_type
*pt
, struct net_device
*orig_dev
)
1484 /* Expand any short form frames */
1485 if (skb_mac_header(skb
)[2] == 1) {
1486 struct ddpehdr
*ddp
;
1487 /* Find our address */
1488 struct atalk_addr
*ap
= atalk_find_dev_addr(dev
);
1490 if (!ap
|| skb
->len
< sizeof(__be16
) || skb
->len
> 1023)
1493 /* Don't mangle buffer if shared */
1494 if (!(skb
= skb_share_check(skb
, GFP_ATOMIC
)))
1498 * The push leaves us with a ddephdr not an shdr, and
1499 * handily the port bytes in the right place preset.
1501 ddp
= (struct ddpehdr
*) skb_push(skb
, sizeof(*ddp
) - 4);
1503 /* Now fill in the long header */
1506 * These two first. The mac overlays the new source/dest
1507 * network information so we MUST copy these before
1508 * we write the network numbers !
1511 ddp
->deh_dnode
= skb_mac_header(skb
)[0]; /* From physical header */
1512 ddp
->deh_snode
= skb_mac_header(skb
)[1]; /* From physical header */
1514 ddp
->deh_dnet
= ap
->s_net
; /* Network number */
1515 ddp
->deh_snet
= ap
->s_net
;
1516 ddp
->deh_sum
= 0; /* No checksum */
1518 * Not sure about this bit...
1520 /* Non routable, so force a drop if we slip up later */
1521 ddp
->deh_len_hops
= htons(skb
->len
+ (DDP_MAXHOPS
<< 10));
1523 skb_reset_transport_header(skb
);
1525 return atalk_rcv(skb
, dev
, pt
, orig_dev
);
1531 static int atalk_sendmsg(struct kiocb
*iocb
, struct socket
*sock
, struct msghdr
*msg
,
1534 struct sock
*sk
= sock
->sk
;
1535 struct atalk_sock
*at
= at_sk(sk
);
1536 struct sockaddr_at
*usat
= (struct sockaddr_at
*)msg
->msg_name
;
1537 int flags
= msg
->msg_flags
;
1539 struct sockaddr_at local_satalk
, gsat
;
1540 struct sk_buff
*skb
;
1541 struct net_device
*dev
;
1542 struct ddpehdr
*ddp
;
1544 struct atalk_route
*rt
;
1547 if (flags
& ~(MSG_DONTWAIT
|MSG_CMSG_COMPAT
))
1550 if (len
> DDP_MAXSZ
)
1554 if (sock_flag(sk
, SOCK_ZAPPED
))
1555 if (atalk_autobind(sk
) < 0)
1558 if (msg
->msg_namelen
< sizeof(*usat
) ||
1559 usat
->sat_family
!= AF_APPLETALK
)
1562 /* netatalk doesn't implement this check */
1563 if (usat
->sat_addr
.s_node
== ATADDR_BCAST
&&
1564 !sock_flag(sk
, SOCK_BROADCAST
)) {
1565 printk(KERN_INFO
"SO_BROADCAST: Fix your netatalk as "
1566 "it will break before 2.2\n");
1572 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1574 usat
= &local_satalk
;
1575 usat
->sat_family
= AF_APPLETALK
;
1576 usat
->sat_port
= at
->dest_port
;
1577 usat
->sat_addr
.s_node
= at
->dest_node
;
1578 usat
->sat_addr
.s_net
= at
->dest_net
;
1581 /* Build a packet */
1582 SOCK_DEBUG(sk
, "SK %p: Got address.\n", sk
);
1585 size
= sizeof(struct ddpehdr
) + len
+ ddp_dl
->header_length
;
1587 if (usat
->sat_addr
.s_net
|| usat
->sat_addr
.s_node
== ATADDR_ANYNODE
) {
1588 rt
= atrtr_find(&usat
->sat_addr
);
1590 struct atalk_addr at_hint
;
1593 at_hint
.s_net
= at
->src_net
;
1595 rt
= atrtr_find(&at_hint
);
1598 return -ENETUNREACH
;
1602 SOCK_DEBUG(sk
, "SK %p: Size needed %d, device %s\n",
1603 sk
, size
, dev
->name
);
1605 size
+= dev
->hard_header_len
;
1606 skb
= sock_alloc_send_skb(sk
, size
, (flags
& MSG_DONTWAIT
), &err
);
1611 skb_reserve(skb
, ddp_dl
->header_length
);
1612 skb_reserve(skb
, dev
->hard_header_len
);
1615 SOCK_DEBUG(sk
, "SK %p: Begin build.\n", sk
);
1617 ddp
= (struct ddpehdr
*)skb_put(skb
, sizeof(struct ddpehdr
));
1618 ddp
->deh_len_hops
= htons(len
+ sizeof(*ddp
));
1619 ddp
->deh_dnet
= usat
->sat_addr
.s_net
;
1620 ddp
->deh_snet
= at
->src_net
;
1621 ddp
->deh_dnode
= usat
->sat_addr
.s_node
;
1622 ddp
->deh_snode
= at
->src_node
;
1623 ddp
->deh_dport
= usat
->sat_port
;
1624 ddp
->deh_sport
= at
->src_port
;
1626 SOCK_DEBUG(sk
, "SK %p: Copy user data (%Zd bytes).\n", sk
, len
);
1628 err
= memcpy_fromiovec(skb_put(skb
, len
), msg
->msg_iov
, len
);
1634 if (sk
->sk_no_check
== 1)
1637 ddp
->deh_sum
= atalk_checksum(skb
, len
+ sizeof(*ddp
));
1640 * Loopback broadcast packets to non gateway targets (ie routes
1641 * to group we are in)
1643 if (ddp
->deh_dnode
== ATADDR_BCAST
&&
1644 !(rt
->flags
& RTF_GATEWAY
) && !(dev
->flags
& IFF_LOOPBACK
)) {
1645 struct sk_buff
*skb2
= skb_copy(skb
, GFP_KERNEL
);
1649 SOCK_DEBUG(sk
, "SK %p: send out(copy).\n", sk
);
1650 if (aarp_send_ddp(dev
, skb2
,
1651 &usat
->sat_addr
, NULL
) == -1)
1653 /* else queued/sent above in the aarp queue */
1657 if (dev
->flags
& IFF_LOOPBACK
|| loopback
) {
1658 SOCK_DEBUG(sk
, "SK %p: Loop back.\n", sk
);
1661 if (ddp
->deh_dnode
== ATADDR_BCAST
) {
1662 struct atalk_addr at_lo
;
1667 rt
= atrtr_find(&at_lo
);
1670 return -ENETUNREACH
;
1675 ddp_dl
->request(ddp_dl
, skb
, dev
->dev_addr
);
1677 SOCK_DEBUG(sk
, "SK %p: send out.\n", sk
);
1678 if (rt
->flags
& RTF_GATEWAY
) {
1679 gsat
.sat_addr
= rt
->gateway
;
1683 if (aarp_send_ddp(dev
, skb
, &usat
->sat_addr
, NULL
) == -1)
1685 /* else queued/sent above in the aarp queue */
1687 SOCK_DEBUG(sk
, "SK %p: Done write (%Zd).\n", sk
, len
);
1692 static int atalk_recvmsg(struct kiocb
*iocb
, struct socket
*sock
, struct msghdr
*msg
,
1693 size_t size
, int flags
)
1695 struct sock
*sk
= sock
->sk
;
1696 struct sockaddr_at
*sat
= (struct sockaddr_at
*)msg
->msg_name
;
1697 struct ddpehdr
*ddp
;
1701 struct sk_buff
*skb
= skb_recv_datagram(sk
, flags
& ~MSG_DONTWAIT
,
1702 flags
& MSG_DONTWAIT
, &err
);
1706 /* FIXME: use skb->cb to be able to use shared skbs */
1708 copied
= ntohs(ddp
->deh_len_hops
) & 1023;
1710 if (sk
->sk_type
!= SOCK_RAW
) {
1711 offset
= sizeof(*ddp
);
1715 if (copied
> size
) {
1717 msg
->msg_flags
|= MSG_TRUNC
;
1719 err
= skb_copy_datagram_iovec(skb
, offset
, msg
->msg_iov
, copied
);
1723 sat
->sat_family
= AF_APPLETALK
;
1724 sat
->sat_port
= ddp
->deh_sport
;
1725 sat
->sat_addr
.s_node
= ddp
->deh_snode
;
1726 sat
->sat_addr
.s_net
= ddp
->deh_snet
;
1728 msg
->msg_namelen
= sizeof(*sat
);
1731 skb_free_datagram(sk
, skb
); /* Free the datagram. */
1732 return err
? : copied
;
1737 * AppleTalk ioctl calls.
1739 static int atalk_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1741 int rc
= -ENOIOCTLCMD
;
1742 struct sock
*sk
= sock
->sk
;
1743 void __user
*argp
= (void __user
*)arg
;
1746 /* Protocol layer */
1748 long amount
= sk
->sk_sndbuf
- sk_wmem_alloc_get(sk
);
1752 rc
= put_user(amount
, (int __user
*)argp
);
1757 * These two are safe on a single CPU system as only
1758 * user tasks fiddle here
1760 struct sk_buff
*skb
= skb_peek(&sk
->sk_receive_queue
);
1764 amount
= skb
->len
- sizeof(struct ddpehdr
);
1765 rc
= put_user(amount
, (int __user
*)argp
);
1769 rc
= sock_get_timestamp(sk
, argp
);
1772 rc
= sock_get_timestampns(sk
, argp
);
1778 if (capable(CAP_NET_ADMIN
))
1779 rc
= atrtr_ioctl(cmd
, argp
);
1784 case SIOCGIFBRDADDR
:
1785 case SIOCATALKDIFADDR
:
1787 case SIOCSARP
: /* proxy AARP */
1788 case SIOCDARP
: /* proxy AARP */
1790 rc
= atif_ioctl(cmd
, argp
);
1799 #ifdef CONFIG_COMPAT
1800 static int atalk_compat_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1803 * All Appletalk ioctls except SIOCATALKDIFADDR are standard. And
1804 * SIOCATALKDIFADDR is handled by upper layer as well, so there is
1805 * nothing to do. Eventually SIOCATALKDIFADDR should be moved
1806 * here so there is no generic SIOCPROTOPRIVATE translation in the
1809 return -ENOIOCTLCMD
;
1814 static struct net_proto_family atalk_family_ops
= {
1815 .family
= PF_APPLETALK
,
1816 .create
= atalk_create
,
1817 .owner
= THIS_MODULE
,
1820 static const struct proto_ops
SOCKOPS_WRAPPED(atalk_dgram_ops
) = {
1821 .family
= PF_APPLETALK
,
1822 .owner
= THIS_MODULE
,
1823 .release
= atalk_release
,
1825 .connect
= atalk_connect
,
1826 .socketpair
= sock_no_socketpair
,
1827 .accept
= sock_no_accept
,
1828 .getname
= atalk_getname
,
1829 .poll
= datagram_poll
,
1830 .ioctl
= atalk_ioctl
,
1831 #ifdef CONFIG_COMPAT
1832 .compat_ioctl
= atalk_compat_ioctl
,
1834 .listen
= sock_no_listen
,
1835 .shutdown
= sock_no_shutdown
,
1836 .setsockopt
= sock_no_setsockopt
,
1837 .getsockopt
= sock_no_getsockopt
,
1838 .sendmsg
= atalk_sendmsg
,
1839 .recvmsg
= atalk_recvmsg
,
1840 .mmap
= sock_no_mmap
,
1841 .sendpage
= sock_no_sendpage
,
1844 SOCKOPS_WRAP(atalk_dgram
, PF_APPLETALK
);
1846 static struct notifier_block ddp_notifier
= {
1847 .notifier_call
= ddp_device_event
,
1850 static struct packet_type ltalk_packet_type
= {
1851 .type
= __constant_htons(ETH_P_LOCALTALK
),
1855 static struct packet_type ppptalk_packet_type
= {
1856 .type
= __constant_htons(ETH_P_PPPTALK
),
1860 static unsigned char ddp_snap_id
[] = { 0x08, 0x00, 0x07, 0x80, 0x9B };
1862 /* Export symbols for use by drivers when AppleTalk is a module */
1863 EXPORT_SYMBOL(aarp_send_ddp
);
1864 EXPORT_SYMBOL(atrtr_get_dev
);
1865 EXPORT_SYMBOL(atalk_find_dev_addr
);
1867 static char atalk_err_snap
[] __initdata
=
1868 KERN_CRIT
"Unable to register DDP with SNAP.\n";
1870 /* Called by proto.c on kernel start up */
1871 static int __init
atalk_init(void)
1873 int rc
= proto_register(&ddp_proto
, 0);
1878 (void)sock_register(&atalk_family_ops
);
1879 ddp_dl
= register_snap_client(ddp_snap_id
, atalk_rcv
);
1881 printk(atalk_err_snap
);
1883 dev_add_pack(<alk_packet_type
);
1884 dev_add_pack(&ppptalk_packet_type
);
1886 register_netdevice_notifier(&ddp_notifier
);
1889 atalk_register_sysctl();
1893 module_init(atalk_init
);
1896 * No explicit module reference count manipulation is needed in the
1897 * protocol. Socket layer sets module reference count for us
1898 * and interfaces reference counting is done
1899 * by the network device layer.
1901 * Ergo, before the AppleTalk module can be removed, all AppleTalk
1902 * sockets be closed from user space.
1904 static void __exit
atalk_exit(void)
1906 #ifdef CONFIG_SYSCTL
1907 atalk_unregister_sysctl();
1908 #endif /* CONFIG_SYSCTL */
1910 aarp_cleanup_module(); /* General aarp clean-up. */
1911 unregister_netdevice_notifier(&ddp_notifier
);
1912 dev_remove_pack(<alk_packet_type
);
1913 dev_remove_pack(&ppptalk_packet_type
);
1914 unregister_snap_client(ddp_dl
);
1915 sock_unregister(PF_APPLETALK
);
1916 proto_unregister(&ddp_proto
);
1918 module_exit(atalk_exit
);
1920 MODULE_LICENSE("GPL");
1921 MODULE_AUTHOR("Alan Cox <Alan.Cox@linux.org>");
1922 MODULE_DESCRIPTION("AppleTalk 0.20\n");
1923 MODULE_ALIAS_NETPROTO(PF_APPLETALK
);