1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *
   4 * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
   5 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
   6 * Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk)
   7 * Copyright (C) Steven Whitehouse GW7RRM (stevew@acm.org)
   8 * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
   9 * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
  10 * Copyright (C) Hans Alblas PE1AYX (hans@esrac.ele.tue.nl)
  11 * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
  12 */
  13#include <linux/capability.h>
  14#include <linux/module.h>
  15#include <linux/errno.h>
  16#include <linux/types.h>
  17#include <linux/socket.h>
  18#include <linux/in.h>
  19#include <linux/kernel.h>
  20#include <linux/sched/signal.h>
  21#include <linux/timer.h>
  22#include <linux/string.h>
  23#include <linux/sockios.h>
  24#include <linux/net.h>
  25#include <linux/slab.h>
  26#include <net/ax25.h>
  27#include <linux/inet.h>
  28#include <linux/netdevice.h>
  29#include <linux/if_arp.h>
  30#include <linux/skbuff.h>
  31#include <net/sock.h>
  32#include <linux/uaccess.h>
  33#include <linux/fcntl.h>
  34#include <linux/termios.h>	/* For TIOCINQ/OUTQ */
  35#include <linux/mm.h>
  36#include <linux/interrupt.h>
  37#include <linux/notifier.h>
  38#include <linux/proc_fs.h>
  39#include <linux/stat.h>
  40#include <linux/sysctl.h>
  41#include <linux/init.h>
  42#include <linux/spinlock.h>
  43#include <net/net_namespace.h>
  44#include <net/tcp_states.h>
  45#include <net/ip.h>
  46#include <net/arp.h>
  47
  48
  49
  50HLIST_HEAD(ax25_list);
  51DEFINE_SPINLOCK(ax25_list_lock);
  52
  53static const struct proto_ops ax25_proto_ops;
  54
  55static void ax25_free_sock(struct sock *sk)
  56{
  57	ax25_cb_put(sk_to_ax25(sk));
  58}
  59
  60/*
  61 *	Socket removal during an interrupt is now safe.
  62 */
  63static void ax25_cb_del(ax25_cb *ax25)
  64{
 
  65	if (!hlist_unhashed(&ax25->ax25_node)) {
  66		spin_lock_bh(&ax25_list_lock);
  67		hlist_del_init(&ax25->ax25_node);
  68		spin_unlock_bh(&ax25_list_lock);
  69		ax25_cb_put(ax25);
  70	}
 
  71}
  72
  73/*
  74 *	Kill all bound sockets on a dropped device.
  75 */
  76static void ax25_kill_by_device(struct net_device *dev)
  77{
  78	ax25_dev *ax25_dev;
  79	ax25_cb *s;
 
  80
  81	if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
  82		return;
 
  83
  84	spin_lock_bh(&ax25_list_lock);
  85again:
  86	ax25_for_each(s, &ax25_list) {
  87		if (s->ax25_dev == ax25_dev) {
  88			s->ax25_dev = NULL;
 
 
 
 
 
 
 
 
 
  89			spin_unlock_bh(&ax25_list_lock);
 
  90			ax25_disconnect(s, ENETUNREACH);
 
 
 
 
 
 
 
 
  91			spin_lock_bh(&ax25_list_lock);
  92
  93			/* The entry could have been deleted from the
  94			 * list meanwhile and thus the next pointer is
  95			 * no longer valid.  Play it safe and restart
  96			 * the scan.  Forward progress is ensured
  97			 * because we set s->ax25_dev to NULL and we
  98			 * are never passed a NULL 'dev' argument.
  99			 */
 100			goto again;
 101		}
 102	}
 103	spin_unlock_bh(&ax25_list_lock);
 104}
 105
 106/*
 107 *	Handle device status changes.
 108 */
 109static int ax25_device_event(struct notifier_block *this, unsigned long event,
 110			     void *ptr)
 111{
 112	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 113
 114	if (!net_eq(dev_net(dev), &init_net))
 115		return NOTIFY_DONE;
 116
 117	/* Reject non AX.25 devices */
 118	if (dev->type != ARPHRD_AX25)
 119		return NOTIFY_DONE;
 120
 121	switch (event) {
 122	case NETDEV_UP:
 123		ax25_dev_device_up(dev);
 124		break;
 125	case NETDEV_DOWN:
 126		ax25_kill_by_device(dev);
 127		ax25_rt_device_down(dev);
 128		ax25_dev_device_down(dev);
 129		break;
 130	default:
 131		break;
 132	}
 133
 134	return NOTIFY_DONE;
 135}
 136
 137/*
 138 *	Add a socket to the bound sockets list.
 139 */
 140void ax25_cb_add(ax25_cb *ax25)
 141{
 142	spin_lock_bh(&ax25_list_lock);
 143	ax25_cb_hold(ax25);
 144	hlist_add_head(&ax25->ax25_node, &ax25_list);
 145	spin_unlock_bh(&ax25_list_lock);
 146}
 147
 148/*
 149 *	Find a socket that wants to accept the SABM we have just
 150 *	received.
 151 */
 152struct sock *ax25_find_listener(ax25_address *addr, int digi,
 153	struct net_device *dev, int type)
 154{
 155	ax25_cb *s;
 156
 157	spin_lock(&ax25_list_lock);
 158	ax25_for_each(s, &ax25_list) {
 159		if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
 160			continue;
 161		if (s->sk && !ax25cmp(&s->source_addr, addr) &&
 162		    s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
 163			/* If device is null we match any device */
 164			if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
 165				sock_hold(s->sk);
 166				spin_unlock(&ax25_list_lock);
 167				return s->sk;
 168			}
 169		}
 170	}
 171	spin_unlock(&ax25_list_lock);
 172
 173	return NULL;
 174}
 175
 176/*
 177 *	Find an AX.25 socket given both ends.
 178 */
 179struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
 180	int type)
 181{
 182	struct sock *sk = NULL;
 183	ax25_cb *s;
 184
 185	spin_lock(&ax25_list_lock);
 186	ax25_for_each(s, &ax25_list) {
 187		if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
 188		    !ax25cmp(&s->dest_addr, dest_addr) &&
 189		    s->sk->sk_type == type) {
 190			sk = s->sk;
 191			sock_hold(sk);
 192			break;
 193		}
 194	}
 195
 196	spin_unlock(&ax25_list_lock);
 197
 198	return sk;
 199}
 200
 201/*
 202 *	Find an AX.25 control block given both ends. It will only pick up
 203 *	floating AX.25 control blocks or non Raw socket bound control blocks.
 204 */
 205ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
 206	ax25_digi *digi, struct net_device *dev)
 207{
 208	ax25_cb *s;
 209
 210	spin_lock_bh(&ax25_list_lock);
 211	ax25_for_each(s, &ax25_list) {
 212		if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
 213			continue;
 214		if (s->ax25_dev == NULL)
 215			continue;
 216		if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
 217			if (digi != NULL && digi->ndigi != 0) {
 218				if (s->digipeat == NULL)
 219					continue;
 220				if (ax25digicmp(s->digipeat, digi) != 0)
 221					continue;
 222			} else {
 223				if (s->digipeat != NULL && s->digipeat->ndigi != 0)
 224					continue;
 225			}
 226			ax25_cb_hold(s);
 227			spin_unlock_bh(&ax25_list_lock);
 228
 229			return s;
 230		}
 231	}
 232	spin_unlock_bh(&ax25_list_lock);
 233
 234	return NULL;
 235}
 236
 237EXPORT_SYMBOL(ax25_find_cb);
 238
 239void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
 240{
 241	ax25_cb *s;
 242	struct sk_buff *copy;
 243
 244	spin_lock(&ax25_list_lock);
 245	ax25_for_each(s, &ax25_list) {
 246		if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
 247		    s->sk->sk_type == SOCK_RAW &&
 248		    s->sk->sk_protocol == proto &&
 249		    s->ax25_dev->dev == skb->dev &&
 250		    atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
 251			if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
 252				continue;
 253			if (sock_queue_rcv_skb(s->sk, copy) != 0)
 254				kfree_skb(copy);
 255		}
 256	}
 257	spin_unlock(&ax25_list_lock);
 258}
 259
 260/*
 261 *	Deferred destroy.
 262 */
 263void ax25_destroy_socket(ax25_cb *);
 264
 265/*
 266 *	Handler for deferred kills.
 267 */
 268static void ax25_destroy_timer(struct timer_list *t)
 269{
 270	ax25_cb *ax25 = from_timer(ax25, t, dtimer);
 271	struct sock *sk;
 272
 273	sk=ax25->sk;
 274
 275	bh_lock_sock(sk);
 276	sock_hold(sk);
 277	ax25_destroy_socket(ax25);
 278	bh_unlock_sock(sk);
 279	sock_put(sk);
 280}
 281
 282/*
 283 *	This is called from user mode and the timers. Thus it protects itself
 284 *	against interrupt users but doesn't worry about being called during
 285 *	work. Once it is removed from the queue no interrupt or bottom half
 286 *	will touch it and we are (fairly 8-) ) safe.
 287 */
 288void ax25_destroy_socket(ax25_cb *ax25)
 289{
 290	struct sk_buff *skb;
 291
 292	ax25_cb_del(ax25);
 293
 294	ax25_stop_heartbeat(ax25);
 295	ax25_stop_t1timer(ax25);
 296	ax25_stop_t2timer(ax25);
 297	ax25_stop_t3timer(ax25);
 298	ax25_stop_idletimer(ax25);
 299
 300	ax25_clear_queues(ax25);	/* Flush the queues */
 301
 302	if (ax25->sk != NULL) {
 303		while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
 304			if (skb->sk != ax25->sk) {
 305				/* A pending connection */
 306				ax25_cb *sax25 = sk_to_ax25(skb->sk);
 307
 308				/* Queue the unaccepted socket for death */
 309				sock_orphan(skb->sk);
 310
 311				/* 9A4GL: hack to release unaccepted sockets */
 312				skb->sk->sk_state = TCP_LISTEN;
 313
 314				ax25_start_heartbeat(sax25);
 315				sax25->state = AX25_STATE_0;
 316			}
 317
 318			kfree_skb(skb);
 319		}
 320		skb_queue_purge(&ax25->sk->sk_write_queue);
 321	}
 322
 323	if (ax25->sk != NULL) {
 324		if (sk_has_allocations(ax25->sk)) {
 325			/* Defer: outstanding buffers */
 326			timer_setup(&ax25->dtimer, ax25_destroy_timer, 0);
 327			ax25->dtimer.expires  = jiffies + 2 * HZ;
 328			add_timer(&ax25->dtimer);
 329		} else {
 330			struct sock *sk=ax25->sk;
 331			ax25->sk=NULL;
 332			sock_put(sk);
 333		}
 334	} else {
 335		ax25_cb_put(ax25);
 336	}
 337}
 338
 339/*
 340 * dl1bke 960311: set parameters for existing AX.25 connections,
 341 *		  includes a KILL command to abort any connection.
 342 *		  VERY useful for debugging ;-)
 343 */
 344static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
 345{
 346	struct ax25_ctl_struct ax25_ctl;
 347	ax25_digi digi;
 348	ax25_dev *ax25_dev;
 349	ax25_cb *ax25;
 350	unsigned int k;
 351	int ret = 0;
 352
 353	if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
 354		return -EFAULT;
 355
 356	if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
 357		return -ENODEV;
 358
 359	if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
 360		return -EINVAL;
 361
 362	if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
 363		return -EINVAL;
 364
 
 
 
 
 365	digi.ndigi = ax25_ctl.digi_count;
 366	for (k = 0; k < digi.ndigi; k++)
 367		digi.calls[k] = ax25_ctl.digi_addr[k];
 368
 369	if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
 
 
 370		return -ENOTCONN;
 
 371
 372	switch (ax25_ctl.cmd) {
 373	case AX25_KILL:
 374		ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
 375#ifdef CONFIG_AX25_DAMA_SLAVE
 376		if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
 377			ax25_dama_off(ax25);
 378#endif
 379		ax25_disconnect(ax25, ENETRESET);
 380		break;
 381
 382	case AX25_WINDOW:
 383		if (ax25->modulus == AX25_MODULUS) {
 384			if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
 385				goto einval_put;
 386		} else {
 387			if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
 388				goto einval_put;
 389		}
 390		ax25->window = ax25_ctl.arg;
 391		break;
 392
 393	case AX25_T1:
 394		if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
 395			goto einval_put;
 396		ax25->rtt = (ax25_ctl.arg * HZ) / 2;
 397		ax25->t1  = ax25_ctl.arg * HZ;
 398		break;
 399
 400	case AX25_T2:
 401		if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
 402			goto einval_put;
 403		ax25->t2 = ax25_ctl.arg * HZ;
 404		break;
 405
 406	case AX25_N2:
 407		if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
 408			goto einval_put;
 409		ax25->n2count = 0;
 410		ax25->n2 = ax25_ctl.arg;
 411		break;
 412
 413	case AX25_T3:
 414		if (ax25_ctl.arg > ULONG_MAX / HZ)
 415			goto einval_put;
 416		ax25->t3 = ax25_ctl.arg * HZ;
 417		break;
 418
 419	case AX25_IDLE:
 420		if (ax25_ctl.arg > ULONG_MAX / (60 * HZ))
 421			goto einval_put;
 422
 423		ax25->idle = ax25_ctl.arg * 60 * HZ;
 424		break;
 425
 426	case AX25_PACLEN:
 427		if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
 428			goto einval_put;
 429		ax25->paclen = ax25_ctl.arg;
 430		break;
 431
 432	default:
 433		goto einval_put;
 434	  }
 435
 436out_put:
 
 437	ax25_cb_put(ax25);
 438	return ret;
 439
 440einval_put:
 441	ret = -EINVAL;
 442	goto out_put;
 443}
 444
 445static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
 446{
 447	ax25->rtt     = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
 448	ax25->t1      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
 449	ax25->t2      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
 450	ax25->t3      = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
 451	ax25->n2      = ax25_dev->values[AX25_VALUES_N2];
 452	ax25->paclen  = ax25_dev->values[AX25_VALUES_PACLEN];
 453	ax25->idle    = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
 454	ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
 455
 456	if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
 457		ax25->modulus = AX25_EMODULUS;
 458		ax25->window  = ax25_dev->values[AX25_VALUES_EWINDOW];
 459	} else {
 460		ax25->modulus = AX25_MODULUS;
 461		ax25->window  = ax25_dev->values[AX25_VALUES_WINDOW];
 462	}
 463}
 464
 465/*
 466 *	Fill in a created AX.25 created control block with the default
 467 *	values for a particular device.
 468 */
 469void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
 470{
 471	ax25->ax25_dev = ax25_dev;
 472
 473	if (ax25->ax25_dev != NULL) {
 474		ax25_fillin_cb_from_dev(ax25, ax25_dev);
 475		return;
 476	}
 477
 478	/*
 479	 * No device, use kernel / AX.25 spec default values
 480	 */
 481	ax25->rtt     = msecs_to_jiffies(AX25_DEF_T1) / 2;
 482	ax25->t1      = msecs_to_jiffies(AX25_DEF_T1);
 483	ax25->t2      = msecs_to_jiffies(AX25_DEF_T2);
 484	ax25->t3      = msecs_to_jiffies(AX25_DEF_T3);
 485	ax25->n2      = AX25_DEF_N2;
 486	ax25->paclen  = AX25_DEF_PACLEN;
 487	ax25->idle    = msecs_to_jiffies(AX25_DEF_IDLE);
 488	ax25->backoff = AX25_DEF_BACKOFF;
 489
 490	if (AX25_DEF_AXDEFMODE) {
 491		ax25->modulus = AX25_EMODULUS;
 492		ax25->window  = AX25_DEF_EWINDOW;
 493	} else {
 494		ax25->modulus = AX25_MODULUS;
 495		ax25->window  = AX25_DEF_WINDOW;
 496	}
 497}
 498
 499/*
 500 * Create an empty AX.25 control block.
 501 */
 502ax25_cb *ax25_create_cb(void)
 503{
 504	ax25_cb *ax25;
 505
 506	if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
 507		return NULL;
 508
 509	refcount_set(&ax25->refcount, 1);
 510
 511	skb_queue_head_init(&ax25->write_queue);
 512	skb_queue_head_init(&ax25->frag_queue);
 513	skb_queue_head_init(&ax25->ack_queue);
 514	skb_queue_head_init(&ax25->reseq_queue);
 515
 516	ax25_setup_timers(ax25);
 517
 518	ax25_fillin_cb(ax25, NULL);
 519
 520	ax25->state = AX25_STATE_0;
 521
 522	return ax25;
 523}
 524
 525/*
 526 *	Handling for system calls applied via the various interfaces to an
 527 *	AX25 socket object
 528 */
 529
 530static int ax25_setsockopt(struct socket *sock, int level, int optname,
 531		sockptr_t optval, unsigned int optlen)
 532{
 533	struct sock *sk = sock->sk;
 534	ax25_cb *ax25;
 535	struct net_device *dev;
 536	char devname[IFNAMSIZ];
 537	unsigned long opt;
 538	int res = 0;
 539
 540	if (level != SOL_AX25)
 541		return -ENOPROTOOPT;
 542
 543	if (optlen < sizeof(unsigned int))
 544		return -EINVAL;
 545
 546	if (copy_from_sockptr(&opt, optval, sizeof(unsigned int)))
 547		return -EFAULT;
 548
 549	lock_sock(sk);
 550	ax25 = sk_to_ax25(sk);
 551
 552	switch (optname) {
 553	case AX25_WINDOW:
 554		if (ax25->modulus == AX25_MODULUS) {
 555			if (opt < 1 || opt > 7) {
 556				res = -EINVAL;
 557				break;
 558			}
 559		} else {
 560			if (opt < 1 || opt > 63) {
 561				res = -EINVAL;
 562				break;
 563			}
 564		}
 565		ax25->window = opt;
 566		break;
 567
 568	case AX25_T1:
 569		if (opt < 1 || opt > ULONG_MAX / HZ) {
 570			res = -EINVAL;
 571			break;
 572		}
 573		ax25->rtt = (opt * HZ) >> 1;
 574		ax25->t1  = opt * HZ;
 575		break;
 576
 577	case AX25_T2:
 578		if (opt < 1 || opt > ULONG_MAX / HZ) {
 579			res = -EINVAL;
 580			break;
 581		}
 582		ax25->t2 = opt * HZ;
 583		break;
 584
 585	case AX25_N2:
 586		if (opt < 1 || opt > 31) {
 587			res = -EINVAL;
 588			break;
 589		}
 590		ax25->n2 = opt;
 591		break;
 592
 593	case AX25_T3:
 594		if (opt < 1 || opt > ULONG_MAX / HZ) {
 595			res = -EINVAL;
 596			break;
 597		}
 598		ax25->t3 = opt * HZ;
 599		break;
 600
 601	case AX25_IDLE:
 602		if (opt > ULONG_MAX / (60 * HZ)) {
 603			res = -EINVAL;
 604			break;
 605		}
 606		ax25->idle = opt * 60 * HZ;
 607		break;
 608
 609	case AX25_BACKOFF:
 610		if (opt > 2) {
 611			res = -EINVAL;
 612			break;
 613		}
 614		ax25->backoff = opt;
 615		break;
 616
 617	case AX25_EXTSEQ:
 618		ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
 619		break;
 620
 621	case AX25_PIDINCL:
 622		ax25->pidincl = opt ? 1 : 0;
 623		break;
 624
 625	case AX25_IAMDIGI:
 626		ax25->iamdigi = opt ? 1 : 0;
 627		break;
 628
 629	case AX25_PACLEN:
 630		if (opt < 16 || opt > 65535) {
 631			res = -EINVAL;
 632			break;
 633		}
 634		ax25->paclen = opt;
 635		break;
 636
 637	case SO_BINDTODEVICE:
 638		if (optlen > IFNAMSIZ - 1)
 639			optlen = IFNAMSIZ - 1;
 640
 641		memset(devname, 0, sizeof(devname));
 642
 643		if (copy_from_sockptr(devname, optval, optlen)) {
 644			res = -EFAULT;
 645			break;
 646		}
 647
 648		if (sk->sk_type == SOCK_SEQPACKET &&
 649		   (sock->state != SS_UNCONNECTED ||
 650		    sk->sk_state == TCP_LISTEN)) {
 651			res = -EADDRNOTAVAIL;
 652			break;
 653		}
 654
 655		rtnl_lock();
 656		dev = __dev_get_by_name(&init_net, devname);
 657		if (!dev) {
 658			rtnl_unlock();
 659			res = -ENODEV;
 660			break;
 661		}
 662
 663		ax25->ax25_dev = ax25_dev_ax25dev(dev);
 664		if (!ax25->ax25_dev) {
 665			rtnl_unlock();
 666			res = -ENODEV;
 667			break;
 668		}
 669		ax25_fillin_cb(ax25, ax25->ax25_dev);
 670		rtnl_unlock();
 671		break;
 672
 673	default:
 674		res = -ENOPROTOOPT;
 675	}
 676	release_sock(sk);
 677
 678	return res;
 679}
 680
 681static int ax25_getsockopt(struct socket *sock, int level, int optname,
 682	char __user *optval, int __user *optlen)
 683{
 684	struct sock *sk = sock->sk;
 685	ax25_cb *ax25;
 686	struct ax25_dev *ax25_dev;
 687	char devname[IFNAMSIZ];
 688	void *valptr;
 689	int val = 0;
 690	int maxlen, length;
 691
 692	if (level != SOL_AX25)
 693		return -ENOPROTOOPT;
 694
 695	if (get_user(maxlen, optlen))
 696		return -EFAULT;
 697
 698	if (maxlen < 1)
 699		return -EFAULT;
 700
 701	valptr = (void *) &val;
 702	length = min_t(unsigned int, maxlen, sizeof(int));
 703
 704	lock_sock(sk);
 705	ax25 = sk_to_ax25(sk);
 706
 707	switch (optname) {
 708	case AX25_WINDOW:
 709		val = ax25->window;
 710		break;
 711
 712	case AX25_T1:
 713		val = ax25->t1 / HZ;
 714		break;
 715
 716	case AX25_T2:
 717		val = ax25->t2 / HZ;
 718		break;
 719
 720	case AX25_N2:
 721		val = ax25->n2;
 722		break;
 723
 724	case AX25_T3:
 725		val = ax25->t3 / HZ;
 726		break;
 727
 728	case AX25_IDLE:
 729		val = ax25->idle / (60 * HZ);
 730		break;
 731
 732	case AX25_BACKOFF:
 733		val = ax25->backoff;
 734		break;
 735
 736	case AX25_EXTSEQ:
 737		val = (ax25->modulus == AX25_EMODULUS);
 738		break;
 739
 740	case AX25_PIDINCL:
 741		val = ax25->pidincl;
 742		break;
 743
 744	case AX25_IAMDIGI:
 745		val = ax25->iamdigi;
 746		break;
 747
 748	case AX25_PACLEN:
 749		val = ax25->paclen;
 750		break;
 751
 752	case SO_BINDTODEVICE:
 753		ax25_dev = ax25->ax25_dev;
 754
 755		if (ax25_dev != NULL && ax25_dev->dev != NULL) {
 756			strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
 757			length = strlen(devname) + 1;
 758		} else {
 759			*devname = '\0';
 760			length = 1;
 761		}
 762
 763		valptr = (void *) devname;
 764		break;
 765
 766	default:
 767		release_sock(sk);
 768		return -ENOPROTOOPT;
 769	}
 770	release_sock(sk);
 771
 772	if (put_user(length, optlen))
 773		return -EFAULT;
 774
 775	return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
 776}
 777
 778static int ax25_listen(struct socket *sock, int backlog)
 779{
 780	struct sock *sk = sock->sk;
 781	int res = 0;
 782
 783	lock_sock(sk);
 784	if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
 785		sk->sk_max_ack_backlog = backlog;
 786		sk->sk_state           = TCP_LISTEN;
 787		goto out;
 788	}
 789	res = -EOPNOTSUPP;
 790
 791out:
 792	release_sock(sk);
 793
 794	return res;
 795}
 796
 797/*
 798 * XXX: when creating ax25_sock we should update the .obj_size setting
 799 * below.
 800 */
 801static struct proto ax25_proto = {
 802	.name	  = "AX25",
 803	.owner	  = THIS_MODULE,
 804	.obj_size = sizeof(struct ax25_sock),
 805};
 806
 807static int ax25_create(struct net *net, struct socket *sock, int protocol,
 808		       int kern)
 809{
 810	struct sock *sk;
 811	ax25_cb *ax25;
 812
 813	if (protocol < 0 || protocol > U8_MAX)
 814		return -EINVAL;
 815
 816	if (!net_eq(net, &init_net))
 817		return -EAFNOSUPPORT;
 818
 819	switch (sock->type) {
 820	case SOCK_DGRAM:
 821		if (protocol == 0 || protocol == PF_AX25)
 822			protocol = AX25_P_TEXT;
 823		break;
 824
 825	case SOCK_SEQPACKET:
 826		switch (protocol) {
 827		case 0:
 828		case PF_AX25:	/* For CLX */
 829			protocol = AX25_P_TEXT;
 830			break;
 831		case AX25_P_SEGMENT:
 832#ifdef CONFIG_INET
 833		case AX25_P_ARP:
 834		case AX25_P_IP:
 835#endif
 836#ifdef CONFIG_NETROM
 837		case AX25_P_NETROM:
 838#endif
 839#ifdef CONFIG_ROSE
 840		case AX25_P_ROSE:
 841#endif
 842			return -ESOCKTNOSUPPORT;
 843#ifdef CONFIG_NETROM_MODULE
 844		case AX25_P_NETROM:
 845			if (ax25_protocol_is_registered(AX25_P_NETROM))
 846				return -ESOCKTNOSUPPORT;
 847			break;
 848#endif
 849#ifdef CONFIG_ROSE_MODULE
 850		case AX25_P_ROSE:
 851			if (ax25_protocol_is_registered(AX25_P_ROSE))
 852				return -ESOCKTNOSUPPORT;
 853			break;
 854#endif
 855		default:
 856			break;
 857		}
 858		break;
 859
 860	case SOCK_RAW:
 861		if (!capable(CAP_NET_RAW))
 862			return -EPERM;
 863		break;
 864	default:
 865		return -ESOCKTNOSUPPORT;
 866	}
 867
 868	sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto, kern);
 869	if (sk == NULL)
 870		return -ENOMEM;
 871
 872	ax25 = ax25_sk(sk)->cb = ax25_create_cb();
 873	if (!ax25) {
 874		sk_free(sk);
 875		return -ENOMEM;
 876	}
 877
 878	sock_init_data(sock, sk);
 879
 880	sk->sk_destruct = ax25_free_sock;
 881	sock->ops    = &ax25_proto_ops;
 882	sk->sk_protocol = protocol;
 883
 884	ax25->sk    = sk;
 885
 886	return 0;
 887}
 888
 889struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
 890{
 891	struct sock *sk;
 892	ax25_cb *ax25, *oax25;
 893
 894	sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot, 0);
 895	if (sk == NULL)
 896		return NULL;
 897
 898	if ((ax25 = ax25_create_cb()) == NULL) {
 899		sk_free(sk);
 900		return NULL;
 901	}
 902
 903	switch (osk->sk_type) {
 904	case SOCK_DGRAM:
 905		break;
 906	case SOCK_SEQPACKET:
 907		break;
 908	default:
 909		sk_free(sk);
 910		ax25_cb_put(ax25);
 911		return NULL;
 912	}
 913
 914	sock_init_data(NULL, sk);
 915
 916	sk->sk_type     = osk->sk_type;
 917	sk->sk_priority = osk->sk_priority;
 918	sk->sk_protocol = osk->sk_protocol;
 919	sk->sk_rcvbuf   = osk->sk_rcvbuf;
 920	sk->sk_sndbuf   = osk->sk_sndbuf;
 921	sk->sk_state    = TCP_ESTABLISHED;
 922	sock_copy_flags(sk, osk);
 923
 924	oax25 = sk_to_ax25(osk);
 925
 926	ax25->modulus = oax25->modulus;
 927	ax25->backoff = oax25->backoff;
 928	ax25->pidincl = oax25->pidincl;
 929	ax25->iamdigi = oax25->iamdigi;
 930	ax25->rtt     = oax25->rtt;
 931	ax25->t1      = oax25->t1;
 932	ax25->t2      = oax25->t2;
 933	ax25->t3      = oax25->t3;
 934	ax25->n2      = oax25->n2;
 935	ax25->idle    = oax25->idle;
 936	ax25->paclen  = oax25->paclen;
 937	ax25->window  = oax25->window;
 938
 939	ax25->ax25_dev    = ax25_dev;
 940	ax25->source_addr = oax25->source_addr;
 941
 942	if (oax25->digipeat != NULL) {
 943		ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
 944					 GFP_ATOMIC);
 945		if (ax25->digipeat == NULL) {
 946			sk_free(sk);
 947			ax25_cb_put(ax25);
 948			return NULL;
 949		}
 950	}
 951
 952	ax25_sk(sk)->cb = ax25;
 953	sk->sk_destruct = ax25_free_sock;
 954	ax25->sk    = sk;
 955
 956	return sk;
 957}
 958
 959static int ax25_release(struct socket *sock)
 960{
 961	struct sock *sk = sock->sk;
 962	ax25_cb *ax25;
 
 963
 964	if (sk == NULL)
 965		return 0;
 966
 967	sock_hold(sk);
 968	sock_orphan(sk);
 969	lock_sock(sk);
 
 970	ax25 = sk_to_ax25(sk);
 
 971
 972	if (sk->sk_type == SOCK_SEQPACKET) {
 973		switch (ax25->state) {
 974		case AX25_STATE_0:
 975			release_sock(sk);
 976			ax25_disconnect(ax25, 0);
 977			lock_sock(sk);
 
 
 978			ax25_destroy_socket(ax25);
 979			break;
 980
 981		case AX25_STATE_1:
 982		case AX25_STATE_2:
 983			ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
 984			release_sock(sk);
 985			ax25_disconnect(ax25, 0);
 986			lock_sock(sk);
 987			if (!sock_flag(ax25->sk, SOCK_DESTROY))
 988				ax25_destroy_socket(ax25);
 989			break;
 990
 991		case AX25_STATE_3:
 992		case AX25_STATE_4:
 993			ax25_clear_queues(ax25);
 994			ax25->n2count = 0;
 995
 996			switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
 997			case AX25_PROTO_STD_SIMPLEX:
 998			case AX25_PROTO_STD_DUPLEX:
 999				ax25_send_control(ax25,
1000						  AX25_DISC,
1001						  AX25_POLLON,
1002						  AX25_COMMAND);
1003				ax25_stop_t2timer(ax25);
1004				ax25_stop_t3timer(ax25);
1005				ax25_stop_idletimer(ax25);
1006				break;
1007#ifdef CONFIG_AX25_DAMA_SLAVE
1008			case AX25_PROTO_DAMA_SLAVE:
1009				ax25_stop_t3timer(ax25);
1010				ax25_stop_idletimer(ax25);
1011				break;
1012#endif
1013			}
1014			ax25_calculate_t1(ax25);
1015			ax25_start_t1timer(ax25);
1016			ax25->state = AX25_STATE_2;
1017			sk->sk_state                = TCP_CLOSE;
1018			sk->sk_shutdown            |= SEND_SHUTDOWN;
1019			sk->sk_state_change(sk);
1020			sock_set_flag(sk, SOCK_DESTROY);
1021			break;
1022
1023		default:
1024			break;
1025		}
1026	} else {
1027		sk->sk_state     = TCP_CLOSE;
1028		sk->sk_shutdown |= SEND_SHUTDOWN;
1029		sk->sk_state_change(sk);
1030		ax25_destroy_socket(ax25);
1031	}
 
 
 
 
 
 
 
 
 
 
 
1032
1033	sock->sk   = NULL;
1034	release_sock(sk);
1035	sock_put(sk);
1036
1037	return 0;
1038}
1039
1040/*
1041 *	We support a funny extension here so you can (as root) give any callsign
1042 *	digipeated via a local address as source. This hack is obsolete now
1043 *	that we've implemented support for SO_BINDTODEVICE. It is however small
1044 *	and trivially backward compatible.
1045 */
1046static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1047{
1048	struct sock *sk = sock->sk;
1049	struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1050	ax25_dev *ax25_dev = NULL;
1051	ax25_uid_assoc *user;
1052	ax25_address call;
1053	ax25_cb *ax25;
1054	int err = 0;
1055
1056	if (addr_len != sizeof(struct sockaddr_ax25) &&
1057	    addr_len != sizeof(struct full_sockaddr_ax25))
1058		/* support for old structure may go away some time
1059		 * ax25_bind(): uses old (6 digipeater) socket structure.
1060		 */
1061		if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1062		    (addr_len > sizeof(struct full_sockaddr_ax25)))
1063			return -EINVAL;
1064
1065	if (addr->fsa_ax25.sax25_family != AF_AX25)
1066		return -EINVAL;
1067
1068	user = ax25_findbyuid(current_euid());
1069	if (user) {
1070		call = user->call;
1071		ax25_uid_put(user);
1072	} else {
1073		if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1074			return -EACCES;
1075
1076		call = addr->fsa_ax25.sax25_call;
1077	}
1078
1079	lock_sock(sk);
1080
1081	ax25 = sk_to_ax25(sk);
1082	if (!sock_flag(sk, SOCK_ZAPPED)) {
1083		err = -EINVAL;
1084		goto out;
1085	}
1086
1087	ax25->source_addr = call;
1088
1089	/*
1090	 * User already set interface with SO_BINDTODEVICE
1091	 */
1092	if (ax25->ax25_dev != NULL)
1093		goto done;
1094
1095	if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1096		if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1097		    (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1098			err = -EADDRNOTAVAIL;
1099			goto out;
1100		}
1101	} else {
1102		if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1103			err = -EADDRNOTAVAIL;
1104			goto out;
1105		}
1106	}
1107
1108	if (ax25_dev != NULL)
1109		ax25_fillin_cb(ax25, ax25_dev);
 
 
1110
1111done:
1112	ax25_cb_add(ax25);
1113	sock_reset_flag(sk, SOCK_ZAPPED);
1114
1115out:
1116	release_sock(sk);
1117
1118	return err;
1119}
1120
1121/*
1122 *	FIXME: nonblock behaviour looks like it may have a bug.
1123 */
1124static int __must_check ax25_connect(struct socket *sock,
1125	struct sockaddr *uaddr, int addr_len, int flags)
1126{
1127	struct sock *sk = sock->sk;
1128	ax25_cb *ax25 = sk_to_ax25(sk), *ax25t;
1129	struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1130	ax25_digi *digi = NULL;
1131	int ct = 0, err = 0;
1132
1133	/*
1134	 * some sanity checks. code further down depends on this
1135	 */
1136
1137	if (addr_len == sizeof(struct sockaddr_ax25))
1138		/* support for this will go away in early 2.5.x
1139		 * ax25_connect(): uses obsolete socket structure
1140		 */
1141		;
1142	else if (addr_len != sizeof(struct full_sockaddr_ax25))
1143		/* support for old structure may go away some time
1144		 * ax25_connect(): uses old (6 digipeater) socket structure.
1145		 */
1146		if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1147		    (addr_len > sizeof(struct full_sockaddr_ax25)))
1148			return -EINVAL;
1149
1150
1151	if (fsa->fsa_ax25.sax25_family != AF_AX25)
1152		return -EINVAL;
1153
1154	lock_sock(sk);
1155
1156	/* deal with restarts */
1157	if (sock->state == SS_CONNECTING) {
1158		switch (sk->sk_state) {
1159		case TCP_SYN_SENT: /* still trying */
1160			err = -EINPROGRESS;
1161			goto out_release;
1162
1163		case TCP_ESTABLISHED: /* connection established */
1164			sock->state = SS_CONNECTED;
1165			goto out_release;
1166
1167		case TCP_CLOSE: /* connection refused */
1168			sock->state = SS_UNCONNECTED;
1169			err = -ECONNREFUSED;
1170			goto out_release;
1171		}
1172	}
1173
1174	if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1175		err = -EISCONN;	/* No reconnect on a seqpacket socket */
1176		goto out_release;
1177	}
1178
1179	sk->sk_state   = TCP_CLOSE;
1180	sock->state = SS_UNCONNECTED;
1181
1182	kfree(ax25->digipeat);
1183	ax25->digipeat = NULL;
1184
1185	/*
1186	 *	Handle digi-peaters to be used.
1187	 */
1188	if (addr_len > sizeof(struct sockaddr_ax25) &&
1189	    fsa->fsa_ax25.sax25_ndigis != 0) {
1190		/* Valid number of digipeaters ? */
1191		if (fsa->fsa_ax25.sax25_ndigis < 1 ||
1192		    fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS ||
1193		    addr_len < sizeof(struct sockaddr_ax25) +
1194		    sizeof(ax25_address) * fsa->fsa_ax25.sax25_ndigis) {
1195			err = -EINVAL;
1196			goto out_release;
1197		}
1198
1199		if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1200			err = -ENOBUFS;
1201			goto out_release;
1202		}
1203
1204		digi->ndigi      = fsa->fsa_ax25.sax25_ndigis;
1205		digi->lastrepeat = -1;
1206
1207		while (ct < fsa->fsa_ax25.sax25_ndigis) {
1208			if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1209			     AX25_HBIT) && ax25->iamdigi) {
1210				digi->repeated[ct] = 1;
1211				digi->lastrepeat   = ct;
1212			} else {
1213				digi->repeated[ct] = 0;
1214			}
1215			digi->calls[ct] = fsa->fsa_digipeater[ct];
1216			ct++;
1217		}
1218	}
1219
1220	/*
1221	 *	Must bind first - autobinding in this may or may not work. If
1222	 *	the socket is already bound, check to see if the device has
1223	 *	been filled in, error if it hasn't.
1224	 */
1225	if (sock_flag(sk, SOCK_ZAPPED)) {
1226		/* check if we can remove this feature. It is broken. */
1227		printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1228			current->comm);
1229		if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1230			kfree(digi);
1231			goto out_release;
1232		}
1233
1234		ax25_fillin_cb(ax25, ax25->ax25_dev);
1235		ax25_cb_add(ax25);
1236	} else {
1237		if (ax25->ax25_dev == NULL) {
1238			kfree(digi);
1239			err = -EHOSTUNREACH;
1240			goto out_release;
1241		}
1242	}
1243
1244	if (sk->sk_type == SOCK_SEQPACKET &&
1245	    (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1246			 ax25->ax25_dev->dev))) {
1247		kfree(digi);
1248		err = -EADDRINUSE;		/* Already such a connection */
1249		ax25_cb_put(ax25t);
1250		goto out_release;
1251	}
1252
1253	ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1254	ax25->digipeat  = digi;
1255
1256	/* First the easy one */
1257	if (sk->sk_type != SOCK_SEQPACKET) {
1258		sock->state = SS_CONNECTED;
1259		sk->sk_state   = TCP_ESTABLISHED;
1260		goto out_release;
1261	}
1262
1263	/* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1264	sock->state        = SS_CONNECTING;
1265	sk->sk_state          = TCP_SYN_SENT;
1266
1267	switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1268	case AX25_PROTO_STD_SIMPLEX:
1269	case AX25_PROTO_STD_DUPLEX:
1270		ax25_std_establish_data_link(ax25);
1271		break;
1272
1273#ifdef CONFIG_AX25_DAMA_SLAVE
1274	case AX25_PROTO_DAMA_SLAVE:
1275		ax25->modulus = AX25_MODULUS;
1276		ax25->window  = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1277		if (ax25->ax25_dev->dama.slave)
1278			ax25_ds_establish_data_link(ax25);
1279		else
1280			ax25_std_establish_data_link(ax25);
1281		break;
1282#endif
1283	}
1284
1285	ax25->state = AX25_STATE_1;
1286
1287	ax25_start_heartbeat(ax25);
1288
1289	/* Now the loop */
1290	if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1291		err = -EINPROGRESS;
1292		goto out_release;
1293	}
1294
1295	if (sk->sk_state == TCP_SYN_SENT) {
1296		DEFINE_WAIT(wait);
1297
1298		for (;;) {
1299			prepare_to_wait(sk_sleep(sk), &wait,
1300					TASK_INTERRUPTIBLE);
1301			if (sk->sk_state != TCP_SYN_SENT)
1302				break;
1303			if (!signal_pending(current)) {
1304				release_sock(sk);
1305				schedule();
1306				lock_sock(sk);
1307				continue;
1308			}
1309			err = -ERESTARTSYS;
1310			break;
1311		}
1312		finish_wait(sk_sleep(sk), &wait);
1313
1314		if (err)
1315			goto out_release;
1316	}
1317
1318	if (sk->sk_state != TCP_ESTABLISHED) {
1319		/* Not in ABM, not in WAIT_UA -> failed */
1320		sock->state = SS_UNCONNECTED;
1321		err = sock_error(sk);	/* Always set at this point */
1322		goto out_release;
1323	}
1324
1325	sock->state = SS_CONNECTED;
1326
1327	err = 0;
1328out_release:
1329	release_sock(sk);
1330
1331	return err;
1332}
1333
1334static int ax25_accept(struct socket *sock, struct socket *newsock, int flags,
1335		       bool kern)
1336{
1337	struct sk_buff *skb;
1338	struct sock *newsk;
1339	DEFINE_WAIT(wait);
1340	struct sock *sk;
1341	int err = 0;
1342
1343	if (sock->state != SS_UNCONNECTED)
1344		return -EINVAL;
1345
1346	if ((sk = sock->sk) == NULL)
1347		return -EINVAL;
1348
1349	lock_sock(sk);
1350	if (sk->sk_type != SOCK_SEQPACKET) {
1351		err = -EOPNOTSUPP;
1352		goto out;
1353	}
1354
1355	if (sk->sk_state != TCP_LISTEN) {
1356		err = -EINVAL;
1357		goto out;
1358	}
1359
1360	/*
1361	 *	The read queue this time is holding sockets ready to use
1362	 *	hooked into the SABM we saved
1363	 */
1364	for (;;) {
1365		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1366		skb = skb_dequeue(&sk->sk_receive_queue);
1367		if (skb)
1368			break;
1369
1370		if (flags & O_NONBLOCK) {
1371			err = -EWOULDBLOCK;
1372			break;
1373		}
1374		if (!signal_pending(current)) {
1375			release_sock(sk);
1376			schedule();
1377			lock_sock(sk);
1378			continue;
1379		}
1380		err = -ERESTARTSYS;
1381		break;
1382	}
1383	finish_wait(sk_sleep(sk), &wait);
1384
1385	if (err)
1386		goto out;
1387
1388	newsk		 = skb->sk;
1389	sock_graft(newsk, newsock);
1390
1391	/* Now attach up the new socket */
1392	kfree_skb(skb);
1393	sk_acceptq_removed(sk);
1394	newsock->state = SS_CONNECTED;
1395
1396out:
1397	release_sock(sk);
1398
1399	return err;
1400}
1401
1402static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1403	int peer)
1404{
1405	struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1406	struct sock *sk = sock->sk;
1407	unsigned char ndigi, i;
1408	ax25_cb *ax25;
1409	int err = 0;
1410
1411	memset(fsa, 0, sizeof(*fsa));
1412	lock_sock(sk);
1413	ax25 = sk_to_ax25(sk);
1414
1415	if (peer != 0) {
1416		if (sk->sk_state != TCP_ESTABLISHED) {
1417			err = -ENOTCONN;
1418			goto out;
1419		}
1420
1421		fsa->fsa_ax25.sax25_family = AF_AX25;
1422		fsa->fsa_ax25.sax25_call   = ax25->dest_addr;
1423
1424		if (ax25->digipeat != NULL) {
1425			ndigi = ax25->digipeat->ndigi;
1426			fsa->fsa_ax25.sax25_ndigis = ndigi;
1427			for (i = 0; i < ndigi; i++)
1428				fsa->fsa_digipeater[i] =
1429						ax25->digipeat->calls[i];
1430		}
1431	} else {
1432		fsa->fsa_ax25.sax25_family = AF_AX25;
1433		fsa->fsa_ax25.sax25_call   = ax25->source_addr;
1434		fsa->fsa_ax25.sax25_ndigis = 1;
1435		if (ax25->ax25_dev != NULL) {
1436			memcpy(&fsa->fsa_digipeater[0],
1437			       ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1438		} else {
1439			fsa->fsa_digipeater[0] = null_ax25_address;
1440		}
1441	}
1442	err = sizeof (struct full_sockaddr_ax25);
1443
1444out:
1445	release_sock(sk);
1446
1447	return err;
1448}
1449
1450static int ax25_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1451{
1452	DECLARE_SOCKADDR(struct sockaddr_ax25 *, usax, msg->msg_name);
1453	struct sock *sk = sock->sk;
1454	struct sockaddr_ax25 sax;
1455	struct sk_buff *skb;
1456	ax25_digi dtmp, *dp;
1457	ax25_cb *ax25;
1458	size_t size;
1459	int lv, err, addr_len = msg->msg_namelen;
1460
1461	if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1462		return -EINVAL;
1463
1464	lock_sock(sk);
1465	ax25 = sk_to_ax25(sk);
1466
1467	if (sock_flag(sk, SOCK_ZAPPED)) {
1468		err = -EADDRNOTAVAIL;
1469		goto out;
1470	}
1471
1472	if (sk->sk_shutdown & SEND_SHUTDOWN) {
1473		send_sig(SIGPIPE, current, 0);
1474		err = -EPIPE;
1475		goto out;
1476	}
1477
1478	if (ax25->ax25_dev == NULL) {
1479		err = -ENETUNREACH;
1480		goto out;
1481	}
1482
1483	if (len > ax25->ax25_dev->dev->mtu) {
1484		err = -EMSGSIZE;
1485		goto out;
1486	}
1487
1488	if (usax != NULL) {
1489		if (usax->sax25_family != AF_AX25) {
1490			err = -EINVAL;
1491			goto out;
1492		}
1493
1494		if (addr_len == sizeof(struct sockaddr_ax25))
1495			/* ax25_sendmsg(): uses obsolete socket structure */
1496			;
1497		else if (addr_len != sizeof(struct full_sockaddr_ax25))
1498			/* support for old structure may go away some time
1499			 * ax25_sendmsg(): uses old (6 digipeater)
1500			 * socket structure.
1501			 */
1502			if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1503			    (addr_len > sizeof(struct full_sockaddr_ax25))) {
1504				err = -EINVAL;
1505				goto out;
1506			}
1507
1508
1509		if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1510			int ct           = 0;
1511			struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1512
1513			/* Valid number of digipeaters ? */
1514			if (usax->sax25_ndigis < 1 ||
1515			    usax->sax25_ndigis > AX25_MAX_DIGIS ||
1516			    addr_len < sizeof(struct sockaddr_ax25) +
1517			    sizeof(ax25_address) * usax->sax25_ndigis) {
1518				err = -EINVAL;
1519				goto out;
1520			}
1521
1522			dtmp.ndigi      = usax->sax25_ndigis;
1523
1524			while (ct < usax->sax25_ndigis) {
1525				dtmp.repeated[ct] = 0;
1526				dtmp.calls[ct]    = fsa->fsa_digipeater[ct];
1527				ct++;
1528			}
1529
1530			dtmp.lastrepeat = 0;
1531		}
1532
1533		sax = *usax;
1534		if (sk->sk_type == SOCK_SEQPACKET &&
1535		    ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1536			err = -EISCONN;
1537			goto out;
1538		}
1539		if (usax->sax25_ndigis == 0)
1540			dp = NULL;
1541		else
1542			dp = &dtmp;
1543	} else {
1544		/*
1545		 *	FIXME: 1003.1g - if the socket is like this because
1546		 *	it has become closed (not started closed) and is VC
1547		 *	we ought to SIGPIPE, EPIPE
1548		 */
1549		if (sk->sk_state != TCP_ESTABLISHED) {
1550			err = -ENOTCONN;
1551			goto out;
1552		}
1553		sax.sax25_family = AF_AX25;
1554		sax.sax25_call   = ax25->dest_addr;
1555		dp = ax25->digipeat;
1556	}
1557
1558	/* Build a packet */
1559	/* Assume the worst case */
1560	size = len + ax25->ax25_dev->dev->hard_header_len;
1561
1562	skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1563	if (skb == NULL)
1564		goto out;
1565
1566	skb_reserve(skb, size - len);
1567
1568	/* User data follows immediately after the AX.25 data */
1569	if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1570		err = -EFAULT;
1571		kfree_skb(skb);
1572		goto out;
1573	}
1574
1575	skb_reset_network_header(skb);
1576
1577	/* Add the PID if one is not supplied by the user in the skb */
1578	if (!ax25->pidincl)
1579		*(u8 *)skb_push(skb, 1) = sk->sk_protocol;
1580
1581	if (sk->sk_type == SOCK_SEQPACKET) {
1582		/* Connected mode sockets go via the LAPB machine */
1583		if (sk->sk_state != TCP_ESTABLISHED) {
1584			kfree_skb(skb);
1585			err = -ENOTCONN;
1586			goto out;
1587		}
1588
1589		/* Shove it onto the queue and kick */
1590		ax25_output(ax25, ax25->paclen, skb);
1591
1592		err = len;
1593		goto out;
1594	}
1595
1596	skb_push(skb, 1 + ax25_addr_size(dp));
1597
1598	/* Building AX.25 Header */
1599
1600	/* Build an AX.25 header */
1601	lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1602			     dp, AX25_COMMAND, AX25_MODULUS);
1603
1604	skb_set_transport_header(skb, lv);
1605
1606	*skb_transport_header(skb) = AX25_UI;
1607
1608	/* Datagram frames go straight out of the door as UI */
1609	ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1610
1611	err = len;
1612
1613out:
1614	release_sock(sk);
1615
1616	return err;
1617}
1618
1619static int ax25_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1620			int flags)
1621{
1622	struct sock *sk = sock->sk;
1623	struct sk_buff *skb;
 
1624	int copied;
1625	int err = 0;
 
 
1626
1627	lock_sock(sk);
1628	/*
1629	 * 	This works for seqpacket too. The receiver has ordered the
1630	 *	queue for us! We do one quick check first though
1631	 */
1632	if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1633		err =  -ENOTCONN;
1634		goto out;
1635	}
1636
1637	/* Now we can treat all alike */
1638	skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1639				flags & MSG_DONTWAIT, &err);
1640	if (skb == NULL)
1641		goto out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1642
1643	if (!sk_to_ax25(sk)->pidincl)
1644		skb_pull(skb, 1);		/* Remove PID */
1645
1646	skb_reset_transport_header(skb);
1647	copied = skb->len;
1648
1649	if (copied > size) {
1650		copied = size;
1651		msg->msg_flags |= MSG_TRUNC;
1652	}
1653
1654	skb_copy_datagram_msg(skb, 0, msg, copied);
1655
1656	if (msg->msg_name) {
1657		ax25_digi digi;
1658		ax25_address src;
1659		const unsigned char *mac = skb_mac_header(skb);
1660		DECLARE_SOCKADDR(struct sockaddr_ax25 *, sax, msg->msg_name);
1661
1662		memset(sax, 0, sizeof(struct full_sockaddr_ax25));
1663		ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1664				&digi, NULL, NULL);
1665		sax->sax25_family = AF_AX25;
1666		/* We set this correctly, even though we may not let the
1667		   application know the digi calls further down (because it
1668		   did NOT ask to know them).  This could get political... **/
1669		sax->sax25_ndigis = digi.ndigi;
1670		sax->sax25_call   = src;
1671
1672		if (sax->sax25_ndigis != 0) {
1673			int ct;
1674			struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1675
1676			for (ct = 0; ct < digi.ndigi; ct++)
1677				fsa->fsa_digipeater[ct] = digi.calls[ct];
1678		}
1679		msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1680	}
1681
1682	skb_free_datagram(sk, skb);
1683	err = copied;
1684
1685out:
1686	release_sock(sk);
1687
 
1688	return err;
1689}
1690
1691static int ax25_shutdown(struct socket *sk, int how)
1692{
1693	/* FIXME - generate DM and RNR states */
1694	return -EOPNOTSUPP;
1695}
1696
1697static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1698{
1699	struct sock *sk = sock->sk;
1700	void __user *argp = (void __user *)arg;
1701	int res = 0;
1702
1703	lock_sock(sk);
1704	switch (cmd) {
1705	case TIOCOUTQ: {
1706		long amount;
1707
1708		amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1709		if (amount < 0)
1710			amount = 0;
1711		res = put_user(amount, (int __user *)argp);
1712		break;
1713	}
1714
1715	case TIOCINQ: {
1716		struct sk_buff *skb;
1717		long amount = 0L;
1718		/* These two are safe on a single CPU system as only user tasks fiddle here */
1719		if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1720			amount = skb->len;
1721		res = put_user(amount, (int __user *) argp);
1722		break;
1723	}
1724
1725	case SIOCAX25ADDUID:	/* Add a uid to the uid/call map table */
1726	case SIOCAX25DELUID:	/* Delete a uid from the uid/call map table */
1727	case SIOCAX25GETUID: {
1728		struct sockaddr_ax25 sax25;
1729		if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1730			res = -EFAULT;
1731			break;
1732		}
1733		res = ax25_uid_ioctl(cmd, &sax25);
1734		break;
1735	}
1736
1737	case SIOCAX25NOUID: {	/* Set the default policy (default/bar) */
1738		long amount;
1739		if (!capable(CAP_NET_ADMIN)) {
1740			res = -EPERM;
1741			break;
1742		}
1743		if (get_user(amount, (long __user *)argp)) {
1744			res = -EFAULT;
1745			break;
1746		}
1747		if (amount < 0 || amount > AX25_NOUID_BLOCK) {
1748			res = -EINVAL;
1749			break;
1750		}
1751		ax25_uid_policy = amount;
1752		res = 0;
1753		break;
1754	}
1755
1756	case SIOCADDRT:
1757	case SIOCDELRT:
1758	case SIOCAX25OPTRT:
1759		if (!capable(CAP_NET_ADMIN)) {
1760			res = -EPERM;
1761			break;
1762		}
1763		res = ax25_rt_ioctl(cmd, argp);
1764		break;
1765
1766	case SIOCAX25CTLCON:
1767		if (!capable(CAP_NET_ADMIN)) {
1768			res = -EPERM;
1769			break;
1770		}
1771		res = ax25_ctl_ioctl(cmd, argp);
1772		break;
1773
1774	case SIOCAX25GETINFO:
1775	case SIOCAX25GETINFOOLD: {
1776		ax25_cb *ax25 = sk_to_ax25(sk);
1777		struct ax25_info_struct ax25_info;
1778
1779		ax25_info.t1        = ax25->t1   / HZ;
1780		ax25_info.t2        = ax25->t2   / HZ;
1781		ax25_info.t3        = ax25->t3   / HZ;
1782		ax25_info.idle      = ax25->idle / (60 * HZ);
1783		ax25_info.n2        = ax25->n2;
1784		ax25_info.t1timer   = ax25_display_timer(&ax25->t1timer)   / HZ;
1785		ax25_info.t2timer   = ax25_display_timer(&ax25->t2timer)   / HZ;
1786		ax25_info.t3timer   = ax25_display_timer(&ax25->t3timer)   / HZ;
1787		ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1788		ax25_info.n2count   = ax25->n2count;
1789		ax25_info.state     = ax25->state;
1790		ax25_info.rcv_q     = sk_rmem_alloc_get(sk);
1791		ax25_info.snd_q     = sk_wmem_alloc_get(sk);
1792		ax25_info.vs        = ax25->vs;
1793		ax25_info.vr        = ax25->vr;
1794		ax25_info.va        = ax25->va;
1795		ax25_info.vs_max    = ax25->vs; /* reserved */
1796		ax25_info.paclen    = ax25->paclen;
1797		ax25_info.window    = ax25->window;
1798
1799		/* old structure? */
1800		if (cmd == SIOCAX25GETINFOOLD) {
1801			static int warned = 0;
1802			if (!warned) {
1803				printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1804					current->comm);
1805				warned=1;
1806			}
1807
1808			if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1809				res = -EFAULT;
1810				break;
1811			}
1812		} else {
1813			if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1814				res = -EINVAL;
1815				break;
1816			}
1817		}
1818		res = 0;
1819		break;
1820	}
1821
1822	case SIOCAX25ADDFWD:
1823	case SIOCAX25DELFWD: {
1824		struct ax25_fwd_struct ax25_fwd;
1825		if (!capable(CAP_NET_ADMIN)) {
1826			res = -EPERM;
1827			break;
1828		}
1829		if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1830			res = -EFAULT;
1831			break;
1832		}
1833		res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1834		break;
1835	}
1836
1837	case SIOCGIFADDR:
1838	case SIOCSIFADDR:
1839	case SIOCGIFDSTADDR:
1840	case SIOCSIFDSTADDR:
1841	case SIOCGIFBRDADDR:
1842	case SIOCSIFBRDADDR:
1843	case SIOCGIFNETMASK:
1844	case SIOCSIFNETMASK:
1845	case SIOCGIFMETRIC:
1846	case SIOCSIFMETRIC:
1847		res = -EINVAL;
1848		break;
1849
1850	default:
1851		res = -ENOIOCTLCMD;
1852		break;
1853	}
1854	release_sock(sk);
1855
1856	return res;
1857}
1858
1859#ifdef CONFIG_PROC_FS
1860
1861static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1862	__acquires(ax25_list_lock)
1863{
1864	spin_lock_bh(&ax25_list_lock);
1865	return seq_hlist_start(&ax25_list, *pos);
1866}
1867
1868static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1869{
1870	return seq_hlist_next(v, &ax25_list, pos);
1871}
1872
1873static void ax25_info_stop(struct seq_file *seq, void *v)
1874	__releases(ax25_list_lock)
1875{
1876	spin_unlock_bh(&ax25_list_lock);
1877}
1878
1879static int ax25_info_show(struct seq_file *seq, void *v)
1880{
1881	ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
1882	char buf[11];
1883	int k;
1884
1885
1886	/*
1887	 * New format:
1888	 * magic dev src_addr dest_addr,digi1,digi2,.. st vs vr va t1 t1 t2 t2 t3 t3 idle idle n2 n2 rtt window paclen Snd-Q Rcv-Q inode
1889	 */
1890
1891	seq_printf(seq, "%p %s %s%s ",
1892		   ax25,
1893		   ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1894		   ax2asc(buf, &ax25->source_addr),
1895		   ax25->iamdigi? "*":"");
1896	seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1897
1898	for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1899		seq_printf(seq, ",%s%s",
1900			   ax2asc(buf, &ax25->digipeat->calls[k]),
1901			   ax25->digipeat->repeated[k]? "*":"");
1902	}
1903
1904	seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1905		   ax25->state,
1906		   ax25->vs, ax25->vr, ax25->va,
1907		   ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1908		   ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1909		   ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1910		   ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1911		   ax25->idle / (60 * HZ),
1912		   ax25->n2count, ax25->n2,
1913		   ax25->rtt / HZ,
1914		   ax25->window,
1915		   ax25->paclen);
1916
1917	if (ax25->sk != NULL) {
1918		seq_printf(seq, " %d %d %lu\n",
1919			   sk_wmem_alloc_get(ax25->sk),
1920			   sk_rmem_alloc_get(ax25->sk),
1921			   sock_i_ino(ax25->sk));
1922	} else {
1923		seq_puts(seq, " * * *\n");
1924	}
1925	return 0;
1926}
1927
1928static const struct seq_operations ax25_info_seqops = {
1929	.start = ax25_info_start,
1930	.next = ax25_info_next,
1931	.stop = ax25_info_stop,
1932	.show = ax25_info_show,
1933};
1934#endif
1935
1936static const struct net_proto_family ax25_family_ops = {
1937	.family =	PF_AX25,
1938	.create =	ax25_create,
1939	.owner	=	THIS_MODULE,
1940};
1941
1942static const struct proto_ops ax25_proto_ops = {
1943	.family		= PF_AX25,
1944	.owner		= THIS_MODULE,
1945	.release	= ax25_release,
1946	.bind		= ax25_bind,
1947	.connect	= ax25_connect,
1948	.socketpair	= sock_no_socketpair,
1949	.accept		= ax25_accept,
1950	.getname	= ax25_getname,
1951	.poll		= datagram_poll,
1952	.ioctl		= ax25_ioctl,
1953	.gettstamp	= sock_gettstamp,
1954	.listen		= ax25_listen,
1955	.shutdown	= ax25_shutdown,
1956	.setsockopt	= ax25_setsockopt,
1957	.getsockopt	= ax25_getsockopt,
1958	.sendmsg	= ax25_sendmsg,
1959	.recvmsg	= ax25_recvmsg,
1960	.mmap		= sock_no_mmap,
1961	.sendpage	= sock_no_sendpage,
1962};
1963
1964/*
1965 *	Called by socket.c on kernel start up
1966 */
1967static struct packet_type ax25_packet_type __read_mostly = {
1968	.type	=	cpu_to_be16(ETH_P_AX25),
1969	.func	=	ax25_kiss_rcv,
1970};
1971
1972static struct notifier_block ax25_dev_notifier = {
1973	.notifier_call = ax25_device_event,
1974};
1975
1976static int __init ax25_init(void)
1977{
1978	int rc = proto_register(&ax25_proto, 0);
1979
1980	if (rc != 0)
1981		goto out;
1982
1983	sock_register(&ax25_family_ops);
1984	dev_add_pack(&ax25_packet_type);
1985	register_netdevice_notifier(&ax25_dev_notifier);
1986
1987	proc_create_seq("ax25_route", 0444, init_net.proc_net, &ax25_rt_seqops);
1988	proc_create_seq("ax25", 0444, init_net.proc_net, &ax25_info_seqops);
1989	proc_create_seq("ax25_calls", 0444, init_net.proc_net,
1990			&ax25_uid_seqops);
1991out:
1992	return rc;
1993}
1994module_init(ax25_init);
1995
1996
1997MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
1998MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
1999MODULE_LICENSE("GPL");
2000MODULE_ALIAS_NETPROTO(PF_AX25);
2001
2002static void __exit ax25_exit(void)
2003{
2004	remove_proc_entry("ax25_route", init_net.proc_net);
2005	remove_proc_entry("ax25", init_net.proc_net);
2006	remove_proc_entry("ax25_calls", init_net.proc_net);
2007
2008	unregister_netdevice_notifier(&ax25_dev_notifier);
2009
2010	dev_remove_pack(&ax25_packet_type);
2011
2012	sock_unregister(PF_AX25);
2013	proto_unregister(&ax25_proto);
2014
2015	ax25_rt_free();
2016	ax25_uid_free();
2017	ax25_dev_free();
2018}
2019module_exit(ax25_exit);