blob: 2712544cf0cac124fcc2d9985d005d01968a3cec [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 Hideakic346dca2008-03-25 21:47:49 +0900119 if (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;
896 sk->sk_socket = osk->sk_socket;
897 sk->sk_priority = osk->sk_priority;
898 sk->sk_protocol = osk->sk_protocol;
899 sk->sk_rcvbuf = osk->sk_rcvbuf;
900 sk->sk_sndbuf = osk->sk_sndbuf;
901 sk->sk_state = TCP_ESTABLISHED;
902 sk->sk_sleep = osk->sk_sleep;
Ralf Baechle53b924b2005-08-23 10:11:30 -0700903 sock_copy_flags(sk, osk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904
905 oax25 = ax25_sk(osk);
906
907 ax25->modulus = oax25->modulus;
908 ax25->backoff = oax25->backoff;
909 ax25->pidincl = oax25->pidincl;
910 ax25->iamdigi = oax25->iamdigi;
911 ax25->rtt = oax25->rtt;
912 ax25->t1 = oax25->t1;
913 ax25->t2 = oax25->t2;
914 ax25->t3 = oax25->t3;
915 ax25->n2 = oax25->n2;
916 ax25->idle = oax25->idle;
917 ax25->paclen = oax25->paclen;
918 ax25->window = oax25->window;
919
920 ax25->ax25_dev = ax25_dev;
921 ax25->source_addr = oax25->source_addr;
922
923 if (oax25->digipeat != NULL) {
Arnaldo Carvalho de Melo0459d70a2006-11-17 12:43:07 -0200924 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
925 GFP_ATOMIC);
926 if (ax25->digipeat == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 sk_free(sk);
928 ax25_cb_put(ax25);
929 return NULL;
930 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 }
932
933 sk->sk_protinfo = ax25;
934 ax25->sk = sk;
935
936 return sk;
937}
938
939static int ax25_release(struct socket *sock)
940{
941 struct sock *sk = sock->sk;
942 ax25_cb *ax25;
943
944 if (sk == NULL)
945 return 0;
946
947 sock_hold(sk);
948 sock_orphan(sk);
949 lock_sock(sk);
950 ax25 = ax25_sk(sk);
951
952 if (sk->sk_type == SOCK_SEQPACKET) {
953 switch (ax25->state) {
954 case AX25_STATE_0:
955 release_sock(sk);
956 ax25_disconnect(ax25, 0);
957 lock_sock(sk);
958 ax25_destroy_socket(ax25);
959 break;
960
961 case AX25_STATE_1:
962 case AX25_STATE_2:
963 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
964 release_sock(sk);
965 ax25_disconnect(ax25, 0);
966 lock_sock(sk);
967 ax25_destroy_socket(ax25);
968 break;
969
970 case AX25_STATE_3:
971 case AX25_STATE_4:
972 ax25_clear_queues(ax25);
973 ax25->n2count = 0;
974
975 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
976 case AX25_PROTO_STD_SIMPLEX:
977 case AX25_PROTO_STD_DUPLEX:
978 ax25_send_control(ax25,
979 AX25_DISC,
980 AX25_POLLON,
981 AX25_COMMAND);
982 ax25_stop_t2timer(ax25);
983 ax25_stop_t3timer(ax25);
984 ax25_stop_idletimer(ax25);
985 break;
986#ifdef CONFIG_AX25_DAMA_SLAVE
987 case AX25_PROTO_DAMA_SLAVE:
988 ax25_stop_t3timer(ax25);
989 ax25_stop_idletimer(ax25);
990 break;
991#endif
992 }
993 ax25_calculate_t1(ax25);
994 ax25_start_t1timer(ax25);
995 ax25->state = AX25_STATE_2;
996 sk->sk_state = TCP_CLOSE;
997 sk->sk_shutdown |= SEND_SHUTDOWN;
998 sk->sk_state_change(sk);
999 sock_set_flag(sk, SOCK_DESTROY);
1000 break;
1001
1002 default:
1003 break;
1004 }
1005 } else {
1006 sk->sk_state = TCP_CLOSE;
1007 sk->sk_shutdown |= SEND_SHUTDOWN;
1008 sk->sk_state_change(sk);
1009 ax25_destroy_socket(ax25);
1010 }
1011
1012 sock->sk = NULL;
1013 release_sock(sk);
1014 sock_put(sk);
1015
1016 return 0;
1017}
1018
1019/*
1020 * We support a funny extension here so you can (as root) give any callsign
1021 * digipeated via a local address as source. This hack is obsolete now
1022 * that we've implemented support for SO_BINDTODEVICE. It is however small
1023 * and trivially backward compatible.
1024 */
1025static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1026{
1027 struct sock *sk = sock->sk;
1028 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1029 ax25_dev *ax25_dev = NULL;
Ralf Baechle01d7dd02005-08-23 10:11:45 -07001030 ax25_uid_assoc *user;
1031 ax25_address call;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 ax25_cb *ax25;
1033 int err = 0;
1034
1035 if (addr_len != sizeof(struct sockaddr_ax25) &&
maximilian attems1987e7b2008-01-28 20:44:11 -08001036 addr_len != sizeof(struct full_sockaddr_ax25))
1037 /* support for old structure may go away some time
1038 * ax25_bind(): uses old (6 digipeater) socket structure.
1039 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
maximilian attems1987e7b2008-01-28 20:44:11 -08001041 (addr_len > sizeof(struct full_sockaddr_ax25)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043
1044 if (addr->fsa_ax25.sax25_family != AF_AX25)
1045 return -EINVAL;
1046
Ralf Baechle01d7dd02005-08-23 10:11:45 -07001047 user = ax25_findbyuid(current->euid);
1048 if (user) {
1049 call = user->call;
1050 ax25_uid_put(user);
1051 } else {
1052 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1053 return -EACCES;
1054
1055 call = addr->fsa_ax25.sax25_call;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 }
1057
1058 lock_sock(sk);
1059
1060 ax25 = ax25_sk(sk);
1061 if (!sock_flag(sk, SOCK_ZAPPED)) {
1062 err = -EINVAL;
1063 goto out;
1064 }
1065
Ralf Baechle01d7dd02005-08-23 10:11:45 -07001066 ax25->source_addr = call;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067
1068 /*
1069 * User already set interface with SO_BINDTODEVICE
1070 */
1071 if (ax25->ax25_dev != NULL)
1072 goto done;
1073
1074 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1075 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1076 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1077 err = -EADDRNOTAVAIL;
1078 goto out;
1079 }
1080 } else {
1081 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1082 err = -EADDRNOTAVAIL;
1083 goto out;
1084 }
1085 }
1086
1087 if (ax25_dev != NULL)
1088 ax25_fillin_cb(ax25, ax25_dev);
1089
1090done:
1091 ax25_cb_add(ax25);
1092 sock_reset_flag(sk, SOCK_ZAPPED);
1093
1094out:
1095 release_sock(sk);
1096
1097 return 0;
1098}
1099
1100/*
1101 * FIXME: nonblock behaviour looks like it may have a bug.
1102 */
Ralf Baechlec9266b92006-12-14 15:49:28 -08001103static int __must_check ax25_connect(struct socket *sock,
1104 struct sockaddr *uaddr, int addr_len, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105{
1106 struct sock *sk = sock->sk;
1107 ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1108 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1109 ax25_digi *digi = NULL;
1110 int ct = 0, err = 0;
1111
1112 /*
1113 * some sanity checks. code further down depends on this
1114 */
1115
maximilian attems27d1cba2008-01-10 03:57:29 -08001116 if (addr_len == sizeof(struct sockaddr_ax25))
1117 /* support for this will go away in early 2.5.x
1118 * ax25_connect(): uses obsolete socket structure
1119 */
1120 ;
1121 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1122 /* support for old structure may go away some time
1123 * ax25_connect(): uses old (6 digipeater) socket structure.
1124 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
maximilian attems27d1cba2008-01-10 03:57:29 -08001126 (addr_len > sizeof(struct full_sockaddr_ax25)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
1130 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1131 return -EINVAL;
1132
1133 lock_sock(sk);
1134
1135 /* deal with restarts */
1136 if (sock->state == SS_CONNECTING) {
1137 switch (sk->sk_state) {
1138 case TCP_SYN_SENT: /* still trying */
1139 err = -EINPROGRESS;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001140 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141
1142 case TCP_ESTABLISHED: /* connection established */
1143 sock->state = SS_CONNECTED;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001144 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145
1146 case TCP_CLOSE: /* connection refused */
1147 sock->state = SS_UNCONNECTED;
1148 err = -ECONNREFUSED;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001149 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 }
1151 }
1152
1153 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1154 err = -EISCONN; /* No reconnect on a seqpacket socket */
Ralf Baechle75606dc2007-04-20 16:06:45 -07001155 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 }
1157
1158 sk->sk_state = TCP_CLOSE;
1159 sock->state = SS_UNCONNECTED;
1160
Jesper Juhla51482b2005-11-08 09:41:34 -08001161 kfree(ax25->digipeat);
1162 ax25->digipeat = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163
1164 /*
1165 * Handle digi-peaters to be used.
1166 */
1167 if (addr_len > sizeof(struct sockaddr_ax25) &&
1168 fsa->fsa_ax25.sax25_ndigis != 0) {
1169 /* Valid number of digipeaters ? */
1170 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1171 err = -EINVAL;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001172 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 }
1174
1175 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1176 err = -ENOBUFS;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001177 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 }
1179
1180 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1181 digi->lastrepeat = -1;
1182
1183 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1184 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1185 AX25_HBIT) && ax25->iamdigi) {
1186 digi->repeated[ct] = 1;
1187 digi->lastrepeat = ct;
1188 } else {
1189 digi->repeated[ct] = 0;
1190 }
1191 digi->calls[ct] = fsa->fsa_digipeater[ct];
1192 ct++;
1193 }
1194 }
1195
1196 /*
1197 * Must bind first - autobinding in this may or may not work. If
1198 * the socket is already bound, check to see if the device has
1199 * been filled in, error if it hasn't.
1200 */
1201 if (sock_flag(sk, SOCK_ZAPPED)) {
1202 /* check if we can remove this feature. It is broken. */
1203 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1204 current->comm);
1205 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1206 kfree(digi);
Ralf Baechle75606dc2007-04-20 16:06:45 -07001207 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 }
1209
1210 ax25_fillin_cb(ax25, ax25->ax25_dev);
1211 ax25_cb_add(ax25);
1212 } else {
1213 if (ax25->ax25_dev == NULL) {
1214 kfree(digi);
1215 err = -EHOSTUNREACH;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001216 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 }
1218 }
1219
1220 if (sk->sk_type == SOCK_SEQPACKET &&
1221 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001222 ax25->ax25_dev->dev))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 kfree(digi);
1224 err = -EADDRINUSE; /* Already such a connection */
1225 ax25_cb_put(ax25t);
Ralf Baechle75606dc2007-04-20 16:06:45 -07001226 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 }
1228
1229 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1230 ax25->digipeat = digi;
1231
1232 /* First the easy one */
1233 if (sk->sk_type != SOCK_SEQPACKET) {
1234 sock->state = SS_CONNECTED;
1235 sk->sk_state = TCP_ESTABLISHED;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001236 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 }
1238
1239 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1240 sock->state = SS_CONNECTING;
1241 sk->sk_state = TCP_SYN_SENT;
1242
1243 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1244 case AX25_PROTO_STD_SIMPLEX:
1245 case AX25_PROTO_STD_DUPLEX:
1246 ax25_std_establish_data_link(ax25);
1247 break;
1248
1249#ifdef CONFIG_AX25_DAMA_SLAVE
1250 case AX25_PROTO_DAMA_SLAVE:
1251 ax25->modulus = AX25_MODULUS;
1252 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1253 if (ax25->ax25_dev->dama.slave)
1254 ax25_ds_establish_data_link(ax25);
1255 else
1256 ax25_std_establish_data_link(ax25);
1257 break;
1258#endif
1259 }
1260
1261 ax25->state = AX25_STATE_1;
1262
1263 ax25_start_heartbeat(ax25);
1264
1265 /* Now the loop */
1266 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1267 err = -EINPROGRESS;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001268 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 }
1270
1271 if (sk->sk_state == TCP_SYN_SENT) {
Ralf Baechle75606dc2007-04-20 16:06:45 -07001272 DEFINE_WAIT(wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 for (;;) {
Ralf Baechle75606dc2007-04-20 16:06:45 -07001275 prepare_to_wait(sk->sk_sleep, &wait,
YOSHIFUJI Hideakibd3b0712007-07-19 10:43:13 +09001276 TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 if (sk->sk_state != TCP_SYN_SENT)
1278 break;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001279 if (!signal_pending(current)) {
1280 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 schedule();
1282 lock_sock(sk);
1283 continue;
1284 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001285 err = -ERESTARTSYS;
1286 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001288 finish_wait(sk->sk_sleep, &wait);
1289
1290 if (err)
1291 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 }
1293
1294 if (sk->sk_state != TCP_ESTABLISHED) {
1295 /* Not in ABM, not in WAIT_UA -> failed */
1296 sock->state = SS_UNCONNECTED;
1297 err = sock_error(sk); /* Always set at this point */
Ralf Baechle75606dc2007-04-20 16:06:45 -07001298 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 }
1300
1301 sock->state = SS_CONNECTED;
1302
Ralf Baechle75606dc2007-04-20 16:06:45 -07001303 err = 0;
1304out_release:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 release_sock(sk);
1306
1307 return err;
1308}
1309
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1311{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 struct sk_buff *skb;
1313 struct sock *newsk;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001314 DEFINE_WAIT(wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 struct sock *sk;
1316 int err = 0;
1317
1318 if (sock->state != SS_UNCONNECTED)
1319 return -EINVAL;
1320
1321 if ((sk = sock->sk) == NULL)
1322 return -EINVAL;
1323
1324 lock_sock(sk);
1325 if (sk->sk_type != SOCK_SEQPACKET) {
1326 err = -EOPNOTSUPP;
1327 goto out;
1328 }
1329
1330 if (sk->sk_state != TCP_LISTEN) {
1331 err = -EINVAL;
1332 goto out;
1333 }
1334
1335 /*
1336 * The read queue this time is holding sockets ready to use
1337 * hooked into the SABM we saved
1338 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 for (;;) {
Ralf Baechle75606dc2007-04-20 16:06:45 -07001340 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 skb = skb_dequeue(&sk->sk_receive_queue);
1342 if (skb)
1343 break;
1344
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 if (flags & O_NONBLOCK) {
Ralf Baechle75606dc2007-04-20 16:06:45 -07001346 err = -EWOULDBLOCK;
1347 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001349 if (!signal_pending(current)) {
1350 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 schedule();
1352 lock_sock(sk);
1353 continue;
1354 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001355 err = -ERESTARTSYS;
1356 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001358 finish_wait(sk->sk_sleep, &wait);
1359
1360 if (err)
1361 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362
1363 newsk = skb->sk;
1364 newsk->sk_socket = newsock;
1365 newsk->sk_sleep = &newsock->wait;
1366
1367 /* Now attach up the new socket */
1368 kfree_skb(skb);
1369 sk->sk_ack_backlog--;
1370 newsock->sk = newsk;
1371 newsock->state = SS_CONNECTED;
1372
1373out:
1374 release_sock(sk);
1375
1376 return err;
1377}
1378
1379static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1380 int *uaddr_len, int peer)
1381{
1382 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1383 struct sock *sk = sock->sk;
1384 unsigned char ndigi, i;
1385 ax25_cb *ax25;
1386 int err = 0;
1387
1388 lock_sock(sk);
1389 ax25 = ax25_sk(sk);
1390
1391 if (peer != 0) {
1392 if (sk->sk_state != TCP_ESTABLISHED) {
1393 err = -ENOTCONN;
1394 goto out;
1395 }
1396
1397 fsa->fsa_ax25.sax25_family = AF_AX25;
1398 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1399 fsa->fsa_ax25.sax25_ndigis = 0;
1400
1401 if (ax25->digipeat != NULL) {
1402 ndigi = ax25->digipeat->ndigi;
1403 fsa->fsa_ax25.sax25_ndigis = ndigi;
1404 for (i = 0; i < ndigi; i++)
1405 fsa->fsa_digipeater[i] =
1406 ax25->digipeat->calls[i];
1407 }
1408 } else {
1409 fsa->fsa_ax25.sax25_family = AF_AX25;
1410 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1411 fsa->fsa_ax25.sax25_ndigis = 1;
1412 if (ax25->ax25_dev != NULL) {
1413 memcpy(&fsa->fsa_digipeater[0],
1414 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1415 } else {
1416 fsa->fsa_digipeater[0] = null_ax25_address;
1417 }
1418 }
1419 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1420
1421out:
1422 release_sock(sk);
1423
1424 return err;
1425}
1426
1427static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1428 struct msghdr *msg, size_t len)
1429{
1430 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1431 struct sock *sk = sock->sk;
1432 struct sockaddr_ax25 sax;
1433 struct sk_buff *skb;
1434 ax25_digi dtmp, *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 ax25_cb *ax25;
1436 size_t size;
1437 int lv, err, addr_len = msg->msg_namelen;
1438
1439 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1440 return -EINVAL;
1441
1442 lock_sock(sk);
1443 ax25 = ax25_sk(sk);
1444
1445 if (sock_flag(sk, SOCK_ZAPPED)) {
1446 err = -EADDRNOTAVAIL;
1447 goto out;
1448 }
1449
1450 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1451 send_sig(SIGPIPE, current, 0);
1452 err = -EPIPE;
1453 goto out;
1454 }
1455
1456 if (ax25->ax25_dev == NULL) {
1457 err = -ENETUNREACH;
1458 goto out;
1459 }
1460
1461 if (len > ax25->ax25_dev->dev->mtu) {
1462 err = -EMSGSIZE;
1463 goto out;
1464 }
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001465
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 if (usax != NULL) {
1467 if (usax->sax25_family != AF_AX25) {
1468 err = -EINVAL;
1469 goto out;
1470 }
1471
maximilian attems27d1cba2008-01-10 03:57:29 -08001472 if (addr_len == sizeof(struct sockaddr_ax25))
1473 /* ax25_sendmsg(): uses obsolete socket structure */
1474 ;
1475 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1476 /* support for old structure may go away some time
1477 * ax25_sendmsg(): uses old (6 digipeater)
1478 * socket structure.
1479 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001481 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1482 err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 goto out;
1484 }
1485
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486
1487 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1488 int ct = 0;
1489 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1490
1491 /* Valid number of digipeaters ? */
1492 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1493 err = -EINVAL;
1494 goto out;
1495 }
1496
1497 dtmp.ndigi = usax->sax25_ndigis;
1498
1499 while (ct < usax->sax25_ndigis) {
1500 dtmp.repeated[ct] = 0;
1501 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1502 ct++;
1503 }
1504
1505 dtmp.lastrepeat = 0;
1506 }
1507
1508 sax = *usax;
1509 if (sk->sk_type == SOCK_SEQPACKET &&
1510 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1511 err = -EISCONN;
1512 goto out;
1513 }
1514 if (usax->sax25_ndigis == 0)
1515 dp = NULL;
1516 else
1517 dp = &dtmp;
1518 } else {
1519 /*
1520 * FIXME: 1003.1g - if the socket is like this because
1521 * it has become closed (not started closed) and is VC
1522 * we ought to SIGPIPE, EPIPE
1523 */
1524 if (sk->sk_state != TCP_ESTABLISHED) {
1525 err = -ENOTCONN;
1526 goto out;
1527 }
1528 sax.sax25_family = AF_AX25;
1529 sax.sax25_call = ax25->dest_addr;
1530 dp = ax25->digipeat;
1531 }
1532
1533 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built.\n");
1534
1535 /* Build a packet */
1536 SOCK_DEBUG(sk, "AX.25: sendto: building packet.\n");
1537
1538 /* Assume the worst case */
1539 size = len + ax25->ax25_dev->dev->hard_header_len;
1540
1541 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1542 if (skb == NULL)
1543 goto out;
1544
1545 skb_reserve(skb, size - len);
1546
1547 SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1548
1549 /* User data follows immediately after the AX.25 data */
1550 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1551 err = -EFAULT;
1552 kfree_skb(skb);
1553 goto out;
1554 }
1555
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001556 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557
1558 /* Add the PID if one is not supplied by the user in the skb */
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001559 if (!ax25->pidincl)
1560 *skb_push(skb, 1) = sk->sk_protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561
1562 SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1563
1564 if (sk->sk_type == SOCK_SEQPACKET) {
1565 /* Connected mode sockets go via the LAPB machine */
1566 if (sk->sk_state != TCP_ESTABLISHED) {
1567 kfree_skb(skb);
1568 err = -ENOTCONN;
1569 goto out;
1570 }
1571
1572 /* Shove it onto the queue and kick */
1573 ax25_output(ax25, ax25->paclen, skb);
1574
1575 err = len;
1576 goto out;
1577 }
1578
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001579 skb_push(skb, 1 + ax25_addr_size(dp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580
1581 SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1582
1583 if (dp != NULL)
1584 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1585
1586 /* Build an AX.25 header */
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001587 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1588 dp, AX25_COMMAND, AX25_MODULUS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589
1590 SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1591
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001592 skb_set_transport_header(skb, lv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001594 SOCK_DEBUG(sk, "base=%p pos=%p\n",
1595 skb->data, skb_transport_header(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001597 *skb_transport_header(skb) = AX25_UI;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598
1599 /* Datagram frames go straight out of the door as UI */
Arnaldo Carvalho de Melo29c4be52005-04-21 16:46:56 -07001600 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601
1602 err = len;
1603
1604out:
1605 release_sock(sk);
1606
1607 return err;
1608}
1609
1610static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1611 struct msghdr *msg, size_t size, int flags)
1612{
1613 struct sock *sk = sock->sk;
1614 struct sk_buff *skb;
1615 int copied;
1616 int err = 0;
1617
1618 lock_sock(sk);
1619 /*
1620 * This works for seqpacket too. The receiver has ordered the
1621 * queue for us! We do one quick check first though
1622 */
1623 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1624 err = -ENOTCONN;
1625 goto out;
1626 }
1627
1628 /* Now we can treat all alike */
1629 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001630 flags & MSG_DONTWAIT, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 if (skb == NULL)
1632 goto out;
1633
1634 if (!ax25_sk(sk)->pidincl)
1635 skb_pull(skb, 1); /* Remove PID */
1636
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001637 skb_reset_transport_header(skb);
1638 copied = skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639
1640 if (copied > size) {
1641 copied = size;
1642 msg->msg_flags |= MSG_TRUNC;
1643 }
1644
1645 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1646
1647 if (msg->msg_namelen != 0) {
1648 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1649 ax25_digi digi;
1650 ax25_address src;
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001651 const unsigned char *mac = skb_mac_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001653 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1654 &digi, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 sax->sax25_family = AF_AX25;
1656 /* We set this correctly, even though we may not let the
1657 application know the digi calls further down (because it
1658 did NOT ask to know them). This could get political... **/
1659 sax->sax25_ndigis = digi.ndigi;
1660 sax->sax25_call = src;
1661
1662 if (sax->sax25_ndigis != 0) {
1663 int ct;
1664 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1665
1666 for (ct = 0; ct < digi.ndigi; ct++)
1667 fsa->fsa_digipeater[ct] = digi.calls[ct];
1668 }
1669 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1670 }
1671
1672 skb_free_datagram(sk, skb);
1673 err = copied;
1674
1675out:
1676 release_sock(sk);
1677
1678 return err;
1679}
1680
1681static int ax25_shutdown(struct socket *sk, int how)
1682{
1683 /* FIXME - generate DM and RNR states */
1684 return -EOPNOTSUPP;
1685}
1686
1687static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1688{
1689 struct sock *sk = sock->sk;
1690 void __user *argp = (void __user *)arg;
1691 int res = 0;
1692
1693 lock_sock(sk);
1694 switch (cmd) {
1695 case TIOCOUTQ: {
1696 long amount;
1697 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1698 if (amount < 0)
1699 amount = 0;
1700 res = put_user(amount, (int __user *)argp);
1701 break;
1702 }
1703
1704 case TIOCINQ: {
1705 struct sk_buff *skb;
1706 long amount = 0L;
1707 /* These two are safe on a single CPU system as only user tasks fiddle here */
1708 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1709 amount = skb->len;
Ralf Baechle20b7d102005-09-12 14:24:55 -07001710 res = put_user(amount, (int __user *) argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 break;
1712 }
1713
1714 case SIOCGSTAMP:
Ralf Baechle9b37ee72005-09-12 14:23:52 -07001715 res = sock_get_timestamp(sk, argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 break;
1717
Eric Dumazetae40eb12007-03-18 17:33:16 -07001718 case SIOCGSTAMPNS:
1719 res = sock_get_timestampns(sk, argp);
1720 break;
1721
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1723 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1724 case SIOCAX25GETUID: {
1725 struct sockaddr_ax25 sax25;
1726 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1727 res = -EFAULT;
1728 break;
1729 }
1730 res = ax25_uid_ioctl(cmd, &sax25);
1731 break;
1732 }
1733
1734 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1735 long amount;
1736 if (!capable(CAP_NET_ADMIN)) {
1737 res = -EPERM;
1738 break;
1739 }
1740 if (get_user(amount, (long __user *)argp)) {
1741 res = -EFAULT;
1742 break;
1743 }
1744 if (amount > AX25_NOUID_BLOCK) {
1745 res = -EINVAL;
1746 break;
1747 }
1748 ax25_uid_policy = amount;
1749 res = 0;
1750 break;
1751 }
1752
1753 case SIOCADDRT:
1754 case SIOCDELRT:
1755 case SIOCAX25OPTRT:
1756 if (!capable(CAP_NET_ADMIN)) {
1757 res = -EPERM;
1758 break;
1759 }
1760 res = ax25_rt_ioctl(cmd, argp);
1761 break;
1762
1763 case SIOCAX25CTLCON:
1764 if (!capable(CAP_NET_ADMIN)) {
1765 res = -EPERM;
1766 break;
1767 }
1768 res = ax25_ctl_ioctl(cmd, argp);
1769 break;
1770
1771 case SIOCAX25GETINFO:
1772 case SIOCAX25GETINFOOLD: {
1773 ax25_cb *ax25 = ax25_sk(sk);
1774 struct ax25_info_struct ax25_info;
1775
1776 ax25_info.t1 = ax25->t1 / HZ;
1777 ax25_info.t2 = ax25->t2 / HZ;
1778 ax25_info.t3 = ax25->t3 / HZ;
1779 ax25_info.idle = ax25->idle / (60 * HZ);
1780 ax25_info.n2 = ax25->n2;
1781 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1782 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1783 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1784 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1785 ax25_info.n2count = ax25->n2count;
1786 ax25_info.state = ax25->state;
1787 ax25_info.rcv_q = atomic_read(&sk->sk_rmem_alloc);
1788 ax25_info.snd_q = atomic_read(&sk->sk_wmem_alloc);
1789 ax25_info.vs = ax25->vs;
1790 ax25_info.vr = ax25->vr;
1791 ax25_info.va = ax25->va;
1792 ax25_info.vs_max = ax25->vs; /* reserved */
1793 ax25_info.paclen = ax25->paclen;
1794 ax25_info.window = ax25->window;
1795
1796 /* old structure? */
1797 if (cmd == SIOCAX25GETINFOOLD) {
1798 static int warned = 0;
1799 if (!warned) {
1800 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1801 current->comm);
1802 warned=1;
1803 }
1804
1805 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1806 res = -EFAULT;
1807 break;
1808 }
1809 } else {
1810 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1811 res = -EINVAL;
1812 break;
1813 }
1814 }
1815 res = 0;
1816 break;
1817 }
1818
1819 case SIOCAX25ADDFWD:
1820 case SIOCAX25DELFWD: {
1821 struct ax25_fwd_struct ax25_fwd;
1822 if (!capable(CAP_NET_ADMIN)) {
1823 res = -EPERM;
1824 break;
1825 }
1826 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1827 res = -EFAULT;
1828 break;
1829 }
1830 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1831 break;
1832 }
1833
1834 case SIOCGIFADDR:
1835 case SIOCSIFADDR:
1836 case SIOCGIFDSTADDR:
1837 case SIOCSIFDSTADDR:
1838 case SIOCGIFBRDADDR:
1839 case SIOCSIFBRDADDR:
1840 case SIOCGIFNETMASK:
1841 case SIOCSIFNETMASK:
1842 case SIOCGIFMETRIC:
1843 case SIOCSIFMETRIC:
1844 res = -EINVAL;
1845 break;
1846
1847 default:
Christoph Hellwigb5e5fa52006-01-03 14:18:33 -08001848 res = -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 break;
1850 }
1851 release_sock(sk);
1852
1853 return res;
1854}
1855
1856#ifdef CONFIG_PROC_FS
1857
1858static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
Eric Dumazetf16f3022008-01-13 22:29:41 -08001859 __acquires(ax25_list_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860{
1861 struct ax25_cb *ax25;
1862 struct hlist_node *node;
1863 int i = 0;
1864
1865 spin_lock_bh(&ax25_list_lock);
1866 ax25_for_each(ax25, node, &ax25_list) {
1867 if (i == *pos)
1868 return ax25;
1869 ++i;
1870 }
1871 return NULL;
1872}
1873
1874static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1875{
1876 ++*pos;
1877
1878 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1879 struct ax25_cb, ax25_node);
1880}
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001881
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882static void ax25_info_stop(struct seq_file *seq, void *v)
Eric Dumazetf16f3022008-01-13 22:29:41 -08001883 __releases(ax25_list_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884{
1885 spin_unlock_bh(&ax25_list_lock);
1886}
1887
1888static int ax25_info_show(struct seq_file *seq, void *v)
1889{
1890 ax25_cb *ax25 = v;
Ralf Baechlef75268c2005-09-06 15:49:39 -07001891 char buf[11];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 int k;
1893
1894
1895 /*
1896 * New format:
1897 * 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
1898 */
1899
1900 seq_printf(seq, "%8.8lx %s %s%s ",
1901 (long) ax25,
1902 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
Ralf Baechlef75268c2005-09-06 15:49:39 -07001903 ax2asc(buf, &ax25->source_addr),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 ax25->iamdigi? "*":"");
Ralf Baechlef75268c2005-09-06 15:49:39 -07001905 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906
1907 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1908 seq_printf(seq, ",%s%s",
Ralf Baechlef75268c2005-09-06 15:49:39 -07001909 ax2asc(buf, &ax25->digipeat->calls[k]),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 ax25->digipeat->repeated[k]? "*":"");
1911 }
1912
1913 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1914 ax25->state,
1915 ax25->vs, ax25->vr, ax25->va,
1916 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1917 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1918 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1919 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1920 ax25->idle / (60 * HZ),
1921 ax25->n2count, ax25->n2,
1922 ax25->rtt / HZ,
1923 ax25->window,
1924 ax25->paclen);
1925
1926 if (ax25->sk != NULL) {
Jarek Poplawski1105b5d2008-02-11 21:24:56 -08001927 seq_printf(seq, " %d %d %lu\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 atomic_read(&ax25->sk->sk_wmem_alloc),
1929 atomic_read(&ax25->sk->sk_rmem_alloc),
Jarek Poplawski1105b5d2008-02-11 21:24:56 -08001930 sock_i_ino(ax25->sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 } else {
1932 seq_puts(seq, " * * *\n");
1933 }
1934 return 0;
1935}
1936
Philippe De Muyter56b3d972007-07-10 23:07:31 -07001937static const struct seq_operations ax25_info_seqops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 .start = ax25_info_start,
1939 .next = ax25_info_next,
1940 .stop = ax25_info_stop,
1941 .show = ax25_info_show,
1942};
1943
1944static int ax25_info_open(struct inode *inode, struct file *file)
1945{
1946 return seq_open(file, &ax25_info_seqops);
1947}
1948
Arjan van de Ven9a321442007-02-12 00:55:35 -08001949static const struct file_operations ax25_info_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950 .owner = THIS_MODULE,
1951 .open = ax25_info_open,
1952 .read = seq_read,
1953 .llseek = seq_lseek,
1954 .release = seq_release,
1955};
1956
1957#endif
1958
1959static struct net_proto_family ax25_family_ops = {
1960 .family = PF_AX25,
1961 .create = ax25_create,
1962 .owner = THIS_MODULE,
1963};
1964
Eric Dumazet90ddc4f2005-12-22 12:49:22 -08001965static const struct proto_ops ax25_proto_ops = {
Ralf Baechle46763562005-09-12 14:25:25 -07001966 .family = PF_AX25,
1967 .owner = THIS_MODULE,
1968 .release = ax25_release,
1969 .bind = ax25_bind,
1970 .connect = ax25_connect,
1971 .socketpair = sock_no_socketpair,
1972 .accept = ax25_accept,
1973 .getname = ax25_getname,
1974 .poll = datagram_poll,
1975 .ioctl = ax25_ioctl,
1976 .listen = ax25_listen,
1977 .shutdown = ax25_shutdown,
1978 .setsockopt = ax25_setsockopt,
1979 .getsockopt = ax25_getsockopt,
1980 .sendmsg = ax25_sendmsg,
1981 .recvmsg = ax25_recvmsg,
1982 .mmap = sock_no_mmap,
1983 .sendpage = sock_no_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984};
1985
1986/*
1987 * Called by socket.c on kernel start up
1988 */
1989static struct packet_type ax25_packet_type = {
1990 .type = __constant_htons(ETH_P_AX25),
1991 .dev = NULL, /* All devices */
1992 .func = ax25_kiss_rcv,
1993};
1994
1995static struct notifier_block ax25_dev_notifier = {
1996 .notifier_call =ax25_device_event,
1997};
1998
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999static int __init ax25_init(void)
2000{
2001 int rc = proto_register(&ax25_proto, 0);
2002
2003 if (rc != 0)
2004 goto out;
2005
2006 sock_register(&ax25_family_ops);
2007 dev_add_pack(&ax25_packet_type);
2008 register_netdevice_notifier(&ax25_dev_notifier);
2009 ax25_register_sysctl();
2010
Eric W. Biederman457c4cb2007-09-12 12:01:34 +02002011 proc_net_fops_create(&init_net, "ax25_route", S_IRUGO, &ax25_route_fops);
2012 proc_net_fops_create(&init_net, "ax25", S_IRUGO, &ax25_info_fops);
2013 proc_net_fops_create(&init_net, "ax25_calls", S_IRUGO, &ax25_uid_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014out:
2015 return rc;
2016}
2017module_init(ax25_init);
2018
2019
2020MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2021MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2022MODULE_LICENSE("GPL");
2023MODULE_ALIAS_NETPROTO(PF_AX25);
2024
2025static void __exit ax25_exit(void)
2026{
Eric W. Biederman457c4cb2007-09-12 12:01:34 +02002027 proc_net_remove(&init_net, "ax25_route");
2028 proc_net_remove(&init_net, "ax25");
2029 proc_net_remove(&init_net, "ax25_calls");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 ax25_rt_free();
2031 ax25_uid_free();
2032 ax25_dev_free();
2033
2034 ax25_unregister_sysctl();
2035 unregister_netdevice_notifier(&ax25_dev_notifier);
2036
2037 dev_remove_pack(&ax25_packet_type);
2038
2039 sock_unregister(PF_AX25);
2040 proto_unregister(&ax25_proto);
2041}
2042module_exit(ax25_exit);