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