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