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/signal.h> 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 bool kern) 323 { 324 struct sock *sk = sock->sk; 325 struct sk_buff *skb; 326 struct atmsvc_msg *msg; 327 struct atm_vcc *old_vcc = ATM_SD(sock); 328 struct atm_vcc *new_vcc; 329 int error; 330 331 lock_sock(sk); 332 333 error = svc_create(sock_net(sk), newsock, 0, kern); 334 if (error) 335 goto out; 336 337 new_vcc = ATM_SD(newsock); 338 339 pr_debug("%p -> %p\n", old_vcc, new_vcc); 340 while (1) { 341 DEFINE_WAIT(wait); 342 343 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 344 while (!(skb = skb_dequeue(&sk->sk_receive_queue)) && 345 sigd) { 346 if (test_bit(ATM_VF_RELEASED, &old_vcc->flags)) 347 break; 348 if (test_bit(ATM_VF_CLOSE, &old_vcc->flags)) { 349 error = -sk->sk_err; 350 break; 351 } 352 if (flags & O_NONBLOCK) { 353 error = -EAGAIN; 354 break; 355 } 356 release_sock(sk); 357 schedule(); 358 lock_sock(sk); 359 if (signal_pending(current)) { 360 error = -ERESTARTSYS; 361 break; 362 } 363 prepare_to_wait(sk_sleep(sk), &wait, 364 TASK_INTERRUPTIBLE); 365 } 366 finish_wait(sk_sleep(sk), &wait); 367 if (error) 368 goto out; 369 if (!skb) { 370 error = -EUNATCH; 371 goto out; 372 } 373 msg = (struct atmsvc_msg *)skb->data; 374 new_vcc->qos = msg->qos; 375 set_bit(ATM_VF_HASQOS, &new_vcc->flags); 376 new_vcc->remote = msg->svc; 377 new_vcc->local = msg->local; 378 new_vcc->sap = msg->sap; 379 error = vcc_connect(newsock, msg->pvc.sap_addr.itf, 380 msg->pvc.sap_addr.vpi, 381 msg->pvc.sap_addr.vci); 382 dev_kfree_skb(skb); 383 sk->sk_ack_backlog--; 384 if (error) { 385 sigd_enq2(NULL, as_reject, old_vcc, NULL, NULL, 386 &old_vcc->qos, error); 387 error = error == -EAGAIN ? -EBUSY : error; 388 goto out; 389 } 390 /* wait should be short, so we ignore the non-blocking flag */ 391 set_bit(ATM_VF_WAITING, &new_vcc->flags); 392 sigd_enq(new_vcc, as_accept, old_vcc, NULL, NULL); 393 for (;;) { 394 prepare_to_wait(sk_sleep(sk_atm(new_vcc)), &wait, 395 TASK_UNINTERRUPTIBLE); 396 if (!test_bit(ATM_VF_WAITING, &new_vcc->flags) || !sigd) 397 break; 398 release_sock(sk); 399 schedule(); 400 lock_sock(sk); 401 } 402 finish_wait(sk_sleep(sk_atm(new_vcc)), &wait); 403 if (!sigd) { 404 error = -EUNATCH; 405 goto out; 406 } 407 if (!sk_atm(new_vcc)->sk_err) 408 break; 409 if (sk_atm(new_vcc)->sk_err != ERESTARTSYS) { 410 error = -sk_atm(new_vcc)->sk_err; 411 goto out; 412 } 413 } 414 newsock->state = SS_CONNECTED; 415 out: 416 release_sock(sk); 417 return error; 418 } 419 420 static int svc_getname(struct socket *sock, struct sockaddr *sockaddr, 421 int *sockaddr_len, int peer) 422 { 423 struct sockaddr_atmsvc *addr; 424 425 *sockaddr_len = sizeof(struct sockaddr_atmsvc); 426 addr = (struct sockaddr_atmsvc *) sockaddr; 427 memcpy(addr, peer ? &ATM_SD(sock)->remote : &ATM_SD(sock)->local, 428 sizeof(struct sockaddr_atmsvc)); 429 return 0; 430 } 431 432 int svc_change_qos(struct atm_vcc *vcc, struct atm_qos *qos) 433 { 434 struct sock *sk = sk_atm(vcc); 435 DEFINE_WAIT(wait); 436 437 set_bit(ATM_VF_WAITING, &vcc->flags); 438 sigd_enq2(vcc, as_modify, NULL, NULL, &vcc->local, qos, 0); 439 for (;;) { 440 prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE); 441 if (!test_bit(ATM_VF_WAITING, &vcc->flags) || 442 test_bit(ATM_VF_RELEASED, &vcc->flags) || !sigd) { 443 break; 444 } 445 schedule(); 446 } 447 finish_wait(sk_sleep(sk), &wait); 448 if (!sigd) 449 return -EUNATCH; 450 return -sk->sk_err; 451 } 452 453 static int svc_setsockopt(struct socket *sock, int level, int optname, 454 char __user *optval, unsigned int optlen) 455 { 456 struct sock *sk = sock->sk; 457 struct atm_vcc *vcc = ATM_SD(sock); 458 int value, error = 0; 459 460 lock_sock(sk); 461 switch (optname) { 462 case SO_ATMSAP: 463 if (level != SOL_ATM || optlen != sizeof(struct atm_sap)) { 464 error = -EINVAL; 465 goto out; 466 } 467 if (copy_from_user(&vcc->sap, optval, optlen)) { 468 error = -EFAULT; 469 goto out; 470 } 471 set_bit(ATM_VF_HASSAP, &vcc->flags); 472 break; 473 case SO_MULTIPOINT: 474 if (level != SOL_ATM || optlen != sizeof(int)) { 475 error = -EINVAL; 476 goto out; 477 } 478 if (get_user(value, (int __user *)optval)) { 479 error = -EFAULT; 480 goto out; 481 } 482 if (value == 1) 483 set_bit(ATM_VF_SESSION, &vcc->flags); 484 else if (value == 0) 485 clear_bit(ATM_VF_SESSION, &vcc->flags); 486 else 487 error = -EINVAL; 488 break; 489 default: 490 error = vcc_setsockopt(sock, level, optname, optval, optlen); 491 } 492 493 out: 494 release_sock(sk); 495 return error; 496 } 497 498 static int svc_getsockopt(struct socket *sock, int level, int optname, 499 char __user *optval, int __user *optlen) 500 { 501 struct sock *sk = sock->sk; 502 int error = 0, len; 503 504 lock_sock(sk); 505 if (!__SO_LEVEL_MATCH(optname, level) || optname != SO_ATMSAP) { 506 error = vcc_getsockopt(sock, level, optname, optval, optlen); 507 goto out; 508 } 509 if (get_user(len, optlen)) { 510 error = -EFAULT; 511 goto out; 512 } 513 if (len != sizeof(struct atm_sap)) { 514 error = -EINVAL; 515 goto out; 516 } 517 if (copy_to_user(optval, &ATM_SD(sock)->sap, sizeof(struct atm_sap))) { 518 error = -EFAULT; 519 goto out; 520 } 521 out: 522 release_sock(sk); 523 return error; 524 } 525 526 static int svc_addparty(struct socket *sock, struct sockaddr *sockaddr, 527 int sockaddr_len, int flags) 528 { 529 DEFINE_WAIT(wait); 530 struct sock *sk = sock->sk; 531 struct atm_vcc *vcc = ATM_SD(sock); 532 int error; 533 534 lock_sock(sk); 535 set_bit(ATM_VF_WAITING, &vcc->flags); 536 sigd_enq(vcc, as_addparty, NULL, NULL, 537 (struct sockaddr_atmsvc *) sockaddr); 538 if (flags & O_NONBLOCK) { 539 error = -EINPROGRESS; 540 goto out; 541 } 542 pr_debug("added wait queue\n"); 543 for (;;) { 544 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 545 if (!test_bit(ATM_VF_WAITING, &vcc->flags) || !sigd) 546 break; 547 schedule(); 548 } 549 finish_wait(sk_sleep(sk), &wait); 550 error = -xchg(&sk->sk_err_soft, 0); 551 out: 552 release_sock(sk); 553 return error; 554 } 555 556 static int svc_dropparty(struct socket *sock, int ep_ref) 557 { 558 DEFINE_WAIT(wait); 559 struct sock *sk = sock->sk; 560 struct atm_vcc *vcc = ATM_SD(sock); 561 int error; 562 563 lock_sock(sk); 564 set_bit(ATM_VF_WAITING, &vcc->flags); 565 sigd_enq2(vcc, as_dropparty, NULL, NULL, NULL, NULL, ep_ref); 566 for (;;) { 567 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 568 if (!test_bit(ATM_VF_WAITING, &vcc->flags) || !sigd) 569 break; 570 schedule(); 571 } 572 finish_wait(sk_sleep(sk), &wait); 573 if (!sigd) { 574 error = -EUNATCH; 575 goto out; 576 } 577 error = -xchg(&sk->sk_err_soft, 0); 578 out: 579 release_sock(sk); 580 return error; 581 } 582 583 static int svc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 584 { 585 int error, ep_ref; 586 struct sockaddr_atmsvc sa; 587 struct atm_vcc *vcc = ATM_SD(sock); 588 589 switch (cmd) { 590 case ATM_ADDPARTY: 591 if (!test_bit(ATM_VF_SESSION, &vcc->flags)) 592 return -EINVAL; 593 if (copy_from_user(&sa, (void __user *) arg, sizeof(sa))) 594 return -EFAULT; 595 error = svc_addparty(sock, (struct sockaddr *)&sa, sizeof(sa), 596 0); 597 break; 598 case ATM_DROPPARTY: 599 if (!test_bit(ATM_VF_SESSION, &vcc->flags)) 600 return -EINVAL; 601 if (copy_from_user(&ep_ref, (void __user *) arg, sizeof(int))) 602 return -EFAULT; 603 error = svc_dropparty(sock, ep_ref); 604 break; 605 default: 606 error = vcc_ioctl(sock, cmd, arg); 607 } 608 609 return error; 610 } 611 612 #ifdef CONFIG_COMPAT 613 static int svc_compat_ioctl(struct socket *sock, unsigned int cmd, 614 unsigned long arg) 615 { 616 /* The definition of ATM_ADDPARTY uses the size of struct atm_iobuf. 617 But actually it takes a struct sockaddr_atmsvc, which doesn't need 618 compat handling. So all we have to do is fix up cmd... */ 619 if (cmd == COMPAT_ATM_ADDPARTY) 620 cmd = ATM_ADDPARTY; 621 622 if (cmd == ATM_ADDPARTY || cmd == ATM_DROPPARTY) 623 return svc_ioctl(sock, cmd, arg); 624 else 625 return vcc_compat_ioctl(sock, cmd, arg); 626 } 627 #endif /* CONFIG_COMPAT */ 628 629 static const struct proto_ops svc_proto_ops = { 630 .family = PF_ATMSVC, 631 .owner = THIS_MODULE, 632 633 .release = svc_release, 634 .bind = svc_bind, 635 .connect = svc_connect, 636 .socketpair = sock_no_socketpair, 637 .accept = svc_accept, 638 .getname = svc_getname, 639 .poll = vcc_poll, 640 .ioctl = svc_ioctl, 641 #ifdef CONFIG_COMPAT 642 .compat_ioctl = svc_compat_ioctl, 643 #endif 644 .listen = svc_listen, 645 .shutdown = svc_shutdown, 646 .setsockopt = svc_setsockopt, 647 .getsockopt = svc_getsockopt, 648 .sendmsg = vcc_sendmsg, 649 .recvmsg = vcc_recvmsg, 650 .mmap = sock_no_mmap, 651 .sendpage = sock_no_sendpage, 652 }; 653 654 655 static int svc_create(struct net *net, struct socket *sock, int protocol, 656 int kern) 657 { 658 int error; 659 660 if (!net_eq(net, &init_net)) 661 return -EAFNOSUPPORT; 662 663 sock->ops = &svc_proto_ops; 664 error = vcc_create(net, sock, protocol, AF_ATMSVC, kern); 665 if (error) 666 return error; 667 ATM_SD(sock)->local.sas_family = AF_ATMSVC; 668 ATM_SD(sock)->remote.sas_family = AF_ATMSVC; 669 return 0; 670 } 671 672 static const struct net_proto_family svc_family_ops = { 673 .family = PF_ATMSVC, 674 .create = svc_create, 675 .owner = THIS_MODULE, 676 }; 677 678 679 /* 680 * Initialize the ATM SVC protocol family 681 */ 682 683 int __init atmsvc_init(void) 684 { 685 return sock_register(&svc_family_ops); 686 } 687 688 void atmsvc_exit(void) 689 { 690 sock_unregister(PF_ATMSVC); 691 } 692