net/ax25/af_ax25.c

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