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/smp_lock.h>
58 #include <linux/termios.h> /* For TIOCOUTQ/INQ */
59 #include <linux/compat.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 "../core/kmap_skb.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
)
96 struct hlist_node
*node
;
98 read_lock_bh(&atalk_sockets_lock
);
99 sk_for_each(s
, node
, &atalk_sockets
) {
100 struct atalk_sock
*at
= at_sk(s
);
102 if (to
->sat_port
!= at
->src_port
)
105 if (to
->sat_addr
.s_net
== ATADDR_ANYNET
&&
106 to
->sat_addr
.s_node
== ATADDR_BCAST
)
109 if (to
->sat_addr
.s_net
== at
->src_net
&&
110 (to
->sat_addr
.s_node
== at
->src_node
||
111 to
->sat_addr
.s_node
== ATADDR_BCAST
||
112 to
->sat_addr
.s_node
== ATADDR_ANYNODE
))
115 /* XXXX.0 -- we got a request for this router. make sure
116 * that the node is appropriately set. */
117 if (to
->sat_addr
.s_node
== ATADDR_ANYNODE
&&
118 to
->sat_addr
.s_net
!= ATADDR_ANYNET
&&
119 atif
->address
.s_node
== at
->src_node
) {
120 to
->sat_addr
.s_node
= atif
->address
.s_node
;
126 read_unlock_bh(&atalk_sockets_lock
);
131 * atalk_find_or_insert_socket - Try to find a socket matching ADDR
132 * @sk - socket to insert in the list if it is not there already
133 * @sat - address to search for
135 * Try to find a socket matching ADDR in the socket list, if found then return
136 * it. If not, insert SK into the socket list.
138 * This entire operation must execute atomically.
140 static struct sock
*atalk_find_or_insert_socket(struct sock
*sk
,
141 struct sockaddr_at
*sat
)
144 struct hlist_node
*node
;
145 struct atalk_sock
*at
;
147 write_lock_bh(&atalk_sockets_lock
);
148 sk_for_each(s
, node
, &atalk_sockets
) {
151 if (at
->src_net
== sat
->sat_addr
.s_net
&&
152 at
->src_node
== sat
->sat_addr
.s_node
&&
153 at
->src_port
== sat
->sat_port
)
157 __atalk_insert_socket(sk
); /* Wheee, it's free, assign and insert. */
159 write_unlock_bh(&atalk_sockets_lock
);
163 static void atalk_destroy_timer(unsigned long data
)
165 struct sock
*sk
= (struct sock
*)data
;
167 if (sk_has_allocations(sk
)) {
168 sk
->sk_timer
.expires
= jiffies
+ SOCK_DESTROY_TIME
;
169 add_timer(&sk
->sk_timer
);
174 static inline void atalk_destroy_socket(struct sock
*sk
)
176 atalk_remove_socket(sk
);
177 skb_queue_purge(&sk
->sk_receive_queue
);
179 if (sk_has_allocations(sk
)) {
180 setup_timer(&sk
->sk_timer
, atalk_destroy_timer
,
182 sk
->sk_timer
.expires
= jiffies
+ SOCK_DESTROY_TIME
;
183 add_timer(&sk
->sk_timer
);
188 /**************************************************************************\
190 * Routing tables for the AppleTalk socket layer. *
192 \**************************************************************************/
194 /* Anti-deadlock ordering is atalk_routes_lock --> iface_lock -DaveM */
195 struct atalk_route
*atalk_routes
;
196 DEFINE_RWLOCK(atalk_routes_lock
);
198 struct atalk_iface
*atalk_interfaces
;
199 DEFINE_RWLOCK(atalk_interfaces_lock
);
201 /* For probing devices or in a routerless network */
202 struct atalk_route atrtr_default
;
204 /* AppleTalk interface control */
206 * Drop a device. Doesn't drop any of its routes - that is the caller's
207 * problem. Called when we down the interface or delete the address.
209 static void atif_drop_device(struct net_device
*dev
)
211 struct atalk_iface
**iface
= &atalk_interfaces
;
212 struct atalk_iface
*tmp
;
214 write_lock_bh(&atalk_interfaces_lock
);
215 while ((tmp
= *iface
) != NULL
) {
216 if (tmp
->dev
== dev
) {
220 dev
->atalk_ptr
= NULL
;
224 write_unlock_bh(&atalk_interfaces_lock
);
227 static struct atalk_iface
*atif_add_device(struct net_device
*dev
,
228 struct atalk_addr
*sa
)
230 struct atalk_iface
*iface
= kzalloc(sizeof(*iface
), GFP_KERNEL
);
237 dev
->atalk_ptr
= iface
;
238 iface
->address
= *sa
;
241 write_lock_bh(&atalk_interfaces_lock
);
242 iface
->next
= atalk_interfaces
;
243 atalk_interfaces
= iface
;
244 write_unlock_bh(&atalk_interfaces_lock
);
249 /* Perform phase 2 AARP probing on our tentative address */
250 static int atif_probe_device(struct atalk_iface
*atif
)
252 int netrange
= ntohs(atif
->nets
.nr_lastnet
) -
253 ntohs(atif
->nets
.nr_firstnet
) + 1;
254 int probe_net
= ntohs(atif
->address
.s_net
);
255 int probe_node
= atif
->address
.s_node
;
258 /* Offset the network we start probing with */
259 if (probe_net
== ATADDR_ANYNET
) {
260 probe_net
= ntohs(atif
->nets
.nr_firstnet
);
262 probe_net
+= jiffies
% netrange
;
264 if (probe_node
== ATADDR_ANYNODE
)
265 probe_node
= jiffies
& 0xFF;
267 /* Scan the networks */
268 atif
->status
|= ATIF_PROBE
;
269 for (netct
= 0; netct
<= netrange
; netct
++) {
270 /* Sweep the available nodes from a given start */
271 atif
->address
.s_net
= htons(probe_net
);
272 for (nodect
= 0; nodect
< 256; nodect
++) {
273 atif
->address
.s_node
= (nodect
+ probe_node
) & 0xFF;
274 if (atif
->address
.s_node
> 0 &&
275 atif
->address
.s_node
< 254) {
276 /* Probe a proposed address */
277 aarp_probe_network(atif
);
279 if (!(atif
->status
& ATIF_PROBE_FAIL
)) {
280 atif
->status
&= ~ATIF_PROBE
;
284 atif
->status
&= ~ATIF_PROBE_FAIL
;
287 if (probe_net
> ntohs(atif
->nets
.nr_lastnet
))
288 probe_net
= ntohs(atif
->nets
.nr_firstnet
);
290 atif
->status
&= ~ATIF_PROBE
;
292 return -EADDRINUSE
; /* Network is full... */
296 /* Perform AARP probing for a proxy address */
297 static int atif_proxy_probe_device(struct atalk_iface
*atif
,
298 struct atalk_addr
* proxy_addr
)
300 int netrange
= ntohs(atif
->nets
.nr_lastnet
) -
301 ntohs(atif
->nets
.nr_firstnet
) + 1;
302 /* we probe the interface's network */
303 int probe_net
= ntohs(atif
->address
.s_net
);
304 int probe_node
= ATADDR_ANYNODE
; /* we'll take anything */
307 /* Offset the network we start probing with */
308 if (probe_net
== ATADDR_ANYNET
) {
309 probe_net
= ntohs(atif
->nets
.nr_firstnet
);
311 probe_net
+= jiffies
% netrange
;
314 if (probe_node
== ATADDR_ANYNODE
)
315 probe_node
= jiffies
& 0xFF;
317 /* Scan the networks */
318 for (netct
= 0; netct
<= netrange
; netct
++) {
319 /* Sweep the available nodes from a given start */
320 proxy_addr
->s_net
= htons(probe_net
);
321 for (nodect
= 0; nodect
< 256; nodect
++) {
322 proxy_addr
->s_node
= (nodect
+ probe_node
) & 0xFF;
323 if (proxy_addr
->s_node
> 0 &&
324 proxy_addr
->s_node
< 254) {
325 /* Tell AARP to probe a proposed address */
326 int ret
= aarp_proxy_probe_network(atif
,
329 if (ret
!= -EADDRINUSE
)
334 if (probe_net
> ntohs(atif
->nets
.nr_lastnet
))
335 probe_net
= ntohs(atif
->nets
.nr_firstnet
);
338 return -EADDRINUSE
; /* Network is full... */
342 struct atalk_addr
*atalk_find_dev_addr(struct net_device
*dev
)
344 struct atalk_iface
*iface
= dev
->atalk_ptr
;
345 return iface
? &iface
->address
: NULL
;
348 static struct atalk_addr
*atalk_find_primary(void)
350 struct atalk_iface
*fiface
= NULL
;
351 struct atalk_addr
*retval
;
352 struct atalk_iface
*iface
;
355 * Return a point-to-point interface only if
356 * there is no non-ptp interface available.
358 read_lock_bh(&atalk_interfaces_lock
);
359 for (iface
= atalk_interfaces
; iface
; iface
= iface
->next
) {
360 if (!fiface
&& !(iface
->dev
->flags
& IFF_LOOPBACK
))
362 if (!(iface
->dev
->flags
& (IFF_LOOPBACK
| IFF_POINTOPOINT
))) {
363 retval
= &iface
->address
;
369 retval
= &fiface
->address
;
370 else if (atalk_interfaces
)
371 retval
= &atalk_interfaces
->address
;
375 read_unlock_bh(&atalk_interfaces_lock
);
380 * Find a match for 'any network' - ie any of our interfaces with that
381 * node number will do just nicely.
383 static struct atalk_iface
*atalk_find_anynet(int node
, struct net_device
*dev
)
385 struct atalk_iface
*iface
= dev
->atalk_ptr
;
387 if (!iface
|| iface
->status
& ATIF_PROBE
)
390 if (node
!= ATADDR_BCAST
&&
391 iface
->address
.s_node
!= node
&&
392 node
!= ATADDR_ANYNODE
)
401 /* Find a match for a specific network:node pair */
402 static struct atalk_iface
*atalk_find_interface(__be16 net
, int node
)
404 struct atalk_iface
*iface
;
406 read_lock_bh(&atalk_interfaces_lock
);
407 for (iface
= atalk_interfaces
; iface
; iface
= iface
->next
) {
408 if ((node
== ATADDR_BCAST
||
409 node
== ATADDR_ANYNODE
||
410 iface
->address
.s_node
== node
) &&
411 iface
->address
.s_net
== net
&&
412 !(iface
->status
& ATIF_PROBE
))
415 /* XXXX.0 -- net.0 returns the iface associated with net */
416 if (node
== ATADDR_ANYNODE
&& net
!= ATADDR_ANYNET
&&
417 ntohs(iface
->nets
.nr_firstnet
) <= ntohs(net
) &&
418 ntohs(net
) <= ntohs(iface
->nets
.nr_lastnet
))
421 read_unlock_bh(&atalk_interfaces_lock
);
427 * Find a route for an AppleTalk packet. This ought to get cached in
428 * the socket (later on...). We know about host routes and the fact
429 * that a route must be direct to broadcast.
431 static struct atalk_route
*atrtr_find(struct atalk_addr
*target
)
434 * we must search through all routes unless we find a
435 * host route, because some host routes might overlap
438 struct atalk_route
*net_route
= NULL
;
439 struct atalk_route
*r
;
441 read_lock_bh(&atalk_routes_lock
);
442 for (r
= atalk_routes
; r
; r
= r
->next
) {
443 if (!(r
->flags
& RTF_UP
))
446 if (r
->target
.s_net
== target
->s_net
) {
447 if (r
->flags
& RTF_HOST
) {
449 * if this host route is for the target,
452 if (r
->target
.s_node
== target
->s_node
)
456 * this route will work if there isn't a
457 * direct host route, so cache it
464 * if we found a network route but not a direct host
465 * route, then return it
469 else if (atrtr_default
.dev
)
471 else /* No route can be found */
474 read_unlock_bh(&atalk_routes_lock
);
480 * Given an AppleTalk network, find the device to use. This can be
483 struct net_device
*atrtr_get_dev(struct atalk_addr
*sa
)
485 struct atalk_route
*atr
= atrtr_find(sa
);
486 return atr
? atr
->dev
: NULL
;
489 /* Set up a default router */
490 static void atrtr_set_default(struct net_device
*dev
)
492 atrtr_default
.dev
= dev
;
493 atrtr_default
.flags
= RTF_UP
;
494 atrtr_default
.gateway
.s_net
= htons(0);
495 atrtr_default
.gateway
.s_node
= 0;
499 * Add a router. Basically make sure it looks valid and stuff the
500 * entry in the list. While it uses netranges we always set them to one
501 * entry to work like netatalk.
503 static int atrtr_create(struct rtentry
*r
, struct net_device
*devhint
)
505 struct sockaddr_at
*ta
= (struct sockaddr_at
*)&r
->rt_dst
;
506 struct sockaddr_at
*ga
= (struct sockaddr_at
*)&r
->rt_gateway
;
507 struct atalk_route
*rt
;
508 struct atalk_iface
*iface
, *riface
;
509 int retval
= -EINVAL
;
512 * Fixme: Raise/Lower a routing change semaphore for these
516 /* Validate the request */
517 if (ta
->sat_family
!= AF_APPLETALK
||
518 (!devhint
&& ga
->sat_family
!= AF_APPLETALK
))
521 /* Now walk the routing table and make our decisions */
522 write_lock_bh(&atalk_routes_lock
);
523 for (rt
= atalk_routes
; rt
; rt
= rt
->next
) {
524 if (r
->rt_flags
!= rt
->flags
)
527 if (ta
->sat_addr
.s_net
== rt
->target
.s_net
) {
528 if (!(rt
->flags
& RTF_HOST
))
530 if (ta
->sat_addr
.s_node
== rt
->target
.s_node
)
538 read_lock_bh(&atalk_interfaces_lock
);
539 for (iface
= atalk_interfaces
; iface
; iface
= iface
->next
) {
541 ntohs(ga
->sat_addr
.s_net
) >=
542 ntohs(iface
->nets
.nr_firstnet
) &&
543 ntohs(ga
->sat_addr
.s_net
) <=
544 ntohs(iface
->nets
.nr_lastnet
))
547 if (ga
->sat_addr
.s_net
== iface
->address
.s_net
&&
548 ga
->sat_addr
.s_node
== iface
->address
.s_node
)
551 read_unlock_bh(&atalk_interfaces_lock
);
553 retval
= -ENETUNREACH
;
557 devhint
= riface
->dev
;
561 rt
= kzalloc(sizeof(*rt
), GFP_ATOMIC
);
567 rt
->next
= atalk_routes
;
571 /* Fill in the routing entry */
572 rt
->target
= ta
->sat_addr
;
575 rt
->flags
= r
->rt_flags
;
576 rt
->gateway
= ga
->sat_addr
;
580 write_unlock_bh(&atalk_routes_lock
);
585 /* Delete a route. Find it and discard it */
586 static int atrtr_delete(struct atalk_addr
* addr
)
588 struct atalk_route
**r
= &atalk_routes
;
590 struct atalk_route
*tmp
;
592 write_lock_bh(&atalk_routes_lock
);
593 while ((tmp
= *r
) != NULL
) {
594 if (tmp
->target
.s_net
== addr
->s_net
&&
595 (!(tmp
->flags
&RTF_GATEWAY
) ||
596 tmp
->target
.s_node
== addr
->s_node
)) {
606 write_unlock_bh(&atalk_routes_lock
);
611 * Called when a device is downed. Just throw away any routes
614 static void atrtr_device_down(struct net_device
*dev
)
616 struct atalk_route
**r
= &atalk_routes
;
617 struct atalk_route
*tmp
;
619 write_lock_bh(&atalk_routes_lock
);
620 while ((tmp
= *r
) != NULL
) {
621 if (tmp
->dev
== dev
) {
628 write_unlock_bh(&atalk_routes_lock
);
630 if (atrtr_default
.dev
== dev
)
631 atrtr_set_default(NULL
);
634 /* Actually down the interface */
635 static inline void atalk_dev_down(struct net_device
*dev
)
637 atrtr_device_down(dev
); /* Remove all routes for the device */
638 aarp_device_down(dev
); /* Remove AARP entries for the device */
639 atif_drop_device(dev
); /* Remove the device */
643 * A device event has occurred. Watch for devices going down and
644 * delete our use of them (iface and route).
646 static int ddp_device_event(struct notifier_block
*this, unsigned long event
,
649 struct net_device
*dev
= ptr
;
651 if (!net_eq(dev_net(dev
), &init_net
))
654 if (event
== NETDEV_DOWN
)
655 /* Discard any use of this */
661 /* ioctl calls. Shouldn't even need touching */
662 /* Device configuration ioctl calls */
663 static int atif_ioctl(int cmd
, void __user
*arg
)
665 static char aarp_mcast
[6] = { 0x09, 0x00, 0x00, 0xFF, 0xFF, 0xFF };
667 struct atalk_netrange
*nr
;
668 struct sockaddr_at
*sa
;
669 struct net_device
*dev
;
670 struct atalk_iface
*atif
;
673 struct rtentry rtdef
;
676 if (copy_from_user(&atreq
, arg
, sizeof(atreq
)))
679 dev
= __dev_get_by_name(&init_net
, atreq
.ifr_name
);
683 sa
= (struct sockaddr_at
*)&atreq
.ifr_addr
;
684 atif
= atalk_find_dev(dev
);
688 if (!capable(CAP_NET_ADMIN
))
690 if (sa
->sat_family
!= AF_APPLETALK
)
692 if (dev
->type
!= ARPHRD_ETHER
&&
693 dev
->type
!= ARPHRD_LOOPBACK
&&
694 dev
->type
!= ARPHRD_LOCALTLK
&&
695 dev
->type
!= ARPHRD_PPP
)
696 return -EPROTONOSUPPORT
;
698 nr
= (struct atalk_netrange
*)&sa
->sat_zero
[0];
702 * if this is a point-to-point iface, and we already
703 * have an iface for this AppleTalk address, then we
704 * should not add a route
706 if ((dev
->flags
& IFF_POINTOPOINT
) &&
707 atalk_find_interface(sa
->sat_addr
.s_net
,
708 sa
->sat_addr
.s_node
)) {
709 printk(KERN_DEBUG
"AppleTalk: point-to-point "
710 "interface added with "
711 "existing address\n");
716 * Phase 1 is fine on LocalTalk but we don't do
717 * EtherTalk phase 1. Anyone wanting to add it go ahead.
719 if (dev
->type
== ARPHRD_ETHER
&& nr
->nr_phase
!= 2)
720 return -EPROTONOSUPPORT
;
721 if (sa
->sat_addr
.s_node
== ATADDR_BCAST
||
722 sa
->sat_addr
.s_node
== 254)
725 /* Already setting address */
726 if (atif
->status
& ATIF_PROBE
)
729 atif
->address
.s_net
= sa
->sat_addr
.s_net
;
730 atif
->address
.s_node
= sa
->sat_addr
.s_node
;
731 atrtr_device_down(dev
); /* Flush old routes */
733 atif
= atif_add_device(dev
, &sa
->sat_addr
);
740 * Check if the chosen address is used. If so we
741 * error and atalkd will try another.
744 if (!(dev
->flags
& IFF_LOOPBACK
) &&
745 !(dev
->flags
& IFF_POINTOPOINT
) &&
746 atif_probe_device(atif
) < 0) {
747 atif_drop_device(dev
);
751 /* Hey it worked - add the direct routes */
752 sa
= (struct sockaddr_at
*)&rtdef
.rt_gateway
;
753 sa
->sat_family
= AF_APPLETALK
;
754 sa
->sat_addr
.s_net
= atif
->address
.s_net
;
755 sa
->sat_addr
.s_node
= atif
->address
.s_node
;
756 sa
= (struct sockaddr_at
*)&rtdef
.rt_dst
;
757 rtdef
.rt_flags
= RTF_UP
;
758 sa
->sat_family
= AF_APPLETALK
;
759 sa
->sat_addr
.s_node
= ATADDR_ANYNODE
;
760 if (dev
->flags
& IFF_LOOPBACK
||
761 dev
->flags
& IFF_POINTOPOINT
)
762 rtdef
.rt_flags
|= RTF_HOST
;
764 /* Routerless initial state */
765 if (nr
->nr_firstnet
== htons(0) &&
766 nr
->nr_lastnet
== htons(0xFFFE)) {
767 sa
->sat_addr
.s_net
= atif
->address
.s_net
;
768 atrtr_create(&rtdef
, dev
);
769 atrtr_set_default(dev
);
771 limit
= ntohs(nr
->nr_lastnet
);
772 if (limit
- ntohs(nr
->nr_firstnet
) > 4096) {
773 printk(KERN_WARNING
"Too many routes/"
778 for (ct
= ntohs(nr
->nr_firstnet
);
780 sa
->sat_addr
.s_net
= htons(ct
);
781 atrtr_create(&rtdef
, dev
);
784 dev_mc_add(dev
, aarp_mcast
, 6, 1);
789 return -EADDRNOTAVAIL
;
791 sa
->sat_family
= AF_APPLETALK
;
792 sa
->sat_addr
= atif
->address
;
797 return -EADDRNOTAVAIL
;
799 sa
->sat_family
= AF_APPLETALK
;
800 sa
->sat_addr
.s_net
= atif
->address
.s_net
;
801 sa
->sat_addr
.s_node
= ATADDR_BCAST
;
804 case SIOCATALKDIFADDR
:
806 if (!capable(CAP_NET_ADMIN
))
808 if (sa
->sat_family
!= AF_APPLETALK
)
814 if (!capable(CAP_NET_ADMIN
))
816 if (sa
->sat_family
!= AF_APPLETALK
)
819 * for now, we only support proxy AARP on ELAP;
820 * we should be able to do it for LocalTalk, too.
822 if (dev
->type
!= ARPHRD_ETHER
)
823 return -EPROTONOSUPPORT
;
826 * atif points to the current interface on this network;
827 * we aren't concerned about its current status (at
828 * least for now), but it has all the settings about
829 * the network we're going to probe. Consequently, it
833 return -EADDRNOTAVAIL
;
835 nr
= (struct atalk_netrange
*)&(atif
->nets
);
837 * Phase 1 is fine on Localtalk but we don't do
838 * Ethertalk phase 1. Anyone wanting to add it go ahead.
840 if (dev
->type
== ARPHRD_ETHER
&& nr
->nr_phase
!= 2)
841 return -EPROTONOSUPPORT
;
843 if (sa
->sat_addr
.s_node
== ATADDR_BCAST
||
844 sa
->sat_addr
.s_node
== 254)
848 * Check if the chosen address is used. If so we
849 * error and ATCP will try another.
851 if (atif_proxy_probe_device(atif
, &(sa
->sat_addr
)) < 0)
855 * We now have an address on the local network, and
856 * the AARP code will defend it for us until we take it
857 * down. We don't set up any routes right now, because
858 * ATCP will install them manually via SIOCADDRT.
863 if (!capable(CAP_NET_ADMIN
))
865 if (sa
->sat_family
!= AF_APPLETALK
)
868 return -EADDRNOTAVAIL
;
870 /* give to aarp module to remove proxy entry */
871 aarp_proxy_remove(atif
->dev
, &(sa
->sat_addr
));
875 return copy_to_user(arg
, &atreq
, sizeof(atreq
)) ? -EFAULT
: 0;
878 /* Routing ioctl() calls */
879 static int atrtr_ioctl(unsigned int cmd
, void __user
*arg
)
883 if (copy_from_user(&rt
, arg
, sizeof(rt
)))
888 if (rt
.rt_dst
.sa_family
!= AF_APPLETALK
)
890 return atrtr_delete(&((struct sockaddr_at
*)
891 &rt
.rt_dst
)->sat_addr
);
894 struct net_device
*dev
= NULL
;
897 if (copy_from_user(name
, rt
.rt_dev
, IFNAMSIZ
-1))
899 name
[IFNAMSIZ
-1] = '\0';
900 dev
= __dev_get_by_name(&init_net
, name
);
904 return atrtr_create(&rt
, dev
);
910 /**************************************************************************\
912 * Handling for system calls applied via the various interfaces to an *
913 * AppleTalk socket object. *
915 \**************************************************************************/
918 * Checksum: This is 'optional'. It's quite likely also a good
919 * candidate for assembler hackery 8)
921 static unsigned long atalk_sum_partial(const unsigned char *data
,
922 int len
, unsigned long sum
)
924 /* This ought to be unwrapped neatly. I'll trust gcc for now */
932 /* Checksum skb data -- similar to skb_checksum */
933 static unsigned long atalk_sum_skb(const struct sk_buff
*skb
, int offset
,
934 int len
, unsigned long sum
)
936 int start
= skb_headlen(skb
);
937 struct sk_buff
*frag_iter
;
940 /* checksum stuff in header space */
941 if ( (copy
= start
- offset
) > 0) {
944 sum
= atalk_sum_partial(skb
->data
+ offset
, copy
, sum
);
945 if ( (len
-= copy
) == 0)
951 /* checksum stuff in frags */
952 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++) {
955 WARN_ON(start
> offset
+ len
);
957 end
= start
+ skb_shinfo(skb
)->frags
[i
].size
;
958 if ((copy
= end
- offset
) > 0) {
960 skb_frag_t
*frag
= &skb_shinfo(skb
)->frags
[i
];
964 vaddr
= kmap_skb_frag(frag
);
965 sum
= atalk_sum_partial(vaddr
+ frag
->page_offset
+
966 offset
- start
, copy
, sum
);
967 kunmap_skb_frag(vaddr
);
976 skb_walk_frags(skb
, frag_iter
) {
979 WARN_ON(start
> offset
+ len
);
981 end
= start
+ frag_iter
->len
;
982 if ((copy
= end
- offset
) > 0) {
985 sum
= atalk_sum_skb(frag_iter
, offset
- start
,
987 if ((len
-= copy
) == 0)
999 static __be16
atalk_checksum(const struct sk_buff
*skb
, int len
)
1003 /* skip header 4 bytes */
1004 sum
= atalk_sum_skb(skb
, 4, len
-4, 0);
1006 /* Use 0xFFFF for 0. 0 itself means none */
1007 return sum
? htons((unsigned short)sum
) : htons(0xFFFF);
1010 static struct proto ddp_proto
= {
1012 .owner
= THIS_MODULE
,
1013 .obj_size
= sizeof(struct atalk_sock
),
1017 * Create a socket. Initialise the socket, blank the addresses
1020 static int atalk_create(struct net
*net
, struct socket
*sock
, int protocol
,
1024 int rc
= -ESOCKTNOSUPPORT
;
1026 if (!net_eq(net
, &init_net
))
1027 return -EAFNOSUPPORT
;
1030 * We permit SOCK_DGRAM and RAW is an extension. It is trivial to do
1031 * and gives you the full ELAP frame. Should be handy for CAP 8)
1033 if (sock
->type
!= SOCK_RAW
&& sock
->type
!= SOCK_DGRAM
)
1036 sk
= sk_alloc(net
, PF_APPLETALK
, GFP_KERNEL
, &ddp_proto
);
1040 sock
->ops
= &atalk_dgram_ops
;
1041 sock_init_data(sock
, sk
);
1043 /* Checksums on by default */
1044 sock_set_flag(sk
, SOCK_ZAPPED
);
1049 /* Free a socket. No work needed */
1050 static int atalk_release(struct socket
*sock
)
1052 struct sock
*sk
= sock
->sk
;
1058 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
;
1084 struct hlist_node
*node
;
1086 sk_for_each(s
, node
, &atalk_sockets
) {
1087 struct atalk_sock
*at
= at_sk(s
);
1089 if (at
->src_net
== sat
->sat_addr
.s_net
&&
1090 at
->src_node
== sat
->sat_addr
.s_node
&&
1091 at
->src_port
== sat
->sat_port
)
1095 /* Wheee, it's free, assign and insert. */
1096 __atalk_insert_socket(sk
);
1097 at_sk(sk
)->src_port
= sat
->sat_port
;
1106 write_unlock_bh(&atalk_sockets_lock
);
1110 static int atalk_autobind(struct sock
*sk
)
1112 struct atalk_sock
*at
= at_sk(sk
);
1113 struct sockaddr_at sat
;
1114 struct atalk_addr
*ap
= atalk_find_primary();
1115 int n
= -EADDRNOTAVAIL
;
1117 if (!ap
|| ap
->s_net
== htons(ATADDR_ANYNET
))
1120 at
->src_net
= sat
.sat_addr
.s_net
= ap
->s_net
;
1121 at
->src_node
= sat
.sat_addr
.s_node
= ap
->s_node
;
1123 n
= atalk_pick_and_bind_port(sk
, &sat
);
1125 sock_reset_flag(sk
, SOCK_ZAPPED
);
1130 /* Set the address 'our end' of the connection */
1131 static int atalk_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int addr_len
)
1133 struct sockaddr_at
*addr
= (struct sockaddr_at
*)uaddr
;
1134 struct sock
*sk
= sock
->sk
;
1135 struct atalk_sock
*at
= at_sk(sk
);
1138 if (!sock_flag(sk
, SOCK_ZAPPED
) ||
1139 addr_len
!= sizeof(struct sockaddr_at
))
1142 if (addr
->sat_family
!= AF_APPLETALK
)
1143 return -EAFNOSUPPORT
;
1146 if (addr
->sat_addr
.s_net
== htons(ATADDR_ANYNET
)) {
1147 struct atalk_addr
*ap
= atalk_find_primary();
1149 err
= -EADDRNOTAVAIL
;
1153 at
->src_net
= addr
->sat_addr
.s_net
= ap
->s_net
;
1154 at
->src_node
= addr
->sat_addr
.s_node
= ap
->s_node
;
1156 err
= -EADDRNOTAVAIL
;
1157 if (!atalk_find_interface(addr
->sat_addr
.s_net
,
1158 addr
->sat_addr
.s_node
))
1161 at
->src_net
= addr
->sat_addr
.s_net
;
1162 at
->src_node
= addr
->sat_addr
.s_node
;
1165 if (addr
->sat_port
== ATADDR_ANYPORT
) {
1166 err
= atalk_pick_and_bind_port(sk
, addr
);
1171 at
->src_port
= addr
->sat_port
;
1174 if (atalk_find_or_insert_socket(sk
, addr
))
1178 sock_reset_flag(sk
, SOCK_ZAPPED
);
1185 /* Set the address we talk to */
1186 static int atalk_connect(struct socket
*sock
, struct sockaddr
*uaddr
,
1187 int addr_len
, int flags
)
1189 struct sock
*sk
= sock
->sk
;
1190 struct atalk_sock
*at
= at_sk(sk
);
1191 struct sockaddr_at
*addr
;
1194 sk
->sk_state
= TCP_CLOSE
;
1195 sock
->state
= SS_UNCONNECTED
;
1197 if (addr_len
!= sizeof(*addr
))
1200 addr
= (struct sockaddr_at
*)uaddr
;
1202 if (addr
->sat_family
!= AF_APPLETALK
)
1203 return -EAFNOSUPPORT
;
1205 if (addr
->sat_addr
.s_node
== ATADDR_BCAST
&&
1206 !sock_flag(sk
, SOCK_BROADCAST
)) {
1208 printk(KERN_WARNING
"%s is broken and did not set "
1209 "SO_BROADCAST. It will break when 2.2 is "
1219 if (sock_flag(sk
, SOCK_ZAPPED
))
1220 if (atalk_autobind(sk
) < 0)
1224 if (!atrtr_get_dev(&addr
->sat_addr
))
1227 at
->dest_port
= addr
->sat_port
;
1228 at
->dest_net
= addr
->sat_addr
.s_net
;
1229 at
->dest_node
= addr
->sat_addr
.s_node
;
1231 sock
->state
= SS_CONNECTED
;
1232 sk
->sk_state
= TCP_ESTABLISHED
;
1240 * Find the name of an AppleTalk socket. Just copy the right
1241 * fields into the sockaddr.
1243 static int atalk_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
1244 int *uaddr_len
, int peer
)
1246 struct sockaddr_at sat
;
1247 struct sock
*sk
= sock
->sk
;
1248 struct atalk_sock
*at
= at_sk(sk
);
1253 if (sock_flag(sk
, SOCK_ZAPPED
))
1254 if (atalk_autobind(sk
) < 0)
1257 *uaddr_len
= sizeof(struct sockaddr_at
);
1258 memset(&sat
.sat_zero
, 0, sizeof(sat
.sat_zero
));
1262 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1265 sat
.sat_addr
.s_net
= at
->dest_net
;
1266 sat
.sat_addr
.s_node
= at
->dest_node
;
1267 sat
.sat_port
= at
->dest_port
;
1269 sat
.sat_addr
.s_net
= at
->src_net
;
1270 sat
.sat_addr
.s_node
= at
->src_node
;
1271 sat
.sat_port
= at
->src_port
;
1275 sat
.sat_family
= AF_APPLETALK
;
1276 memcpy(uaddr
, &sat
, sizeof(sat
));
1283 static unsigned int atalk_poll(struct file
*file
, struct socket
*sock
,
1288 err
= datagram_poll(file
, sock
, wait
);
1293 #if defined(CONFIG_IPDDP) || defined(CONFIG_IPDDP_MODULE)
1294 static __inline__
int is_ip_over_ddp(struct sk_buff
*skb
)
1296 return skb
->data
[12] == 22;
1299 static int handle_ip_over_ddp(struct sk_buff
*skb
)
1301 struct net_device
*dev
= __dev_get_by_name(&init_net
, "ipddp0");
1302 struct net_device_stats
*stats
;
1304 /* This needs to be able to handle ipddp"N" devices */
1310 skb
->protocol
= htons(ETH_P_IP
);
1313 skb_reset_transport_header(skb
);
1315 stats
= netdev_priv(dev
);
1316 stats
->rx_packets
++;
1317 stats
->rx_bytes
+= skb
->len
+ 13;
1318 return netif_rx(skb
); /* Send the SKB up to a higher place. */
1321 /* make it easy for gcc to optimize this test out, i.e. kill the code */
1322 #define is_ip_over_ddp(skb) 0
1323 #define handle_ip_over_ddp(skb) 0
1326 static int atalk_route_packet(struct sk_buff
*skb
, struct net_device
*dev
,
1327 struct ddpehdr
*ddp
, __u16 len_hops
, int origlen
)
1329 struct atalk_route
*rt
;
1330 struct atalk_addr ta
;
1333 * Don't route multicast, etc., packets, or packets sent to "this
1336 if (skb
->pkt_type
!= PACKET_HOST
|| !ddp
->deh_dnet
) {
1340 * Can it ever happen that a packet is from a PPP iface and
1341 * needs to be broadcast onto the default network?
1343 if (dev
->type
== ARPHRD_PPP
)
1344 printk(KERN_DEBUG
"AppleTalk: didn't forward broadcast "
1345 "packet received from PPP iface\n");
1349 ta
.s_net
= ddp
->deh_dnet
;
1350 ta
.s_node
= ddp
->deh_dnode
;
1352 /* Route the packet */
1353 rt
= atrtr_find(&ta
);
1354 /* increment hops count */
1355 len_hops
+= 1 << 10;
1356 if (!rt
|| !(len_hops
& (15 << 10)))
1359 /* FIXME: use skb->cb to be able to use shared skbs */
1362 * Route goes through another gateway, so set the target to the
1366 if (rt
->flags
& RTF_GATEWAY
) {
1367 ta
.s_net
= rt
->gateway
.s_net
;
1368 ta
.s_node
= rt
->gateway
.s_node
;
1371 /* Fix up skb->len field */
1372 skb_trim(skb
, min_t(unsigned int, origlen
,
1373 (rt
->dev
->hard_header_len
+
1374 ddp_dl
->header_length
+ (len_hops
& 1023))));
1376 /* FIXME: use skb->cb to be able to use shared skbs */
1377 ddp
->deh_len_hops
= htons(len_hops
);
1380 * Send the buffer onwards
1382 * Now we must always be careful. If it's come from LocalTalk to
1383 * EtherTalk it might not fit
1385 * Order matters here: If a packet has to be copied to make a new
1386 * headroom (rare hopefully) then it won't need unsharing.
1388 * Note. ddp-> becomes invalid at the realloc.
1390 if (skb_headroom(skb
) < 22) {
1391 /* 22 bytes - 12 ether, 2 len, 3 802.2 5 snap */
1392 struct sk_buff
*nskb
= skb_realloc_headroom(skb
, 32);
1396 skb
= skb_unshare(skb
, GFP_ATOMIC
);
1399 * If the buffer didn't vanish into the lack of space bitbucket we can
1405 if (aarp_send_ddp(rt
->dev
, skb
, &ta
, NULL
) == NET_XMIT_DROP
)
1407 return NET_RX_SUCCESS
;
1415 * atalk_rcv - Receive a packet (in skb) from device dev
1416 * @skb - packet received
1417 * @dev - network device where the packet comes from
1420 * Receive a packet (in skb) from device dev. This has come from the SNAP
1421 * decoder, and on entry skb->transport_header is the DDP header, skb->len
1422 * is the DDP header, skb->len is the DDP length. The physical headers
1423 * have been extracted. PPP should probably pass frames marked as for this
1424 * layer. [ie ARPHRD_ETHERTALK]
1426 static int atalk_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
1427 struct packet_type
*pt
, struct net_device
*orig_dev
)
1429 struct ddpehdr
*ddp
;
1431 struct atalk_iface
*atif
;
1432 struct sockaddr_at tosat
;
1436 if (!net_eq(dev_net(dev
), &init_net
))
1439 /* Don't mangle buffer if shared */
1440 if (!(skb
= skb_share_check(skb
, GFP_ATOMIC
)))
1443 /* Size check and make sure header is contiguous */
1444 if (!pskb_may_pull(skb
, sizeof(*ddp
)))
1449 len_hops
= ntohs(ddp
->deh_len_hops
);
1451 /* Trim buffer in case of stray trailing data */
1453 skb_trim(skb
, min_t(unsigned int, skb
->len
, len_hops
& 1023));
1456 * Size check to see if ddp->deh_len was crap
1457 * (Otherwise we'll detonate most spectacularly
1458 * in the middle of atalk_checksum() or recvmsg()).
1460 if (skb
->len
< sizeof(*ddp
) || skb
->len
< (len_hops
& 1023)) {
1461 pr_debug("AppleTalk: dropping corrupted frame (deh_len=%u, "
1462 "skb->len=%u)\n", len_hops
& 1023, skb
->len
);
1467 * Any checksums. Note we don't do htons() on this == is assumed to be
1468 * valid for net byte orders all over the networking code...
1471 atalk_checksum(skb
, len_hops
& 1023) != ddp
->deh_sum
)
1472 /* Not a valid AppleTalk frame - dustbin time */
1475 /* Check the packet is aimed at us */
1476 if (!ddp
->deh_dnet
) /* Net 0 is 'this network' */
1477 atif
= atalk_find_anynet(ddp
->deh_dnode
, dev
);
1479 atif
= atalk_find_interface(ddp
->deh_dnet
, ddp
->deh_dnode
);
1482 /* Not ours, so we route the packet via the correct
1485 return atalk_route_packet(skb
, dev
, ddp
, len_hops
, origlen
);
1488 /* if IP over DDP is not selected this code will be optimized out */
1489 if (is_ip_over_ddp(skb
))
1490 return handle_ip_over_ddp(skb
);
1492 * Which socket - atalk_search_socket() looks for a *full match*
1493 * of the <net, node, port> tuple.
1495 tosat
.sat_addr
.s_net
= ddp
->deh_dnet
;
1496 tosat
.sat_addr
.s_node
= ddp
->deh_dnode
;
1497 tosat
.sat_port
= ddp
->deh_dport
;
1499 sock
= atalk_search_socket(&tosat
, atif
);
1500 if (!sock
) /* But not one of our sockets */
1503 /* Queue packet (standard) */
1506 if (sock_queue_rcv_skb(sock
, skb
) < 0)
1509 return NET_RX_SUCCESS
;
1519 * Receive a LocalTalk frame. We make some demands on the caller here.
1520 * Caller must provide enough headroom on the packet to pull the short
1521 * header and append a long one.
1523 static int ltalk_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
1524 struct packet_type
*pt
, struct net_device
*orig_dev
)
1526 if (!net_eq(dev_net(dev
), &init_net
))
1529 /* Expand any short form frames */
1530 if (skb_mac_header(skb
)[2] == 1) {
1531 struct ddpehdr
*ddp
;
1532 /* Find our address */
1533 struct atalk_addr
*ap
= atalk_find_dev_addr(dev
);
1535 if (!ap
|| skb
->len
< sizeof(__be16
) || skb
->len
> 1023)
1538 /* Don't mangle buffer if shared */
1539 if (!(skb
= skb_share_check(skb
, GFP_ATOMIC
)))
1543 * The push leaves us with a ddephdr not an shdr, and
1544 * handily the port bytes in the right place preset.
1546 ddp
= (struct ddpehdr
*) skb_push(skb
, sizeof(*ddp
) - 4);
1548 /* Now fill in the long header */
1551 * These two first. The mac overlays the new source/dest
1552 * network information so we MUST copy these before
1553 * we write the network numbers !
1556 ddp
->deh_dnode
= skb_mac_header(skb
)[0]; /* From physical header */
1557 ddp
->deh_snode
= skb_mac_header(skb
)[1]; /* From physical header */
1559 ddp
->deh_dnet
= ap
->s_net
; /* Network number */
1560 ddp
->deh_snet
= ap
->s_net
;
1561 ddp
->deh_sum
= 0; /* No checksum */
1563 * Not sure about this bit...
1565 /* Non routable, so force a drop if we slip up later */
1566 ddp
->deh_len_hops
= htons(skb
->len
+ (DDP_MAXHOPS
<< 10));
1568 skb_reset_transport_header(skb
);
1570 return atalk_rcv(skb
, dev
, pt
, orig_dev
);
1576 static int atalk_sendmsg(struct kiocb
*iocb
, struct socket
*sock
, struct msghdr
*msg
,
1579 struct sock
*sk
= sock
->sk
;
1580 struct atalk_sock
*at
= at_sk(sk
);
1581 struct sockaddr_at
*usat
= (struct sockaddr_at
*)msg
->msg_name
;
1582 int flags
= msg
->msg_flags
;
1584 struct sockaddr_at local_satalk
, gsat
;
1585 struct sk_buff
*skb
;
1586 struct net_device
*dev
;
1587 struct ddpehdr
*ddp
;
1589 struct atalk_route
*rt
;
1592 if (flags
& ~(MSG_DONTWAIT
|MSG_CMSG_COMPAT
))
1595 if (len
> DDP_MAXSZ
)
1601 if (sock_flag(sk
, SOCK_ZAPPED
))
1602 if (atalk_autobind(sk
) < 0)
1606 if (msg
->msg_namelen
< sizeof(*usat
) ||
1607 usat
->sat_family
!= AF_APPLETALK
)
1611 /* netatalk didn't implement this check */
1612 if (usat
->sat_addr
.s_node
== ATADDR_BCAST
&&
1613 !sock_flag(sk
, SOCK_BROADCAST
)) {
1618 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1620 usat
= &local_satalk
;
1621 usat
->sat_family
= AF_APPLETALK
;
1622 usat
->sat_port
= at
->dest_port
;
1623 usat
->sat_addr
.s_node
= at
->dest_node
;
1624 usat
->sat_addr
.s_net
= at
->dest_net
;
1627 /* Build a packet */
1628 SOCK_DEBUG(sk
, "SK %p: Got address.\n", sk
);
1631 size
= sizeof(struct ddpehdr
) + len
+ ddp_dl
->header_length
;
1633 if (usat
->sat_addr
.s_net
|| usat
->sat_addr
.s_node
== ATADDR_ANYNODE
) {
1634 rt
= atrtr_find(&usat
->sat_addr
);
1636 struct atalk_addr at_hint
;
1639 at_hint
.s_net
= at
->src_net
;
1641 rt
= atrtr_find(&at_hint
);
1649 SOCK_DEBUG(sk
, "SK %p: Size needed %d, device %s\n",
1650 sk
, size
, dev
->name
);
1652 size
+= dev
->hard_header_len
;
1653 skb
= sock_alloc_send_skb(sk
, size
, (flags
& MSG_DONTWAIT
), &err
);
1658 skb_reserve(skb
, ddp_dl
->header_length
);
1659 skb_reserve(skb
, dev
->hard_header_len
);
1662 SOCK_DEBUG(sk
, "SK %p: Begin build.\n", sk
);
1664 ddp
= (struct ddpehdr
*)skb_put(skb
, sizeof(struct ddpehdr
));
1665 ddp
->deh_len_hops
= htons(len
+ sizeof(*ddp
));
1666 ddp
->deh_dnet
= usat
->sat_addr
.s_net
;
1667 ddp
->deh_snet
= at
->src_net
;
1668 ddp
->deh_dnode
= usat
->sat_addr
.s_node
;
1669 ddp
->deh_snode
= at
->src_node
;
1670 ddp
->deh_dport
= usat
->sat_port
;
1671 ddp
->deh_sport
= at
->src_port
;
1673 SOCK_DEBUG(sk
, "SK %p: Copy user data (%Zd bytes).\n", sk
, len
);
1675 err
= memcpy_fromiovec(skb_put(skb
, len
), msg
->msg_iov
, len
);
1682 if (sk
->sk_no_check
== 1)
1685 ddp
->deh_sum
= atalk_checksum(skb
, len
+ sizeof(*ddp
));
1688 * Loopback broadcast packets to non gateway targets (ie routes
1689 * to group we are in)
1691 if (ddp
->deh_dnode
== ATADDR_BCAST
&&
1692 !(rt
->flags
& RTF_GATEWAY
) && !(dev
->flags
& IFF_LOOPBACK
)) {
1693 struct sk_buff
*skb2
= skb_copy(skb
, GFP_KERNEL
);
1697 SOCK_DEBUG(sk
, "SK %p: send out(copy).\n", sk
);
1699 * If it fails it is queued/sent above in the aarp queue
1701 aarp_send_ddp(dev
, skb2
, &usat
->sat_addr
, NULL
);
1705 if (dev
->flags
& IFF_LOOPBACK
|| loopback
) {
1706 SOCK_DEBUG(sk
, "SK %p: Loop back.\n", sk
);
1709 if (ddp
->deh_dnode
== ATADDR_BCAST
) {
1710 struct atalk_addr at_lo
;
1715 rt
= atrtr_find(&at_lo
);
1724 ddp_dl
->request(ddp_dl
, skb
, dev
->dev_addr
);
1726 SOCK_DEBUG(sk
, "SK %p: send out.\n", sk
);
1727 if (rt
->flags
& RTF_GATEWAY
) {
1728 gsat
.sat_addr
= rt
->gateway
;
1733 * If it fails it is queued/sent above in the aarp queue
1735 aarp_send_ddp(dev
, skb
, &usat
->sat_addr
, NULL
);
1737 SOCK_DEBUG(sk
, "SK %p: Done write (%Zd).\n", sk
, len
);
1744 static int atalk_recvmsg(struct kiocb
*iocb
, struct socket
*sock
, struct msghdr
*msg
,
1745 size_t size
, int flags
)
1747 struct sock
*sk
= sock
->sk
;
1748 struct sockaddr_at
*sat
= (struct sockaddr_at
*)msg
->msg_name
;
1749 struct ddpehdr
*ddp
;
1753 struct sk_buff
*skb
;
1756 skb
= skb_recv_datagram(sk
, flags
& ~MSG_DONTWAIT
,
1757 flags
& MSG_DONTWAIT
, &err
);
1761 /* FIXME: use skb->cb to be able to use shared skbs */
1763 copied
= ntohs(ddp
->deh_len_hops
) & 1023;
1765 if (sk
->sk_type
!= SOCK_RAW
) {
1766 offset
= sizeof(*ddp
);
1770 if (copied
> size
) {
1772 msg
->msg_flags
|= MSG_TRUNC
;
1774 err
= skb_copy_datagram_iovec(skb
, offset
, msg
->msg_iov
, copied
);
1778 sat
->sat_family
= AF_APPLETALK
;
1779 sat
->sat_port
= ddp
->deh_sport
;
1780 sat
->sat_addr
.s_node
= ddp
->deh_snode
;
1781 sat
->sat_addr
.s_net
= ddp
->deh_snet
;
1783 msg
->msg_namelen
= sizeof(*sat
);
1786 skb_free_datagram(sk
, skb
); /* Free the datagram. */
1790 return err
? : copied
;
1795 * AppleTalk ioctl calls.
1797 static int atalk_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1799 int rc
= -ENOIOCTLCMD
;
1800 struct sock
*sk
= sock
->sk
;
1801 void __user
*argp
= (void __user
*)arg
;
1804 /* Protocol layer */
1806 long amount
= sk
->sk_sndbuf
- sk_wmem_alloc_get(sk
);
1810 rc
= put_user(amount
, (int __user
*)argp
);
1815 * These two are safe on a single CPU system as only
1816 * user tasks fiddle here
1818 struct sk_buff
*skb
= skb_peek(&sk
->sk_receive_queue
);
1822 amount
= skb
->len
- sizeof(struct ddpehdr
);
1823 rc
= put_user(amount
, (int __user
*)argp
);
1827 rc
= sock_get_timestamp(sk
, argp
);
1830 rc
= sock_get_timestampns(sk
, argp
);
1836 if (capable(CAP_NET_ADMIN
))
1837 rc
= atrtr_ioctl(cmd
, argp
);
1842 case SIOCGIFBRDADDR
:
1843 case SIOCATALKDIFADDR
:
1845 case SIOCSARP
: /* proxy AARP */
1846 case SIOCDARP
: /* proxy AARP */
1848 rc
= atif_ioctl(cmd
, argp
);
1857 #ifdef CONFIG_COMPAT
1858 static int atalk_compat_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1861 * SIOCATALKDIFADDR is a SIOCPROTOPRIVATE ioctl number, so we
1862 * cannot handle it in common code. The data we access if ifreq
1863 * here is compatible, so we can simply call the native
1866 if (cmd
== SIOCATALKDIFADDR
)
1867 return atalk_ioctl(sock
, cmd
, (unsigned long)compat_ptr(arg
));
1869 return -ENOIOCTLCMD
;
1874 static const struct net_proto_family atalk_family_ops
= {
1875 .family
= PF_APPLETALK
,
1876 .create
= atalk_create
,
1877 .owner
= THIS_MODULE
,
1880 static const struct proto_ops atalk_dgram_ops
= {
1881 .family
= PF_APPLETALK
,
1882 .owner
= THIS_MODULE
,
1883 .release
= atalk_release
,
1885 .connect
= atalk_connect
,
1886 .socketpair
= sock_no_socketpair
,
1887 .accept
= sock_no_accept
,
1888 .getname
= atalk_getname
,
1890 .ioctl
= atalk_ioctl
,
1891 #ifdef CONFIG_COMPAT
1892 .compat_ioctl
= atalk_compat_ioctl
,
1894 .listen
= sock_no_listen
,
1895 .shutdown
= sock_no_shutdown
,
1896 .setsockopt
= sock_no_setsockopt
,
1897 .getsockopt
= sock_no_getsockopt
,
1898 .sendmsg
= atalk_sendmsg
,
1899 .recvmsg
= atalk_recvmsg
,
1900 .mmap
= sock_no_mmap
,
1901 .sendpage
= sock_no_sendpage
,
1904 static struct notifier_block ddp_notifier
= {
1905 .notifier_call
= ddp_device_event
,
1908 static struct packet_type ltalk_packet_type __read_mostly
= {
1909 .type
= cpu_to_be16(ETH_P_LOCALTALK
),
1913 static struct packet_type ppptalk_packet_type __read_mostly
= {
1914 .type
= cpu_to_be16(ETH_P_PPPTALK
),
1918 static unsigned char ddp_snap_id
[] = { 0x08, 0x00, 0x07, 0x80, 0x9B };
1920 /* Export symbols for use by drivers when AppleTalk is a module */
1921 EXPORT_SYMBOL(atrtr_get_dev
);
1922 EXPORT_SYMBOL(atalk_find_dev_addr
);
1924 static const char atalk_err_snap
[] __initconst
=
1925 KERN_CRIT
"Unable to register DDP with SNAP.\n";
1927 /* Called by proto.c on kernel start up */
1928 static int __init
atalk_init(void)
1930 int rc
= proto_register(&ddp_proto
, 0);
1935 (void)sock_register(&atalk_family_ops
);
1936 ddp_dl
= register_snap_client(ddp_snap_id
, atalk_rcv
);
1938 printk(atalk_err_snap
);
1940 dev_add_pack(<alk_packet_type
);
1941 dev_add_pack(&ppptalk_packet_type
);
1943 register_netdevice_notifier(&ddp_notifier
);
1946 atalk_register_sysctl();
1950 module_init(atalk_init
);
1953 * No explicit module reference count manipulation is needed in the
1954 * protocol. Socket layer sets module reference count for us
1955 * and interfaces reference counting is done
1956 * by the network device layer.
1958 * Ergo, before the AppleTalk module can be removed, all AppleTalk
1959 * sockets be closed from user space.
1961 static void __exit
atalk_exit(void)
1963 #ifdef CONFIG_SYSCTL
1964 atalk_unregister_sysctl();
1965 #endif /* CONFIG_SYSCTL */
1967 aarp_cleanup_module(); /* General aarp clean-up. */
1968 unregister_netdevice_notifier(&ddp_notifier
);
1969 dev_remove_pack(<alk_packet_type
);
1970 dev_remove_pack(&ppptalk_packet_type
);
1971 unregister_snap_client(ddp_dl
);
1972 sock_unregister(PF_APPLETALK
);
1973 proto_unregister(&ddp_proto
);
1975 module_exit(atalk_exit
);
1977 MODULE_LICENSE("GPL");
1978 MODULE_AUTHOR("Alan Cox <alan@lxorguk.ukuu.org.uk>");
1979 MODULE_DESCRIPTION("AppleTalk 0.20\n");
1980 MODULE_ALIAS_NETPROTO(PF_APPLETALK
);