xref: /openbmc/linux/drivers/isdn/mISDN/socket.c (revision b6dcefde) 
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 done;
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 		goto done;
235 	err = _pms(sk)->ch.recv(_pms(sk)->ch.peer, skb);
236 	if (err)
237 		goto done;
238 	else {
239 		skb = NULL;
240 		err = len;
241 	}
242 
243 done:
244 	if (skb)
245 		kfree_skb(skb);
246 	release_sock(sk);
247 	return err;
248 }
249 
250 static int
251 data_sock_release(struct socket *sock)
252 {
253 	struct sock *sk = sock->sk;
254 
255 	if (*debug & DEBUG_SOCKET)
256 		printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
257 	if (!sk)
258 		return 0;
259 	switch (sk->sk_protocol) {
260 	case ISDN_P_TE_S0:
261 	case ISDN_P_NT_S0:
262 	case ISDN_P_TE_E1:
263 	case ISDN_P_NT_E1:
264 		if (sk->sk_state == MISDN_BOUND)
265 			delete_channel(&_pms(sk)->ch);
266 		else
267 			mISDN_sock_unlink(&data_sockets, sk);
268 		break;
269 	case ISDN_P_LAPD_TE:
270 	case ISDN_P_LAPD_NT:
271 	case ISDN_P_B_RAW:
272 	case ISDN_P_B_HDLC:
273 	case ISDN_P_B_X75SLP:
274 	case ISDN_P_B_L2DTMF:
275 	case ISDN_P_B_L2DSP:
276 	case ISDN_P_B_L2DSPHDLC:
277 		delete_channel(&_pms(sk)->ch);
278 		mISDN_sock_unlink(&data_sockets, sk);
279 		break;
280 	}
281 
282 	lock_sock(sk);
283 
284 	sock_orphan(sk);
285 	skb_queue_purge(&sk->sk_receive_queue);
286 
287 	release_sock(sk);
288 	sock_put(sk);
289 
290 	return 0;
291 }
292 
293 static int
294 data_sock_ioctl_bound(struct sock *sk, unsigned int cmd, void __user *p)
295 {
296 	struct mISDN_ctrl_req	cq;
297 	int			err = -EINVAL, val[2];
298 	struct mISDNchannel	*bchan, *next;
299 
300 	lock_sock(sk);
301 	if (!_pms(sk)->dev) {
302 		err = -ENODEV;
303 		goto done;
304 	}
305 	switch (cmd) {
306 	case IMCTRLREQ:
307 		if (copy_from_user(&cq, p, sizeof(cq))) {
308 			err = -EFAULT;
309 			break;
310 		}
311 		if ((sk->sk_protocol & ~ISDN_P_B_MASK) == ISDN_P_B_START) {
312 			list_for_each_entry_safe(bchan, next,
313 				&_pms(sk)->dev->bchannels, list) {
314 				if (bchan->nr == cq.channel) {
315 					err = bchan->ctrl(bchan,
316 						CONTROL_CHANNEL, &cq);
317 					break;
318 				}
319 			}
320 		} else
321 			err = _pms(sk)->dev->D.ctrl(&_pms(sk)->dev->D,
322 				CONTROL_CHANNEL, &cq);
323 		if (err)
324 			break;
325 		if (copy_to_user(p, &cq, sizeof(cq)))
326 			err = -EFAULT;
327 		break;
328 	case IMCLEAR_L2:
329 		if (sk->sk_protocol != ISDN_P_LAPD_NT) {
330 			err = -EINVAL;
331 			break;
332 		}
333 		val[0] = cmd;
334 		if (get_user(val[1], (int __user *)p)) {
335 			err = -EFAULT;
336 			break;
337 		}
338 		err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
339 		    CONTROL_CHANNEL, val);
340 		break;
341 	case IMHOLD_L1:
342 		if (sk->sk_protocol != ISDN_P_LAPD_NT
343 		 && sk->sk_protocol != ISDN_P_LAPD_TE) {
344 			err = -EINVAL;
345 			break;
346 		}
347 		val[0] = cmd;
348 		if (get_user(val[1], (int __user *)p)) {
349 			err = -EFAULT;
350 			break;
351 		}
352 		err = _pms(sk)->dev->teimgr->ctrl(_pms(sk)->dev->teimgr,
353 		    CONTROL_CHANNEL, val);
354 		break;
355 	default:
356 		err = -EINVAL;
357 		break;
358 	}
359 done:
360 	release_sock(sk);
361 	return err;
362 }
363 
364 static int
365 data_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
366 {
367 	int 			err = 0, id;
368 	struct sock		*sk = sock->sk;
369 	struct mISDNdevice	*dev;
370 	struct mISDNversion	ver;
371 
372 	switch (cmd) {
373 	case IMGETVERSION:
374 		ver.major = MISDN_MAJOR_VERSION;
375 		ver.minor = MISDN_MINOR_VERSION;
376 		ver.release = MISDN_RELEASE;
377 		if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
378 			err = -EFAULT;
379 		break;
380 	case IMGETCOUNT:
381 		id = get_mdevice_count();
382 		if (put_user(id, (int __user *)arg))
383 			err = -EFAULT;
384 		break;
385 	case IMGETDEVINFO:
386 		if (get_user(id, (int __user *)arg)) {
387 			err = -EFAULT;
388 			break;
389 		}
390 		dev = get_mdevice(id);
391 		if (dev) {
392 			struct mISDN_devinfo di;
393 
394 			di.id = dev->id;
395 			di.Dprotocols = dev->Dprotocols;
396 			di.Bprotocols = dev->Bprotocols | get_all_Bprotocols();
397 			di.protocol = dev->D.protocol;
398 			memcpy(di.channelmap, dev->channelmap,
399 				sizeof(di.channelmap));
400 			di.nrbchan = dev->nrbchan;
401 			strcpy(di.name, dev_name(&dev->dev));
402 			if (copy_to_user((void __user *)arg, &di, sizeof(di)))
403 				err = -EFAULT;
404 		} else
405 			err = -ENODEV;
406 		break;
407 	default:
408 		if (sk->sk_state == MISDN_BOUND)
409 			err = data_sock_ioctl_bound(sk, cmd,
410 				(void __user *)arg);
411 		else
412 			err = -ENOTCONN;
413 	}
414 	return err;
415 }
416 
417 static int data_sock_setsockopt(struct socket *sock, int level, int optname,
418 	char __user *optval, unsigned int len)
419 {
420 	struct sock *sk = sock->sk;
421 	int err = 0, opt = 0;
422 
423 	if (*debug & DEBUG_SOCKET)
424 		printk(KERN_DEBUG "%s(%p, %d, %x, %p, %d)\n", __func__, sock,
425 		    level, optname, optval, len);
426 
427 	lock_sock(sk);
428 
429 	switch (optname) {
430 	case MISDN_TIME_STAMP:
431 		if (get_user(opt, (int __user *)optval)) {
432 			err = -EFAULT;
433 			break;
434 		}
435 
436 		if (opt)
437 			_pms(sk)->cmask |= MISDN_TIME_STAMP;
438 		else
439 			_pms(sk)->cmask &= ~MISDN_TIME_STAMP;
440 		break;
441 	default:
442 		err = -ENOPROTOOPT;
443 		break;
444 	}
445 	release_sock(sk);
446 	return err;
447 }
448 
449 static int data_sock_getsockopt(struct socket *sock, int level, int optname,
450 	char __user *optval, int __user *optlen)
451 {
452 	struct sock *sk = sock->sk;
453 	int len, opt;
454 
455 	if (get_user(len, optlen))
456 		return -EFAULT;
457 
458 	switch (optname) {
459 	case MISDN_TIME_STAMP:
460 		if (_pms(sk)->cmask & MISDN_TIME_STAMP)
461 			opt = 1;
462 		else
463 			opt = 0;
464 
465 		if (put_user(opt, optval))
466 			return -EFAULT;
467 		break;
468 	default:
469 		return -ENOPROTOOPT;
470 	}
471 
472 	return 0;
473 }
474 
475 static int
476 data_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
477 {
478 	struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
479 	struct sock *sk = sock->sk;
480 	struct hlist_node *node;
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, node, &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 
558 done:
559 	release_sock(sk);
560 	return err;
561 }
562 
563 static int
564 data_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->dev = _pms(sk)->dev->id;
577 	maddr->channel = _pms(sk)->ch.nr;
578 	maddr->sapi = _pms(sk)->ch.addr & 0xff;
579 	maddr->tei = (_pms(sk)->ch.addr >> 8) & 0xff;
580 	release_sock(sk);
581 	return 0;
582 }
583 
584 static const struct proto_ops data_sock_ops = {
585 	.family		= PF_ISDN,
586 	.owner		= THIS_MODULE,
587 	.release	= data_sock_release,
588 	.ioctl		= data_sock_ioctl,
589 	.bind		= data_sock_bind,
590 	.getname	= data_sock_getname,
591 	.sendmsg	= mISDN_sock_sendmsg,
592 	.recvmsg	= mISDN_sock_recvmsg,
593 	.poll		= datagram_poll,
594 	.listen		= sock_no_listen,
595 	.shutdown	= sock_no_shutdown,
596 	.setsockopt	= data_sock_setsockopt,
597 	.getsockopt	= data_sock_getsockopt,
598 	.connect	= sock_no_connect,
599 	.socketpair	= sock_no_socketpair,
600 	.accept		= sock_no_accept,
601 	.mmap		= sock_no_mmap
602 };
603 
604 static int
605 data_sock_create(struct net *net, struct socket *sock, int protocol)
606 {
607 	struct sock *sk;
608 
609 	if (sock->type != SOCK_DGRAM)
610 		return -ESOCKTNOSUPPORT;
611 
612 	sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto);
613 	if (!sk)
614 		return -ENOMEM;
615 
616 	sock_init_data(sock, sk);
617 
618 	sock->ops = &data_sock_ops;
619 	sock->state = SS_UNCONNECTED;
620 	sock_reset_flag(sk, SOCK_ZAPPED);
621 
622 	sk->sk_protocol = protocol;
623 	sk->sk_state    = MISDN_OPEN;
624 	mISDN_sock_link(&data_sockets, sk);
625 
626 	return 0;
627 }
628 
629 static int
630 base_sock_release(struct socket *sock)
631 {
632 	struct sock *sk = sock->sk;
633 
634 	printk(KERN_DEBUG "%s(%p) sk=%p\n", __func__, sock, sk);
635 	if (!sk)
636 		return 0;
637 
638 	mISDN_sock_unlink(&base_sockets, sk);
639 	sock_orphan(sk);
640 	sock_put(sk);
641 
642 	return 0;
643 }
644 
645 static int
646 base_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
647 {
648 	int 			err = 0, id;
649 	struct mISDNdevice	*dev;
650 	struct mISDNversion	ver;
651 
652 	switch (cmd) {
653 	case IMGETVERSION:
654 		ver.major = MISDN_MAJOR_VERSION;
655 		ver.minor = MISDN_MINOR_VERSION;
656 		ver.release = MISDN_RELEASE;
657 		if (copy_to_user((void __user *)arg, &ver, sizeof(ver)))
658 			err = -EFAULT;
659 		break;
660 	case IMGETCOUNT:
661 		id = get_mdevice_count();
662 		if (put_user(id, (int __user *)arg))
663 			err = -EFAULT;
664 		break;
665 	case IMGETDEVINFO:
666 		if (get_user(id, (int __user *)arg)) {
667 			err = -EFAULT;
668 			break;
669 		}
670 		dev = get_mdevice(id);
671 		if (dev) {
672 			struct mISDN_devinfo di;
673 
674 			di.id = dev->id;
675 			di.Dprotocols = dev->Dprotocols;
676 			di.Bprotocols = dev->Bprotocols | get_all_Bprotocols();
677 			di.protocol = dev->D.protocol;
678 			memcpy(di.channelmap, dev->channelmap,
679 				sizeof(di.channelmap));
680 			di.nrbchan = dev->nrbchan;
681 			strcpy(di.name, dev_name(&dev->dev));
682 			if (copy_to_user((void __user *)arg, &di, sizeof(di)))
683 				err = -EFAULT;
684 		} else
685 			err = -ENODEV;
686 		break;
687 	case IMSETDEVNAME:
688 		{
689 			struct mISDN_devrename dn;
690 			if (copy_from_user(&dn, (void __user *)arg,
691 			    sizeof(dn))) {
692 				err = -EFAULT;
693 				break;
694 			}
695 			dev = get_mdevice(dn.id);
696 			if (dev)
697 				err = device_rename(&dev->dev, dn.name);
698 			else
699 				err = -ENODEV;
700 		}
701 		break;
702 	default:
703 		err = -EINVAL;
704 	}
705 	return err;
706 }
707 
708 static int
709 base_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
710 {
711 	struct sockaddr_mISDN *maddr = (struct sockaddr_mISDN *) addr;
712 	struct sock *sk = sock->sk;
713 	int err = 0;
714 
715 	if (!maddr || maddr->family != AF_ISDN)
716 		return -EINVAL;
717 
718 	lock_sock(sk);
719 
720 	if (_pms(sk)->dev) {
721 		err = -EALREADY;
722 		goto done;
723 	}
724 
725 	_pms(sk)->dev = get_mdevice(maddr->dev);
726 	if (!_pms(sk)->dev) {
727 		err = -ENODEV;
728 		goto done;
729 	}
730 	sk->sk_state = MISDN_BOUND;
731 
732 done:
733 	release_sock(sk);
734 	return err;
735 }
736 
737 static const struct proto_ops base_sock_ops = {
738 	.family		= PF_ISDN,
739 	.owner		= THIS_MODULE,
740 	.release	= base_sock_release,
741 	.ioctl		= base_sock_ioctl,
742 	.bind		= base_sock_bind,
743 	.getname	= sock_no_getname,
744 	.sendmsg	= sock_no_sendmsg,
745 	.recvmsg	= sock_no_recvmsg,
746 	.poll		= sock_no_poll,
747 	.listen		= sock_no_listen,
748 	.shutdown	= sock_no_shutdown,
749 	.setsockopt	= sock_no_setsockopt,
750 	.getsockopt	= sock_no_getsockopt,
751 	.connect	= sock_no_connect,
752 	.socketpair	= sock_no_socketpair,
753 	.accept		= sock_no_accept,
754 	.mmap		= sock_no_mmap
755 };
756 
757 
758 static int
759 base_sock_create(struct net *net, struct socket *sock, int protocol)
760 {
761 	struct sock *sk;
762 
763 	if (sock->type != SOCK_RAW)
764 		return -ESOCKTNOSUPPORT;
765 
766 	sk = sk_alloc(net, PF_ISDN, GFP_KERNEL, &mISDN_proto);
767 	if (!sk)
768 		return -ENOMEM;
769 
770 	sock_init_data(sock, sk);
771 	sock->ops = &base_sock_ops;
772 	sock->state = SS_UNCONNECTED;
773 	sock_reset_flag(sk, SOCK_ZAPPED);
774 	sk->sk_protocol = protocol;
775 	sk->sk_state    = MISDN_OPEN;
776 	mISDN_sock_link(&base_sockets, sk);
777 
778 	return 0;
779 }
780 
781 static int
782 mISDN_sock_create(struct net *net, struct socket *sock, int proto, int kern)
783 {
784 	int err = -EPROTONOSUPPORT;
785 
786 	switch	(proto) {
787 	case ISDN_P_BASE:
788 		err = base_sock_create(net, sock, proto);
789 		break;
790 	case ISDN_P_TE_S0:
791 	case ISDN_P_NT_S0:
792 	case ISDN_P_TE_E1:
793 	case ISDN_P_NT_E1:
794 	case ISDN_P_LAPD_TE:
795 	case ISDN_P_LAPD_NT:
796 	case ISDN_P_B_RAW:
797 	case ISDN_P_B_HDLC:
798 	case ISDN_P_B_X75SLP:
799 	case ISDN_P_B_L2DTMF:
800 	case ISDN_P_B_L2DSP:
801 	case ISDN_P_B_L2DSPHDLC:
802 		err = data_sock_create(net, sock, proto);
803 		break;
804 	default:
805 		return err;
806 	}
807 
808 	return err;
809 }
810 
811 static const struct net_proto_family mISDN_sock_family_ops = {
812 	.owner  = THIS_MODULE,
813 	.family = PF_ISDN,
814 	.create = mISDN_sock_create,
815 };
816 
817 int
818 misdn_sock_init(u_int *deb)
819 {
820 	int err;
821 
822 	debug = deb;
823 	err = sock_register(&mISDN_sock_family_ops);
824 	if (err)
825 		printk(KERN_ERR "%s: error(%d)\n", __func__, err);
826 	return err;
827 }
828 
829 void
830 misdn_sock_cleanup(void)
831 {
832 	sock_unregister(PF_ISDN);
833 }
834 
835