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