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