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>
23 static struct proto mISDN_proto = {
26 .obj_size = sizeof(struct mISDN_sock)
29 #define _pms(sk) ((struct mISDN_sock *)sk)
31 static struct mISDN_sock_list data_sockets = {
32 .lock = __RW_LOCK_UNLOCKED(data_sockets.lock)
35 static struct mISDN_sock_list base_sockets = {
36 .lock = __RW_LOCK_UNLOCKED(base_sockets.lock)
39 #define L2_HEADER_LEN 4
41 static inline struct sk_buff *
42 _l2_alloc_skb(unsigned int len, gfp_t gfp_mask)
46 skb = alloc_skb(len + L2_HEADER_LEN, gfp_mask);
48 skb_reserve(skb, L2_HEADER_LEN);
53 mISDN_sock_link(struct mISDN_sock_list *l, struct sock *sk)
55 write_lock_bh(&l->lock);
56 sk_add_node(sk, &l->head);
57 write_unlock_bh(&l->lock);
60 static void mISDN_sock_unlink(struct mISDN_sock_list *l, struct sock *sk)
62 write_lock_bh(&l->lock);
64 write_unlock_bh(&l->lock);
68 mISDN_send(struct mISDNchannel *ch, struct sk_buff *skb)
70 struct mISDN_sock *msk;
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)
79 err = sock_queue_rcv_skb(&msk->sk, skb);
81 printk(KERN_WARNING "%s: error %d\n", __func__, err);
86 mISDN_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
88 struct mISDN_sock *msk;
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);
95 msk->sk.sk_state = MISDN_CLOSED;
102 mISDN_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
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);
113 mISDN_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
114 struct msghdr *msg, size_t len, int flags)
117 struct sock *sk = sock->sk;
118 struct sockaddr_mISDN *maddr;
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,
126 if (flags & (MSG_OOB))
129 if (sk->sk_state == MISDN_CLOSED)
132 skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &err);
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;
147 maddr->channel = _pms(sk)->ch.nr;
148 maddr->sapi = _pms(sk)->ch.addr & 0xFF;
149 maddr->tei = (_pms(sk)->ch.addr >> 8) & 0xFF;
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;
158 copied = skb->len + MISDN_HEADER_LEN;
160 if (flags & MSG_PEEK)
161 atomic_dec(&skb->users);
163 skb_queue_head(&sk->sk_receive_queue, skb);
166 memcpy(skb_push(skb, MISDN_HEADER_LEN), mISDN_HEAD_P(skb),
169 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
171 mISDN_sock_cmsg(sk, msg, skb);
173 skb_free_datagram(sk, skb);
175 return err ? : copied;
179 mISDN_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
180 struct msghdr *msg, size_t len)
182 struct sock *sk = sock->sk;
185 struct sockaddr_mISDN *maddr;
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,
192 if (msg->msg_flags & MSG_OOB)
195 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
198 if (len < MISDN_HEADER_LEN)
201 if (sk->sk_state != MISDN_BOUND)
206 skb = _l2_alloc_skb(len, GFP_KERNEL);
210 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
215 memcpy(mISDN_HEAD_P(skb), skb->data, MISDN_HEADER_LEN);
216 skb_pull(skb, MISDN_HEADER_LEN);
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;
228 if (*debug & DEBUG_SOCKET)
229 printk(KERN_DEBUG "%s: ID:%x\n",
230 __func__, mISDN_HEAD_ID(skb));
233 if (!_pms(sk)->ch.peer ||
234 (err = _pms(sk)->ch.recv(_pms(sk)->ch.peer, skb)))
249 data_sock_release(struct socket *sock)
251 struct sock *sk = sock->sk;
253 if (*debug & DEBUG_SOCKET)
254 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
257 switch (sk->sk_protocol) {
262 if (sk->sk_state == MISDN_BOUND)
263 delete_channel(&_pms(sk)->ch);
265 mISDN_sock_unlink(&data_sockets, sk);
271 case ISDN_P_B_X75SLP:
272 case ISDN_P_B_L2DTMF:
274 case ISDN_P_B_L2DSPHDLC:
275 delete_channel(&_pms(sk)->ch);
276 mISDN_sock_unlink(&data_sockets, sk);
283 skb_queue_purge(&sk->sk_receive_queue);
292 data_sock_ioctl_bound(struct sock *sk, unsigned int cmd, void __user *p)
294 struct mISDN_ctrl_req cq;
295 int err = -EINVAL, val;
296 struct mISDNchannel *bchan, *next;
299 if (!_pms(sk)->dev) {
305 if (copy_from_user(&cq, p, sizeof(cq))) {
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);
319 err = _pms(sk)->dev->D.ctrl(&_pms(sk)->dev->D,
320 CONTROL_CHANNEL, &cq);
323 if (copy_to_user(p, &cq, sizeof(cq)))
327 if (sk->sk_protocol != ISDN_P_LAPD_NT) {
331 if (get_user(val, (int __user *)p)) {
335 err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
336 CONTROL_CHANNEL, &val);
348 data_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
351 struct sock *sk = sock->sk;
352 struct mISDNdevice *dev;
353 struct mISDNversion ver;
357 ver.major = MISDN_MAJOR_VERSION;
358 ver.minor = MISDN_MINOR_VERSION;
359 ver.release = MISDN_RELEASE;
360 if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
364 id = get_mdevice_count();
365 if (put_user(id, (int __user *)arg))
369 if (get_user(id, (int __user *)arg)) {
373 dev = get_mdevice(id);
375 struct mISDN_devinfo di;
378 di.Dprotocols = dev->Dprotocols;
379 di.Bprotocols = dev->Bprotocols | get_all_Bprotocols();
380 di.protocol = dev->D.protocol;
381 memcpy(di.channelmap, dev->channelmap,
382 sizeof(di.channelmap));
383 di.nrbchan = dev->nrbchan;
384 strcpy(di.name, dev_name(&dev->dev));
385 if (copy_to_user((void __user *)arg, &di, sizeof(di)))
391 if (sk->sk_state == MISDN_BOUND)
392 err = data_sock_ioctl_bound(sk, cmd,
400 static int data_sock_setsockopt(struct socket *sock, int level, int optname,
401 char __user *optval, int len)
403 struct sock *sk = sock->sk;
404 int err = 0, opt = 0;
406 if (*debug & DEBUG_SOCKET)
407 printk(KERN_DEBUG "%s(%p, %d, %x, %p, %d)\n", __func__, sock,
408 level, optname, optval, len);
413 case MISDN_TIME_STAMP:
414 if (get_user(opt, (int __user *)optval)) {
420 _pms(sk)->cmask |= MISDN_TIME_STAMP;
422 _pms(sk)->cmask &= ~MISDN_TIME_STAMP;
432 static int data_sock_getsockopt(struct socket *sock, int level, int optname,
433 char __user *optval, int __user *optlen)
435 struct sock *sk = sock->sk;
438 if (get_user(len, optlen))
442 case MISDN_TIME_STAMP:
443 if (_pms(sk)->cmask & MISDN_TIME_STAMP)
448 if (put_user(opt, optval))
459 data_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
461 struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
462 struct sock *sk = sock->sk;
463 struct hlist_node *node;
467 if (*debug & DEBUG_SOCKET)
468 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
469 if (addr_len != sizeof(struct sockaddr_mISDN))
471 if (!maddr || maddr->family != AF_ISDN)
480 _pms(sk)->dev = get_mdevice(maddr->dev);
481 if (!_pms(sk)->dev) {
486 read_lock_bh(&data_sockets.lock);
487 sk_for_each(csk, node, &data_sockets.head) {
490 if (_pms(csk)->dev != _pms(sk)->dev)
492 if (csk->sk_protocol >= ISDN_P_B_START)
494 if (IS_ISDN_P_TE(csk->sk_protocol)
495 == IS_ISDN_P_TE(sk->sk_protocol))
497 read_unlock_bh(&data_sockets.lock);
501 read_unlock_bh(&data_sockets.lock);
503 _pms(sk)->ch.send = mISDN_send;
504 _pms(sk)->ch.ctrl = mISDN_ctrl;
506 switch (sk->sk_protocol) {
511 mISDN_sock_unlink(&data_sockets, sk);
512 err = connect_layer1(_pms(sk)->dev, &_pms(sk)->ch,
513 sk->sk_protocol, maddr);
515 mISDN_sock_link(&data_sockets, sk);
519 err = create_l2entity(_pms(sk)->dev, &_pms(sk)->ch,
520 sk->sk_protocol, maddr);
524 case ISDN_P_B_X75SLP:
525 case ISDN_P_B_L2DTMF:
527 case ISDN_P_B_L2DSPHDLC:
528 err = connect_Bstack(_pms(sk)->dev, &_pms(sk)->ch,
529 sk->sk_protocol, maddr);
532 err = -EPROTONOSUPPORT;
536 sk->sk_state = MISDN_BOUND;
537 _pms(sk)->ch.protocol = sk->sk_protocol;
545 data_sock_getname(struct socket *sock, struct sockaddr *addr,
546 int *addr_len, int peer)
548 struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
549 struct sock *sk = sock->sk;
556 *addr_len = sizeof(*maddr);
557 maddr->dev = _pms(sk)->dev->id;
558 maddr->channel = _pms(sk)->ch.nr;
559 maddr->sapi = _pms(sk)->ch.addr & 0xff;
560 maddr->tei = (_pms(sk)->ch.addr >> 8) & 0xff;
565 static const struct proto_ops data_sock_ops = {
567 .owner = THIS_MODULE,
568 .release = data_sock_release,
569 .ioctl = data_sock_ioctl,
570 .bind = data_sock_bind,
571 .getname = data_sock_getname,
572 .sendmsg = mISDN_sock_sendmsg,
573 .recvmsg = mISDN_sock_recvmsg,
574 .poll = datagram_poll,
575 .listen = sock_no_listen,
576 .shutdown = sock_no_shutdown,
577 .setsockopt = data_sock_setsockopt,
578 .getsockopt = data_sock_getsockopt,
579 .connect = sock_no_connect,
580 .socketpair = sock_no_socketpair,
581 .accept = sock_no_accept,
586 data_sock_create(struct net *net, struct socket *sock, int protocol)
590 if (sock->type != SOCK_DGRAM)
591 return -ESOCKTNOSUPPORT;
593 sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto);
597 sock_init_data(sock, sk);
599 sock->ops = &data_sock_ops;
600 sock->state = SS_UNCONNECTED;
601 sock_reset_flag(sk, SOCK_ZAPPED);
603 sk->sk_protocol = protocol;
604 sk->sk_state = MISDN_OPEN;
605 mISDN_sock_link(&data_sockets, sk);
611 base_sock_release(struct socket *sock)
613 struct sock *sk = sock->sk;
615 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
619 mISDN_sock_unlink(&base_sockets, sk);
627 base_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
630 struct mISDNdevice *dev;
631 struct mISDNversion ver;
635 ver.major = MISDN_MAJOR_VERSION;
636 ver.minor = MISDN_MINOR_VERSION;
637 ver.release = MISDN_RELEASE;
638 if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
642 id = get_mdevice_count();
643 if (put_user(id, (int __user *)arg))
647 if (get_user(id, (int __user *)arg)) {
651 dev = get_mdevice(id);
653 struct mISDN_devinfo di;
656 di.Dprotocols = dev->Dprotocols;
657 di.Bprotocols = dev->Bprotocols | get_all_Bprotocols();
658 di.protocol = dev->D.protocol;
659 memcpy(di.channelmap, dev->channelmap,
660 sizeof(di.channelmap));
661 di.nrbchan = dev->nrbchan;
662 strcpy(di.name, dev_name(&dev->dev));
663 if (copy_to_user((void __user *)arg, &di, sizeof(di)))
670 struct mISDN_devrename dn;
671 if (copy_from_user(&dn, (void __user *)arg,
676 dev = get_mdevice(dn.id);
678 err = device_rename(&dev->dev, dn.name);
690 base_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
692 struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
693 struct sock *sk = sock->sk;
696 if (!maddr || maddr->family != AF_ISDN)
706 _pms(sk)->dev = get_mdevice(maddr->dev);
707 if (!_pms(sk)->dev) {
711 sk->sk_state = MISDN_BOUND;
718 static const struct proto_ops base_sock_ops = {
720 .owner = THIS_MODULE,
721 .release = base_sock_release,
722 .ioctl = base_sock_ioctl,
723 .bind = base_sock_bind,
724 .getname = sock_no_getname,
725 .sendmsg = sock_no_sendmsg,
726 .recvmsg = sock_no_recvmsg,
727 .poll = sock_no_poll,
728 .listen = sock_no_listen,
729 .shutdown = sock_no_shutdown,
730 .setsockopt = sock_no_setsockopt,
731 .getsockopt = sock_no_getsockopt,
732 .connect = sock_no_connect,
733 .socketpair = sock_no_socketpair,
734 .accept = sock_no_accept,
740 base_sock_create(struct net *net, struct socket *sock, int protocol)
744 if (sock->type != SOCK_RAW)
745 return -ESOCKTNOSUPPORT;
747 sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto);
751 sock_init_data(sock, sk);
752 sock->ops = &base_sock_ops;
753 sock->state = SS_UNCONNECTED;
754 sock_reset_flag(sk, SOCK_ZAPPED);
755 sk->sk_protocol = protocol;
756 sk->sk_state = MISDN_OPEN;
757 mISDN_sock_link(&base_sockets, sk);
763 mISDN_sock_create(struct net *net, struct socket *sock, int proto)
765 int err = -EPROTONOSUPPORT;
769 err = base_sock_create(net, sock, proto);
779 case ISDN_P_B_X75SLP:
780 case ISDN_P_B_L2DTMF:
782 case ISDN_P_B_L2DSPHDLC:
783 err = data_sock_create(net, sock, proto);
793 net_proto_family mISDN_sock_family_ops = {
794 .owner = THIS_MODULE,
796 .create = mISDN_sock_create,
800 misdn_sock_init(u_int *deb)
805 err = sock_register(&mISDN_sock_family_ops);
807 printk(KERN_ERR "%s: error(%d)\n", __func__, err);
812 misdn_sock_cleanup(void)
814 sock_unregister(PF_ISDN);