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