SAFE public projects git trees. - safe/jmp/linux-2.6/blob - net/ax25/af_ax25.c

   1 /*
   2  * This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 2 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
   8  * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
   9  * Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk)
  10  * Copyright (C) Steven Whitehouse GW7RRM (stevew@acm.org)
  11  * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
  12  * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
  13  * Copyright (C) Hans Alblas PE1AYX (hans@esrac.ele.tue.nl)
  14  * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
  15  */
  16 #include <linux/capability.h>
  17 #include <linux/module.h>
  18 #include <linux/errno.h>
  19 #include <linux/types.h>
  20 #include <linux/socket.h>
  21 #include <linux/in.h>
  22 #include <linux/kernel.h>
  23 #include <linux/sched.h>
  24 #include <linux/timer.h>
  25 #include <linux/string.h>
  26 #include <linux/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 (sk_has_allocations(ax25->sk)) {
 334                         /* Defer: outstanding buffers */
 335                         setup_timer(&ax25->dtimer, ax25_destroy_timer,
 336                                         (unsigned long)ax25);
 337                         ax25->dtimer.expires  = jiffies + 2 * HZ;
 338                         add_timer(&ax25->dtimer);
 339                 } else {
 340                         struct sock *sk=ax25->sk;
 341                         ax25->sk=NULL;
 342                         sock_put(sk);
 343                 }
 344         } else {
 345                 ax25_cb_put(ax25);
 346         }
 347 }
 348
 349 /*
 350  * dl1bke 960311: set parameters for existing AX.25 connections,
 351  *                includes a KILL command to abort any connection.
 352  *                VERY useful for debugging ;-)
 353  */
 354 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
 355 {
 356         struct ax25_ctl_struct ax25_ctl;
 357         ax25_digi digi;
 358         ax25_dev *ax25_dev;
 359         ax25_cb *ax25;
 360         unsigned int k;
 361         int ret = 0;
 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                                 goto einval_put;
 393                 } else {
 394                         if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
 395                                 goto einval_put;
 396                 }
 397                 ax25->window = ax25_ctl.arg;
 398                 break;
 399
 400         case AX25_T1:
 401                 if (ax25_ctl.arg < 1)
 402                         goto einval_put;
 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                         goto einval_put;
 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                         goto einval_put;
 416                 ax25->n2count = 0;
 417                 ax25->n2 = ax25_ctl.arg;
 418                 break;
 419
 420         case AX25_T3:
 421                 if (ax25_ctl.arg < 0)
 422                         goto einval_put;
 423                 ax25->t3 = ax25_ctl.arg * HZ;
 424                 break;
 425
 426         case AX25_IDLE:
 427                 if (ax25_ctl.arg < 0)
 428                         goto einval_put;
 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                         goto einval_put;
 435                 ax25->paclen = ax25_ctl.arg;
 436                 break;
 437
 438         default:
 439                 goto einval_put;
 440           }
 441
 442 out_put:
 443         ax25_cb_put(ax25);
 444         return ret;
 445
 446 einval_put:
 447         ret = -EINVAL;
 448         goto out_put;
 449 }
 450
 451 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
 452 {
 453         ax25->rtt     = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
 454         ax25->t1      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
 455         ax25->t2      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
 456         ax25->t3      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
 457         ax25->n2      = ax25_dev->values[AX25_VALUES_N2];
 458         ax25->paclen  = ax25_dev->values[AX25_VALUES_PACLEN];
 459         ax25->idle    = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
 460         ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
 461
 462         if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
 463                 ax25->modulus = AX25_EMODULUS;
 464                 ax25->window  = ax25_dev->values[AX25_VALUES_EWINDOW];
 465         } else {
 466                 ax25->modulus = AX25_MODULUS;
 467                 ax25->window  = ax25_dev->values[AX25_VALUES_WINDOW];
 468         }
 469 }
 470
 471 /*
 472  *      Fill in a created AX.25 created control block with the default
 473  *      values for a particular device.
 474  */
 475 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
 476 {
 477         ax25->ax25_dev = ax25_dev;
 478
 479         if (ax25->ax25_dev != NULL) {
 480                 ax25_fillin_cb_from_dev(ax25, ax25_dev);
 481                 return;
 482         }
 483
 484         /*
 485          * No device, use kernel / AX.25 spec default values
 486          */
 487         ax25->rtt     = msecs_to_jiffies(AX25_DEF_T1) / 2;
 488         ax25->t1      = msecs_to_jiffies(AX25_DEF_T1);
 489         ax25->t2      = msecs_to_jiffies(AX25_DEF_T2);
 490         ax25->t3      = msecs_to_jiffies(AX25_DEF_T3);
 491         ax25->n2      = AX25_DEF_N2;
 492         ax25->paclen  = AX25_DEF_PACLEN;
 493         ax25->idle    = msecs_to_jiffies(AX25_DEF_IDLE);
 494         ax25->backoff = AX25_DEF_BACKOFF;
 495
 496         if (AX25_DEF_AXDEFMODE) {
 497                 ax25->modulus = AX25_EMODULUS;
 498                 ax25->window  = AX25_DEF_EWINDOW;
 499         } else {
 500                 ax25->modulus = AX25_MODULUS;
 501                 ax25->window  = AX25_DEF_WINDOW;
 502         }
 503 }
 504
 505 /*
 506  * Create an empty AX.25 control block.
 507  */
 508 ax25_cb *ax25_create_cb(void)
 509 {
 510         ax25_cb *ax25;
 511
 512         if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
 513                 return NULL;
 514
 515         atomic_set(&ax25->refcount, 1);
 516
 517         skb_queue_head_init(&ax25->write_queue);
 518         skb_queue_head_init(&ax25->frag_queue);
 519         skb_queue_head_init(&ax25->ack_queue);
 520         skb_queue_head_init(&ax25->reseq_queue);
 521
 522         ax25_setup_timers(ax25);
 523
 524         ax25_fillin_cb(ax25, NULL);
 525
 526         ax25->state = AX25_STATE_0;
 527
 528         return ax25;
 529 }
 530
 531 /*
 532  *      Handling for system calls applied via the various interfaces to an
 533  *      AX25 socket object
 534  */
 535
 536 static int ax25_setsockopt(struct socket *sock, int level, int optname,
 537         char __user *optval, int optlen)
 538 {
 539         struct sock *sk = sock->sk;
 540         ax25_cb *ax25;
 541         struct net_device *dev;
 542         char devname[IFNAMSIZ];
 543         int opt, res = 0;
 544
 545         if (level != SOL_AX25)
 546                 return -ENOPROTOOPT;
 547
 548         if (optlen < sizeof(int))
 549                 return -EINVAL;
 550
 551         if (get_user(opt, (int __user *)optval))
 552                 return -EFAULT;
 553
 554         lock_sock(sk);
 555         ax25 = ax25_sk(sk);
 556
 557         switch (optname) {
 558         case AX25_WINDOW:
 559                 if (ax25->modulus == AX25_MODULUS) {
 560                         if (opt < 1 || opt > 7) {
 561                                 res = -EINVAL;
 562                                 break;
 563                         }
 564                 } else {
 565                         if (opt < 1 || opt > 63) {
 566                                 res = -EINVAL;
 567                                 break;
 568                         }
 569                 }
 570                 ax25->window = opt;
 571                 break;
 572
 573         case AX25_T1:
 574                 if (opt < 1) {
 575                         res = -EINVAL;
 576                         break;
 577                 }
 578                 ax25->rtt = (opt * HZ) >> 1;
 579                 ax25->t1  = opt * HZ;
 580                 break;
 581
 582         case AX25_T2:
 583                 if (opt < 1) {
 584                         res = -EINVAL;
 585                         break;
 586                 }
 587                 ax25->t2 = opt * HZ;
 588                 break;
 589
 590         case AX25_N2:
 591                 if (opt < 1 || opt > 31) {
 592                         res = -EINVAL;
 593                         break;
 594                 }
 595                 ax25->n2 = opt;
 596                 break;
 597
 598         case AX25_T3:
 599                 if (opt < 1) {
 600                         res = -EINVAL;
 601                         break;
 602                 }
 603                 ax25->t3 = opt * HZ;
 604                 break;
 605
 606         case AX25_IDLE:
 607                 if (opt < 0) {
 608                         res = -EINVAL;
 609                         break;
 610                 }
 611                 ax25->idle = opt * 60 * HZ;
 612                 break;
 613
 614         case AX25_BACKOFF:
 615                 if (opt < 0 || opt > 2) {
 616                         res = -EINVAL;
 617                         break;
 618                 }
 619                 ax25->backoff = opt;
 620                 break;
 621
 622         case AX25_EXTSEQ:
 623                 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
 624                 break;
 625
 626         case AX25_PIDINCL:
 627                 ax25->pidincl = opt ? 1 : 0;
 628                 break;
 629
 630         case AX25_IAMDIGI:
 631                 ax25->iamdigi = opt ? 1 : 0;
 632                 break;
 633
 634         case AX25_PACLEN:
 635                 if (opt < 16 || opt > 65535) {
 636                         res = -EINVAL;
 637                         break;
 638                 }
 639                 ax25->paclen = opt;
 640                 break;
 641
 642         case SO_BINDTODEVICE:
 643                 if (optlen > IFNAMSIZ)
 644                         optlen=IFNAMSIZ;
 645                 if (copy_from_user(devname, optval, optlen)) {
 646                 res = -EFAULT;
 647                         break;
 648                 }
 649
 650                 dev = dev_get_by_name(&init_net, devname);
 651                 if (dev == NULL) {
 652                         res = -ENODEV;
 653                         break;
 654                 }
 655
 656                 if (sk->sk_type == SOCK_SEQPACKET &&
 657                    (sock->state != SS_UNCONNECTED ||
 658                     sk->sk_state == TCP_LISTEN)) {
 659                         res = -EADDRNOTAVAIL;
 660                         dev_put(dev);
 661                         break;
 662                 }
 663
 664                 ax25->ax25_dev = ax25_dev_ax25dev(dev);
 665                 ax25_fillin_cb(ax25, ax25->ax25_dev);
 666                 break;
 667
 668         default:
 669                 res = -ENOPROTOOPT;
 670         }
 671         release_sock(sk);
 672
 673         return res;
 674 }
 675
 676 static int ax25_getsockopt(struct socket *sock, int level, int optname,
 677         char __user *optval, int __user *optlen)
 678 {
 679         struct sock *sk = sock->sk;
 680         ax25_cb *ax25;
 681         struct ax25_dev *ax25_dev;
 682         char devname[IFNAMSIZ];
 683         void *valptr;
 684         int val = 0;
 685         int maxlen, length;
 686
 687         if (level != SOL_AX25)
 688                 return -ENOPROTOOPT;
 689
 690         if (get_user(maxlen, optlen))
 691                 return -EFAULT;
 692
 693         if (maxlen < 1)
 694                 return -EFAULT;
 695
 696         valptr = (void *) &val;
 697         length = min_t(unsigned int, maxlen, sizeof(int));
 698
 699         lock_sock(sk);
 700         ax25 = ax25_sk(sk);
 701
 702         switch (optname) {
 703         case AX25_WINDOW:
 704                 val = ax25->window;
 705                 break;
 706
 707         case AX25_T1:
 708                 val = ax25->t1 / HZ;
 709                 break;
 710
 711         case AX25_T2:
 712                 val = ax25->t2 / HZ;
 713                 break;
 714
 715         case AX25_N2:
 716                 val = ax25->n2;
 717                 break;
 718
 719         case AX25_T3:
 720                 val = ax25->t3 / HZ;
 721                 break;
 722
 723         case AX25_IDLE:
 724                 val = ax25->idle / (60 * HZ);
 725                 break;
 726
 727         case AX25_BACKOFF:
 728                 val = ax25->backoff;
 729                 break;
 730
 731         case AX25_EXTSEQ:
 732                 val = (ax25->modulus == AX25_EMODULUS);
 733                 break;
 734
 735         case AX25_PIDINCL:
 736                 val = ax25->pidincl;
 737                 break;
 738
 739         case AX25_IAMDIGI:
 740                 val = ax25->iamdigi;
 741                 break;
 742
 743         case AX25_PACLEN:
 744                 val = ax25->paclen;
 745                 break;
 746
 747         case SO_BINDTODEVICE:
 748                 ax25_dev = ax25->ax25_dev;
 749
 750                 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
 751                         strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
 752                         length = strlen(devname) + 1;
 753                 } else {
 754                         *devname = '\0';
 755                         length = 1;
 756                 }
 757
 758                 valptr = (void *) devname;
 759                 break;
 760
 761         default:
 762                 release_sock(sk);
 763                 return -ENOPROTOOPT;
 764         }
 765         release_sock(sk);
 766
 767         if (put_user(length, optlen))
 768                 return -EFAULT;
 769
 770         return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
 771 }
 772
 773 static int ax25_listen(struct socket *sock, int backlog)
 774 {
 775         struct sock *sk = sock->sk;
 776         int res = 0;
 777
 778         lock_sock(sk);
 779         if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
 780                 sk->sk_max_ack_backlog = backlog;
 781                 sk->sk_state           = TCP_LISTEN;
 782                 goto out;
 783         }
 784         res = -EOPNOTSUPP;
 785
 786 out:
 787         release_sock(sk);
 788
 789         return res;
 790 }
 791
 792 /*
 793  * XXX: when creating ax25_sock we should update the .obj_size setting
 794  * below.
 795  */
 796 static struct proto ax25_proto = {
 797         .name     = "AX25",
 798         .owner    = THIS_MODULE,
 799         .obj_size = sizeof(struct sock),
 800 };
 801
 802 static int ax25_create(struct net *net, struct socket *sock, int protocol)
 803 {
 804         struct sock *sk;
 805         ax25_cb *ax25;
 806
 807         if (net != &init_net)
 808                 return -EAFNOSUPPORT;
 809
 810         switch (sock->type) {
 811         case SOCK_DGRAM:
 812                 if (protocol == 0 || protocol == PF_AX25)
 813                         protocol = AX25_P_TEXT;
 814                 break;
 815
 816         case SOCK_SEQPACKET:
 817                 switch (protocol) {
 818                 case 0:
 819                 case PF_AX25:   /* For CLX */
 820                         protocol = AX25_P_TEXT;
 821                         break;
 822                 case AX25_P_SEGMENT:
 823 #ifdef CONFIG_INET
 824                 case AX25_P_ARP:
 825                 case AX25_P_IP:
 826 #endif
 827 #ifdef CONFIG_NETROM
 828                 case AX25_P_NETROM:
 829 #endif
 830 #ifdef CONFIG_ROSE
 831                 case AX25_P_ROSE:
 832 #endif
 833                         return -ESOCKTNOSUPPORT;
 834 #ifdef CONFIG_NETROM_MODULE
 835                 case AX25_P_NETROM:
 836                         if (ax25_protocol_is_registered(AX25_P_NETROM))
 837                                 return -ESOCKTNOSUPPORT;
 838 #endif
 839 #ifdef CONFIG_ROSE_MODULE
 840                 case AX25_P_ROSE:
 841                         if (ax25_protocol_is_registered(AX25_P_ROSE))
 842                                 return -ESOCKTNOSUPPORT;
 843 #endif
 844                 default:
 845                         break;
 846                 }
 847                 break;
 848
 849         case SOCK_RAW:
 850                 break;
 851         default:
 852                 return -ESOCKTNOSUPPORT;
 853         }
 854
 855         sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
 856         if (sk == NULL)
 857                 return -ENOMEM;
 858
 859         ax25 = sk->sk_protinfo = ax25_create_cb();
 860         if (!ax25) {
 861                 sk_free(sk);
 862                 return -ENOMEM;
 863         }
 864
 865         sock_init_data(sock, sk);
 866
 867         sk->sk_destruct = ax25_free_sock;
 868         sock->ops    = &ax25_proto_ops;
 869         sk->sk_protocol = protocol;
 870
 871         ax25->sk    = sk;
 872
 873         return 0;
 874 }
 875
 876 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
 877 {
 878         struct sock *sk;
 879         ax25_cb *ax25, *oax25;
 880
 881         sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC,       osk->sk_prot);
 882         if (sk == NULL)
 883                 return NULL;
 884
 885         if ((ax25 = ax25_create_cb()) == NULL) {
 886                 sk_free(sk);
 887                 return NULL;
 888         }
 889
 890         switch (osk->sk_type) {
 891         case SOCK_DGRAM:
 892                 break;
 893         case SOCK_SEQPACKET:
 894                 break;
 895         default:
 896                 sk_free(sk);
 897                 ax25_cb_put(ax25);
 898                 return NULL;
 899         }
 900
 901         sock_init_data(NULL, sk);
 902
 903         sk->sk_destruct = ax25_free_sock;
 904         sk->sk_type     = osk->sk_type;
 905         sk->sk_priority = osk->sk_priority;
 906         sk->sk_protocol = osk->sk_protocol;
 907         sk->sk_rcvbuf   = osk->sk_rcvbuf;
 908         sk->sk_sndbuf   = osk->sk_sndbuf;
 909         sk->sk_state    = TCP_ESTABLISHED;
 910         sock_copy_flags(sk, osk);
 911
 912         oax25 = ax25_sk(osk);
 913
 914         ax25->modulus = oax25->modulus;
 915         ax25->backoff = oax25->backoff;
 916         ax25->pidincl = oax25->pidincl;
 917         ax25->iamdigi = oax25->iamdigi;
 918         ax25->rtt     = oax25->rtt;
 919         ax25->t1      = oax25->t1;
 920         ax25->t2      = oax25->t2;
 921         ax25->t3      = oax25->t3;
 922         ax25->n2      = oax25->n2;
 923         ax25->idle    = oax25->idle;
 924         ax25->paclen  = oax25->paclen;
 925         ax25->window  = oax25->window;
 926
 927         ax25->ax25_dev    = ax25_dev;
 928         ax25->source_addr = oax25->source_addr;
 929
 930         if (oax25->digipeat != NULL) {
 931                 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
 932                                          GFP_ATOMIC);
 933                 if (ax25->digipeat == NULL) {
 934                         sk_free(sk);
 935                         ax25_cb_put(ax25);
 936                         return NULL;
 937                 }
 938         }
 939
 940         sk->sk_protinfo = ax25;
 941         ax25->sk    = sk;
 942
 943         return sk;
 944 }
 945
 946 static int ax25_release(struct socket *sock)
 947 {
 948         struct sock *sk = sock->sk;
 949         ax25_cb *ax25;
 950
 951         if (sk == NULL)
 952                 return 0;
 953
 954         sock_hold(sk);
 955         sock_orphan(sk);
 956         lock_sock(sk);
 957         ax25 = ax25_sk(sk);
 958
 959         if (sk->sk_type == SOCK_SEQPACKET) {
 960                 switch (ax25->state) {
 961                 case AX25_STATE_0:
 962                         release_sock(sk);
 963                         ax25_disconnect(ax25, 0);
 964                         lock_sock(sk);
 965                         ax25_destroy_socket(ax25);
 966                         break;
 967
 968                 case AX25_STATE_1:
 969                 case AX25_STATE_2:
 970                         ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
 971                         release_sock(sk);
 972                         ax25_disconnect(ax25, 0);
 973                         lock_sock(sk);
 974                         ax25_destroy_socket(ax25);
 975                         break;
 976
 977                 case AX25_STATE_3:
 978                 case AX25_STATE_4:
 979                         ax25_clear_queues(ax25);
 980                         ax25->n2count = 0;
 981
 982                         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
 983                         case AX25_PROTO_STD_SIMPLEX:
 984                         case AX25_PROTO_STD_DUPLEX:
 985                                 ax25_send_control(ax25,
 986                                                   AX25_DISC,
 987                                                   AX25_POLLON,
 988                                                   AX25_COMMAND);
 989                                 ax25_stop_t2timer(ax25);
 990                                 ax25_stop_t3timer(ax25);
 991                                 ax25_stop_idletimer(ax25);
 992                                 break;
 993 #ifdef CONFIG_AX25_DAMA_SLAVE
 994                         case AX25_PROTO_DAMA_SLAVE:
 995                                 ax25_stop_t3timer(ax25);
 996                                 ax25_stop_idletimer(ax25);
 997                                 break;
 998 #endif
 999                         }
1000                         ax25_calculate_t1(ax25);
1001                         ax25_start_t1timer(ax25);
1002                         ax25->state = AX25_STATE_2;
1003                         sk->sk_state                = TCP_CLOSE;
1004                         sk->sk_shutdown            |= SEND_SHUTDOWN;
1005                         sk->sk_state_change(sk);
1006                         sock_set_flag(sk, SOCK_DESTROY);
1007                         break;
1008
1009                 default:
1010                         break;
1011                 }
1012         } else {
1013                 sk->sk_state     = TCP_CLOSE;
1014                 sk->sk_shutdown |= SEND_SHUTDOWN;
1015                 sk->sk_state_change(sk);
1016                 ax25_destroy_socket(ax25);
1017         }
1018
1019         sock->sk   = NULL;
1020         release_sock(sk);
1021         sock_put(sk);
1022
1023         return 0;
1024 }
1025
1026 /*
1027  *      We support a funny extension here so you can (as root) give any callsign
1028  *      digipeated via a local address as source. This hack is obsolete now
1029  *      that we've implemented support for SO_BINDTODEVICE. It is however small
1030  *      and trivially backward compatible.
1031  */
1032 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1033 {
1034         struct sock *sk = sock->sk;
1035         struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1036         ax25_dev *ax25_dev = NULL;
1037         ax25_uid_assoc *user;
1038         ax25_address call;
1039         ax25_cb *ax25;
1040         int err = 0;
1041
1042         if (addr_len != sizeof(struct sockaddr_ax25) &&
1043             addr_len != sizeof(struct full_sockaddr_ax25))
1044                 /* support for old structure may go away some time
1045                  * ax25_bind(): uses old (6 digipeater) socket structure.
1046                  */
1047                 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1048                     (addr_len > sizeof(struct full_sockaddr_ax25)))
1049                         return -EINVAL;
1050
1051         if (addr->fsa_ax25.sax25_family != AF_AX25)
1052                 return -EINVAL;
1053
1054         user = ax25_findbyuid(current_euid());
1055         if (user) {
1056                 call = user->call;
1057                 ax25_uid_put(user);
1058         } else {
1059                 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1060                         return -EACCES;
1061
1062                 call = addr->fsa_ax25.sax25_call;
1063         }
1064
1065         lock_sock(sk);
1066
1067         ax25 = ax25_sk(sk);
1068         if (!sock_flag(sk, SOCK_ZAPPED)) {
1069                 err = -EINVAL;
1070                 goto out;
1071         }
1072
1073         ax25->source_addr = call;
1074
1075         /*
1076          * User already set interface with SO_BINDTODEVICE
1077          */
1078         if (ax25->ax25_dev != NULL)
1079                 goto done;
1080
1081         if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1082                 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1083                     (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1084                         err = -EADDRNOTAVAIL;
1085                         goto out;
1086                 }
1087         } else {
1088                 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1089                         err = -EADDRNOTAVAIL;
1090                         goto out;
1091                 }
1092         }
1093
1094         if (ax25_dev != NULL)
1095                 ax25_fillin_cb(ax25, ax25_dev);
1096
1097 done:
1098         ax25_cb_add(ax25);
1099         sock_reset_flag(sk, SOCK_ZAPPED);
1100
1101 out:
1102         release_sock(sk);
1103
1104         return 0;
1105 }
1106
1107 /*
1108  *      FIXME: nonblock behaviour looks like it may have a bug.
1109  */
1110 static int __must_check ax25_connect(struct socket *sock,
1111         struct sockaddr *uaddr, int addr_len, int flags)
1112 {
1113         struct sock *sk = sock->sk;
1114         ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1115         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1116         ax25_digi *digi = NULL;
1117         int ct = 0, err = 0;
1118
1119         /*
1120          * some sanity checks. code further down depends on this
1121          */
1122
1123         if (addr_len == sizeof(struct sockaddr_ax25))
1124                 /* support for this will go away in early 2.5.x
1125                  * ax25_connect(): uses obsolete socket structure
1126                  */
1127                 ;
1128         else if (addr_len != sizeof(struct full_sockaddr_ax25))
1129                 /* support for old structure may go away some time
1130                  * ax25_connect(): uses old (6 digipeater) socket structure.
1131                  */
1132                 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1133                     (addr_len > sizeof(struct full_sockaddr_ax25)))
1134                         return -EINVAL;
1135
1136
1137         if (fsa->fsa_ax25.sax25_family != AF_AX25)
1138                 return -EINVAL;
1139
1140         lock_sock(sk);
1141
1142         /* deal with restarts */
1143         if (sock->state == SS_CONNECTING) {
1144                 switch (sk->sk_state) {
1145                 case TCP_SYN_SENT: /* still trying */
1146                         err = -EINPROGRESS;
1147                         goto out_release;
1148
1149                 case TCP_ESTABLISHED: /* connection established */
1150                         sock->state = SS_CONNECTED;
1151                         goto out_release;
1152
1153                 case TCP_CLOSE: /* connection refused */
1154                         sock->state = SS_UNCONNECTED;
1155                         err = -ECONNREFUSED;
1156                         goto out_release;
1157                 }
1158         }
1159
1160         if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1161                 err = -EISCONN; /* No reconnect on a seqpacket socket */
1162                 goto out_release;
1163         }
1164
1165         sk->sk_state   = TCP_CLOSE;
1166         sock->state = SS_UNCONNECTED;
1167
1168         kfree(ax25->digipeat);
1169         ax25->digipeat = NULL;
1170
1171         /*
1172          *      Handle digi-peaters to be used.
1173          */
1174         if (addr_len > sizeof(struct sockaddr_ax25) &&
1175             fsa->fsa_ax25.sax25_ndigis != 0) {
1176                 /* Valid number of digipeaters ? */
1177                 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1178                         err = -EINVAL;
1179                         goto out_release;
1180                 }
1181
1182                 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1183                         err = -ENOBUFS;
1184                         goto out_release;
1185                 }
1186
1187                 digi->ndigi      = fsa->fsa_ax25.sax25_ndigis;
1188                 digi->lastrepeat = -1;
1189
1190                 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1191                         if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1192                              AX25_HBIT) && ax25->iamdigi) {
1193                                 digi->repeated[ct] = 1;
1194                                 digi->lastrepeat   = ct;
1195                         } else {
1196                                 digi->repeated[ct] = 0;
1197                         }
1198                         digi->calls[ct] = fsa->fsa_digipeater[ct];
1199                         ct++;
1200                 }
1201         }
1202
1203         /*
1204          *      Must bind first - autobinding in this may or may not work. If
1205          *      the socket is already bound, check to see if the device has
1206          *      been filled in, error if it hasn't.
1207          */
1208         if (sock_flag(sk, SOCK_ZAPPED)) {
1209                 /* check if we can remove this feature. It is broken. */
1210                 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1211                         current->comm);
1212                 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1213                         kfree(digi);
1214                         goto out_release;
1215                 }
1216
1217                 ax25_fillin_cb(ax25, ax25->ax25_dev);
1218                 ax25_cb_add(ax25);
1219         } else {
1220                 if (ax25->ax25_dev == NULL) {
1221                         kfree(digi);
1222                         err = -EHOSTUNREACH;
1223                         goto out_release;
1224                 }
1225         }
1226
1227         if (sk->sk_type == SOCK_SEQPACKET &&
1228             (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1229                          ax25->ax25_dev->dev))) {
1230                 kfree(digi);
1231                 err = -EADDRINUSE;              /* Already such a connection */
1232                 ax25_cb_put(ax25t);
1233                 goto out_release;
1234         }
1235
1236         ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1237         ax25->digipeat  = digi;
1238
1239         /* First the easy one */
1240         if (sk->sk_type != SOCK_SEQPACKET) {
1241                 sock->state = SS_CONNECTED;
1242                 sk->sk_state   = TCP_ESTABLISHED;
1243                 goto out_release;
1244         }
1245
1246         /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1247         sock->state        = SS_CONNECTING;
1248         sk->sk_state          = TCP_SYN_SENT;
1249
1250         switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1251         case AX25_PROTO_STD_SIMPLEX:
1252         case AX25_PROTO_STD_DUPLEX:
1253                 ax25_std_establish_data_link(ax25);
1254                 break;
1255
1256 #ifdef CONFIG_AX25_DAMA_SLAVE
1257         case AX25_PROTO_DAMA_SLAVE:
1258                 ax25->modulus = AX25_MODULUS;
1259                 ax25->window  = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1260                 if (ax25->ax25_dev->dama.slave)
1261                         ax25_ds_establish_data_link(ax25);
1262                 else
1263                         ax25_std_establish_data_link(ax25);
1264                 break;
1265 #endif
1266         }
1267
1268         ax25->state = AX25_STATE_1;
1269
1270         ax25_start_heartbeat(ax25);
1271
1272         /* Now the loop */
1273         if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1274                 err = -EINPROGRESS;
1275                 goto out_release;
1276         }
1277
1278         if (sk->sk_state == TCP_SYN_SENT) {
1279                 DEFINE_WAIT(wait);
1280
1281                 for (;;) {
1282                         prepare_to_wait(sk->sk_sleep, &wait,
1283                                         TASK_INTERRUPTIBLE);
1284                         if (sk->sk_state != TCP_SYN_SENT)
1285                                 break;
1286                         if (!signal_pending(current)) {
1287                                 release_sock(sk);
1288                                 schedule();
1289                                 lock_sock(sk);
1290                                 continue;
1291                         }
1292                         err = -ERESTARTSYS;
1293                         break;
1294                 }
1295                 finish_wait(sk->sk_sleep, &wait);
1296
1297                 if (err)
1298                         goto out_release;
1299         }
1300
1301         if (sk->sk_state != TCP_ESTABLISHED) {
1302                 /* Not in ABM, not in WAIT_UA -> failed */
1303                 sock->state = SS_UNCONNECTED;
1304                 err = sock_error(sk);   /* Always set at this point */
1305                 goto out_release;
1306         }
1307
1308         sock->state = SS_CONNECTED;
1309
1310         err = 0;
1311 out_release:
1312         release_sock(sk);
1313
1314         return err;
1315 }
1316
1317 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1318 {
1319         struct sk_buff *skb;
1320         struct sock *newsk;
1321         DEFINE_WAIT(wait);
1322         struct sock *sk;
1323         int err = 0;
1324
1325         if (sock->state != SS_UNCONNECTED)
1326                 return -EINVAL;
1327
1328         if ((sk = sock->sk) == NULL)
1329                 return -EINVAL;
1330
1331         lock_sock(sk);
1332         if (sk->sk_type != SOCK_SEQPACKET) {
1333                 err = -EOPNOTSUPP;
1334                 goto out;
1335         }
1336
1337         if (sk->sk_state != TCP_LISTEN) {
1338                 err = -EINVAL;
1339                 goto out;
1340         }
1341
1342         /*
1343          *      The read queue this time is holding sockets ready to use
1344          *      hooked into the SABM we saved
1345          */
1346         for (;;) {
1347                 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1348                 skb = skb_dequeue(&sk->sk_receive_queue);
1349                 if (skb)
1350                         break;
1351
1352                 if (flags & O_NONBLOCK) {
1353                         err = -EWOULDBLOCK;
1354                         break;
1355                 }
1356                 if (!signal_pending(current)) {
1357                         release_sock(sk);
1358                         schedule();
1359                         lock_sock(sk);
1360                         continue;
1361                 }
1362                 err = -ERESTARTSYS;
1363                 break;
1364         }
1365         finish_wait(sk->sk_sleep, &wait);
1366
1367         if (err)
1368                 goto out;
1369
1370         newsk            = skb->sk;
1371         sock_graft(newsk, newsock);
1372
1373         /* Now attach up the new socket */
1374         kfree_skb(skb);
1375         sk->sk_ack_backlog--;
1376         newsock->state = SS_CONNECTED;
1377
1378 out:
1379         release_sock(sk);
1380
1381         return err;
1382 }
1383
1384 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1385         int *uaddr_len, int peer)
1386 {
1387         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1388         struct sock *sk = sock->sk;
1389         unsigned char ndigi, i;
1390         ax25_cb *ax25;
1391         int err = 0;
1392
1393         lock_sock(sk);
1394         ax25 = ax25_sk(sk);
1395
1396         if (peer != 0) {
1397                 if (sk->sk_state != TCP_ESTABLISHED) {
1398                         err = -ENOTCONN;
1399                         goto out;
1400                 }
1401
1402                 fsa->fsa_ax25.sax25_family = AF_AX25;
1403                 fsa->fsa_ax25.sax25_call   = ax25->dest_addr;
1404                 fsa->fsa_ax25.sax25_ndigis = 0;
1405
1406                 if (ax25->digipeat != NULL) {
1407                         ndigi = ax25->digipeat->ndigi;
1408                         fsa->fsa_ax25.sax25_ndigis = ndigi;
1409                         for (i = 0; i < ndigi; i++)
1410                                 fsa->fsa_digipeater[i] =
1411                                                 ax25->digipeat->calls[i];
1412                 }
1413         } else {
1414                 fsa->fsa_ax25.sax25_family = AF_AX25;
1415                 fsa->fsa_ax25.sax25_call   = ax25->source_addr;
1416                 fsa->fsa_ax25.sax25_ndigis = 1;
1417                 if (ax25->ax25_dev != NULL) {
1418                         memcpy(&fsa->fsa_digipeater[0],
1419                                ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1420                 } else {
1421                         fsa->fsa_digipeater[0] = null_ax25_address;
1422                 }
1423         }
1424         *uaddr_len = sizeof (struct full_sockaddr_ax25);
1425
1426 out:
1427         release_sock(sk);
1428
1429         return err;
1430 }
1431
1432 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1433                         struct msghdr *msg, size_t len)
1434 {
1435         struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1436         struct sock *sk = sock->sk;
1437         struct sockaddr_ax25 sax;
1438         struct sk_buff *skb;
1439         ax25_digi dtmp, *dp;
1440         ax25_cb *ax25;
1441         size_t size;
1442         int lv, err, addr_len = msg->msg_namelen;
1443
1444         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1445                 return -EINVAL;
1446
1447         lock_sock(sk);
1448         ax25 = ax25_sk(sk);
1449
1450         if (sock_flag(sk, SOCK_ZAPPED)) {
1451                 err = -EADDRNOTAVAIL;
1452                 goto out;
1453         }
1454
1455         if (sk->sk_shutdown & SEND_SHUTDOWN) {
1456                 send_sig(SIGPIPE, current, 0);
1457                 err = -EPIPE;
1458                 goto out;
1459         }
1460
1461         if (ax25->ax25_dev == NULL) {
1462                 err = -ENETUNREACH;
1463                 goto out;
1464         }
1465
1466         if (len > ax25->ax25_dev->dev->mtu) {
1467                 err = -EMSGSIZE;
1468                 goto out;
1469         }
1470
1471         if (usax != NULL) {
1472                 if (usax->sax25_family != AF_AX25) {
1473                         err = -EINVAL;
1474                         goto out;
1475                 }
1476
1477                 if (addr_len == sizeof(struct sockaddr_ax25))
1478                         /* ax25_sendmsg(): uses obsolete socket structure */
1479                         ;
1480                 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1481                         /* support for old structure may go away some time
1482                          * ax25_sendmsg(): uses old (6 digipeater)
1483                          * socket structure.
1484                          */
1485                         if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1486                             (addr_len > sizeof(struct full_sockaddr_ax25))) {
1487                                 err = -EINVAL;
1488                                 goto out;
1489                         }
1490
1491
1492                 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1493                         int ct           = 0;
1494                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1495
1496                         /* Valid number of digipeaters ? */
1497                         if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1498                                 err = -EINVAL;
1499                                 goto out;
1500                         }
1501
1502                         dtmp.ndigi      = usax->sax25_ndigis;
1503
1504                         while (ct < usax->sax25_ndigis) {
1505                                 dtmp.repeated[ct] = 0;
1506                                 dtmp.calls[ct]    = fsa->fsa_digipeater[ct];
1507                                 ct++;
1508                         }
1509
1510                         dtmp.lastrepeat = 0;
1511                 }
1512
1513                 sax = *usax;
1514                 if (sk->sk_type == SOCK_SEQPACKET &&
1515                     ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1516                         err = -EISCONN;
1517                         goto out;
1518                 }
1519                 if (usax->sax25_ndigis == 0)
1520                         dp = NULL;
1521                 else
1522                         dp = &dtmp;
1523         } else {
1524                 /*
1525                  *      FIXME: 1003.1g - if the socket is like this because
1526                  *      it has become closed (not started closed) and is VC
1527                  *      we ought to SIGPIPE, EPIPE
1528                  */
1529                 if (sk->sk_state != TCP_ESTABLISHED) {
1530                         err = -ENOTCONN;
1531                         goto out;
1532                 }
1533                 sax.sax25_family = AF_AX25;
1534                 sax.sax25_call   = ax25->dest_addr;
1535                 dp = ax25->digipeat;
1536         }
1537
1538         /* Build a packet */
1539         SOCK_DEBUG(sk, "AX.25: sendto: Addresses built. Building packet.\n");
1540
1541         /* Assume the worst case */
1542         size = len + ax25->ax25_dev->dev->hard_header_len;
1543
1544         skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1545         if (skb == NULL)
1546                 goto out;
1547
1548         skb_reserve(skb, size - len);
1549
1550         SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1551
1552         /* User data follows immediately after the AX.25 data */
1553         if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1554                 err = -EFAULT;
1555                 kfree_skb(skb);
1556                 goto out;
1557         }
1558
1559         skb_reset_network_header(skb);
1560
1561         /* Add the PID if one is not supplied by the user in the skb */
1562         if (!ax25->pidincl)
1563                 *skb_push(skb, 1) = sk->sk_protocol;
1564
1565         SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1566
1567         if (sk->sk_type == SOCK_SEQPACKET) {
1568                 /* Connected mode sockets go via the LAPB machine */
1569                 if (sk->sk_state != TCP_ESTABLISHED) {
1570                         kfree_skb(skb);
1571                         err = -ENOTCONN;
1572                         goto out;
1573                 }
1574
1575                 /* Shove it onto the queue and kick */
1576                 ax25_output(ax25, ax25->paclen, skb);
1577
1578                 err = len;
1579                 goto out;
1580         }
1581
1582         skb_push(skb, 1 + ax25_addr_size(dp));
1583
1584         SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1585
1586         if (dp != NULL)
1587                 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1588
1589         /* Build an AX.25 header */
1590         lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1591                              dp, AX25_COMMAND, AX25_MODULUS);
1592
1593         SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1594
1595         skb_set_transport_header(skb, lv);
1596
1597         SOCK_DEBUG(sk, "base=%p pos=%p\n",
1598                    skb->data, skb_transport_header(skb));
1599
1600         *skb_transport_header(skb) = AX25_UI;
1601
1602         /* Datagram frames go straight out of the door as UI */
1603         ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1604
1605         err = len;
1606
1607 out:
1608         release_sock(sk);
1609
1610         return err;
1611 }
1612
1613 static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1614         struct msghdr *msg, size_t size, int flags)
1615 {
1616         struct sock *sk = sock->sk;
1617         struct sk_buff *skb;
1618         int copied;
1619         int err = 0;
1620
1621         lock_sock(sk);
1622         /*
1623          *      This works for seqpacket too. The receiver has ordered the
1624          *      queue for us! We do one quick check first though
1625          */
1626         if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1627                 err =  -ENOTCONN;
1628                 goto out;
1629         }
1630
1631         /* Now we can treat all alike */
1632         skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1633                                 flags & MSG_DONTWAIT, &err);
1634         if (skb == NULL)
1635                 goto out;
1636
1637         if (!ax25_sk(sk)->pidincl)
1638                 skb_pull(skb, 1);               /* Remove PID */
1639
1640         skb_reset_transport_header(skb);
1641         copied = skb->len;
1642
1643         if (copied > size) {
1644                 copied = size;
1645                 msg->msg_flags |= MSG_TRUNC;
1646         }
1647
1648         skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1649
1650         if (msg->msg_namelen != 0) {
1651                 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1652                 ax25_digi digi;
1653                 ax25_address src;
1654                 const unsigned char *mac = skb_mac_header(skb);
1655
1656                 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1657                                 &digi, NULL, NULL);
1658                 sax->sax25_family = AF_AX25;
1659                 /* We set this correctly, even though we may not let the
1660                    application know the digi calls further down (because it
1661                    did NOT ask to know them).  This could get political... **/
1662                 sax->sax25_ndigis = digi.ndigi;
1663                 sax->sax25_call   = src;
1664
1665                 if (sax->sax25_ndigis != 0) {
1666                         int ct;
1667                         struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1668
1669                         for (ct = 0; ct < digi.ndigi; ct++)
1670                                 fsa->fsa_digipeater[ct] = digi.calls[ct];
1671                 }
1672                 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1673         }
1674
1675         skb_free_datagram(sk, skb);
1676         err = copied;
1677
1678 out:
1679         release_sock(sk);
1680
1681         return err;
1682 }
1683
1684 static int ax25_shutdown(struct socket *sk, int how)
1685 {
1686         /* FIXME - generate DM and RNR states */
1687         return -EOPNOTSUPP;
1688 }
1689
1690 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1691 {
1692         struct sock *sk = sock->sk;
1693         void __user *argp = (void __user *)arg;
1694         int res = 0;
1695
1696         lock_sock(sk);
1697         switch (cmd) {
1698         case TIOCOUTQ: {
1699                 long amount;
1700
1701                 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
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     = sk_rmem_alloc_get(sk);
1792                 ax25_info.snd_q     = sk_wmem_alloc_get(sk);
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                 seq_printf(seq, " %d %d %lu\n",
1932                            sk_wmem_alloc_get(ax25->sk),
1933                            sk_rmem_alloc_get(ax25->sk),
1934                            sock_i_ino(ax25->sk));
1935         } else {
1936                 seq_puts(seq, " * * *\n");
1937         }
1938         return 0;
1939 }
1940
1941 static const struct seq_operations ax25_info_seqops = {
1942         .start = ax25_info_start,
1943         .next = ax25_info_next,
1944         .stop = ax25_info_stop,
1945         .show = ax25_info_show,
1946 };
1947
1948 static int ax25_info_open(struct inode *inode, struct file *file)
1949 {
1950         return seq_open(file, &ax25_info_seqops);
1951 }
1952
1953 static const struct file_operations ax25_info_fops = {
1954         .owner = THIS_MODULE,
1955         .open = ax25_info_open,
1956         .read = seq_read,
1957         .llseek = seq_lseek,
1958         .release = seq_release,
1959 };
1960
1961 #endif
1962
1963 static struct net_proto_family ax25_family_ops = {
1964         .family =       PF_AX25,
1965         .create =       ax25_create,
1966         .owner  =       THIS_MODULE,
1967 };
1968
1969 static const struct proto_ops ax25_proto_ops = {
1970         .family         = PF_AX25,
1971         .owner          = THIS_MODULE,
1972         .release        = ax25_release,
1973         .bind           = ax25_bind,
1974         .connect        = ax25_connect,
1975         .socketpair     = sock_no_socketpair,
1976         .accept         = ax25_accept,
1977         .getname        = ax25_getname,
1978         .poll           = datagram_poll,
1979         .ioctl          = ax25_ioctl,
1980         .listen         = ax25_listen,
1981         .shutdown       = ax25_shutdown,
1982         .setsockopt     = ax25_setsockopt,
1983         .getsockopt     = ax25_getsockopt,
1984         .sendmsg        = ax25_sendmsg,
1985         .recvmsg        = ax25_recvmsg,
1986         .mmap           = sock_no_mmap,
1987         .sendpage       = sock_no_sendpage,
1988 };
1989
1990 /*
1991  *      Called by socket.c on kernel start up
1992  */
1993 static struct packet_type ax25_packet_type __read_mostly = {
1994         .type   =       cpu_to_be16(ETH_P_AX25),
1995         .func   =       ax25_kiss_rcv,
1996 };
1997
1998 static struct notifier_block ax25_dev_notifier = {
1999         .notifier_call =ax25_device_event,
2000 };
2001
2002 static int __init ax25_init(void)
2003 {
2004         int rc = proto_register(&ax25_proto, 0);
2005
2006         if (rc != 0)
2007                 goto out;
2008
2009         sock_register(&ax25_family_ops);
2010         dev_add_pack(&ax25_packet_type);
2011         register_netdevice_notifier(&ax25_dev_notifier);
2012         ax25_register_sysctl();
2013
2014         proc_net_fops_create(&init_net, "ax25_route", S_IRUGO, &ax25_route_fops);
2015         proc_net_fops_create(&init_net, "ax25", S_IRUGO, &ax25_info_fops);
2016         proc_net_fops_create(&init_net, "ax25_calls", S_IRUGO, &ax25_uid_fops);
2017 out:
2018         return rc;
2019 }
2020 module_init(ax25_init);
2021
2022
2023 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2024 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2025 MODULE_LICENSE("GPL");
2026 MODULE_ALIAS_NETPROTO(PF_AX25);
2027
2028 static void __exit ax25_exit(void)
2029 {
2030         proc_net_remove(&init_net, "ax25_route");
2031         proc_net_remove(&init_net, "ax25");
2032         proc_net_remove(&init_net, "ax25_calls");
2033         ax25_rt_free();
2034         ax25_uid_free();
2035         ax25_dev_free();
2036
2037         ax25_unregister_sysctl();
2038         unregister_netdevice_notifier(&ax25_dev_notifier);
2039
2040         dev_remove_pack(&ax25_packet_type);
2041
2042         sock_unregister(PF_AX25);
2043         proto_unregister(&ax25_proto);
2044 }
2045 module_exit(ax25_exit);