3 * Author Karsten Keil <kkeil@novell.com>
5 * Copyright 2008 by Karsten Keil <kkeil@novell.com>
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.
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.
18 #include <linux/mISDNif.h>
19 #include <linux/slab.h>
20 #include <linux/export.h>
25 static struct proto mISDN_proto = {
28 .obj_size = sizeof(struct mISDN_sock)
31 #define _pms(sk) ((struct mISDN_sock *)sk)
33 static struct mISDN_sock_list data_sockets = {
34 .lock = __RW_LOCK_UNLOCKED(data_sockets.lock)
37 static struct mISDN_sock_list base_sockets = {
38 .lock = __RW_LOCK_UNLOCKED(base_sockets.lock)
41 #define L2_HEADER_LEN 4
43 static inline struct sk_buff *
44 _l2_alloc_skb(unsigned int len, gfp_t gfp_mask)
48 skb = alloc_skb(len + L2_HEADER_LEN, gfp_mask);
50 skb_reserve(skb, L2_HEADER_LEN);
55 mISDN_sock_link(struct mISDN_sock_list *l, struct sock *sk)
57 write_lock_bh(&l->lock);
58 sk_add_node(sk, &l->head);
59 write_unlock_bh(&l->lock);
62 static void mISDN_sock_unlink(struct mISDN_sock_list *l, struct sock *sk)
64 write_lock_bh(&l->lock);
66 write_unlock_bh(&l->lock);
70 mISDN_send(struct mISDNchannel *ch, struct sk_buff *skb)
72 struct mISDN_sock *msk;
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)
81 err = sock_queue_rcv_skb(&msk->sk, skb);
83 printk(KERN_WARNING "%s: error %d\n", __func__, err);
88 mISDN_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
90 struct mISDN_sock *msk;
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);
97 msk->sk.sk_state = MISDN_CLOSED;
104 mISDN_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
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);
115 mISDN_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
119 struct sock *sk = sock->sk;
123 if (*debug & DEBUG_SOCKET)
124 printk(KERN_DEBUG "%s: len %d, flags %x ch.nr %d, proto %x\n",
125 __func__, (int)len, flags, _pms(sk)->ch.nr,
127 if (flags & (MSG_OOB))
130 if (sk->sk_state == MISDN_CLOSED)
133 skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &err);
138 DECLARE_SOCKADDR(struct sockaddr_mISDN *, maddr, msg->msg_name);
140 maddr->family = AF_ISDN;
141 maddr->dev = _pms(sk)->dev->id;
142 if ((sk->sk_protocol == ISDN_P_LAPD_TE) ||
143 (sk->sk_protocol == ISDN_P_LAPD_NT)) {
144 maddr->channel = (mISDN_HEAD_ID(skb) >> 16) & 0xff;
145 maddr->tei = (mISDN_HEAD_ID(skb) >> 8) & 0xff;
146 maddr->sapi = mISDN_HEAD_ID(skb) & 0xff;
148 maddr->channel = _pms(sk)->ch.nr;
149 maddr->sapi = _pms(sk)->ch.addr & 0xFF;
150 maddr->tei = (_pms(sk)->ch.addr >> 8) & 0xFF;
152 msg->msg_namelen = sizeof(*maddr);
155 copied = skb->len + MISDN_HEADER_LEN;
157 if (flags & MSG_PEEK)
158 refcount_dec(&skb->users);
160 skb_queue_head(&sk->sk_receive_queue, skb);
163 memcpy(skb_push(skb, MISDN_HEADER_LEN), mISDN_HEAD_P(skb),
166 err = skb_copy_datagram_msg(skb, 0, msg, copied);
168 mISDN_sock_cmsg(sk, msg, skb);
170 skb_free_datagram(sk, skb);
172 return err ? : copied;
176 mISDN_sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
178 struct sock *sk = sock->sk;
182 if (*debug & DEBUG_SOCKET)
183 printk(KERN_DEBUG "%s: len %d flags %x ch %d proto %x\n",
184 __func__, (int)len, msg->msg_flags, _pms(sk)->ch.nr,
187 if (msg->msg_flags & MSG_OOB)
190 if (msg->msg_flags & ~(MSG_DONTWAIT | MSG_NOSIGNAL | MSG_ERRQUEUE))
193 if (len < MISDN_HEADER_LEN)
196 if (sk->sk_state != MISDN_BOUND)
201 skb = _l2_alloc_skb(len, GFP_KERNEL);
205 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
210 memcpy(mISDN_HEAD_P(skb), skb->data, MISDN_HEADER_LEN);
211 skb_pull(skb, MISDN_HEADER_LEN);
213 if (msg->msg_namelen >= sizeof(struct sockaddr_mISDN)) {
214 /* if we have a address, we use it */
215 DECLARE_SOCKADDR(struct sockaddr_mISDN *, maddr, msg->msg_name);
216 mISDN_HEAD_ID(skb) = maddr->channel;
217 } else { /* use default for L2 messages */
218 if ((sk->sk_protocol == ISDN_P_LAPD_TE) ||
219 (sk->sk_protocol == ISDN_P_LAPD_NT))
220 mISDN_HEAD_ID(skb) = _pms(sk)->ch.nr;
223 if (*debug & DEBUG_SOCKET)
224 printk(KERN_DEBUG "%s: ID:%x\n",
225 __func__, mISDN_HEAD_ID(skb));
228 if (!_pms(sk)->ch.peer)
230 err = _pms(sk)->ch.recv(_pms(sk)->ch.peer, skb);
245 data_sock_release(struct socket *sock)
247 struct sock *sk = sock->sk;
249 if (*debug & DEBUG_SOCKET)
250 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
253 switch (sk->sk_protocol) {
258 if (sk->sk_state == MISDN_BOUND)
259 delete_channel(&_pms(sk)->ch);
261 mISDN_sock_unlink(&data_sockets, sk);
267 case ISDN_P_B_X75SLP:
268 case ISDN_P_B_L2DTMF:
270 case ISDN_P_B_L2DSPHDLC:
271 delete_channel(&_pms(sk)->ch);
272 mISDN_sock_unlink(&data_sockets, sk);
279 skb_queue_purge(&sk->sk_receive_queue);
288 data_sock_ioctl_bound(struct sock *sk, unsigned int cmd, void __user *p)
290 struct mISDN_ctrl_req cq;
291 int err = -EINVAL, val[2];
292 struct mISDNchannel *bchan, *next;
295 if (!_pms(sk)->dev) {
301 if (copy_from_user(&cq, p, sizeof(cq))) {
305 if ((sk->sk_protocol & ~ISDN_P_B_MASK) == ISDN_P_B_START) {
306 list_for_each_entry_safe(bchan, next,
307 &_pms(sk)->dev->bchannels, list) {
308 if (bchan->nr == cq.channel) {
309 err = bchan->ctrl(bchan,
310 CONTROL_CHANNEL, &cq);
315 err = _pms(sk)->dev->D.ctrl(&_pms(sk)->dev->D,
316 CONTROL_CHANNEL, &cq);
319 if (copy_to_user(p, &cq, sizeof(cq)))
323 if (sk->sk_protocol != ISDN_P_LAPD_NT) {
328 if (get_user(val[1], (int __user *)p)) {
332 err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
333 CONTROL_CHANNEL, val);
336 if (sk->sk_protocol != ISDN_P_LAPD_NT
337 && sk->sk_protocol != ISDN_P_LAPD_TE) {
342 if (get_user(val[1], (int __user *)p)) {
346 err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
347 CONTROL_CHANNEL, val);
359 data_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
362 struct sock *sk = sock->sk;
363 struct mISDNdevice *dev;
364 struct mISDNversion ver;
368 ver.major = MISDN_MAJOR_VERSION;
369 ver.minor = MISDN_MINOR_VERSION;
370 ver.release = MISDN_RELEASE;
371 if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
375 id = get_mdevice_count();
376 if (put_user(id, (int __user *)arg))
380 if (get_user(id, (int __user *)arg)) {
384 dev = get_mdevice(id);
386 struct mISDN_devinfo di;
388 memset(&di, 0, sizeof(di));
390 di.Dprotocols = dev->Dprotocols;
391 di.Bprotocols = dev->Bprotocols | get_all_Bprotocols();
392 di.protocol = dev->D.protocol;
393 memcpy(di.channelmap, dev->channelmap,
394 sizeof(di.channelmap));
395 di.nrbchan = dev->nrbchan;
396 strcpy(di.name, dev_name(&dev->dev));
397 if (copy_to_user((void __user *)arg, &di, sizeof(di)))
403 if (sk->sk_state == MISDN_BOUND)
404 err = data_sock_ioctl_bound(sk, cmd,
412 static int data_sock_setsockopt(struct socket *sock, int level, int optname,
413 char __user *optval, unsigned int len)
415 struct sock *sk = sock->sk;
416 int err = 0, opt = 0;
418 if (*debug & DEBUG_SOCKET)
419 printk(KERN_DEBUG "%s(%p, %d, %x, %p, %d)\n", __func__, sock,
420 level, optname, optval, len);
425 case MISDN_TIME_STAMP:
426 if (get_user(opt, (int __user *)optval)) {
432 _pms(sk)->cmask |= MISDN_TIME_STAMP;
434 _pms(sk)->cmask &= ~MISDN_TIME_STAMP;
444 static int data_sock_getsockopt(struct socket *sock, int level, int optname,
445 char __user *optval, int __user *optlen)
447 struct sock *sk = sock->sk;
450 if (get_user(len, optlen))
453 if (len != sizeof(char))
457 case MISDN_TIME_STAMP:
458 if (_pms(sk)->cmask & MISDN_TIME_STAMP)
463 if (put_user(opt, optval))
474 data_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
476 struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
477 struct sock *sk = sock->sk;
481 if (*debug & DEBUG_SOCKET)
482 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
483 if (addr_len != sizeof(struct sockaddr_mISDN))
485 if (!maddr || maddr->family != AF_ISDN)
494 _pms(sk)->dev = get_mdevice(maddr->dev);
495 if (!_pms(sk)->dev) {
500 if (sk->sk_protocol < ISDN_P_B_START) {
501 read_lock_bh(&data_sockets.lock);
502 sk_for_each(csk, &data_sockets.head) {
505 if (_pms(csk)->dev != _pms(sk)->dev)
507 if (csk->sk_protocol >= ISDN_P_B_START)
509 if (IS_ISDN_P_TE(csk->sk_protocol)
510 == IS_ISDN_P_TE(sk->sk_protocol))
512 read_unlock_bh(&data_sockets.lock);
516 read_unlock_bh(&data_sockets.lock);
519 _pms(sk)->ch.send = mISDN_send;
520 _pms(sk)->ch.ctrl = mISDN_ctrl;
522 switch (sk->sk_protocol) {
527 mISDN_sock_unlink(&data_sockets, sk);
528 err = connect_layer1(_pms(sk)->dev, &_pms(sk)->ch,
529 sk->sk_protocol, maddr);
531 mISDN_sock_link(&data_sockets, sk);
535 err = create_l2entity(_pms(sk)->dev, &_pms(sk)->ch,
536 sk->sk_protocol, maddr);
540 case ISDN_P_B_X75SLP:
541 case ISDN_P_B_L2DTMF:
543 case ISDN_P_B_L2DSPHDLC:
544 err = connect_Bstack(_pms(sk)->dev, &_pms(sk)->ch,
545 sk->sk_protocol, maddr);
548 err = -EPROTONOSUPPORT;
552 sk->sk_state = MISDN_BOUND;
553 _pms(sk)->ch.protocol = sk->sk_protocol;
561 data_sock_getname(struct socket *sock, struct sockaddr *addr,
564 struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
565 struct sock *sk = sock->sk;
572 maddr->family = AF_ISDN;
573 maddr->dev = _pms(sk)->dev->id;
574 maddr->channel = _pms(sk)->ch.nr;
575 maddr->sapi = _pms(sk)->ch.addr & 0xff;
576 maddr->tei = (_pms(sk)->ch.addr >> 8) & 0xff;
578 return sizeof(*maddr);
581 static const struct proto_ops data_sock_ops = {
583 .owner = THIS_MODULE,
584 .release = data_sock_release,
585 .ioctl = data_sock_ioctl,
586 .bind = data_sock_bind,
587 .getname = data_sock_getname,
588 .sendmsg = mISDN_sock_sendmsg,
589 .recvmsg = mISDN_sock_recvmsg,
590 .poll = datagram_poll,
591 .listen = sock_no_listen,
592 .shutdown = sock_no_shutdown,
593 .setsockopt = data_sock_setsockopt,
594 .getsockopt = data_sock_getsockopt,
595 .connect = sock_no_connect,
596 .socketpair = sock_no_socketpair,
597 .accept = sock_no_accept,
602 data_sock_create(struct net *net, struct socket *sock, int protocol, int kern)
606 if (sock->type != SOCK_DGRAM)
607 return -ESOCKTNOSUPPORT;
609 sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto, kern);
613 sock_init_data(sock, sk);
615 sock->ops = &data_sock_ops;
616 sock->state = SS_UNCONNECTED;
617 sock_reset_flag(sk, SOCK_ZAPPED);
619 sk->sk_protocol = protocol;
620 sk->sk_state = MISDN_OPEN;
621 mISDN_sock_link(&data_sockets, sk);
627 base_sock_release(struct socket *sock)
629 struct sock *sk = sock->sk;
631 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
635 mISDN_sock_unlink(&base_sockets, sk);
643 base_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
646 struct mISDNdevice *dev;
647 struct mISDNversion ver;
651 ver.major = MISDN_MAJOR_VERSION;
652 ver.minor = MISDN_MINOR_VERSION;
653 ver.release = MISDN_RELEASE;
654 if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
658 id = get_mdevice_count();
659 if (put_user(id, (int __user *)arg))
663 if (get_user(id, (int __user *)arg)) {
667 dev = get_mdevice(id);
669 struct mISDN_devinfo di;
671 memset(&di, 0, sizeof(di));
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,
677 sizeof(di.channelmap));
678 di.nrbchan = dev->nrbchan;
679 strcpy(di.name, dev_name(&dev->dev));
680 if (copy_to_user((void __user *)arg, &di, sizeof(di)))
687 struct mISDN_devrename dn;
688 if (copy_from_user(&dn, (void __user *)arg,
693 dev = get_mdevice(dn.id);
695 err = device_rename(&dev->dev, dn.name);
707 base_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
709 struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
710 struct sock *sk = sock->sk;
713 if (!maddr || maddr->family != AF_ISDN)
716 if (addr_len < sizeof(struct sockaddr_mISDN))
726 _pms(sk)->dev = get_mdevice(maddr->dev);
727 if (!_pms(sk)->dev) {
731 sk->sk_state = MISDN_BOUND;
738 static const struct proto_ops base_sock_ops = {
740 .owner = THIS_MODULE,
741 .release = base_sock_release,
742 .ioctl = base_sock_ioctl,
743 .bind = base_sock_bind,
744 .getname = sock_no_getname,
745 .sendmsg = sock_no_sendmsg,
746 .recvmsg = sock_no_recvmsg,
747 .listen = sock_no_listen,
748 .shutdown = sock_no_shutdown,
749 .setsockopt = sock_no_setsockopt,
750 .getsockopt = sock_no_getsockopt,
751 .connect = sock_no_connect,
752 .socketpair = sock_no_socketpair,
753 .accept = sock_no_accept,
759 base_sock_create(struct net *net, struct socket *sock, int protocol, int kern)
763 if (sock->type != SOCK_RAW)
764 return -ESOCKTNOSUPPORT;
766 sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto, kern);
770 sock_init_data(sock, sk);
771 sock->ops = &base_sock_ops;
772 sock->state = SS_UNCONNECTED;
773 sock_reset_flag(sk, SOCK_ZAPPED);
774 sk->sk_protocol = protocol;
775 sk->sk_state = MISDN_OPEN;
776 mISDN_sock_link(&base_sockets, sk);
782 mISDN_sock_create(struct net *net, struct socket *sock, int proto, int kern)
784 int err = -EPROTONOSUPPORT;
788 err = base_sock_create(net, sock, proto, kern);
798 case ISDN_P_B_X75SLP:
799 case ISDN_P_B_L2DTMF:
801 case ISDN_P_B_L2DSPHDLC:
802 err = data_sock_create(net, sock, proto, kern);
811 static const struct net_proto_family mISDN_sock_family_ops = {
812 .owner = THIS_MODULE,
814 .create = mISDN_sock_create,
818 misdn_sock_init(u_int *deb)
823 err = sock_register(&mISDN_sock_family_ops);
825 printk(KERN_ERR "%s: error(%d)\n", __func__, err);
830 misdn_sock_cleanup(void)
832 sock_unregister(PF_ISDN);