[linux-2.6-block.git] / net / atm / svc.c

// SPDX-License-Identifier: GPL-2.0
/* net/atm/svc.c - ATM SVC sockets */

/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */

#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__

#include <linux/string.h>
#include <linux/net.h>		/* struct socket, struct proto_ops */
#include <linux/errno.h>	/* error codes */
#include <linux/kernel.h>	/* printk */
#include <linux/skbuff.h>
#include <linux/wait.h>
#include <linux/sched/signal.h>
#include <linux/fcntl.h>	/* O_NONBLOCK */
#include <linux/init.h>
#include <linux/atm.h>		/* ATM stuff */
#include <linux/atmsap.h>
#include <linux/atmsvc.h>
#include <linux/atmdev.h>
#include <linux/bitops.h>
#include <net/sock.h>		/* for sock_no_* */
#include <linux/uaccess.h>
#include <linux/export.h>

#include "resources.h"
#include "common.h"		/* common for PVCs and SVCs */
#include "signaling.h"
#include "addr.h"

#ifdef CONFIG_COMPAT
/* It actually takes struct sockaddr_atmsvc, not struct atm_iobuf */
#define COMPAT_ATM_ADDPARTY _IOW('a', ATMIOC_SPECIAL + 4, struct compat_atm_iobuf)
#endif

static int svc_create(struct net *net, struct socket *sock, int protocol,
		      int kern);

/*
 * Note: since all this is still nicely synchronized with the signaling demon,
 *       there's no need to protect sleep loops with clis. If signaling is
 *       moved into the kernel, that would change.
 */


static int svc_shutdown(struct socket *sock, int how)
{
	return 0;
}

static void svc_disconnect(struct atm_vcc *vcc)
{
	DEFINE_WAIT(wait);
	struct sk_buff *skb;
	struct sock *sk = sk_atm(vcc);

	pr_debug("%p\n", vcc);
	if (test_bit(ATM_VF_REGIS, &vcc->flags)) {
		sigd_enq(vcc, as_close, NULL, NULL, NULL);
		for (;;) {
			prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
			if (test_bit(ATM_VF_RELEASED, &vcc->flags) || !sigd)
				break;
			schedule();
		}
		finish_wait(sk_sleep(sk), &wait);
	}
	/* beware - socket is still in use by atmsigd until the last
	   as_indicate has been answered */
	while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
		atm_return(vcc, skb->truesize);
		pr_debug("LISTEN REL\n");
		sigd_enq2(NULL, as_reject, vcc, NULL, NULL, &vcc->qos, 0);
		dev_kfree_skb(skb);
	}
	clear_bit(ATM_VF_REGIS, &vcc->flags);
	/* ... may retry later */
}

static int svc_release(struct socket *sock)
{
	struct sock *sk = sock->sk;
	struct atm_vcc *vcc;

	if (sk) {
		vcc = ATM_SD(sock);
		pr_debug("%p\n", vcc);
		clear_bit(ATM_VF_READY, &vcc->flags);
		/*
		 * VCC pointer is used as a reference,
		 * so we must not free it (thereby subjecting it to re-use)
		 * before all pending connections are closed
		 */
		svc_disconnect(vcc);
		vcc_release(sock);
	}
	return 0;
}

static int svc_bind(struct socket *sock, struct sockaddr *sockaddr,
		    int sockaddr_len)
{
	DEFINE_WAIT(wait);
	struct sock *sk = sock->sk;
	struct sockaddr_atmsvc *addr;
	struct atm_vcc *vcc;
	int error;

	if (sockaddr_len != sizeof(struct sockaddr_atmsvc))
		return -EINVAL;
	lock_sock(sk);
	if (sock->state == SS_CONNECTED) {
		error = -EISCONN;
		goto out;
	}
	if (sock->state != SS_UNCONNECTED) {
		error = -EINVAL;
		goto out;
	}
	vcc = ATM_SD(sock);
	addr = (struct sockaddr_atmsvc *) sockaddr;
	if (addr->sas_family != AF_ATMSVC) {
		error = -EAFNOSUPPORT;
		goto out;
	}
	clear_bit(ATM_VF_BOUND, &vcc->flags);
	    /* failing rebind will kill old binding */
	/* @@@ check memory (de)allocation on rebind */
	if (!test_bit(ATM_VF_HASQOS, &vcc->flags)) {
		error = -EBADFD;
		goto out;
	}
	vcc->local = *addr;
	set_bit(ATM_VF_WAITING, &vcc->flags);
	sigd_enq(vcc, as_bind, NULL, NULL, &vcc->local);
	for (;;) {
		prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
		if (!test_bit(ATM_VF_WAITING, &vcc->flags) || !sigd)
			break;
		schedule();
	}
	finish_wait(sk_sleep(sk), &wait);
	clear_bit(ATM_VF_REGIS, &vcc->flags); /* doesn't count */
	if (!sigd) {
		error = -EUNATCH;
		goto out;
	}
	if (!sk->sk_err)
		set_bit(ATM_VF_BOUND, &vcc->flags);
	error = -sk->sk_err;
out:
	release_sock(sk);
	return error;
}

static int svc_connect(struct socket *sock, struct sockaddr *sockaddr,
		       int sockaddr_len, int flags)
{
	DEFINE_WAIT(wait);
	struct sock *sk = sock->sk;
	struct sockaddr_atmsvc *addr;
	struct atm_vcc *vcc = ATM_SD(sock);
	int error;

	pr_debug("%p\n", vcc);
	lock_sock(sk);
	if (sockaddr_len != sizeof(struct sockaddr_atmsvc)) {
		error = -EINVAL;
		goto out;
	}

	switch (sock->state) {
	default:
		error = -EINVAL;
		goto out;
	case SS_CONNECTED:
		error = -EISCONN;
		goto out;
	case SS_CONNECTING:
		if (test_bit(ATM_VF_WAITING, &vcc->flags)) {
			error = -EALREADY;
			goto out;
		}
		sock->state = SS_UNCONNECTED;
		if (sk->sk_err) {
			error = -sk->sk_err;
			goto out;
		}
		break;
	case SS_UNCONNECTED:
		addr = (struct sockaddr_atmsvc *) sockaddr;
		if (addr->sas_family != AF_ATMSVC) {
			error = -EAFNOSUPPORT;
			goto out;
		}
		if (!test_bit(ATM_VF_HASQOS, &vcc->flags)) {
			error = -EBADFD;
			goto out;
		}
		if (vcc->qos.txtp.traffic_class == ATM_ANYCLASS ||
		    vcc->qos.rxtp.traffic_class == ATM_ANYCLASS) {
			error = -EINVAL;
			goto out;
		}
		if (!vcc->qos.txtp.traffic_class &&
		    !vcc->qos.rxtp.traffic_class) {
			error = -EINVAL;
			goto out;
		}
		vcc->remote = *addr;
		set_bit(ATM_VF_WAITING, &vcc->flags);
		sigd_enq(vcc, as_connect, NULL, NULL, &vcc->remote);
		if (flags & O_NONBLOCK) {
			sock->state = SS_CONNECTING;
			error = -EINPROGRESS;
			goto out;
		}
		error = 0;
		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
		while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
			schedule();
			if (!signal_pending(current)) {
				prepare_to_wait(sk_sleep(sk), &wait,
						TASK_INTERRUPTIBLE);
				continue;
			}
			pr_debug("*ABORT*\n");
			/*
			 * This is tricky:
			 *   Kernel ---close--> Demon
			 *   Kernel <--close--- Demon
			 * or
			 *   Kernel ---close--> Demon
			 *   Kernel <--error--- Demon
			 * or
			 *   Kernel ---close--> Demon
			 *   Kernel <--okay---- Demon
			 *   Kernel <--close--- Demon
			 */
			sigd_enq(vcc, as_close, NULL, NULL, NULL);
			while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
				prepare_to_wait(sk_sleep(sk), &wait,
						TASK_INTERRUPTIBLE);
				schedule();
			}
			if (!sk->sk_err)
				while (!test_bit(ATM_VF_RELEASED, &vcc->flags) &&
				       sigd) {
					prepare_to_wait(sk_sleep(sk), &wait,
							TASK_INTERRUPTIBLE);
					schedule();
				}
			clear_bit(ATM_VF_REGIS, &vcc->flags);
			clear_bit(ATM_VF_RELEASED, &vcc->flags);
			clear_bit(ATM_VF_CLOSE, &vcc->flags);
			    /* we're gone now but may connect later */
			error = -EINTR;
			break;
		}
		finish_wait(sk_sleep(sk), &wait);
		if (error)
			goto out;
		if (!sigd) {
			error = -EUNATCH;
			goto out;
		}
		if (sk->sk_err) {
			error = -sk->sk_err;
			goto out;
		}
	}

	vcc->qos.txtp.max_pcr = SELECT_TOP_PCR(vcc->qos.txtp);
	vcc->qos.txtp.pcr = 0;
	vcc->qos.txtp.min_pcr = 0;

	error = vcc_connect(sock, vcc->itf, vcc->vpi, vcc->vci);
	if (!error)
		sock->state = SS_CONNECTED;
	else
		(void)svc_disconnect(vcc);
out:
	release_sock(sk);
	return error;
}

static int svc_listen(struct socket *sock, int backlog)
{
	DEFINE_WAIT(wait);
	struct sock *sk = sock->sk;
	struct atm_vcc *vcc = ATM_SD(sock);
	int error;

	pr_debug("%p\n", vcc);
	lock_sock(sk);
	/* let server handle listen on unbound sockets */
	if (test_bit(ATM_VF_SESSION, &vcc->flags)) {
		error = -EINVAL;
		goto out;
	}
	if (test_bit(ATM_VF_LISTEN, &vcc->flags)) {
		error = -EADDRINUSE;
		goto out;
	}
	set_bit(ATM_VF_WAITING, &vcc->flags);
	sigd_enq(vcc, as_listen, NULL, NULL, &vcc->local);
	for (;;) {
		prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
		if (!test_bit(ATM_VF_WAITING, &vcc->flags) || !sigd)
			break;
		schedule();
	}
	finish_wait(sk_sleep(sk), &wait);
	if (!sigd) {
		error = -EUNATCH;
		goto out;
	}
	set_bit(ATM_VF_LISTEN, &vcc->flags);
	vcc_insert_socket(sk);
	sk->sk_max_ack_backlog = backlog > 0 ? backlog : ATM_BACKLOG_DEFAULT;
	error = -sk->sk_err;
out:
	release_sock(sk);
	return error;
}

static int svc_accept(struct socket *sock, struct socket *newsock,
		      struct proto_accept_arg *arg)
{
	struct sock *sk = sock->sk;
	struct sk_buff *skb;
	struct atmsvc_msg *msg;
	struct atm_vcc *old_vcc = ATM_SD(sock);
	struct atm_vcc *new_vcc;
	int error;

	lock_sock(sk);

	error = svc_create(sock_net(sk), newsock, 0, arg->kern);
	if (error)
		goto out;

	new_vcc = ATM_SD(newsock);

	pr_debug("%p -> %p\n", old_vcc, new_vcc);
	while (1) {
		DEFINE_WAIT(wait);

		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
		while (!(skb = skb_dequeue(&sk->sk_receive_queue)) &&
		       sigd) {
			if (test_bit(ATM_VF_RELEASED, &old_vcc->flags))
				break;
			if (test_bit(ATM_VF_CLOSE, &old_vcc->flags)) {
				error = -sk->sk_err;
				break;
			}
			if (arg->flags & O_NONBLOCK) {
				error = -EAGAIN;
				break;
			}
			release_sock(sk);
			schedule();
			lock_sock(sk);
			if (signal_pending(current)) {
				error = -ERESTARTSYS;
				break;
			}
			prepare_to_wait(sk_sleep(sk), &wait,
					TASK_INTERRUPTIBLE);
		}
		finish_wait(sk_sleep(sk), &wait);
		if (error)
			goto out;
		if (!skb) {
			error = -EUNATCH;
			goto out;
		}
		msg = (struct atmsvc_msg *)skb->data;
		new_vcc->qos = msg->qos;
		set_bit(ATM_VF_HASQOS, &new_vcc->flags);
		new_vcc->remote = msg->svc;
		new_vcc->local = msg->local;
		new_vcc->sap = msg->sap;
		error = vcc_connect(newsock, msg->pvc.sap_addr.itf,
				    msg->pvc.sap_addr.vpi,
				    msg->pvc.sap_addr.vci);
		dev_kfree_skb(skb);
		sk_acceptq_removed(sk);
		if (error) {
			sigd_enq2(NULL, as_reject, old_vcc, NULL, NULL,
				  &old_vcc->qos, error);
			error = error == -EAGAIN ? -EBUSY : error;
			goto out;
		}
		/* wait should be short, so we ignore the non-blocking flag */
		set_bit(ATM_VF_WAITING, &new_vcc->flags);
		sigd_enq(new_vcc, as_accept, old_vcc, NULL, NULL);
		for (;;) {
			prepare_to_wait(sk_sleep(sk_atm(new_vcc)), &wait,
					TASK_UNINTERRUPTIBLE);
			if (!test_bit(ATM_VF_WAITING, &new_vcc->flags) || !sigd)
				break;
			release_sock(sk);
			schedule();
			lock_sock(sk);
		}
		finish_wait(sk_sleep(sk_atm(new_vcc)), &wait);
		if (!sigd) {
			error = -EUNATCH;
			goto out;
		}
		if (!sk_atm(new_vcc)->sk_err)
			break;
		if (sk_atm(new_vcc)->sk_err != ERESTARTSYS) {
			error = -sk_atm(new_vcc)->sk_err;
			goto out;
		}
	}
	newsock->state = SS_CONNECTED;
out:
	release_sock(sk);
	return error;
}

static int svc_getname(struct socket *sock, struct sockaddr *sockaddr,
		       int peer)
{
	struct sockaddr_atmsvc *addr;

	addr = (struct sockaddr_atmsvc *) sockaddr;
	memcpy(addr, peer ? &ATM_SD(sock)->remote : &ATM_SD(sock)->local,
	       sizeof(struct sockaddr_atmsvc));
	return sizeof(struct sockaddr_atmsvc);
}

int svc_change_qos(struct atm_vcc *vcc, struct atm_qos *qos)
{
	struct sock *sk = sk_atm(vcc);
	DEFINE_WAIT(wait);

	set_bit(ATM_VF_WAITING, &vcc->flags);
	sigd_enq2(vcc, as_modify, NULL, NULL, &vcc->local, qos, 0);
	for (;;) {
		prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
		if (!test_bit(ATM_VF_WAITING, &vcc->flags) ||
		    test_bit(ATM_VF_RELEASED, &vcc->flags) || !sigd) {
			break;
		}
		schedule();
	}
	finish_wait(sk_sleep(sk), &wait);
	if (!sigd)
		return -EUNATCH;
	return -sk->sk_err;
}

static int svc_setsockopt(struct socket *sock, int level, int optname,
			  sockptr_t optval, unsigned int optlen)
{
	struct sock *sk = sock->sk;
	struct atm_vcc *vcc = ATM_SD(sock);
	int value, error = 0;

	lock_sock(sk);
	switch (optname) {
	case SO_ATMSAP:
		if (level != SOL_ATM || optlen != sizeof(struct atm_sap)) {
			error = -EINVAL;
			goto out;
		}
		if (copy_from_sockptr(&vcc->sap, optval, optlen)) {
			error = -EFAULT;
			goto out;
		}
		set_bit(ATM_VF_HASSAP, &vcc->flags);
		break;
	case SO_MULTIPOINT:
		if (level != SOL_ATM || optlen != sizeof(int)) {
			error = -EINVAL;
			goto out;
		}
		if (copy_from_sockptr(&value, optval, sizeof(int))) {
			error = -EFAULT;
			goto out;
		}
		if (value == 1)
			set_bit(ATM_VF_SESSION, &vcc->flags);
		else if (value == 0)
			clear_bit(ATM_VF_SESSION, &vcc->flags);
		else
			error = -EINVAL;
		break;
	default:
		error = vcc_setsockopt(sock, level, optname, optval, optlen);
	}

out:
	release_sock(sk);
	return error;
}

static int svc_getsockopt(struct socket *sock, int level, int optname,
			  char __user *optval, int __user *optlen)
{
	struct sock *sk = sock->sk;
	int error = 0, len;

	lock_sock(sk);
	if (!__SO_LEVEL_MATCH(optname, level) || optname != SO_ATMSAP) {
		error = vcc_getsockopt(sock, level, optname, optval, optlen);
		goto out;
	}
	if (get_user(len, optlen)) {
		error = -EFAULT;
		goto out;
	}
	if (len != sizeof(struct atm_sap)) {
		error = -EINVAL;
		goto out;
	}
	if (copy_to_user(optval, &ATM_SD(sock)->sap, sizeof(struct atm_sap))) {
		error = -EFAULT;
		goto out;
	}
out:
	release_sock(sk);
	return error;
}

static int svc_addparty(struct socket *sock, struct sockaddr *sockaddr,
			int sockaddr_len, int flags)
{
	DEFINE_WAIT(wait);
	struct sock *sk = sock->sk;
	struct atm_vcc *vcc = ATM_SD(sock);
	int error;

	lock_sock(sk);
	set_bit(ATM_VF_WAITING, &vcc->flags);
	sigd_enq(vcc, as_addparty, NULL, NULL,
		 (struct sockaddr_atmsvc *) sockaddr);
	if (flags & O_NONBLOCK) {
		error = -EINPROGRESS;
		goto out;
	}
	pr_debug("added wait queue\n");
	for (;;) {
		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
		if (!test_bit(ATM_VF_WAITING, &vcc->flags) || !sigd)
			break;
		schedule();
	}
	finish_wait(sk_sleep(sk), &wait);
	error = -xchg(&sk->sk_err_soft, 0);
out:
	release_sock(sk);
	return error;
}

static int svc_dropparty(struct socket *sock, int ep_ref)
{
	DEFINE_WAIT(wait);
	struct sock *sk = sock->sk;
	struct atm_vcc *vcc = ATM_SD(sock);
	int error;

	lock_sock(sk);
	set_bit(ATM_VF_WAITING, &vcc->flags);
	sigd_enq2(vcc, as_dropparty, NULL, NULL, NULL, NULL, ep_ref);
	for (;;) {
		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
		if (!test_bit(ATM_VF_WAITING, &vcc->flags) || !sigd)
			break;
		schedule();
	}
	finish_wait(sk_sleep(sk), &wait);
	if (!sigd) {
		error = -EUNATCH;
		goto out;
	}
	error = -xchg(&sk->sk_err_soft, 0);
out:
	release_sock(sk);
	return error;
}

static int svc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	int error, ep_ref;
	struct sockaddr_atmsvc sa;
	struct atm_vcc *vcc = ATM_SD(sock);

	switch (cmd) {
	case ATM_ADDPARTY:
		if (!test_bit(ATM_VF_SESSION, &vcc->flags))
			return -EINVAL;
		if (copy_from_user(&sa, (void __user *) arg, sizeof(sa)))
			return -EFAULT;
		error = svc_addparty(sock, (struct sockaddr *)&sa, sizeof(sa),
				     0);
		break;
	case ATM_DROPPARTY:
		if (!test_bit(ATM_VF_SESSION, &vcc->flags))
			return -EINVAL;
		if (copy_from_user(&ep_ref, (void __user *) arg, sizeof(int)))
			return -EFAULT;
		error = svc_dropparty(sock, ep_ref);
		break;
	default:
		error = vcc_ioctl(sock, cmd, arg);
	}

	return error;
}

#ifdef CONFIG_COMPAT
static int svc_compat_ioctl(struct socket *sock, unsigned int cmd,
			    unsigned long arg)
{
	/* The definition of ATM_ADDPARTY uses the size of struct atm_iobuf.
	   But actually it takes a struct sockaddr_atmsvc, which doesn't need
	   compat handling. So all we have to do is fix up cmd... */
	if (cmd == COMPAT_ATM_ADDPARTY)
		cmd = ATM_ADDPARTY;

	if (cmd == ATM_ADDPARTY || cmd == ATM_DROPPARTY)
		return svc_ioctl(sock, cmd, arg);
	else
		return vcc_compat_ioctl(sock, cmd, arg);
}
#endif /* CONFIG_COMPAT */

static const struct proto_ops svc_proto_ops = {
	.family =	PF_ATMSVC,
	.owner =	THIS_MODULE,

	.release =	svc_release,
	.bind =		svc_bind,
	.connect =	svc_connect,
	.socketpair =	sock_no_socketpair,
	.accept =	svc_accept,
	.getname =	svc_getname,
	.poll =		vcc_poll,
	.ioctl =	svc_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl =	svc_compat_ioctl,
#endif
	.gettstamp =	sock_gettstamp,
	.listen =	svc_listen,
	.shutdown =	svc_shutdown,
	.setsockopt =	svc_setsockopt,
	.getsockopt =	svc_getsockopt,
	.sendmsg =	vcc_sendmsg,
	.recvmsg =	vcc_recvmsg,
	.mmap =		sock_no_mmap,
};


static int svc_create(struct net *net, struct socket *sock, int protocol,
		      int kern)
{
	int error;

	if (!net_eq(net, &init_net))
		return -EAFNOSUPPORT;

	sock->ops = &svc_proto_ops;
	error = vcc_create(net, sock, protocol, AF_ATMSVC, kern);
	if (error)
		return error;
	ATM_SD(sock)->local.sas_family = AF_ATMSVC;
	ATM_SD(sock)->remote.sas_family = AF_ATMSVC;
	return 0;
}

static const struct net_proto_family svc_family_ops = {
	.family = PF_ATMSVC,
	.create = svc_create,
	.owner = THIS_MODULE,
};


/*
 *	Initialize the ATM SVC protocol family
 */

int __init atmsvc_init(void)
{
	return sock_register(&svc_family_ops);
}

void atmsvc_exit(void)
{
	sock_unregister(PF_ATMSVC);
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4 LT	2	/* net/atm/svc.c - ATM SVC sockets */
	3
	4	/* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
	5
99824461	6	#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
1da177e4 LT	7
	8	#include <linux/string.h>
	9	#include <linux/net.h> /* struct socket, struct proto_ops */
	10	#include <linux/errno.h> /* error codes */
	11	#include <linux/kernel.h> /* printk */
	12	#include <linux/skbuff.h>
	13	#include <linux/wait.h>
174cd4b1	14	#include <linux/sched/signal.h>
1da177e4 LT	15	#include <linux/fcntl.h> /* O_NONBLOCK */
	16	#include <linux/init.h>
	17	#include <linux/atm.h> /* ATM stuff */
	18	#include <linux/atmsap.h>
	19	#include <linux/atmsvc.h>
	20	#include <linux/atmdev.h>
	21	#include <linux/bitops.h>
	22	#include <net/sock.h> /* for sock_no_* */
b7d9371b	23	#include <linux/uaccess.h>
bc3b2d7f	24	#include <linux/export.h>
1da177e4 LT	25
	26	#include "resources.h"
	27	#include "common.h" /* common for PVCs and SVCs */
	28	#include "signaling.h"
	29	#include "addr.h"
	30
5fe5a758 PD	31	#ifdef CONFIG_COMPAT
	32	/* It actually takes struct sockaddr_atmsvc, not struct atm_iobuf */
	33	#define COMPAT_ATM_ADDPARTY _IOW('a', ATMIOC_SPECIAL + 4, struct compat_atm_iobuf)
	34	#endif
	35
b7d9371b JP	36	static int svc_create(struct net net, struct socket sock, int protocol,
b7d9371b JP	37	int kern);
1da177e4	38
1da177e4 LT	39	/*
	40	* Note: since all this is still nicely synchronized with the signaling demon,
	41	* there's no need to protect sleep loops with clis. If signaling is
	42	* moved into the kernel, that would change.
	43	*/
	44
	45
b7d9371b	46	static int svc_shutdown(struct socket *sock, int how)
1da177e4 LT	47	{
	48	return 0;
	49	}
	50
1da177e4 LT	51	static void svc_disconnect(struct atm_vcc *vcc)
	52	{
	53	DEFINE_WAIT(wait);
	54	struct sk_buff *skb;
	55	struct sock *sk = sk_atm(vcc);
	56
b7d9371b JP	57	pr_debug("%p\n", vcc);
b7d9371b JP	58	if (test_bit(ATM_VF_REGIS, &vcc->flags)) {
b7d9371b	59	sigd_enq(vcc, as_close, NULL, NULL, NULL);
de713b57 C	60	for (;;) {
	61	prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
	62	if (test_bit(ATM_VF_RELEASED, &vcc->flags) \|\| !sigd)
	63	break;
1da177e4	64	schedule();
1da177e4	65	}
aa395145	66	finish_wait(sk_sleep(sk), &wait);
1da177e4 LT	67	}
	68	/* beware - socket is still in use by atmsigd until the last
	69	as_indicate has been answered */
	70	while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
	71	atm_return(vcc, skb->truesize);
52240062	72	pr_debug("LISTEN REL\n");
b7d9371b	73	sigd_enq2(NULL, as_reject, vcc, NULL, NULL, &vcc->qos, 0);
1da177e4 LT	74	dev_kfree_skb(skb);
	75	}
	76	clear_bit(ATM_VF_REGIS, &vcc->flags);
	77	/* ... may retry later */
	78	}
	79
1da177e4 LT	80	static int svc_release(struct socket *sock)
	81	{
	82	struct sock *sk = sock->sk;
	83	struct atm_vcc *vcc;
	84
b7d9371b	85	if (sk) {
1da177e4	86	vcc = ATM_SD(sock);
99824461	87	pr_debug("%p\n", vcc);
1da177e4	88	clear_bit(ATM_VF_READY, &vcc->flags);
b7d9371b JP	89	/*
	90	* VCC pointer is used as a reference,
	91	* so we must not free it (thereby subjecting it to re-use)
	92	* before all pending connections are closed
	93	*/
1da177e4 LT	94	svc_disconnect(vcc);
	95	vcc_release(sock);
	96	}
	97	return 0;
	98	}
	99
b7d9371b JP	100	static int svc_bind(struct socket sock, struct sockaddr sockaddr,
b7d9371b JP	101	int sockaddr_len)
1da177e4 LT	102	{
	103	DEFINE_WAIT(wait);
	104	struct sock *sk = sock->sk;
	105	struct sockaddr_atmsvc *addr;
	106	struct atm_vcc *vcc;
	107	int error;
	108
	109	if (sockaddr_len != sizeof(struct sockaddr_atmsvc))
	110	return -EINVAL;
	111	lock_sock(sk);
	112	if (sock->state == SS_CONNECTED) {
	113	error = -EISCONN;
	114	goto out;
	115	}
	116	if (sock->state != SS_UNCONNECTED) {
	117	error = -EINVAL;
	118	goto out;
	119	}
	120	vcc = ATM_SD(sock);
1da177e4 LT	121	addr = (struct sockaddr_atmsvc *) sockaddr;
	122	if (addr->sas_family != AF_ATMSVC) {
	123	error = -EAFNOSUPPORT;
	124	goto out;
	125	}
b7d9371b	126	clear_bit(ATM_VF_BOUND, &vcc->flags);
1da177e4 LT	127	/* failing rebind will kill old binding */
1da177e4 LT	128	/* @@@ check memory (de)allocation on rebind */
b7d9371b	129	if (!test_bit(ATM_VF_HASQOS, &vcc->flags)) {
1da177e4 LT	130	error = -EBADFD;
	131	goto out;
	132	}
	133	vcc->local = *addr;
	134	set_bit(ATM_VF_WAITING, &vcc->flags);
b7d9371b	135	sigd_enq(vcc, as_bind, NULL, NULL, &vcc->local);
de713b57	136	for (;;) {
aa395145	137	prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
de713b57 C	138	if (!test_bit(ATM_VF_WAITING, &vcc->flags) \|\| !sigd)
	139	break;
	140	schedule();
1da177e4	141	}
aa395145	142	finish_wait(sk_sleep(sk), &wait);
b7d9371b	143	clear_bit(ATM_VF_REGIS, &vcc->flags); /* doesn't count */
1da177e4 LT	144	if (!sigd) {
	145	error = -EUNATCH;
	146	goto out;
	147	}
f7d57453	148	if (!sk->sk_err)
b7d9371b	149	set_bit(ATM_VF_BOUND, &vcc->flags);
1da177e4 LT	150	error = -sk->sk_err;
	151	out:
	152	release_sock(sk);
	153	return error;
	154	}
	155
b7d9371b JP	156	static int svc_connect(struct socket sock, struct sockaddr sockaddr,
b7d9371b JP	157	int sockaddr_len, int flags)
1da177e4 LT	158	{
	159	DEFINE_WAIT(wait);
	160	struct sock *sk = sock->sk;
	161	struct sockaddr_atmsvc *addr;
	162	struct atm_vcc *vcc = ATM_SD(sock);
	163	int error;
	164
b7d9371b	165	pr_debug("%p\n", vcc);
1da177e4 LT	166	lock_sock(sk);
	167	if (sockaddr_len != sizeof(struct sockaddr_atmsvc)) {
	168	error = -EINVAL;
	169	goto out;
	170	}
	171
	172	switch (sock->state) {
	173	default:
	174	error = -EINVAL;
	175	goto out;
	176	case SS_CONNECTED:
	177	error = -EISCONN;
	178	goto out;
	179	case SS_CONNECTING:
	180	if (test_bit(ATM_VF_WAITING, &vcc->flags)) {
	181	error = -EALREADY;
	182	goto out;
	183	}
	184	sock->state = SS_UNCONNECTED;
	185	if (sk->sk_err) {
	186	error = -sk->sk_err;
	187	goto out;
	188	}
	189	break;
	190	case SS_UNCONNECTED:
	191	addr = (struct sockaddr_atmsvc *) sockaddr;
	192	if (addr->sas_family != AF_ATMSVC) {
	193	error = -EAFNOSUPPORT;
	194	goto out;
	195	}
	196	if (!test_bit(ATM_VF_HASQOS, &vcc->flags)) {
	197	error = -EBADFD;
	198	goto out;
	199	}
	200	if (vcc->qos.txtp.traffic_class == ATM_ANYCLASS \|\|
	201	vcc->qos.rxtp.traffic_class == ATM_ANYCLASS) {
	202	error = -EINVAL;
	203	goto out;
	204	}
	205	if (!vcc->qos.txtp.traffic_class &&
	206	!vcc->qos.rxtp.traffic_class) {
	207	error = -EINVAL;
	208	goto out;
	209	}
	210	vcc->remote = *addr;
	211	set_bit(ATM_VF_WAITING, &vcc->flags);
b7d9371b	212	sigd_enq(vcc, as_connect, NULL, NULL, &vcc->remote);
1da177e4	213	if (flags & O_NONBLOCK) {
1da177e4 LT	214	sock->state = SS_CONNECTING;
	215	error = -EINPROGRESS;
	216	goto out;
	217	}
	218	error = 0;
de713b57	219	prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1da177e4 LT	220	while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
	221	schedule();
	222	if (!signal_pending(current)) {
aa395145	223	prepare_to_wait(sk_sleep(sk), &wait,
b7d9371b	224	TASK_INTERRUPTIBLE);
1da177e4 LT	225	continue;
1da177e4 LT	226	}
52240062	227	pr_debug("ABORT\n");
1da177e4 LT	228	/*
	229	* This is tricky:
	230	* Kernel ---close--> Demon
	231	* Kernel <--close--- Demon
f7d57453	232	* or
1da177e4 LT	233	* Kernel ---close--> Demon
	234	* Kernel <--error--- Demon
	235	* or
	236	* Kernel ---close--> Demon
	237	* Kernel <--okay---- Demon
	238	* Kernel <--close--- Demon
	239	*/
b7d9371b	240	sigd_enq(vcc, as_close, NULL, NULL, NULL);
1da177e4	241	while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
aa395145	242	prepare_to_wait(sk_sleep(sk), &wait,
b7d9371b	243	TASK_INTERRUPTIBLE);
1da177e4 LT	244	schedule();
	245	}
	246	if (!sk->sk_err)
b7d9371b JP	247	while (!test_bit(ATM_VF_RELEASED, &vcc->flags) &&
b7d9371b JP	248	sigd) {
aa395145	249	prepare_to_wait(sk_sleep(sk), &wait,
b7d9371b	250	TASK_INTERRUPTIBLE);
1da177e4 LT	251	schedule();
1da177e4 LT	252	}
b7d9371b JP	253	clear_bit(ATM_VF_REGIS, &vcc->flags);
	254	clear_bit(ATM_VF_RELEASED, &vcc->flags);
	255	clear_bit(ATM_VF_CLOSE, &vcc->flags);
1da177e4 LT	256	/* we're gone now but may connect later */
	257	error = -EINTR;
	258	break;
	259	}
aa395145	260	finish_wait(sk_sleep(sk), &wait);
1da177e4 LT	261	if (error)
	262	goto out;
	263	if (!sigd) {
	264	error = -EUNATCH;
	265	goto out;
	266	}
	267	if (sk->sk_err) {
	268	error = -sk->sk_err;
	269	goto out;
	270	}
	271	}
391296c9	272
1da177e4 LT	273	vcc->qos.txtp.max_pcr = SELECT_TOP_PCR(vcc->qos.txtp);
	274	vcc->qos.txtp.pcr = 0;
	275	vcc->qos.txtp.min_pcr = 0;
391296c9	276
b7d9371b JP	277	error = vcc_connect(sock, vcc->itf, vcc->vpi, vcc->vci);
b7d9371b JP	278	if (!error)
1da177e4 LT	279	sock->state = SS_CONNECTED;
1da177e4 LT	280	else
b7d9371b	281	(void)svc_disconnect(vcc);
1da177e4 LT	282	out:
	283	release_sock(sk);
	284	return error;
	285	}
	286
b7d9371b	287	static int svc_listen(struct socket *sock, int backlog)
1da177e4 LT	288	{
	289	DEFINE_WAIT(wait);
	290	struct sock *sk = sock->sk;
	291	struct atm_vcc *vcc = ATM_SD(sock);
	292	int error;
	293
99824461	294	pr_debug("%p\n", vcc);
1da177e4 LT	295	lock_sock(sk);
1da177e4 LT	296	/* let server handle listen on unbound sockets */
b7d9371b	297	if (test_bit(ATM_VF_SESSION, &vcc->flags)) {
1da177e4 LT	298	error = -EINVAL;
	299	goto out;
	300	}
17b24b3c CW	301	if (test_bit(ATM_VF_LISTEN, &vcc->flags)) {
	302	error = -EADDRINUSE;
	303	goto out;
b7d9371b	304	}
1da177e4	305	set_bit(ATM_VF_WAITING, &vcc->flags);
b7d9371b	306	sigd_enq(vcc, as_listen, NULL, NULL, &vcc->local);
de713b57	307	for (;;) {
aa395145	308	prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
de713b57 C	309	if (!test_bit(ATM_VF_WAITING, &vcc->flags) \|\| !sigd)
	310	break;
	311	schedule();
1da177e4	312	}
aa395145	313	finish_wait(sk_sleep(sk), &wait);
1da177e4 LT	314	if (!sigd) {
	315	error = -EUNATCH;
	316	goto out;
	317	}
b7d9371b	318	set_bit(ATM_VF_LISTEN, &vcc->flags);
17b24b3c	319	vcc_insert_socket(sk);
1da177e4 LT	320	sk->sk_max_ack_backlog = backlog > 0 ? backlog : ATM_BACKLOG_DEFAULT;
	321	error = -sk->sk_err;
	322	out:
	323	release_sock(sk);
	324	return error;
	325	}
	326
92ef0fd5 JA	327	static int svc_accept(struct socket sock, struct socket newsock,
92ef0fd5 JA	328	struct proto_accept_arg *arg)
1da177e4 LT	329	{
	330	struct sock *sk = sock->sk;
	331	struct sk_buff *skb;
	332	struct atmsvc_msg *msg;
	333	struct atm_vcc *old_vcc = ATM_SD(sock);
	334	struct atm_vcc *new_vcc;
	335	int error;
	336
	337	lock_sock(sk);
	338
92ef0fd5	339	error = svc_create(sock_net(sk), newsock, 0, arg->kern);
1da177e4 LT	340	if (error)
	341	goto out;
	342
	343	new_vcc = ATM_SD(newsock);
	344
99824461	345	pr_debug("%p -> %p\n", old_vcc, new_vcc);
1da177e4 LT	346	while (1) {
	347	DEFINE_WAIT(wait);
	348
aa395145	349	prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1da177e4 LT	350	while (!(skb = skb_dequeue(&sk->sk_receive_queue)) &&
1da177e4 LT	351	sigd) {
b7d9371b JP	352	if (test_bit(ATM_VF_RELEASED, &old_vcc->flags))
	353	break;
	354	if (test_bit(ATM_VF_CLOSE, &old_vcc->flags)) {
1da177e4 LT	355	error = -sk->sk_err;
	356	break;
	357	}
92ef0fd5	358	if (arg->flags & O_NONBLOCK) {
1da177e4 LT	359	error = -EAGAIN;
	360	break;
	361	}
	362	release_sock(sk);
	363	schedule();
	364	lock_sock(sk);
	365	if (signal_pending(current)) {
	366	error = -ERESTARTSYS;
	367	break;
	368	}
aa395145	369	prepare_to_wait(sk_sleep(sk), &wait,
b7d9371b	370	TASK_INTERRUPTIBLE);
1da177e4	371	}
aa395145	372	finish_wait(sk_sleep(sk), &wait);
1da177e4 LT	373	if (error)
	374	goto out;
	375	if (!skb) {
	376	error = -EUNATCH;
	377	goto out;
	378	}
b7d9371b	379	msg = (struct atmsvc_msg *)skb->data;
1da177e4	380	new_vcc->qos = msg->qos;
b7d9371b	381	set_bit(ATM_VF_HASQOS, &new_vcc->flags);
1da177e4 LT	382	new_vcc->remote = msg->svc;
	383	new_vcc->local = msg->local;
	384	new_vcc->sap = msg->sap;
	385	error = vcc_connect(newsock, msg->pvc.sap_addr.itf,
b7d9371b JP	386	msg->pvc.sap_addr.vpi,
b7d9371b JP	387	msg->pvc.sap_addr.vci);
1da177e4	388	dev_kfree_skb(skb);
7976a11b	389	sk_acceptq_removed(sk);
1da177e4	390	if (error) {
b7d9371b JP	391	sigd_enq2(NULL, as_reject, old_vcc, NULL, NULL,
b7d9371b JP	392	&old_vcc->qos, error);
1da177e4 LT	393	error = error == -EAGAIN ? -EBUSY : error;
	394	goto out;
	395	}
	396	/* wait should be short, so we ignore the non-blocking flag */
	397	set_bit(ATM_VF_WAITING, &new_vcc->flags);
b7d9371b	398	sigd_enq(new_vcc, as_accept, old_vcc, NULL, NULL);
de713b57 C	399	for (;;) {
	400	prepare_to_wait(sk_sleep(sk_atm(new_vcc)), &wait,
	401	TASK_UNINTERRUPTIBLE);
	402	if (!test_bit(ATM_VF_WAITING, &new_vcc->flags) \|\| !sigd)
	403	break;
1da177e4 LT	404	release_sock(sk);
	405	schedule();
	406	lock_sock(sk);
1da177e4	407	}
aa395145	408	finish_wait(sk_sleep(sk_atm(new_vcc)), &wait);
1da177e4 LT	409	if (!sigd) {
	410	error = -EUNATCH;
	411	goto out;
	412	}
	413	if (!sk_atm(new_vcc)->sk_err)
	414	break;
	415	if (sk_atm(new_vcc)->sk_err != ERESTARTSYS) {
	416	error = -sk_atm(new_vcc)->sk_err;
	417	goto out;
	418	}
	419	}
	420	newsock->state = SS_CONNECTED;
	421	out:
	422	release_sock(sk);
	423	return error;
	424	}
	425
b7d9371b	426	static int svc_getname(struct socket sock, struct sockaddr sockaddr,
9b2c45d4	427	int peer)
1da177e4 LT	428	{
	429	struct sockaddr_atmsvc *addr;
	430
1da177e4	431	addr = (struct sockaddr_atmsvc *) sockaddr;
b7d9371b JP	432	memcpy(addr, peer ? &ATM_SD(sock)->remote : &ATM_SD(sock)->local,
b7d9371b JP	433	sizeof(struct sockaddr_atmsvc));
9b2c45d4	434	return sizeof(struct sockaddr_atmsvc);
1da177e4 LT	435	}
1da177e4 LT	436
b7d9371b	437	int svc_change_qos(struct atm_vcc vcc, struct atm_qos qos)
1da177e4 LT	438	{
	439	struct sock *sk = sk_atm(vcc);
	440	DEFINE_WAIT(wait);
	441
	442	set_bit(ATM_VF_WAITING, &vcc->flags);
b7d9371b	443	sigd_enq2(vcc, as_modify, NULL, NULL, &vcc->local, qos, 0);
de713b57	444	for (;;) {
aa395145	445	prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
de713b57 C	446	if (!test_bit(ATM_VF_WAITING, &vcc->flags) \|\|
	447	test_bit(ATM_VF_RELEASED, &vcc->flags) \|\| !sigd) {
	448	break;
	449	}
	450	schedule();
1da177e4	451	}
aa395145	452	finish_wait(sk_sleep(sk), &wait);
b7d9371b JP	453	if (!sigd)
b7d9371b JP	454	return -EUNATCH;
1da177e4 LT	455	return -sk->sk_err;
	456	}
	457
1da177e4	458	static int svc_setsockopt(struct socket *sock, int level, int optname,
a7b75c5a	459	sockptr_t optval, unsigned int optlen)
1da177e4 LT	460	{
	461	struct sock *sk = sock->sk;
	462	struct atm_vcc *vcc = ATM_SD(sock);
	463	int value, error = 0;
	464
	465	lock_sock(sk);
	466	switch (optname) {
b7d9371b JP	467	case SO_ATMSAP:
	468	if (level != SOL_ATM \|\| optlen != sizeof(struct atm_sap)) {
	469	error = -EINVAL;
	470	goto out;
	471	}
a7b75c5a	472	if (copy_from_sockptr(&vcc->sap, optval, optlen)) {
b7d9371b JP	473	error = -EFAULT;
	474	goto out;
	475	}
	476	set_bit(ATM_VF_HASSAP, &vcc->flags);
	477	break;
	478	case SO_MULTIPOINT:
	479	if (level != SOL_ATM \|\| optlen != sizeof(int)) {
	480	error = -EINVAL;
	481	goto out;
	482	}
a7b75c5a	483	if (copy_from_sockptr(&value, optval, sizeof(int))) {
b7d9371b JP	484	error = -EFAULT;
	485	goto out;
	486	}
	487	if (value == 1)
	488	set_bit(ATM_VF_SESSION, &vcc->flags);
	489	else if (value == 0)
	490	clear_bit(ATM_VF_SESSION, &vcc->flags);
	491	else
	492	error = -EINVAL;
	493	break;
	494	default:
	495	error = vcc_setsockopt(sock, level, optname, optval, optlen);
1da177e4 LT	496	}
	497
	498	out:
	499	release_sock(sk);
	500	return error;
	501	}
	502
b7d9371b JP	503	static int svc_getsockopt(struct socket *sock, int level, int optname,
b7d9371b JP	504	char __user optval, int __user optlen)
1da177e4 LT	505	{
	506	struct sock *sk = sock->sk;
	507	int error = 0, len;
	508
	509	lock_sock(sk);
	510	if (!__SO_LEVEL_MATCH(optname, level) \|\| optname != SO_ATMSAP) {
	511	error = vcc_getsockopt(sock, level, optname, optval, optlen);
	512	goto out;
	513	}
	514	if (get_user(len, optlen)) {
	515	error = -EFAULT;
	516	goto out;
	517	}
	518	if (len != sizeof(struct atm_sap)) {
	519	error = -EINVAL;
	520	goto out;
	521	}
	522	if (copy_to_user(optval, &ATM_SD(sock)->sap, sizeof(struct atm_sap))) {
	523	error = -EFAULT;
	524	goto out;
	525	}
	526	out:
	527	release_sock(sk);
	528	return error;
	529	}
	530
1da177e4 LT	531	static int svc_addparty(struct socket sock, struct sockaddr sockaddr,
	532	int sockaddr_len, int flags)
	533	{
	534	DEFINE_WAIT(wait);
	535	struct sock *sk = sock->sk;
	536	struct atm_vcc *vcc = ATM_SD(sock);
	537	int error;
	538
	539	lock_sock(sk);
	540	set_bit(ATM_VF_WAITING, &vcc->flags);
1da177e4	541	sigd_enq(vcc, as_addparty, NULL, NULL,
f7d57453	542	(struct sockaddr_atmsvc *) sockaddr);
1da177e4	543	if (flags & O_NONBLOCK) {
1da177e4 LT	544	error = -EINPROGRESS;
	545	goto out;
	546	}
99824461	547	pr_debug("added wait queue\n");
de713b57	548	for (;;) {
aa395145	549	prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
de713b57 C	550	if (!test_bit(ATM_VF_WAITING, &vcc->flags) \|\| !sigd)
	551	break;
	552	schedule();
1da177e4	553	}
aa395145	554	finish_wait(sk_sleep(sk), &wait);
c685293a	555	error = -xchg(&sk->sk_err_soft, 0);
1da177e4 LT	556	out:
	557	release_sock(sk);
	558	return error;
	559	}
	560
1da177e4 LT	561	static int svc_dropparty(struct socket *sock, int ep_ref)
	562	{
	563	DEFINE_WAIT(wait);
	564	struct sock *sk = sock->sk;
	565	struct atm_vcc *vcc = ATM_SD(sock);
	566	int error;
	567
	568	lock_sock(sk);
	569	set_bit(ATM_VF_WAITING, &vcc->flags);
1da177e4	570	sigd_enq2(vcc, as_dropparty, NULL, NULL, NULL, NULL, ep_ref);
de713b57	571	for (;;) {
aa395145	572	prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
de713b57 C	573	if (!test_bit(ATM_VF_WAITING, &vcc->flags) \|\| !sigd)
	574	break;
	575	schedule();
1da177e4	576	}
aa395145	577	finish_wait(sk_sleep(sk), &wait);
1da177e4 LT	578	if (!sigd) {
	579	error = -EUNATCH;
	580	goto out;
	581	}
c685293a	582	error = -xchg(&sk->sk_err_soft, 0);
1da177e4 LT	583	out:
	584	release_sock(sk);
	585	return error;
	586	}
	587
1da177e4 LT	588	static int svc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1da177e4 LT	589	{
f7d57453 YH	590	int error, ep_ref;
f7d57453 YH	591	struct sockaddr_atmsvc sa;
1da177e4	592	struct atm_vcc *vcc = ATM_SD(sock);
f7d57453	593
1da177e4	594	switch (cmd) {
b7d9371b JP	595	case ATM_ADDPARTY:
	596	if (!test_bit(ATM_VF_SESSION, &vcc->flags))
	597	return -EINVAL;
	598	if (copy_from_user(&sa, (void __user *) arg, sizeof(sa)))
	599	return -EFAULT;
	600	error = svc_addparty(sock, (struct sockaddr *)&sa, sizeof(sa),
	601	0);
	602	break;
	603	case ATM_DROPPARTY:
	604	if (!test_bit(ATM_VF_SESSION, &vcc->flags))
	605	return -EINVAL;
	606	if (copy_from_user(&ep_ref, (void __user *) arg, sizeof(int)))
	607	return -EFAULT;
	608	error = svc_dropparty(sock, ep_ref);
	609	break;
	610	default:
	611	error = vcc_ioctl(sock, cmd, arg);
1da177e4 LT	612	}
	613
	614	return error;
	615	}
	616
8865c418	617	#ifdef CONFIG_COMPAT
b7d9371b JP	618	static int svc_compat_ioctl(struct socket *sock, unsigned int cmd,
b7d9371b JP	619	unsigned long arg)
8865c418 DW	620	{
	621	/* The definition of ATM_ADDPARTY uses the size of struct atm_iobuf.
	622	But actually it takes a struct sockaddr_atmsvc, which doesn't need
	623	compat handling. So all we have to do is fix up cmd... */
	624	if (cmd == COMPAT_ATM_ADDPARTY)
	625	cmd = ATM_ADDPARTY;
	626
	627	if (cmd == ATM_ADDPARTY \|\| cmd == ATM_DROPPARTY)
	628	return svc_ioctl(sock, cmd, arg);
	629	else
	630	return vcc_compat_ioctl(sock, cmd, arg);
	631	}
	632	#endif /* CONFIG_COMPAT */
	633
90ddc4f0	634	static const struct proto_ops svc_proto_ops = {
1da177e4 LT	635	.family = PF_ATMSVC,
	636	.owner = THIS_MODULE,
	637
	638	.release = svc_release,
	639	.bind = svc_bind,
	640	.connect = svc_connect,
	641	.socketpair = sock_no_socketpair,
	642	.accept = svc_accept,
	643	.getname = svc_getname,
a11e1d43	644	.poll = vcc_poll,
1da177e4	645	.ioctl = svc_ioctl,
8865c418 DW	646	#ifdef CONFIG_COMPAT
	647	.compat_ioctl = svc_compat_ioctl,
	648	#endif
c7cbdbf2	649	.gettstamp = sock_gettstamp,
1da177e4 LT	650	.listen = svc_listen,
	651	.shutdown = svc_shutdown,
	652	.setsockopt = svc_setsockopt,
	653	.getsockopt = svc_getsockopt,
	654	.sendmsg = vcc_sendmsg,
	655	.recvmsg = vcc_recvmsg,
	656	.mmap = sock_no_mmap,
1da177e4 LT	657	};
	658
	659
3f378b68 EP	660	static int svc_create(struct net net, struct socket sock, int protocol,
3f378b68 EP	661	int kern)
1da177e4 LT	662	{
	663	int error;
	664
09ad9bc7	665	if (!net_eq(net, &init_net))
1b8d7ae4 EB	666	return -EAFNOSUPPORT;
1b8d7ae4 EB	667
1da177e4	668	sock->ops = &svc_proto_ops;
11aa9c28	669	error = vcc_create(net, sock, protocol, AF_ATMSVC, kern);
b7d9371b JP	670	if (error)
b7d9371b JP	671	return error;
1da177e4 LT	672	ATM_SD(sock)->local.sas_family = AF_ATMSVC;
	673	ATM_SD(sock)->remote.sas_family = AF_ATMSVC;
	674	return 0;
	675	}
	676
ec1b4cf7	677	static const struct net_proto_family svc_family_ops = {
1da177e4 LT	678	.family = PF_ATMSVC,
	679	.create = svc_create,
	680	.owner = THIS_MODULE,
	681	};
	682
	683
	684	/*
	685	* Initialize the ATM SVC protocol family
	686	*/
	687
	688	int __init atmsvc_init(void)
	689	{
	690	return sock_register(&svc_family_ops);
	691	}
	692
	693	void atmsvc_exit(void)
	694	{
	695	sock_unregister(PF_ATMSVC);
	696	}