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 #include <stdio.h>
  43 #include <string.h>
  44 #include <errno.h>
  45 #include <fcntl.h>
  46 #ifdef HAVE_UNISTD_H
  47 #include <unistd.h>
  48 #endif
  49
  50 #include "jim.h"
  51
  52 #if defined(HAVE_SYS_SOCKET_H) && defined(HAVE_SELECT) && defined(HAVE_NETINET_IN_H) && defined(HAVE_NETDB_H) && defined(HAVE_ARPA_INET_H)
  53 #include <sys/socket.h>
  54 #include <netinet/in.h>
  55 #include <arpa/inet.h>
  56 #include <netdb.h>
  57 #ifdef HAVE_SYS_UN_H
  58 #include <sys/un.h>
  59 #endif
  60 #else
  61 #define JIM_ANSIC
  62 #endif
  63
  64 #include "jim-eventloop.h"
  65 #include "jim-subcmd.h"
  66
  67 #define AIO_CMD_LEN 32      /* e.g. aio.handleXXXXXX */
  68 #define AIO_BUF_LEN 256     /* Can keep this small and rely on stdio buffering */
  69
  70 #ifndef HAVE_FTELLO
  71     #define ftello ftell
  72 #endif
  73 #ifndef HAVE_FSEEKO
  74     #define fseeko fseek
  75 #endif
  76
  77 #define AIO_KEEPOPEN 1
  78
  79 #if defined(JIM_IPV6)
  80 #define IPV6 1
  81 #else
  82 #define IPV6 0
  83 #ifndef PF_INET6
  84 #define PF_INET6 0
  85 #endif
  86 #endif
  87
  88 #if !defined(JIM_ANSIC) && !defined(JIM_BOOTSTRAP)
  89 union sockaddr_any {
  90     struct sockaddr sa;
  91     struct sockaddr_in sin;
  92 #if IPV6
  93     struct sockaddr_in6 sin6;
  94 #endif
  95 };
  96
  97 #ifndef HAVE_INET_NTOP
  98 const char *inet_ntop(int af, const void *src, char *dst, int size)
  99 {
 100     if (af != PF_INET) {
 101         return NULL;
 102     }
 103     snprintf(dst, size, "%s", inet_ntoa(((struct sockaddr_in *)src)->sin_addr));
 104     return dst;
 105 }
 106 #endif
 107 #endif /* JIM_BOOTSTRAP */
 108
 109 typedef struct AioFile
 110 {
 111     FILE *fp;
 112     Jim_Obj *filename;
 113     int type;
 114     int openFlags;              /* AIO_KEEPOPEN? keep FILE* */
 115     int fd;
 116     Jim_Obj *rEvent;
 117     Jim_Obj *wEvent;
 118     Jim_Obj *eEvent;
 119     int addr_family;
 120 } AioFile;
 121
 122 static int JimAioSubCmdProc(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
 123 static int JimMakeChannel(Jim_Interp *interp, FILE *fh, int fd, Jim_Obj *filename,
 124     const char *hdlfmt, int family, const char *mode);
 125
 126 #if !defined(JIM_ANSIC) && !defined(JIM_BOOTSTRAP)
 127 static int JimParseIPv6Address(Jim_Interp *interp, const char *hostport, union sockaddr_any *sa, int *salen)
 128 {
 129 #if IPV6
 130     /*
 131      * An IPv6 addr/port looks like:
 132      *   [::1]
 133      *   [::1]:2000
 134      *   [fe80::223:6cff:fe95:bdc0%en1]:2000
 135      *   [::]:2000
 136      *   2000
 137      *
 138      *   Note that the "any" address is ::, which is the same as when no address is specified.
 139      */
 140      char *sthost = NULL;
 141      const char *stport;
 142      int ret = JIM_OK;
 143      struct addrinfo req;
 144      struct addrinfo *ai;
 145
 146     stport = strrchr(hostport, ':');
 147     if (!stport) {
 148         /* No : so, the whole thing is the port */
 149         stport = hostport;
 150         hostport = "::";
 151         sthost = Jim_StrDup(hostport);
 152     }
 153     else {
 154         stport++;
 155     }
 156
 157     if (*hostport == '[') {
 158         /* This is a numeric ipv6 address */
 159         char *pt = strchr(++hostport, ']');
 160         if (pt) {
 161             sthost = Jim_StrDupLen(hostport, pt - hostport);
 162         }
 163     }
 164
 165     if (!sthost) {
 166         sthost = Jim_StrDupLen(hostport, stport - hostport - 1);
 167     }
 168
 169     memset(&req, '\0', sizeof(req));
 170     req.ai_family = PF_INET6;
 171
 172     if (getaddrinfo(sthost, NULL, &req, &ai)) {
 173         Jim_SetResultFormatted(interp, "Not a valid address: %s", hostport);
 174         ret = JIM_ERR;
 175     }
 176     else {
 177         memcpy(&sa->sin, ai->ai_addr, ai->ai_addrlen);
 178         *salen = ai->ai_addrlen;
 179
 180         sa->sin.sin_port = htons(atoi(stport));
 181
 182         freeaddrinfo(ai);
 183     }
 184     Jim_Free(sthost);
 185
 186     return ret;
 187 #else
 188     Jim_SetResultString(interp, "ipv6 not supported", -1);
 189     return JIM_ERR;
 190 #endif
 191 }
 192
 193 static int JimParseIpAddress(Jim_Interp *interp, const char *hostport, union sockaddr_any *sa, int *salen)
 194 {
 195     /* An IPv4 addr/port looks like:
 196      *   192.168.1.5
 197      *   192.168.1.5:2000
 198      *   2000
 199      *
 200      * If the address is missing, INADDR_ANY is used.
 201      * If the port is missing, 0 is used (only useful for server sockets).
 202      */
 203     char *sthost = NULL;
 204     const char *stport;
 205     int ret = JIM_OK;
 206
 207     stport = strrchr(hostport, ':');
 208     if (!stport) {
 209         /* No : so, the whole thing is the port */
 210         stport = hostport;
 211         sthost = Jim_StrDup("0.0.0.0");
 212     }
 213     else {
 214         sthost = Jim_StrDupLen(hostport, stport - hostport);
 215         stport++;
 216     }
 217
 218     {
 219 #ifdef HAVE_GETADDRINFO
 220         struct addrinfo req;
 221         struct addrinfo *ai;
 222         memset(&req, '\0', sizeof(req));
 223         req.ai_family = PF_INET;
 224
 225         if (getaddrinfo(sthost, NULL, &req, &ai)) {
 226             ret = JIM_ERR;
 227         }
 228         else {
 229             memcpy(&sa->sin, ai->ai_addr, ai->ai_addrlen);
 230             *salen = ai->ai_addrlen;
 231             freeaddrinfo(ai);
 232         }
 233 #else
 234         struct hostent *he;
 235
 236         ret = JIM_ERR;
 237
 238         if ((he = gethostbyname(sthost)) != NULL) {
 239             if (he->h_length == sizeof(sa->sin.sin_addr)) {
 240                 *salen = sizeof(sa->sin);
 241                 sa->sin.sin_family= he->h_addrtype;
 242                 memcpy(&sa->sin.sin_addr, he->h_addr, he->h_length); /* set address */
 243                 ret = JIM_OK;
 244             }
 245         }
 246 #endif
 247
 248         sa->sin.sin_port = htons(atoi(stport));
 249     }
 250     Jim_Free(sthost);
 251
 252     if (ret != JIM_OK) {
 253         Jim_SetResultFormatted(interp, "Not a valid address: %s", hostport);
 254     }
 255
 256     return ret;
 257 }
 258
 259 #ifdef HAVE_SYS_UN_H
 260 static int JimParseDomainAddress(Jim_Interp *interp, const char *path, struct sockaddr_un *sa)
 261 {
 262     sa->sun_family = PF_UNIX;
 263     snprintf(sa->sun_path, sizeof(sa->sun_path), "%s", path);
 264
 265     return JIM_OK;
 266 }
 267 #endif
 268 #endif /* JIM_BOOTSTRAP */
 269
 270 static void JimAioSetError(Jim_Interp *interp, Jim_Obj *name)
 271 {
 272     if (name) {
 273         Jim_SetResultFormatted(interp, "%#s: %s", name, strerror(errno));
 274     }
 275     else {
 276         Jim_SetResultString(interp, strerror(errno), -1);
 277     }
 278 }
 279
 280 static void JimAioDelProc(Jim_Interp *interp, void *privData)
 281 {
 282     AioFile *af = privData;
 283
 284     JIM_NOTUSED(interp);
 285
 286     if (!(af->openFlags & AIO_KEEPOPEN)) {
 287         fclose(af->fp);
 288     }
 289
 290     Jim_DecrRefCount(interp, af->filename);
 291
 292 #ifdef jim_ext_eventloop
 293     /* remove all existing EventHandlers */
 294     Jim_DeleteFileHandler(interp, af->fp, JIM_EVENT_READABLE | JIM_EVENT_WRITABLE | JIM_EVENT_EXCEPTION);
 295 #endif
 296     Jim_Free(af);
 297 }
 298
 299 static int JimCheckStreamError(Jim_Interp *interp, AioFile *af)
 300 {
 301     if (!ferror(af->fp)) {
 302         return JIM_OK;
 303     }
 304     clearerr(af->fp);
 305     /* EAGAIN and similar are not error conditions. Just treat them like eof */
 306     if (feof(af->fp) || errno == EAGAIN || errno == EINTR) {
 307         return JIM_OK;
 308     }
 309 #ifdef ECONNRESET
 310     if (errno == ECONNRESET) {
 311         return JIM_OK;
 312     }
 313 #endif
 314 #ifdef ECONNABORTED
 315     if (errno != ECONNABORTED) {
 316         return JIM_OK;
 317     }
 318 #endif
 319     JimAioSetError(interp, af->filename);
 320     return JIM_ERR;
 321 }
 322
 323 static int aio_cmd_read(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 324 {
 325     AioFile *af = Jim_CmdPrivData(interp);
 326     char buf[AIO_BUF_LEN];
 327     Jim_Obj *objPtr;
 328     int nonewline = 0;
 329     jim_wide neededLen = -1;         /* -1 is "read as much as possible" */
 330
 331     if (argc && Jim_CompareStringImmediate(interp, argv[0], "-nonewline")) {
 332         nonewline = 1;
 333         argv++;
 334         argc--;
 335     }
 336     if (argc == 1) {
 337         if (Jim_GetWide(interp, argv[0], &neededLen) != JIM_OK)
 338             return JIM_ERR;
 339         if (neededLen < 0) {
 340             Jim_SetResultString(interp, "invalid parameter: negative len", -1);
 341             return JIM_ERR;
 342         }
 343     }
 344     else if (argc) {
 345         return -1;
 346     }
 347     objPtr = Jim_NewStringObj(interp, NULL, 0);
 348     while (neededLen != 0) {
 349         int retval;
 350         int readlen;
 351
 352         if (neededLen == -1) {
 353             readlen = AIO_BUF_LEN;
 354         }
 355         else {
 356             readlen = (neededLen > AIO_BUF_LEN ? AIO_BUF_LEN : neededLen);
 357         }
 358         retval = fread(buf, 1, readlen, af->fp);
 359         if (retval > 0) {
 360             Jim_AppendString(interp, objPtr, buf, retval);
 361             if (neededLen != -1) {
 362                 neededLen -= retval;
 363             }
 364         }
 365         if (retval != readlen)
 366             break;
 367     }
 368     /* Check for error conditions */
 369     if (JimCheckStreamError(interp, af)) {
 370         Jim_FreeNewObj(interp, objPtr);
 371         return JIM_ERR;
 372     }
 373     if (nonewline) {
 374         int len;
 375         const char *s = Jim_GetString(objPtr, &len);
 376
 377         if (len > 0 && s[len - 1] == '\n') {
 378             objPtr->length--;
 379             objPtr->bytes[objPtr->length] = '\0';
 380         }
 381     }
 382     Jim_SetResult(interp, objPtr);
 383     return JIM_OK;
 384 }
 385
 386 static int aio_cmd_copy(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 387 {
 388     AioFile *af = Jim_CmdPrivData(interp);
 389     jim_wide count = 0;
 390     jim_wide maxlen = JIM_WIDE_MAX;
 391     FILE *outfh = Jim_AioFilehandle(interp, argv[0]);
 392
 393     if (outfh == NULL) {
 394         return JIM_ERR;
 395     }
 396
 397     if (argc == 2) {
 398         if (Jim_GetWide(interp, argv[1], &maxlen) != JIM_OK) {
 399             return JIM_ERR;
 400         }
 401     }
 402
 403     while (count < maxlen) {
 404         int ch = fgetc(af->fp);
 405
 406         if (ch == EOF || fputc(ch, outfh) == EOF) {
 407             break;
 408         }
 409         count++;
 410     }
 411
 412     if (ferror(af->fp)) {
 413         Jim_SetResultFormatted(interp, "error while reading: %s", strerror(errno));
 414         clearerr(af->fp);
 415         return JIM_ERR;
 416     }
 417
 418     if (ferror(outfh)) {
 419         Jim_SetResultFormatted(interp, "error while writing: %s", strerror(errno));
 420         clearerr(outfh);
 421         return JIM_ERR;
 422     }
 423
 424     Jim_SetResultInt(interp, count);
 425
 426     return JIM_OK;
 427 }
 428
 429 static int aio_cmd_gets(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 430 {
 431     AioFile *af = Jim_CmdPrivData(interp);
 432     char buf[AIO_BUF_LEN];
 433     Jim_Obj *objPtr;
 434     int len;
 435
 436     errno = 0;
 437
 438     objPtr = Jim_NewStringObj(interp, NULL, 0);
 439     while (1) {
 440         buf[AIO_BUF_LEN - 1] = '_';
 441         if (fgets(buf, AIO_BUF_LEN, af->fp) == NULL)
 442             break;
 443
 444         if (buf[AIO_BUF_LEN - 1] == '\0' && buf[AIO_BUF_LEN - 2] != '\n') {
 445             Jim_AppendString(interp, objPtr, buf, AIO_BUF_LEN - 1);
 446         }
 447         else {
 448             len = strlen(buf);
 449
 450             if (len && (buf[len - 1] == '\n')) {
 451                 /* strip "\n" */
 452                 len--;
 453             }
 454
 455             Jim_AppendString(interp, objPtr, buf, len);
 456             break;
 457         }
 458     }
 459     if (JimCheckStreamError(interp, af)) {
 460         /* I/O error */
 461         Jim_FreeNewObj(interp, objPtr);
 462         return JIM_ERR;
 463     }
 464
 465     if (argc) {
 466         if (Jim_SetVariable(interp, argv[0], objPtr) != JIM_OK) {
 467             Jim_FreeNewObj(interp, objPtr);
 468             return JIM_ERR;
 469         }
 470
 471         len = Jim_Length(objPtr);
 472
 473         if (len == 0 && feof(af->fp)) {
 474             /* On EOF returns -1 if varName was specified */
 475             len = -1;
 476         }
 477         Jim_SetResultInt(interp, len);
 478     }
 479     else {
 480         Jim_SetResult(interp, objPtr);
 481     }
 482     return JIM_OK;
 483 }
 484
 485 static int aio_cmd_puts(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 486 {
 487     AioFile *af = Jim_CmdPrivData(interp);
 488     int wlen;
 489     const char *wdata;
 490     Jim_Obj *strObj;
 491
 492     if (argc == 2) {
 493         if (!Jim_CompareStringImmediate(interp, argv[0], "-nonewline")) {
 494             return -1;
 495         }
 496         strObj = argv[1];
 497     }
 498     else {
 499         strObj = argv[0];
 500     }
 501
 502     wdata = Jim_GetString(strObj, &wlen);
 503     if (fwrite(wdata, 1, wlen, af->fp) == (unsigned)wlen) {
 504         if (argc == 2 || putc('\n', af->fp) != EOF) {
 505             return JIM_OK;
 506         }
 507     }
 508     JimAioSetError(interp, af->filename);
 509     return JIM_ERR;
 510 }
 511
 512 static int aio_cmd_isatty(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 513 {
 514 #ifdef HAVE_ISATTY
 515     AioFile *af = Jim_CmdPrivData(interp);
 516     Jim_SetResultInt(interp, isatty(fileno(af->fp)));
 517 #else
 518     Jim_SetResultInt(interp, 0);
 519 #endif
 520
 521     return JIM_OK;
 522 }
 523
 524 #if !defined(JIM_ANSIC) && !defined(JIM_BOOTSTRAP)
 525 static int aio_cmd_recvfrom(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 526 {
 527     AioFile *af = Jim_CmdPrivData(interp);
 528     char *buf;
 529     union sockaddr_any sa;
 530     long len;
 531     socklen_t salen = sizeof(sa);
 532     int rlen;
 533
 534     if (Jim_GetLong(interp, argv[0], &len) != JIM_OK) {
 535         return JIM_ERR;
 536     }
 537
 538     buf = Jim_Alloc(len + 1);
 539
 540     rlen = recvfrom(fileno(af->fp), buf, len, 0, &sa.sa, &salen);
 541     if (rlen < 0) {
 542         Jim_Free(buf);
 543         JimAioSetError(interp, NULL);
 544         return JIM_ERR;
 545     }
 546     buf[rlen] = 0;
 547     Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, buf, rlen));
 548
 549     if (argc > 1) {
 550         /* INET6_ADDRSTRLEN is 46. Add some for [] and port */
 551         char addrbuf[60];
 552
 553 #if IPV6
 554         if (sa.sa.sa_family == PF_INET6) {
 555             addrbuf[0] = '[';
 556             /* Allow 9 for []:65535\0 */
 557             inet_ntop(sa.sa.sa_family, &sa.sin6.sin6_addr, addrbuf + 1, sizeof(addrbuf) - 9);
 558             snprintf(addrbuf + strlen(addrbuf), 8, "]:%d", ntohs(sa.sin.sin_port));
 559         }
 560         else
 561 #endif
 562         if (sa.sa.sa_family == PF_INET) {
 563             /* Allow 7 for :65535\0 */
 564             inet_ntop(sa.sa.sa_family, &sa.sin.sin_addr, addrbuf, sizeof(addrbuf) - 7);
 565             snprintf(addrbuf + strlen(addrbuf), 7, ":%d", ntohs(sa.sin.sin_port));
 566         }
 567         else {
 568             /* recvfrom still works on unix domain sockets, etc */
 569             addrbuf[0] = 0;
 570         }
 571
 572         if (Jim_SetVariable(interp, argv[1], Jim_NewStringObj(interp, addrbuf, -1)) != JIM_OK) {
 573             return JIM_ERR;
 574         }
 575     }
 576
 577     return JIM_OK;
 578 }
 579
 580
 581 static int aio_cmd_sendto(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 582 {
 583     AioFile *af = Jim_CmdPrivData(interp);
 584     int wlen;
 585     int len;
 586     const char *wdata;
 587     union sockaddr_any sa;
 588     const char *addr = Jim_String(argv[1]);
 589     int salen;
 590
 591     if (IPV6 && af->addr_family == PF_INET6) {
 592         if (JimParseIPv6Address(interp, addr, &sa, &salen) != JIM_OK) {
 593             return JIM_ERR;
 594         }
 595     }
 596     else if (JimParseIpAddress(interp, addr, &sa, &salen) != JIM_OK) {
 597         return JIM_ERR;
 598     }
 599     wdata = Jim_GetString(argv[0], &wlen);
 600
 601     /* Note that we don't validate the socket type. Rely on sendto() failing if appropriate */
 602     len = sendto(fileno(af->fp), wdata, wlen, 0, &sa.sa, salen);
 603     if (len < 0) {
 604         JimAioSetError(interp, NULL);
 605         return JIM_ERR;
 606     }
 607     Jim_SetResultInt(interp, len);
 608     return JIM_OK;
 609 }
 610
 611 static int aio_cmd_accept(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 612 {
 613     AioFile *af = Jim_CmdPrivData(interp);
 614     int sock;
 615     union sockaddr_any sa;
 616     socklen_t addrlen = sizeof(sa);
 617
 618     sock = accept(af->fd, &sa.sa, &addrlen);
 619     if (sock < 0) {
 620         JimAioSetError(interp, NULL);
 621         return JIM_ERR;
 622     }
 623
 624     /* Create the file command */
 625     return JimMakeChannel(interp, NULL, sock, Jim_NewStringObj(interp, "accept", -1),
 626         "aio.sockstream%ld", af->addr_family, "r+");
 627 }
 628
 629 static int aio_cmd_listen(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 630 {
 631     AioFile *af = Jim_CmdPrivData(interp);
 632     long backlog;
 633
 634     if (Jim_GetLong(interp, argv[0], &backlog) != JIM_OK) {
 635         return JIM_ERR;
 636     }
 637
 638     if (listen(af->fd, backlog)) {
 639         JimAioSetError(interp, NULL);
 640         return JIM_ERR;
 641     }
 642
 643     return JIM_OK;
 644 }
 645 #endif /* JIM_BOOTSTRAP */
 646
 647 static int aio_cmd_flush(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 648 {
 649     AioFile *af = Jim_CmdPrivData(interp);
 650
 651     if (fflush(af->fp) == EOF) {
 652         JimAioSetError(interp, af->filename);
 653         return JIM_ERR;
 654     }
 655     return JIM_OK;
 656 }
 657
 658 static int aio_cmd_eof(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 659 {
 660     AioFile *af = Jim_CmdPrivData(interp);
 661
 662     Jim_SetResultInt(interp, feof(af->fp));
 663     return JIM_OK;
 664 }
 665
 666 static int aio_cmd_close(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 667 {
 668     if (argc == 3) {
 669 #if !defined(JIM_ANSIC) && defined(HAVE_SHUTDOWN)
 670         static const char * const options[] = { "r", "w", NULL };
 671         enum { OPT_R, OPT_W, };
 672         int option;
 673         AioFile *af = Jim_CmdPrivData(interp);
 674
 675         if (Jim_GetEnum(interp, argv[2], options, &option, NULL, JIM_ERRMSG) != JIM_OK) {
 676             return JIM_ERR;
 677         }
 678         if (shutdown(af->fd, option == OPT_R ? SHUT_RD : SHUT_WR) == 0) {
 679             return JIM_OK;
 680         }
 681         JimAioSetError(interp, NULL);
 682 #else
 683         Jim_SetResultString(interp, "async close not supported", -1);
 684 #endif
 685         return JIM_ERR;
 686     }
 687
 688     return Jim_DeleteCommand(interp, Jim_String(argv[0]));
 689 }
 690
 691 static int aio_cmd_seek(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 692 {
 693     AioFile *af = Jim_CmdPrivData(interp);
 694     int orig = SEEK_SET;
 695     jim_wide offset;
 696
 697     if (argc == 2) {
 698         if (Jim_CompareStringImmediate(interp, argv[1], "start"))
 699             orig = SEEK_SET;
 700         else if (Jim_CompareStringImmediate(interp, argv[1], "current"))
 701             orig = SEEK_CUR;
 702         else if (Jim_CompareStringImmediate(interp, argv[1], "end"))
 703             orig = SEEK_END;
 704         else {
 705             return -1;
 706         }
 707     }
 708     if (Jim_GetWide(interp, argv[0], &offset) != JIM_OK) {
 709         return JIM_ERR;
 710     }
 711     if (fseeko(af->fp, offset, orig) == -1) {
 712         JimAioSetError(interp, af->filename);
 713         return JIM_ERR;
 714     }
 715     return JIM_OK;
 716 }
 717
 718 static int aio_cmd_tell(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 719 {
 720     AioFile *af = Jim_CmdPrivData(interp);
 721
 722     Jim_SetResultInt(interp, ftello(af->fp));
 723     return JIM_OK;
 724 }
 725
 726 static int aio_cmd_filename(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 727 {
 728     AioFile *af = Jim_CmdPrivData(interp);
 729
 730     Jim_SetResult(interp, af->filename);
 731     return JIM_OK;
 732 }
 733
 734 #ifdef O_NDELAY
 735 static int aio_cmd_ndelay(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 736 {
 737     AioFile *af = Jim_CmdPrivData(interp);
 738
 739     int fmode = fcntl(af->fd, F_GETFL);
 740
 741     if (argc) {
 742         long nb;
 743
 744         if (Jim_GetLong(interp, argv[0], &nb) != JIM_OK) {
 745             return JIM_ERR;
 746         }
 747         if (nb) {
 748             fmode |= O_NDELAY;
 749         }
 750         else {
 751             fmode &= ~O_NDELAY;
 752         }
 753         fcntl(af->fd, F_SETFL, fmode);
 754     }
 755     Jim_SetResultInt(interp, (fmode & O_NONBLOCK) ? 1 : 0);
 756     return JIM_OK;
 757 }
 758 #endif
 759
 760 static int aio_cmd_buffering(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 761 {
 762     AioFile *af = Jim_CmdPrivData(interp);
 763
 764     static const char * const options[] = {
 765         "none",
 766         "line",
 767         "full",
 768         NULL
 769     };
 770     enum
 771     {
 772         OPT_NONE,
 773         OPT_LINE,
 774         OPT_FULL,
 775     };
 776     int option;
 777
 778     if (Jim_GetEnum(interp, argv[0], options, &option, NULL, JIM_ERRMSG) != JIM_OK) {
 779         return JIM_ERR;
 780     }
 781     switch (option) {
 782         case OPT_NONE:
 783             setvbuf(af->fp, NULL, _IONBF, 0);
 784             break;
 785         case OPT_LINE:
 786             setvbuf(af->fp, NULL, _IOLBF, BUFSIZ);
 787             break;
 788         case OPT_FULL:
 789             setvbuf(af->fp, NULL, _IOFBF, BUFSIZ);
 790             break;
 791     }
 792     return JIM_OK;
 793 }
 794
 795 #ifdef jim_ext_eventloop
 796 static void JimAioFileEventFinalizer(Jim_Interp *interp, void *clientData)
 797 {
 798     Jim_Obj **objPtrPtr = clientData;
 799
 800     Jim_DecrRefCount(interp, *objPtrPtr);
 801     *objPtrPtr = NULL;
 802 }
 803
 804 static int JimAioFileEventHandler(Jim_Interp *interp, void *clientData, int mask)
 805 {
 806     Jim_Obj **objPtrPtr = clientData;
 807
 808     return Jim_EvalObjBackground(interp, *objPtrPtr);
 809 }
 810
 811 static int aio_eventinfo(Jim_Interp *interp, AioFile * af, unsigned mask, Jim_Obj **scriptHandlerObj,
 812     int argc, Jim_Obj * const *argv)
 813 {
 814     if (argc == 0) {
 815         /* Return current script */
 816         if (*scriptHandlerObj) {
 817             Jim_SetResult(interp, *scriptHandlerObj);
 818         }
 819         return JIM_OK;
 820     }
 821
 822     if (*scriptHandlerObj) {
 823         /* Delete old handler */
 824         Jim_DeleteFileHandler(interp, af->fp, mask);
 825     }
 826
 827     /* Now possibly add the new script(s) */
 828     if (Jim_Length(argv[0]) == 0) {
 829         /* Empty script, so done */
 830         return JIM_OK;
 831     }
 832
 833     /* A new script to add */
 834     Jim_IncrRefCount(argv[0]);
 835     *scriptHandlerObj = argv[0];
 836
 837     Jim_CreateFileHandler(interp, af->fp, mask,
 838         JimAioFileEventHandler, scriptHandlerObj, JimAioFileEventFinalizer);
 839
 840     return JIM_OK;
 841 }
 842
 843 static int aio_cmd_readable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 844 {
 845     AioFile *af = Jim_CmdPrivData(interp);
 846
 847     return aio_eventinfo(interp, af, JIM_EVENT_READABLE, &af->rEvent, argc, argv);
 848 }
 849
 850 static int aio_cmd_writable(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 851 {
 852     AioFile *af = Jim_CmdPrivData(interp);
 853
 854     return aio_eventinfo(interp, af, JIM_EVENT_WRITABLE, &af->wEvent, argc, argv);
 855 }
 856
 857 static int aio_cmd_onexception(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 858 {
 859     AioFile *af = Jim_CmdPrivData(interp);
 860
 861     return aio_eventinfo(interp, af, JIM_EVENT_EXCEPTION, &af->wEvent, argc, argv);
 862 }
 863 #endif
 864
 865 static const jim_subcmd_type aio_command_table[] = {
 866     {   "read",
 867         "?-nonewline? ?len?",
 868         aio_cmd_read,
 869         0,
 870         2,
 871         /* Description: Read and return bytes from the stream. To eof if no len. */
 872     },
 873     {   "copyto",
 874         "handle ?size?",
 875         aio_cmd_copy,
 876         1,
 877         2,
 878         /* Description: Copy up to 'size' bytes to the given filehandle, or to eof if no size. */
 879     },
 880     {   "gets",
 881         "?var?",
 882         aio_cmd_gets,
 883         0,
 884         1,
 885         /* Description: Read one line and return it or store it in the var */
 886     },
 887     {   "puts",
 888         "?-nonewline? str",
 889         aio_cmd_puts,
 890         1,
 891         2,
 892         /* Description: Write the string, with newline unless -nonewline */
 893     },
 894     {   "isatty",
 895         NULL,
 896         aio_cmd_isatty,
 897         0,
 898         0,
 899         /* Description: Is the file descriptor a tty? */
 900     },
 901 #if !defined(JIM_ANSIC) && !defined(JIM_BOOTSTRAP)
 902     {   "recvfrom",
 903         "len ?addrvar?",
 904         aio_cmd_recvfrom,
 905         1,
 906         2,
 907         /* Description: Receive up to 'len' bytes on the socket. Sets 'addrvar' with receive address, if set */
 908     },
 909     {   "sendto",
 910         "str address",
 911         aio_cmd_sendto,
 912         2,
 913         2,
 914         /* Description: Send 'str' to the given address (dgram only) */
 915     },
 916     {   "accept",
 917         NULL,
 918         aio_cmd_accept,
 919         0,
 920         0,
 921         /* Description: Server socket only: Accept a connection and return stream */
 922     },
 923     {   "listen",
 924         "backlog",
 925         aio_cmd_listen,
 926         1,
 927         1,
 928         /* Description: Set the listen backlog for server socket */
 929     },
 930 #endif /* JIM_BOOTSTRAP */
 931     {   "flush",
 932         NULL,
 933         aio_cmd_flush,
 934         0,
 935         0,
 936         /* Description: Flush the stream */
 937     },
 938     {   "eof",
 939         NULL,
 940         aio_cmd_eof,
 941         0,
 942         0,
 943         /* Description: Returns 1 if stream is at eof */
 944     },
 945     {   "close",
 946         "?r(ead)|w(rite)?",
 947         aio_cmd_close,
 948         0,
 949         1,
 950         JIM_MODFLAG_FULLARGV,
 951         /* Description: Closes the stream. */
 952     },
 953     {   "seek",
 954         "offset ?start|current|end",
 955         aio_cmd_seek,
 956         1,
 957         2,
 958         /* Description: Seeks in the stream (default 'current') */
 959     },
 960     {   "tell",
 961         NULL,
 962         aio_cmd_tell,
 963         0,
 964         0,
 965         /* Description: Returns the current seek position */
 966     },
 967     {   "filename",
 968         NULL,
 969         aio_cmd_filename,
 970         0,
 971         0,
 972         /* Description: Returns the original filename */
 973     },
 974 #ifdef O_NDELAY
 975     {   "ndelay",
 976         "?0|1?",
 977         aio_cmd_ndelay,
 978         0,
 979         1,
 980         /* Description: Set O_NDELAY (if arg). Returns current/new setting. */
 981     },
 982 #endif
 983     {   "buffering",
 984         "none|line|full",
 985         aio_cmd_buffering,
 986         1,
 987         1,
 988         /* Description: Sets buffering */
 989     },
 990 #ifdef jim_ext_eventloop
 991     {   "readable",
 992         "?readable-script?",
 993         aio_cmd_readable,
 994         0,
 995         1,
 996         /* Description: Returns script, or invoke readable-script when readable, {} to remove */
 997     },
 998     {   "writable",
 999         "?writable-script?",
1000         aio_cmd_writable,
1001         0,
1002         1,
1003         /* Description: Returns script, or invoke writable-script when writable, {} to remove */
1004     },
1005     {   "onexception",
1006         "?exception-script?",
1007         aio_cmd_onexception,
1008         0,
1009         1,
1010         /* Description: Returns script, or invoke exception-script when oob data, {} to remove */
1011     },
1012 #endif
1013     { NULL }
1014 };
1015
1016 static int JimAioSubCmdProc(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1017 {
1018     return Jim_CallSubCmd(interp, Jim_ParseSubCmd(interp, aio_command_table, argc, argv), argc, argv);
1019 }
1020
1021 static int JimAioOpenCommand(Jim_Interp *interp, int argc,
1022         Jim_Obj *const *argv)
1023 {
1024     const char *mode;
1025
1026     if (argc != 2 && argc != 3)
1027         Jim_WrongNumArgs(interp, 1, argv, "filename ?mode?");
1028
1029     mode = (argc == 3) ? Jim_String(argv[2]) : "r";
1030
1031 #ifdef jim_ext_tclcompat
1032     {
1033         const char *filename = Jim_String(argv[1]);
1034
1035         /* If the filename starts with '|', use popen instead */
1036         if (*filename == '|') {
1037             Jim_Obj *evalObj[3];
1038
1039             evalObj[0] = Jim_NewStringObj(interp, "::popen", -1);
1040             evalObj[1] = Jim_NewStringObj(interp, filename + 1, -1);
1041             evalObj[2] = Jim_NewStringObj(interp, mode, -1);
1042
1043             return Jim_EvalObjVector(interp, 3, evalObj);
1044         }
1045     }
1046 #endif
1047     return JimMakeChannel(interp, NULL, -1, argv[1], "aio.handle%ld", 0, mode);
1048 }
1049
1050 /**
1051  * Creates a channel for fh/fd/filename.
1052  *
1053  * If fh is not NULL, uses that as the channel (and sets AIO_KEEPOPEN).
1054  * Otherwise, if fd is >= 0, uses that as the channel.
1055  * Otherwise opens 'filename' with mode 'mode'.
1056  *
1057  * hdlfmt is a sprintf format for the filehandle. Anything with %ld at the end will do.
1058  * mode is used for open or fdopen.
1059  *
1060  * Creates the command and sets the name as the current result.
1061  */
1062 static int JimMakeChannel(Jim_Interp *interp, FILE *fh, int fd, Jim_Obj *filename,
1063     const char *hdlfmt, int family, const char *mode)
1064 {
1065     AioFile *af;
1066     char buf[AIO_CMD_LEN];
1067     int openFlags = 0;
1068
1069     if (fh) {
1070         filename = Jim_NewStringObj(interp, hdlfmt, -1);
1071         openFlags = AIO_KEEPOPEN;
1072     }
1073
1074     Jim_IncrRefCount(filename);
1075
1076     if (fh == NULL) {
1077 #if !defined(JIM_ANSIC)
1078         if (fd >= 0) {
1079             fh = fdopen(fd, mode);
1080         }
1081         else
1082 #endif
1083             fh = fopen(Jim_String(filename), mode);
1084
1085         if (fh == NULL) {
1086             JimAioSetError(interp, filename);
1087 #if !defined(JIM_ANSIC)
1088             if (fd >= 0) {
1089                 close(fd);
1090             }
1091 #endif
1092             Jim_DecrRefCount(interp, filename);
1093             return JIM_ERR;
1094         }
1095     }
1096
1097     /* Create the file command */
1098     af = Jim_Alloc(sizeof(*af));
1099     memset(af, 0, sizeof(*af));
1100     af->fp = fh;
1101     af->fd = fileno(fh);
1102     af->filename = filename;
1103 #ifdef FD_CLOEXEC
1104     if ((openFlags & AIO_KEEPOPEN) == 0) {
1105         fcntl(af->fd, F_SETFD, FD_CLOEXEC);
1106     }
1107 #endif
1108     af->openFlags = openFlags;
1109     af->addr_family = family;
1110     snprintf(buf, sizeof(buf), hdlfmt, Jim_GetId(interp));
1111     Jim_CreateCommand(interp, buf, JimAioSubCmdProc, af, JimAioDelProc);
1112
1113     /* Note that the command must use the global namespace, even if
1114      * the current namespace is something different
1115      */
1116     Jim_SetResult(interp, Jim_MakeGlobalNamespaceName(interp, Jim_NewStringObj(interp, buf, -1)));
1117
1118     return JIM_OK;
1119 }
1120
1121 static int JimMakeChannelPair(Jim_Interp *interp, int p[2], Jim_Obj *filename,
1122     const char *hdlfmt, int family, const char *mode[2])
1123 {
1124     if (JimMakeChannel(interp, NULL, p[0], filename, hdlfmt, family, mode[0]) == JIM_OK) {
1125         Jim_Obj *objPtr = Jim_NewListObj(interp, NULL, 0);
1126         Jim_ListAppendElement(interp, objPtr, Jim_GetResult(interp));
1127
1128         if (JimMakeChannel(interp, NULL, p[1], filename, hdlfmt, family, mode[1]) == JIM_OK) {
1129             Jim_ListAppendElement(interp, objPtr, Jim_GetResult(interp));
1130             Jim_SetResult(interp, objPtr);
1131             return JIM_OK;
1132         }
1133     }
1134
1135     /* Can only be here if fdopen() failed */
1136     close(p[0]);
1137     close(p[1]);
1138     JimAioSetError(interp, NULL);
1139     return JIM_ERR;
1140 }
1141
1142 #if !defined(JIM_ANSIC) && !defined(JIM_BOOTSTRAP)
1143
1144 static int JimAioSockCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
1145 {
1146     const char *hdlfmt = "aio.unknown%ld";
1147     const char *socktypes[] = {
1148         "unix",
1149         "unix.server",
1150         "dgram",
1151         "dgram.server",
1152         "stream",
1153         "stream.server",
1154         "pipe",
1155         "pair",
1156         NULL
1157     };
1158     enum
1159     {
1160         SOCK_UNIX,
1161         SOCK_UNIX_SERVER,
1162         SOCK_DGRAM_CLIENT,
1163         SOCK_DGRAM_SERVER,
1164         SOCK_STREAM_CLIENT,
1165         SOCK_STREAM_SERVER,
1166         SOCK_STREAM_PIPE,
1167         SOCK_STREAM_SOCKETPAIR,
1168     };
1169     int socktype;
1170     int sock;
1171     const char *hostportarg = NULL;
1172     int res;
1173     int on = 1;
1174     const char *mode = "r+";
1175     int family = PF_INET;
1176     Jim_Obj *argv0 = argv[0];
1177     int ipv6 = 0;
1178
1179     if (argc > 1 && Jim_CompareStringImmediate(interp, argv[1], "-ipv6")) {
1180         if (!IPV6) {
1181             Jim_SetResultString(interp, "ipv6 not supported", -1);
1182             return JIM_ERR;
1183         }
1184         ipv6 = 1;
1185         family = PF_INET6;
1186     }
1187     argc -= ipv6;
1188     argv += ipv6;
1189
1190     if (argc < 2) {
1191       wrongargs:
1192         Jim_WrongNumArgs(interp, 1, &argv0, "?-ipv6? type ?address?");
1193         return JIM_ERR;
1194     }
1195
1196     if (Jim_GetEnum(interp, argv[1], socktypes, &socktype, "socket type", JIM_ERRMSG) != JIM_OK)
1197         return JIM_ERR;
1198
1199     Jim_SetEmptyResult(interp);
1200
1201     hdlfmt = "aio.sock%ld";
1202
1203     if (argc > 2) {
1204         hostportarg = Jim_String(argv[2]);
1205     }
1206
1207     switch (socktype) {
1208         case SOCK_DGRAM_CLIENT:
1209             if (argc == 2) {
1210                 /* No address, so an unconnected dgram socket */
1211                 sock = socket(family, SOCK_DGRAM, 0);
1212                 if (sock < 0) {
1213                     JimAioSetError(interp, NULL);
1214                     return JIM_ERR;
1215                 }
1216                 break;
1217             }
1218             /* fall through */
1219         case SOCK_STREAM_CLIENT:
1220             {
1221                 union sockaddr_any sa;
1222                 int salen;
1223
1224                 if (argc != 3) {
1225                     goto wrongargs;
1226                 }
1227
1228                 if (ipv6) {
1229                     if (JimParseIPv6Address(interp, hostportarg, &sa, &salen) != JIM_OK) {
1230                         return JIM_ERR;
1231                     }
1232                 }
1233                 else if (JimParseIpAddress(interp, hostportarg, &sa, &salen) != JIM_OK) {
1234                     return JIM_ERR;
1235                 }
1236                 sock = socket(family, (socktype == SOCK_DGRAM_CLIENT) ? SOCK_DGRAM : SOCK_STREAM, 0);
1237                 if (sock < 0) {
1238                     JimAioSetError(interp, NULL);
1239                     return JIM_ERR;
1240                 }
1241                 res = connect(sock, &sa.sa, salen);
1242                 if (res) {
1243                     JimAioSetError(interp, argv[2]);
1244                     close(sock);
1245                     return JIM_ERR;
1246                 }
1247             }
1248             break;
1249
1250         case SOCK_STREAM_SERVER:
1251         case SOCK_DGRAM_SERVER:
1252             {
1253                 union sockaddr_any sa;
1254                 int salen;
1255
1256                 if (argc != 3) {
1257                     goto wrongargs;
1258                 }
1259
1260                 if (ipv6) {
1261                     if (JimParseIPv6Address(interp, hostportarg, &sa, &salen) != JIM_OK) {
1262                         return JIM_ERR;
1263                     }
1264                 }
1265                 else if (JimParseIpAddress(interp, hostportarg, &sa, &salen) != JIM_OK) {
1266                     return JIM_ERR;
1267                 }
1268                 sock = socket(family, (socktype == SOCK_DGRAM_SERVER) ? SOCK_DGRAM : SOCK_STREAM, 0);
1269                 if (sock < 0) {
1270                     JimAioSetError(interp, NULL);
1271                     return JIM_ERR;
1272                 }
1273
1274                 /* Enable address reuse */
1275                 setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&on, sizeof(on));
1276
1277                 res = bind(sock, &sa.sa, salen);
1278                 if (res) {
1279                     JimAioSetError(interp, argv[2]);
1280                     close(sock);
1281                     return JIM_ERR;
1282                 }
1283                 if (socktype == SOCK_STREAM_SERVER) {
1284                     res = listen(sock, 5);
1285                     if (res) {
1286                         JimAioSetError(interp, NULL);
1287                         close(sock);
1288                         return JIM_ERR;
1289                     }
1290                 }
1291                 hdlfmt = "aio.socksrv%ld";
1292             }
1293             break;
1294
1295 #ifdef HAVE_SYS_UN_H
1296         case SOCK_UNIX:
1297             {
1298                 struct sockaddr_un sa;
1299                 socklen_t len;
1300
1301                 if (argc != 3 || ipv6) {
1302                     goto wrongargs;
1303                 }
1304
1305                 if (JimParseDomainAddress(interp, hostportarg, &sa) != JIM_OK) {
1306                     JimAioSetError(interp, argv[2]);
1307                     return JIM_ERR;
1308                 }
1309                 family = PF_UNIX;
1310                 sock = socket(PF_UNIX, SOCK_STREAM, 0);
1311                 if (sock < 0) {
1312                     JimAioSetError(interp, NULL);
1313                     return JIM_ERR;
1314                 }
1315                 len = strlen(sa.sun_path) + 1 + sizeof(sa.sun_family);
1316                 res = connect(sock, (struct sockaddr *)&sa, len);
1317                 if (res) {
1318                     JimAioSetError(interp, argv[2]);
1319                     close(sock);
1320                     return JIM_ERR;
1321                 }
1322                 hdlfmt = "aio.sockunix%ld";
1323                 break;
1324             }
1325
1326         case SOCK_UNIX_SERVER:
1327             {
1328                 struct sockaddr_un sa;
1329                 socklen_t len;
1330
1331                 if (argc != 3 || ipv6) {
1332                     goto wrongargs;
1333                 }
1334
1335                 if (JimParseDomainAddress(interp, hostportarg, &sa) != JIM_OK) {
1336                     JimAioSetError(interp, argv[2]);
1337                     return JIM_ERR;
1338                 }
1339                 family = PF_UNIX;
1340                 sock = socket(PF_UNIX, SOCK_STREAM, 0);
1341                 if (sock < 0) {
1342                     JimAioSetError(interp, NULL);
1343                     return JIM_ERR;
1344                 }
1345                 len = strlen(sa.sun_path) + 1 + sizeof(sa.sun_family);
1346                 res = bind(sock, (struct sockaddr *)&sa, len);
1347                 if (res) {
1348                     JimAioSetError(interp, argv[2]);
1349                     close(sock);
1350                     return JIM_ERR;
1351                 }
1352                 res = listen(sock, 5);
1353                 if (res) {
1354                     JimAioSetError(interp, NULL);
1355                     close(sock);
1356                     return JIM_ERR;
1357                 }
1358                 hdlfmt = "aio.sockunixsrv%ld";
1359                 break;
1360             }
1361 #endif
1362
1363 #if defined(HAVE_SOCKETPAIR) && defined(HAVE_SYS_UN_H)
1364         case SOCK_STREAM_SOCKETPAIR:
1365             {
1366                 int p[2];
1367                 static const char *mode[2] = { "r+", "r+" };
1368
1369                 if (argc != 2 || ipv6) {
1370                     goto wrongargs;
1371                 }
1372
1373                 if (socketpair(PF_UNIX, SOCK_STREAM, 0, p) < 0) {
1374                     JimAioSetError(interp, NULL);
1375                     return JIM_ERR;
1376                 }
1377                 return JimMakeChannelPair(interp, p, argv[1], "aio.sockpair%ld", PF_UNIX, mode);
1378             }
1379             break;
1380 #endif
1381
1382 #if defined(HAVE_PIPE)
1383         case SOCK_STREAM_PIPE:
1384             {
1385                 int p[2];
1386                 static const char *mode[2] = { "r", "w" };
1387
1388                 if (argc != 2 || ipv6) {
1389                     goto wrongargs;
1390                 }
1391
1392                 if (pipe(p) < 0) {
1393                     JimAioSetError(interp, NULL);
1394                     return JIM_ERR;
1395                 }
1396
1397                 return JimMakeChannelPair(interp, p, argv[1], "aio.pipe%ld", 0, mode);
1398             }
1399             break;
1400 #endif
1401
1402         default:
1403             Jim_SetResultString(interp, "Unsupported socket type", -1);
1404             return JIM_ERR;
1405     }
1406
1407     return JimMakeChannel(interp, NULL, sock, argv[1], hdlfmt, family, mode);
1408 }
1409 #endif /* JIM_BOOTSTRAP */
1410
1411 FILE *Jim_AioFilehandle(Jim_Interp *interp, Jim_Obj *command)
1412 {
1413     Jim_Cmd *cmdPtr = Jim_GetCommand(interp, command, JIM_ERRMSG);
1414
1415     /* XXX: There ought to be a supported API for this */
1416     if (cmdPtr && !cmdPtr->isproc && cmdPtr->u.native.cmdProc == JimAioSubCmdProc) {
1417         return ((AioFile *) cmdPtr->u.native.privData)->fp;
1418     }
1419     Jim_SetResultFormatted(interp, "Not a filehandle: \"%#s\"", command);
1420     return NULL;
1421 }
1422
1423 int Jim_aioInit(Jim_Interp *interp)
1424 {
1425     if (Jim_PackageProvide(interp, "aio", "1.0", JIM_ERRMSG))
1426         return JIM_ERR;
1427
1428     Jim_CreateCommand(interp, "open", JimAioOpenCommand, NULL, NULL);
1429 #ifndef JIM_ANSIC
1430     Jim_CreateCommand(interp, "socket", JimAioSockCommand, NULL, NULL);
1431 #endif
1432
1433     /* Create filehandles for stdin, stdout and stderr */
1434     JimMakeChannel(interp, stdin, -1, NULL, "stdin", 0, "r");
1435     JimMakeChannel(interp, stdout, -1, NULL, "stdout", 0, "w");
1436     JimMakeChannel(interp, stderr, -1, NULL, "stderr", 0, "w");
1437
1438     return JIM_OK;
1439 }