[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 <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 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 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 */
		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)
		goto done;
	err = _pms(sk)->ch.recv(_pms(sk)->ch.peer, skb);
	if (err)
		goto done;
	else {
		skb = NULL;
		err = len;
	}

done:
	if (skb)
		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;
			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, unsigned 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;

	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 *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->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 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;

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