net/ax25/af_ax25.c

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