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
 879         if (sock_flag(osk, SOCK_DBG))
 880                 sock_set_flag(sk, SOCK_DBG);
 881
 882         if (sock_flag(osk, SOCK_ZAPPED))
 883                 sock_set_flag(sk, SOCK_ZAPPED);
 884
 885         oax25 = ax25_sk(osk);
 886
 887         ax25->modulus = oax25->modulus;
 888         ax25->backoff = oax25->backoff;
 889         ax25->pidincl = oax25->pidincl;
 890         ax25->iamdigi = oax25->iamdigi;
 891         ax25->rtt     = oax25->rtt;
 892         ax25->t1      = oax25->t1;
 893         ax25->t2      = oax25->t2;
 894         ax25->t3      = oax25->t3;
 895         ax25->n2      = oax25->n2;
 896         ax25->idle    = oax25->idle;
 897         ax25->paclen  = oax25->paclen;
 898         ax25->window  = oax25->window;
 899
 900         ax25->ax25_dev    = ax25_dev;
 901         ax25->source_addr = oax25->source_addr;
 902
 903         if (oax25->digipeat != NULL) {
 904                 if ((ax25->digipeat = kmalloc(sizeof(ax25_digi), GFP_ATOMIC)) == NULL) {
 905                         sk_free(sk);
 906                         ax25_cb_put(ax25);
 907                         return NULL;
 908                 }
 909
 910                 memcpy(ax25->digipeat, oax25->digipeat, sizeof(ax25_digi));
 911         }
 912
 913         sk->sk_protinfo = ax25;
 914         ax25->sk    = sk;
 915
 916         return sk;
 917 }
 918
 919 static int ax25_release(struct socket *sock)
 920 {
 921         struct sock *sk = sock->sk;
 922         ax25_cb *ax25;
 923
 924         if (sk == NULL)
 925                 return 0;
 926
 927         sock_hold(sk);
 928         sock_orphan(sk);
 929         lock_sock(sk);
 930         ax25 = ax25_sk(sk);
 931
 932         if (sk->sk_type == SOCK_SEQPACKET) {
 933                 switch (ax25->state) {
 934                 case AX25_STATE_0:
 935                         release_sock(sk);
 936                         ax25_disconnect(ax25, 0);
 937                         lock_sock(sk);
 938                         ax25_destroy_socket(ax25);
 939                         break;
 940
 941                 case AX25_STATE_1:
 942                 case AX25_STATE_2:
 943                         ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
 944                         release_sock(sk);
 945                         ax25_disconnect(ax25, 0);
 946                         lock_sock(sk);
 947                         ax25_destroy_socket(ax25);
 948                         break;
 949
 950                 case AX25_STATE_3:
 951                 case AX25_STATE_4:
 952                         ax25_clear_queues(ax25);
 953                         ax25->n2count = 0;
 954
 955                         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
 956                         case AX25_PROTO_STD_SIMPLEX:
 957                         case AX25_PROTO_STD_DUPLEX:
 958                                 ax25_send_control(ax25,
 959                                                   AX25_DISC,
 960                                                   AX25_POLLON,
 961                                                   AX25_COMMAND);
 962                                 ax25_stop_t2timer(ax25);
 963                                 ax25_stop_t3timer(ax25);
 964                                 ax25_stop_idletimer(ax25);
 965                                 break;
 966 #ifdef CONFIG_AX25_DAMA_SLAVE
 967                         case AX25_PROTO_DAMA_SLAVE:
 968                                 ax25_stop_t3timer(ax25);
 969                                 ax25_stop_idletimer(ax25);
 970                                 break;
 971 #endif
 972                         }
 973                         ax25_calculate_t1(ax25);
 974                         ax25_start_t1timer(ax25);
 975                         ax25->state = AX25_STATE_2;
 976                         sk->sk_state                = TCP_CLOSE;
 977                         sk->sk_shutdown            |= SEND_SHUTDOWN;
 978                         sk->sk_state_change(sk);
 979                         sock_set_flag(sk, SOCK_DESTROY);
 980                         break;
 981
 982                 default:
 983                         break;
 984                 }
 985         } else {
 986                 sk->sk_state     = TCP_CLOSE;
 987                 sk->sk_shutdown |= SEND_SHUTDOWN;
 988                 sk->sk_state_change(sk);
 989                 ax25_destroy_socket(ax25);
 990         }
 991
 992         sock->sk   = NULL;
 993         release_sock(sk);
 994         sock_put(sk);
 995
 996         return 0;
 997 }
 998
 999 /*
1000  *      We support a funny extension here so you can (as root) give any callsign
1001  *      digipeated via a local address as source. This hack is obsolete now
1002  *      that we've implemented support for SO_BINDTODEVICE. It is however small
1003  *      and trivially backward compatible.
1004  */
1005 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1006 {
1007         struct sock *sk = sock->sk;
1008         struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1009         ax25_dev *ax25_dev = NULL;
1010         ax25_address *call;
1011         ax25_cb *ax25;
1012         int err = 0;
1013
1014         if (addr_len != sizeof(struct sockaddr_ax25) &&
1015             addr_len != sizeof(struct full_sockaddr_ax25)) {
1016                 /* support for old structure may go away some time */
1017                 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1018                     (addr_len > sizeof(struct full_sockaddr_ax25))) {
1019                         return -EINVAL;
1020         }
1021
1022                 printk(KERN_WARNING "ax25_bind(): %s uses old (6 digipeater) socket structure.\n",
1023                         current->comm);
1024         }
1025
1026         if (addr->fsa_ax25.sax25_family != AF_AX25)
1027                 return -EINVAL;
1028
1029         call = ax25_findbyuid(current->euid);
1030         if (call == NULL && ax25_uid_policy && !capable(CAP_NET_ADMIN)) {
1031                 return -EACCES;
1032         }
1033
1034         lock_sock(sk);
1035
1036         ax25 = ax25_sk(sk);
1037         if (!sock_flag(sk, SOCK_ZAPPED)) {
1038                 err = -EINVAL;
1039                 goto out;
1040         }
1041
1042         if (call == NULL)
1043                 ax25->source_addr = addr->fsa_ax25.sax25_call;
1044         else
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         if (ax25->digipeat != NULL) {
1143                 kfree(ax25->digipeat);
1144                 ax25->digipeat = NULL;
1145         }
1146
1147         /*
1148          *      Handle digi-peaters to be used.
1149          */
1150         if (addr_len > sizeof(struct sockaddr_ax25) &&
1151             fsa->fsa_ax25.sax25_ndigis != 0) {
1152                 /* Valid number of digipeaters ? */
1153                 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1154                         err = -EINVAL;
1155                         goto out;
1156                 }
1157
1158                 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1159                         err = -ENOBUFS;
1160                         goto out;
1161                 }
1162
1163                 digi->ndigi      = fsa->fsa_ax25.sax25_ndigis;
1164                 digi->lastrepeat = -1;
1165
1166                 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1167                         if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1168                              AX25_HBIT) && ax25->iamdigi) {
1169                                 digi->repeated[ct] = 1;
1170                                 digi->lastrepeat   = ct;
1171                         } else {
1172                                 digi->repeated[ct] = 0;
1173                         }
1174                         digi->calls[ct] = fsa->fsa_digipeater[ct];
1175                         ct++;
1176                 }
1177         }
1178
1179         /*
1180          *      Must bind first - autobinding in this may or may not work. If
1181          *      the socket is already bound, check to see if the device has
1182          *      been filled in, error if it hasn't.
1183          */
1184         if (sock_flag(sk, SOCK_ZAPPED)) {
1185                 /* check if we can remove this feature. It is broken. */
1186                 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1187                         current->comm);
1188                 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1189                         kfree(digi);
1190                         goto out;
1191                 }
1192
1193                 ax25_fillin_cb(ax25, ax25->ax25_dev);
1194                 ax25_cb_add(ax25);
1195         } else {
1196                 if (ax25->ax25_dev == NULL) {
1197                         kfree(digi);
1198                         err = -EHOSTUNREACH;
1199                         goto out;
1200                 }
1201         }
1202
1203         if (sk->sk_type == SOCK_SEQPACKET &&
1204             (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1205                          ax25->ax25_dev->dev))) {
1206                 kfree(digi);
1207                 err = -EADDRINUSE;              /* Already such a connection */
1208                 ax25_cb_put(ax25t);
1209                 goto out;
1210         }
1211
1212         ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1213         ax25->digipeat  = digi;
1214
1215         /* First the easy one */
1216         if (sk->sk_type != SOCK_SEQPACKET) {
1217                 sock->state = SS_CONNECTED;
1218                 sk->sk_state   = TCP_ESTABLISHED;
1219                 goto out;
1220         }
1221
1222         /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1223         sock->state        = SS_CONNECTING;
1224         sk->sk_state          = TCP_SYN_SENT;
1225
1226         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1227         case AX25_PROTO_STD_SIMPLEX:
1228         case AX25_PROTO_STD_DUPLEX:
1229                 ax25_std_establish_data_link(ax25);
1230                 break;
1231
1232 #ifdef CONFIG_AX25_DAMA_SLAVE
1233         case AX25_PROTO_DAMA_SLAVE:
1234                 ax25->modulus = AX25_MODULUS;
1235                 ax25->window  = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1236                 if (ax25->ax25_dev->dama.slave)
1237                         ax25_ds_establish_data_link(ax25);
1238                 else
1239                         ax25_std_establish_data_link(ax25);
1240                 break;
1241 #endif
1242         }
1243
1244         ax25->state = AX25_STATE_1;
1245
1246         ax25_start_heartbeat(ax25);
1247
1248         /* Now the loop */
1249         if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1250                 err = -EINPROGRESS;
1251                 goto out;
1252         }
1253
1254         if (sk->sk_state == TCP_SYN_SENT) {
1255                 struct task_struct *tsk = current;
1256                 DECLARE_WAITQUEUE(wait, tsk);
1257
1258                 add_wait_queue(sk->sk_sleep, &wait);
1259                 for (;;) {
1260                         if (sk->sk_state != TCP_SYN_SENT)
1261                                 break;
1262                         set_current_state(TASK_INTERRUPTIBLE);
1263                         release_sock(sk);
1264                         if (!signal_pending(tsk)) {
1265                                 schedule();
1266                                 lock_sock(sk);
1267                                 continue;
1268                         }
1269                         current->state = TASK_RUNNING;
1270                         remove_wait_queue(sk->sk_sleep, &wait);
1271                         return -ERESTARTSYS;
1272                 }
1273                 current->state = TASK_RUNNING;
1274                 remove_wait_queue(sk->sk_sleep, &wait);
1275         }
1276
1277         if (sk->sk_state != TCP_ESTABLISHED) {
1278                 /* Not in ABM, not in WAIT_UA -> failed */
1279                 sock->state = SS_UNCONNECTED;
1280                 err = sock_error(sk);   /* Always set at this point */
1281                 goto out;
1282         }
1283
1284         sock->state = SS_CONNECTED;
1285
1286         err=0;
1287 out:
1288         release_sock(sk);
1289
1290         return err;
1291 }
1292
1293
1294 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1295 {
1296         struct task_struct *tsk = current;
1297         DECLARE_WAITQUEUE(wait, tsk);
1298         struct sk_buff *skb;
1299         struct sock *newsk;
1300         struct sock *sk;
1301         int err = 0;
1302
1303         if (sock->state != SS_UNCONNECTED)
1304                 return -EINVAL;
1305
1306         if ((sk = sock->sk) == NULL)
1307                 return -EINVAL;
1308
1309         lock_sock(sk);
1310         if (sk->sk_type != SOCK_SEQPACKET) {
1311                 err = -EOPNOTSUPP;
1312                 goto out;
1313         }
1314
1315         if (sk->sk_state != TCP_LISTEN) {
1316                 err = -EINVAL;
1317                 goto out;
1318         }
1319
1320         /*
1321          *      The read queue this time is holding sockets ready to use
1322          *      hooked into the SABM we saved
1323          */
1324         add_wait_queue(sk->sk_sleep, &wait);
1325         for (;;) {
1326                 skb = skb_dequeue(&sk->sk_receive_queue);
1327                 if (skb)
1328                         break;
1329
1330                 release_sock(sk);
1331                 current->state = TASK_INTERRUPTIBLE;
1332                 if (flags & O_NONBLOCK) {
1333                         current->state = TASK_RUNNING;
1334                         remove_wait_queue(sk->sk_sleep, &wait);
1335                         return -EWOULDBLOCK;
1336                 }
1337                 if (!signal_pending(tsk)) {
1338                         schedule();
1339                         lock_sock(sk);
1340                         continue;
1341                 }
1342                 current->state = TASK_RUNNING;
1343                 remove_wait_queue(sk->sk_sleep, &wait);
1344                 return -ERESTARTSYS;
1345         }
1346         current->state = TASK_RUNNING;
1347         remove_wait_queue(sk->sk_sleep, &wait);
1348
1349         newsk            = skb->sk;
1350         newsk->sk_socket = newsock;
1351         newsk->sk_sleep  = &newsock->wait;
1352
1353         /* Now attach up the new socket */
1354         kfree_skb(skb);
1355         sk->sk_ack_backlog--;
1356         newsock->sk    = newsk;
1357         newsock->state = SS_CONNECTED;
1358
1359 out:
1360         release_sock(sk);
1361
1362         return err;
1363 }
1364
1365 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1366         int *uaddr_len, int peer)
1367 {
1368         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1369         struct sock *sk = sock->sk;
1370         unsigned char ndigi, i;
1371         ax25_cb *ax25;
1372         int err = 0;
1373
1374         lock_sock(sk);
1375         ax25 = ax25_sk(sk);
1376
1377         if (peer != 0) {
1378                 if (sk->sk_state != TCP_ESTABLISHED) {
1379                         err = -ENOTCONN;
1380                         goto out;
1381                 }
1382
1383                 fsa->fsa_ax25.sax25_family = AF_AX25;
1384                 fsa->fsa_ax25.sax25_call   = ax25->dest_addr;
1385                 fsa->fsa_ax25.sax25_ndigis = 0;
1386
1387                 if (ax25->digipeat != NULL) {
1388                         ndigi = ax25->digipeat->ndigi;
1389                         fsa->fsa_ax25.sax25_ndigis = ndigi;
1390                         for (i = 0; i < ndigi; i++)
1391                                 fsa->fsa_digipeater[i] =
1392                                                 ax25->digipeat->calls[i];
1393                 }
1394         } else {
1395                 fsa->fsa_ax25.sax25_family = AF_AX25;
1396                 fsa->fsa_ax25.sax25_call   = ax25->source_addr;
1397                 fsa->fsa_ax25.sax25_ndigis = 1;
1398                 if (ax25->ax25_dev != NULL) {
1399                         memcpy(&fsa->fsa_digipeater[0],
1400                                ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1401                 } else {
1402                         fsa->fsa_digipeater[0] = null_ax25_address;
1403                 }
1404         }
1405         *uaddr_len = sizeof (struct full_sockaddr_ax25);
1406
1407 out:
1408         release_sock(sk);
1409
1410         return err;
1411 }
1412
1413 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1414                         struct msghdr *msg, size_t len)
1415 {
1416         struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1417         struct sock *sk = sock->sk;
1418         struct sockaddr_ax25 sax;
1419         struct sk_buff *skb;
1420         ax25_digi dtmp, *dp;
1421         unsigned char *asmptr;
1422         ax25_cb *ax25;
1423         size_t size;
1424         int lv, err, addr_len = msg->msg_namelen;
1425
1426         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1427                 return -EINVAL;
1428
1429         lock_sock(sk);
1430         ax25 = ax25_sk(sk);
1431
1432         if (sock_flag(sk, SOCK_ZAPPED)) {
1433                 err = -EADDRNOTAVAIL;
1434                 goto out;
1435         }
1436
1437         if (sk->sk_shutdown & SEND_SHUTDOWN) {
1438                 send_sig(SIGPIPE, current, 0);
1439                 err = -EPIPE;
1440                 goto out;
1441         }
1442
1443         if (ax25->ax25_dev == NULL) {
1444                 err = -ENETUNREACH;
1445                 goto out;
1446         }
1447
1448         if (len > ax25->ax25_dev->dev->mtu) {
1449                 err = -EMSGSIZE;
1450                 goto out;
1451         }
1452
1453         if (usax != NULL) {
1454                 if (usax->sax25_family != AF_AX25) {
1455                         err = -EINVAL;
1456                         goto out;
1457                 }
1458
1459                 if (addr_len == sizeof(struct sockaddr_ax25)) {
1460                         printk(KERN_WARNING "ax25_sendmsg(): %s uses obsolete socket structure\n",
1461                                 current->comm);
1462                 }
1463                 else if (addr_len != sizeof(struct full_sockaddr_ax25)) {
1464                         /* support for old structure may go away some time */
1465                         if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1466                             (addr_len > sizeof(struct full_sockaddr_ax25))) {
1467                                 err = -EINVAL;
1468                                 goto out;
1469                         }
1470
1471                         printk(KERN_WARNING "ax25_sendmsg(): %s uses old (6 digipeater) socket structure.\n",
1472                                 current->comm);
1473                 }
1474
1475                 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1476                         int ct           = 0;
1477                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1478
1479                         /* Valid number of digipeaters ? */
1480                         if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1481                                 err = -EINVAL;
1482                                 goto out;
1483                         }
1484
1485                         dtmp.ndigi      = usax->sax25_ndigis;
1486
1487                         while (ct < usax->sax25_ndigis) {
1488                                 dtmp.repeated[ct] = 0;
1489                                 dtmp.calls[ct]    = fsa->fsa_digipeater[ct];
1490                                 ct++;
1491                         }
1492
1493                         dtmp.lastrepeat = 0;
1494                 }
1495
1496                 sax = *usax;
1497                 if (sk->sk_type == SOCK_SEQPACKET &&
1498                     ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1499                         err = -EISCONN;
1500                         goto out;
1501                 }
1502                 if (usax->sax25_ndigis == 0)
1503                         dp = NULL;
1504                 else
1505                         dp = &dtmp;
1506         } else {
1507                 /*
1508                  *      FIXME: 1003.1g - if the socket is like this because
1509                  *      it has become closed (not started closed) and is VC
1510                  *      we ought to SIGPIPE, EPIPE
1511                  */
1512                 if (sk->sk_state != TCP_ESTABLISHED) {
1513                         err = -ENOTCONN;
1514                         goto out;
1515                 }
1516                 sax.sax25_family = AF_AX25;
1517                 sax.sax25_call   = ax25->dest_addr;
1518                 dp = ax25->digipeat;
1519         }
1520
1521         SOCK_DEBUG(sk, "AX.25: sendto: Addresses built.\n");
1522
1523         /* Build a packet */
1524         SOCK_DEBUG(sk, "AX.25: sendto: building packet.\n");
1525
1526         /* Assume the worst case */
1527         size = len + ax25->ax25_dev->dev->hard_header_len;
1528
1529         skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1530         if (skb == NULL)
1531                 goto out;
1532
1533         skb_reserve(skb, size - len);
1534
1535         SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1536
1537         /* User data follows immediately after the AX.25 data */
1538         if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1539                 err = -EFAULT;
1540                 kfree_skb(skb);
1541                 goto out;
1542         }
1543
1544         skb->nh.raw = skb->data;
1545
1546         /* Add the PID if one is not supplied by the user in the skb */
1547         if (!ax25->pidincl) {
1548                 asmptr  = skb_push(skb, 1);
1549                 *asmptr = sk->sk_protocol;
1550         }
1551
1552         SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1553
1554         if (sk->sk_type == SOCK_SEQPACKET) {
1555                 /* Connected mode sockets go via the LAPB machine */
1556                 if (sk->sk_state != TCP_ESTABLISHED) {
1557                         kfree_skb(skb);
1558                         err = -ENOTCONN;
1559                         goto out;
1560                 }
1561
1562                 /* Shove it onto the queue and kick */
1563                 ax25_output(ax25, ax25->paclen, skb);
1564
1565                 err = len;
1566                 goto out;
1567         }
1568
1569         asmptr = skb_push(skb, 1 + ax25_addr_size(dp));
1570
1571         SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1572
1573         if (dp != NULL)
1574                 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1575
1576         /* Build an AX.25 header */
1577         asmptr += (lv = ax25_addr_build(asmptr, &ax25->source_addr,
1578                                         &sax.sax25_call, dp,
1579                                         AX25_COMMAND, AX25_MODULUS));
1580
1581         SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1582
1583         skb->h.raw = asmptr;
1584
1585         SOCK_DEBUG(sk, "base=%p pos=%p\n", skb->data, asmptr);
1586
1587         *asmptr = AX25_UI;
1588
1589         /* Datagram frames go straight out of the door as UI */
1590         ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1591
1592         err = len;
1593
1594 out:
1595         release_sock(sk);
1596
1597         return err;
1598 }
1599
1600 static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1601         struct msghdr *msg, size_t size, int flags)
1602 {
1603         struct sock *sk = sock->sk;
1604         struct sk_buff *skb;
1605         int copied;
1606         int err = 0;
1607
1608         lock_sock(sk);
1609         /*
1610          *      This works for seqpacket too. The receiver has ordered the
1611          *      queue for us! We do one quick check first though
1612          */
1613         if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1614                 err =  -ENOTCONN;
1615                 goto out;
1616         }
1617
1618         /* Now we can treat all alike */
1619         skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1620                                 flags & MSG_DONTWAIT, &err);
1621         if (skb == NULL)
1622                 goto out;
1623
1624         if (!ax25_sk(sk)->pidincl)
1625                 skb_pull(skb, 1);               /* Remove PID */
1626
1627         skb->h.raw = skb->data;
1628         copied     = skb->len;
1629
1630         if (copied > size) {
1631                 copied = size;
1632                 msg->msg_flags |= MSG_TRUNC;
1633         }
1634
1635         skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1636
1637         if (msg->msg_namelen != 0) {
1638                 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1639                 ax25_digi digi;
1640                 ax25_address src;
1641
1642                 ax25_addr_parse(skb->mac.raw+1, skb->data-skb->mac.raw-1, &src, NULL, &digi, NULL, NULL);
1643
1644                 sax->sax25_family = AF_AX25;
1645                 /* We set this correctly, even though we may not let the
1646                    application know the digi calls further down (because it
1647                    did NOT ask to know them).  This could get political... **/
1648                 sax->sax25_ndigis = digi.ndigi;
1649                 sax->sax25_call   = src;
1650
1651                 if (sax->sax25_ndigis != 0) {
1652                         int ct;
1653                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1654
1655                         for (ct = 0; ct < digi.ndigi; ct++)
1656                                 fsa->fsa_digipeater[ct] = digi.calls[ct];
1657                 }
1658                 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1659         }
1660
1661         skb_free_datagram(sk, skb);
1662         err = copied;
1663
1664 out:
1665         release_sock(sk);
1666
1667         return err;
1668 }
1669
1670 static int ax25_shutdown(struct socket *sk, int how)
1671 {
1672         /* FIXME - generate DM and RNR states */
1673         return -EOPNOTSUPP;
1674 }
1675
1676 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1677 {
1678         struct sock *sk = sock->sk;
1679         void __user *argp = (void __user *)arg;
1680         int res = 0;
1681
1682         lock_sock(sk);
1683         switch (cmd) {
1684         case TIOCOUTQ: {
1685                 long amount;
1686                 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1687                 if (amount < 0)
1688                         amount = 0;
1689                 res = put_user(amount, (int __user *)argp);
1690                 break;
1691         }
1692
1693         case TIOCINQ: {
1694                 struct sk_buff *skb;
1695                 long amount = 0L;
1696                 /* These two are safe on a single CPU system as only user tasks fiddle here */
1697                 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1698                         amount = skb->len;
1699                 res = put_user(amount, (int __user *)argp);
1700                 break;
1701         }
1702
1703         case SIOCGSTAMP:
1704                 if (sk != NULL) {
1705                         res = sock_get_timestamp(sk, argp);
1706                         break;
1707                 }
1708                 res = -EINVAL;
1709                 break;
1710
1711         case SIOCAX25ADDUID:    /* Add a uid to the uid/call map table */
1712         case SIOCAX25DELUID:    /* Delete a uid from the uid/call map table */
1713         case SIOCAX25GETUID: {
1714                 struct sockaddr_ax25 sax25;
1715                 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1716                         res = -EFAULT;
1717                         break;
1718                 }
1719                 res = ax25_uid_ioctl(cmd, &sax25);
1720                 break;
1721         }
1722
1723         case SIOCAX25NOUID: {   /* Set the default policy (default/bar) */
1724                 long amount;
1725                 if (!capable(CAP_NET_ADMIN)) {
1726                         res = -EPERM;
1727                         break;
1728                 }
1729                 if (get_user(amount, (long __user *)argp)) {
1730                         res = -EFAULT;
1731                         break;
1732                 }
1733                 if (amount > AX25_NOUID_BLOCK) {
1734                         res = -EINVAL;
1735                         break;
1736                 }
1737                 ax25_uid_policy = amount;
1738                 res = 0;
1739                 break;
1740         }
1741
1742         case SIOCADDRT:
1743         case SIOCDELRT:
1744         case SIOCAX25OPTRT:
1745                 if (!capable(CAP_NET_ADMIN)) {
1746                         res = -EPERM;
1747                         break;
1748                 }
1749                 res = ax25_rt_ioctl(cmd, argp);
1750                 break;
1751
1752         case SIOCAX25CTLCON:
1753                 if (!capable(CAP_NET_ADMIN)) {
1754                         res = -EPERM;
1755                         break;
1756                 }
1757                 res = ax25_ctl_ioctl(cmd, argp);
1758                 break;
1759
1760         case SIOCAX25GETINFO:
1761         case SIOCAX25GETINFOOLD: {
1762                 ax25_cb *ax25 = ax25_sk(sk);
1763                 struct ax25_info_struct ax25_info;
1764
1765                 ax25_info.t1        = ax25->t1   / HZ;
1766                 ax25_info.t2        = ax25->t2   / HZ;
1767                 ax25_info.t3        = ax25->t3   / HZ;
1768                 ax25_info.idle      = ax25->idle / (60 * HZ);
1769                 ax25_info.n2        = ax25->n2;
1770                 ax25_info.t1timer   = ax25_display_timer(&ax25->t1timer)   / HZ;
1771                 ax25_info.t2timer   = ax25_display_timer(&ax25->t2timer)   / HZ;
1772                 ax25_info.t3timer   = ax25_display_timer(&ax25->t3timer)   / HZ;
1773                 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1774                 ax25_info.n2count   = ax25->n2count;
1775                 ax25_info.state     = ax25->state;
1776                 ax25_info.rcv_q     = atomic_read(&sk->sk_rmem_alloc);
1777                 ax25_info.snd_q     = atomic_read(&sk->sk_wmem_alloc);
1778                 ax25_info.vs        = ax25->vs;
1779                 ax25_info.vr        = ax25->vr;
1780                 ax25_info.va        = ax25->va;
1781                 ax25_info.vs_max    = ax25->vs; /* reserved */
1782                 ax25_info.paclen    = ax25->paclen;
1783                 ax25_info.window    = ax25->window;
1784
1785                 /* old structure? */
1786                 if (cmd == SIOCAX25GETINFOOLD) {
1787                         static int warned = 0;
1788                         if (!warned) {
1789                                 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1790                                         current->comm);
1791                                 warned=1;
1792                         }
1793
1794                         if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1795                                 res = -EFAULT;
1796                                 break;
1797                         }
1798                 } else {
1799                         if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1800                                 res = -EINVAL;
1801                                 break;
1802                         }
1803                 }
1804                 res = 0;
1805                 break;
1806         }
1807
1808         case SIOCAX25ADDFWD:
1809         case SIOCAX25DELFWD: {
1810                 struct ax25_fwd_struct ax25_fwd;
1811                 if (!capable(CAP_NET_ADMIN)) {
1812                         res = -EPERM;
1813                         break;
1814                 }
1815                 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1816                         res = -EFAULT;
1817                         break;
1818                 }
1819                 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1820                 break;
1821         }
1822
1823         case SIOCGIFADDR:
1824         case SIOCSIFADDR:
1825         case SIOCGIFDSTADDR:
1826         case SIOCSIFDSTADDR:
1827         case SIOCGIFBRDADDR:
1828         case SIOCSIFBRDADDR:
1829         case SIOCGIFNETMASK:
1830         case SIOCSIFNETMASK:
1831         case SIOCGIFMETRIC:
1832         case SIOCSIFMETRIC:
1833                 res = -EINVAL;
1834                 break;
1835
1836         default:
1837                 res = dev_ioctl(cmd, argp);
1838                 break;
1839         }
1840         release_sock(sk);
1841
1842         return res;
1843 }
1844
1845 #ifdef CONFIG_PROC_FS
1846
1847 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1848 {
1849         struct ax25_cb *ax25;
1850         struct hlist_node *node;
1851         int i = 0;
1852
1853         spin_lock_bh(&ax25_list_lock);
1854         ax25_for_each(ax25, node, &ax25_list) {
1855                 if (i == *pos)
1856                         return ax25;
1857                 ++i;
1858         }
1859         return NULL;
1860 }
1861
1862 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1863 {
1864         ++*pos;
1865
1866         return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1867                             struct ax25_cb, ax25_node);
1868 }
1869
1870 static void ax25_info_stop(struct seq_file *seq, void *v)
1871 {
1872         spin_unlock_bh(&ax25_list_lock);
1873 }
1874
1875 static int ax25_info_show(struct seq_file *seq, void *v)
1876 {
1877         ax25_cb *ax25 = v;
1878         int k;
1879
1880
1881         /*
1882          * New format:
1883          * 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
1884          */
1885
1886         seq_printf(seq, "%8.8lx %s %s%s ",
1887                    (long) ax25,
1888                    ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1889                    ax2asc(&ax25->source_addr),
1890                    ax25->iamdigi? "*":"");
1891         seq_printf(seq, "%s", ax2asc(&ax25->dest_addr));
1892
1893         for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1894                 seq_printf(seq, ",%s%s",
1895                            ax2asc(&ax25->digipeat->calls[k]),
1896                            ax25->digipeat->repeated[k]? "*":"");
1897         }
1898
1899         seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1900                    ax25->state,
1901                    ax25->vs, ax25->vr, ax25->va,
1902                    ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1903                    ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1904                    ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1905                    ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1906                    ax25->idle / (60 * HZ),
1907                    ax25->n2count, ax25->n2,
1908                    ax25->rtt / HZ,
1909                    ax25->window,
1910                    ax25->paclen);
1911
1912         if (ax25->sk != NULL) {
1913                 bh_lock_sock(ax25->sk);
1914                 seq_printf(seq," %d %d %ld\n",
1915                            atomic_read(&ax25->sk->sk_wmem_alloc),
1916                            atomic_read(&ax25->sk->sk_rmem_alloc),
1917                            ax25->sk->sk_socket != NULL ? SOCK_INODE(ax25->sk->sk_socket)->i_ino : 0L);
1918                 bh_unlock_sock(ax25->sk);
1919         } else {
1920                 seq_puts(seq, " * * *\n");
1921         }
1922         return 0;
1923 }
1924
1925 static struct seq_operations ax25_info_seqops = {
1926         .start = ax25_info_start,
1927         .next = ax25_info_next,
1928         .stop = ax25_info_stop,
1929         .show = ax25_info_show,
1930 };
1931
1932 static int ax25_info_open(struct inode *inode, struct file *file)
1933 {
1934         return seq_open(file, &ax25_info_seqops);
1935 }
1936
1937 static struct file_operations ax25_info_fops = {
1938         .owner = THIS_MODULE,
1939         .open = ax25_info_open,
1940         .read = seq_read,
1941         .llseek = seq_lseek,
1942         .release = seq_release,
1943 };
1944
1945 #endif
1946
1947 static struct net_proto_family ax25_family_ops = {
1948         .family =       PF_AX25,
1949         .create =       ax25_create,
1950         .owner  =       THIS_MODULE,
1951 };
1952
1953 static struct proto_ops ax25_proto_ops = {
1954         .family =       PF_AX25,
1955         .owner =        THIS_MODULE,
1956         .release =      ax25_release,
1957         .bind =         ax25_bind,
1958         .connect =      ax25_connect,
1959         .socketpair =   sock_no_socketpair,
1960         .accept =       ax25_accept,
1961         .getname =      ax25_getname,
1962         .poll =         datagram_poll,
1963         .ioctl =        ax25_ioctl,
1964         .listen =       ax25_listen,
1965         .shutdown =     ax25_shutdown,
1966         .setsockopt =   ax25_setsockopt,
1967         .getsockopt =   ax25_getsockopt,
1968         .sendmsg =      ax25_sendmsg,
1969         .recvmsg =      ax25_recvmsg,
1970         .mmap =         sock_no_mmap,
1971         .sendpage =     sock_no_sendpage,
1972 };
1973
1974 /*
1975  *      Called by socket.c on kernel start up
1976  */
1977 static struct packet_type ax25_packet_type = {
1978         .type   =       __constant_htons(ETH_P_AX25),
1979         .dev    =       NULL,                           /* All devices */
1980         .func   =       ax25_kiss_rcv,
1981 };
1982
1983 static struct notifier_block ax25_dev_notifier = {
1984         .notifier_call =ax25_device_event,
1985 };
1986
1987 EXPORT_SYMBOL(ax25_encapsulate);
1988 EXPORT_SYMBOL(ax25_rebuild_header);
1989 EXPORT_SYMBOL(ax25_findbyuid);
1990 EXPORT_SYMBOL(ax25_find_cb);
1991 EXPORT_SYMBOL(ax25_linkfail_register);
1992 EXPORT_SYMBOL(ax25_linkfail_release);
1993 EXPORT_SYMBOL(ax25_listen_register);
1994 EXPORT_SYMBOL(ax25_listen_release);
1995 EXPORT_SYMBOL(ax25_protocol_register);
1996 EXPORT_SYMBOL(ax25_protocol_release);
1997 EXPORT_SYMBOL(ax25_send_frame);
1998 EXPORT_SYMBOL(ax25_uid_policy);
1999 EXPORT_SYMBOL(ax25cmp);
2000 EXPORT_SYMBOL(ax2asc);
2001 EXPORT_SYMBOL(asc2ax);
2002 EXPORT_SYMBOL(null_ax25_address);
2003 EXPORT_SYMBOL(ax25_display_timer);
2004
2005 static int __init ax25_init(void)
2006 {
2007         int rc = proto_register(&ax25_proto, 0);
2008
2009         if (rc != 0)
2010                 goto out;
2011
2012         sock_register(&ax25_family_ops);
2013         dev_add_pack(&ax25_packet_type);
2014         register_netdevice_notifier(&ax25_dev_notifier);
2015         ax25_register_sysctl();
2016
2017         proc_net_fops_create("ax25_route", S_IRUGO, &ax25_route_fops);
2018         proc_net_fops_create("ax25", S_IRUGO, &ax25_info_fops);
2019         proc_net_fops_create("ax25_calls", S_IRUGO, &ax25_uid_fops);
2020 out:
2021         return rc;
2022 }
2023 module_init(ax25_init);
2024
2025
2026 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2027 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2028 MODULE_LICENSE("GPL");
2029 MODULE_ALIAS_NETPROTO(PF_AX25);
2030
2031 static void __exit ax25_exit(void)
2032 {
2033         proc_net_remove("ax25_route");
2034         proc_net_remove("ax25");
2035         proc_net_remove("ax25_calls");
2036         ax25_rt_free();
2037         ax25_uid_free();
2038         ax25_dev_free();
2039
2040         ax25_unregister_sysctl();
2041         unregister_netdevice_notifier(&ax25_dev_notifier);
2042
2043         dev_remove_pack(&ax25_packet_type);
2044
2045         sock_unregister(PF_AX25);
2046         proto_unregister(&ax25_proto);
2047 }
2048 module_exit(ax25_exit);