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