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