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