static int aio_cmd_sendto(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
int wlen;
int len;
const char *wdata;
union sockaddr_any sa;
const char *addr = Jim_String(argv[1]);
int salen;
if (IPV6 && af->addr_family == PF_INET6) {
if (JimParseIPv6Address(interp, addr, &sa, &salen) != JIM_OK) {
return JIM_ERR;
}
}
else if (JimParseIpAddress(interp, addr, &sa, &salen) != JIM_OK) {
return JIM_ERR;
}
wdata = Jim_GetString(argv[0], &wlen);
/* Note that we don't validate the socket type. Rely on sendto() failing if appropriate */
len = sendto(fileno(af->fp), wdata, wlen, 0, &sa.sa, salen);
if (len < 0) {
JimAioSetError(interp, NULL);
return JIM_ERR;
}
Jim_SetResultInt(interp, len);
return JIM_OK;
}
static int aio_cmd_buffering(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
static const char * const options[] = {
"none",
"line",
"full",
NULL
};
enum
{
OPT_NONE,
OPT_LINE,
OPT_FULL,
};
int option;
if (Jim_GetEnum(interp, argv[0], options, &option, NULL, JIM_ERRMSG) != JIM_OK) {
return JIM_ERR;
}
switch (option) {
case OPT_NONE:
setvbuf(af->fp, NULL, _IONBF, 0);
break;
case OPT_LINE:
setvbuf(af->fp, NULL, _IOLBF, BUFSIZ);
break;
case OPT_FULL:
setvbuf(af->fp, NULL, _IOFBF, BUFSIZ);
break;
}
return JIM_OK;
}
static int aio_cmd_tell(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
Jim_SetResultInt(interp, ftell(af->fp));
return JIM_OK;
}
static int aio_cmd_seek(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
int orig = SEEK_SET;
long offset;
if (argc == 2) {
if (Jim_CompareStringImmediate(interp, argv[1], "start"))
orig = SEEK_SET;
else if (Jim_CompareStringImmediate(interp, argv[1], "current"))
orig = SEEK_CUR;
else if (Jim_CompareStringImmediate(interp, argv[1], "end"))
orig = SEEK_END;
else {
return -1;
}
}
if (Jim_GetLong(interp, argv[0], &offset) != JIM_OK) {
return JIM_ERR;
}
if (fseek(af->fp, offset, orig) == -1) {
JimAioSetError(interp, af->filename);
return JIM_ERR;
}
return JIM_OK;
}
static int aio_cmd_filename(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
Jim_SetResult(interp, af->filename);
return JIM_OK;
}
static int aio_cmd_puts(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
int wlen;
const char *wdata;
Jim_Obj *strObj;
if (argc == 2) {
if (!Jim_CompareStringImmediate(interp, argv[0], "-nonewline")) {
return -1;
}
strObj = argv[1];
}
else {
strObj = argv[0];
}
wdata = Jim_GetString(strObj, &wlen);
if (fwrite(wdata, 1, wlen, af->fp) == (unsigned)wlen) {
if (argc == 2 || putc('\n', af->fp) != EOF) {
return JIM_OK;
}
}
JimAioSetError(interp, af->filename);
return JIM_ERR;
}
static int JimCleanupChildren(Jim_Interp *interp, int numPids, pidtype *pidPtr, fdtype errorId)
{
struct WaitInfoTable *table = Jim_CmdPrivData(interp);
int result = JIM_OK;
int i;
for (i = 0; i < numPids; i++) {
int waitStatus = 0;
if (JimWaitForProcess(table, pidPtr[i], &waitStatus) != JIM_BAD_PID) {
if (JimCheckWaitStatus(interp, pidPtr[i], waitStatus) != JIM_OK) {
result = JIM_ERR;
}
}
}
Jim_Free(pidPtr);
/*
* Read the standard error file. If there's anything there,
* then add the file's contents to the result
* string.
*/
if (errorId != JIM_BAD_FD) {
JimRewindFd(errorId);
if (JimAppendStreamToString(interp, errorId, Jim_GetResult(interp)) != JIM_OK) {
result = JIM_ERR;
}
}
JimTrimTrailingNewline(interp);
return result;
}
int Jim_SubCmdProc(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
const jim_subcmd_type *ct =
Jim_ParseSubCmd(interp, (const jim_subcmd_type *)Jim_CmdPrivData(interp), argc, argv);
return Jim_CallSubCmd(interp, ct, argc, argv);
}
static int JimELUpdateCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
Jim_EventLoop *eventLoop = Jim_CmdPrivData(interp);
static const char * const options[] = {
"idletasks", NULL
};
enum { UPDATE_IDLE, UPDATE_NONE };
int option = UPDATE_NONE;
int flags = JIM_TIME_EVENTS;
if (argc == 1) {
flags = JIM_ALL_EVENTS;
}
else if (argc > 2 || Jim_GetEnum(interp, argv[1], options, &option, NULL, JIM_ERRMSG | JIM_ENUM_ABBREV) != JIM_OK) {
Jim_WrongNumArgs(interp, 1, argv, "?idletasks?");
return JIM_ERR;
}
eventLoop->suppress_bgerror = 0;
while (Jim_ProcessEvents(interp, flags | JIM_DONT_WAIT) > 0) {
}
return JIM_OK;
}
static BOOL
Win32_GetLastInputInfo(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
struct lastinputinfo_t {
UINT cbSize;
DWORD dwTime;
} lii;
typedef BOOL (__stdcall *LPFNGETLASTINPUTINFO)(struct lastinputinfo_t *);
LPFNGETLASTINPUTINFO lpfnGetLastInputInfo = NULL;
HMODULE hLib = (HMODULE)Jim_CmdPrivData(interp);
JIM_NOTUSED(objc);
JIM_NOTUSED(objv);
if (hLib != NULL)
lpfnGetLastInputInfo = (LPFNGETLASTINPUTINFO)GetProcAddress(hLib, "GetLastInputInfo");
if (lpfnGetLastInputInfo == NULL) {
Jim_SetResultString(interp, "command not available on this platform", -1);
return JIM_ERR;
}
lii.cbSize = sizeof(lii);
if (!lpfnGetLastInputInfo(&lii)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "GetLastInputInfo", GetLastError()));
return JIM_ERR;
}
Jim_SetResult(interp, Jim_NewIntObj(interp, lii.dwTime));
return JIM_OK;
}
static int aio_cmd_flush(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
if (fflush(af->fp) == EOF) {
JimAioSetError(interp, af->filename);
return JIM_ERR;
}
return JIM_OK;
}
static int aio_cmd_gets(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
char buf[AIO_BUF_LEN];
Jim_Obj *objPtr;
int len;
errno = 0;
objPtr = Jim_NewStringObj(interp, NULL, 0);
while (1) {
buf[AIO_BUF_LEN - 1] = '_';
if (fgets(buf, AIO_BUF_LEN, af->fp) == NULL)
break;
if (buf[AIO_BUF_LEN - 1] == '\0' && buf[AIO_BUF_LEN - 2] != '\n') {
Jim_AppendString(interp, objPtr, buf, AIO_BUF_LEN - 1);
}
else {
len = strlen(buf);
if (len && (buf[len - 1] == '\n')) {
/* strip "\n" */
len--;
}
Jim_AppendString(interp, objPtr, buf, len);
break;
}
}
if (JimCheckStreamError(interp, af)) {
/* I/O error */
Jim_FreeNewObj(interp, objPtr);
return JIM_ERR;
}
if (argc) {
if (Jim_SetVariable(interp, argv[0], objPtr) != JIM_OK) {
Jim_FreeNewObj(interp, objPtr);
return JIM_ERR;
}
len = Jim_Length(objPtr);
if (len == 0 && feof(af->fp)) {
/* On EOF returns -1 if varName was specified */
len = -1;
}
Jim_SetResultInt(interp, len);
}
else {
Jim_SetResult(interp, objPtr);
}
return JIM_OK;
}
static int aio_cmd_recvfrom(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
char *buf;
union sockaddr_any sa;
long len;
socklen_t salen = sizeof(sa);
int rlen;
if (Jim_GetLong(interp, argv[0], &len) != JIM_OK) {
return JIM_ERR;
}
buf = Jim_Alloc(len + 1);
rlen = recvfrom(fileno(af->fp), buf, len, 0, &sa.sa, &salen);
if (rlen < 0) {
Jim_Free(buf);
JimAioSetError(interp, NULL);
return JIM_ERR;
}
buf[rlen] = 0;
Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, buf, rlen));
if (argc > 1) {
/* INET6_ADDRSTRLEN is 46. Add some for [] and port */
char addrbuf[60];
#if IPV6
if (sa.sa.sa_family == PF_INET6) {
addrbuf[0] = '[';
/* Allow 9 for []:65535\0 */
inet_ntop(sa.sa.sa_family, &sa.sin6.sin6_addr, addrbuf + 1, sizeof(addrbuf) - 9);
snprintf(addrbuf + strlen(addrbuf), 8, "]:%d", ntohs(sa.sin.sin_port));
}
else
#endif
{
/* Allow 7 for :65535\0 */
inet_ntop(sa.sa.sa_family, &sa.sin.sin_addr, addrbuf, sizeof(addrbuf) - 7);
snprintf(addrbuf + strlen(addrbuf), 7, ":%d", ntohs(sa.sin.sin_port));
}
if (Jim_SetVariable(interp, argv[1], Jim_NewStringObj(interp, addrbuf, -1)) != JIM_OK) {
return JIM_ERR;
}
}
return JIM_OK;
}
static int interp_cmd_alias(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
Jim_Interp *child = Jim_CmdPrivData(interp);
Jim_Obj *aliasPrefixList;
/* The prefix list will be held inside the child, but it still belongs
* to the parent!
*/
aliasPrefixList = Jim_NewListObj(interp, argv + 1, argc - 1);
Jim_IncrRefCount(aliasPrefixList);
Jim_CreateCommand(child, Jim_String(argv[0]), JimInterpAliasProc, aliasPrefixList, JimInterpDelAlias);
return JIM_OK;
}
static int JimELVwaitCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
Jim_EventLoop *eventLoop = Jim_CmdPrivData(interp);
Jim_Obj *oldValue;
int rc;
if (argc != 2) {
Jim_WrongNumArgs(interp, 1, argv, "name");
return JIM_ERR;
}
oldValue = Jim_GetGlobalVariable(interp, argv[1], JIM_NONE);
if (oldValue) {
Jim_IncrRefCount(oldValue);
}
else {
/* If a result was left, it is an error */
if (Jim_Length(Jim_GetResult(interp))) {
return JIM_ERR;
}
}
eventLoop->suppress_bgerror = 0;
while ((rc = Jim_ProcessEvents(interp, JIM_ALL_EVENTS)) >= 0) {
Jim_Obj *currValue;
currValue = Jim_GetGlobalVariable(interp, argv[1], JIM_NONE);
/* Stop the loop if the vwait-ed variable changed value,
* or if was unset and now is set (or the contrary)
* or if a signal was caught
*/
if ((oldValue && !currValue) ||
(!oldValue && currValue) ||
(oldValue && currValue && !Jim_StringEqObj(oldValue, currValue)) ||
Jim_CheckSignal(interp)) {
break;
}
}
if (oldValue)
Jim_DecrRefCount(interp, oldValue);
if (rc == -2) {
return JIM_ERR;
}
Jim_SetEmptyResult(interp);
return JIM_OK;
}
static int
Win32_GetPerformanceInfo(Jim_Interp *interp, int objc, Jim_Obj *const *objv)
{
Jim_Obj *a[26];
size_t n = 0;
PERFORMANCE_INFORMATION pi;
LPFNGETPERFORMANCEINFO lpfnGetPerformanceInfo = NULL;
HMODULE hLib = (HMODULE)Jim_CmdPrivData(interp);
JIM_NOTUSED(objc);
JIM_NOTUSED(objv);
if (hLib != NULL)
lpfnGetPerformanceInfo = (LPFNGETPERFORMANCEINFO)GetProcAddress(hLib, "GetPerformanceInfo");
if (lpfnGetPerformanceInfo == NULL) {
/* should never happen */
Jim_SetResultString(interp, "argh!", -1);
return JIM_ERR;
}
pi.cb = sizeof(pi);
if (!lpfnGetPerformanceInfo(&pi, sizeof(pi))) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "GetPerformanceInfo", GetLastError()));
return JIM_ERR;
}
#define JIMADD(name) \
a[n++] = Jim_NewStringObj(interp, #name, -1); \
a[n++] = Jim_NewIntObj(interp, pi.name )
JIMADD(CommitTotal);
JIMADD(CommitLimit);
JIMADD(CommitPeak);
JIMADD(PhysicalTotal);
JIMADD(PhysicalAvailable);
JIMADD(SystemCache);
JIMADD(KernelTotal);
JIMADD(KernelPaged);
JIMADD(KernelNonpaged);
JIMADD(PageSize);
JIMADD(HandleCount);
JIMADD(ProcessCount);
JIMADD(ThreadCount);
#undef JIMADD
Jim_SetResult(interp, Jim_NewListObj(interp, a, n));
return JIM_OK;
}
static int aio_cmd_listen(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
long backlog;
if (Jim_GetLong(interp, argv[0], &backlog) != JIM_OK) {
return JIM_ERR;
}
if (listen(af->fd, backlog)) {
JimAioSetError(interp, NULL);
return JIM_ERR;
}
return JIM_OK;
}
static void JimDetachPids(Jim_Interp *interp, int numPids, const pidtype *pidPtr)
{
int j;
struct WaitInfoTable *table = Jim_CmdPrivData(interp);
for (j = 0; j < numPids; j++) {
/* Find it in the table */
int i;
for (i = 0; i < table->used; i++) {
if (pidPtr[j] == table->info[i].pid) {
table->info[i].flags |= WI_DETACHED;
break;
}
}
}
}
static int aio_cmd_accept(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
int sock;
union sockaddr_any sa;
socklen_t addrlen = sizeof(sa);
sock = accept(af->fd, &sa.sa, &addrlen);
if (sock < 0) {
JimAioSetError(interp, NULL);
return JIM_ERR;
}
/* Create the file command */
return JimMakeChannel(interp, NULL, sock, Jim_NewStringObj(interp, "accept", -1),
"aio.sockstream%ld", af->addr_family, "r+");
}
/*
* Parse "interface" keyword.
*/
static int
InterfaceFunc(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
struct mystate *softc;
struct iface *iface;
Jim_Obj *ipobj;
const char *ip;
const char *name;
int error;
iface = NULL;
ipobj = NULL;
ip = name = NULL;
error = 0;
if (argc != 3)
return (JIM_ERR);
softc = Jim_CmdPrivData(interp);
/* Name of the interface. */
name = Jim_GetString(argv[1], NULL);
softc->block_parsing = 1;
/* Body of the block */
error = Jim_EvalObj(interp, argv[2]);
if (error) {
printf("couldn't evaluate\n");
return (JIM_ERR);
}
softc->block_parsing = 0;
/* Take our hidden variable */
ipobj = Jim_GetVariableStr(interp, JCONF_VAR_IP, JIM_NONE);
assert(ipobj != NULL);
ip = Jim_GetString(ipobj, NULL);
if (ip == NULL) {
Jim_fprintf(interp, interp->cookie_stdout, "NULL!\n");
return (JIM_ERR);
}
iface = iface_alloc(ip, name);
assert(iface != NULL);
INSERT(softc->head, iface);
return (JIM_OK);
}
static int interp_cmd_eval(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
int ret;
Jim_Interp *child = Jim_CmdPrivData(interp);
Jim_Obj *scriptObj;
Jim_Obj *targetScriptObj;
scriptObj = Jim_ConcatObj(interp, argc, argv);
targetScriptObj = JimInterpCopyObj(child, scriptObj);
Jim_FreeNewObj(interp, scriptObj);
Jim_IncrRefCount(targetScriptObj);
ret = Jim_EvalObj(child, targetScriptObj);
Jim_DecrRefCount(child, targetScriptObj);
JimInterpCopyResult(interp, child);
return ret;
}
static int aio_cmd_copy(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
long count = 0;
long maxlen = LONG_MAX;
FILE *outfh = Jim_AioFilehandle(interp, argv[0]);
if (outfh == NULL) {
return JIM_ERR;
}
if (argc == 2) {
if (Jim_GetLong(interp, argv[1], &maxlen) != JIM_OK) {
return JIM_ERR;
}
}
while (count < maxlen) {
int ch = fgetc(af->fp);
if (ch == EOF || fputc(ch, outfh) == EOF) {
break;
}
count++;
}
if (ferror(af->fp)) {
Jim_SetResultFormatted(interp, "error while reading: %s", strerror(errno));
clearerr(af->fp);
return JIM_ERR;
}
if (ferror(outfh)) {
Jim_SetResultFormatted(interp, "error while writing: %s", strerror(errno));
clearerr(outfh);
return JIM_ERR;
}
Jim_SetResultInt(interp, count);
return JIM_OK;
}
/*
* Parse "ip" keyword.
*/
static int
InterfaceIPFunc(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
struct mystate *softc;
int error;
/*
* Get private date shared across this parser.
*/
softc = Jim_CmdPrivData(interp);
/* Check, if we're run from the right place. */
if (softc->block_parsing == 0) {
printf("Trying to use 'ip' outside 'interface' block\n");
return (JIM_ERR);
}
if (argc != 2)
return (JIM_ERR);
error = Jim_SetVariableStr(interp, JCONF_VAR_IP, argv[1]);
assert(error == JIM_OK);
return (JIM_OK);
}
static int JimInterpAliasProc(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
int i, ret;
Jim_Interp *parent = Jim_GetAssocData(interp, "interp.parent");
Jim_Obj *targetPrefixObj = Jim_CmdPrivData(interp);
Jim_Obj *targetScriptObj;
assert(parent);
/* Build the complete command */
targetScriptObj = Jim_DuplicateObj(parent, targetPrefixObj);
for (i = 1; i < argc; i++) {
Jim_ListAppendElement(parent, targetScriptObj,
JimInterpCopyObj(parent, argv[i]));
}
Jim_IncrRefCount(targetScriptObj);
ret = Jim_EvalObj(parent, targetScriptObj);
Jim_DecrRefCount(parent, targetScriptObj);
JimInterpCopyResult(interp, parent);
return ret;
}
static int aio_cmd_ndelay(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
int fmode = af->flags;
if (argc) {
long nb;
if (Jim_GetLong(interp, argv[0], &nb) != JIM_OK) {
return JIM_ERR;
}
if (nb) {
fmode |= O_NDELAY;
}
else {
fmode &= ~O_NDELAY;
}
fcntl(af->fd, F_SETFL, fmode);
af->flags = fmode;
}
Jim_SetResultInt(interp, (fmode & O_NONBLOCK) ? 1 : 0);
return JIM_OK;
}
/* Calls to [aio.file] create commands that are implemented by this
* C command. */
static int JimAioHandlerCommand(Jim_Interp *interp, int argc,
Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
int option;
const char *options[] = {
"close",
"seek", "tell",
"gets", "read", "puts",
"flush", "eof",
"ndelay",
"readable", "writable", "onexception",
"accept",
NULL
};
enum {OPT_CLOSE,
OPT_SEEK, OPT_TELL,
OPT_GETS, OPT_READ, OPT_PUTS,
OPT_FLUSH, OPT_EOF,
OPT_NDELAY,
OPT_READABLE, OPT_WRITABLE, OPT_EXCEPTION,
OPT_ACCEPT
};
if (argc < 2) {
Jim_WrongNumArgs(interp, 1, argv, "method ?args ...?");
return JIM_ERR;
}
if (Jim_GetEnum(interp, argv[1], options, &option, "AIO method",
JIM_ERRMSG) != JIM_OK)
return JIM_ERR;
/* CLOSE */
if (option == OPT_CLOSE) {
if (argc != 2) {
Jim_WrongNumArgs(interp, 2, argv, "");
return JIM_ERR;
}
Jim_DeleteCommand(interp, Jim_GetString(argv[0], NULL));
return JIM_OK;
} else if (option == OPT_SEEK) {
/* SEEK */
int orig = SEEK_SET;
long offset;
if (argc != 3 && argc != 4) {
Jim_WrongNumArgs(interp, 2, argv, "offset ?origin?");
return JIM_ERR;
}
if (argc == 4) {
if (Jim_CompareStringImmediate(interp, argv[3], "start"))
orig = SEEK_SET;
else if (Jim_CompareStringImmediate(interp, argv[3], "current"))
orig = SEEK_CUR;
else if (Jim_CompareStringImmediate(interp, argv[3], "end"))
orig = SEEK_END;
else {
Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
Jim_AppendStrings(interp, Jim_GetResult(interp),
"bad origin \"", Jim_GetString(argv[3], NULL),
"\" must be: start, current, or end", NULL);
return JIM_ERR;
}
}
if (Jim_GetLong(interp, argv[2], &offset) != JIM_OK)
return JIM_ERR;
if (fseek(af->fp, offset, orig) == -1) {
JimAioSetError(interp);
return JIM_ERR;
}
return JIM_OK;
} else if (option == OPT_TELL) {
/* TELL */
long position;
if (argc != 2) {
Jim_WrongNumArgs(interp, 2, argv, "");
return JIM_ERR;
}
position = ftell(af->fp);
Jim_SetResult(interp, Jim_NewIntObj(interp, position));
return JIM_OK;
} else if (option == OPT_GETS) {
/* GETS */
char buf[AIO_BUF_LEN];
Jim_Obj *objPtr;
if (argc != 2 && argc != 3) {
Jim_WrongNumArgs(interp, 2, argv, "?varName?");
return JIM_ERR;
}
objPtr = Jim_NewStringObj(interp, NULL, 0);
while (1) {
int more = 0;
buf[AIO_BUF_LEN-1] = '_';
if (fgets(buf, AIO_BUF_LEN, af->fp) == NULL)
break;
if (buf[AIO_BUF_LEN-1] == '\0' && buf[AIO_BUF_LEN-2] != '\n')
more = 1;
if (more) {
Jim_AppendString(interp, objPtr, buf, AIO_BUF_LEN-1);
} else {
/* strip "\n" */
Jim_AppendString(interp, objPtr, buf, strlen(buf)-1);
}
if (!more)
break;
}
if (ferror(af->fp) && (errno != EAGAIN)) {
/* I/O error */
Jim_IncrRefCount(objPtr);
Jim_DecrRefCount(interp, objPtr);
JimAioSetError(interp);
return JIM_ERR;
}
/* On EOF returns -1 if varName was specified, or the empty string. */
if (feof(af->fp) && Jim_Length(objPtr) == 0) {
Jim_IncrRefCount(objPtr);
Jim_DecrRefCount(interp, objPtr);
if (argc == 3)
Jim_SetResult(interp, Jim_NewIntObj(interp, -1));
return JIM_OK;
}
if (argc == 3) {
int totLen;
Jim_GetString(objPtr, &totLen);
if (Jim_SetVariable(interp, argv[2], objPtr) != JIM_OK) {
Jim_IncrRefCount(objPtr);
Jim_DecrRefCount(interp, objPtr);
return JIM_ERR;
}
Jim_SetResult(interp, Jim_NewIntObj(interp, totLen));
} else {
Jim_SetResult(interp, objPtr);
}
return JIM_OK;
} else if (option == OPT_READ) {
/* READ */
char buf[AIO_BUF_LEN];
Jim_Obj *objPtr;
int nonewline = 0;
int neededLen = -1; /* -1 is "read as much as possible" */
if (argc != 2 && argc != 3) {
Jim_WrongNumArgs(interp, 2, argv, "?-nonewline? ?len?");
return JIM_ERR;
}
if (argc == 3 &&
Jim_CompareStringImmediate(interp, argv[2], "-nonewline"))
{
nonewline = 1;
argv++;
argc--;
}
if (argc == 3) {
jim_wide wideValue;
if (Jim_GetWide(interp, argv[2], &wideValue) != JIM_OK)
return JIM_ERR;
if (wideValue < 0) {
Jim_SetResultString(interp, "invalid parameter: negative len",
-1);
return JIM_ERR;
}
neededLen = (int) wideValue;
}
objPtr = Jim_NewStringObj(interp, NULL, 0);
while (neededLen != 0) {
int retval;
int readlen;
if (neededLen == -1) {
readlen = AIO_BUF_LEN;
} else {
readlen = (neededLen > AIO_BUF_LEN ? AIO_BUF_LEN : neededLen);
}
retval = fread(buf, 1, readlen, af->fp);
if (retval > 0) {
Jim_AppendString(interp, objPtr, buf, retval);
if (neededLen != -1) {
neededLen -= retval;
}
}
if (retval != readlen) break;
}
/* Check for error conditions */
if (ferror(af->fp)) {
/* I/O error */
Jim_FreeNewObj(interp, objPtr);
JimAioSetError(interp);
return JIM_ERR;
}
if (nonewline) {
int len;
const char *s = Jim_GetString(objPtr, &len);
if (len > 0 && s[len-1] == '\n') {
objPtr->length--;
objPtr->bytes[objPtr->length] = '\0';
}
}
Jim_SetResult(interp, objPtr);
return JIM_OK;
} else if (option == OPT_PUTS) {
/* PUTS */
int wlen;
const char *wdata;
if (argc != 3 && (argc != 4 || !Jim_CompareStringImmediate(
interp, argv[2], "-nonewline"))) {
Jim_WrongNumArgs(interp, 2, argv, "?-nonewline? string");
return JIM_ERR;
}
wdata = Jim_GetString(argv[2+(argc==4)], &wlen);
if (fwrite(wdata, 1, wlen, af->fp) != (unsigned)wlen ||
(argc == 3 && fwrite("\n", 1, 1, af->fp) != 1)) {
JimAioSetError(interp);
return JIM_ERR;
}
return JIM_OK;
} else if (option == OPT_FLUSH) {
/* FLUSH */
if (argc != 2) {
Jim_WrongNumArgs(interp, 2, argv, "");
return JIM_ERR;
}
if (fflush(af->fp) == EOF) {
JimAioSetError(interp);
return JIM_ERR;
}
return JIM_OK;
} else if (option == OPT_EOF) {
/* EOF */
if (argc != 2) {
Jim_WrongNumArgs(interp, 2, argv, "");
return JIM_ERR;
}
Jim_SetResult(interp, Jim_NewIntObj(interp, feof(af->fp)));
return JIM_OK;
} else if (option == OPT_NDELAY) {
#ifdef O_NDELAY
int fmode = af->flags;
if (argc == 3) {
jim_wide wideValue;
if (Jim_GetWide(interp, argv[2], &wideValue) != JIM_OK)
return JIM_ERR;
switch (wideValue) {
case 0:
fmode &= ~O_NDELAY; break ;
case 1:
fmode |= O_NDELAY; break ;
}
fcntl(af->fd,F_SETFL,fmode);
af->flags = fmode;
}
Jim_SetResult(interp, Jim_NewIntObj(interp, (fmode & O_NONBLOCK)?1:0));
return JIM_OK;
#else
return JIM_ERR;
#endif
} else if ( (option == OPT_READABLE)
|| (option == OPT_WRITABLE)
|| (option == OPT_EXCEPTION)
) {
int mask = 0;
Jim_Obj **scrListObjpp = NULL;
Jim_Obj *listObj;
const char *dummy = NULL;
int scrlen = 0;
if (!(Jim_CreateFileHandler && Jim_DeleteFileHandler)) {
Jim_SetResultString(interp, "Eventloop not present ( or loaded too late ) !", -1);
return JIM_ERR;
}
switch (option) {
case OPT_READABLE: mask = JIM_EVENT_READABLE; scrListObjpp = &af->rEvent;
if (argc == 4) mask |= JIM_EVENT_FEOF ; break;
case OPT_WRITABLE: mask = JIM_EVENT_WRITABLE; scrListObjpp = &af->wEvent; break;
case OPT_EXCEPTION: mask = JIM_EVENT_EXCEPTION; scrListObjpp = &af->eEvent; break;
}
switch (argc) {
case 4:
case 3:
if (*scrListObjpp) {
Jim_DeleteFileHandler(interp, af->fp); //,mask);
Jim_DecrRefCount(interp, *scrListObjpp);
*scrListObjpp = NULL;
}
if ( dummy = Jim_GetString(argv[2],&scrlen),(scrlen == 0)) {
break;
} else {
*scrListObjpp = Jim_NewListObj(interp, NULL, 0);
Jim_IncrRefCount(*scrListObjpp);
// fprintf(stderr,"0 %p \n",*scrListObjpp);
listObj = argv[2];
if (Jim_IsShared(listObj))
listObj = Jim_DuplicateObj(interp, listObj);
// Jim_IncrRefCount(listObj);
// fprintf(stderr,"script:\"%s\" argp: %p objp1: %p\n", Jim_GetString(argv[2], NULL),argv[2],listObj);
// fprintf(stderr,"1");
Jim_ListAppendElement(interp,*scrListObjpp,listObj);
// fprintf(stderr,"2");
if (mask & JIM_EVENT_FEOF) {
listObj = argv[3];
if (Jim_IsShared(listObj))
listObj = Jim_DuplicateObj(interp, listObj);
// Jim_IncrRefCount(listObj);
// fprintf(stderr,"script:\"%s\" argp: %p objp2: %p\n", Jim_GetString(argv[3], NULL),argv[3],listObj);
// fprintf(stderr,"3");
Jim_ListAppendElement(interp,*scrListObjpp,listObj);
// fprintf(stderr,"4");
}
// fprintf(stderr,"event readable fd: %d, script:\"%s\" objp3: %p\n",af->fd, Jim_GetString(argv[2], NULL),argv[2]);
Jim_IncrRefCount(*scrListObjpp);
// fprintf(stderr,"6 %p \n",Jim_CreateFileHandler);
Jim_CreateFileHandler(interp, af->fp, mask,
JimAioFileEventHandler,
*scrListObjpp,
JimAioFileEventFinalizer);
// fprintf(stderr,"7");
}
break;
case 2:
if (*scrListObjpp)
Jim_SetResult(interp,*scrListObjpp);
return JIM_OK;
default:
Jim_WrongNumArgs(interp, 2, argv, "");
return JIM_ERR;
}
} else if (option == OPT_ACCEPT) {
int ret;
fprintf(stderr,"ACCEPT\n");
ret = JimAioAcceptHelper(interp,af);
fprintf(stderr,"ret %d\n",ret);
return (ret);
}
return JIM_OK;
}
/* Calls to commands created via [sdl.surface] are implemented by this
* C command. */
static int JimSdlHandlerCommand(Jim_Interp *interp, int argc,
Jim_Obj *const *argv)
{
JimSdlSurface *jss = Jim_CmdPrivData(interp);
int option;
const char *options[] = {
"free", "flip", "pixel", "rectangle", "box", "line", "aaline",
"circle", "aacircle", "fcircle", NULL
};
enum {OPT_FREE, OPT_FLIP, OPT_PIXEL, OPT_RECTANGLE, OPT_BOX, OPT_LINE,
OPT_AALINE, OPT_CIRCLE, OPT_AACIRCLE, OPT_FCIRCLE};
if (argc < 2) {
Jim_WrongNumArgs(interp, 1, argv, "method ?args ...?");
return JIM_ERR;
}
if (Jim_GetEnum(interp, argv[1], options, &option, "SDL surface method",
JIM_ERRMSG) != JIM_OK)
return JIM_ERR;
if (option == OPT_PIXEL) {
/* PIXEL */
long x, y, red, green, blue, alpha = 255;
if (argc != 7 && argc != 8) {
Jim_WrongNumArgs(interp, 2, argv, "x y red green blue ?alpha?");
return JIM_ERR;
}
if (Jim_GetLong(interp, argv[2], &x) != JIM_OK ||
Jim_GetLong(interp, argv[3], &y) != JIM_OK ||
Jim_GetLong(interp, argv[4], &red) != JIM_OK ||
Jim_GetLong(interp, argv[5], &green) != JIM_OK ||
Jim_GetLong(interp, argv[6], &blue) != JIM_OK)
{
return JIM_ERR;
}
if (argc == 8 && Jim_GetLong(interp, argv[7], &alpha) != JIM_OK)
return JIM_ERR;
// pixelRGBA(jss->screen, x, y, red, green, blue, alpha);
uint32_t color = 0;
color |= alpha << 24;
color |= red << 16;
color |= green << 8;
color |= blue;
SDL_DrawPixel(jss->screen, x, y, color);
return JIM_OK;
} else if (option == OPT_RECTANGLE || option == OPT_BOX ||
option == OPT_LINE || option == OPT_AALINE)
{
/* RECTANGLE, BOX, LINE, AALINE */
long x1, y1, x2, y2, red, green, blue, alpha = 255;
if (argc != 9 && argc != 10) {
Jim_WrongNumArgs(interp, 2, argv, "x y red green blue ?alpha?");
return JIM_ERR;
}
if (Jim_GetLong(interp, argv[2], &x1) != JIM_OK ||
Jim_GetLong(interp, argv[3], &y1) != JIM_OK ||
Jim_GetLong(interp, argv[4], &x2) != JIM_OK ||
Jim_GetLong(interp, argv[5], &y2) != JIM_OK ||
Jim_GetLong(interp, argv[6], &red) != JIM_OK ||
Jim_GetLong(interp, argv[7], &green) != JIM_OK ||
Jim_GetLong(interp, argv[8], &blue) != JIM_OK)
{
return JIM_ERR;
}
if (argc == 10 && Jim_GetLong(interp, argv[9], &alpha) != JIM_OK)
return JIM_ERR;
uint32_t color = 0;
color |= alpha << 24;
color |= red << 16;
color |= green << 8;
color |= blue;
switch(option) {
case OPT_RECTANGLE: {
// rectangleRGBA(jss->screen, x1, y1, x2, y2, red, green, blue, alpha);
SDL_Rect r = {
.x = x1, .y = y1,
.w = x2 - x1, .h = y2 - y1
};
SDL_DrawRect(jss->screen, &r, color);
break;
}
case OPT_BOX: {
// boxRGBA(jss->screen, x1, y1, x2, y2, red, green, blue, alpha);
SDL_Point rect_poly[4] = {
{ .x = x1, .y = y1 },
{ .x = x2, .y = y1 },
{ .x = x2, .y = y2 },
{ .x = x1, .y = y2 }
};
SDL_FillPolygon(jss->screen, rect_poly, sizeof(rect_poly)/sizeof(rect_poly[0]), color);
break;
}
static int JimELAfterCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
Jim_EventLoop *eventLoop = Jim_CmdPrivData(interp);
double ms = 0;
jim_wide id;
Jim_Obj *objPtr, *idObjPtr;
static const char * const options[] = {
"cancel", "info", "idle", NULL
};
enum
{ AFTER_CANCEL, AFTER_INFO, AFTER_IDLE, AFTER_RESTART, AFTER_EXPIRE, AFTER_CREATE };
int option = AFTER_CREATE;
if (argc < 2) {
Jim_WrongNumArgs(interp, 1, argv, "option ?arg ...?");
return JIM_ERR;
}
if (Jim_GetDouble(interp, argv[1], &ms) != JIM_OK) {
if (Jim_GetEnum(interp, argv[1], options, &option, "argument", JIM_ERRMSG) != JIM_OK) {
return JIM_ERR;
}
Jim_SetEmptyResult(interp);
}
else if (argc == 2) {
/* Simply a sleep */
usleep(ms * 1000);
return JIM_OK;
}
switch (option) {
case AFTER_IDLE:
if (argc < 3) {
Jim_WrongNumArgs(interp, 2, argv, "script ?script ...?");
return JIM_ERR;
}
/* fall through */
case AFTER_CREATE: {
Jim_Obj *scriptObj = Jim_ConcatObj(interp, argc - 2, argv + 2);
Jim_IncrRefCount(scriptObj);
id = Jim_CreateTimeHandler(interp, (jim_wide)(ms * 1000), JimAfterTimeHandler, scriptObj,
JimAfterTimeEventFinalizer);
objPtr = Jim_NewStringObj(interp, NULL, 0);
Jim_AppendString(interp, objPtr, "after#", -1);
idObjPtr = Jim_NewIntObj(interp, id);
Jim_IncrRefCount(idObjPtr);
Jim_AppendObj(interp, objPtr, idObjPtr);
Jim_DecrRefCount(interp, idObjPtr);
Jim_SetResult(interp, objPtr);
return JIM_OK;
}
case AFTER_CANCEL:
if (argc < 3) {
Jim_WrongNumArgs(interp, 2, argv, "id|command");
return JIM_ERR;
}
else {
jim_wide remain = 0;
id = JimParseAfterId(argv[2]);
if (id <= 0) {
/* Not an event id, so search by script */
Jim_Obj *scriptObj = Jim_ConcatObj(interp, argc - 2, argv + 2);
id = JimFindAfterByScript(eventLoop, scriptObj);
Jim_FreeNewObj(interp, scriptObj);
if (id <= 0) {
/* Not found */
break;
}
}
remain = Jim_DeleteTimeHandler(interp, id);
if (remain >= 0) {
Jim_SetResultInt(interp, remain);
}
}
break;
case AFTER_INFO:
if (argc == 2) {
Jim_TimeEvent *te = eventLoop->timeEventHead;
Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
char buf[30];
const char *fmt = "after#%" JIM_WIDE_MODIFIER;
while (te) {
snprintf(buf, sizeof(buf), fmt, te->id);
Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, buf, -1));
te = te->next;
}
Jim_SetResult(interp, listObj);
}
else if (argc == 3) {
id = JimParseAfterId(argv[2]);
if (id >= 0) {
Jim_TimeEvent *e = JimFindTimeHandlerById(eventLoop, id);
if (e && e->timeProc == JimAfterTimeHandler) {
Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
Jim_ListAppendElement(interp, listObj, e->clientData);
Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, e->initialus ? "timer" : "idle", -1));
Jim_SetResult(interp, listObj);
return JIM_OK;
}
}
Jim_SetResultFormatted(interp, "event \"%#s\" doesn't exist", argv[2]);
return JIM_ERR;
}
else {
Jim_WrongNumArgs(interp, 2, argv, "?id?");
return JIM_ERR;
}
break;
}
return JIM_OK;
}
/*
*----------------------------------------------------------------------
*
* JimCreatePipeline --
*
* Given an argc/argv array, instantiate a pipeline of processes
* as described by the argv.
*
* Results:
* The return value is a count of the number of new processes
* created, or -1 if an error occurred while creating the pipeline.
* *pidArrayPtr is filled in with the address of a dynamically
* allocated array giving the ids of all of the processes. It
* is up to the caller to free this array when it isn't needed
* anymore. If inPipePtr is non-NULL, *inPipePtr is filled in
* with the file id for the input pipe for the pipeline (if any):
* the caller must eventually close this file. If outPipePtr
* isn't NULL, then *outPipePtr is filled in with the file id
* for the output pipe from the pipeline: the caller must close
* this file. If errFilePtr isn't NULL, then *errFilePtr is filled
* with a file id that may be used to read error output after the
* pipeline completes.
*
* Side effects:
* Processes and pipes are created.
*
*----------------------------------------------------------------------
*/
static int
JimCreatePipeline(Jim_Interp *interp, int argc, Jim_Obj *const *argv, pidtype **pidArrayPtr,
fdtype *inPipePtr, fdtype *outPipePtr, fdtype *errFilePtr)
{
pidtype *pidPtr = NULL; /* Points to malloc-ed array holding all
* the pids of child processes. */
int numPids = 0; /* Actual number of processes that exist
* at *pidPtr right now. */
int cmdCount; /* Count of number of distinct commands
* found in argc/argv. */
const char *input = NULL; /* Describes input for pipeline, depending
* on "inputFile". NULL means take input
* from stdin/pipe. */
int input_len = 0; /* Length of input, if relevant */
#define FILE_NAME 0 /* input/output: filename */
#define FILE_APPEND 1 /* output only: filename, append */
#define FILE_HANDLE 2 /* input/output: filehandle */
#define FILE_TEXT 3 /* input only: input is actual text */
int inputFile = FILE_NAME; /* 1 means input is name of input file.
* 2 means input is filehandle name.
* 0 means input holds actual
* text to be input to command. */
int outputFile = FILE_NAME; /* 0 means output is the name of output file.
* 1 means output is the name of output file, and append.
* 2 means output is filehandle name.
* All this is ignored if output is NULL
*/
int errorFile = FILE_NAME; /* 0 means error is the name of error file.
* 1 means error is the name of error file, and append.
* 2 means error is filehandle name.
* All this is ignored if error is NULL
*/
const char *output = NULL; /* Holds name of output file to pipe to,
* or NULL if output goes to stdout/pipe. */
const char *error = NULL; /* Holds name of stderr file to pipe to,
* or NULL if stderr goes to stderr/pipe. */
fdtype inputId = JIM_BAD_FD;
/* Readable file id input to current command in
* pipeline (could be file or pipe). JIM_BAD_FD
* means use stdin. */
fdtype outputId = JIM_BAD_FD;
/* Writable file id for output from current
* command in pipeline (could be file or pipe).
* JIM_BAD_FD means use stdout. */
fdtype errorId = JIM_BAD_FD;
/* Writable file id for all standard error
* output from all commands in pipeline. JIM_BAD_FD
* means use stderr. */
fdtype lastOutputId = JIM_BAD_FD;
/* Write file id for output from last command
* in pipeline (could be file or pipe).
* -1 means use stdout. */
fdtype pipeIds[2]; /* File ids for pipe that's being created. */
int firstArg, lastArg; /* Indexes of first and last arguments in
* current command. */
int lastBar;
int i;
pidtype pid;
char **save_environ;
struct WaitInfoTable *table = Jim_CmdPrivData(interp);
/* Holds the args which will be used to exec */
char **arg_array = Jim_Alloc(sizeof(*arg_array) * (argc + 1));
int arg_count = 0;
JimReapDetachedPids(table);
if (inPipePtr != NULL) {
*inPipePtr = JIM_BAD_FD;
}
if (outPipePtr != NULL) {
*outPipePtr = JIM_BAD_FD;
}
if (errFilePtr != NULL) {
*errFilePtr = JIM_BAD_FD;
}
pipeIds[0] = pipeIds[1] = JIM_BAD_FD;
/*
* First, scan through all the arguments to figure out the structure
* of the pipeline. Count the number of distinct processes (it's the
* number of "|" arguments). If there are "<", "<<", or ">" arguments
* then make note of input and output redirection and remove these
* arguments and the arguments that follow them.
*/
cmdCount = 1;
lastBar = -1;
for (i = 0; i < argc; i++) {
const char *arg = Jim_String(argv[i]);
if (arg[0] == '<') {
inputFile = FILE_NAME;
input = arg + 1;
if (*input == '<') {
inputFile = FILE_TEXT;
input_len = Jim_Length(argv[i]) - 2;
input++;
}
else if (*input == '@') {
inputFile = FILE_HANDLE;
input++;
}
if (!*input && ++i < argc) {
input = Jim_GetString(argv[i], &input_len);
}
}
else if (arg[0] == '>') {
int dup_error = 0;
outputFile = FILE_NAME;
output = arg + 1;
if (*output == '>') {
outputFile = FILE_APPEND;
output++;
}
if (*output == '&') {
/* Redirect stderr too */
output++;
dup_error = 1;
}
if (*output == '@') {
outputFile = FILE_HANDLE;
output++;
}
if (!*output && ++i < argc) {
output = Jim_String(argv[i]);
}
if (dup_error) {
errorFile = outputFile;
error = output;
}
}
else if (arg[0] == '2' && arg[1] == '>') {
error = arg + 2;
errorFile = FILE_NAME;
if (*error == '@') {
errorFile = FILE_HANDLE;
error++;
}
else if (*error == '>') {
errorFile = FILE_APPEND;
error++;
}
if (!*error && ++i < argc) {
error = Jim_String(argv[i]);
}
}
else {
if (strcmp(arg, "|") == 0 || strcmp(arg, "|&") == 0) {
if (i == lastBar + 1 || i == argc - 1) {
Jim_SetResultString(interp, "illegal use of | or |& in command", -1);
goto badargs;
}
lastBar = i;
cmdCount++;
}
/* Either |, |& or a "normal" arg, so store it in the arg array */
arg_array[arg_count++] = (char *)arg;
continue;
}
if (i >= argc) {
Jim_SetResultFormatted(interp, "can't specify \"%s\" as last word in command", arg);
goto badargs;
}
}
if (arg_count == 0) {
Jim_SetResultString(interp, "didn't specify command to execute", -1);
badargs:
Jim_Free(arg_array);
return -1;
}
/* Must do this before vfork(), so do it now */
save_environ = JimSaveEnv(JimBuildEnv(interp));
/*
* Set up the redirected input source for the pipeline, if
* so requested.
*/
if (input != NULL) {
if (inputFile == FILE_TEXT) {
/*
* Immediate data in command. Create temporary file and
* put data into file.
*/
inputId = JimCreateTemp(interp, input, input_len);
if (inputId == JIM_BAD_FD) {
goto error;
}
}
else if (inputFile == FILE_HANDLE) {
/* Should be a file descriptor */
FILE *fh = JimGetAioFilehandle(interp, input);
if (fh == NULL) {
goto error;
}
inputId = JimDupFd(JimFileno(fh));
}
else {
/*
* File redirection. Just open the file.
*/
inputId = JimOpenForRead(input);
if (inputId == JIM_BAD_FD) {
Jim_SetResultFormatted(interp, "couldn't read file \"%s\": %s", input, JimStrError());
goto error;
}
}
}
else if (inPipePtr != NULL) {
if (JimPipe(pipeIds) != 0) {
Jim_SetResultErrno(interp, "couldn't create input pipe for command");
goto error;
}
inputId = pipeIds[0];
*inPipePtr = pipeIds[1];
pipeIds[0] = pipeIds[1] = JIM_BAD_FD;
}
/*
* Set up the redirected output sink for the pipeline from one
* of two places, if requested.
*/
if (output != NULL) {
if (outputFile == FILE_HANDLE) {
FILE *fh = JimGetAioFilehandle(interp, output);
if (fh == NULL) {
goto error;
}
fflush(fh);
lastOutputId = JimDupFd(JimFileno(fh));
}
else {
/*
* Output is to go to a file.
*/
lastOutputId = JimOpenForWrite(output, outputFile == FILE_APPEND);
if (lastOutputId == JIM_BAD_FD) {
Jim_SetResultFormatted(interp, "couldn't write file \"%s\": %s", output, JimStrError());
goto error;
}
}
}
else if (outPipePtr != NULL) {
/*
* Output is to go to a pipe.
*/
if (JimPipe(pipeIds) != 0) {
Jim_SetResultErrno(interp, "couldn't create output pipe");
goto error;
}
lastOutputId = pipeIds[1];
*outPipePtr = pipeIds[0];
pipeIds[0] = pipeIds[1] = JIM_BAD_FD;
}
/* If we are redirecting stderr with 2>filename or 2>@fileId, then we ignore errFilePtr */
if (error != NULL) {
if (errorFile == FILE_HANDLE) {
if (strcmp(error, "1") == 0) {
/* Special 2>@1 */
if (lastOutputId != JIM_BAD_FD) {
errorId = JimDupFd(lastOutputId);
}
else {
/* No redirection of stdout, so just use 2>@stdout */
error = "stdout";
}
}
if (errorId == JIM_BAD_FD) {
FILE *fh = JimGetAioFilehandle(interp, error);
if (fh == NULL) {
goto error;
}
fflush(fh);
errorId = JimDupFd(JimFileno(fh));
}
}
else {
/*
* Output is to go to a file.
*/
errorId = JimOpenForWrite(error, errorFile == FILE_APPEND);
if (errorId == JIM_BAD_FD) {
Jim_SetResultFormatted(interp, "couldn't write file \"%s\": %s", error, JimStrError());
goto error;
}
}
}
else if (errFilePtr != NULL) {
/*
* Set up the standard error output sink for the pipeline, if
* requested. Use a temporary file which is opened, then deleted.
* Could potentially just use pipe, but if it filled up it could
* cause the pipeline to deadlock: we'd be waiting for processes
* to complete before reading stderr, and processes couldn't complete
* because stderr was backed up.
*/
errorId = JimCreateTemp(interp, NULL, 0);
if (errorId == JIM_BAD_FD) {
goto error;
}
*errFilePtr = JimDupFd(errorId);
}
/*
* Scan through the argc array, forking off a process for each
* group of arguments between "|" arguments.
*/
pidPtr = Jim_Alloc(cmdCount * sizeof(*pidPtr));
for (i = 0; i < numPids; i++) {
pidPtr[i] = JIM_BAD_PID;
}
for (firstArg = 0; firstArg < arg_count; numPids++, firstArg = lastArg + 1) {
int pipe_dup_err = 0;
fdtype origErrorId = errorId;
for (lastArg = firstArg; lastArg < arg_count; lastArg++) {
if (arg_array[lastArg][0] == '|') {
if (arg_array[lastArg][1] == '&') {
pipe_dup_err = 1;
}
break;
}
}
/* Replace | with NULL for execv() */
arg_array[lastArg] = NULL;
if (lastArg == arg_count) {
outputId = lastOutputId;
}
else {
if (JimPipe(pipeIds) != 0) {
Jim_SetResultErrno(interp, "couldn't create pipe");
goto error;
}
outputId = pipeIds[1];
}
/* Now fork the child */
#ifdef __MINGW32__
pid = JimStartWinProcess(interp, &arg_array[firstArg], save_environ ? save_environ[0] : NULL, inputId, outputId, errorId);
if (pid == JIM_BAD_PID) {
Jim_SetResultFormatted(interp, "couldn't exec \"%s\"", arg_array[firstArg]);
goto error;
}
#else
/*
* Disable SIGPIPE signals: if they were allowed, this process
* might go away unexpectedly if children misbehave. This code
* can potentially interfere with other application code that
* expects to handle SIGPIPEs; what's really needed is an
* arbiter for signals to allow them to be "shared".
*/
if (table->info == NULL) {
(void)signal(SIGPIPE, SIG_IGN);
}
/* Need to do this befor vfork() */
if (pipe_dup_err) {
errorId = outputId;
}
/*
* Make a new process and enter it into the table if the fork
* is successful.
*/
pid = vfork();
if (pid < 0) {
Jim_SetResultErrno(interp, "couldn't fork child process");
goto error;
}
if (pid == 0) {
/* Child */
if (inputId != -1) dup2(inputId, 0);
if (outputId != -1) dup2(outputId, 1);
if (errorId != -1) dup2(errorId, 2);
for (i = 3; (i <= outputId) || (i <= inputId) || (i <= errorId); i++) {
close(i);
}
execvpe(arg_array[firstArg], &arg_array[firstArg], Jim_GetEnviron());
/* Need to prep an error message before vfork(), just in case */
fprintf(stderr, "couldn't exec \"%s\"", arg_array[firstArg]);
_exit(127);
}
#endif
/* parent */
/*
* Enlarge the wait table if there isn't enough space for a new
* entry.
*/
if (table->used == table->size) {
table->size += WAIT_TABLE_GROW_BY;
table->info = Jim_Realloc(table->info, table->size * sizeof(*table->info));
}
table->info[table->used].pid = pid;
table->info[table->used].flags = 0;
table->used++;
pidPtr[numPids] = pid;
/* Restore in case of pipe_dup_err */
errorId = origErrorId;
/*
* Close off our copies of file descriptors that were set up for
* this child, then set up the input for the next child.
*/
if (inputId != JIM_BAD_FD) {
JimCloseFd(inputId);
}
if (outputId != JIM_BAD_FD) {
JimCloseFd(outputId);
}
inputId = pipeIds[0];
pipeIds[0] = pipeIds[1] = JIM_BAD_FD;
}
*pidArrayPtr = pidPtr;
/*
* All done. Cleanup open files lying around and then return.
*/
cleanup:
if (inputId != JIM_BAD_FD) {
JimCloseFd(inputId);
}
if (lastOutputId != JIM_BAD_FD) {
JimCloseFd(lastOutputId);
}
if (errorId != JIM_BAD_FD) {
JimCloseFd(errorId);
}
Jim_Free(arg_array);
JimRestoreEnv(save_environ);
return numPids;
/*
* An error occurred. There could have been extra files open, such
* as pipes between children. Clean them all up. Detach any child
* processes that have been created.
*/
error:
if ((inPipePtr != NULL) && (*inPipePtr != JIM_BAD_FD)) {
JimCloseFd(*inPipePtr);
*inPipePtr = JIM_BAD_FD;
}
if ((outPipePtr != NULL) && (*outPipePtr != JIM_BAD_FD)) {
JimCloseFd(*outPipePtr);
*outPipePtr = JIM_BAD_FD;
}
if ((errFilePtr != NULL) && (*errFilePtr != JIM_BAD_FD)) {
JimCloseFd(*errFilePtr);
*errFilePtr = JIM_BAD_FD;
}
if (pipeIds[0] != JIM_BAD_FD) {
JimCloseFd(pipeIds[0]);
}
if (pipeIds[1] != JIM_BAD_FD) {
JimCloseFd(pipeIds[1]);
}
if (pidPtr != NULL) {
for (i = 0; i < numPids; i++) {
if (pidPtr[i] != JIM_BAD_PID) {
JimDetachPids(interp, 1, &pidPtr[i]);
}
}
Jim_Free(pidPtr);
}
numPids = -1;
goto cleanup;
}
/* Syslog_Log -
* implements syslog tcl command. General format: syslog ?options? level text
* options -facility -ident -options
*
* syslog ?-facility cron|daemon|...? ?-ident string? ?-options int? ?debug|info|...? text
*/
int Jim_SyslogCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
int priority = LOG_INFO;
int i = 1;
SyslogInfo *info = Jim_CmdPrivData(interp);
if (argc <= 1) {
wrongargs:
Jim_WrongNumArgs(interp, 1, argv,
"?-facility cron|daemon|...? ?-ident string? ?-options int? ?debug|info|...? message");
return JIM_ERR;
}
while (i < argc - 1) {
if (Jim_CompareStringImmediate(interp, argv[i], "-facility")) {
int entry =
Jim_FindByName(Jim_String(argv[i + 1]), facilities,
sizeof(facilities) / sizeof(*facilities));
if (entry < 0) {
Jim_SetResultString(interp, "Unknown facility", -1);
return JIM_ERR;
}
if (info->facility != entry) {
info->facility = entry;
if (info->logOpened) {
closelog();
info->logOpened = 0;
}
}
}
else if (Jim_CompareStringImmediate(interp, argv[i], "-options")) {
long tmp;
if (Jim_GetLong(interp, argv[i + 1], &tmp) == JIM_ERR) {
return JIM_ERR;
}
info->options = tmp;
if (info->logOpened) {
closelog();
info->logOpened = 0;
}
}
else if (Jim_CompareStringImmediate(interp, argv[i], "-ident")) {
strncpy(info->ident, Jim_String(argv[i + 1]), sizeof(info->ident));
info->ident[sizeof(info->ident) - 1] = 0;
if (info->logOpened) {
closelog();
info->logOpened = 0;
}
}
else {
break;
}
i += 2;
}
/* There should be either 0, 1 or 2 args left */
if (i == argc) {
/* No args, but they have set some options, so OK */
return JIM_OK;
}
if (i < argc - 1) {
priority =
Jim_FindByName(Jim_String(argv[i]), priorities,
sizeof(priorities) / sizeof(*priorities));
if (priority < 0) {
Jim_SetResultString(interp, "Unknown priority", -1);
return JIM_ERR;
}
i++;
}
if (i != argc - 1) {
goto wrongargs;
}
if (!info->logOpened) {
if (!info->ident[0]) {
Jim_Obj *argv0 = Jim_GetGlobalVariableStr(interp, "argv0", JIM_NONE);
if (argv0) {
strncpy(info->ident, Jim_String(argv0), sizeof(info->ident));
}
else {
strcpy(info->ident, "Tcl script");
}
info->ident[sizeof(info->ident) - 1] = 0;
}
openlog(info->ident, info->options, info->facility);
info->logOpened = 1;
}
syslog(priority, "%s", Jim_String(argv[i]));
return JIM_OK;
}
