1 /* net/atm/svc.c - ATM SVC sockets */ 2 3 /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */ 4 5 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__ 6 7 #include <linux/string.h> 8 #include <linux/net.h> /* struct socket, struct proto_ops */ 9 #include <linux/errno.h> /* error codes */ 10 #include <linux/kernel.h> /* printk */ 11 #include <linux/skbuff.h> 12 #include <linux/wait.h> 13 #include <linux/sched.h> /* jiffies and HZ */ 14 #include <linux/fcntl.h> /* O_NONBLOCK */ 15 #include <linux/init.h> 16 #include <linux/atm.h> /* ATM stuff */ 17 #include <linux/atmsap.h> 18 #include <linux/atmsvc.h> 19 #include <linux/atmdev.h> 20 #include <linux/bitops.h> 21 #include <net/sock.h> /* for sock_no_* */ 22 #include <linux/uaccess.h> 23 #include <linux/export.h> 24 25 #include "resources.h" 26 #include "common.h" /* common for PVCs and SVCs */ 27 #include "signaling.h" 28 #include "addr.h" 29 30 static int svc_create(struct net *net, struct socket *sock, int protocol, 31 int kern); 32 33 /* 34 * Note: since all this is still nicely synchronized with the signaling demon, 35 * there's no need to protect sleep loops with clis. If signaling is 36 * moved into the kernel, that would change. 37 */ 38 39 40 static int svc_shutdown(struct socket *sock, int how) 41 { 42 return 0; 43 } 44 45 static void svc_disconnect(struct atm_vcc *vcc) 46 { 47 DEFINE_WAIT(wait); 48 struct sk_buff *skb; 49 struct sock *sk = sk_atm(vcc); 50 51 pr_debug("%p\n", vcc); 52 if (test_bit(ATM_VF_REGIS, &vcc->flags)) { 53 sigd_enq(vcc, as_close, NULL, NULL, NULL); 54 for (;;) { 55 prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE); 56 if (test_bit(ATM_VF_RELEASED, &vcc->flags) || !sigd) 57 break; 58 schedule(); 59 } 60 finish_wait(sk_sleep(sk), &wait); 61 } 62 /* beware - socket is still in use by atmsigd until the last 63 as_indicate has been answered */ 64 while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) { 65 atm_return(vcc, skb->truesize); 66 pr_debug("LISTEN REL\n"); 67 sigd_enq2(NULL, as_reject, vcc, NULL, NULL, &vcc->qos, 0); 68 dev_kfree_skb(skb); 69 } 70 clear_bit(ATM_VF_REGIS, &vcc->flags); 71 /* ... may retry later */ 72 } 73 74 static int svc_release(struct socket *sock) 75 { 76 struct sock *sk = sock->sk; 77 struct atm_vcc *vcc; 78 79 if (sk) { 80 vcc = ATM_SD(sock); 81 pr_debug("%p\n", vcc); 82 clear_bit(ATM_VF_READY, &vcc->flags); 83 /* 84 * VCC pointer is used as a reference, 85 * so we must not free it (thereby subjecting it to re-use) 86 * before all pending connections are closed 87 */ 88 svc_disconnect(vcc); 89 vcc_release(sock); 90 } 91 return 0; 92 } 93 94 static int svc_bind(struct socket *sock, struct sockaddr *sockaddr, 95 int sockaddr_len) 96 { 97 DEFINE_WAIT(wait); 98 struct sock *sk = sock->sk; 99 struct sockaddr_atmsvc *addr; 100 struct atm_vcc *vcc; 101 int error; 102 103 if (sockaddr_len != sizeof(struct sockaddr_atmsvc)) 104 return -EINVAL; 105 lock_sock(sk); 106 if (sock->state == SS_CONNECTED) { 107 error = -EISCONN; 108 goto out; 109 } 110 if (sock->state != SS_UNCONNECTED) { 111 error = -EINVAL; 112 goto out; 113 } 114 vcc = ATM_SD(sock); 115 addr = (struct sockaddr_atmsvc *) sockaddr; 116 if (addr->sas_family != AF_ATMSVC) { 117 error = -EAFNOSUPPORT; 118 goto out; 119 } 120 clear_bit(ATM_VF_BOUND, &vcc->flags); 121 /* failing rebind will kill old binding */ 122 /* @@@ check memory (de)allocation on rebind */ 123 if (!test_bit(ATM_VF_HASQOS, &vcc->flags)) { 124 error = -EBADFD; 125 goto out; 126 } 127 vcc->local = *addr; 128 set_bit(ATM_VF_WAITING, &vcc->flags); 129 sigd_enq(vcc, as_bind, NULL, NULL, &vcc->local); 130 for (;;) { 131 prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE); 132 if (!test_bit(ATM_VF_WAITING, &vcc->flags) || !sigd) 133 break; 134 schedule(); 135 } 136 finish_wait(sk_sleep(sk), &wait); 137 clear_bit(ATM_VF_REGIS, &vcc->flags); /* doesn't count */ 138 if (!sigd) { 139 error = -EUNATCH; 140 goto out; 141 } 142 if (!sk->sk_err) 143 set_bit(ATM_VF_BOUND, &vcc->flags); 144 error = -sk->sk_err; 145 out: 146 release_sock(sk); 147 return error; 148 } 149 150 static int svc_connect(struct socket *sock, struct sockaddr *sockaddr, 151 int sockaddr_len, int flags) 152 { 153 DEFINE_WAIT(wait); 154 struct sock *sk = sock->sk; 155 struct sockaddr_atmsvc *addr; 156 struct atm_vcc *vcc = ATM_SD(sock); 157 int error; 158 159 pr_debug("%p\n", vcc); 160 lock_sock(sk); 161 if (sockaddr_len != sizeof(struct sockaddr_atmsvc)) { 162 error = -EINVAL; 163 goto out; 164 } 165 166 switch (sock->state) { 167 default: 168 error = -EINVAL; 169 goto out; 170 case SS_CONNECTED: 171 error = -EISCONN; 172 goto out; 173 case SS_CONNECTING: 174 if (test_bit(ATM_VF_WAITING, &vcc->flags)) { 175 error = -EALREADY; 176 goto out; 177 } 178 sock->state = SS_UNCONNECTED; 179 if (sk->sk_err) { 180 error = -sk->sk_err; 181 goto out; 182 } 183 break; 184 case SS_UNCONNECTED: 185 addr = (struct sockaddr_atmsvc *) sockaddr; 186 if (addr->sas_family != AF_ATMSVC) { 187 error = -EAFNOSUPPORT; 188 goto out; 189 } 190 if (!test_bit(ATM_VF_HASQOS, &vcc->flags)) { 191 error = -EBADFD; 192 goto out; 193 } 194 if (vcc->qos.txtp.traffic_class == ATM_ANYCLASS || 195 vcc->qos.rxtp.traffic_class == ATM_ANYCLASS) { 196 error = -EINVAL; 197 goto out; 198 } 199 if (!vcc->qos.txtp.traffic_class && 200 !vcc->qos.rxtp.traffic_class) { 201 error = -EINVAL; 202 goto out; 203 } 204 vcc->remote = *addr; 205 set_bit(ATM_VF_WAITING, &vcc->flags); 206 sigd_enq(vcc, as_connect, NULL, NULL, &vcc->remote); 207 if (flags & O_NONBLOCK) { 208 sock->state = SS_CONNECTING; 209 error = -EINPROGRESS; 210 goto out; 211 } 212 error = 0; 213 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 214 while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) { 215 schedule(); 216 if (!signal_pending(current)) { 217 prepare_to_wait(sk_sleep(sk), &wait, 218 TASK_INTERRUPTIBLE); 219 continue; 220 } 221 pr_debug("*ABORT*\n"); 222 /* 223 * This is tricky: 224 * Kernel ---close--> Demon 225 * Kernel <--close--- Demon 226 * or 227 * Kernel ---close--> Demon 228 * Kernel <--error--- Demon 229 * or 230 * Kernel ---close--> Demon 231 * Kernel <--okay---- Demon 232 * Kernel <--close--- Demon 233 */ 234 sigd_enq(vcc, as_close, NULL, NULL, NULL); 235 while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) { 236 prepare_to_wait(sk_sleep(sk), &wait, 237 TASK_INTERRUPTIBLE); 238 schedule(); 239 } 240 if (!sk->sk_err) 241 while (!test_bit(ATM_VF_RELEASED, &vcc->flags) && 242 sigd) { 243 prepare_to_wait(sk_sleep(sk), &wait, 244 TASK_INTERRUPTIBLE); 245 schedule(); 246 } 247 clear_bit(ATM_VF_REGIS, &vcc->flags); 248 clear_bit(ATM_VF_RELEASED, &vcc->flags); 249 clear_bit(ATM_VF_CLOSE, &vcc->flags); 250 /* we're gone now but may connect later */ 251 error = -EINTR; 252 break; 253 } 254 finish_wait(sk_sleep(sk), &wait); 255 if (error) 256 goto out; 257 if (!sigd) { 258 error = -EUNATCH; 259 goto out; 260 } 261 if (sk->sk_err) { 262 error = -sk->sk_err; 263 goto out; 264 } 265 } 266 267 vcc->qos.txtp.max_pcr = SELECT_TOP_PCR(vcc->qos.txtp); 268 vcc->qos.txtp.pcr = 0; 269 vcc->qos.txtp.min_pcr = 0; 270 271 error = vcc_connect(sock, vcc->itf, vcc->vpi, vcc->vci); 272 if (!error) 273 sock->state = SS_CONNECTED; 274 else 275 (void)svc_disconnect(vcc); 276 out: 277 release_sock(sk); 278 return error; 279 } 280 281 static int svc_listen(struct socket *sock, int backlog) 282 { 283 DEFINE_WAIT(wait); 284 struct sock *sk = sock->sk; 285 struct atm_vcc *vcc = ATM_SD(sock); 286 int error; 287 288 pr_debug("%p\n", vcc); 289 lock_sock(sk); 290 /* let server handle listen on unbound sockets */ 291 if (test_bit(ATM_VF_SESSION, &vcc->flags)) { 292 error = -EINVAL; 293 goto out; 294 } 295 if (test_bit(ATM_VF_LISTEN, &vcc->flags)) { 296 error = -EADDRINUSE; 297 goto out; 298 } 299 set_bit(ATM_VF_WAITING, &vcc->flags); 300 sigd_enq(vcc, as_listen, NULL, NULL, &vcc->local); 301 for (;;) { 302 prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE); 303 if (!test_bit(ATM_VF_WAITING, &vcc->flags) || !sigd) 304 break; 305 schedule(); 306 } 307 finish_wait(sk_sleep(sk), &wait); 308 if (!sigd) { 309 error = -EUNATCH; 310 goto out; 311 } 312 set_bit(ATM_VF_LISTEN, &vcc->flags); 313 vcc_insert_socket(sk); 314 sk->sk_max_ack_backlog = backlog > 0 ? backlog : ATM_BACKLOG_DEFAULT; 315 error = -sk->sk_err; 316 out: 317 release_sock(sk); 318 return error; 319 } 320 321 static int svc_accept(struct socket *sock, struct socket *newsock, int flags) 322 { 323 struct sock *sk = sock->sk; 324 struct sk_buff *skb; 325 struct atmsvc_msg *msg; 326 struct atm_vcc *old_vcc = ATM_SD(sock); 327 struct atm_vcc *new_vcc; 328 int error; 329 330 lock_sock(sk); 331 332 error = svc_create(sock_net(sk), newsock, 0, 0); 333 if (error) 334 goto out; 335 336 new_vcc = ATM_SD(newsock); 337 338 pr_debug("%p -> %p\n", old_vcc, new_vcc); 339 while (1) { 340 DEFINE_WAIT(wait); 341 342 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 343 while (!(skb = skb_dequeue(&sk->sk_receive_queue)) && 344 sigd) { 345 if (test_bit(ATM_VF_RELEASED, &old_vcc->flags)) 346 break; 347 if (test_bit(ATM_VF_CLOSE, &old_vcc->flags)) { 348 error = -sk->sk_err; 349 break; 350 } 351 if (flags & O_NONBLOCK) { 352 error = -EAGAIN; 353 break; 354 } 355 release_sock(sk); 356 schedule(); 357 lock_sock(sk); 358 if (signal_pending(current)) { 359 error = -ERESTARTSYS; 360 break; 361 } 362 prepare_to_wait(sk_sleep(sk), &wait, 363 TASK_INTERRUPTIBLE); 364 } 365 finish_wait(sk_sleep(sk), &wait); 366 if (error) 367 goto out; 368 if (!skb) { 369 error = -EUNATCH; 370 goto out; 371 } 372 msg = (struct atmsvc_msg *)skb->data; 373 new_vcc->qos = msg->qos; 374 set_bit(ATM_VF_HASQOS, &new_vcc->flags); 375 new_vcc->remote = msg->svc; 376 new_vcc->local = msg->local; 377 new_vcc->sap = msg->sap; 378 error = vcc_connect(newsock, msg->pvc.sap_addr.itf, 379 msg->pvc.sap_addr.vpi, 380 msg->pvc.sap_addr.vci); 381 dev_kfree_skb(skb); 382 sk->sk_ack_backlog--; 383 if (error) { 384 sigd_enq2(NULL, as_reject, old_vcc, NULL, NULL, 385 &old_vcc->qos, error); 386 error = error == -EAGAIN ? -EBUSY : error; 387 goto out; 388 } 389 /* wait should be short, so we ignore the non-blocking flag */ 390 set_bit(ATM_VF_WAITING, &new_vcc->flags); 391 sigd_enq(new_vcc, as_accept, old_vcc, NULL, NULL); 392 for (;;) { 393 prepare_to_wait(sk_sleep(sk_atm(new_vcc)), &wait, 394 TASK_UNINTERRUPTIBLE); 395 if (!test_bit(ATM_VF_WAITING, &new_vcc->flags) || !sigd) 396 break; 397 release_sock(sk); 398 schedule(); 399 lock_sock(sk); 400 } 401 finish_wait(sk_sleep(sk_atm(new_vcc)), &wait); 402 if (!sigd) { 403 error = -EUNATCH; 404 goto out; 405 } 406 if (!sk_atm(new_vcc)->sk_err) 407 break; 408 if (sk_atm(new_vcc)->sk_err != ERESTARTSYS) { 409 error = -sk_atm(new_vcc)->sk_err; 410 goto out; 411 } 412 } 413 newsock->state = SS_CONNECTED; 414 out: 415 release_sock(sk); 416 return error; 417 } 418 419 static int svc_getname(struct socket *sock, struct sockaddr *sockaddr, 420 int *sockaddr_len, int peer) 421 { 422 struct sockaddr_atmsvc *addr; 423 424 *sockaddr_len = sizeof(struct sockaddr_atmsvc); 425 addr = (struct sockaddr_atmsvc *) sockaddr; 426 memcpy(addr, peer ? &ATM_SD(sock)->remote : &ATM_SD(sock)->local, 427 sizeof(struct sockaddr_atmsvc)); 428 return 0; 429 } 430 431 int svc_change_qos(struct atm_vcc *vcc, struct atm_qos *qos) 432 { 433 struct sock *sk = sk_atm(vcc); 434 DEFINE_WAIT(wait); 435 436 set_bit(ATM_VF_WAITING, &vcc->flags); 437 sigd_enq2(vcc, as_modify, NULL, NULL, &vcc->local, qos, 0); 438 for (;;) { 439 prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE); 440 if (!test_bit(ATM_VF_WAITING, &vcc->flags) || 441 test_bit(ATM_VF_RELEASED, &vcc->flags) || !sigd) { 442 break; 443 } 444 schedule(); 445 } 446 finish_wait(sk_sleep(sk), &wait); 447 if (!sigd) 448 return -EUNATCH; 449 return -sk->sk_err; 450 } 451 452 static int svc_setsockopt(struct socket *sock, int level, int optname, 453 char __user *optval, unsigned int optlen) 454 { 455 struct sock *sk = sock->sk; 456 struct atm_vcc *vcc = ATM_SD(sock); 457 int value, error = 0; 458 459 lock_sock(sk); 460 switch (optname) { 461 case SO_ATMSAP: 462 if (level != SOL_ATM || optlen != sizeof(struct atm_sap)) { 463 error = -EINVAL; 464 goto out; 465 } 466 if (copy_from_user(&vcc->sap, optval, optlen)) { 467 error = -EFAULT; 468 goto out; 469 } 470 set_bit(ATM_VF_HASSAP, &vcc->flags); 471 break; 472 case SO_MULTIPOINT: 473 if (level != SOL_ATM || optlen != sizeof(int)) { 474 error = -EINVAL; 475 goto out; 476 } 477 if (get_user(value, (int __user *)optval)) { 478 error = -EFAULT; 479 goto out; 480 } 481 if (value == 1) 482 set_bit(ATM_VF_SESSION, &vcc->flags); 483 else if (value == 0) 484 clear_bit(ATM_VF_SESSION, &vcc->flags); 485 else 486 error = -EINVAL; 487 break; 488 default: 489 error = vcc_setsockopt(sock, level, optname, optval, optlen); 490 } 491 492 out: 493 release_sock(sk); 494 return error; 495 } 496 497 static int svc_getsockopt(struct socket *sock, int level, int optname, 498 char __user *optval, int __user *optlen) 499 { 500 struct sock *sk = sock->sk; 501 int error = 0, len; 502 503 lock_sock(sk); 504 if (!__SO_LEVEL_MATCH(optname, level) || optname != SO_ATMSAP) { 505 error = vcc_getsockopt(sock, level, optname, optval, optlen); 506 goto out; 507 } 508 if (get_user(len, optlen)) { 509 error = -EFAULT; 510 goto out; 511 } 512 if (len != sizeof(struct atm_sap)) { 513 error = -EINVAL; 514 goto out; 515 } 516 if (copy_to_user(optval, &ATM_SD(sock)->sap, sizeof(struct atm_sap))) { 517 error = -EFAULT; 518 goto out; 519 } 520 out: 521 release_sock(sk); 522 return error; 523 } 524 525 static int svc_addparty(struct socket *sock, struct sockaddr *sockaddr, 526 int sockaddr_len, int flags) 527 { 528 DEFINE_WAIT(wait); 529 struct sock *sk = sock->sk; 530 struct atm_vcc *vcc = ATM_SD(sock); 531 int error; 532 533 lock_sock(sk); 534 set_bit(ATM_VF_WAITING, &vcc->flags); 535 sigd_enq(vcc, as_addparty, NULL, NULL, 536 (struct sockaddr_atmsvc *) sockaddr); 537 if (flags & O_NONBLOCK) { 538 error = -EINPROGRESS; 539 goto out; 540 } 541 pr_debug("added wait queue\n"); 542 for (;;) { 543 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 544 if (!test_bit(ATM_VF_WAITING, &vcc->flags) || !sigd) 545 break; 546 schedule(); 547 } 548 finish_wait(sk_sleep(sk), &wait); 549 error = xchg(&sk->sk_err_soft, 0); 550 out: 551 release_sock(sk); 552 return error; 553 } 554 555 static int svc_dropparty(struct socket *sock, int ep_ref) 556 { 557 DEFINE_WAIT(wait); 558 struct sock *sk = sock->sk; 559 struct atm_vcc *vcc = ATM_SD(sock); 560 int error; 561 562 lock_sock(sk); 563 set_bit(ATM_VF_WAITING, &vcc->flags); 564 sigd_enq2(vcc, as_dropparty, NULL, NULL, NULL, NULL, ep_ref); 565 for (;;) { 566 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 567 if (!test_bit(ATM_VF_WAITING, &vcc->flags) || !sigd) 568 break; 569 schedule(); 570 } 571 finish_wait(sk_sleep(sk), &wait); 572 if (!sigd) { 573 error = -EUNATCH; 574 goto out; 575 } 576 error = xchg(&sk->sk_err_soft, 0); 577 out: 578 release_sock(sk); 579 return error; 580 } 581 582 static int svc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 583 { 584 int error, ep_ref; 585 struct sockaddr_atmsvc sa; 586 struct atm_vcc *vcc = ATM_SD(sock); 587 588 switch (cmd) { 589 case ATM_ADDPARTY: 590 if (!test_bit(ATM_VF_SESSION, &vcc->flags)) 591 return -EINVAL; 592 if (copy_from_user(&sa, (void __user *) arg, sizeof(sa))) 593 return -EFAULT; 594 error = svc_addparty(sock, (struct sockaddr *)&sa, sizeof(sa), 595 0); 596 break; 597 case ATM_DROPPARTY: 598 if (!test_bit(ATM_VF_SESSION, &vcc->flags)) 599 return -EINVAL; 600 if (copy_from_user(&ep_ref, (void __user *) arg, sizeof(int))) 601 return -EFAULT; 602 error = svc_dropparty(sock, ep_ref); 603 break; 604 default: 605 error = vcc_ioctl(sock, cmd, arg); 606 } 607 608 return error; 609 } 610 611 #ifdef CONFIG_COMPAT 612 static int svc_compat_ioctl(struct socket *sock, unsigned int cmd, 613 unsigned long arg) 614 { 615 /* The definition of ATM_ADDPARTY uses the size of struct atm_iobuf. 616 But actually it takes a struct sockaddr_atmsvc, which doesn't need 617 compat handling. So all we have to do is fix up cmd... */ 618 if (cmd == COMPAT_ATM_ADDPARTY) 619 cmd = ATM_ADDPARTY; 620 621 if (cmd == ATM_ADDPARTY || cmd == ATM_DROPPARTY) 622 return svc_ioctl(sock, cmd, arg); 623 else 624 return vcc_compat_ioctl(sock, cmd, arg); 625 } 626 #endif /* CONFIG_COMPAT */ 627 628 static const struct proto_ops svc_proto_ops = { 629 .family = PF_ATMSVC, 630 .owner = THIS_MODULE, 631 632 .release = svc_release, 633 .bind = svc_bind, 634 .connect = svc_connect, 635 .socketpair = sock_no_socketpair, 636 .accept = svc_accept, 637 .getname = svc_getname, 638 .poll = vcc_poll, 639 .ioctl = svc_ioctl, 640 #ifdef CONFIG_COMPAT 641 .compat_ioctl = svc_compat_ioctl, 642 #endif 643 .listen = svc_listen, 644 .shutdown = svc_shutdown, 645 .setsockopt = svc_setsockopt, 646 .getsockopt = svc_getsockopt, 647 .sendmsg = vcc_sendmsg, 648 .recvmsg = vcc_recvmsg, 649 .mmap = sock_no_mmap, 650 .sendpage = sock_no_sendpage, 651 }; 652 653 654 static int svc_create(struct net *net, struct socket *sock, int protocol, 655 int kern) 656 { 657 int error; 658 659 if (!net_eq(net, &init_net)) 660 return -EAFNOSUPPORT; 661 662 sock->ops = &svc_proto_ops; 663 error = vcc_create(net, sock, protocol, AF_ATMSVC); 664 if (error) 665 return error; 666 ATM_SD(sock)->local.sas_family = AF_ATMSVC; 667 ATM_SD(sock)->remote.sas_family = AF_ATMSVC; 668 return 0; 669 } 670 671 static const struct net_proto_family svc_family_ops = { 672 .family = PF_ATMSVC, 673 .create = svc_create, 674 .owner = THIS_MODULE, 675 }; 676 677 678 /* 679 * Initialize the ATM SVC protocol family 680 */ 681 682 int __init atmsvc_init(void) 683 { 684 return sock_register(&svc_family_ops); 685 } 686 687 void atmsvc_exit(void) 688 { 689 sock_unregister(PF_ATMSVC); 690 } 691