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