net/rose/af_rose.c

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