err.no Git - linux-2.6/blob - net/ax25/af_ax25.c

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