← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to net/appletalk/ddp.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

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