[linux-block.git] / drivers / isdn / mISDN / socket.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 *
 * Author	Karsten Keil <kkeil@novell.com>
 *
 * Copyright 2008  by Karsten Keil <kkeil@novell.com>
 */

#include <linux/mISDNif.h>
#include <linux/slab.h>
#include <linux/export.h>
#include "core.h"

static u_int	*debug;

static struct proto mISDN_proto = {
	.name		= "misdn",
	.owner		= THIS_MODULE,
	.obj_size	= sizeof(struct mISDN_sock)
};

#define _pms(sk)	((struct mISDN_sock *)sk)

static struct mISDN_sock_list	data_sockets = {
	.lock = __RW_LOCK_UNLOCKED(data_sockets.lock)
};

static struct mISDN_sock_list	base_sockets = {
	.lock = __RW_LOCK_UNLOCKED(base_sockets.lock)
};

#define L2_HEADER_LEN	4

static inline struct sk_buff *
_l2_alloc_skb(unsigned int len, gfp_t gfp_mask)
{
	struct sk_buff  *skb;

	skb = alloc_skb(len + L2_HEADER_LEN, gfp_mask);
	if (likely(skb))
		skb_reserve(skb, L2_HEADER_LEN);
	return skb;
}

static void
mISDN_sock_link(struct mISDN_sock_list *l, struct sock *sk)
{
	write_lock_bh(&l->lock);
	sk_add_node(sk, &l->head);
	write_unlock_bh(&l->lock);
}

static void mISDN_sock_unlink(struct mISDN_sock_list *l, struct sock *sk)
{
	write_lock_bh(&l->lock);
	sk_del_node_init(sk);
	write_unlock_bh(&l->lock);
}

static int
mISDN_send(struct mISDNchannel *ch, struct sk_buff *skb)
{
	struct mISDN_sock *msk;
	int	err;

	msk = container_of(ch, struct mISDN_sock, ch);
	if (*debug & DEBUG_SOCKET)
		printk(KERN_DEBUG "%s len %d %p\n", __func__, skb->len, skb);
	if (msk->sk.sk_state == MISDN_CLOSED)
		return -EUNATCH;
	__net_timestamp(skb);
	err = sock_queue_rcv_skb(&msk->sk, skb);
	if (err)
		printk(KERN_WARNING "%s: error %d\n", __func__, err);
	return err;
}

static int
mISDN_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
{
	struct mISDN_sock *msk;

	msk = container_of(ch, struct mISDN_sock, ch);
	if (*debug & DEBUG_SOCKET)
		printk(KERN_DEBUG "%s(%p, %x, %p)\n", __func__, ch, cmd, arg);
	switch (cmd) {
	case CLOSE_CHANNEL:
		msk->sk.sk_state = MISDN_CLOSED;
		break;
	}
	return 0;
}

static inline void
mISDN_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
{
	struct __kernel_old_timeval	tv;

	if (_pms(sk)->cmask & MISDN_TIME_STAMP) {
		skb_get_timestamp(skb, &tv);
		put_cmsg(msg, SOL_MISDN, MISDN_TIME_STAMP, sizeof(tv), &tv);
	}
}

static int
mISDN_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
		   int flags)
{
	struct sk_buff		*skb;
	struct sock		*sk = sock->sk;

	int		copied, err;

	if (*debug & DEBUG_SOCKET)
		printk(KERN_DEBUG "%s: len %d, flags %x ch.nr %d, proto %x\n",
		       __func__, (int)len, flags, _pms(sk)->ch.nr,
		       sk->sk_protocol);
	if (flags & (MSG_OOB))
		return -EOPNOTSUPP;

	if (sk->sk_state == MISDN_CLOSED)
		return 0;

	skb = skb_recv_datagram(sk, flags, &err);
	if (!skb)
		return err;

	if (msg->msg_name) {
		DECLARE_SOCKADDR(struct sockaddr_mISDN *, maddr, msg->msg_name);

		maddr->family = AF_ISDN;
		maddr->dev = _pms(sk)->dev->id;
		if ((sk->sk_protocol == ISDN_P_LAPD_TE) ||
		    (sk->sk_protocol == ISDN_P_LAPD_NT)) {
			maddr->channel = (mISDN_HEAD_ID(skb) >> 16) & 0xff;
			maddr->tei =  (mISDN_HEAD_ID(skb) >> 8) & 0xff;
			maddr->sapi = mISDN_HEAD_ID(skb) & 0xff;
		} else {
			maddr->channel = _pms(sk)->ch.nr;
			maddr->sapi = _pms(sk)->ch.addr & 0xFF;
			maddr->tei =  (_pms(sk)->ch.addr >> 8) & 0xFF;
		}
		msg->msg_namelen = sizeof(*maddr);
	}

	copied = skb->len + MISDN_HEADER_LEN;
	if (len < copied) {
		if (flags & MSG_PEEK)
			refcount_dec(&skb->users);
		else
			skb_queue_head(&sk->sk_receive_queue, skb);
		return -ENOSPC;
	}
	memcpy(skb_push(skb, MISDN_HEADER_LEN), mISDN_HEAD_P(skb),
	       MISDN_HEADER_LEN);

	err = skb_copy_datagram_msg(skb, 0, msg, copied);

	mISDN_sock_cmsg(sk, msg, skb);

	skb_free_datagram(sk, skb);

	return err ? : copied;
}

static int
mISDN_sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
{
	struct sock		*sk = sock->sk;
	struct sk_buff		*skb;
	int			err = -ENOMEM;

	if (*debug & DEBUG_SOCKET)
		printk(KERN_DEBUG "%s: len %d flags %x ch %d proto %x\n",
		       __func__, (int)len, msg->msg_flags, _pms(sk)->ch.nr,
		       sk->sk_protocol);

	if (msg->msg_flags & MSG_OOB)
		return -EOPNOTSUPP;

	if (msg->msg_flags & ~(MSG_DONTWAIT | MSG_NOSIGNAL | MSG_ERRQUEUE))
		return -EINVAL;

	if (len < MISDN_HEADER_LEN)
		return -EINVAL;

	if (sk->sk_state != MISDN_BOUND)
		return -EBADFD;

	lock_sock(sk);

	skb = _l2_alloc_skb(len, GFP_KERNEL);
	if (!skb)
		goto done;

	if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
		err = -EFAULT;
		goto done;
	}

	memcpy(mISDN_HEAD_P(skb), skb->data, MISDN_HEADER_LEN);
	skb_pull(skb, MISDN_HEADER_LEN);

	if (msg->msg_namelen >= sizeof(struct sockaddr_mISDN)) {
		/* if we have a address, we use it */
		DECLARE_SOCKADDR(struct sockaddr_mISDN *, maddr, msg->msg_name);
		mISDN_HEAD_ID(skb) = maddr->channel;
	} else { /* use default for L2 messages */
		if ((sk->sk_protocol == ISDN_P_LAPD_TE) ||
		    (sk->sk_protocol == ISDN_P_LAPD_NT))
			mISDN_HEAD_ID(skb) = _pms(sk)->ch.nr;
	}

	if (*debug & DEBUG_SOCKET)
		printk(KERN_DEBUG "%s: ID:%x\n",
		       __func__, mISDN_HEAD_ID(skb));

	err = -ENODEV;
	if (!_pms(sk)->ch.peer)
		goto done;
	err = _pms(sk)->ch.recv(_pms(sk)->ch.peer, skb);
	if (err)
		goto done;
	else {
		skb = NULL;
		err = len;
	}

done:
	kfree_skb(skb);
	release_sock(sk);
	return err;
}

static int
data_sock_release(struct socket *sock)
{
	struct sock *sk = sock->sk;

	if (*debug & DEBUG_SOCKET)
		printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
	if (!sk)
		return 0;
	switch (sk->sk_protocol) {
	case ISDN_P_TE_S0:
	case ISDN_P_NT_S0:
	case ISDN_P_TE_E1:
	case ISDN_P_NT_E1:
		if (sk->sk_state == MISDN_BOUND)
			delete_channel(&_pms(sk)->ch);
		else
			mISDN_sock_unlink(&data_sockets, sk);
		break;
	case ISDN_P_LAPD_TE:
	case ISDN_P_LAPD_NT:
	case ISDN_P_B_RAW:
	case ISDN_P_B_HDLC:
	case ISDN_P_B_X75SLP:
	case ISDN_P_B_L2DTMF:
	case ISDN_P_B_L2DSP:
	case ISDN_P_B_L2DSPHDLC:
		delete_channel(&_pms(sk)->ch);
		mISDN_sock_unlink(&data_sockets, sk);
		break;
	}

	lock_sock(sk);

	sock_orphan(sk);
	skb_queue_purge(&sk->sk_receive_queue);

	release_sock(sk);
	sock_put(sk);

	return 0;
}

static int
data_sock_ioctl_bound(struct sock *sk, unsigned int cmd, void __user *p)
{
	struct mISDN_ctrl_req	cq;
	int			err = -EINVAL, val[2];
	struct mISDNchannel	*bchan, *next;

	lock_sock(sk);
	if (!_pms(sk)->dev) {
		err = -ENODEV;
		goto done;
	}
	switch (cmd) {
	case IMCTRLREQ:
		if (copy_from_user(&cq, p, sizeof(cq))) {
			err = -EFAULT;
			break;
		}
		if ((sk->sk_protocol & ~ISDN_P_B_MASK) == ISDN_P_B_START) {
			list_for_each_entry_safe(bchan, next,
						 &_pms(sk)->dev->bchannels, list) {
				if (bchan->nr == cq.channel) {
					err = bchan->ctrl(bchan,
							  CONTROL_CHANNEL, &cq);
					break;
				}
			}
		} else
			err = _pms(sk)->dev->D.ctrl(&_pms(sk)->dev->D,
						    CONTROL_CHANNEL, &cq);
		if (err)
			break;
		if (copy_to_user(p, &cq, sizeof(cq)))
			err = -EFAULT;
		break;
	case IMCLEAR_L2:
		if (sk->sk_protocol != ISDN_P_LAPD_NT) {
			err = -EINVAL;
			break;
		}
		val[0] = cmd;
		if (get_user(val[1], (int __user *)p)) {
			err = -EFAULT;
			break;
		}
		err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
						  CONTROL_CHANNEL, val);
		break;
	case IMHOLD_L1:
		if (sk->sk_protocol != ISDN_P_LAPD_NT
		    && sk->sk_protocol != ISDN_P_LAPD_TE) {
			err = -EINVAL;
			break;
		}
		val[0] = cmd;
		if (get_user(val[1], (int __user *)p)) {
			err = -EFAULT;
			break;
		}
		err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
						  CONTROL_CHANNEL, val);
		break;
	default:
		err = -EINVAL;
		break;
	}
done:
	release_sock(sk);
	return err;
}

static int
data_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	int			err = 0, id;
	struct sock		*sk = sock->sk;
	struct mISDNdevice	*dev;
	struct mISDNversion	ver;

	switch (cmd) {
	case IMGETVERSION:
		ver.major = MISDN_MAJOR_VERSION;
		ver.minor = MISDN_MINOR_VERSION;
		ver.release = MISDN_RELEASE;
		if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
			err = -EFAULT;
		break;
	case IMGETCOUNT:
		id = get_mdevice_count();
		if (put_user(id, (int __user *)arg))
			err = -EFAULT;
		break;
	case IMGETDEVINFO:
		if (get_user(id, (int __user *)arg)) {
			err = -EFAULT;
			break;
		}
		dev = get_mdevice(id);
		if (dev) {
			struct mISDN_devinfo di;

			memset(&di, 0, sizeof(di));
			di.id = dev->id;
			di.Dprotocols = dev->Dprotocols;
			di.Bprotocols = dev->Bprotocols | get_all_Bprotocols();
			di.protocol = dev->D.protocol;
			memcpy(di.channelmap, dev->channelmap,
			       sizeof(di.channelmap));
			di.nrbchan = dev->nrbchan;
			strscpy(di.name, dev_name(&dev->dev), sizeof(di.name));
			if (copy_to_user((void __user *)arg, &di, sizeof(di)))
				err = -EFAULT;
		} else
			err = -ENODEV;
		break;
	default:
		if (sk->sk_state == MISDN_BOUND)
			err = data_sock_ioctl_bound(sk, cmd,
						    (void __user *)arg);
		else
			err = -ENOTCONN;
	}
	return err;
}

static int data_sock_setsockopt(struct socket *sock, int level, int optname,
				sockptr_t optval, unsigned int optlen)
{
	struct sock *sk = sock->sk;
	int err = 0, opt = 0;

	if (*debug & DEBUG_SOCKET)
		printk(KERN_DEBUG "%s(%p, %d, %x, optval, %d)\n", __func__, sock,
		       level, optname, optlen);

	lock_sock(sk);

	switch (optname) {
	case MISDN_TIME_STAMP:
		err = copy_safe_from_sockptr(&opt, sizeof(opt),
					     optval, optlen);
		if (err)
			break;

		if (opt)
			_pms(sk)->cmask |= MISDN_TIME_STAMP;
		else
			_pms(sk)->cmask &= ~MISDN_TIME_STAMP;
		break;
	default:
		err = -ENOPROTOOPT;
		break;
	}
	release_sock(sk);
	return err;
}

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

	if (get_user(len, optlen))
		return -EFAULT;

	if (len != sizeof(char))
		return -EINVAL;

	switch (optname) {
	case MISDN_TIME_STAMP:
		if (_pms(sk)->cmask & MISDN_TIME_STAMP)
			opt = 1;
		else
			opt = 0;

		if (put_user(opt, optval))
			return -EFAULT;
		break;
	default:
		return -ENOPROTOOPT;
	}

	return 0;
}

static int
data_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
{
	struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
	struct sock *sk = sock->sk;
	struct sock *csk;
	int err = 0;

	if (*debug & DEBUG_SOCKET)
		printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
	if (addr_len != sizeof(struct sockaddr_mISDN))
		return -EINVAL;
	if (!maddr || maddr->family != AF_ISDN)
		return -EINVAL;

	lock_sock(sk);

	if (_pms(sk)->dev) {
		err = -EALREADY;
		goto done;
	}
	_pms(sk)->dev = get_mdevice(maddr->dev);
	if (!_pms(sk)->dev) {
		err = -ENODEV;
		goto done;
	}

	if (sk->sk_protocol < ISDN_P_B_START) {
		read_lock_bh(&data_sockets.lock);
		sk_for_each(csk, &data_sockets.head) {
			if (sk == csk)
				continue;
			if (_pms(csk)->dev != _pms(sk)->dev)
				continue;
			if (csk->sk_protocol >= ISDN_P_B_START)
				continue;
			if (IS_ISDN_P_TE(csk->sk_protocol)
			    == IS_ISDN_P_TE(sk->sk_protocol))
				continue;
			read_unlock_bh(&data_sockets.lock);
			err = -EBUSY;
			goto done;
		}
		read_unlock_bh(&data_sockets.lock);
	}

	_pms(sk)->ch.send = mISDN_send;
	_pms(sk)->ch.ctrl = mISDN_ctrl;

	switch (sk->sk_protocol) {
	case ISDN_P_TE_S0:
	case ISDN_P_NT_S0:
	case ISDN_P_TE_E1:
	case ISDN_P_NT_E1:
		mISDN_sock_unlink(&data_sockets, sk);
		err = connect_layer1(_pms(sk)->dev, &_pms(sk)->ch,
				     sk->sk_protocol, maddr);
		if (err)
			mISDN_sock_link(&data_sockets, sk);
		break;
	case ISDN_P_LAPD_TE:
	case ISDN_P_LAPD_NT:
		err = create_l2entity(_pms(sk)->dev, &_pms(sk)->ch,
				      sk->sk_protocol, maddr);
		break;
	case ISDN_P_B_RAW:
	case ISDN_P_B_HDLC:
	case ISDN_P_B_X75SLP:
	case ISDN_P_B_L2DTMF:
	case ISDN_P_B_L2DSP:
	case ISDN_P_B_L2DSPHDLC:
		err = connect_Bstack(_pms(sk)->dev, &_pms(sk)->ch,
				     sk->sk_protocol, maddr);
		break;
	default:
		err = -EPROTONOSUPPORT;
	}
	if (err)
		goto done;
	sk->sk_state = MISDN_BOUND;
	_pms(sk)->ch.protocol = sk->sk_protocol;

done:
	release_sock(sk);
	return err;
}

static int
data_sock_getname(struct socket *sock, struct sockaddr *addr,
		  int peer)
{
	struct sockaddr_mISDN	*maddr = (struct sockaddr_mISDN *) addr;
	struct sock		*sk = sock->sk;

	if (!_pms(sk)->dev)
		return -EBADFD;

	lock_sock(sk);

	maddr->family = AF_ISDN;
	maddr->dev = _pms(sk)->dev->id;
	maddr->channel = _pms(sk)->ch.nr;
	maddr->sapi = _pms(sk)->ch.addr & 0xff;
	maddr->tei = (_pms(sk)->ch.addr >> 8) & 0xff;
	release_sock(sk);
	return sizeof(*maddr);
}

static const struct proto_ops data_sock_ops = {
	.family		= PF_ISDN,
	.owner		= THIS_MODULE,
	.release	= data_sock_release,
	.ioctl		= data_sock_ioctl,
	.bind		= data_sock_bind,
	.getname	= data_sock_getname,
	.sendmsg	= mISDN_sock_sendmsg,
	.recvmsg	= mISDN_sock_recvmsg,
	.poll		= datagram_poll,
	.listen		= sock_no_listen,
	.shutdown	= sock_no_shutdown,
	.setsockopt	= data_sock_setsockopt,
	.getsockopt	= data_sock_getsockopt,
	.connect	= sock_no_connect,
	.socketpair	= sock_no_socketpair,
	.accept		= sock_no_accept,
	.mmap		= sock_no_mmap
};

static int
data_sock_create(struct net *net, struct socket *sock, int protocol, int kern)
{
	struct sock *sk;

	if (sock->type != SOCK_DGRAM)
		return -ESOCKTNOSUPPORT;

	sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto, kern);
	if (!sk)
		return -ENOMEM;

	sock_init_data(sock, sk);

	sock->ops = &data_sock_ops;
	sock->state = SS_UNCONNECTED;
	sock_reset_flag(sk, SOCK_ZAPPED);

	sk->sk_protocol = protocol;
	sk->sk_state    = MISDN_OPEN;
	mISDN_sock_link(&data_sockets, sk);

	return 0;
}

static int
base_sock_release(struct socket *sock)
{
	struct sock *sk = sock->sk;

	printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
	if (!sk)
		return 0;

	mISDN_sock_unlink(&base_sockets, sk);
	sock_orphan(sk);
	sock_put(sk);

	return 0;
}

static int
base_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	int			err = 0, id;
	struct mISDNdevice	*dev;
	struct mISDNversion	ver;

	switch (cmd) {
	case IMGETVERSION:
		ver.major = MISDN_MAJOR_VERSION;
		ver.minor = MISDN_MINOR_VERSION;
		ver.release = MISDN_RELEASE;
		if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
			err = -EFAULT;
		break;
	case IMGETCOUNT:
		id = get_mdevice_count();
		if (put_user(id, (int __user *)arg))
			err = -EFAULT;
		break;
	case IMGETDEVINFO:
		if (get_user(id, (int __user *)arg)) {
			err = -EFAULT;
			break;
		}
		dev = get_mdevice(id);
		if (dev) {
			struct mISDN_devinfo di;

			memset(&di, 0, sizeof(di));
			di.id = dev->id;
			di.Dprotocols = dev->Dprotocols;
			di.Bprotocols = dev->Bprotocols | get_all_Bprotocols();
			di.protocol = dev->D.protocol;
			memcpy(di.channelmap, dev->channelmap,
			       sizeof(di.channelmap));
			di.nrbchan = dev->nrbchan;
			strscpy(di.name, dev_name(&dev->dev), sizeof(di.name));
			if (copy_to_user((void __user *)arg, &di, sizeof(di)))
				err = -EFAULT;
		} else
			err = -ENODEV;
		break;
	case IMSETDEVNAME:
	{
		struct mISDN_devrename dn;
		if (copy_from_user(&dn, (void __user *)arg,
				   sizeof(dn))) {
			err = -EFAULT;
			break;
		}
		dn.name[sizeof(dn.name) - 1] = '\0';
		dev = get_mdevice(dn.id);
		if (dev)
			err = device_rename(&dev->dev, dn.name);
		else
			err = -ENODEV;
	}
	break;
	default:
		err = -EINVAL;
	}
	return err;
}

static int
base_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
{
	struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
	struct sock *sk = sock->sk;
	int err = 0;

	if (addr_len < sizeof(struct sockaddr_mISDN))
		return -EINVAL;

	if (!maddr || maddr->family != AF_ISDN)
		return -EINVAL;

	lock_sock(sk);

	if (_pms(sk)->dev) {
		err = -EALREADY;
		goto done;
	}

	_pms(sk)->dev = get_mdevice(maddr->dev);
	if (!_pms(sk)->dev) {
		err = -ENODEV;
		goto done;
	}
	sk->sk_state = MISDN_BOUND;

done:
	release_sock(sk);
	return err;
}

static const struct proto_ops base_sock_ops = {
	.family		= PF_ISDN,
	.owner		= THIS_MODULE,
	.release	= base_sock_release,
	.ioctl		= base_sock_ioctl,
	.bind		= base_sock_bind,
	.getname	= sock_no_getname,
	.sendmsg	= sock_no_sendmsg,
	.recvmsg	= sock_no_recvmsg,
	.listen		= sock_no_listen,
	.shutdown	= sock_no_shutdown,
	.connect	= sock_no_connect,
	.socketpair	= sock_no_socketpair,
	.accept		= sock_no_accept,
	.mmap		= sock_no_mmap
};


static int
base_sock_create(struct net *net, struct socket *sock, int protocol, int kern)
{
	struct sock *sk;

	if (sock->type != SOCK_RAW)
		return -ESOCKTNOSUPPORT;
	if (!capable(CAP_NET_RAW))
		return -EPERM;

	sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto, kern);
	if (!sk)
		return -ENOMEM;

	sock_init_data(sock, sk);
	sock->ops = &base_sock_ops;
	sock->state = SS_UNCONNECTED;
	sock_reset_flag(sk, SOCK_ZAPPED);
	sk->sk_protocol = protocol;
	sk->sk_state    = MISDN_OPEN;
	mISDN_sock_link(&base_sockets, sk);

	return 0;
}

static int
mISDN_sock_create(struct net *net, struct socket *sock, int proto, int kern)
{
	int err = -EPROTONOSUPPORT;

	switch (proto) {
	case ISDN_P_BASE:
		err = base_sock_create(net, sock, proto, kern);
		break;
	case ISDN_P_TE_S0:
	case ISDN_P_NT_S0:
	case ISDN_P_TE_E1:
	case ISDN_P_NT_E1:
	case ISDN_P_LAPD_TE:
	case ISDN_P_LAPD_NT:
	case ISDN_P_B_RAW:
	case ISDN_P_B_HDLC:
	case ISDN_P_B_X75SLP:
	case ISDN_P_B_L2DTMF:
	case ISDN_P_B_L2DSP:
	case ISDN_P_B_L2DSPHDLC:
		err = data_sock_create(net, sock, proto, kern);
		break;
	default:
		return err;
	}

	return err;
}

static const struct net_proto_family mISDN_sock_family_ops = {
	.owner  = THIS_MODULE,
	.family = PF_ISDN,
	.create = mISDN_sock_create,
};

int
misdn_sock_init(u_int *deb)
{
	int err;

	debug = deb;
	err = sock_register(&mISDN_sock_family_ops);
	if (err)
		printk(KERN_ERR "%s: error(%d)\n", __func__, err);
	return err;
}

void
misdn_sock_cleanup(void)
{
	sock_unregister(PF_ISDN);
}
Commit	Line	Data
1802d0be	1	// SPDX-License-Identifier: GPL-2.0-only
1b2b03f8 KK	2	/*
	3	*
	4	* Author Karsten Keil <kkeil@novell.com>
	5	*
	6	* Copyright 2008 by Karsten Keil <kkeil@novell.com>
1b2b03f8 KK	7	*/
	8
	9	#include <linux/mISDNif.h>
5a0e3ad6	10	#include <linux/slab.h>
5d76fc21	11	#include <linux/export.h>
1b2b03f8 KK	12	#include "core.h"
1b2b03f8 KK	13
dfa96ec1	14	static u_int *debug;
1b2b03f8 KK	15
	16	static struct proto mISDN_proto = {
	17	.name = "misdn",
	18	.owner = THIS_MODULE,
	19	.obj_size = sizeof(struct mISDN_sock)
	20	};
	21
	22	#define _pms(sk) ((struct mISDN_sock *)sk)
	23
	24	static struct mISDN_sock_list data_sockets = {
	25	.lock = __RW_LOCK_UNLOCKED(data_sockets.lock)
	26	};
	27
	28	static struct mISDN_sock_list base_sockets = {
	29	.lock = __RW_LOCK_UNLOCKED(base_sockets.lock)
	30	};
	31
	32	#define L2_HEADER_LEN 4
	33
	34	static inline struct sk_buff *
	35	_l2_alloc_skb(unsigned int len, gfp_t gfp_mask)
	36	{
	37	struct sk_buff *skb;
	38
	39	skb = alloc_skb(len + L2_HEADER_LEN, gfp_mask);
	40	if (likely(skb))
	41	skb_reserve(skb, L2_HEADER_LEN);
	42	return skb;
	43	}
	44
	45	static void
	46	mISDN_sock_link(struct mISDN_sock_list l, struct sock sk)
	47	{
	48	write_lock_bh(&l->lock);
	49	sk_add_node(sk, &l->head);
	50	write_unlock_bh(&l->lock);
	51	}
	52
	53	static void mISDN_sock_unlink(struct mISDN_sock_list l, struct sock sk)
	54	{
	55	write_lock_bh(&l->lock);
	56	sk_del_node_init(sk);
	57	write_unlock_bh(&l->lock);
	58	}
	59
	60	static int
	61	mISDN_send(struct mISDNchannel ch, struct sk_buff skb)
	62	{
	63	struct mISDN_sock *msk;
	64	int err;
	65
	66	msk = container_of(ch, struct mISDN_sock, ch);
	67	if (*debug & DEBUG_SOCKET)
	68	printk(KERN_DEBUG "%s len %d %p\n", __func__, skb->len, skb);
	69	if (msk->sk.sk_state == MISDN_CLOSED)
	70	return -EUNATCH;
	71	__net_timestamp(skb);
	72	err = sock_queue_rcv_skb(&msk->sk, skb);
	73	if (err)
	74	printk(KERN_WARNING "%s: error %d\n", __func__, err);
	75	return err;
	76	}
	77
	78	static int
79	mISDN_ctrl(struct mISDNchannel ch, u_int cmd, void arg)
80	{
81	struct mISDN_sock *msk;
82
83	msk = container_of(ch, struct mISDN_sock, ch);
84	if (*debug & DEBUG_SOCKET)
85	printk(KERN_DEBUG "%s(%p, %x, %p)\n", __func__, ch, cmd, arg);
86	switch (cmd) {
87	case CLOSE_CHANNEL:
88	msk->sk.sk_state = MISDN_CLOSED;
89	break;
90	}
91	return 0;
92	}
93
94	static inline void
95	mISDN_sock_cmsg(struct sock sk, struct msghdr msg, struct sk_buff *skb)
96	{
13c6ee2a	97	struct __kernel_old_timeval tv;
1b2b03f8 KK	98
	99	if (_pms(sk)->cmask & MISDN_TIME_STAMP) {
	100	skb_get_timestamp(skb, &tv);
	101	put_cmsg(msg, SOL_MISDN, MISDN_TIME_STAMP, sizeof(tv), &tv);
	102	}
	103	}
	104
	105	static int
1b784140 YX	106	mISDN_sock_recvmsg(struct socket sock, struct msghdr msg, size_t len,
1b784140 YX	107	int flags)
1b2b03f8 KK	108	{
	109	struct sk_buff *skb;
	110	struct sock *sk = sock->sk;
1b2b03f8 KK	111
	112	int copied, err;
	113
	114	if (*debug & DEBUG_SOCKET)
	115	printk(KERN_DEBUG "%s: len %d, flags %x ch.nr %d, proto %x\n",
475be4d8 JP	116	__func__, (int)len, flags, _pms(sk)->ch.nr,
475be4d8 JP	117	sk->sk_protocol);
1b2b03f8 KK	118	if (flags & (MSG_OOB))
	119	return -EOPNOTSUPP;
	120
	121	if (sk->sk_state == MISDN_CLOSED)
	122	return 0;
	123
f4b41f06	124	skb = skb_recv_datagram(sk, flags, &err);
1b2b03f8 KK	125	if (!skb)
	126	return err;
	127
f3d33426	128	if (msg->msg_name) {
342dfc30	129	DECLARE_SOCKADDR(struct sockaddr_mISDN *, maddr, msg->msg_name);
f3d33426	130
1b2b03f8 KK	131	maddr->family = AF_ISDN;
	132	maddr->dev = _pms(sk)->dev->id;
	133	if ((sk->sk_protocol == ISDN_P_LAPD_TE) \|\|
	134	(sk->sk_protocol == ISDN_P_LAPD_NT)) {
	135	maddr->channel = (mISDN_HEAD_ID(skb) >> 16) & 0xff;
	136	maddr->tei = (mISDN_HEAD_ID(skb) >> 8) & 0xff;
	137	maddr->sapi = mISDN_HEAD_ID(skb) & 0xff;
	138	} else {
	139	maddr->channel = _pms(sk)->ch.nr;
	140	maddr->sapi = _pms(sk)->ch.addr & 0xFF;
	141	maddr->tei = (_pms(sk)->ch.addr >> 8) & 0xFF;
	142	}
f3d33426	143	msg->msg_namelen = sizeof(*maddr);
1b2b03f8 KK	144	}
	145
	146	copied = skb->len + MISDN_HEADER_LEN;
	147	if (len < copied) {
	148	if (flags & MSG_PEEK)
63354797	149	refcount_dec(&skb->users);
1b2b03f8 KK	150	else
	151	skb_queue_head(&sk->sk_receive_queue, skb);
	152	return -ENOSPC;
	153	}
	154	memcpy(skb_push(skb, MISDN_HEADER_LEN), mISDN_HEAD_P(skb),
475be4d8	155	MISDN_HEADER_LEN);
1b2b03f8	156
51f3d02b	157	err = skb_copy_datagram_msg(skb, 0, msg, copied);
1b2b03f8 KK	158
	159	mISDN_sock_cmsg(sk, msg, skb);
	160
	161	skb_free_datagram(sk, skb);
	162
	163	return err ? : copied;
	164	}
	165
	166	static int
1b784140	167	mISDN_sock_sendmsg(struct socket sock, struct msghdr msg, size_t len)
1b2b03f8 KK	168	{
	169	struct sock *sk = sock->sk;
	170	struct sk_buff *skb;
	171	int err = -ENOMEM;
1b2b03f8 KK	172
	173	if (*debug & DEBUG_SOCKET)
	174	printk(KERN_DEBUG "%s: len %d flags %x ch %d proto %x\n",
475be4d8 JP	175	__func__, (int)len, msg->msg_flags, _pms(sk)->ch.nr,
475be4d8 JP	176	sk->sk_protocol);
1b2b03f8 KK	177
	178	if (msg->msg_flags & MSG_OOB)
	179	return -EOPNOTSUPP;
	180
475be4d8	181	if (msg->msg_flags & ~(MSG_DONTWAIT \| MSG_NOSIGNAL \| MSG_ERRQUEUE))
1b2b03f8 KK	182	return -EINVAL;
	183
	184	if (len < MISDN_HEADER_LEN)
	185	return -EINVAL;
	186
	187	if (sk->sk_state != MISDN_BOUND)
	188	return -EBADFD;
	189
	190	lock_sock(sk);
	191
	192	skb = _l2_alloc_skb(len, GFP_KERNEL);
	193	if (!skb)
	194	goto done;
	195
6ce8e9ce	196	if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1b2b03f8	197	err = -EFAULT;
5df3b8bc	198	goto done;
1b2b03f8 KK	199	}
	200
	201	memcpy(mISDN_HEAD_P(skb), skb->data, MISDN_HEADER_LEN);
	202	skb_pull(skb, MISDN_HEADER_LEN);
	203
	204	if (msg->msg_namelen >= sizeof(struct sockaddr_mISDN)) {
	205	/* if we have a address, we use it */
342dfc30	206	DECLARE_SOCKADDR(struct sockaddr_mISDN *, maddr, msg->msg_name);
1b2b03f8 KK	207	mISDN_HEAD_ID(skb) = maddr->channel;
	208	} else { /* use default for L2 messages */
	209	if ((sk->sk_protocol == ISDN_P_LAPD_TE) \|\|
	210	(sk->sk_protocol == ISDN_P_LAPD_NT))
eac74af9	211	mISDN_HEAD_ID(skb) = _pms(sk)->ch.nr;
1b2b03f8 KK	212	}
	213
	214	if (*debug & DEBUG_SOCKET)
	215	printk(KERN_DEBUG "%s: ID:%x\n",
475be4d8	216	__func__, mISDN_HEAD_ID(skb));
1b2b03f8 KK	217
1b2b03f8 KK	218	err = -ENODEV;
5df3b8bc KK	219	if (!_pms(sk)->ch.peer)
	220	goto done;
	221	err = _pms(sk)->ch.recv(_pms(sk)->ch.peer, skb);
	222	if (err)
	223	goto done;
	224	else {
	225	skb = NULL;
	226	err = len;
	227	}
1b2b03f8 KK	228
1b2b03f8 KK	229	done:
66ab2359	230	kfree_skb(skb);
1b2b03f8 KK	231	release_sock(sk);
1b2b03f8 KK	232	return err;
1b2b03f8 KK	233	}
	234
	235	static int
	236	data_sock_release(struct socket *sock)
	237	{
	238	struct sock *sk = sock->sk;
	239
	240	if (*debug & DEBUG_SOCKET)
	241	printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
	242	if (!sk)
	243	return 0;
	244	switch (sk->sk_protocol) {
	245	case ISDN_P_TE_S0:
	246	case ISDN_P_NT_S0:
	247	case ISDN_P_TE_E1:
	248	case ISDN_P_NT_E1:
	249	if (sk->sk_state == MISDN_BOUND)
	250	delete_channel(&_pms(sk)->ch);
	251	else
	252	mISDN_sock_unlink(&data_sockets, sk);
	253	break;
	254	case ISDN_P_LAPD_TE:
	255	case ISDN_P_LAPD_NT:
	256	case ISDN_P_B_RAW:
	257	case ISDN_P_B_HDLC:
	258	case ISDN_P_B_X75SLP:
	259	case ISDN_P_B_L2DTMF:
	260	case ISDN_P_B_L2DSP:
	261	case ISDN_P_B_L2DSPHDLC:
	262	delete_channel(&_pms(sk)->ch);
	263	mISDN_sock_unlink(&data_sockets, sk);
	264	break;
	265	}
	266
	267	lock_sock(sk);
	268
	269	sock_orphan(sk);
	270	skb_queue_purge(&sk->sk_receive_queue);
	271
	272	release_sock(sk);
	273	sock_put(sk);
	274
	275	return 0;
	276	}
	277
	278	static int
	279	data_sock_ioctl_bound(struct sock sk, unsigned int cmd, void __user p)
	280	{
	281	struct mISDN_ctrl_req cq;
e73f6b22	282	int err = -EINVAL, val[2];
1b2b03f8 KK	283	struct mISDNchannel bchan, next;
	284
	285	lock_sock(sk);
	286	if (!_pms(sk)->dev) {
	287	err = -ENODEV;
	288	goto done;
	289	}
	290	switch (cmd) {
	291	case IMCTRLREQ:
	292	if (copy_from_user(&cq, p, sizeof(cq))) {
	293	err = -EFAULT;
	294	break;
	295	}
	296	if ((sk->sk_protocol & ~ISDN_P_B_MASK) == ISDN_P_B_START) {
	297	list_for_each_entry_safe(bchan, next,
475be4d8	298	&_pms(sk)->dev->bchannels, list) {
1b2b03f8 KK	299	if (bchan->nr == cq.channel) {
1b2b03f8 KK	300	err = bchan->ctrl(bchan,
475be4d8	301	CONTROL_CHANNEL, &cq);
1b2b03f8 KK	302	break;
	303	}
	304	}
	305	} else
	306	err = _pms(sk)->dev->D.ctrl(&_pms(sk)->dev->D,
475be4d8	307	CONTROL_CHANNEL, &cq);
1b2b03f8 KK	308	if (err)
	309	break;
	310	if (copy_to_user(p, &cq, sizeof(cq)))
	311	err = -EFAULT;
	312	break;
	313	case IMCLEAR_L2:
	314	if (sk->sk_protocol != ISDN_P_LAPD_NT) {
	315	err = -EINVAL;
	316	break;
	317	}
e73f6b22 AE	318	val[0] = cmd;
e73f6b22 AE	319	if (get_user(val[1], (int __user *)p)) {
1b2b03f8 KK	320	err = -EFAULT;
	321	break;
	322	}
	323	err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
475be4d8	324	CONTROL_CHANNEL, val);
e73f6b22 AE	325	break;
	326	case IMHOLD_L1:
	327	if (sk->sk_protocol != ISDN_P_LAPD_NT
475be4d8	328	&& sk->sk_protocol != ISDN_P_LAPD_TE) {
e73f6b22 AE	329	err = -EINVAL;
	330	break;
	331	}
	332	val[0] = cmd;
	333	if (get_user(val[1], (int __user *)p)) {
	334	err = -EFAULT;
	335	break;
	336	}
	337	err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
475be4d8	338	CONTROL_CHANNEL, val);
1b2b03f8 KK	339	break;
	340	default:
	341	err = -EINVAL;
	342	break;
	343	}
	344	done:
	345	release_sock(sk);
	346	return err;
	347	}
	348
	349	static int
	350	data_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	351	{
475be4d8	352	int err = 0, id;
1b2b03f8 KK	353	struct sock *sk = sock->sk;
	354	struct mISDNdevice *dev;
	355	struct mISDNversion ver;
	356
	357	switch (cmd) {
	358	case IMGETVERSION:
	359	ver.major = MISDN_MAJOR_VERSION;
	360	ver.minor = MISDN_MINOR_VERSION;
	361	ver.release = MISDN_RELEASE;
	362	if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
	363	err = -EFAULT;
	364	break;
	365	case IMGETCOUNT:
	366	id = get_mdevice_count();
	367	if (put_user(id, (int __user *)arg))
	368	err = -EFAULT;
	369	break;
	370	case IMGETDEVINFO:
	371	if (get_user(id, (int __user *)arg)) {
	372	err = -EFAULT;
	373	break;
	374	}
	375	dev = get_mdevice(id);
	376	if (dev) {
	377	struct mISDN_devinfo di;
	378
ce384d91	379	memset(&di, 0, sizeof(di));
1b2b03f8 KK	380	di.id = dev->id;
	381	di.Dprotocols = dev->Dprotocols;
	382	di.Bprotocols = dev->Bprotocols \| get_all_Bprotocols();
	383	di.protocol = dev->D.protocol;
	384	memcpy(di.channelmap, dev->channelmap,
475be4d8	385	sizeof(di.channelmap));
1b2b03f8	386	di.nrbchan = dev->nrbchan;
ccfb62f2	387	strscpy(di.name, dev_name(&dev->dev), sizeof(di.name));
1b2b03f8 KK	388	if (copy_to_user((void __user *)arg, &di, sizeof(di)))
	389	err = -EFAULT;
	390	} else
	391	err = -ENODEV;
	392	break;
	393	default:
	394	if (sk->sk_state == MISDN_BOUND)
	395	err = data_sock_ioctl_bound(sk, cmd,
475be4d8	396	(void __user *)arg);
1b2b03f8 KK	397	else
	398	err = -ENOTCONN;
	399	}
	400	return err;
	401	}
	402
	403	static int data_sock_setsockopt(struct socket *sock, int level, int optname,
138b7878	404	sockptr_t optval, unsigned int optlen)
1b2b03f8 KK	405	{
	406	struct sock *sk = sock->sk;
	407	int err = 0, opt = 0;
	408
	409	if (*debug & DEBUG_SOCKET)
2d6be17d	410	printk(KERN_DEBUG "%s(%p, %d, %x, optval, %d)\n", __func__, sock,
138b7878	411	level, optname, optlen);
1b2b03f8 KK	412
	413	lock_sock(sk);
	414
	415	switch (optname) {
	416	case MISDN_TIME_STAMP:
138b7878 ED	417	err = copy_safe_from_sockptr(&opt, sizeof(opt),
	418	optval, optlen);
	419	if (err)
1b2b03f8	420	break;
1b2b03f8 KK	421
	422	if (opt)
	423	_pms(sk)->cmask \|= MISDN_TIME_STAMP;
	424	else
	425	_pms(sk)->cmask &= ~MISDN_TIME_STAMP;
	426	break;
	427	default:
	428	err = -ENOPROTOOPT;
	429	break;
	430	}
	431	release_sock(sk);
	432	return err;
	433	}
	434
	435	static int data_sock_getsockopt(struct socket *sock, int level, int optname,
475be4d8	436	char __user optval, int __user optlen)
1b2b03f8 KK	437	{
	438	struct sock *sk = sock->sk;
	439	int len, opt;
	440
	441	if (get_user(len, optlen))
	442	return -EFAULT;
	443
81b424d9 DM	444	if (len != sizeof(char))
	445	return -EINVAL;
	446
1b2b03f8 KK	447	switch (optname) {
	448	case MISDN_TIME_STAMP:
	449	if (_pms(sk)->cmask & MISDN_TIME_STAMP)
	450	opt = 1;
	451	else
	452	opt = 0;
	453
	454	if (put_user(opt, optval))
	455	return -EFAULT;
	456	break;
	457	default:
	458	return -ENOPROTOOPT;
	459	}
	460
	461	return 0;
	462	}
	463
	464	static int
	465	data_sock_bind(struct socket sock, struct sockaddr addr, int addr_len)
	466	{
	467	struct sockaddr_mISDN maddr = (struct sockaddr_mISDN ) addr;
	468	struct sock *sk = sock->sk;
1b4d3312	469	struct sock *csk;
1b2b03f8 KK	470	int err = 0;
	471
	472	if (*debug & DEBUG_SOCKET)
	473	printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
	474	if (addr_len != sizeof(struct sockaddr_mISDN))
	475	return -EINVAL;
	476	if (!maddr \|\| maddr->family != AF_ISDN)
	477	return -EINVAL;
	478
	479	lock_sock(sk);
	480
	481	if (_pms(sk)->dev) {
	482	err = -EALREADY;
	483	goto done;
	484	}
	485	_pms(sk)->dev = get_mdevice(maddr->dev);
	486	if (!_pms(sk)->dev) {
	487	err = -ENODEV;
	488	goto done;
	489	}
1b4d3312	490
9a812553 AE	491	if (sk->sk_protocol < ISDN_P_B_START) {
9a812553 AE	492	read_lock_bh(&data_sockets.lock);
b67bfe0d	493	sk_for_each(csk, &data_sockets.head) {
9a812553 AE	494	if (sk == csk)
	495	continue;
	496	if (_pms(csk)->dev != _pms(sk)->dev)
	497	continue;
	498	if (csk->sk_protocol >= ISDN_P_B_START)
	499	continue;
	500	if (IS_ISDN_P_TE(csk->sk_protocol)
475be4d8	501	== IS_ISDN_P_TE(sk->sk_protocol))
9a812553 AE	502	continue;
	503	read_unlock_bh(&data_sockets.lock);
	504	err = -EBUSY;
	505	goto done;
	506	}
1b4d3312	507	read_unlock_bh(&data_sockets.lock);
1b4d3312	508	}
1b4d3312	509
1b2b03f8 KK	510	_pms(sk)->ch.send = mISDN_send;
	511	_pms(sk)->ch.ctrl = mISDN_ctrl;
	512
	513	switch (sk->sk_protocol) {
	514	case ISDN_P_TE_S0:
	515	case ISDN_P_NT_S0:
	516	case ISDN_P_TE_E1:
	517	case ISDN_P_NT_E1:
	518	mISDN_sock_unlink(&data_sockets, sk);
	519	err = connect_layer1(_pms(sk)->dev, &_pms(sk)->ch,
475be4d8	520	sk->sk_protocol, maddr);
1b2b03f8 KK	521	if (err)
	522	mISDN_sock_link(&data_sockets, sk);
	523	break;
	524	case ISDN_P_LAPD_TE:
	525	case ISDN_P_LAPD_NT:
	526	err = create_l2entity(_pms(sk)->dev, &_pms(sk)->ch,
475be4d8	527	sk->sk_protocol, maddr);
1b2b03f8 KK	528	break;
	529	case ISDN_P_B_RAW:
	530	case ISDN_P_B_HDLC:
	531	case ISDN_P_B_X75SLP:
	532	case ISDN_P_B_L2DTMF:
	533	case ISDN_P_B_L2DSP:
	534	case ISDN_P_B_L2DSPHDLC:
	535	err = connect_Bstack(_pms(sk)->dev, &_pms(sk)->ch,
475be4d8	536	sk->sk_protocol, maddr);
1b2b03f8 KK	537	break;
	538	default:
	539	err = -EPROTONOSUPPORT;
	540	}
	541	if (err)
	542	goto done;
	543	sk->sk_state = MISDN_BOUND;
	544	_pms(sk)->ch.protocol = sk->sk_protocol;
	545
	546	done:
	547	release_sock(sk);
	548	return err;
	549	}
	550
	551	static int
	552	data_sock_getname(struct socket sock, struct sockaddr addr,
9b2c45d4	553	int peer)
1b2b03f8	554	{
475be4d8	555	struct sockaddr_mISDN maddr = (struct sockaddr_mISDN ) addr;
1b2b03f8 KK	556	struct sock *sk = sock->sk;
	557
	558	if (!_pms(sk)->dev)
	559	return -EBADFD;
	560
	561	lock_sock(sk);
	562
d9152097	563	maddr->family = AF_ISDN;
1b2b03f8 KK	564	maddr->dev = _pms(sk)->dev->id;
	565	maddr->channel = _pms(sk)->ch.nr;
	566	maddr->sapi = _pms(sk)->ch.addr & 0xff;
	567	maddr->tei = (_pms(sk)->ch.addr >> 8) & 0xff;
	568	release_sock(sk);
9b2c45d4	569	return sizeof(*maddr);
1b2b03f8 KK	570	}
	571
	572	static const struct proto_ops data_sock_ops = {
	573	.family = PF_ISDN,
	574	.owner = THIS_MODULE,
	575	.release = data_sock_release,
	576	.ioctl = data_sock_ioctl,
	577	.bind = data_sock_bind,
	578	.getname = data_sock_getname,
	579	.sendmsg = mISDN_sock_sendmsg,
	580	.recvmsg = mISDN_sock_recvmsg,
a11e1d43	581	.poll = datagram_poll,
1b2b03f8 KK	582	.listen = sock_no_listen,
	583	.shutdown = sock_no_shutdown,
	584	.setsockopt = data_sock_setsockopt,
	585	.getsockopt = data_sock_getsockopt,
	586	.connect = sock_no_connect,
	587	.socketpair = sock_no_socketpair,
	588	.accept = sock_no_accept,
	589	.mmap = sock_no_mmap
	590	};
	591
	592	static int
11aa9c28	593	data_sock_create(struct net net, struct socket sock, int protocol, int kern)
1b2b03f8 KK	594	{
	595	struct sock *sk;
	596
	597	if (sock->type != SOCK_DGRAM)
	598	return -ESOCKTNOSUPPORT;
	599
11aa9c28	600	sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto, kern);
1b2b03f8 KK	601	if (!sk)
	602	return -ENOMEM;
	603
	604	sock_init_data(sock, sk);
	605
	606	sock->ops = &data_sock_ops;
	607	sock->state = SS_UNCONNECTED;
	608	sock_reset_flag(sk, SOCK_ZAPPED);
	609
	610	sk->sk_protocol = protocol;
	611	sk->sk_state = MISDN_OPEN;
	612	mISDN_sock_link(&data_sockets, sk);
	613
	614	return 0;
	615	}
	616
	617	static int
	618	base_sock_release(struct socket *sock)
	619	{
	620	struct sock *sk = sock->sk;
	621
	622	printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
	623	if (!sk)
	624	return 0;
	625
	626	mISDN_sock_unlink(&base_sockets, sk);
	627	sock_orphan(sk);
	628	sock_put(sk);
	629
	630	return 0;
	631	}
	632
	633	static int
	634	base_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	635	{
475be4d8	636	int err = 0, id;
1b2b03f8 KK	637	struct mISDNdevice *dev;
	638	struct mISDNversion ver;
	639
	640	switch (cmd) {
	641	case IMGETVERSION:
	642	ver.major = MISDN_MAJOR_VERSION;
	643	ver.minor = MISDN_MINOR_VERSION;
	644	ver.release = MISDN_RELEASE;
	645	if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
	646	err = -EFAULT;
	647	break;
	648	case IMGETCOUNT:
	649	id = get_mdevice_count();
	650	if (put_user(id, (int __user *)arg))
	651	err = -EFAULT;
	652	break;
	653	case IMGETDEVINFO:
	654	if (get_user(id, (int __user *)arg)) {
	655	err = -EFAULT;
	656	break;
	657	}
	658	dev = get_mdevice(id);
	659	if (dev) {
	660	struct mISDN_devinfo di;
	661
ce384d91	662	memset(&di, 0, sizeof(di));
1b2b03f8 KK	663	di.id = dev->id;
	664	di.Dprotocols = dev->Dprotocols;
	665	di.Bprotocols = dev->Bprotocols \| get_all_Bprotocols();
	666	di.protocol = dev->D.protocol;
	667	memcpy(di.channelmap, dev->channelmap,
475be4d8	668	sizeof(di.channelmap));
1b2b03f8	669	di.nrbchan = dev->nrbchan;
ccfb62f2	670	strscpy(di.name, dev_name(&dev->dev), sizeof(di.name));
1b2b03f8 KK	671	if (copy_to_user((void __user *)arg, &di, sizeof(di)))
	672	err = -EFAULT;
	673	} else
	674	err = -ENODEV;
	675	break;
8b6015f7	676	case IMSETDEVNAME:
475be4d8 JP	677	{
	678	struct mISDN_devrename dn;
	679	if (copy_from_user(&dn, (void __user *)arg,
	680	sizeof(dn))) {
	681	err = -EFAULT;
	682	break;
8b6015f7	683	}
ccfb62f2	684	dn.name[sizeof(dn.name) - 1] = '\0';
475be4d8 JP	685	dev = get_mdevice(dn.id);
	686	if (dev)
	687	err = device_rename(&dev->dev, dn.name);
	688	else
	689	err = -ENODEV;
	690	}
	691	break;
1b2b03f8 KK	692	default:
	693	err = -EINVAL;
	694	}
	695	return err;
	696	}
	697
	698	static int
	699	base_sock_bind(struct socket sock, struct sockaddr addr, int addr_len)
	700	{
	701	struct sockaddr_mISDN maddr = (struct sockaddr_mISDN ) addr;
	702	struct sock *sk = sock->sk;
	703	int err = 0;
	704
238ffdc4	705	if (addr_len < sizeof(struct sockaddr_mISDN))
1b2b03f8 KK	706	return -EINVAL;
1b2b03f8 KK	707
238ffdc4	708	if (!maddr \|\| maddr->family != AF_ISDN)
b8216468 ED	709	return -EINVAL;
b8216468 ED	710
1b2b03f8 KK	711	lock_sock(sk);
	712
	713	if (_pms(sk)->dev) {
	714	err = -EALREADY;
	715	goto done;
	716	}
	717
	718	_pms(sk)->dev = get_mdevice(maddr->dev);
	719	if (!_pms(sk)->dev) {
	720	err = -ENODEV;
	721	goto done;
	722	}
	723	sk->sk_state = MISDN_BOUND;
	724
	725	done:
	726	release_sock(sk);
	727	return err;
	728	}
	729
	730	static const struct proto_ops base_sock_ops = {
	731	.family = PF_ISDN,
	732	.owner = THIS_MODULE,
	733	.release = base_sock_release,
	734	.ioctl = base_sock_ioctl,
	735	.bind = base_sock_bind,
	736	.getname = sock_no_getname,
	737	.sendmsg = sock_no_sendmsg,
	738	.recvmsg = sock_no_recvmsg,
1b2b03f8 KK	739	.listen = sock_no_listen,
1b2b03f8 KK	740	.shutdown = sock_no_shutdown,
1b2b03f8 KK	741	.connect = sock_no_connect,
	742	.socketpair = sock_no_socketpair,
	743	.accept = sock_no_accept,
	744	.mmap = sock_no_mmap
	745	};
	746
	747
	748	static int
11aa9c28	749	base_sock_create(struct net net, struct socket sock, int protocol, int kern)
1b2b03f8 KK	750	{
	751	struct sock *sk;
	752
	753	if (sock->type != SOCK_RAW)
	754	return -ESOCKTNOSUPPORT;
b91ee4aa ON	755	if (!capable(CAP_NET_RAW))
b91ee4aa ON	756	return -EPERM;
1b2b03f8	757
11aa9c28	758	sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto, kern);
1b2b03f8 KK	759	if (!sk)
	760	return -ENOMEM;
	761
	762	sock_init_data(sock, sk);
	763	sock->ops = &base_sock_ops;
	764	sock->state = SS_UNCONNECTED;
	765	sock_reset_flag(sk, SOCK_ZAPPED);
	766	sk->sk_protocol = protocol;
	767	sk->sk_state = MISDN_OPEN;
	768	mISDN_sock_link(&base_sockets, sk);
	769
	770	return 0;
	771	}
	772
	773	static int
3f378b68	774	mISDN_sock_create(struct net net, struct socket sock, int proto, int kern)
1b2b03f8 KK	775	{
	776	int err = -EPROTONOSUPPORT;
	777
475be4d8	778	switch (proto) {
1b2b03f8	779	case ISDN_P_BASE:
11aa9c28	780	err = base_sock_create(net, sock, proto, kern);
1b2b03f8 KK	781	break;
	782	case ISDN_P_TE_S0:
	783	case ISDN_P_NT_S0:
	784	case ISDN_P_TE_E1:
	785	case ISDN_P_NT_E1:
	786	case ISDN_P_LAPD_TE:
	787	case ISDN_P_LAPD_NT:
	788	case ISDN_P_B_RAW:
	789	case ISDN_P_B_HDLC:
	790	case ISDN_P_B_X75SLP:
	791	case ISDN_P_B_L2DTMF:
	792	case ISDN_P_B_L2DSP:
	793	case ISDN_P_B_L2DSPHDLC:
11aa9c28	794	err = data_sock_create(net, sock, proto, kern);
1b2b03f8 KK	795	break;
	796	default:
	797	return err;
	798	}
	799
	800	return err;
	801	}
	802
ec1b4cf7	803	static const struct net_proto_family mISDN_sock_family_ops = {
1b2b03f8 KK	804	.owner = THIS_MODULE,
	805	.family = PF_ISDN,
	806	.create = mISDN_sock_create,
	807	};
	808
	809	int
	810	misdn_sock_init(u_int *deb)
	811	{
	812	int err;
	813
	814	debug = deb;
	815	err = sock_register(&mISDN_sock_family_ops);
	816	if (err)
	817	printk(KERN_ERR "%s: error(%d)\n", __func__, err);
	818	return err;
	819	}
	820
	821	void
	822	misdn_sock_cleanup(void)
	823	{
	824	sock_unregister(PF_ISDN);
	825	}