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