regina/os_unx.c

   1 /*
   2  *  The Regina Rexx Interpreter
   3  *  Copyright (C) 2005 Florian Grosse-Coosmann
   4  *
   5  *  System interfacing functions for unix and equivalent systems
   6  *
   7  *  This library is free software; you can redistribute it and/or
   8  *  modify it under the terms of the GNU Library General Public
   9  *  License as published by the Free Software Foundation; either
  10  *  version 2 of the License, or (at your option) any later version.
  11  *
  12  *  This library is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  *  Library General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU Library General Public
  18  *  License along with this library; if not, write to the Free
  19  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include "rexx.h"
  23 #include "utsname.h"
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #if defined(HAVE_STRING_H)
  29 # include <stdio.h>
  30 #endif
  31
  32 #if defined(DOS)
  33 # ifdef _POSIX_SOURCE   /* emulation system? */
  34 #  undef _POSIX_SOURCE
  35 # endif
  36 # include <dos.h>
  37 #endif
  38
  39 #if defined(HAVE_ASSERT_H)
  40 # include <assert.h>
  41 #endif
  42
  43 #if defined(HAVE_UNISTD_H)
  44 # include <unistd.h>
  45 #endif
  46
  47 #if defined(HAVE_SYS_STAT_H)
  48 # include <sys/stat.h>
  49 #endif
  50
  51 #if defined(HAVE_SYS_WAIT_H)
  52 # include <sys/wait.h>
  53 #endif
  54
  55 #if defined(HAVE_FCNTL_H)
  56 # include <fcntl.h>
  57 #endif
  58
  59 #if defined(HAVE_SYS_FCNTL_H)
  60 # include <sys/fcntl.h>
  61 #endif
  62
  63 #if defined(HAVE_PROCESS_H)
  64 # include <process.h>
  65 #endif
  66
  67 #if defined(HAVE_SHARE_H)
  68 # include <share.h>
  69 #endif
  70
  71 #if defined(HAVE_TIME_H)
  72 # include <time.h>
  73 #endif
  74
  75 #if defined(HAVE_ERRNO_H)
  76 # include <errno.h>
  77 #endif
  78
  79 #if defined(HAVE_SIGNAL_H)
  80 # include <signal.h>
  81 #endif
  82
  83 #if defined(HAVE_ASSERT_H)
  84 # include <assert.h>
  85 #endif
  86
  87 #if defined(HAVE_SYS_UTSNAME_H)
  88 # include <sys/utsname.h>
  89 #endif
  90
  91 #if defined(HAVE_POLL) && (defined(HAVE_POLL_H) || defined(HAVE_SYS_POLL_H))
  92 # if defined(HAVE_POLL_H)
  93 #  include <poll.h>
  94 # else
  95 #  include <sys/poll.h>
  96 # endif
  97   /* implement a simple(!) wait mechanism for a max. of 3 handles */
  98   typedef struct {
  99    const tsd_t *TSD;
 100    struct pollfd _p[3] ;
 101    int _p_cnt ;
 102   } AsyncInfo;
 103 #elif defined(HAVE_SYS_SELECT_H) || defined(SELECT_IN_TIME_H) || defined(HAVE_SYS_SOCKET_H)
 104 # if defined(HAVE_SYS_SELECT_H)
 105 #   include <sys/select.h>
 106 # elif defined(HAVE_SYS_SOCKET_H)
 107 #   include <sys/socket.h>
 108 # else
 109 #   include <time.h>
 110 # endif
 111   /* implement a simple(!) wait mechanism for a max. of 3 handles */
 112   typedef struct {
 113    const tsd_t *TSD;
 114    fd_set _p_in;
 115    fd_set _p_out;
 116    int _p_max ;
 117   } AsyncInfo;
 118 #endif
 119
 120 #if defined(HAVE_SYS_RESOURCE_H)
 121 # include <sys/resource.h>
 122 #endif
 123
 124 static int Unx_setenv( const char *name, const char *value )
 125 {
 126 #if defined(HAVE_SETENV)
 127    setenv( name, value, 1 );
 128    return 1;
 129 #else
 130    char *cmd;
 131
 132    if (value == NULL)
 133       value = "";
 134    cmd = malloc( strlen(name) + strlen(value) + 2);
 135    sprintf( cmd, "%s=%s", name, value );
 136    putenv( cmd );
 137    free( cmd );
 138    return 1;
 139 #  endif
 140 }
 141 /* MaxFiles returns the maximum number of files which can be addressed by a
 142  * single process. We guess the result if we can't determine it.
 143  */
 144 #if defined(__QNX__) && !defined(__QNXNTO__)
 145 #include <sys/osinfo.h>
 146 static int MaxFiles(void)
 147 /*
 148  * returns the maximum number of files which can be addressed by a single
 149  * process. We guess the result if we can't determine it.
 150  */
 151 {
 152    struct _osinfo osdata;
 153    if ( qnx_osinfo( 0, &osdata ) != -1 )
 154    {
 155       return osdata.num_fds[1];
 156    }
 157    else
 158    {
 159       return 256;
 160    }
 161 }
 162 #else
 163 static int MaxFiles(void)
 164 {
 165    int rlmax = INT_MAX; /* resource's limit */
 166    int scmax = INT_MAX; /* sysconf limit */
 167
 168 #ifdef _SC_OPEN_MAX
 169    scmax = sysconf(_SC_OPEN_MAX); /* systemwide maximum */
 170 #endif
 171
 172 #if defined(HAVE_SYS_RESOURCE_H) && defined(RLIMIT_OFILE)
 173    /* user's limit might be decreased by himself: */
 174    {
 175       struct rlimit rl;
 176
 177       if (getrlimit(RLIMIT_OFILE,&rl) == 0)
 178          if ((unsigned) rl.rlim_cur < (unsigned) INT_MAX)
 179             rlmax = (int) rl.rlim_cur;
 180    }
 181 #endif
 182
 183    if (rlmax < scmax) /* map rlmax to scmax */
 184       scmax = rlmax;
 185    if (scmax != INT_MAX) /* either getrlimit or sysconf valid? */
 186       return(scmax);
 187
 188 #ifdef POSIX_OPEN_MAX
 189    /* maybe, we have a hardcoded limit */
 190    if (POSIX_OPEN_MAX != INT_MAX) /* shall work in most cases */
 191         return(POSIX_OPEN_MAX);
 192 #endif
 193
 194    return(256); /* just a guess */
 195 }
 196 #endif
 197
 198 /*
 199  * fork_exec spawns a new process with the given commandline.
 200  * it returns -1 on error (errno set), 0 on process start error (rcode set),
 201  * a process descriptor otherwise.
 202  * Basically this is a child process and we run in the child's environment
 203  * after the first few lines. The setup hasn't been done and the command needs
 204  * to be started.
 205  * Redirection takes place if one of the handles env->input.hdls[0],
 206  * env->output.hdls[1] or env->error.hdls[1] is defined. Other handles (except
 207  * standard handles) are closed. env->subtype must be a SUBENVIR_... constant.
 208  * cmdline is the whole command line.
 209  * Never use TSD after the fork() since this is not only a different thread,
 210  * it's a different process!
 211  */
 212 int Unx_fork_exec(tsd_t *TSD, environment *env, const char *cmdline, int *rcode)
 213 {
 214    static const char *interpreter[] = { "regina", /* preferable even if not */
 215                                                   /* dynamic                */
 216                                         "rexx" };
 217    char **args ;
 218    int i, rc, max_hdls = MaxFiles() ;
 219    int broken_address_command = get_options_flag( TSD->currlevel, EXT_BROKEN_ADDRESS_COMMAND );
 220    int subtype;
 221
 222    if ( ( rc = fork() ) != 0 )
 223       return( rc );
 224
 225    /* Now we are the child */
 226
 227 #define STD_REDIR(hdl,dest) if ((hdl != -1) && (hdl != dest)) dup2(hdl, dest)
 228 #define SET_MAXHDL(hdl) if (hdl > max_hdls) max_hdls = hdl
 229 #define SET_MAXHDLS(ep) SET_MAXHDL(ep.hdls[0]); SET_MAXHDL(ep.hdls[1])
 230
 231                                         /* Force the standard redirections:  */
 232    STD_REDIR(env->input.hdls[0],    0);
 233    STD_REDIR(env->output.hdls[1],   1);
 234    if (env->error.SameAsOutput)
 235    {
 236       STD_REDIR(1,                  2);
 237    }
 238    else
 239    {
 240       STD_REDIR(env->error.hdls[1], 2);
 241    }
 242
 243                                     /* any handle greater than the default ? */
 244    SET_MAXHDLS(env->input);
 245    SET_MAXHDLS(env->output);
 246    if (!env->error.SameAsOutput)
 247       SET_MAXHDLS(env->error);
 248
 249    for (i=3; i <= max_hdls; i++)
 250       close( i ) ;
 251
 252    /*
 253     * If the BROKEN_ADDRESS_COMMAND OPTION is in place,
 254     * and our environment is COMMAND, change it to SYSTEM
 255     */
 256    if ( env->subtype == SUBENVIR_PATH /* was SUBENVIR_COMMAND */
 257    &&   broken_address_command )
 258       subtype = SUBENVIR_SYSTEM;
 259    else
 260       subtype = env->subtype;
 261
 262    switch ( subtype )
 263    {
 264       case SUBENVIR_PATH:
 265          args = makeargs(cmdline, '\\');
 266          execvp(*args, args);
 267          break;
 268
 269       case SUBENVIR_COMMAND:
 270          args = makeargs(cmdline, '\\');
 271          execv(*args, args);
 272          break;
 273
 274       case SUBENVIR_SYSTEM:
 275 #if defined(HAVE_WIN32GUI)
 276          rc = mysystem( cmdline ) ;
 277 #else
 278          rc = system( cmdline ) ;
 279 #endif
 280 #ifdef VMS
 281          exit (rc); /* This is a separate process, exit() is allowed */
 282 #else
 283          if ( WIFEXITED( rc ) )
 284          {
 285             fflush( stdout );
 286             _exit( (int) WEXITSTATUS(rc) ); /* This is a separate process, exit() is allowed */
 287          }
 288          else if ( WIFSIGNALED( rc ) )
 289             raise( WTERMSIG( rc ) ); /* This is a separate process, raise() is allowed */
 290          else
 291             raise( WSTOPSIG( rc ) ); /* This is a separate process, raise() is allowed */
 292 #endif
 293          break;
 294       case SUBENVIR_REXX:
 295          {
 296             char *new_cmdline;
 297             char **run;
 298             int i;
 299             unsigned len;
 300
 301             if (argv0 == NULL)
 302                len = 7; /* max("rexx", "regina") */
 303             else
 304                {
 305                   len = strlen(argv0);
 306                   if (len < 7)
 307                      len = 7; /* max("rexx", "regina") */
 308                }
 309             len += strlen(cmdline) + 2; /* Blank + term ASCII0 */
 310
 311             if ((new_cmdline = (char *)malloc(len)) == NULL)
 312                raise( SIGKILL ); /* This is a separate process, raise() is allowed */
 313
 314             if (argv0 != NULL) /* always the best choice */
 315             {
 316                strcpy(new_cmdline, argv0);
 317                strcat(new_cmdline, " ");
 318                strcat(new_cmdline, cmdline);
 319                args = makeargs(new_cmdline, '\\');
 320                execv(*args, args);
 321                destroyargs(args);
 322             }
 323
 324             /* load an interpreter by name from the path */
 325             for (i = 0; i < (int) (sizeof(interpreter) / sizeof(interpreter[0]));i++)
 326             {
 327                strcpy(new_cmdline, interpreter[i]);
 328                strcat(new_cmdline, " ");
 329                strcat(new_cmdline, cmdline);
 330                args = makeargs(new_cmdline, '\\');
 331                execvp(*args, args);
 332                destroyargs(args);
 333             }
 334
 335             /* last chance, worst choice, use the re-entering code: */
 336             strcpy(new_cmdline, "\"\" ");
 337             strcat(new_cmdline, cmdline);
 338             args = makeargs(new_cmdline, '\\');
 339
 340             for (i = 0, run = args; *run; run++)
 341                i++;
 342             fflush( stdout );
 343             _exit(__regina_reexecute_main(i, args));
 344    }
 345
 346       default: /* illegal subtype */
 347          raise( SIGKILL ) ; /* This is a separate process, raise() is allowed */
 348    }
 349
 350    /* exec() failed */
 351    raise( SIGKILL ); /* This is a separate process, raise() is allowed */
 352 #undef SET_MAXHDLS
 353 #undef SET_MAXHDL
 354 #undef STD_REDIR
 355    return -1; /* keep the compiler happy */
 356 }
 357
 358 /* wait waits for a process started by fork_exec.
 359  * In general, this is called after the complete IO to the called process but
 360  * it isn't guaranteed. Never call if you don't expect a sudden death of the
 361  * subprocess.
 362  * Returns the exit status of the subprocess under normal circumstances. If
 363  * the subprocess has died by a signal, the return value is -(100+signalnumber)
 364  */
 365 static int Unx_wait(int process)
 366 {
 367    int rc, retval, status;
 368 #ifdef VMS
 369    for ( ; ; )
 370    {
 371       rc = wait( &status ) ;
 372       if (rc != -1)
 373          break;
 374       rc = errno;
 375       if (rc == EINTR)
 376          continue;
 377       break;
 378    }
 379    retval = status & 0xff ;
 380 #else
 381    for ( ; ; )
 382    {
 383 # ifdef NEXT
 384       /*
 385        * According to Paul F. Kunz, NeXTSTEP 3.1 Prerelease doesn't have
 386        * the waitpid() function, so wait() must be used instead. The
 387        * following klugde will remain until NeXTSTEP gets waitpid().
 388        */
 389       wait( &status ) ;
 390 # else /* ndef NEXT */
 391 #  ifdef DOS
 392       rc = wait( &status ) ;
 393 #  else /* ndef DOS */
 394       rc = waitpid( process, &status, 0 ) ;
 395 #  endif /* def DOS */
 396 # endif /* def NEXT */
 397       if (rc != -1)
 398          break;
 399       rc = errno;
 400       if (rc == EINTR)
 401          continue;
 402       break;
 403    }
 404    /* still ndef VMS */
 405    if (WIFEXITED(status))
 406    {
 407       retval = (int) WEXITSTATUS(status);
 408       if ( retval < 0 )
 409          retval = -retval;
 410    }
 411    else if (WIFSIGNALED(status))
 412    {
 413       retval = -WTERMSIG(status);
 414       if ( retval > 0 )
 415          retval = -retval;
 416       else if ( retval == 0 )
 417          retval = -1;
 418    }
 419    else
 420    {
 421       retval = -WSTOPSIG(status);
 422       if ( retval > 0 )
 423          retval = -retval;
 424       else if ( retval == 0 )
 425          retval = -1;
 426    }
 427 #endif /* def VMS */
 428    return(retval);
 429 }
 430
 431 /* open_subprocess_connection acts like the unix-known function pipe and sets
 432  * ep->RedirectedFile if necessary. Just in the latter case ep->data
 433  * is set to the filename.
 434  */
 435 static int Unx_open_subprocess_connection(const tsd_t *TSD, environpart *ep)
 436 {
 437    return(pipe(ep->hdls));
 438 }
 439
 440 /* sets the given handle to the non-blocking mode. The value may change.
 441  * async_info CAN be used to add the handle to the internal list of watched
 442  * handles.
 443  */
 444 static void Unx_unblock_handle( int *handle, void *async_info )
 445 {
 446    int fl ;
 447
 448    if (*handle == -1)
 449       return ;
 450
 451    fl = fcntl( *handle, F_GETFL ) ;
 452
 453    if ( fl == -1 ) /* We can either abort or try to continue, try to */
 454       return ;     /* continue for now.                              */
 455
 456    fcntl( *handle, F_SETFL, fl | O_NONBLOCK ) ;
 457 }
 458
 459 /* restart_file sets the file pointer of the given handle to the beginning.
 460  */
 461 static void Unx_restart_file(int hdl)
 462 {
 463    lseek(hdl, 0l, SEEK_SET);
 464 }
 465
 466 /* close acts like close() but closes a handle returned by
 467  * open_subprocess_connection.
 468  * async_info MAY be used to delete the handle from the internal list of
 469  * watched handles.
 470  */
 471 static int Unx_close(int handle, void *async_info)
 472 {
 473    return(close(handle));
 474 }
 475
 476 /*
 477  * close_special acts like close() but closes any OS specific handle.
 478  * The close happens if the handle is not -1. A specific operation may be
 479  * associated with this. Have a look for occurances of "hdls[2]".
 480  */
 481 static void Unx_close_special( int handle )
 482 {
 483    assert( handle == -1 );
 484 }
 485
 486 /* read acts like read() but returns either an error (return code
 487  * == -errno) or the number of bytes read. EINTR and friends leads to a
 488  * re-read.
 489  * use_blocked_io is a flag. If set, the handle is set to blocked IO and
 490  * we shall use blocked IO here.
 491  */
 492 static int Unx_read(int hdl, void *buf, unsigned size, void *async_info)
 493 {
 494    int done ;
 495
 496    do {
 497       done = read( hdl, buf, size ) ;
 498    } while ((done == -1) && (errno == EINTR));
 499
 500    if (done < 0)
 501    {
 502       done = errno;
 503       if (done == 0)      /* no error set? */
 504          done = EPIPE ;   /* good assumption */
 505 #if defined(EWOULDBLOCK) && defined(EAGAIN) && (EAGAIN != EWOULDBLOCK)
 506       /* BSD knows this value with the same meaning as EAGAIN */
 507       if (done == EWOULDBLOCK)
 508          done = EAGAIN ;
 509 #endif
 510       return( -done ) ; /* error */
 511    }
 512
 513    return(done);
 514 }
 515
 516 /* write acts like write() but returns either an error (return code
 517  * == -errno) or the number of bytes written. EINTR and friends leads to a
 518  * re-write.
 519  * use_blocked_io is a flag. If set, the handle is set to blocked IO and
 520  * we shall use blocked IO here.
 521  * The file must be flushed if buf or size are 0.
 522  */
 523 static int Unx_write(int hdl, const void *buf, unsigned size, void *async_info)
 524 {
 525    int done ;
 526
 527    if ((buf == NULL) || (size == 0)) /* nothing to to for flushing buffers */
 528       return(0);
 529
 530    do {
 531       done = write( hdl, buf, size ) ;
 532    } while ((done == -1) && (errno == EINTR));
 533
 534    if (done < 0)
 535    {
 536       done = errno;
 537       if (done == 0)       /* no error set? */
 538          done = ENOSPC ;   /* good assumption */
 539 #if defined(EWOULDBLOCK) && defined(EAGAIN) && (EAGAIN != EWOULDBLOCK)
 540       /* BSD knows this value with the same meaning as EAGAIN */
 541       if (done == EWOULDBLOCK)
 542          done = EAGAIN ;
 543 #endif
 544       return( -done ) ; /* error */
 545    }
 546
 547    return(done);
 548 }
 549
 550 /* create_async_info return an opaque structure to allow the process wait for
 551  * asyncronous IO. There are three IO slots (in, out, error) which can be
 552  * filled by add_waiter. The structure can be cleaned by reset_async_info.
 553  * The structure must be destroyed by delete_async_info.
 554  */
 555 static void *Unx_create_async_info(const tsd_t *TSD)
 556 {
 557    AsyncInfo *ai = (AsyncInfo *)MallocTSD(sizeof(AsyncInfo));
 558
 559    ai->TSD = TSD;
 560    return(ai);
 561 }
 562 /* delete_async_info deletes the structure created by create_async_info and
 563  * all of its components.
 564  */
 565 static void Unx_delete_async_info(void *async_info)
 566 {
 567    AsyncInfo *ai = (AsyncInfo *)async_info;
 568
 569    if (ai == NULL)
 570       return;
 571    Free_TSD(ai->TSD, ai);
 572 }
 573
 574 #if defined(POLLIN) && defined(HAVE_POLL) /* we have poll() */
 575
 576 /* reset_async_info clear async_info in such a way that fresh add_waiter()
 577  * calls can be performed.
 578  */
 579 static void Unx_reset_async_info(void *async_info)
 580 {
 581    AsyncInfo *ai = (AsyncInfo *)async_info;
 582
 583    ai->_p_cnt = 0;
 584 }
 585
 586 /* add_async_waiter adds a further handle to the asyncronous IO structure.
 587  * add_as_read_handle must be != 0 if the next operation shall be a
 588  * read, else it must be 0 for write.
 589  * Call reset_async_info before a wait-cycle to different handles and use
 590  * wait_async_info to wait for at least one IO-able handle.
 591  */
 592 static void Unx_add_async_waiter(void *async_info, int handle, int add_as_read_handle)
 593 {
 594    AsyncInfo *ai = (AsyncInfo *)async_info;
 595
 596    assert(ai->_p_cnt < 3);
 597    ai->_p[ai->_p_cnt].fd = handle;
 598    ai->_p[ai->_p_cnt++].events = (add_as_read_handle) ? POLLIN : POLLOUT;
 599 }
 600
 601 /* wait_async_info waits for some handles to become ready. This function
 602  * returns if at least one handle becomes ready.
 603  * A handle can be added with add_async_waiter to the bundle of handles to
 604  * wait for.
 605  * No special handling is implemented if an asyncronous interrupt occurs.
 606  * Thus, there is no guarantee to have handle which works.
 607  */
 608 static void Unx_wait_async_info(void *async_info)
 609 {
 610    AsyncInfo *ai = (AsyncInfo *)async_info;
 611
 612    if (ai->_p_cnt)
 613       poll(ai->_p, ai->_p_cnt, -1);
 614 }
 615
 616 #else /* end of POLLIN, must be select */
 617
 618 /* reset_async_info clear async_info in such a way that fresh add_waiter()
 619  * calls can be performed.
 620  */
 621 static void Unx_reset_async_info(void *async_info)
 622 {
 623    AsyncInfo *ai = async_info;
 624
 625    FD_ZERO( &ai->_p_in );
 626    FD_ZERO( &ai->_p_out );
 627    ai->_p_max = -1 ;
 628 }
 629
 630 /* add_async_waiter adds a further handle to the asyncronous IO structure.
 631  * add_as_read_handle must be != 0 if the next operation shall be a
 632  * read, else it must be 0 for write.
 633  * Call reset_async_info before a wait-cycle to different handles and use
 634  * wait_async_info to wait for at least one IO-able handle.
 635  */
 636 static void Unx_add_async_waiter(void *async_info, int handle, int add_as_read_handle)
 637 {
 638    AsyncInfo *ai = async_info;
 639
 640    FD_SET(handle,(add_as_read_handle) ? &ai->_p_in : &ai->_p_out ) ;
 641    if (handle > ai->_p_max)
 642       ai->_p_max = handle ;
 643 }
 644
 645 /* wait_async_info waits for some handles to become ready. This function
 646  * returns if at least one handle becomes ready.
 647  * A handle can be added with add_async_waiter to the bundle of handles to
 648  * wait for.
 649  * No special handling is implemented if an asyncronous interrupt occurs.
 650  * Thus, there is no guarantee to have handle which works.
 651  */
 652 static void Unx_wait_async_info(void *async_info)
 653 {
 654    AsyncInfo *ai = async_info;
 655
 656    if (ai->_p_max >= 0)
 657       select( ai->_p_max+1, &ai->_p_in, &ai->_p_out, NULL, NULL);
 658 }
 659
 660 #endif /* POLLIN or select */
 661
 662
 663 static int Unx_uname(struct regina_utsname *name)
 664 {
 665    struct utsname osdata;
 666
 667    /*
 668     * Don't know whether utsname uses pointer or char[].
 669     * So just copy data.
 670     */
 671    if ( uname( &osdata ) < 0 )
 672    {
 673       memset( name, 0, sizeof(struct regina_utsname) );
 674       return -1;
 675    }
 676
 677    strcpy( name->sysname,  osdata.sysname  );
 678    strcpy( name->nodename, osdata.nodename );
 679    strcpy( name->release,  osdata.release  );
 680    strcpy( name->version,  osdata.version  );
 681    strcpy( name->machine,  osdata.machine  );
 682
 683    return 0;
 684 }
 685
 686 static void Unx_init(void)
 687 {
 688 }
 689
 690 OS_Dep_funcs __regina_OS_Unx =
 691 {
 692    Unx_init,                           /* init                       */
 693    Unx_setenv,                         /* setenv                     */
 694    Unx_fork_exec,                      /* fork_exec                  */
 695    Unx_wait,                           /* wait                       */
 696    Unx_open_subprocess_connection,     /* open_subprocess_connection */
 697    Unx_unblock_handle,                 /* unblock_handle             */
 698    Unx_restart_file,                   /* restart_file               */
 699    Unx_close,                          /* close                      */
 700    Unx_close_special,                  /* close_special              */
 701    Unx_read,                           /* read                       */
 702    Unx_write,                          /* write                      */
 703    Unx_create_async_info,              /* create_async_info          */
 704    Unx_delete_async_info,              /* delete_async_info          */
 705    Unx_reset_async_info,               /* reset_async_info           */
 706    Unx_add_async_waiter,               /* add_async_waiter           */
 707    Unx_wait_async_info,                /* wait_async_info            */
 708    Unx_uname                           /* uname                      */
 709 };