jim-aio.c

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