1
2
3
4
5
6
7
8
9
10
11
12
13
14
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 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_msg(skb, 0, msg, 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 struct sockaddr_mISDN *maddr;
183
184 if (*debug & DEBUG_SOCKET)
185 printk(KERN_DEBUG "%s: len %d flags %x ch %d proto %x\n",
186 __func__, (int)len, msg->msg_flags, _pms(sk)->ch.nr,
187 sk->sk_protocol);
188
189 if (msg->msg_flags & MSG_OOB)
190 return -EOPNOTSUPP;
191
192 if (msg->msg_flags & ~(MSG_DONTWAIT | MSG_NOSIGNAL | MSG_ERRQUEUE))
193 return -EINVAL;
194
195 if (len < MISDN_HEADER_LEN)
196 return -EINVAL;
197
198 if (sk->sk_state != MISDN_BOUND)
199 return -EBADFD;
200
201 lock_sock(sk);
202
203 skb = _l2_alloc_skb(len, GFP_KERNEL);
204 if (!skb)
205 goto done;
206
207 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
208 err = -EFAULT;
209 goto done;
210 }
211
212 memcpy(mISDN_HEAD_P(skb), skb->data, MISDN_HEADER_LEN);
213 skb_pull(skb, MISDN_HEADER_LEN);
214
215 if (msg->msg_namelen >= sizeof(struct sockaddr_mISDN)) {
216
217 maddr = (struct sockaddr_mISDN *)msg->msg_name;
218 mISDN_HEAD_ID(skb) = maddr->channel;
219 } else {
220 if ((sk->sk_protocol == ISDN_P_LAPD_TE) ||
221 (sk->sk_protocol == ISDN_P_LAPD_NT))
222 mISDN_HEAD_ID(skb) = _pms(sk)->ch.nr;
223 }
224
225 if (*debug & DEBUG_SOCKET)
226 printk(KERN_DEBUG "%s: ID:%x\n",
227 __func__, mISDN_HEAD_ID(skb));
228
229 err = -ENODEV;
230 if (!_pms(sk)->ch.peer)
231 goto done;
232 err = _pms(sk)->ch.recv(_pms(sk)->ch.peer, skb);
233 if (err)
234 goto done;
235 else {
236 skb = NULL;
237 err = len;
238 }
239
240done:
241 if (skb)
242 kfree_skb(skb);
243 release_sock(sk);
244 return err;
245}
246
247static int
248data_sock_release(struct socket *sock)
249{
250 struct sock *sk = sock->sk;
251
252 if (*debug & DEBUG_SOCKET)
253 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
254 if (!sk)
255 return 0;
256 switch (sk->sk_protocol) {
257 case ISDN_P_TE_S0:
258 case ISDN_P_NT_S0:
259 case ISDN_P_TE_E1:
260 case ISDN_P_NT_E1:
261 if (sk->sk_state == MISDN_BOUND)
262 delete_channel(&_pms(sk)->ch);
263 else
264 mISDN_sock_unlink(&data_sockets, sk);
265 break;
266 case ISDN_P_LAPD_TE:
267 case ISDN_P_LAPD_NT:
268 case ISDN_P_B_RAW:
269 case ISDN_P_B_HDLC:
270 case ISDN_P_B_X75SLP:
271 case ISDN_P_B_L2DTMF:
272 case ISDN_P_B_L2DSP:
273 case ISDN_P_B_L2DSPHDLC:
274 delete_channel(&_pms(sk)->ch);
275 mISDN_sock_unlink(&data_sockets, sk);
276 break;
277 }
278
279 lock_sock(sk);
280
281 sock_orphan(sk);
282 skb_queue_purge(&sk->sk_receive_queue);
283
284 release_sock(sk);
285 sock_put(sk);
286
287 return 0;
288}
289
290static int
291data_sock_ioctl_bound(struct sock *sk, unsigned int cmd, void __user *p)
292{
293 struct mISDN_ctrl_req cq;
294 int err = -EINVAL, val[2];
295 struct mISDNchannel *bchan, *next;
296
297 lock_sock(sk);
298 if (!_pms(sk)->dev) {
299 err = -ENODEV;
300 goto done;
301 }
302 switch (cmd) {
303 case IMCTRLREQ:
304 if (copy_from_user(&cq, p, sizeof(cq))) {
305 err = -EFAULT;
306 break;
307 }
308 if ((sk->sk_protocol & ~ISDN_P_B_MASK) == ISDN_P_B_START) {
309 list_for_each_entry_safe(bchan, next,
310 &_pms(sk)->dev->bchannels, list) {
311 if (bchan->nr == cq.channel) {
312 err = bchan->ctrl(bchan,
313 CONTROL_CHANNEL, &cq);
314 break;
315 }
316 }
317 } else
318 err = _pms(sk)->dev->D.ctrl(&_pms(sk)->dev->D,
319 CONTROL_CHANNEL, &cq);
320 if (err)
321 break;
322 if (copy_to_user(p, &cq, sizeof(cq)))
323 err = -EFAULT;
324 break;
325 case IMCLEAR_L2:
326 if (sk->sk_protocol != ISDN_P_LAPD_NT) {
327 err = -EINVAL;
328 break;
329 }
330 val[0] = cmd;
331 if (get_user(val[1], (int __user *)p)) {
332 err = -EFAULT;
333 break;
334 }
335 err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
336 CONTROL_CHANNEL, val);
337 break;
338 case IMHOLD_L1:
339 if (sk->sk_protocol != ISDN_P_LAPD_NT
340 && sk->sk_protocol != ISDN_P_LAPD_TE) {
341 err = -EINVAL;
342 break;
343 }
344 val[0] = cmd;
345 if (get_user(val[1], (int __user *)p)) {
346 err = -EFAULT;
347 break;
348 }
349 err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
350 CONTROL_CHANNEL, val);
351 break;
352 default:
353 err = -EINVAL;
354 break;
355 }
356done:
357 release_sock(sk);
358 return err;
359}
360
361static int
362data_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
363{
364 int err = 0, id;
365 struct sock *sk = sock->sk;
366 struct mISDNdevice *dev;
367 struct mISDNversion ver;
368
369 switch (cmd) {
370 case IMGETVERSION:
371 ver.major = MISDN_MAJOR_VERSION;
372 ver.minor = MISDN_MINOR_VERSION;
373 ver.release = MISDN_RELEASE;
374 if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
375 err = -EFAULT;
376 break;
377 case IMGETCOUNT:
378 id = get_mdevice_count();
379 if (put_user(id, (int __user *)arg))
380 err = -EFAULT;
381 break;
382 case IMGETDEVINFO:
383 if (get_user(id, (int __user *)arg)) {
384 err = -EFAULT;
385 break;
386 }
387 dev = get_mdevice(id);
388 if (dev) {
389 struct mISDN_devinfo di;
390
391 memset(&di, 0, sizeof(di));
392 di.id = dev->id;
393 di.Dprotocols = dev->Dprotocols;
394 di.Bprotocols = dev->Bprotocols | get_all_Bprotocols();
395 di.protocol = dev->D.protocol;
396 memcpy(di.channelmap, dev->channelmap,
397 sizeof(di.channelmap));
398 di.nrbchan = dev->nrbchan;
399 strcpy(di.name, dev_name(&dev->dev));
400 if (copy_to_user((void __user *)arg, &di, sizeof(di)))
401 err = -EFAULT;
402 } else
403 err = -ENODEV;
404 break;
405 default:
406 if (sk->sk_state == MISDN_BOUND)
407 err = data_sock_ioctl_bound(sk, cmd,
408 (void __user *)arg);
409 else
410 err = -ENOTCONN;
411 }
412 return err;
413}
414
415static int data_sock_setsockopt(struct socket *sock, int level, int optname,
416 char __user *optval, unsigned int len)
417{
418 struct sock *sk = sock->sk;
419 int err = 0, opt = 0;
420
421 if (*debug & DEBUG_SOCKET)
422 printk(KERN_DEBUG "%s(%p, %d, %x, %p, %d)\n", __func__, sock,
423 level, optname, optval, len);
424
425 lock_sock(sk);
426
427 switch (optname) {
428 case MISDN_TIME_STAMP:
429 if (get_user(opt, (int __user *)optval)) {
430 err = -EFAULT;
431 break;
432 }
433
434 if (opt)
435 _pms(sk)->cmask |= MISDN_TIME_STAMP;
436 else
437 _pms(sk)->cmask &= ~MISDN_TIME_STAMP;
438 break;
439 default:
440 err = -ENOPROTOOPT;
441 break;
442 }
443 release_sock(sk);
444 return err;
445}
446
447static int data_sock_getsockopt(struct socket *sock, int level, int optname,
448 char __user *optval, int __user *optlen)
449{
450 struct sock *sk = sock->sk;
451 int len, opt;
452
453 if (get_user(len, optlen))
454 return -EFAULT;
455
456 if (len != sizeof(char))
457 return -EINVAL;
458
459 switch (optname) {
460 case MISDN_TIME_STAMP:
461 if (_pms(sk)->cmask & MISDN_TIME_STAMP)
462 opt = 1;
463 else
464 opt = 0;
465
466 if (put_user(opt, optval))
467 return -EFAULT;
468 break;
469 default:
470 return -ENOPROTOOPT;
471 }
472
473 return 0;
474}
475
476static int
477data_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
478{
479 struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
480 struct sock *sk = sock->sk;
481 struct sock *csk;
482 int err = 0;
483
484 if (*debug & DEBUG_SOCKET)
485 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
486 if (addr_len != sizeof(struct sockaddr_mISDN))
487 return -EINVAL;
488 if (!maddr || maddr->family != AF_ISDN)
489 return -EINVAL;
490
491 lock_sock(sk);
492
493 if (_pms(sk)->dev) {
494 err = -EALREADY;
495 goto done;
496 }
497 _pms(sk)->dev = get_mdevice(maddr->dev);
498 if (!_pms(sk)->dev) {
499 err = -ENODEV;
500 goto done;
501 }
502
503 if (sk->sk_protocol < ISDN_P_B_START) {
504 read_lock_bh(&data_sockets.lock);
505 sk_for_each(csk, &data_sockets.head) {
506 if (sk == csk)
507 continue;
508 if (_pms(csk)->dev != _pms(sk)->dev)
509 continue;
510 if (csk->sk_protocol >= ISDN_P_B_START)
511 continue;
512 if (IS_ISDN_P_TE(csk->sk_protocol)
513 == IS_ISDN_P_TE(sk->sk_protocol))
514 continue;
515 read_unlock_bh(&data_sockets.lock);
516 err = -EBUSY;
517 goto done;
518 }
519 read_unlock_bh(&data_sockets.lock);
520 }
521
522 _pms(sk)->ch.send = mISDN_send;
523 _pms(sk)->ch.ctrl = mISDN_ctrl;
524
525 switch (sk->sk_protocol) {
526 case ISDN_P_TE_S0:
527 case ISDN_P_NT_S0:
528 case ISDN_P_TE_E1:
529 case ISDN_P_NT_E1:
530 mISDN_sock_unlink(&data_sockets, sk);
531 err = connect_layer1(_pms(sk)->dev, &_pms(sk)->ch,
532 sk->sk_protocol, maddr);
533 if (err)
534 mISDN_sock_link(&data_sockets, sk);
535 break;
536 case ISDN_P_LAPD_TE:
537 case ISDN_P_LAPD_NT:
538 err = create_l2entity(_pms(sk)->dev, &_pms(sk)->ch,
539 sk->sk_protocol, maddr);
540 break;
541 case ISDN_P_B_RAW:
542 case ISDN_P_B_HDLC:
543 case ISDN_P_B_X75SLP:
544 case ISDN_P_B_L2DTMF:
545 case ISDN_P_B_L2DSP:
546 case ISDN_P_B_L2DSPHDLC:
547 err = connect_Bstack(_pms(sk)->dev, &_pms(sk)->ch,
548 sk->sk_protocol, maddr);
549 break;
550 default:
551 err = -EPROTONOSUPPORT;
552 }
553 if (err)
554 goto done;
555 sk->sk_state = MISDN_BOUND;
556 _pms(sk)->ch.protocol = sk->sk_protocol;
557
558done:
559 release_sock(sk);
560 return err;
561}
562
563static int
564data_sock_getname(struct socket *sock, struct sockaddr *addr,
565 int *addr_len, int peer)
566{
567 struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
568 struct sock *sk = sock->sk;
569
570 if (!_pms(sk)->dev)
571 return -EBADFD;
572
573 lock_sock(sk);
574
575 *addr_len = sizeof(*maddr);
576 maddr->family = AF_ISDN;
577 maddr->dev = _pms(sk)->dev->id;
578 maddr->channel = _pms(sk)->ch.nr;
579 maddr->sapi = _pms(sk)->ch.addr & 0xff;
580 maddr->tei = (_pms(sk)->ch.addr >> 8) & 0xff;
581 release_sock(sk);
582 return 0;
583}
584
585static const struct proto_ops data_sock_ops = {
586 .family = PF_ISDN,
587 .owner = THIS_MODULE,
588 .release = data_sock_release,
589 .ioctl = data_sock_ioctl,
590 .bind = data_sock_bind,
591 .getname = data_sock_getname,
592 .sendmsg = mISDN_sock_sendmsg,
593 .recvmsg = mISDN_sock_recvmsg,
594 .poll = datagram_poll,
595 .listen = sock_no_listen,
596 .shutdown = sock_no_shutdown,
597 .setsockopt = data_sock_setsockopt,
598 .getsockopt = data_sock_getsockopt,
599 .connect = sock_no_connect,
600 .socketpair = sock_no_socketpair,
601 .accept = sock_no_accept,
602 .mmap = sock_no_mmap
603};
604
605static int
606data_sock_create(struct net *net, struct socket *sock, int protocol)
607{
608 struct sock *sk;
609
610 if (sock->type != SOCK_DGRAM)
611 return -ESOCKTNOSUPPORT;
612
613 sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto);
614 if (!sk)
615 return -ENOMEM;
616
617 sock_init_data(sock, sk);
618
619 sock->ops = &data_sock_ops;
620 sock->state = SS_UNCONNECTED;
621 sock_reset_flag(sk, SOCK_ZAPPED);
622
623 sk->sk_protocol = protocol;
624 sk->sk_state = MISDN_OPEN;
625 mISDN_sock_link(&data_sockets, sk);
626
627 return 0;
628}
629
630static int
631base_sock_release(struct socket *sock)
632{
633 struct sock *sk = sock->sk;
634
635 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
636 if (!sk)
637 return 0;
638
639 mISDN_sock_unlink(&base_sockets, sk);
640 sock_orphan(sk);
641 sock_put(sk);
642
643 return 0;
644}
645
646static int
647base_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
648{
649 int err = 0, id;
650 struct mISDNdevice *dev;
651 struct mISDNversion ver;
652
653 switch (cmd) {
654 case IMGETVERSION:
655 ver.major = MISDN_MAJOR_VERSION;
656 ver.minor = MISDN_MINOR_VERSION;
657 ver.release = MISDN_RELEASE;
658 if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
659 err = -EFAULT;
660 break;
661 case IMGETCOUNT:
662 id = get_mdevice_count();
663 if (put_user(id, (int __user *)arg))
664 err = -EFAULT;
665 break;
666 case IMGETDEVINFO:
667 if (get_user(id, (int __user *)arg)) {
668 err = -EFAULT;
669 break;
670 }
671 dev = get_mdevice(id);
672 if (dev) {
673 struct mISDN_devinfo di;
674
675 memset(&di, 0, sizeof(di));
676 di.id = dev->id;
677 di.Dprotocols = dev->Dprotocols;
678 di.Bprotocols = dev->Bprotocols | get_all_Bprotocols();
679 di.protocol = dev->D.protocol;
680 memcpy(di.channelmap, dev->channelmap,
681 sizeof(di.channelmap));
682 di.nrbchan = dev->nrbchan;
683 strcpy(di.name, dev_name(&dev->dev));
684 if (copy_to_user((void __user *)arg, &di, sizeof(di)))
685 err = -EFAULT;
686 } else
687 err = -ENODEV;
688 break;
689 case IMSETDEVNAME:
690 {
691 struct mISDN_devrename dn;
692 if (copy_from_user(&dn, (void __user *)arg,
693 sizeof(dn))) {
694 err = -EFAULT;
695 break;
696 }
697 dev = get_mdevice(dn.id);
698 if (dev)
699 err = device_rename(&dev->dev, dn.name);
700 else
701 err = -ENODEV;
702 }
703 break;
704 default:
705 err = -EINVAL;
706 }
707 return err;
708}
709
710static int
711base_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
712{
713 struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
714 struct sock *sk = sock->sk;
715 int err = 0;
716
717 if (!maddr || maddr->family != AF_ISDN)
718 return -EINVAL;
719
720 lock_sock(sk);
721
722 if (_pms(sk)->dev) {
723 err = -EALREADY;
724 goto done;
725 }
726
727 _pms(sk)->dev = get_mdevice(maddr->dev);
728 if (!_pms(sk)->dev) {
729 err = -ENODEV;
730 goto done;
731 }
732 sk->sk_state = MISDN_BOUND;
733
734done:
735 release_sock(sk);
736 return err;
737}
738
739static const struct proto_ops base_sock_ops = {
740 .family = PF_ISDN,
741 .owner = THIS_MODULE,
742 .release = base_sock_release,
743 .ioctl = base_sock_ioctl,
744 .bind = base_sock_bind,
745 .getname = sock_no_getname,
746 .sendmsg = sock_no_sendmsg,
747 .recvmsg = sock_no_recvmsg,
748 .poll = sock_no_poll,
749 .listen = sock_no_listen,
750 .shutdown = sock_no_shutdown,
751 .setsockopt = sock_no_setsockopt,
752 .getsockopt = sock_no_getsockopt,
753 .connect = sock_no_connect,
754 .socketpair = sock_no_socketpair,
755 .accept = sock_no_accept,
756 .mmap = sock_no_mmap
757};
758
759
760static int
761base_sock_create(struct net *net, struct socket *sock, int protocol)
762{
763 struct sock *sk;
764
765 if (sock->type != SOCK_RAW)
766 return -ESOCKTNOSUPPORT;
767
768 sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto);
769 if (!sk)
770 return -ENOMEM;
771
772 sock_init_data(sock, sk);
773 sock->ops = &base_sock_ops;
774 sock->state = SS_UNCONNECTED;
775 sock_reset_flag(sk, SOCK_ZAPPED);
776 sk->sk_protocol = protocol;
777 sk->sk_state = MISDN_OPEN;
778 mISDN_sock_link(&base_sockets, sk);
779
780 return 0;
781}
782
783static int
784mISDN_sock_create(struct net *net, struct socket *sock, int proto, int kern)
785{
786 int err = -EPROTONOSUPPORT;
787
788 switch (proto) {
789 case ISDN_P_BASE:
790 err = base_sock_create(net, sock, proto);
791 break;
792 case ISDN_P_TE_S0:
793 case ISDN_P_NT_S0:
794 case ISDN_P_TE_E1:
795 case ISDN_P_NT_E1:
796 case ISDN_P_LAPD_TE:
797 case ISDN_P_LAPD_NT:
798 case ISDN_P_B_RAW:
799 case ISDN_P_B_HDLC:
800 case ISDN_P_B_X75SLP:
801 case ISDN_P_B_L2DTMF:
802 case ISDN_P_B_L2DSP:
803 case ISDN_P_B_L2DSPHDLC:
804 err = data_sock_create(net, sock, proto);
805 break;
806 default:
807 return err;
808 }
809
810 return err;
811}
812
813static const struct net_proto_family mISDN_sock_family_ops = {
814 .owner = THIS_MODULE,
815 .family = PF_ISDN,
816 .create = mISDN_sock_create,
817};
818
819int
820misdn_sock_init(u_int *deb)
821{
822 int err;
823
824 debug = deb;
825 err = sock_register(&mISDN_sock_family_ops);
826 if (err)
827 printk(KERN_ERR "%s: error(%d)\n", __func__, err);
828 return err;
829}
830
831void
832misdn_sock_cleanup(void)
833{
834 sock_unregister(PF_ISDN);
835}
836
