jim-aio.c

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