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