jim-aio.c

   1 /* Jim - A small embeddable Tcl interpreter
   2  *
   3  * Copyright 2005 Salvatore Sanfilippo <antirez@invece.org>
   4  * Copyright 2005 Clemens Hintze <c.hintze@gmx.net>
   5  * Copyright 2005 patthoyts - Pat Thoyts <patthoyts@users.sf.net>
   6  * Copyright 2008 oharboe - Øyvind Harboe - oyvind.harboe@zylin.com
   7  * Copyright 2008 Andrew Lunn <andrew@lunn.ch>
   8  * Copyright 2008 Duane Ellis <openocd@duaneellis.com>
   9  * Copyright 2008 Uwe Klein <uklein@klein-messgeraete.de>
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  *
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above
  18  *    copyright notice, this list of conditions and the following
  19  *    disclaimer in the documentation and/or other materials
  20  *    provided with the distribution.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
  23  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  24  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  25  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  26  * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  27  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  28  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  31  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  33  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  *
  35  * The views and conclusions contained in the software and documentation
  36  * are those of the authors and should not be interpreted as representing
  37  * official policies, either expressed or implied, of the Jim Tcl Project.
  38  **/
  39
  40 #include "jimautoconf.h"
  41
  42 #ifndef _GNU_SOURCE
  43 #define _GNU_SOURCE
  44 #endif
  45 #include <stdio.h>
  46 #include <string.h>
  47 #include <errno.h>
  48 #include <fcntl.h>
  49 #ifdef HAVE_UNISTD_H
  50 #include <unistd.h>
  51 #include <sys/stat.h>
  52 #endif
  53
  54 #include "jim.h"
  55 #include "jimiocompat.h"
  56
  57 #if defined(HAVE_SYS_SOCKET_H) && defined(HAVE_SELECT) && defined(HAVE_NETINET_IN_H) && defined(HAVE_NETDB_H) && defined(HAVE_ARPA_INET_H)
  58 #include <sys/socket.h>
  59 #include <netinet/in.h>
  60 #include <netinet/tcp.h>
  61 #include <arpa/inet.h>
  62 #include <netdb.h>
  63 #ifdef HAVE_SYS_UN_H
  64 #include <sys/un.h>
  65 #endif
  66 #define HAVE_SOCKETS
  67 #elif defined (__MINGW32__)
  68 /* currently mingw32 doesn't support sockets, but has pipe, fdopen */
  69 #else
  70 #define JIM_ANSIC
  71 #endif
  72
  73 #if defined(JIM_SSL)
  74 #include <openssl/ssl.h>
  75 #include <openssl/err.h>
  76 #endif
  77
  78 #ifdef HAVE_TERMIOS_H
  79 #include <jim-tty.h>
  80 #endif
  81
  82 #include "jim-eventloop.h"
  83 #include "jim-subcmd.h"
  84
  85 #define AIO_CMD_LEN 32      /* e.g. aio.handleXXXXXX */
  86 #define AIO_BUF_LEN 256     /* Can keep this small and rely on stdio buffering */
  87
  88 #ifndef HAVE_FTELLO
  89     #define ftello ftell
  90 #endif
  91 #ifndef HAVE_FSEEKO
  92     #define fseeko fseek
  93 #endif
  94
  95 #define AIO_KEEPOPEN 1
  96
  97 #if defined(JIM_IPV6)
  98 #define IPV6 1
  99 #else
 100 #define IPV6 0
 101 #ifndef PF_INET6
 102 #define PF_INET6 0
 103 #endif
 104 #endif
 105
 106 #ifdef JIM_ANSIC
 107 /* no fdopen() with ANSIC, so can't support these */
 108 #undef HAVE_PIPE
 109 #undef HAVE_SOCKETPAIR
 110 #endif
 111
 112 #define JimCheckStreamError(interp, af) af->fops->error(af)
 113
 114 #if defined(HAVE_SOCKETS) && !defined(JIM_BOOTSTRAP)
 115 union sockaddr_any {
 116     struct sockaddr sa;
 117     struct sockaddr_in sin;
 118 #if IPV6
 119     struct sockaddr_in6 sin6;
 120 #endif
 121 };
 122
 123 #ifndef HAVE_INET_NTOP
 124 const char *inet_ntop(int af, const void *src, char *dst, int size)
 125 {
 126     if (af != PF_INET) {
 127         return NULL;
 128     }
 129     snprintf(dst, size, "%s", inet_ntoa(((struct sockaddr_in *)src)->sin_addr));
 130     return dst;
 131 }
 132 #endif
 133 #endif /* JIM_BOOTSTRAP */
 134
 135 struct AioFile;
 136
 137 typedef struct {
 138     int (*writer)(struct AioFile *af, const char *buf, int len);
 139     int (*reader)(struct AioFile *af, char *buf, int len);
 140     const char *(*getline)(struct AioFile *af, char *buf, int len);
 141     int (*error)(const struct AioFile *af);
 142     const char *(*strerror)(struct AioFile *af);
 143     int (*verify)(struct AioFile *af);
 144 } JimAioFopsType;
 145
 146 typedef struct AioFile
 147 {
 148     FILE *fp;
 149     Jim_Obj *filename;
 150     int type;
 151     int openFlags;              /* AIO_KEEPOPEN? keep FILE* */
 152     int fd;
 153     Jim_Obj *rEvent;
 154     Jim_Obj *wEvent;
 155     Jim_Obj *eEvent;
 156     int addr_family;
 157     void *ssl;
 158     const JimAioFopsType *fops;
 159 } AioFile;
 160
 161 static int stdio_writer(struct AioFile *af, const char *buf, int len)
 162 {
 163     return fwrite(buf, 1, len, af->fp);
 164 }
 165
 166 static int stdio_reader(struct AioFile *af, char *buf, int len)
 167 {
 168     return fread(buf, 1, len, af->fp);
 169 }
 170
 171 static const char *stdio_getline(struct AioFile *af, char *buf, int len)
 172 {
 173     return fgets(buf, len, af->fp);
 174 }
 175
 176 static int stdio_error(const AioFile *af)
 177 {
 178     if (!ferror(af->fp)) {
 179         return JIM_OK;
 180     }
 181     clearerr(af->fp);
 182     /* EAGAIN and similar are not error conditions. Just treat them like eof */
 183     if (feof(af->fp) || errno == EAGAIN || errno == EINTR) {
 184         return JIM_OK;
 185     }
 186 #ifdef ECONNRESET
 187     if (errno == ECONNRESET) {
 188         return JIM_OK;
 189     }
 190 #endif
 191 #ifdef ECONNABORTED
 192     if (errno == ECONNABORTED) {
 193         return JIM_OK;
 194     }
 195 #endif
 196     return JIM_ERR;
 197 }
 198
 199 static const char *stdio_strerror(struct AioFile *af)
 200 {
 201     return strerror(errno);
 202 }
 203
 204 static const JimAioFopsType stdio_fops = {
 205     stdio_writer,
 206     stdio_reader,
 207     stdio_getline,
 208     stdio_error,
 209     stdio_strerror,
 210     NULL
 211 };
 212
 213 #if defined(JIM_SSL) && !defined(JIM_BOOTSTRAP)
 214
 215 static SSL_CTX *JimAioSslCtx(Jim_Interp *interp);
 216
 217 static int ssl_writer(struct AioFile *af, const char *buf, int len)
 218 {
 219     return SSL_write(af->ssl, buf, len);
 220 }
 221
 222 static int ssl_reader(struct AioFile *af, char *buf, int len)
 223 {
 224     return SSL_read(af->ssl, buf, len);
 225 }
 226
 227 static const char *ssl_getline(struct AioFile *af, char *buf, int len)
 228 {
 229     int i;
 230     for (i = 0; i < len + 1; i++) {
 231         if (SSL_read(af->ssl, &buf[i], 1) != 1) {
 232             if (i == 0) {
 233                 return NULL;
 234             }
 235             break;
 236         }
 237         if (buf[i] == '\n') {
 238             break;
 239         }
 240     }
 241     buf[i] = '\0';
 242     return buf;
 243 }
 244
 245 static int ssl_error(const struct AioFile *af)
 246 {
 247     if (ERR_peek_error() == 0) {
 248         return JIM_OK;
 249     }
 250
 251     return JIM_ERR;
 252 }
 253
 254 static const char *ssl_strerror(struct AioFile *af)
 255 {
 256     int err = ERR_get_error();
 257
 258     if (err) {
 259         return ERR_error_string(err, NULL);
 260     }
 261
 262     /* should not happen */
 263     return "unknown SSL error";
 264 }
 265
 266 static int ssl_verify(struct AioFile *af)
 267 {
 268     X509 *cert;
 269
 270     cert = SSL_get_peer_certificate(af->ssl);
 271     if (!cert) {
 272         return JIM_ERR;
 273     }
 274     X509_free(cert);
 275
 276     if (SSL_get_verify_result(af->ssl) == X509_V_OK) {
 277         return JIM_OK;
 278     }
 279
 280     return JIM_ERR;
 281 }
 282
 283 static const JimAioFopsType ssl_fops = {
 284     ssl_writer,
 285     ssl_reader,
 286     ssl_getline,
 287     ssl_error,
 288     ssl_strerror,
 289     ssl_verify
 290 };
 291 #endif /* JIM_BOOTSTRAP */
 292
 293 static int JimAioSubCmdProc(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
 294 static AioFile *JimMakeChannel(Jim_Interp *interp, FILE *fh, int fd, Jim_Obj *filename,
 295     const char *hdlfmt, int family, const char *mode);
 296
 297 #if defined(HAVE_SOCKETS) && !defined(JIM_BOOTSTRAP)
 298 static int JimParseIPv6Address(Jim_Interp *interp, const char *hostport, union sockaddr_any *sa, int *salen)
 299 {
 300 #if IPV6
 301     /*
 302      * An IPv6 addr/port looks like:
 303      *   [::1]
 304      *   [::1]:2000
 305      *   [fe80::223:6cff:fe95:bdc0%en1]:2000
 306      *   [::]:2000
 307      *   2000
 308      *
 309      *   Note that the "any" address is ::, which is the same as when no address is specified.
 310      */
 311      char *sthost = NULL;
 312      const char *stport;
 313      int ret = JIM_OK;
 314      struct addrinfo req;
 315      struct addrinfo *ai;
 316
 317     stport = strrchr(hostport, ':');
 318     if (!stport) {
 319         /* No : so, the whole thing is the port */
 320         stport = hostport;
 321         hostport = "::";
 322         sthost = Jim_StrDup(hostport);
 323     }
 324     else {
 325         stport++;
 326     }
 327
 328     if (*hostport == '[') {
 329         /* This is a numeric ipv6 address */
 330         char *pt = strchr(++hostport, ']');
 331         if (pt) {
 332             sthost = Jim_StrDupLen(hostport, pt - hostport);
 333         }
 334     }
 335
 336     if (!sthost) {
 337         sthost = Jim_StrDupLen(hostport, stport - hostport - 1);
 338     }
 339
 340     memset(&req, '\0', sizeof(req));
 341     req.ai_family = PF_INET6;
 342
 343     if (getaddrinfo(sthost, NULL, &req, &ai)) {
 344         Jim_SetResultFormatted(interp, "Not a valid address: %s", hostport);
 345         ret = JIM_ERR;
 346     }
 347     else {
 348         memcpy(&sa->sin, ai->ai_addr, ai->ai_addrlen);
 349         *salen = ai->ai_addrlen;
 350
 351         sa->sin.sin_port = htons(atoi(stport));
 352
 353         freeaddrinfo(ai);
 354     }
 355     Jim_Free(sthost);
 356
 357     return ret;
 358 #else
 359     Jim_SetResultString(interp, "ipv6 not supported", -1);
 360     return JIM_ERR;
 361 #endif
 362 }
 363
 364 static int JimParseIpAddress(Jim_Interp *interp, const char *hostport, union sockaddr_any *sa, int *salen)
 365 {
 366     /* An IPv4 addr/port looks like:
 367      *   192.168.1.5
 368      *   192.168.1.5:2000
 369      *   2000
 370      *
 371      * If the address is missing, INADDR_ANY is used.
 372      * If the port is missing, 0 is used (only useful for server sockets).
 373      */
 374     char *sthost = NULL;
 375     const char *stport;
 376     int ret = JIM_OK;
 377
 378     stport = strrchr(hostport, ':');
 379     if (!stport) {
 380         /* No : so, the whole thing is the port */
 381         stport = hostport;
 382         sthost = Jim_StrDup("0.0.0.0");
 383     }
 384     else {
 385         sthost = Jim_StrDupLen(hostport, stport - hostport);
 386         stport++;
 387     }
 388
 389     {
 390 #ifdef HAVE_GETADDRINFO
 391         struct addrinfo req;
 392         struct addrinfo *ai;
 393         memset(&req, '\0', sizeof(req));
 394         req.ai_family = PF_INET;
 395
 396         if (getaddrinfo(sthost, NULL, &req, &ai)) {
 397             ret = JIM_ERR;
 398         }
 399         else {
 400             memcpy(&sa->sin, ai->ai_addr, ai->ai_addrlen);
 401             *salen = ai->ai_addrlen;
 402             freeaddrinfo(ai);
 403         }
 404 #else
 405         struct hostent *he;
 406
 407         ret = JIM_ERR;
 408
 409         if ((he = gethostbyname(sthost)) != NULL) {
 410             if (he->h_length == sizeof(sa->sin.sin_addr)) {
 411                 *salen = sizeof(sa->sin);
 412                 sa->sin.sin_family= he->h_addrtype;
 413                 memcpy(&sa->sin.sin_addr, he->h_addr, he->h_length); /* set address */
 414                 ret = JIM_OK;
 415             }
 416         }
 417 #endif
 418
 419         sa->sin.sin_port = htons(atoi(stport));
 420     }
 421     Jim_Free(sthost);
 422
 423     if (ret != JIM_OK) {
 424         Jim_SetResultFormatted(interp, "Not a valid address: %s", hostport);
 425     }
 426
 427     return ret;
 428 }
 429
 430 #ifdef HAVE_SYS_UN_H
 431 static int JimParseDomainAddress(Jim_Interp *interp, const char *path, struct sockaddr_un *sa)
 432 {
 433     sa->sun_family = PF_UNIX;
 434     snprintf(sa->sun_path, sizeof(sa->sun_path), "%s", path);
 435
 436     return JIM_OK;
 437 }
 438 #endif
 439
 440 /**
 441  * Format that address in 'sa' as a string and store in variable 'varObjPtr'
 442  */
 443 static int JimFormatIpAddress(Jim_Interp *interp, Jim_Obj *varObjPtr, const union sockaddr_any *sa)
 444 {
 445     /* INET6_ADDRSTRLEN is 46. Add some for [] and port */
 446     char addrbuf[60];
 447
 448 #if IPV6
 449     if (sa->sa.sa_family == PF_INET6) {
 450         addrbuf[0] = '[';
 451         /* Allow 9 for []:65535\0 */
 452         inet_ntop(sa->sa.sa_family, &sa->sin6.sin6_addr, addrbuf + 1, sizeof(addrbuf) - 9);
 453         snprintf(addrbuf + strlen(addrbuf), 8, "]:%d", ntohs(sa->sin.sin_port));
 454     }
 455     else
 456 #endif
 457     if (sa->sa.sa_family == PF_INET) {
 458         /* Allow 7 for :65535\0 */
 459         inet_ntop(sa->sa.sa_family, &sa->sin.sin_addr, addrbuf, sizeof(addrbuf) - 7);
 460         snprintf(addrbuf + strlen(addrbuf), 7, ":%d", ntohs(sa->sin.sin_port));
 461     }
 462     else {
 463         /* recvfrom still works on unix domain sockets, etc */
 464         addrbuf[0] = 0;
 465     }
 466
 467     return Jim_SetVariable(interp, varObjPtr, Jim_NewStringObj(interp, addrbuf, -1));
 468 }
 469
 470 #endif /* JIM_BOOTSTRAP */
 471
 472 static const char *JimAioErrorString(AioFile *af)
 473 {
 474     if (af && af->fops)
 475         return af->fops->strerror(af);
 476
 477     return strerror(errno);
 478 }
 479
 480 static void JimAioSetError(Jim_Interp *interp, Jim_Obj *name)
 481 {
 482     AioFile *af = Jim_CmdPrivData(interp);
 483
 484     if (name) {
 485         Jim_SetResultFormatted(interp, "%#s: %s", name, JimAioErrorString(af));
 486     }
 487     else {
 488         Jim_SetResultString(interp, JimAioErrorString(af), -1);
 489     }
 490 }
 491
 492 static void JimAioDelProc(Jim_Interp *interp, void *privData)
 493 {
 494     AioFile *af = privData;
 495
 496     JIM_NOTUSED(interp);
 497
 498     Jim_DecrRefCount(interp, af->filename);
 499
 500 #ifdef jim_ext_eventloop
 501     /* remove all existing EventHandlers */
 502     Jim_DeleteFileHandler(interp, af->fd, JIM_EVENT_READABLE | JIM_EVENT_WRITABLE | JIM_EVENT_EXCEPTION);
 503 #endif
 504
 505 #if defined(JIM_SSL)
 506     if (af->ssl != NULL) {
 507         SSL_free(af->ssl);
 508     }
 509 #endif
 510     if (!(af->openFlags & AIO_KEEPOPEN)) {
 511         fclose(af->fp);
 512     }
 513
 514     Jim_Free(af);
 515 }
 516
 517 static int aio_cmd_read(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 518 {
 519     AioFile *af = Jim_CmdPrivData(interp);
 520     char buf[AIO_BUF_LEN];
 521     Jim_Obj *objPtr;
 522     int nonewline = 0;
 523     jim_wide neededLen = -1;         /* -1 is "read as much as possible" */
 524
 525     if (argc && Jim_CompareStringImmediate(interp, argv[0], "-nonewline")) {
 526         nonewline = 1;
 527         argv++;
 528         argc--;
 529     }
 530     if (argc == 1) {
 531         if (Jim_GetWide(interp, argv[0], &neededLen) != JIM_OK)
 532             return JIM_ERR;
 533         if (neededLen < 0) {
 534             Jim_SetResultString(interp, "invalid parameter: negative len", -1);
 535             return JIM_ERR;
 536         }
 537     }
 538     else if (argc) {
 539         return -1;
 540     }
 541     objPtr = Jim_NewStringObj(interp, NULL, 0);
 542     while (neededLen != 0) {
 543         int retval;
 544         int readlen;
 545
 546         if (neededLen == -1) {
 547             readlen = AIO_BUF_LEN;
 548         }
 549         else {
 550             readlen = (neededLen > AIO_BUF_LEN ? AIO_BUF_LEN : neededLen);
 551         }
 552         retval = af->fops->reader(af, buf, readlen);
 553         if (retval > 0) {
 554             Jim_AppendString(interp, objPtr, buf, retval);
 555             if (neededLen != -1) {
 556                 neededLen -= retval;
 557             }
 558         }
 559         if (retval != readlen)
 560             break;
 561     }
 562     /* Check for error conditions */
 563     if (JimCheckStreamError(interp, af)) {
 564         Jim_FreeNewObj(interp, objPtr);
 565         return JIM_ERR;
 566     }
 567     if (nonewline) {
 568         int len;
 569         const char *s = Jim_GetString(objPtr, &len);
 570
 571         if (len > 0 && s[len - 1] == '\n') {
 572             objPtr->length--;
 573             objPtr->bytes[objPtr->length] = '\0';
 574         }
 575     }
 576     Jim_SetResult(interp, objPtr);
 577     return JIM_OK;
 578 }
 579
 580 AioFile *Jim_AioFile(Jim_Interp *interp, Jim_Obj *command)
 581 {
 582     Jim_Cmd *cmdPtr = Jim_GetCommand(interp, command, JIM_ERRMSG);
 583
 584     /* XXX: There ought to be a supported API for this */
 585     if (cmdPtr && !cmdPtr->isproc && cmdPtr->u.native.cmdProc == JimAioSubCmdProc) {
 586         return (AioFile *) cmdPtr->u.native.privData;
 587     }
 588     Jim_SetResultFormatted(interp, "Not a filehandle: \"%#s\"", command);
 589     return NULL;
 590 }
 591
 592 FILE *Jim_AioFilehandle(Jim_Interp *interp, Jim_Obj *command)
 593 {
 594     AioFile *af;
 595
 596     af = Jim_AioFile(interp, command);
 597     if (af == NULL) {
 598         return NULL;
 599     }
 600
 601     return af->fp;
 602 }
 603
 604 static int aio_cmd_getfd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 605 {
 606     AioFile *af = Jim_CmdPrivData(interp);
 607
 608     fflush(af->fp);
 609     Jim_SetResultInt(interp, fileno(af->fp));
 610
 611     return JIM_OK;
 612 }
 613
 614 static int aio_cmd_copy(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 615 {
 616     AioFile *af = Jim_CmdPrivData(interp);
 617     jim_wide count = 0;
 618     jim_wide maxlen = JIM_WIDE_MAX;
 619     AioFile *outf = Jim_AioFile(interp, argv[0]);
 620
 621     if (outf == NULL) {
 622         return JIM_ERR;
 623     }
 624
 625     if (argc == 2) {
 626         if (Jim_GetWide(interp, argv[1], &maxlen) != JIM_OK) {
 627             return JIM_ERR;
 628         }
 629     }
 630
 631     while (count < maxlen) {
 632         char ch;
 633
 634         if (af->fops->reader(af, &ch, 1) != 1) {
 635             break;
 636         }
 637         if (outf->fops->writer(outf, &ch, 1) != 1) {
 638             break;
 639         }
 640         count++;
 641     }
 642
 643     if (JimCheckStreamError(interp, af) || JimCheckStreamError(interp, outf)) {
 644         return JIM_ERR;
 645     }
 646
 647     Jim_SetResultInt(interp, count);
 648
 649     return JIM_OK;
 650 }
 651
 652 static int aio_cmd_gets(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 653 {
 654     AioFile *af = Jim_CmdPrivData(interp);
 655     char buf[AIO_BUF_LEN];
 656     Jim_Obj *objPtr;
 657     int len;
 658
 659     errno = 0;
 660
 661     objPtr = Jim_NewStringObj(interp, NULL, 0);
 662     while (1) {
 663         buf[AIO_BUF_LEN - 1] = '_';
 664
 665         if (af->fops->getline(af, buf, AIO_BUF_LEN) == NULL)
 666             break;
 667
 668         if (buf[AIO_BUF_LEN - 1] == '\0' && buf[AIO_BUF_LEN - 2] != '\n') {
 669             Jim_AppendString(interp, objPtr, buf, AIO_BUF_LEN - 1);
 670         }
 671         else {
 672             len = strlen(buf);
 673
 674             if (len && (buf[len - 1] == '\n')) {
 675                 /* strip "\n" */
 676                 len--;
 677             }
 678
 679             Jim_AppendString(interp, objPtr, buf, len);
 680             break;
 681         }
 682     }
 683
 684     if (JimCheckStreamError(interp, af)) {
 685         /* I/O error */
 686         Jim_FreeNewObj(interp, objPtr);
 687         return JIM_ERR;
 688     }
 689
 690     if (argc) {
 691         if (Jim_SetVariable(interp, argv[0], objPtr) != JIM_OK) {
 692             Jim_FreeNewObj(interp, objPtr);
 693             return JIM_ERR;
 694         }
 695
 696         len = Jim_Length(objPtr);
 697
 698         if (len == 0 && feof(af->fp)) {
 699             /* On EOF returns -1 if varName was specified */
 700             len = -1;
 701         }
 702         Jim_SetResultInt(interp, len);
 703     }
 704     else {
 705         Jim_SetResult(interp, objPtr);
 706     }
 707     return JIM_OK;
 708 }
 709
 710 static int aio_cmd_puts(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 711 {
 712     AioFile *af = Jim_CmdPrivData(interp);
 713     int wlen;
 714     const char *wdata;
 715     Jim_Obj *strObj;
 716
 717     if (argc == 2) {
 718         if (!Jim_CompareStringImmediate(interp, argv[0], "-nonewline")) {
 719             return -1;
 720         }
 721         strObj = argv[1];
 722     }
 723     else {
 724         strObj = argv[0];
 725     }
 726
 727     wdata = Jim_GetString(strObj, &wlen);
 728     if (af->fops->writer(af, wdata, wlen) == wlen) {
 729         if (argc == 2 || af->fops->writer(af, "\n", 1) == 1) {
 730             return JIM_OK;
 731         }
 732     }
 733     JimAioSetError(interp, af->filename);
 734     return JIM_ERR;
 735 }
 736
 737 static int aio_cmd_isatty(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 738 {
 739 #ifdef HAVE_ISATTY
 740     AioFile *af = Jim_CmdPrivData(interp);
 741     Jim_SetResultInt(interp, isatty(fileno(af->fp)));
 742 #else
 743     Jim_SetResultInt(interp, 0);
 744 #endif
 745
 746     return JIM_OK;
 747 }
 748
 749 #if defined(HAVE_SOCKETS) && !defined(JIM_BOOTSTRAP)
 750 static int aio_cmd_recvfrom(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 751 {
 752     AioFile *af = Jim_CmdPrivData(interp);
 753     char *buf;
 754     union sockaddr_any sa;
 755     long len;
 756     socklen_t salen = sizeof(sa);
 757     int rlen;
 758
 759     if (Jim_GetLong(interp, argv[0], &len) != JIM_OK) {
 760         return JIM_ERR;
 761     }
 762
 763     buf = Jim_Alloc(len + 1);
 764
 765     rlen = recvfrom(fileno(af->fp), buf, len, 0, &sa.sa, &salen);
 766     if (rlen < 0) {
 767         Jim_Free(buf);
 768         JimAioSetError(interp, NULL);
 769         return JIM_ERR;
 770     }
 771     buf[rlen] = 0;
 772     Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, buf, rlen));
 773
 774     if (argc > 1) {
 775         return JimFormatIpAddress(interp, argv[1], &sa);
 776     }
 777
 778     return JIM_OK;
 779 }
 780
 781
 782 static int aio_cmd_sendto(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 783 {
 784     AioFile *af = Jim_CmdPrivData(interp);
 785     int wlen;
 786     int len;
 787     const char *wdata;
 788     union sockaddr_any sa;
 789     const char *addr = Jim_String(argv[1]);
 790     int salen;
 791
 792     if (IPV6 && af->addr_family == PF_INET6) {
 793         if (JimParseIPv6Address(interp, addr, &sa, &salen) != JIM_OK) {
 794             return JIM_ERR;
 795         }
 796     }
 797     else if (JimParseIpAddress(interp, addr, &sa, &salen) != JIM_OK) {
 798         return JIM_ERR;
 799     }
 800     wdata = Jim_GetString(argv[0], &wlen);
 801
 802     /* Note that we don't validate the socket type. Rely on sendto() failing if appropriate */
 803     len = sendto(fileno(af->fp), wdata, wlen, 0, &sa.sa, salen);
 804     if (len < 0) {
 805         JimAioSetError(interp, NULL);
 806         return JIM_ERR;
 807     }
 808     Jim_SetResultInt(interp, len);
 809     return JIM_OK;
 810 }
 811
 812 static int aio_cmd_accept(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 813 {
 814     AioFile *af = Jim_CmdPrivData(interp);
 815     int sock;
 816     union sockaddr_any sa;
 817     socklen_t addrlen = sizeof(sa);
 818
 819     sock = accept(af->fd, &sa.sa, &addrlen);
 820     if (sock < 0) {
 821         JimAioSetError(interp, NULL);
 822         return JIM_ERR;
 823     }
 824
 825     if (argc > 0) {
 826         if (JimFormatIpAddress(interp, argv[0], &sa) != JIM_OK) {
 827             return JIM_ERR;
 828         }
 829     }
 830
 831     /* Create the file command */
 832     return JimMakeChannel(interp, NULL, sock, Jim_NewStringObj(interp, "accept", -1),
 833         "aio.sockstream%ld", af->addr_family, "r+") ? JIM_OK : JIM_ERR;
 834 }
 835
 836 static int aio_cmd_listen(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 837 {
 838     AioFile *af = Jim_CmdPrivData(interp);
 839     long backlog;
 840
 841     if (Jim_GetLong(interp, argv[0], &backlog) != JIM_OK) {
 842         return JIM_ERR;
 843     }
 844
 845     if (listen(af->fd, backlog)) {
 846         JimAioSetError(interp, NULL);
 847         return JIM_ERR;
 848     }
 849
 850     return JIM_OK;
 851 }
 852 #endif /* JIM_BOOTSTRAP */
 853
 854 static int aio_cmd_flush(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 855 {
 856     AioFile *af = Jim_CmdPrivData(interp);
 857
 858     if (fflush(af->fp) == EOF) {
 859         JimAioSetError(interp, af->filename);
 860         return JIM_ERR;
 861     }
 862     return JIM_OK;
 863 }
 864
 865 static int aio_cmd_eof(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 866 {
 867     AioFile *af = Jim_CmdPrivData(interp);
 868
 869     Jim_SetResultInt(interp, feof(af->fp));
 870     return JIM_OK;
 871 }
 872
 873 static int aio_cmd_close(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 874 {
 875     if (argc == 3) {
 876 #if defined(HAVE_SOCKETS) && defined(HAVE_SHUTDOWN)
 877         static const char * const options[] = { "r", "w", NULL };
 878         enum { OPT_R, OPT_W, };
 879         int option;
 880         AioFile *af = Jim_CmdPrivData(interp);
 881
 882         if (Jim_GetEnum(interp, argv[2], options, &option, NULL, JIM_ERRMSG) != JIM_OK) {
 883             return JIM_ERR;
 884         }
 885         if (shutdown(af->fd, option == OPT_R ? SHUT_RD : SHUT_WR) == 0) {
 886             return JIM_OK;
 887         }
 888         JimAioSetError(interp, NULL);
 889 #else
 890         Jim_SetResultString(interp, "async close not supported", -1);
 891 #endif
 892         return JIM_ERR;
 893     }
 894
 895     return Jim_DeleteCommand(interp, Jim_String(argv[0]));
 896 }
 897
 898 static int aio_cmd_seek(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 899 {
 900     AioFile *af = Jim_CmdPrivData(interp);
 901     int orig = SEEK_SET;
 902     jim_wide offset;
 903
 904     if (argc == 2) {
 905         if (Jim_CompareStringImmediate(interp, argv[1], "start"))
 906             orig = SEEK_SET;
 907         else if (Jim_CompareStringImmediate(interp, argv[1], "current"))
 908             orig = SEEK_CUR;
 909         else if (Jim_CompareStringImmediate(interp, argv[1], "end"))
 910             orig = SEEK_END;
 911         else {
 912             return -1;
 913         }
 914     }
 915     if (Jim_GetWide(interp, argv[0], &offset) != JIM_OK) {
 916         return JIM_ERR;
 917     }
 918     if (fseeko(af->fp, offset, orig) == -1) {
 919         JimAioSetError(interp, af->filename);
 920         return JIM_ERR;
 921     }
 922     return JIM_OK;
 923 }
 924
 925 static int aio_cmd_tell(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 926 {
 927     AioFile *af = Jim_CmdPrivData(interp);
 928
 929     Jim_SetResultInt(interp, ftello(af->fp));
 930     return JIM_OK;
 931 }
 932
 933 static int aio_cmd_filename(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 934 {
 935     AioFile *af = Jim_CmdPrivData(interp);
 936
 937     Jim_SetResult(interp, af->filename);
 938     return JIM_OK;
 939 }
 940
 941 #ifdef O_NDELAY
 942 static int aio_cmd_ndelay(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 943 {
 944     AioFile *af = Jim_CmdPrivData(interp);
 945
 946     int fmode = fcntl(af->fd, F_GETFL);
 947
 948     if (argc) {
 949         long nb;
 950
 951         if (Jim_GetLong(interp, argv[0], &nb) != JIM_OK) {
 952             return JIM_ERR;
 953         }
 954         if (nb) {
 955             fmode |= O_NDELAY;
 956         }
 957         else {
 958             fmode &= ~O_NDELAY;
 959         }
 960         (void)fcntl(af->fd, F_SETFL, fmode);
 961     }
 962     Jim_SetResultInt(interp, (fmode & O_NONBLOCK) ? 1 : 0);
 963     return JIM_OK;
 964 }
 965 #endif
 966
 967 #if defined(HAVE_SOCKETS) && !defined(JIM_BOOTSTRAP)
 968 #define SOCKOPT_BOOL 0
 969 #define SOCKOPT_INT 1
 970 #define SOCKOPT_TIMEVAL 2   /* not currently supported */
 971
 972 static const struct sockopt_def {
 973     const char *name;
 974     int level;
 975     int opt;
 976     int type;   /* SOCKOPT_xxx */
 977 } sockopts[] = {
 978 #ifdef SOL_SOCKET
 979 #ifdef SO_BROADCAST
 980     { "broadcast", SOL_SOCKET, SO_BROADCAST },
 981 #endif
 982 #ifdef SO_DEBUG
 983     { "debug", SOL_SOCKET, SO_DEBUG },
 984 #endif
 985 #ifdef SO_KEEPALIVE
 986     { "keepalive", SOL_SOCKET, SO_KEEPALIVE },
 987 #endif
 988 #ifdef SO_NOSIGPIPE
 989     { "nosigpipe", SOL_SOCKET, SO_NOSIGPIPE },
 990 #endif
 991 #ifdef SO_OOBINLINE
 992     { "oobinline", SOL_SOCKET, SO_OOBINLINE },
 993 #endif
 994 #ifdef SO_SNDBUF
 995     { "sndbuf", SOL_SOCKET, SO_SNDBUF, SOCKOPT_INT },
 996 #endif
 997 #ifdef SO_RCVBUF
 998     { "rcvbuf", SOL_SOCKET, SO_RCVBUF, SOCKOPT_INT },
 999 #endif
1000 #if 0 && defined(SO_SNDTIMEO)
1001     { "sndtimeo", SOL_SOCKET, SO_SNDTIMEO, SOCKOPT_TIMEVAL },
1002 #endif
1003 #if 0 && defined(SO_RCVTIMEO)
1004     { "rcvtimeo", SOL_SOCKET, SO_RCVTIMEO, SOCKOPT_TIMEVAL },
1005 #endif
1006 #endif
1007 #ifdef IPPROTO_TCP
1008 #ifdef TCP_NODELAY
1009     { "tcp_nodelay", IPPROTO_TCP, TCP_NODELAY },
1010 #endif
1011 #endif
1012 };
1013
1014 static int aio_cmd_sockopt(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1015 {
1016     AioFile *af = Jim_CmdPrivData(interp);
1017     int i;
1018
1019     if (argc == 0) {
1020         Jim_Obj *dictObjPtr = Jim_NewListObj(interp, NULL, 0);
1021         for (i = 0; i < sizeof(sockopts) / sizeof(*sockopts); i++) {
1022             int value = 0;
1023             socklen_t len = sizeof(value);
1024             if (getsockopt(af->fd, sockopts[i].level, sockopts[i].opt, (void *)&value, &len) == 0) {
1025                 if (sockopts[i].type == SOCKOPT_BOOL) {
1026                     value = !!value;
1027                 }
1028                 Jim_ListAppendElement(interp, dictObjPtr, Jim_NewStringObj(interp, sockopts[i].name, -1));
1029                 Jim_ListAppendElement(interp, dictObjPtr, Jim_NewIntObj(interp, value));
1030             }
1031         }
1032         Jim_SetResult(interp, dictObjPtr);
1033         return JIM_OK;
1034     }
1035     if (argc == 1) {
1036         return -1;
1037     }
1038
1039     /* Set an option */
1040     for (i = 0; i < sizeof(sockopts) / sizeof(*sockopts); i++) {
1041         if (strcmp(Jim_String(argv[0]), sockopts[i].name) == 0) {
1042             int on;
1043             if (sockopts[i].type == SOCKOPT_BOOL) {
1044                 if (Jim_GetBoolean(interp, argv[1], &on) != JIM_OK) {
1045                     return JIM_ERR;
1046                 }
1047             }
1048             else {
1049                 long longval;
1050                 if (Jim_GetLong(interp, argv[1], &longval) != JIM_OK) {
1051                     return JIM_ERR;
1052                 }
1053                 on = longval;
1054             }
1055             if (setsockopt(af->fd, sockopts[i].level, sockopts[i].opt, (void *)&on, sizeof(on)) < 0) {
1056                 Jim_SetResultFormatted(interp, "Failed to set %#s: %s", argv[0], strerror(errno));
1057                 return JIM_ERR;
1058             }
1059             return JIM_OK;
1060         }
1061     }
1062     /* Not found */
1063     Jim_SetResultFormatted(interp, "Unknown sockopt %#s", argv[0]);
1064     return JIM_ERR;
1065 }
1066 #endif /* JIM_BOOTSTRAP */
1067
1068 #ifdef HAVE_FSYNC
1069 static int aio_cmd_sync(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1070 {
1071     AioFile *af = Jim_CmdPrivData(interp);
1072
1073     fflush(af->fp);
1074     fsync(af->fd);
1075     return JIM_OK;
1076 }
1077 #endif
1078
1079 static int aio_cmd_buffering(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1080 {
1081     AioFile *af = Jim_CmdPrivData(interp);
1082
1083     static const char * const options[] = {
1084         "none",
1085         "line",
1086         "full",
1087         NULL
1088     };
1089     enum
1090     {
1091         OPT_NONE,
1092         OPT_LINE,
1093         OPT_FULL,
1094     };
1095     int option;
1096
1097     if (Jim_GetEnum(interp, argv[0], options, &option, NULL, JIM_ERRMSG) != JIM_OK) {
1098         return JIM_ERR;
1099     }
1100     switch (option) {
1101         case OPT_NONE:
1102             setvbuf(af->fp, NULL, _IONBF, 0);
1103             break;
1104         case OPT_LINE:
1105             setvbuf(af->fp, NULL, _IOLBF, BUFSIZ);
1106             break;
1107         case OPT_FULL:
1108             setvbuf(af->fp, NULL, _IOFBF, BUFSIZ);
1109             break;
1110     }
1111     return JIM_OK;
1112 }
1113
1114 #ifdef jim_ext_eventloop
1115 static void JimAioFileEventFinalizer(Jim_Interp *interp, void *clientData)
1116 {
1117     Jim_Obj **objPtrPtr = clientData;
1118
1119     Jim_DecrRefCount(interp, *objPtrPtr);
1120     *objPtrPtr = NULL;
1121 }
1122
1123 static int JimAioFileEventHandler(Jim_Interp *interp, void *clientData, int mask)
1124 {
1125     Jim_Obj **objPtrPtr = clientData;
1126
1127     return Jim_EvalObjBackground(interp, *objPtrPtr);
1128 }
1129
1130 static int aio_eventinfo(Jim_Interp *interp, AioFile * af, unsigned mask, Jim_Obj **scriptHandlerObj,
1131     int argc, Jim_Obj * const *argv)
1132 {
1133     if (argc == 0) {
1134         /* Return current script */
1135         if (*scriptHandlerObj) {
1136             Jim_SetResult(interp, *scriptHandlerObj);
1137         }
1138         return JIM_OK;
1139     }
1140
1141     if (*scriptHandlerObj) {
1142         /* Delete old handler */
1143         Jim_DeleteFileHandler(interp, af->fd, mask);
1144     }
1145
1146     /* Now possibly add the new script(s) */
1147     if (Jim_Length(argv[0]) == 0) {
1148         /* Empty script, so done */
1149         return JIM_OK;
1150     }
1151
1152     /* A new script to add */
1153     Jim_IncrRefCount(argv[0]);
1154     *scriptHandlerObj = argv[0];
1155
1156     Jim_CreateFileHandler(interp, af->fd, mask,
1157         JimAioFileEventHandler, scriptHandlerObj, JimAioFileEventFinalizer);
1158
1159     return JIM_OK;
1160 }
1161
1162 static int aio_cmd_readable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1163 {
1164     AioFile *af = Jim_CmdPrivData(interp);
1165
1166     return aio_eventinfo(interp, af, JIM_EVENT_READABLE, &af->rEvent, argc, argv);
1167 }
1168
1169 static int aio_cmd_writable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1170 {
1171     AioFile *af = Jim_CmdPrivData(interp);
1172
1173     return aio_eventinfo(interp, af, JIM_EVENT_WRITABLE, &af->wEvent, argc, argv);
1174 }
1175
1176 static int aio_cmd_onexception(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1177 {
1178     AioFile *af = Jim_CmdPrivData(interp);
1179
1180     return aio_eventinfo(interp, af, JIM_EVENT_EXCEPTION, &af->eEvent, argc, argv);
1181 }
1182 #endif
1183
1184 #if defined(JIM_SSL) && !defined(JIM_BOOTSTRAP)
1185 static int aio_cmd_ssl(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1186 {
1187     AioFile *af = Jim_CmdPrivData(interp);
1188     SSL *ssl;
1189     SSL_CTX *ssl_ctx;
1190     int server = 0;
1191
1192     if (argc == 5) {
1193         if (!Jim_CompareStringImmediate(interp, argv[2], "-server")) {
1194             return JIM_ERR;
1195         }
1196         server = 1;
1197     }
1198     else if (argc != 2) {
1199         Jim_WrongNumArgs(interp, 2, argv, "?-server cert priv?");
1200         return JIM_ERR;
1201     }
1202
1203     if (af->ssl) {
1204         Jim_SetResultFormatted(interp, "%#s: stream is already ssl", argv[0]);
1205         return JIM_ERR;
1206     }
1207
1208     ssl_ctx = JimAioSslCtx(interp);
1209     if (ssl_ctx == NULL) {
1210         return JIM_ERR;
1211     }
1212
1213     ssl = SSL_new(ssl_ctx);
1214     if (ssl == NULL) {
1215         goto out;
1216     }
1217
1218     SSL_set_cipher_list(ssl, "ALL");
1219
1220     if (SSL_set_fd(ssl, fileno(af->fp)) == 0) {
1221         goto out;
1222     }
1223
1224     if (server) {
1225         if (SSL_use_certificate_file(ssl, Jim_String(argv[3]), SSL_FILETYPE_PEM) != 1) {
1226             goto out;
1227         }
1228
1229         if (SSL_use_PrivateKey_file(ssl, Jim_String(argv[4]), SSL_FILETYPE_PEM) != 1) {
1230             goto out;
1231         }
1232
1233         if (SSL_accept(ssl) != 1) {
1234             goto out;
1235         }
1236     }
1237     else {
1238         if (SSL_connect(ssl) != 1) {
1239             goto out;
1240         }
1241     }
1242
1243     af->ssl = ssl;
1244     af->fops = &ssl_fops;
1245
1246     /* Set the command name as the result */
1247     Jim_SetResult(interp, argv[0]);
1248
1249     return JIM_OK;
1250
1251 out:
1252     if (ssl) {
1253         SSL_free(ssl);
1254     }
1255     Jim_SetResultString(interp, ERR_error_string(ERR_get_error(), NULL), -1);
1256     return JIM_ERR;
1257 }
1258
1259 static int aio_cmd_verify(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1260 {
1261     AioFile *af = Jim_CmdPrivData(interp);
1262     int ret;
1263
1264     if (!af->fops->verify) {
1265         return JIM_OK;
1266     }
1267
1268     ret = af->fops->verify(af);
1269     if (ret != JIM_OK) {
1270         if (JimCheckStreamError(interp, af)) {
1271             JimAioSetError(interp, af->filename);
1272         } else {
1273             Jim_SetResultString(interp, "failed to verify the connection authenticity", -1);
1274         }
1275     }
1276     return ret;
1277 }
1278 #endif /* JIM_BOOTSTRAP */
1279
1280 #if defined(HAVE_STRUCT_FLOCK) && !defined(JIM_BOOTSTRAP)
1281 static int aio_cmd_lock(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1282 {
1283     AioFile *af = Jim_CmdPrivData(interp);
1284     struct flock fl;
1285
1286     fl.l_start = 0;
1287     fl.l_len = 0;
1288     fl.l_type = F_WRLCK;
1289     fl.l_whence = SEEK_SET;
1290
1291     switch (fcntl(af->fd, F_SETLK, &fl))
1292     {
1293         case 0:
1294             Jim_SetResultInt(interp, 1);
1295             break;
1296         case -1:
1297             if (errno == EACCES || errno == EAGAIN)
1298                 Jim_SetResultInt(interp, 0);
1299             else
1300             {
1301                 Jim_SetResultFormatted(interp, "lock failed: %s",
1302                     strerror(errno));
1303                 return JIM_ERR;
1304             }
1305             break;
1306         default:
1307             Jim_SetResultInt(interp, 0);
1308             break;
1309     }
1310
1311     return JIM_OK;
1312 }
1313
1314 static int aio_cmd_unlock(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1315 {
1316     AioFile *af = Jim_CmdPrivData(interp);
1317     struct flock fl;
1318     fl.l_start = 0;
1319     fl.l_len = 0;
1320     fl.l_type = F_UNLCK;
1321     fl.l_whence = SEEK_SET;
1322
1323     Jim_SetResultInt(interp, fcntl(af->fd, F_SETLK, &fl) == 0);
1324     return JIM_OK;
1325 }
1326 #endif /* JIM_BOOTSTRAP */
1327
1328 #if defined(HAVE_TERMIOS_H) && !defined(JIM_BOOTSTRAP)
1329 static int aio_cmd_tty(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1330 {
1331     AioFile *af = Jim_CmdPrivData(interp);
1332     Jim_Obj *dictObjPtr;
1333     int ret;
1334
1335     if (argc == 0) {
1336         /* get the current settings as a dictionary */
1337         dictObjPtr = Jim_GetTtySettings(interp, af->fd);
1338         if (dictObjPtr == NULL) {
1339             JimAioSetError(interp, NULL);
1340             return JIM_ERR;
1341         }
1342         Jim_SetResult(interp, dictObjPtr);
1343         return JIM_OK;
1344     }
1345
1346     if (argc > 1) {
1347         /* Convert name value arguments to a dictionary */
1348         dictObjPtr = Jim_NewListObj(interp, argv, argc);
1349     }
1350     else {
1351         /* The settings are already given as a list */
1352         dictObjPtr = argv[0];
1353     }
1354     Jim_IncrRefCount(dictObjPtr);
1355
1356     if (Jim_ListLength(interp, dictObjPtr) % 2) {
1357         /* Must be a valid dictionary */
1358         Jim_DecrRefCount(interp, dictObjPtr);
1359         return -1;
1360     }
1361
1362     ret = Jim_SetTtySettings(interp, af->fd, dictObjPtr);
1363     if (ret < 0) {
1364         JimAioSetError(interp, NULL);
1365         ret = JIM_ERR;
1366     }
1367     Jim_DecrRefCount(interp, dictObjPtr);
1368
1369     return ret;
1370 }
1371 #endif /* JIM_BOOTSTRAP */
1372
1373 static const jim_subcmd_type aio_command_table[] = {
1374     {   "read",
1375         "?-nonewline? ?len?",
1376         aio_cmd_read,
1377         0,
1378         2,
1379         /* Description: Read and return bytes from the stream. To eof if no len. */
1380     },
1381     {   "copyto",
1382         "handle ?size?",
1383         aio_cmd_copy,
1384         1,
1385         2,
1386         /* Description: Copy up to 'size' bytes to the given filehandle, or to eof if no size. */
1387     },
1388     {   "getfd",
1389         NULL,
1390         aio_cmd_getfd,
1391         0,
1392         0,
1393         /* Description: Internal command to return the underlying file descriptor. */
1394     },
1395     {   "gets",
1396         "?var?",
1397         aio_cmd_gets,
1398         0,
1399         1,
1400         /* Description: Read one line and return it or store it in the var */
1401     },
1402     {   "puts",
1403         "?-nonewline? str",
1404         aio_cmd_puts,
1405         1,
1406         2,
1407         /* Description: Write the string, with newline unless -nonewline */
1408     },
1409     {   "isatty",
1410         NULL,
1411         aio_cmd_isatty,
1412         0,
1413         0,
1414         /* Description: Is the file descriptor a tty? */
1415     },
1416 #if defined(HAVE_SOCKETS) && !defined(JIM_BOOTSTRAP)
1417     {   "recvfrom",
1418         "len ?addrvar?",
1419         aio_cmd_recvfrom,
1420         1,
1421         2,
1422         /* Description: Receive up to 'len' bytes on the socket. Sets 'addrvar' with receive address, if set */
1423     },
1424     {   "sendto",
1425         "str address",
1426         aio_cmd_sendto,
1427         2,
1428         2,
1429         /* Description: Send 'str' to the given address (dgram only) */
1430     },
1431     {   "accept",
1432         "?addrvar?",
1433         aio_cmd_accept,
1434         0,
1435         1,
1436         /* Description: Server socket only: Accept a connection and return stream */
1437     },
1438     {   "listen",
1439         "backlog",
1440         aio_cmd_listen,
1441         1,
1442         1,
1443         /* Description: Set the listen backlog for server socket */
1444     },
1445     {   "sockopt",
1446         "?opt 0|1?",
1447         aio_cmd_sockopt,
1448         0,
1449         2,
1450         /* Description: Return a dictionary of sockopts, or set the value of a sockopt */
1451     },
1452 #endif /* JIM_BOOTSTRAP */
1453     {   "flush",
1454         NULL,
1455         aio_cmd_flush,
1456         0,
1457         0,
1458         /* Description: Flush the stream */
1459     },
1460     {   "eof",
1461         NULL,
1462         aio_cmd_eof,
1463         0,
1464         0,
1465         /* Description: Returns 1 if stream is at eof */
1466     },
1467     {   "close",
1468         "?r(ead)|w(rite)?",
1469         aio_cmd_close,
1470         0,
1471         1,
1472         JIM_MODFLAG_FULLARGV,
1473         /* Description: Closes the stream. */
1474     },
1475     {   "seek",
1476         "offset ?start|current|end",
1477         aio_cmd_seek,
1478         1,
1479         2,
1480         /* Description: Seeks in the stream (default 'current') */
1481     },
1482     {   "tell",
1483         NULL,
1484         aio_cmd_tell,
1485         0,
1486         0,
1487         /* Description: Returns the current seek position */
1488     },
1489     {   "filename",
1490         NULL,
1491         aio_cmd_filename,
1492         0,
1493         0,
1494         /* Description: Returns the original filename */
1495     },
1496 #ifdef O_NDELAY
1497     {   "ndelay",
1498         "?0|1?",
1499         aio_cmd_ndelay,
1500         0,
1501         1,
1502         /* Description: Set O_NDELAY (if arg). Returns current/new setting. */
1503     },
1504 #endif
1505 #ifdef HAVE_FSYNC
1506     {   "sync",
1507         NULL,
1508         aio_cmd_sync,
1509         0,
1510         0,
1511         /* Description: Flush and fsync() the stream */
1512     },
1513 #endif
1514     {   "buffering",
1515         "none|line|full",
1516         aio_cmd_buffering,
1517         1,
1518         1,
1519         /* Description: Sets buffering */
1520     },
1521 #ifdef jim_ext_eventloop
1522     {   "readable",
1523         "?readable-script?",
1524         aio_cmd_readable,
1525         0,
1526         1,
1527         /* Description: Returns script, or invoke readable-script when readable, {} to remove */
1528     },
1529     {   "writable",
1530         "?writable-script?",
1531         aio_cmd_writable,
1532         0,
1533         1,
1534         /* Description: Returns script, or invoke writable-script when writable, {} to remove */
1535     },
1536     {   "onexception",
1537         "?exception-script?",
1538         aio_cmd_onexception,
1539         0,
1540         1,
1541         /* Description: Returns script, or invoke exception-script when oob data, {} to remove */
1542     },
1543 #endif
1544 #if !defined(JIM_BOOTSTRAP)
1545 #if defined(JIM_SSL)
1546     {   "ssl",
1547         "?-server cert priv?",
1548         aio_cmd_ssl,
1549         0,
1550         3,
1551         JIM_MODFLAG_FULLARGV
1552         /* Description: Wraps a stream socket with SSL/TLS and returns a new channel */
1553     },
1554     {   "verify",
1555         NULL,
1556         aio_cmd_verify,
1557         0,
1558         0,
1559         /* Description: Verifies the certificate of a SSL/TLS channel */
1560     },
1561 #endif
1562 #if defined(HAVE_STRUCT_FLOCK)
1563     {   "lock",
1564         NULL,
1565         aio_cmd_lock,
1566         0,
1567         0,
1568         /* Description: Attempt to get a lock. */
1569     },
1570     {   "unlock",
1571         NULL,
1572         aio_cmd_unlock,
1573         0,
1574         0,
1575         /* Description: Relase a lock. */
1576     },
1577 #endif
1578 #if defined(HAVE_TERMIOS_H)
1579     {   "tty",
1580         "?baud rate? ?data bits? ?stop bits? ?parity even|odd|none? ?handshake xonxoff|rtscts|none? ?input raw|cooked? ?output raw|cooked? ?vmin n? ?vtime n?",
1581         aio_cmd_tty,
1582         0,
1583         -1,
1584         /* Description: Get or set tty settings - valid only on a tty */
1585     },
1586 #endif
1587 #endif /* JIM_BOOTSTRAP */
1588     { NULL }
1589 };
1590
1591 static int JimAioSubCmdProc(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1592 {
1593     return Jim_CallSubCmd(interp, Jim_ParseSubCmd(interp, aio_command_table, argc, argv), argc, argv);
1594 }
1595
1596 static int JimAioOpenCommand(Jim_Interp *interp, int argc,
1597         Jim_Obj *const *argv)
1598 {
1599     const char *mode;
1600
1601     if (argc != 2 && argc != 3) {
1602         Jim_WrongNumArgs(interp, 1, argv, "filename ?mode?");
1603         return JIM_ERR;
1604     }
1605
1606     mode = (argc == 3) ? Jim_String(argv[2]) : "r";
1607
1608 #ifdef jim_ext_tclcompat
1609     {
1610         const char *filename = Jim_String(argv[1]);
1611
1612         /* If the filename starts with '|', use popen instead */
1613         if (*filename == '|') {
1614             Jim_Obj *evalObj[3];
1615
1616             evalObj[0] = Jim_NewStringObj(interp, "::popen", -1);
1617             evalObj[1] = Jim_NewStringObj(interp, filename + 1, -1);
1618             evalObj[2] = Jim_NewStringObj(interp, mode, -1);
1619
1620             return Jim_EvalObjVector(interp, 3, evalObj);
1621         }
1622     }
1623 #endif
1624     return JimMakeChannel(interp, NULL, -1, argv[1], "aio.handle%ld", 0, mode) ? JIM_OK : JIM_ERR;
1625 }
1626
1627 #if defined(JIM_SSL) && !defined(JIM_BOOTSTRAP)
1628 static void JimAioSslContextDelProc(struct Jim_Interp *interp, void *privData)
1629 {
1630     SSL_CTX_free((SSL_CTX *)privData);
1631     ERR_free_strings();
1632 }
1633
1634 static SSL_CTX *JimAioSslCtx(Jim_Interp *interp)
1635 {
1636     SSL_CTX *ssl_ctx = (SSL_CTX *)Jim_GetAssocData(interp, "ssl_ctx");
1637     if (ssl_ctx == NULL) {
1638         SSL_load_error_strings();
1639         SSL_library_init();
1640         ssl_ctx = SSL_CTX_new(TLSv1_2_method());
1641         if (ssl_ctx && SSL_CTX_set_default_verify_paths(ssl_ctx)) {
1642             SSL_CTX_set_verify(ssl_ctx, SSL_VERIFY_NONE, NULL);
1643             Jim_SetAssocData(interp, "ssl_ctx", JimAioSslContextDelProc, ssl_ctx);
1644         } else {
1645             Jim_SetResultString(interp, ERR_error_string(ERR_get_error(), NULL), -1);
1646         }
1647     }
1648     return ssl_ctx;
1649 }
1650 #endif /* JIM_BOOTSTRAP */
1651
1652 /**
1653  * Creates a channel for fh/fd/filename.
1654  *
1655  * If fh is not NULL, uses that as the channel (and sets AIO_KEEPOPEN).
1656  * Otherwise, if fd is >= 0, uses that as the channel.
1657  * Otherwise opens 'filename' with mode 'mode'.
1658  *
1659  * hdlfmt is a sprintf format for the filehandle. Anything with %ld at the end will do.
1660  * mode is used for open or fdopen.
1661  *
1662  * Creates the command and sets the name as the current result.
1663  * Returns the AioFile pointer on sucess or NULL on failure.
1664  */
1665 static AioFile *JimMakeChannel(Jim_Interp *interp, FILE *fh, int fd, Jim_Obj *filename,
1666     const char *hdlfmt, int family, const char *mode)
1667 {
1668     AioFile *af;
1669     char buf[AIO_CMD_LEN];
1670     int openFlags = 0;
1671
1672     snprintf(buf, sizeof(buf), hdlfmt, Jim_GetId(interp));
1673
1674     if (fh) {
1675         openFlags = AIO_KEEPOPEN;
1676     }
1677
1678     snprintf(buf, sizeof(buf), hdlfmt, Jim_GetId(interp));
1679     if (!filename) {
1680         filename = Jim_NewStringObj(interp, buf, -1);
1681     }
1682
1683     Jim_IncrRefCount(filename);
1684
1685     if (fh == NULL) {
1686         if (fd >= 0) {
1687 #ifndef JIM_ANSIC
1688             fh = fdopen(fd, mode);
1689 #endif
1690         }
1691         else
1692             fh = fopen(Jim_String(filename), mode);
1693
1694         if (fh == NULL) {
1695             JimAioSetError(interp, filename);
1696 #ifndef JIM_ANSIC
1697             if (fd >= 0) {
1698                 close(fd);
1699             }
1700 #endif
1701             Jim_DecrRefCount(interp, filename);
1702             return NULL;
1703         }
1704     }
1705
1706     /* Create the file command */
1707     af = Jim_Alloc(sizeof(*af));
1708     memset(af, 0, sizeof(*af));
1709     af->fp = fh;
1710 #ifndef JIM_ANSIC
1711     af->fd = fileno(fh);
1712 #endif
1713     af->filename = filename;
1714 #ifdef FD_CLOEXEC
1715     if ((openFlags & AIO_KEEPOPEN) == 0) {
1716         (void)fcntl(af->fd, F_SETFD, FD_CLOEXEC);
1717     }
1718 #endif
1719     af->openFlags = openFlags;
1720     af->addr_family = family;
1721     af->fops = &stdio_fops;
1722     af->ssl = NULL;
1723
1724     Jim_CreateCommand(interp, buf, JimAioSubCmdProc, af, JimAioDelProc);
1725
1726     /* Note that the command must use the global namespace, even if
1727      * the current namespace is something different
1728      */
1729     Jim_SetResult(interp, Jim_MakeGlobalNamespaceName(interp, Jim_NewStringObj(interp, buf, -1)));
1730
1731     return af;
1732 }
1733
1734 #if defined(HAVE_PIPE) || (defined(HAVE_SOCKETPAIR) && defined(HAVE_SYS_UN_H))
1735 /**
1736  * Create a pair of channels. e.g. from pipe() or socketpair()
1737  */
1738 static int JimMakeChannelPair(Jim_Interp *interp, int p[2], Jim_Obj *filename,
1739     const char *hdlfmt, int family, const char *mode[2])
1740 {
1741     if (JimMakeChannel(interp, NULL, p[0], filename, hdlfmt, family, mode[0])) {
1742         Jim_Obj *objPtr = Jim_NewListObj(interp, NULL, 0);
1743         Jim_ListAppendElement(interp, objPtr, Jim_GetResult(interp));
1744         if (JimMakeChannel(interp, NULL, p[1], filename, hdlfmt, family, mode[1])) {
1745             Jim_ListAppendElement(interp, objPtr, Jim_GetResult(interp));
1746             Jim_SetResult(interp, objPtr);
1747             return JIM_OK;
1748         }
1749     }
1750
1751     /* Can only be here if fdopen() failed */
1752     close(p[0]);
1753     close(p[1]);
1754     JimAioSetError(interp, NULL);
1755     return JIM_ERR;
1756 }
1757 #endif
1758
1759 #ifdef HAVE_PIPE
1760 static int JimAioPipeCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1761 {
1762     int p[2];
1763     static const char *mode[2] = { "r", "w" };
1764
1765     if (argc != 1) {
1766         Jim_WrongNumArgs(interp, 1, argv, "");
1767         return JIM_ERR;
1768     }
1769
1770     if (pipe(p) != 0) {
1771         JimAioSetError(interp, NULL);
1772         return JIM_ERR;
1773     }
1774
1775     return JimMakeChannelPair(interp, p, argv[0], "aio.pipe%ld", 0, mode);
1776 }
1777 #endif
1778
1779 #if defined(HAVE_SOCKETS) && !defined(JIM_BOOTSTRAP)
1780
1781 static int JimAioSockCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1782 {
1783     const char *hdlfmt = "aio.unknown%ld";
1784     const char *socktypes[] = {
1785         "unix",
1786         "unix.server",
1787         "dgram",
1788         "dgram.server",
1789         "stream",
1790         "stream.server",
1791         "pipe",
1792         "pair",
1793         NULL
1794     };
1795     enum
1796     {
1797         SOCK_UNIX,
1798         SOCK_UNIX_SERVER,
1799         SOCK_DGRAM_CLIENT,
1800         SOCK_DGRAM_SERVER,
1801         SOCK_STREAM_CLIENT,
1802         SOCK_STREAM_SERVER,
1803         SOCK_STREAM_PIPE,
1804         SOCK_STREAM_SOCKETPAIR,
1805     };
1806     int socktype;
1807     int sock;
1808     const char *hostportarg = NULL;
1809     int res;
1810     int on = 1;
1811     const char *mode = "r+";
1812     int family = PF_INET;
1813     Jim_Obj *argv0 = argv[0];
1814     int ipv6 = 0;
1815
1816     if (argc > 1 && Jim_CompareStringImmediate(interp, argv[1], "-ipv6")) {
1817         if (!IPV6) {
1818             Jim_SetResultString(interp, "ipv6 not supported", -1);
1819             return JIM_ERR;
1820         }
1821         ipv6 = 1;
1822         family = PF_INET6;
1823     }
1824     argc -= ipv6;
1825     argv += ipv6;
1826
1827     if (argc < 2) {
1828       wrongargs:
1829         Jim_WrongNumArgs(interp, 1, &argv0, "?-ipv6? type ?address?");
1830         return JIM_ERR;
1831     }
1832
1833     if (Jim_GetEnum(interp, argv[1], socktypes, &socktype, "socket type", JIM_ERRMSG) != JIM_OK)
1834         return Jim_CheckShowCommands(interp, argv[1], socktypes);
1835
1836     Jim_SetEmptyResult(interp);
1837
1838     hdlfmt = "aio.sock%ld";
1839
1840     if (argc > 2) {
1841         hostportarg = Jim_String(argv[2]);
1842     }
1843
1844     switch (socktype) {
1845         case SOCK_DGRAM_CLIENT:
1846             if (argc == 2) {
1847                 /* No address, so an unconnected dgram socket */
1848                 sock = socket(family, SOCK_DGRAM, 0);
1849                 if (sock < 0) {
1850                     JimAioSetError(interp, NULL);
1851                     return JIM_ERR;
1852                 }
1853                 break;
1854             }
1855             /* fall through */
1856         case SOCK_STREAM_CLIENT:
1857             {
1858                 union sockaddr_any sa;
1859                 int salen;
1860
1861                 if (argc != 3) {
1862                     goto wrongargs;
1863                 }
1864
1865                 if (ipv6) {
1866                     if (JimParseIPv6Address(interp, hostportarg, &sa, &salen) != JIM_OK) {
1867                         return JIM_ERR;
1868                     }
1869                 }
1870                 else if (JimParseIpAddress(interp, hostportarg, &sa, &salen) != JIM_OK) {
1871                     return JIM_ERR;
1872                 }
1873                 sock = socket(family, (socktype == SOCK_DGRAM_CLIENT) ? SOCK_DGRAM : SOCK_STREAM, 0);
1874                 if (sock < 0) {
1875                     JimAioSetError(interp, NULL);
1876                     return JIM_ERR;
1877                 }
1878                 res = connect(sock, &sa.sa, salen);
1879                 if (res) {
1880                     JimAioSetError(interp, argv[2]);
1881                     close(sock);
1882                     return JIM_ERR;
1883                 }
1884             }
1885             break;
1886
1887         case SOCK_STREAM_SERVER:
1888         case SOCK_DGRAM_SERVER:
1889             {
1890                 union sockaddr_any sa;
1891                 int salen;
1892
1893                 if (argc != 3) {
1894                     goto wrongargs;
1895                 }
1896
1897                 if (ipv6) {
1898                     if (JimParseIPv6Address(interp, hostportarg, &sa, &salen) != JIM_OK) {
1899                         return JIM_ERR;
1900                     }
1901                 }
1902                 else if (JimParseIpAddress(interp, hostportarg, &sa, &salen) != JIM_OK) {
1903                     return JIM_ERR;
1904                 }
1905                 sock = socket(family, (socktype == SOCK_DGRAM_SERVER) ? SOCK_DGRAM : SOCK_STREAM, 0);
1906                 if (sock < 0) {
1907                     JimAioSetError(interp, NULL);
1908                     return JIM_ERR;
1909                 }
1910
1911                 /* Enable address reuse */
1912                 setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&on, sizeof(on));
1913
1914                 res = bind(sock, &sa.sa, salen);
1915                 if (res) {
1916                     JimAioSetError(interp, argv[2]);
1917                     close(sock);
1918                     return JIM_ERR;
1919                 }
1920                 if (socktype == SOCK_STREAM_SERVER) {
1921                     res = listen(sock, 5);
1922                     if (res) {
1923                         JimAioSetError(interp, NULL);
1924                         close(sock);
1925                         return JIM_ERR;
1926                     }
1927                 }
1928                 hdlfmt = "aio.socksrv%ld";
1929             }
1930             break;
1931
1932 #ifdef HAVE_SYS_UN_H
1933         case SOCK_UNIX:
1934             {
1935                 struct sockaddr_un sa;
1936                 socklen_t len;
1937
1938                 if (argc != 3 || ipv6) {
1939                     goto wrongargs;
1940                 }
1941
1942                 if (JimParseDomainAddress(interp, hostportarg, &sa) != JIM_OK) {
1943                     JimAioSetError(interp, argv[2]);
1944                     return JIM_ERR;
1945                 }
1946                 family = PF_UNIX;
1947                 sock = socket(PF_UNIX, SOCK_STREAM, 0);
1948                 if (sock < 0) {
1949                     JimAioSetError(interp, NULL);
1950                     return JIM_ERR;
1951                 }
1952                 len = strlen(sa.sun_path) + 1 + sizeof(sa.sun_family);
1953                 res = connect(sock, (struct sockaddr *)&sa, len);
1954                 if (res) {
1955                     JimAioSetError(interp, argv[2]);
1956                     close(sock);
1957                     return JIM_ERR;
1958                 }
1959                 hdlfmt = "aio.sockunix%ld";
1960                 break;
1961             }
1962
1963         case SOCK_UNIX_SERVER:
1964             {
1965                 struct sockaddr_un sa;
1966                 socklen_t len;
1967
1968                 if (argc != 3 || ipv6) {
1969                     goto wrongargs;
1970                 }
1971
1972                 if (JimParseDomainAddress(interp, hostportarg, &sa) != JIM_OK) {
1973                     JimAioSetError(interp, argv[2]);
1974                     return JIM_ERR;
1975                 }
1976                 family = PF_UNIX;
1977                 sock = socket(PF_UNIX, SOCK_STREAM, 0);
1978                 if (sock < 0) {
1979                     JimAioSetError(interp, NULL);
1980                     return JIM_ERR;
1981                 }
1982                 len = strlen(sa.sun_path) + 1 + sizeof(sa.sun_family);
1983                 res = bind(sock, (struct sockaddr *)&sa, len);
1984                 if (res) {
1985                     JimAioSetError(interp, argv[2]);
1986                     close(sock);
1987                     return JIM_ERR;
1988                 }
1989                 res = listen(sock, 5);
1990                 if (res) {
1991                     JimAioSetError(interp, NULL);
1992                     close(sock);
1993                     return JIM_ERR;
1994                 }
1995                 hdlfmt = "aio.sockunixsrv%ld";
1996                 break;
1997             }
1998 #endif
1999
2000 #if defined(HAVE_SOCKETPAIR) && defined(HAVE_SYS_UN_H)
2001         case SOCK_STREAM_SOCKETPAIR:
2002             {
2003                 int p[2];
2004                 static const char *mode[2] = { "r+", "r+" };
2005
2006                 if (argc != 2 || ipv6) {
2007                     goto wrongargs;
2008                 }
2009
2010                 if (socketpair(PF_UNIX, SOCK_STREAM, 0, p) < 0) {
2011                     JimAioSetError(interp, NULL);
2012                     return JIM_ERR;
2013                 }
2014                 return JimMakeChannelPair(interp, p, argv[1], "aio.sockpair%ld", PF_UNIX, mode);
2015             }
2016             break;
2017 #endif
2018
2019 #if defined(HAVE_PIPE)
2020         case SOCK_STREAM_PIPE:
2021             if (argc != 2 || ipv6) {
2022                 goto wrongargs;
2023             }
2024             return JimAioPipeCommand(interp, 1, &argv[1]);
2025 #endif
2026
2027         default:
2028             Jim_SetResultString(interp, "Unsupported socket type", -1);
2029             return JIM_ERR;
2030     }
2031
2032     return JimMakeChannel(interp, NULL, sock, argv[1], hdlfmt, family, mode) ? JIM_OK : JIM_ERR;
2033 }
2034 #endif /* JIM_BOOTSTRAP */
2035
2036 #if defined(JIM_SSL) && !defined(JIM_BOOTSTRAP)
2037 static int JimAioLoadSSLCertsCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
2038 {
2039     SSL_CTX *ssl_ctx;
2040
2041     if (argc != 2) {
2042         Jim_WrongNumArgs(interp, 1, argv, "dir");
2043         return JIM_ERR;
2044     }
2045
2046     ssl_ctx = JimAioSslCtx(interp);
2047     if (!ssl_ctx) {
2048         return JIM_ERR;
2049     }
2050     if (SSL_CTX_load_verify_locations(ssl_ctx, NULL, Jim_String(argv[1])) == 1) {
2051         return JIM_OK;
2052     }
2053     Jim_SetResultString(interp, ERR_error_string(ERR_get_error(), NULL), -1);
2054     return JIM_ERR;
2055 }
2056 #endif /* JIM_BOOTSTRAP */
2057
2058 int Jim_aioInit(Jim_Interp *interp)
2059 {
2060     if (Jim_PackageProvide(interp, "aio", "1.0", JIM_ERRMSG))
2061         return JIM_ERR;
2062
2063 #if defined(JIM_SSL)
2064     Jim_CreateCommand(interp, "load_ssl_certs", JimAioLoadSSLCertsCommand, NULL, NULL);
2065 #endif
2066
2067     Jim_CreateCommand(interp, "open", JimAioOpenCommand, NULL, NULL);
2068 #ifdef HAVE_SOCKETS
2069     Jim_CreateCommand(interp, "socket", JimAioSockCommand, NULL, NULL);
2070 #endif
2071 #ifdef HAVE_PIPE
2072     Jim_CreateCommand(interp, "pipe", JimAioPipeCommand, NULL, NULL);
2073 #endif
2074
2075     /* Create filehandles for stdin, stdout and stderr */
2076     JimMakeChannel(interp, stdin, -1, NULL, "stdin", 0, "r");
2077     JimMakeChannel(interp, stdout, -1, NULL, "stdout", 0, "w");
2078     JimMakeChannel(interp, stderr, -1, NULL, "stderr", 0, "w");
2079
2080     return JIM_OK;
2081 }