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