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