blob: 7b11f8bc5071cba0de51054913fa5f3e8bb3f063 [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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090028#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <net/ax25.h>
30#include <linux/inet.h>
31#include <linux/netdevice.h>
32#include <linux/if_arp.h>
33#include <linux/skbuff.h>
34#include <net/sock.h>
35#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#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;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
85 if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
86 return;
87
88 spin_lock_bh(&ax25_list_lock);
Jarek Poplawskiecd2ebd2008-01-10 21:21:20 -080089again:
Sasha Levinb67bfe02013-02-27 17:06:00 -080090 ax25_for_each(s, &ax25_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 if (s->ax25_dev == ax25_dev) {
92 s->ax25_dev = NULL;
Jarek Poplawskiecd2ebd2008-01-10 21:21:20 -080093 spin_unlock_bh(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 ax25_disconnect(s, ENETUNREACH);
Jarek Poplawskiecd2ebd2008-01-10 21:21:20 -080095 spin_lock_bh(&ax25_list_lock);
96
97 /* The entry could have been deleted from the
98 * list meanwhile and thus the next pointer is
99 * no longer valid. Play it safe and restart
100 * the scan. Forward progress is ensured
101 * because we set s->ax25_dev to NULL and we
102 * are never passed a NULL 'dev' argument.
103 */
104 goto again;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 }
106 }
107 spin_unlock_bh(&ax25_list_lock);
108}
109
110/*
111 * Handle device status changes.
112 */
113static int ax25_device_event(struct notifier_block *this, unsigned long event,
114 void *ptr)
115{
116 struct net_device *dev = (struct net_device *)ptr;
117
YOSHIFUJI Hideaki721499e2008-07-19 22:34:43 -0700118 if (!net_eq(dev_net(dev), &init_net))
Eric W. Biedermane9dc8652007-09-12 13:02:17 +0200119 return NOTIFY_DONE;
120
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 /* Reject non AX.25 devices */
122 if (dev->type != ARPHRD_AX25)
123 return NOTIFY_DONE;
124
125 switch (event) {
126 case NETDEV_UP:
127 ax25_dev_device_up(dev);
128 break;
129 case NETDEV_DOWN:
130 ax25_kill_by_device(dev);
131 ax25_rt_device_down(dev);
132 ax25_dev_device_down(dev);
133 break;
134 default:
135 break;
136 }
137
138 return NOTIFY_DONE;
139}
140
141/*
142 * Add a socket to the bound sockets list.
143 */
144void ax25_cb_add(ax25_cb *ax25)
145{
146 spin_lock_bh(&ax25_list_lock);
147 ax25_cb_hold(ax25);
148 hlist_add_head(&ax25->ax25_node, &ax25_list);
149 spin_unlock_bh(&ax25_list_lock);
150}
151
152/*
153 * Find a socket that wants to accept the SABM we have just
154 * received.
155 */
156struct sock *ax25_find_listener(ax25_address *addr, int digi,
157 struct net_device *dev, int type)
158{
159 ax25_cb *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700161 spin_lock(&ax25_list_lock);
Sasha Levinb67bfe02013-02-27 17:06:00 -0800162 ax25_for_each(s, &ax25_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
164 continue;
165 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
166 s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
167 /* If device is null we match any device */
168 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
169 sock_hold(s->sk);
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700170 spin_unlock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 return s->sk;
172 }
173 }
174 }
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700175 spin_unlock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
177 return NULL;
178}
179
180/*
181 * Find an AX.25 socket given both ends.
182 */
183struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
184 int type)
185{
186 struct sock *sk = NULL;
187 ax25_cb *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700189 spin_lock(&ax25_list_lock);
Sasha Levinb67bfe02013-02-27 17:06:00 -0800190 ax25_for_each(s, &ax25_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
192 !ax25cmp(&s->dest_addr, dest_addr) &&
193 s->sk->sk_type == type) {
194 sk = s->sk;
195 sock_hold(sk);
196 break;
197 }
198 }
199
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700200 spin_unlock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
202 return sk;
203}
204
205/*
206 * Find an AX.25 control block given both ends. It will only pick up
207 * floating AX.25 control blocks or non Raw socket bound control blocks.
208 */
209ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
210 ax25_digi *digi, struct net_device *dev)
211{
212 ax25_cb *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
214 spin_lock_bh(&ax25_list_lock);
Sasha Levinb67bfe02013-02-27 17:06:00 -0800215 ax25_for_each(s, &ax25_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
217 continue;
218 if (s->ax25_dev == NULL)
219 continue;
220 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
221 if (digi != NULL && digi->ndigi != 0) {
222 if (s->digipeat == NULL)
223 continue;
224 if (ax25digicmp(s->digipeat, digi) != 0)
225 continue;
226 } else {
227 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
228 continue;
229 }
230 ax25_cb_hold(s);
231 spin_unlock_bh(&ax25_list_lock);
232
233 return s;
234 }
235 }
236 spin_unlock_bh(&ax25_list_lock);
237
238 return NULL;
239}
240
Ralf Baechle70868ea2006-05-03 23:25:17 -0700241EXPORT_SYMBOL(ax25_find_cb);
242
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
244{
245 ax25_cb *s;
246 struct sk_buff *copy;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700248 spin_lock(&ax25_list_lock);
Sasha Levinb67bfe02013-02-27 17:06:00 -0800249 ax25_for_each(s, &ax25_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
251 s->sk->sk_type == SOCK_RAW &&
252 s->sk->sk_protocol == proto &&
253 s->ax25_dev->dev == skb->dev &&
254 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
255 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
256 continue;
257 if (sock_queue_rcv_skb(s->sk, copy) != 0)
258 kfree_skb(copy);
259 }
260 }
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700261 spin_unlock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262}
263
264/*
265 * Deferred destroy.
266 */
267void ax25_destroy_socket(ax25_cb *);
268
269/*
270 * Handler for deferred kills.
271 */
272static void ax25_destroy_timer(unsigned long data)
273{
274 ax25_cb *ax25=(ax25_cb *)data;
275 struct sock *sk;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900276
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 sk=ax25->sk;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900278
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 bh_lock_sock(sk);
280 sock_hold(sk);
281 ax25_destroy_socket(ax25);
282 bh_unlock_sock(sk);
283 sock_put(sk);
284}
285
286/*
287 * This is called from user mode and the timers. Thus it protects itself
288 * against interrupt users but doesn't worry about being called during
289 * work. Once it is removed from the queue no interrupt or bottom half
290 * will touch it and we are (fairly 8-) ) safe.
291 */
292void ax25_destroy_socket(ax25_cb *ax25)
293{
294 struct sk_buff *skb;
295
296 ax25_cb_del(ax25);
297
298 ax25_stop_heartbeat(ax25);
299 ax25_stop_t1timer(ax25);
300 ax25_stop_t2timer(ax25);
301 ax25_stop_t3timer(ax25);
302 ax25_stop_idletimer(ax25);
303
304 ax25_clear_queues(ax25); /* Flush the queues */
305
306 if (ax25->sk != NULL) {
307 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
308 if (skb->sk != ax25->sk) {
309 /* A pending connection */
310 ax25_cb *sax25 = ax25_sk(skb->sk);
311
312 /* Queue the unaccepted socket for death */
313 sock_orphan(skb->sk);
314
David S. Miller33d1d2c2008-10-06 12:53:50 -0700315 /* 9A4GL: hack to release unaccepted sockets */
316 skb->sk->sk_state = TCP_LISTEN;
317
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 ax25_start_heartbeat(sax25);
319 sax25->state = AX25_STATE_0;
320 }
321
322 kfree_skb(skb);
323 }
324 skb_queue_purge(&ax25->sk->sk_write_queue);
325 }
326
327 if (ax25->sk != NULL) {
Eric Dumazetc5640392009-06-16 10:12:03 +0000328 if (sk_has_allocations(ax25->sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 /* Defer: outstanding buffers */
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800330 setup_timer(&ax25->dtimer, ax25_destroy_timer,
331 (unsigned long)ax25);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 ax25->dtimer.expires = jiffies + 2 * HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 add_timer(&ax25->dtimer);
334 } else {
335 struct sock *sk=ax25->sk;
336 ax25->sk=NULL;
337 sock_put(sk);
338 }
339 } else {
340 ax25_cb_put(ax25);
341 }
342}
343
344/*
345 * dl1bke 960311: set parameters for existing AX.25 connections,
346 * includes a KILL command to abort any connection.
347 * VERY useful for debugging ;-)
348 */
349static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
350{
351 struct ax25_ctl_struct ax25_ctl;
352 ax25_digi digi;
353 ax25_dev *ax25_dev;
354 ax25_cb *ax25;
355 unsigned int k;
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000356 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
358 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
359 return -EFAULT;
360
361 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
362 return -ENODEV;
363
364 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
365 return -EINVAL;
366
roel kluin43ab8502009-10-14 05:26:30 +0000367 if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
368 return -EINVAL;
369
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 digi.ndigi = ax25_ctl.digi_count;
371 for (k = 0; k < digi.ndigi; k++)
372 digi.calls[k] = ax25_ctl.digi_addr[k];
373
374 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
375 return -ENOTCONN;
376
377 switch (ax25_ctl.cmd) {
378 case AX25_KILL:
379 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
380#ifdef CONFIG_AX25_DAMA_SLAVE
381 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
382 ax25_dama_off(ax25);
383#endif
384 ax25_disconnect(ax25, ENETRESET);
385 break;
386
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900387 case AX25_WINDOW:
388 if (ax25->modulus == AX25_MODULUS) {
389 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000390 goto einval_put;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900391 } else {
392 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000393 goto einval_put;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900394 }
395 ax25->window = ax25_ctl.arg;
396 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900398 case AX25_T1:
Ralf Baechlebe639ac2011-11-24 06:12:59 +0000399 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000400 goto einval_put;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900401 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
402 ax25->t1 = ax25_ctl.arg * HZ;
403 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900405 case AX25_T2:
Ralf Baechlebe639ac2011-11-24 06:12:59 +0000406 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000407 goto einval_put;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900408 ax25->t2 = ax25_ctl.arg * HZ;
409 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900411 case AX25_N2:
412 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000413 goto einval_put;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900414 ax25->n2count = 0;
415 ax25->n2 = ax25_ctl.arg;
416 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900418 case AX25_T3:
Ralf Baechlebe639ac2011-11-24 06:12:59 +0000419 if (ax25_ctl.arg > ULONG_MAX / HZ)
420 goto einval_put;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900421 ax25->t3 = ax25_ctl.arg * HZ;
422 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900424 case AX25_IDLE:
Ralf Baechlebe639ac2011-11-24 06:12:59 +0000425 if (ax25_ctl.arg > ULONG_MAX / (60 * HZ))
426 goto einval_put;
427
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900428 ax25->idle = ax25_ctl.arg * 60 * HZ;
429 break;
430
431 case AX25_PACLEN:
432 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000433 goto einval_put;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900434 ax25->paclen = ax25_ctl.arg;
435 break;
436
437 default:
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000438 goto einval_put;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 }
440
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000441out_put:
442 ax25_cb_put(ax25);
443 return ret;
444
445einval_put:
446 ret = -EINVAL;
447 goto out_put;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448}
449
Ralf Baechlee1fdb5b2006-05-03 23:27:16 -0700450static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
451{
452 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
453 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
454 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
455 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
456 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
457 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
458 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
459 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
460
461 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
462 ax25->modulus = AX25_EMODULUS;
463 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
464 } else {
465 ax25->modulus = AX25_MODULUS;
466 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
467 }
468}
469
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470/*
471 * Fill in a created AX.25 created control block with the default
472 * values for a particular device.
473 */
474void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
475{
476 ax25->ax25_dev = ax25_dev;
477
478 if (ax25->ax25_dev != NULL) {
Ralf Baechlee1fdb5b2006-05-03 23:27:16 -0700479 ax25_fillin_cb_from_dev(ax25, ax25_dev);
480 return;
481 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
Ralf Baechlee1fdb5b2006-05-03 23:27:16 -0700483 /*
484 * No device, use kernel / AX.25 spec default values
485 */
486 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
487 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
488 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
489 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
490 ax25->n2 = AX25_DEF_N2;
491 ax25->paclen = AX25_DEF_PACLEN;
492 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
493 ax25->backoff = AX25_DEF_BACKOFF;
494
495 if (AX25_DEF_AXDEFMODE) {
496 ax25->modulus = AX25_EMODULUS;
497 ax25->window = AX25_DEF_EWINDOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 } else {
Ralf Baechlee1fdb5b2006-05-03 23:27:16 -0700499 ax25->modulus = AX25_MODULUS;
500 ax25->window = AX25_DEF_WINDOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 }
502}
503
504/*
505 * Create an empty AX.25 control block.
506 */
507ax25_cb *ax25_create_cb(void)
508{
509 ax25_cb *ax25;
510
Ralf Baechle1b30dd32006-07-09 12:14:22 -0700511 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 return NULL;
513
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 atomic_set(&ax25->refcount, 1);
515
516 skb_queue_head_init(&ax25->write_queue);
517 skb_queue_head_init(&ax25->frag_queue);
518 skb_queue_head_init(&ax25->ack_queue);
519 skb_queue_head_init(&ax25->reseq_queue);
520
Jarek Poplawski21fab4a2008-02-11 21:36:39 -0800521 ax25_setup_timers(ax25);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522
523 ax25_fillin_cb(ax25, NULL);
524
525 ax25->state = AX25_STATE_0;
526
527 return ax25;
528}
529
530/*
531 * Handling for system calls applied via the various interfaces to an
532 * AX25 socket object
533 */
534
535static int ax25_setsockopt(struct socket *sock, int level, int optname,
David S. Millerb7058842009-09-30 16:12:20 -0700536 char __user *optval, unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537{
538 struct sock *sk = sock->sk;
539 ax25_cb *ax25;
540 struct net_device *dev;
541 char devname[IFNAMSIZ];
Xi Wangba1cffe2011-12-27 09:43:19 +0000542 unsigned long opt;
543 int res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
545 if (level != SOL_AX25)
546 return -ENOPROTOOPT;
547
Xi Wangba1cffe2011-12-27 09:43:19 +0000548 if (optlen < sizeof(unsigned int))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 return -EINVAL;
550
Xi Wangba1cffe2011-12-27 09:43:19 +0000551 if (get_user(opt, (unsigned int __user *)optval))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 return -EFAULT;
553
554 lock_sock(sk);
555 ax25 = ax25_sk(sk);
556
557 switch (optname) {
558 case AX25_WINDOW:
559 if (ax25->modulus == AX25_MODULUS) {
560 if (opt < 1 || opt > 7) {
561 res = -EINVAL;
562 break;
563 }
564 } else {
565 if (opt < 1 || opt > 63) {
566 res = -EINVAL;
567 break;
568 }
569 }
570 ax25->window = opt;
571 break;
572
573 case AX25_T1:
Ralf Baechlebe639ac2011-11-24 06:12:59 +0000574 if (opt < 1 || opt > ULONG_MAX / HZ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 res = -EINVAL;
576 break;
577 }
Eric Dumazetf16f3022008-01-13 22:29:41 -0800578 ax25->rtt = (opt * HZ) >> 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 ax25->t1 = opt * HZ;
580 break;
581
582 case AX25_T2:
Ralf Baechlebe639ac2011-11-24 06:12:59 +0000583 if (opt < 1 || opt > ULONG_MAX / HZ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 res = -EINVAL;
585 break;
586 }
587 ax25->t2 = opt * HZ;
588 break;
589
590 case AX25_N2:
591 if (opt < 1 || opt > 31) {
592 res = -EINVAL;
593 break;
594 }
595 ax25->n2 = opt;
596 break;
597
598 case AX25_T3:
Ralf Baechlebe639ac2011-11-24 06:12:59 +0000599 if (opt < 1 || opt > ULONG_MAX / HZ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 res = -EINVAL;
601 break;
602 }
603 ax25->t3 = opt * HZ;
604 break;
605
606 case AX25_IDLE:
Xi Wangba1cffe2011-12-27 09:43:19 +0000607 if (opt > ULONG_MAX / (60 * HZ)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 res = -EINVAL;
609 break;
610 }
611 ax25->idle = opt * 60 * HZ;
612 break;
613
614 case AX25_BACKOFF:
Xi Wangba1cffe2011-12-27 09:43:19 +0000615 if (opt > 2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 res = -EINVAL;
617 break;
618 }
619 ax25->backoff = opt;
620 break;
621
622 case AX25_EXTSEQ:
623 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
624 break;
625
626 case AX25_PIDINCL:
627 ax25->pidincl = opt ? 1 : 0;
628 break;
629
630 case AX25_IAMDIGI:
631 ax25->iamdigi = opt ? 1 : 0;
632 break;
633
634 case AX25_PACLEN:
635 if (opt < 16 || opt > 65535) {
636 res = -EINVAL;
637 break;
638 }
639 ax25->paclen = opt;
640 break;
641
642 case SO_BINDTODEVICE:
643 if (optlen > IFNAMSIZ)
Ralf Baechle2f722912009-09-28 12:26:28 -0700644 optlen = IFNAMSIZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
Ralf Baechle2f722912009-09-28 12:26:28 -0700646 if (copy_from_user(devname, optval, optlen)) {
647 res = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 break;
649 }
650
651 if (sk->sk_type == SOCK_SEQPACKET &&
652 (sock->state != SS_UNCONNECTED ||
653 sk->sk_state == TCP_LISTEN)) {
654 res = -EADDRNOTAVAIL;
Ralf Baechle2f722912009-09-28 12:26:28 -0700655 break;
656 }
657
658 dev = dev_get_by_name(&init_net, devname);
659 if (!dev) {
660 res = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 break;
662 }
663
664 ax25->ax25_dev = ax25_dev_ax25dev(dev);
665 ax25_fillin_cb(ax25, ax25->ax25_dev);
Ralf Baechle2f722912009-09-28 12:26:28 -0700666 dev_put(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 break;
668
669 default:
670 res = -ENOPROTOOPT;
671 }
672 release_sock(sk);
673
674 return res;
675}
676
677static int ax25_getsockopt(struct socket *sock, int level, int optname,
678 char __user *optval, int __user *optlen)
679{
680 struct sock *sk = sock->sk;
681 ax25_cb *ax25;
682 struct ax25_dev *ax25_dev;
683 char devname[IFNAMSIZ];
684 void *valptr;
685 int val = 0;
686 int maxlen, length;
687
688 if (level != SOL_AX25)
689 return -ENOPROTOOPT;
690
691 if (get_user(maxlen, optlen))
692 return -EFAULT;
693
694 if (maxlen < 1)
695 return -EFAULT;
696
697 valptr = (void *) &val;
698 length = min_t(unsigned int, maxlen, sizeof(int));
699
700 lock_sock(sk);
701 ax25 = ax25_sk(sk);
702
703 switch (optname) {
704 case AX25_WINDOW:
705 val = ax25->window;
706 break;
707
708 case AX25_T1:
709 val = ax25->t1 / HZ;
710 break;
711
712 case AX25_T2:
713 val = ax25->t2 / HZ;
714 break;
715
716 case AX25_N2:
717 val = ax25->n2;
718 break;
719
720 case AX25_T3:
721 val = ax25->t3 / HZ;
722 break;
723
724 case AX25_IDLE:
725 val = ax25->idle / (60 * HZ);
726 break;
727
728 case AX25_BACKOFF:
729 val = ax25->backoff;
730 break;
731
732 case AX25_EXTSEQ:
733 val = (ax25->modulus == AX25_EMODULUS);
734 break;
735
736 case AX25_PIDINCL:
737 val = ax25->pidincl;
738 break;
739
740 case AX25_IAMDIGI:
741 val = ax25->iamdigi;
742 break;
743
744 case AX25_PACLEN:
745 val = ax25->paclen;
746 break;
747
748 case SO_BINDTODEVICE:
749 ax25_dev = ax25->ax25_dev;
750
751 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
752 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
753 length = strlen(devname) + 1;
754 } else {
755 *devname = '\0';
756 length = 1;
757 }
758
759 valptr = (void *) devname;
760 break;
761
762 default:
763 release_sock(sk);
764 return -ENOPROTOOPT;
765 }
766 release_sock(sk);
767
768 if (put_user(length, optlen))
769 return -EFAULT;
770
771 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
772}
773
774static int ax25_listen(struct socket *sock, int backlog)
775{
776 struct sock *sk = sock->sk;
777 int res = 0;
778
779 lock_sock(sk);
780 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
781 sk->sk_max_ack_backlog = backlog;
782 sk->sk_state = TCP_LISTEN;
783 goto out;
784 }
785 res = -EOPNOTSUPP;
786
787out:
788 release_sock(sk);
789
790 return res;
791}
792
793/*
794 * XXX: when creating ax25_sock we should update the .obj_size setting
795 * below.
796 */
797static struct proto ax25_proto = {
798 .name = "AX25",
799 .owner = THIS_MODULE,
800 .obj_size = sizeof(struct sock),
801};
802
Eric Paris3f378b62009-11-05 22:18:14 -0800803static int ax25_create(struct net *net, struct socket *sock, int protocol,
804 int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805{
806 struct sock *sk;
807 ax25_cb *ax25;
808
Octavian Purdila09ad9bc2009-11-25 15:14:13 -0800809 if (!net_eq(net, &init_net))
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700810 return -EAFNOSUPPORT;
811
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 switch (sock->type) {
813 case SOCK_DGRAM:
814 if (protocol == 0 || protocol == PF_AX25)
815 protocol = AX25_P_TEXT;
816 break;
817
818 case SOCK_SEQPACKET:
819 switch (protocol) {
820 case 0:
821 case PF_AX25: /* For CLX */
822 protocol = AX25_P_TEXT;
823 break;
824 case AX25_P_SEGMENT:
825#ifdef CONFIG_INET
826 case AX25_P_ARP:
827 case AX25_P_IP:
828#endif
829#ifdef CONFIG_NETROM
830 case AX25_P_NETROM:
831#endif
832#ifdef CONFIG_ROSE
833 case AX25_P_ROSE:
834#endif
835 return -ESOCKTNOSUPPORT;
836#ifdef CONFIG_NETROM_MODULE
837 case AX25_P_NETROM:
838 if (ax25_protocol_is_registered(AX25_P_NETROM))
839 return -ESOCKTNOSUPPORT;
Alan Coxef764a12012-07-13 06:33:08 +0000840 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841#endif
842#ifdef CONFIG_ROSE_MODULE
843 case AX25_P_ROSE:
844 if (ax25_protocol_is_registered(AX25_P_ROSE))
845 return -ESOCKTNOSUPPORT;
846#endif
847 default:
848 break;
849 }
850 break;
851
852 case SOCK_RAW:
853 break;
854 default:
855 return -ESOCKTNOSUPPORT;
856 }
857
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700858 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
859 if (sk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 return -ENOMEM;
861
862 ax25 = sk->sk_protinfo = ax25_create_cb();
863 if (!ax25) {
864 sk_free(sk);
865 return -ENOMEM;
866 }
867
868 sock_init_data(sock, sk);
869
870 sk->sk_destruct = ax25_free_sock;
871 sock->ops = &ax25_proto_ops;
872 sk->sk_protocol = protocol;
873
874 ax25->sk = sk;
875
876 return 0;
877}
878
879struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
880{
881 struct sock *sk;
882 ax25_cb *ax25, *oax25;
883
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900884 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot);
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700885 if (sk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 return NULL;
887
888 if ((ax25 = ax25_create_cb()) == NULL) {
889 sk_free(sk);
890 return NULL;
891 }
892
893 switch (osk->sk_type) {
894 case SOCK_DGRAM:
895 break;
896 case SOCK_SEQPACKET:
897 break;
898 default:
899 sk_free(sk);
900 ax25_cb_put(ax25);
901 return NULL;
902 }
903
904 sock_init_data(NULL, sk);
905
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 sk->sk_type = osk->sk_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 sk->sk_priority = osk->sk_priority;
908 sk->sk_protocol = osk->sk_protocol;
909 sk->sk_rcvbuf = osk->sk_rcvbuf;
910 sk->sk_sndbuf = osk->sk_sndbuf;
911 sk->sk_state = TCP_ESTABLISHED;
Ralf Baechle53b924b2005-08-23 10:11:30 -0700912 sock_copy_flags(sk, osk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
914 oax25 = ax25_sk(osk);
915
916 ax25->modulus = oax25->modulus;
917 ax25->backoff = oax25->backoff;
918 ax25->pidincl = oax25->pidincl;
919 ax25->iamdigi = oax25->iamdigi;
920 ax25->rtt = oax25->rtt;
921 ax25->t1 = oax25->t1;
922 ax25->t2 = oax25->t2;
923 ax25->t3 = oax25->t3;
924 ax25->n2 = oax25->n2;
925 ax25->idle = oax25->idle;
926 ax25->paclen = oax25->paclen;
927 ax25->window = oax25->window;
928
929 ax25->ax25_dev = ax25_dev;
930 ax25->source_addr = oax25->source_addr;
931
932 if (oax25->digipeat != NULL) {
Arnaldo Carvalho de Melo0459d70a2006-11-17 12:43:07 -0200933 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
934 GFP_ATOMIC);
935 if (ax25->digipeat == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 sk_free(sk);
937 ax25_cb_put(ax25);
938 return NULL;
939 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 }
941
942 sk->sk_protinfo = ax25;
Jarek Poplawski8c185ab2009-09-27 10:57:02 +0000943 sk->sk_destruct = ax25_free_sock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 ax25->sk = sk;
945
946 return sk;
947}
948
949static int ax25_release(struct socket *sock)
950{
951 struct sock *sk = sock->sk;
952 ax25_cb *ax25;
953
954 if (sk == NULL)
955 return 0;
956
957 sock_hold(sk);
958 sock_orphan(sk);
959 lock_sock(sk);
960 ax25 = ax25_sk(sk);
961
962 if (sk->sk_type == SOCK_SEQPACKET) {
963 switch (ax25->state) {
964 case AX25_STATE_0:
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_1:
972 case AX25_STATE_2:
973 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
974 release_sock(sk);
975 ax25_disconnect(ax25, 0);
976 lock_sock(sk);
977 ax25_destroy_socket(ax25);
978 break;
979
980 case AX25_STATE_3:
981 case AX25_STATE_4:
982 ax25_clear_queues(ax25);
983 ax25->n2count = 0;
984
985 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
986 case AX25_PROTO_STD_SIMPLEX:
987 case AX25_PROTO_STD_DUPLEX:
988 ax25_send_control(ax25,
989 AX25_DISC,
990 AX25_POLLON,
991 AX25_COMMAND);
992 ax25_stop_t2timer(ax25);
993 ax25_stop_t3timer(ax25);
994 ax25_stop_idletimer(ax25);
995 break;
996#ifdef CONFIG_AX25_DAMA_SLAVE
997 case AX25_PROTO_DAMA_SLAVE:
998 ax25_stop_t3timer(ax25);
999 ax25_stop_idletimer(ax25);
1000 break;
1001#endif
1002 }
1003 ax25_calculate_t1(ax25);
1004 ax25_start_t1timer(ax25);
1005 ax25->state = AX25_STATE_2;
1006 sk->sk_state = TCP_CLOSE;
1007 sk->sk_shutdown |= SEND_SHUTDOWN;
1008 sk->sk_state_change(sk);
1009 sock_set_flag(sk, SOCK_DESTROY);
1010 break;
1011
1012 default:
1013 break;
1014 }
1015 } else {
1016 sk->sk_state = TCP_CLOSE;
1017 sk->sk_shutdown |= SEND_SHUTDOWN;
1018 sk->sk_state_change(sk);
1019 ax25_destroy_socket(ax25);
1020 }
1021
1022 sock->sk = NULL;
1023 release_sock(sk);
1024 sock_put(sk);
1025
1026 return 0;
1027}
1028
1029/*
1030 * We support a funny extension here so you can (as root) give any callsign
1031 * digipeated via a local address as source. This hack is obsolete now
1032 * that we've implemented support for SO_BINDTODEVICE. It is however small
1033 * and trivially backward compatible.
1034 */
1035static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1036{
1037 struct sock *sk = sock->sk;
1038 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1039 ax25_dev *ax25_dev = NULL;
Ralf Baechle01d7dd02005-08-23 10:11:45 -07001040 ax25_uid_assoc *user;
1041 ax25_address call;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 ax25_cb *ax25;
1043 int err = 0;
1044
1045 if (addr_len != sizeof(struct sockaddr_ax25) &&
maximilian attems1987e7b2008-01-28 20:44:11 -08001046 addr_len != sizeof(struct full_sockaddr_ax25))
1047 /* support for old structure may go away some time
1048 * ax25_bind(): uses old (6 digipeater) socket structure.
1049 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
maximilian attems1987e7b2008-01-28 20:44:11 -08001051 (addr_len > sizeof(struct full_sockaddr_ax25)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053
1054 if (addr->fsa_ax25.sax25_family != AF_AX25)
1055 return -EINVAL;
1056
David Howells73400402008-11-14 10:39:06 +11001057 user = ax25_findbyuid(current_euid());
Ralf Baechle01d7dd02005-08-23 10:11:45 -07001058 if (user) {
1059 call = user->call;
1060 ax25_uid_put(user);
1061 } else {
1062 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1063 return -EACCES;
1064
1065 call = addr->fsa_ax25.sax25_call;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 }
1067
1068 lock_sock(sk);
1069
1070 ax25 = ax25_sk(sk);
1071 if (!sock_flag(sk, SOCK_ZAPPED)) {
1072 err = -EINVAL;
1073 goto out;
1074 }
1075
Ralf Baechle01d7dd02005-08-23 10:11:45 -07001076 ax25->source_addr = call;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077
1078 /*
1079 * User already set interface with SO_BINDTODEVICE
1080 */
1081 if (ax25->ax25_dev != NULL)
1082 goto done;
1083
1084 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1085 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1086 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1087 err = -EADDRNOTAVAIL;
1088 goto out;
1089 }
1090 } else {
1091 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1092 err = -EADDRNOTAVAIL;
1093 goto out;
1094 }
1095 }
1096
1097 if (ax25_dev != NULL)
1098 ax25_fillin_cb(ax25, ax25_dev);
1099
1100done:
1101 ax25_cb_add(ax25);
1102 sock_reset_flag(sk, SOCK_ZAPPED);
1103
1104out:
1105 release_sock(sk);
1106
Julia Lawall49339cc2010-08-16 06:28:19 +00001107 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108}
1109
1110/*
1111 * FIXME: nonblock behaviour looks like it may have a bug.
1112 */
Ralf Baechlec9266b92006-12-14 15:49:28 -08001113static int __must_check ax25_connect(struct socket *sock,
1114 struct sockaddr *uaddr, int addr_len, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115{
1116 struct sock *sk = sock->sk;
1117 ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1118 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1119 ax25_digi *digi = NULL;
1120 int ct = 0, err = 0;
1121
1122 /*
1123 * some sanity checks. code further down depends on this
1124 */
1125
maximilian attems27d1cba2008-01-10 03:57:29 -08001126 if (addr_len == sizeof(struct sockaddr_ax25))
1127 /* support for this will go away in early 2.5.x
1128 * ax25_connect(): uses obsolete socket structure
1129 */
1130 ;
1131 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1132 /* support for old structure may go away some time
1133 * ax25_connect(): uses old (6 digipeater) socket structure.
1134 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
maximilian attems27d1cba2008-01-10 03:57:29 -08001136 (addr_len > sizeof(struct full_sockaddr_ax25)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139
1140 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1141 return -EINVAL;
1142
1143 lock_sock(sk);
1144
1145 /* deal with restarts */
1146 if (sock->state == SS_CONNECTING) {
1147 switch (sk->sk_state) {
1148 case TCP_SYN_SENT: /* still trying */
1149 err = -EINPROGRESS;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001150 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
1152 case TCP_ESTABLISHED: /* connection established */
1153 sock->state = SS_CONNECTED;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001154 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155
1156 case TCP_CLOSE: /* connection refused */
1157 sock->state = SS_UNCONNECTED;
1158 err = -ECONNREFUSED;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001159 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 }
1161 }
1162
1163 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1164 err = -EISCONN; /* No reconnect on a seqpacket socket */
Ralf Baechle75606dc2007-04-20 16:06:45 -07001165 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 }
1167
1168 sk->sk_state = TCP_CLOSE;
1169 sock->state = SS_UNCONNECTED;
1170
Jesper Juhla51482b2005-11-08 09:41:34 -08001171 kfree(ax25->digipeat);
1172 ax25->digipeat = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173
1174 /*
1175 * Handle digi-peaters to be used.
1176 */
1177 if (addr_len > sizeof(struct sockaddr_ax25) &&
1178 fsa->fsa_ax25.sax25_ndigis != 0) {
1179 /* Valid number of digipeaters ? */
1180 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1181 err = -EINVAL;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001182 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 }
1184
1185 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1186 err = -ENOBUFS;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001187 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 }
1189
1190 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1191 digi->lastrepeat = -1;
1192
1193 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1194 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1195 AX25_HBIT) && ax25->iamdigi) {
1196 digi->repeated[ct] = 1;
1197 digi->lastrepeat = ct;
1198 } else {
1199 digi->repeated[ct] = 0;
1200 }
1201 digi->calls[ct] = fsa->fsa_digipeater[ct];
1202 ct++;
1203 }
1204 }
1205
1206 /*
1207 * Must bind first - autobinding in this may or may not work. If
1208 * the socket is already bound, check to see if the device has
1209 * been filled in, error if it hasn't.
1210 */
1211 if (sock_flag(sk, SOCK_ZAPPED)) {
1212 /* check if we can remove this feature. It is broken. */
1213 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1214 current->comm);
1215 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1216 kfree(digi);
Ralf Baechle75606dc2007-04-20 16:06:45 -07001217 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 }
1219
1220 ax25_fillin_cb(ax25, ax25->ax25_dev);
1221 ax25_cb_add(ax25);
1222 } else {
1223 if (ax25->ax25_dev == NULL) {
1224 kfree(digi);
1225 err = -EHOSTUNREACH;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001226 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 }
1228 }
1229
1230 if (sk->sk_type == SOCK_SEQPACKET &&
1231 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001232 ax25->ax25_dev->dev))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 kfree(digi);
1234 err = -EADDRINUSE; /* Already such a connection */
1235 ax25_cb_put(ax25t);
Ralf Baechle75606dc2007-04-20 16:06:45 -07001236 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 }
1238
1239 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1240 ax25->digipeat = digi;
1241
1242 /* First the easy one */
1243 if (sk->sk_type != SOCK_SEQPACKET) {
1244 sock->state = SS_CONNECTED;
1245 sk->sk_state = TCP_ESTABLISHED;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001246 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 }
1248
1249 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1250 sock->state = SS_CONNECTING;
1251 sk->sk_state = TCP_SYN_SENT;
1252
1253 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1254 case AX25_PROTO_STD_SIMPLEX:
1255 case AX25_PROTO_STD_DUPLEX:
1256 ax25_std_establish_data_link(ax25);
1257 break;
1258
1259#ifdef CONFIG_AX25_DAMA_SLAVE
1260 case AX25_PROTO_DAMA_SLAVE:
1261 ax25->modulus = AX25_MODULUS;
1262 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1263 if (ax25->ax25_dev->dama.slave)
1264 ax25_ds_establish_data_link(ax25);
1265 else
1266 ax25_std_establish_data_link(ax25);
1267 break;
1268#endif
1269 }
1270
1271 ax25->state = AX25_STATE_1;
1272
1273 ax25_start_heartbeat(ax25);
1274
1275 /* Now the loop */
1276 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1277 err = -EINPROGRESS;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001278 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 }
1280
1281 if (sk->sk_state == TCP_SYN_SENT) {
Ralf Baechle75606dc2007-04-20 16:06:45 -07001282 DEFINE_WAIT(wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 for (;;) {
Eric Dumazetaa395142010-04-20 13:03:51 +00001285 prepare_to_wait(sk_sleep(sk), &wait,
YOSHIFUJI Hideakibd3b0712007-07-19 10:43:13 +09001286 TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 if (sk->sk_state != TCP_SYN_SENT)
1288 break;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001289 if (!signal_pending(current)) {
1290 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 schedule();
1292 lock_sock(sk);
1293 continue;
1294 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001295 err = -ERESTARTSYS;
1296 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 }
Eric Dumazetaa395142010-04-20 13:03:51 +00001298 finish_wait(sk_sleep(sk), &wait);
Ralf Baechle75606dc2007-04-20 16:06:45 -07001299
1300 if (err)
1301 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 }
1303
1304 if (sk->sk_state != TCP_ESTABLISHED) {
1305 /* Not in ABM, not in WAIT_UA -> failed */
1306 sock->state = SS_UNCONNECTED;
1307 err = sock_error(sk); /* Always set at this point */
Ralf Baechle75606dc2007-04-20 16:06:45 -07001308 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 }
1310
1311 sock->state = SS_CONNECTED;
1312
Ralf Baechle75606dc2007-04-20 16:06:45 -07001313 err = 0;
1314out_release:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 release_sock(sk);
1316
1317 return err;
1318}
1319
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1321{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 struct sk_buff *skb;
1323 struct sock *newsk;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001324 DEFINE_WAIT(wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 struct sock *sk;
1326 int err = 0;
1327
1328 if (sock->state != SS_UNCONNECTED)
1329 return -EINVAL;
1330
1331 if ((sk = sock->sk) == NULL)
1332 return -EINVAL;
1333
1334 lock_sock(sk);
1335 if (sk->sk_type != SOCK_SEQPACKET) {
1336 err = -EOPNOTSUPP;
1337 goto out;
1338 }
1339
1340 if (sk->sk_state != TCP_LISTEN) {
1341 err = -EINVAL;
1342 goto out;
1343 }
1344
1345 /*
1346 * The read queue this time is holding sockets ready to use
1347 * hooked into the SABM we saved
1348 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 for (;;) {
Eric Dumazetaa395142010-04-20 13:03:51 +00001350 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 skb = skb_dequeue(&sk->sk_receive_queue);
1352 if (skb)
1353 break;
1354
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 if (flags & O_NONBLOCK) {
Ralf Baechle75606dc2007-04-20 16:06:45 -07001356 err = -EWOULDBLOCK;
1357 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001359 if (!signal_pending(current)) {
1360 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 schedule();
1362 lock_sock(sk);
1363 continue;
1364 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001365 err = -ERESTARTSYS;
1366 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 }
Eric Dumazetaa395142010-04-20 13:03:51 +00001368 finish_wait(sk_sleep(sk), &wait);
Ralf Baechle75606dc2007-04-20 16:06:45 -07001369
1370 if (err)
1371 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372
1373 newsk = skb->sk;
David S. Miller9375cb82008-06-17 02:20:54 -07001374 sock_graft(newsk, newsock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
1376 /* Now attach up the new socket */
1377 kfree_skb(skb);
1378 sk->sk_ack_backlog--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 newsock->state = SS_CONNECTED;
1380
1381out:
1382 release_sock(sk);
1383
1384 return err;
1385}
1386
1387static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1388 int *uaddr_len, int peer)
1389{
1390 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1391 struct sock *sk = sock->sk;
1392 unsigned char ndigi, i;
1393 ax25_cb *ax25;
1394 int err = 0;
1395
Kees Cook5b919f82011-01-12 00:34:49 -08001396 memset(fsa, 0, sizeof(*fsa));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 lock_sock(sk);
1398 ax25 = ax25_sk(sk);
1399
1400 if (peer != 0) {
1401 if (sk->sk_state != TCP_ESTABLISHED) {
1402 err = -ENOTCONN;
1403 goto out;
1404 }
1405
1406 fsa->fsa_ax25.sax25_family = AF_AX25;
1407 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408
1409 if (ax25->digipeat != NULL) {
1410 ndigi = ax25->digipeat->ndigi;
1411 fsa->fsa_ax25.sax25_ndigis = ndigi;
1412 for (i = 0; i < ndigi; i++)
1413 fsa->fsa_digipeater[i] =
1414 ax25->digipeat->calls[i];
1415 }
1416 } else {
1417 fsa->fsa_ax25.sax25_family = AF_AX25;
1418 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1419 fsa->fsa_ax25.sax25_ndigis = 1;
1420 if (ax25->ax25_dev != NULL) {
1421 memcpy(&fsa->fsa_digipeater[0],
1422 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1423 } else {
1424 fsa->fsa_digipeater[0] = null_ax25_address;
1425 }
1426 }
1427 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1428
1429out:
1430 release_sock(sk);
1431
1432 return err;
1433}
1434
1435static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1436 struct msghdr *msg, size_t len)
1437{
1438 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1439 struct sock *sk = sock->sk;
1440 struct sockaddr_ax25 sax;
1441 struct sk_buff *skb;
1442 ax25_digi dtmp, *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 ax25_cb *ax25;
1444 size_t size;
1445 int lv, err, addr_len = msg->msg_namelen;
1446
1447 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1448 return -EINVAL;
1449
1450 lock_sock(sk);
1451 ax25 = ax25_sk(sk);
1452
1453 if (sock_flag(sk, SOCK_ZAPPED)) {
1454 err = -EADDRNOTAVAIL;
1455 goto out;
1456 }
1457
1458 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1459 send_sig(SIGPIPE, current, 0);
1460 err = -EPIPE;
1461 goto out;
1462 }
1463
1464 if (ax25->ax25_dev == NULL) {
1465 err = -ENETUNREACH;
1466 goto out;
1467 }
1468
1469 if (len > ax25->ax25_dev->dev->mtu) {
1470 err = -EMSGSIZE;
1471 goto out;
1472 }
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001473
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 if (usax != NULL) {
1475 if (usax->sax25_family != AF_AX25) {
1476 err = -EINVAL;
1477 goto out;
1478 }
1479
maximilian attems27d1cba2008-01-10 03:57:29 -08001480 if (addr_len == sizeof(struct sockaddr_ax25))
1481 /* ax25_sendmsg(): uses obsolete socket structure */
1482 ;
1483 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1484 /* support for old structure may go away some time
1485 * ax25_sendmsg(): uses old (6 digipeater)
1486 * socket structure.
1487 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001489 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1490 err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 goto out;
1492 }
1493
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494
1495 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1496 int ct = 0;
1497 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1498
1499 /* Valid number of digipeaters ? */
1500 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1501 err = -EINVAL;
1502 goto out;
1503 }
1504
1505 dtmp.ndigi = usax->sax25_ndigis;
1506
1507 while (ct < usax->sax25_ndigis) {
1508 dtmp.repeated[ct] = 0;
1509 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1510 ct++;
1511 }
1512
1513 dtmp.lastrepeat = 0;
1514 }
1515
1516 sax = *usax;
1517 if (sk->sk_type == SOCK_SEQPACKET &&
1518 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1519 err = -EISCONN;
1520 goto out;
1521 }
1522 if (usax->sax25_ndigis == 0)
1523 dp = NULL;
1524 else
1525 dp = &dtmp;
1526 } else {
1527 /*
1528 * FIXME: 1003.1g - if the socket is like this because
1529 * it has become closed (not started closed) and is VC
1530 * we ought to SIGPIPE, EPIPE
1531 */
1532 if (sk->sk_state != TCP_ESTABLISHED) {
1533 err = -ENOTCONN;
1534 goto out;
1535 }
1536 sax.sax25_family = AF_AX25;
1537 sax.sax25_call = ax25->dest_addr;
1538 dp = ax25->digipeat;
1539 }
1540
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541 /* Build a packet */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 /* Assume the worst case */
1543 size = len + ax25->ax25_dev->dev->hard_header_len;
1544
1545 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1546 if (skb == NULL)
1547 goto out;
1548
1549 skb_reserve(skb, size - len);
1550
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 /* User data follows immediately after the AX.25 data */
1552 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1553 err = -EFAULT;
1554 kfree_skb(skb);
1555 goto out;
1556 }
1557
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001558 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559
1560 /* Add the PID if one is not supplied by the user in the skb */
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001561 if (!ax25->pidincl)
1562 *skb_push(skb, 1) = sk->sk_protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 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
Ralf Baechle8849b722011-04-14 00:20:07 -07001581 /* Building AX.25 Header */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582
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
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001587 skb_set_transport_header(skb, lv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001589 *skb_transport_header(skb) = AX25_UI;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590
1591 /* Datagram frames go straight out of the door as UI */
Arnaldo Carvalho de Melo29c4be52005-04-21 16:46:56 -07001592 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593
1594 err = len;
1595
1596out:
1597 release_sock(sk);
1598
1599 return err;
1600}
1601
1602static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1603 struct msghdr *msg, size_t size, int flags)
1604{
1605 struct sock *sk = sock->sk;
1606 struct sk_buff *skb;
1607 int copied;
1608 int err = 0;
1609
1610 lock_sock(sk);
1611 /*
1612 * This works for seqpacket too. The receiver has ordered the
1613 * queue for us! We do one quick check first though
1614 */
1615 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1616 err = -ENOTCONN;
1617 goto out;
1618 }
1619
1620 /* Now we can treat all alike */
1621 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001622 flags & MSG_DONTWAIT, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 if (skb == NULL)
1624 goto out;
1625
1626 if (!ax25_sk(sk)->pidincl)
1627 skb_pull(skb, 1); /* Remove PID */
1628
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001629 skb_reset_transport_header(skb);
1630 copied = skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631
1632 if (copied > size) {
1633 copied = size;
1634 msg->msg_flags |= MSG_TRUNC;
1635 }
1636
1637 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1638
1639 if (msg->msg_namelen != 0) {
1640 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1641 ax25_digi digi;
1642 ax25_address src;
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001643 const unsigned char *mac = skb_mac_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001645 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1646 &digi, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 sax->sax25_family = AF_AX25;
1648 /* We set this correctly, even though we may not let the
1649 application know the digi calls further down (because it
1650 did NOT ask to know them). This could get political... **/
1651 sax->sax25_ndigis = digi.ndigi;
1652 sax->sax25_call = src;
1653
1654 if (sax->sax25_ndigis != 0) {
1655 int ct;
1656 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1657
1658 for (ct = 0; ct < digi.ndigi; ct++)
1659 fsa->fsa_digipeater[ct] = digi.calls[ct];
1660 }
1661 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1662 }
1663
1664 skb_free_datagram(sk, skb);
1665 err = copied;
1666
1667out:
1668 release_sock(sk);
1669
1670 return err;
1671}
1672
1673static int ax25_shutdown(struct socket *sk, int how)
1674{
1675 /* FIXME - generate DM and RNR states */
1676 return -EOPNOTSUPP;
1677}
1678
1679static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1680{
1681 struct sock *sk = sock->sk;
1682 void __user *argp = (void __user *)arg;
1683 int res = 0;
1684
1685 lock_sock(sk);
1686 switch (cmd) {
1687 case TIOCOUTQ: {
1688 long amount;
Eric Dumazet31e6d362009-06-17 19:05:41 -07001689
1690 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 if (amount < 0)
1692 amount = 0;
1693 res = put_user(amount, (int __user *)argp);
1694 break;
1695 }
1696
1697 case TIOCINQ: {
1698 struct sk_buff *skb;
1699 long amount = 0L;
1700 /* These two are safe on a single CPU system as only user tasks fiddle here */
1701 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1702 amount = skb->len;
Ralf Baechle20b7d102005-09-12 14:24:55 -07001703 res = put_user(amount, (int __user *) argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 break;
1705 }
1706
1707 case SIOCGSTAMP:
Ralf Baechle9b37ee72005-09-12 14:23:52 -07001708 res = sock_get_timestamp(sk, argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 break;
1710
Eric Dumazetae40eb12007-03-18 17:33:16 -07001711 case SIOCGSTAMPNS:
1712 res = sock_get_timestampns(sk, argp);
1713 break;
1714
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1716 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1717 case SIOCAX25GETUID: {
1718 struct sockaddr_ax25 sax25;
1719 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1720 res = -EFAULT;
1721 break;
1722 }
1723 res = ax25_uid_ioctl(cmd, &sax25);
1724 break;
1725 }
1726
1727 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1728 long amount;
1729 if (!capable(CAP_NET_ADMIN)) {
1730 res = -EPERM;
1731 break;
1732 }
1733 if (get_user(amount, (long __user *)argp)) {
1734 res = -EFAULT;
1735 break;
1736 }
1737 if (amount > AX25_NOUID_BLOCK) {
1738 res = -EINVAL;
1739 break;
1740 }
1741 ax25_uid_policy = amount;
1742 res = 0;
1743 break;
1744 }
1745
1746 case SIOCADDRT:
1747 case SIOCDELRT:
1748 case SIOCAX25OPTRT:
1749 if (!capable(CAP_NET_ADMIN)) {
1750 res = -EPERM;
1751 break;
1752 }
1753 res = ax25_rt_ioctl(cmd, argp);
1754 break;
1755
1756 case SIOCAX25CTLCON:
1757 if (!capable(CAP_NET_ADMIN)) {
1758 res = -EPERM;
1759 break;
1760 }
1761 res = ax25_ctl_ioctl(cmd, argp);
1762 break;
1763
1764 case SIOCAX25GETINFO:
1765 case SIOCAX25GETINFOOLD: {
1766 ax25_cb *ax25 = ax25_sk(sk);
1767 struct ax25_info_struct ax25_info;
1768
1769 ax25_info.t1 = ax25->t1 / HZ;
1770 ax25_info.t2 = ax25->t2 / HZ;
1771 ax25_info.t3 = ax25->t3 / HZ;
1772 ax25_info.idle = ax25->idle / (60 * HZ);
1773 ax25_info.n2 = ax25->n2;
1774 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1775 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1776 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1777 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1778 ax25_info.n2count = ax25->n2count;
1779 ax25_info.state = ax25->state;
Eric Dumazet407fc5c2009-09-20 06:32:55 +00001780 ax25_info.rcv_q = sk_rmem_alloc_get(sk);
1781 ax25_info.snd_q = sk_wmem_alloc_get(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 ax25_info.vs = ax25->vs;
1783 ax25_info.vr = ax25->vr;
1784 ax25_info.va = ax25->va;
1785 ax25_info.vs_max = ax25->vs; /* reserved */
1786 ax25_info.paclen = ax25->paclen;
1787 ax25_info.window = ax25->window;
1788
1789 /* old structure? */
1790 if (cmd == SIOCAX25GETINFOOLD) {
1791 static int warned = 0;
1792 if (!warned) {
1793 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1794 current->comm);
1795 warned=1;
1796 }
1797
1798 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1799 res = -EFAULT;
1800 break;
1801 }
1802 } else {
1803 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1804 res = -EINVAL;
1805 break;
1806 }
1807 }
1808 res = 0;
1809 break;
1810 }
1811
1812 case SIOCAX25ADDFWD:
1813 case SIOCAX25DELFWD: {
1814 struct ax25_fwd_struct ax25_fwd;
1815 if (!capable(CAP_NET_ADMIN)) {
1816 res = -EPERM;
1817 break;
1818 }
1819 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1820 res = -EFAULT;
1821 break;
1822 }
1823 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1824 break;
1825 }
1826
1827 case SIOCGIFADDR:
1828 case SIOCSIFADDR:
1829 case SIOCGIFDSTADDR:
1830 case SIOCSIFDSTADDR:
1831 case SIOCGIFBRDADDR:
1832 case SIOCSIFBRDADDR:
1833 case SIOCGIFNETMASK:
1834 case SIOCSIFNETMASK:
1835 case SIOCGIFMETRIC:
1836 case SIOCSIFMETRIC:
1837 res = -EINVAL;
1838 break;
1839
1840 default:
Christoph Hellwigb5e5fa52006-01-03 14:18:33 -08001841 res = -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 break;
1843 }
1844 release_sock(sk);
1845
1846 return res;
1847}
1848
1849#ifdef CONFIG_PROC_FS
1850
1851static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
Eric Dumazetf16f3022008-01-13 22:29:41 -08001852 __acquires(ax25_list_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 spin_lock_bh(&ax25_list_lock);
Li Zefanb512f3d2010-02-08 23:19:59 +00001855 return seq_hlist_start(&ax25_list, *pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856}
1857
1858static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1859{
Li Zefanb512f3d2010-02-08 23:19:59 +00001860 return seq_hlist_next(v, &ax25_list, pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861}
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001862
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863static void ax25_info_stop(struct seq_file *seq, void *v)
Eric Dumazetf16f3022008-01-13 22:29:41 -08001864 __releases(ax25_list_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865{
1866 spin_unlock_bh(&ax25_list_lock);
1867}
1868
1869static int ax25_info_show(struct seq_file *seq, void *v)
1870{
Li Zefanb512f3d2010-02-08 23:19:59 +00001871 ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
Ralf Baechlef75268c2005-09-06 15:49:39 -07001872 char buf[11];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 int k;
1874
1875
1876 /*
1877 * New format:
1878 * 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
1879 */
1880
1881 seq_printf(seq, "%8.8lx %s %s%s ",
1882 (long) ax25,
1883 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
Ralf Baechlef75268c2005-09-06 15:49:39 -07001884 ax2asc(buf, &ax25->source_addr),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 ax25->iamdigi? "*":"");
Ralf Baechlef75268c2005-09-06 15:49:39 -07001886 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887
1888 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1889 seq_printf(seq, ",%s%s",
Ralf Baechlef75268c2005-09-06 15:49:39 -07001890 ax2asc(buf, &ax25->digipeat->calls[k]),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 ax25->digipeat->repeated[k]? "*":"");
1892 }
1893
1894 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1895 ax25->state,
1896 ax25->vs, ax25->vr, ax25->va,
1897 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1898 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1899 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1900 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1901 ax25->idle / (60 * HZ),
1902 ax25->n2count, ax25->n2,
1903 ax25->rtt / HZ,
1904 ax25->window,
1905 ax25->paclen);
1906
1907 if (ax25->sk != NULL) {
Jarek Poplawski1105b5d2008-02-11 21:24:56 -08001908 seq_printf(seq, " %d %d %lu\n",
Eric Dumazet31e6d362009-06-17 19:05:41 -07001909 sk_wmem_alloc_get(ax25->sk),
1910 sk_rmem_alloc_get(ax25->sk),
Jarek Poplawski1105b5d2008-02-11 21:24:56 -08001911 sock_i_ino(ax25->sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 } else {
1913 seq_puts(seq, " * * *\n");
1914 }
1915 return 0;
1916}
1917
Philippe De Muyter56b3d972007-07-10 23:07:31 -07001918static const struct seq_operations ax25_info_seqops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 .start = ax25_info_start,
1920 .next = ax25_info_next,
1921 .stop = ax25_info_stop,
1922 .show = ax25_info_show,
1923};
1924
1925static int ax25_info_open(struct inode *inode, struct file *file)
1926{
1927 return seq_open(file, &ax25_info_seqops);
1928}
1929
Arjan van de Ven9a321442007-02-12 00:55:35 -08001930static const struct file_operations ax25_info_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 .owner = THIS_MODULE,
1932 .open = ax25_info_open,
1933 .read = seq_read,
1934 .llseek = seq_lseek,
1935 .release = seq_release,
1936};
1937
1938#endif
1939
Stephen Hemmingerec1b4cf2009-10-05 05:58:39 +00001940static const struct net_proto_family ax25_family_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 .family = PF_AX25,
1942 .create = ax25_create,
1943 .owner = THIS_MODULE,
1944};
1945
Eric Dumazet90ddc4f2005-12-22 12:49:22 -08001946static const struct proto_ops ax25_proto_ops = {
Ralf Baechle46763562005-09-12 14:25:25 -07001947 .family = PF_AX25,
1948 .owner = THIS_MODULE,
1949 .release = ax25_release,
1950 .bind = ax25_bind,
1951 .connect = ax25_connect,
1952 .socketpair = sock_no_socketpair,
1953 .accept = ax25_accept,
1954 .getname = ax25_getname,
1955 .poll = datagram_poll,
1956 .ioctl = ax25_ioctl,
1957 .listen = ax25_listen,
1958 .shutdown = ax25_shutdown,
1959 .setsockopt = ax25_setsockopt,
1960 .getsockopt = ax25_getsockopt,
1961 .sendmsg = ax25_sendmsg,
1962 .recvmsg = ax25_recvmsg,
1963 .mmap = sock_no_mmap,
1964 .sendpage = sock_no_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965};
1966
1967/*
1968 * Called by socket.c on kernel start up
1969 */
Stephen Hemminger7546dd92009-03-09 08:18:29 +00001970static struct packet_type ax25_packet_type __read_mostly = {
Harvey Harrison09640e62009-02-01 00:45:17 -08001971 .type = cpu_to_be16(ETH_P_AX25),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972 .func = ax25_kiss_rcv,
1973};
1974
1975static struct notifier_block ax25_dev_notifier = {
1976 .notifier_call =ax25_device_event,
1977};
1978
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979static int __init ax25_init(void)
1980{
1981 int rc = proto_register(&ax25_proto, 0);
1982
1983 if (rc != 0)
1984 goto out;
1985
1986 sock_register(&ax25_family_ops);
1987 dev_add_pack(&ax25_packet_type);
1988 register_netdevice_notifier(&ax25_dev_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989
Gao fengd4beaa62013-02-18 01:34:54 +00001990 proc_create("ax25_route", S_IRUGO, init_net.proc_net,
1991 &ax25_route_fops);
1992 proc_create("ax25", S_IRUGO, init_net.proc_net, &ax25_info_fops);
1993 proc_create("ax25_calls", S_IRUGO, init_net.proc_net, &ax25_uid_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994out:
1995 return rc;
1996}
1997module_init(ax25_init);
1998
1999
2000MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2001MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2002MODULE_LICENSE("GPL");
2003MODULE_ALIAS_NETPROTO(PF_AX25);
2004
2005static void __exit ax25_exit(void)
2006{
Gao fengece31ff2013-02-18 01:34:56 +00002007 remove_proc_entry("ax25_route", init_net.proc_net);
2008 remove_proc_entry("ax25", init_net.proc_net);
2009 remove_proc_entry("ax25_calls", init_net.proc_net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 unregister_netdevice_notifier(&ax25_dev_notifier);
2012
2013 dev_remove_pack(&ax25_packet_type);
2014
2015 sock_unregister(PF_AX25);
2016 proto_unregister(&ax25_proto);
Eric W. Biederman3adadc02012-04-18 16:11:23 +00002017
2018 ax25_rt_free();
2019 ax25_uid_free();
2020 ax25_dev_free();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021}
2022module_exit(ax25_exit);