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 (atomic_read(&sk
->sk_wmem_alloc
) ||
166 atomic_read(&sk
->sk_rmem_alloc
)) {
167 sk
->sk_timer
.expires
= jiffies
+ SOCK_DESTROY_TIME
;
168 add_timer(&sk
->sk_timer
);
173 static inline void atalk_destroy_socket(struct sock
*sk
)
175 atalk_remove_socket(sk
);
176 skb_queue_purge(&sk
->sk_receive_queue
);
178 if (atomic_read(&sk
->sk_wmem_alloc
) ||
179 atomic_read(&sk
->sk_rmem_alloc
)) {
180 init_timer(&sk
->sk_timer
);
181 sk
->sk_timer
.expires
= jiffies
+ SOCK_DESTROY_TIME
;
182 sk
->sk_timer
.function
= atalk_destroy_timer
;
183 sk
->sk_timer
.data
= (unsigned long)sk
;
184 add_timer(&sk
->sk_timer
);
189 /**************************************************************************\
191 * Routing tables for the AppleTalk socket layer. *
193 \**************************************************************************/
195 /* Anti-deadlock ordering is atalk_routes_lock --> iface_lock -DaveM */
196 struct atalk_route
*atalk_routes
;
197 DEFINE_RWLOCK(atalk_routes_lock
);
199 struct atalk_iface
*atalk_interfaces
;
200 DEFINE_RWLOCK(atalk_interfaces_lock
);
202 /* For probing devices or in a routerless network */
203 struct atalk_route atrtr_default
;
205 /* AppleTalk interface control */
207 * Drop a device. Doesn't drop any of its routes - that is the caller's
208 * problem. Called when we down the interface or delete the address.
210 static void atif_drop_device(struct net_device
*dev
)
212 struct atalk_iface
**iface
= &atalk_interfaces
;
213 struct atalk_iface
*tmp
;
215 write_lock_bh(&atalk_interfaces_lock
);
216 while ((tmp
= *iface
) != NULL
) {
217 if (tmp
->dev
== dev
) {
221 dev
->atalk_ptr
= NULL
;
225 write_unlock_bh(&atalk_interfaces_lock
);
228 static struct atalk_iface
*atif_add_device(struct net_device
*dev
,
229 struct atalk_addr
*sa
)
231 struct atalk_iface
*iface
= kzalloc(sizeof(*iface
), GFP_KERNEL
);
238 dev
->atalk_ptr
= iface
;
239 iface
->address
= *sa
;
242 write_lock_bh(&atalk_interfaces_lock
);
243 iface
->next
= atalk_interfaces
;
244 atalk_interfaces
= iface
;
245 write_unlock_bh(&atalk_interfaces_lock
);
250 /* Perform phase 2 AARP probing on our tentative address */
251 static int atif_probe_device(struct atalk_iface
*atif
)
253 int netrange
= ntohs(atif
->nets
.nr_lastnet
) -
254 ntohs(atif
->nets
.nr_firstnet
) + 1;
255 int probe_net
= ntohs(atif
->address
.s_net
);
256 int probe_node
= atif
->address
.s_node
;
259 /* Offset the network we start probing with */
260 if (probe_net
== ATADDR_ANYNET
) {
261 probe_net
= ntohs(atif
->nets
.nr_firstnet
);
263 probe_net
+= jiffies
% netrange
;
265 if (probe_node
== ATADDR_ANYNODE
)
266 probe_node
= jiffies
& 0xFF;
268 /* Scan the networks */
269 atif
->status
|= ATIF_PROBE
;
270 for (netct
= 0; netct
<= netrange
; netct
++) {
271 /* Sweep the available nodes from a given start */
272 atif
->address
.s_net
= htons(probe_net
);
273 for (nodect
= 0; nodect
< 256; nodect
++) {
274 atif
->address
.s_node
= (nodect
+ probe_node
) & 0xFF;
275 if (atif
->address
.s_node
> 0 &&
276 atif
->address
.s_node
< 254) {
277 /* Probe a proposed address */
278 aarp_probe_network(atif
);
280 if (!(atif
->status
& ATIF_PROBE_FAIL
)) {
281 atif
->status
&= ~ATIF_PROBE
;
285 atif
->status
&= ~ATIF_PROBE_FAIL
;
288 if (probe_net
> ntohs(atif
->nets
.nr_lastnet
))
289 probe_net
= ntohs(atif
->nets
.nr_firstnet
);
291 atif
->status
&= ~ATIF_PROBE
;
293 return -EADDRINUSE
; /* Network is full... */
297 /* Perform AARP probing for a proxy address */
298 static int atif_proxy_probe_device(struct atalk_iface
*atif
,
299 struct atalk_addr
* proxy_addr
)
301 int netrange
= ntohs(atif
->nets
.nr_lastnet
) -
302 ntohs(atif
->nets
.nr_firstnet
) + 1;
303 /* we probe the interface's network */
304 int probe_net
= ntohs(atif
->address
.s_net
);
305 int probe_node
= ATADDR_ANYNODE
; /* we'll take anything */
308 /* Offset the network we start probing with */
309 if (probe_net
== ATADDR_ANYNET
) {
310 probe_net
= ntohs(atif
->nets
.nr_firstnet
);
312 probe_net
+= jiffies
% netrange
;
315 if (probe_node
== ATADDR_ANYNODE
)
316 probe_node
= jiffies
& 0xFF;
318 /* Scan the networks */
319 for (netct
= 0; netct
<= netrange
; netct
++) {
320 /* Sweep the available nodes from a given start */
321 proxy_addr
->s_net
= htons(probe_net
);
322 for (nodect
= 0; nodect
< 256; nodect
++) {
323 proxy_addr
->s_node
= (nodect
+ probe_node
) & 0xFF;
324 if (proxy_addr
->s_node
> 0 &&
325 proxy_addr
->s_node
< 254) {
326 /* Tell AARP to probe a proposed address */
327 int ret
= aarp_proxy_probe_network(atif
,
330 if (ret
!= -EADDRINUSE
)
335 if (probe_net
> ntohs(atif
->nets
.nr_lastnet
))
336 probe_net
= ntohs(atif
->nets
.nr_firstnet
);
339 return -EADDRINUSE
; /* Network is full... */
343 struct atalk_addr
*atalk_find_dev_addr(struct net_device
*dev
)
345 struct atalk_iface
*iface
= dev
->atalk_ptr
;
346 return iface
? &iface
->address
: NULL
;
349 static struct atalk_addr
*atalk_find_primary(void)
351 struct atalk_iface
*fiface
= NULL
;
352 struct atalk_addr
*retval
;
353 struct atalk_iface
*iface
;
356 * Return a point-to-point interface only if
357 * there is no non-ptp interface available.
359 read_lock_bh(&atalk_interfaces_lock
);
360 for (iface
= atalk_interfaces
; iface
; iface
= iface
->next
) {
361 if (!fiface
&& !(iface
->dev
->flags
& IFF_LOOPBACK
))
363 if (!(iface
->dev
->flags
& (IFF_LOOPBACK
| IFF_POINTOPOINT
))) {
364 retval
= &iface
->address
;
370 retval
= &fiface
->address
;
371 else if (atalk_interfaces
)
372 retval
= &atalk_interfaces
->address
;
376 read_unlock_bh(&atalk_interfaces_lock
);
381 * Find a match for 'any network' - ie any of our interfaces with that
382 * node number will do just nicely.
384 static struct atalk_iface
*atalk_find_anynet(int node
, struct net_device
*dev
)
386 struct atalk_iface
*iface
= dev
->atalk_ptr
;
388 if (!iface
|| iface
->status
& ATIF_PROBE
)
391 if (node
!= ATADDR_BCAST
&&
392 iface
->address
.s_node
!= node
&&
393 node
!= ATADDR_ANYNODE
)
402 /* Find a match for a specific network:node pair */
403 static struct atalk_iface
*atalk_find_interface(__be16 net
, int node
)
405 struct atalk_iface
*iface
;
407 read_lock_bh(&atalk_interfaces_lock
);
408 for (iface
= atalk_interfaces
; iface
; iface
= iface
->next
) {
409 if ((node
== ATADDR_BCAST
||
410 node
== ATADDR_ANYNODE
||
411 iface
->address
.s_node
== node
) &&
412 iface
->address
.s_net
== net
&&
413 !(iface
->status
& ATIF_PROBE
))
416 /* XXXX.0 -- net.0 returns the iface associated with net */
417 if (node
== ATADDR_ANYNODE
&& net
!= ATADDR_ANYNET
&&
418 ntohs(iface
->nets
.nr_firstnet
) <= ntohs(net
) &&
419 ntohs(net
) <= ntohs(iface
->nets
.nr_lastnet
))
422 read_unlock_bh(&atalk_interfaces_lock
);
428 * Find a route for an AppleTalk packet. This ought to get cached in
429 * the socket (later on...). We know about host routes and the fact
430 * that a route must be direct to broadcast.
432 static struct atalk_route
*atrtr_find(struct atalk_addr
*target
)
435 * we must search through all routes unless we find a
436 * host route, because some host routes might overlap
439 struct atalk_route
*net_route
= NULL
;
440 struct atalk_route
*r
;
442 read_lock_bh(&atalk_routes_lock
);
443 for (r
= atalk_routes
; r
; r
= r
->next
) {
444 if (!(r
->flags
& RTF_UP
))
447 if (r
->target
.s_net
== target
->s_net
) {
448 if (r
->flags
& RTF_HOST
) {
450 * if this host route is for the target,
453 if (r
->target
.s_node
== target
->s_node
)
457 * this route will work if there isn't a
458 * direct host route, so cache it
465 * if we found a network route but not a direct host
466 * route, then return it
470 else if (atrtr_default
.dev
)
472 else /* No route can be found */
475 read_unlock_bh(&atalk_routes_lock
);
481 * Given an AppleTalk network, find the device to use. This can be
484 struct net_device
*atrtr_get_dev(struct atalk_addr
*sa
)
486 struct atalk_route
*atr
= atrtr_find(sa
);
487 return atr
? atr
->dev
: NULL
;
490 /* Set up a default router */
491 static void atrtr_set_default(struct net_device
*dev
)
493 atrtr_default
.dev
= dev
;
494 atrtr_default
.flags
= RTF_UP
;
495 atrtr_default
.gateway
.s_net
= htons(0);
496 atrtr_default
.gateway
.s_node
= 0;
500 * Add a router. Basically make sure it looks valid and stuff the
501 * entry in the list. While it uses netranges we always set them to one
502 * entry to work like netatalk.
504 static int atrtr_create(struct rtentry
*r
, struct net_device
*devhint
)
506 struct sockaddr_at
*ta
= (struct sockaddr_at
*)&r
->rt_dst
;
507 struct sockaddr_at
*ga
= (struct sockaddr_at
*)&r
->rt_gateway
;
508 struct atalk_route
*rt
;
509 struct atalk_iface
*iface
, *riface
;
510 int retval
= -EINVAL
;
513 * Fixme: Raise/Lower a routing change semaphore for these
517 /* Validate the request */
518 if (ta
->sat_family
!= AF_APPLETALK
||
519 (!devhint
&& ga
->sat_family
!= AF_APPLETALK
))
522 /* Now walk the routing table and make our decisions */
523 write_lock_bh(&atalk_routes_lock
);
524 for (rt
= atalk_routes
; rt
; rt
= rt
->next
) {
525 if (r
->rt_flags
!= rt
->flags
)
528 if (ta
->sat_addr
.s_net
== rt
->target
.s_net
) {
529 if (!(rt
->flags
& RTF_HOST
))
531 if (ta
->sat_addr
.s_node
== rt
->target
.s_node
)
539 read_lock_bh(&atalk_interfaces_lock
);
540 for (iface
= atalk_interfaces
; iface
; iface
= iface
->next
) {
542 ntohs(ga
->sat_addr
.s_net
) >=
543 ntohs(iface
->nets
.nr_firstnet
) &&
544 ntohs(ga
->sat_addr
.s_net
) <=
545 ntohs(iface
->nets
.nr_lastnet
))
548 if (ga
->sat_addr
.s_net
== iface
->address
.s_net
&&
549 ga
->sat_addr
.s_node
== iface
->address
.s_node
)
552 read_unlock_bh(&atalk_interfaces_lock
);
554 retval
= -ENETUNREACH
;
558 devhint
= riface
->dev
;
562 rt
= kzalloc(sizeof(*rt
), GFP_ATOMIC
);
568 rt
->next
= atalk_routes
;
572 /* Fill in the routing entry */
573 rt
->target
= ta
->sat_addr
;
576 rt
->flags
= r
->rt_flags
;
577 rt
->gateway
= ga
->sat_addr
;
581 write_unlock_bh(&atalk_routes_lock
);
586 /* Delete a route. Find it and discard it */
587 static int atrtr_delete(struct atalk_addr
* addr
)
589 struct atalk_route
**r
= &atalk_routes
;
591 struct atalk_route
*tmp
;
593 write_lock_bh(&atalk_routes_lock
);
594 while ((tmp
= *r
) != NULL
) {
595 if (tmp
->target
.s_net
== addr
->s_net
&&
596 (!(tmp
->flags
&RTF_GATEWAY
) ||
597 tmp
->target
.s_node
== addr
->s_node
)) {
607 write_unlock_bh(&atalk_routes_lock
);
612 * Called when a device is downed. Just throw away any routes
615 static void atrtr_device_down(struct net_device
*dev
)
617 struct atalk_route
**r
= &atalk_routes
;
618 struct atalk_route
*tmp
;
620 write_lock_bh(&atalk_routes_lock
);
621 while ((tmp
= *r
) != NULL
) {
622 if (tmp
->dev
== dev
) {
629 write_unlock_bh(&atalk_routes_lock
);
631 if (atrtr_default
.dev
== dev
)
632 atrtr_set_default(NULL
);
635 /* Actually down the interface */
636 static inline void atalk_dev_down(struct net_device
*dev
)
638 atrtr_device_down(dev
); /* Remove all routes for the device */
639 aarp_device_down(dev
); /* Remove AARP entries for the device */
640 atif_drop_device(dev
); /* Remove the device */
644 * A device event has occurred. Watch for devices going down and
645 * delete our use of them (iface and route).
647 static int ddp_device_event(struct notifier_block
*this, unsigned long event
,
650 struct net_device
*dev
= ptr
;
652 if (event
== NETDEV_DOWN
)
653 /* Discard any use of this */
659 /* ioctl calls. Shouldn't even need touching */
660 /* Device configuration ioctl calls */
661 static int atif_ioctl(int cmd
, void __user
*arg
)
663 static char aarp_mcast
[6] = { 0x09, 0x00, 0x00, 0xFF, 0xFF, 0xFF };
665 struct atalk_netrange
*nr
;
666 struct sockaddr_at
*sa
;
667 struct net_device
*dev
;
668 struct atalk_iface
*atif
;
671 struct rtentry rtdef
;
674 if (copy_from_user(&atreq
, arg
, sizeof(atreq
)))
677 dev
= __dev_get_by_name(atreq
.ifr_name
);
681 sa
= (struct sockaddr_at
*)&atreq
.ifr_addr
;
682 atif
= atalk_find_dev(dev
);
686 if (!capable(CAP_NET_ADMIN
))
688 if (sa
->sat_family
!= AF_APPLETALK
)
690 if (dev
->type
!= ARPHRD_ETHER
&&
691 dev
->type
!= ARPHRD_LOOPBACK
&&
692 dev
->type
!= ARPHRD_LOCALTLK
&&
693 dev
->type
!= ARPHRD_PPP
)
694 return -EPROTONOSUPPORT
;
696 nr
= (struct atalk_netrange
*)&sa
->sat_zero
[0];
700 * if this is a point-to-point iface, and we already
701 * have an iface for this AppleTalk address, then we
702 * should not add a route
704 if ((dev
->flags
& IFF_POINTOPOINT
) &&
705 atalk_find_interface(sa
->sat_addr
.s_net
,
706 sa
->sat_addr
.s_node
)) {
707 printk(KERN_DEBUG
"AppleTalk: point-to-point "
708 "interface added with "
709 "existing address\n");
714 * Phase 1 is fine on LocalTalk but we don't do
715 * EtherTalk phase 1. Anyone wanting to add it go ahead.
717 if (dev
->type
== ARPHRD_ETHER
&& nr
->nr_phase
!= 2)
718 return -EPROTONOSUPPORT
;
719 if (sa
->sat_addr
.s_node
== ATADDR_BCAST
||
720 sa
->sat_addr
.s_node
== 254)
723 /* Already setting address */
724 if (atif
->status
& ATIF_PROBE
)
727 atif
->address
.s_net
= sa
->sat_addr
.s_net
;
728 atif
->address
.s_node
= sa
->sat_addr
.s_node
;
729 atrtr_device_down(dev
); /* Flush old routes */
731 atif
= atif_add_device(dev
, &sa
->sat_addr
);
738 * Check if the chosen address is used. If so we
739 * error and atalkd will try another.
742 if (!(dev
->flags
& IFF_LOOPBACK
) &&
743 !(dev
->flags
& IFF_POINTOPOINT
) &&
744 atif_probe_device(atif
) < 0) {
745 atif_drop_device(dev
);
749 /* Hey it worked - add the direct routes */
750 sa
= (struct sockaddr_at
*)&rtdef
.rt_gateway
;
751 sa
->sat_family
= AF_APPLETALK
;
752 sa
->sat_addr
.s_net
= atif
->address
.s_net
;
753 sa
->sat_addr
.s_node
= atif
->address
.s_node
;
754 sa
= (struct sockaddr_at
*)&rtdef
.rt_dst
;
755 rtdef
.rt_flags
= RTF_UP
;
756 sa
->sat_family
= AF_APPLETALK
;
757 sa
->sat_addr
.s_node
= ATADDR_ANYNODE
;
758 if (dev
->flags
& IFF_LOOPBACK
||
759 dev
->flags
& IFF_POINTOPOINT
)
760 rtdef
.rt_flags
|= RTF_HOST
;
762 /* Routerless initial state */
763 if (nr
->nr_firstnet
== htons(0) &&
764 nr
->nr_lastnet
== htons(0xFFFE)) {
765 sa
->sat_addr
.s_net
= atif
->address
.s_net
;
766 atrtr_create(&rtdef
, dev
);
767 atrtr_set_default(dev
);
769 limit
= ntohs(nr
->nr_lastnet
);
770 if (limit
- ntohs(nr
->nr_firstnet
) > 4096) {
771 printk(KERN_WARNING
"Too many routes/"
776 for (ct
= ntohs(nr
->nr_firstnet
);
778 sa
->sat_addr
.s_net
= htons(ct
);
779 atrtr_create(&rtdef
, dev
);
782 dev_mc_add(dev
, aarp_mcast
, 6, 1);
787 return -EADDRNOTAVAIL
;
789 sa
->sat_family
= AF_APPLETALK
;
790 sa
->sat_addr
= atif
->address
;
795 return -EADDRNOTAVAIL
;
797 sa
->sat_family
= AF_APPLETALK
;
798 sa
->sat_addr
.s_net
= atif
->address
.s_net
;
799 sa
->sat_addr
.s_node
= ATADDR_BCAST
;
802 case SIOCATALKDIFADDR
:
804 if (!capable(CAP_NET_ADMIN
))
806 if (sa
->sat_family
!= AF_APPLETALK
)
812 if (!capable(CAP_NET_ADMIN
))
814 if (sa
->sat_family
!= AF_APPLETALK
)
817 return -EADDRNOTAVAIL
;
820 * for now, we only support proxy AARP on ELAP;
821 * we should be able to do it for LocalTalk, too.
823 if (dev
->type
!= ARPHRD_ETHER
)
824 return -EPROTONOSUPPORT
;
827 * atif points to the current interface on this network;
828 * we aren't concerned about its current status (at
829 * least for now), but it has all the settings about
830 * the network we're going to probe. Consequently, it
834 return -EADDRNOTAVAIL
;
836 nr
= (struct atalk_netrange
*)&(atif
->nets
);
838 * Phase 1 is fine on Localtalk but we don't do
839 * Ethertalk phase 1. Anyone wanting to add it go ahead.
841 if (dev
->type
== ARPHRD_ETHER
&& nr
->nr_phase
!= 2)
842 return -EPROTONOSUPPORT
;
844 if (sa
->sat_addr
.s_node
== ATADDR_BCAST
||
845 sa
->sat_addr
.s_node
== 254)
849 * Check if the chosen address is used. If so we
850 * error and ATCP will try another.
852 if (atif_proxy_probe_device(atif
, &(sa
->sat_addr
)) < 0)
856 * We now have an address on the local network, and
857 * the AARP code will defend it for us until we take it
858 * down. We don't set up any routes right now, because
859 * ATCP will install them manually via SIOCADDRT.
864 if (!capable(CAP_NET_ADMIN
))
866 if (sa
->sat_family
!= AF_APPLETALK
)
869 return -EADDRNOTAVAIL
;
871 /* give to aarp module to remove proxy entry */
872 aarp_proxy_remove(atif
->dev
, &(sa
->sat_addr
));
876 return copy_to_user(arg
, &atreq
, sizeof(atreq
)) ? -EFAULT
: 0;
879 /* Routing ioctl() calls */
880 static int atrtr_ioctl(unsigned int cmd
, void __user
*arg
)
884 if (copy_from_user(&rt
, arg
, sizeof(rt
)))
889 if (rt
.rt_dst
.sa_family
!= AF_APPLETALK
)
891 return atrtr_delete(&((struct sockaddr_at
*)
892 &rt
.rt_dst
)->sat_addr
);
895 struct net_device
*dev
= NULL
;
898 if (copy_from_user(name
, rt
.rt_dev
, IFNAMSIZ
-1))
900 name
[IFNAMSIZ
-1] = '\0';
901 dev
= __dev_get_by_name(name
);
905 return atrtr_create(&rt
, dev
);
911 /**************************************************************************\
913 * Handling for system calls applied via the various interfaces to an *
914 * AppleTalk socket object. *
916 \**************************************************************************/
919 * Checksum: This is 'optional'. It's quite likely also a good
920 * candidate for assembler hackery 8)
922 static unsigned long atalk_sum_partial(const unsigned char *data
,
923 int len
, unsigned long sum
)
925 /* This ought to be unwrapped neatly. I'll trust gcc for now */
938 /* Checksum skb data -- similar to skb_checksum */
939 static unsigned long atalk_sum_skb(const struct sk_buff
*skb
, int offset
,
940 int len
, unsigned long sum
)
942 int start
= skb_headlen(skb
);
945 /* checksum stuff in header space */
946 if ( (copy
= start
- offset
) > 0) {
949 sum
= atalk_sum_partial(skb
->data
+ offset
, copy
, sum
);
950 if ( (len
-= copy
) == 0)
956 /* checksum stuff in frags */
957 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++) {
960 BUG_TRAP(start
<= offset
+ len
);
962 end
= start
+ skb_shinfo(skb
)->frags
[i
].size
;
963 if ((copy
= end
- offset
) > 0) {
965 skb_frag_t
*frag
= &skb_shinfo(skb
)->frags
[i
];
969 vaddr
= kmap_skb_frag(frag
);
970 sum
= atalk_sum_partial(vaddr
+ frag
->page_offset
+
971 offset
- start
, copy
, sum
);
972 kunmap_skb_frag(vaddr
);
981 if (skb_shinfo(skb
)->frag_list
) {
982 struct sk_buff
*list
= skb_shinfo(skb
)->frag_list
;
984 for (; list
; list
= list
->next
) {
987 BUG_TRAP(start
<= offset
+ len
);
989 end
= start
+ list
->len
;
990 if ((copy
= end
- offset
) > 0) {
993 sum
= atalk_sum_skb(list
, offset
- start
,
995 if ((len
-= copy
) == 0)
1008 static __be16
atalk_checksum(const struct sk_buff
*skb
, int len
)
1012 /* skip header 4 bytes */
1013 sum
= atalk_sum_skb(skb
, 4, len
-4, 0);
1015 /* Use 0xFFFF for 0. 0 itself means none */
1016 return sum
? htons((unsigned short)sum
) : htons(0xFFFF);
1019 static struct proto ddp_proto
= {
1021 .owner
= THIS_MODULE
,
1022 .obj_size
= sizeof(struct atalk_sock
),
1026 * Create a socket. Initialise the socket, blank the addresses
1029 static int atalk_create(struct net
*net
, struct socket
*sock
, int protocol
)
1032 int rc
= -ESOCKTNOSUPPORT
;
1034 if (net
!= &init_net
)
1035 return -EAFNOSUPPORT
;
1038 * We permit SOCK_DGRAM and RAW is an extension. It is trivial to do
1039 * and gives you the full ELAP frame. Should be handy for CAP 8)
1041 if (sock
->type
!= SOCK_RAW
&& sock
->type
!= SOCK_DGRAM
)
1044 sk
= sk_alloc(net
, PF_APPLETALK
, GFP_KERNEL
, &ddp_proto
, 1);
1048 sock
->ops
= &atalk_dgram_ops
;
1049 sock_init_data(sock
, sk
);
1051 /* Checksums on by default */
1052 sock_set_flag(sk
, SOCK_ZAPPED
);
1057 /* Free a socket. No work needed */
1058 static int atalk_release(struct socket
*sock
)
1060 struct sock
*sk
= sock
->sk
;
1065 atalk_destroy_socket(sk
);
1071 * atalk_pick_and_bind_port - Pick a source port when one is not given
1072 * @sk - socket to insert into the tables
1073 * @sat - address to search for
1075 * Pick a source port when one is not given. If we can find a suitable free
1076 * one, we insert the socket into the tables using it.
1078 * This whole operation must be atomic.
1080 static int atalk_pick_and_bind_port(struct sock
*sk
, struct sockaddr_at
*sat
)
1084 write_lock_bh(&atalk_sockets_lock
);
1086 for (sat
->sat_port
= ATPORT_RESERVED
;
1087 sat
->sat_port
< ATPORT_LAST
;
1090 struct hlist_node
*node
;
1092 sk_for_each(s
, node
, &atalk_sockets
) {
1093 struct atalk_sock
*at
= at_sk(s
);
1095 if (at
->src_net
== sat
->sat_addr
.s_net
&&
1096 at
->src_node
== sat
->sat_addr
.s_node
&&
1097 at
->src_port
== sat
->sat_port
)
1101 /* Wheee, it's free, assign and insert. */
1102 __atalk_insert_socket(sk
);
1103 at_sk(sk
)->src_port
= sat
->sat_port
;
1112 write_unlock_bh(&atalk_sockets_lock
);
1116 static int atalk_autobind(struct sock
*sk
)
1118 struct atalk_sock
*at
= at_sk(sk
);
1119 struct sockaddr_at sat
;
1120 struct atalk_addr
*ap
= atalk_find_primary();
1121 int n
= -EADDRNOTAVAIL
;
1123 if (!ap
|| ap
->s_net
== htons(ATADDR_ANYNET
))
1126 at
->src_net
= sat
.sat_addr
.s_net
= ap
->s_net
;
1127 at
->src_node
= sat
.sat_addr
.s_node
= ap
->s_node
;
1129 n
= atalk_pick_and_bind_port(sk
, &sat
);
1131 sock_reset_flag(sk
, SOCK_ZAPPED
);
1136 /* Set the address 'our end' of the connection */
1137 static int atalk_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int addr_len
)
1139 struct sockaddr_at
*addr
= (struct sockaddr_at
*)uaddr
;
1140 struct sock
*sk
= sock
->sk
;
1141 struct atalk_sock
*at
= at_sk(sk
);
1143 if (!sock_flag(sk
, SOCK_ZAPPED
) ||
1144 addr_len
!= sizeof(struct sockaddr_at
))
1147 if (addr
->sat_family
!= AF_APPLETALK
)
1148 return -EAFNOSUPPORT
;
1150 if (addr
->sat_addr
.s_net
== htons(ATADDR_ANYNET
)) {
1151 struct atalk_addr
*ap
= atalk_find_primary();
1154 return -EADDRNOTAVAIL
;
1156 at
->src_net
= addr
->sat_addr
.s_net
= ap
->s_net
;
1157 at
->src_node
= addr
->sat_addr
.s_node
= ap
->s_node
;
1159 if (!atalk_find_interface(addr
->sat_addr
.s_net
,
1160 addr
->sat_addr
.s_node
))
1161 return -EADDRNOTAVAIL
;
1163 at
->src_net
= addr
->sat_addr
.s_net
;
1164 at
->src_node
= addr
->sat_addr
.s_node
;
1167 if (addr
->sat_port
== ATADDR_ANYPORT
) {
1168 int n
= atalk_pick_and_bind_port(sk
, addr
);
1173 at
->src_port
= addr
->sat_port
;
1175 if (atalk_find_or_insert_socket(sk
, addr
))
1179 sock_reset_flag(sk
, SOCK_ZAPPED
);
1183 /* Set the address we talk to */
1184 static int atalk_connect(struct socket
*sock
, struct sockaddr
*uaddr
,
1185 int addr_len
, int flags
)
1187 struct sock
*sk
= sock
->sk
;
1188 struct atalk_sock
*at
= at_sk(sk
);
1189 struct sockaddr_at
*addr
;
1191 sk
->sk_state
= TCP_CLOSE
;
1192 sock
->state
= SS_UNCONNECTED
;
1194 if (addr_len
!= sizeof(*addr
))
1197 addr
= (struct sockaddr_at
*)uaddr
;
1199 if (addr
->sat_family
!= AF_APPLETALK
)
1200 return -EAFNOSUPPORT
;
1202 if (addr
->sat_addr
.s_node
== ATADDR_BCAST
&&
1203 !sock_flag(sk
, SOCK_BROADCAST
)) {
1205 printk(KERN_WARNING
"%s is broken and did not set "
1206 "SO_BROADCAST. It will break when 2.2 is "
1214 if (sock_flag(sk
, SOCK_ZAPPED
))
1215 if (atalk_autobind(sk
) < 0)
1218 if (!atrtr_get_dev(&addr
->sat_addr
))
1219 return -ENETUNREACH
;
1221 at
->dest_port
= addr
->sat_port
;
1222 at
->dest_net
= addr
->sat_addr
.s_net
;
1223 at
->dest_node
= addr
->sat_addr
.s_node
;
1225 sock
->state
= SS_CONNECTED
;
1226 sk
->sk_state
= TCP_ESTABLISHED
;
1231 * Find the name of an AppleTalk socket. Just copy the right
1232 * fields into the sockaddr.
1234 static int atalk_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
1235 int *uaddr_len
, int peer
)
1237 struct sockaddr_at sat
;
1238 struct sock
*sk
= sock
->sk
;
1239 struct atalk_sock
*at
= at_sk(sk
);
1241 if (sock_flag(sk
, SOCK_ZAPPED
))
1242 if (atalk_autobind(sk
) < 0)
1245 *uaddr_len
= sizeof(struct sockaddr_at
);
1248 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1251 sat
.sat_addr
.s_net
= at
->dest_net
;
1252 sat
.sat_addr
.s_node
= at
->dest_node
;
1253 sat
.sat_port
= at
->dest_port
;
1255 sat
.sat_addr
.s_net
= at
->src_net
;
1256 sat
.sat_addr
.s_node
= at
->src_node
;
1257 sat
.sat_port
= at
->src_port
;
1260 sat
.sat_family
= AF_APPLETALK
;
1261 memcpy(uaddr
, &sat
, sizeof(sat
));
1265 #if defined(CONFIG_IPDDP) || defined(CONFIG_IPDDP_MODULE)
1266 static __inline__
int is_ip_over_ddp(struct sk_buff
*skb
)
1268 return skb
->data
[12] == 22;
1271 static int handle_ip_over_ddp(struct sk_buff
*skb
)
1273 struct net_device
*dev
= __dev_get_by_name("ipddp0");
1274 struct net_device_stats
*stats
;
1276 /* This needs to be able to handle ipddp"N" devices */
1280 skb
->protocol
= htons(ETH_P_IP
);
1283 skb_reset_transport_header(skb
);
1286 stats
->rx_packets
++;
1287 stats
->rx_bytes
+= skb
->len
+ 13;
1288 netif_rx(skb
); /* Send the SKB up to a higher place. */
1292 /* make it easy for gcc to optimize this test out, i.e. kill the code */
1293 #define is_ip_over_ddp(skb) 0
1294 #define handle_ip_over_ddp(skb) 0
1297 static void atalk_route_packet(struct sk_buff
*skb
, struct net_device
*dev
,
1298 struct ddpehdr
*ddp
, __u16 len_hops
,
1301 struct atalk_route
*rt
;
1302 struct atalk_addr ta
;
1305 * Don't route multicast, etc., packets, or packets sent to "this
1308 if (skb
->pkt_type
!= PACKET_HOST
|| !ddp
->deh_dnet
) {
1312 * Can it ever happen that a packet is from a PPP iface and
1313 * needs to be broadcast onto the default network?
1315 if (dev
->type
== ARPHRD_PPP
)
1316 printk(KERN_DEBUG
"AppleTalk: didn't forward broadcast "
1317 "packet received from PPP iface\n");
1321 ta
.s_net
= ddp
->deh_dnet
;
1322 ta
.s_node
= ddp
->deh_dnode
;
1324 /* Route the packet */
1325 rt
= atrtr_find(&ta
);
1326 /* increment hops count */
1327 len_hops
+= 1 << 10;
1328 if (!rt
|| !(len_hops
& (15 << 10)))
1331 /* FIXME: use skb->cb to be able to use shared skbs */
1334 * Route goes through another gateway, so set the target to the
1338 if (rt
->flags
& RTF_GATEWAY
) {
1339 ta
.s_net
= rt
->gateway
.s_net
;
1340 ta
.s_node
= rt
->gateway
.s_node
;
1343 /* Fix up skb->len field */
1344 skb_trim(skb
, min_t(unsigned int, origlen
,
1345 (rt
->dev
->hard_header_len
+
1346 ddp_dl
->header_length
+ (len_hops
& 1023))));
1348 /* FIXME: use skb->cb to be able to use shared skbs */
1349 ddp
->deh_len_hops
= htons(len_hops
);
1352 * Send the buffer onwards
1354 * Now we must always be careful. If it's come from LocalTalk to
1355 * EtherTalk it might not fit
1357 * Order matters here: If a packet has to be copied to make a new
1358 * headroom (rare hopefully) then it won't need unsharing.
1360 * Note. ddp-> becomes invalid at the realloc.
1362 if (skb_headroom(skb
) < 22) {
1363 /* 22 bytes - 12 ether, 2 len, 3 802.2 5 snap */
1364 struct sk_buff
*nskb
= skb_realloc_headroom(skb
, 32);
1370 skb
= skb_unshare(skb
, GFP_ATOMIC
);
1373 * If the buffer didn't vanish into the lack of space bitbucket we can
1376 if (skb
&& aarp_send_ddp(rt
->dev
, skb
, &ta
, NULL
) == -1)
1385 * atalk_rcv - Receive a packet (in skb) from device dev
1386 * @skb - packet received
1387 * @dev - network device where the packet comes from
1390 * Receive a packet (in skb) from device dev. This has come from the SNAP
1391 * decoder, and on entry skb->transport_header is the DDP header, skb->len
1392 * is the DDP header, skb->len is the DDP length. The physical headers
1393 * have been extracted. PPP should probably pass frames marked as for this
1394 * layer. [ie ARPHRD_ETHERTALK]
1396 static int atalk_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
1397 struct packet_type
*pt
, struct net_device
*orig_dev
)
1399 struct ddpehdr
*ddp
;
1401 struct atalk_iface
*atif
;
1402 struct sockaddr_at tosat
;
1406 /* Don't mangle buffer if shared */
1407 if (!(skb
= skb_share_check(skb
, GFP_ATOMIC
)))
1410 /* Size check and make sure header is contiguous */
1411 if (!pskb_may_pull(skb
, sizeof(*ddp
)))
1416 len_hops
= ntohs(ddp
->deh_len_hops
);
1418 /* Trim buffer in case of stray trailing data */
1420 skb_trim(skb
, min_t(unsigned int, skb
->len
, len_hops
& 1023));
1423 * Size check to see if ddp->deh_len was crap
1424 * (Otherwise we'll detonate most spectacularly
1425 * in the middle of atalk_checksum() or recvmsg()).
1427 if (skb
->len
< sizeof(*ddp
) || skb
->len
< (len_hops
& 1023)) {
1428 pr_debug("AppleTalk: dropping corrupted frame (deh_len=%u, "
1429 "skb->len=%u)\n", len_hops
& 1023, skb
->len
);
1434 * Any checksums. Note we don't do htons() on this == is assumed to be
1435 * valid for net byte orders all over the networking code...
1438 atalk_checksum(skb
, len_hops
& 1023) != ddp
->deh_sum
)
1439 /* Not a valid AppleTalk frame - dustbin time */
1442 /* Check the packet is aimed at us */
1443 if (!ddp
->deh_dnet
) /* Net 0 is 'this network' */
1444 atif
= atalk_find_anynet(ddp
->deh_dnode
, dev
);
1446 atif
= atalk_find_interface(ddp
->deh_dnet
, ddp
->deh_dnode
);
1449 /* Not ours, so we route the packet via the correct
1452 atalk_route_packet(skb
, dev
, ddp
, len_hops
, origlen
);
1456 /* if IP over DDP is not selected this code will be optimized out */
1457 if (is_ip_over_ddp(skb
))
1458 return handle_ip_over_ddp(skb
);
1460 * Which socket - atalk_search_socket() looks for a *full match*
1461 * of the <net, node, port> tuple.
1463 tosat
.sat_addr
.s_net
= ddp
->deh_dnet
;
1464 tosat
.sat_addr
.s_node
= ddp
->deh_dnode
;
1465 tosat
.sat_port
= ddp
->deh_dport
;
1467 sock
= atalk_search_socket(&tosat
, atif
);
1468 if (!sock
) /* But not one of our sockets */
1471 /* Queue packet (standard) */
1474 if (sock_queue_rcv_skb(sock
, skb
) < 0)
1484 * Receive a LocalTalk frame. We make some demands on the caller here.
1485 * Caller must provide enough headroom on the packet to pull the short
1486 * header and append a long one.
1488 static int ltalk_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
1489 struct packet_type
*pt
, struct net_device
*orig_dev
)
1491 /* Expand any short form frames */
1492 if (skb_mac_header(skb
)[2] == 1) {
1493 struct ddpehdr
*ddp
;
1494 /* Find our address */
1495 struct atalk_addr
*ap
= atalk_find_dev_addr(dev
);
1497 if (!ap
|| skb
->len
< sizeof(__be16
) || skb
->len
> 1023)
1500 /* Don't mangle buffer if shared */
1501 if (!(skb
= skb_share_check(skb
, GFP_ATOMIC
)))
1505 * The push leaves us with a ddephdr not an shdr, and
1506 * handily the port bytes in the right place preset.
1508 ddp
= (struct ddpehdr
*) skb_push(skb
, sizeof(*ddp
) - 4);
1510 /* Now fill in the long header */
1513 * These two first. The mac overlays the new source/dest
1514 * network information so we MUST copy these before
1515 * we write the network numbers !
1518 ddp
->deh_dnode
= skb_mac_header(skb
)[0]; /* From physical header */
1519 ddp
->deh_snode
= skb_mac_header(skb
)[1]; /* From physical header */
1521 ddp
->deh_dnet
= ap
->s_net
; /* Network number */
1522 ddp
->deh_snet
= ap
->s_net
;
1523 ddp
->deh_sum
= 0; /* No checksum */
1525 * Not sure about this bit...
1527 /* Non routable, so force a drop if we slip up later */
1528 ddp
->deh_len_hops
= htons(skb
->len
+ (DDP_MAXHOPS
<< 10));
1530 skb_reset_transport_header(skb
);
1532 return atalk_rcv(skb
, dev
, pt
, orig_dev
);
1538 static int atalk_sendmsg(struct kiocb
*iocb
, struct socket
*sock
, struct msghdr
*msg
,
1541 struct sock
*sk
= sock
->sk
;
1542 struct atalk_sock
*at
= at_sk(sk
);
1543 struct sockaddr_at
*usat
= (struct sockaddr_at
*)msg
->msg_name
;
1544 int flags
= msg
->msg_flags
;
1546 struct sockaddr_at local_satalk
, gsat
;
1547 struct sk_buff
*skb
;
1548 struct net_device
*dev
;
1549 struct ddpehdr
*ddp
;
1551 struct atalk_route
*rt
;
1554 if (flags
& ~(MSG_DONTWAIT
|MSG_CMSG_COMPAT
))
1557 if (len
> DDP_MAXSZ
)
1561 if (sock_flag(sk
, SOCK_ZAPPED
))
1562 if (atalk_autobind(sk
) < 0)
1565 if (msg
->msg_namelen
< sizeof(*usat
) ||
1566 usat
->sat_family
!= AF_APPLETALK
)
1569 /* netatalk doesn't implement this check */
1570 if (usat
->sat_addr
.s_node
== ATADDR_BCAST
&&
1571 !sock_flag(sk
, SOCK_BROADCAST
)) {
1572 printk(KERN_INFO
"SO_BROADCAST: Fix your netatalk as "
1573 "it will break before 2.2\n");
1579 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1581 usat
= &local_satalk
;
1582 usat
->sat_family
= AF_APPLETALK
;
1583 usat
->sat_port
= at
->dest_port
;
1584 usat
->sat_addr
.s_node
= at
->dest_node
;
1585 usat
->sat_addr
.s_net
= at
->dest_net
;
1588 /* Build a packet */
1589 SOCK_DEBUG(sk
, "SK %p: Got address.\n", sk
);
1592 size
= sizeof(struct ddpehdr
) + len
+ ddp_dl
->header_length
;
1594 if (usat
->sat_addr
.s_net
|| usat
->sat_addr
.s_node
== ATADDR_ANYNODE
) {
1595 rt
= atrtr_find(&usat
->sat_addr
);
1597 struct atalk_addr at_hint
;
1600 at_hint
.s_net
= at
->src_net
;
1602 rt
= atrtr_find(&at_hint
);
1605 return -ENETUNREACH
;
1609 SOCK_DEBUG(sk
, "SK %p: Size needed %d, device %s\n",
1610 sk
, size
, dev
->name
);
1612 size
+= dev
->hard_header_len
;
1613 skb
= sock_alloc_send_skb(sk
, size
, (flags
& MSG_DONTWAIT
), &err
);
1618 skb_reserve(skb
, ddp_dl
->header_length
);
1619 skb_reserve(skb
, dev
->hard_header_len
);
1622 SOCK_DEBUG(sk
, "SK %p: Begin build.\n", sk
);
1624 ddp
= (struct ddpehdr
*)skb_put(skb
, sizeof(struct ddpehdr
));
1625 ddp
->deh_len_hops
= htons(len
+ sizeof(*ddp
));
1626 ddp
->deh_dnet
= usat
->sat_addr
.s_net
;
1627 ddp
->deh_snet
= at
->src_net
;
1628 ddp
->deh_dnode
= usat
->sat_addr
.s_node
;
1629 ddp
->deh_snode
= at
->src_node
;
1630 ddp
->deh_dport
= usat
->sat_port
;
1631 ddp
->deh_sport
= at
->src_port
;
1633 SOCK_DEBUG(sk
, "SK %p: Copy user data (%Zd bytes).\n", sk
, len
);
1635 err
= memcpy_fromiovec(skb_put(skb
, len
), msg
->msg_iov
, len
);
1641 if (sk
->sk_no_check
== 1)
1644 ddp
->deh_sum
= atalk_checksum(skb
, len
+ sizeof(*ddp
));
1647 * Loopback broadcast packets to non gateway targets (ie routes
1648 * to group we are in)
1650 if (ddp
->deh_dnode
== ATADDR_BCAST
&&
1651 !(rt
->flags
& RTF_GATEWAY
) && !(dev
->flags
& IFF_LOOPBACK
)) {
1652 struct sk_buff
*skb2
= skb_copy(skb
, GFP_KERNEL
);
1656 SOCK_DEBUG(sk
, "SK %p: send out(copy).\n", sk
);
1657 if (aarp_send_ddp(dev
, skb2
,
1658 &usat
->sat_addr
, NULL
) == -1)
1660 /* else queued/sent above in the aarp queue */
1664 if (dev
->flags
& IFF_LOOPBACK
|| loopback
) {
1665 SOCK_DEBUG(sk
, "SK %p: Loop back.\n", sk
);
1668 if (ddp
->deh_dnode
== ATADDR_BCAST
) {
1669 struct atalk_addr at_lo
;
1674 rt
= atrtr_find(&at_lo
);
1677 return -ENETUNREACH
;
1682 ddp_dl
->request(ddp_dl
, skb
, dev
->dev_addr
);
1684 SOCK_DEBUG(sk
, "SK %p: send out.\n", sk
);
1685 if (rt
->flags
& RTF_GATEWAY
) {
1686 gsat
.sat_addr
= rt
->gateway
;
1690 if (aarp_send_ddp(dev
, skb
, &usat
->sat_addr
, NULL
) == -1)
1692 /* else queued/sent above in the aarp queue */
1694 SOCK_DEBUG(sk
, "SK %p: Done write (%Zd).\n", sk
, len
);
1699 static int atalk_recvmsg(struct kiocb
*iocb
, struct socket
*sock
, struct msghdr
*msg
,
1700 size_t size
, int flags
)
1702 struct sock
*sk
= sock
->sk
;
1703 struct sockaddr_at
*sat
= (struct sockaddr_at
*)msg
->msg_name
;
1704 struct ddpehdr
*ddp
;
1708 struct sk_buff
*skb
= skb_recv_datagram(sk
, flags
& ~MSG_DONTWAIT
,
1709 flags
& MSG_DONTWAIT
, &err
);
1713 /* FIXME: use skb->cb to be able to use shared skbs */
1715 copied
= ntohs(ddp
->deh_len_hops
) & 1023;
1717 if (sk
->sk_type
!= SOCK_RAW
) {
1718 offset
= sizeof(*ddp
);
1722 if (copied
> size
) {
1724 msg
->msg_flags
|= MSG_TRUNC
;
1726 err
= skb_copy_datagram_iovec(skb
, offset
, msg
->msg_iov
, copied
);
1730 sat
->sat_family
= AF_APPLETALK
;
1731 sat
->sat_port
= ddp
->deh_sport
;
1732 sat
->sat_addr
.s_node
= ddp
->deh_snode
;
1733 sat
->sat_addr
.s_net
= ddp
->deh_snet
;
1735 msg
->msg_namelen
= sizeof(*sat
);
1738 skb_free_datagram(sk
, skb
); /* Free the datagram. */
1739 return err
? : copied
;
1744 * AppleTalk ioctl calls.
1746 static int atalk_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1748 int rc
= -ENOIOCTLCMD
;
1749 struct sock
*sk
= sock
->sk
;
1750 void __user
*argp
= (void __user
*)arg
;
1753 /* Protocol layer */
1755 long amount
= sk
->sk_sndbuf
-
1756 atomic_read(&sk
->sk_wmem_alloc
);
1760 rc
= put_user(amount
, (int __user
*)argp
);
1765 * These two are safe on a single CPU system as only
1766 * user tasks fiddle here
1768 struct sk_buff
*skb
= skb_peek(&sk
->sk_receive_queue
);
1772 amount
= skb
->len
- sizeof(struct ddpehdr
);
1773 rc
= put_user(amount
, (int __user
*)argp
);
1777 rc
= sock_get_timestamp(sk
, argp
);
1780 rc
= sock_get_timestampns(sk
, argp
);
1786 if (capable(CAP_NET_ADMIN
))
1787 rc
= atrtr_ioctl(cmd
, argp
);
1792 case SIOCGIFBRDADDR
:
1793 case SIOCATALKDIFADDR
:
1795 case SIOCSARP
: /* proxy AARP */
1796 case SIOCDARP
: /* proxy AARP */
1798 rc
= atif_ioctl(cmd
, argp
);
1807 #ifdef CONFIG_COMPAT
1808 static int atalk_compat_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1811 * All Appletalk ioctls except SIOCATALKDIFADDR are standard. And
1812 * SIOCATALKDIFADDR is handled by upper layer as well, so there is
1813 * nothing to do. Eventually SIOCATALKDIFADDR should be moved
1814 * here so there is no generic SIOCPROTOPRIVATE translation in the
1817 return -ENOIOCTLCMD
;
1822 static struct net_proto_family atalk_family_ops
= {
1823 .family
= PF_APPLETALK
,
1824 .create
= atalk_create
,
1825 .owner
= THIS_MODULE
,
1828 static const struct proto_ops
SOCKOPS_WRAPPED(atalk_dgram_ops
) = {
1829 .family
= PF_APPLETALK
,
1830 .owner
= THIS_MODULE
,
1831 .release
= atalk_release
,
1833 .connect
= atalk_connect
,
1834 .socketpair
= sock_no_socketpair
,
1835 .accept
= sock_no_accept
,
1836 .getname
= atalk_getname
,
1837 .poll
= datagram_poll
,
1838 .ioctl
= atalk_ioctl
,
1839 #ifdef CONFIG_COMPAT
1840 .compat_ioctl
= atalk_compat_ioctl
,
1842 .listen
= sock_no_listen
,
1843 .shutdown
= sock_no_shutdown
,
1844 .setsockopt
= sock_no_setsockopt
,
1845 .getsockopt
= sock_no_getsockopt
,
1846 .sendmsg
= atalk_sendmsg
,
1847 .recvmsg
= atalk_recvmsg
,
1848 .mmap
= sock_no_mmap
,
1849 .sendpage
= sock_no_sendpage
,
1852 SOCKOPS_WRAP(atalk_dgram
, PF_APPLETALK
);
1854 static struct notifier_block ddp_notifier
= {
1855 .notifier_call
= ddp_device_event
,
1858 static struct packet_type ltalk_packet_type
= {
1859 .type
= __constant_htons(ETH_P_LOCALTALK
),
1863 static struct packet_type ppptalk_packet_type
= {
1864 .type
= __constant_htons(ETH_P_PPPTALK
),
1868 static unsigned char ddp_snap_id
[] = { 0x08, 0x00, 0x07, 0x80, 0x9B };
1870 /* Export symbols for use by drivers when AppleTalk is a module */
1871 EXPORT_SYMBOL(aarp_send_ddp
);
1872 EXPORT_SYMBOL(atrtr_get_dev
);
1873 EXPORT_SYMBOL(atalk_find_dev_addr
);
1875 static char atalk_err_snap
[] __initdata
=
1876 KERN_CRIT
"Unable to register DDP with SNAP.\n";
1878 /* Called by proto.c on kernel start up */
1879 static int __init
atalk_init(void)
1881 int rc
= proto_register(&ddp_proto
, 0);
1886 (void)sock_register(&atalk_family_ops
);
1887 ddp_dl
= register_snap_client(ddp_snap_id
, atalk_rcv
);
1889 printk(atalk_err_snap
);
1891 dev_add_pack(<alk_packet_type
);
1892 dev_add_pack(&ppptalk_packet_type
);
1894 register_netdevice_notifier(&ddp_notifier
);
1897 atalk_register_sysctl();
1901 module_init(atalk_init
);
1904 * No explicit module reference count manipulation is needed in the
1905 * protocol. Socket layer sets module reference count for us
1906 * and interfaces reference counting is done
1907 * by the network device layer.
1909 * Ergo, before the AppleTalk module can be removed, all AppleTalk
1910 * sockets be closed from user space.
1912 static void __exit
atalk_exit(void)
1914 #ifdef CONFIG_SYSCTL
1915 atalk_unregister_sysctl();
1916 #endif /* CONFIG_SYSCTL */
1918 aarp_cleanup_module(); /* General aarp clean-up. */
1919 unregister_netdevice_notifier(&ddp_notifier
);
1920 dev_remove_pack(<alk_packet_type
);
1921 dev_remove_pack(&ppptalk_packet_type
);
1922 unregister_snap_client(ddp_dl
);
1923 sock_unregister(PF_APPLETALK
);
1924 proto_unregister(&ddp_proto
);
1926 module_exit(atalk_exit
);
1928 MODULE_LICENSE("GPL");
1929 MODULE_AUTHOR("Alan Cox <Alan.Cox@linux.org>");
1930 MODULE_DESCRIPTION("AppleTalk 0.20\n");
1931 MODULE_ALIAS_NETPROTO(PF_APPLETALK
);