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)
 639                         optlen = IFNAMSIZ;
 640
 641                 if (copy_from_user(devname, optval, optlen)) {
 642                         res = -EFAULT;
 643                         break;
 644                 }
 645
 646                 if (sk->sk_type == SOCK_SEQPACKET &&
 647                    (sock->state != SS_UNCONNECTED ||
 648                     sk->sk_state == TCP_LISTEN)) {
 649                         res = -EADDRNOTAVAIL;
 650                         break;
 651                 }
 652
 653                 rtnl_lock();
 654                 dev = __dev_get_by_name(&init_net, devname);
 655                 if (!dev) {
 656                         rtnl_unlock();
 657                         res = -ENODEV;
 658                         break;
 659                 }
 660
 661                 ax25->ax25_dev = ax25_dev_ax25dev(dev);
 662                 if (!ax25->ax25_dev) {
 663                         rtnl_unlock();
 664                         res = -ENODEV;
 665                         break;
 666                 }
 667                 ax25_fillin_cb(ax25, ax25->ax25_dev);
 668                 rtnl_unlock();
 669                 break;
 670
 671         default:
 672                 res = -ENOPROTOOPT;
 673         }
 674         release_sock(sk);
 675
 676         return res;
 677 }
 678
 679 static int ax25_getsockopt(struct socket *sock, int level, int optname,
 680         char __user *optval, int __user *optlen)
 681 {
 682         struct sock *sk = sock->sk;
 683         ax25_cb *ax25;
 684         struct ax25_dev *ax25_dev;
 685         char devname[IFNAMSIZ];
 686         void *valptr;
 687         int val = 0;
 688         int maxlen, length;
 689
 690         if (level != SOL_AX25)
 691                 return -ENOPROTOOPT;
 692
 693         if (get_user(maxlen, optlen))
 694                 return -EFAULT;
 695
 696         if (maxlen < 1)
 697                 return -EFAULT;
 698
 699         valptr = (void *) &val;
 700         length = min_t(unsigned int, maxlen, sizeof(int));
 701
 702         lock_sock(sk);
 703         ax25 = sk_to_ax25(sk);
 704
 705         switch (optname) {
 706         case AX25_WINDOW:
 707                 val = ax25->window;
 708                 break;
 709
 710         case AX25_T1:
 711                 val = ax25->t1 / HZ;
 712                 break;
 713
 714         case AX25_T2:
 715                 val = ax25->t2 / HZ;
 716                 break;
 717
 718         case AX25_N2:
 719                 val = ax25->n2;
 720                 break;
 721
 722         case AX25_T3:
 723                 val = ax25->t3 / HZ;
 724                 break;
 725
 726         case AX25_IDLE:
 727                 val = ax25->idle / (60 * HZ);
 728                 break;
 729
 730         case AX25_BACKOFF:
 731                 val = ax25->backoff;
 732                 break;
 733
 734         case AX25_EXTSEQ:
 735                 val = (ax25->modulus == AX25_EMODULUS);
 736                 break;
 737
 738         case AX25_PIDINCL:
 739                 val = ax25->pidincl;
 740                 break;
 741
 742         case AX25_IAMDIGI:
 743                 val = ax25->iamdigi;
 744                 break;
 745
 746         case AX25_PACLEN:
 747                 val = ax25->paclen;
 748                 break;
 749
 750         case SO_BINDTODEVICE:
 751                 ax25_dev = ax25->ax25_dev;
 752
 753                 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
 754                         strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
 755                         length = strlen(devname) + 1;
 756                 } else {
 757                         *devname = '\0';
 758                         length = 1;
 759                 }
 760
 761                 valptr = (void *) devname;
 762                 break;
 763
 764         default:
 765                 release_sock(sk);
 766                 return -ENOPROTOOPT;
 767         }
 768         release_sock(sk);
 769
 770         if (put_user(length, optlen))
 771                 return -EFAULT;
 772
 773         return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
 774 }
 775
 776 static int ax25_listen(struct socket *sock, int backlog)
 777 {
 778         struct sock *sk = sock->sk;
 779         int res = 0;
 780
 781         lock_sock(sk);
 782         if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
 783                 sk->sk_max_ack_backlog = backlog;
 784                 sk->sk_state           = TCP_LISTEN;
 785                 goto out;
 786         }
 787         res = -EOPNOTSUPP;
 788
 789 out:
 790         release_sock(sk);
 791
 792         return res;
 793 }
 794
 795 /*
 796  * XXX: when creating ax25_sock we should update the .obj_size setting
 797  * below.
 798  */
 799 static struct proto ax25_proto = {
 800         .name     = "AX25",
 801         .owner    = THIS_MODULE,
 802         .obj_size = sizeof(struct ax25_sock),
 803 };
 804
 805 static int ax25_create(struct net *net, struct socket *sock, int protocol,
 806                        int kern)
 807 {
 808         struct sock *sk;
 809         ax25_cb *ax25;
 810
 811         if (protocol < 0 || protocol > U8_MAX)
 812                 return -EINVAL;
 813
 814         if (!net_eq(net, &init_net))
 815                 return -EAFNOSUPPORT;
 816
 817         switch (sock->type) {
 818         case SOCK_DGRAM:
 819                 if (protocol == 0 || protocol == PF_AX25)
 820                         protocol = AX25_P_TEXT;
 821                 break;
 822
 823         case SOCK_SEQPACKET:
 824                 switch (protocol) {
 825                 case 0:
 826                 case PF_AX25:   /* For CLX */
 827                         protocol = AX25_P_TEXT;
 828                         break;
 829                 case AX25_P_SEGMENT:
 830 #ifdef CONFIG_INET
 831                 case AX25_P_ARP:
 832                 case AX25_P_IP:
 833 #endif
 834 #ifdef CONFIG_NETROM
 835                 case AX25_P_NETROM:
 836 #endif
 837 #ifdef CONFIG_ROSE
 838                 case AX25_P_ROSE:
 839 #endif
 840                         return -ESOCKTNOSUPPORT;
 841 #ifdef CONFIG_NETROM_MODULE
 842                 case AX25_P_NETROM:
 843                         if (ax25_protocol_is_registered(AX25_P_NETROM))
 844                                 return -ESOCKTNOSUPPORT;
 845                         break;
 846 #endif
 847 #ifdef CONFIG_ROSE_MODULE
 848                 case AX25_P_ROSE:
 849                         if (ax25_protocol_is_registered(AX25_P_ROSE))
 850                                 return -ESOCKTNOSUPPORT;
 851 #endif
 852                 default:
 853                         break;
 854                 }
 855                 break;
 856
 857         case SOCK_RAW:
 858                 if (!capable(CAP_NET_RAW))
 859                         return -EPERM;
 860                 break;
 861         default:
 862                 return -ESOCKTNOSUPPORT;
 863         }
 864
 865         sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto, kern);
 866         if (sk == NULL)
 867                 return -ENOMEM;
 868
 869         ax25 = ax25_sk(sk)->cb = ax25_create_cb();
 870         if (!ax25) {
 871                 sk_free(sk);
 872                 return -ENOMEM;
 873         }
 874
 875         sock_init_data(sock, sk);
 876
 877         sk->sk_destruct = ax25_free_sock;
 878         sock->ops    = &ax25_proto_ops;
 879         sk->sk_protocol = protocol;
 880
 881         ax25->sk    = sk;
 882
 883         return 0;
 884 }
 885
 886 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
 887 {
 888         struct sock *sk;
 889         ax25_cb *ax25, *oax25;
 890
 891         sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot, 0);
 892         if (sk == NULL)
 893                 return NULL;
 894
 895         if ((ax25 = ax25_create_cb()) == NULL) {
 896                 sk_free(sk);
 897                 return NULL;
 898         }
 899
 900         switch (osk->sk_type) {
 901         case SOCK_DGRAM:
 902                 break;
 903         case SOCK_SEQPACKET:
 904                 break;
 905         default:
 906                 sk_free(sk);
 907                 ax25_cb_put(ax25);
 908                 return NULL;
 909         }
 910
 911         sock_init_data(NULL, sk);
 912
 913         sk->sk_type     = osk->sk_type;
 914         sk->sk_priority = osk->sk_priority;
 915         sk->sk_protocol = osk->sk_protocol;
 916         sk->sk_rcvbuf   = osk->sk_rcvbuf;
 917         sk->sk_sndbuf   = osk->sk_sndbuf;
 918         sk->sk_state    = TCP_ESTABLISHED;
 919         sock_copy_flags(sk, osk);
 920
 921         oax25 = sk_to_ax25(osk);
 922
 923         ax25->modulus = oax25->modulus;
 924         ax25->backoff = oax25->backoff;
 925         ax25->pidincl = oax25->pidincl;
 926         ax25->iamdigi = oax25->iamdigi;
 927         ax25->rtt     = oax25->rtt;
 928         ax25->t1      = oax25->t1;
 929         ax25->t2      = oax25->t2;
 930         ax25->t3      = oax25->t3;
 931         ax25->n2      = oax25->n2;
 932         ax25->idle    = oax25->idle;
 933         ax25->paclen  = oax25->paclen;
 934         ax25->window  = oax25->window;
 935
 936         ax25->ax25_dev    = ax25_dev;
 937         ax25->source_addr = oax25->source_addr;
 938
 939         if (oax25->digipeat != NULL) {
 940                 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
 941                                          GFP_ATOMIC);
 942                 if (ax25->digipeat == NULL) {
 943                         sk_free(sk);
 944                         ax25_cb_put(ax25);
 945                         return NULL;
 946                 }
 947         }
 948
 949         ax25_sk(sk)->cb = ax25;
 950         sk->sk_destruct = ax25_free_sock;
 951         ax25->sk    = sk;
 952
 953         return sk;
 954 }
 955
 956 static int ax25_release(struct socket *sock)
 957 {
 958         struct sock *sk = sock->sk;
 959         ax25_cb *ax25;
 960
 961         if (sk == NULL)
 962                 return 0;
 963
 964         sock_hold(sk);
 965         sock_orphan(sk);
 966         lock_sock(sk);
 967         ax25 = sk_to_ax25(sk);
 968
 969         if (sk->sk_type == SOCK_SEQPACKET) {
 970                 switch (ax25->state) {
 971                 case AX25_STATE_0:
 972                         release_sock(sk);
 973                         ax25_disconnect(ax25, 0);
 974                         lock_sock(sk);
 975                         ax25_destroy_socket(ax25);
 976                         break;
 977
 978                 case AX25_STATE_1:
 979                 case AX25_STATE_2:
 980                         ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
 981                         release_sock(sk);
 982                         ax25_disconnect(ax25, 0);
 983                         lock_sock(sk);
 984                         if (!sock_flag(ax25->sk, SOCK_DESTROY))
 985                                 ax25_destroy_socket(ax25);
 986                         break;
 987
 988                 case AX25_STATE_3:
 989                 case AX25_STATE_4:
 990                         ax25_clear_queues(ax25);
 991                         ax25->n2count = 0;
 992
 993                         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
 994                         case AX25_PROTO_STD_SIMPLEX:
 995                         case AX25_PROTO_STD_DUPLEX:
 996                                 ax25_send_control(ax25,
 997                                                   AX25_DISC,
 998                                                   AX25_POLLON,
 999                                                   AX25_COMMAND);
1000                                 ax25_stop_t2timer(ax25);
1001                                 ax25_stop_t3timer(ax25);
1002                                 ax25_stop_idletimer(ax25);
1003                                 break;
1004 #ifdef CONFIG_AX25_DAMA_SLAVE
1005                         case AX25_PROTO_DAMA_SLAVE:
1006                                 ax25_stop_t3timer(ax25);
1007                                 ax25_stop_idletimer(ax25);
1008                                 break;
1009 #endif
1010                         }
1011                         ax25_calculate_t1(ax25);
1012                         ax25_start_t1timer(ax25);
1013                         ax25->state = AX25_STATE_2;
1014                         sk->sk_state                = TCP_CLOSE;
1015                         sk->sk_shutdown            |= SEND_SHUTDOWN;
1016                         sk->sk_state_change(sk);
1017                         sock_set_flag(sk, SOCK_DESTROY);
1018                         break;
1019
1020                 default:
1021                         break;
1022                 }
1023         } else {
1024                 sk->sk_state     = TCP_CLOSE;
1025                 sk->sk_shutdown |= SEND_SHUTDOWN;
1026                 sk->sk_state_change(sk);
1027                 ax25_destroy_socket(ax25);
1028         }
1029
1030         sock->sk   = NULL;
1031         release_sock(sk);
1032         sock_put(sk);
1033
1034         return 0;
1035 }
1036
1037 /*
1038  *      We support a funny extension here so you can (as root) give any callsign
1039  *      digipeated via a local address as source. This hack is obsolete now
1040  *      that we've implemented support for SO_BINDTODEVICE. It is however small
1041  *      and trivially backward compatible.
1042  */
1043 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1044 {
1045         struct sock *sk = sock->sk;
1046         struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1047         ax25_dev *ax25_dev = NULL;
1048         ax25_uid_assoc *user;
1049         ax25_address call;
1050         ax25_cb *ax25;
1051         int err = 0;
1052
1053         if (addr_len != sizeof(struct sockaddr_ax25) &&
1054             addr_len != sizeof(struct full_sockaddr_ax25))
1055                 /* support for old structure may go away some time
1056                  * ax25_bind(): uses old (6 digipeater) socket structure.
1057                  */
1058                 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1059                     (addr_len > sizeof(struct full_sockaddr_ax25)))
1060                         return -EINVAL;
1061
1062         if (addr->fsa_ax25.sax25_family != AF_AX25)
1063                 return -EINVAL;
1064
1065         user = ax25_findbyuid(current_euid());
1066         if (user) {
1067                 call = user->call;
1068                 ax25_uid_put(user);
1069         } else {
1070                 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1071                         return -EACCES;
1072
1073                 call = addr->fsa_ax25.sax25_call;
1074         }
1075
1076         lock_sock(sk);
1077
1078         ax25 = sk_to_ax25(sk);
1079         if (!sock_flag(sk, SOCK_ZAPPED)) {
1080                 err = -EINVAL;
1081                 goto out;
1082         }
1083
1084         ax25->source_addr = call;
1085
1086         /*
1087          * User already set interface with SO_BINDTODEVICE
1088          */
1089         if (ax25->ax25_dev != NULL)
1090                 goto done;
1091
1092         if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1093                 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1094                     (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1095                         err = -EADDRNOTAVAIL;
1096                         goto out;
1097                 }
1098         } else {
1099                 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1100                         err = -EADDRNOTAVAIL;
1101                         goto out;
1102                 }
1103         }
1104
1105         if (ax25_dev != NULL)
1106                 ax25_fillin_cb(ax25, ax25_dev);
1107
1108 done:
1109         ax25_cb_add(ax25);
1110         sock_reset_flag(sk, SOCK_ZAPPED);
1111
1112 out:
1113         release_sock(sk);
1114
1115         return err;
1116 }
1117
1118 /*
1119  *      FIXME: nonblock behaviour looks like it may have a bug.
1120  */
1121 static int __must_check ax25_connect(struct socket *sock,
1122         struct sockaddr *uaddr, int addr_len, int flags)
1123 {
1124         struct sock *sk = sock->sk;
1125         ax25_cb *ax25 = sk_to_ax25(sk), *ax25t;
1126         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1127         ax25_digi *digi = NULL;
1128         int ct = 0, err = 0;
1129
1130         /*
1131          * some sanity checks. code further down depends on this
1132          */
1133
1134         if (addr_len == sizeof(struct sockaddr_ax25))
1135                 /* support for this will go away in early 2.5.x
1136                  * ax25_connect(): uses obsolete socket structure
1137                  */
1138                 ;
1139         else if (addr_len != sizeof(struct full_sockaddr_ax25))
1140                 /* support for old structure may go away some time
1141                  * ax25_connect(): uses old (6 digipeater) socket structure.
1142                  */
1143                 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1144                     (addr_len > sizeof(struct full_sockaddr_ax25)))
1145                         return -EINVAL;
1146
1147
1148         if (fsa->fsa_ax25.sax25_family != AF_AX25)
1149                 return -EINVAL;
1150
1151         lock_sock(sk);
1152
1153         /* deal with restarts */
1154         if (sock->state == SS_CONNECTING) {
1155                 switch (sk->sk_state) {
1156                 case TCP_SYN_SENT: /* still trying */
1157                         err = -EINPROGRESS;
1158                         goto out_release;
1159
1160                 case TCP_ESTABLISHED: /* connection established */
1161                         sock->state = SS_CONNECTED;
1162                         goto out_release;
1163
1164                 case TCP_CLOSE: /* connection refused */
1165                         sock->state = SS_UNCONNECTED;
1166                         err = -ECONNREFUSED;
1167                         goto out_release;
1168                 }
1169         }
1170
1171         if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1172                 err = -EISCONN; /* No reconnect on a seqpacket socket */
1173                 goto out_release;
1174         }
1175
1176         sk->sk_state   = TCP_CLOSE;
1177         sock->state = SS_UNCONNECTED;
1178
1179         kfree(ax25->digipeat);
1180         ax25->digipeat = NULL;
1181
1182         /*
1183          *      Handle digi-peaters to be used.
1184          */
1185         if (addr_len > sizeof(struct sockaddr_ax25) &&
1186             fsa->fsa_ax25.sax25_ndigis != 0) {
1187                 /* Valid number of digipeaters ? */
1188                 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1189                         err = -EINVAL;
1190                         goto out_release;
1191                 }
1192
1193                 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1194                         err = -ENOBUFS;
1195                         goto out_release;
1196                 }
1197
1198                 digi->ndigi      = fsa->fsa_ax25.sax25_ndigis;
1199                 digi->lastrepeat = -1;
1200
1201                 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1202                         if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1203                              AX25_HBIT) && ax25->iamdigi) {
1204                                 digi->repeated[ct] = 1;
1205                                 digi->lastrepeat   = ct;
1206                         } else {
1207                                 digi->repeated[ct] = 0;
1208                         }
1209                         digi->calls[ct] = fsa->fsa_digipeater[ct];
1210                         ct++;
1211                 }
1212         }
1213
1214         /*
1215          *      Must bind first - autobinding in this may or may not work. If
1216          *      the socket is already bound, check to see if the device has
1217          *      been filled in, error if it hasn't.
1218          */
1219         if (sock_flag(sk, SOCK_ZAPPED)) {
1220                 /* check if we can remove this feature. It is broken. */
1221                 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1222                         current->comm);
1223                 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1224                         kfree(digi);
1225                         goto out_release;
1226                 }
1227
1228                 ax25_fillin_cb(ax25, ax25->ax25_dev);
1229                 ax25_cb_add(ax25);
1230         } else {
1231                 if (ax25->ax25_dev == NULL) {
1232                         kfree(digi);
1233                         err = -EHOSTUNREACH;
1234                         goto out_release;
1235                 }
1236         }
1237
1238         if (sk->sk_type == SOCK_SEQPACKET &&
1239             (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1240                          ax25->ax25_dev->dev))) {
1241                 kfree(digi);
1242                 err = -EADDRINUSE;              /* Already such a connection */
1243                 ax25_cb_put(ax25t);
1244                 goto out_release;
1245         }
1246
1247         ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1248         ax25->digipeat  = digi;
1249
1250         /* First the easy one */
1251         if (sk->sk_type != SOCK_SEQPACKET) {
1252                 sock->state = SS_CONNECTED;
1253                 sk->sk_state   = TCP_ESTABLISHED;
1254                 goto out_release;
1255         }
1256
1257         /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1258         sock->state        = SS_CONNECTING;
1259         sk->sk_state          = TCP_SYN_SENT;
1260
1261         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1262         case AX25_PROTO_STD_SIMPLEX:
1263         case AX25_PROTO_STD_DUPLEX:
1264                 ax25_std_establish_data_link(ax25);
1265                 break;
1266
1267 #ifdef CONFIG_AX25_DAMA_SLAVE
1268         case AX25_PROTO_DAMA_SLAVE:
1269                 ax25->modulus = AX25_MODULUS;
1270                 ax25->window  = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1271                 if (ax25->ax25_dev->dama.slave)
1272                         ax25_ds_establish_data_link(ax25);
1273                 else
1274                         ax25_std_establish_data_link(ax25);
1275                 break;
1276 #endif
1277         }
1278
1279         ax25->state = AX25_STATE_1;
1280
1281         ax25_start_heartbeat(ax25);
1282
1283         /* Now the loop */
1284         if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1285                 err = -EINPROGRESS;
1286                 goto out_release;
1287         }
1288
1289         if (sk->sk_state == TCP_SYN_SENT) {
1290                 DEFINE_WAIT(wait);
1291
1292                 for (;;) {
1293                         prepare_to_wait(sk_sleep(sk), &wait,
1294                                         TASK_INTERRUPTIBLE);
1295                         if (sk->sk_state != TCP_SYN_SENT)
1296                                 break;
1297                         if (!signal_pending(current)) {
1298                                 release_sock(sk);
1299                                 schedule();
1300                                 lock_sock(sk);
1301                                 continue;
1302                         }
1303                         err = -ERESTARTSYS;
1304                         break;
1305                 }
1306                 finish_wait(sk_sleep(sk), &wait);
1307
1308                 if (err)
1309                         goto out_release;
1310         }
1311
1312         if (sk->sk_state != TCP_ESTABLISHED) {
1313                 /* Not in ABM, not in WAIT_UA -> failed */
1314                 sock->state = SS_UNCONNECTED;
1315                 err = sock_error(sk);   /* Always set at this point */
1316                 goto out_release;
1317         }
1318
1319         sock->state = SS_CONNECTED;
1320
1321         err = 0;
1322 out_release:
1323         release_sock(sk);
1324
1325         return err;
1326 }
1327
1328 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags,
1329                        bool kern)
1330 {
1331         struct sk_buff *skb;
1332         struct sock *newsk;
1333         DEFINE_WAIT(wait);
1334         struct sock *sk;
1335         int err = 0;
1336
1337         if (sock->state != SS_UNCONNECTED)
1338                 return -EINVAL;
1339
1340         if ((sk = sock->sk) == NULL)
1341                 return -EINVAL;
1342
1343         lock_sock(sk);
1344         if (sk->sk_type != SOCK_SEQPACKET) {
1345                 err = -EOPNOTSUPP;
1346                 goto out;
1347         }
1348
1349         if (sk->sk_state != TCP_LISTEN) {
1350                 err = -EINVAL;
1351                 goto out;
1352         }
1353
1354         /*
1355          *      The read queue this time is holding sockets ready to use
1356          *      hooked into the SABM we saved
1357          */
1358         for (;;) {
1359                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1360                 skb = skb_dequeue(&sk->sk_receive_queue);
1361                 if (skb)
1362                         break;
1363
1364                 if (flags & O_NONBLOCK) {
1365                         err = -EWOULDBLOCK;
1366                         break;
1367                 }
1368                 if (!signal_pending(current)) {
1369                         release_sock(sk);
1370                         schedule();
1371                         lock_sock(sk);
1372                         continue;
1373                 }
1374                 err = -ERESTARTSYS;
1375                 break;
1376         }
1377         finish_wait(sk_sleep(sk), &wait);
1378
1379         if (err)
1380                 goto out;
1381
1382         newsk            = skb->sk;
1383         sock_graft(newsk, newsock);
1384
1385         /* Now attach up the new socket */
1386         kfree_skb(skb);
1387         sk_acceptq_removed(sk);
1388         newsock->state = SS_CONNECTED;
1389
1390 out:
1391         release_sock(sk);
1392
1393         return err;
1394 }
1395
1396 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1397         int peer)
1398 {
1399         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1400         struct sock *sk = sock->sk;
1401         unsigned char ndigi, i;
1402         ax25_cb *ax25;
1403         int err = 0;
1404
1405         memset(fsa, 0, sizeof(*fsa));
1406         lock_sock(sk);
1407         ax25 = sk_to_ax25(sk);
1408
1409         if (peer != 0) {
1410                 if (sk->sk_state != TCP_ESTABLISHED) {
1411                         err = -ENOTCONN;
1412                         goto out;
1413                 }
1414
1415                 fsa->fsa_ax25.sax25_family = AF_AX25;
1416                 fsa->fsa_ax25.sax25_call   = ax25->dest_addr;
1417
1418                 if (ax25->digipeat != NULL) {
1419                         ndigi = ax25->digipeat->ndigi;
1420                         fsa->fsa_ax25.sax25_ndigis = ndigi;
1421                         for (i = 0; i < ndigi; i++)
1422                                 fsa->fsa_digipeater[i] =
1423                                                 ax25->digipeat->calls[i];
1424                 }
1425         } else {
1426                 fsa->fsa_ax25.sax25_family = AF_AX25;
1427                 fsa->fsa_ax25.sax25_call   = ax25->source_addr;
1428                 fsa->fsa_ax25.sax25_ndigis = 1;
1429                 if (ax25->ax25_dev != NULL) {
1430                         memcpy(&fsa->fsa_digipeater[0],
1431                                ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1432                 } else {
1433                         fsa->fsa_digipeater[0] = null_ax25_address;
1434                 }
1435         }
1436         err = sizeof (struct full_sockaddr_ax25);
1437
1438 out:
1439         release_sock(sk);
1440
1441         return err;
1442 }
1443
1444 static int ax25_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1445 {
1446         DECLARE_SOCKADDR(struct sockaddr_ax25 *, usax, msg->msg_name);
1447         struct sock *sk = sock->sk;
1448         struct sockaddr_ax25 sax;
1449         struct sk_buff *skb;
1450         ax25_digi dtmp, *dp;
1451         ax25_cb *ax25;
1452         size_t size;
1453         int lv, err, addr_len = msg->msg_namelen;
1454
1455         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1456                 return -EINVAL;
1457
1458         lock_sock(sk);
1459         ax25 = sk_to_ax25(sk);
1460
1461         if (sock_flag(sk, SOCK_ZAPPED)) {
1462                 err = -EADDRNOTAVAIL;
1463                 goto out;
1464         }
1465
1466         if (sk->sk_shutdown & SEND_SHUTDOWN) {
1467                 send_sig(SIGPIPE, current, 0);
1468                 err = -EPIPE;
1469                 goto out;
1470         }
1471
1472         if (ax25->ax25_dev == NULL) {
1473                 err = -ENETUNREACH;
1474                 goto out;
1475         }
1476
1477         if (len > ax25->ax25_dev->dev->mtu) {
1478                 err = -EMSGSIZE;
1479                 goto out;
1480         }
1481
1482         if (usax != NULL) {
1483                 if (usax->sax25_family != AF_AX25) {
1484                         err = -EINVAL;
1485                         goto out;
1486                 }
1487
1488                 if (addr_len == sizeof(struct sockaddr_ax25))
1489                         /* ax25_sendmsg(): uses obsolete socket structure */
1490                         ;
1491                 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1492                         /* support for old structure may go away some time
1493                          * ax25_sendmsg(): uses old (6 digipeater)
1494                          * socket structure.
1495                          */
1496                         if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1497                             (addr_len > sizeof(struct full_sockaddr_ax25))) {
1498                                 err = -EINVAL;
1499                                 goto out;
1500                         }
1501
1502
1503                 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1504                         int ct           = 0;
1505                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1506
1507                         /* Valid number of digipeaters ? */
1508                         if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1509                                 err = -EINVAL;
1510                                 goto out;
1511                         }
1512
1513                         dtmp.ndigi      = usax->sax25_ndigis;
1514
1515                         while (ct < usax->sax25_ndigis) {
1516                                 dtmp.repeated[ct] = 0;
1517                                 dtmp.calls[ct]    = fsa->fsa_digipeater[ct];
1518                                 ct++;
1519                         }
1520
1521                         dtmp.lastrepeat = 0;
1522                 }
1523
1524                 sax = *usax;
1525                 if (sk->sk_type == SOCK_SEQPACKET &&
1526                     ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1527                         err = -EISCONN;
1528                         goto out;
1529                 }
1530                 if (usax->sax25_ndigis == 0)
1531                         dp = NULL;
1532                 else
1533                         dp = &dtmp;
1534         } else {
1535                 /*
1536                  *      FIXME: 1003.1g - if the socket is like this because
1537                  *      it has become closed (not started closed) and is VC
1538                  *      we ought to SIGPIPE, EPIPE
1539                  */
1540                 if (sk->sk_state != TCP_ESTABLISHED) {
1541                         err = -ENOTCONN;
1542                         goto out;
1543                 }
1544                 sax.sax25_family = AF_AX25;
1545                 sax.sax25_call   = ax25->dest_addr;
1546                 dp = ax25->digipeat;
1547         }
1548
1549         /* Build a packet */
1550         /* Assume the worst case */
1551         size = len + ax25->ax25_dev->dev->hard_header_len;
1552
1553         skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1554         if (skb == NULL)
1555                 goto out;
1556
1557         skb_reserve(skb, size - len);
1558
1559         /* User data follows immediately after the AX.25 data */
1560         if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1561                 err = -EFAULT;
1562                 kfree_skb(skb);
1563                 goto out;
1564         }
1565
1566         skb_reset_network_header(skb);
1567
1568         /* Add the PID if one is not supplied by the user in the skb */
1569         if (!ax25->pidincl)
1570                 *(u8 *)skb_push(skb, 1) = sk->sk_protocol;
1571
1572         if (sk->sk_type == SOCK_SEQPACKET) {
1573                 /* Connected mode sockets go via the LAPB machine */
1574                 if (sk->sk_state != TCP_ESTABLISHED) {
1575                         kfree_skb(skb);
1576                         err = -ENOTCONN;
1577                         goto out;
1578                 }
1579
1580                 /* Shove it onto the queue and kick */
1581                 ax25_output(ax25, ax25->paclen, skb);
1582
1583                 err = len;
1584                 goto out;
1585         }
1586
1587         skb_push(skb, 1 + ax25_addr_size(dp));
1588
1589         /* Building AX.25 Header */
1590
1591         /* Build an AX.25 header */
1592         lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1593                              dp, AX25_COMMAND, AX25_MODULUS);
1594
1595         skb_set_transport_header(skb, lv);
1596
1597         *skb_transport_header(skb) = AX25_UI;
1598
1599         /* Datagram frames go straight out of the door as UI */
1600         ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1601
1602         err = len;
1603
1604 out:
1605         release_sock(sk);
1606
1607         return err;
1608 }
1609
1610 static int ax25_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1611                         int flags)
1612 {
1613         struct sock *sk = sock->sk;
1614         struct sk_buff *skb;
1615         int copied;
1616         int err = 0;
1617
1618         lock_sock(sk);
1619         /*
1620          *      This works for seqpacket too. The receiver has ordered the
1621          *      queue for us! We do one quick check first though
1622          */
1623         if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1624                 err =  -ENOTCONN;
1625                 goto out;
1626         }
1627
1628         /* Now we can treat all alike */
1629         skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1630                                 flags & MSG_DONTWAIT, &err);
1631         if (skb == NULL)
1632                 goto out;
1633
1634         if (!sk_to_ax25(sk)->pidincl)
1635                 skb_pull(skb, 1);               /* Remove PID */
1636
1637         skb_reset_transport_header(skb);
1638         copied = skb->len;
1639
1640         if (copied > size) {
1641                 copied = size;
1642                 msg->msg_flags |= MSG_TRUNC;
1643         }
1644
1645         skb_copy_datagram_msg(skb, 0, msg, copied);
1646
1647         if (msg->msg_name) {
1648                 ax25_digi digi;
1649                 ax25_address src;
1650                 const unsigned char *mac = skb_mac_header(skb);
1651                 DECLARE_SOCKADDR(struct sockaddr_ax25 *, sax, msg->msg_name);
1652
1653                 memset(sax, 0, sizeof(struct full_sockaddr_ax25));
1654                 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1655                                 &digi, NULL, NULL);
1656                 sax->sax25_family = AF_AX25;
1657                 /* We set this correctly, even though we may not let the
1658                    application know the digi calls further down (because it
1659                    did NOT ask to know them).  This could get political... **/
1660                 sax->sax25_ndigis = digi.ndigi;
1661                 sax->sax25_call   = src;
1662
1663                 if (sax->sax25_ndigis != 0) {
1664                         int ct;
1665                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1666
1667                         for (ct = 0; ct < digi.ndigi; ct++)
1668                                 fsa->fsa_digipeater[ct] = digi.calls[ct];
1669                 }
1670                 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1671         }
1672
1673         skb_free_datagram(sk, skb);
1674         err = copied;
1675
1676 out:
1677         release_sock(sk);
1678
1679         return err;
1680 }
1681
1682 static int ax25_shutdown(struct socket *sk, int how)
1683 {
1684         /* FIXME - generate DM and RNR states */
1685         return -EOPNOTSUPP;
1686 }
1687
1688 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1689 {
1690         struct sock *sk = sock->sk;
1691         void __user *argp = (void __user *)arg;
1692         int res = 0;
1693
1694         lock_sock(sk);
1695         switch (cmd) {
1696         case TIOCOUTQ: {
1697                 long amount;
1698
1699                 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1700                 if (amount < 0)
1701                         amount = 0;
1702                 res = put_user(amount, (int __user *)argp);
1703                 break;
1704         }
1705
1706         case TIOCINQ: {
1707                 struct sk_buff *skb;
1708                 long amount = 0L;
1709                 /* These two are safe on a single CPU system as only user tasks fiddle here */
1710                 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1711                         amount = skb->len;
1712                 res = put_user(amount, (int __user *) argp);
1713                 break;
1714         }
1715
1716         case SIOCAX25ADDUID:    /* Add a uid to the uid/call map table */
1717         case SIOCAX25DELUID:    /* Delete a uid from the uid/call map table */
1718         case SIOCAX25GETUID: {
1719                 struct sockaddr_ax25 sax25;
1720                 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1721                         res = -EFAULT;
1722                         break;
1723                 }
1724                 res = ax25_uid_ioctl(cmd, &sax25);
1725                 break;
1726         }
1727
1728         case SIOCAX25NOUID: {   /* Set the default policy (default/bar) */
1729                 long amount;
1730                 if (!capable(CAP_NET_ADMIN)) {
1731                         res = -EPERM;
1732                         break;
1733                 }
1734                 if (get_user(amount, (long __user *)argp)) {
1735                         res = -EFAULT;
1736                         break;
1737                 }
1738                 if (amount < 0 || amount > AX25_NOUID_BLOCK) {
1739                         res = -EINVAL;
1740                         break;
1741                 }
1742                 ax25_uid_policy = amount;
1743                 res = 0;
1744                 break;
1745         }
1746
1747         case SIOCADDRT:
1748         case SIOCDELRT:
1749         case SIOCAX25OPTRT:
1750                 if (!capable(CAP_NET_ADMIN)) {
1751                         res = -EPERM;
1752                         break;
1753                 }
1754                 res = ax25_rt_ioctl(cmd, argp);
1755                 break;
1756
1757         case SIOCAX25CTLCON:
1758                 if (!capable(CAP_NET_ADMIN)) {
1759                         res = -EPERM;
1760                         break;
1761                 }
1762                 res = ax25_ctl_ioctl(cmd, argp);
1763                 break;
1764
1765         case SIOCAX25GETINFO:
1766         case SIOCAX25GETINFOOLD: {
1767                 ax25_cb *ax25 = sk_to_ax25(sk);
1768                 struct ax25_info_struct ax25_info;
1769
1770                 ax25_info.t1        = ax25->t1   / HZ;
1771                 ax25_info.t2        = ax25->t2   / HZ;
1772                 ax25_info.t3        = ax25->t3   / HZ;
1773                 ax25_info.idle      = ax25->idle / (60 * HZ);
1774                 ax25_info.n2        = ax25->n2;
1775                 ax25_info.t1timer   = ax25_display_timer(&ax25->t1timer)   / HZ;
1776                 ax25_info.t2timer   = ax25_display_timer(&ax25->t2timer)   / HZ;
1777                 ax25_info.t3timer   = ax25_display_timer(&ax25->t3timer)   / HZ;
1778                 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1779                 ax25_info.n2count   = ax25->n2count;
1780                 ax25_info.state     = ax25->state;
1781                 ax25_info.rcv_q     = sk_rmem_alloc_get(sk);
1782                 ax25_info.snd_q     = sk_wmem_alloc_get(sk);
1783                 ax25_info.vs        = ax25->vs;
1784                 ax25_info.vr        = ax25->vr;
1785                 ax25_info.va        = ax25->va;
1786                 ax25_info.vs_max    = ax25->vs; /* reserved */
1787                 ax25_info.paclen    = ax25->paclen;
1788                 ax25_info.window    = ax25->window;
1789
1790                 /* old structure? */
1791                 if (cmd == SIOCAX25GETINFOOLD) {
1792                         static int warned = 0;
1793                         if (!warned) {
1794                                 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1795                                         current->comm);
1796                                 warned=1;
1797                         }
1798
1799                         if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1800                                 res = -EFAULT;
1801                                 break;
1802                         }
1803                 } else {
1804                         if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1805                                 res = -EINVAL;
1806                                 break;
1807                         }
1808                 }
1809                 res = 0;
1810                 break;
1811         }
1812
1813         case SIOCAX25ADDFWD:
1814         case SIOCAX25DELFWD: {
1815                 struct ax25_fwd_struct ax25_fwd;
1816                 if (!capable(CAP_NET_ADMIN)) {
1817                         res = -EPERM;
1818                         break;
1819                 }
1820                 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1821                         res = -EFAULT;
1822                         break;
1823                 }
1824                 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1825                 break;
1826         }
1827
1828         case SIOCGIFADDR:
1829         case SIOCSIFADDR:
1830         case SIOCGIFDSTADDR:
1831         case SIOCSIFDSTADDR:
1832         case SIOCGIFBRDADDR:
1833         case SIOCSIFBRDADDR:
1834         case SIOCGIFNETMASK:
1835         case SIOCSIFNETMASK:
1836         case SIOCGIFMETRIC:
1837         case SIOCSIFMETRIC:
1838                 res = -EINVAL;
1839                 break;
1840
1841         default:
1842                 res = -ENOIOCTLCMD;
1843                 break;
1844         }
1845         release_sock(sk);
1846
1847         return res;
1848 }
1849
1850 #ifdef CONFIG_PROC_FS
1851
1852 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1853         __acquires(ax25_list_lock)
1854 {
1855         spin_lock_bh(&ax25_list_lock);
1856         return seq_hlist_start(&ax25_list, *pos);
1857 }
1858
1859 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1860 {
1861         return seq_hlist_next(v, &ax25_list, pos);
1862 }
1863
1864 static void ax25_info_stop(struct seq_file *seq, void *v)
1865         __releases(ax25_list_lock)
1866 {
1867         spin_unlock_bh(&ax25_list_lock);
1868 }
1869
1870 static int ax25_info_show(struct seq_file *seq, void *v)
1871 {
1872         ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
1873         char buf[11];
1874         int k;
1875
1876
1877         /*
1878          * New format:
1879          * 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
1880          */
1881
1882         seq_printf(seq, "%p %s %s%s ",
1883                    ax25,
1884                    ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1885                    ax2asc(buf, &ax25->source_addr),
1886                    ax25->iamdigi? "*":"");
1887         seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1888
1889         for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1890                 seq_printf(seq, ",%s%s",
1891                            ax2asc(buf, &ax25->digipeat->calls[k]),
1892                            ax25->digipeat->repeated[k]? "*":"");
1893         }
1894
1895         seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1896                    ax25->state,
1897                    ax25->vs, ax25->vr, ax25->va,
1898                    ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1899                    ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1900                    ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1901                    ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1902                    ax25->idle / (60 * HZ),
1903                    ax25->n2count, ax25->n2,
1904                    ax25->rtt / HZ,
1905                    ax25->window,
1906                    ax25->paclen);
1907
1908         if (ax25->sk != NULL) {
1909                 seq_printf(seq, " %d %d %lu\n",
1910                            sk_wmem_alloc_get(ax25->sk),
1911                            sk_rmem_alloc_get(ax25->sk),
1912                            sock_i_ino(ax25->sk));
1913         } else {
1914                 seq_puts(seq, " * * *\n");
1915         }
1916         return 0;
1917 }
1918
1919 static const struct seq_operations ax25_info_seqops = {
1920         .start = ax25_info_start,
1921         .next = ax25_info_next,
1922         .stop = ax25_info_stop,
1923         .show = ax25_info_show,
1924 };
1925 #endif
1926
1927 static const struct net_proto_family ax25_family_ops = {
1928         .family =       PF_AX25,
1929         .create =       ax25_create,
1930         .owner  =       THIS_MODULE,
1931 };
1932
1933 static const struct proto_ops ax25_proto_ops = {
1934         .family         = PF_AX25,
1935         .owner          = THIS_MODULE,
1936         .release        = ax25_release,
1937         .bind           = ax25_bind,
1938         .connect        = ax25_connect,
1939         .socketpair     = sock_no_socketpair,
1940         .accept         = ax25_accept,
1941         .getname        = ax25_getname,
1942         .poll           = datagram_poll,
1943         .ioctl          = ax25_ioctl,
1944         .gettstamp      = sock_gettstamp,
1945         .listen         = ax25_listen,
1946         .shutdown       = ax25_shutdown,
1947         .setsockopt     = ax25_setsockopt,
1948         .getsockopt     = ax25_getsockopt,
1949         .sendmsg        = ax25_sendmsg,
1950         .recvmsg        = ax25_recvmsg,
1951         .mmap           = sock_no_mmap,
1952         .sendpage       = sock_no_sendpage,
1953 };
1954
1955 /*
1956  *      Called by socket.c on kernel start up
1957  */
1958 static struct packet_type ax25_packet_type __read_mostly = {
1959         .type   =       cpu_to_be16(ETH_P_AX25),
1960         .func   =       ax25_kiss_rcv,
1961 };
1962
1963 static struct notifier_block ax25_dev_notifier = {
1964         .notifier_call = ax25_device_event,
1965 };
1966
1967 static int __init ax25_init(void)
1968 {
1969         int rc = proto_register(&ax25_proto, 0);
1970
1971         if (rc != 0)
1972                 goto out;
1973
1974         sock_register(&ax25_family_ops);
1975         dev_add_pack(&ax25_packet_type);
1976         register_netdevice_notifier(&ax25_dev_notifier);
1977
1978         proc_create_seq("ax25_route", 0444, init_net.proc_net, &ax25_rt_seqops);
1979         proc_create_seq("ax25", 0444, init_net.proc_net, &ax25_info_seqops);
1980         proc_create_seq("ax25_calls", 0444, init_net.proc_net,
1981                         &ax25_uid_seqops);
1982 out:
1983         return rc;
1984 }
1985 module_init(ax25_init);
1986
1987
1988 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
1989 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
1990 MODULE_LICENSE("GPL");
1991 MODULE_ALIAS_NETPROTO(PF_AX25);
1992
1993 static void __exit ax25_exit(void)
1994 {
1995         remove_proc_entry("ax25_route", init_net.proc_net);
1996         remove_proc_entry("ax25", init_net.proc_net);
1997         remove_proc_entry("ax25_calls", init_net.proc_net);
1998
1999         unregister_netdevice_notifier(&ax25_dev_notifier);
2000
2001         dev_remove_pack(&ax25_packet_type);
2002
2003         sock_unregister(PF_AX25);
2004         proto_unregister(&ax25_proto);
2005
2006         ax25_rt_free();
2007         ax25_uid_free();
2008         ax25_dev_free();
2009 }
2010 module_exit(ax25_exit);