git.oblomov.eu Git - linux-2.6/blob - net/ax25/af_ax25.c

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