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