blob: fd9d06f291dc31f4bb0d108f85d3eff51ead0e3f [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
David S. Miller33d1d2c2008-10-06 12:53:50 -0700320 /* 9A4GL: hack to release unaccepted sockets */
321 skb->sk->sk_state = TCP_LISTEN;
322
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 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) {
333 if (atomic_read(&ax25->sk->sk_wmem_alloc) ||
334 atomic_read(&ax25->sk->sk_rmem_alloc)) {
335 /* Defer: outstanding buffers */
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800336 setup_timer(&ax25->dtimer, ax25_destroy_timer,
337 (unsigned long)ax25);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 ax25->dtimer.expires = jiffies + 2 * HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 add_timer(&ax25->dtimer);
340 } else {
341 struct sock *sk=ax25->sk;
342 ax25->sk=NULL;
343 sock_put(sk);
344 }
345 } else {
346 ax25_cb_put(ax25);
347 }
348}
349
350/*
351 * dl1bke 960311: set parameters for existing AX.25 connections,
352 * includes a KILL command to abort any connection.
353 * VERY useful for debugging ;-)
354 */
355static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
356{
357 struct ax25_ctl_struct ax25_ctl;
358 ax25_digi digi;
359 ax25_dev *ax25_dev;
360 ax25_cb *ax25;
361 unsigned int k;
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
372 digi.ndigi = ax25_ctl.digi_count;
373 for (k = 0; k < digi.ndigi; k++)
374 digi.calls[k] = ax25_ctl.digi_addr[k];
375
376 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
377 return -ENOTCONN;
378
379 switch (ax25_ctl.cmd) {
380 case AX25_KILL:
381 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
382#ifdef CONFIG_AX25_DAMA_SLAVE
383 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
384 ax25_dama_off(ax25);
385#endif
386 ax25_disconnect(ax25, ENETRESET);
387 break;
388
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900389 case AX25_WINDOW:
390 if (ax25->modulus == AX25_MODULUS) {
391 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
392 return -EINVAL;
393 } else {
394 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
395 return -EINVAL;
396 }
397 ax25->window = ax25_ctl.arg;
398 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900400 case AX25_T1:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 if (ax25_ctl.arg < 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 return -EINVAL;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900403 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
404 ax25->t1 = ax25_ctl.arg * HZ;
405 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900407 case AX25_T2:
408 if (ax25_ctl.arg < 1)
409 return -EINVAL;
410 ax25->t2 = ax25_ctl.arg * HZ;
411 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900413 case AX25_N2:
414 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
415 return -EINVAL;
416 ax25->n2count = 0;
417 ax25->n2 = ax25_ctl.arg;
418 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900420 case AX25_T3:
421 if (ax25_ctl.arg < 0)
422 return -EINVAL;
423 ax25->t3 = ax25_ctl.arg * HZ;
424 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900426 case AX25_IDLE:
427 if (ax25_ctl.arg < 0)
428 return -EINVAL;
429 ax25->idle = ax25_ctl.arg * 60 * HZ;
430 break;
431
432 case AX25_PACLEN:
433 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
434 return -EINVAL;
435 ax25->paclen = ax25_ctl.arg;
436 break;
437
438 default:
439 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 }
441
442 return 0;
443}
444
Ralf Baechlee1fdb5b2006-05-03 23:27:16 -0700445static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
446{
447 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
448 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
449 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
450 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
451 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
452 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
453 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
454 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
455
456 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
457 ax25->modulus = AX25_EMODULUS;
458 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
459 } else {
460 ax25->modulus = AX25_MODULUS;
461 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
462 }
463}
464
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465/*
466 * Fill in a created AX.25 created control block with the default
467 * values for a particular device.
468 */
469void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
470{
471 ax25->ax25_dev = ax25_dev;
472
473 if (ax25->ax25_dev != NULL) {
Ralf Baechlee1fdb5b2006-05-03 23:27:16 -0700474 ax25_fillin_cb_from_dev(ax25, ax25_dev);
475 return;
476 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
Ralf Baechlee1fdb5b2006-05-03 23:27:16 -0700478 /*
479 * No device, use kernel / AX.25 spec default values
480 */
481 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
482 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
483 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
484 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
485 ax25->n2 = AX25_DEF_N2;
486 ax25->paclen = AX25_DEF_PACLEN;
487 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
488 ax25->backoff = AX25_DEF_BACKOFF;
489
490 if (AX25_DEF_AXDEFMODE) {
491 ax25->modulus = AX25_EMODULUS;
492 ax25->window = AX25_DEF_EWINDOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 } else {
Ralf Baechlee1fdb5b2006-05-03 23:27:16 -0700494 ax25->modulus = AX25_MODULUS;
495 ax25->window = AX25_DEF_WINDOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 }
497}
498
499/*
500 * Create an empty AX.25 control block.
501 */
502ax25_cb *ax25_create_cb(void)
503{
504 ax25_cb *ax25;
505
Ralf Baechle1b30dd32006-07-09 12:14:22 -0700506 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 return NULL;
508
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 atomic_set(&ax25->refcount, 1);
510
511 skb_queue_head_init(&ax25->write_queue);
512 skb_queue_head_init(&ax25->frag_queue);
513 skb_queue_head_init(&ax25->ack_queue);
514 skb_queue_head_init(&ax25->reseq_queue);
515
Jarek Poplawski21fab4a2008-02-11 21:36:39 -0800516 ax25_setup_timers(ax25);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517
518 ax25_fillin_cb(ax25, NULL);
519
520 ax25->state = AX25_STATE_0;
521
522 return ax25;
523}
524
525/*
526 * Handling for system calls applied via the various interfaces to an
527 * AX25 socket object
528 */
529
530static int ax25_setsockopt(struct socket *sock, int level, int optname,
531 char __user *optval, int optlen)
532{
533 struct sock *sk = sock->sk;
534 ax25_cb *ax25;
535 struct net_device *dev;
536 char devname[IFNAMSIZ];
537 int opt, res = 0;
538
539 if (level != SOL_AX25)
540 return -ENOPROTOOPT;
541
542 if (optlen < sizeof(int))
543 return -EINVAL;
544
545 if (get_user(opt, (int __user *)optval))
546 return -EFAULT;
547
548 lock_sock(sk);
549 ax25 = ax25_sk(sk);
550
551 switch (optname) {
552 case AX25_WINDOW:
553 if (ax25->modulus == AX25_MODULUS) {
554 if (opt < 1 || opt > 7) {
555 res = -EINVAL;
556 break;
557 }
558 } else {
559 if (opt < 1 || opt > 63) {
560 res = -EINVAL;
561 break;
562 }
563 }
564 ax25->window = opt;
565 break;
566
567 case AX25_T1:
568 if (opt < 1) {
569 res = -EINVAL;
570 break;
571 }
Eric Dumazetf16f3022008-01-13 22:29:41 -0800572 ax25->rtt = (opt * HZ) >> 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 ax25->t1 = opt * HZ;
574 break;
575
576 case AX25_T2:
577 if (opt < 1) {
578 res = -EINVAL;
579 break;
580 }
581 ax25->t2 = opt * HZ;
582 break;
583
584 case AX25_N2:
585 if (opt < 1 || opt > 31) {
586 res = -EINVAL;
587 break;
588 }
589 ax25->n2 = opt;
590 break;
591
592 case AX25_T3:
593 if (opt < 1) {
594 res = -EINVAL;
595 break;
596 }
597 ax25->t3 = opt * HZ;
598 break;
599
600 case AX25_IDLE:
601 if (opt < 0) {
602 res = -EINVAL;
603 break;
604 }
605 ax25->idle = opt * 60 * HZ;
606 break;
607
608 case AX25_BACKOFF:
609 if (opt < 0 || opt > 2) {
610 res = -EINVAL;
611 break;
612 }
613 ax25->backoff = opt;
614 break;
615
616 case AX25_EXTSEQ:
617 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
618 break;
619
620 case AX25_PIDINCL:
621 ax25->pidincl = opt ? 1 : 0;
622 break;
623
624 case AX25_IAMDIGI:
625 ax25->iamdigi = opt ? 1 : 0;
626 break;
627
628 case AX25_PACLEN:
629 if (opt < 16 || opt > 65535) {
630 res = -EINVAL;
631 break;
632 }
633 ax25->paclen = opt;
634 break;
635
636 case SO_BINDTODEVICE:
637 if (optlen > IFNAMSIZ)
638 optlen=IFNAMSIZ;
639 if (copy_from_user(devname, optval, optlen)) {
640 res = -EFAULT;
641 break;
642 }
643
Eric W. Biederman881d9662007-09-17 11:56:21 -0700644 dev = dev_get_by_name(&init_net, devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 if (dev == NULL) {
646 res = -ENODEV;
647 break;
648 }
649
650 if (sk->sk_type == SOCK_SEQPACKET &&
651 (sock->state != SS_UNCONNECTED ||
652 sk->sk_state == TCP_LISTEN)) {
653 res = -EADDRNOTAVAIL;
654 dev_put(dev);
655 break;
656 }
657
658 ax25->ax25_dev = ax25_dev_ax25dev(dev);
659 ax25_fillin_cb(ax25, ax25->ax25_dev);
660 break;
661
662 default:
663 res = -ENOPROTOOPT;
664 }
665 release_sock(sk);
666
667 return res;
668}
669
670static int ax25_getsockopt(struct socket *sock, int level, int optname,
671 char __user *optval, int __user *optlen)
672{
673 struct sock *sk = sock->sk;
674 ax25_cb *ax25;
675 struct ax25_dev *ax25_dev;
676 char devname[IFNAMSIZ];
677 void *valptr;
678 int val = 0;
679 int maxlen, length;
680
681 if (level != SOL_AX25)
682 return -ENOPROTOOPT;
683
684 if (get_user(maxlen, optlen))
685 return -EFAULT;
686
687 if (maxlen < 1)
688 return -EFAULT;
689
690 valptr = (void *) &val;
691 length = min_t(unsigned int, maxlen, sizeof(int));
692
693 lock_sock(sk);
694 ax25 = ax25_sk(sk);
695
696 switch (optname) {
697 case AX25_WINDOW:
698 val = ax25->window;
699 break;
700
701 case AX25_T1:
702 val = ax25->t1 / HZ;
703 break;
704
705 case AX25_T2:
706 val = ax25->t2 / HZ;
707 break;
708
709 case AX25_N2:
710 val = ax25->n2;
711 break;
712
713 case AX25_T3:
714 val = ax25->t3 / HZ;
715 break;
716
717 case AX25_IDLE:
718 val = ax25->idle / (60 * HZ);
719 break;
720
721 case AX25_BACKOFF:
722 val = ax25->backoff;
723 break;
724
725 case AX25_EXTSEQ:
726 val = (ax25->modulus == AX25_EMODULUS);
727 break;
728
729 case AX25_PIDINCL:
730 val = ax25->pidincl;
731 break;
732
733 case AX25_IAMDIGI:
734 val = ax25->iamdigi;
735 break;
736
737 case AX25_PACLEN:
738 val = ax25->paclen;
739 break;
740
741 case SO_BINDTODEVICE:
742 ax25_dev = ax25->ax25_dev;
743
744 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
745 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
746 length = strlen(devname) + 1;
747 } else {
748 *devname = '\0';
749 length = 1;
750 }
751
752 valptr = (void *) devname;
753 break;
754
755 default:
756 release_sock(sk);
757 return -ENOPROTOOPT;
758 }
759 release_sock(sk);
760
761 if (put_user(length, optlen))
762 return -EFAULT;
763
764 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
765}
766
767static int ax25_listen(struct socket *sock, int backlog)
768{
769 struct sock *sk = sock->sk;
770 int res = 0;
771
772 lock_sock(sk);
773 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
774 sk->sk_max_ack_backlog = backlog;
775 sk->sk_state = TCP_LISTEN;
776 goto out;
777 }
778 res = -EOPNOTSUPP;
779
780out:
781 release_sock(sk);
782
783 return res;
784}
785
786/*
787 * XXX: when creating ax25_sock we should update the .obj_size setting
788 * below.
789 */
790static struct proto ax25_proto = {
791 .name = "AX25",
792 .owner = THIS_MODULE,
793 .obj_size = sizeof(struct sock),
794};
795
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700796static int ax25_create(struct net *net, struct socket *sock, int protocol)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797{
798 struct sock *sk;
799 ax25_cb *ax25;
800
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700801 if (net != &init_net)
802 return -EAFNOSUPPORT;
803
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 switch (sock->type) {
805 case SOCK_DGRAM:
806 if (protocol == 0 || protocol == PF_AX25)
807 protocol = AX25_P_TEXT;
808 break;
809
810 case SOCK_SEQPACKET:
811 switch (protocol) {
812 case 0:
813 case PF_AX25: /* For CLX */
814 protocol = AX25_P_TEXT;
815 break;
816 case AX25_P_SEGMENT:
817#ifdef CONFIG_INET
818 case AX25_P_ARP:
819 case AX25_P_IP:
820#endif
821#ifdef CONFIG_NETROM
822 case AX25_P_NETROM:
823#endif
824#ifdef CONFIG_ROSE
825 case AX25_P_ROSE:
826#endif
827 return -ESOCKTNOSUPPORT;
828#ifdef CONFIG_NETROM_MODULE
829 case AX25_P_NETROM:
830 if (ax25_protocol_is_registered(AX25_P_NETROM))
831 return -ESOCKTNOSUPPORT;
832#endif
833#ifdef CONFIG_ROSE_MODULE
834 case AX25_P_ROSE:
835 if (ax25_protocol_is_registered(AX25_P_ROSE))
836 return -ESOCKTNOSUPPORT;
837#endif
838 default:
839 break;
840 }
841 break;
842
843 case SOCK_RAW:
844 break;
845 default:
846 return -ESOCKTNOSUPPORT;
847 }
848
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700849 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
850 if (sk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 return -ENOMEM;
852
853 ax25 = sk->sk_protinfo = ax25_create_cb();
854 if (!ax25) {
855 sk_free(sk);
856 return -ENOMEM;
857 }
858
859 sock_init_data(sock, sk);
860
861 sk->sk_destruct = ax25_free_sock;
862 sock->ops = &ax25_proto_ops;
863 sk->sk_protocol = protocol;
864
865 ax25->sk = sk;
866
867 return 0;
868}
869
870struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
871{
872 struct sock *sk;
873 ax25_cb *ax25, *oax25;
874
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900875 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot);
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700876 if (sk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 return NULL;
878
879 if ((ax25 = ax25_create_cb()) == NULL) {
880 sk_free(sk);
881 return NULL;
882 }
883
884 switch (osk->sk_type) {
885 case SOCK_DGRAM:
886 break;
887 case SOCK_SEQPACKET:
888 break;
889 default:
890 sk_free(sk);
891 ax25_cb_put(ax25);
892 return NULL;
893 }
894
895 sock_init_data(NULL, sk);
896
897 sk->sk_destruct = ax25_free_sock;
898 sk->sk_type = osk->sk_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 sk->sk_priority = osk->sk_priority;
900 sk->sk_protocol = osk->sk_protocol;
901 sk->sk_rcvbuf = osk->sk_rcvbuf;
902 sk->sk_sndbuf = osk->sk_sndbuf;
903 sk->sk_state = TCP_ESTABLISHED;
Ralf Baechle53b924b2005-08-23 10:11:30 -0700904 sock_copy_flags(sk, osk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905
906 oax25 = ax25_sk(osk);
907
908 ax25->modulus = oax25->modulus;
909 ax25->backoff = oax25->backoff;
910 ax25->pidincl = oax25->pidincl;
911 ax25->iamdigi = oax25->iamdigi;
912 ax25->rtt = oax25->rtt;
913 ax25->t1 = oax25->t1;
914 ax25->t2 = oax25->t2;
915 ax25->t3 = oax25->t3;
916 ax25->n2 = oax25->n2;
917 ax25->idle = oax25->idle;
918 ax25->paclen = oax25->paclen;
919 ax25->window = oax25->window;
920
921 ax25->ax25_dev = ax25_dev;
922 ax25->source_addr = oax25->source_addr;
923
924 if (oax25->digipeat != NULL) {
Arnaldo Carvalho de Melo0459d70a2006-11-17 12:43:07 -0200925 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
926 GFP_ATOMIC);
927 if (ax25->digipeat == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 sk_free(sk);
929 ax25_cb_put(ax25);
930 return NULL;
931 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 }
933
934 sk->sk_protinfo = ax25;
935 ax25->sk = sk;
936
937 return sk;
938}
939
940static int ax25_release(struct socket *sock)
941{
942 struct sock *sk = sock->sk;
943 ax25_cb *ax25;
944
945 if (sk == NULL)
946 return 0;
947
948 sock_hold(sk);
949 sock_orphan(sk);
950 lock_sock(sk);
951 ax25 = ax25_sk(sk);
952
953 if (sk->sk_type == SOCK_SEQPACKET) {
954 switch (ax25->state) {
955 case AX25_STATE_0:
956 release_sock(sk);
957 ax25_disconnect(ax25, 0);
958 lock_sock(sk);
959 ax25_destroy_socket(ax25);
960 break;
961
962 case AX25_STATE_1:
963 case AX25_STATE_2:
964 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
965 release_sock(sk);
966 ax25_disconnect(ax25, 0);
967 lock_sock(sk);
968 ax25_destroy_socket(ax25);
969 break;
970
971 case AX25_STATE_3:
972 case AX25_STATE_4:
973 ax25_clear_queues(ax25);
974 ax25->n2count = 0;
975
976 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
977 case AX25_PROTO_STD_SIMPLEX:
978 case AX25_PROTO_STD_DUPLEX:
979 ax25_send_control(ax25,
980 AX25_DISC,
981 AX25_POLLON,
982 AX25_COMMAND);
983 ax25_stop_t2timer(ax25);
984 ax25_stop_t3timer(ax25);
985 ax25_stop_idletimer(ax25);
986 break;
987#ifdef CONFIG_AX25_DAMA_SLAVE
988 case AX25_PROTO_DAMA_SLAVE:
989 ax25_stop_t3timer(ax25);
990 ax25_stop_idletimer(ax25);
991 break;
992#endif
993 }
994 ax25_calculate_t1(ax25);
995 ax25_start_t1timer(ax25);
996 ax25->state = AX25_STATE_2;
997 sk->sk_state = TCP_CLOSE;
998 sk->sk_shutdown |= SEND_SHUTDOWN;
999 sk->sk_state_change(sk);
1000 sock_set_flag(sk, SOCK_DESTROY);
1001 break;
1002
1003 default:
1004 break;
1005 }
1006 } else {
1007 sk->sk_state = TCP_CLOSE;
1008 sk->sk_shutdown |= SEND_SHUTDOWN;
1009 sk->sk_state_change(sk);
1010 ax25_destroy_socket(ax25);
1011 }
1012
1013 sock->sk = NULL;
1014 release_sock(sk);
1015 sock_put(sk);
1016
1017 return 0;
1018}
1019
1020/*
1021 * We support a funny extension here so you can (as root) give any callsign
1022 * digipeated via a local address as source. This hack is obsolete now
1023 * that we've implemented support for SO_BINDTODEVICE. It is however small
1024 * and trivially backward compatible.
1025 */
1026static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1027{
1028 struct sock *sk = sock->sk;
1029 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1030 ax25_dev *ax25_dev = NULL;
Ralf Baechle01d7dd02005-08-23 10:11:45 -07001031 ax25_uid_assoc *user;
1032 ax25_address call;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 ax25_cb *ax25;
1034 int err = 0;
1035
1036 if (addr_len != sizeof(struct sockaddr_ax25) &&
maximilian attems1987e7b2008-01-28 20:44:11 -08001037 addr_len != sizeof(struct full_sockaddr_ax25))
1038 /* support for old structure may go away some time
1039 * ax25_bind(): uses old (6 digipeater) socket structure.
1040 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
maximilian attems1987e7b2008-01-28 20:44:11 -08001042 (addr_len > sizeof(struct full_sockaddr_ax25)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044
1045 if (addr->fsa_ax25.sax25_family != AF_AX25)
1046 return -EINVAL;
1047
David Howells73400402008-11-14 10:39:06 +11001048 user = ax25_findbyuid(current_euid());
Ralf Baechle01d7dd02005-08-23 10:11:45 -07001049 if (user) {
1050 call = user->call;
1051 ax25_uid_put(user);
1052 } else {
1053 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1054 return -EACCES;
1055
1056 call = addr->fsa_ax25.sax25_call;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 }
1058
1059 lock_sock(sk);
1060
1061 ax25 = ax25_sk(sk);
1062 if (!sock_flag(sk, SOCK_ZAPPED)) {
1063 err = -EINVAL;
1064 goto out;
1065 }
1066
Ralf Baechle01d7dd02005-08-23 10:11:45 -07001067 ax25->source_addr = call;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068
1069 /*
1070 * User already set interface with SO_BINDTODEVICE
1071 */
1072 if (ax25->ax25_dev != NULL)
1073 goto done;
1074
1075 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1076 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1077 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1078 err = -EADDRNOTAVAIL;
1079 goto out;
1080 }
1081 } else {
1082 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1083 err = -EADDRNOTAVAIL;
1084 goto out;
1085 }
1086 }
1087
1088 if (ax25_dev != NULL)
1089 ax25_fillin_cb(ax25, ax25_dev);
1090
1091done:
1092 ax25_cb_add(ax25);
1093 sock_reset_flag(sk, SOCK_ZAPPED);
1094
1095out:
1096 release_sock(sk);
1097
1098 return 0;
1099}
1100
1101/*
1102 * FIXME: nonblock behaviour looks like it may have a bug.
1103 */
Ralf Baechlec9266b92006-12-14 15:49:28 -08001104static int __must_check ax25_connect(struct socket *sock,
1105 struct sockaddr *uaddr, int addr_len, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106{
1107 struct sock *sk = sock->sk;
1108 ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1109 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1110 ax25_digi *digi = NULL;
1111 int ct = 0, err = 0;
1112
1113 /*
1114 * some sanity checks. code further down depends on this
1115 */
1116
maximilian attems27d1cba2008-01-10 03:57:29 -08001117 if (addr_len == sizeof(struct sockaddr_ax25))
1118 /* support for this will go away in early 2.5.x
1119 * ax25_connect(): uses obsolete socket structure
1120 */
1121 ;
1122 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1123 /* support for old structure may go away some time
1124 * ax25_connect(): uses old (6 digipeater) socket structure.
1125 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
maximilian attems27d1cba2008-01-10 03:57:29 -08001127 (addr_len > sizeof(struct full_sockaddr_ax25)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
1131 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1132 return -EINVAL;
1133
1134 lock_sock(sk);
1135
1136 /* deal with restarts */
1137 if (sock->state == SS_CONNECTING) {
1138 switch (sk->sk_state) {
1139 case TCP_SYN_SENT: /* still trying */
1140 err = -EINPROGRESS;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001141 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142
1143 case TCP_ESTABLISHED: /* connection established */
1144 sock->state = SS_CONNECTED;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001145 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146
1147 case TCP_CLOSE: /* connection refused */
1148 sock->state = SS_UNCONNECTED;
1149 err = -ECONNREFUSED;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001150 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 }
1152 }
1153
1154 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1155 err = -EISCONN; /* No reconnect on a seqpacket socket */
Ralf Baechle75606dc2007-04-20 16:06:45 -07001156 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 }
1158
1159 sk->sk_state = TCP_CLOSE;
1160 sock->state = SS_UNCONNECTED;
1161
Jesper Juhla51482b2005-11-08 09:41:34 -08001162 kfree(ax25->digipeat);
1163 ax25->digipeat = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164
1165 /*
1166 * Handle digi-peaters to be used.
1167 */
1168 if (addr_len > sizeof(struct sockaddr_ax25) &&
1169 fsa->fsa_ax25.sax25_ndigis != 0) {
1170 /* Valid number of digipeaters ? */
1171 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1172 err = -EINVAL;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001173 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 }
1175
1176 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1177 err = -ENOBUFS;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001178 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 }
1180
1181 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1182 digi->lastrepeat = -1;
1183
1184 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1185 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1186 AX25_HBIT) && ax25->iamdigi) {
1187 digi->repeated[ct] = 1;
1188 digi->lastrepeat = ct;
1189 } else {
1190 digi->repeated[ct] = 0;
1191 }
1192 digi->calls[ct] = fsa->fsa_digipeater[ct];
1193 ct++;
1194 }
1195 }
1196
1197 /*
1198 * Must bind first - autobinding in this may or may not work. If
1199 * the socket is already bound, check to see if the device has
1200 * been filled in, error if it hasn't.
1201 */
1202 if (sock_flag(sk, SOCK_ZAPPED)) {
1203 /* check if we can remove this feature. It is broken. */
1204 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1205 current->comm);
1206 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1207 kfree(digi);
Ralf Baechle75606dc2007-04-20 16:06:45 -07001208 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 }
1210
1211 ax25_fillin_cb(ax25, ax25->ax25_dev);
1212 ax25_cb_add(ax25);
1213 } else {
1214 if (ax25->ax25_dev == NULL) {
1215 kfree(digi);
1216 err = -EHOSTUNREACH;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001217 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 }
1219 }
1220
1221 if (sk->sk_type == SOCK_SEQPACKET &&
1222 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001223 ax25->ax25_dev->dev))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 kfree(digi);
1225 err = -EADDRINUSE; /* Already such a connection */
1226 ax25_cb_put(ax25t);
Ralf Baechle75606dc2007-04-20 16:06:45 -07001227 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 }
1229
1230 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1231 ax25->digipeat = digi;
1232
1233 /* First the easy one */
1234 if (sk->sk_type != SOCK_SEQPACKET) {
1235 sock->state = SS_CONNECTED;
1236 sk->sk_state = TCP_ESTABLISHED;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001237 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 }
1239
1240 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1241 sock->state = SS_CONNECTING;
1242 sk->sk_state = TCP_SYN_SENT;
1243
1244 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1245 case AX25_PROTO_STD_SIMPLEX:
1246 case AX25_PROTO_STD_DUPLEX:
1247 ax25_std_establish_data_link(ax25);
1248 break;
1249
1250#ifdef CONFIG_AX25_DAMA_SLAVE
1251 case AX25_PROTO_DAMA_SLAVE:
1252 ax25->modulus = AX25_MODULUS;
1253 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1254 if (ax25->ax25_dev->dama.slave)
1255 ax25_ds_establish_data_link(ax25);
1256 else
1257 ax25_std_establish_data_link(ax25);
1258 break;
1259#endif
1260 }
1261
1262 ax25->state = AX25_STATE_1;
1263
1264 ax25_start_heartbeat(ax25);
1265
1266 /* Now the loop */
1267 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1268 err = -EINPROGRESS;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001269 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 }
1271
1272 if (sk->sk_state == TCP_SYN_SENT) {
Ralf Baechle75606dc2007-04-20 16:06:45 -07001273 DEFINE_WAIT(wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 for (;;) {
Ralf Baechle75606dc2007-04-20 16:06:45 -07001276 prepare_to_wait(sk->sk_sleep, &wait,
YOSHIFUJI Hideakibd3b0712007-07-19 10:43:13 +09001277 TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 if (sk->sk_state != TCP_SYN_SENT)
1279 break;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001280 if (!signal_pending(current)) {
1281 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 schedule();
1283 lock_sock(sk);
1284 continue;
1285 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001286 err = -ERESTARTSYS;
1287 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001289 finish_wait(sk->sk_sleep, &wait);
1290
1291 if (err)
1292 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 }
1294
1295 if (sk->sk_state != TCP_ESTABLISHED) {
1296 /* Not in ABM, not in WAIT_UA -> failed */
1297 sock->state = SS_UNCONNECTED;
1298 err = sock_error(sk); /* Always set at this point */
Ralf Baechle75606dc2007-04-20 16:06:45 -07001299 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 }
1301
1302 sock->state = SS_CONNECTED;
1303
Ralf Baechle75606dc2007-04-20 16:06:45 -07001304 err = 0;
1305out_release:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 release_sock(sk);
1307
1308 return err;
1309}
1310
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1312{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 struct sk_buff *skb;
1314 struct sock *newsk;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001315 DEFINE_WAIT(wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 struct sock *sk;
1317 int err = 0;
1318
1319 if (sock->state != SS_UNCONNECTED)
1320 return -EINVAL;
1321
1322 if ((sk = sock->sk) == NULL)
1323 return -EINVAL;
1324
1325 lock_sock(sk);
1326 if (sk->sk_type != SOCK_SEQPACKET) {
1327 err = -EOPNOTSUPP;
1328 goto out;
1329 }
1330
1331 if (sk->sk_state != TCP_LISTEN) {
1332 err = -EINVAL;
1333 goto out;
1334 }
1335
1336 /*
1337 * The read queue this time is holding sockets ready to use
1338 * hooked into the SABM we saved
1339 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 for (;;) {
Ralf Baechle75606dc2007-04-20 16:06:45 -07001341 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 skb = skb_dequeue(&sk->sk_receive_queue);
1343 if (skb)
1344 break;
1345
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 if (flags & O_NONBLOCK) {
Ralf Baechle75606dc2007-04-20 16:06:45 -07001347 err = -EWOULDBLOCK;
1348 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001350 if (!signal_pending(current)) {
1351 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 schedule();
1353 lock_sock(sk);
1354 continue;
1355 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001356 err = -ERESTARTSYS;
1357 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001359 finish_wait(sk->sk_sleep, &wait);
1360
1361 if (err)
1362 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
1364 newsk = skb->sk;
David S. Miller9375cb82008-06-17 02:20:54 -07001365 sock_graft(newsk, newsock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366
1367 /* Now attach up the new socket */
1368 kfree_skb(skb);
1369 sk->sk_ack_backlog--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 newsock->state = SS_CONNECTED;
1371
1372out:
1373 release_sock(sk);
1374
1375 return err;
1376}
1377
1378static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1379 int *uaddr_len, int peer)
1380{
1381 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1382 struct sock *sk = sock->sk;
1383 unsigned char ndigi, i;
1384 ax25_cb *ax25;
1385 int err = 0;
1386
1387 lock_sock(sk);
1388 ax25 = ax25_sk(sk);
1389
1390 if (peer != 0) {
1391 if (sk->sk_state != TCP_ESTABLISHED) {
1392 err = -ENOTCONN;
1393 goto out;
1394 }
1395
1396 fsa->fsa_ax25.sax25_family = AF_AX25;
1397 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1398 fsa->fsa_ax25.sax25_ndigis = 0;
1399
1400 if (ax25->digipeat != NULL) {
1401 ndigi = ax25->digipeat->ndigi;
1402 fsa->fsa_ax25.sax25_ndigis = ndigi;
1403 for (i = 0; i < ndigi; i++)
1404 fsa->fsa_digipeater[i] =
1405 ax25->digipeat->calls[i];
1406 }
1407 } else {
1408 fsa->fsa_ax25.sax25_family = AF_AX25;
1409 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1410 fsa->fsa_ax25.sax25_ndigis = 1;
1411 if (ax25->ax25_dev != NULL) {
1412 memcpy(&fsa->fsa_digipeater[0],
1413 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1414 } else {
1415 fsa->fsa_digipeater[0] = null_ax25_address;
1416 }
1417 }
1418 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1419
1420out:
1421 release_sock(sk);
1422
1423 return err;
1424}
1425
1426static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1427 struct msghdr *msg, size_t len)
1428{
1429 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1430 struct sock *sk = sock->sk;
1431 struct sockaddr_ax25 sax;
1432 struct sk_buff *skb;
1433 ax25_digi dtmp, *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 ax25_cb *ax25;
1435 size_t size;
1436 int lv, err, addr_len = msg->msg_namelen;
1437
1438 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1439 return -EINVAL;
1440
1441 lock_sock(sk);
1442 ax25 = ax25_sk(sk);
1443
1444 if (sock_flag(sk, SOCK_ZAPPED)) {
1445 err = -EADDRNOTAVAIL;
1446 goto out;
1447 }
1448
1449 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1450 send_sig(SIGPIPE, current, 0);
1451 err = -EPIPE;
1452 goto out;
1453 }
1454
1455 if (ax25->ax25_dev == NULL) {
1456 err = -ENETUNREACH;
1457 goto out;
1458 }
1459
1460 if (len > ax25->ax25_dev->dev->mtu) {
1461 err = -EMSGSIZE;
1462 goto out;
1463 }
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001464
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 if (usax != NULL) {
1466 if (usax->sax25_family != AF_AX25) {
1467 err = -EINVAL;
1468 goto out;
1469 }
1470
maximilian attems27d1cba2008-01-10 03:57:29 -08001471 if (addr_len == sizeof(struct sockaddr_ax25))
1472 /* ax25_sendmsg(): uses obsolete socket structure */
1473 ;
1474 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1475 /* support for old structure may go away some time
1476 * ax25_sendmsg(): uses old (6 digipeater)
1477 * socket structure.
1478 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001480 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1481 err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 goto out;
1483 }
1484
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485
1486 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1487 int ct = 0;
1488 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1489
1490 /* Valid number of digipeaters ? */
1491 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1492 err = -EINVAL;
1493 goto out;
1494 }
1495
1496 dtmp.ndigi = usax->sax25_ndigis;
1497
1498 while (ct < usax->sax25_ndigis) {
1499 dtmp.repeated[ct] = 0;
1500 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1501 ct++;
1502 }
1503
1504 dtmp.lastrepeat = 0;
1505 }
1506
1507 sax = *usax;
1508 if (sk->sk_type == SOCK_SEQPACKET &&
1509 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1510 err = -EISCONN;
1511 goto out;
1512 }
1513 if (usax->sax25_ndigis == 0)
1514 dp = NULL;
1515 else
1516 dp = &dtmp;
1517 } else {
1518 /*
1519 * FIXME: 1003.1g - if the socket is like this because
1520 * it has become closed (not started closed) and is VC
1521 * we ought to SIGPIPE, EPIPE
1522 */
1523 if (sk->sk_state != TCP_ESTABLISHED) {
1524 err = -ENOTCONN;
1525 goto out;
1526 }
1527 sax.sax25_family = AF_AX25;
1528 sax.sax25_call = ax25->dest_addr;
1529 dp = ax25->digipeat;
1530 }
1531
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 /* Build a packet */
Bernard Pidoux60784422009-03-21 13:33:18 -07001533 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built. Building packet.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534
1535 /* Assume the worst case */
1536 size = len + ax25->ax25_dev->dev->hard_header_len;
1537
1538 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1539 if (skb == NULL)
1540 goto out;
1541
1542 skb_reserve(skb, size - len);
1543
1544 SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1545
1546 /* User data follows immediately after the AX.25 data */
1547 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1548 err = -EFAULT;
1549 kfree_skb(skb);
1550 goto out;
1551 }
1552
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001553 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554
1555 /* Add the PID if one is not supplied by the user in the skb */
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001556 if (!ax25->pidincl)
1557 *skb_push(skb, 1) = sk->sk_protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558
1559 SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1560
1561 if (sk->sk_type == SOCK_SEQPACKET) {
1562 /* Connected mode sockets go via the LAPB machine */
1563 if (sk->sk_state != TCP_ESTABLISHED) {
1564 kfree_skb(skb);
1565 err = -ENOTCONN;
1566 goto out;
1567 }
1568
1569 /* Shove it onto the queue and kick */
1570 ax25_output(ax25, ax25->paclen, skb);
1571
1572 err = len;
1573 goto out;
1574 }
1575
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001576 skb_push(skb, 1 + ax25_addr_size(dp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577
1578 SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1579
1580 if (dp != NULL)
1581 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1582
1583 /* Build an AX.25 header */
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001584 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1585 dp, AX25_COMMAND, AX25_MODULUS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586
1587 SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1588
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001589 skb_set_transport_header(skb, lv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001591 SOCK_DEBUG(sk, "base=%p pos=%p\n",
1592 skb->data, skb_transport_header(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001594 *skb_transport_header(skb) = AX25_UI;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595
1596 /* Datagram frames go straight out of the door as UI */
Arnaldo Carvalho de Melo29c4be52005-04-21 16:46:56 -07001597 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598
1599 err = len;
1600
1601out:
1602 release_sock(sk);
1603
1604 return err;
1605}
1606
1607static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1608 struct msghdr *msg, size_t size, int flags)
1609{
1610 struct sock *sk = sock->sk;
1611 struct sk_buff *skb;
1612 int copied;
1613 int err = 0;
1614
1615 lock_sock(sk);
1616 /*
1617 * This works for seqpacket too. The receiver has ordered the
1618 * queue for us! We do one quick check first though
1619 */
1620 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1621 err = -ENOTCONN;
1622 goto out;
1623 }
1624
1625 /* Now we can treat all alike */
1626 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001627 flags & MSG_DONTWAIT, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628 if (skb == NULL)
1629 goto out;
1630
1631 if (!ax25_sk(sk)->pidincl)
1632 skb_pull(skb, 1); /* Remove PID */
1633
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001634 skb_reset_transport_header(skb);
1635 copied = skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636
1637 if (copied > size) {
1638 copied = size;
1639 msg->msg_flags |= MSG_TRUNC;
1640 }
1641
1642 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1643
1644 if (msg->msg_namelen != 0) {
1645 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1646 ax25_digi digi;
1647 ax25_address src;
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001648 const unsigned char *mac = skb_mac_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001650 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1651 &digi, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 sax->sax25_family = AF_AX25;
1653 /* We set this correctly, even though we may not let the
1654 application know the digi calls further down (because it
1655 did NOT ask to know them). This could get political... **/
1656 sax->sax25_ndigis = digi.ndigi;
1657 sax->sax25_call = src;
1658
1659 if (sax->sax25_ndigis != 0) {
1660 int ct;
1661 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1662
1663 for (ct = 0; ct < digi.ndigi; ct++)
1664 fsa->fsa_digipeater[ct] = digi.calls[ct];
1665 }
1666 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1667 }
1668
1669 skb_free_datagram(sk, skb);
1670 err = copied;
1671
1672out:
1673 release_sock(sk);
1674
1675 return err;
1676}
1677
1678static int ax25_shutdown(struct socket *sk, int how)
1679{
1680 /* FIXME - generate DM and RNR states */
1681 return -EOPNOTSUPP;
1682}
1683
1684static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1685{
1686 struct sock *sk = sock->sk;
1687 void __user *argp = (void __user *)arg;
1688 int res = 0;
1689
1690 lock_sock(sk);
1691 switch (cmd) {
1692 case TIOCOUTQ: {
1693 long amount;
1694 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
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;
Ralf Baechle20b7d102005-09-12 14:24:55 -07001707 res = put_user(amount, (int __user *) argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708 break;
1709 }
1710
1711 case SIOCGSTAMP:
Ralf Baechle9b37ee72005-09-12 14:23:52 -07001712 res = sock_get_timestamp(sk, argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 break;
1714
Eric Dumazetae40eb12007-03-18 17:33:16 -07001715 case SIOCGSTAMPNS:
1716 res = sock_get_timestampns(sk, argp);
1717 break;
1718
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 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;
1784 ax25_info.rcv_q = atomic_read(&sk->sk_rmem_alloc);
1785 ax25_info.snd_q = atomic_read(&sk->sk_wmem_alloc);
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:
Christoph Hellwigb5e5fa52006-01-03 14:18:33 -08001845 res = -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 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)
Eric Dumazetf16f3022008-01-13 22:29:41 -08001856 __acquires(ax25_list_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857{
1858 struct ax25_cb *ax25;
1859 struct hlist_node *node;
1860 int i = 0;
1861
1862 spin_lock_bh(&ax25_list_lock);
1863 ax25_for_each(ax25, node, &ax25_list) {
1864 if (i == *pos)
1865 return ax25;
1866 ++i;
1867 }
1868 return NULL;
1869}
1870
1871static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1872{
1873 ++*pos;
1874
1875 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1876 struct ax25_cb, ax25_node);
1877}
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001878
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879static void ax25_info_stop(struct seq_file *seq, void *v)
Eric Dumazetf16f3022008-01-13 22:29:41 -08001880 __releases(ax25_list_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881{
1882 spin_unlock_bh(&ax25_list_lock);
1883}
1884
1885static int ax25_info_show(struct seq_file *seq, void *v)
1886{
1887 ax25_cb *ax25 = v;
Ralf Baechlef75268c2005-09-06 15:49:39 -07001888 char buf[11];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 int k;
1890
1891
1892 /*
1893 * New format:
1894 * 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
1895 */
1896
1897 seq_printf(seq, "%8.8lx %s %s%s ",
1898 (long) ax25,
1899 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
Ralf Baechlef75268c2005-09-06 15:49:39 -07001900 ax2asc(buf, &ax25->source_addr),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901 ax25->iamdigi? "*":"");
Ralf Baechlef75268c2005-09-06 15:49:39 -07001902 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903
1904 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1905 seq_printf(seq, ",%s%s",
Ralf Baechlef75268c2005-09-06 15:49:39 -07001906 ax2asc(buf, &ax25->digipeat->calls[k]),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907 ax25->digipeat->repeated[k]? "*":"");
1908 }
1909
1910 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1911 ax25->state,
1912 ax25->vs, ax25->vr, ax25->va,
1913 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1914 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1915 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1916 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1917 ax25->idle / (60 * HZ),
1918 ax25->n2count, ax25->n2,
1919 ax25->rtt / HZ,
1920 ax25->window,
1921 ax25->paclen);
1922
1923 if (ax25->sk != NULL) {
Jarek Poplawski1105b5d2008-02-11 21:24:56 -08001924 seq_printf(seq, " %d %d %lu\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 atomic_read(&ax25->sk->sk_wmem_alloc),
1926 atomic_read(&ax25->sk->sk_rmem_alloc),
Jarek Poplawski1105b5d2008-02-11 21:24:56 -08001927 sock_i_ino(ax25->sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 } else {
1929 seq_puts(seq, " * * *\n");
1930 }
1931 return 0;
1932}
1933
Philippe De Muyter56b3d972007-07-10 23:07:31 -07001934static const struct seq_operations ax25_info_seqops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 .start = ax25_info_start,
1936 .next = ax25_info_next,
1937 .stop = ax25_info_stop,
1938 .show = ax25_info_show,
1939};
1940
1941static int ax25_info_open(struct inode *inode, struct file *file)
1942{
1943 return seq_open(file, &ax25_info_seqops);
1944}
1945
Arjan van de Ven9a321442007-02-12 00:55:35 -08001946static const struct file_operations ax25_info_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947 .owner = THIS_MODULE,
1948 .open = ax25_info_open,
1949 .read = seq_read,
1950 .llseek = seq_lseek,
1951 .release = seq_release,
1952};
1953
1954#endif
1955
1956static struct net_proto_family ax25_family_ops = {
1957 .family = PF_AX25,
1958 .create = ax25_create,
1959 .owner = THIS_MODULE,
1960};
1961
Eric Dumazet90ddc4f2005-12-22 12:49:22 -08001962static const struct proto_ops ax25_proto_ops = {
Ralf Baechle46763562005-09-12 14:25:25 -07001963 .family = PF_AX25,
1964 .owner = THIS_MODULE,
1965 .release = ax25_release,
1966 .bind = ax25_bind,
1967 .connect = ax25_connect,
1968 .socketpair = sock_no_socketpair,
1969 .accept = ax25_accept,
1970 .getname = ax25_getname,
1971 .poll = datagram_poll,
1972 .ioctl = ax25_ioctl,
1973 .listen = ax25_listen,
1974 .shutdown = ax25_shutdown,
1975 .setsockopt = ax25_setsockopt,
1976 .getsockopt = ax25_getsockopt,
1977 .sendmsg = ax25_sendmsg,
1978 .recvmsg = ax25_recvmsg,
1979 .mmap = sock_no_mmap,
1980 .sendpage = sock_no_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981};
1982
1983/*
1984 * Called by socket.c on kernel start up
1985 */
Stephen Hemminger7546dd92009-03-09 08:18:29 +00001986static struct packet_type ax25_packet_type __read_mostly = {
Harvey Harrison09640e62009-02-01 00:45:17 -08001987 .type = cpu_to_be16(ETH_P_AX25),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 .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);