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