Fix small typo
[linux-2.6] / drivers / isdn / mISDN / socket.c
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
21 static u_int    *debug;
22
23 static 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
31 static struct mISDN_sock_list   data_sockets = {
32         .lock = __RW_LOCK_UNLOCKED(data_sockets.lock)
33 };
34
35 static struct mISDN_sock_list   base_sockets = {
36         .lock = __RW_LOCK_UNLOCKED(base_sockets.lock)
37 };
38
39 #define L2_HEADER_LEN   4
40
41 static 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
52 static void
53 mISDN_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
60 static 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
67 static int
68 mISDN_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
85 static int
86 mISDN_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
101 static inline void
102 mISDN_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
112 static int
113 mISDN_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
178 static int
179 mISDN_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
239 done:
240         release_sock(sk);
241         return err;
242
243 drop:
244         kfree_skb(skb);
245         goto done;
246 }
247
248 static int
249 data_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
291 static int
292 data_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         }
342 done:
343         release_sock(sk);
344         return err;
345 }
346
347 static int
348 data_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,
382                                 sizeof(di.channelmap));
383                         di.nrbchan = dev->nrbchan;
384                         strcpy(di.name, dev_name(&dev->dev));
385                         if (copy_to_user((void __user *)arg, &di, sizeof(di)))
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
400 static 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
432 static 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
458 static int
459 data_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;
463         struct hlist_node *node;
464         struct sock *csk;
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         }
485
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                 }
502                 read_unlock_bh(&data_sockets.lock);
503         }
504
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
541 done:
542         release_sock(sk);
543         return err;
544 }
545
546 static int
547 data_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
567 static 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
587 static int
588 data_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
612 static int
613 base_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
628 static int
629 base_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,
662                                 sizeof(di.channelmap));
663                         di.nrbchan = dev->nrbchan;
664                         strcpy(di.name, dev_name(&dev->dev));
665                         if (copy_to_user((void __user *)arg, &di, sizeof(di)))
666                                 err = -EFAULT;
667                 } else
668                         err = -ENODEV;
669                 break;
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)
680                                 err = device_rename(&dev->dev, dn.name);
681                         else
682                                 err = -ENODEV;
683                 }
684                 break;
685         default:
686                 err = -EINVAL;
687         }
688         return err;
689 }
690
691 static int
692 base_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
715 done:
716         release_sock(sk);
717         return err;
718 }
719
720 static 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
741 static int
742 base_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
764 static int
765 mISDN_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
794 static struct
795 net_proto_family mISDN_sock_family_ops = {
796         .owner  = THIS_MODULE,
797         .family = PF_ISDN,
798         .create = mISDN_sock_create,
799 };
800
801 int
802 misdn_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
813 void
814 misdn_sock_cleanup(void)
815 {
816         sock_unregister(PF_ISDN);
817 }
818