net/atm/svc.c

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