src/vcl/vcom.c

   1 /*
   2  * Copyright (c) 2016 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 #include <unistd.h>
  16 #include <stdio.h>
  17 #include <signal.h>
  18 #include <dlfcn.h>
  19 #include <pthread.h>
  20 #include <time.h>
  21 #include <stdarg.h>
  22 #include <sys/resource.h>
  23
  24 #include <vcl/vcom_socket_wrapper.h>
  25 #include <vcl/vcom.h>
  26 #include <sys/time.h>
  27
  28 #include <vcl/vppcom.h>
  29 #include <vcl/vcom_socket.h>
  30
  31 /* GCC have printf type attribute check. */
  32 #ifdef HAVE_FUNCTION_ATTRIBUTE_FORMAT
  33 #define PRINTF_ATTRIBUTE(a,b)                       \
  34     __attribute__ ((__format__ (__printf__, a, b)))
  35 #else
  36 #define PRINTF_ATTRIBUTE(a,b)
  37 #endif /* HAVE_FUNCTION_ATTRIBUTE_FORMAT */
  38
  39 #define HAVE_CONSTRUCTOR_ATTRIBUTE
  40 #ifdef HAVE_CONSTRUCTOR_ATTRIBUTE
  41 #define CONSTRUCTOR_ATTRIBUTE                       \
  42     __attribute__ ((constructor))
  43 #else
  44 #define CONSTRUCTOR_ATTRIBUTE
  45 #endif /* HAVE_CONSTRUCTOR_ATTRIBUTE */
  46
  47 #define HAVE_DESTRUCTOR_ATTRIBUTE
  48 #ifdef HAVE_DESTRUCTOR_ATTRIBUTE
  49 #define DESTRUCTOR_ATTRIBUTE                        \
  50     __attribute__ ((destructor))
  51 #else
  52 #define DESTRUCTOR_ATTRIBUTE
  53 #endif
  54
  55 #define HAVE_ADDRESS_SANITIZER_ATTRIBUTE
  56 #ifdef HAVE_ADDRESS_SANITIZER_ATTRIBUTE
  57 #define DO_NOT_SANITIZE_ADDRESS_ATTRIBUTE           \
  58     __attribute__((no_sanitize_address))
  59 #else
  60 #define DO_NOT_SANITIZE_ADDRESS_ATTRIBUTE
  61 #endif
  62
  63 #define VCOM_SOCKET_FD_MAX  0x10000
  64
  65 static char vcom_app_name[MAX_VCOM_APP_NAME];
  66
  67 /*
  68  * RETURN:  0 on success or -1 on error.
  69  * */
  70 int
  71 vcom_set_app_name (char *__app_name)
  72 {
  73   return snprintf (vcom_app_name, MAX_VCOM_APP_NAME, "vcom-%s-%d",
  74                    __app_name, getpid ()) < 0 ? -1 : 0;
  75 }
  76
  77 static char *
  78 vcom_get_app_name ()
  79 {
  80   if (vcom_app_name[0] == '\0')
  81     {
  82       snprintf (vcom_app_name, MAX_VCOM_APP_NAME, "vcom-app-%d", getpid ());
  83     }
  84   return vcom_app_name;
  85 }
  86
  87 /*
  88  * 1 if init, 0 otherwise
  89  */
  90 static int is_vcom_init;
  91
  92 /*
  93  * TBD: Make it thread safe
  94  */
  95
  96 /*
  97  * constructor function called before main is called
  98  * RETURN: 0 on success -1 on failure
  99  * */
 100 static inline int
 101 vcom_init ()
 102 {
 103   pid_t pid = getpid ();
 104
 105   if (!is_vcom_init)
 106     {
 107       if (vppcom_app_create (vcom_get_app_name ()) != 0)
 108         {
 109           printf ("\n[%d] vcom_init...failed!\n", pid);
 110           if (VCOM_DEBUG > 0)
 111             fprintf (stderr,
 112                      "[%d] vcom_init: vppcom_app_create failed!\n", pid);
 113           return -1;
 114         }
 115       if (vcom_socket_main_init () != 0)
 116         {
 117           printf ("\n[%d] vcom_init...failed!\n", pid);
 118           if (VCOM_DEBUG > 0)
 119             fprintf (stderr,
 120                      "[%d] vcom_init: vcom_socket_main_init failed!\n", pid);
 121           return -1;
 122         }
 123
 124       is_vcom_init = 1;
 125       printf ("\n[%d] vcom_init...done!\n", pid);
 126     }
 127   return 0;
 128 }
 129
 130 static inline void
 131 vcom_destroy (void)
 132 {
 133   pid_t pid = getpid ();
 134
 135   if (is_vcom_init)
 136     {
 137       vcom_socket_main_destroy ();
 138       vppcom_app_destroy ();
 139       is_vcom_init = 0;
 140       fprintf (stderr, "\n[%d] vcom_destroy...done!\n", pid);
 141     }
 142 }
 143
 144 static inline int
 145 is_vcom_socket_fd (int fd)
 146 {
 147   return vcom_socket_is_vcom_fd (fd);
 148 }
 149
 150 static inline int
 151 is_vcom_epfd (int epfd)
 152 {
 153   return vcom_socket_is_vcom_epfd (epfd);
 154 }
 155
 156
 157 /*
 158  *
 159  * Generic glibc fd api
 160  *
 161  */
 162
 163 /* Close the file descriptor FD.
 164
 165    This function is a cancellation point and therefore
 166    not marked with __THROW.  */
 167 /*
 168  * PRE:     is_vcom_socket_fd(__fd) == 1
 169  * RETURN:  0 on success and -1 for errors.
 170  * */
 171 int
 172 vcom_close (int __fd)
 173 {
 174   if (vcom_init () != 0)
 175     {
 176       return -1;
 177     }
 178
 179   if (vcom_socket_close (__fd) != 0)
 180     {
 181       return -1;
 182     }
 183
 184   return 0;
 185 }
 186
 187 /*
 188  * RETURN:  0 on success, or -1 on error
 189  */
 190 int
 191 close (int __fd)
 192 {
 193   int rv;
 194   pid_t pid = getpid ();
 195
 196   if (is_vcom_socket_fd (__fd) || is_vcom_epfd (__fd))
 197     {
 198       if (VCOM_DEBUG > 0)
 199         vcom_socket_main_show ();
 200       rv = vcom_close (__fd);
 201       if (VCOM_DEBUG > 0)
 202         fprintf (stderr, "[%d] close: " "'%04d'='%04d'\n", pid, rv, __fd);
 203       if (VCOM_DEBUG > 0)
 204         vcom_socket_main_show ();
 205       if (rv != 0)
 206         {
 207           errno = -rv;
 208           return -1;
 209         }
 210       return 0;
 211     }
 212   return libc_close (__fd);
 213 }
 214
 215 /* Read NBYTES into BUF from FD.  Return the
 216    number read, -1 for errors or 0 for EOF.
 217
 218    This function is a cancellation point and therefore
 219    not marked with __THROW.  */
 220 ssize_t
 221 vcom_read (int __fd, void *__buf, size_t __nbytes)
 222 {
 223   if (vcom_init () != 0)
 224     {
 225       return -1;
 226     }
 227
 228   return vcom_socket_read (__fd, __buf, __nbytes);
 229 }
 230
 231 ssize_t
 232 read (int __fd, void *__buf, size_t __nbytes)
 233 {
 234   ssize_t size = 0;
 235   pid_t pid = getpid ();
 236   pthread_t tid = pthread_self ();
 237
 238   if (is_vcom_socket_fd (__fd))
 239     {
 240       if (VCOM_DEBUG > 2)
 241         fprintf (stderr,
 242                  "[%d][%lu (0x%lx)] read:1 "
 243                  "'%04d'='%04d', '%p', '%04d'\n",
 244                  pid, (unsigned long) tid, (unsigned long) tid,
 245                  (int) size, __fd, __buf, (int) __nbytes);
 246       size = vcom_read (__fd, __buf, __nbytes);
 247       if (VCOM_DEBUG > 2)
 248         fprintf (stderr,
 249                  "[%d][%lu (0x%lx)] read:2 "
 250                  "'%04d'='%04d', '%p', '%04d'\n",
 251                  pid, (unsigned long) tid, (unsigned long) tid,
 252                  (int) size, __fd, __buf, (int) __nbytes);
 253       if (size < 0)
 254         {
 255           errno = -size;
 256           return -1;
 257         }
 258       return size;
 259     }
 260   return libc_read (__fd, __buf, __nbytes);
 261 }
 262
 263 ssize_t
 264 vcom_readv (int __fd, const struct iovec * __iov, int __iovcnt)
 265 {
 266   if (vcom_init () != 0)
 267     {
 268       return -1;
 269     }
 270
 271   return vcom_socket_readv (__fd, __iov, __iovcnt);
 272 }
 273
 274 ssize_t
 275 readv (int __fd, const struct iovec * __iov, int __iovcnt)
 276 {
 277   ssize_t size = 0;
 278
 279   if (is_vcom_socket_fd (__fd))
 280     {
 281       size = vcom_readv (__fd, __iov, __iovcnt);
 282       if (size < 0)
 283         {
 284           errno = -size;
 285           return -1;
 286         }
 287       return size;
 288     }
 289   else
 290     return libc_readv (__fd, __iov, __iovcnt);
 291 }
 292
 293 /* Write N bytes of BUF to FD.  Return the number written, or -1.
 294
 295    This function is a cancellation point and therefore
 296    not marked with __THROW.  */
 297 ssize_t
 298 vcom_write (int __fd, const void *__buf, size_t __n)
 299 {
 300   if (vcom_init () != 0)
 301     {
 302       return -1;
 303     }
 304
 305   return vcom_socket_write (__fd, (void *) __buf, __n);
 306 }
 307
 308 ssize_t
 309 write (int __fd, const void *__buf, size_t __n)
 310 {
 311   ssize_t size = 0;
 312   pid_t pid = getpid ();
 313   pthread_t tid = pthread_self ();
 314
 315   if (is_vcom_socket_fd (__fd))
 316     {
 317       if (VCOM_DEBUG > 2)
 318         fprintf (stderr,
 319                  "[%d][%lu (0x%lx)] write:1 "
 320                  "'%04d'='%04d', '%p', '%04d'\n",
 321                  pid, (unsigned long) tid, (unsigned long) tid,
 322                  (int) size, __fd, __buf, (int) __n);
 323       size = vcom_write (__fd, __buf, __n);
 324       if (VCOM_DEBUG > 2)
 325         fprintf (stderr,
 326                  "[%d][%lu (0x%lx)] write:2 "
 327                  "'%04d'='%04d', '%p', '%04d'\n",
 328                  pid, (unsigned long) tid, (unsigned long) tid,
 329                  (int) size, __fd, __buf, (int) __n);
 330       if (size < 0)
 331         {
 332           errno = -size;
 333           return -1;
 334         }
 335       return size;
 336     }
 337   return libc_write (__fd, __buf, __n);
 338 }
 339
 340 ssize_t
 341 vcom_writev (int __fd, const struct iovec * __iov, int __iovcnt)
 342 {
 343   if (vcom_init () != 0)
 344     {
 345       return -1;
 346     }
 347
 348   return vcom_socket_writev (__fd, __iov, __iovcnt);
 349 }
 350
 351 ssize_t
 352 writev (int __fd, const struct iovec * __iov, int __iovcnt)
 353 {
 354   ssize_t size = 0;
 355
 356   if (is_vcom_socket_fd (__fd))
 357     {
 358       size = vcom_writev (__fd, __iov, __iovcnt);
 359       if (size < 0)
 360         {
 361           errno = -size;
 362           return -1;
 363         }
 364       return size;
 365     }
 366   else
 367     return libc_writev (__fd, __iov, __iovcnt);
 368 }
 369
 370 /* Do the file control operation described by CMD on FD.
 371    The remaining arguments are interpreted depending on CMD.
 372
 373    This function is a cancellation point and therefore
 374    not marked with __THROW.  */
 375 int
 376 vcom_fcntl_va (int __fd, int __cmd, va_list __ap)
 377 {
 378   if (vcom_init () != 0)
 379     {
 380       return -1;
 381     }
 382
 383   return vcom_socket_fcntl_va (__fd, __cmd, __ap);
 384 }
 385
 386 int
 387 vcom_fcntl (int __fd, int __cmd, ...)
 388 {
 389   int rv = -1;
 390   va_list ap;
 391
 392   if (is_vcom_socket_fd (__fd))
 393     {
 394       va_start (ap, __cmd);
 395       rv = vcom_fcntl_va (__fd, __cmd, ap);
 396       va_end (ap);
 397     }
 398   return rv;
 399 }
 400
 401 int
 402 fcntl (int __fd, int __cmd, ...)
 403 {
 404   int rv;
 405   va_list ap;
 406   pid_t pid = getpid ();
 407
 408   va_start (ap, __cmd);
 409   if (is_vcom_socket_fd (__fd))
 410     {
 411       rv = vcom_fcntl_va (__fd, __cmd, ap);
 412       if (VCOM_DEBUG > 0)
 413         fprintf (stderr,
 414                  "[%d] fcntl: "
 415                  "'%04d'='%04d', '%04d'\n", pid, rv, __fd, __cmd);
 416       if (rv < 0)
 417         {
 418           errno = -rv;
 419           rv = -1;
 420         }
 421       goto out;
 422     }
 423   rv = libc_vfcntl (__fd, __cmd, ap);
 424
 425 out:
 426   va_end (ap);
 427   return rv;
 428 }
 429
 430 int
 431 vcom_ioctl_va (int __fd, unsigned long int __cmd, va_list __ap)
 432 {
 433   if (vcom_init () != 0)
 434     {
 435       return -1;
 436     }
 437
 438   return vcom_socket_ioctl_va (__fd, __cmd, __ap);
 439 }
 440
 441 int
 442 vcom_ioctl (int __fd, unsigned long int __cmd, ...)
 443 {
 444   int rv = -1;
 445   va_list ap;
 446
 447   if (is_vcom_socket_fd (__fd))
 448     {
 449       va_start (ap, __cmd);
 450       rv = vcom_ioctl_va (__fd, __cmd, ap);
 451       va_end (ap);
 452     }
 453   return rv;
 454 }
 455
 456 int
 457 ioctl (int __fd, unsigned long int __cmd, ...)
 458 {
 459   int rv;
 460   va_list ap;
 461   pid_t pid = getpid ();
 462
 463   va_start (ap, __cmd);
 464   if (is_vcom_socket_fd (__fd))
 465     {
 466       rv = vcom_ioctl_va (__fd, __cmd, ap);
 467       if (VCOM_DEBUG > 0)
 468         fprintf (stderr,
 469                  "[%d] ioctl: "
 470                  "'%04d'='%04d', '%04ld'\n", pid, rv, __fd, __cmd);
 471       if (rv < 0)
 472         {
 473           errno = -rv;
 474           rv = -1;
 475         }
 476       goto out;
 477     }
 478   rv = libc_vioctl (__fd, __cmd, ap);
 479
 480 out:
 481   va_end (ap);
 482   return rv;
 483 }
 484
 485 /*
 486  * Check the first NFDS descriptors each in READFDS (if not NULL) for
 487  *  read readiness, in WRITEFDS (if not NULL) for write readiness,
 488  *  and in EXCEPTFDS (if not NULL) for exceptional conditions.
 489  *  If TIMEOUT is not NULL, time out after waiting the interval
 490  *  specified therein.  Returns the number of ready descriptors,
 491  *  or -1 for errors.
 492  *
 493  * This function is a cancellation point and therefore not marked
 494  * with __THROW.
 495  * */
 496
 497 /*
 498  * clear all vcom FDs from fd_sets __readfds, __writefds and
 499  * __exceptfds and update the new nfds
 500  *
 501  * new nfds is the highest-numbered file descriptor
 502  * in any of the three sets, plus 1
 503  *
 504  * Return the number of file descriptors contained in the
 505  * three descriptor sets. ie. the total number of the bits
 506  * that are set in  __readfds, __writefds and __exceptfds
 507  */
 508 static inline int
 509 vcom_fd_clear (int __nfds,
 510                int *__new_nfds,
 511                fd_set * __restrict __readfds,
 512                fd_set * __restrict __writefds,
 513                fd_set * __restrict __exceptfds)
 514 {
 515   int fd;
 516   /* invalid max_fd is -1 */
 517   int max_fd = -1;
 518   int nfd = 0;
 519
 520
 521   /* clear all vcom fd from the sets */
 522   for (fd = 0; fd < __nfds; fd++)
 523     {
 524
 525       /* clear vcom fd from set */
 526       /*
 527        * F fd set
 528        */
 529 #define _(F)                                    \
 530       if ((F) && FD_ISSET (fd, (F)))            \
 531         {                                       \
 532           if (is_vcom_socket_fd (fd))           \
 533             {                                   \
 534               FD_CLR (fd, (F));                 \
 535             }                                   \
 536         }
 537
 538
 539       _(__readfds);
 540       _(__writefds);
 541       _(__exceptfds);
 542 #undef _
 543     }
 544
 545   /*
 546    *  compute nfd and __new_nfds
 547    */
 548   for (fd = 0; fd < __nfds; fd++)
 549     {
 550
 551       /*
 552        * F fd set
 553        */
 554 #define _(F)                                    \
 555       if ((F) && FD_ISSET (fd, (F)))            \
 556         {                                       \
 557           if (fd > max_fd)                      \
 558             {                                   \
 559               max_fd = fd;                      \
 560             }                                   \
 561           ++nfd;                                \
 562         }
 563
 564
 565       _(__readfds);
 566       _(__writefds);
 567       _(__exceptfds);
 568 #undef _
 569     }
 570
 571   *__new_nfds = max_fd != -1 ? max_fd + 1 : 0;
 572   return nfd;
 573 }
 574
 575 /*
 576  * Return the number of file descriptors contained in the
 577  * three descriptor sets. ie. the total number of the bits
 578  * that are set in  __readfds, __writefds and __exceptfds
 579  */
 580 static inline int
 581 vcom_fd_set (int __nfds,
 582              /* dest */
 583              int *__new_nfds,
 584              fd_set * __restrict __readfds,
 585              fd_set * __restrict __writefds, fd_set * __restrict __exceptfds,
 586              /* src */
 587              fd_set * __restrict __saved_readfds,
 588              fd_set * __restrict __saved_writefds,
 589              fd_set * __restrict __saved_exceptfds)
 590 {
 591   int fd;
 592   /* invalid max_fd is -1 */
 593   int max_fd = -1;
 594   int nfd = 0;
 595
 596   for (fd = 0; fd < __nfds; fd++)
 597     {
 598       /*
 599        * F fd set
 600        * S saved fd set
 601        */
 602 #define _(S,F)                                  \
 603       if ((F) && (S) && FD_ISSET (fd, (S)))     \
 604         {                                       \
 605           if (is_vcom_socket_fd (fd))           \
 606             {                                   \
 607               FD_SET (fd, (F));                 \
 608             }                                   \
 609         }
 610
 611
 612       _(__saved_readfds, __readfds);
 613       _(__saved_writefds, __writefds);
 614 #undef _
 615     }
 616
 617
 618   /*
 619    *  compute nfd and __new_nfds
 620    */
 621   for (fd = 0; fd < __nfds; fd++)
 622     {
 623
 624       /*
 625        * F fd set
 626        */
 627 #define _(F)                                    \
 628       if ((F) && FD_ISSET (fd, (F)))            \
 629         {                                       \
 630           if (fd > max_fd)                      \
 631             {                                   \
 632               max_fd = fd;                      \
 633             }                                   \
 634           ++nfd;                                \
 635         }
 636
 637
 638       _(__readfds);
 639       _(__writefds);
 640       _(__exceptfds);
 641 #undef _
 642     }
 643
 644   *__new_nfds = max_fd != -1 ? max_fd + 1 : 0;
 645   return nfd;
 646 }
 647
 648 /*
 649  * split select sets(src) into
 650  * vcom sets(dest1) and libc sets(dest2)
 651  */
 652 static inline void
 653 vcom_fd_set_split (
 654                     /* src, select sets */
 655                     int nfds,
 656                     fd_set * __restrict readfds,
 657                     fd_set * __restrict writefds,
 658                     fd_set * __restrict exceptfds,
 659                     /* dest1, vcom sets */
 660                     int *vcom_nfds,
 661                     fd_set * __restrict vcom_readfds,
 662                     fd_set * __restrict vcom_writefds,
 663                     fd_set * __restrict vcom_exceptfds, int *vcom_nfd,
 664                     /* dest2, libc sets */
 665                     int *libc_nfds,
 666                     fd_set * __restrict libc_readfds,
 667                     fd_set * __restrict libc_writefds,
 668                     fd_set * __restrict libc_exceptfds, int *libc_nfd)
 669 {
 670   int fd;
 671
 672   /* vcom */
 673   /* invalid max_fd is -1 */
 674   int vcom_max_fd = -1;
 675   int vcom_nfd2 = 0;
 676
 677   /* libc */
 678   /* invalid max_fd is -1 */
 679   int libc_max_fd = -1;
 680   int libc_nfd2 = 0;
 681
 682
 683   for (fd = 0; fd < nfds; fd++)
 684     {
 685       /*
 686        * S select fd set
 687        * V vcom fd set
 688        * L libc fd set
 689        */
 690 #define _(S,V,L)                            \
 691       if ((S) && FD_ISSET (fd, (S)))        \
 692         {                                   \
 693           if (is_vcom_socket_fd (fd))       \
 694             {                               \
 695               if ((V))                      \
 696                 {                           \
 697                   FD_SET(fd, (V));          \
 698                   if (fd > vcom_max_fd)     \
 699                     {                       \
 700                       vcom_max_fd = fd;     \
 701                     }                       \
 702                   ++vcom_nfd2;              \
 703                 }                           \
 704             }                               \
 705           else                              \
 706             {                               \
 707               if ((L))                      \
 708                 {                           \
 709                   FD_SET(fd, (L));          \
 710                   if (fd > libc_max_fd)     \
 711                     {                       \
 712                       libc_max_fd = fd;     \
 713                     }                       \
 714                   ++libc_nfd2;              \
 715                 }                           \
 716             }                               \
 717         }
 718
 719
 720       _(readfds, vcom_readfds, libc_readfds);
 721       _(writefds, vcom_writefds, libc_writefds);
 722       _(exceptfds, vcom_exceptfds, libc_exceptfds);
 723 #undef _
 724     }
 725
 726   if (vcom_nfds)
 727     *vcom_nfds = vcom_max_fd != -1 ? vcom_max_fd + 1 : 0;
 728   if (vcom_nfd)
 729     *vcom_nfd = vcom_nfd2;
 730   if (libc_nfds)
 731     *libc_nfds = libc_max_fd != -1 ? libc_max_fd + 1 : 0;
 732   if (libc_nfd)
 733     *libc_nfd = libc_nfd2;
 734 }
 735
 736 /*
 737  * merge vcom sets(src1) and libc sets(src2)
 738  * into select sets(dest)
 739  */
 740 static inline void
 741 vcom_fd_set_merge (
 742                     /* dest, select sets */
 743                     int *nfds,
 744                     fd_set * __restrict readfds,
 745                     fd_set * __restrict writefds,
 746                     fd_set * __restrict exceptfds, int *nfd,
 747                     /* src1, vcom sets */
 748                     int vcom_nfds,
 749                     fd_set * __restrict vcom_readfds,
 750                     fd_set * __restrict vcom_writefds,
 751                     fd_set * __restrict vcom_exceptfds, int vcom_nfd,
 752                     /* src2, libc sets */
 753                     int libc_nfds,
 754                     fd_set * __restrict libc_readfds,
 755                     fd_set * __restrict libc_writefds,
 756                     fd_set * __restrict libc_exceptfds, int libc_nfd)
 757 {
 758   int fd;
 759   /* invalid max_fd is -1 */
 760   int max_fd = -1;
 761   int nfd2 = 0;
 762
 763
 764   /* FD_BIT_OR
 765    *
 766    * dest |= src at current bit index
 767    * update MAX and NFD of dest fd set
 768    *
 769    *
 770    * FS source fd set
 771    * FD dest fd set
 772    * BI bit index
 773    * MAX current max_fd of dest fd sets
 774    * NFD current nfd of dest fd sets
 775    * N  nfds of source fd set
 776    */
 777 #define FD_BIT_OR(FD,FS,BI,          \
 778                   MAX,NFD)           \
 779   if ((FS) && (FD) && FD_ISSET ((BI), (FS)))    \
 780     {                                           \
 781       FD_SET ((BI), (FD));                      \
 782       if ((BI) > (MAX))                         \
 783         {                                       \
 784           (MAX) = (BI);                         \
 785         }                                       \
 786       ++(NFD);                                  \
 787     }
 788
 789
 790   /* FD_RWE_SET_OR */
 791   /*
 792    * SR,SW,SE source RWE fd sets
 793    * DR,DW,DE dest RWE fd sets
 794    * BI bit index
 795    * NFDS  nfds of source fd sets
 796    * MAX current max_fd of dest fd sets
 797    * NFD current nfd of dest fd sets
 798    */
 799 #define FD_RWE_SETS_OR(DR,DW,DE,      \
 800                       SR,SW,SE,       \
 801                       BI,NFDS,        \
 802                       MAX,NFD)        \
 803   do                                                      \
 804     {                                                     \
 805       for ((BI) = 0; (BI) < (NFDS); (BI)++)               \
 806         {                                                 \
 807           FD_BIT_OR((DR), (SR), (BI), (MAX), (NFD));      \
 808           FD_BIT_OR((DW), (SW), (BI), (MAX), (NFD));      \
 809           FD_BIT_OR((DE), (SE), (BI), (MAX), (NFD));      \
 810         }                                                 \
 811       }                                                   \
 812     while (0);
 813
 814
 815   /* source(vcom) to dest(select) rwe fd sets */
 816   FD_RWE_SETS_OR (readfds, writefds, exceptfds,
 817                   vcom_readfds, vcom_writefds, vcom_exceptfds,
 818                   fd, vcom_nfds, max_fd, nfd2);
 819
 820   /* source(libc) to dest(select) rwe fd sets */
 821   FD_RWE_SETS_OR (readfds, writefds, exceptfds,
 822                   libc_readfds, libc_writefds, libc_exceptfds,
 823                   fd, libc_nfds, max_fd, nfd2);
 824
 825 #undef FD_RWE_SETS_OR
 826 #undef FD_BIT_OR
 827
 828   if (nfds)
 829     *nfds = max_fd != -1 ? max_fd + 1 : 0;
 830   if (nfd)
 831     *nfd = nfd2;
 832 }
 833
 834 /*
 835  * RETURN 1 if fds is NULL or empty. 0 otherwise
 836  */
 837 static inline int
 838 fd_set_iszero (fd_set * __restrict fds)
 839 {
 840   int fd;
 841
 842   /* NULL fds */
 843   if (!fds)
 844     return 1;
 845
 846   for (fd = 0; fd < FD_SETSIZE; fd++)
 847     {
 848       if (FD_ISSET (fd, fds))
 849         {
 850           /* non-empty fds */
 851           return 0;
 852         }
 853     }
 854   /* empty fds */
 855   return 1;
 856 }
 857
 858
 859 /*
 860  * ################
 861  * kernel time64.h
 862  * ################
 863  * */
 864 typedef long int s64;
 865 typedef unsigned long int u64;
 866
 867 typedef long long int __s64;
 868 typedef unsigned long long int __u64;
 869
 870 typedef __s64 time64_t;
 871 typedef __u64 timeu64_t;
 872
 873 /* Parameters used to convert the timespec values: */
 874 #define MSEC_PER_SEC    1000L
 875 #define USEC_PER_MSEC   1000L
 876 #define NSEC_PER_USEC   1000L
 877 #define NSEC_PER_MSEC   1000000L
 878 #define USEC_PER_SEC    1000000L
 879 #define NSEC_PER_SEC    1000000000L
 880 #define FSEC_PER_SEC    1000000000000000LL
 881
 882
 883 /*
 884  * ################
 885  * kernel time.h
 886  * ################
 887  * */
 888
 889
 890 #define TIME_T_MAX      (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
 891
 892 #ifdef VCOM_USE_TIMESPEC_EQUAL
 893 static inline int
 894 timespec_equal (const struct timespec *a, const struct timespec *b)
 895 {
 896   return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
 897 }
 898 #endif
 899
 900 /*
 901  * lhs < rhs:  return <0
 902  * lhs == rhs: return 0
 903  * lhs > rhs:  return >0
 904  */
 905 static inline int
 906 timespec_compare (const struct timespec *lhs, const struct timespec *rhs)
 907 {
 908   if (lhs->tv_sec < rhs->tv_sec)
 909     return -1;
 910   if (lhs->tv_sec > rhs->tv_sec)
 911     return 1;
 912   return lhs->tv_nsec - rhs->tv_nsec;
 913 }
 914
 915 #ifdef VCOM_USE_TIMEVAL_COMPARE
 916 static inline int
 917 timeval_compare (const struct timeval *lhs, const struct timeval *rhs)
 918 {
 919   if (lhs->tv_sec < rhs->tv_sec)
 920     return -1;
 921   if (lhs->tv_sec > rhs->tv_sec)
 922     return 1;
 923   return lhs->tv_usec - rhs->tv_usec;
 924 }
 925 #endif
 926
 927 extern void set_normalized_timespec (struct timespec *ts, time_t sec,
 928                                      s64 nsec);
 929
 930 static inline struct timespec
 931 timespec_add (struct timespec lhs, struct timespec rhs)
 932 {
 933   struct timespec ts_delta;
 934   set_normalized_timespec (&ts_delta, lhs.tv_sec + rhs.tv_sec,
 935                            lhs.tv_nsec + rhs.tv_nsec);
 936   return ts_delta;
 937 }
 938
 939 /*
 940  * sub = lhs - rhs, in normalized form
 941  */
 942 static inline struct timespec
 943 timespec_sub (struct timespec lhs, struct timespec rhs)
 944 {
 945   struct timespec ts_delta;
 946   set_normalized_timespec (&ts_delta, lhs.tv_sec - rhs.tv_sec,
 947                            lhs.tv_nsec - rhs.tv_nsec);
 948   return ts_delta;
 949 }
 950
 951 /*
 952  * ################
 953  * kernel time.c
 954  * ################
 955  * */
 956
 957
 958 /**
 959  * set_normalized_timespec - set timespec sec and nsec parts and normalize
 960  *
 961  * @ts:         pointer to timespec variable to be set
 962  * @sec:        seconds to set
 963  * @nsec:       nanoseconds to set
 964  *
 965  * Set seconds and nanoseconds field of a timespec variable and
 966  * normalize to the timespec storage format
 967  *
 968  * Note: The tv_nsec part is always in the range of
 969  *      0 <= tv_nsec < NSEC_PER_SEC
 970  * For negative values only the tv_sec field is negative !
 971  */
 972 void
 973 set_normalized_timespec (struct timespec *ts, time_t sec, s64 nsec)
 974 {
 975   while (nsec >= NSEC_PER_SEC)
 976     {
 977       /*
 978        * The following asm() prevents the compiler from
 979        * optimising this loop into a modulo operation. See
 980        * also __iter_div_u64_rem() in include/linux/time.h
 981        */
 982     asm ("":"+rm" (nsec));
 983       nsec -= NSEC_PER_SEC;
 984       ++sec;
 985     }
 986   while (nsec < 0)
 987     {
 988     asm ("":"+rm" (nsec));
 989       nsec += NSEC_PER_SEC;
 990       --sec;
 991     }
 992   ts->tv_sec = sec;
 993   ts->tv_nsec = nsec;
 994 }
 995
 996 #define vcom_timerisvalid(tvp)        (!((tvp)->tv_sec < 0 || (tvp)->tv_usec < 0))
 997
 998 /* Macros for converting between `struct timeval' and `struct timespec'.  */
 999 #define VCOM_TIMEVAL_TO_TIMESPEC(tv, ts) {                             \
1000         (ts)->tv_sec = (tv)->tv_sec;                                    \
1001         (ts)->tv_nsec = (tv)->tv_usec * 1000;                           \
1002 }
1003 #define VCOM_TIMESPEC_TO_TIMEVAL(tv, ts) {                             \
1004         (tv)->tv_sec = (ts)->tv_sec;                                    \
1005         (tv)->tv_usec = (ts)->tv_nsec / 1000;                           \
1006 }
1007
1008 static inline int
1009 vcom_select_impl (int vcom_nfds, fd_set * __restrict vcom_readfds,
1010                   fd_set * __restrict vcom_writefds,
1011                   fd_set * __restrict vcom_exceptfds,
1012                   struct timeval *__restrict timeout)
1013 {
1014   return vcom_socket_select (vcom_nfds, vcom_readfds,
1015                              vcom_writefds, vcom_exceptfds, timeout);
1016 }
1017
1018 int
1019 vcom_select (int __nfds, fd_set * __restrict __readfds,
1020              fd_set * __restrict __writefds,
1021              fd_set * __restrict __exceptfds,
1022              struct timeval *__restrict __timeout)
1023 {
1024   int rv;
1025   int rv2 = 0;
1026   pid_t pid = getpid ();
1027
1028   int timedout = 0;
1029   /* block indefinitely */
1030   int no_timeout = 0;
1031   int first_clock_gettime_failed = 0;
1032   /* timeout value in units of timespec */
1033   struct timespec timeout_ts;
1034   struct timespec start_time, now, end_time;
1035
1036   /* select sets attributes - after merge */
1037   int new_nfds = 0;
1038   int new_nfd = -1;
1039
1040   /* vcom */
1041   int vcom_nfds = 0;
1042   fd_set vcom_readfds;
1043   fd_set vcom_writefds;
1044   fd_set vcom_exceptfds;
1045   int vcom_nfd = -1;
1046
1047   /* libc */
1048   int libc_nfds = 0;
1049   fd_set libc_readfds;
1050   fd_set libc_writefds;
1051   fd_set libc_exceptfds;
1052   int libc_nfd = -1;
1053
1054   /* for polling */
1055   struct timeval tv = {.tv_sec = 0,.tv_usec = 0 };
1056
1057   /* validate __timeout */
1058   if (__timeout)
1059     {
1060       /* validate tv_sec */
1061       /* bogus */
1062       if (!vcom_timerisvalid (__timeout))
1063         {
1064           rv = -EINVAL;
1065           goto select_done;
1066         }
1067
1068       /* validate tv_usec */
1069       /* TBD: */
1070       /* init timeout_ts */
1071       VCOM_TIMEVAL_TO_TIMESPEC (__timeout, &timeout_ts);
1072       set_normalized_timespec (&timeout_ts,
1073                                timeout_ts.tv_sec, timeout_ts.tv_nsec);
1074     }
1075
1076   rv = clock_gettime (CLOCK_MONOTONIC, &start_time);
1077   if (rv == -1)
1078     {
1079       rv = -errno;
1080       first_clock_gettime_failed = 1;
1081       goto select_done;
1082     }
1083
1084   /* init end_time */
1085   if (__timeout)
1086     {
1087       if (timerisset (__timeout))
1088         {
1089           end_time = timespec_add (start_time, timeout_ts);
1090         }
1091       else
1092         {
1093           /*
1094            * if both fields of the timeout structure are zero,
1095            * then select returns immediately
1096            * */
1097           end_time = start_time;
1098         }
1099     }
1100   else
1101     {
1102       /* block indefinitely */
1103       no_timeout = 1;
1104     }
1105
1106
1107
1108   if (vcom_init () != 0)
1109     {
1110       rv = -1;
1111       goto select_done;
1112     }
1113
1114   /* validate __nfds */
1115   if (__nfds < 0 || __nfds > FD_SETSIZE)
1116     {
1117       rv = -EINVAL;
1118       goto select_done;
1119     }
1120
1121
1122   /*
1123    * usleep(3) emulation
1124    * */
1125
1126   /* call libc_select() with a finite timeout and
1127    * no file descriptors or empty fd sets and
1128    * zero nfds */
1129   if (__nfds == 0 &&
1130       (!__readfds || fd_set_iszero (__readfds)) &&
1131       (!__writefds || fd_set_iszero (__writefds)) &&
1132       (!__exceptfds || fd_set_iszero (__exceptfds)))
1133     {
1134       if (__timeout)
1135         {
1136           rv = libc_select (__nfds,
1137                             __readfds, __writefds, __exceptfds, __timeout);
1138           if (rv == -1)
1139             rv = -errno;
1140         }
1141       else
1142         {
1143           /* TBD: block indefinitely or return -EINVAL */
1144           rv = -EINVAL;
1145         }
1146       goto select_done;
1147     }
1148
1149   /* init once before the polling loop */
1150
1151   /* zero vcom and libc fd sets */
1152   /*
1153    * S select fd set
1154    * V vcom fd set
1155    * L libc fd set
1156    */
1157 #define _(S,V,L)      \
1158   if ((S))            \
1159     {                 \
1160       FD_ZERO ((V));  \
1161       FD_ZERO ((L));  \
1162     }
1163
1164
1165   _(__readfds, &vcom_readfds, &libc_readfds);
1166   _(__writefds, &vcom_writefds, &libc_writefds);
1167   _(__exceptfds, &vcom_exceptfds, &libc_exceptfds);
1168 #undef _
1169   new_nfds = 0;
1170   new_nfd = -1;
1171
1172   vcom_nfds = 0;
1173   vcom_nfd = -1;
1174   libc_nfds = 0;
1175   libc_nfd = -1;
1176
1177   vcom_fd_set_split (
1178                       /* src, select sets */
1179                       __nfds, __readfds, __writefds, __exceptfds,
1180                       /* dest1, vcom sets */
1181                       __readfds || __writefds || __exceptfds ?
1182                       &vcom_nfds : NULL,
1183                       __readfds ? &vcom_readfds : NULL,
1184                       __writefds ? &vcom_writefds : NULL,
1185                       __exceptfds ? &vcom_exceptfds : NULL,
1186                       __readfds || __writefds || __exceptfds ?
1187                       &vcom_nfd : NULL,
1188                       /* dest2, libc sets */
1189                       __readfds || __writefds || __exceptfds ?
1190                       &libc_nfds : NULL,
1191                       __readfds ? &libc_readfds : NULL,
1192                       __writefds ? &libc_writefds : NULL,
1193                       __exceptfds ? &libc_exceptfds : NULL,
1194                       __readfds || __writefds || __exceptfds ?
1195                       &libc_nfd : NULL);
1196
1197   /*
1198    * polling loop
1199    * */
1200   do
1201     {
1202       new_nfd = -1;
1203       vcom_nfd = -1;
1204       libc_nfd = -1;
1205
1206       /*
1207        * if both fields of timeval structure are zero,
1208        * vcom_select_impl and libc_select returns immediately.
1209        * useful for polling and ensure fairness among
1210        * file descriptors watched.
1211        */
1212
1213       /* for polling */
1214       tv.tv_sec = 0;
1215       tv.tv_usec = 0;
1216
1217       /* select on vcom fds */
1218       if (vcom_nfds)
1219         {
1220           vcom_nfd = vcom_select_impl (vcom_nfds,
1221                                        __readfds ? &vcom_readfds : NULL,
1222                                        __writefds ? &vcom_writefds : NULL,
1223                                        __exceptfds ? &vcom_exceptfds : NULL,
1224                                        &tv);
1225           if (VCOM_DEBUG > 2)
1226             fprintf (stderr,
1227                      "[%d] select vcom: "
1228                      "'%04d'='%04d'\n", pid, vcom_nfd, vcom_nfds);
1229
1230           if (vcom_nfd < 0)
1231             {
1232               rv = vcom_nfd;
1233               goto select_done;
1234             }
1235         }
1236       /* select on libc fds */
1237       if (libc_nfds)
1238         {
1239           libc_nfd = libc_select (libc_nfds,
1240                                   __readfds ? &libc_readfds : NULL,
1241                                   __writefds ? &libc_writefds : NULL,
1242                                   __exceptfds ? &libc_exceptfds : NULL, &tv);
1243           if (VCOM_DEBUG > 2)
1244             fprintf (stderr,
1245                      "[%d] select libc: "
1246                      "'%04d'='%04d'\n", pid, libc_nfd, libc_nfds);
1247
1248           if (libc_nfd < 0)
1249             {
1250               /* tv becomes undefined */
1251               libc_nfd = errno;
1252               rv = libc_nfd;
1253               goto select_done;
1254             }
1255         }
1256
1257       /* check if any file descriptors changed status */
1258       if ((vcom_nfds && vcom_nfd > 0) || (libc_nfds && libc_nfd > 0))
1259         {
1260           /* zero the sets before merge and exit */
1261
1262           /*
1263            * F fd set
1264            */
1265 #define _(F)                  \
1266           if ((F))            \
1267             {                 \
1268               FD_ZERO ((F));  \
1269             }
1270
1271
1272           _(__readfds);
1273           _(__writefds);
1274           _(__exceptfds);
1275 #undef _
1276           new_nfds = 0;
1277           new_nfd = -1;
1278
1279           /*
1280            * on exit, sets are modified in place to indicate which
1281            * file descriptors actually changed status
1282            * */
1283           vcom_fd_set_merge (
1284                               /* dest, select sets */
1285                               &new_nfds,
1286                               __readfds,
1287                               __writefds,
1288                               __exceptfds,
1289                               __readfds || __writefds || __exceptfds ?
1290                               &new_nfd : NULL,
1291                               /* src1, vcom sets */
1292                               vcom_nfds,
1293                               __readfds ? &vcom_readfds : NULL,
1294                               __writefds ? &vcom_writefds : NULL,
1295                               __exceptfds ? &vcom_exceptfds : NULL, vcom_nfd,
1296                               /* src2, libc sets */
1297                               libc_nfds,
1298                               __readfds ? &libc_readfds : NULL,
1299                               __writefds ? &libc_writefds : NULL,
1300                               __exceptfds ? &libc_exceptfds : NULL, libc_nfd);
1301           /*
1302            * return the number of file descriptors contained in the
1303            * three returned sets
1304            * */
1305           rv = 0;
1306           /*
1307            * for documentation
1308            *
1309            * if(vcom_nfd > 0)
1310            *   rv += vcom_nfd;
1311            * if(libc_nfd > 0)
1312            *   rv += libc_nfd;
1313            */
1314
1315           rv = new_nfd == -1 ? 0 : new_nfd;
1316           goto select_done;
1317         }
1318
1319       rv = clock_gettime (CLOCK_MONOTONIC, &now);
1320       if (rv == -1)
1321         {
1322           rv = -errno;
1323           goto select_done;
1324         }
1325     }
1326   while (no_timeout || timespec_compare (&now, &end_time) < 0);
1327
1328   /* timeout expired before anything interesting happened */
1329   timedout = 1;
1330   rv = 0;
1331
1332 select_done:
1333   if (VCOM_DEBUG > 2)
1334     fprintf (stderr, "[%d] vselect1: " "'%04d'='%04d'\n", pid, rv, __nfds);
1335   /*
1336    * modify timeout parameter to reflect the amount of time not slept
1337    * */
1338   if (__timeout)
1339     {
1340       if (vcom_timerisvalid (__timeout))
1341         {
1342           /* timeout expired */
1343           if (timedout)
1344             {
1345               timerclear (__timeout);
1346             }
1347           else if (!first_clock_gettime_failed)
1348             {
1349               rv2 = clock_gettime (CLOCK_MONOTONIC, &now);
1350               if (rv2 == -1)
1351                 {
1352                   rv = -errno;
1353                 }
1354               else
1355                 {
1356                   struct timespec ts_delta;
1357                   ts_delta = timespec_sub (end_time, now);
1358                   VCOM_TIMESPEC_TO_TIMEVAL (__timeout, &ts_delta);
1359                 }
1360             }
1361         }
1362     }
1363   if (VCOM_DEBUG > 2)
1364     fprintf (stderr, "[%d] vselect2: " "'%04d',='%04d'\n", pid, rv, __nfds);
1365
1366   return rv;
1367 }
1368
1369 int
1370 vcom_select_internal (int __nfds, fd_set * __restrict __readfds,
1371                       fd_set * __restrict __writefds,
1372                       fd_set * __restrict __exceptfds,
1373                       struct timeval *__restrict __timeout)
1374 {
1375   int rv;
1376   int new_nfds = 0;
1377   int nfd = 0;
1378   pid_t pid = getpid ();
1379
1380   fd_set saved_readfds;
1381   fd_set saved_writefds;
1382   fd_set saved_exceptfds;
1383
1384   /* validate __nfds */
1385   if (__nfds < 0)
1386     {
1387       errno = EINVAL;
1388       return -1;
1389     }
1390
1391   /* validate __timeout */
1392   if (__timeout)
1393     {
1394       /* validate tv_sec */
1395       /* bogus */
1396       if (__timeout->tv_sec < 0 || __timeout->tv_usec < 0)
1397         {
1398           errno = EINVAL;
1399           return -1;
1400         }
1401
1402       /* validate tv_usec */
1403       /* TBD: */
1404     }
1405
1406   /* init saved_x fds */
1407   if (__readfds)
1408     {
1409       saved_readfds = *__readfds;
1410       /*
1411          memcpy (&saved_readfds, __readfds, sizeof (*__readfds));
1412        */
1413     }
1414   else
1415     {
1416       FD_ZERO (&saved_readfds);
1417     }
1418
1419   if (__writefds)
1420     {
1421       saved_writefds = *__writefds;
1422       /*
1423          memcpy (&saved_writefds, __writefds, sizeof (*__writefds));
1424        */
1425
1426     }
1427   else
1428     {
1429       FD_ZERO (&saved_writefds);
1430     }
1431
1432   if (__exceptfds)
1433     {
1434       saved_exceptfds = *__exceptfds;
1435       /*
1436          memcpy (&saved_exceptfds, __exceptfds, sizeof (*__exceptfds));
1437        */
1438
1439     }
1440   else
1441     {
1442       FD_ZERO (&saved_exceptfds);
1443     }
1444
1445   /* clear vcom fds */
1446   nfd = vcom_fd_clear (__nfds, &new_nfds, __readfds, __writefds, __exceptfds);
1447
1448   /* set to an invalid value */
1449   rv = -2;
1450   /* have kernel fds */
1451   if (new_nfds)
1452     rv = libc_select (new_nfds, __readfds,
1453                       __writefds, __exceptfds, __timeout);
1454
1455   if (new_nfds && rv == -1)
1456     {
1457       /* on error, the file descriptor sets are unmodified */
1458       if (__readfds)
1459         *__readfds = saved_readfds;
1460       if (__writefds)
1461         *__writefds = saved_writefds;
1462       if (__exceptfds)
1463         *__exceptfds = saved_exceptfds;
1464       return rv;
1465     }
1466   else if ((new_nfds && rv != -1) || (rv == -2))
1467     {
1468       /* restore vcom fds */
1469       nfd = vcom_fd_set (__nfds,
1470                          &new_nfds,
1471                          __readfds,
1472                          __writefds,
1473                          __exceptfds,
1474                          &saved_readfds, &saved_writefds, &saved_exceptfds);
1475       rv = nfd;
1476     }
1477
1478   if (VCOM_DEBUG > 0)
1479     fprintf (stderr, "[%d] select: " "'%04d'='%04d'\n", pid, rv, __nfds);
1480   return rv;
1481 }
1482
1483 int
1484 select (int __nfds, fd_set * __restrict __readfds,
1485         fd_set * __restrict __writefds,
1486         fd_set * __restrict __exceptfds, struct timeval *__restrict __timeout)
1487 {
1488   int rv = 0;
1489   pid_t pid = getpid ();
1490
1491   if (VCOM_DEBUG > 2)
1492     fprintf (stderr, "[%d] select1: " "'%04d'='%04d'\n", pid, rv, __nfds);
1493   rv = vcom_select (__nfds, __readfds, __writefds, __exceptfds, __timeout);
1494   if (VCOM_DEBUG > 2)
1495     fprintf (stderr, "[%d] select2: " "'%04d'='%04d'\n", pid, rv, __nfds);
1496   if (rv < 0)
1497     {
1498       errno = -rv;
1499       return -1;
1500     }
1501   return rv;
1502 }
1503
1504 #ifdef __USE_XOPEN2K
1505 /*
1506  * Same as above only that the TIMEOUT value is given with higher
1507  * resolution and a sigmask which is been set temporarily.  This
1508  * version should be used.
1509  *
1510  * This function is a cancellation point and therefore not marked
1511  * with __THROW.
1512  * */
1513 int
1514 vcom_pselect (int __nfds, fd_set * __restrict __readfds,
1515               fd_set * __restrict __writefds,
1516               fd_set * __restrict __exceptfds,
1517               const struct timespec *__restrict __timeout,
1518               const __sigset_t * __restrict __sigmask)
1519 {
1520   int fd;
1521   int vcom_nfds = 0;
1522
1523   for (fd = 0; fd < __nfds; fd++)
1524     {
1525       if (__readfds && FD_ISSET (fd, __readfds))
1526         {
1527           if (is_vcom_socket_fd (fd))
1528             {
1529               vcom_nfds++;
1530             }
1531         }
1532
1533       if (__writefds && FD_ISSET (fd, __writefds))
1534         {
1535           if (is_vcom_socket_fd (fd))
1536             {
1537               vcom_nfds++;
1538             }
1539         }
1540       if (__exceptfds && FD_ISSET (fd, __exceptfds))
1541         {
1542           if (is_vcom_socket_fd (fd))
1543             {
1544               FD_CLR (fd, __exceptfds);
1545             }
1546         }
1547     }
1548   return vcom_nfds;
1549 }
1550
1551 int
1552 pselect (int __nfds, fd_set * __restrict __readfds,
1553          fd_set * __restrict __writefds,
1554          fd_set * __restrict __exceptfds,
1555          const struct timespec *__restrict __timeout,
1556          const __sigset_t * __restrict __sigmask)
1557 {
1558   int rv;
1559   int new_nfds = 0;
1560   int nfd = 0;
1561   pid_t pid = getpid ();
1562
1563   fd_set saved_readfds;
1564   fd_set saved_writefds;
1565   fd_set saved_exceptfds;
1566
1567   /* validate __nfds */
1568   if (__nfds < 0)
1569     {
1570       errno = EINVAL;
1571       return -1;
1572     }
1573
1574   /* validate __timeout */
1575   if (__timeout)
1576     {
1577       /* validate tv_sec */
1578       /* bogus */
1579       if (__timeout->tv_sec < 0 || __timeout->tv_nsec < 0)
1580         {
1581           errno = EINVAL;
1582           return -1;
1583         }
1584
1585       /* validate tv_usec */
1586       /* TBD: */
1587     }
1588
1589   /* init saved fds */
1590   if (__readfds)
1591     {
1592       saved_readfds = *__readfds;
1593       /*
1594          memcpy (&saved_readfds, __readfds, sizeof (*__readfds));
1595        */
1596     }
1597   else
1598     {
1599       FD_ZERO (&saved_readfds);
1600     }
1601
1602   if (__writefds)
1603     {
1604       saved_writefds = *__writefds;
1605       /*
1606          memcpy (&saved_writefds, __writefds, sizeof (*__writefds));
1607        */
1608
1609     }
1610   else
1611     {
1612       FD_ZERO (&saved_writefds);
1613     }
1614
1615   if (__exceptfds)
1616     {
1617       saved_exceptfds = *__exceptfds;
1618       /*
1619          memcpy (&saved_exceptfds, __exceptfds, sizeof (*__exceptfds));
1620        */
1621
1622     }
1623   else
1624     {
1625       FD_ZERO (&saved_exceptfds);
1626     }
1627
1628   /* clear vcom fds */
1629   nfd = vcom_fd_clear (__nfds, &new_nfds, __readfds, __writefds, __exceptfds);
1630
1631   /* set to an invalid value */
1632   rv = -2;
1633   if (new_nfds)
1634     rv = libc_pselect (new_nfds,
1635                        __readfds,
1636                        __writefds, __exceptfds, __timeout, __sigmask);
1637
1638   if (new_nfds && rv == -1)
1639     {
1640       /* on error, the file descriptor sets are unmodified */
1641       if (__readfds)
1642         *__readfds = saved_readfds;
1643       if (__writefds)
1644         *__writefds = saved_writefds;
1645       if (__exceptfds)
1646         *__exceptfds = saved_exceptfds;
1647       return rv;
1648     }
1649   else if ((new_nfds && rv != -1) || (rv == -2))
1650     {
1651       /* restore vcom fds */
1652       nfd = vcom_fd_set (__nfds,
1653                          &new_nfds,
1654                          __readfds,
1655                          __writefds,
1656                          __exceptfds,
1657                          &saved_readfds, &saved_writefds, &saved_exceptfds);
1658       rv = nfd;
1659     }
1660
1661   if (VCOM_DEBUG > 2)
1662     fprintf (stderr, "[%d] pselect: " "'%04d'='%04d'\n", pid, rv, __nfds);
1663   return rv;
1664 }
1665 #endif
1666
1667 /*
1668  *
1669  * Socket specific glibc api
1670  *
1671  */
1672
1673 /* Create a new socket of type TYPE in domain DOMAIN, using
1674  * protocol PROTOCOL.  If PROTOCOL is zero, one is chosen
1675  * automatically. Returns a file descriptor for the new socket,
1676  * or -1 for errors.
1677  * RETURN:  a valid file descriptor for the new socket,
1678  * or -1 for errors.
1679  * */
1680
1681 int
1682 vcom_socket (int __domain, int __type, int __protocol)
1683 {
1684   if (vcom_init () != 0)
1685     {
1686       return -1;
1687     }
1688
1689   return vcom_socket_socket (__domain, __type, __protocol);
1690 }
1691
1692 int
1693 socket (int __domain, int __type, int __protocol)
1694 {
1695   int rv;
1696   pid_t pid = getpid ();
1697   pthread_t tid = pthread_self ();
1698
1699   /* handle domains implemented by vpp */
1700   switch (__domain)
1701     {
1702     case AF_INET:
1703     case AF_INET6:
1704       /* handle types implemented by vpp */
1705       switch (__type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
1706         {
1707         case SOCK_STREAM:
1708         case SOCK_DGRAM:
1709           if (VCOM_DEBUG > 0)
1710             vcom_socket_main_show ();
1711           rv = vcom_socket (__domain, __type, __protocol);
1712           if (VCOM_DEBUG > 0)
1713             fprintf (stderr,
1714                      "[%d][%lu (0x%lx)] socket: "
1715                      "'%04d'= D='%04d', T='%04d', P='%04d'\n",
1716                      pid, (unsigned long) tid, (unsigned long) tid,
1717                      rv, __domain, __type, __protocol);
1718           if (VCOM_DEBUG > 0)
1719             vcom_socket_main_show ();
1720           if (rv < 0)
1721             {
1722               errno = -rv;
1723               return -1;
1724             }
1725           return rv;
1726           break;
1727
1728         default:
1729           goto CALL_GLIBC_SOCKET_API;
1730           break;
1731         }
1732
1733       break;
1734
1735     default:
1736       goto CALL_GLIBC_SOCKET_API;
1737       break;
1738     }
1739
1740 CALL_GLIBC_SOCKET_API:
1741   return libc_socket (__domain, __type, __protocol);
1742 }
1743
1744 /*
1745  * Create two new sockets, of type TYPE in domain DOMAIN and using
1746  * protocol PROTOCOL, which are connected to each other, and put file
1747  * descriptors for them in FDS[0] and FDS[1].  If PROTOCOL is zero,
1748  * one will be chosen automatically.
1749  * Returns 0 on success, -1 for errors.
1750  * */
1751 int
1752 vcom_socketpair (int __domain, int __type, int __protocol, int __fds[2])
1753 {
1754   if (vcom_init () != 0)
1755     {
1756       return -1;
1757     }
1758
1759   return vcom_socket_socketpair (__domain, __type, __protocol, __fds);
1760 }
1761
1762 int
1763 socketpair (int __domain, int __type, int __protocol, int __fds[2])
1764 {
1765   int rv;
1766   pid_t pid = getpid ();
1767
1768   /* handle domains implemented by vpp */
1769   switch (__domain)
1770     {
1771     case AF_INET:
1772     case AF_INET6:
1773       /* handle types implemented by vpp */
1774       switch (__type)
1775         {
1776         case SOCK_STREAM:
1777         case SOCK_DGRAM:
1778           rv = vcom_socketpair (__domain, __type, __protocol, __fds);
1779           if (VCOM_DEBUG > 0)
1780             fprintf (stderr,
1781                      "[%d] socketpair: "
1782                      "'%04d'= D='%04d', T='%04d', P='%04d'\n",
1783                      pid, rv, __domain, __type, __protocol);
1784           if (rv < 0)
1785             {
1786               errno = -rv;
1787               return -1;
1788             }
1789           return 0;
1790           break;
1791
1792         default:
1793           goto CALL_GLIBC_SOCKET_API;
1794           break;
1795         }
1796
1797       break;
1798
1799     default:
1800       goto CALL_GLIBC_SOCKET_API;
1801       break;
1802     }
1803
1804 CALL_GLIBC_SOCKET_API:
1805   return libc_socketpair (__domain, __type, __protocol, __fds);
1806 }
1807
1808 /*
1809  * Give the socket FD the local address ADDR
1810  * (which is LEN bytes long).
1811  * */
1812 int
1813 vcom_bind (int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len)
1814 {
1815   int rv;
1816
1817   if (vcom_init () != 0)
1818     {
1819       return -1;
1820     }
1821
1822   /* validate __len */
1823   switch (__addr->sa_family)
1824     {
1825     case AF_INET:
1826       if (__len != sizeof (struct sockaddr_in))
1827         return -EINVAL;
1828       break;
1829     case AF_INET6:
1830       if (__len != sizeof (struct sockaddr_in6))
1831         return -EINVAL;
1832       break;
1833
1834     default:
1835       return -1;
1836       break;
1837     }
1838
1839   /* handle domains implemented by vpp */
1840   switch (__addr->sa_family)
1841     {
1842     case AF_INET:
1843     case AF_INET6:
1844       rv = vcom_socket_bind (__fd, __addr, __len);
1845       return rv;
1846       break;
1847
1848     default:
1849       return -1;
1850       break;
1851     }
1852
1853   return -1;
1854 }
1855
1856 int
1857 bind (int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len)
1858 {
1859   int rv;
1860   pid_t pid = getpid ();
1861
1862   if (is_vcom_socket_fd (__fd))
1863     {
1864
1865       rv = vcom_bind (__fd, __addr, __len);
1866       if (VCOM_DEBUG > 0)
1867         fprintf (stderr,
1868                  "[%d] bind: "
1869                  "'%04d'='%04d', '%p', '%04d'\n",
1870                  pid, rv, __fd, __addr, __len);
1871       if (rv != 0)
1872         {
1873           errno = -rv;
1874           return -1;
1875         }
1876       return 0;
1877     }
1878   return libc_bind (__fd, __addr, __len);
1879 }
1880
1881 /*
1882  * Put the local address of FD into *ADDR and its length in *LEN.
1883  * */
1884 int
1885 vcom_getsockname (int __fd, __SOCKADDR_ARG __addr,
1886                   socklen_t * __restrict __len)
1887 {
1888   if (vcom_init () != 0)
1889     {
1890       return -1;
1891     }
1892
1893   return vcom_socket_getsockname (__fd, __addr, __len);
1894 }
1895
1896 int
1897 getsockname (int __fd, __SOCKADDR_ARG __addr, socklen_t * __restrict __len)
1898 {
1899   int rv;
1900   pid_t pid = getpid ();
1901
1902   if (is_vcom_socket_fd (__fd))
1903     {
1904       rv = vcom_getsockname (__fd, __addr, __len);
1905       if (VCOM_DEBUG > 0)
1906         fprintf (stderr,
1907                  "[%d] getsockname: "
1908                  "'%04d'='%04d', '%p', '%p'\n", pid, rv, __fd, __addr, __len);
1909       if (rv != 0)
1910         {
1911           errno = -rv;
1912           return -1;
1913         }
1914       return 0;
1915     }
1916   return libc_getsockname (__fd, __addr, __len);
1917 }
1918
1919 /*
1920  * Open a connection on socket FD to peer at ADDR
1921  * (which LEN bytes long). For connectionless socket types, just set
1922  * the default address to send to and the only address from which to
1923  * accept transmissions. Return 0 on success, -1 for errors.
1924  * This function is a cancellation point and therefore not marked
1925  * with __THROW.
1926  * */
1927 int
1928 vcom_connect (int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len)
1929 {
1930   int rv = -1;
1931
1932   if (vcom_init () != 0)
1933     {
1934       return -1;
1935     }
1936
1937   /* validate __len */
1938   switch (__addr->sa_family)
1939     {
1940     case AF_INET:
1941       if (__len != INET_ADDRSTRLEN)
1942         return -1;
1943       break;
1944     case AF_INET6:
1945       if (__len != INET6_ADDRSTRLEN)
1946         return -1;
1947       break;
1948
1949     default:
1950       return -1;
1951       break;
1952     }
1953
1954   /* handle domains implemented by vpp */
1955   switch (__addr->sa_family)
1956     {
1957     case AF_INET:
1958     case AF_INET6:
1959       rv = vcom_socket_connect (__fd, __addr, __len);
1960       break;
1961
1962     default:
1963       return -1;
1964       break;
1965     }
1966
1967   return rv;
1968 }
1969
1970 int
1971 connect (int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len)
1972 {
1973   int rv;
1974   pid_t pid = getpid ();
1975   pthread_t tid = pthread_self ();
1976
1977   if (is_vcom_socket_fd (__fd))
1978     {
1979       rv = vcom_connect (__fd, __addr, __len);
1980       if (VCOM_DEBUG > 0)
1981         fprintf (stderr,
1982                  "[%d][%lu (0x%lx)] connect: "
1983                  "'%04d'='%04d', '%p', '%04d'\n",
1984                  pid, (unsigned long) tid, (unsigned long) tid,
1985                  rv, __fd, __addr, __len);
1986       if (rv != 0)
1987         {
1988           errno = -rv;
1989           return -1;
1990         }
1991       return 0;
1992     }
1993
1994   return libc_connect (__fd, __addr, __len);
1995 }
1996
1997 /*
1998  * Put the address of the peer connected to socket FD into *ADDR
1999  * (which is *LEN bytes long), and its actual length into *LEN.
2000  * */
2001 int
2002 vcom_getpeername (int __fd, __SOCKADDR_ARG __addr,
2003                   socklen_t * __restrict __len)
2004 {
2005   if (vcom_init () != 0)
2006     {
2007       return -1;
2008     }
2009
2010   return vcom_socket_getpeername (__fd, __addr, __len);
2011 }
2012
2013 int
2014 getpeername (int __fd, __SOCKADDR_ARG __addr, socklen_t * __restrict __len)
2015 {
2016   int rv;
2017   pid_t pid = getpid ();
2018
2019   if (is_vcom_socket_fd (__fd))
2020     {
2021       rv = vcom_getpeername (__fd, __addr, __len);
2022       if (VCOM_DEBUG > 0)
2023         fprintf (stderr,
2024                  "[%d] getpeername: "
2025                  "'%04d'='%04d', '%p', '%p'\n", pid, rv, __fd, __addr, __len);
2026       if (rv != 0)
2027         {
2028           errno = -rv;
2029           return -1;
2030         }
2031       return 0;
2032     }
2033   return libc_getpeername (__fd, __addr, __len);
2034 }
2035
2036 /*
2037  * Send N bytes of BUF to socket FD.  Returns the number sent or -1.
2038  * This function is a cancellation point and therefore not marked
2039  * with __THROW.
2040  * */
2041 ssize_t
2042 vcom_send (int __fd, const void *__buf, size_t __n, int __flags)
2043 {
2044
2045   if (vcom_init () != 0)
2046     {
2047       return -1;
2048     }
2049
2050   return vcom_socket_send (__fd, (void *) __buf, (int) __n, __flags);
2051 }
2052
2053 ssize_t
2054 send (int __fd, const void *__buf, size_t __n, int __flags)
2055 {
2056   ssize_t size;
2057   pid_t pid = getpid ();
2058
2059   if (is_vcom_socket_fd (__fd))
2060     {
2061       size = vcom_send (__fd, __buf, __n, __flags);
2062       if (VCOM_DEBUG > 0)
2063         fprintf (stderr,
2064                  "[%d] send: "
2065                  "'%04d'='%04d', '%p', '%04d', '%04x'\n",
2066                  pid, (int) size, __fd, __buf, (int) __n, __flags);
2067       if (size < 0)
2068         {
2069           errno = -size;
2070           return -1;
2071         }
2072       return size;
2073     }
2074   return libc_send (__fd, __buf, __n, __flags);
2075 }
2076
2077 /*
2078  * Read N bytes into BUF from socket FD.
2079  * Returns the number read or -1 for errors.
2080  * This function is a cancellation point and therefore not marked
2081  *  with __THROW.
2082  *  */
2083 ssize_t
2084 vcom_recv (int __fd, void *__buf, size_t __n, int __flags)
2085 {
2086   if (vcom_init () != 0)
2087     {
2088       return -1;
2089     }
2090
2091   return vcom_socket_recv (__fd, __buf, __n, __flags);
2092 }
2093
2094 ssize_t
2095 recv (int __fd, void *__buf, size_t __n, int __flags)
2096 {
2097   ssize_t size;
2098   pid_t pid = getpid ();
2099
2100   if (is_vcom_socket_fd (__fd))
2101     {
2102       size = vcom_recv (__fd, __buf, __n, __flags);
2103       if (VCOM_DEBUG > 0)
2104         fprintf (stderr,
2105                  "[%d] recv: "
2106                  "'%04d'='%04d', '%p', '%04d', '%04x'\n",
2107                  pid, (int) size, __fd, __buf, (int) __n, __flags);
2108       if (size < 0)
2109         {
2110           errno = -size;
2111           return -1;
2112         }
2113       return size;
2114     }
2115   return libc_recv (__fd, __buf, __n, __flags);
2116 }
2117
2118 /*
2119  * Send N bytes of BUF on socket FD to peer at address ADDR (which is
2120  * ADDR_LEN bytes long).  Returns the number sent, or -1 for errors.
2121  * This function is a cancellation point and therefore not marked
2122  * with __THROW.
2123  * */
2124 ssize_t
2125 vcom_sendto (int __fd, const void *__buf, size_t __n, int __flags,
2126              __CONST_SOCKADDR_ARG __addr, socklen_t __addr_len)
2127 {
2128   if (vcom_init () != 0)
2129     {
2130       return -1;
2131     }
2132
2133   return vcom_socket_sendto (__fd, __buf, __n, __flags, __addr, __addr_len);
2134 }
2135
2136 ssize_t
2137 sendto (int __fd, const void *__buf, size_t __n, int __flags,
2138         __CONST_SOCKADDR_ARG __addr, socklen_t __addr_len)
2139 {
2140   ssize_t size;
2141   pid_t pid = getpid ();
2142
2143   if (is_vcom_socket_fd (__fd))
2144     {
2145       size = vcom_sendto (__fd, __buf, __n, __flags, __addr, __addr_len);
2146       if (VCOM_DEBUG > 0)
2147         fprintf (stderr,
2148                  "[%d] sendto: "
2149                  "'%04d'='%04d', '%p', '%04d', '%04x', "
2150                  "'%p', '%04d'\n",
2151                  pid, (int) size, __fd, __buf, (int) __n, __flags,
2152                  __addr, __addr_len);
2153       if (size < 0)
2154         {
2155           errno = -size;
2156           return -1;
2157         }
2158       return size;
2159     }
2160   return libc_sendto (__fd, __buf, __n, __flags, __addr, __addr_len);
2161 }
2162
2163 /*
2164  * Read N bytes into BUF through socket FD.
2165  * If ADDR is not NULL, fill in *ADDR_LEN bytes of it with the
2166  * address of the sender, and store the actual size of the address
2167  * in *ADDR_LEN.
2168  * Returns the number of bytes read or -1 for errors.
2169  * This function is a cancellation point and therefore not marked
2170  * with __THROW.
2171  * */
2172 ssize_t
2173 vcom_recvfrom (int __fd, void *__restrict __buf, size_t __n,
2174                int __flags,
2175                __SOCKADDR_ARG __addr, socklen_t * __restrict __addr_len)
2176 {
2177   if (vcom_init () != 0)
2178     {
2179       return -1;
2180     }
2181
2182   return vcom_socket_recvfrom (__fd, __buf, __n, __flags, __addr, __addr_len);
2183 }
2184
2185 ssize_t
2186 recvfrom (int __fd, void *__restrict __buf, size_t __n,
2187           int __flags,
2188           __SOCKADDR_ARG __addr, socklen_t * __restrict __addr_len)
2189 {
2190   ssize_t size;
2191   pid_t pid = getpid ();
2192
2193   if (is_vcom_socket_fd (__fd))
2194     {
2195       size = vcom_recvfrom (__fd, __buf, __n, __flags, __addr, __addr_len);
2196       if (VCOM_DEBUG > 0)
2197         fprintf (stderr,
2198                  "[%d] recvfrom: "
2199                  "'%04d'='%04d', '%p', '%04d', '%04x', "
2200                  "'%p', '%p'\n",
2201                  pid, (int) size, __fd, __buf, (int) __n, __flags,
2202                  __addr, __addr_len);
2203       if (size < 0)
2204         {
2205           errno = -size;
2206           return -1;
2207         }
2208       return size;
2209     }
2210   return libc_recvfrom (__fd, __buf, __n, __flags, __addr, __addr_len);
2211 }
2212
2213 /*
2214  * Send a message described MESSAGE on socket FD.
2215  * Returns the number of bytes sent, or -1 for errors.
2216  * This function is a cancellation point and therefore not marked
2217  * with __THROW.
2218  * */
2219 ssize_t
2220 vcom_sendmsg (int __fd, const struct msghdr * __message, int __flags)
2221 {
2222   if (vcom_init () != 0)
2223     {
2224       return -1;
2225     }
2226
2227   return vcom_socket_sendmsg (__fd, __message, __flags);
2228 }
2229
2230 ssize_t
2231 sendmsg (int __fd, const struct msghdr * __message, int __flags)
2232 {
2233   ssize_t size;
2234   pid_t pid = getpid ();
2235
2236   if (is_vcom_socket_fd (__fd))
2237     {
2238       size = vcom_sendmsg (__fd, __message, __flags);
2239       if (VCOM_DEBUG > 0)
2240         fprintf (stderr,
2241                  "[%d] sendmsg: "
2242                  "'%04d'='%04d', '%p', '%04x'\n",
2243                  pid, (int) size, __fd, __message, __flags);
2244       if (size < 0)
2245         {
2246           errno = -size;
2247           return -1;
2248         }
2249       return size;
2250     }
2251   return libc_sendmsg (__fd, __message, __flags);
2252 }
2253
2254 #ifdef __USE_GNU
2255 /*
2256  * Send a VLEN messages as described by VMESSAGES to socket FD.
2257  * Returns the number of datagrams successfully written
2258  * or -1 for errors.
2259  * This function is a cancellation point and therefore not marked
2260  * with __THROW.
2261  * */
2262 int
2263 vcom_sendmmsg (int __fd, struct mmsghdr *__vmessages,
2264                unsigned int __vlen, int __flags)
2265 {
2266   if (vcom_init () != 0)
2267     {
2268       return -1;
2269     }
2270
2271   return vcom_socket_sendmmsg (__fd, __message, __vlen, __flags);
2272 }
2273
2274 int
2275 sendmmsg (int __fd, struct mmsghdr *__vmessages,
2276           unsigned int __vlen, int __flags)
2277 {
2278   ssize_t size;
2279   pid_t pid = getpid ();
2280
2281   if (is_vcom_socket_fd (__fd))
2282     {
2283       size = vcom_sendmmsg (__fd, __message, __vlen, __flags);
2284       if (VCOM_DEBUG > 0)
2285         fprintf (stderr,
2286                  "[%d] sendmmsg: "
2287                  "'%04d'='%04d', '%p', '%04d', '%04x'\n",
2288                  pid, (int) size, __fd, __vmessages, __vlen, __flags);
2289       if (size < 0)
2290         {
2291           errno = -size;
2292           return -1;
2293         }
2294       return size;
2295     }
2296   return libc_sendmmsg (__fd, __message, __vlen, __flags);
2297 }
2298
2299 #endif
2300
2301 /*
2302  * Receive a message as described by MESSAGE from socket FD.
2303  * Returns the number of bytes read or -1 for errors.
2304  * This function is a cancellation point and therefore not marked
2305  * with __THROW.
2306  * */
2307 ssize_t
2308 vcom_recvmsg (int __fd, struct msghdr * __message, int __flags)
2309 {
2310   if (vcom_init () != 0)
2311     {
2312       return -1;
2313     }
2314
2315   return vcom_socket_recvmsg (__fd, __message, __flags);
2316 }
2317
2318 ssize_t
2319 recvmsg (int __fd, struct msghdr * __message, int __flags)
2320 {
2321   ssize_t size;
2322   pid_t pid = getpid ();
2323
2324   if (is_vcom_socket_fd (__fd))
2325     {
2326       size = vcom_recvmsg (__fd, __message, __flags);
2327       if (VCOM_DEBUG > 0)
2328         fprintf (stderr,
2329                  "[%d] recvmsg: "
2330                  "'%04d'='%04d', '%p', '%04x'\n",
2331                  pid, (int) size, __fd, __message, __flags);
2332       if (size < 0)
2333         {
2334           errno = -size;
2335           return -1;
2336         }
2337       return size;
2338     }
2339   return libc_recvmsg (__fd, __message, __flags);
2340 }
2341
2342 #ifdef __USE_GNU
2343 /*
2344  * Receive up to VLEN messages as described by VMESSAGES from socket FD.
2345  * Returns the number of messages received or -1 for errors.
2346  * This function is a cancellation point and therefore not marked
2347  * with __THROW.
2348  * */
2349 int
2350 vcom_recvmmsg (int __fd, struct mmsghdr *__vmessages,
2351                unsigned int __vlen, int __flags, struct timespec *__tmo)
2352 {
2353   if (vcom_init () != 0)
2354     {
2355       return -1;
2356     }
2357
2358   return vcom_socket_recvmmsg (__fd, __message, __vlen, __flags, __tmo);
2359 }
2360
2361 int
2362 recvmmsg (int __fd, struct mmsghdr *__vmessages,
2363           unsigned int __vlen, int __flags, struct timespec *__tmo)
2364 {
2365   ssize_t size;
2366   pid_t pid = getpid ();
2367
2368   if (is_vcom_socket_fd (__fd))
2369     {
2370       size = vcom_recvmmsg (__fd, __message, __vlen, __flags, __tmo);
2371       if (VCOM_DEBUG > 0)
2372         fprintf (stderr,
2373                  "[%d] recvmmsg: "
2374                  "'%04d'='%04d', '%p', "
2375                  "'%04d', '%04x', '%p'\n",
2376                  pid, (int) size, __fd, __vmessages, __vlen, __flags, __tmo);
2377       if (size < 0)
2378         {
2379           errno = -size;
2380           return -1;
2381         }
2382       return size;
2383     }
2384   return libc_recvmmsg (__fd, __message, __vlen, __flags, __tmo);
2385 }
2386
2387 #endif
2388
2389 /*
2390  * Put the current value for socket FD's option OPTNAME
2391  * at protocol level LEVEL into OPTVAL (which is *OPTLEN bytes long),
2392  * and set *OPTLEN to the value's actual length.
2393  * Returns 0 on success, -1 for errors.
2394  * */
2395 int
2396 vcom_getsockopt (int __fd, int __level, int __optname,
2397                  void *__restrict __optval, socklen_t * __restrict __optlen)
2398 {
2399   if (vcom_init () != 0)
2400     {
2401       return -1;
2402     }
2403
2404   return vcom_socket_getsockopt (__fd, __level, __optname,
2405                                  __optval, __optlen);
2406 }
2407
2408 int
2409 getsockopt (int __fd, int __level, int __optname,
2410             void *__restrict __optval, socklen_t * __restrict __optlen)
2411 {
2412   int rv;
2413   pid_t pid = getpid ();
2414
2415   if (is_vcom_socket_fd (__fd))
2416     {
2417       rv = vcom_getsockopt (__fd, __level, __optname, __optval, __optlen);
2418       if (VCOM_DEBUG > 2)
2419         fprintf (stderr,
2420                  "[%d] getsockopt: "
2421                  "'%04d'='%04d', '%04d', '%04d', "
2422                  "'%p', '%p'\n",
2423                  pid, rv, __fd, __level, __optname, __optval, __optlen);
2424       if (rv != 0)
2425         {
2426           errno = -rv;
2427           return -1;
2428         }
2429       return 0;
2430     }
2431   return libc_getsockopt (__fd, __level, __optname, __optval, __optlen);
2432 }
2433
2434 /*
2435  * Set socket FD's option OPTNAME at protocol level LEVEL
2436  * to *OPTVAL (which is OPTLEN bytes long).
2437  * Returns 0 on success, -1 for errors.
2438  * */
2439 int
2440 vcom_setsockopt (int __fd, int __level, int __optname,
2441                  const void *__optval, socklen_t __optlen)
2442 {
2443   if (vcom_init () != 0)
2444     {
2445       return -1;
2446     }
2447
2448   return vcom_socket_setsockopt (__fd, __level, __optname,
2449                                  __optval, __optlen);
2450 }
2451
2452 int
2453 setsockopt (int __fd, int __level, int __optname,
2454             const void *__optval, socklen_t __optlen)
2455 {
2456   int rv;
2457   pid_t pid = getpid ();
2458
2459   if (is_vcom_socket_fd (__fd))
2460     {
2461       rv = vcom_setsockopt (__fd, __level, __optname, __optval, __optlen);
2462       if (VCOM_DEBUG > 0)
2463         fprintf (stderr,
2464                  "[%d] setsockopt: "
2465                  "'%04d'='%04d', '%04d', '%04d', "
2466                  "'%p', '%04d'\n",
2467                  pid, rv, __fd, __level, __optname, __optval, __optlen);
2468       if (rv != 0)
2469         {
2470           errno = -rv;
2471           return -1;
2472         }
2473       return 0;
2474     }
2475   return libc_setsockopt (__fd, __level, __optname, __optval, __optlen);
2476 }
2477
2478 /*
2479  * Prepare to accept connections on socket FD.
2480  * N connection requests will be queued before further
2481  * requests are refused.
2482  * Returns 0 on success, -1 for errors.
2483  * */
2484 int
2485 vcom_listen (int __fd, int __n)
2486 {
2487   if (vcom_init () != 0)
2488     {
2489       return -1;
2490     }
2491
2492   return vcom_socket_listen (__fd, __n);
2493 }
2494
2495 int
2496 listen (int __fd, int __n)
2497 {
2498   int rv;
2499   pid_t pid = getpid ();
2500
2501   if (is_vcom_socket_fd (__fd))
2502     {
2503       rv = vcom_listen (__fd, __n);
2504       if (VCOM_DEBUG > 0)
2505         fprintf (stderr,
2506                  "[%d] listen: "
2507                  "'%04d'='%04d', '%04d'\n", pid, rv, __fd, __n);
2508       if (rv != 0)
2509         {
2510           errno = -rv;
2511           return -1;
2512         }
2513       return 0;
2514     }
2515   return libc_listen (__fd, __n);
2516 }
2517
2518 /*
2519  * Await a connection on socket FD.
2520  * When a connection arrives, open a new socket to communicate
2521  * with it, set *ADDR (which is *ADDR_LEN bytes long) to the address
2522  * of the connecting peer and *ADDR_LEN to the address's actual
2523  * length, and return the new socket's descriptor, or -1 for errors.
2524  * This function is a cancellation point and therefore not marked
2525  * with __THROW.
2526  * */
2527 int
2528 vcom_accept (int __fd, __SOCKADDR_ARG __addr,
2529              socklen_t * __restrict __addr_len)
2530 {
2531
2532   if (vcom_init () != 0)
2533     {
2534       return -1;
2535     }
2536   return vcom_socket_accept (__fd, __addr, __addr_len);
2537 }
2538
2539 int
2540 accept (int __fd, __SOCKADDR_ARG __addr, socklen_t * __restrict __addr_len)
2541 {
2542   int rv = -1;
2543   pid_t pid = getpid ();
2544   pthread_t tid = pthread_self ();
2545
2546   if (is_vcom_socket_fd (__fd))
2547     {
2548       if (VCOM_DEBUG > 0)
2549         vcom_socket_main_show ();
2550       if (VCOM_DEBUG > 0)
2551         fprintf (stderr,
2552                  "[%d][%lu (0x%lx)] accept1: "
2553                  "'%04d'='%04d', '%p', '%p'\n",
2554                  pid, (unsigned long) tid, (unsigned long) tid,
2555                  rv, __fd, __addr, __addr_len);
2556       rv = vcom_accept (__fd, __addr, __addr_len);
2557       if (VCOM_DEBUG > 0)
2558         fprintf (stderr,
2559                  "[%d][%lu (0x%lx)] accept2: "
2560                  "'%04d'='%04d', '%p', '%p'\n",
2561                  pid, (unsigned long) tid, (unsigned long) tid,
2562                  rv, __fd, __addr, __addr_len);
2563       if (VCOM_DEBUG > 0)
2564         vcom_socket_main_show ();
2565       if (rv < 0)
2566         {
2567           errno = -rv;
2568           return -1;
2569         }
2570       return rv;
2571     }
2572   return libc_accept (__fd, __addr, __addr_len);
2573 }
2574
2575 #ifdef __USE_GNU
2576 /*
2577  * Similar to 'accept' but takes an additional parameter to specify
2578  * flags.
2579  * This function is a cancellation point and therefore not marked
2580  * with __THROW.
2581  * */
2582 int
2583 vcom_accept4 (int __fd, __SOCKADDR_ARG __addr,
2584               socklen_t * __restrict __addr_len, int __flags)
2585 {
2586
2587   if (vcom_init () != 0)
2588     {
2589       return -1;
2590     }
2591
2592   return vcom_socket_accept4 (__fd, __addr, __addr_len, __flags);
2593 }
2594
2595 int
2596 accept4 (int __fd, __SOCKADDR_ARG __addr,
2597          socklen_t * __restrict __addr_len, int __flags)
2598 {
2599   int rv;
2600   pid_t pid = getpid ();
2601
2602   if (is_vcom_socket_fd (__fd))
2603     {
2604       if (VCOM_DEBUG > 0)
2605         vcom_socket_main_show ();
2606       rv = vcom_accept4 (__fd, __addr, __addr_len, __flags);
2607       if (VCOM_DEBUG > 0)
2608         fprintf (stderr,
2609                  "[%d] accept4: "
2610                  "'%04d'='%04d', '%p', '%p', '%04x'\n",
2611                  pid, rv, __fd, __addr, __addr_len, __flags);
2612       if (VCOM_DEBUG > 0)
2613         vcom_socket_main_show ();
2614       if (rv < 0)
2615         {
2616           errno = -rv;
2617           return -1;
2618         }
2619       return rv;
2620     }
2621   return libc_accept4 (__fd, __addr, __addr_len, __flags);
2622 }
2623
2624 #endif
2625
2626 /*
2627  * Shut down all or part of the connection open on socket FD.
2628  * HOW determines what to shut down:
2629  *   SHUT_RD   = No more receptions;
2630  *   SHUT_WR   = No more transmissions;
2631  *   SHUT_RDWR = No more receptions or transmissions.
2632  * Returns 0 on success, -1 for errors.
2633  * */
2634 int
2635 vcom_shutdown (int __fd, int __how)
2636 {
2637   if (vcom_init () != 0)
2638     {
2639       return -1;
2640     }
2641   return vcom_socket_shutdown (__fd, __how);
2642 }
2643
2644 int
2645 shutdown (int __fd, int __how)
2646 {
2647   int rv;
2648   pid_t pid = getpid ();
2649
2650   if (is_vcom_socket_fd (__fd))
2651     {
2652       rv = vcom_shutdown (__fd, __how);
2653       if (VCOM_DEBUG > 0)
2654         fprintf (stderr,
2655                  "[%d] shutdown: "
2656                  "'%04d'='%04d', '%04d'\n", pid, rv, __fd, __how);
2657       if (rv != 0)
2658         {
2659           errno = -rv;
2660           return -1;
2661         }
2662       return 0;
2663     }
2664   return libc_shutdown (__fd, __how);
2665 }
2666
2667 int
2668 vcom_epoll_create (int __size)
2669 {
2670
2671   if (vcom_init () != 0)
2672     {
2673       return -1;
2674     }
2675
2676   if (__size <= 0)
2677     {
2678       return -EINVAL;
2679     }
2680
2681   /* __size argument is ignored "thereafter" */
2682   return vcom_epoll_create1 (0);
2683 }
2684
2685 /*
2686  * __size argument is ignored, but must be greater than zero
2687  */
2688 int
2689 epoll_create (int __size)
2690 {
2691   int rv = 0;
2692   pid_t pid = getpid ();
2693
2694   rv = vcom_epoll_create (__size);
2695   if (VCOM_DEBUG > 0)
2696     fprintf (stderr,
2697              "[%d] epoll_create: " "'%04d'='%04d'\n", pid, rv, __size);
2698   if (rv < 0)
2699     {
2700       errno = -rv;
2701       return -1;
2702     }
2703   return rv;
2704 }
2705
2706 int
2707 vcom_epoll_create1 (int __flags)
2708 {
2709   if (vcom_init () != 0)
2710     {
2711       return -1;
2712     }
2713
2714   if (__flags < 0)
2715     {
2716       return -EINVAL;
2717     }
2718   if (__flags & ~EPOLL_CLOEXEC)
2719     {
2720       return -EINVAL;
2721     }
2722   /* __flags can be either zero or EPOLL_CLOEXEC */
2723   /* implementation */
2724   return vcom_socket_epoll_create1 (__flags);
2725 }
2726
2727 /*
2728  * __flags can be either zero or EPOLL_CLOEXEC
2729  * */
2730 int
2731 epoll_create1 (int __flags)
2732 {
2733   int rv = 0;
2734   pid_t pid = getpid ();
2735
2736   rv = vcom_epoll_create1 (__flags);
2737   if (VCOM_DEBUG > 0)
2738     fprintf (stderr,
2739              "[%d] epoll_create: " "'%04d'='%08x'\n", pid, rv, __flags);
2740   if (rv < 0)
2741     {
2742       errno = -rv;
2743       return -1;
2744     }
2745   return rv;
2746 }
2747
2748 static inline int
2749 ep_op_has_event (int op)
2750 {
2751   return op != EPOLL_CTL_DEL;
2752 }
2753
2754 int
2755 vcom_epoll_ctl (int __epfd, int __op, int __fd, struct epoll_event *__event)
2756 {
2757   if (vcom_init () != 0)
2758     {
2759       return -1;
2760     }
2761
2762   /*
2763    * the requested operation __op is not supported
2764    * by this interface */
2765   if (!((__op == EPOLL_CTL_ADD) ||
2766         (__op == EPOLL_CTL_MOD) || (__op == EPOLL_CTL_DEL)))
2767     {
2768       return -EINVAL;
2769     }
2770
2771   /* op is ADD or MOD but event parameter is NULL */
2772   if ((ep_op_has_event (__op) && !__event))
2773     {
2774       return -EFAULT;
2775     }
2776
2777   /* fd is same as epfd */
2778   /* do not permit adding an epoll file descriptor inside itself */
2779   if (__epfd == __fd)
2780     {
2781       return -EINVAL;
2782     }
2783
2784   /* implementation */
2785   return vcom_socket_epoll_ctl (__epfd, __op, __fd, __event);
2786 }
2787
2788 /*
2789  * implement the controller interface for epoll
2790  * that enables the insertion/removal/change of
2791  * file descriptors inside the interest set.
2792  */
2793 int
2794 epoll_ctl (int __epfd, int __op, int __fd, struct epoll_event *__event)
2795 {
2796   int rv;
2797   pid_t pid = getpid ();
2798
2799   if (is_vcom_epfd (__epfd))
2800     {
2801       /* TBD: currently limiting epoll to support only vcom fds */
2802       if (is_vcom_socket_fd (__fd))
2803         {
2804           rv = vcom_epoll_ctl (__epfd, __op, __fd, __event);
2805           if (VCOM_DEBUG > 0)
2806             fprintf (stderr,
2807                      "[%d] epoll_ctl: "
2808                      "'%04d'='%04d', '%04d', '%04d'\n",
2809                      pid, rv, __epfd, __op, __fd);
2810           if (rv != 0)
2811             {
2812               errno = -rv;
2813               return -1;
2814             }
2815           return 0;
2816         }
2817       else
2818         {
2819           /*
2820            * TBD: currently epoll does not support kernel fds
2821            * or epoll fds */
2822           errno = EBADF;
2823           return -1;
2824         }
2825     }
2826   else
2827     {
2828       /* epfd is not an epoll file descriptor */
2829       errno = EINVAL;
2830       return -1;
2831     }
2832   return 0;
2833 }
2834
2835 int
2836 vcom_epoll_wait (int __epfd, struct epoll_event *__events,
2837                  int __maxevents, int __timeout)
2838 {
2839   if (vcom_init () != 0)
2840     {
2841       return -1;
2842     }
2843
2844   return vcom_epoll_pwait (__epfd, __events, __maxevents, __timeout, NULL);
2845 }
2846
2847 int
2848 epoll_wait (int __epfd, struct epoll_event *__events,
2849             int __maxevents, int __timeout)
2850 {
2851   int rv;
2852   pid_t pid = getpid ();
2853
2854   if (__maxevents <= 0 || __maxevents > EP_MAX_EVENTS)
2855     {
2856       errno = EINVAL;
2857       return -1;
2858     }
2859
2860   if (is_vcom_epfd (__epfd))
2861     {
2862       rv = vcom_epoll_wait (__epfd, __events, __maxevents, __timeout);
2863       if (VCOM_DEBUG > 0)
2864         fprintf (stderr,
2865                  "[%d] epoll_wait: "
2866                  "'%04d'='%04d', '%p', "
2867                  "'%04d', '%04d'\n",
2868                  pid, rv, __epfd, __events, __maxevents, __timeout);
2869       if (rv < 0)
2870         {
2871           errno = -rv;
2872           return -1;
2873         }
2874       return rv;
2875     }
2876   else
2877     {
2878       errno = EINVAL;
2879       return -1;
2880     }
2881   return 0;
2882 }
2883
2884
2885 int
2886 vcom_epoll_pwait (int __epfd, struct epoll_event *__events,
2887                   int __maxevents, int __timeout, const __sigset_t * __ss)
2888 {
2889   if (vcom_init () != 0)
2890     {
2891       return -1;
2892     }
2893
2894   /* implementation */
2895   return vcom_socket_epoll_pwait (__epfd, __events,
2896                                   __maxevents, __timeout, __ss);
2897 }
2898
2899 int
2900 epoll_pwait (int __epfd, struct epoll_event *__events,
2901              int __maxevents, int __timeout, const __sigset_t * __ss)
2902 {
2903   int rv;
2904   pid_t pid = getpid ();
2905
2906   if (__maxevents <= 0 || __maxevents > EP_MAX_EVENTS)
2907     {
2908       errno = EINVAL;
2909       return -1;
2910     }
2911
2912   if (is_vcom_epfd (__epfd))
2913     {
2914       rv = vcom_epoll_pwait (__epfd, __events, __maxevents, __timeout, __ss);
2915       if (VCOM_DEBUG > 0)
2916         fprintf (stderr,
2917                  "[%d] epoll_pwait: "
2918                  "'%04d'='%04d', '%p', "
2919                  "'%04d', '%04d', "
2920                  "'%p'\n",
2921                  pid, rv, __epfd, __events, __maxevents, __timeout, __ss);
2922       if (rv < 0)
2923         {
2924           errno = -rv;
2925           return -1;
2926         }
2927       return rv;
2928     }
2929   else
2930     {
2931       errno = EINVAL;
2932       return -1;
2933     }
2934
2935   return 0;
2936 }
2937
2938 /* Poll the file descriptors described by the NFDS structures starting at
2939    FDS.  If TIMEOUT is nonzero and not -1, allow TIMEOUT milliseconds for
2940    an event to occur; if TIMEOUT is -1, block until an event occurs.
2941    Returns the number of file descriptors with events, zero if timed out,
2942    or -1 for errors.
2943
2944    This function is a cancellation point and therefore not marked with
2945    __THROW.  */
2946
2947 int
2948 vcom_poll (struct pollfd *__fds, nfds_t __nfds, int __timeout)
2949 {
2950   int rv = 0;
2951   pid_t pid = getpid ();
2952
2953   struct rlimit nofile_limit;
2954   struct pollfd vcom_fds[MAX_POLL_NFDS_DEFAULT];
2955   nfds_t fds_idx = 0;
2956
2957   /* actual set of file descriptors to be monitored */
2958   nfds_t libc_nfds = 0;
2959   nfds_t vcom_nfds = 0;
2960
2961   /* ready file descriptors
2962    *
2963    * number of structures which have nonzero revents  fields
2964    * in other words, descriptors  with events or errors reported.
2965    * */
2966   /* after call to libc_poll () */
2967   int rlibc_nfds = 0;
2968   /* after call to vcom_socket_poll () */
2969   int rvcom_nfds = 0;
2970
2971
2972   /* timeout value in units of timespec */
2973   struct timespec timeout_ts;
2974   struct timespec start_time, now, end_time;
2975
2976
2977   /* get start_time */
2978   rv = clock_gettime (CLOCK_MONOTONIC, &start_time);
2979   if (rv == -1)
2980     {
2981       rv = -errno;
2982       goto poll_done;
2983     }
2984
2985   /* set timeout_ts & end_time */
2986   if (__timeout >= 0)
2987     {
2988       /* set timeout_ts */
2989       timeout_ts.tv_sec = __timeout / MSEC_PER_SEC;
2990       timeout_ts.tv_nsec = (__timeout % MSEC_PER_SEC) * NSEC_PER_MSEC;
2991       set_normalized_timespec (&timeout_ts,
2992                                timeout_ts.tv_sec, timeout_ts.tv_nsec);
2993       /* set end_time */
2994       if (__timeout)
2995         {
2996           end_time = timespec_add (start_time, timeout_ts);
2997         }
2998       else
2999         {
3000           end_time = start_time;
3001         }
3002     }
3003
3004   if (vcom_init () != 0)
3005     {
3006       rv = -1;
3007       goto poll_done;
3008     }
3009
3010   /* validate __fds */
3011   if (!__fds)
3012     {
3013       rv = -EFAULT;
3014       goto poll_done;
3015     }
3016
3017   /* validate __nfds */
3018   /*TBD: call getrlimit once when vcl-ldpreload library is init */
3019   rv = getrlimit (RLIMIT_NOFILE, &nofile_limit);
3020   if (rv != 0)
3021     {
3022       rv = -errno;
3023       goto poll_done;
3024     }
3025   if (__nfds >= nofile_limit.rlim_cur)
3026     {
3027       rv = -EINVAL;
3028       goto poll_done;
3029     }
3030
3031   /*
3032    * for the POC, it's fair to assume that nfds is less than 1024
3033    * */
3034   if (__nfds >= MAX_POLL_NFDS_DEFAULT)
3035     {
3036       rv = -EINVAL;
3037       goto poll_done;
3038     }
3039
3040   /* set revents field (output parameter)
3041    * to zero
3042    * */
3043   for (fds_idx = 0; fds_idx < __nfds; fds_idx++)
3044     {
3045       __fds[fds_idx].revents = 0;
3046     }
3047
3048 #if 0
3049   /* set revents field (output parameter)
3050    * to zero for user ignored fds
3051    * */
3052   for (fds_idx = 0; fds_idx < __nfds; fds_idx++)
3053     {
3054       /*
3055        * if negative fd, ignore events field
3056        * and set output parameter (revents field) to zero */
3057       if (__fds[fds_idx].fd < 0)
3058         {
3059           __fds[fds_idx].revents = 0;
3060         }
3061     }
3062 #endif
3063
3064   /*
3065    * 00. prepare __fds and vcom_fds for polling
3066    *     copy __fds to vcom_fds
3067    * 01. negate all except libc fds in __fds,
3068    *     ignore user negated fds
3069    * 02. negate all except vcom_fds in vocm fds,
3070    *     ignore user negated fds
3071    *     ignore fd 0 by setting it to negative number
3072    * */
3073   memcpy (vcom_fds, __fds, sizeof (*__fds) * __nfds);
3074   libc_nfds = 0;
3075   vcom_nfds = 0;
3076   for (fds_idx = 0; fds_idx < __nfds; fds_idx++)
3077     {
3078       /* ignore negative fds */
3079       if (__fds[fds_idx].fd < 0)
3080         {
3081           continue;
3082         }
3083
3084       /*
3085        * 00. ignore vcom fds in __fds
3086        * 01. ignore libc fds in vcom_fds,
3087        *     ignore fd 0 by setting it to negative number.
3088        *     as fd 0 cannot be ignored.
3089        */
3090       if (is_vcom_socket_fd (__fds[fds_idx].fd) ||
3091           is_vcom_epfd (__fds[fds_idx].fd))
3092         {
3093           __fds[fds_idx].fd = -__fds[fds_idx].fd;
3094           vcom_nfds++;
3095         }
3096       else
3097         {
3098           libc_nfds++;
3099           /* ignore fd 0 by setting it to negative number */
3100           if (!vcom_fds[fds_idx].fd)
3101             {
3102               vcom_fds[fds_idx].fd = -1;
3103             }
3104           vcom_fds[fds_idx].fd = -vcom_fds[fds_idx].fd;
3105         }
3106     }
3107
3108   /*
3109    * polling loop
3110    *
3111    * poll on libc fds and vcom fds
3112    *
3113    * specifying a timeout of zero causes libc_poll() and
3114    * vcom_socket_poll() to return immediately, even if no
3115    * file descriptors are ready
3116    * */
3117   do
3118     {
3119       rlibc_nfds = 0;
3120       rvcom_nfds = 0;
3121
3122       /*
3123        * timeout parameter for libc_poll () set to zero
3124        * to poll on libc fds
3125        * */
3126
3127       /* poll on libc fds */
3128       if (libc_nfds)
3129         {
3130           /*
3131            * a timeout of zero causes libc_poll()
3132            * to return immediately
3133            * */
3134           rlibc_nfds = libc_poll (__fds, __nfds, 0);
3135           if (VCOM_DEBUG > 2)
3136             fprintf (stderr,
3137                      "[%d] poll libc: "
3138                      "'%04d'='%08lu'\n", pid, rlibc_nfds, __nfds);
3139
3140           if (rlibc_nfds < 0)
3141             {
3142               rv = -errno;
3143               goto poll_done_update_nfds;
3144             }
3145         }
3146
3147       /*
3148        * timeout parameter for vcom_socket_poll () set to zero
3149        * to poll on vcom fds
3150        * */
3151
3152       /* poll on vcom fds */
3153       if (vcom_nfds)
3154         {
3155           /*
3156            * a timeout of zero causes vcom_socket_poll()
3157            * to return immediately
3158            * */
3159           rvcom_nfds = vcom_socket_poll (vcom_fds, __nfds, 0);
3160           if (VCOM_DEBUG > 2)
3161             fprintf (stderr,
3162                      "[%d] poll vcom: "
3163                      "'%04d'='%08lu'\n", pid, rvcom_nfds, __nfds);
3164           if (rvcom_nfds < 0)
3165             {
3166               rv = rvcom_nfds;
3167               goto poll_done_update_nfds;
3168             }
3169         }
3170
3171       /* check if any file descriptors changed status */
3172       if ((libc_nfds && rlibc_nfds > 0) || (vcom_nfds && rvcom_nfds > 0))
3173         {
3174           /* something interesting happened */
3175           rv = rlibc_nfds + rvcom_nfds;
3176           goto poll_done_update_nfds;
3177         }
3178
3179       rv = clock_gettime (CLOCK_MONOTONIC, &now);
3180       if (rv == -1)
3181         {
3182           rv = -errno;
3183           goto poll_done_update_nfds;
3184         }
3185     }
3186
3187   /* block indefinitely || timeout elapsed  */
3188   while ((__timeout < 0) || timespec_compare (&now, &end_time) < 0);
3189
3190   /* timeout expired before anything interesting happened */
3191   rv = 0;
3192
3193 poll_done_update_nfds:
3194   for (fds_idx = 0; fds_idx < __nfds; fds_idx++)
3195     {
3196       /* ignore negative fds in vcom_fds
3197        * 00. user negated fds
3198        * 01. libc fds
3199        * */
3200       if (vcom_fds[fds_idx].fd < 0)
3201         {
3202           continue;
3203         }
3204
3205       /* from here on handle positive vcom fds */
3206       /*
3207        * restore vcom fds to positive number in __fds
3208        * and update revents in __fds with the events
3209        * that actually occurred in vcom fds
3210        * */
3211       __fds[fds_idx].fd = -__fds[fds_idx].fd;
3212       if (rvcom_nfds)
3213         {
3214           __fds[fds_idx].revents = vcom_fds[fds_idx].revents;
3215         }
3216     }
3217
3218 poll_done:
3219   if (VCOM_DEBUG > 2)
3220     fprintf (stderr, "[%d] vpoll: " "'%04d'='%08lu'\n", pid, rv, __nfds);
3221   return rv;
3222 }
3223
3224 /*
3225  * 00. The  field  __fds[i].fd contains a file descriptor for an
3226  *     open file.
3227  *     If this field is negative, then the corresponding
3228  *     events field is ignored and the revents field returns zero.
3229  *     The field __fds[i].events is an input parameter.
3230  *     The field __fds[i].revents is an output parameter.
3231  * 01. Specifying a negative value in  timeout
3232  *     means  an infinite timeout.
3233  *     Specifying a timeout of zero causes poll() to return
3234  *     immediately, even if no file descriptors are ready.
3235  *
3236  * NOTE: observed __nfds is less than 128 from kubecon strace files
3237  */
3238
3239
3240 int
3241 poll (struct pollfd *__fds, nfds_t __nfds, int __timeout)
3242 {
3243   int rv = 0;
3244   pid_t pid = getpid ();
3245
3246
3247   if (VCOM_DEBUG > 2)
3248     fprintf (stderr, "[%d] poll1: " "'%04d'='%08lu, %d, 0x%x'\n",
3249              pid, rv, __nfds, __fds[0].fd, __fds[0].events);
3250   rv = vcom_poll (__fds, __nfds, __timeout);
3251   if (VCOM_DEBUG > 2)
3252     fprintf (stderr, "[%d] poll2: " "'%04d'='%08lu, %d, 0x%x'\n",
3253              pid, rv, __nfds, __fds[0].fd, __fds[0].revents);
3254   if (rv < 0)
3255     {
3256       errno = -rv;
3257       return -1;
3258     }
3259   return rv;
3260 }
3261
3262 #ifdef __USE_GNU
3263 /* Like poll, but before waiting the threads signal mask is replaced
3264    with that specified in the fourth parameter.  For better usability,
3265    the timeout value is specified using a TIMESPEC object.
3266
3267    This function is a cancellation point and therefore not marked with
3268    __THROW.  */
3269 int
3270 vcom_ppoll (struct pollfd *__fds, nfds_t __nfds,
3271             const struct timespec *__timeout, const __sigset_t * __ss)
3272 {
3273   if (vcom_init () != 0)
3274     {
3275       return -1;
3276     }
3277
3278   return -EOPNOTSUPP;
3279 }
3280
3281 int
3282 ppoll (struct pollfd *__fds, nfds_t __nfds,
3283        const struct timespec *__timeout, const __sigset_t * __ss)
3284 {
3285   int rv = 0;
3286
3287   errno = EOPNOTSUPP;
3288   rv = -1;
3289   return rv;
3290 }
3291 #endif
3292
3293 void CONSTRUCTOR_ATTRIBUTE vcom_constructor (void);
3294
3295 void DESTRUCTOR_ATTRIBUTE vcom_destructor (void);
3296
3297 void
3298 vcom_constructor (void)
3299 {
3300   pid_t pid = getpid ();
3301
3302   swrap_constructor ();
3303   if (vcom_init () != 0)
3304     {
3305       printf ("\n[%d] vcom_constructor...failed!\n", pid);
3306     }
3307   else
3308     {
3309       printf ("\n[%d] vcom_constructor...done!\n", pid);
3310     }
3311 }
3312
3313 /*
3314  * This function is called when the library is unloaded
3315  */
3316 void
3317 vcom_destructor (void)
3318 {
3319   pid_t pid = getpid ();
3320
3321   vcom_destroy ();
3322   swrap_destructor ();
3323   printf ("\n[%d] vcom_destructor...done!\n", pid);
3324 }
3325
3326
3327 /*
3328  * fd.io coding-style-patch-verification: ON
3329  *
3330  * Local Variables:
3331  * eval: (c-set-style "gnu")
3332  * End:
3333  */