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

   1 /*
   2  * This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 2 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
   8  * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
   9  * Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk)
  10  * Copyright (C) Steven Whitehouse GW7RRM (stevew@acm.org)
  11  * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
  12  * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
  13  * Copyright (C) Hans Alblas PE1AYX (hans@esrac.ele.tue.nl)
  14  * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
  15  */
  16 #include <linux/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 (!net_eq(dev_net(dev), &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                                 /* 9A4GL: hack to release unaccepted sockets */
 321                                 skb->sk->sk_state = TCP_LISTEN;
 322
 323                                 ax25_start_heartbeat(sax25);
 324                                 sax25->state = AX25_STATE_0;
 325                         }
 326
 327                         kfree_skb(skb);
 328                 }
 329                 skb_queue_purge(&ax25->sk->sk_write_queue);
 330         }
 331
 332         if (ax25->sk != NULL) {
 333                 if (atomic_read(&ax25->sk->sk_wmem_alloc) ||
 334                     atomic_read(&ax25->sk->sk_rmem_alloc)) {
 335                         /* Defer: outstanding buffers */
 336                         setup_timer(&ax25->dtimer, ax25_destroy_timer,
 337                                         (unsigned long)ax25);
 338                         ax25->dtimer.expires  = jiffies + 2 * HZ;
 339                         add_timer(&ax25->dtimer);
 340                 } else {
 341                         struct sock *sk=ax25->sk;
 342                         ax25->sk=NULL;
 343                         sock_put(sk);
 344                 }
 345         } else {
 346                 ax25_cb_put(ax25);
 347         }
 348 }
 349
 350 /*
 351  * dl1bke 960311: set parameters for existing AX.25 connections,
 352  *                includes a KILL command to abort any connection.
 353  *                VERY useful for debugging ;-)
 354  */
 355 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
 356 {
 357         struct ax25_ctl_struct ax25_ctl;
 358         ax25_digi digi;
 359         ax25_dev *ax25_dev;
 360         ax25_cb *ax25;
 361         unsigned int k;
 362
 363         if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
 364                 return -EFAULT;
 365
 366         if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
 367                 return -ENODEV;
 368
 369         if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
 370                 return -EINVAL;
 371
 372         digi.ndigi = ax25_ctl.digi_count;
 373         for (k = 0; k < digi.ndigi; k++)
 374                 digi.calls[k] = ax25_ctl.digi_addr[k];
 375
 376         if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
 377                 return -ENOTCONN;
 378
 379         switch (ax25_ctl.cmd) {
 380         case AX25_KILL:
 381                 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
 382 #ifdef CONFIG_AX25_DAMA_SLAVE
 383                 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
 384                         ax25_dama_off(ax25);
 385 #endif
 386                 ax25_disconnect(ax25, ENETRESET);
 387                 break;
 388
 389         case AX25_WINDOW:
 390                 if (ax25->modulus == AX25_MODULUS) {
 391                         if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
 392                                 return -EINVAL;
 393                 } else {
 394                         if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
 395                                 return -EINVAL;
 396                 }
 397                 ax25->window = ax25_ctl.arg;
 398                 break;
 399
 400         case AX25_T1:
 401                 if (ax25_ctl.arg < 1)
 402                         return -EINVAL;
 403                 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
 404                 ax25->t1  = ax25_ctl.arg * HZ;
 405                 break;
 406
 407         case AX25_T2:
 408                 if (ax25_ctl.arg < 1)
 409                         return -EINVAL;
 410                 ax25->t2 = ax25_ctl.arg * HZ;
 411                 break;
 412
 413         case AX25_N2:
 414                 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
 415                         return -EINVAL;
 416                 ax25->n2count = 0;
 417                 ax25->n2 = ax25_ctl.arg;
 418                 break;
 419
 420         case AX25_T3:
 421                 if (ax25_ctl.arg < 0)
 422                         return -EINVAL;
 423                 ax25->t3 = ax25_ctl.arg * HZ;
 424                 break;
 425
 426         case AX25_IDLE:
 427                 if (ax25_ctl.arg < 0)
 428                         return -EINVAL;
 429                 ax25->idle = ax25_ctl.arg * 60 * HZ;
 430                 break;
 431
 432         case AX25_PACLEN:
 433                 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
 434                         return -EINVAL;
 435                 ax25->paclen = ax25_ctl.arg;
 436                 break;
 437
 438         default:
 439                 return -EINVAL;
 440           }
 441
 442         return 0;
 443 }
 444
 445 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
 446 {
 447         ax25->rtt     = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
 448         ax25->t1      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
 449         ax25->t2      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
 450         ax25->t3      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
 451         ax25->n2      = ax25_dev->values[AX25_VALUES_N2];
 452         ax25->paclen  = ax25_dev->values[AX25_VALUES_PACLEN];
 453         ax25->idle    = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
 454         ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
 455
 456         if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
 457                 ax25->modulus = AX25_EMODULUS;
 458                 ax25->window  = ax25_dev->values[AX25_VALUES_EWINDOW];
 459         } else {
 460                 ax25->modulus = AX25_MODULUS;
 461                 ax25->window  = ax25_dev->values[AX25_VALUES_WINDOW];
 462         }
 463 }
 464
 465 /*
 466  *      Fill in a created AX.25 created control block with the default
 467  *      values for a particular device.
 468  */
 469 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
 470 {
 471         ax25->ax25_dev = ax25_dev;
 472
 473         if (ax25->ax25_dev != NULL) {
 474                 ax25_fillin_cb_from_dev(ax25, ax25_dev);
 475                 return;
 476         }
 477
 478         /*
 479          * No device, use kernel / AX.25 spec default values
 480          */
 481         ax25->rtt     = msecs_to_jiffies(AX25_DEF_T1) / 2;
 482         ax25->t1      = msecs_to_jiffies(AX25_DEF_T1);
 483         ax25->t2      = msecs_to_jiffies(AX25_DEF_T2);
 484         ax25->t3      = msecs_to_jiffies(AX25_DEF_T3);
 485         ax25->n2      = AX25_DEF_N2;
 486         ax25->paclen  = AX25_DEF_PACLEN;
 487         ax25->idle    = msecs_to_jiffies(AX25_DEF_IDLE);
 488         ax25->backoff = AX25_DEF_BACKOFF;
 489
 490         if (AX25_DEF_AXDEFMODE) {
 491                 ax25->modulus = AX25_EMODULUS;
 492                 ax25->window  = AX25_DEF_EWINDOW;
 493         } else {
 494                 ax25->modulus = AX25_MODULUS;
 495                 ax25->window  = AX25_DEF_WINDOW;
 496         }
 497 }
 498
 499 /*
 500  * Create an empty AX.25 control block.
 501  */
 502 ax25_cb *ax25_create_cb(void)
 503 {
 504         ax25_cb *ax25;
 505
 506         if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
 507                 return NULL;
 508
 509         atomic_set(&ax25->refcount, 1);
 510
 511         skb_queue_head_init(&ax25->write_queue);
 512         skb_queue_head_init(&ax25->frag_queue);
 513         skb_queue_head_init(&ax25->ack_queue);
 514         skb_queue_head_init(&ax25->reseq_queue);
 515
 516         ax25_setup_timers(ax25);
 517
 518         ax25_fillin_cb(ax25, NULL);
 519
 520         ax25->state = AX25_STATE_0;
 521
 522         return ax25;
 523 }
 524
 525 /*
 526  *      Handling for system calls applied via the various interfaces to an
 527  *      AX25 socket object
 528  */
 529
 530 static int ax25_setsockopt(struct socket *sock, int level, int optname,
 531         char __user *optval, int optlen)
 532 {
 533         struct sock *sk = sock->sk;
 534         ax25_cb *ax25;
 535         struct net_device *dev;
 536         char devname[IFNAMSIZ];
 537         int opt, res = 0;
 538
 539         if (level != SOL_AX25)
 540                 return -ENOPROTOOPT;
 541
 542         if (optlen < sizeof(int))
 543                 return -EINVAL;
 544
 545         if (get_user(opt, (int __user *)optval))
 546                 return -EFAULT;
 547
 548         lock_sock(sk);
 549         ax25 = ax25_sk(sk);
 550
 551         switch (optname) {
 552         case AX25_WINDOW:
 553                 if (ax25->modulus == AX25_MODULUS) {
 554                         if (opt < 1 || opt > 7) {
 555                                 res = -EINVAL;
 556                                 break;
 557                         }
 558                 } else {
 559                         if (opt < 1 || opt > 63) {
 560                                 res = -EINVAL;
 561                                 break;
 562                         }
 563                 }
 564                 ax25->window = opt;
 565                 break;
 566
 567         case AX25_T1:
 568                 if (opt < 1) {
 569                         res = -EINVAL;
 570                         break;
 571                 }
 572                 ax25->rtt = (opt * HZ) >> 1;
 573                 ax25->t1  = opt * HZ;
 574                 break;
 575
 576         case AX25_T2:
 577                 if (opt < 1) {
 578                         res = -EINVAL;
 579                         break;
 580                 }
 581                 ax25->t2 = opt * HZ;
 582                 break;
 583
 584         case AX25_N2:
 585                 if (opt < 1 || opt > 31) {
 586                         res = -EINVAL;
 587                         break;
 588                 }
 589                 ax25->n2 = opt;
 590                 break;
 591
 592         case AX25_T3:
 593                 if (opt < 1) {
 594                         res = -EINVAL;
 595                         break;
 596                 }
 597                 ax25->t3 = opt * HZ;
 598                 break;
 599
 600         case AX25_IDLE:
 601                 if (opt < 0) {
 602                         res = -EINVAL;
 603                         break;
 604                 }
 605                 ax25->idle = opt * 60 * HZ;
 606                 break;
 607
 608         case AX25_BACKOFF:
 609                 if (opt < 0 || opt > 2) {
 610                         res = -EINVAL;
 611                         break;
 612                 }
 613                 ax25->backoff = opt;
 614                 break;
 615
 616         case AX25_EXTSEQ:
 617                 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
 618                 break;
 619
 620         case AX25_PIDINCL:
 621                 ax25->pidincl = opt ? 1 : 0;
 622                 break;
 623
 624         case AX25_IAMDIGI:
 625                 ax25->iamdigi = opt ? 1 : 0;
 626                 break;
 627
 628         case AX25_PACLEN:
 629                 if (opt < 16 || opt > 65535) {
 630                         res = -EINVAL;
 631                         break;
 632                 }
 633                 ax25->paclen = opt;
 634                 break;
 635
 636         case SO_BINDTODEVICE:
 637                 if (optlen > IFNAMSIZ)
 638                         optlen=IFNAMSIZ;
 639                 if (copy_from_user(devname, optval, optlen)) {
 640                 res = -EFAULT;
 641                         break;
 642                 }
 643
 644                 dev = dev_get_by_name(&init_net, devname);
 645                 if (dev == NULL) {
 646                         res = -ENODEV;
 647                         break;
 648                 }
 649
 650                 if (sk->sk_type == SOCK_SEQPACKET &&
 651                    (sock->state != SS_UNCONNECTED ||
 652                     sk->sk_state == TCP_LISTEN)) {
 653                         res = -EADDRNOTAVAIL;
 654                         dev_put(dev);
 655                         break;
 656                 }
 657
 658                 ax25->ax25_dev = ax25_dev_ax25dev(dev);
 659                 ax25_fillin_cb(ax25, ax25->ax25_dev);
 660                 break;
 661
 662         default:
 663                 res = -ENOPROTOOPT;
 664         }
 665         release_sock(sk);
 666
 667         return res;
 668 }
 669
 670 static int ax25_getsockopt(struct socket *sock, int level, int optname,
 671         char __user *optval, int __user *optlen)
 672 {
 673         struct sock *sk = sock->sk;
 674         ax25_cb *ax25;
 675         struct ax25_dev *ax25_dev;
 676         char devname[IFNAMSIZ];
 677         void *valptr;
 678         int val = 0;
 679         int maxlen, length;
 680
 681         if (level != SOL_AX25)
 682                 return -ENOPROTOOPT;
 683
 684         if (get_user(maxlen, optlen))
 685                 return -EFAULT;
 686
 687         if (maxlen < 1)
 688                 return -EFAULT;
 689
 690         valptr = (void *) &val;
 691         length = min_t(unsigned int, maxlen, sizeof(int));
 692
 693         lock_sock(sk);
 694         ax25 = ax25_sk(sk);
 695
 696         switch (optname) {
 697         case AX25_WINDOW:
 698                 val = ax25->window;
 699                 break;
 700
 701         case AX25_T1:
 702                 val = ax25->t1 / HZ;
 703                 break;
 704
 705         case AX25_T2:
 706                 val = ax25->t2 / HZ;
 707                 break;
 708
 709         case AX25_N2:
 710                 val = ax25->n2;
 711                 break;
 712
 713         case AX25_T3:
 714                 val = ax25->t3 / HZ;
 715                 break;
 716
 717         case AX25_IDLE:
 718                 val = ax25->idle / (60 * HZ);
 719                 break;
 720
 721         case AX25_BACKOFF:
 722                 val = ax25->backoff;
 723                 break;
 724
 725         case AX25_EXTSEQ:
 726                 val = (ax25->modulus == AX25_EMODULUS);
 727                 break;
 728
 729         case AX25_PIDINCL:
 730                 val = ax25->pidincl;
 731                 break;
 732
 733         case AX25_IAMDIGI:
 734                 val = ax25->iamdigi;
 735                 break;
 736
 737         case AX25_PACLEN:
 738                 val = ax25->paclen;
 739                 break;
 740
 741         case SO_BINDTODEVICE:
 742                 ax25_dev = ax25->ax25_dev;
 743
 744                 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
 745                         strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
 746                         length = strlen(devname) + 1;
 747                 } else {
 748                         *devname = '\0';
 749                         length = 1;
 750                 }
 751
 752                 valptr = (void *) devname;
 753                 break;
 754
 755         default:
 756                 release_sock(sk);
 757                 return -ENOPROTOOPT;
 758         }
 759         release_sock(sk);
 760
 761         if (put_user(length, optlen))
 762                 return -EFAULT;
 763
 764         return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
 765 }
 766
 767 static int ax25_listen(struct socket *sock, int backlog)
 768 {
 769         struct sock *sk = sock->sk;
 770         int res = 0;
 771
 772         lock_sock(sk);
 773         if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
 774                 sk->sk_max_ack_backlog = backlog;
 775                 sk->sk_state           = TCP_LISTEN;
 776                 goto out;
 777         }
 778         res = -EOPNOTSUPP;
 779
 780 out:
 781         release_sock(sk);
 782
 783         return res;
 784 }
 785
 786 /*
 787  * XXX: when creating ax25_sock we should update the .obj_size setting
 788  * below.
 789  */
 790 static struct proto ax25_proto = {
 791         .name     = "AX25",
 792         .owner    = THIS_MODULE,
 793         .obj_size = sizeof(struct sock),
 794 };
 795
 796 static int ax25_create(struct net *net, struct socket *sock, int protocol)
 797 {
 798         struct sock *sk;
 799         ax25_cb *ax25;
 800
 801         if (net != &init_net)
 802                 return -EAFNOSUPPORT;
 803
 804         switch (sock->type) {
 805         case SOCK_DGRAM:
 806                 if (protocol == 0 || protocol == PF_AX25)
 807                         protocol = AX25_P_TEXT;
 808                 break;
 809
 810         case SOCK_SEQPACKET:
 811                 switch (protocol) {
 812                 case 0:
 813                 case PF_AX25:   /* For CLX */
 814                         protocol = AX25_P_TEXT;
 815                         break;
 816                 case AX25_P_SEGMENT:
 817 #ifdef CONFIG_INET
 818                 case AX25_P_ARP:
 819                 case AX25_P_IP:
 820 #endif
 821 #ifdef CONFIG_NETROM
 822                 case AX25_P_NETROM:
 823 #endif
 824 #ifdef CONFIG_ROSE
 825                 case AX25_P_ROSE:
 826 #endif
 827                         return -ESOCKTNOSUPPORT;
 828 #ifdef CONFIG_NETROM_MODULE
 829                 case AX25_P_NETROM:
 830                         if (ax25_protocol_is_registered(AX25_P_NETROM))
 831                                 return -ESOCKTNOSUPPORT;
 832 #endif
 833 #ifdef CONFIG_ROSE_MODULE
 834                 case AX25_P_ROSE:
 835                         if (ax25_protocol_is_registered(AX25_P_ROSE))
 836                                 return -ESOCKTNOSUPPORT;
 837 #endif
 838                 default:
 839                         break;
 840                 }
 841                 break;
 842
 843         case SOCK_RAW:
 844                 break;
 845         default:
 846                 return -ESOCKTNOSUPPORT;
 847         }
 848
 849         sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
 850         if (sk == NULL)
 851                 return -ENOMEM;
 852
 853         ax25 = sk->sk_protinfo = ax25_create_cb();
 854         if (!ax25) {
 855                 sk_free(sk);
 856                 return -ENOMEM;
 857         }
 858
 859         sock_init_data(sock, sk);
 860
 861         sk->sk_destruct = ax25_free_sock;
 862         sock->ops    = &ax25_proto_ops;
 863         sk->sk_protocol = protocol;
 864
 865         ax25->sk    = sk;
 866
 867         return 0;
 868 }
 869
 870 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
 871 {
 872         struct sock *sk;
 873         ax25_cb *ax25, *oax25;
 874
 875         sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC,       osk->sk_prot);
 876         if (sk == NULL)
 877                 return NULL;
 878
 879         if ((ax25 = ax25_create_cb()) == NULL) {
 880                 sk_free(sk);
 881                 return NULL;
 882         }
 883
 884         switch (osk->sk_type) {
 885         case SOCK_DGRAM:
 886                 break;
 887         case SOCK_SEQPACKET:
 888                 break;
 889         default:
 890                 sk_free(sk);
 891                 ax25_cb_put(ax25);
 892                 return NULL;
 893         }
 894
 895         sock_init_data(NULL, sk);
 896
 897         sk->sk_destruct = ax25_free_sock;
 898         sk->sk_type     = osk->sk_type;
 899         sk->sk_priority = osk->sk_priority;
 900         sk->sk_protocol = osk->sk_protocol;
 901         sk->sk_rcvbuf   = osk->sk_rcvbuf;
 902         sk->sk_sndbuf   = osk->sk_sndbuf;
 903         sk->sk_state    = TCP_ESTABLISHED;
 904         sock_copy_flags(sk, osk);
 905
 906         oax25 = ax25_sk(osk);
 907
 908         ax25->modulus = oax25->modulus;
 909         ax25->backoff = oax25->backoff;
 910         ax25->pidincl = oax25->pidincl;
 911         ax25->iamdigi = oax25->iamdigi;
 912         ax25->rtt     = oax25->rtt;
 913         ax25->t1      = oax25->t1;
 914         ax25->t2      = oax25->t2;
 915         ax25->t3      = oax25->t3;
 916         ax25->n2      = oax25->n2;
 917         ax25->idle    = oax25->idle;
 918         ax25->paclen  = oax25->paclen;
 919         ax25->window  = oax25->window;
 920
 921         ax25->ax25_dev    = ax25_dev;
 922         ax25->source_addr = oax25->source_addr;
 923
 924         if (oax25->digipeat != NULL) {
 925                 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
 926                                          GFP_ATOMIC);
 927                 if (ax25->digipeat == NULL) {
 928                         sk_free(sk);
 929                         ax25_cb_put(ax25);
 930                         return NULL;
 931                 }
 932         }
 933
 934         sk->sk_protinfo = ax25;
 935         ax25->sk    = sk;
 936
 937         return sk;
 938 }
 939
 940 static int ax25_release(struct socket *sock)
 941 {
 942         struct sock *sk = sock->sk;
 943         ax25_cb *ax25;
 944
 945         if (sk == NULL)
 946                 return 0;
 947
 948         sock_hold(sk);
 949         sock_orphan(sk);
 950         lock_sock(sk);
 951         ax25 = ax25_sk(sk);
 952
 953         if (sk->sk_type == SOCK_SEQPACKET) {
 954                 switch (ax25->state) {
 955                 case AX25_STATE_0:
 956                         release_sock(sk);
 957                         ax25_disconnect(ax25, 0);
 958                         lock_sock(sk);
 959                         ax25_destroy_socket(ax25);
 960                         break;
 961
 962                 case AX25_STATE_1:
 963                 case AX25_STATE_2:
 964                         ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
 965                         release_sock(sk);
 966                         ax25_disconnect(ax25, 0);
 967                         lock_sock(sk);
 968                         ax25_destroy_socket(ax25);
 969                         break;
 970
 971                 case AX25_STATE_3:
 972                 case AX25_STATE_4:
 973                         ax25_clear_queues(ax25);
 974                         ax25->n2count = 0;
 975
 976                         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
 977                         case AX25_PROTO_STD_SIMPLEX:
 978                         case AX25_PROTO_STD_DUPLEX:
 979                                 ax25_send_control(ax25,
 980                                                   AX25_DISC,
 981                                                   AX25_POLLON,
 982                                                   AX25_COMMAND);
 983                                 ax25_stop_t2timer(ax25);
 984                                 ax25_stop_t3timer(ax25);
 985                                 ax25_stop_idletimer(ax25);
 986                                 break;
 987 #ifdef CONFIG_AX25_DAMA_SLAVE
 988                         case AX25_PROTO_DAMA_SLAVE:
 989                                 ax25_stop_t3timer(ax25);
 990                                 ax25_stop_idletimer(ax25);
 991                                 break;
 992 #endif
 993                         }
 994                         ax25_calculate_t1(ax25);
 995                         ax25_start_t1timer(ax25);
 996                         ax25->state = AX25_STATE_2;
 997                         sk->sk_state                = TCP_CLOSE;
 998                         sk->sk_shutdown            |= SEND_SHUTDOWN;
 999                         sk->sk_state_change(sk);
1000                         sock_set_flag(sk, SOCK_DESTROY);
1001                         break;
1002
1003                 default:
1004                         break;
1005                 }
1006         } else {
1007                 sk->sk_state     = TCP_CLOSE;
1008                 sk->sk_shutdown |= SEND_SHUTDOWN;
1009                 sk->sk_state_change(sk);
1010                 ax25_destroy_socket(ax25);
1011         }
1012
1013         sock->sk   = NULL;
1014         release_sock(sk);
1015         sock_put(sk);
1016
1017         return 0;
1018 }
1019
1020 /*
1021  *      We support a funny extension here so you can (as root) give any callsign
1022  *      digipeated via a local address as source. This hack is obsolete now
1023  *      that we've implemented support for SO_BINDTODEVICE. It is however small
1024  *      and trivially backward compatible.
1025  */
1026 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1027 {
1028         struct sock *sk = sock->sk;
1029         struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1030         ax25_dev *ax25_dev = NULL;
1031         ax25_uid_assoc *user;
1032         ax25_address call;
1033         ax25_cb *ax25;
1034         int err = 0;
1035
1036         if (addr_len != sizeof(struct sockaddr_ax25) &&
1037             addr_len != sizeof(struct full_sockaddr_ax25))
1038                 /* support for old structure may go away some time
1039                  * ax25_bind(): uses old (6 digipeater) socket structure.
1040                  */
1041                 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1042                     (addr_len > sizeof(struct full_sockaddr_ax25)))
1043                         return -EINVAL;
1044
1045         if (addr->fsa_ax25.sax25_family != AF_AX25)
1046                 return -EINVAL;
1047
1048         user = ax25_findbyuid(current_euid());
1049         if (user) {
1050                 call = user->call;
1051                 ax25_uid_put(user);
1052         } else {
1053                 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1054                         return -EACCES;
1055
1056                 call = addr->fsa_ax25.sax25_call;
1057         }
1058
1059         lock_sock(sk);
1060
1061         ax25 = ax25_sk(sk);
1062         if (!sock_flag(sk, SOCK_ZAPPED)) {
1063                 err = -EINVAL;
1064                 goto out;
1065         }
1066
1067         ax25->source_addr = call;
1068
1069         /*
1070          * User already set interface with SO_BINDTODEVICE
1071          */
1072         if (ax25->ax25_dev != NULL)
1073                 goto done;
1074
1075         if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1076                 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1077                     (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1078                         err = -EADDRNOTAVAIL;
1079                         goto out;
1080                 }
1081         } else {
1082                 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1083                         err = -EADDRNOTAVAIL;
1084                         goto out;
1085                 }
1086         }
1087
1088         if (ax25_dev != NULL)
1089                 ax25_fillin_cb(ax25, ax25_dev);
1090
1091 done:
1092         ax25_cb_add(ax25);
1093         sock_reset_flag(sk, SOCK_ZAPPED);
1094
1095 out:
1096         release_sock(sk);
1097
1098         return 0;
1099 }
1100
1101 /*
1102  *      FIXME: nonblock behaviour looks like it may have a bug.
1103  */
1104 static int __must_check ax25_connect(struct socket *sock,
1105         struct sockaddr *uaddr, int addr_len, int flags)
1106 {
1107         struct sock *sk = sock->sk;
1108         ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1109         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1110         ax25_digi *digi = NULL;
1111         int ct = 0, err = 0;
1112
1113         /*
1114          * some sanity checks. code further down depends on this
1115          */
1116
1117         if (addr_len == sizeof(struct sockaddr_ax25))
1118                 /* support for this will go away in early 2.5.x
1119                  * ax25_connect(): uses obsolete socket structure
1120                  */
1121                 ;
1122         else if (addr_len != sizeof(struct full_sockaddr_ax25))
1123                 /* support for old structure may go away some time
1124                  * ax25_connect(): uses old (6 digipeater) socket structure.
1125                  */
1126                 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1127                     (addr_len > sizeof(struct full_sockaddr_ax25)))
1128                         return -EINVAL;
1129
1130
1131         if (fsa->fsa_ax25.sax25_family != AF_AX25)
1132                 return -EINVAL;
1133
1134         lock_sock(sk);
1135
1136         /* deal with restarts */
1137         if (sock->state == SS_CONNECTING) {
1138                 switch (sk->sk_state) {
1139                 case TCP_SYN_SENT: /* still trying */
1140                         err = -EINPROGRESS;
1141                         goto out_release;
1142
1143                 case TCP_ESTABLISHED: /* connection established */
1144                         sock->state = SS_CONNECTED;
1145                         goto out_release;
1146
1147                 case TCP_CLOSE: /* connection refused */
1148                         sock->state = SS_UNCONNECTED;
1149                         err = -ECONNREFUSED;
1150                         goto out_release;
1151                 }
1152         }
1153
1154         if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1155                 err = -EISCONN; /* No reconnect on a seqpacket socket */
1156                 goto out_release;
1157         }
1158
1159         sk->sk_state   = TCP_CLOSE;
1160         sock->state = SS_UNCONNECTED;
1161
1162         kfree(ax25->digipeat);
1163         ax25->digipeat = NULL;
1164
1165         /*
1166          *      Handle digi-peaters to be used.
1167          */
1168         if (addr_len > sizeof(struct sockaddr_ax25) &&
1169             fsa->fsa_ax25.sax25_ndigis != 0) {
1170                 /* Valid number of digipeaters ? */
1171                 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1172                         err = -EINVAL;
1173                         goto out_release;
1174                 }
1175
1176                 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1177                         err = -ENOBUFS;
1178                         goto out_release;
1179                 }
1180
1181                 digi->ndigi      = fsa->fsa_ax25.sax25_ndigis;
1182                 digi->lastrepeat = -1;
1183
1184                 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1185                         if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1186                              AX25_HBIT) && ax25->iamdigi) {
1187                                 digi->repeated[ct] = 1;
1188                                 digi->lastrepeat   = ct;
1189                         } else {
1190                                 digi->repeated[ct] = 0;
1191                         }
1192                         digi->calls[ct] = fsa->fsa_digipeater[ct];
1193                         ct++;
1194                 }
1195         }
1196
1197         /*
1198          *      Must bind first - autobinding in this may or may not work. If
1199          *      the socket is already bound, check to see if the device has
1200          *      been filled in, error if it hasn't.
1201          */
1202         if (sock_flag(sk, SOCK_ZAPPED)) {
1203                 /* check if we can remove this feature. It is broken. */
1204                 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1205                         current->comm);
1206                 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1207                         kfree(digi);
1208                         goto out_release;
1209                 }
1210
1211                 ax25_fillin_cb(ax25, ax25->ax25_dev);
1212                 ax25_cb_add(ax25);
1213         } else {
1214                 if (ax25->ax25_dev == NULL) {
1215                         kfree(digi);
1216                         err = -EHOSTUNREACH;
1217                         goto out_release;
1218                 }
1219         }
1220
1221         if (sk->sk_type == SOCK_SEQPACKET &&
1222             (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1223                          ax25->ax25_dev->dev))) {
1224                 kfree(digi);
1225                 err = -EADDRINUSE;              /* Already such a connection */
1226                 ax25_cb_put(ax25t);
1227                 goto out_release;
1228         }
1229
1230         ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1231         ax25->digipeat  = digi;
1232
1233         /* First the easy one */
1234         if (sk->sk_type != SOCK_SEQPACKET) {
1235                 sock->state = SS_CONNECTED;
1236                 sk->sk_state   = TCP_ESTABLISHED;
1237                 goto out_release;
1238         }
1239
1240         /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1241         sock->state        = SS_CONNECTING;
1242         sk->sk_state          = TCP_SYN_SENT;
1243
1244         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1245         case AX25_PROTO_STD_SIMPLEX:
1246         case AX25_PROTO_STD_DUPLEX:
1247                 ax25_std_establish_data_link(ax25);
1248                 break;
1249
1250 #ifdef CONFIG_AX25_DAMA_SLAVE
1251         case AX25_PROTO_DAMA_SLAVE:
1252                 ax25->modulus = AX25_MODULUS;
1253                 ax25->window  = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1254                 if (ax25->ax25_dev->dama.slave)
1255                         ax25_ds_establish_data_link(ax25);
1256                 else
1257                         ax25_std_establish_data_link(ax25);
1258                 break;
1259 #endif
1260         }
1261
1262         ax25->state = AX25_STATE_1;
1263
1264         ax25_start_heartbeat(ax25);
1265
1266         /* Now the loop */
1267         if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1268                 err = -EINPROGRESS;
1269                 goto out_release;
1270         }
1271
1272         if (sk->sk_state == TCP_SYN_SENT) {
1273                 DEFINE_WAIT(wait);
1274
1275                 for (;;) {
1276                         prepare_to_wait(sk->sk_sleep, &wait,
1277                                         TASK_INTERRUPTIBLE);
1278                         if (sk->sk_state != TCP_SYN_SENT)
1279                                 break;
1280                         if (!signal_pending(current)) {
1281                                 release_sock(sk);
1282                                 schedule();
1283                                 lock_sock(sk);
1284                                 continue;
1285                         }
1286                         err = -ERESTARTSYS;
1287                         break;
1288                 }
1289                 finish_wait(sk->sk_sleep, &wait);
1290
1291                 if (err)
1292                         goto out_release;
1293         }
1294
1295         if (sk->sk_state != TCP_ESTABLISHED) {
1296                 /* Not in ABM, not in WAIT_UA -> failed */
1297                 sock->state = SS_UNCONNECTED;
1298                 err = sock_error(sk);   /* Always set at this point */
1299                 goto out_release;
1300         }
1301
1302         sock->state = SS_CONNECTED;
1303
1304         err = 0;
1305 out_release:
1306         release_sock(sk);
1307
1308         return err;
1309 }
1310
1311 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1312 {
1313         struct sk_buff *skb;
1314         struct sock *newsk;
1315         DEFINE_WAIT(wait);
1316         struct sock *sk;
1317         int err = 0;
1318
1319         if (sock->state != SS_UNCONNECTED)
1320                 return -EINVAL;
1321
1322         if ((sk = sock->sk) == NULL)
1323                 return -EINVAL;
1324
1325         lock_sock(sk);
1326         if (sk->sk_type != SOCK_SEQPACKET) {
1327                 err = -EOPNOTSUPP;
1328                 goto out;
1329         }
1330
1331         if (sk->sk_state != TCP_LISTEN) {
1332                 err = -EINVAL;
1333                 goto out;
1334         }
1335
1336         /*
1337          *      The read queue this time is holding sockets ready to use
1338          *      hooked into the SABM we saved
1339          */
1340         for (;;) {
1341                 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1342                 skb = skb_dequeue(&sk->sk_receive_queue);
1343                 if (skb)
1344                         break;
1345
1346                 if (flags & O_NONBLOCK) {
1347                         err = -EWOULDBLOCK;
1348                         break;
1349                 }
1350                 if (!signal_pending(current)) {
1351                         release_sock(sk);
1352                         schedule();
1353                         lock_sock(sk);
1354                         continue;
1355                 }
1356                 err = -ERESTARTSYS;
1357                 break;
1358         }
1359         finish_wait(sk->sk_sleep, &wait);
1360
1361         if (err)
1362                 goto out;
1363
1364         newsk            = skb->sk;
1365         sock_graft(newsk, newsock);
1366
1367         /* Now attach up the new socket */
1368         kfree_skb(skb);
1369         sk->sk_ack_backlog--;
1370         newsock->state = SS_CONNECTED;
1371
1372 out:
1373         release_sock(sk);
1374
1375         return err;
1376 }
1377
1378 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1379         int *uaddr_len, int peer)
1380 {
1381         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1382         struct sock *sk = sock->sk;
1383         unsigned char ndigi, i;
1384         ax25_cb *ax25;
1385         int err = 0;
1386
1387         lock_sock(sk);
1388         ax25 = ax25_sk(sk);
1389
1390         if (peer != 0) {
1391                 if (sk->sk_state != TCP_ESTABLISHED) {
1392                         err = -ENOTCONN;
1393                         goto out;
1394                 }
1395
1396                 fsa->fsa_ax25.sax25_family = AF_AX25;
1397                 fsa->fsa_ax25.sax25_call   = ax25->dest_addr;
1398                 fsa->fsa_ax25.sax25_ndigis = 0;
1399
1400                 if (ax25->digipeat != NULL) {
1401                         ndigi = ax25->digipeat->ndigi;
1402                         fsa->fsa_ax25.sax25_ndigis = ndigi;
1403                         for (i = 0; i < ndigi; i++)
1404                                 fsa->fsa_digipeater[i] =
1405                                                 ax25->digipeat->calls[i];
1406                 }
1407         } else {
1408                 fsa->fsa_ax25.sax25_family = AF_AX25;
1409                 fsa->fsa_ax25.sax25_call   = ax25->source_addr;
1410                 fsa->fsa_ax25.sax25_ndigis = 1;
1411                 if (ax25->ax25_dev != NULL) {
1412                         memcpy(&fsa->fsa_digipeater[0],
1413                                ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1414                 } else {
1415                         fsa->fsa_digipeater[0] = null_ax25_address;
1416                 }
1417         }
1418         *uaddr_len = sizeof (struct full_sockaddr_ax25);
1419
1420 out:
1421         release_sock(sk);
1422
1423         return err;
1424 }
1425
1426 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1427                         struct msghdr *msg, size_t len)
1428 {
1429         struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1430         struct sock *sk = sock->sk;
1431         struct sockaddr_ax25 sax;
1432         struct sk_buff *skb;
1433         ax25_digi dtmp, *dp;
1434         ax25_cb *ax25;
1435         size_t size;
1436         int lv, err, addr_len = msg->msg_namelen;
1437
1438         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1439                 return -EINVAL;
1440
1441         lock_sock(sk);
1442         ax25 = ax25_sk(sk);
1443
1444         if (sock_flag(sk, SOCK_ZAPPED)) {
1445                 err = -EADDRNOTAVAIL;
1446                 goto out;
1447         }
1448
1449         if (sk->sk_shutdown & SEND_SHUTDOWN) {
1450                 send_sig(SIGPIPE, current, 0);
1451                 err = -EPIPE;
1452                 goto out;
1453         }
1454
1455         if (ax25->ax25_dev == NULL) {
1456                 err = -ENETUNREACH;
1457                 goto out;
1458         }
1459
1460         if (len > ax25->ax25_dev->dev->mtu) {
1461                 err = -EMSGSIZE;
1462                 goto out;
1463         }
1464
1465         if (usax != NULL) {
1466                 if (usax->sax25_family != AF_AX25) {
1467                         err = -EINVAL;
1468                         goto out;
1469                 }
1470
1471                 if (addr_len == sizeof(struct sockaddr_ax25))
1472                         /* ax25_sendmsg(): uses obsolete socket structure */
1473                         ;
1474                 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1475                         /* support for old structure may go away some time
1476                          * ax25_sendmsg(): uses old (6 digipeater)
1477                          * socket structure.
1478                          */
1479                         if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1480                             (addr_len > sizeof(struct full_sockaddr_ax25))) {
1481                                 err = -EINVAL;
1482                                 goto out;
1483                         }
1484
1485
1486                 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1487                         int ct           = 0;
1488                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1489
1490                         /* Valid number of digipeaters ? */
1491                         if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1492                                 err = -EINVAL;
1493                                 goto out;
1494                         }
1495
1496                         dtmp.ndigi      = usax->sax25_ndigis;
1497
1498                         while (ct < usax->sax25_ndigis) {
1499                                 dtmp.repeated[ct] = 0;
1500                                 dtmp.calls[ct]    = fsa->fsa_digipeater[ct];
1501                                 ct++;
1502                         }
1503
1504                         dtmp.lastrepeat = 0;
1505                 }
1506
1507                 sax = *usax;
1508                 if (sk->sk_type == SOCK_SEQPACKET &&
1509                     ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1510                         err = -EISCONN;
1511                         goto out;
1512                 }
1513                 if (usax->sax25_ndigis == 0)
1514                         dp = NULL;
1515                 else
1516                         dp = &dtmp;
1517         } else {
1518                 /*
1519                  *      FIXME: 1003.1g - if the socket is like this because
1520                  *      it has become closed (not started closed) and is VC
1521                  *      we ought to SIGPIPE, EPIPE
1522                  */
1523                 if (sk->sk_state != TCP_ESTABLISHED) {
1524                         err = -ENOTCONN;
1525                         goto out;
1526                 }
1527                 sax.sax25_family = AF_AX25;
1528                 sax.sax25_call   = ax25->dest_addr;
1529                 dp = ax25->digipeat;
1530         }
1531
1532         /* Build a packet */
1533         SOCK_DEBUG(sk, "AX.25: sendto: Addresses built. 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         __acquires(ax25_list_lock)
1857 {
1858         struct ax25_cb *ax25;
1859         struct hlist_node *node;
1860         int i = 0;
1861
1862         spin_lock_bh(&ax25_list_lock);
1863         ax25_for_each(ax25, node, &ax25_list) {
1864                 if (i == *pos)
1865                         return ax25;
1866                 ++i;
1867         }
1868         return NULL;
1869 }
1870
1871 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1872 {
1873         ++*pos;
1874
1875         return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1876                             struct ax25_cb, ax25_node);
1877 }
1878
1879 static void ax25_info_stop(struct seq_file *seq, void *v)
1880         __releases(ax25_list_lock)
1881 {
1882         spin_unlock_bh(&ax25_list_lock);
1883 }
1884
1885 static int ax25_info_show(struct seq_file *seq, void *v)
1886 {
1887         ax25_cb *ax25 = v;
1888         char buf[11];
1889         int k;
1890
1891
1892         /*
1893          * New format:
1894          * 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
1895          */
1896
1897         seq_printf(seq, "%8.8lx %s %s%s ",
1898                    (long) ax25,
1899                    ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1900                    ax2asc(buf, &ax25->source_addr),
1901                    ax25->iamdigi? "*":"");
1902         seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1903
1904         for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1905                 seq_printf(seq, ",%s%s",
1906                            ax2asc(buf, &ax25->digipeat->calls[k]),
1907                            ax25->digipeat->repeated[k]? "*":"");
1908         }
1909
1910         seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1911                    ax25->state,
1912                    ax25->vs, ax25->vr, ax25->va,
1913                    ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1914                    ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1915                    ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1916                    ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1917                    ax25->idle / (60 * HZ),
1918                    ax25->n2count, ax25->n2,
1919                    ax25->rtt / HZ,
1920                    ax25->window,
1921                    ax25->paclen);
1922
1923         if (ax25->sk != NULL) {
1924                 seq_printf(seq, " %d %d %lu\n",
1925                            atomic_read(&ax25->sk->sk_wmem_alloc),
1926                            atomic_read(&ax25->sk->sk_rmem_alloc),
1927                            sock_i_ino(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 __read_mostly = {
1987         .type   =       cpu_to_be16(ETH_P_AX25),
1988         .func   =       ax25_kiss_rcv,
1989 };
1990
1991 static struct notifier_block ax25_dev_notifier = {
1992         .notifier_call =ax25_device_event,
1993 };
1994
1995 static int __init ax25_init(void)
1996 {
1997         int rc = proto_register(&ax25_proto, 0);
1998
1999         if (rc != 0)
2000                 goto out;
2001
2002         sock_register(&ax25_family_ops);
2003         dev_add_pack(&ax25_packet_type);
2004         register_netdevice_notifier(&ax25_dev_notifier);
2005         ax25_register_sysctl();
2006
2007         proc_net_fops_create(&init_net, "ax25_route", S_IRUGO, &ax25_route_fops);
2008         proc_net_fops_create(&init_net, "ax25", S_IRUGO, &ax25_info_fops);
2009         proc_net_fops_create(&init_net, "ax25_calls", S_IRUGO, &ax25_uid_fops);
2010 out:
2011         return rc;
2012 }
2013 module_init(ax25_init);
2014
2015
2016 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2017 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2018 MODULE_LICENSE("GPL");
2019 MODULE_ALIAS_NETPROTO(PF_AX25);
2020
2021 static void __exit ax25_exit(void)
2022 {
2023         proc_net_remove(&init_net, "ax25_route");
2024         proc_net_remove(&init_net, "ax25");
2025         proc_net_remove(&init_net, "ax25_calls");
2026         ax25_rt_free();
2027         ax25_uid_free();
2028         ax25_dev_free();
2029
2030         ax25_unregister_sysctl();
2031         unregister_netdevice_notifier(&ax25_dev_notifier);
2032
2033         dev_remove_pack(&ax25_packet_type);
2034
2035         sock_unregister(PF_AX25);
2036         proto_unregister(&ax25_proto);
2037 }
2038 module_exit(ax25_exit);