Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
af_ax25.c
Go to the documentation of this file.
1 /*
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 ([email protected])
8  * Copyright (C) Jonathan Naylor G4KLX ([email protected])
9  * Copyright (C) Darryl Miles G7LED ([email protected])
10  * Copyright (C) Steven Whitehouse GW7RRM ([email protected])
11  * Copyright (C) Joerg Reuter DL1BKE ([email protected])
12  * Copyright (C) Hans-Joachim Hetscher DD8NE ([email protected])
13  * Copyright (C) Hans Alblas PE1AYX ([email protected])
14  * Copyright (C) Frederic Rible F1OAT ([email protected])
15  */
16 #include <linux/capability.h>
17 #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>
26 #include <linux/sockios.h>
27 #include <linux/net.h>
28 #include <linux/slab.h>
29 #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>
36 #include <linux/fcntl.h>
37 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
38 #include <linux/mm.h>
39 #include <linux/interrupt.h>
40 #include <linux/notifier.h>
41 #include <linux/proc_fs.h>
42 #include <linux/stat.h>
43 #include <linux/netfilter.h>
44 #include <linux/sysctl.h>
45 #include <linux/init.h>
46 #include <linux/spinlock.h>
47 #include <net/net_namespace.h>
48 #include <net/tcp_states.h>
49 #include <net/ip.h>
50 #include <net/arp.h>
51 
52 
53 
54 HLIST_HEAD(ax25_list);
55 DEFINE_SPINLOCK(ax25_list_lock);
56 
57 static const struct proto_ops ax25_proto_ops;
58 
59 static 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  */
67 static 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  */
80 static 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);
90 again:
91  ax25_for_each(s, node, &ax25_list) {
92  if (s->ax25_dev == ax25_dev) {
93  s->ax25_dev = NULL;
94  spin_unlock_bh(&ax25_list_lock);
95  ax25_disconnect(s, ENETUNREACH);
96  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;
106  }
107  }
108  spin_unlock_bh(&ax25_list_lock);
109 }
110 
111 /*
112  * Handle device status changes.
113  */
114 static 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 
119  if (!net_eq(dev_net(dev), &init_net))
120  return NOTIFY_DONE;
121 
122  /* 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  */
145 void 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  */
157 struct 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 
163  spin_lock(&ax25_list_lock);
164  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);
172  spin_unlock(&ax25_list_lock);
173  return s->sk;
174  }
175  }
176  }
177  spin_unlock(&ax25_list_lock);
178 
179  return NULL;
180 }
181 
182 /*
183  * Find an AX.25 socket given both ends.
184  */
185 struct 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 
192  spin_lock(&ax25_list_lock);
193  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 
203  spin_unlock(&ax25_list_lock);
204 
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  */
212 ax25_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 
245 EXPORT_SYMBOL(ax25_find_cb);
246 
247 void 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 
253  spin_lock(&ax25_list_lock);
254  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  }
266  spin_unlock(&ax25_list_lock);
267 }
268 
269 /*
270  * Deferred destroy.
271  */
272 void ax25_destroy_socket(ax25_cb *);
273 
274 /*
275  * Handler for deferred kills.
276  */
277 static void ax25_destroy_timer(unsigned long data)
278 {
279  ax25_cb *ax25=(ax25_cb *)data;
280  struct sock *sk;
281 
282  sk=ax25->sk;
283 
284  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  */
297 void ax25_destroy_socket(ax25_cb *ax25)
298 {
299  struct sk_buff *skb;
300 
301  ax25_cb_del(ax25);
302 
303  ax25_stop_heartbeat(ax25);
304  ax25_stop_t1timer(ax25);
305  ax25_stop_t2timer(ax25);
306  ax25_stop_t3timer(ax25);
307  ax25_stop_idletimer(ax25);
308 
309  ax25_clear_queues(ax25); /* Flush the queues */
310 
311  if (ax25->sk != NULL) {
312  while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
313  if (skb->sk != ax25->sk) {
314  /* A pending connection */
315  ax25_cb *sax25 = ax25_sk(skb->sk);
316 
317  /* Queue the unaccepted socket for death */
318  sock_orphan(skb->sk);
319 
320  /* 9A4GL: hack to release unaccepted sockets */
321  skb->sk->sk_state = TCP_LISTEN;
322 
323  ax25_start_heartbeat(sax25);
324  sax25->state = AX25_STATE_0;
325  }
326 
327  kfree_skb(skb);
328  }
329  skb_queue_purge(&ax25->sk->sk_write_queue);
330  }
331 
332  if (ax25->sk != NULL) {
333  if (sk_has_allocations(ax25->sk)) {
334  /* Defer: outstanding buffers */
335  setup_timer(&ax25->dtimer, ax25_destroy_timer,
336  (unsigned long)ax25);
337  ax25->dtimer.expires = jiffies + 2 * HZ;
338  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  */
354 static 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;
361  int ret = 0;
362 
363  if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
364  return -EFAULT;
365 
366  if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
367  return -ENODEV;
368 
369  if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
370  return -EINVAL;
371 
372  if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
373  return -EINVAL;
374 
375  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 
392  case AX25_WINDOW:
393  if (ax25->modulus == AX25_MODULUS) {
394  if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
395  goto einval_put;
396  } else {
397  if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
398  goto einval_put;
399  }
400  ax25->window = ax25_ctl.arg;
401  break;
402 
403  case AX25_T1:
404  if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
405  goto einval_put;
406  ax25->rtt = (ax25_ctl.arg * HZ) / 2;
407  ax25->t1 = ax25_ctl.arg * HZ;
408  break;
409 
410  case AX25_T2:
411  if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
412  goto einval_put;
413  ax25->t2 = ax25_ctl.arg * HZ;
414  break;
415 
416  case AX25_N2:
417  if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
418  goto einval_put;
419  ax25->n2count = 0;
420  ax25->n2 = ax25_ctl.arg;
421  break;
422 
423  case AX25_T3:
424  if (ax25_ctl.arg > ULONG_MAX / HZ)
425  goto einval_put;
426  ax25->t3 = ax25_ctl.arg * HZ;
427  break;
428 
429  case AX25_IDLE:
430  if (ax25_ctl.arg > ULONG_MAX / (60 * HZ))
431  goto einval_put;
432 
433  ax25->idle = ax25_ctl.arg * 60 * HZ;
434  break;
435 
436  case AX25_PACLEN:
437  if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
438  goto einval_put;
439  ax25->paclen = ax25_ctl.arg;
440  break;
441 
442  default:
443  goto einval_put;
444  }
445 
446 out_put:
447  ax25_cb_put(ax25);
448  return ret;
449 
450 einval_put:
451  ret = -EINVAL;
452  goto out_put;
453 }
454 
455 static 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 
475 /*
476  * Fill in a created AX.25 created control block with the default
477  * values for a particular device.
478  */
479 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
480 {
481  ax25->ax25_dev = ax25_dev;
482 
483  if (ax25->ax25_dev != NULL) {
484  ax25_fillin_cb_from_dev(ax25, ax25_dev);
485  return;
486  }
487 
488  /*
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;
503  } else {
504  ax25->modulus = AX25_MODULUS;
505  ax25->window = AX25_DEF_WINDOW;
506  }
507 }
508 
509 /*
510  * Create an empty AX.25 control block.
511  */
512 ax25_cb *ax25_create_cb(void)
513 {
514  ax25_cb *ax25;
515 
516  if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
517  return NULL;
518 
519  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 
526  ax25_setup_timers(ax25);
527 
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 
540 static int ax25_setsockopt(struct socket *sock, int level, int optname,
541  char __user *optval, unsigned int optlen)
542 {
543  struct sock *sk = sock->sk;
544  ax25_cb *ax25;
545  struct net_device *dev;
546  char devname[IFNAMSIZ];
547  unsigned long opt;
548  int res = 0;
549 
550  if (level != SOL_AX25)
551  return -ENOPROTOOPT;
552 
553  if (optlen < sizeof(unsigned int))
554  return -EINVAL;
555 
556  if (get_user(opt, (unsigned int __user *)optval))
557  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:
579  if (opt < 1 || opt > ULONG_MAX / HZ) {
580  res = -EINVAL;
581  break;
582  }
583  ax25->rtt = (opt * HZ) >> 1;
584  ax25->t1 = opt * HZ;
585  break;
586 
587  case AX25_T2:
588  if (opt < 1 || opt > ULONG_MAX / HZ) {
589  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:
604  if (opt < 1 || opt > ULONG_MAX / HZ) {
605  res = -EINVAL;
606  break;
607  }
608  ax25->t3 = opt * HZ;
609  break;
610 
611  case AX25_IDLE:
612  if (opt > ULONG_MAX / (60 * HZ)) {
613  res = -EINVAL;
614  break;
615  }
616  ax25->idle = opt * 60 * HZ;
617  break;
618 
619  case AX25_BACKOFF:
620  if (opt > 2) {
621  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)
649  optlen = IFNAMSIZ;
650 
651  if (copy_from_user(devname, optval, optlen)) {
652  res = -EFAULT;
653  break;
654  }
655 
656  if (sk->sk_type == SOCK_SEQPACKET &&
657  (sock->state != SS_UNCONNECTED ||
658  sk->sk_state == TCP_LISTEN)) {
659  res = -EADDRNOTAVAIL;
660  break;
661  }
662 
663  dev = dev_get_by_name(&init_net, devname);
664  if (!dev) {
665  res = -ENODEV;
666  break;
667  }
668 
669  ax25->ax25_dev = ax25_dev_ax25dev(dev);
670  ax25_fillin_cb(ax25, ax25->ax25_dev);
671  dev_put(dev);
672  break;
673 
674  default:
675  res = -ENOPROTOOPT;
676  }
677  release_sock(sk);
678 
679  return res;
680 }
681 
682 static 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 
779 static 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 
792 out:
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  */
802 static struct proto ax25_proto = {
803  .name = "AX25",
804  .owner = THIS_MODULE,
805  .obj_size = sizeof(struct sock),
806 };
807 
808 static int ax25_create(struct net *net, struct socket *sock, int protocol,
809  int kern)
810 {
811  struct sock *sk;
812  ax25_cb *ax25;
813 
814  if (!net_eq(net, &init_net))
815  return -EAFNOSUPPORT;
816 
817  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;
845  break;
846 #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 
863  sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
864  if (sk == NULL)
865  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 
884 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
885 {
886  struct sock *sk;
887  ax25_cb *ax25, *oax25;
888 
889  sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot);
890  if (sk == NULL)
891  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 
911  sk->sk_type = osk->sk_type;
912  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;
917  sock_copy_flags(sk, osk);
918 
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) {
938  ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
939  GFP_ATOMIC);
940  if (ax25->digipeat == NULL) {
941  sk_free(sk);
942  ax25_cb_put(ax25);
943  return NULL;
944  }
945  }
946 
947  sk->sk_protinfo = ax25;
948  sk->sk_destruct = ax25_free_sock;
949  ax25->sk = sk;
950 
951  return sk;
952 }
953 
954 static 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  */
1040 static 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;
1045  ax25_uid_assoc *user;
1046  ax25_address call;
1047  ax25_cb *ax25;
1048  int err = 0;
1049 
1050  if (addr_len != sizeof(struct sockaddr_ax25) &&
1051  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  */
1055  if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1056  (addr_len > sizeof(struct full_sockaddr_ax25)))
1057  return -EINVAL;
1058 
1059  if (addr->fsa_ax25.sax25_family != AF_AX25)
1060  return -EINVAL;
1061 
1062  user = ax25_findbyuid(current_euid());
1063  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;
1071  }
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 
1081  ax25->source_addr = call;
1082 
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 
1105 done:
1106  ax25_cb_add(ax25);
1107  sock_reset_flag(sk, SOCK_ZAPPED);
1108 
1109 out:
1110  release_sock(sk);
1111 
1112  return err;
1113 }
1114 
1115 /*
1116  * FIXME: nonblock behaviour looks like it may have a bug.
1117  */
1118 static int __must_check ax25_connect(struct socket *sock,
1119  struct sockaddr *uaddr, int addr_len, int flags)
1120 {
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 
1131  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  */
1140  if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1141  (addr_len > sizeof(struct full_sockaddr_ax25)))
1142  return -EINVAL;
1143 
1144 
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;
1155  goto out_release;
1156 
1157  case TCP_ESTABLISHED: /* connection established */
1158  sock->state = SS_CONNECTED;
1159  goto out_release;
1160 
1161  case TCP_CLOSE: /* connection refused */
1162  sock->state = SS_UNCONNECTED;
1163  err = -ECONNREFUSED;
1164  goto out_release;
1165  }
1166  }
1167 
1168  if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1169  err = -EISCONN; /* No reconnect on a seqpacket socket */
1170  goto out_release;
1171  }
1172 
1173  sk->sk_state = TCP_CLOSE;
1174  sock->state = SS_UNCONNECTED;
1175 
1176  kfree(ax25->digipeat);
1177  ax25->digipeat = NULL;
1178 
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;
1187  goto out_release;
1188  }
1189 
1190  if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1191  err = -ENOBUFS;
1192  goto out_release;
1193  }
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 [email protected]\n",
1219  current->comm);
1220  if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1221  kfree(digi);
1222  goto out_release;
1223  }
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;
1231  goto out_release;
1232  }
1233  }
1234 
1235  if (sk->sk_type == SOCK_SEQPACKET &&
1236  (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1237  ax25->ax25_dev->dev))) {
1238  kfree(digi);
1239  err = -EADDRINUSE; /* Already such a connection */
1240  ax25_cb_put(ax25t);
1241  goto out_release;
1242  }
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;
1251  goto out_release;
1252  }
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;
1283  goto out_release;
1284  }
1285 
1286  if (sk->sk_state == TCP_SYN_SENT) {
1287  DEFINE_WAIT(wait);
1288 
1289  for (;;) {
1290  prepare_to_wait(sk_sleep(sk), &wait,
1291  TASK_INTERRUPTIBLE);
1292  if (sk->sk_state != TCP_SYN_SENT)
1293  break;
1294  if (!signal_pending(current)) {
1295  release_sock(sk);
1296  schedule();
1297  lock_sock(sk);
1298  continue;
1299  }
1300  err = -ERESTARTSYS;
1301  break;
1302  }
1303  finish_wait(sk_sleep(sk), &wait);
1304 
1305  if (err)
1306  goto out_release;
1307  }
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 */
1313  goto out_release;
1314  }
1315 
1316  sock->state = SS_CONNECTED;
1317 
1318  err = 0;
1319 out_release:
1320  release_sock(sk);
1321 
1322  return err;
1323 }
1324 
1325 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1326 {
1327  struct sk_buff *skb;
1328  struct sock *newsk;
1329  DEFINE_WAIT(wait);
1330  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  */
1354  for (;;) {
1355  prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1356  skb = skb_dequeue(&sk->sk_receive_queue);
1357  if (skb)
1358  break;
1359 
1360  if (flags & O_NONBLOCK) {
1361  err = -EWOULDBLOCK;
1362  break;
1363  }
1364  if (!signal_pending(current)) {
1365  release_sock(sk);
1366  schedule();
1367  lock_sock(sk);
1368  continue;
1369  }
1370  err = -ERESTARTSYS;
1371  break;
1372  }
1373  finish_wait(sk_sleep(sk), &wait);
1374 
1375  if (err)
1376  goto out;
1377 
1378  newsk = skb->sk;
1379  sock_graft(newsk, newsock);
1380 
1381  /* Now attach up the new socket */
1382  kfree_skb(skb);
1383  sk->sk_ack_backlog--;
1384  newsock->state = SS_CONNECTED;
1385 
1386 out:
1387  release_sock(sk);
1388 
1389  return err;
1390 }
1391 
1392 static 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 
1401  memset(fsa, 0, sizeof(*fsa));
1402  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;
1413 
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 
1434 out:
1435  release_sock(sk);
1436 
1437  return err;
1438 }
1439 
1440 static 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;
1448  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  }
1478 
1479  if (usax != NULL) {
1480  if (usax->sax25_family != AF_AX25) {
1481  err = -EINVAL;
1482  goto out;
1483  }
1484 
1485  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  */
1493  if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1494  (addr_len > sizeof(struct full_sockaddr_ax25))) {
1495  err = -EINVAL;
1496  goto out;
1497  }
1498 
1499 
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 
1546  /* Build a packet */
1547  /* 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 
1556  /* 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 
1563  skb_reset_network_header(skb);
1564 
1565  /* Add the PID if one is not supplied by the user in the skb */
1566  if (!ax25->pidincl)
1567  *skb_push(skb, 1) = sk->sk_protocol;
1568 
1569  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 
1584  skb_push(skb, 1 + ax25_addr_size(dp));
1585 
1586  /* Building AX.25 Header */
1587 
1588  /* Build an AX.25 header */
1589  lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1590  dp, AX25_COMMAND, AX25_MODULUS);
1591 
1592  skb_set_transport_header(skb, lv);
1593 
1594  *skb_transport_header(skb) = AX25_UI;
1595 
1596  /* Datagram frames go straight out of the door as UI */
1597  ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1598 
1599  err = len;
1600 
1601 out:
1602  release_sock(sk);
1603 
1604  return err;
1605 }
1606 
1607 static 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,
1627  flags & MSG_DONTWAIT, &err);
1628  if (skb == NULL)
1629  goto out;
1630 
1631  if (!ax25_sk(sk)->pidincl)
1632  skb_pull(skb, 1); /* Remove PID */
1633 
1634  skb_reset_transport_header(skb);
1635  copied = skb->len;
1636 
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;
1648  const unsigned char *mac = skb_mac_header(skb);
1649 
1650  ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1651  &digi, NULL, NULL);
1652  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 
1672 out:
1673  release_sock(sk);
1674 
1675  return err;
1676 }
1677 
1678 static int ax25_shutdown(struct socket *sk, int how)
1679 {
1680  /* FIXME - generate DM and RNR states */
1681  return -EOPNOTSUPP;
1682 }
1683 
1684 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1685 {
1686  struct sock *sk = sock->sk;
1687  void __user *argp = (void __user *)arg;
1688  int res = 0;
1689 
1690  lock_sock(sk);
1691  switch (cmd) {
1692  case TIOCOUTQ: {
1693  long amount;
1694 
1695  amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1696  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;
1708  res = put_user(amount, (int __user *) argp);
1709  break;
1710  }
1711 
1712  case SIOCGSTAMP:
1713  res = sock_get_timestamp(sk, argp);
1714  break;
1715 
1716  case SIOCGSTAMPNS:
1717  res = sock_get_timestampns(sk, argp);
1718  break;
1719 
1720  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;
1785  ax25_info.rcv_q = sk_rmem_alloc_get(sk);
1786  ax25_info.snd_q = sk_wmem_alloc_get(sk);
1787  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:
1846  res = -ENOIOCTLCMD;
1847  break;
1848  }
1849  release_sock(sk);
1850 
1851  return res;
1852 }
1853 
1854 #ifdef CONFIG_PROC_FS
1855 
1856 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1857  __acquires(ax25_list_lock)
1858 {
1859  spin_lock_bh(&ax25_list_lock);
1860  return seq_hlist_start(&ax25_list, *pos);
1861 }
1862 
1863 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1864 {
1865  return seq_hlist_next(v, &ax25_list, pos);
1866 }
1867 
1868 static void ax25_info_stop(struct seq_file *seq, void *v)
1869  __releases(ax25_list_lock)
1870 {
1871  spin_unlock_bh(&ax25_list_lock);
1872 }
1873 
1874 static int ax25_info_show(struct seq_file *seq, void *v)
1875 {
1876  ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
1877  char buf[11];
1878  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,
1889  ax2asc(buf, &ax25->source_addr),
1890  ax25->iamdigi? "*":"");
1891  seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1892 
1893  for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1894  seq_printf(seq, ",%s%s",
1895  ax2asc(buf, &ax25->digipeat->calls[k]),
1896  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) {
1913  seq_printf(seq, " %d %d %lu\n",
1914  sk_wmem_alloc_get(ax25->sk),
1915  sk_rmem_alloc_get(ax25->sk),
1916  sock_i_ino(ax25->sk));
1917  } else {
1918  seq_puts(seq, " * * *\n");
1919  }
1920  return 0;
1921 }
1922 
1923 static const struct seq_operations ax25_info_seqops = {
1924  .start = ax25_info_start,
1925  .next = ax25_info_next,
1926  .stop = ax25_info_stop,
1927  .show = ax25_info_show,
1928 };
1929 
1930 static int ax25_info_open(struct inode *inode, struct file *file)
1931 {
1932  return seq_open(file, &ax25_info_seqops);
1933 }
1934 
1935 static const struct file_operations ax25_info_fops = {
1936  .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 
1945 static const struct net_proto_family ax25_family_ops = {
1946  .family = PF_AX25,
1947  .create = ax25_create,
1948  .owner = THIS_MODULE,
1949 };
1950 
1951 static const struct proto_ops ax25_proto_ops = {
1952  .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,
1970 };
1971 
1972 /*
1973  * Called by socket.c on kernel start up
1974  */
1975 static struct packet_type ax25_packet_type __read_mostly = {
1976  .type = cpu_to_be16(ETH_P_AX25),
1977  .func = ax25_kiss_rcv,
1978 };
1979 
1980 static struct notifier_block ax25_dev_notifier = {
1981  .notifier_call =ax25_device_event,
1982 };
1983 
1984 static 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);
1994 
1995  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);
1998 out:
1999  return rc;
2000 }
2001 module_init(ax25_init);
2002 
2003 
2004 MODULE_AUTHOR("Jonathan Naylor G4KLX <[email protected]>");
2005 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2006 MODULE_LICENSE("GPL");
2007 MODULE_ALIAS_NETPROTO(PF_AX25);
2008 
2009 static void __exit ax25_exit(void)
2010 {
2011  proc_net_remove(&init_net, "ax25_route");
2012  proc_net_remove(&init_net, "ax25");
2013  proc_net_remove(&init_net, "ax25_calls");
2014 
2015  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);
2021 
2022  ax25_rt_free();
2023  ax25_uid_free();
2024  ax25_dev_free();
2025 }
2026 module_exit(ax25_exit);
Generated on Thu Jan 10 2013 14:56:48 for Linux Kernel by   doxygen 1.8.2