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