[mirror_ubuntu-hirsute-kernel.git] / drivers / isdn / mISDN / socket.c

/*
 *
 * Author	Karsten Keil <kkeil@novell.com>
 *
 * Copyright 2008  by Karsten Keil <kkeil@novell.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */

#include <linux/mISDNif.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 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 kiocb *iocb, struct socket *sock,
    struct msghdr *msg, size_t len, int flags)
{
	struct sk_buff		*skb;
	struct sock		*sk = sock->sk;
	struct sockaddr_mISDN	*maddr;

	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, flags & MSG_DONTWAIT, &err);
	if (!skb)
		return err;

	if (msg->msg_namelen >= sizeof(struct sockaddr_mISDN)) {
		msg->msg_namelen = sizeof(struct sockaddr_mISDN);
		maddr = (struct sockaddr_mISDN *)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;
		}
	} else {
		if (msg->msg_namelen)
			printk(KERN_WARNING "%s: too small namelen %d\n",
			    __func__, msg->msg_namelen);
		msg->msg_namelen = 0;
	}

	copied = skb->len + MISDN_HEADER_LEN;
	if (len < copied) {
		if (flags & MSG_PEEK)
			atomic_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_iovec(skb, 0, msg->msg_iov, copied);

	mISDN_sock_cmsg(sk, msg, skb);

	skb_free_datagram(sk, skb);

	return err ? : copied;
}

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

	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_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
		err = -EFAULT;
		goto drop;
	}

	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 */
		maddr = (struct sockaddr_mISDN *)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 ||
	    (err = _pms(sk)->ch.recv(_pms(sk)->ch.peer, skb)))
		goto drop;

	err = len;

done:
	release_sock(sk);
	return err;

drop:
	kfree_skb(skb);
	goto done;
}

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;

			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;
			strcpy(di.name, dev_name(&dev->dev));
			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,
	char __user *optval, int len)
{
	struct sock *sk = sock->sk;
	int err = 0, opt = 0;

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

	lock_sock(sk);

	switch (optname) {
	case MISDN_TIME_STAMP:
		if (get_user(opt, (int __user *)optval)) {
			err = -EFAULT;
			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;

	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 hlist_node *node;
	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, node, &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 *addr_len, int peer)
{
	struct sockaddr_mISDN 	*maddr = (struct sockaddr_mISDN *) addr;
	struct sock		*sk = sock->sk;

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

	lock_sock(sk);

	*addr_len = sizeof(*maddr);
	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 0;
}

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)
{
	struct sock *sk;

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

	sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto);
	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;

			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;
			strcpy(di.name, dev_name(&dev->dev));
			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;
			}
			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 (!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,
	.poll		= sock_no_poll,
	.listen		= sock_no_listen,
	.shutdown	= sock_no_shutdown,
	.setsockopt	= sock_no_setsockopt,
	.getsockopt	= sock_no_getsockopt,
	.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)
{
	struct sock *sk;

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

	sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto);
	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 err = -EPROTONOSUPPORT;

	switch	(proto) {
	case ISDN_P_BASE:
		err = base_sock_create(net, sock, proto);
		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);
		break;
	default:
		return err;
	}

	return err;
}

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