include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-3.10.git] / 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 <linux/slab.h>
20 #include "core.h"
21
22 static u_int    *debug;
23
24 static struct proto mISDN_proto = {
25         .name           = "misdn",
26         .owner          = THIS_MODULE,
27         .obj_size       = sizeof(struct mISDN_sock)
28 };
29
30 #define _pms(sk)        ((struct mISDN_sock *)sk)
31
32 static struct mISDN_sock_list   data_sockets = {
33         .lock = __RW_LOCK_UNLOCKED(data_sockets.lock)
34 };
35
36 static struct mISDN_sock_list   base_sockets = {
37         .lock = __RW_LOCK_UNLOCKED(base_sockets.lock)
38 };
39
40 #define L2_HEADER_LEN   4
41
42 static inline struct sk_buff *
43 _l2_alloc_skb(unsigned int len, gfp_t gfp_mask)
44 {
45         struct sk_buff  *skb;
46
47         skb = alloc_skb(len + L2_HEADER_LEN, gfp_mask);
48         if (likely(skb))
49                 skb_reserve(skb, L2_HEADER_LEN);
50         return skb;
51 }
52
53 static void
54 mISDN_sock_link(struct mISDN_sock_list *l, struct sock *sk)
55 {
56         write_lock_bh(&l->lock);
57         sk_add_node(sk, &l->head);
58         write_unlock_bh(&l->lock);
59 }
60
61 static void mISDN_sock_unlink(struct mISDN_sock_list *l, struct sock *sk)
62 {
63         write_lock_bh(&l->lock);
64         sk_del_node_init(sk);
65         write_unlock_bh(&l->lock);
66 }
67
68 static int
69 mISDN_send(struct mISDNchannel *ch, struct sk_buff *skb)
70 {
71         struct mISDN_sock *msk;
72         int     err;
73
74         msk = container_of(ch, struct mISDN_sock, ch);
75         if (*debug & DEBUG_SOCKET)
76                 printk(KERN_DEBUG "%s len %d %p\n", __func__, skb->len, skb);
77         if (msk->sk.sk_state == MISDN_CLOSED)
78                 return -EUNATCH;
79         __net_timestamp(skb);
80         err = sock_queue_rcv_skb(&msk->sk, skb);
81         if (err)
82                 printk(KERN_WARNING "%s: error %d\n", __func__, err);
83         return err;
84 }
85
86 static int
87 mISDN_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
88 {
89         struct mISDN_sock *msk;
90
91         msk = container_of(ch, struct mISDN_sock, ch);
92         if (*debug & DEBUG_SOCKET)
93                 printk(KERN_DEBUG "%s(%p, %x, %p)\n", __func__, ch, cmd, arg);
94         switch (cmd) {
95         case CLOSE_CHANNEL:
96                 msk->sk.sk_state = MISDN_CLOSED;
97                 break;
98         }
99         return 0;
100 }
101
102 static inline void
103 mISDN_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
104 {
105         struct timeval  tv;
106
107         if (_pms(sk)->cmask & MISDN_TIME_STAMP) {
108                 skb_get_timestamp(skb, &tv);
109                 put_cmsg(msg, SOL_MISDN, MISDN_TIME_STAMP, sizeof(tv), &tv);
110         }
111 }
112
113 static int
114 mISDN_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
115     struct msghdr *msg, size_t len, int flags)
116 {
117         struct sk_buff          *skb;
118         struct sock             *sk = sock->sk;
119         struct sockaddr_mISDN   *maddr;
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_namelen >= sizeof(struct sockaddr_mISDN)) {
138                 msg->msg_namelen = sizeof(struct sockaddr_mISDN);
139                 maddr = (struct sockaddr_mISDN *)msg->msg_name;
140                 maddr->family = AF_ISDN;
141                 maddr->dev = _pms(sk)->dev->id;
142                 if ((sk->sk_protocol == ISDN_P_LAPD_TE) ||
143                     (sk->sk_protocol == ISDN_P_LAPD_NT)) {
144                         maddr->channel = (mISDN_HEAD_ID(skb) >> 16) & 0xff;
145                         maddr->tei =  (mISDN_HEAD_ID(skb) >> 8) & 0xff;
146                         maddr->sapi = mISDN_HEAD_ID(skb) & 0xff;
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         } else {
153                 if (msg->msg_namelen)
154                         printk(KERN_WARNING "%s: too small namelen %d\n",
155                             __func__, msg->msg_namelen);
156                 msg->msg_namelen = 0;
157         }
158
159         copied = skb->len + MISDN_HEADER_LEN;
160         if (len < copied) {
161                 if (flags & MSG_PEEK)
162                         atomic_dec(&skb->users);
163                 else
164                         skb_queue_head(&sk->sk_receive_queue, skb);
165                 return -ENOSPC;
166         }
167         memcpy(skb_push(skb, MISDN_HEADER_LEN), mISDN_HEAD_P(skb),
168             MISDN_HEADER_LEN);
169
170         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
171
172         mISDN_sock_cmsg(sk, msg, skb);
173
174         skb_free_datagram(sk, skb);
175
176         return err ? : copied;
177 }
178
179 static int
180 mISDN_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
181     struct msghdr *msg, size_t len)
182 {
183         struct sock             *sk = sock->sk;
184         struct sk_buff          *skb;
185         int                     err = -ENOMEM;
186         struct sockaddr_mISDN   *maddr;
187
188         if (*debug & DEBUG_SOCKET)
189                 printk(KERN_DEBUG "%s: len %d flags %x ch %d proto %x\n",
190                      __func__, (int)len, msg->msg_flags, _pms(sk)->ch.nr,
191                      sk->sk_protocol);
192
193         if (msg->msg_flags & MSG_OOB)
194                 return -EOPNOTSUPP;
195
196         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
197                 return -EINVAL;
198
199         if (len < MISDN_HEADER_LEN)
200                 return -EINVAL;
201
202         if (sk->sk_state != MISDN_BOUND)
203                 return -EBADFD;
204
205         lock_sock(sk);
206
207         skb = _l2_alloc_skb(len, GFP_KERNEL);
208         if (!skb)
209                 goto done;
210
211         if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
212                 err = -EFAULT;
213                 goto done;
214         }
215
216         memcpy(mISDN_HEAD_P(skb), skb->data, MISDN_HEADER_LEN);
217         skb_pull(skb, MISDN_HEADER_LEN);
218
219         if (msg->msg_namelen >= sizeof(struct sockaddr_mISDN)) {
220                 /* if we have a address, we use it */
221                 maddr = (struct sockaddr_mISDN *)msg->msg_name;
222                 mISDN_HEAD_ID(skb) = maddr->channel;
223         } else { /* use default for L2 messages */
224                 if ((sk->sk_protocol == ISDN_P_LAPD_TE) ||
225                     (sk->sk_protocol == ISDN_P_LAPD_NT))
226                         mISDN_HEAD_ID(skb) = _pms(sk)->ch.nr;
227         }
228
229         if (*debug & DEBUG_SOCKET)
230                 printk(KERN_DEBUG "%s: ID:%x\n",
231                      __func__, mISDN_HEAD_ID(skb));
232
233         err = -ENODEV;
234         if (!_pms(sk)->ch.peer)
235                 goto done;
236         err = _pms(sk)->ch.recv(_pms(sk)->ch.peer, skb);
237         if (err)
238                 goto done;
239         else {
240                 skb = NULL;
241                 err = len;
242         }
243
244 done:
245         if (skb)
246                 kfree_skb(skb);
247         release_sock(sk);
248         return err;
249 }
250
251 static int
252 data_sock_release(struct socket *sock)
253 {
254         struct sock *sk = sock->sk;
255
256         if (*debug & DEBUG_SOCKET)
257                 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
258         if (!sk)
259                 return 0;
260         switch (sk->sk_protocol) {
261         case ISDN_P_TE_S0:
262         case ISDN_P_NT_S0:
263         case ISDN_P_TE_E1:
264         case ISDN_P_NT_E1:
265                 if (sk->sk_state == MISDN_BOUND)
266                         delete_channel(&_pms(sk)->ch);
267                 else
268                         mISDN_sock_unlink(&data_sockets, sk);
269                 break;
270         case ISDN_P_LAPD_TE:
271         case ISDN_P_LAPD_NT:
272         case ISDN_P_B_RAW:
273         case ISDN_P_B_HDLC:
274         case ISDN_P_B_X75SLP:
275         case ISDN_P_B_L2DTMF:
276         case ISDN_P_B_L2DSP:
277         case ISDN_P_B_L2DSPHDLC:
278                 delete_channel(&_pms(sk)->ch);
279                 mISDN_sock_unlink(&data_sockets, sk);
280                 break;
281         }
282
283         lock_sock(sk);
284
285         sock_orphan(sk);
286         skb_queue_purge(&sk->sk_receive_queue);
287
288         release_sock(sk);
289         sock_put(sk);
290
291         return 0;
292 }
293
294 static int
295 data_sock_ioctl_bound(struct sock *sk, unsigned int cmd, void __user *p)
296 {
297         struct mISDN_ctrl_req   cq;
298         int                     err = -EINVAL, val[2];
299         struct mISDNchannel     *bchan, *next;
300
301         lock_sock(sk);
302         if (!_pms(sk)->dev) {
303                 err = -ENODEV;
304                 goto done;
305         }
306         switch (cmd) {
307         case IMCTRLREQ:
308                 if (copy_from_user(&cq, p, sizeof(cq))) {
309                         err = -EFAULT;
310                         break;
311                 }
312                 if ((sk->sk_protocol & ~ISDN_P_B_MASK) == ISDN_P_B_START) {
313                         list_for_each_entry_safe(bchan, next,
314                                 &_pms(sk)->dev->bchannels, list) {
315                                 if (bchan->nr == cq.channel) {
316                                         err = bchan->ctrl(bchan,
317                                                 CONTROL_CHANNEL, &cq);
318                                         break;
319                                 }
320                         }
321                 } else
322                         err = _pms(sk)->dev->D.ctrl(&_pms(sk)->dev->D,
323                                 CONTROL_CHANNEL, &cq);
324                 if (err)
325                         break;
326                 if (copy_to_user(p, &cq, sizeof(cq)))
327                         err = -EFAULT;
328                 break;
329         case IMCLEAR_L2:
330                 if (sk->sk_protocol != ISDN_P_LAPD_NT) {
331                         err = -EINVAL;
332                         break;
333                 }
334                 val[0] = cmd;
335                 if (get_user(val[1], (int __user *)p)) {
336                         err = -EFAULT;
337                         break;
338                 }
339                 err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
340                     CONTROL_CHANNEL, val);
341                 break;
342         case IMHOLD_L1:
343                 if (sk->sk_protocol != ISDN_P_LAPD_NT
344                  && sk->sk_protocol != ISDN_P_LAPD_TE) {
345                         err = -EINVAL;
346                         break;
347                 }
348                 val[0] = cmd;
349                 if (get_user(val[1], (int __user *)p)) {
350                         err = -EFAULT;
351                         break;
352                 }
353                 err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
354                     CONTROL_CHANNEL, val);
355                 break;
356         default:
357                 err = -EINVAL;
358                 break;
359         }
360 done:
361         release_sock(sk);
362         return err;
363 }
364
365 static int
366 data_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
367 {
368         int                     err = 0, id;
369         struct sock             *sk = sock->sk;
370         struct mISDNdevice      *dev;
371         struct mISDNversion     ver;
372
373         switch (cmd) {
374         case IMGETVERSION:
375                 ver.major = MISDN_MAJOR_VERSION;
376                 ver.minor = MISDN_MINOR_VERSION;
377                 ver.release = MISDN_RELEASE;
378                 if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
379                         err = -EFAULT;
380                 break;
381         case IMGETCOUNT:
382                 id = get_mdevice_count();
383                 if (put_user(id, (int __user *)arg))
384                         err = -EFAULT;
385                 break;
386         case IMGETDEVINFO:
387                 if (get_user(id, (int __user *)arg)) {
388                         err = -EFAULT;
389                         break;
390                 }
391                 dev = get_mdevice(id);
392                 if (dev) {
393                         struct mISDN_devinfo di;
394
395                         di.id = dev->id;
396                         di.Dprotocols = dev->Dprotocols;
397                         di.Bprotocols = dev->Bprotocols | get_all_Bprotocols();
398                         di.protocol = dev->D.protocol;
399                         memcpy(di.channelmap, dev->channelmap,
400                                 sizeof(di.channelmap));
401                         di.nrbchan = dev->nrbchan;
402                         strcpy(di.name, dev_name(&dev->dev));
403                         if (copy_to_user((void __user *)arg, &di, sizeof(di)))
404                                 err = -EFAULT;
405                 } else
406                         err = -ENODEV;
407                 break;
408         default:
409                 if (sk->sk_state == MISDN_BOUND)
410                         err = data_sock_ioctl_bound(sk, cmd,
411                                 (void __user *)arg);
412                 else
413                         err = -ENOTCONN;
414         }
415         return err;
416 }
417
418 static int data_sock_setsockopt(struct socket *sock, int level, int optname,
419         char __user *optval, unsigned int len)
420 {
421         struct sock *sk = sock->sk;
422         int err = 0, opt = 0;
423
424         if (*debug & DEBUG_SOCKET)
425                 printk(KERN_DEBUG "%s(%p, %d, %x, %p, %d)\n", __func__, sock,
426                     level, optname, optval, len);
427
428         lock_sock(sk);
429
430         switch (optname) {
431         case MISDN_TIME_STAMP:
432                 if (get_user(opt, (int __user *)optval)) {
433                         err = -EFAULT;
434                         break;
435                 }
436
437                 if (opt)
438                         _pms(sk)->cmask |= MISDN_TIME_STAMP;
439                 else
440                         _pms(sk)->cmask &= ~MISDN_TIME_STAMP;
441                 break;
442         default:
443                 err = -ENOPROTOOPT;
444                 break;
445         }
446         release_sock(sk);
447         return err;
448 }
449
450 static int data_sock_getsockopt(struct socket *sock, int level, int optname,
451         char __user *optval, int __user *optlen)
452 {
453         struct sock *sk = sock->sk;
454         int len, opt;
455
456         if (get_user(len, optlen))
457                 return -EFAULT;
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
476 static int
477 data_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 hlist_node *node;
482         struct sock *csk;
483         int err = 0;
484
485         if (*debug & DEBUG_SOCKET)
486                 printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
487         if (addr_len != sizeof(struct sockaddr_mISDN))
488                 return -EINVAL;
489         if (!maddr || maddr->family != AF_ISDN)
490                 return -EINVAL;
491
492         lock_sock(sk);
493
494         if (_pms(sk)->dev) {
495                 err = -EALREADY;
496                 goto done;
497         }
498         _pms(sk)->dev = get_mdevice(maddr->dev);
499         if (!_pms(sk)->dev) {
500                 err = -ENODEV;
501                 goto done;
502         }
503
504         if (sk->sk_protocol < ISDN_P_B_START) {
505                 read_lock_bh(&data_sockets.lock);
506                 sk_for_each(csk, node, &data_sockets.head) {
507                         if (sk == csk)
508                                 continue;
509                         if (_pms(csk)->dev != _pms(sk)->dev)
510                                 continue;
511                         if (csk->sk_protocol >= ISDN_P_B_START)
512                                 continue;
513                         if (IS_ISDN_P_TE(csk->sk_protocol)
514                                         == IS_ISDN_P_TE(sk->sk_protocol))
515                                 continue;
516                         read_unlock_bh(&data_sockets.lock);
517                         err = -EBUSY;
518                         goto done;
519                 }
520                 read_unlock_bh(&data_sockets.lock);
521         }
522
523         _pms(sk)->ch.send = mISDN_send;
524         _pms(sk)->ch.ctrl = mISDN_ctrl;
525
526         switch (sk->sk_protocol) {
527         case ISDN_P_TE_S0:
528         case ISDN_P_NT_S0:
529         case ISDN_P_TE_E1:
530         case ISDN_P_NT_E1:
531                 mISDN_sock_unlink(&data_sockets, sk);
532                 err = connect_layer1(_pms(sk)->dev, &_pms(sk)->ch,
533                     sk->sk_protocol, maddr);
534                 if (err)
535                         mISDN_sock_link(&data_sockets, sk);
536                 break;
537         case ISDN_P_LAPD_TE:
538         case ISDN_P_LAPD_NT:
539                 err = create_l2entity(_pms(sk)->dev, &_pms(sk)->ch,
540                     sk->sk_protocol, maddr);
541                 break;
542         case ISDN_P_B_RAW:
543         case ISDN_P_B_HDLC:
544         case ISDN_P_B_X75SLP:
545         case ISDN_P_B_L2DTMF:
546         case ISDN_P_B_L2DSP:
547         case ISDN_P_B_L2DSPHDLC:
548                 err = connect_Bstack(_pms(sk)->dev, &_pms(sk)->ch,
549                     sk->sk_protocol, maddr);
550                 break;
551         default:
552                 err = -EPROTONOSUPPORT;
553         }
554         if (err)
555                 goto done;
556         sk->sk_state = MISDN_BOUND;
557         _pms(sk)->ch.protocol = sk->sk_protocol;
558
559 done:
560         release_sock(sk);
561         return err;
562 }
563
564 static int
565 data_sock_getname(struct socket *sock, struct sockaddr *addr,
566     int *addr_len, int peer)
567 {
568         struct sockaddr_mISDN   *maddr = (struct sockaddr_mISDN *) addr;
569         struct sock             *sk = sock->sk;
570
571         if (!_pms(sk)->dev)
572                 return -EBADFD;
573
574         lock_sock(sk);
575
576         *addr_len = sizeof(*maddr);
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
585 static 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
605 static int
606 data_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
630 static int
631 base_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
646 static int
647 base_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                         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
709 static int
710 base_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
733 done:
734         release_sock(sk);
735         return err;
736 }
737
738 static 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
759 static int
760 base_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
782 static int
783 mISDN_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
812 static const struct net_proto_family mISDN_sock_family_ops = {
813         .owner  = THIS_MODULE,
814         .family = PF_ISDN,
815         .create = mISDN_sock_create,
816 };
817
818 int
819 misdn_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
830 void
831 misdn_sock_cleanup(void)
832 {
833         sock_unregister(PF_ISDN);
834 }
835