blob: 779095ded689918de025f48c47db880aa9b5d724 [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;
84 struct hlist_node *node;
85
86 if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
87 return;
88
89 spin_lock_bh(&ax25_list_lock);
Jarek Poplawskiecd2ebd2008-01-10 21:21:20 -080090again:
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 ax25_for_each(s, node, &ax25_list) {
92 if (s->ax25_dev == ax25_dev) {
93 s->ax25_dev = NULL;
Jarek Poplawskiecd2ebd2008-01-10 21:21:20 -080094 spin_unlock_bh(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 ax25_disconnect(s, ENETUNREACH);
Jarek Poplawskiecd2ebd2008-01-10 21:21:20 -080096 spin_lock_bh(&ax25_list_lock);
97
98 /* The entry could have been deleted from the
99 * list meanwhile and thus the next pointer is
100 * no longer valid. Play it safe and restart
101 * the scan. Forward progress is ensured
102 * because we set s->ax25_dev to NULL and we
103 * are never passed a NULL 'dev' argument.
104 */
105 goto again;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 }
107 }
108 spin_unlock_bh(&ax25_list_lock);
109}
110
111/*
112 * Handle device status changes.
113 */
114static int ax25_device_event(struct notifier_block *this, unsigned long event,
115 void *ptr)
116{
117 struct net_device *dev = (struct net_device *)ptr;
118
YOSHIFUJI Hideaki721499e2008-07-19 22:34:43 -0700119 if (!net_eq(dev_net(dev), &init_net))
Eric W. Biedermane9dc8652007-09-12 13:02:17 +0200120 return NOTIFY_DONE;
121
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 /* Reject non AX.25 devices */
123 if (dev->type != ARPHRD_AX25)
124 return NOTIFY_DONE;
125
126 switch (event) {
127 case NETDEV_UP:
128 ax25_dev_device_up(dev);
129 break;
130 case NETDEV_DOWN:
131 ax25_kill_by_device(dev);
132 ax25_rt_device_down(dev);
133 ax25_dev_device_down(dev);
134 break;
135 default:
136 break;
137 }
138
139 return NOTIFY_DONE;
140}
141
142/*
143 * Add a socket to the bound sockets list.
144 */
145void ax25_cb_add(ax25_cb *ax25)
146{
147 spin_lock_bh(&ax25_list_lock);
148 ax25_cb_hold(ax25);
149 hlist_add_head(&ax25->ax25_node, &ax25_list);
150 spin_unlock_bh(&ax25_list_lock);
151}
152
153/*
154 * Find a socket that wants to accept the SABM we have just
155 * received.
156 */
157struct sock *ax25_find_listener(ax25_address *addr, int digi,
158 struct net_device *dev, int type)
159{
160 ax25_cb *s;
161 struct hlist_node *node;
162
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700163 spin_lock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 ax25_for_each(s, node, &ax25_list) {
165 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
166 continue;
167 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
168 s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
169 /* If device is null we match any device */
170 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
171 sock_hold(s->sk);
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700172 spin_unlock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 return s->sk;
174 }
175 }
176 }
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700177 spin_unlock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
179 return NULL;
180}
181
182/*
183 * Find an AX.25 socket given both ends.
184 */
185struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
186 int type)
187{
188 struct sock *sk = NULL;
189 ax25_cb *s;
190 struct hlist_node *node;
191
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700192 spin_lock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 ax25_for_each(s, node, &ax25_list) {
194 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
195 !ax25cmp(&s->dest_addr, dest_addr) &&
196 s->sk->sk_type == type) {
197 sk = s->sk;
198 sock_hold(sk);
199 break;
200 }
201 }
202
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700203 spin_unlock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
205 return sk;
206}
207
208/*
209 * Find an AX.25 control block given both ends. It will only pick up
210 * floating AX.25 control blocks or non Raw socket bound control blocks.
211 */
212ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
213 ax25_digi *digi, struct net_device *dev)
214{
215 ax25_cb *s;
216 struct hlist_node *node;
217
218 spin_lock_bh(&ax25_list_lock);
219 ax25_for_each(s, node, &ax25_list) {
220 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
221 continue;
222 if (s->ax25_dev == NULL)
223 continue;
224 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
225 if (digi != NULL && digi->ndigi != 0) {
226 if (s->digipeat == NULL)
227 continue;
228 if (ax25digicmp(s->digipeat, digi) != 0)
229 continue;
230 } else {
231 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
232 continue;
233 }
234 ax25_cb_hold(s);
235 spin_unlock_bh(&ax25_list_lock);
236
237 return s;
238 }
239 }
240 spin_unlock_bh(&ax25_list_lock);
241
242 return NULL;
243}
244
Ralf Baechle70868ea2006-05-03 23:25:17 -0700245EXPORT_SYMBOL(ax25_find_cb);
246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
248{
249 ax25_cb *s;
250 struct sk_buff *copy;
251 struct hlist_node *node;
252
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700253 spin_lock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 ax25_for_each(s, node, &ax25_list) {
255 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
256 s->sk->sk_type == SOCK_RAW &&
257 s->sk->sk_protocol == proto &&
258 s->ax25_dev->dev == skb->dev &&
259 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
260 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
261 continue;
262 if (sock_queue_rcv_skb(s->sk, copy) != 0)
263 kfree_skb(copy);
264 }
265 }
Ralf Baechlec19c4b92006-07-12 13:25:23 -0700266 spin_unlock(&ax25_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267}
268
269/*
270 * Deferred destroy.
271 */
272void ax25_destroy_socket(ax25_cb *);
273
274/*
275 * Handler for deferred kills.
276 */
277static void ax25_destroy_timer(unsigned long data)
278{
279 ax25_cb *ax25=(ax25_cb *)data;
280 struct sock *sk;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900281
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 sk=ax25->sk;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900283
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 bh_lock_sock(sk);
285 sock_hold(sk);
286 ax25_destroy_socket(ax25);
287 bh_unlock_sock(sk);
288 sock_put(sk);
289}
290
291/*
292 * This is called from user mode and the timers. Thus it protects itself
293 * against interrupt users but doesn't worry about being called during
294 * work. Once it is removed from the queue no interrupt or bottom half
295 * will touch it and we are (fairly 8-) ) safe.
296 */
297void ax25_destroy_socket(ax25_cb *ax25)
298{
299 struct sk_buff *skb;
300
301 ax25_cb_del(ax25);
302
303 ax25_stop_heartbeat(ax25);
304 ax25_stop_t1timer(ax25);
305 ax25_stop_t2timer(ax25);
306 ax25_stop_t3timer(ax25);
307 ax25_stop_idletimer(ax25);
308
309 ax25_clear_queues(ax25); /* Flush the queues */
310
311 if (ax25->sk != NULL) {
312 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
313 if (skb->sk != ax25->sk) {
314 /* A pending connection */
315 ax25_cb *sax25 = ax25_sk(skb->sk);
316
317 /* Queue the unaccepted socket for death */
318 sock_orphan(skb->sk);
319
David S. Miller33d1d2c2008-10-06 12:53:50 -0700320 /* 9A4GL: hack to release unaccepted sockets */
321 skb->sk->sk_state = TCP_LISTEN;
322
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 ax25_start_heartbeat(sax25);
324 sax25->state = AX25_STATE_0;
325 }
326
327 kfree_skb(skb);
328 }
329 skb_queue_purge(&ax25->sk->sk_write_queue);
330 }
331
332 if (ax25->sk != NULL) {
Eric Dumazetc5640392009-06-16 10:12:03 +0000333 if (sk_has_allocations(ax25->sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 /* Defer: outstanding buffers */
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800335 setup_timer(&ax25->dtimer, ax25_destroy_timer,
336 (unsigned long)ax25);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 ax25->dtimer.expires = jiffies + 2 * HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 add_timer(&ax25->dtimer);
339 } else {
340 struct sock *sk=ax25->sk;
341 ax25->sk=NULL;
342 sock_put(sk);
343 }
344 } else {
345 ax25_cb_put(ax25);
346 }
347}
348
349/*
350 * dl1bke 960311: set parameters for existing AX.25 connections,
351 * includes a KILL command to abort any connection.
352 * VERY useful for debugging ;-)
353 */
354static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
355{
356 struct ax25_ctl_struct ax25_ctl;
357 ax25_digi digi;
358 ax25_dev *ax25_dev;
359 ax25_cb *ax25;
360 unsigned int k;
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000361 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362
363 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
364 return -EFAULT;
365
366 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
367 return -ENODEV;
368
369 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
370 return -EINVAL;
371
roel kluin43ab8502009-10-14 05:26:30 +0000372 if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
373 return -EINVAL;
374
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 digi.ndigi = ax25_ctl.digi_count;
376 for (k = 0; k < digi.ndigi; k++)
377 digi.calls[k] = ax25_ctl.digi_addr[k];
378
379 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
380 return -ENOTCONN;
381
382 switch (ax25_ctl.cmd) {
383 case AX25_KILL:
384 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
385#ifdef CONFIG_AX25_DAMA_SLAVE
386 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
387 ax25_dama_off(ax25);
388#endif
389 ax25_disconnect(ax25, ENETRESET);
390 break;
391
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900392 case AX25_WINDOW:
393 if (ax25->modulus == AX25_MODULUS) {
394 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000395 goto einval_put;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900396 } else {
397 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000398 goto einval_put;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900399 }
400 ax25->window = ax25_ctl.arg;
401 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900403 case AX25_T1:
Ralf Baechlebe639ac2011-11-24 06:12:59 +0000404 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000405 goto einval_put;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900406 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
407 ax25->t1 = ax25_ctl.arg * HZ;
408 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900410 case AX25_T2:
Ralf Baechlebe639ac2011-11-24 06:12:59 +0000411 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000412 goto einval_put;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900413 ax25->t2 = ax25_ctl.arg * HZ;
414 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900416 case AX25_N2:
417 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000418 goto einval_put;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900419 ax25->n2count = 0;
420 ax25->n2 = ax25_ctl.arg;
421 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900423 case AX25_T3:
Ralf Baechlebe639ac2011-11-24 06:12:59 +0000424 if (ax25_ctl.arg > ULONG_MAX / HZ)
425 goto einval_put;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900426 ax25->t3 = ax25_ctl.arg * HZ;
427 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900429 case AX25_IDLE:
Ralf Baechlebe639ac2011-11-24 06:12:59 +0000430 if (ax25_ctl.arg > ULONG_MAX / (60 * HZ))
431 goto einval_put;
432
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900433 ax25->idle = ax25_ctl.arg * 60 * HZ;
434 break;
435
436 case AX25_PACLEN:
437 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000438 goto einval_put;
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +0900439 ax25->paclen = ax25_ctl.arg;
440 break;
441
442 default:
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000443 goto einval_put;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 }
445
Jarek Poplawskic0181d42009-09-25 03:10:38 +0000446out_put:
447 ax25_cb_put(ax25);
448 return ret;
449
450einval_put:
451 ret = -EINVAL;
452 goto out_put;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453}
454
Ralf Baechlee1fdb5b2006-05-03 23:27:16 -0700455static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
456{
457 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
458 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
459 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
460 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
461 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
462 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
463 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
464 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
465
466 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
467 ax25->modulus = AX25_EMODULUS;
468 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
469 } else {
470 ax25->modulus = AX25_MODULUS;
471 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
472 }
473}
474
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475/*
476 * Fill in a created AX.25 created control block with the default
477 * values for a particular device.
478 */
479void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
480{
481 ax25->ax25_dev = ax25_dev;
482
483 if (ax25->ax25_dev != NULL) {
Ralf Baechlee1fdb5b2006-05-03 23:27:16 -0700484 ax25_fillin_cb_from_dev(ax25, ax25_dev);
485 return;
486 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
Ralf Baechlee1fdb5b2006-05-03 23:27:16 -0700488 /*
489 * No device, use kernel / AX.25 spec default values
490 */
491 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
492 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
493 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
494 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
495 ax25->n2 = AX25_DEF_N2;
496 ax25->paclen = AX25_DEF_PACLEN;
497 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
498 ax25->backoff = AX25_DEF_BACKOFF;
499
500 if (AX25_DEF_AXDEFMODE) {
501 ax25->modulus = AX25_EMODULUS;
502 ax25->window = AX25_DEF_EWINDOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 } else {
Ralf Baechlee1fdb5b2006-05-03 23:27:16 -0700504 ax25->modulus = AX25_MODULUS;
505 ax25->window = AX25_DEF_WINDOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 }
507}
508
509/*
510 * Create an empty AX.25 control block.
511 */
512ax25_cb *ax25_create_cb(void)
513{
514 ax25_cb *ax25;
515
Ralf Baechle1b30dd32006-07-09 12:14:22 -0700516 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 return NULL;
518
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 atomic_set(&ax25->refcount, 1);
520
521 skb_queue_head_init(&ax25->write_queue);
522 skb_queue_head_init(&ax25->frag_queue);
523 skb_queue_head_init(&ax25->ack_queue);
524 skb_queue_head_init(&ax25->reseq_queue);
525
Jarek Poplawski21fab4a2008-02-11 21:36:39 -0800526 ax25_setup_timers(ax25);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527
528 ax25_fillin_cb(ax25, NULL);
529
530 ax25->state = AX25_STATE_0;
531
532 return ax25;
533}
534
535/*
536 * Handling for system calls applied via the various interfaces to an
537 * AX25 socket object
538 */
539
540static int ax25_setsockopt(struct socket *sock, int level, int optname,
David S. Millerb7058842009-09-30 16:12:20 -0700541 char __user *optval, unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542{
543 struct sock *sk = sock->sk;
544 ax25_cb *ax25;
545 struct net_device *dev;
546 char devname[IFNAMSIZ];
Xi Wangba1cffe2011-12-27 09:43:19 +0000547 unsigned long opt;
548 int res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
550 if (level != SOL_AX25)
551 return -ENOPROTOOPT;
552
Xi Wangba1cffe2011-12-27 09:43:19 +0000553 if (optlen < sizeof(unsigned int))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 return -EINVAL;
555
Xi Wangba1cffe2011-12-27 09:43:19 +0000556 if (get_user(opt, (unsigned int __user *)optval))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 return -EFAULT;
558
559 lock_sock(sk);
560 ax25 = ax25_sk(sk);
561
562 switch (optname) {
563 case AX25_WINDOW:
564 if (ax25->modulus == AX25_MODULUS) {
565 if (opt < 1 || opt > 7) {
566 res = -EINVAL;
567 break;
568 }
569 } else {
570 if (opt < 1 || opt > 63) {
571 res = -EINVAL;
572 break;
573 }
574 }
575 ax25->window = opt;
576 break;
577
578 case AX25_T1:
Ralf Baechlebe639ac2011-11-24 06:12:59 +0000579 if (opt < 1 || opt > ULONG_MAX / HZ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 res = -EINVAL;
581 break;
582 }
Eric Dumazetf16f3022008-01-13 22:29:41 -0800583 ax25->rtt = (opt * HZ) >> 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 ax25->t1 = opt * HZ;
585 break;
586
587 case AX25_T2:
Ralf Baechlebe639ac2011-11-24 06:12:59 +0000588 if (opt < 1 || opt > ULONG_MAX / HZ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 res = -EINVAL;
590 break;
591 }
592 ax25->t2 = opt * HZ;
593 break;
594
595 case AX25_N2:
596 if (opt < 1 || opt > 31) {
597 res = -EINVAL;
598 break;
599 }
600 ax25->n2 = opt;
601 break;
602
603 case AX25_T3:
Ralf Baechlebe639ac2011-11-24 06:12:59 +0000604 if (opt < 1 || opt > ULONG_MAX / HZ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 res = -EINVAL;
606 break;
607 }
608 ax25->t3 = opt * HZ;
609 break;
610
611 case AX25_IDLE:
Xi Wangba1cffe2011-12-27 09:43:19 +0000612 if (opt > ULONG_MAX / (60 * HZ)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 res = -EINVAL;
614 break;
615 }
616 ax25->idle = opt * 60 * HZ;
617 break;
618
619 case AX25_BACKOFF:
Xi Wangba1cffe2011-12-27 09:43:19 +0000620 if (opt > 2) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 res = -EINVAL;
622 break;
623 }
624 ax25->backoff = opt;
625 break;
626
627 case AX25_EXTSEQ:
628 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
629 break;
630
631 case AX25_PIDINCL:
632 ax25->pidincl = opt ? 1 : 0;
633 break;
634
635 case AX25_IAMDIGI:
636 ax25->iamdigi = opt ? 1 : 0;
637 break;
638
639 case AX25_PACLEN:
640 if (opt < 16 || opt > 65535) {
641 res = -EINVAL;
642 break;
643 }
644 ax25->paclen = opt;
645 break;
646
647 case SO_BINDTODEVICE:
648 if (optlen > IFNAMSIZ)
Ralf Baechle2f722912009-09-28 12:26:28 -0700649 optlen = IFNAMSIZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
Ralf Baechle2f722912009-09-28 12:26:28 -0700651 if (copy_from_user(devname, optval, optlen)) {
652 res = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 break;
654 }
655
656 if (sk->sk_type == SOCK_SEQPACKET &&
657 (sock->state != SS_UNCONNECTED ||
658 sk->sk_state == TCP_LISTEN)) {
659 res = -EADDRNOTAVAIL;
Ralf Baechle2f722912009-09-28 12:26:28 -0700660 break;
661 }
662
663 dev = dev_get_by_name(&init_net, devname);
664 if (!dev) {
665 res = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 break;
667 }
668
669 ax25->ax25_dev = ax25_dev_ax25dev(dev);
670 ax25_fillin_cb(ax25, ax25->ax25_dev);
Ralf Baechle2f722912009-09-28 12:26:28 -0700671 dev_put(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 break;
673
674 default:
675 res = -ENOPROTOOPT;
676 }
677 release_sock(sk);
678
679 return res;
680}
681
682static int ax25_getsockopt(struct socket *sock, int level, int optname,
683 char __user *optval, int __user *optlen)
684{
685 struct sock *sk = sock->sk;
686 ax25_cb *ax25;
687 struct ax25_dev *ax25_dev;
688 char devname[IFNAMSIZ];
689 void *valptr;
690 int val = 0;
691 int maxlen, length;
692
693 if (level != SOL_AX25)
694 return -ENOPROTOOPT;
695
696 if (get_user(maxlen, optlen))
697 return -EFAULT;
698
699 if (maxlen < 1)
700 return -EFAULT;
701
702 valptr = (void *) &val;
703 length = min_t(unsigned int, maxlen, sizeof(int));
704
705 lock_sock(sk);
706 ax25 = ax25_sk(sk);
707
708 switch (optname) {
709 case AX25_WINDOW:
710 val = ax25->window;
711 break;
712
713 case AX25_T1:
714 val = ax25->t1 / HZ;
715 break;
716
717 case AX25_T2:
718 val = ax25->t2 / HZ;
719 break;
720
721 case AX25_N2:
722 val = ax25->n2;
723 break;
724
725 case AX25_T3:
726 val = ax25->t3 / HZ;
727 break;
728
729 case AX25_IDLE:
730 val = ax25->idle / (60 * HZ);
731 break;
732
733 case AX25_BACKOFF:
734 val = ax25->backoff;
735 break;
736
737 case AX25_EXTSEQ:
738 val = (ax25->modulus == AX25_EMODULUS);
739 break;
740
741 case AX25_PIDINCL:
742 val = ax25->pidincl;
743 break;
744
745 case AX25_IAMDIGI:
746 val = ax25->iamdigi;
747 break;
748
749 case AX25_PACLEN:
750 val = ax25->paclen;
751 break;
752
753 case SO_BINDTODEVICE:
754 ax25_dev = ax25->ax25_dev;
755
756 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
757 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
758 length = strlen(devname) + 1;
759 } else {
760 *devname = '\0';
761 length = 1;
762 }
763
764 valptr = (void *) devname;
765 break;
766
767 default:
768 release_sock(sk);
769 return -ENOPROTOOPT;
770 }
771 release_sock(sk);
772
773 if (put_user(length, optlen))
774 return -EFAULT;
775
776 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
777}
778
779static int ax25_listen(struct socket *sock, int backlog)
780{
781 struct sock *sk = sock->sk;
782 int res = 0;
783
784 lock_sock(sk);
785 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
786 sk->sk_max_ack_backlog = backlog;
787 sk->sk_state = TCP_LISTEN;
788 goto out;
789 }
790 res = -EOPNOTSUPP;
791
792out:
793 release_sock(sk);
794
795 return res;
796}
797
798/*
799 * XXX: when creating ax25_sock we should update the .obj_size setting
800 * below.
801 */
802static struct proto ax25_proto = {
803 .name = "AX25",
804 .owner = THIS_MODULE,
805 .obj_size = sizeof(struct sock),
806};
807
Eric Paris3f378b62009-11-05 22:18:14 -0800808static int ax25_create(struct net *net, struct socket *sock, int protocol,
809 int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810{
811 struct sock *sk;
812 ax25_cb *ax25;
813
Octavian Purdila09ad9bc2009-11-25 15:14:13 -0800814 if (!net_eq(net, &init_net))
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700815 return -EAFNOSUPPORT;
816
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 switch (sock->type) {
818 case SOCK_DGRAM:
819 if (protocol == 0 || protocol == PF_AX25)
820 protocol = AX25_P_TEXT;
821 break;
822
823 case SOCK_SEQPACKET:
824 switch (protocol) {
825 case 0:
826 case PF_AX25: /* For CLX */
827 protocol = AX25_P_TEXT;
828 break;
829 case AX25_P_SEGMENT:
830#ifdef CONFIG_INET
831 case AX25_P_ARP:
832 case AX25_P_IP:
833#endif
834#ifdef CONFIG_NETROM
835 case AX25_P_NETROM:
836#endif
837#ifdef CONFIG_ROSE
838 case AX25_P_ROSE:
839#endif
840 return -ESOCKTNOSUPPORT;
841#ifdef CONFIG_NETROM_MODULE
842 case AX25_P_NETROM:
843 if (ax25_protocol_is_registered(AX25_P_NETROM))
844 return -ESOCKTNOSUPPORT;
Alan Coxef764a12012-07-13 06:33:08 +0000845 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846#endif
847#ifdef CONFIG_ROSE_MODULE
848 case AX25_P_ROSE:
849 if (ax25_protocol_is_registered(AX25_P_ROSE))
850 return -ESOCKTNOSUPPORT;
851#endif
852 default:
853 break;
854 }
855 break;
856
857 case SOCK_RAW:
858 break;
859 default:
860 return -ESOCKTNOSUPPORT;
861 }
862
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700863 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
864 if (sk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 return -ENOMEM;
866
867 ax25 = sk->sk_protinfo = ax25_create_cb();
868 if (!ax25) {
869 sk_free(sk);
870 return -ENOMEM;
871 }
872
873 sock_init_data(sock, sk);
874
875 sk->sk_destruct = ax25_free_sock;
876 sock->ops = &ax25_proto_ops;
877 sk->sk_protocol = protocol;
878
879 ax25->sk = sk;
880
881 return 0;
882}
883
884struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
885{
886 struct sock *sk;
887 ax25_cb *ax25, *oax25;
888
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900889 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot);
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700890 if (sk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 return NULL;
892
893 if ((ax25 = ax25_create_cb()) == NULL) {
894 sk_free(sk);
895 return NULL;
896 }
897
898 switch (osk->sk_type) {
899 case SOCK_DGRAM:
900 break;
901 case SOCK_SEQPACKET:
902 break;
903 default:
904 sk_free(sk);
905 ax25_cb_put(ax25);
906 return NULL;
907 }
908
909 sock_init_data(NULL, sk);
910
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 sk->sk_type = osk->sk_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 sk->sk_priority = osk->sk_priority;
913 sk->sk_protocol = osk->sk_protocol;
914 sk->sk_rcvbuf = osk->sk_rcvbuf;
915 sk->sk_sndbuf = osk->sk_sndbuf;
916 sk->sk_state = TCP_ESTABLISHED;
Ralf Baechle53b924b2005-08-23 10:11:30 -0700917 sock_copy_flags(sk, osk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918
919 oax25 = ax25_sk(osk);
920
921 ax25->modulus = oax25->modulus;
922 ax25->backoff = oax25->backoff;
923 ax25->pidincl = oax25->pidincl;
924 ax25->iamdigi = oax25->iamdigi;
925 ax25->rtt = oax25->rtt;
926 ax25->t1 = oax25->t1;
927 ax25->t2 = oax25->t2;
928 ax25->t3 = oax25->t3;
929 ax25->n2 = oax25->n2;
930 ax25->idle = oax25->idle;
931 ax25->paclen = oax25->paclen;
932 ax25->window = oax25->window;
933
934 ax25->ax25_dev = ax25_dev;
935 ax25->source_addr = oax25->source_addr;
936
937 if (oax25->digipeat != NULL) {
Arnaldo Carvalho de Melo0459d70a2006-11-17 12:43:07 -0200938 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
939 GFP_ATOMIC);
940 if (ax25->digipeat == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 sk_free(sk);
942 ax25_cb_put(ax25);
943 return NULL;
944 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 }
946
947 sk->sk_protinfo = ax25;
Jarek Poplawski8c185ab2009-09-27 10:57:02 +0000948 sk->sk_destruct = ax25_free_sock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 ax25->sk = sk;
950
951 return sk;
952}
953
954static int ax25_release(struct socket *sock)
955{
956 struct sock *sk = sock->sk;
957 ax25_cb *ax25;
958
959 if (sk == NULL)
960 return 0;
961
962 sock_hold(sk);
963 sock_orphan(sk);
964 lock_sock(sk);
965 ax25 = ax25_sk(sk);
966
967 if (sk->sk_type == SOCK_SEQPACKET) {
968 switch (ax25->state) {
969 case AX25_STATE_0:
970 release_sock(sk);
971 ax25_disconnect(ax25, 0);
972 lock_sock(sk);
973 ax25_destroy_socket(ax25);
974 break;
975
976 case AX25_STATE_1:
977 case AX25_STATE_2:
978 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
979 release_sock(sk);
980 ax25_disconnect(ax25, 0);
981 lock_sock(sk);
982 ax25_destroy_socket(ax25);
983 break;
984
985 case AX25_STATE_3:
986 case AX25_STATE_4:
987 ax25_clear_queues(ax25);
988 ax25->n2count = 0;
989
990 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
991 case AX25_PROTO_STD_SIMPLEX:
992 case AX25_PROTO_STD_DUPLEX:
993 ax25_send_control(ax25,
994 AX25_DISC,
995 AX25_POLLON,
996 AX25_COMMAND);
997 ax25_stop_t2timer(ax25);
998 ax25_stop_t3timer(ax25);
999 ax25_stop_idletimer(ax25);
1000 break;
1001#ifdef CONFIG_AX25_DAMA_SLAVE
1002 case AX25_PROTO_DAMA_SLAVE:
1003 ax25_stop_t3timer(ax25);
1004 ax25_stop_idletimer(ax25);
1005 break;
1006#endif
1007 }
1008 ax25_calculate_t1(ax25);
1009 ax25_start_t1timer(ax25);
1010 ax25->state = AX25_STATE_2;
1011 sk->sk_state = TCP_CLOSE;
1012 sk->sk_shutdown |= SEND_SHUTDOWN;
1013 sk->sk_state_change(sk);
1014 sock_set_flag(sk, SOCK_DESTROY);
1015 break;
1016
1017 default:
1018 break;
1019 }
1020 } else {
1021 sk->sk_state = TCP_CLOSE;
1022 sk->sk_shutdown |= SEND_SHUTDOWN;
1023 sk->sk_state_change(sk);
1024 ax25_destroy_socket(ax25);
1025 }
1026
1027 sock->sk = NULL;
1028 release_sock(sk);
1029 sock_put(sk);
1030
1031 return 0;
1032}
1033
1034/*
1035 * We support a funny extension here so you can (as root) give any callsign
1036 * digipeated via a local address as source. This hack is obsolete now
1037 * that we've implemented support for SO_BINDTODEVICE. It is however small
1038 * and trivially backward compatible.
1039 */
1040static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1041{
1042 struct sock *sk = sock->sk;
1043 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1044 ax25_dev *ax25_dev = NULL;
Ralf Baechle01d7dd02005-08-23 10:11:45 -07001045 ax25_uid_assoc *user;
1046 ax25_address call;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 ax25_cb *ax25;
1048 int err = 0;
1049
1050 if (addr_len != sizeof(struct sockaddr_ax25) &&
maximilian attems1987e7b2008-01-28 20:44:11 -08001051 addr_len != sizeof(struct full_sockaddr_ax25))
1052 /* support for old structure may go away some time
1053 * ax25_bind(): uses old (6 digipeater) socket structure.
1054 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
maximilian attems1987e7b2008-01-28 20:44:11 -08001056 (addr_len > sizeof(struct full_sockaddr_ax25)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058
1059 if (addr->fsa_ax25.sax25_family != AF_AX25)
1060 return -EINVAL;
1061
David Howells73400402008-11-14 10:39:06 +11001062 user = ax25_findbyuid(current_euid());
Ralf Baechle01d7dd02005-08-23 10:11:45 -07001063 if (user) {
1064 call = user->call;
1065 ax25_uid_put(user);
1066 } else {
1067 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1068 return -EACCES;
1069
1070 call = addr->fsa_ax25.sax25_call;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 }
1072
1073 lock_sock(sk);
1074
1075 ax25 = ax25_sk(sk);
1076 if (!sock_flag(sk, SOCK_ZAPPED)) {
1077 err = -EINVAL;
1078 goto out;
1079 }
1080
Ralf Baechle01d7dd02005-08-23 10:11:45 -07001081 ax25->source_addr = call;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082
1083 /*
1084 * User already set interface with SO_BINDTODEVICE
1085 */
1086 if (ax25->ax25_dev != NULL)
1087 goto done;
1088
1089 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1090 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1091 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1092 err = -EADDRNOTAVAIL;
1093 goto out;
1094 }
1095 } else {
1096 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1097 err = -EADDRNOTAVAIL;
1098 goto out;
1099 }
1100 }
1101
1102 if (ax25_dev != NULL)
1103 ax25_fillin_cb(ax25, ax25_dev);
1104
1105done:
1106 ax25_cb_add(ax25);
1107 sock_reset_flag(sk, SOCK_ZAPPED);
1108
1109out:
1110 release_sock(sk);
1111
Julia Lawall49339cc2010-08-16 06:28:19 +00001112 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113}
1114
1115/*
1116 * FIXME: nonblock behaviour looks like it may have a bug.
1117 */
Ralf Baechlec9266b92006-12-14 15:49:28 -08001118static int __must_check ax25_connect(struct socket *sock,
1119 struct sockaddr *uaddr, int addr_len, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120{
1121 struct sock *sk = sock->sk;
1122 ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1123 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1124 ax25_digi *digi = NULL;
1125 int ct = 0, err = 0;
1126
1127 /*
1128 * some sanity checks. code further down depends on this
1129 */
1130
maximilian attems27d1cba2008-01-10 03:57:29 -08001131 if (addr_len == sizeof(struct sockaddr_ax25))
1132 /* support for this will go away in early 2.5.x
1133 * ax25_connect(): uses obsolete socket structure
1134 */
1135 ;
1136 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1137 /* support for old structure may go away some time
1138 * ax25_connect(): uses old (6 digipeater) socket structure.
1139 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
maximilian attems27d1cba2008-01-10 03:57:29 -08001141 (addr_len > sizeof(struct full_sockaddr_ax25)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144
1145 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1146 return -EINVAL;
1147
1148 lock_sock(sk);
1149
1150 /* deal with restarts */
1151 if (sock->state == SS_CONNECTING) {
1152 switch (sk->sk_state) {
1153 case TCP_SYN_SENT: /* still trying */
1154 err = -EINPROGRESS;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001155 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156
1157 case TCP_ESTABLISHED: /* connection established */
1158 sock->state = SS_CONNECTED;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001159 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160
1161 case TCP_CLOSE: /* connection refused */
1162 sock->state = SS_UNCONNECTED;
1163 err = -ECONNREFUSED;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001164 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 }
1166 }
1167
1168 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1169 err = -EISCONN; /* No reconnect on a seqpacket socket */
Ralf Baechle75606dc2007-04-20 16:06:45 -07001170 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 }
1172
1173 sk->sk_state = TCP_CLOSE;
1174 sock->state = SS_UNCONNECTED;
1175
Jesper Juhla51482b2005-11-08 09:41:34 -08001176 kfree(ax25->digipeat);
1177 ax25->digipeat = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178
1179 /*
1180 * Handle digi-peaters to be used.
1181 */
1182 if (addr_len > sizeof(struct sockaddr_ax25) &&
1183 fsa->fsa_ax25.sax25_ndigis != 0) {
1184 /* Valid number of digipeaters ? */
1185 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1186 err = -EINVAL;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001187 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 }
1189
1190 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1191 err = -ENOBUFS;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001192 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 }
1194
1195 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1196 digi->lastrepeat = -1;
1197
1198 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1199 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1200 AX25_HBIT) && ax25->iamdigi) {
1201 digi->repeated[ct] = 1;
1202 digi->lastrepeat = ct;
1203 } else {
1204 digi->repeated[ct] = 0;
1205 }
1206 digi->calls[ct] = fsa->fsa_digipeater[ct];
1207 ct++;
1208 }
1209 }
1210
1211 /*
1212 * Must bind first - autobinding in this may or may not work. If
1213 * the socket is already bound, check to see if the device has
1214 * been filled in, error if it hasn't.
1215 */
1216 if (sock_flag(sk, SOCK_ZAPPED)) {
1217 /* check if we can remove this feature. It is broken. */
1218 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1219 current->comm);
1220 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1221 kfree(digi);
Ralf Baechle75606dc2007-04-20 16:06:45 -07001222 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 }
1224
1225 ax25_fillin_cb(ax25, ax25->ax25_dev);
1226 ax25_cb_add(ax25);
1227 } else {
1228 if (ax25->ax25_dev == NULL) {
1229 kfree(digi);
1230 err = -EHOSTUNREACH;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001231 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 }
1233 }
1234
1235 if (sk->sk_type == SOCK_SEQPACKET &&
1236 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001237 ax25->ax25_dev->dev))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 kfree(digi);
1239 err = -EADDRINUSE; /* Already such a connection */
1240 ax25_cb_put(ax25t);
Ralf Baechle75606dc2007-04-20 16:06:45 -07001241 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 }
1243
1244 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1245 ax25->digipeat = digi;
1246
1247 /* First the easy one */
1248 if (sk->sk_type != SOCK_SEQPACKET) {
1249 sock->state = SS_CONNECTED;
1250 sk->sk_state = TCP_ESTABLISHED;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001251 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 }
1253
1254 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1255 sock->state = SS_CONNECTING;
1256 sk->sk_state = TCP_SYN_SENT;
1257
1258 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1259 case AX25_PROTO_STD_SIMPLEX:
1260 case AX25_PROTO_STD_DUPLEX:
1261 ax25_std_establish_data_link(ax25);
1262 break;
1263
1264#ifdef CONFIG_AX25_DAMA_SLAVE
1265 case AX25_PROTO_DAMA_SLAVE:
1266 ax25->modulus = AX25_MODULUS;
1267 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1268 if (ax25->ax25_dev->dama.slave)
1269 ax25_ds_establish_data_link(ax25);
1270 else
1271 ax25_std_establish_data_link(ax25);
1272 break;
1273#endif
1274 }
1275
1276 ax25->state = AX25_STATE_1;
1277
1278 ax25_start_heartbeat(ax25);
1279
1280 /* Now the loop */
1281 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1282 err = -EINPROGRESS;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001283 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 }
1285
1286 if (sk->sk_state == TCP_SYN_SENT) {
Ralf Baechle75606dc2007-04-20 16:06:45 -07001287 DEFINE_WAIT(wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 for (;;) {
Eric Dumazetaa395142010-04-20 13:03:51 +00001290 prepare_to_wait(sk_sleep(sk), &wait,
YOSHIFUJI Hideakibd3b0712007-07-19 10:43:13 +09001291 TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 if (sk->sk_state != TCP_SYN_SENT)
1293 break;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001294 if (!signal_pending(current)) {
1295 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 schedule();
1297 lock_sock(sk);
1298 continue;
1299 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001300 err = -ERESTARTSYS;
1301 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 }
Eric Dumazetaa395142010-04-20 13:03:51 +00001303 finish_wait(sk_sleep(sk), &wait);
Ralf Baechle75606dc2007-04-20 16:06:45 -07001304
1305 if (err)
1306 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 }
1308
1309 if (sk->sk_state != TCP_ESTABLISHED) {
1310 /* Not in ABM, not in WAIT_UA -> failed */
1311 sock->state = SS_UNCONNECTED;
1312 err = sock_error(sk); /* Always set at this point */
Ralf Baechle75606dc2007-04-20 16:06:45 -07001313 goto out_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 }
1315
1316 sock->state = SS_CONNECTED;
1317
Ralf Baechle75606dc2007-04-20 16:06:45 -07001318 err = 0;
1319out_release:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 release_sock(sk);
1321
1322 return err;
1323}
1324
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1326{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 struct sk_buff *skb;
1328 struct sock *newsk;
Ralf Baechle75606dc2007-04-20 16:06:45 -07001329 DEFINE_WAIT(wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 struct sock *sk;
1331 int err = 0;
1332
1333 if (sock->state != SS_UNCONNECTED)
1334 return -EINVAL;
1335
1336 if ((sk = sock->sk) == NULL)
1337 return -EINVAL;
1338
1339 lock_sock(sk);
1340 if (sk->sk_type != SOCK_SEQPACKET) {
1341 err = -EOPNOTSUPP;
1342 goto out;
1343 }
1344
1345 if (sk->sk_state != TCP_LISTEN) {
1346 err = -EINVAL;
1347 goto out;
1348 }
1349
1350 /*
1351 * The read queue this time is holding sockets ready to use
1352 * hooked into the SABM we saved
1353 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 for (;;) {
Eric Dumazetaa395142010-04-20 13:03:51 +00001355 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 skb = skb_dequeue(&sk->sk_receive_queue);
1357 if (skb)
1358 break;
1359
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 if (flags & O_NONBLOCK) {
Ralf Baechle75606dc2007-04-20 16:06:45 -07001361 err = -EWOULDBLOCK;
1362 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001364 if (!signal_pending(current)) {
1365 release_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 schedule();
1367 lock_sock(sk);
1368 continue;
1369 }
Ralf Baechle75606dc2007-04-20 16:06:45 -07001370 err = -ERESTARTSYS;
1371 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 }
Eric Dumazetaa395142010-04-20 13:03:51 +00001373 finish_wait(sk_sleep(sk), &wait);
Ralf Baechle75606dc2007-04-20 16:06:45 -07001374
1375 if (err)
1376 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377
1378 newsk = skb->sk;
David S. Miller9375cb82008-06-17 02:20:54 -07001379 sock_graft(newsk, newsock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380
1381 /* Now attach up the new socket */
1382 kfree_skb(skb);
1383 sk->sk_ack_backlog--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 newsock->state = SS_CONNECTED;
1385
1386out:
1387 release_sock(sk);
1388
1389 return err;
1390}
1391
1392static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1393 int *uaddr_len, int peer)
1394{
1395 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1396 struct sock *sk = sock->sk;
1397 unsigned char ndigi, i;
1398 ax25_cb *ax25;
1399 int err = 0;
1400
Kees Cook5b919f82011-01-12 00:34:49 -08001401 memset(fsa, 0, sizeof(*fsa));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 lock_sock(sk);
1403 ax25 = ax25_sk(sk);
1404
1405 if (peer != 0) {
1406 if (sk->sk_state != TCP_ESTABLISHED) {
1407 err = -ENOTCONN;
1408 goto out;
1409 }
1410
1411 fsa->fsa_ax25.sax25_family = AF_AX25;
1412 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413
1414 if (ax25->digipeat != NULL) {
1415 ndigi = ax25->digipeat->ndigi;
1416 fsa->fsa_ax25.sax25_ndigis = ndigi;
1417 for (i = 0; i < ndigi; i++)
1418 fsa->fsa_digipeater[i] =
1419 ax25->digipeat->calls[i];
1420 }
1421 } else {
1422 fsa->fsa_ax25.sax25_family = AF_AX25;
1423 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1424 fsa->fsa_ax25.sax25_ndigis = 1;
1425 if (ax25->ax25_dev != NULL) {
1426 memcpy(&fsa->fsa_digipeater[0],
1427 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1428 } else {
1429 fsa->fsa_digipeater[0] = null_ax25_address;
1430 }
1431 }
1432 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1433
1434out:
1435 release_sock(sk);
1436
1437 return err;
1438}
1439
1440static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1441 struct msghdr *msg, size_t len)
1442{
1443 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1444 struct sock *sk = sock->sk;
1445 struct sockaddr_ax25 sax;
1446 struct sk_buff *skb;
1447 ax25_digi dtmp, *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 ax25_cb *ax25;
1449 size_t size;
1450 int lv, err, addr_len = msg->msg_namelen;
1451
1452 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1453 return -EINVAL;
1454
1455 lock_sock(sk);
1456 ax25 = ax25_sk(sk);
1457
1458 if (sock_flag(sk, SOCK_ZAPPED)) {
1459 err = -EADDRNOTAVAIL;
1460 goto out;
1461 }
1462
1463 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1464 send_sig(SIGPIPE, current, 0);
1465 err = -EPIPE;
1466 goto out;
1467 }
1468
1469 if (ax25->ax25_dev == NULL) {
1470 err = -ENETUNREACH;
1471 goto out;
1472 }
1473
1474 if (len > ax25->ax25_dev->dev->mtu) {
1475 err = -EMSGSIZE;
1476 goto out;
1477 }
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001478
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 if (usax != NULL) {
1480 if (usax->sax25_family != AF_AX25) {
1481 err = -EINVAL;
1482 goto out;
1483 }
1484
maximilian attems27d1cba2008-01-10 03:57:29 -08001485 if (addr_len == sizeof(struct sockaddr_ax25))
1486 /* ax25_sendmsg(): uses obsolete socket structure */
1487 ;
1488 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1489 /* support for old structure may go away some time
1490 * ax25_sendmsg(): uses old (6 digipeater)
1491 * socket structure.
1492 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001494 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1495 err = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 goto out;
1497 }
1498
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499
1500 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1501 int ct = 0;
1502 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1503
1504 /* Valid number of digipeaters ? */
1505 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1506 err = -EINVAL;
1507 goto out;
1508 }
1509
1510 dtmp.ndigi = usax->sax25_ndigis;
1511
1512 while (ct < usax->sax25_ndigis) {
1513 dtmp.repeated[ct] = 0;
1514 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1515 ct++;
1516 }
1517
1518 dtmp.lastrepeat = 0;
1519 }
1520
1521 sax = *usax;
1522 if (sk->sk_type == SOCK_SEQPACKET &&
1523 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1524 err = -EISCONN;
1525 goto out;
1526 }
1527 if (usax->sax25_ndigis == 0)
1528 dp = NULL;
1529 else
1530 dp = &dtmp;
1531 } else {
1532 /*
1533 * FIXME: 1003.1g - if the socket is like this because
1534 * it has become closed (not started closed) and is VC
1535 * we ought to SIGPIPE, EPIPE
1536 */
1537 if (sk->sk_state != TCP_ESTABLISHED) {
1538 err = -ENOTCONN;
1539 goto out;
1540 }
1541 sax.sax25_family = AF_AX25;
1542 sax.sax25_call = ax25->dest_addr;
1543 dp = ax25->digipeat;
1544 }
1545
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546 /* Build a packet */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 /* Assume the worst case */
1548 size = len + ax25->ax25_dev->dev->hard_header_len;
1549
1550 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1551 if (skb == NULL)
1552 goto out;
1553
1554 skb_reserve(skb, size - len);
1555
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 /* User data follows immediately after the AX.25 data */
1557 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1558 err = -EFAULT;
1559 kfree_skb(skb);
1560 goto out;
1561 }
1562
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001563 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564
1565 /* Add the PID if one is not supplied by the user in the skb */
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001566 if (!ax25->pidincl)
1567 *skb_push(skb, 1) = sk->sk_protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 if (sk->sk_type == SOCK_SEQPACKET) {
1570 /* Connected mode sockets go via the LAPB machine */
1571 if (sk->sk_state != TCP_ESTABLISHED) {
1572 kfree_skb(skb);
1573 err = -ENOTCONN;
1574 goto out;
1575 }
1576
1577 /* Shove it onto the queue and kick */
1578 ax25_output(ax25, ax25->paclen, skb);
1579
1580 err = len;
1581 goto out;
1582 }
1583
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001584 skb_push(skb, 1 + ax25_addr_size(dp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585
Ralf Baechle8849b722011-04-14 00:20:07 -07001586 /* Building AX.25 Header */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587
1588 /* Build an AX.25 header */
Arnaldo Carvalho de Melo967b05f2007-03-13 13:51:52 -03001589 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1590 dp, AX25_COMMAND, AX25_MODULUS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591
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 *skb_transport_header(skb) = AX25_UI;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595
1596 /* Datagram frames go straight out of the door as UI */
Arnaldo Carvalho de Melo29c4be52005-04-21 16:46:56 -07001597 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598
1599 err = len;
1600
1601out:
1602 release_sock(sk);
1603
1604 return err;
1605}
1606
1607static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1608 struct msghdr *msg, size_t size, int flags)
1609{
1610 struct sock *sk = sock->sk;
1611 struct sk_buff *skb;
1612 int copied;
1613 int err = 0;
1614
1615 lock_sock(sk);
1616 /*
1617 * This works for seqpacket too. The receiver has ordered the
1618 * queue for us! We do one quick check first though
1619 */
1620 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1621 err = -ENOTCONN;
1622 goto out;
1623 }
1624
1625 /* Now we can treat all alike */
1626 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001627 flags & MSG_DONTWAIT, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628 if (skb == NULL)
1629 goto out;
1630
1631 if (!ax25_sk(sk)->pidincl)
1632 skb_pull(skb, 1); /* Remove PID */
1633
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001634 skb_reset_transport_header(skb);
1635 copied = skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636
1637 if (copied > size) {
1638 copied = size;
1639 msg->msg_flags |= MSG_TRUNC;
1640 }
1641
1642 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1643
1644 if (msg->msg_namelen != 0) {
1645 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1646 ax25_digi digi;
1647 ax25_address src;
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001648 const unsigned char *mac = skb_mac_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001650 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1651 &digi, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 sax->sax25_family = AF_AX25;
1653 /* We set this correctly, even though we may not let the
1654 application know the digi calls further down (because it
1655 did NOT ask to know them). This could get political... **/
1656 sax->sax25_ndigis = digi.ndigi;
1657 sax->sax25_call = src;
1658
1659 if (sax->sax25_ndigis != 0) {
1660 int ct;
1661 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1662
1663 for (ct = 0; ct < digi.ndigi; ct++)
1664 fsa->fsa_digipeater[ct] = digi.calls[ct];
1665 }
1666 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1667 }
1668
1669 skb_free_datagram(sk, skb);
1670 err = copied;
1671
1672out:
1673 release_sock(sk);
1674
1675 return err;
1676}
1677
1678static int ax25_shutdown(struct socket *sk, int how)
1679{
1680 /* FIXME - generate DM and RNR states */
1681 return -EOPNOTSUPP;
1682}
1683
1684static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1685{
1686 struct sock *sk = sock->sk;
1687 void __user *argp = (void __user *)arg;
1688 int res = 0;
1689
1690 lock_sock(sk);
1691 switch (cmd) {
1692 case TIOCOUTQ: {
1693 long amount;
Eric Dumazet31e6d362009-06-17 19:05:41 -07001694
1695 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 if (amount < 0)
1697 amount = 0;
1698 res = put_user(amount, (int __user *)argp);
1699 break;
1700 }
1701
1702 case TIOCINQ: {
1703 struct sk_buff *skb;
1704 long amount = 0L;
1705 /* These two are safe on a single CPU system as only user tasks fiddle here */
1706 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1707 amount = skb->len;
Ralf Baechle20b7d102005-09-12 14:24:55 -07001708 res = put_user(amount, (int __user *) argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 break;
1710 }
1711
1712 case SIOCGSTAMP:
Ralf Baechle9b37ee72005-09-12 14:23:52 -07001713 res = sock_get_timestamp(sk, argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 break;
1715
Eric Dumazetae40eb12007-03-18 17:33:16 -07001716 case SIOCGSTAMPNS:
1717 res = sock_get_timestampns(sk, argp);
1718 break;
1719
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1721 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1722 case SIOCAX25GETUID: {
1723 struct sockaddr_ax25 sax25;
1724 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1725 res = -EFAULT;
1726 break;
1727 }
1728 res = ax25_uid_ioctl(cmd, &sax25);
1729 break;
1730 }
1731
1732 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1733 long amount;
1734 if (!capable(CAP_NET_ADMIN)) {
1735 res = -EPERM;
1736 break;
1737 }
1738 if (get_user(amount, (long __user *)argp)) {
1739 res = -EFAULT;
1740 break;
1741 }
1742 if (amount > AX25_NOUID_BLOCK) {
1743 res = -EINVAL;
1744 break;
1745 }
1746 ax25_uid_policy = amount;
1747 res = 0;
1748 break;
1749 }
1750
1751 case SIOCADDRT:
1752 case SIOCDELRT:
1753 case SIOCAX25OPTRT:
1754 if (!capable(CAP_NET_ADMIN)) {
1755 res = -EPERM;
1756 break;
1757 }
1758 res = ax25_rt_ioctl(cmd, argp);
1759 break;
1760
1761 case SIOCAX25CTLCON:
1762 if (!capable(CAP_NET_ADMIN)) {
1763 res = -EPERM;
1764 break;
1765 }
1766 res = ax25_ctl_ioctl(cmd, argp);
1767 break;
1768
1769 case SIOCAX25GETINFO:
1770 case SIOCAX25GETINFOOLD: {
1771 ax25_cb *ax25 = ax25_sk(sk);
1772 struct ax25_info_struct ax25_info;
1773
1774 ax25_info.t1 = ax25->t1 / HZ;
1775 ax25_info.t2 = ax25->t2 / HZ;
1776 ax25_info.t3 = ax25->t3 / HZ;
1777 ax25_info.idle = ax25->idle / (60 * HZ);
1778 ax25_info.n2 = ax25->n2;
1779 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1780 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1781 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1782 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1783 ax25_info.n2count = ax25->n2count;
1784 ax25_info.state = ax25->state;
Eric Dumazet407fc5c2009-09-20 06:32:55 +00001785 ax25_info.rcv_q = sk_rmem_alloc_get(sk);
1786 ax25_info.snd_q = sk_wmem_alloc_get(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787 ax25_info.vs = ax25->vs;
1788 ax25_info.vr = ax25->vr;
1789 ax25_info.va = ax25->va;
1790 ax25_info.vs_max = ax25->vs; /* reserved */
1791 ax25_info.paclen = ax25->paclen;
1792 ax25_info.window = ax25->window;
1793
1794 /* old structure? */
1795 if (cmd == SIOCAX25GETINFOOLD) {
1796 static int warned = 0;
1797 if (!warned) {
1798 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1799 current->comm);
1800 warned=1;
1801 }
1802
1803 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1804 res = -EFAULT;
1805 break;
1806 }
1807 } else {
1808 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1809 res = -EINVAL;
1810 break;
1811 }
1812 }
1813 res = 0;
1814 break;
1815 }
1816
1817 case SIOCAX25ADDFWD:
1818 case SIOCAX25DELFWD: {
1819 struct ax25_fwd_struct ax25_fwd;
1820 if (!capable(CAP_NET_ADMIN)) {
1821 res = -EPERM;
1822 break;
1823 }
1824 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1825 res = -EFAULT;
1826 break;
1827 }
1828 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1829 break;
1830 }
1831
1832 case SIOCGIFADDR:
1833 case SIOCSIFADDR:
1834 case SIOCGIFDSTADDR:
1835 case SIOCSIFDSTADDR:
1836 case SIOCGIFBRDADDR:
1837 case SIOCSIFBRDADDR:
1838 case SIOCGIFNETMASK:
1839 case SIOCSIFNETMASK:
1840 case SIOCGIFMETRIC:
1841 case SIOCSIFMETRIC:
1842 res = -EINVAL;
1843 break;
1844
1845 default:
Christoph Hellwigb5e5fa52006-01-03 14:18:33 -08001846 res = -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 break;
1848 }
1849 release_sock(sk);
1850
1851 return res;
1852}
1853
1854#ifdef CONFIG_PROC_FS
1855
1856static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
Eric Dumazetf16f3022008-01-13 22:29:41 -08001857 __acquires(ax25_list_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 spin_lock_bh(&ax25_list_lock);
Li Zefanb512f3d2010-02-08 23:19:59 +00001860 return seq_hlist_start(&ax25_list, *pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861}
1862
1863static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1864{
Li Zefanb512f3d2010-02-08 23:19:59 +00001865 return seq_hlist_next(v, &ax25_list, pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866}
YOSHIFUJI Hideaki528930b2007-02-09 23:24:31 +09001867
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868static void ax25_info_stop(struct seq_file *seq, void *v)
Eric Dumazetf16f3022008-01-13 22:29:41 -08001869 __releases(ax25_list_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870{
1871 spin_unlock_bh(&ax25_list_lock);
1872}
1873
1874static int ax25_info_show(struct seq_file *seq, void *v)
1875{
Li Zefanb512f3d2010-02-08 23:19:59 +00001876 ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
Ralf Baechlef75268c2005-09-06 15:49:39 -07001877 char buf[11];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878 int k;
1879
1880
1881 /*
1882 * New format:
1883 * 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
1884 */
1885
1886 seq_printf(seq, "%8.8lx %s %s%s ",
1887 (long) ax25,
1888 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
Ralf Baechlef75268c2005-09-06 15:49:39 -07001889 ax2asc(buf, &ax25->source_addr),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 ax25->iamdigi? "*":"");
Ralf Baechlef75268c2005-09-06 15:49:39 -07001891 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892
1893 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1894 seq_printf(seq, ",%s%s",
Ralf Baechlef75268c2005-09-06 15:49:39 -07001895 ax2asc(buf, &ax25->digipeat->calls[k]),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 ax25->digipeat->repeated[k]? "*":"");
1897 }
1898
1899 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1900 ax25->state,
1901 ax25->vs, ax25->vr, ax25->va,
1902 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1903 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1904 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1905 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1906 ax25->idle / (60 * HZ),
1907 ax25->n2count, ax25->n2,
1908 ax25->rtt / HZ,
1909 ax25->window,
1910 ax25->paclen);
1911
1912 if (ax25->sk != NULL) {
Jarek Poplawski1105b5d2008-02-11 21:24:56 -08001913 seq_printf(seq, " %d %d %lu\n",
Eric Dumazet31e6d362009-06-17 19:05:41 -07001914 sk_wmem_alloc_get(ax25->sk),
1915 sk_rmem_alloc_get(ax25->sk),
Jarek Poplawski1105b5d2008-02-11 21:24:56 -08001916 sock_i_ino(ax25->sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917 } else {
1918 seq_puts(seq, " * * *\n");
1919 }
1920 return 0;
1921}
1922
Philippe De Muyter56b3d972007-07-10 23:07:31 -07001923static const struct seq_operations ax25_info_seqops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924 .start = ax25_info_start,
1925 .next = ax25_info_next,
1926 .stop = ax25_info_stop,
1927 .show = ax25_info_show,
1928};
1929
1930static int ax25_info_open(struct inode *inode, struct file *file)
1931{
1932 return seq_open(file, &ax25_info_seqops);
1933}
1934
Arjan van de Ven9a321442007-02-12 00:55:35 -08001935static const struct file_operations ax25_info_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 .owner = THIS_MODULE,
1937 .open = ax25_info_open,
1938 .read = seq_read,
1939 .llseek = seq_lseek,
1940 .release = seq_release,
1941};
1942
1943#endif
1944
Stephen Hemmingerec1b4cf2009-10-05 05:58:39 +00001945static const struct net_proto_family ax25_family_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 .family = PF_AX25,
1947 .create = ax25_create,
1948 .owner = THIS_MODULE,
1949};
1950
Eric Dumazet90ddc4f2005-12-22 12:49:22 -08001951static const struct proto_ops ax25_proto_ops = {
Ralf Baechle46763562005-09-12 14:25:25 -07001952 .family = PF_AX25,
1953 .owner = THIS_MODULE,
1954 .release = ax25_release,
1955 .bind = ax25_bind,
1956 .connect = ax25_connect,
1957 .socketpair = sock_no_socketpair,
1958 .accept = ax25_accept,
1959 .getname = ax25_getname,
1960 .poll = datagram_poll,
1961 .ioctl = ax25_ioctl,
1962 .listen = ax25_listen,
1963 .shutdown = ax25_shutdown,
1964 .setsockopt = ax25_setsockopt,
1965 .getsockopt = ax25_getsockopt,
1966 .sendmsg = ax25_sendmsg,
1967 .recvmsg = ax25_recvmsg,
1968 .mmap = sock_no_mmap,
1969 .sendpage = sock_no_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970};
1971
1972/*
1973 * Called by socket.c on kernel start up
1974 */
Stephen Hemminger7546dd92009-03-09 08:18:29 +00001975static struct packet_type ax25_packet_type __read_mostly = {
Harvey Harrison09640e62009-02-01 00:45:17 -08001976 .type = cpu_to_be16(ETH_P_AX25),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977 .func = ax25_kiss_rcv,
1978};
1979
1980static struct notifier_block ax25_dev_notifier = {
1981 .notifier_call =ax25_device_event,
1982};
1983
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984static int __init ax25_init(void)
1985{
1986 int rc = proto_register(&ax25_proto, 0);
1987
1988 if (rc != 0)
1989 goto out;
1990
1991 sock_register(&ax25_family_ops);
1992 dev_add_pack(&ax25_packet_type);
1993 register_netdevice_notifier(&ax25_dev_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994
Eric W. Biederman457c4cb2007-09-12 12:01:34 +02001995 proc_net_fops_create(&init_net, "ax25_route", S_IRUGO, &ax25_route_fops);
1996 proc_net_fops_create(&init_net, "ax25", S_IRUGO, &ax25_info_fops);
1997 proc_net_fops_create(&init_net, "ax25_calls", S_IRUGO, &ax25_uid_fops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998out:
1999 return rc;
2000}
2001module_init(ax25_init);
2002
2003
2004MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2005MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2006MODULE_LICENSE("GPL");
2007MODULE_ALIAS_NETPROTO(PF_AX25);
2008
2009static void __exit ax25_exit(void)
2010{
Eric W. Biederman457c4cb2007-09-12 12:01:34 +02002011 proc_net_remove(&init_net, "ax25_route");
2012 proc_net_remove(&init_net, "ax25");
2013 proc_net_remove(&init_net, "ax25_calls");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 unregister_netdevice_notifier(&ax25_dev_notifier);
2016
2017 dev_remove_pack(&ax25_packet_type);
2018
2019 sock_unregister(PF_AX25);
2020 proto_unregister(&ax25_proto);
Eric W. Biederman3adadc02012-04-18 16:11:23 +00002021
2022 ax25_rt_free();
2023 ax25_uid_free();
2024 ax25_dev_free();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025}
2026module_exit(ax25_exit);