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