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