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