~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ax25/af_ax25.c

Version: ~ [ linux-5.0-rc2 ] ~ [ linux-4.20.2 ] ~ [ linux-4.19.15 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.93 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.150 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.170 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.132 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.62 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 (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  */
 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/signal.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 <linux/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/sysctl.h>
 44 #include <linux/init.h>
 45 #include <linux/spinlock.h>
 46 #include <net/net_namespace.h>
 47 #include <net/tcp_states.h>
 48 #include <net/ip.h>
 49 #include <net/arp.h>
 50 
 51 
 52 
 53 HLIST_HEAD(ax25_list);
 54 DEFINE_SPINLOCK(ax25_list_lock);
 55 
 56 static const struct proto_ops ax25_proto_ops;
 57 
 58 static void ax25_free_sock(struct sock *sk)
 59 {
 60         ax25_cb_put(sk_to_ax25(sk));
 61 }
 62 
 63 /*
 64  *      Socket removal during an interrupt is now safe.
 65  */
 66 static void ax25_cb_del(ax25_cb *ax25)
 67 {
 68         if (!hlist_unhashed(&ax25->ax25_node)) {
 69                 spin_lock_bh(&ax25_list_lock);
 70                 hlist_del_init(&ax25->ax25_node);
 71                 spin_unlock_bh(&ax25_list_lock);
 72                 ax25_cb_put(ax25);
 73         }
 74 }
 75 
 76 /*
 77  *      Kill all bound sockets on a dropped device.
 78  */
 79 static void ax25_kill_by_device(struct net_device *dev)
 80 {
 81         ax25_dev *ax25_dev;
 82         ax25_cb *s;
 83 
 84         if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
 85                 return;
 86 
 87         spin_lock_bh(&ax25_list_lock);
 88 again:
 89         ax25_for_each(s, &ax25_list) {
 90                 if (s->ax25_dev == ax25_dev) {
 91                         s->ax25_dev = NULL;
 92                         spin_unlock_bh(&ax25_list_lock);
 93                         ax25_disconnect(s, ENETUNREACH);
 94                         spin_lock_bh(&ax25_list_lock);
 95 
 96                         /* The entry could have been deleted from the
 97                          * list meanwhile and thus the next pointer is
 98                          * no longer valid.  Play it safe and restart
 99                          * the scan.  Forward progress is ensured
100                          * because we set s->ax25_dev to NULL and we
101                          * are never passed a NULL 'dev' argument.
102                          */
103                         goto again;
104                 }
105         }
106         spin_unlock_bh(&ax25_list_lock);
107 }
108 
109 /*
110  *      Handle device status changes.
111  */
112 static int ax25_device_event(struct notifier_block *this, unsigned long event,
113                              void *ptr)
114 {
115         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
116 
117         if (!net_eq(dev_net(dev), &init_net))
118                 return NOTIFY_DONE;
119 
120         /* Reject non AX.25 devices */
121         if (dev->type != ARPHRD_AX25)
122                 return NOTIFY_DONE;
123 
124         switch (event) {
125         case NETDEV_UP:
126                 ax25_dev_device_up(dev);
127                 break;
128         case NETDEV_DOWN:
129                 ax25_kill_by_device(dev);
130                 ax25_rt_device_down(dev);
131                 ax25_dev_device_down(dev);
132                 break;
133         default:
134                 break;
135         }
136 
137         return NOTIFY_DONE;
138 }
139 
140 /*
141  *      Add a socket to the bound sockets list.
142  */
143 void ax25_cb_add(ax25_cb *ax25)
144 {
145         spin_lock_bh(&ax25_list_lock);
146         ax25_cb_hold(ax25);
147         hlist_add_head(&ax25->ax25_node, &ax25_list);
148         spin_unlock_bh(&ax25_list_lock);
149 }
150 
151 /*
152  *      Find a socket that wants to accept the SABM we have just
153  *      received.
154  */
155 struct sock *ax25_find_listener(ax25_address *addr, int digi,
156         struct net_device *dev, int type)
157 {
158         ax25_cb *s;
159 
160         spin_lock(&ax25_list_lock);
161         ax25_for_each(s, &ax25_list) {
162                 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
163                         continue;
164                 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
165                     s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
166                         /* If device is null we match any device */
167                         if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
168                                 sock_hold(s->sk);
169                                 spin_unlock(&ax25_list_lock);
170                                 return s->sk;
171                         }
172                 }
173         }
174         spin_unlock(&ax25_list_lock);
175 
176         return NULL;
177 }
178 
179 /*
180  *      Find an AX.25 socket given both ends.
181  */
182 struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
183         int type)
184 {
185         struct sock *sk = NULL;
186         ax25_cb *s;
187 
188         spin_lock(&ax25_list_lock);
189         ax25_for_each(s, &ax25_list) {
190                 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
191                     !ax25cmp(&s->dest_addr, dest_addr) &&
192                     s->sk->sk_type == type) {
193                         sk = s->sk;
194                         sock_hold(sk);
195                         break;
196                 }
197         }
198 
199         spin_unlock(&ax25_list_lock);
200 
201         return sk;
202 }
203 
204 /*
205  *      Find an AX.25 control block given both ends. It will only pick up
206  *      floating AX.25 control blocks or non Raw socket bound control blocks.
207  */
208 ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
209         ax25_digi *digi, struct net_device *dev)
210 {
211         ax25_cb *s;
212 
213         spin_lock_bh(&ax25_list_lock);
214         ax25_for_each(s, &ax25_list) {
215                 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
216                         continue;
217                 if (s->ax25_dev == NULL)
218                         continue;
219                 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
220                         if (digi != NULL && digi->ndigi != 0) {
221                                 if (s->digipeat == NULL)
222                                         continue;
223                                 if (ax25digicmp(s->digipeat, digi) != 0)
224                                         continue;
225                         } else {
226                                 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
227                                         continue;
228                         }
229                         ax25_cb_hold(s);
230                         spin_unlock_bh(&ax25_list_lock);
231 
232                         return s;
233                 }
234         }
235         spin_unlock_bh(&ax25_list_lock);
236 
237         return NULL;
238 }
239 
240 EXPORT_SYMBOL(ax25_find_cb);
241 
242 void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
243 {
244         ax25_cb *s;
245         struct sk_buff *copy;
246 
247         spin_lock(&ax25_list_lock);
248         ax25_for_each(s, &ax25_list) {
249                 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
250                     s->sk->sk_type == SOCK_RAW &&
251                     s->sk->sk_protocol == proto &&
252                     s->ax25_dev->dev == skb->dev &&
253                     atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
254                         if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
255                                 continue;
256                         if (sock_queue_rcv_skb(s->sk, copy) != 0)
257                                 kfree_skb(copy);
258                 }
259         }
260         spin_unlock(&ax25_list_lock);
261 }
262 
263 /*
264  *      Deferred destroy.
265  */
266 void ax25_destroy_socket(ax25_cb *);
267 
268 /*
269  *      Handler for deferred kills.
270  */
271 static void ax25_destroy_timer(struct timer_list *t)
272 {
273         ax25_cb *ax25 = from_timer(ax25, t, dtimer);
274         struct sock *sk;
275 
276         sk=ax25->sk;
277 
278         bh_lock_sock(sk);
279         sock_hold(sk);
280         ax25_destroy_socket(ax25);
281         bh_unlock_sock(sk);
282         sock_put(sk);
283 }
284 
285 /*
286  *      This is called from user mode and the timers. Thus it protects itself
287  *      against interrupt users but doesn't worry about being called during
288  *      work. Once it is removed from the queue no interrupt or bottom half
289  *      will touch it and we are (fairly 8-) ) safe.
290  */
291 void ax25_destroy_socket(ax25_cb *ax25)
292 {
293         struct sk_buff *skb;
294 
295         ax25_cb_del(ax25);
296 
297         ax25_stop_heartbeat(ax25);
298         ax25_stop_t1timer(ax25);
299         ax25_stop_t2timer(ax25);
300         ax25_stop_t3timer(ax25);
301         ax25_stop_idletimer(ax25);
302 
303         ax25_clear_queues(ax25);        /* Flush the queues */
304 
305         if (ax25->sk != NULL) {
306                 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
307                         if (skb->sk != ax25->sk) {
308                                 /* A pending connection */
309                                 ax25_cb *sax25 = sk_to_ax25(skb->sk);
310 
311                                 /* Queue the unaccepted socket for death */
312                                 sock_orphan(skb->sk);
313 
314                                 /* 9A4GL: hack to release unaccepted sockets */
315                                 skb->sk->sk_state = TCP_LISTEN;
316 
317                                 ax25_start_heartbeat(sax25);
318                                 sax25->state = AX25_STATE_0;
319                         }
320 
321                         kfree_skb(skb);
322                 }
323                 skb_queue_purge(&ax25->sk->sk_write_queue);
324         }
325 
326         if (ax25->sk != NULL) {
327                 if (sk_has_allocations(ax25->sk)) {
328                         /* Defer: outstanding buffers */
329                         timer_setup(&ax25->dtimer, ax25_destroy_timer, 0);
330                         ax25->dtimer.expires  = jiffies + 2 * HZ;
331                         add_timer(&ax25->dtimer);
332                 } else {
333                         struct sock *sk=ax25->sk;
334                         ax25->sk=NULL;
335                         sock_put(sk);
336                 }
337         } else {
338                 ax25_cb_put(ax25);
339         }
340 }
341 
342 /*
343  * dl1bke 960311: set parameters for existing AX.25 connections,
344  *                includes a KILL command to abort any connection.
345  *                VERY useful for debugging ;-)
346  */
347 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
348 {
349         struct ax25_ctl_struct ax25_ctl;
350         ax25_digi digi;
351         ax25_dev *ax25_dev;
352         ax25_cb *ax25;
353         unsigned int k;
354         int ret = 0;
355 
356         if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
357                 return -EFAULT;
358 
359         if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
360                 return -ENODEV;
361 
362         if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
363                 return -EINVAL;
364 
365         if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
366                 return -EINVAL;
367 
368         digi.ndigi = ax25_ctl.digi_count;
369         for (k = 0; k < digi.ndigi; k++)
370                 digi.calls[k] = ax25_ctl.digi_addr[k];
371 
372         if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
373                 return -ENOTCONN;
374 
375         switch (ax25_ctl.cmd) {
376         case AX25_KILL:
377                 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
378 #ifdef CONFIG_AX25_DAMA_SLAVE
379                 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
380                         ax25_dama_off(ax25);
381 #endif
382                 ax25_disconnect(ax25, ENETRESET);
383                 break;
384 
385         case AX25_WINDOW:
386                 if (ax25->modulus == AX25_MODULUS) {
387                         if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
388                                 goto einval_put;
389                 } else {
390                         if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
391                                 goto einval_put;
392                 }
393                 ax25->window = ax25_ctl.arg;
394                 break;
395 
396         case AX25_T1:
397                 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
398                         goto einval_put;
399                 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
400                 ax25->t1  = ax25_ctl.arg * HZ;
401                 break;
402 
403         case AX25_T2:
404                 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
405                         goto einval_put;
406                 ax25->t2 = ax25_ctl.arg * HZ;
407                 break;
408 
409         case AX25_N2:
410                 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
411                         goto einval_put;
412                 ax25->n2count = 0;
413                 ax25->n2 = ax25_ctl.arg;
414                 break;
415 
416         case AX25_T3:
417                 if (ax25_ctl.arg > ULONG_MAX / HZ)
418                         goto einval_put;
419                 ax25->t3 = ax25_ctl.arg * HZ;
420                 break;
421 
422         case AX25_IDLE:
423                 if (ax25_ctl.arg > ULONG_MAX / (60 * HZ))
424                         goto einval_put;
425 
426                 ax25->idle = ax25_ctl.arg * 60 * HZ;
427                 break;
428 
429         case AX25_PACLEN:
430                 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
431                         goto einval_put;
432                 ax25->paclen = ax25_ctl.arg;
433                 break;
434 
435         default:
436                 goto einval_put;
437           }
438 
439 out_put:
440         ax25_cb_put(ax25);
441         return ret;
442 
443 einval_put:
444         ret = -EINVAL;
445         goto out_put;
446 }
447 
448 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
449 {
450         ax25->rtt     = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
451         ax25->t1      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
452         ax25->t2      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
453         ax25->t3      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
454         ax25->n2      = ax25_dev->values[AX25_VALUES_N2];
455         ax25->paclen  = ax25_dev->values[AX25_VALUES_PACLEN];
456         ax25->idle    = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
457         ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
458 
459         if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
460                 ax25->modulus = AX25_EMODULUS;
461                 ax25->window  = ax25_dev->values[AX25_VALUES_EWINDOW];
462         } else {
463                 ax25->modulus = AX25_MODULUS;
464                 ax25->window  = ax25_dev->values[AX25_VALUES_WINDOW];
465         }
466 }
467 
468 /*
469  *      Fill in a created AX.25 created control block with the default
470  *      values for a particular device.
471  */
472 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
473 {
474         ax25->ax25_dev = ax25_dev;
475 
476         if (ax25->ax25_dev != NULL) {
477                 ax25_fillin_cb_from_dev(ax25, ax25_dev);
478                 return;
479         }
480 
481         /*
482          * No device, use kernel / AX.25 spec default values
483          */
484         ax25->rtt     = msecs_to_jiffies(AX25_DEF_T1) / 2;
485         ax25->t1      = msecs_to_jiffies(AX25_DEF_T1);
486         ax25->t2      = msecs_to_jiffies(AX25_DEF_T2);
487         ax25->t3      = msecs_to_jiffies(AX25_DEF_T3);
488         ax25->n2      = AX25_DEF_N2;
489         ax25->paclen  = AX25_DEF_PACLEN;
490         ax25->idle    = msecs_to_jiffies(AX25_DEF_IDLE);
491         ax25->backoff = AX25_DEF_BACKOFF;
492 
493         if (AX25_DEF_AXDEFMODE) {
494                 ax25->modulus = AX25_EMODULUS;
495                 ax25->window  = AX25_DEF_EWINDOW;
496         } else {
497                 ax25->modulus = AX25_MODULUS;
498                 ax25->window  = AX25_DEF_WINDOW;
499         }
500 }
501 
502 /*
503  * Create an empty AX.25 control block.
504  */
505 ax25_cb *ax25_create_cb(void)
506 {
507         ax25_cb *ax25;
508 
509         if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
510                 return NULL;
511 
512         refcount_set(&ax25->refcount, 1);
513 
514         skb_queue_head_init(&ax25->write_queue);
515         skb_queue_head_init(&ax25->frag_queue);
516         skb_queue_head_init(&ax25->ack_queue);
517         skb_queue_head_init(&ax25->reseq_queue);
518 
519         ax25_setup_timers(ax25);
520 
521         ax25_fillin_cb(ax25, NULL);
522 
523         ax25->state = AX25_STATE_0;
524 
525         return ax25;
526 }
527 
528 /*
529  *      Handling for system calls applied via the various interfaces to an
530  *      AX25 socket object
531  */
532 
533 static int ax25_setsockopt(struct socket *sock, int level, int optname,
534         char __user *optval, unsigned int optlen)
535 {
536         struct sock *sk = sock->sk;
537         ax25_cb *ax25;
538         struct net_device *dev;
539         char devname[IFNAMSIZ];
540         unsigned long opt;
541         int res = 0;
542 
543         if (level != SOL_AX25)
544                 return -ENOPROTOOPT;
545 
546         if (optlen < sizeof(unsigned int))
547                 return -EINVAL;
548 
549         if (get_user(opt, (unsigned int __user *)optval))
550                 return -EFAULT;
551 
552         lock_sock(sk);
553         ax25 = sk_to_ax25(sk);
554 
555         switch (optname) {
556         case AX25_WINDOW:
557                 if (ax25->modulus == AX25_MODULUS) {
558                         if (opt < 1 || opt > 7) {
559                                 res = -EINVAL;
560                                 break;
561                         }
562                 } else {
563                         if (opt < 1 || opt > 63) {
564                                 res = -EINVAL;
565                                 break;
566                         }
567                 }
568                 ax25->window = opt;
569                 break;
570 
571         case AX25_T1:
572                 if (opt < 1 || opt > ULONG_MAX / HZ) {
573                         res = -EINVAL;
574                         break;
575                 }
576                 ax25->rtt = (opt * HZ) >> 1;
577                 ax25->t1  = opt * HZ;
578                 break;
579 
580         case AX25_T2:
581                 if (opt < 1 || opt > ULONG_MAX / HZ) {
582                         res = -EINVAL;
583                         break;
584                 }
585                 ax25->t2 = opt * HZ;
586                 break;
587 
588         case AX25_N2:
589                 if (opt < 1 || opt > 31) {
590                         res = -EINVAL;
591                         break;
592                 }
593                 ax25->n2 = opt;
594                 break;
595 
596         case AX25_T3:
597                 if (opt < 1 || opt > ULONG_MAX / HZ) {
598                         res = -EINVAL;
599                         break;
600                 }
601                 ax25->t3 = opt * HZ;
602                 break;
603 
604         case AX25_IDLE:
605                 if (opt > ULONG_MAX / (60 * HZ)) {
606                         res = -EINVAL;
607                         break;
608                 }
609                 ax25->idle = opt * 60 * HZ;
610                 break;
611 
612         case AX25_BACKOFF:
613                 if (opt > 2) {
614                         res = -EINVAL;
615                         break;
616                 }
617                 ax25->backoff = opt;
618                 break;
619 
620         case AX25_EXTSEQ:
621                 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
622                 break;
623 
624         case AX25_PIDINCL:
625                 ax25->pidincl = opt ? 1 : 0;
626                 break;
627 
628         case AX25_IAMDIGI:
629                 ax25->iamdigi = opt ? 1 : 0;
630                 break;
631 
632         case AX25_PACLEN:
633                 if (opt < 16 || opt > 65535) {
634                         res = -EINVAL;
635                         break;
636                 }
637                 ax25->paclen = opt;
638                 break;
639 
640         case SO_BINDTODEVICE:
641                 if (optlen > IFNAMSIZ)
642                         optlen = IFNAMSIZ;
643 
644                 if (copy_from_user(devname, optval, optlen)) {
645                         res = -EFAULT;
646                         break;
647                 }
648 
649                 if (sk->sk_type == SOCK_SEQPACKET &&
650                    (sock->state != SS_UNCONNECTED ||
651                     sk->sk_state == TCP_LISTEN)) {
652                         res = -EADDRNOTAVAIL;
653                         break;
654                 }
655 
656                 rtnl_lock();
657                 dev = __dev_get_by_name(&init_net, devname);
658                 if (!dev) {
659                         rtnl_unlock();
660                         res = -ENODEV;
661                         break;
662                 }
663 
664                 ax25->ax25_dev = ax25_dev_ax25dev(dev);
665                 if (!ax25->ax25_dev) {
666                         rtnl_unlock();
667                         res = -ENODEV;
668                         break;
669                 }
670                 ax25_fillin_cb(ax25, ax25->ax25_dev);
671                 rtnl_unlock();
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 = sk_to_ax25(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 ax25_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 (protocol < 0 || protocol > SK_PROTOCOL_MAX)
815                 return -EINVAL;
816 
817         if (!net_eq(net, &init_net))
818                 return -EAFNOSUPPORT;
819 
820         switch (sock->type) {
821         case SOCK_DGRAM:
822                 if (protocol == 0 || protocol == PF_AX25)
823                         protocol = AX25_P_TEXT;
824                 break;
825 
826         case SOCK_SEQPACKET:
827                 switch (protocol) {
828                 case 0:
829                 case PF_AX25:   /* For CLX */
830                         protocol = AX25_P_TEXT;
831                         break;
832                 case AX25_P_SEGMENT:
833 #ifdef CONFIG_INET
834                 case AX25_P_ARP:
835                 case AX25_P_IP:
836 #endif
837 #ifdef CONFIG_NETROM
838                 case AX25_P_NETROM:
839 #endif
840 #ifdef CONFIG_ROSE
841                 case AX25_P_ROSE:
842 #endif
843                         return -ESOCKTNOSUPPORT;
844 #ifdef CONFIG_NETROM_MODULE
845                 case AX25_P_NETROM:
846                         if (ax25_protocol_is_registered(AX25_P_NETROM))
847                                 return -ESOCKTNOSUPPORT;
848                         break;
849 #endif
850 #ifdef CONFIG_ROSE_MODULE
851                 case AX25_P_ROSE:
852                         if (ax25_protocol_is_registered(AX25_P_ROSE))
853                                 return -ESOCKTNOSUPPORT;
854 #endif
855                 default:
856                         break;
857                 }
858                 break;
859 
860         case SOCK_RAW:
861                 break;
862         default:
863                 return -ESOCKTNOSUPPORT;
864         }
865 
866         sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto, kern);
867         if (sk == NULL)
868                 return -ENOMEM;
869 
870         ax25 = ax25_sk(sk)->cb = ax25_create_cb();
871         if (!ax25) {
872                 sk_free(sk);
873                 return -ENOMEM;
874         }
875 
876         sock_init_data(sock, sk);
877 
878         sk->sk_destruct = ax25_free_sock;
879         sock->ops    = &ax25_proto_ops;
880         sk->sk_protocol = protocol;
881 
882         ax25->sk    = sk;
883 
884         return 0;
885 }
886 
887 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
888 {
889         struct sock *sk;
890         ax25_cb *ax25, *oax25;
891 
892         sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot, 0);
893         if (sk == NULL)
894                 return NULL;
895 
896         if ((ax25 = ax25_create_cb()) == NULL) {
897                 sk_free(sk);
898                 return NULL;
899         }
900 
901         switch (osk->sk_type) {
902         case SOCK_DGRAM:
903                 break;
904         case SOCK_SEQPACKET:
905                 break;
906         default:
907                 sk_free(sk);
908                 ax25_cb_put(ax25);
909                 return NULL;
910         }
911 
912         sock_init_data(NULL, sk);
913 
914         sk->sk_type     = osk->sk_type;
915         sk->sk_priority = osk->sk_priority;
916         sk->sk_protocol = osk->sk_protocol;
917         sk->sk_rcvbuf   = osk->sk_rcvbuf;
918         sk->sk_sndbuf   = osk->sk_sndbuf;
919         sk->sk_state    = TCP_ESTABLISHED;
920         sock_copy_flags(sk, osk);
921 
922         oax25 = sk_to_ax25(osk);
923 
924         ax25->modulus = oax25->modulus;
925         ax25->backoff = oax25->backoff;
926         ax25->pidincl = oax25->pidincl;
927         ax25->iamdigi = oax25->iamdigi;
928         ax25->rtt     = oax25->rtt;
929         ax25->t1      = oax25->t1;
930         ax25->t2      = oax25->t2;
931         ax25->t3      = oax25->t3;
932         ax25->n2      = oax25->n2;
933         ax25->idle    = oax25->idle;
934         ax25->paclen  = oax25->paclen;
935         ax25->window  = oax25->window;
936 
937         ax25->ax25_dev    = ax25_dev;
938         ax25->source_addr = oax25->source_addr;
939 
940         if (oax25->digipeat != NULL) {
941                 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
942                                          GFP_ATOMIC);
943                 if (ax25->digipeat == NULL) {
944                         sk_free(sk);
945                         ax25_cb_put(ax25);
946                         return NULL;
947                 }
948         }
949 
950         ax25_sk(sk)->cb = ax25;
951         sk->sk_destruct = ax25_free_sock;
952         ax25->sk    = sk;
953 
954         return sk;
955 }
956 
957 static int ax25_release(struct socket *sock)
958 {
959         struct sock *sk = sock->sk;
960         ax25_cb *ax25;
961 
962         if (sk == NULL)
963                 return 0;
964 
965         sock_hold(sk);
966         sock_orphan(sk);
967         lock_sock(sk);
968         ax25 = sk_to_ax25(sk);
969 
970         if (sk->sk_type == SOCK_SEQPACKET) {
971                 switch (ax25->state) {
972                 case AX25_STATE_0:
973                         release_sock(sk);
974                         ax25_disconnect(ax25, 0);
975                         lock_sock(sk);
976                         ax25_destroy_socket(ax25);
977                         break;
978 
979                 case AX25_STATE_1:
980                 case AX25_STATE_2:
981                         ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
982                         release_sock(sk);
983                         ax25_disconnect(ax25, 0);
984                         lock_sock(sk);
985                         if (!sock_flag(ax25->sk, SOCK_DESTROY))
986                                 ax25_destroy_socket(ax25);
987                         break;
988 
989                 case AX25_STATE_3:
990                 case AX25_STATE_4:
991                         ax25_clear_queues(ax25);
992                         ax25->n2count = 0;
993 
994                         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
995                         case AX25_PROTO_STD_SIMPLEX:
996                         case AX25_PROTO_STD_DUPLEX:
997                                 ax25_send_control(ax25,
998                                                   AX25_DISC,
999                                                   AX25_POLLON,
1000                                                   AX25_COMMAND);
1001                                 ax25_stop_t2timer(ax25);
1002                                 ax25_stop_t3timer(ax25);
1003                                 ax25_stop_idletimer(ax25);
1004                                 break;
1005 #ifdef CONFIG_AX25_DAMA_SLAVE
1006                         case AX25_PROTO_DAMA_SLAVE:
1007                                 ax25_stop_t3timer(ax25);
1008                                 ax25_stop_idletimer(ax25);
1009                                 break;
1010 #endif
1011                         }
1012                         ax25_calculate_t1(ax25);
1013                         ax25_start_t1timer(ax25);
1014                         ax25->state = AX25_STATE_2;
1015                         sk->sk_state                = TCP_CLOSE;
1016                         sk->sk_shutdown            |= SEND_SHUTDOWN;
1017                         sk->sk_state_change(sk);
1018                         sock_set_flag(sk, SOCK_DESTROY);
1019                         break;
1020 
1021                 default:
1022                         break;
1023                 }
1024         } else {
1025                 sk->sk_state     = TCP_CLOSE;
1026                 sk->sk_shutdown |= SEND_SHUTDOWN;
1027                 sk->sk_state_change(sk);
1028                 ax25_destroy_socket(ax25);
1029         }
1030 
1031         sock->sk   = NULL;
1032         release_sock(sk);
1033         sock_put(sk);
1034 
1035         return 0;
1036 }
1037 
1038 /*
1039  *      We support a funny extension here so you can (as root) give any callsign
1040  *      digipeated via a local address as source. This hack is obsolete now
1041  *      that we've implemented support for SO_BINDTODEVICE. It is however small
1042  *      and trivially backward compatible.
1043  */
1044 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1045 {
1046         struct sock *sk = sock->sk;
1047         struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1048         ax25_dev *ax25_dev = NULL;
1049         ax25_uid_assoc *user;
1050         ax25_address call;
1051         ax25_cb *ax25;
1052         int err = 0;
1053 
1054         if (addr_len != sizeof(struct sockaddr_ax25) &&
1055             addr_len != sizeof(struct full_sockaddr_ax25))
1056                 /* support for old structure may go away some time
1057                  * ax25_bind(): uses old (6 digipeater) socket structure.
1058                  */
1059                 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1060                     (addr_len > sizeof(struct full_sockaddr_ax25)))
1061                         return -EINVAL;
1062 
1063         if (addr->fsa_ax25.sax25_family != AF_AX25)
1064                 return -EINVAL;
1065 
1066         user = ax25_findbyuid(current_euid());
1067         if (user) {
1068                 call = user->call;
1069                 ax25_uid_put(user);
1070         } else {
1071                 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1072                         return -EACCES;
1073 
1074                 call = addr->fsa_ax25.sax25_call;
1075         }
1076 
1077         lock_sock(sk);
1078 
1079         ax25 = sk_to_ax25(sk);
1080         if (!sock_flag(sk, SOCK_ZAPPED)) {
1081                 err = -EINVAL;
1082                 goto out;
1083         }
1084 
1085         ax25->source_addr = call;
1086 
1087         /*
1088          * User already set interface with SO_BINDTODEVICE
1089          */
1090         if (ax25->ax25_dev != NULL)
1091                 goto done;
1092 
1093         if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1094                 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1095                     (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1096                         err = -EADDRNOTAVAIL;
1097                         goto out;
1098                 }
1099         } else {
1100                 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1101                         err = -EADDRNOTAVAIL;
1102                         goto out;
1103                 }
1104         }
1105 
1106         if (ax25_dev != NULL)
1107                 ax25_fillin_cb(ax25, ax25_dev);
1108 
1109 done:
1110         ax25_cb_add(ax25);
1111         sock_reset_flag(sk, SOCK_ZAPPED);
1112 
1113 out:
1114         release_sock(sk);
1115 
1116         return err;
1117 }
1118 
1119 /*
1120  *      FIXME: nonblock behaviour looks like it may have a bug.
1121  */
1122 static int __must_check ax25_connect(struct socket *sock,
1123         struct sockaddr *uaddr, int addr_len, int flags)
1124 {
1125         struct sock *sk = sock->sk;
1126         ax25_cb *ax25 = sk_to_ax25(sk), *ax25t;
1127         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1128         ax25_digi *digi = NULL;
1129         int ct = 0, err = 0;
1130 
1131         /*
1132          * some sanity checks. code further down depends on this
1133          */
1134 
1135         if (addr_len == sizeof(struct sockaddr_ax25))
1136                 /* support for this will go away in early 2.5.x
1137                  * ax25_connect(): uses obsolete socket structure
1138                  */
1139                 ;
1140         else if (addr_len != sizeof(struct full_sockaddr_ax25))
1141                 /* support for old structure may go away some time
1142                  * ax25_connect(): uses old (6 digipeater) socket structure.
1143                  */
1144                 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1145                     (addr_len > sizeof(struct full_sockaddr_ax25)))
1146                         return -EINVAL;
1147 
1148 
1149         if (fsa->fsa_ax25.sax25_family != AF_AX25)
1150                 return -EINVAL;
1151 
1152         lock_sock(sk);
1153 
1154         /* deal with restarts */
1155         if (sock->state == SS_CONNECTING) {
1156                 switch (sk->sk_state) {
1157                 case TCP_SYN_SENT: /* still trying */
1158                         err = -EINPROGRESS;
1159                         goto out_release;
1160 
1161                 case TCP_ESTABLISHED: /* connection established */
1162                         sock->state = SS_CONNECTED;
1163                         goto out_release;
1164 
1165                 case TCP_CLOSE: /* connection refused */
1166                         sock->state = SS_UNCONNECTED;
1167                         err = -ECONNREFUSED;
1168                         goto out_release;
1169                 }
1170         }
1171 
1172         if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1173                 err = -EISCONN; /* No reconnect on a seqpacket socket */
1174                 goto out_release;
1175         }
1176 
1177         sk->sk_state   = TCP_CLOSE;
1178         sock->state = SS_UNCONNECTED;
1179 
1180         kfree(ax25->digipeat);
1181         ax25->digipeat = NULL;
1182 
1183         /*
1184          *      Handle digi-peaters to be used.
1185          */
1186         if (addr_len > sizeof(struct sockaddr_ax25) &&
1187             fsa->fsa_ax25.sax25_ndigis != 0) {
1188                 /* Valid number of digipeaters ? */
1189                 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1190                         err = -EINVAL;
1191                         goto out_release;
1192                 }
1193 
1194                 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1195                         err = -ENOBUFS;
1196                         goto out_release;
1197                 }
1198 
1199                 digi->ndigi      = fsa->fsa_ax25.sax25_ndigis;
1200                 digi->lastrepeat = -1;
1201 
1202                 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1203                         if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1204                              AX25_HBIT) && ax25->iamdigi) {
1205                                 digi->repeated[ct] = 1;
1206                                 digi->lastrepeat   = ct;
1207                         } else {
1208                                 digi->repeated[ct] = 0;
1209                         }
1210                         digi->calls[ct] = fsa->fsa_digipeater[ct];
1211                         ct++;
1212                 }
1213         }
1214 
1215         /*
1216          *      Must bind first - autobinding in this may or may not work. If
1217          *      the socket is already bound, check to see if the device has
1218          *      been filled in, error if it hasn't.
1219          */
1220         if (sock_flag(sk, SOCK_ZAPPED)) {
1221                 /* check if we can remove this feature. It is broken. */
1222                 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1223                         current->comm);
1224                 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1225                         kfree(digi);
1226                         goto out_release;
1227                 }
1228 
1229                 ax25_fillin_cb(ax25, ax25->ax25_dev);
1230                 ax25_cb_add(ax25);
1231         } else {
1232                 if (ax25->ax25_dev == NULL) {
1233                         kfree(digi);
1234                         err = -EHOSTUNREACH;
1235                         goto out_release;
1236                 }
1237         }
1238 
1239         if (sk->sk_type == SOCK_SEQPACKET &&
1240             (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1241                          ax25->ax25_dev->dev))) {
1242                 kfree(digi);
1243                 err = -EADDRINUSE;              /* Already such a connection */
1244                 ax25_cb_put(ax25t);
1245                 goto out_release;
1246         }
1247 
1248         ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1249         ax25->digipeat  = digi;
1250 
1251         /* First the easy one */
1252         if (sk->sk_type != SOCK_SEQPACKET) {
1253                 sock->state = SS_CONNECTED;
1254                 sk->sk_state   = TCP_ESTABLISHED;
1255                 goto out_release;
1256         }
1257 
1258         /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1259         sock->state        = SS_CONNECTING;
1260         sk->sk_state          = TCP_SYN_SENT;
1261 
1262         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1263         case AX25_PROTO_STD_SIMPLEX:
1264         case AX25_PROTO_STD_DUPLEX:
1265                 ax25_std_establish_data_link(ax25);
1266                 break;
1267 
1268 #ifdef CONFIG_AX25_DAMA_SLAVE
1269         case AX25_PROTO_DAMA_SLAVE:
1270                 ax25->modulus = AX25_MODULUS;
1271                 ax25->window  = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1272                 if (ax25->ax25_dev->dama.slave)
1273                         ax25_ds_establish_data_link(ax25);
1274                 else
1275                         ax25_std_establish_data_link(ax25);
1276                 break;
1277 #endif
1278         }
1279 
1280         ax25->state = AX25_STATE_1;
1281 
1282         ax25_start_heartbeat(ax25);
1283 
1284         /* Now the loop */
1285         if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1286                 err = -EINPROGRESS;
1287                 goto out_release;
1288         }
1289 
1290         if (sk->sk_state == TCP_SYN_SENT) {
1291                 DEFINE_WAIT(wait);
1292 
1293                 for (;;) {
1294                         prepare_to_wait(sk_sleep(sk), &wait,
1295                                         TASK_INTERRUPTIBLE);
1296                         if (sk->sk_state != TCP_SYN_SENT)
1297                                 break;
1298                         if (!signal_pending(current)) {
1299                                 release_sock(sk);
1300                                 schedule();
1301                                 lock_sock(sk);
1302                                 continue;
1303                         }
1304                         err = -ERESTARTSYS;
1305                         break;
1306                 }
1307                 finish_wait(sk_sleep(sk), &wait);
1308 
1309                 if (err)
1310                         goto out_release;
1311         }
1312 
1313         if (sk->sk_state != TCP_ESTABLISHED) {
1314                 /* Not in ABM, not in WAIT_UA -> failed */
1315                 sock->state = SS_UNCONNECTED;
1316                 err = sock_error(sk);   /* Always set at this point */
1317                 goto out_release;
1318         }
1319 
1320         sock->state = SS_CONNECTED;
1321 
1322         err = 0;
1323 out_release:
1324         release_sock(sk);
1325 
1326         return err;
1327 }
1328 
1329 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags,
1330                        bool kern)
1331 {
1332         struct sk_buff *skb;
1333         struct sock *newsk;
1334         DEFINE_WAIT(wait);
1335         struct sock *sk;
1336         int err = 0;
1337 
1338         if (sock->state != SS_UNCONNECTED)
1339                 return -EINVAL;
1340 
1341         if ((sk = sock->sk) == NULL)
1342                 return -EINVAL;
1343 
1344         lock_sock(sk);
1345         if (sk->sk_type != SOCK_SEQPACKET) {
1346                 err = -EOPNOTSUPP;
1347                 goto out;
1348         }
1349 
1350         if (sk->sk_state != TCP_LISTEN) {
1351                 err = -EINVAL;
1352                 goto out;
1353         }
1354 
1355         /*
1356          *      The read queue this time is holding sockets ready to use
1357          *      hooked into the SABM we saved
1358          */
1359         for (;;) {
1360                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1361                 skb = skb_dequeue(&sk->sk_receive_queue);
1362                 if (skb)
1363                         break;
1364 
1365                 if (flags & O_NONBLOCK) {
1366                         err = -EWOULDBLOCK;
1367                         break;
1368                 }
1369                 if (!signal_pending(current)) {
1370                         release_sock(sk);
1371                         schedule();
1372                         lock_sock(sk);
1373                         continue;
1374                 }
1375                 err = -ERESTARTSYS;
1376                 break;
1377         }
1378         finish_wait(sk_sleep(sk), &wait);
1379 
1380         if (err)
1381                 goto out;
1382 
1383         newsk            = skb->sk;
1384         sock_graft(newsk, newsock);
1385 
1386         /* Now attach up the new socket */
1387         kfree_skb(skb);
1388         sk->sk_ack_backlog--;
1389         newsock->state = SS_CONNECTED;
1390 
1391 out:
1392         release_sock(sk);
1393 
1394         return err;
1395 }
1396 
1397 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1398         int peer)
1399 {
1400         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1401         struct sock *sk = sock->sk;
1402         unsigned char ndigi, i;
1403         ax25_cb *ax25;
1404         int err = 0;
1405 
1406         memset(fsa, 0, sizeof(*fsa));
1407         lock_sock(sk);
1408         ax25 = sk_to_ax25(sk);
1409 
1410         if (peer != 0) {
1411                 if (sk->sk_state != TCP_ESTABLISHED) {
1412                         err = -ENOTCONN;
1413                         goto out;
1414                 }
1415 
1416                 fsa->fsa_ax25.sax25_family = AF_AX25;
1417                 fsa->fsa_ax25.sax25_call   = ax25->dest_addr;
1418 
1419                 if (ax25->digipeat != NULL) {
1420                         ndigi = ax25->digipeat->ndigi;
1421                         fsa->fsa_ax25.sax25_ndigis = ndigi;
1422                         for (i = 0; i < ndigi; i++)
1423                                 fsa->fsa_digipeater[i] =
1424                                                 ax25->digipeat->calls[i];
1425                 }
1426         } else {
1427                 fsa->fsa_ax25.sax25_family = AF_AX25;
1428                 fsa->fsa_ax25.sax25_call   = ax25->source_addr;
1429                 fsa->fsa_ax25.sax25_ndigis = 1;
1430                 if (ax25->ax25_dev != NULL) {
1431                         memcpy(&fsa->fsa_digipeater[0],
1432                                ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1433                 } else {
1434                         fsa->fsa_digipeater[0] = null_ax25_address;
1435                 }
1436         }
1437         err = sizeof (struct full_sockaddr_ax25);
1438 
1439 out:
1440         release_sock(sk);
1441 
1442         return err;
1443 }
1444 
1445 static int ax25_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1446 {
1447         DECLARE_SOCKADDR(struct sockaddr_ax25 *, usax, msg->msg_name);
1448         struct sock *sk = sock->sk;
1449         struct sockaddr_ax25 sax;
1450         struct sk_buff *skb;
1451         ax25_digi dtmp, *dp;
1452         ax25_cb *ax25;
1453         size_t size;
1454         int lv, err, addr_len = msg->msg_namelen;
1455 
1456         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1457                 return -EINVAL;
1458 
1459         lock_sock(sk);
1460         ax25 = sk_to_ax25(sk);
1461 
1462         if (sock_flag(sk, SOCK_ZAPPED)) {
1463                 err = -EADDRNOTAVAIL;
1464                 goto out;
1465         }
1466 
1467         if (sk->sk_shutdown & SEND_SHUTDOWN) {
1468                 send_sig(SIGPIPE, current, 0);
1469                 err = -EPIPE;
1470                 goto out;
1471         }
1472 
1473         if (ax25->ax25_dev == NULL) {
1474                 err = -ENETUNREACH;
1475                 goto out;
1476         }
1477 
1478         if (len > ax25->ax25_dev->dev->mtu) {
1479                 err = -EMSGSIZE;
1480                 goto out;
1481         }
1482 
1483         if (usax != NULL) {
1484                 if (usax->sax25_family != AF_AX25) {
1485                         err = -EINVAL;
1486                         goto out;
1487                 }
1488 
1489                 if (addr_len == sizeof(struct sockaddr_ax25))
1490                         /* ax25_sendmsg(): uses obsolete socket structure */
1491                         ;
1492                 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1493                         /* support for old structure may go away some time
1494                          * ax25_sendmsg(): uses old (6 digipeater)
1495                          * socket structure.
1496                          */
1497                         if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1498                             (addr_len > sizeof(struct full_sockaddr_ax25))) {
1499                                 err = -EINVAL;
1500                                 goto out;
1501                         }
1502 
1503 
1504                 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1505                         int ct           = 0;
1506                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1507 
1508                         /* Valid number of digipeaters ? */
1509                         if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1510                                 err = -EINVAL;
1511                                 goto out;
1512                         }
1513 
1514                         dtmp.ndigi      = usax->sax25_ndigis;
1515 
1516                         while (ct < usax->sax25_ndigis) {
1517                                 dtmp.repeated[ct] = 0;
1518                                 dtmp.calls[ct]    = fsa->fsa_digipeater[ct];
1519                                 ct++;
1520                         }
1521 
1522                         dtmp.lastrepeat = 0;
1523                 }
1524 
1525                 sax = *usax;
1526                 if (sk->sk_type == SOCK_SEQPACKET &&
1527                     ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1528                         err = -EISCONN;
1529                         goto out;
1530                 }
1531                 if (usax->sax25_ndigis == 0)
1532                         dp = NULL;
1533                 else
1534                         dp = &dtmp;
1535         } else {
1536                 /*
1537                  *      FIXME: 1003.1g - if the socket is like this because
1538                  *      it has become closed (not started closed) and is VC
1539                  *      we ought to SIGPIPE, EPIPE
1540                  */
1541                 if (sk->sk_state != TCP_ESTABLISHED) {
1542                         err = -ENOTCONN;
1543                         goto out;
1544                 }
1545                 sax.sax25_family = AF_AX25;
1546                 sax.sax25_call   = ax25->dest_addr;
1547                 dp = ax25->digipeat;
1548         }
1549 
1550         /* Build a packet */
1551         /* Assume the worst case */
1552         size = len + ax25->ax25_dev->dev->hard_header_len;
1553 
1554         skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1555         if (skb == NULL)
1556                 goto out;
1557 
1558         skb_reserve(skb, size - len);
1559 
1560         /* User data follows immediately after the AX.25 data */
1561         if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1562                 err = -EFAULT;
1563                 kfree_skb(skb);
1564                 goto out;
1565         }
1566 
1567         skb_reset_network_header(skb);
1568 
1569         /* Add the PID if one is not supplied by the user in the skb */
1570         if (!ax25->pidincl)
1571                 *(u8 *)skb_push(skb, 1) = sk->sk_protocol;
1572 
1573         if (sk->sk_type == SOCK_SEQPACKET) {
1574                 /* Connected mode sockets go via the LAPB machine */
1575                 if (sk->sk_state != TCP_ESTABLISHED) {
1576                         kfree_skb(skb);
1577                         err = -ENOTCONN;
1578                         goto out;
1579                 }
1580 
1581                 /* Shove it onto the queue and kick */
1582                 ax25_output(ax25, ax25->paclen, skb);
1583 
1584                 err = len;
1585                 goto out;
1586         }
1587 
1588         skb_push(skb, 1 + ax25_addr_size(dp));
1589 
1590         /* Building AX.25 Header */
1591 
1592         /* Build an AX.25 header */
1593         lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1594                              dp, AX25_COMMAND, AX25_MODULUS);
1595 
1596         skb_set_transport_header(skb, lv);
1597 
1598         *skb_transport_header(skb) = AX25_UI;
1599 
1600         /* Datagram frames go straight out of the door as UI */
1601         ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1602 
1603         err = len;
1604 
1605 out:
1606         release_sock(sk);
1607 
1608         return err;
1609 }
1610 
1611 static int ax25_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1612                         int flags)
1613 {
1614         struct sock *sk = sock->sk;
1615         struct sk_buff *skb;
1616         int copied;
1617         int err = 0;
1618 
1619         lock_sock(sk);
1620         /*
1621          *      This works for seqpacket too. The receiver has ordered the
1622          *      queue for us! We do one quick check first though
1623          */
1624         if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1625                 err =  -ENOTCONN;
1626                 goto out;
1627         }
1628 
1629         /* Now we can treat all alike */
1630         skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1631                                 flags & MSG_DONTWAIT, &err);
1632         if (skb == NULL)
1633                 goto out;
1634 
1635         if (!sk_to_ax25(sk)->pidincl)
1636                 skb_pull(skb, 1);               /* Remove PID */
1637 
1638         skb_reset_transport_header(skb);
1639         copied = skb->len;
1640 
1641         if (copied > size) {
1642                 copied = size;
1643                 msg->msg_flags |= MSG_TRUNC;
1644         }
1645 
1646         skb_copy_datagram_msg(skb, 0, msg, copied);
1647 
1648         if (msg->msg_name) {
1649                 ax25_digi digi;
1650                 ax25_address src;
1651                 const unsigned char *mac = skb_mac_header(skb);
1652                 DECLARE_SOCKADDR(struct sockaddr_ax25 *, sax, msg->msg_name);
1653 
1654                 memset(sax, 0, sizeof(struct full_sockaddr_ax25));
1655                 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1656                                 &digi, NULL, NULL);
1657                 sax->sax25_family = AF_AX25;
1658                 /* We set this correctly, even though we may not let the
1659                    application know the digi calls further down (because it
1660                    did NOT ask to know them).  This could get political... **/
1661                 sax->sax25_ndigis = digi.ndigi;
1662                 sax->sax25_call   = src;
1663 
1664                 if (sax->sax25_ndigis != 0) {
1665                         int ct;
1666                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1667 
1668                         for (ct = 0; ct < digi.ndigi; ct++)
1669                                 fsa->fsa_digipeater[ct] = digi.calls[ct];
1670                 }
1671                 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1672         }
1673 
1674         skb_free_datagram(sk, skb);
1675         err = copied;
1676 
1677 out:
1678         release_sock(sk);
1679 
1680         return err;
1681 }
1682 
1683 static int ax25_shutdown(struct socket *sk, int how)
1684 {
1685         /* FIXME - generate DM and RNR states */
1686         return -EOPNOTSUPP;
1687 }
1688 
1689 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1690 {
1691         struct sock *sk = sock->sk;
1692         void __user *argp = (void __user *)arg;
1693         int res = 0;
1694 
1695         lock_sock(sk);
1696         switch (cmd) {
1697         case TIOCOUTQ: {
1698                 long amount;
1699 
1700                 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1701                 if (amount < 0)
1702                         amount = 0;
1703                 res = put_user(amount, (int __user *)argp);
1704                 break;
1705         }
1706 
1707         case TIOCINQ: {
1708                 struct sk_buff *skb;
1709                 long amount = 0L;
1710                 /* These two are safe on a single CPU system as only user tasks fiddle here */
1711                 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1712                         amount = skb->len;
1713                 res = put_user(amount, (int __user *) argp);
1714                 break;
1715         }
1716 
1717         case SIOCGSTAMP:
1718                 res = sock_get_timestamp(sk, argp);
1719                 break;
1720 
1721         case SIOCGSTAMPNS:
1722                 res = sock_get_timestampns(sk, argp);
1723                 break;
1724 
1725         case SIOCAX25ADDUID:    /* Add a uid to the uid/call map table */
1726         case SIOCAX25DELUID:    /* Delete a uid from the uid/call map table */
1727         case SIOCAX25GETUID: {
1728                 struct sockaddr_ax25 sax25;
1729                 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1730                         res = -EFAULT;
1731                         break;
1732                 }
1733                 res = ax25_uid_ioctl(cmd, &sax25);
1734                 break;
1735         }
1736 
1737         case SIOCAX25NOUID: {   /* Set the default policy (default/bar) */
1738                 long amount;
1739                 if (!capable(CAP_NET_ADMIN)) {
1740                         res = -EPERM;
1741                         break;
1742                 }
1743                 if (get_user(amount, (long __user *)argp)) {
1744                         res = -EFAULT;
1745                         break;
1746                 }
1747                 if (amount < 0 || amount > AX25_NOUID_BLOCK) {
1748                         res = -EINVAL;
1749                         break;
1750                 }
1751                 ax25_uid_policy = amount;
1752                 res = 0;
1753                 break;
1754         }
1755 
1756         case SIOCADDRT:
1757         case SIOCDELRT:
1758         case SIOCAX25OPTRT:
1759                 if (!capable(CAP_NET_ADMIN)) {
1760                         res = -EPERM;
1761                         break;
1762                 }
1763                 res = ax25_rt_ioctl(cmd, argp);
1764                 break;
1765 
1766         case SIOCAX25CTLCON:
1767                 if (!capable(CAP_NET_ADMIN)) {
1768                         res = -EPERM;
1769                         break;
1770                 }
1771                 res = ax25_ctl_ioctl(cmd, argp);
1772                 break;
1773 
1774         case SIOCAX25GETINFO:
1775         case SIOCAX25GETINFOOLD: {
1776                 ax25_cb *ax25 = sk_to_ax25(sk);
1777                 struct ax25_info_struct ax25_info;
1778 
1779                 ax25_info.t1        = ax25->t1   / HZ;
1780                 ax25_info.t2        = ax25->t2   / HZ;
1781                 ax25_info.t3        = ax25->t3   / HZ;
1782                 ax25_info.idle      = ax25->idle / (60 * HZ);
1783                 ax25_info.n2        = ax25->n2;
1784                 ax25_info.t1timer   = ax25_display_timer(&ax25->t1timer)   / HZ;
1785                 ax25_info.t2timer   = ax25_display_timer(&ax25->t2timer)   / HZ;
1786                 ax25_info.t3timer   = ax25_display_timer(&ax25->t3timer)   / HZ;
1787                 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1788                 ax25_info.n2count   = ax25->n2count;
1789                 ax25_info.state     = ax25->state;
1790                 ax25_info.rcv_q     = sk_rmem_alloc_get(sk);
1791                 ax25_info.snd_q     = sk_wmem_alloc_get(sk);
1792                 ax25_info.vs        = ax25->vs;
1793                 ax25_info.vr        = ax25->vr;
1794                 ax25_info.va        = ax25->va;
1795                 ax25_info.vs_max    = ax25->vs; /* reserved */
1796                 ax25_info.paclen    = ax25->paclen;
1797                 ax25_info.window    = ax25->window;
1798 
1799                 /* old structure? */
1800                 if (cmd == SIOCAX25GETINFOOLD) {
1801                         static int warned = 0;
1802                         if (!warned) {
1803                                 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1804                                         current->comm);
1805                                 warned=1;
1806                         }
1807 
1808                         if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1809                                 res = -EFAULT;
1810                                 break;
1811                         }
1812                 } else {
1813                         if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1814                                 res = -EINVAL;
1815                                 break;
1816                         }
1817                 }
1818                 res = 0;
1819                 break;
1820         }
1821 
1822         case SIOCAX25ADDFWD:
1823         case SIOCAX25DELFWD: {
1824                 struct ax25_fwd_struct ax25_fwd;
1825                 if (!capable(CAP_NET_ADMIN)) {
1826                         res = -EPERM;
1827                         break;
1828                 }
1829                 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1830                         res = -EFAULT;
1831                         break;
1832                 }
1833                 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1834                 break;
1835         }
1836 
1837         case SIOCGIFADDR:
1838         case SIOCSIFADDR:
1839         case SIOCGIFDSTADDR:
1840         case SIOCSIFDSTADDR:
1841         case SIOCGIFBRDADDR:
1842         case SIOCSIFBRDADDR:
1843         case SIOCGIFNETMASK:
1844         case SIOCSIFNETMASK:
1845         case SIOCGIFMETRIC:
1846         case SIOCSIFMETRIC:
1847                 res = -EINVAL;
1848                 break;
1849 
1850         default:
1851                 res = -ENOIOCTLCMD;
1852                 break;
1853         }
1854         release_sock(sk);
1855 
1856         return res;
1857 }
1858 
1859 #ifdef CONFIG_PROC_FS
1860 
1861 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1862         __acquires(ax25_list_lock)
1863 {
1864         spin_lock_bh(&ax25_list_lock);
1865         return seq_hlist_start(&ax25_list, *pos);
1866 }
1867 
1868 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1869 {
1870         return seq_hlist_next(v, &ax25_list, pos);
1871 }
1872 
1873 static void ax25_info_stop(struct seq_file *seq, void *v)
1874         __releases(ax25_list_lock)
1875 {
1876         spin_unlock_bh(&ax25_list_lock);
1877 }
1878 
1879 static int ax25_info_show(struct seq_file *seq, void *v)
1880 {
1881         ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
1882         char buf[11];
1883         int k;
1884 
1885 
1886         /*
1887          * New format:
1888          * 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
1889          */
1890 
1891         seq_printf(seq, "%8.8lx %s %s%s ",
1892                    (long) ax25,
1893                    ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1894                    ax2asc(buf, &ax25->source_addr),
1895                    ax25->iamdigi? "*":"");
1896         seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1897 
1898         for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1899                 seq_printf(seq, ",%s%s",
1900                            ax2asc(buf, &ax25->digipeat->calls[k]),
1901                            ax25->digipeat->repeated[k]? "*":"");
1902         }
1903 
1904         seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1905                    ax25->state,
1906                    ax25->vs, ax25->vr, ax25->va,
1907                    ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1908                    ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1909                    ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1910                    ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1911                    ax25->idle / (60 * HZ),
1912                    ax25->n2count, ax25->n2,
1913                    ax25->rtt / HZ,
1914                    ax25->window,
1915                    ax25->paclen);
1916 
1917         if (ax25->sk != NULL) {
1918                 seq_printf(seq, " %d %d %lu\n",
1919                            sk_wmem_alloc_get(ax25->sk),
1920                            sk_rmem_alloc_get(ax25->sk),
1921                            sock_i_ino(ax25->sk));
1922         } else {
1923                 seq_puts(seq, " * * *\n");
1924         }
1925         return 0;
1926 }
1927 
1928 static const struct seq_operations ax25_info_seqops = {
1929         .start = ax25_info_start,
1930         .next = ax25_info_next,
1931         .stop = ax25_info_stop,
1932         .show = ax25_info_show,
1933 };
1934 #endif
1935 
1936 static const struct net_proto_family ax25_family_ops = {
1937         .family =       PF_AX25,
1938         .create =       ax25_create,
1939         .owner  =       THIS_MODULE,
1940 };
1941 
1942 static const struct proto_ops ax25_proto_ops = {
1943         .family         = PF_AX25,
1944         .owner          = THIS_MODULE,
1945         .release        = ax25_release,
1946         .bind           = ax25_bind,
1947         .connect        = ax25_connect,
1948         .socketpair     = sock_no_socketpair,
1949         .accept         = ax25_accept,
1950         .getname        = ax25_getname,
1951         .poll           = datagram_poll,
1952         .ioctl          = ax25_ioctl,
1953         .listen         = ax25_listen,
1954         .shutdown       = ax25_shutdown,
1955         .setsockopt     = ax25_setsockopt,
1956         .getsockopt     = ax25_getsockopt,
1957         .sendmsg        = ax25_sendmsg,
1958         .recvmsg        = ax25_recvmsg,
1959         .mmap           = sock_no_mmap,
1960         .sendpage       = sock_no_sendpage,
1961 };
1962 
1963 /*
1964  *      Called by socket.c on kernel start up
1965  */
1966 static struct packet_type ax25_packet_type __read_mostly = {
1967         .type   =       cpu_to_be16(ETH_P_AX25),
1968         .func   =       ax25_kiss_rcv,
1969 };
1970 
1971 static struct notifier_block ax25_dev_notifier = {
1972         .notifier_call = ax25_device_event,
1973 };
1974 
1975 static int __init ax25_init(void)
1976 {
1977         int rc = proto_register(&ax25_proto, 0);
1978 
1979         if (rc != 0)
1980                 goto out;
1981 
1982         sock_register(&ax25_family_ops);
1983         dev_add_pack(&ax25_packet_type);
1984         register_netdevice_notifier(&ax25_dev_notifier);
1985 
1986         proc_create_seq("ax25_route", 0444, init_net.proc_net, &ax25_rt_seqops);
1987         proc_create_seq("ax25", 0444, init_net.proc_net, &ax25_info_seqops);
1988         proc_create_seq("ax25_calls", 0444, init_net.proc_net,
1989                         &ax25_uid_seqops);
1990 out:
1991         return rc;
1992 }
1993 module_init(ax25_init);
1994 
1995 
1996 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
1997 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
1998 MODULE_LICENSE("GPL");
1999 MODULE_ALIAS_NETPROTO(PF_AX25);
2000 
2001 static void __exit ax25_exit(void)
2002 {
2003         remove_proc_entry("ax25_route", init_net.proc_net);
2004         remove_proc_entry("ax25", init_net.proc_net);
2005         remove_proc_entry("ax25_calls", init_net.proc_net);
2006 
2007         unregister_netdevice_notifier(&ax25_dev_notifier);
2008 
2009         dev_remove_pack(&ax25_packet_type);
2010 
2011         sock_unregister(PF_AX25);
2012         proto_unregister(&ax25_proto);
2013 
2014         ax25_rt_free();
2015         ax25_uid_free();
2016         ax25_dev_free();
2017 }
2018 module_exit(ax25_exit);
2019 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp