blob: 01c83e2a4c196f813122158af5aa5bf5ea13cbd0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 */
Randy Dunlap4fc268d2006-01-11 12:17:47 -080016#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/sockios.h>
27#include <linux/net.h>
28#include <net/ax25.h>
29#include <linux/inet.h>
30#include <linux/netdevice.h>
31#include <linux/if_arp.h>
32#include <linux/skbuff.h>
33#include <net/sock.h>
34#include <asm/uaccess.h>
35#include <asm/system.h>
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>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020047#include <net/net_namespace.h>
Arnaldo Carvalho de Meloc752f072005-08-09 20:08:28 -070048#include <net/tcp_states.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#include <net/ip.h>
50#include <net/arp.h>
51
52
53
54HLIST_HEAD(ax25_list);
55DEFINE_SPINLOCK(ax25_list_lock);
56
Eric Dumazet90ddc4f2005-12-22 12:49:22 -080057static const struct proto_ops ax25_proto_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
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);
Jarek Poplawskiecd2ebd2008-01-10 21:21:20 -080090again:
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 ax25_for_each(s, node, &ax25_list) {
92 if (s->ax25_dev == ax25_dev) {
93 s->ax25_dev = NULL;
Jarek Poplawskiecd2ebd2008-01-10 21:21:20 -080094 spin_unlock_bh(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 ax25_disconnect(s, ENETUNREACH);
Jarek Poplawskiecd2ebd2008-01-10 21:21:20 -080096 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 }
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
YOSHIFUJI Hideaki721499e2008-07-19 22:34:43 -0700119 if (!net_eq(dev_net(dev), &init_net))
Eric W. Biedermane9dc8652007-09-12 13:02:17 +0200120 return NOTIFY_DONE;
121
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 /* 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
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700163 spin_lock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 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);
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700172 spin_unlock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 return s->sk;
174 }
175 }
176 }
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700177 spin_unlock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
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
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700192 spin_lock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 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
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700203 spin_unlock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
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
Ralf Baechle70868ea2006-05-03 23:25:17 -0700245EXPORT_SYMBOL(ax25_find_cb);
246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247void 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
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700253 spin_lock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 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 }
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700266 spin_unlock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267}
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;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900281
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 sk=ax25->sk;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900283
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 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
320 ax25_start_heartbeat(sax25);
321 sax25->state = AX25_STATE_0;
322 }
323
324 kfree_skb(skb);
325 }
326 skb_queue_purge(&ax25->sk->sk_write_queue);
327 }
328
329 if (ax25->sk != NULL) {
330 if (atomic_read(&ax25->sk->sk_wmem_alloc) ||
331 atomic_read(&ax25->sk->sk_rmem_alloc)) {
332 /* Defer: outstanding buffers */
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800333 setup_timer(&ax25->dtimer, ax25_destroy_timer,
334 (unsigned long)ax25);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 ax25->dtimer.expires = jiffies + 2 * HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 add_timer(&ax25->dtimer);
337 } else {
338 struct sock *sk=ax25->sk;
339 ax25->sk=NULL;
340 sock_put(sk);
341 }
342 } else {
343 ax25_cb_put(ax25);
344 }
345}
346
347/*
348 * dl1bke 960311: set parameters for existing AX.25 connections,
349 * includes a KILL command to abort any connection.
350 * VERY useful for debugging ;-)
351 */
352static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
353{
354 struct ax25_ctl_struct ax25_ctl;
355 ax25_digi digi;
356 ax25_dev *ax25_dev;
357 ax25_cb *ax25;
358 unsigned int k;
359
360 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
361 return -EFAULT;
362
363 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
364 return -ENODEV;
365
366 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
367 return -EINVAL;
368
369 digi.ndigi = ax25_ctl.digi_count;
370 for (k = 0; k < digi.ndigi; k++)
371 digi.calls[k] = ax25_ctl.digi_addr[k];
372
373 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
374 return -ENOTCONN;
375
376 switch (ax25_ctl.cmd) {
377 case AX25_KILL:
378 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
379#ifdef CONFIG_AX25_DAMA_SLAVE
380 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
381 ax25_dama_off(ax25);
382#endif
383 ax25_disconnect(ax25, ENETRESET);
384 break;
385
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900386 case AX25_WINDOW:
387 if (ax25->modulus == AX25_MODULUS) {
388 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
389 return -EINVAL;
390 } else {
391 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
392 return -EINVAL;
393 }
394 ax25->window = ax25_ctl.arg;
395 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900397 case AX25_T1:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 if (ax25_ctl.arg < 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 return -EINVAL;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900400 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
401 ax25->t1 = ax25_ctl.arg * HZ;
402 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900404 case AX25_T2:
405 if (ax25_ctl.arg < 1)
406 return -EINVAL;
407 ax25->t2 = ax25_ctl.arg * HZ;
408 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900410 case AX25_N2:
411 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
412 return -EINVAL;
413 ax25->n2count = 0;
414 ax25->n2 = ax25_ctl.arg;
415 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900417 case AX25_T3:
418 if (ax25_ctl.arg < 0)
419 return -EINVAL;
420 ax25->t3 = ax25_ctl.arg * HZ;
421 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900423 case AX25_IDLE:
424 if (ax25_ctl.arg < 0)
425 return -EINVAL;
426 ax25->idle = ax25_ctl.arg * 60 * HZ;
427 break;
428
429 case AX25_PACLEN:
430 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
431 return -EINVAL;
432 ax25->paclen = ax25_ctl.arg;
433 break;
434
435 default:
436 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 }
438
439 return 0;
440}
441
Ralf Baechlee1fdb5b2006-05-03 23:27:16 -0700442static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
443{
444 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
445 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
446 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
447 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
448 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
449 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
450 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
451 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
452
453 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
454 ax25->modulus = AX25_EMODULUS;
455 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
456 } else {
457 ax25->modulus = AX25_MODULUS;
458 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
459 }
460}
461
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462/*
463 * Fill in a created AX.25 created control block with the default
464 * values for a particular device.
465 */
466void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
467{
468 ax25->ax25_dev = ax25_dev;
469
470 if (ax25->ax25_dev != NULL) {
Ralf Baechlee1fdb5b2006-05-03 23:27:16 -0700471 ax25_fillin_cb_from_dev(ax25, ax25_dev);
472 return;
473 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
Ralf Baechlee1fdb5b2006-05-03 23:27:16 -0700475 /*
476 * No device, use kernel / AX.25 spec default values
477 */
478 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
479 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
480 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
481 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
482 ax25->n2 = AX25_DEF_N2;
483 ax25->paclen = AX25_DEF_PACLEN;
484 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
485 ax25->backoff = AX25_DEF_BACKOFF;
486
487 if (AX25_DEF_AXDEFMODE) {
488 ax25->modulus = AX25_EMODULUS;
489 ax25->window = AX25_DEF_EWINDOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 } else {
Ralf Baechlee1fdb5b2006-05-03 23:27:16 -0700491 ax25->modulus = AX25_MODULUS;
492 ax25->window = AX25_DEF_WINDOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 }
494}
495
496/*
497 * Create an empty AX.25 control block.
498 */
499ax25_cb *ax25_create_cb(void)
500{
501 ax25_cb *ax25;
502
Ralf Baechle1b30dd32006-07-09 12:14:22 -0700503 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 return NULL;
505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 atomic_set(&ax25->refcount, 1);
507
508 skb_queue_head_init(&ax25->write_queue);
509 skb_queue_head_init(&ax25->frag_queue);
510 skb_queue_head_init(&ax25->ack_queue);
511 skb_queue_head_init(&ax25->reseq_queue);
512
Jarek Poplawski21fab4a2008-02-11 21:36:39 -0800513 ax25_setup_timers(ax25);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
515 ax25_fillin_cb(ax25, NULL);
516
517 ax25->state = AX25_STATE_0;
518
519 return ax25;
520}
521
522/*
523 * Handling for system calls applied via the various interfaces to an
524 * AX25 socket object
525 */
526
527static int ax25_setsockopt(struct socket *sock, int level, int optname,
528 char __user *optval, int optlen)
529{
530 struct sock *sk = sock->sk;
531 ax25_cb *ax25;
532 struct net_device *dev;
533 char devname[IFNAMSIZ];
534 int opt, res = 0;
535
536 if (level != SOL_AX25)
537 return -ENOPROTOOPT;
538
539 if (optlen < sizeof(int))
540 return -EINVAL;
541
542 if (get_user(opt, (int __user *)optval))
543 return -EFAULT;
544
545 lock_sock(sk);
546 ax25 = ax25_sk(sk);
547
548 switch (optname) {
549 case AX25_WINDOW:
550 if (ax25->modulus == AX25_MODULUS) {
551 if (opt < 1 || opt > 7) {
552 res = -EINVAL;
553 break;
554 }
555 } else {
556 if (opt < 1 || opt > 63) {
557 res = -EINVAL;
558 break;
559 }
560 }
561 ax25->window = opt;
562 break;
563
564 case AX25_T1:
565 if (opt < 1) {
566 res = -EINVAL;
567 break;
568 }
Eric Dumazetf16f3022008-01-13 22:29:41 -0800569 ax25->rtt = (opt * HZ) >> 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 ax25->t1 = opt * HZ;
571 break;
572
573 case AX25_T2:
574 if (opt < 1) {
575 res = -EINVAL;
576 break;
577 }
578 ax25->t2 = opt * HZ;
579 break;
580
581 case AX25_N2:
582 if (opt < 1 || opt > 31) {
583 res = -EINVAL;
584 break;
585 }
586 ax25->n2 = opt;
587 break;
588
589 case AX25_T3:
590 if (opt < 1) {
591 res = -EINVAL;
592 break;
593 }
594 ax25->t3 = opt * HZ;
595 break;
596
597 case AX25_IDLE:
598 if (opt < 0) {
599 res = -EINVAL;
600 break;
601 }
602 ax25->idle = opt * 60 * HZ;
603 break;
604
605 case AX25_BACKOFF:
606 if (opt < 0 || opt > 2) {
607 res = -EINVAL;
608 break;
609 }
610 ax25->backoff = opt;
611 break;
612
613 case AX25_EXTSEQ:
614 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
615 break;
616
617 case AX25_PIDINCL:
618 ax25->pidincl = opt ? 1 : 0;
619 break;
620
621 case AX25_IAMDIGI:
622 ax25->iamdigi = opt ? 1 : 0;
623 break;
624
625 case AX25_PACLEN:
626 if (opt < 16 || opt > 65535) {
627 res = -EINVAL;
628 break;
629 }
630 ax25->paclen = opt;
631 break;
632
633 case SO_BINDTODEVICE:
634 if (optlen > IFNAMSIZ)
635 optlen=IFNAMSIZ;
636 if (copy_from_user(devname, optval, optlen)) {
637 res = -EFAULT;
638 break;
639 }
640
Eric W. Biederman881d9662007-09-17 11:56:21 -0700641 dev = dev_get_by_name(&init_net, devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 if (dev == NULL) {
643 res = -ENODEV;
644 break;
645 }
646
647 if (sk->sk_type == SOCK_SEQPACKET &&
648 (sock->state != SS_UNCONNECTED ||
649 sk->sk_state == TCP_LISTEN)) {
650 res = -EADDRNOTAVAIL;
651 dev_put(dev);
652 break;
653 }
654
655 ax25->ax25_dev = ax25_dev_ax25dev(dev);
656 ax25_fillin_cb(ax25, ax25->ax25_dev);
657 break;
658
659 default:
660 res = -ENOPROTOOPT;
661 }
662 release_sock(sk);
663
664 return res;
665}
666
667static int ax25_getsockopt(struct socket *sock, int level, int optname,
668 char __user *optval, int __user *optlen)
669{
670 struct sock *sk = sock->sk;
671 ax25_cb *ax25;
672 struct ax25_dev *ax25_dev;
673 char devname[IFNAMSIZ];
674 void *valptr;
675 int val = 0;
676 int maxlen, length;
677
678 if (level != SOL_AX25)
679 return -ENOPROTOOPT;
680
681 if (get_user(maxlen, optlen))
682 return -EFAULT;
683
684 if (maxlen < 1)
685 return -EFAULT;
686
687 valptr = (void *) &val;
688 length = min_t(unsigned int, maxlen, sizeof(int));
689
690 lock_sock(sk);
691 ax25 = ax25_sk(sk);
692
693 switch (optname) {
694 case AX25_WINDOW:
695 val = ax25->window;
696 break;
697
698 case AX25_T1:
699 val = ax25->t1 / HZ;
700 break;
701
702 case AX25_T2:
703 val = ax25->t2 / HZ;
704 break;
705
706 case AX25_N2:
707 val = ax25->n2;
708 break;
709
710 case AX25_T3:
711 val = ax25->t3 / HZ;
712 break;
713
714 case AX25_IDLE:
715 val = ax25->idle / (60 * HZ);
716 break;
717
718 case AX25_BACKOFF:
719 val = ax25->backoff;
720 break;
721
722 case AX25_EXTSEQ:
723 val = (ax25->modulus == AX25_EMODULUS);
724 break;
725
726 case AX25_PIDINCL:
727 val = ax25->pidincl;
728 break;
729
730 case AX25_IAMDIGI:
731 val = ax25->iamdigi;
732 break;
733
734 case AX25_PACLEN:
735 val = ax25->paclen;
736 break;
737
738 case SO_BINDTODEVICE:
739 ax25_dev = ax25->ax25_dev;
740
741 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
742 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
743 length = strlen(devname) + 1;
744 } else {
745 *devname = '\0';
746 length = 1;
747 }
748
749 valptr = (void *) devname;
750 break;
751
752 default:
753 release_sock(sk);
754 return -ENOPROTOOPT;
755 }
756 release_sock(sk);
757
758 if (put_user(length, optlen))
759 return -EFAULT;
760
761 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
762}
763
764static int ax25_listen(struct socket *sock, int backlog)
765{
766 struct sock *sk = sock->sk;
767 int res = 0;
768
769 lock_sock(sk);
770 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
771 sk->sk_max_ack_backlog = backlog;
772 sk->sk_state = TCP_LISTEN;
773 goto out;
774 }
775 res = -EOPNOTSUPP;
776
777out:
778 release_sock(sk);
779
780 return res;
781}
782
783/*
784 * XXX: when creating ax25_sock we should update the .obj_size setting
785 * below.
786 */
787static struct proto ax25_proto = {
788 .name = "AX25",
789 .owner = THIS_MODULE,
790 .obj_size = sizeof(struct sock),
791};
792
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700793static int ax25_create(struct net *net, struct socket *sock, int protocol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794{
795 struct sock *sk;
796 ax25_cb *ax25;
797
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700798 if (net != &init_net)
799 return -EAFNOSUPPORT;
800
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 switch (sock->type) {
802 case SOCK_DGRAM:
803 if (protocol == 0 || protocol == PF_AX25)
804 protocol = AX25_P_TEXT;
805 break;
806
807 case SOCK_SEQPACKET:
808 switch (protocol) {
809 case 0:
810 case PF_AX25: /* For CLX */
811 protocol = AX25_P_TEXT;
812 break;
813 case AX25_P_SEGMENT:
814#ifdef CONFIG_INET
815 case AX25_P_ARP:
816 case AX25_P_IP:
817#endif
818#ifdef CONFIG_NETROM
819 case AX25_P_NETROM:
820#endif
821#ifdef CONFIG_ROSE
822 case AX25_P_ROSE:
823#endif
824 return -ESOCKTNOSUPPORT;
825#ifdef CONFIG_NETROM_MODULE
826 case AX25_P_NETROM:
827 if (ax25_protocol_is_registered(AX25_P_NETROM))
828 return -ESOCKTNOSUPPORT;
829#endif
830#ifdef CONFIG_ROSE_MODULE
831 case AX25_P_ROSE:
832 if (ax25_protocol_is_registered(AX25_P_ROSE))
833 return -ESOCKTNOSUPPORT;
834#endif
835 default:
836 break;
837 }
838 break;
839
840 case SOCK_RAW:
841 break;
842 default:
843 return -ESOCKTNOSUPPORT;
844 }
845
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700846 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
847 if (sk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 return -ENOMEM;
849
850 ax25 = sk->sk_protinfo = ax25_create_cb();
851 if (!ax25) {
852 sk_free(sk);
853 return -ENOMEM;
854 }
855
856 sock_init_data(sock, sk);
857
858 sk->sk_destruct = ax25_free_sock;
859 sock->ops = &ax25_proto_ops;
860 sk->sk_protocol = protocol;
861
862 ax25->sk = sk;
863
864 return 0;
865}
866
867struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
868{
869 struct sock *sk;
870 ax25_cb *ax25, *oax25;
871
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900872 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot);
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700873 if (sk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 return NULL;
875
876 if ((ax25 = ax25_create_cb()) == NULL) {
877 sk_free(sk);
878 return NULL;
879 }
880
881 switch (osk->sk_type) {
882 case SOCK_DGRAM:
883 break;
884 case SOCK_SEQPACKET:
885 break;
886 default:
887 sk_free(sk);
888 ax25_cb_put(ax25);
889 return NULL;
890 }
891
892 sock_init_data(NULL, sk);
893
894 sk->sk_destruct = ax25_free_sock;
895 sk->sk_type = osk->sk_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 sk->sk_priority = osk->sk_priority;
897 sk->sk_protocol = osk->sk_protocol;
898 sk->sk_rcvbuf = osk->sk_rcvbuf;
899 sk->sk_sndbuf = osk->sk_sndbuf;
900 sk->sk_state = TCP_ESTABLISHED;
Ralf Baechle53b924b2005-08-23 10:11:30 -0700901 sock_copy_flags(sk, osk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902
903 oax25 = ax25_sk(osk);
904
905 ax25->modulus = oax25->modulus;
906 ax25->backoff = oax25->backoff;
907 ax25->pidincl = oax25->pidincl;
908 ax25->iamdigi = oax25->iamdigi;
909 ax25->rtt = oax25->rtt;
910 ax25->t1 = oax25->t1;
911 ax25->t2 = oax25->t2;
912 ax25->t3 = oax25->t3;
913 ax25->n2 = oax25->n2;
914 ax25->idle = oax25->idle;
915 ax25->paclen = oax25->paclen;
916 ax25->window = oax25->window;
917
918 ax25->ax25_dev = ax25_dev;
919 ax25->source_addr = oax25->source_addr;
920
921 if (oax25->digipeat != NULL) {
Arnaldo Carvalho de Melo0459d70a2006-11-17 12:43:07 -0200922 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
923 GFP_ATOMIC);
924 if (ax25->digipeat == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 sk_free(sk);
926 ax25_cb_put(ax25);
927 return NULL;
928 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 }
930
931 sk->sk_protinfo = ax25;
932 ax25->sk = sk;
933
934 return sk;
935}
936
937static int ax25_release(struct socket *sock)
938{
939 struct sock *sk = sock->sk;
940 ax25_cb *ax25;
941
942 if (sk == NULL)
943 return 0;
944
945 sock_hold(sk);
946 sock_orphan(sk);
947 lock_sock(sk);
948 ax25 = ax25_sk(sk);
949
950 if (sk->sk_type == SOCK_SEQPACKET) {
951 switch (ax25->state) {
952 case AX25_STATE_0:
953 release_sock(sk);
954 ax25_disconnect(ax25, 0);
955 lock_sock(sk);
956 ax25_destroy_socket(ax25);
957 break;
958
959 case AX25_STATE_1:
960 case AX25_STATE_2:
961 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
962 release_sock(sk);
963 ax25_disconnect(ax25, 0);
964 lock_sock(sk);
965 ax25_destroy_socket(ax25);
966 break;
967
968 case AX25_STATE_3:
969 case AX25_STATE_4:
970 ax25_clear_queues(ax25);
971 ax25->n2count = 0;
972
973 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
974 case AX25_PROTO_STD_SIMPLEX:
975 case AX25_PROTO_STD_DUPLEX:
976 ax25_send_control(ax25,
977 AX25_DISC,
978 AX25_POLLON,
979 AX25_COMMAND);
980 ax25_stop_t2timer(ax25);
981 ax25_stop_t3timer(ax25);
982 ax25_stop_idletimer(ax25);
983 break;
984#ifdef CONFIG_AX25_DAMA_SLAVE
985 case AX25_PROTO_DAMA_SLAVE:
986 ax25_stop_t3timer(ax25);
987 ax25_stop_idletimer(ax25);
988 break;
989#endif
990 }
991 ax25_calculate_t1(ax25);
992 ax25_start_t1timer(ax25);
993 ax25->state = AX25_STATE_2;
994 sk->sk_state = TCP_CLOSE;
995 sk->sk_shutdown |= SEND_SHUTDOWN;
996 sk->sk_state_change(sk);
997 sock_set_flag(sk, SOCK_DESTROY);
998 break;
999
1000 default:
1001 break;
1002 }
1003 } else {
1004 sk->sk_state = TCP_CLOSE;
1005 sk->sk_shutdown |= SEND_SHUTDOWN;
1006 sk->sk_state_change(sk);
1007 ax25_destroy_socket(ax25);
1008 }
1009
1010 sock->sk = NULL;
1011 release_sock(sk);
1012 sock_put(sk);
1013
1014 return 0;
1015}
1016
1017/*
1018 * We support a funny extension here so you can (as root) give any callsign
1019 * digipeated via a local address as source. This hack is obsolete now
1020 * that we've implemented support for SO_BINDTODEVICE. It is however small
1021 * and trivially backward compatible.
1022 */
1023static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1024{
1025 struct sock *sk = sock->sk;
1026 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1027 ax25_dev *ax25_dev = NULL;
Ralf Baechle01d7dd02005-08-23 10:11:45 -07001028 ax25_uid_assoc *user;
1029 ax25_address call;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 ax25_cb *ax25;
1031 int err = 0;
1032
1033 if (addr_len != sizeof(struct sockaddr_ax25) &&
maximilian attems1987e7b2008-01-28 20:44:11 -08001034 addr_len != sizeof(struct full_sockaddr_ax25))
1035 /* support for old structure may go away some time
1036 * ax25_bind(): uses old (6 digipeater) socket structure.
1037 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
maximilian attems1987e7b2008-01-28 20:44:11 -08001039 (addr_len > sizeof(struct full_sockaddr_ax25)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041
1042 if (addr->fsa_ax25.sax25_family != AF_AX25)
1043 return -EINVAL;
1044
Ralf Baechle01d7dd02005-08-23 10:11:45 -07001045 user = ax25_findbyuid(current->euid);
1046 if (user) {
1047 call = user->call;
1048 ax25_uid_put(user);
1049 } else {
1050 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1051 return -EACCES;
1052
1053 call = addr->fsa_ax25.sax25_call;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 }
1055
1056 lock_sock(sk);
1057
1058 ax25 = ax25_sk(sk);
1059 if (!sock_flag(sk, SOCK_ZAPPED)) {
1060 err = -EINVAL;
1061 goto out;
1062 }
1063
Ralf Baechle01d7dd02005-08-23 10:11:45 -07001064 ax25->source_addr = call;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
1066 /*
1067 * User already set interface with SO_BINDTODEVICE
1068 */
1069 if (ax25->ax25_dev != NULL)
1070 goto done;
1071
1072 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1073 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1074 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1075 err = -EADDRNOTAVAIL;
1076 goto out;
1077 }
1078 } else {
1079 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1080 err = -EADDRNOTAVAIL;
1081 goto out;
1082 }
1083 }
1084
1085 if (ax25_dev != NULL)
1086 ax25_fillin_cb(ax25, ax25_dev);
1087
1088done:
1089 ax25_cb_add(ax25);
1090 sock_reset_flag(sk, SOCK_ZAPPED);
1091
1092out:
1093 release_sock(sk);
1094
1095 return 0;
1096}
1097
1098/*
1099 * FIXME: nonblock behaviour looks like it may have a bug.
1100 */
Ralf Baechlec9266b92006-12-14 15:49:28 -08001101static int __must_check ax25_connect(struct socket *sock,
1102 struct sockaddr *uaddr, int addr_len, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103{
1104 struct sock *sk = sock->sk;
1105 ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1106 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1107 ax25_digi *digi = NULL;
1108 int ct = 0, err = 0;
1109
1110 /*
1111 * some sanity checks. code further down depends on this
1112 */
1113
maximilian attems27d1cba2008-01-10 03:57:29 -08001114 if (addr_len == sizeof(struct sockaddr_ax25))
1115 /* support for this will go away in early 2.5.x
1116 * ax25_connect(): uses obsolete socket structure
1117 */
1118 ;
1119 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1120 /* support for old structure may go away some time
1121 * ax25_connect(): uses old (6 digipeater) socket structure.
1122 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
maximilian attems27d1cba2008-01-10 03:57:29 -08001124 (addr_len > sizeof(struct full_sockaddr_ax25)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127
1128 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1129 return -EINVAL;
1130
1131 lock_sock(sk);
1132
1133 /* deal with restarts */
1134 if (sock->state == SS_CONNECTING) {
1135 switch (sk->sk_state) {
1136 case TCP_SYN_SENT: /* still trying */
1137 err = -EINPROGRESS;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001138 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139
1140 case TCP_ESTABLISHED: /* connection established */
1141 sock->state = SS_CONNECTED;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001142 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143
1144 case TCP_CLOSE: /* connection refused */
1145 sock->state = SS_UNCONNECTED;
1146 err = -ECONNREFUSED;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001147 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 }
1149 }
1150
1151 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1152 err = -EISCONN; /* No reconnect on a seqpacket socket */
Ralf Baechle75606dc2007-04-20 16:06:45 -07001153 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 }
1155
1156 sk->sk_state = TCP_CLOSE;
1157 sock->state = SS_UNCONNECTED;
1158
Jesper Juhla51482b2005-11-08 09:41:34 -08001159 kfree(ax25->digipeat);
1160 ax25->digipeat = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161
1162 /*
1163 * Handle digi-peaters to be used.
1164 */
1165 if (addr_len > sizeof(struct sockaddr_ax25) &&
1166 fsa->fsa_ax25.sax25_ndigis != 0) {
1167 /* Valid number of digipeaters ? */
1168 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1169 err = -EINVAL;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001170 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 }
1172
1173 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1174 err = -ENOBUFS;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001175 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 }
1177
1178 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1179 digi->lastrepeat = -1;
1180
1181 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1182 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1183 AX25_HBIT) && ax25->iamdigi) {
1184 digi->repeated[ct] = 1;
1185 digi->lastrepeat = ct;
1186 } else {
1187 digi->repeated[ct] = 0;
1188 }
1189 digi->calls[ct] = fsa->fsa_digipeater[ct];
1190 ct++;
1191 }
1192 }
1193
1194 /*
1195 * Must bind first - autobinding in this may or may not work. If
1196 * the socket is already bound, check to see if the device has
1197 * been filled in, error if it hasn't.
1198 */
1199 if (sock_flag(sk, SOCK_ZAPPED)) {
1200 /* check if we can remove this feature. It is broken. */
1201 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1202 current->comm);
1203 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1204 kfree(digi);
Ralf Baechle75606dc2007-04-20 16:06:45 -07001205 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 }
1207
1208 ax25_fillin_cb(ax25, ax25->ax25_dev);
1209 ax25_cb_add(ax25);
1210 } else {
1211 if (ax25->ax25_dev == NULL) {
1212 kfree(digi);
1213 err = -EHOSTUNREACH;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001214 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 }
1216 }
1217
1218 if (sk->sk_type == SOCK_SEQPACKET &&
1219 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001220 ax25->ax25_dev->dev))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 kfree(digi);
1222 err = -EADDRINUSE; /* Already such a connection */
1223 ax25_cb_put(ax25t);
Ralf Baechle75606dc2007-04-20 16:06:45 -07001224 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 }
1226
1227 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1228 ax25->digipeat = digi;
1229
1230 /* First the easy one */
1231 if (sk->sk_type != SOCK_SEQPACKET) {
1232 sock->state = SS_CONNECTED;
1233 sk->sk_state = TCP_ESTABLISHED;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001234 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 }
1236
1237 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1238 sock->state = SS_CONNECTING;
1239 sk->sk_state = TCP_SYN_SENT;
1240
1241 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1242 case AX25_PROTO_STD_SIMPLEX:
1243 case AX25_PROTO_STD_DUPLEX:
1244 ax25_std_establish_data_link(ax25);
1245 break;
1246
1247#ifdef CONFIG_AX25_DAMA_SLAVE
1248 case AX25_PROTO_DAMA_SLAVE:
1249 ax25->modulus = AX25_MODULUS;
1250 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1251 if (ax25->ax25_dev->dama.slave)
1252 ax25_ds_establish_data_link(ax25);
1253 else
1254 ax25_std_establish_data_link(ax25);
1255 break;
1256#endif
1257 }
1258
1259 ax25->state = AX25_STATE_1;
1260
1261 ax25_start_heartbeat(ax25);
1262
1263 /* Now the loop */
1264 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1265 err = -EINPROGRESS;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001266 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 }
1268
1269 if (sk->sk_state == TCP_SYN_SENT) {
Ralf Baechle75606dc2007-04-20 16:06:45 -07001270 DEFINE_WAIT(wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 for (;;) {
Ralf Baechle75606dc2007-04-20 16:06:45 -07001273 prepare_to_wait(sk->sk_sleep, &wait,
YOSHIFUJI Hideakibd3b0712007-07-19 10:43:13 +09001274 TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 if (sk->sk_state != TCP_SYN_SENT)
1276 break;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001277 if (!signal_pending(current)) {
1278 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 schedule();
1280 lock_sock(sk);
1281 continue;
1282 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001283 err = -ERESTARTSYS;
1284 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001286 finish_wait(sk->sk_sleep, &wait);
1287
1288 if (err)
1289 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 }
1291
1292 if (sk->sk_state != TCP_ESTABLISHED) {
1293 /* Not in ABM, not in WAIT_UA -> failed */
1294 sock->state = SS_UNCONNECTED;
1295 err = sock_error(sk); /* Always set at this point */
Ralf Baechle75606dc2007-04-20 16:06:45 -07001296 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 }
1298
1299 sock->state = SS_CONNECTED;
1300
Ralf Baechle75606dc2007-04-20 16:06:45 -07001301 err = 0;
1302out_release:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 release_sock(sk);
1304
1305 return err;
1306}
1307
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1309{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 struct sk_buff *skb;
1311 struct sock *newsk;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001312 DEFINE_WAIT(wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 struct sock *sk;
1314 int err = 0;
1315
1316 if (sock->state != SS_UNCONNECTED)
1317 return -EINVAL;
1318
1319 if ((sk = sock->sk) == NULL)
1320 return -EINVAL;
1321
1322 lock_sock(sk);
1323 if (sk->sk_type != SOCK_SEQPACKET) {
1324 err = -EOPNOTSUPP;
1325 goto out;
1326 }
1327
1328 if (sk->sk_state != TCP_LISTEN) {
1329 err = -EINVAL;
1330 goto out;
1331 }
1332
1333 /*
1334 * The read queue this time is holding sockets ready to use
1335 * hooked into the SABM we saved
1336 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 for (;;) {
Ralf Baechle75606dc2007-04-20 16:06:45 -07001338 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 skb = skb_dequeue(&sk->sk_receive_queue);
1340 if (skb)
1341 break;
1342
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 if (flags & O_NONBLOCK) {
Ralf Baechle75606dc2007-04-20 16:06:45 -07001344 err = -EWOULDBLOCK;
1345 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001347 if (!signal_pending(current)) {
1348 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 schedule();
1350 lock_sock(sk);
1351 continue;
1352 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001353 err = -ERESTARTSYS;
1354 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001356 finish_wait(sk->sk_sleep, &wait);
1357
1358 if (err)
1359 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360
1361 newsk = skb->sk;
David S. Miller9375cb82008-06-17 02:20:54 -07001362 sock_graft(newsk, newsock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
1364 /* Now attach up the new socket */
1365 kfree_skb(skb);
1366 sk->sk_ack_backlog--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 newsock->state = SS_CONNECTED;
1368
1369out:
1370 release_sock(sk);
1371
1372 return err;
1373}
1374
1375static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1376 int *uaddr_len, int peer)
1377{
1378 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1379 struct sock *sk = sock->sk;
1380 unsigned char ndigi, i;
1381 ax25_cb *ax25;
1382 int err = 0;
1383
1384 lock_sock(sk);
1385 ax25 = ax25_sk(sk);
1386
1387 if (peer != 0) {
1388 if (sk->sk_state != TCP_ESTABLISHED) {
1389 err = -ENOTCONN;
1390 goto out;
1391 }
1392
1393 fsa->fsa_ax25.sax25_family = AF_AX25;
1394 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1395 fsa->fsa_ax25.sax25_ndigis = 0;
1396
1397 if (ax25->digipeat != NULL) {
1398 ndigi = ax25->digipeat->ndigi;
1399 fsa->fsa_ax25.sax25_ndigis = ndigi;
1400 for (i = 0; i < ndigi; i++)
1401 fsa->fsa_digipeater[i] =
1402 ax25->digipeat->calls[i];
1403 }
1404 } else {
1405 fsa->fsa_ax25.sax25_family = AF_AX25;
1406 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1407 fsa->fsa_ax25.sax25_ndigis = 1;
1408 if (ax25->ax25_dev != NULL) {
1409 memcpy(&fsa->fsa_digipeater[0],
1410 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1411 } else {
1412 fsa->fsa_digipeater[0] = null_ax25_address;
1413 }
1414 }
1415 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1416
1417out:
1418 release_sock(sk);
1419
1420 return err;
1421}
1422
1423static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1424 struct msghdr *msg, size_t len)
1425{
1426 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1427 struct sock *sk = sock->sk;
1428 struct sockaddr_ax25 sax;
1429 struct sk_buff *skb;
1430 ax25_digi dtmp, *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 ax25_cb *ax25;
1432 size_t size;
1433 int lv, err, addr_len = msg->msg_namelen;
1434
1435 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1436 return -EINVAL;
1437
1438 lock_sock(sk);
1439 ax25 = ax25_sk(sk);
1440
1441 if (sock_flag(sk, SOCK_ZAPPED)) {
1442 err = -EADDRNOTAVAIL;
1443 goto out;
1444 }
1445
1446 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1447 send_sig(SIGPIPE, current, 0);
1448 err = -EPIPE;
1449 goto out;
1450 }
1451
1452 if (ax25->ax25_dev == NULL) {
1453 err = -ENETUNREACH;
1454 goto out;
1455 }
1456
1457 if (len > ax25->ax25_dev->dev->mtu) {
1458 err = -EMSGSIZE;
1459 goto out;
1460 }
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001461
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462 if (usax != NULL) {
1463 if (usax->sax25_family != AF_AX25) {
1464 err = -EINVAL;
1465 goto out;
1466 }
1467
maximilian attems27d1cba2008-01-10 03:57:29 -08001468 if (addr_len == sizeof(struct sockaddr_ax25))
1469 /* ax25_sendmsg(): uses obsolete socket structure */
1470 ;
1471 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1472 /* support for old structure may go away some time
1473 * ax25_sendmsg(): uses old (6 digipeater)
1474 * socket structure.
1475 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001477 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1478 err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 goto out;
1480 }
1481
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482
1483 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1484 int ct = 0;
1485 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1486
1487 /* Valid number of digipeaters ? */
1488 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1489 err = -EINVAL;
1490 goto out;
1491 }
1492
1493 dtmp.ndigi = usax->sax25_ndigis;
1494
1495 while (ct < usax->sax25_ndigis) {
1496 dtmp.repeated[ct] = 0;
1497 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1498 ct++;
1499 }
1500
1501 dtmp.lastrepeat = 0;
1502 }
1503
1504 sax = *usax;
1505 if (sk->sk_type == SOCK_SEQPACKET &&
1506 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1507 err = -EISCONN;
1508 goto out;
1509 }
1510 if (usax->sax25_ndigis == 0)
1511 dp = NULL;
1512 else
1513 dp = &dtmp;
1514 } else {
1515 /*
1516 * FIXME: 1003.1g - if the socket is like this because
1517 * it has become closed (not started closed) and is VC
1518 * we ought to SIGPIPE, EPIPE
1519 */
1520 if (sk->sk_state != TCP_ESTABLISHED) {
1521 err = -ENOTCONN;
1522 goto out;
1523 }
1524 sax.sax25_family = AF_AX25;
1525 sax.sax25_call = ax25->dest_addr;
1526 dp = ax25->digipeat;
1527 }
1528
1529 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built.\n");
1530
1531 /* Build a packet */
1532 SOCK_DEBUG(sk, "AX.25: sendto: building packet.\n");
1533
1534 /* Assume the worst case */
1535 size = len + ax25->ax25_dev->dev->hard_header_len;
1536
1537 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1538 if (skb == NULL)
1539 goto out;
1540
1541 skb_reserve(skb, size - len);
1542
1543 SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1544
1545 /* User data follows immediately after the AX.25 data */
1546 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1547 err = -EFAULT;
1548 kfree_skb(skb);
1549 goto out;
1550 }
1551
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001552 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553
1554 /* Add the PID if one is not supplied by the user in the skb */
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001555 if (!ax25->pidincl)
1556 *skb_push(skb, 1) = sk->sk_protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557
1558 SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1559
1560 if (sk->sk_type == SOCK_SEQPACKET) {
1561 /* Connected mode sockets go via the LAPB machine */
1562 if (sk->sk_state != TCP_ESTABLISHED) {
1563 kfree_skb(skb);
1564 err = -ENOTCONN;
1565 goto out;
1566 }
1567
1568 /* Shove it onto the queue and kick */
1569 ax25_output(ax25, ax25->paclen, skb);
1570
1571 err = len;
1572 goto out;
1573 }
1574
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001575 skb_push(skb, 1 + ax25_addr_size(dp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576
1577 SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1578
1579 if (dp != NULL)
1580 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1581
1582 /* Build an AX.25 header */
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001583 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1584 dp, AX25_COMMAND, AX25_MODULUS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585
1586 SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1587
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001588 skb_set_transport_header(skb, lv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001590 SOCK_DEBUG(sk, "base=%p pos=%p\n",
1591 skb->data, skb_transport_header(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001593 *skb_transport_header(skb) = AX25_UI;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594
1595 /* Datagram frames go straight out of the door as UI */
Arnaldo Carvalho de Melo29c4be52005-04-21 16:46:56 -07001596 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597
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,
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001626 flags & MSG_DONTWAIT, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 if (skb == NULL)
1628 goto out;
1629
1630 if (!ax25_sk(sk)->pidincl)
1631 skb_pull(skb, 1); /* Remove PID */
1632
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001633 skb_reset_transport_header(skb);
1634 copied = skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635
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;
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001647 const unsigned char *mac = skb_mac_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001649 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1650 &digi, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 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;
1693 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1694 if (amount < 0)
1695 amount = 0;
1696 res = put_user(amount, (int __user *)argp);
1697 break;
1698 }
1699
1700 case TIOCINQ: {
1701 struct sk_buff *skb;
1702 long amount = 0L;
1703 /* These two are safe on a single CPU system as only user tasks fiddle here */
1704 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1705 amount = skb->len;
Ralf Baechle20b7d102005-09-12 14:24:55 -07001706 res = put_user(amount, (int __user *) argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 break;
1708 }
1709
1710 case SIOCGSTAMP:
Ralf Baechle9b37ee72005-09-12 14:23:52 -07001711 res = sock_get_timestamp(sk, argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 break;
1713
Eric Dumazetae40eb12007-03-18 17:33:16 -07001714 case SIOCGSTAMPNS:
1715 res = sock_get_timestampns(sk, argp);
1716 break;
1717
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1719 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1720 case SIOCAX25GETUID: {
1721 struct sockaddr_ax25 sax25;
1722 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1723 res = -EFAULT;
1724 break;
1725 }
1726 res = ax25_uid_ioctl(cmd, &sax25);
1727 break;
1728 }
1729
1730 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1731 long amount;
1732 if (!capable(CAP_NET_ADMIN)) {
1733 res = -EPERM;
1734 break;
1735 }
1736 if (get_user(amount, (long __user *)argp)) {
1737 res = -EFAULT;
1738 break;
1739 }
1740 if (amount > AX25_NOUID_BLOCK) {
1741 res = -EINVAL;
1742 break;
1743 }
1744 ax25_uid_policy = amount;
1745 res = 0;
1746 break;
1747 }
1748
1749 case SIOCADDRT:
1750 case SIOCDELRT:
1751 case SIOCAX25OPTRT:
1752 if (!capable(CAP_NET_ADMIN)) {
1753 res = -EPERM;
1754 break;
1755 }
1756 res = ax25_rt_ioctl(cmd, argp);
1757 break;
1758
1759 case SIOCAX25CTLCON:
1760 if (!capable(CAP_NET_ADMIN)) {
1761 res = -EPERM;
1762 break;
1763 }
1764 res = ax25_ctl_ioctl(cmd, argp);
1765 break;
1766
1767 case SIOCAX25GETINFO:
1768 case SIOCAX25GETINFOOLD: {
1769 ax25_cb *ax25 = ax25_sk(sk);
1770 struct ax25_info_struct ax25_info;
1771
1772 ax25_info.t1 = ax25->t1 / HZ;
1773 ax25_info.t2 = ax25->t2 / HZ;
1774 ax25_info.t3 = ax25->t3 / HZ;
1775 ax25_info.idle = ax25->idle / (60 * HZ);
1776 ax25_info.n2 = ax25->n2;
1777 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1778 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1779 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1780 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1781 ax25_info.n2count = ax25->n2count;
1782 ax25_info.state = ax25->state;
1783 ax25_info.rcv_q = atomic_read(&sk->sk_rmem_alloc);
1784 ax25_info.snd_q = atomic_read(&sk->sk_wmem_alloc);
1785 ax25_info.vs = ax25->vs;
1786 ax25_info.vr = ax25->vr;
1787 ax25_info.va = ax25->va;
1788 ax25_info.vs_max = ax25->vs; /* reserved */
1789 ax25_info.paclen = ax25->paclen;
1790 ax25_info.window = ax25->window;
1791
1792 /* old structure? */
1793 if (cmd == SIOCAX25GETINFOOLD) {
1794 static int warned = 0;
1795 if (!warned) {
1796 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1797 current->comm);
1798 warned=1;
1799 }
1800
1801 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1802 res = -EFAULT;
1803 break;
1804 }
1805 } else {
1806 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1807 res = -EINVAL;
1808 break;
1809 }
1810 }
1811 res = 0;
1812 break;
1813 }
1814
1815 case SIOCAX25ADDFWD:
1816 case SIOCAX25DELFWD: {
1817 struct ax25_fwd_struct ax25_fwd;
1818 if (!capable(CAP_NET_ADMIN)) {
1819 res = -EPERM;
1820 break;
1821 }
1822 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1823 res = -EFAULT;
1824 break;
1825 }
1826 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1827 break;
1828 }
1829
1830 case SIOCGIFADDR:
1831 case SIOCSIFADDR:
1832 case SIOCGIFDSTADDR:
1833 case SIOCSIFDSTADDR:
1834 case SIOCGIFBRDADDR:
1835 case SIOCSIFBRDADDR:
1836 case SIOCGIFNETMASK:
1837 case SIOCSIFNETMASK:
1838 case SIOCGIFMETRIC:
1839 case SIOCSIFMETRIC:
1840 res = -EINVAL;
1841 break;
1842
1843 default:
Christoph Hellwigb5e5fa52006-01-03 14:18:33 -08001844 res = -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 break;
1846 }
1847 release_sock(sk);
1848
1849 return res;
1850}
1851
1852#ifdef CONFIG_PROC_FS
1853
1854static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
Eric Dumazetf16f3022008-01-13 22:29:41 -08001855 __acquires(ax25_list_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856{
1857 struct ax25_cb *ax25;
1858 struct hlist_node *node;
1859 int i = 0;
1860
1861 spin_lock_bh(&ax25_list_lock);
1862 ax25_for_each(ax25, node, &ax25_list) {
1863 if (i == *pos)
1864 return ax25;
1865 ++i;
1866 }
1867 return NULL;
1868}
1869
1870static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1871{
1872 ++*pos;
1873
1874 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1875 struct ax25_cb, ax25_node);
1876}
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001877
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878static void ax25_info_stop(struct seq_file *seq, void *v)
Eric Dumazetf16f3022008-01-13 22:29:41 -08001879 __releases(ax25_list_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880{
1881 spin_unlock_bh(&ax25_list_lock);
1882}
1883
1884static int ax25_info_show(struct seq_file *seq, void *v)
1885{
1886 ax25_cb *ax25 = v;
Ralf Baechlef75268c2005-09-06 15:49:39 -07001887 char buf[11];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 int k;
1889
1890
1891 /*
1892 * New format:
1893 * 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
1894 */
1895
1896 seq_printf(seq, "%8.8lx %s %s%s ",
1897 (long) ax25,
1898 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
Ralf Baechlef75268c2005-09-06 15:49:39 -07001899 ax2asc(buf, &ax25->source_addr),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 ax25->iamdigi? "*":"");
Ralf Baechlef75268c2005-09-06 15:49:39 -07001901 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902
1903 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1904 seq_printf(seq, ",%s%s",
Ralf Baechlef75268c2005-09-06 15:49:39 -07001905 ax2asc(buf, &ax25->digipeat->calls[k]),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 ax25->digipeat->repeated[k]? "*":"");
1907 }
1908
1909 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1910 ax25->state,
1911 ax25->vs, ax25->vr, ax25->va,
1912 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1913 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1914 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1915 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1916 ax25->idle / (60 * HZ),
1917 ax25->n2count, ax25->n2,
1918 ax25->rtt / HZ,
1919 ax25->window,
1920 ax25->paclen);
1921
1922 if (ax25->sk != NULL) {
Jarek Poplawski1105b5d2008-02-11 21:24:56 -08001923 seq_printf(seq, " %d %d %lu\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924 atomic_read(&ax25->sk->sk_wmem_alloc),
1925 atomic_read(&ax25->sk->sk_rmem_alloc),
Jarek Poplawski1105b5d2008-02-11 21:24:56 -08001926 sock_i_ino(ax25->sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927 } else {
1928 seq_puts(seq, " * * *\n");
1929 }
1930 return 0;
1931}
1932
Philippe De Muyter56b3d972007-07-10 23:07:31 -07001933static const struct seq_operations ax25_info_seqops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934 .start = ax25_info_start,
1935 .next = ax25_info_next,
1936 .stop = ax25_info_stop,
1937 .show = ax25_info_show,
1938};
1939
1940static int ax25_info_open(struct inode *inode, struct file *file)
1941{
1942 return seq_open(file, &ax25_info_seqops);
1943}
1944
Arjan van de Ven9a321442007-02-12 00:55:35 -08001945static const struct file_operations ax25_info_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 .owner = THIS_MODULE,
1947 .open = ax25_info_open,
1948 .read = seq_read,
1949 .llseek = seq_lseek,
1950 .release = seq_release,
1951};
1952
1953#endif
1954
1955static struct net_proto_family ax25_family_ops = {
1956 .family = PF_AX25,
1957 .create = ax25_create,
1958 .owner = THIS_MODULE,
1959};
1960
Eric Dumazet90ddc4f2005-12-22 12:49:22 -08001961static const struct proto_ops ax25_proto_ops = {
Ralf Baechle46763562005-09-12 14:25:25 -07001962 .family = PF_AX25,
1963 .owner = THIS_MODULE,
1964 .release = ax25_release,
1965 .bind = ax25_bind,
1966 .connect = ax25_connect,
1967 .socketpair = sock_no_socketpair,
1968 .accept = ax25_accept,
1969 .getname = ax25_getname,
1970 .poll = datagram_poll,
1971 .ioctl = ax25_ioctl,
1972 .listen = ax25_listen,
1973 .shutdown = ax25_shutdown,
1974 .setsockopt = ax25_setsockopt,
1975 .getsockopt = ax25_getsockopt,
1976 .sendmsg = ax25_sendmsg,
1977 .recvmsg = ax25_recvmsg,
1978 .mmap = sock_no_mmap,
1979 .sendpage = sock_no_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980};
1981
1982/*
1983 * Called by socket.c on kernel start up
1984 */
1985static struct packet_type ax25_packet_type = {
1986 .type = __constant_htons(ETH_P_AX25),
1987 .dev = NULL, /* All devices */
1988 .func = ax25_kiss_rcv,
1989};
1990
1991static struct notifier_block ax25_dev_notifier = {
1992 .notifier_call =ax25_device_event,
1993};
1994
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995static int __init ax25_init(void)
1996{
1997 int rc = proto_register(&ax25_proto, 0);
1998
1999 if (rc != 0)
2000 goto out;
2001
2002 sock_register(&ax25_family_ops);
2003 dev_add_pack(&ax25_packet_type);
2004 register_netdevice_notifier(&ax25_dev_notifier);
2005 ax25_register_sysctl();
2006
Eric W. Biederman457c4cb2007-09-12 12:01:34 +02002007 proc_net_fops_create(&init_net, "ax25_route", S_IRUGO, &ax25_route_fops);
2008 proc_net_fops_create(&init_net, "ax25", S_IRUGO, &ax25_info_fops);
2009 proc_net_fops_create(&init_net, "ax25_calls", S_IRUGO, &ax25_uid_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010out:
2011 return rc;
2012}
2013module_init(ax25_init);
2014
2015
2016MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2017MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2018MODULE_LICENSE("GPL");
2019MODULE_ALIAS_NETPROTO(PF_AX25);
2020
2021static void __exit ax25_exit(void)
2022{
Eric W. Biederman457c4cb2007-09-12 12:01:34 +02002023 proc_net_remove(&init_net, "ax25_route");
2024 proc_net_remove(&init_net, "ax25");
2025 proc_net_remove(&init_net, "ax25_calls");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026 ax25_rt_free();
2027 ax25_uid_free();
2028 ax25_dev_free();
2029
2030 ax25_unregister_sysctl();
2031 unregister_netdevice_notifier(&ax25_dev_notifier);
2032
2033 dev_remove_pack(&ax25_packet_type);
2034
2035 sock_unregister(PF_AX25);
2036 proto_unregister(&ax25_proto);
2037}
2038module_exit(ax25_exit);