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