net/ax25/af_ax25.c

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