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;
1131
1132                 case TCP_ESTABLISHED: /* connection established */
1133                         sock->state = SS_CONNECTED;
1134                         goto out;
1135
1136                 case TCP_CLOSE: /* connection refused */
1137                         sock->state = SS_UNCONNECTED;
1138                         err = -ECONNREFUSED;
1139                         goto out;
1140                 }
1141         }
1142
1143         if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1144                 err = -EISCONN; /* No reconnect on a seqpacket socket */
1145                 goto out;
1146         }
1147
1148         sk->sk_state   = TCP_CLOSE;
1149         sock->state = SS_UNCONNECTED;
1150
1151         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;
1163                 }
1164
1165                 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1166                         err = -ENOBUFS;
1167                         goto out;
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;
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;
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;
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;
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;
1259         }
1260
1261         if (sk->sk_state == TCP_SYN_SENT) {
1262                 struct task_struct *tsk = current;
1263                 DECLARE_WAITQUEUE(wait, tsk);
1264
1265                 add_wait_queue(sk->sk_sleep, &wait);
1266                 for (;;) {
1267                         if (sk->sk_state != TCP_SYN_SENT)
1268                                 break;
1269                         set_current_state(TASK_INTERRUPTIBLE);
1270                         release_sock(sk);
1271                         if (!signal_pending(tsk)) {
1272                                 schedule();
1273                                 lock_sock(sk);
1274                                 continue;
1275                         }
1276                         current->state = TASK_RUNNING;
1277                         remove_wait_queue(sk->sk_sleep, &wait);
1278                         return -ERESTARTSYS;
1279                 }
1280                 current->state = TASK_RUNNING;
1281                 remove_wait_queue(sk->sk_sleep, &wait);
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;
1289         }
1290
1291         sock->state = SS_CONNECTED;
1292
1293         err=0;
1294 out:
1295         release_sock(sk);
1296
1297         return err;
1298 }
1299
1300
1301 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1302 {
1303         struct task_struct *tsk = current;
1304         DECLARE_WAITQUEUE(wait, tsk);
1305         struct sk_buff *skb;
1306         struct sock *newsk;
1307         struct sock *sk;
1308         int err = 0;
1309
1310         if (sock->state != SS_UNCONNECTED)
1311                 return -EINVAL;
1312
1313         if ((sk = sock->sk) == NULL)
1314                 return -EINVAL;
1315
1316         lock_sock(sk);
1317         if (sk->sk_type != SOCK_SEQPACKET) {
1318                 err = -EOPNOTSUPP;
1319                 goto out;
1320         }
1321
1322         if (sk->sk_state != TCP_LISTEN) {
1323                 err = -EINVAL;
1324                 goto out;
1325         }
1326
1327         /*
1328          *      The read queue this time is holding sockets ready to use
1329          *      hooked into the SABM we saved
1330          */
1331         add_wait_queue(sk->sk_sleep, &wait);
1332         for (;;) {
1333                 skb = skb_dequeue(&sk->sk_receive_queue);
1334                 if (skb)
1335                         break;
1336
1337                 release_sock(sk);
1338                 current->state = TASK_INTERRUPTIBLE;
1339                 if (flags & O_NONBLOCK) {
1340                         current->state = TASK_RUNNING;
1341                         remove_wait_queue(sk->sk_sleep, &wait);
1342                         return -EWOULDBLOCK;
1343                 }
1344                 if (!signal_pending(tsk)) {
1345                         schedule();
1346                         lock_sock(sk);
1347                         continue;
1348                 }
1349                 current->state = TASK_RUNNING;
1350                 remove_wait_queue(sk->sk_sleep, &wait);
1351                 return -ERESTARTSYS;
1352         }
1353         current->state = TASK_RUNNING;
1354         remove_wait_queue(sk->sk_sleep, &wait);
1355
1356         newsk            = skb->sk;
1357         newsk->sk_socket = newsock;
1358         newsk->sk_sleep  = &newsock->wait;
1359
1360         /* Now attach up the new socket */
1361         kfree_skb(skb);
1362         sk->sk_ack_backlog--;
1363         newsock->sk    = newsk;
1364         newsock->state = SS_CONNECTED;
1365
1366 out:
1367         release_sock(sk);
1368
1369         return err;
1370 }
1371
1372 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1373         int *uaddr_len, int peer)
1374 {
1375         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1376         struct sock *sk = sock->sk;
1377         unsigned char ndigi, i;
1378         ax25_cb *ax25;
1379         int err = 0;
1380
1381         lock_sock(sk);
1382         ax25 = ax25_sk(sk);
1383
1384         if (peer != 0) {
1385                 if (sk->sk_state != TCP_ESTABLISHED) {
1386                         err = -ENOTCONN;
1387                         goto out;
1388                 }
1389
1390                 fsa->fsa_ax25.sax25_family = AF_AX25;
1391                 fsa->fsa_ax25.sax25_call   = ax25->dest_addr;
1392                 fsa->fsa_ax25.sax25_ndigis = 0;
1393
1394                 if (ax25->digipeat != NULL) {
1395                         ndigi = ax25->digipeat->ndigi;
1396                         fsa->fsa_ax25.sax25_ndigis = ndigi;
1397                         for (i = 0; i < ndigi; i++)
1398                                 fsa->fsa_digipeater[i] =
1399                                                 ax25->digipeat->calls[i];
1400                 }
1401         } else {
1402                 fsa->fsa_ax25.sax25_family = AF_AX25;
1403                 fsa->fsa_ax25.sax25_call   = ax25->source_addr;
1404                 fsa->fsa_ax25.sax25_ndigis = 1;
1405                 if (ax25->ax25_dev != NULL) {
1406                         memcpy(&fsa->fsa_digipeater[0],
1407                                ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1408                 } else {
1409                         fsa->fsa_digipeater[0] = null_ax25_address;
1410                 }
1411         }
1412         *uaddr_len = sizeof (struct full_sockaddr_ax25);
1413
1414 out:
1415         release_sock(sk);
1416
1417         return err;
1418 }
1419
1420 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1421                         struct msghdr *msg, size_t len)
1422 {
1423         struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1424         struct sock *sk = sock->sk;
1425         struct sockaddr_ax25 sax;
1426         struct sk_buff *skb;
1427         ax25_digi dtmp, *dp;
1428         unsigned char *asmptr;
1429         ax25_cb *ax25;
1430         size_t size;
1431         int lv, err, addr_len = msg->msg_namelen;
1432
1433         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1434                 return -EINVAL;
1435
1436         lock_sock(sk);
1437         ax25 = ax25_sk(sk);
1438
1439         if (sock_flag(sk, SOCK_ZAPPED)) {
1440                 err = -EADDRNOTAVAIL;
1441                 goto out;
1442         }
1443
1444         if (sk->sk_shutdown & SEND_SHUTDOWN) {
1445                 send_sig(SIGPIPE, current, 0);
1446                 err = -EPIPE;
1447                 goto out;
1448         }
1449
1450         if (ax25->ax25_dev == NULL) {
1451                 err = -ENETUNREACH;
1452                 goto out;
1453         }
1454
1455         if (len > ax25->ax25_dev->dev->mtu) {
1456                 err = -EMSGSIZE;
1457                 goto out;
1458         }
1459
1460         if (usax != NULL) {
1461                 if (usax->sax25_family != AF_AX25) {
1462                         err = -EINVAL;
1463                         goto out;
1464                 }
1465
1466                 if (addr_len == sizeof(struct sockaddr_ax25)) {
1467                         printk(KERN_WARNING "ax25_sendmsg(): %s uses obsolete socket structure\n",
1468                                 current->comm);
1469                 }
1470                 else if (addr_len != sizeof(struct full_sockaddr_ax25)) {
1471                         /* support for old structure may go away some time */
1472                         if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1473                             (addr_len > sizeof(struct full_sockaddr_ax25))) {
1474                                 err = -EINVAL;
1475                                 goto out;
1476                         }
1477
1478                         printk(KERN_WARNING "ax25_sendmsg(): %s uses old (6 digipeater) socket structure.\n",
1479                                 current->comm);
1480                 }
1481
1482                 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1483                         int ct           = 0;
1484                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1485
1486                         /* Valid number of digipeaters ? */
1487                         if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1488                                 err = -EINVAL;
1489                                 goto out;
1490                         }
1491
1492                         dtmp.ndigi      = usax->sax25_ndigis;
1493
1494                         while (ct < usax->sax25_ndigis) {
1495                                 dtmp.repeated[ct] = 0;
1496                                 dtmp.calls[ct]    = fsa->fsa_digipeater[ct];
1497                                 ct++;
1498                         }
1499
1500                         dtmp.lastrepeat = 0;
1501                 }
1502
1503                 sax = *usax;
1504                 if (sk->sk_type == SOCK_SEQPACKET &&
1505                     ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1506                         err = -EISCONN;
1507                         goto out;
1508                 }
1509                 if (usax->sax25_ndigis == 0)
1510                         dp = NULL;
1511                 else
1512                         dp = &dtmp;
1513         } else {
1514                 /*
1515                  *      FIXME: 1003.1g - if the socket is like this because
1516                  *      it has become closed (not started closed) and is VC
1517                  *      we ought to SIGPIPE, EPIPE
1518                  */
1519                 if (sk->sk_state != TCP_ESTABLISHED) {
1520                         err = -ENOTCONN;
1521                         goto out;
1522                 }
1523                 sax.sax25_family = AF_AX25;
1524                 sax.sax25_call   = ax25->dest_addr;
1525                 dp = ax25->digipeat;
1526         }
1527
1528         SOCK_DEBUG(sk, "AX.25: sendto: Addresses built.\n");
1529
1530         /* Build a packet */
1531         SOCK_DEBUG(sk, "AX.25: sendto: building packet.\n");
1532
1533         /* Assume the worst case */
1534         size = len + ax25->ax25_dev->dev->hard_header_len;
1535
1536         skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1537         if (skb == NULL)
1538                 goto out;
1539
1540         skb_reserve(skb, size - len);
1541
1542         SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1543
1544         /* User data follows immediately after the AX.25 data */
1545         if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1546                 err = -EFAULT;
1547                 kfree_skb(skb);
1548                 goto out;
1549         }
1550
1551         skb->nh.raw = skb->data;
1552
1553         /* Add the PID if one is not supplied by the user in the skb */
1554         if (!ax25->pidincl) {
1555                 asmptr  = skb_push(skb, 1);
1556                 *asmptr = sk->sk_protocol;
1557         }
1558
1559         SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1560
1561         if (sk->sk_type == SOCK_SEQPACKET) {
1562                 /* Connected mode sockets go via the LAPB machine */
1563                 if (sk->sk_state != TCP_ESTABLISHED) {
1564                         kfree_skb(skb);
1565                         err = -ENOTCONN;
1566                         goto out;
1567                 }
1568
1569                 /* Shove it onto the queue and kick */
1570                 ax25_output(ax25, ax25->paclen, skb);
1571
1572                 err = len;
1573                 goto out;
1574         }
1575
1576         asmptr = skb_push(skb, 1 + ax25_addr_size(dp));
1577
1578         SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1579
1580         if (dp != NULL)
1581                 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1582
1583         /* Build an AX.25 header */
1584         asmptr += (lv = ax25_addr_build(asmptr, &ax25->source_addr,
1585                                         &sax.sax25_call, dp,
1586                                         AX25_COMMAND, AX25_MODULUS));
1587
1588         SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1589
1590         skb->h.raw = asmptr;
1591
1592         SOCK_DEBUG(sk, "base=%p pos=%p\n", skb->data, asmptr);
1593
1594         *asmptr = AX25_UI;
1595
1596         /* Datagram frames go straight out of the door as UI */
1597         ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1598
1599         err = len;
1600
1601 out:
1602         release_sock(sk);
1603
1604         return err;
1605 }
1606
1607 static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1608         struct msghdr *msg, size_t size, int flags)
1609 {
1610         struct sock *sk = sock->sk;
1611         struct sk_buff *skb;
1612         int copied;
1613         int err = 0;
1614
1615         lock_sock(sk);
1616         /*
1617          *      This works for seqpacket too. The receiver has ordered the
1618          *      queue for us! We do one quick check first though
1619          */
1620         if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1621                 err =  -ENOTCONN;
1622                 goto out;
1623         }
1624
1625         /* Now we can treat all alike */
1626         skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1627                                 flags & MSG_DONTWAIT, &err);
1628         if (skb == NULL)
1629                 goto out;
1630
1631         if (!ax25_sk(sk)->pidincl)
1632                 skb_pull(skb, 1);               /* Remove PID */
1633
1634         skb->h.raw = skb->data;
1635         copied     = skb->len;
1636
1637         if (copied > size) {
1638                 copied = size;
1639                 msg->msg_flags |= MSG_TRUNC;
1640         }
1641
1642         skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1643
1644         if (msg->msg_namelen != 0) {
1645                 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1646                 ax25_digi digi;
1647                 ax25_address src;
1648
1649                 ax25_addr_parse(skb->mac.raw+1, skb->data-skb->mac.raw-1, &src, NULL, &digi, NULL, NULL);
1650
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 SIOCAX25ADDUID:    /* Add a uid to the uid/call map table */
1715         case SIOCAX25DELUID:    /* Delete a uid from the uid/call map table */
1716         case SIOCAX25GETUID: {
1717                 struct sockaddr_ax25 sax25;
1718                 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1719                         res = -EFAULT;
1720                         break;
1721                 }
1722                 res = ax25_uid_ioctl(cmd, &sax25);
1723                 break;
1724         }
1725
1726         case SIOCAX25NOUID: {   /* Set the default policy (default/bar) */
1727                 long amount;
1728                 if (!capable(CAP_NET_ADMIN)) {
1729                         res = -EPERM;
1730                         break;
1731                 }
1732                 if (get_user(amount, (long __user *)argp)) {
1733                         res = -EFAULT;
1734                         break;
1735                 }
1736                 if (amount > AX25_NOUID_BLOCK) {
1737                         res = -EINVAL;
1738                         break;
1739                 }
1740                 ax25_uid_policy = amount;
1741                 res = 0;
1742                 break;
1743         }
1744
1745         case SIOCADDRT:
1746         case SIOCDELRT:
1747         case SIOCAX25OPTRT:
1748                 if (!capable(CAP_NET_ADMIN)) {
1749                         res = -EPERM;
1750                         break;
1751                 }
1752                 res = ax25_rt_ioctl(cmd, argp);
1753                 break;
1754
1755         case SIOCAX25CTLCON:
1756                 if (!capable(CAP_NET_ADMIN)) {
1757                         res = -EPERM;
1758                         break;
1759                 }
1760                 res = ax25_ctl_ioctl(cmd, argp);
1761                 break;
1762
1763         case SIOCAX25GETINFO:
1764         case SIOCAX25GETINFOOLD: {
1765                 ax25_cb *ax25 = ax25_sk(sk);
1766                 struct ax25_info_struct ax25_info;
1767
1768                 ax25_info.t1        = ax25->t1   / HZ;
1769                 ax25_info.t2        = ax25->t2   / HZ;
1770                 ax25_info.t3        = ax25->t3   / HZ;
1771                 ax25_info.idle      = ax25->idle / (60 * HZ);
1772                 ax25_info.n2        = ax25->n2;
1773                 ax25_info.t1timer   = ax25_display_timer(&ax25->t1timer)   / HZ;
1774                 ax25_info.t2timer   = ax25_display_timer(&ax25->t2timer)   / HZ;
1775                 ax25_info.t3timer   = ax25_display_timer(&ax25->t3timer)   / HZ;
1776                 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1777                 ax25_info.n2count   = ax25->n2count;
1778                 ax25_info.state     = ax25->state;
1779                 ax25_info.rcv_q     = atomic_read(&sk->sk_rmem_alloc);
1780                 ax25_info.snd_q     = atomic_read(&sk->sk_wmem_alloc);
1781                 ax25_info.vs        = ax25->vs;
1782                 ax25_info.vr        = ax25->vr;
1783                 ax25_info.va        = ax25->va;
1784                 ax25_info.vs_max    = ax25->vs; /* reserved */
1785                 ax25_info.paclen    = ax25->paclen;
1786                 ax25_info.window    = ax25->window;
1787
1788                 /* old structure? */
1789                 if (cmd == SIOCAX25GETINFOOLD) {
1790                         static int warned = 0;
1791                         if (!warned) {
1792                                 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1793                                         current->comm);
1794                                 warned=1;
1795                         }
1796
1797                         if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1798                                 res = -EFAULT;
1799                                 break;
1800                         }
1801                 } else {
1802                         if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1803                                 res = -EINVAL;
1804                                 break;
1805                         }
1806                 }
1807                 res = 0;
1808                 break;
1809         }
1810
1811         case SIOCAX25ADDFWD:
1812         case SIOCAX25DELFWD: {
1813                 struct ax25_fwd_struct ax25_fwd;
1814                 if (!capable(CAP_NET_ADMIN)) {
1815                         res = -EPERM;
1816                         break;
1817                 }
1818                 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1819                         res = -EFAULT;
1820                         break;
1821                 }
1822                 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1823                 break;
1824         }
1825
1826         case SIOCGIFADDR:
1827         case SIOCSIFADDR:
1828         case SIOCGIFDSTADDR:
1829         case SIOCSIFDSTADDR:
1830         case SIOCGIFBRDADDR:
1831         case SIOCSIFBRDADDR:
1832         case SIOCGIFNETMASK:
1833         case SIOCSIFNETMASK:
1834         case SIOCGIFMETRIC:
1835         case SIOCSIFMETRIC:
1836                 res = -EINVAL;
1837                 break;
1838
1839         default:
1840                 res = -ENOIOCTLCMD;
1841                 break;
1842         }
1843         release_sock(sk);
1844
1845         return res;
1846 }
1847
1848 #ifdef CONFIG_PROC_FS
1849
1850 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1851 {
1852         struct ax25_cb *ax25;
1853         struct hlist_node *node;
1854         int i = 0;
1855
1856         spin_lock_bh(&ax25_list_lock);
1857         ax25_for_each(ax25, node, &ax25_list) {
1858                 if (i == *pos)
1859                         return ax25;
1860                 ++i;
1861         }
1862         return NULL;
1863 }
1864
1865 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1866 {
1867         ++*pos;
1868
1869         return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1870                             struct ax25_cb, ax25_node);
1871 }
1872
1873 static void ax25_info_stop(struct seq_file *seq, void *v)
1874 {
1875         spin_unlock_bh(&ax25_list_lock);
1876 }
1877
1878 static int ax25_info_show(struct seq_file *seq, void *v)
1879 {
1880         ax25_cb *ax25 = v;
1881         char buf[11];
1882         int k;
1883
1884
1885         /*
1886          * New format:
1887          * 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
1888          */
1889
1890         seq_printf(seq, "%8.8lx %s %s%s ",
1891                    (long) ax25,
1892                    ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1893                    ax2asc(buf, &ax25->source_addr),
1894                    ax25->iamdigi? "*":"");
1895         seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1896
1897         for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1898                 seq_printf(seq, ",%s%s",
1899                            ax2asc(buf, &ax25->digipeat->calls[k]),
1900                            ax25->digipeat->repeated[k]? "*":"");
1901         }
1902
1903         seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1904                    ax25->state,
1905                    ax25->vs, ax25->vr, ax25->va,
1906                    ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1907                    ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1908                    ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1909                    ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1910                    ax25->idle / (60 * HZ),
1911                    ax25->n2count, ax25->n2,
1912                    ax25->rtt / HZ,
1913                    ax25->window,
1914                    ax25->paclen);
1915
1916         if (ax25->sk != NULL) {
1917                 bh_lock_sock(ax25->sk);
1918                 seq_printf(seq," %d %d %ld\n",
1919                            atomic_read(&ax25->sk->sk_wmem_alloc),
1920                            atomic_read(&ax25->sk->sk_rmem_alloc),
1921                            ax25->sk->sk_socket != NULL ? SOCK_INODE(ax25->sk->sk_socket)->i_ino : 0L);
1922                 bh_unlock_sock(ax25->sk);
1923         } else {
1924                 seq_puts(seq, " * * *\n");
1925         }
1926         return 0;
1927 }
1928
1929 static struct seq_operations ax25_info_seqops = {
1930         .start = ax25_info_start,
1931         .next = ax25_info_next,
1932         .stop = ax25_info_stop,
1933         .show = ax25_info_show,
1934 };
1935
1936 static int ax25_info_open(struct inode *inode, struct file *file)
1937 {
1938         return seq_open(file, &ax25_info_seqops);
1939 }
1940
1941 static struct file_operations ax25_info_fops = {
1942         .owner = THIS_MODULE,
1943         .open = ax25_info_open,
1944         .read = seq_read,
1945         .llseek = seq_lseek,
1946         .release = seq_release,
1947 };
1948
1949 #endif
1950
1951 static struct net_proto_family ax25_family_ops = {
1952         .family =       PF_AX25,
1953         .create =       ax25_create,
1954         .owner  =       THIS_MODULE,
1955 };
1956
1957 static const struct proto_ops ax25_proto_ops = {
1958         .family         = PF_AX25,
1959         .owner          = THIS_MODULE,
1960         .release        = ax25_release,
1961         .bind           = ax25_bind,
1962         .connect        = ax25_connect,
1963         .socketpair     = sock_no_socketpair,
1964         .accept         = ax25_accept,
1965         .getname        = ax25_getname,
1966         .poll           = datagram_poll,
1967         .ioctl          = ax25_ioctl,
1968         .listen         = ax25_listen,
1969         .shutdown       = ax25_shutdown,
1970         .setsockopt     = ax25_setsockopt,
1971         .getsockopt     = ax25_getsockopt,
1972         .sendmsg        = ax25_sendmsg,
1973         .recvmsg        = ax25_recvmsg,
1974         .mmap           = sock_no_mmap,
1975         .sendpage       = sock_no_sendpage,
1976 };
1977
1978 /*
1979  *      Called by socket.c on kernel start up
1980  */
1981 static struct packet_type ax25_packet_type = {
1982         .type   =       __constant_htons(ETH_P_AX25),
1983         .dev    =       NULL,                           /* All devices */
1984         .func   =       ax25_kiss_rcv,
1985 };
1986
1987 static struct notifier_block ax25_dev_notifier = {
1988         .notifier_call =ax25_device_event,
1989 };
1990
1991 static int __init ax25_init(void)
1992 {
1993         int rc = proto_register(&ax25_proto, 0);
1994
1995         if (rc != 0)
1996                 goto out;
1997
1998         sock_register(&ax25_family_ops);
1999         dev_add_pack(&ax25_packet_type);
2000         register_netdevice_notifier(&ax25_dev_notifier);
2001         ax25_register_sysctl();
2002
2003         proc_net_fops_create("ax25_route", S_IRUGO, &ax25_route_fops);
2004         proc_net_fops_create("ax25", S_IRUGO, &ax25_info_fops);
2005         proc_net_fops_create("ax25_calls", S_IRUGO, &ax25_uid_fops);
2006 out:
2007         return rc;
2008 }
2009 module_init(ax25_init);
2010
2011
2012 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2013 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2014 MODULE_LICENSE("GPL");
2015 MODULE_ALIAS_NETPROTO(PF_AX25);
2016
2017 static void __exit ax25_exit(void)
2018 {
2019         proc_net_remove("ax25_route");
2020         proc_net_remove("ax25");
2021         proc_net_remove("ax25_calls");
2022         ax25_rt_free();
2023         ax25_uid_free();
2024         ax25_dev_free();
2025
2026         ax25_unregister_sysctl();
2027         unregister_netdevice_notifier(&ax25_dev_notifier);
2028
2029         dev_remove_pack(&ax25_packet_type);
2030
2031         sock_unregister(PF_AX25);
2032         proto_unregister(&ax25_proto);
2033 }
2034 module_exit(ax25_exit);