linux/net/rose/af_rose.c
<<
>>
Prefs
   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) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
   8 * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
   9 * Copyright (C) Terry Dawson VK2KTJ (terry@animats.net)
  10 * Copyright (C) Tomi Manninen OH2BNS (oh2bns@sral.fi)
  11 */
  12
  13#include <linux/capability.h>
  14#include <linux/module.h>
  15#include <linux/moduleparam.h>
  16#include <linux/init.h>
  17#include <linux/errno.h>
  18#include <linux/types.h>
  19#include <linux/socket.h>
  20#include <linux/in.h>
  21#include <linux/slab.h>
  22#include <linux/kernel.h>
  23#include <linux/sched.h>
  24#include <linux/spinlock.h>
  25#include <linux/timer.h>
  26#include <linux/string.h>
  27#include <linux/sockios.h>
  28#include <linux/net.h>
  29#include <linux/stat.h>
  30#include <net/net_namespace.h>
  31#include <net/ax25.h>
  32#include <linux/inet.h>
  33#include <linux/netdevice.h>
  34#include <linux/if_arp.h>
  35#include <linux/skbuff.h>
  36#include <net/sock.h>
  37#include <asm/uaccess.h>
  38#include <linux/fcntl.h>
  39#include <linux/termios.h>
  40#include <linux/mm.h>
  41#include <linux/interrupt.h>
  42#include <linux/notifier.h>
  43#include <net/rose.h>
  44#include <linux/proc_fs.h>
  45#include <linux/seq_file.h>
  46#include <net/tcp_states.h>
  47#include <net/ip.h>
  48#include <net/arp.h>
  49
  50static int rose_ndevs = 10;
  51
  52int sysctl_rose_restart_request_timeout = ROSE_DEFAULT_T0;
  53int sysctl_rose_call_request_timeout    = ROSE_DEFAULT_T1;
  54int sysctl_rose_reset_request_timeout   = ROSE_DEFAULT_T2;
  55int sysctl_rose_clear_request_timeout   = ROSE_DEFAULT_T3;
  56int sysctl_rose_no_activity_timeout     = ROSE_DEFAULT_IDLE;
  57int sysctl_rose_ack_hold_back_timeout   = ROSE_DEFAULT_HB;
  58int sysctl_rose_routing_control         = ROSE_DEFAULT_ROUTING;
  59int sysctl_rose_link_fail_timeout       = ROSE_DEFAULT_FAIL_TIMEOUT;
  60int sysctl_rose_maximum_vcs             = ROSE_DEFAULT_MAXVC;
  61int sysctl_rose_window_size             = ROSE_DEFAULT_WINDOW_SIZE;
  62
  63static HLIST_HEAD(rose_list);
  64static DEFINE_SPINLOCK(rose_list_lock);
  65
  66static const struct proto_ops rose_proto_ops;
  67
  68ax25_address rose_callsign;
  69
  70/*
  71 * ROSE network devices are virtual network devices encapsulating ROSE
  72 * frames into AX.25 which will be sent through an AX.25 device, so form a
  73 * special "super class" of normal net devices; split their locks off into a
  74 * separate class since they always nest.
  75 */
  76static struct lock_class_key rose_netdev_xmit_lock_key;
  77static struct lock_class_key rose_netdev_addr_lock_key;
  78
  79static void rose_set_lockdep_one(struct net_device *dev,
  80                                 struct netdev_queue *txq,
  81                                 void *_unused)
  82{
  83        lockdep_set_class(&txq->_xmit_lock, &rose_netdev_xmit_lock_key);
  84}
  85
  86static void rose_set_lockdep_key(struct net_device *dev)
  87{
  88        lockdep_set_class(&dev->addr_list_lock, &rose_netdev_addr_lock_key);
  89        netdev_for_each_tx_queue(dev, rose_set_lockdep_one, NULL);
  90}
  91
  92/*
  93 *      Convert a ROSE address into text.
  94 */
  95char *rose2asc(char *buf, const rose_address *addr)
  96{
  97        if (addr->rose_addr[0] == 0x00 && addr->rose_addr[1] == 0x00 &&
  98            addr->rose_addr[2] == 0x00 && addr->rose_addr[3] == 0x00 &&
  99            addr->rose_addr[4] == 0x00) {
 100                strcpy(buf, "*");
 101        } else {
 102                sprintf(buf, "%02X%02X%02X%02X%02X", addr->rose_addr[0] & 0xFF,
 103                                                addr->rose_addr[1] & 0xFF,
 104                                                addr->rose_addr[2] & 0xFF,
 105                                                addr->rose_addr[3] & 0xFF,
 106                                                addr->rose_addr[4] & 0xFF);
 107        }
 108
 109        return buf;
 110}
 111
 112/*
 113 *      Compare two ROSE addresses, 0 == equal.
 114 */
 115int rosecmp(rose_address *addr1, rose_address *addr2)
 116{
 117        int i;
 118
 119        for (i = 0; i < 5; i++)
 120                if (addr1->rose_addr[i] != addr2->rose_addr[i])
 121                        return 1;
 122
 123        return 0;
 124}
 125
 126/*
 127 *      Compare two ROSE addresses for only mask digits, 0 == equal.
 128 */
 129int rosecmpm(rose_address *addr1, rose_address *addr2, unsigned short mask)
 130{
 131        unsigned int i, j;
 132
 133        if (mask > 10)
 134                return 1;
 135
 136        for (i = 0; i < mask; i++) {
 137                j = i / 2;
 138
 139                if ((i % 2) != 0) {
 140                        if ((addr1->rose_addr[j] & 0x0F) != (addr2->rose_addr[j] & 0x0F))
 141                                return 1;
 142                } else {
 143                        if ((addr1->rose_addr[j] & 0xF0) != (addr2->rose_addr[j] & 0xF0))
 144                                return 1;
 145                }
 146        }
 147
 148        return 0;
 149}
 150
 151/*
 152 *      Socket removal during an interrupt is now safe.
 153 */
 154static void rose_remove_socket(struct sock *sk)
 155{
 156        spin_lock_bh(&rose_list_lock);
 157        sk_del_node_init(sk);
 158        spin_unlock_bh(&rose_list_lock);
 159}
 160
 161/*
 162 *      Kill all bound sockets on a broken link layer connection to a
 163 *      particular neighbour.
 164 */
 165void rose_kill_by_neigh(struct rose_neigh *neigh)
 166{
 167        struct sock *s;
 168
 169        spin_lock_bh(&rose_list_lock);
 170        sk_for_each(s, &rose_list) {
 171                struct rose_sock *rose = rose_sk(s);
 172
 173                if (rose->neighbour == neigh) {
 174                        rose_disconnect(s, ENETUNREACH, ROSE_OUT_OF_ORDER, 0);
 175                        rose->neighbour->use--;
 176                        rose->neighbour = NULL;
 177                }
 178        }
 179        spin_unlock_bh(&rose_list_lock);
 180}
 181
 182/*
 183 *      Kill all bound sockets on a dropped device.
 184 */
 185static void rose_kill_by_device(struct net_device *dev)
 186{
 187        struct sock *s;
 188
 189        spin_lock_bh(&rose_list_lock);
 190        sk_for_each(s, &rose_list) {
 191                struct rose_sock *rose = rose_sk(s);
 192
 193                if (rose->device == dev) {
 194                        rose_disconnect(s, ENETUNREACH, ROSE_OUT_OF_ORDER, 0);
 195                        rose->neighbour->use--;
 196                        rose->device = NULL;
 197                }
 198        }
 199        spin_unlock_bh(&rose_list_lock);
 200}
 201
 202/*
 203 *      Handle device status changes.
 204 */
 205static int rose_device_event(struct notifier_block *this,
 206                             unsigned long event, void *ptr)
 207{
 208        struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 209
 210        if (!net_eq(dev_net(dev), &init_net))
 211                return NOTIFY_DONE;
 212
 213        if (event != NETDEV_DOWN)
 214                return NOTIFY_DONE;
 215
 216        switch (dev->type) {
 217        case ARPHRD_ROSE:
 218                rose_kill_by_device(dev);
 219                break;
 220        case ARPHRD_AX25:
 221                rose_link_device_down(dev);
 222                rose_rt_device_down(dev);
 223                break;
 224        }
 225
 226        return NOTIFY_DONE;
 227}
 228
 229/*
 230 *      Add a socket to the bound sockets list.
 231 */
 232static void rose_insert_socket(struct sock *sk)
 233{
 234
 235        spin_lock_bh(&rose_list_lock);
 236        sk_add_node(sk, &rose_list);
 237        spin_unlock_bh(&rose_list_lock);
 238}
 239
 240/*
 241 *      Find a socket that wants to accept the Call Request we just
 242 *      received.
 243 */
 244static struct sock *rose_find_listener(rose_address *addr, ax25_address *call)
 245{
 246        struct sock *s;
 247
 248        spin_lock_bh(&rose_list_lock);
 249        sk_for_each(s, &rose_list) {
 250                struct rose_sock *rose = rose_sk(s);
 251
 252                if (!rosecmp(&rose->source_addr, addr) &&
 253                    !ax25cmp(&rose->source_call, call) &&
 254                    !rose->source_ndigis && s->sk_state == TCP_LISTEN)
 255                        goto found;
 256        }
 257
 258        sk_for_each(s, &rose_list) {
 259                struct rose_sock *rose = rose_sk(s);
 260
 261                if (!rosecmp(&rose->source_addr, addr) &&
 262                    !ax25cmp(&rose->source_call, &null_ax25_address) &&
 263                    s->sk_state == TCP_LISTEN)
 264                        goto found;
 265        }
 266        s = NULL;
 267found:
 268        spin_unlock_bh(&rose_list_lock);
 269        return s;
 270}
 271
 272/*
 273 *      Find a connected ROSE socket given my LCI and device.
 274 */
 275struct sock *rose_find_socket(unsigned int lci, struct rose_neigh *neigh)
 276{
 277        struct sock *s;
 278
 279        spin_lock_bh(&rose_list_lock);
 280        sk_for_each(s, &rose_list) {
 281                struct rose_sock *rose = rose_sk(s);
 282
 283                if (rose->lci == lci && rose->neighbour == neigh)
 284                        goto found;
 285        }
 286        s = NULL;
 287found:
 288        spin_unlock_bh(&rose_list_lock);
 289        return s;
 290}
 291
 292/*
 293 *      Find a unique LCI for a given device.
 294 */
 295unsigned int rose_new_lci(struct rose_neigh *neigh)
 296{
 297        int lci;
 298
 299        if (neigh->dce_mode) {
 300                for (lci = 1; lci <= sysctl_rose_maximum_vcs; lci++)
 301                        if (rose_find_socket(lci, neigh) == NULL && rose_route_free_lci(lci, neigh) == NULL)
 302                                return lci;
 303        } else {
 304                for (lci = sysctl_rose_maximum_vcs; lci > 0; lci--)
 305                        if (rose_find_socket(lci, neigh) == NULL && rose_route_free_lci(lci, neigh) == NULL)
 306                                return lci;
 307        }
 308
 309        return 0;
 310}
 311
 312/*
 313 *      Deferred destroy.
 314 */
 315void rose_destroy_socket(struct sock *);
 316
 317/*
 318 *      Handler for deferred kills.
 319 */
 320static void rose_destroy_timer(unsigned long data)
 321{
 322        rose_destroy_socket((struct sock *)data);
 323}
 324
 325/*
 326 *      This is called from user mode and the timers. Thus it protects itself
 327 *      against interrupt users but doesn't worry about being called during
 328 *      work.  Once it is removed from the queue no interrupt or bottom half
 329 *      will touch it and we are (fairly 8-) ) safe.
 330 */
 331void rose_destroy_socket(struct sock *sk)
 332{
 333        struct sk_buff *skb;
 334
 335        rose_remove_socket(sk);
 336        rose_stop_heartbeat(sk);
 337        rose_stop_idletimer(sk);
 338        rose_stop_timer(sk);
 339
 340        rose_clear_queues(sk);          /* Flush the queues */
 341
 342        while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
 343                if (skb->sk != sk) {    /* A pending connection */
 344                        /* Queue the unaccepted socket for death */
 345                        sock_set_flag(skb->sk, SOCK_DEAD);
 346                        rose_start_heartbeat(skb->sk);
 347                        rose_sk(skb->sk)->state = ROSE_STATE_0;
 348                }
 349
 350                kfree_skb(skb);
 351        }
 352
 353        if (sk_has_allocations(sk)) {
 354                /* Defer: outstanding buffers */
 355                setup_timer(&sk->sk_timer, rose_destroy_timer,
 356                                (unsigned long)sk);
 357                sk->sk_timer.expires  = jiffies + 10 * HZ;
 358                add_timer(&sk->sk_timer);
 359        } else
 360                sock_put(sk);
 361}
 362
 363/*
 364 *      Handling for system calls applied via the various interfaces to a
 365 *      ROSE socket object.
 366 */
 367
 368static int rose_setsockopt(struct socket *sock, int level, int optname,
 369        char __user *optval, unsigned int optlen)
 370{
 371        struct sock *sk = sock->sk;
 372        struct rose_sock *rose = rose_sk(sk);
 373        int opt;
 374
 375        if (level != SOL_ROSE)
 376                return -ENOPROTOOPT;
 377
 378        if (optlen < sizeof(int))
 379                return -EINVAL;
 380
 381        if (get_user(opt, (int __user *)optval))
 382                return -EFAULT;
 383
 384        switch (optname) {
 385        case ROSE_DEFER:
 386                rose->defer = opt ? 1 : 0;
 387                return 0;
 388
 389        case ROSE_T1:
 390                if (opt < 1)
 391                        return -EINVAL;
 392                rose->t1 = opt * HZ;
 393                return 0;
 394
 395        case ROSE_T2:
 396                if (opt < 1)
 397                        return -EINVAL;
 398                rose->t2 = opt * HZ;
 399                return 0;
 400
 401        case ROSE_T3:
 402                if (opt < 1)
 403                        return -EINVAL;
 404                rose->t3 = opt * HZ;
 405                return 0;
 406
 407        case ROSE_HOLDBACK:
 408                if (opt < 1)
 409                        return -EINVAL;
 410                rose->hb = opt * HZ;
 411                return 0;
 412
 413        case ROSE_IDLE:
 414                if (opt < 0)
 415                        return -EINVAL;
 416                rose->idle = opt * 60 * HZ;
 417                return 0;
 418
 419        case ROSE_QBITINCL:
 420                rose->qbitincl = opt ? 1 : 0;
 421                return 0;
 422
 423        default:
 424                return -ENOPROTOOPT;
 425        }
 426}
 427
 428static int rose_getsockopt(struct socket *sock, int level, int optname,
 429        char __user *optval, int __user *optlen)
 430{
 431        struct sock *sk = sock->sk;
 432        struct rose_sock *rose = rose_sk(sk);
 433        int val = 0;
 434        int len;
 435
 436        if (level != SOL_ROSE)
 437                return -ENOPROTOOPT;
 438
 439        if (get_user(len, optlen))
 440                return -EFAULT;
 441
 442        if (len < 0)
 443                return -EINVAL;
 444
 445        switch (optname) {
 446        case ROSE_DEFER:
 447                val = rose->defer;
 448                break;
 449
 450        case ROSE_T1:
 451                val = rose->t1 / HZ;
 452                break;
 453
 454        case ROSE_T2:
 455                val = rose->t2 / HZ;
 456                break;
 457
 458        case ROSE_T3:
 459                val = rose->t3 / HZ;
 460                break;
 461
 462        case ROSE_HOLDBACK:
 463                val = rose->hb / HZ;
 464                break;
 465
 466        case ROSE_IDLE:
 467                val = rose->idle / (60 * HZ);
 468                break;
 469
 470        case ROSE_QBITINCL:
 471                val = rose->qbitincl;
 472                break;
 473
 474        default:
 475                return -ENOPROTOOPT;
 476        }
 477
 478        len = min_t(unsigned int, len, sizeof(int));
 479
 480        if (put_user(len, optlen))
 481                return -EFAULT;
 482
 483        return copy_to_user(optval, &val, len) ? -EFAULT : 0;
 484}
 485
 486static int rose_listen(struct socket *sock, int backlog)
 487{
 488        struct sock *sk = sock->sk;
 489
 490        if (sk->sk_state != TCP_LISTEN) {
 491                struct rose_sock *rose = rose_sk(sk);
 492
 493                rose->dest_ndigis = 0;
 494                memset(&rose->dest_addr, 0, ROSE_ADDR_LEN);
 495                memset(&rose->dest_call, 0, AX25_ADDR_LEN);
 496                memset(rose->dest_digis, 0, AX25_ADDR_LEN * ROSE_MAX_DIGIS);
 497                sk->sk_max_ack_backlog = backlog;
 498                sk->sk_state           = TCP_LISTEN;
 499                return 0;
 500        }
 501
 502        return -EOPNOTSUPP;
 503}
 504
 505static struct proto rose_proto = {
 506        .name     = "ROSE",
 507        .owner    = THIS_MODULE,
 508        .obj_size = sizeof(struct rose_sock),
 509};
 510
 511static int rose_create(struct net *net, struct socket *sock, int protocol,
 512                       int kern)
 513{
 514        struct sock *sk;
 515        struct rose_sock *rose;
 516
 517        if (!net_eq(net, &init_net))
 518                return -EAFNOSUPPORT;
 519
 520        if (sock->type != SOCK_SEQPACKET || protocol != 0)
 521                return -ESOCKTNOSUPPORT;
 522
 523        sk = sk_alloc(net, PF_ROSE, GFP_ATOMIC, &rose_proto);
 524        if (sk == NULL)
 525                return -ENOMEM;
 526
 527        rose = rose_sk(sk);
 528
 529        sock_init_data(sock, sk);
 530
 531        skb_queue_head_init(&rose->ack_queue);
 532#ifdef M_BIT
 533        skb_queue_head_init(&rose->frag_queue);
 534        rose->fraglen    = 0;
 535#endif
 536
 537        sock->ops    = &rose_proto_ops;
 538        sk->sk_protocol = protocol;
 539
 540        init_timer(&rose->timer);
 541        init_timer(&rose->idletimer);
 542
 543        rose->t1   = msecs_to_jiffies(sysctl_rose_call_request_timeout);
 544        rose->t2   = msecs_to_jiffies(sysctl_rose_reset_request_timeout);
 545        rose->t3   = msecs_to_jiffies(sysctl_rose_clear_request_timeout);
 546        rose->hb   = msecs_to_jiffies(sysctl_rose_ack_hold_back_timeout);
 547        rose->idle = msecs_to_jiffies(sysctl_rose_no_activity_timeout);
 548
 549        rose->state = ROSE_STATE_0;
 550
 551        return 0;
 552}
 553
 554static struct sock *rose_make_new(struct sock *osk)
 555{
 556        struct sock *sk;
 557        struct rose_sock *rose, *orose;
 558
 559        if (osk->sk_type != SOCK_SEQPACKET)
 560                return NULL;
 561
 562        sk = sk_alloc(sock_net(osk), PF_ROSE, GFP_ATOMIC, &rose_proto);
 563        if (sk == NULL)
 564                return NULL;
 565
 566        rose = rose_sk(sk);
 567
 568        sock_init_data(NULL, sk);
 569
 570        skb_queue_head_init(&rose->ack_queue);
 571#ifdef M_BIT
 572        skb_queue_head_init(&rose->frag_queue);
 573        rose->fraglen  = 0;
 574#endif
 575
 576        sk->sk_type     = osk->sk_type;
 577        sk->sk_priority = osk->sk_priority;
 578        sk->sk_protocol = osk->sk_protocol;
 579        sk->sk_rcvbuf   = osk->sk_rcvbuf;
 580        sk->sk_sndbuf   = osk->sk_sndbuf;
 581        sk->sk_state    = TCP_ESTABLISHED;
 582        sock_copy_flags(sk, osk);
 583
 584        init_timer(&rose->timer);
 585        init_timer(&rose->idletimer);
 586
 587        orose           = rose_sk(osk);
 588        rose->t1        = orose->t1;
 589        rose->t2        = orose->t2;
 590        rose->t3        = orose->t3;
 591        rose->hb        = orose->hb;
 592        rose->idle      = orose->idle;
 593        rose->defer     = orose->defer;
 594        rose->device    = orose->device;
 595        rose->qbitincl  = orose->qbitincl;
 596
 597        return sk;
 598}
 599
 600static int rose_release(struct socket *sock)
 601{
 602        struct sock *sk = sock->sk;
 603        struct rose_sock *rose;
 604
 605        if (sk == NULL) return 0;
 606
 607        sock_hold(sk);
 608        sock_orphan(sk);
 609        lock_sock(sk);
 610        rose = rose_sk(sk);
 611
 612        switch (rose->state) {
 613        case ROSE_STATE_0:
 614                release_sock(sk);
 615                rose_disconnect(sk, 0, -1, -1);
 616                lock_sock(sk);
 617                rose_destroy_socket(sk);
 618                break;
 619
 620        case ROSE_STATE_2:
 621                rose->neighbour->use--;
 622                release_sock(sk);
 623                rose_disconnect(sk, 0, -1, -1);
 624                lock_sock(sk);
 625                rose_destroy_socket(sk);
 626                break;
 627
 628        case ROSE_STATE_1:
 629        case ROSE_STATE_3:
 630        case ROSE_STATE_4:
 631        case ROSE_STATE_5:
 632                rose_clear_queues(sk);
 633                rose_stop_idletimer(sk);
 634                rose_write_internal(sk, ROSE_CLEAR_REQUEST);
 635                rose_start_t3timer(sk);
 636                rose->state  = ROSE_STATE_2;
 637                sk->sk_state    = TCP_CLOSE;
 638                sk->sk_shutdown |= SEND_SHUTDOWN;
 639                sk->sk_state_change(sk);
 640                sock_set_flag(sk, SOCK_DEAD);
 641                sock_set_flag(sk, SOCK_DESTROY);
 642                break;
 643
 644        default:
 645                break;
 646        }
 647
 648        sock->sk = NULL;
 649        release_sock(sk);
 650        sock_put(sk);
 651
 652        return 0;
 653}
 654
 655static int rose_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 656{
 657        struct sock *sk = sock->sk;
 658        struct rose_sock *rose = rose_sk(sk);
 659        struct sockaddr_rose *addr = (struct sockaddr_rose *)uaddr;
 660        struct net_device *dev;
 661        ax25_address *source;
 662        ax25_uid_assoc *user;
 663        int n;
 664
 665        if (!sock_flag(sk, SOCK_ZAPPED))
 666                return -EINVAL;
 667
 668        if (addr_len != sizeof(struct sockaddr_rose) && addr_len != sizeof(struct full_sockaddr_rose))
 669                return -EINVAL;
 670
 671        if (addr->srose_family != AF_ROSE)
 672                return -EINVAL;
 673
 674        if (addr_len == sizeof(struct sockaddr_rose) && addr->srose_ndigis > 1)
 675                return -EINVAL;
 676
 677        if ((unsigned int) addr->srose_ndigis > ROSE_MAX_DIGIS)
 678                return -EINVAL;
 679
 680        if ((dev = rose_dev_get(&addr->srose_addr)) == NULL)
 681                return -EADDRNOTAVAIL;
 682
 683        source = &addr->srose_call;
 684
 685        user = ax25_findbyuid(current_euid());
 686        if (user) {
 687                rose->source_call = user->call;
 688                ax25_uid_put(user);
 689        } else {
 690                if (ax25_uid_policy && !capable(CAP_NET_BIND_SERVICE))
 691                        return -EACCES;
 692                rose->source_call   = *source;
 693        }
 694
 695        rose->source_addr   = addr->srose_addr;
 696        rose->device        = dev;
 697        rose->source_ndigis = addr->srose_ndigis;
 698
 699        if (addr_len == sizeof(struct full_sockaddr_rose)) {
 700                struct full_sockaddr_rose *full_addr = (struct full_sockaddr_rose *)uaddr;
 701                for (n = 0 ; n < addr->srose_ndigis ; n++)
 702                        rose->source_digis[n] = full_addr->srose_digis[n];
 703        } else {
 704                if (rose->source_ndigis == 1) {
 705                        rose->source_digis[0] = addr->srose_digi;
 706                }
 707        }
 708
 709        rose_insert_socket(sk);
 710
 711        sock_reset_flag(sk, SOCK_ZAPPED);
 712
 713        return 0;
 714}
 715
 716static int rose_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len, int flags)
 717{
 718        struct sock *sk = sock->sk;
 719        struct rose_sock *rose = rose_sk(sk);
 720        struct sockaddr_rose *addr = (struct sockaddr_rose *)uaddr;
 721        unsigned char cause, diagnostic;
 722        struct net_device *dev;
 723        ax25_uid_assoc *user;
 724        int n, err = 0;
 725
 726        if (addr_len != sizeof(struct sockaddr_rose) && addr_len != sizeof(struct full_sockaddr_rose))
 727                return -EINVAL;
 728
 729        if (addr->srose_family != AF_ROSE)
 730                return -EINVAL;
 731
 732        if (addr_len == sizeof(struct sockaddr_rose) && addr->srose_ndigis > 1)
 733                return -EINVAL;
 734
 735        if ((unsigned int) addr->srose_ndigis > ROSE_MAX_DIGIS)
 736                return -EINVAL;
 737
 738        /* Source + Destination digis should not exceed ROSE_MAX_DIGIS */
 739        if ((rose->source_ndigis + addr->srose_ndigis) > ROSE_MAX_DIGIS)
 740                return -EINVAL;
 741
 742        lock_sock(sk);
 743
 744        if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
 745                /* Connect completed during a ERESTARTSYS event */
 746                sock->state = SS_CONNECTED;
 747                goto out_release;
 748        }
 749
 750        if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) {
 751                sock->state = SS_UNCONNECTED;
 752                err = -ECONNREFUSED;
 753                goto out_release;
 754        }
 755
 756        if (sk->sk_state == TCP_ESTABLISHED) {
 757                /* No reconnect on a seqpacket socket */
 758                err = -EISCONN;
 759                goto out_release;
 760        }
 761
 762        sk->sk_state   = TCP_CLOSE;
 763        sock->state = SS_UNCONNECTED;
 764
 765        rose->neighbour = rose_get_neigh(&addr->srose_addr, &cause,
 766                                         &diagnostic, 0);
 767        if (!rose->neighbour) {
 768                err = -ENETUNREACH;
 769                goto out_release;
 770        }
 771
 772        rose->lci = rose_new_lci(rose->neighbour);
 773        if (!rose->lci) {
 774                err = -ENETUNREACH;
 775                goto out_release;
 776        }
 777
 778        if (sock_flag(sk, SOCK_ZAPPED)) {       /* Must bind first - autobinding in this may or may not work */
 779                sock_reset_flag(sk, SOCK_ZAPPED);
 780
 781                if ((dev = rose_dev_first()) == NULL) {
 782                        err = -ENETUNREACH;
 783                        goto out_release;
 784                }
 785
 786                user = ax25_findbyuid(current_euid());
 787                if (!user) {
 788                        err = -EINVAL;
 789                        goto out_release;
 790                }
 791
 792                memcpy(&rose->source_addr, dev->dev_addr, ROSE_ADDR_LEN);
 793                rose->source_call = user->call;
 794                rose->device      = dev;
 795                ax25_uid_put(user);
 796
 797                rose_insert_socket(sk);         /* Finish the bind */
 798        }
 799        rose->dest_addr   = addr->srose_addr;
 800        rose->dest_call   = addr->srose_call;
 801        rose->rand        = ((long)rose & 0xFFFF) + rose->lci;
 802        rose->dest_ndigis = addr->srose_ndigis;
 803
 804        if (addr_len == sizeof(struct full_sockaddr_rose)) {
 805                struct full_sockaddr_rose *full_addr = (struct full_sockaddr_rose *)uaddr;
 806                for (n = 0 ; n < addr->srose_ndigis ; n++)
 807                        rose->dest_digis[n] = full_addr->srose_digis[n];
 808        } else {
 809                if (rose->dest_ndigis == 1) {
 810                        rose->dest_digis[0] = addr->srose_digi;
 811                }
 812        }
 813
 814        /* Move to connecting socket, start sending Connect Requests */
 815        sock->state   = SS_CONNECTING;
 816        sk->sk_state     = TCP_SYN_SENT;
 817
 818        rose->state = ROSE_STATE_1;
 819
 820        rose->neighbour->use++;
 821
 822        rose_write_internal(sk, ROSE_CALL_REQUEST);
 823        rose_start_heartbeat(sk);
 824        rose_start_t1timer(sk);
 825
 826        /* Now the loop */
 827        if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
 828                err = -EINPROGRESS;
 829                goto out_release;
 830        }
 831
 832        /*
 833         * A Connect Ack with Choke or timeout or failed routing will go to
 834         * closed.
 835         */
 836        if (sk->sk_state == TCP_SYN_SENT) {
 837                DEFINE_WAIT(wait);
 838
 839                for (;;) {
 840                        prepare_to_wait(sk_sleep(sk), &wait,
 841                                        TASK_INTERRUPTIBLE);
 842                        if (sk->sk_state != TCP_SYN_SENT)
 843                                break;
 844                        if (!signal_pending(current)) {
 845                                release_sock(sk);
 846                                schedule();
 847                                lock_sock(sk);
 848                                continue;
 849                        }
 850                        err = -ERESTARTSYS;
 851                        break;
 852                }
 853                finish_wait(sk_sleep(sk), &wait);
 854
 855                if (err)
 856                        goto out_release;
 857        }
 858
 859        if (sk->sk_state != TCP_ESTABLISHED) {
 860                sock->state = SS_UNCONNECTED;
 861                err = sock_error(sk);   /* Always set at this point */
 862                goto out_release;
 863        }
 864
 865        sock->state = SS_CONNECTED;
 866
 867out_release:
 868        release_sock(sk);
 869
 870        return err;
 871}
 872
 873static int rose_accept(struct socket *sock, struct socket *newsock, int flags)
 874{
 875        struct sk_buff *skb;
 876        struct sock *newsk;
 877        DEFINE_WAIT(wait);
 878        struct sock *sk;
 879        int err = 0;
 880
 881        if ((sk = sock->sk) == NULL)
 882                return -EINVAL;
 883
 884        lock_sock(sk);
 885        if (sk->sk_type != SOCK_SEQPACKET) {
 886                err = -EOPNOTSUPP;
 887                goto out_release;
 888        }
 889
 890        if (sk->sk_state != TCP_LISTEN) {
 891                err = -EINVAL;
 892                goto out_release;
 893        }
 894
 895        /*
 896         *      The write queue this time is holding sockets ready to use
 897         *      hooked into the SABM we saved
 898         */
 899        for (;;) {
 900                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
 901
 902                skb = skb_dequeue(&sk->sk_receive_queue);
 903                if (skb)
 904                        break;
 905
 906                if (flags & O_NONBLOCK) {
 907                        err = -EWOULDBLOCK;
 908                        break;
 909                }
 910                if (!signal_pending(current)) {
 911                        release_sock(sk);
 912                        schedule();
 913                        lock_sock(sk);
 914                        continue;
 915                }
 916                err = -ERESTARTSYS;
 917                break;
 918        }
 919        finish_wait(sk_sleep(sk), &wait);
 920        if (err)
 921                goto out_release;
 922
 923        newsk = skb->sk;
 924        sock_graft(newsk, newsock);
 925
 926        /* Now attach up the new socket */
 927        skb->sk = NULL;
 928        kfree_skb(skb);
 929        sk->sk_ack_backlog--;
 930
 931out_release:
 932        release_sock(sk);
 933
 934        return err;
 935}
 936
 937static int rose_getname(struct socket *sock, struct sockaddr *uaddr,
 938        int *uaddr_len, int peer)
 939{
 940        struct full_sockaddr_rose *srose = (struct full_sockaddr_rose *)uaddr;
 941        struct sock *sk = sock->sk;
 942        struct rose_sock *rose = rose_sk(sk);
 943        int n;
 944
 945        memset(srose, 0, sizeof(*srose));
 946        if (peer != 0) {
 947                if (sk->sk_state != TCP_ESTABLISHED)
 948                        return -ENOTCONN;
 949                srose->srose_family = AF_ROSE;
 950                srose->srose_addr   = rose->dest_addr;
 951                srose->srose_call   = rose->dest_call;
 952                srose->srose_ndigis = rose->dest_ndigis;
 953                for (n = 0; n < rose->dest_ndigis; n++)
 954                        srose->srose_digis[n] = rose->dest_digis[n];
 955        } else {
 956                srose->srose_family = AF_ROSE;
 957                srose->srose_addr   = rose->source_addr;
 958                srose->srose_call   = rose->source_call;
 959                srose->srose_ndigis = rose->source_ndigis;
 960                for (n = 0; n < rose->source_ndigis; n++)
 961                        srose->srose_digis[n] = rose->source_digis[n];
 962        }
 963
 964        *uaddr_len = sizeof(struct full_sockaddr_rose);
 965        return 0;
 966}
 967
 968int rose_rx_call_request(struct sk_buff *skb, struct net_device *dev, struct rose_neigh *neigh, unsigned int lci)
 969{
 970        struct sock *sk;
 971        struct sock *make;
 972        struct rose_sock *make_rose;
 973        struct rose_facilities_struct facilities;
 974        int n;
 975
 976        skb->sk = NULL;         /* Initially we don't know who it's for */
 977
 978        /*
 979         *      skb->data points to the rose frame start
 980         */
 981        memset(&facilities, 0x00, sizeof(struct rose_facilities_struct));
 982
 983        if (!rose_parse_facilities(skb->data + ROSE_CALL_REQ_FACILITIES_OFF,
 984                                   skb->len - ROSE_CALL_REQ_FACILITIES_OFF,
 985                                   &facilities)) {
 986                rose_transmit_clear_request(neigh, lci, ROSE_INVALID_FACILITY, 76);
 987                return 0;
 988        }
 989
 990        sk = rose_find_listener(&facilities.source_addr, &facilities.source_call);
 991
 992        /*
 993         * We can't accept the Call Request.
 994         */
 995        if (sk == NULL || sk_acceptq_is_full(sk) ||
 996            (make = rose_make_new(sk)) == NULL) {
 997                rose_transmit_clear_request(neigh, lci, ROSE_NETWORK_CONGESTION, 120);
 998                return 0;
 999        }
1000
1001        skb->sk     = make;
1002        make->sk_state = TCP_ESTABLISHED;
1003        make_rose = rose_sk(make);
1004
1005        make_rose->lci           = lci;
1006        make_rose->dest_addr     = facilities.dest_addr;
1007        make_rose->dest_call     = facilities.dest_call;
1008        make_rose->dest_ndigis   = facilities.dest_ndigis;
1009        for (n = 0 ; n < facilities.dest_ndigis ; n++)
1010                make_rose->dest_digis[n] = facilities.dest_digis[n];
1011        make_rose->source_addr   = facilities.source_addr;
1012        make_rose->source_call   = facilities.source_call;
1013        make_rose->source_ndigis = facilities.source_ndigis;
1014        for (n = 0 ; n < facilities.source_ndigis ; n++)
1015                make_rose->source_digis[n]= facilities.source_digis[n];
1016        make_rose->neighbour     = neigh;
1017        make_rose->device        = dev;
1018        make_rose->facilities    = facilities;
1019
1020        make_rose->neighbour->use++;
1021
1022        if (rose_sk(sk)->defer) {
1023                make_rose->state = ROSE_STATE_5;
1024        } else {
1025                rose_write_internal(make, ROSE_CALL_ACCEPTED);
1026                make_rose->state = ROSE_STATE_3;
1027                rose_start_idletimer(make);
1028        }
1029
1030        make_rose->condition = 0x00;
1031        make_rose->vs        = 0;
1032        make_rose->va        = 0;
1033        make_rose->vr        = 0;
1034        make_rose->vl        = 0;
1035        sk->sk_ack_backlog++;
1036
1037        rose_insert_socket(make);
1038
1039        skb_queue_head(&sk->sk_receive_queue, skb);
1040
1041        rose_start_heartbeat(make);
1042
1043        if (!sock_flag(sk, SOCK_DEAD))
1044                sk->sk_data_ready(sk, skb->len);
1045
1046        return 1;
1047}
1048
1049static int rose_sendmsg(struct kiocb *iocb, struct socket *sock,
1050                        struct msghdr *msg, size_t len)
1051{
1052        struct sock *sk = sock->sk;
1053        struct rose_sock *rose = rose_sk(sk);
1054        struct sockaddr_rose *usrose = (struct sockaddr_rose *)msg->msg_name;
1055        int err;
1056        struct full_sockaddr_rose srose;
1057        struct sk_buff *skb;
1058        unsigned char *asmptr;
1059        int n, size, qbit = 0;
1060
1061        if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1062                return -EINVAL;
1063
1064        if (sock_flag(sk, SOCK_ZAPPED))
1065                return -EADDRNOTAVAIL;
1066
1067        if (sk->sk_shutdown & SEND_SHUTDOWN) {
1068                send_sig(SIGPIPE, current, 0);
1069                return -EPIPE;
1070        }
1071
1072        if (rose->neighbour == NULL || rose->device == NULL)
1073                return -ENETUNREACH;
1074
1075        if (usrose != NULL) {
1076                if (msg->msg_namelen != sizeof(struct sockaddr_rose) && msg->msg_namelen != sizeof(struct full_sockaddr_rose))
1077                        return -EINVAL;
1078                memset(&srose, 0, sizeof(struct full_sockaddr_rose));
1079                memcpy(&srose, usrose, msg->msg_namelen);
1080                if (rosecmp(&rose->dest_addr, &srose.srose_addr) != 0 ||
1081                    ax25cmp(&rose->dest_call, &srose.srose_call) != 0)
1082                        return -EISCONN;
1083                if (srose.srose_ndigis != rose->dest_ndigis)
1084                        return -EISCONN;
1085                if (srose.srose_ndigis == rose->dest_ndigis) {
1086                        for (n = 0 ; n < srose.srose_ndigis ; n++)
1087                                if (ax25cmp(&rose->dest_digis[n],
1088                                            &srose.srose_digis[n]))
1089                                        return -EISCONN;
1090                }
1091                if (srose.srose_family != AF_ROSE)
1092                        return -EINVAL;
1093        } else {
1094                if (sk->sk_state != TCP_ESTABLISHED)
1095                        return -ENOTCONN;
1096
1097                srose.srose_family = AF_ROSE;
1098                srose.srose_addr   = rose->dest_addr;
1099                srose.srose_call   = rose->dest_call;
1100                srose.srose_ndigis = rose->dest_ndigis;
1101                for (n = 0 ; n < rose->dest_ndigis ; n++)
1102                        srose.srose_digis[n] = rose->dest_digis[n];
1103        }
1104
1105        /* Build a packet */
1106        /* Sanity check the packet size */
1107        if (len > 65535)
1108                return -EMSGSIZE;
1109
1110        size = len + AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + ROSE_MIN_LEN;
1111
1112        if ((skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT, &err)) == NULL)
1113                return err;
1114
1115        skb_reserve(skb, AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + ROSE_MIN_LEN);
1116
1117        /*
1118         *      Put the data on the end
1119         */
1120
1121        skb_reset_transport_header(skb);
1122        skb_put(skb, len);
1123
1124        err = memcpy_fromiovec(skb_transport_header(skb), msg->msg_iov, len);
1125        if (err) {
1126                kfree_skb(skb);
1127                return err;
1128        }
1129
1130        /*
1131         *      If the Q BIT Include socket option is in force, the first
1132         *      byte of the user data is the logical value of the Q Bit.
1133         */
1134        if (rose->qbitincl) {
1135                qbit = skb->data[0];
1136                skb_pull(skb, 1);
1137        }
1138
1139        /*
1140         *      Push down the ROSE header
1141         */
1142        asmptr = skb_push(skb, ROSE_MIN_LEN);
1143
1144        /* Build a ROSE Network header */
1145        asmptr[0] = ((rose->lci >> 8) & 0x0F) | ROSE_GFI;
1146        asmptr[1] = (rose->lci >> 0) & 0xFF;
1147        asmptr[2] = ROSE_DATA;
1148
1149        if (qbit)
1150                asmptr[0] |= ROSE_Q_BIT;
1151
1152        if (sk->sk_state != TCP_ESTABLISHED) {
1153                kfree_skb(skb);
1154                return -ENOTCONN;
1155        }
1156
1157#ifdef M_BIT
1158#define ROSE_PACLEN (256-ROSE_MIN_LEN)
1159        if (skb->len - ROSE_MIN_LEN > ROSE_PACLEN) {
1160                unsigned char header[ROSE_MIN_LEN];
1161                struct sk_buff *skbn;
1162                int frontlen;
1163                int lg;
1164
1165                /* Save a copy of the Header */
1166                skb_copy_from_linear_data(skb, header, ROSE_MIN_LEN);
1167                skb_pull(skb, ROSE_MIN_LEN);
1168
1169                frontlen = skb_headroom(skb);
1170
1171                while (skb->len > 0) {
1172                        if ((skbn = sock_alloc_send_skb(sk, frontlen + ROSE_PACLEN, 0, &err)) == NULL) {
1173                                kfree_skb(skb);
1174                                return err;
1175                        }
1176
1177                        skbn->sk   = sk;
1178                        skbn->free = 1;
1179                        skbn->arp  = 1;
1180
1181                        skb_reserve(skbn, frontlen);
1182
1183                        lg = (ROSE_PACLEN > skb->len) ? skb->len : ROSE_PACLEN;
1184
1185                        /* Copy the user data */
1186                        skb_copy_from_linear_data(skb, skb_put(skbn, lg), lg);
1187                        skb_pull(skb, lg);
1188
1189                        /* Duplicate the Header */
1190                        skb_push(skbn, ROSE_MIN_LEN);
1191                        skb_copy_to_linear_data(skbn, header, ROSE_MIN_LEN);
1192
1193                        if (skb->len > 0)
1194                                skbn->data[2] |= M_BIT;
1195
1196                        skb_queue_tail(&sk->sk_write_queue, skbn); /* Throw it on the queue */
1197                }
1198
1199                skb->free = 1;
1200                kfree_skb(skb);
1201        } else {
1202                skb_queue_tail(&sk->sk_write_queue, skb);               /* Throw it on the queue */
1203        }
1204#else
1205        skb_queue_tail(&sk->sk_write_queue, skb);       /* Shove it onto the queue */
1206#endif
1207
1208        rose_kick(sk);
1209
1210        return len;
1211}
1212
1213
1214static int rose_recvmsg(struct kiocb *iocb, struct socket *sock,
1215                        struct msghdr *msg, size_t size, int flags)
1216{
1217        struct sock *sk = sock->sk;
1218        struct rose_sock *rose = rose_sk(sk);
1219        struct sockaddr_rose *srose = (struct sockaddr_rose *)msg->msg_name;
1220        size_t copied;
1221        unsigned char *asmptr;
1222        struct sk_buff *skb;
1223        int n, er, qbit;
1224
1225        /*
1226         * This works for seqpacket too. The receiver has ordered the queue for
1227         * us! We do one quick check first though
1228         */
1229        if (sk->sk_state != TCP_ESTABLISHED)
1230                return -ENOTCONN;
1231
1232        /* Now we can treat all alike */
1233        if ((skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, flags & MSG_DONTWAIT, &er)) == NULL)
1234                return er;
1235
1236        qbit = (skb->data[0] & ROSE_Q_BIT) == ROSE_Q_BIT;
1237
1238        skb_pull(skb, ROSE_MIN_LEN);
1239
1240        if (rose->qbitincl) {
1241                asmptr  = skb_push(skb, 1);
1242                *asmptr = qbit;
1243        }
1244
1245        skb_reset_transport_header(skb);
1246        copied     = skb->len;
1247
1248        if (copied > size) {
1249                copied = size;
1250                msg->msg_flags |= MSG_TRUNC;
1251        }
1252
1253        skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1254
1255        if (srose != NULL) {
1256                memset(srose, 0, msg->msg_namelen);
1257                srose->srose_family = AF_ROSE;
1258                srose->srose_addr   = rose->dest_addr;
1259                srose->srose_call   = rose->dest_call;
1260                srose->srose_ndigis = rose->dest_ndigis;
1261                if (msg->msg_namelen >= sizeof(struct full_sockaddr_rose)) {
1262                        struct full_sockaddr_rose *full_srose = (struct full_sockaddr_rose *)msg->msg_name;
1263                        for (n = 0 ; n < rose->dest_ndigis ; n++)
1264                                full_srose->srose_digis[n] = rose->dest_digis[n];
1265                        msg->msg_namelen = sizeof(struct full_sockaddr_rose);
1266                } else {
1267                        if (rose->dest_ndigis >= 1) {
1268                                srose->srose_ndigis = 1;
1269                                srose->srose_digi = rose->dest_digis[0];
1270                        }
1271                        msg->msg_namelen = sizeof(struct sockaddr_rose);
1272                }
1273        }
1274
1275        skb_free_datagram(sk, skb);
1276
1277        return copied;
1278}
1279
1280
1281static int rose_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1282{
1283        struct sock *sk = sock->sk;
1284        struct rose_sock *rose = rose_sk(sk);
1285        void __user *argp = (void __user *)arg;
1286
1287        switch (cmd) {
1288        case TIOCOUTQ: {
1289                long amount;
1290
1291                amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1292                if (amount < 0)
1293                        amount = 0;
1294                return put_user(amount, (unsigned int __user *) argp);
1295        }
1296
1297        case TIOCINQ: {
1298                struct sk_buff *skb;
1299                long amount = 0L;
1300                /* These two are safe on a single CPU system as only user tasks fiddle here */
1301                if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1302                        amount = skb->len;
1303                return put_user(amount, (unsigned int __user *) argp);
1304        }
1305
1306        case SIOCGSTAMP:
1307                return sock_get_timestamp(sk, (struct timeval __user *) argp);
1308
1309        case SIOCGSTAMPNS:
1310                return sock_get_timestampns(sk, (struct timespec __user *) argp);
1311
1312        case SIOCGIFADDR:
1313        case SIOCSIFADDR:
1314        case SIOCGIFDSTADDR:
1315        case SIOCSIFDSTADDR:
1316        case SIOCGIFBRDADDR:
1317        case SIOCSIFBRDADDR:
1318        case SIOCGIFNETMASK:
1319        case SIOCSIFNETMASK:
1320        case SIOCGIFMETRIC:
1321        case SIOCSIFMETRIC:
1322                return -EINVAL;
1323
1324        case SIOCADDRT:
1325        case SIOCDELRT:
1326        case SIOCRSCLRRT:
1327                if (!capable(CAP_NET_ADMIN))
1328                        return -EPERM;
1329                return rose_rt_ioctl(cmd, argp);
1330
1331        case SIOCRSGCAUSE: {
1332                struct rose_cause_struct rose_cause;
1333                rose_cause.cause      = rose->cause;
1334                rose_cause.diagnostic = rose->diagnostic;
1335                return copy_to_user(argp, &rose_cause, sizeof(struct rose_cause_struct)) ? -EFAULT : 0;
1336        }
1337
1338        case SIOCRSSCAUSE: {
1339                struct rose_cause_struct rose_cause;
1340                if (copy_from_user(&rose_cause, argp, sizeof(struct rose_cause_struct)))
1341                        return -EFAULT;
1342                rose->cause      = rose_cause.cause;
1343                rose->diagnostic = rose_cause.diagnostic;
1344                return 0;
1345        }
1346
1347        case SIOCRSSL2CALL:
1348                if (!capable(CAP_NET_ADMIN)) return -EPERM;
1349                if (ax25cmp(&rose_callsign, &null_ax25_address) != 0)
1350                        ax25_listen_release(&rose_callsign, NULL);
1351                if (copy_from_user(&rose_callsign, argp, sizeof(ax25_address)))
1352                        return -EFAULT;
1353                if (ax25cmp(&rose_callsign, &null_ax25_address) != 0)
1354                        return ax25_listen_register(&rose_callsign, NULL);
1355
1356                return 0;
1357
1358        case SIOCRSGL2CALL:
1359                return copy_to_user(argp, &rose_callsign, sizeof(ax25_address)) ? -EFAULT : 0;
1360
1361        case SIOCRSACCEPT:
1362                if (rose->state == ROSE_STATE_5) {
1363                        rose_write_internal(sk, ROSE_CALL_ACCEPTED);
1364                        rose_start_idletimer(sk);
1365                        rose->condition = 0x00;
1366                        rose->vs        = 0;
1367                        rose->va        = 0;
1368                        rose->vr        = 0;
1369                        rose->vl        = 0;
1370                        rose->state     = ROSE_STATE_3;
1371                }
1372                return 0;
1373
1374        default:
1375                return -ENOIOCTLCMD;
1376        }
1377
1378        return 0;
1379}
1380
1381#ifdef CONFIG_PROC_FS
1382static void *rose_info_start(struct seq_file *seq, loff_t *pos)
1383        __acquires(rose_list_lock)
1384{
1385        spin_lock_bh(&rose_list_lock);
1386        return seq_hlist_start_head(&rose_list, *pos);
1387}
1388
1389static void *rose_info_next(struct seq_file *seq, void *v, loff_t *pos)
1390{
1391        return seq_hlist_next(v, &rose_list, pos);
1392}
1393
1394static void rose_info_stop(struct seq_file *seq, void *v)
1395        __releases(rose_list_lock)
1396{
1397        spin_unlock_bh(&rose_list_lock);
1398}
1399
1400static int rose_info_show(struct seq_file *seq, void *v)
1401{
1402        char buf[11], rsbuf[11];
1403
1404        if (v == SEQ_START_TOKEN)
1405                seq_puts(seq,
1406                         "dest_addr  dest_call src_addr   src_call  dev   lci neigh st vs vr va   t  t1  t2  t3  hb    idle Snd-Q Rcv-Q inode\n");
1407
1408        else {
1409                struct sock *s = sk_entry(v);
1410                struct rose_sock *rose = rose_sk(s);
1411                const char *devname, *callsign;
1412                const struct net_device *dev = rose->device;
1413
1414                if (!dev)
1415                        devname = "???";
1416                else
1417                        devname = dev->name;
1418
1419                seq_printf(seq, "%-10s %-9s ",
1420                           rose2asc(rsbuf, &rose->dest_addr),
1421                           ax2asc(buf, &rose->dest_call));
1422
1423                if (ax25cmp(&rose->source_call, &null_ax25_address) == 0)
1424                        callsign = "??????-?";
1425                else
1426                        callsign = ax2asc(buf, &rose->source_call);
1427
1428                seq_printf(seq,
1429                           "%-10s %-9s %-5s %3.3X %05d  %d  %d  %d  %d %3lu %3lu %3lu %3lu %3lu %3lu/%03lu %5d %5d %ld\n",
1430                        rose2asc(rsbuf, &rose->source_addr),
1431                        callsign,
1432                        devname,
1433                        rose->lci & 0x0FFF,
1434                        (rose->neighbour) ? rose->neighbour->number : 0,
1435                        rose->state,
1436                        rose->vs,
1437                        rose->vr,
1438                        rose->va,
1439                        ax25_display_timer(&rose->timer) / HZ,
1440                        rose->t1 / HZ,
1441                        rose->t2 / HZ,
1442                        rose->t3 / HZ,
1443                        rose->hb / HZ,
1444                        ax25_display_timer(&rose->idletimer) / (60 * HZ),
1445                        rose->idle / (60 * HZ),
1446                        sk_wmem_alloc_get(s),
1447                        sk_rmem_alloc_get(s),
1448                        s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
1449        }
1450
1451        return 0;
1452}
1453
1454static const struct seq_operations rose_info_seqops = {
1455        .start = rose_info_start,
1456        .next = rose_info_next,
1457        .stop = rose_info_stop,
1458        .show = rose_info_show,
1459};
1460
1461static int rose_info_open(struct inode *inode, struct file *file)
1462{
1463        return seq_open(file, &rose_info_seqops);
1464}
1465
1466static const struct file_operations rose_info_fops = {
1467        .owner = THIS_MODULE,
1468        .open = rose_info_open,
1469        .read = seq_read,
1470        .llseek = seq_lseek,
1471        .release = seq_release,
1472};
1473#endif  /* CONFIG_PROC_FS */
1474
1475static const struct net_proto_family rose_family_ops = {
1476        .family         =       PF_ROSE,
1477        .create         =       rose_create,
1478        .owner          =       THIS_MODULE,
1479};
1480
1481static const struct proto_ops rose_proto_ops = {
1482        .family         =       PF_ROSE,
1483        .owner          =       THIS_MODULE,
1484        .release        =       rose_release,
1485        .bind           =       rose_bind,
1486        .connect        =       rose_connect,
1487        .socketpair     =       sock_no_socketpair,
1488        .accept         =       rose_accept,
1489        .getname        =       rose_getname,
1490        .poll           =       datagram_poll,
1491        .ioctl          =       rose_ioctl,
1492        .listen         =       rose_listen,
1493        .shutdown       =       sock_no_shutdown,
1494        .setsockopt     =       rose_setsockopt,
1495        .getsockopt     =       rose_getsockopt,
1496        .sendmsg        =       rose_sendmsg,
1497        .recvmsg        =       rose_recvmsg,
1498        .mmap           =       sock_no_mmap,
1499        .sendpage       =       sock_no_sendpage,
1500};
1501
1502static struct notifier_block rose_dev_notifier = {
1503        .notifier_call  =       rose_device_event,
1504};
1505
1506static struct net_device **dev_rose;
1507
1508static struct ax25_protocol rose_pid = {
1509        .pid    = AX25_P_ROSE,
1510        .func   = rose_route_frame
1511};
1512
1513static struct ax25_linkfail rose_linkfail_notifier = {
1514        .func   = rose_link_failed
1515};
1516
1517static int __init rose_proto_init(void)
1518{
1519        int i;
1520        int rc;
1521
1522        if (rose_ndevs > 0x7FFFFFFF/sizeof(struct net_device *)) {
1523                printk(KERN_ERR "ROSE: rose_proto_init - rose_ndevs parameter to large\n");
1524                rc = -EINVAL;
1525                goto out;
1526        }
1527
1528        rc = proto_register(&rose_proto, 0);
1529        if (rc != 0)
1530                goto out;
1531
1532        rose_callsign = null_ax25_address;
1533
1534        dev_rose = kzalloc(rose_ndevs * sizeof(struct net_device *), GFP_KERNEL);
1535        if (dev_rose == NULL) {
1536                printk(KERN_ERR "ROSE: rose_proto_init - unable to allocate device structure\n");
1537                rc = -ENOMEM;
1538                goto out_proto_unregister;
1539        }
1540
1541        for (i = 0; i < rose_ndevs; i++) {
1542                struct net_device *dev;
1543                char name[IFNAMSIZ];
1544
1545                sprintf(name, "rose%d", i);
1546                dev = alloc_netdev(0, name, rose_setup);
1547                if (!dev) {
1548                        printk(KERN_ERR "ROSE: rose_proto_init - unable to allocate memory\n");
1549                        rc = -ENOMEM;
1550                        goto fail;
1551                }
1552                rc = register_netdev(dev);
1553                if (rc) {
1554                        printk(KERN_ERR "ROSE: netdevice registration failed\n");
1555                        free_netdev(dev);
1556                        goto fail;
1557                }
1558                rose_set_lockdep_key(dev);
1559                dev_rose[i] = dev;
1560        }
1561
1562        sock_register(&rose_family_ops);
1563        register_netdevice_notifier(&rose_dev_notifier);
1564
1565        ax25_register_pid(&rose_pid);
1566        ax25_linkfail_register(&rose_linkfail_notifier);
1567
1568#ifdef CONFIG_SYSCTL
1569        rose_register_sysctl();
1570#endif
1571        rose_loopback_init();
1572
1573        rose_add_loopback_neigh();
1574
1575        proc_create("rose", S_IRUGO, init_net.proc_net, &rose_info_fops);
1576        proc_create("rose_neigh", S_IRUGO, init_net.proc_net,
1577                    &rose_neigh_fops);
1578        proc_create("rose_nodes", S_IRUGO, init_net.proc_net,
1579                    &rose_nodes_fops);
1580        proc_create("rose_routes", S_IRUGO, init_net.proc_net,
1581                    &rose_routes_fops);
1582out:
1583        return rc;
1584fail:
1585        while (--i >= 0) {
1586                unregister_netdev(dev_rose[i]);
1587                free_netdev(dev_rose[i]);
1588        }
1589        kfree(dev_rose);
1590out_proto_unregister:
1591        proto_unregister(&rose_proto);
1592        goto out;
1593}
1594module_init(rose_proto_init);
1595
1596module_param(rose_ndevs, int, 0);
1597MODULE_PARM_DESC(rose_ndevs, "number of ROSE devices");
1598
1599MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
1600MODULE_DESCRIPTION("The amateur radio ROSE network layer protocol");
1601MODULE_LICENSE("GPL");
1602MODULE_ALIAS_NETPROTO(PF_ROSE);
1603
1604static void __exit rose_exit(void)
1605{
1606        int i;
1607
1608        remove_proc_entry("rose", init_net.proc_net);
1609        remove_proc_entry("rose_neigh", init_net.proc_net);
1610        remove_proc_entry("rose_nodes", init_net.proc_net);
1611        remove_proc_entry("rose_routes", init_net.proc_net);
1612        rose_loopback_clear();
1613
1614        rose_rt_free();
1615
1616        ax25_protocol_release(AX25_P_ROSE);
1617        ax25_linkfail_release(&rose_linkfail_notifier);
1618
1619        if (ax25cmp(&rose_callsign, &null_ax25_address) != 0)
1620                ax25_listen_release(&rose_callsign, NULL);
1621
1622#ifdef CONFIG_SYSCTL
1623        rose_unregister_sysctl();
1624#endif
1625        unregister_netdevice_notifier(&rose_dev_notifier);
1626
1627        sock_unregister(PF_ROSE);
1628
1629        for (i = 0; i < rose_ndevs; i++) {
1630                struct net_device *dev = dev_rose[i];
1631
1632                if (dev) {
1633                        unregister_netdev(dev);
1634                        free_netdev(dev);
1635                }
1636        }
1637
1638        kfree(dev_rose);
1639        proto_unregister(&rose_proto);
1640}
1641
1642module_exit(rose_exit);
1643
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.