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