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
)
106 struct __kernel_old_timeval tv
;
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 (addr_len
< sizeof(struct sockaddr_mISDN
))
716 if (!maddr
|| maddr
->family
!= AF_ISDN
)
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
);