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