net/ax25/af_ax25.c

   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);