projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
icplus: fix interrupt for IC+ 101A/G and 1001LF
[deliverable/linux.git] / net / ax25 / af_ax25.c
CommitLineData
1da177e4
LT		 1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
8 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
9 * Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk)
10 * Copyright (C) Steven Whitehouse GW7RRM (stevew@acm.org)
11 * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
12 * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
13 * Copyright (C) Hans Alblas PE1AYX (hans@esrac.ele.tue.nl)
14 * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
15 */
4fc268d2 16#include <linux/capability.h>
1da177e4
LT		 17#include <linux/module.h>
18#include <linux/errno.h>
19#include <linux/types.h>
20#include <linux/socket.h>
21#include <linux/in.h>
22#include <linux/kernel.h>
23#include <linux/sched.h>
24#include <linux/timer.h>
25#include <linux/string.h>
1da177e4
LT		 26#include <linux/sockios.h>
27#include <linux/net.h>
5a0e3ad6 28#include <linux/slab.h>
1da177e4
LT		 29#include <net/ax25.h>
30#include <linux/inet.h>
31#include <linux/netdevice.h>
32#include <linux/if_arp.h>
33#include <linux/skbuff.h>
34#include <net/sock.h>
35#include <asm/uaccess.h>
1da177e4
LT		 36#include <linux/fcntl.h>
37#include <linux/termios.h> /* For TIOCINQ/OUTQ */
38#include <linux/mm.h>
39#include <linux/interrupt.h>
40#include <linux/notifier.h>
41#include <linux/proc_fs.h>
42#include <linux/stat.h>
43#include <linux/netfilter.h>
44#include <linux/sysctl.h>
45#include <linux/init.h>
46#include <linux/spinlock.h>
457c4cbc 47#include <net/net_namespace.h>
c752f073 48#include <net/tcp_states.h>
1da177e4
LT		 49#include <net/ip.h>
50#include <net/arp.h>
51
52
53
54HLIST_HEAD(ax25_list);
55DEFINE_SPINLOCK(ax25_list_lock);
56
90ddc4f0 57static const struct proto_ops ax25_proto_ops;
1da177e4
LT		 58
59static void ax25_free_sock(struct sock *sk)
60{
61 ax25_cb_put(ax25_sk(sk));
62}
63
64/*
65 * Socket removal during an interrupt is now safe.
66 */
67static void ax25_cb_del(ax25_cb *ax25)
68{
69 if (!hlist_unhashed(&ax25->ax25_node)) {
70 spin_lock_bh(&ax25_list_lock);
71 hlist_del_init(&ax25->ax25_node);
72 spin_unlock_bh(&ax25_list_lock);
73 ax25_cb_put(ax25);
74 }
75}
76
77/*
78 * Kill all bound sockets on a dropped device.
79 */
80static void ax25_kill_by_device(struct net_device *dev)
81{
82 ax25_dev *ax25_dev;
83 ax25_cb *s;
84 struct hlist_node *node;
85
86 if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
87 return;
88
89 spin_lock_bh(&ax25_list_lock);
ecd2ebde 90again:
1da177e4
LT		 91 ax25_for_each(s, node, &ax25_list) {
92 if (s->ax25_dev == ax25_dev) {
93 s->ax25_dev = NULL;
ecd2ebde 94 spin_unlock_bh(&ax25_list_lock);
1da177e4 95 ax25_disconnect(s, ENETUNREACH);
ecd2ebde
JP		 96 spin_lock_bh(&ax25_list_lock);
97
98 /* The entry could have been deleted from the
99 * list meanwhile and thus the next pointer is
100 * no longer valid. Play it safe and restart
101 * the scan. Forward progress is ensured
102 * because we set s->ax25_dev to NULL and we
103 * are never passed a NULL 'dev' argument.
104 */
105 goto again;
1da177e4
LT		 106 }
107 }
108 spin_unlock_bh(&ax25_list_lock);
109}
110
111/*
112 * Handle device status changes.
113 */
114static int ax25_device_event(struct notifier_block *this, unsigned long event,
115 void *ptr)
116{
117 struct net_device *dev = (struct net_device *)ptr;
118
721499e8 119 if (!net_eq(dev_net(dev), &init_net))
e9dc8653
EB		 120 return NOTIFY_DONE;
121
1da177e4
LT		 122 /* Reject non AX.25 devices */
123 if (dev->type != ARPHRD_AX25)
124 return NOTIFY_DONE;
125
126 switch (event) {
127 case NETDEV_UP:
128 ax25_dev_device_up(dev);
129 break;
130 case NETDEV_DOWN:
131 ax25_kill_by_device(dev);
132 ax25_rt_device_down(dev);
133 ax25_dev_device_down(dev);
134 break;
135 default:
136 break;
137 }
138
139 return NOTIFY_DONE;
140}
141
142/*
143 * Add a socket to the bound sockets list.
144 */
145void ax25_cb_add(ax25_cb *ax25)
146{
147 spin_lock_bh(&ax25_list_lock);
148 ax25_cb_hold(ax25);
149 hlist_add_head(&ax25->ax25_node, &ax25_list);
150 spin_unlock_bh(&ax25_list_lock);
151}
152
153/*
154 * Find a socket that wants to accept the SABM we have just
155 * received.
156 */
157struct sock *ax25_find_listener(ax25_address *addr, int digi,
158 struct net_device *dev, int type)
159{
160 ax25_cb *s;
161 struct hlist_node *node;
162
c19c4b9c 163 spin_lock(&ax25_list_lock);
1da177e4
LT		 164 ax25_for_each(s, node, &ax25_list) {
165 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
166 continue;
167 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
168 s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
169 /* If device is null we match any device */
170 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
171 sock_hold(s->sk);
c19c4b9c 172 spin_unlock(&ax25_list_lock);
1da177e4
LT		 173 return s->sk;
174 }
175 }
176 }
c19c4b9c 177 spin_unlock(&ax25_list_lock);
1da177e4
LT		 178
179 return NULL;
180}
181
182/*
183 * Find an AX.25 socket given both ends.
184 */
185struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
186 int type)
187{
188 struct sock *sk = NULL;
189 ax25_cb *s;
190 struct hlist_node *node;
191
c19c4b9c 192 spin_lock(&ax25_list_lock);
1da177e4
LT		 193 ax25_for_each(s, node, &ax25_list) {
194 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
195 !ax25cmp(&s->dest_addr, dest_addr) &&
196 s->sk->sk_type == type) {
197 sk = s->sk;
198 sock_hold(sk);
199 break;
200 }
201 }
202
c19c4b9c 203 spin_unlock(&ax25_list_lock);
1da177e4
LT		 204
205 return sk;
206}
207
208/*
209 * Find an AX.25 control block given both ends. It will only pick up
210 * floating AX.25 control blocks or non Raw socket bound control blocks.
211 */
212ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
213 ax25_digi *digi, struct net_device *dev)
214{
215 ax25_cb *s;
216 struct hlist_node *node;
217
218 spin_lock_bh(&ax25_list_lock);
219 ax25_for_each(s, node, &ax25_list) {
220 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
221 continue;
222 if (s->ax25_dev == NULL)
223 continue;
224 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
225 if (digi != NULL && digi->ndigi != 0) {
226 if (s->digipeat == NULL)
227 continue;
228 if (ax25digicmp(s->digipeat, digi) != 0)
229 continue;
230 } else {
231 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
232 continue;
233 }
234 ax25_cb_hold(s);
235 spin_unlock_bh(&ax25_list_lock);
236
237 return s;
238 }
239 }
240 spin_unlock_bh(&ax25_list_lock);
241
242 return NULL;
243}
244
70868eac
RB		 245EXPORT_SYMBOL(ax25_find_cb);
246
1da177e4
LT		 247void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
248{
249 ax25_cb *s;
250 struct sk_buff *copy;
251 struct hlist_node *node;
252
c19c4b9c 253 spin_lock(&ax25_list_lock);
1da177e4
LT		 254 ax25_for_each(s, node, &ax25_list) {
255 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
256 s->sk->sk_type == SOCK_RAW &&
257 s->sk->sk_protocol == proto &&
258 s->ax25_dev->dev == skb->dev &&
259 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
260 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
261 continue;
262 if (sock_queue_rcv_skb(s->sk, copy) != 0)
263 kfree_skb(copy);
264 }
265 }
c19c4b9c 266 spin_unlock(&ax25_list_lock);
1da177e4
LT		 267}
268
269/*
270 * Deferred destroy.
271 */
272void ax25_destroy_socket(ax25_cb *);
273
274/*
275 * Handler for deferred kills.
276 */
277static void ax25_destroy_timer(unsigned long data)
278{
279 ax25_cb *ax25=(ax25_cb *)data;
280 struct sock *sk;
528930b9 281
1da177e4 282 sk=ax25->sk;
528930b9 283
1da177e4
LT		 284 bh_lock_sock(sk);
285 sock_hold(sk);
286 ax25_destroy_socket(ax25);
287 bh_unlock_sock(sk);
288 sock_put(sk);
289}
290
291/*
292 * This is called from user mode and the timers. Thus it protects itself
293 * against interrupt users but doesn't worry about being called during
294 * work. Once it is removed from the queue no interrupt or bottom half
295 * will touch it and we are (fairly 8-) ) safe.
296 */
297void ax25_destroy_socket(ax25_cb *ax25)
298{
299 struct sk_buff *skb;
300
301 ax25_cb_del(ax25);
302
303 ax25_stop_heartbeat(ax25);
304 ax25_stop_t1timer(ax25);
305 ax25_stop_t2timer(ax25);
306 ax25_stop_t3timer(ax25);
307 ax25_stop_idletimer(ax25);
308
309 ax25_clear_queues(ax25); /* Flush the queues */
310
311 if (ax25->sk != NULL) {
312 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
313 if (skb->sk != ax25->sk) {
314 /* A pending connection */
315 ax25_cb *sax25 = ax25_sk(skb->sk);
316
317 /* Queue the unaccepted socket for death */
318 sock_orphan(skb->sk);
319
33d1d2c5
DM		 320 /* 9A4GL: hack to release unaccepted sockets */
321 skb->sk->sk_state = TCP_LISTEN;
322
1da177e4
LT		 323 ax25_start_heartbeat(sax25);
324 sax25->state = AX25_STATE_0;
325 }
326
327 kfree_skb(skb);
328 }
329 skb_queue_purge(&ax25->sk->sk_write_queue);
330 }
331
332 if (ax25->sk != NULL) {
c564039f 333 if (sk_has_allocations(ax25->sk)) {
1da177e4 334 /* Defer: outstanding buffers */
b24b8a24
PE		 335 setup_timer(&ax25->dtimer, ax25_destroy_timer,
336 (unsigned long)ax25);
1da177e4 337 ax25->dtimer.expires = jiffies + 2 * HZ;
1da177e4
LT		 338 add_timer(&ax25->dtimer);
339 } else {
340 struct sock *sk=ax25->sk;
341 ax25->sk=NULL;
342 sock_put(sk);
343 }
344 } else {
345 ax25_cb_put(ax25);
346 }
347}
348
349/*
350 * dl1bke 960311: set parameters for existing AX.25 connections,
351 * includes a KILL command to abort any connection.
352 * VERY useful for debugging ;-)
353 */
354static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
355{
356 struct ax25_ctl_struct ax25_ctl;
357 ax25_digi digi;
358 ax25_dev *ax25_dev;
359 ax25_cb *ax25;
360 unsigned int k;
c0181d42 361 int ret = 0;
1da177e4
LT		 362
363 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
364 return -EFAULT;
365
366 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
367 return -ENODEV;
368
369 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
370 return -EINVAL;
371
43ab8502 372 if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
373 return -EINVAL;
374
1da177e4
LT		 375 digi.ndigi = ax25_ctl.digi_count;
376 for (k = 0; k < digi.ndigi; k++)
377 digi.calls[k] = ax25_ctl.digi_addr[k];
378
379 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
380 return -ENOTCONN;
381
382 switch (ax25_ctl.cmd) {
383 case AX25_KILL:
384 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
385#ifdef CONFIG_AX25_DAMA_SLAVE
386 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
387 ax25_dama_off(ax25);
388#endif
389 ax25_disconnect(ax25, ENETRESET);
390 break;
391
528930b9
YH		 392 case AX25_WINDOW:
393 if (ax25->modulus == AX25_MODULUS) {
394 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
c0181d42 395 goto einval_put;
528930b9
YH		 396 } else {
397 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
c0181d42 398 goto einval_put;
528930b9
YH		 399 }
400 ax25->window = ax25_ctl.arg;
401 break;
402
403 case AX25_T1:
be639ac6 404 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
c0181d42 405 goto einval_put;
528930b9
YH		 406 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
407 ax25->t1 = ax25_ctl.arg * HZ;
408 break;
409
410 case AX25_T2:
be639ac6 411 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
c0181d42 412 goto einval_put;
528930b9
YH		 413 ax25->t2 = ax25_ctl.arg * HZ;
414 break;
415
416 case AX25_N2:
417 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
c0181d42 418 goto einval_put;
528930b9
YH		 419 ax25->n2count = 0;
420 ax25->n2 = ax25_ctl.arg;
421 break;
422
423 case AX25_T3:
be639ac6
RB		 424 if (ax25_ctl.arg > ULONG_MAX / HZ)
425 goto einval_put;
528930b9
YH		 426 ax25->t3 = ax25_ctl.arg * HZ;
427 break;
428
429 case AX25_IDLE:
be639ac6
RB		 430 if (ax25_ctl.arg > ULONG_MAX / (60 * HZ))
431 goto einval_put;
432
528930b9
YH		 433 ax25->idle = ax25_ctl.arg * 60 * HZ;
434 break;
435
436 case AX25_PACLEN:
437 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
c0181d42 438 goto einval_put;
528930b9
YH		 439 ax25->paclen = ax25_ctl.arg;
440 break;
441
442 default:
c0181d42 443 goto einval_put;
1da177e4
LT		 444 }
445
c0181d42
JP		 446out_put:
447 ax25_cb_put(ax25);
448 return ret;
449
450einval_put:
451 ret = -EINVAL;
452 goto out_put;
1da177e4
LT		 453}
454
e1fdb5b3
RB		 455static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
456{
457 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
458 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
459 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
460 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
461 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
462 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
463 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
464 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
465
466 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
467 ax25->modulus = AX25_EMODULUS;
468 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
469 } else {
470 ax25->modulus = AX25_MODULUS;
471 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
472 }
473}
474
1da177e4
LT		 475/*
476 * Fill in a created AX.25 created control block with the default
477 * values for a particular device.
478 */
479void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
480{
481 ax25->ax25_dev = ax25_dev;
482
483 if (ax25->ax25_dev != NULL) {
e1fdb5b3
RB		 484 ax25_fillin_cb_from_dev(ax25, ax25_dev);
485 return;
486 }
487
488 /*
489 * No device, use kernel / AX.25 spec default values
490 */
491 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
492 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
493 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
494 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
495 ax25->n2 = AX25_DEF_N2;
496 ax25->paclen = AX25_DEF_PACLEN;
497 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
498 ax25->backoff = AX25_DEF_BACKOFF;
499
500 if (AX25_DEF_AXDEFMODE) {
501 ax25->modulus = AX25_EMODULUS;
502 ax25->window = AX25_DEF_EWINDOW;
1da177e4 503 } else {
e1fdb5b3
RB		 504 ax25->modulus = AX25_MODULUS;
505 ax25->window = AX25_DEF_WINDOW;
1da177e4
LT		 506 }
507}
508
509/*
510 * Create an empty AX.25 control block.
511 */
512ax25_cb *ax25_create_cb(void)
513{
514 ax25_cb *ax25;
515
1b30dd35 516 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
1da177e4
LT		 517 return NULL;
518
1da177e4
LT		 519 atomic_set(&ax25->refcount, 1);
520
521 skb_queue_head_init(&ax25->write_queue);
522 skb_queue_head_init(&ax25->frag_queue);
523 skb_queue_head_init(&ax25->ack_queue);
524 skb_queue_head_init(&ax25->reseq_queue);
525
21fab4a8 526 ax25_setup_timers(ax25);
1da177e4
LT		 527
528 ax25_fillin_cb(ax25, NULL);
529
530 ax25->state = AX25_STATE_0;
531
532 return ax25;
533}
534
535/*
536 * Handling for system calls applied via the various interfaces to an
537 * AX25 socket object
538 */
539
540static int ax25_setsockopt(struct socket *sock, int level, int optname,
b7058842 541 char __user *optval, unsigned int optlen)
1da177e4
LT		 542{
543 struct sock *sk = sock->sk;
544 ax25_cb *ax25;
545 struct net_device *dev;
546 char devname[IFNAMSIZ];
ba1cffe0
XW		 547 unsigned long opt;
548 int res = 0;
1da177e4
LT		 549
550 if (level != SOL_AX25)
551 return -ENOPROTOOPT;
552
ba1cffe0 553 if (optlen < sizeof(unsigned int))
1da177e4
LT		 554 return -EINVAL;
555
ba1cffe0 556 if (get_user(opt, (unsigned int __user *)optval))
1da177e4
LT		 557 return -EFAULT;
558
559 lock_sock(sk);
560 ax25 = ax25_sk(sk);
561
562 switch (optname) {
563 case AX25_WINDOW:
564 if (ax25->modulus == AX25_MODULUS) {
565 if (opt < 1 || opt > 7) {
566 res = -EINVAL;
567 break;
568 }
569 } else {
570 if (opt < 1 || opt > 63) {
571 res = -EINVAL;
572 break;
573 }
574 }
575 ax25->window = opt;
576 break;
577
578 case AX25_T1:
be639ac6 579 if (opt < 1 || opt > ULONG_MAX / HZ) {
1da177e4
LT		 580 res = -EINVAL;
581 break;
582 }
f16f3026 583 ax25->rtt = (opt * HZ) >> 1;
1da177e4
LT		 584 ax25->t1 = opt * HZ;
585 break;
586
587 case AX25_T2:
be639ac6 588 if (opt < 1 || opt > ULONG_MAX / HZ) {
1da177e4
LT		 589 res = -EINVAL;
590 break;
591 }
592 ax25->t2 = opt * HZ;
593 break;
594
595 case AX25_N2:
596 if (opt < 1 || opt > 31) {
597 res = -EINVAL;
598 break;
599 }
600 ax25->n2 = opt;
601 break;
602
603 case AX25_T3:
be639ac6 604 if (opt < 1 || opt > ULONG_MAX / HZ) {
1da177e4
LT		 605 res = -EINVAL;
606 break;
607 }
608 ax25->t3 = opt * HZ;
609 break;
610
611 case AX25_IDLE:
ba1cffe0 612 if (opt > ULONG_MAX / (60 * HZ)) {
1da177e4
LT		 613 res = -EINVAL;
614 break;
615 }
616 ax25->idle = opt * 60 * HZ;
617 break;
618
619 case AX25_BACKOFF:
ba1cffe0 620 if (opt > 2) {
1da177e4
LT		 621 res = -EINVAL;
622 break;
623 }
624 ax25->backoff = opt;
625 break;
626
627 case AX25_EXTSEQ:
628 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
629 break;
630
631 case AX25_PIDINCL:
632 ax25->pidincl = opt ? 1 : 0;
633 break;
634
635 case AX25_IAMDIGI:
636 ax25->iamdigi = opt ? 1 : 0;
637 break;
638
639 case AX25_PACLEN:
640 if (opt < 16 || opt > 65535) {
641 res = -EINVAL;
642 break;
643 }
644 ax25->paclen = opt;
645 break;
646
647 case SO_BINDTODEVICE:
648 if (optlen > IFNAMSIZ)
2f72291d 649 optlen = IFNAMSIZ;
1da177e4 650
2f72291d
RB		 651 if (copy_from_user(devname, optval, optlen)) {
652 res = -EFAULT;
1da177e4
LT		 653 break;
654 }
655
656 if (sk->sk_type == SOCK_SEQPACKET &&
657 (sock->state != SS_UNCONNECTED ||
658 sk->sk_state == TCP_LISTEN)) {
659 res = -EADDRNOTAVAIL;
2f72291d
RB		 660 break;
661 }
662
663 dev = dev_get_by_name(&init_net, devname);
664 if (!dev) {
665 res = -ENODEV;
1da177e4
LT		 666 break;
667 }
668
669 ax25->ax25_dev = ax25_dev_ax25dev(dev);
670 ax25_fillin_cb(ax25, ax25->ax25_dev);
2f72291d 671 dev_put(dev);
1da177e4
LT		 672 break;
673
674 default:
675 res = -ENOPROTOOPT;
676 }
677 release_sock(sk);
678
679 return res;
680}
681
682static int ax25_getsockopt(struct socket *sock, int level, int optname,
683 char __user *optval, int __user *optlen)
684{
685 struct sock *sk = sock->sk;
686 ax25_cb *ax25;
687 struct ax25_dev *ax25_dev;
688 char devname[IFNAMSIZ];
689 void *valptr;
690 int val = 0;
691 int maxlen, length;
692
693 if (level != SOL_AX25)
694 return -ENOPROTOOPT;
695
696 if (get_user(maxlen, optlen))
697 return -EFAULT;
698
699 if (maxlen < 1)
700 return -EFAULT;
701
702 valptr = (void *) &val;
703 length = min_t(unsigned int, maxlen, sizeof(int));
704
705 lock_sock(sk);
706 ax25 = ax25_sk(sk);
707
708 switch (optname) {
709 case AX25_WINDOW:
710 val = ax25->window;
711 break;
712
713 case AX25_T1:
714 val = ax25->t1 / HZ;
715 break;
716
717 case AX25_T2:
718 val = ax25->t2 / HZ;
719 break;
720
721 case AX25_N2:
722 val = ax25->n2;
723 break;
724
725 case AX25_T3:
726 val = ax25->t3 / HZ;
727 break;
728
729 case AX25_IDLE:
730 val = ax25->idle / (60 * HZ);
731 break;
732
733 case AX25_BACKOFF:
734 val = ax25->backoff;
735 break;
736
737 case AX25_EXTSEQ:
738 val = (ax25->modulus == AX25_EMODULUS);
739 break;
740
741 case AX25_PIDINCL:
742 val = ax25->pidincl;
743 break;
744
745 case AX25_IAMDIGI:
746 val = ax25->iamdigi;
747 break;
748
749 case AX25_PACLEN:
750 val = ax25->paclen;
751 break;
752
753 case SO_BINDTODEVICE:
754 ax25_dev = ax25->ax25_dev;
755
756 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
757 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
758 length = strlen(devname) + 1;
759 } else {
760 *devname = '\0';
761 length = 1;
762 }
763
764 valptr = (void *) devname;
765 break;
766
767 default:
768 release_sock(sk);
769 return -ENOPROTOOPT;
770 }
771 release_sock(sk);
772
773 if (put_user(length, optlen))
774 return -EFAULT;
775
776 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
777}
778
779static int ax25_listen(struct socket *sock, int backlog)
780{
781 struct sock *sk = sock->sk;
782 int res = 0;
783
784 lock_sock(sk);
785 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
786 sk->sk_max_ack_backlog = backlog;
787 sk->sk_state = TCP_LISTEN;
788 goto out;
789 }
790 res = -EOPNOTSUPP;
791
792out:
793 release_sock(sk);
794
795 return res;
796}
797
798/*
799 * XXX: when creating ax25_sock we should update the .obj_size setting
800 * below.
801 */
802static struct proto ax25_proto = {
803 .name = "AX25",
804 .owner = THIS_MODULE,
805 .obj_size = sizeof(struct sock),
806};
807
3f378b68
EP		 808static int ax25_create(struct net *net, struct socket *sock, int protocol,
809 int kern)
1da177e4
LT		 810{
811 struct sock *sk;
812 ax25_cb *ax25;
813
09ad9bc7 814 if (!net_eq(net, &init_net))
1b8d7ae4
EB		 815 return -EAFNOSUPPORT;
816
1da177e4
LT		 817 switch (sock->type) {
818 case SOCK_DGRAM:
819 if (protocol == 0 || protocol == PF_AX25)
820 protocol = AX25_P_TEXT;
821 break;
822
823 case SOCK_SEQPACKET:
824 switch (protocol) {
825 case 0:
826 case PF_AX25: /* For CLX */
827 protocol = AX25_P_TEXT;
828 break;
829 case AX25_P_SEGMENT:
830#ifdef CONFIG_INET
831 case AX25_P_ARP:
832 case AX25_P_IP:
833#endif
834#ifdef CONFIG_NETROM
835 case AX25_P_NETROM:
836#endif
837#ifdef CONFIG_ROSE
838 case AX25_P_ROSE:
839#endif
840 return -ESOCKTNOSUPPORT;
841#ifdef CONFIG_NETROM_MODULE
842 case AX25_P_NETROM:
843 if (ax25_protocol_is_registered(AX25_P_NETROM))
844 return -ESOCKTNOSUPPORT;
845#endif
846#ifdef CONFIG_ROSE_MODULE
847 case AX25_P_ROSE:
848 if (ax25_protocol_is_registered(AX25_P_ROSE))
849 return -ESOCKTNOSUPPORT;
850#endif
851 default:
852 break;
853 }
854 break;
855
856 case SOCK_RAW:
857 break;
858 default:
859 return -ESOCKTNOSUPPORT;
860 }
861
6257ff21
PE		 862 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
863 if (sk == NULL)
1da177e4
LT		 864 return -ENOMEM;
865
866 ax25 = sk->sk_protinfo = ax25_create_cb();
867 if (!ax25) {
868 sk_free(sk);
869 return -ENOMEM;
870 }
871
872 sock_init_data(sock, sk);
873
874 sk->sk_destruct = ax25_free_sock;
875 sock->ops = &ax25_proto_ops;
876 sk->sk_protocol = protocol;
877
878 ax25->sk = sk;
879
880 return 0;
881}
882
883struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
884{
885 struct sock *sk;
886 ax25_cb *ax25, *oax25;
887
3b1e0a65 888 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot);
6257ff21 889 if (sk == NULL)
1da177e4
LT		 890 return NULL;
891
892 if ((ax25 = ax25_create_cb()) == NULL) {
893 sk_free(sk);
894 return NULL;
895 }
896
897 switch (osk->sk_type) {
898 case SOCK_DGRAM:
899 break;
900 case SOCK_SEQPACKET:
901 break;
902 default:
903 sk_free(sk);
904 ax25_cb_put(ax25);
905 return NULL;
906 }
907
908 sock_init_data(NULL, sk);
909
1da177e4 910 sk->sk_type = osk->sk_type;
1da177e4
LT		 911 sk->sk_priority = osk->sk_priority;
912 sk->sk_protocol = osk->sk_protocol;
913 sk->sk_rcvbuf = osk->sk_rcvbuf;
914 sk->sk_sndbuf = osk->sk_sndbuf;
915 sk->sk_state = TCP_ESTABLISHED;
53b924b3 916 sock_copy_flags(sk, osk);
1da177e4
LT		 917
918 oax25 = ax25_sk(osk);
919
920 ax25->modulus = oax25->modulus;
921 ax25->backoff = oax25->backoff;
922 ax25->pidincl = oax25->pidincl;
923 ax25->iamdigi = oax25->iamdigi;
924 ax25->rtt = oax25->rtt;
925 ax25->t1 = oax25->t1;
926 ax25->t2 = oax25->t2;
927 ax25->t3 = oax25->t3;
928 ax25->n2 = oax25->n2;
929 ax25->idle = oax25->idle;
930 ax25->paclen = oax25->paclen;
931 ax25->window = oax25->window;
932
933 ax25->ax25_dev = ax25_dev;
934 ax25->source_addr = oax25->source_addr;
935
936 if (oax25->digipeat != NULL) {
0459d70a
ACM		 937 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
938 GFP_ATOMIC);
939 if (ax25->digipeat == NULL) {
1da177e4
LT		 940 sk_free(sk);
941 ax25_cb_put(ax25);
942 return NULL;
943 }
1da177e4
LT		 944 }
945
946 sk->sk_protinfo = ax25;
8c185ab6 947 sk->sk_destruct = ax25_free_sock;
1da177e4
LT		 948 ax25->sk = sk;
949
950 return sk;
951}
952
953static int ax25_release(struct socket *sock)
954{
955 struct sock *sk = sock->sk;
956 ax25_cb *ax25;
957
958 if (sk == NULL)
959 return 0;
960
961 sock_hold(sk);
962 sock_orphan(sk);
963 lock_sock(sk);
964 ax25 = ax25_sk(sk);
965
966 if (sk->sk_type == SOCK_SEQPACKET) {
967 switch (ax25->state) {
968 case AX25_STATE_0:
969 release_sock(sk);
970 ax25_disconnect(ax25, 0);
971 lock_sock(sk);
972 ax25_destroy_socket(ax25);
973 break;
974
975 case AX25_STATE_1:
976 case AX25_STATE_2:
977 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
978 release_sock(sk);
979 ax25_disconnect(ax25, 0);
980 lock_sock(sk);
981 ax25_destroy_socket(ax25);
982 break;
983
984 case AX25_STATE_3:
985 case AX25_STATE_4:
986 ax25_clear_queues(ax25);
987 ax25->n2count = 0;
988
989 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
990 case AX25_PROTO_STD_SIMPLEX:
991 case AX25_PROTO_STD_DUPLEX:
992 ax25_send_control(ax25,
993 AX25_DISC,
994 AX25_POLLON,
995 AX25_COMMAND);
996 ax25_stop_t2timer(ax25);
997 ax25_stop_t3timer(ax25);
998 ax25_stop_idletimer(ax25);
999 break;
1000#ifdef CONFIG_AX25_DAMA_SLAVE
1001 case AX25_PROTO_DAMA_SLAVE:
1002 ax25_stop_t3timer(ax25);
1003 ax25_stop_idletimer(ax25);
1004 break;
1005#endif
1006 }
1007 ax25_calculate_t1(ax25);
1008 ax25_start_t1timer(ax25);
1009 ax25->state = AX25_STATE_2;
1010 sk->sk_state = TCP_CLOSE;
1011 sk->sk_shutdown |= SEND_SHUTDOWN;
1012 sk->sk_state_change(sk);
1013 sock_set_flag(sk, SOCK_DESTROY);
1014 break;
1015
1016 default:
1017 break;
1018 }
1019 } else {
1020 sk->sk_state = TCP_CLOSE;
1021 sk->sk_shutdown |= SEND_SHUTDOWN;
1022 sk->sk_state_change(sk);
1023 ax25_destroy_socket(ax25);
1024 }
1025
1026 sock->sk = NULL;
1027 release_sock(sk);
1028 sock_put(sk);
1029
1030 return 0;
1031}
1032
1033/*
1034 * We support a funny extension here so you can (as root) give any callsign
1035 * digipeated via a local address as source. This hack is obsolete now
1036 * that we've implemented support for SO_BINDTODEVICE. It is however small
1037 * and trivially backward compatible.
1038 */
1039static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1040{
1041 struct sock *sk = sock->sk;
1042 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1043 ax25_dev *ax25_dev = NULL;
01d7dd0e
RB		 1044 ax25_uid_assoc *user;
1045 ax25_address call;
1da177e4
LT		 1046 ax25_cb *ax25;
1047 int err = 0;
1048
1049 if (addr_len != sizeof(struct sockaddr_ax25) &&
1987e7b4 1050 addr_len != sizeof(struct full_sockaddr_ax25))
1051 /* support for old structure may go away some time
1052 * ax25_bind(): uses old (6 digipeater) socket structure.
1053 */
1da177e4 1054 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1987e7b4 1055 (addr_len > sizeof(struct full_sockaddr_ax25)))
1da177e4 1056 return -EINVAL;
1da177e4
LT		 1057
1058 if (addr->fsa_ax25.sax25_family != AF_AX25)
1059 return -EINVAL;
1060
73400407 1061 user = ax25_findbyuid(current_euid());
01d7dd0e
RB		 1062 if (user) {
1063 call = user->call;
1064 ax25_uid_put(user);
1065 } else {
1066 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1067 return -EACCES;
1068
1069 call = addr->fsa_ax25.sax25_call;
1da177e4
LT		 1070 }
1071
1072 lock_sock(sk);
1073
1074 ax25 = ax25_sk(sk);
1075 if (!sock_flag(sk, SOCK_ZAPPED)) {
1076 err = -EINVAL;
1077 goto out;
1078 }
1079
01d7dd0e 1080 ax25->source_addr = call;
1da177e4
LT		 1081
1082 /*
1083 * User already set interface with SO_BINDTODEVICE
1084 */
1085 if (ax25->ax25_dev != NULL)
1086 goto done;
1087
1088 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1089 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1090 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1091 err = -EADDRNOTAVAIL;
1092 goto out;
1093 }
1094 } else {
1095 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1096 err = -EADDRNOTAVAIL;
1097 goto out;
1098 }
1099 }
1100
1101 if (ax25_dev != NULL)
1102 ax25_fillin_cb(ax25, ax25_dev);
1103
1104done:
1105 ax25_cb_add(ax25);
1106 sock_reset_flag(sk, SOCK_ZAPPED);
1107
1108out:
1109 release_sock(sk);
1110
49339cca 1111 return err;
1da177e4
LT		 1112}
1113
1114/*
1115 * FIXME: nonblock behaviour looks like it may have a bug.
1116 */
c9266b99
RB		 1117static int __must_check ax25_connect(struct socket *sock,
1118 struct sockaddr *uaddr, int addr_len, int flags)
1da177e4
LT		 1119{
1120 struct sock *sk = sock->sk;
1121 ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1122 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1123 ax25_digi *digi = NULL;
1124 int ct = 0, err = 0;
1125
1126 /*
1127 * some sanity checks. code further down depends on this
1128 */
1129
27d1cba2 1130 if (addr_len == sizeof(struct sockaddr_ax25))
1131 /* support for this will go away in early 2.5.x
1132 * ax25_connect(): uses obsolete socket structure
1133 */
1134 ;
1135 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1136 /* support for old structure may go away some time
1137 * ax25_connect(): uses old (6 digipeater) socket structure.
1138 */
1da177e4 1139 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
27d1cba2 1140 (addr_len > sizeof(struct full_sockaddr_ax25)))
1da177e4 1141 return -EINVAL;
1da177e4 1142
1da177e4
LT		 1143
1144 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1145 return -EINVAL;
1146
1147 lock_sock(sk);
1148
1149 /* deal with restarts */
1150 if (sock->state == SS_CONNECTING) {
1151 switch (sk->sk_state) {
1152 case TCP_SYN_SENT: /* still trying */
1153 err = -EINPROGRESS;
75606dc6 1154 goto out_release;
1da177e4
LT		 1155
1156 case TCP_ESTABLISHED: /* connection established */
1157 sock->state = SS_CONNECTED;
75606dc6 1158 goto out_release;
1da177e4
LT		 1159
1160 case TCP_CLOSE: /* connection refused */
1161 sock->state = SS_UNCONNECTED;
1162 err = -ECONNREFUSED;
75606dc6 1163 goto out_release;
1da177e4
LT		 1164 }
1165 }
1166
1167 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1168 err = -EISCONN; /* No reconnect on a seqpacket socket */
75606dc6 1169 goto out_release;
1da177e4
LT		 1170 }
1171
1172 sk->sk_state = TCP_CLOSE;
1173 sock->state = SS_UNCONNECTED;
1174
a51482bd
JJ		 1175 kfree(ax25->digipeat);
1176 ax25->digipeat = NULL;
1da177e4
LT		 1177
1178 /*
1179 * Handle digi-peaters to be used.
1180 */
1181 if (addr_len > sizeof(struct sockaddr_ax25) &&
1182 fsa->fsa_ax25.sax25_ndigis != 0) {
1183 /* Valid number of digipeaters ? */
1184 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1185 err = -EINVAL;
75606dc6 1186 goto out_release;
1da177e4
LT		 1187 }
1188
1189 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1190 err = -ENOBUFS;
75606dc6 1191 goto out_release;
1da177e4
LT		 1192 }
1193
1194 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1195 digi->lastrepeat = -1;
1196
1197 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1198 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1199 AX25_HBIT) && ax25->iamdigi) {
1200 digi->repeated[ct] = 1;
1201 digi->lastrepeat = ct;
1202 } else {
1203 digi->repeated[ct] = 0;
1204 }
1205 digi->calls[ct] = fsa->fsa_digipeater[ct];
1206 ct++;
1207 }
1208 }
1209
1210 /*
1211 * Must bind first - autobinding in this may or may not work. If
1212 * the socket is already bound, check to see if the device has
1213 * been filled in, error if it hasn't.
1214 */
1215 if (sock_flag(sk, SOCK_ZAPPED)) {
1216 /* check if we can remove this feature. It is broken. */
1217 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1218 current->comm);
1219 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1220 kfree(digi);
75606dc6 1221 goto out_release;
1da177e4
LT		 1222 }
1223
1224 ax25_fillin_cb(ax25, ax25->ax25_dev);
1225 ax25_cb_add(ax25);
1226 } else {
1227 if (ax25->ax25_dev == NULL) {
1228 kfree(digi);
1229 err = -EHOSTUNREACH;
75606dc6 1230 goto out_release;
1da177e4
LT		 1231 }
1232 }
1233
1234 if (sk->sk_type == SOCK_SEQPACKET &&
1235 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
528930b9 1236 ax25->ax25_dev->dev))) {
1da177e4
LT		 1237 kfree(digi);
1238 err = -EADDRINUSE; /* Already such a connection */
1239 ax25_cb_put(ax25t);
75606dc6 1240 goto out_release;
1da177e4
LT		 1241 }
1242
1243 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1244 ax25->digipeat = digi;
1245
1246 /* First the easy one */
1247 if (sk->sk_type != SOCK_SEQPACKET) {
1248 sock->state = SS_CONNECTED;
1249 sk->sk_state = TCP_ESTABLISHED;
75606dc6 1250 goto out_release;
1da177e4
LT		 1251 }
1252
1253 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1254 sock->state = SS_CONNECTING;
1255 sk->sk_state = TCP_SYN_SENT;
1256
1257 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1258 case AX25_PROTO_STD_SIMPLEX:
1259 case AX25_PROTO_STD_DUPLEX:
1260 ax25_std_establish_data_link(ax25);
1261 break;
1262
1263#ifdef CONFIG_AX25_DAMA_SLAVE
1264 case AX25_PROTO_DAMA_SLAVE:
1265 ax25->modulus = AX25_MODULUS;
1266 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1267 if (ax25->ax25_dev->dama.slave)
1268 ax25_ds_establish_data_link(ax25);
1269 else
1270 ax25_std_establish_data_link(ax25);
1271 break;
1272#endif
1273 }
1274
1275 ax25->state = AX25_STATE_1;
1276
1277 ax25_start_heartbeat(ax25);
1278
1279 /* Now the loop */
1280 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1281 err = -EINPROGRESS;
75606dc6 1282 goto out_release;
1da177e4
LT		 1283 }
1284
1285 if (sk->sk_state == TCP_SYN_SENT) {
75606dc6 1286 DEFINE_WAIT(wait);
1da177e4 1287
1da177e4 1288 for (;;) {
aa395145 1289 prepare_to_wait(sk_sleep(sk), &wait,
bd3b071b 1290 TASK_INTERRUPTIBLE);
1da177e4
LT		 1291 if (sk->sk_state != TCP_SYN_SENT)
1292 break;
75606dc6
RB		 1293 if (!signal_pending(current)) {
1294 release_sock(sk);
1da177e4
LT		 1295 schedule();
1296 lock_sock(sk);
1297 continue;
1298 }
75606dc6
RB		 1299 err = -ERESTARTSYS;
1300 break;
1da177e4 1301 }
aa395145 1302 finish_wait(sk_sleep(sk), &wait);
75606dc6
RB		 1303
1304 if (err)
1305 goto out_release;
1da177e4
LT		 1306 }
1307
1308 if (sk->sk_state != TCP_ESTABLISHED) {
1309 /* Not in ABM, not in WAIT_UA -> failed */
1310 sock->state = SS_UNCONNECTED;
1311 err = sock_error(sk); /* Always set at this point */
75606dc6 1312 goto out_release;
1da177e4
LT		 1313 }
1314
1315 sock->state = SS_CONNECTED;
1316
75606dc6
RB		 1317 err = 0;
1318out_release:
1da177e4
LT		 1319 release_sock(sk);
1320
1321 return err;
1322}
1323
1da177e4
LT		 1324static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1325{
1da177e4
LT		 1326 struct sk_buff *skb;
1327 struct sock *newsk;
75606dc6 1328 DEFINE_WAIT(wait);
1da177e4
LT		 1329 struct sock *sk;
1330 int err = 0;
1331
1332 if (sock->state != SS_UNCONNECTED)
1333 return -EINVAL;
1334
1335 if ((sk = sock->sk) == NULL)
1336 return -EINVAL;
1337
1338 lock_sock(sk);
1339 if (sk->sk_type != SOCK_SEQPACKET) {
1340 err = -EOPNOTSUPP;
1341 goto out;
1342 }
1343
1344 if (sk->sk_state != TCP_LISTEN) {
1345 err = -EINVAL;
1346 goto out;
1347 }
1348
1349 /*
1350 * The read queue this time is holding sockets ready to use
1351 * hooked into the SABM we saved
1352 */
1da177e4 1353 for (;;) {
aa395145 1354 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1da177e4
LT		 1355 skb = skb_dequeue(&sk->sk_receive_queue);
1356 if (skb)
1357 break;
1358
1da177e4 1359 if (flags & O_NONBLOCK) {
75606dc6
RB		 1360 err = -EWOULDBLOCK;
1361 break;
1da177e4 1362 }
75606dc6
RB		 1363 if (!signal_pending(current)) {
1364 release_sock(sk);
1da177e4
LT		 1365 schedule();
1366 lock_sock(sk);
1367 continue;
1368 }
75606dc6
RB		 1369 err = -ERESTARTSYS;
1370 break;
1da177e4 1371 }
aa395145 1372 finish_wait(sk_sleep(sk), &wait);
75606dc6
RB		 1373
1374 if (err)
1375 goto out;
1da177e4
LT		 1376
1377 newsk = skb->sk;
9375cb8a 1378 sock_graft(newsk, newsock);
1da177e4
LT		 1379
1380 /* Now attach up the new socket */
1381 kfree_skb(skb);
1382 sk->sk_ack_backlog--;
1da177e4
LT		 1383 newsock->state = SS_CONNECTED;
1384
1385out:
1386 release_sock(sk);
1387
1388 return err;
1389}
1390
1391static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1392 int *uaddr_len, int peer)
1393{
1394 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1395 struct sock *sk = sock->sk;
1396 unsigned char ndigi, i;
1397 ax25_cb *ax25;
1398 int err = 0;
1399
5b919f83 1400 memset(fsa, 0, sizeof(*fsa));
1da177e4
LT		 1401 lock_sock(sk);
1402 ax25 = ax25_sk(sk);
1403
1404 if (peer != 0) {
1405 if (sk->sk_state != TCP_ESTABLISHED) {
1406 err = -ENOTCONN;
1407 goto out;
1408 }
1409
1410 fsa->fsa_ax25.sax25_family = AF_AX25;
1411 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1da177e4
LT		 1412
1413 if (ax25->digipeat != NULL) {
1414 ndigi = ax25->digipeat->ndigi;
1415 fsa->fsa_ax25.sax25_ndigis = ndigi;
1416 for (i = 0; i < ndigi; i++)
1417 fsa->fsa_digipeater[i] =
1418 ax25->digipeat->calls[i];
1419 }
1420 } else {
1421 fsa->fsa_ax25.sax25_family = AF_AX25;
1422 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1423 fsa->fsa_ax25.sax25_ndigis = 1;
1424 if (ax25->ax25_dev != NULL) {
1425 memcpy(&fsa->fsa_digipeater[0],
1426 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1427 } else {
1428 fsa->fsa_digipeater[0] = null_ax25_address;
1429 }
1430 }
1431 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1432
1433out:
1434 release_sock(sk);
1435
1436 return err;
1437}
1438
1439static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1440 struct msghdr *msg, size_t len)
1441{
1442 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1443 struct sock *sk = sock->sk;
1444 struct sockaddr_ax25 sax;
1445 struct sk_buff *skb;
1446 ax25_digi dtmp, *dp;
1da177e4
LT		 1447 ax25_cb *ax25;
1448 size_t size;
1449 int lv, err, addr_len = msg->msg_namelen;
1450
1451 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1452 return -EINVAL;
1453
1454 lock_sock(sk);
1455 ax25 = ax25_sk(sk);
1456
1457 if (sock_flag(sk, SOCK_ZAPPED)) {
1458 err = -EADDRNOTAVAIL;
1459 goto out;
1460 }
1461
1462 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1463 send_sig(SIGPIPE, current, 0);
1464 err = -EPIPE;
1465 goto out;
1466 }
1467
1468 if (ax25->ax25_dev == NULL) {
1469 err = -ENETUNREACH;
1470 goto out;
1471 }
1472
1473 if (len > ax25->ax25_dev->dev->mtu) {
1474 err = -EMSGSIZE;
1475 goto out;
1476 }
528930b9 1477
1da177e4
LT		 1478 if (usax != NULL) {
1479 if (usax->sax25_family != AF_AX25) {
1480 err = -EINVAL;
1481 goto out;
1482 }
1483
27d1cba2 1484 if (addr_len == sizeof(struct sockaddr_ax25))
1485 /* ax25_sendmsg(): uses obsolete socket structure */
1486 ;
1487 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1488 /* support for old structure may go away some time
1489 * ax25_sendmsg(): uses old (6 digipeater)
1490 * socket structure.
1491 */
1da177e4 1492 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
528930b9
YH		 1493 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1494 err = -EINVAL;
1da177e4
LT		 1495 goto out;
1496 }
1497
1da177e4
LT		 1498
1499 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1500 int ct = 0;
1501 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1502
1503 /* Valid number of digipeaters ? */
1504 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1505 err = -EINVAL;
1506 goto out;
1507 }
1508
1509 dtmp.ndigi = usax->sax25_ndigis;
1510
1511 while (ct < usax->sax25_ndigis) {
1512 dtmp.repeated[ct] = 0;
1513 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1514 ct++;
1515 }
1516
1517 dtmp.lastrepeat = 0;
1518 }
1519
1520 sax = *usax;
1521 if (sk->sk_type == SOCK_SEQPACKET &&
1522 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1523 err = -EISCONN;
1524 goto out;
1525 }
1526 if (usax->sax25_ndigis == 0)
1527 dp = NULL;
1528 else
1529 dp = &dtmp;
1530 } else {
1531 /*
1532 * FIXME: 1003.1g - if the socket is like this because
1533 * it has become closed (not started closed) and is VC
1534 * we ought to SIGPIPE, EPIPE
1535 */
1536 if (sk->sk_state != TCP_ESTABLISHED) {
1537 err = -ENOTCONN;
1538 goto out;
1539 }
1540 sax.sax25_family = AF_AX25;
1541 sax.sax25_call = ax25->dest_addr;
1542 dp = ax25->digipeat;
1543 }
1544
1da177e4 1545 /* Build a packet */
1da177e4
LT		 1546 /* Assume the worst case */
1547 size = len + ax25->ax25_dev->dev->hard_header_len;
1548
1549 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1550 if (skb == NULL)
1551 goto out;
1552
1553 skb_reserve(skb, size - len);
1554
1da177e4
LT		 1555 /* User data follows immediately after the AX.25 data */
1556 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1557 err = -EFAULT;
1558 kfree_skb(skb);
1559 goto out;
1560 }
1561
c1d2bbe1 1562 skb_reset_network_header(skb);
1da177e4
LT		 1563
1564 /* Add the PID if one is not supplied by the user in the skb */
967b05f6
ACM		 1565 if (!ax25->pidincl)
1566 *skb_push(skb, 1) = sk->sk_protocol;
1da177e4 1567
1da177e4
LT		 1568 if (sk->sk_type == SOCK_SEQPACKET) {
1569 /* Connected mode sockets go via the LAPB machine */
1570 if (sk->sk_state != TCP_ESTABLISHED) {
1571 kfree_skb(skb);
1572 err = -ENOTCONN;
1573 goto out;
1574 }
1575
1576 /* Shove it onto the queue and kick */
1577 ax25_output(ax25, ax25->paclen, skb);
1578
1579 err = len;
1580 goto out;
1581 }
1582
967b05f6 1583 skb_push(skb, 1 + ax25_addr_size(dp));
1da177e4 1584
8849b720 1585 /* Building AX.25 Header */
1da177e4
LT		 1586
1587 /* Build an AX.25 header */
967b05f6
ACM		 1588 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1589 dp, AX25_COMMAND, AX25_MODULUS);
1da177e4 1590
967b05f6 1591 skb_set_transport_header(skb, lv);
1da177e4 1592
9c70220b 1593 *skb_transport_header(skb) = AX25_UI;
1da177e4
LT		 1594
1595 /* Datagram frames go straight out of the door as UI */
29c4be51 1596 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1da177e4
LT		 1597
1598 err = len;
1599
1600out:
1601 release_sock(sk);
1602
1603 return err;
1604}
1605
1606static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1607 struct msghdr *msg, size_t size, int flags)
1608{
1609 struct sock *sk = sock->sk;
1610 struct sk_buff *skb;
1611 int copied;
1612 int err = 0;
1613
1614 lock_sock(sk);
1615 /*
1616 * This works for seqpacket too. The receiver has ordered the
1617 * queue for us! We do one quick check first though
1618 */
1619 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1620 err = -ENOTCONN;
1621 goto out;
1622 }
1623
1624 /* Now we can treat all alike */
1625 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
528930b9 1626 flags & MSG_DONTWAIT, &err);
1da177e4
LT		 1627 if (skb == NULL)
1628 goto out;
1629
1630 if (!ax25_sk(sk)->pidincl)
1631 skb_pull(skb, 1); /* Remove PID */
1632
badff6d0
ACM		 1633 skb_reset_transport_header(skb);
1634 copied = skb->len;
1da177e4
LT		 1635
1636 if (copied > size) {
1637 copied = size;
1638 msg->msg_flags |= MSG_TRUNC;
1639 }
1640
1641 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1642
1643 if (msg->msg_namelen != 0) {
1644 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1645 ax25_digi digi;
1646 ax25_address src;
98e399f8 1647 const unsigned char *mac = skb_mac_header(skb);
1da177e4 1648
98e399f8
ACM		 1649 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1650 &digi, NULL, NULL);
1da177e4
LT		 1651 sax->sax25_family = AF_AX25;
1652 /* We set this correctly, even though we may not let the
1653 application know the digi calls further down (because it
1654 did NOT ask to know them). This could get political... **/
1655 sax->sax25_ndigis = digi.ndigi;
1656 sax->sax25_call = src;
1657
1658 if (sax->sax25_ndigis != 0) {
1659 int ct;
1660 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1661
1662 for (ct = 0; ct < digi.ndigi; ct++)
1663 fsa->fsa_digipeater[ct] = digi.calls[ct];
1664 }
1665 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1666 }
1667
1668 skb_free_datagram(sk, skb);
1669 err = copied;
1670
1671out:
1672 release_sock(sk);
1673
1674 return err;
1675}
1676
1677static int ax25_shutdown(struct socket *sk, int how)
1678{
1679 /* FIXME - generate DM and RNR states */
1680 return -EOPNOTSUPP;
1681}
1682
1683static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1684{
1685 struct sock *sk = sock->sk;
1686 void __user *argp = (void __user *)arg;
1687 int res = 0;
1688
1689 lock_sock(sk);
1690 switch (cmd) {
1691 case TIOCOUTQ: {
1692 long amount;
31e6d363
ED		 1693
1694 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1da177e4
LT		 1695 if (amount < 0)
1696 amount = 0;
1697 res = put_user(amount, (int __user *)argp);
1698 break;
1699 }
1700
1701 case TIOCINQ: {
1702 struct sk_buff *skb;
1703 long amount = 0L;
1704 /* These two are safe on a single CPU system as only user tasks fiddle here */
1705 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1706 amount = skb->len;
20b7d10a 1707 res = put_user(amount, (int __user *) argp);
1da177e4
LT		 1708 break;
1709 }
1710
1711 case SIOCGSTAMP:
9b37ee75 1712 res = sock_get_timestamp(sk, argp);
1da177e4
LT		 1713 break;
1714
ae40eb1e
ED		 1715 case SIOCGSTAMPNS:
1716 res = sock_get_timestampns(sk, argp);
1717 break;
1718
1da177e4
LT		 1719 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1720 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1721 case SIOCAX25GETUID: {
1722 struct sockaddr_ax25 sax25;
1723 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1724 res = -EFAULT;
1725 break;
1726 }
1727 res = ax25_uid_ioctl(cmd, &sax25);
1728 break;
1729 }
1730
1731 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1732 long amount;
1733 if (!capable(CAP_NET_ADMIN)) {
1734 res = -EPERM;
1735 break;
1736 }
1737 if (get_user(amount, (long __user *)argp)) {
1738 res = -EFAULT;
1739 break;
1740 }
1741 if (amount > AX25_NOUID_BLOCK) {
1742 res = -EINVAL;
1743 break;
1744 }
1745 ax25_uid_policy = amount;
1746 res = 0;
1747 break;
1748 }
1749
1750 case SIOCADDRT:
1751 case SIOCDELRT:
1752 case SIOCAX25OPTRT:
1753 if (!capable(CAP_NET_ADMIN)) {
1754 res = -EPERM;
1755 break;
1756 }
1757 res = ax25_rt_ioctl(cmd, argp);
1758 break;
1759
1760 case SIOCAX25CTLCON:
1761 if (!capable(CAP_NET_ADMIN)) {
1762 res = -EPERM;
1763 break;
1764 }
1765 res = ax25_ctl_ioctl(cmd, argp);
1766 break;
1767
1768 case SIOCAX25GETINFO:
1769 case SIOCAX25GETINFOOLD: {
1770 ax25_cb *ax25 = ax25_sk(sk);
1771 struct ax25_info_struct ax25_info;
1772
1773 ax25_info.t1 = ax25->t1 / HZ;
1774 ax25_info.t2 = ax25->t2 / HZ;
1775 ax25_info.t3 = ax25->t3 / HZ;
1776 ax25_info.idle = ax25->idle / (60 * HZ);
1777 ax25_info.n2 = ax25->n2;
1778 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1779 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1780 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1781 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1782 ax25_info.n2count = ax25->n2count;
1783 ax25_info.state = ax25->state;
407fc5cf
ED		 1784 ax25_info.rcv_q = sk_rmem_alloc_get(sk);
1785 ax25_info.snd_q = sk_wmem_alloc_get(sk);
1da177e4
LT		 1786 ax25_info.vs = ax25->vs;
1787 ax25_info.vr = ax25->vr;
1788 ax25_info.va = ax25->va;
1789 ax25_info.vs_max = ax25->vs; /* reserved */
1790 ax25_info.paclen = ax25->paclen;
1791 ax25_info.window = ax25->window;
1792
1793 /* old structure? */
1794 if (cmd == SIOCAX25GETINFOOLD) {
1795 static int warned = 0;
1796 if (!warned) {
1797 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1798 current->comm);
1799 warned=1;
1800 }
1801
1802 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1803 res = -EFAULT;
1804 break;
1805 }
1806 } else {
1807 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1808 res = -EINVAL;
1809 break;
1810 }
1811 }
1812 res = 0;
1813 break;
1814 }
1815
1816 case SIOCAX25ADDFWD:
1817 case SIOCAX25DELFWD: {
1818 struct ax25_fwd_struct ax25_fwd;
1819 if (!capable(CAP_NET_ADMIN)) {
1820 res = -EPERM;
1821 break;
1822 }
1823 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1824 res = -EFAULT;
1825 break;
1826 }
1827 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1828 break;
1829 }
1830
1831 case SIOCGIFADDR:
1832 case SIOCSIFADDR:
1833 case SIOCGIFDSTADDR:
1834 case SIOCSIFDSTADDR:
1835 case SIOCGIFBRDADDR:
1836 case SIOCSIFBRDADDR:
1837 case SIOCGIFNETMASK:
1838 case SIOCSIFNETMASK:
1839 case SIOCGIFMETRIC:
1840 case SIOCSIFMETRIC:
1841 res = -EINVAL;
1842 break;
1843
1844 default:
b5e5fa5e 1845 res = -ENOIOCTLCMD;
1da177e4
LT		 1846 break;
1847 }
1848 release_sock(sk);
1849
1850 return res;
1851}
1852
1853#ifdef CONFIG_PROC_FS
1854
1855static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
f16f3026 1856 __acquires(ax25_list_lock)
1da177e4 1857{
1da177e4 1858 spin_lock_bh(&ax25_list_lock);
b512f3d8 1859 return seq_hlist_start(&ax25_list, *pos);
1da177e4
LT		 1860}
1861
1862static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1863{
b512f3d8 1864 return seq_hlist_next(v, &ax25_list, pos);
1da177e4 1865}
528930b9 1866
1da177e4 1867static void ax25_info_stop(struct seq_file *seq, void *v)
f16f3026 1868 __releases(ax25_list_lock)
1da177e4
LT		 1869{
1870 spin_unlock_bh(&ax25_list_lock);
1871}
1872
1873static int ax25_info_show(struct seq_file *seq, void *v)
1874{
b512f3d8 1875 ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
f75268cd 1876 char buf[11];
1da177e4
LT		 1877 int k;
1878
1879
1880 /*
1881 * New format:
1882 * magic dev src_addr dest_addr,digi1,digi2,.. st vs vr va t1 t1 t2 t2 t3 t3 idle idle n2 n2 rtt window paclen Snd-Q Rcv-Q inode
1883 */
1884
1885 seq_printf(seq, "%8.8lx %s %s%s ",
1886 (long) ax25,
1887 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
f75268cd 1888 ax2asc(buf, &ax25->source_addr),
1da177e4 1889 ax25->iamdigi? "*":"");
f75268cd 1890 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1da177e4
LT		 1891
1892 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1893 seq_printf(seq, ",%s%s",
f75268cd 1894 ax2asc(buf, &ax25->digipeat->calls[k]),
1da177e4
LT		 1895 ax25->digipeat->repeated[k]? "*":"");
1896 }
1897
1898 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1899 ax25->state,
1900 ax25->vs, ax25->vr, ax25->va,
1901 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1902 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1903 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1904 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1905 ax25->idle / (60 * HZ),
1906 ax25->n2count, ax25->n2,
1907 ax25->rtt / HZ,
1908 ax25->window,
1909 ax25->paclen);
1910
1911 if (ax25->sk != NULL) {
1105b5d1 1912 seq_printf(seq, " %d %d %lu\n",
31e6d363
ED		 1913 sk_wmem_alloc_get(ax25->sk),
1914 sk_rmem_alloc_get(ax25->sk),
1105b5d1 1915 sock_i_ino(ax25->sk));
1da177e4
LT		 1916 } else {
1917 seq_puts(seq, " * * *\n");
1918 }
1919 return 0;
1920}
1921
56b3d975 1922static const struct seq_operations ax25_info_seqops = {
1da177e4
LT		 1923 .start = ax25_info_start,
1924 .next = ax25_info_next,
1925 .stop = ax25_info_stop,
1926 .show = ax25_info_show,
1927};
1928
1929static int ax25_info_open(struct inode *inode, struct file *file)
1930{
1931 return seq_open(file, &ax25_info_seqops);
1932}
1933
9a32144e 1934static const struct file_operations ax25_info_fops = {
1da177e4
LT		 1935 .owner = THIS_MODULE,
1936 .open = ax25_info_open,
1937 .read = seq_read,
1938 .llseek = seq_lseek,
1939 .release = seq_release,
1940};
1941
1942#endif
1943
ec1b4cf7 1944static const struct net_proto_family ax25_family_ops = {
1da177e4
LT		 1945 .family = PF_AX25,
1946 .create = ax25_create,
1947 .owner = THIS_MODULE,
1948};
1949
90ddc4f0 1950static const struct proto_ops ax25_proto_ops = {
4676356b
RB		 1951 .family = PF_AX25,
1952 .owner = THIS_MODULE,
1953 .release = ax25_release,
1954 .bind = ax25_bind,
1955 .connect = ax25_connect,
1956 .socketpair = sock_no_socketpair,
1957 .accept = ax25_accept,
1958 .getname = ax25_getname,
1959 .poll = datagram_poll,
1960 .ioctl = ax25_ioctl,
1961 .listen = ax25_listen,
1962 .shutdown = ax25_shutdown,
1963 .setsockopt = ax25_setsockopt,
1964 .getsockopt = ax25_getsockopt,
1965 .sendmsg = ax25_sendmsg,
1966 .recvmsg = ax25_recvmsg,
1967 .mmap = sock_no_mmap,
1968 .sendpage = sock_no_sendpage,
1da177e4
LT		 1969};
1970
1971/*
1972 * Called by socket.c on kernel start up
1973 */
7546dd97 1974static struct packet_type ax25_packet_type __read_mostly = {
09640e63 1975 .type = cpu_to_be16(ETH_P_AX25),
1da177e4
LT		 1976 .func = ax25_kiss_rcv,
1977};
1978
1979static struct notifier_block ax25_dev_notifier = {
1980 .notifier_call =ax25_device_event,
1981};
1982
1da177e4
LT		 1983static int __init ax25_init(void)
1984{
1985 int rc = proto_register(&ax25_proto, 0);
1986
1987 if (rc != 0)
1988 goto out;
1989
1990 sock_register(&ax25_family_ops);
1991 dev_add_pack(&ax25_packet_type);
1992 register_netdevice_notifier(&ax25_dev_notifier);
1993 ax25_register_sysctl();
1994
457c4cbc
EB		 1995 proc_net_fops_create(&init_net, "ax25_route", S_IRUGO, &ax25_route_fops);
1996 proc_net_fops_create(&init_net, "ax25", S_IRUGO, &ax25_info_fops);
1997 proc_net_fops_create(&init_net, "ax25_calls", S_IRUGO, &ax25_uid_fops);
1da177e4
LT		 1998out:
1999 return rc;
2000}
2001module_init(ax25_init);
2002
2003
2004MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2005MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2006MODULE_LICENSE("GPL");
2007MODULE_ALIAS_NETPROTO(PF_AX25);
2008
2009static void __exit ax25_exit(void)
2010{
457c4cbc
EB		 2011 proc_net_remove(&init_net, "ax25_route");
2012 proc_net_remove(&init_net, "ax25");
2013 proc_net_remove(&init_net, "ax25_calls");
1da177e4
LT		 2014 ax25_rt_free();
2015 ax25_uid_free();
2016 ax25_dev_free();
2017
2018 ax25_unregister_sysctl();
2019 unregister_netdevice_notifier(&ax25_dev_notifier);
2020
2021 dev_remove_pack(&ax25_packet_type);
2022
2023 sock_unregister(PF_AX25);
2024 proto_unregister(&ax25_proto);
2025}
2026module_exit(ax25_exit);
Linux kernel - Deliverables
This page took 1.480239 seconds and 5 git commands to generate.