int
copyprevshellword(UNUSED(char **args))
{
LinkList l;
LinkNode n;
int i;
char *p = NULL;
if (zmult <= 0)
return 1;
if ((l = bufferwords(NULL, NULL, &i, LEXFLAGS_ZLE))) {
i -= (zmult-1);
if (i < 0)
return 1;
for (n = firstnode(l); n; incnode(n))
if (!i--) {
p = getdata(n);
break;
}
}
if (p) {
int len;
ZLE_STRING_T lineadd = stringaszleline(p, 0, &len, NULL, NULL);
spaceinline(len);
ZS_memcpy(zleline + zlecs, lineadd, len);
zlecs += len;
free(lineadd);
}
return 0;
}
int
countlinknodes(LinkList list)
{
LinkNode nd;
int ct = 0;
for (nd = firstnode(list); nd; incnode(nd), ct++);
return ct;
}
static void
tcp_cleanup(void)
{
LinkNode node, next;
for (node = firstnode(ztcp_sessions); node; node = next) {
next = node->next;
tcp_close((Tcp_session)getdata(node));
}
}
static void
checksched(void)
{
time_t t;
struct schedcmd *sch;
if(!schedcmds)
return;
t = time(NULL);
/*
* List is ordered, so we only need to consider the
* head element.
*/
while (schedcmds && schedcmds->time <= t) {
/*
* Remove the entry to be executed from the list
* before execution: this makes quite sure that
* the entry hasn't been monkeyed with when we
* free it.
*/
sch = schedcmds;
schedcmds = sch->next;
/*
* Delete from the timed function list now in case
* the called code reschedules.
*/
scheddeltimed();
if ((sch->flags & SCHEDFLAG_TRASH_ZLE) && zleactive)
zleentry(ZLE_CMD_TRASH);
execstring(sch->cmd, 0, 0, "sched");
zsfree(sch->cmd);
zfree(sch, sizeof(struct schedcmd));
/*
* Fix time for future events.
* I had this outside the loop, for a little extra efficiency.
* However, it then occurred to me that having the list of
* forthcoming entries up to date could be regarded as
* a feature, and the inefficiency is negligible.
*
* Careful in case the code we called has already set
* up a timed event; if it has, that'll be up to date since
* we haven't changed the list here.
*/
if (schedcmds && !schedcmdtimed) {
/*
* We've already delete the function from the list.
*/
DPUTS(timedfns && firstnode(timedfns),
"BUG: already timed fn (1)");
schedaddtimed(schedcmds->time);
}
}
}
static Tcp_session
zts_byfd(int fd)
{
LinkNode node;
for (node = firstnode(ztcp_sessions); node; incnode(node))
if (((Tcp_session)getdata(node))->fd == fd)
return (Tcp_session)getdata(node);
return NULL;
}
void
prefork(LinkList list, int flags)
{
LinkNode node;
MUSTUSEHEAP("prefork");
for (node = firstnode(list); node; incnode(node)) {
char *str, *str3;
str = str3 = (char *)getdata(node);
if ((*str == Inang || *str == Outang || *str == Equals) &&
str[1] == Inpar) {
if (*str == Inang || *str == Outang)
setdata(node, (void *) getproc(str)); /* <(...) or >(...) */
else
setdata(node, (void *) getoutputfile(str)); /* =(...) */
if (!getdata(node))
return;
} else {
if (isset(SHFILEEXPANSION))
filesub((char **)getaddrdata(node), flags & 3);
if (!(node = stringsubst(list, node, flags & 4)))
return;
}
}
for (node = firstnode(list); node; incnode(node)) {
if (*(char *)getdata(node)) {
remnulargs(getdata(node));
if (unset(IGNOREBRACES) && !(flags & 4))
while (hasbraces(getdata(node)))
xpandbraces(list, &node);
if (unset(SHFILEEXPANSION))
filesub((char **)getaddrdata(node), flags & 3);
} else if (!(flags & 4))
uremnode(list, node);
if (errflag)
return;
}
}
void
globlist(LinkList list)
{
LinkNode node, next;
badcshglob = 0;
for (node = firstnode(list); !errflag && node; node = next) {
next = nextnode(node);
glob(list, node);
}
if (badcshglob == 1)
zerr("no match", NULL, 0);
}
static void cond_subst(char **strp, int glob_ok)
{
if (glob_ok &&
checkglobqual(*strp, strlen(*strp), 1, NULL)) {
LinkList args = newlinklist();
addlinknode(args, *strp);
prefork(args, 0, NULL);
while (!errflag && args && nonempty(args) &&
has_token((char *)peekfirst(args)))
zglob(args, firstnode(args), 0);
*strp = sepjoin(hlinklist2array(args, 0), NULL, 1);
} else
singsub(strp);
}
static void
calc_timeout(struct ztmout *tmoutp, long do_keytmout)
{
if (do_keytmout && (keytimeout > 0 || do_keytmout < 0)) {
if (do_keytmout < 0)
tmoutp->exp100ths = (time_t)-do_keytmout;
else if (keytimeout > ZMAXTIMEOUT * 100 /* 24 days for a keypress???? */)
tmoutp->exp100ths = ZMAXTIMEOUT * 100;
else
tmoutp->exp100ths = keytimeout;
tmoutp->tp = ZTM_KEY;
} else
tmoutp->tp = ZTM_NONE;
if (timedfns) {
for (;;) {
LinkNode tfnode = firstnode(timedfns);
Timedfn tfdat;
time_t diff, exp100ths;
if (!tfnode)
break;
tfdat = (Timedfn)getdata(tfnode);
diff = tfdat->when - time(NULL);
if (diff < 0) {
/* Already due; call it and rescan. */
tfdat->func();
continue;
}
if (diff > ZMAXTIMEOUT) {
tmoutp->exp100ths = ZMAXTIMEOUT * 100;
tmoutp->tp = ZTM_MAX;
} else if (diff > 0) {
exp100ths = diff * 100;
if (tmoutp->tp != ZTM_KEY ||
exp100ths < tmoutp->exp100ths) {
tmoutp->exp100ths = exp100ths;
tmoutp->tp = ZTM_FUNC;
}
}
break;
}
/* In case we called a function which messed up the display... */
if (resetneeded)
zrefresh();
}
}
Thingy
executenamedcommand(char *prmt)
{
Thingy cmd, retval = NULL;
int l, len, feep = 0, listed = 0, curlist = 0;
int ols = (listshown && validlist), olll = lastlistlen;
char *cmdbuf, *ptr;
char *okeymap = ztrdup(curkeymapname);
clearlist = 1;
/* prmt may be constant */
prmt = ztrdup(prmt);
l = strlen(prmt);
cmdbuf = (char *)zhalloc(l + NAMLEN + 2
#ifdef MULTIBYTE_SUPPORT
+ 2 * MB_CUR_MAX
#endif
);
strcpy(cmdbuf, prmt);
zsfree(prmt);
statusline = cmdbuf;
selectlocalmap(command_keymap);
selectkeymap("main", 1);
ptr = cmdbuf += l;
len = 0;
for (;;) {
*ptr = '_';
ptr[1] = '\0';
zrefresh();
if (!(cmd = getkeycmd()) || cmd == Th(z_sendbreak)) {
statusline = NULL;
selectkeymap(okeymap, 1);
zsfree(okeymap);
if ((listshown = ols)) {
showinglist = -2;
lastlistlen = olll;
} else if (listed)
clearlist = listshown = 1;
retval = NULL;
goto done;
}
if(cmd == Th(z_clearscreen)) {
clearscreen(zlenoargs);
if (curlist) {
int zmultsav = zmult;
zmult = 1;
listlist(namedcmdll);
showinglist = 0;
zmult = zmultsav;
}
} else if(cmd == Th(z_redisplay)) {
redisplay(zlenoargs);
if (curlist) {
int zmultsav = zmult;
zmult = 1;
listlist(namedcmdll);
showinglist = 0;
zmult = zmultsav;
}
} else if(cmd == Th(z_viquotedinsert)) {
*ptr = '^';
zrefresh();
getfullchar(0);
if(LASTFULLCHAR == ZLEEOF || !LASTFULLCHAR || len >= NAMLEN)
feep = 1;
else {
int ret = zlecharasstring(LASTFULLCHAR, ptr);
len += ret;
ptr += ret;
curlist = 0;
}
} else if(cmd == Th(z_quotedinsert)) {
if(getfullchar(0) == ZLEEOF ||
!LASTFULLCHAR || len == NAMLEN)
feep = 1;
else {
int ret = zlecharasstring(LASTFULLCHAR, ptr);
len += ret;
ptr += ret;
curlist = 0;
}
} else if(cmd == Th(z_backwarddeletechar) ||
cmd == Th(z_vibackwarddeletechar)) {
if (len) {
ptr = backwardmetafiedchar(cmdbuf, ptr, NULL);
len = ptr - cmdbuf;
curlist = 0;
}
} else if(cmd == Th(z_killregion) || cmd == Th(z_backwardkillword) ||
cmd == Th(z_vibackwardkillword)) {
if (len)
curlist = 0;
while (len) {
convchar_t cc;
ptr = backwardmetafiedchar(cmdbuf, ptr, &cc);
len = ptr - cmdbuf;
if (cc == ZWC('-'))
break;
}
} else if(cmd == Th(z_killwholeline) || cmd == Th(z_vikillline) ||
cmd == Th(z_backwardkillline)) {
len = 0;
ptr = cmdbuf;
if (listed)
clearlist = listshown = 1;
curlist = 0;
} else if (cmd == Th(z_bracketedpaste)) {
char *insert = bracketedstring();
size_t inslen = strlen(insert);
if (len + inslen > NAMLEN)
feep = 1;
else {
strcpy(ptr, insert);
len += inslen;
ptr += inslen;
if (listed) {
clearlist = listshown = 1;
listed = 0;
} else
curlist = 0;
}
free(insert);
} else {
if(cmd == Th(z_acceptline) || cmd == Th(z_vicmdmode)) {
Thingy r;
unambiguous:
*ptr = 0;
r = rthingy(cmdbuf);
if (!(r->flags & DISABLED)) {
unrefthingy(r);
statusline = NULL;
selectkeymap(okeymap, 1);
zsfree(okeymap);
if ((listshown = ols)) {
showinglist = -2;
lastlistlen = olll;
} else if (listed)
clearlist = listshown = 1;
retval = r;
goto done;
}
unrefthingy(r);
}
if(cmd == Th(z_selfinsertunmeta)) {
fixunmeta();
cmd = Th(z_selfinsert);
}
if (cmd == Th(z_listchoices) || cmd == Th(z_deletecharorlist) ||
cmd == Th(z_expandorcomplete) || cmd == Th(z_completeword) ||
cmd == Th(z_expandorcompleteprefix) || cmd == Th(z_vicmdmode) ||
cmd == Th(z_acceptline) || lastchar == ' ' || lastchar == '\t') {
namedcmdambig = 100;
namedcmdll = newlinklist();
*ptr = '\0';
namedcmdstr = cmdbuf;
scanhashtable(thingytab, 1, 0, DISABLED, scancompcmd, 0);
namedcmdstr = NULL;
if (empty(namedcmdll)) {
feep = 1;
if (listed)
clearlist = listshown = 1;
curlist = 0;
} else if (cmd == Th(z_listchoices) ||
cmd == Th(z_deletecharorlist)) {
int zmultsav = zmult;
*ptr = '_';
ptr[1] = '\0';
zmult = 1;
listlist(namedcmdll);
listed = curlist = 1;
showinglist = 0;
zmult = zmultsav;
} else if (!nextnode(firstnode(namedcmdll))) {
strcpy(ptr = cmdbuf, peekfirst(namedcmdll));
len = strlen(ptr);
ptr += len;
if (cmd == Th(z_acceptline) || cmd == Th(z_vicmdmode))
goto unambiguous;
} else {
strcpy(cmdbuf, peekfirst(namedcmdll));
ptr = cmdbuf + namedcmdambig;
*ptr = '_';
ptr[1] = '\0';
if (isset(AUTOLIST) &&
!(isset(LISTAMBIGUOUS) && namedcmdambig > len)) {
int zmultsav = zmult;
if (isset(LISTBEEP))
feep = 1;
zmult = 1;
listlist(namedcmdll);
listed = curlist = 1;
showinglist = 0;
zmult = zmultsav;
}
len = namedcmdambig;
}
} else {
if (len == NAMLEN || cmd != Th(z_selfinsert))
feep = 1;
else {
#ifdef MULTIBYTE_SUPPORT
if (!lastchar_wide_valid)
getrestchar(lastchar, NULL, NULL);
if (lastchar_wide == WEOF)
feep = 1;
else
#endif
if (ZC_icntrl(LASTFULLCHAR))
feep = 1;
else {
int ret = zlecharasstring(LASTFULLCHAR, ptr);
len += ret;
ptr += ret;
if (listed) {
clearlist = listshown = 1;
listed = 0;
} else
curlist = 0;
}
}
}
}
if (feep)
handlefeep(zlenoargs);
feep = 0;
}
done:
selectlocalmap(NULL);
return retval;
}
void
getredirs(LinkList redirs)
{
LinkNode n;
static char *fstr[] =
{
">", ">|", ">>", ">>|", "&>", "&>|", "&>>", "&>>|", "<>", "<",
"<<", "<<-", "<<<", "<&", ">&", NULL /* >&- */, "<", ">"
};
taddchr(' ');
for (n = firstnode(redirs); n; incnode(n)) {
Redir f = (Redir) getdata(n);
switch (f->type) {
case REDIR_WRITE:
case REDIR_WRITENOW:
case REDIR_APP:
case REDIR_APPNOW:
case REDIR_ERRWRITE:
case REDIR_ERRWRITENOW:
case REDIR_ERRAPP:
case REDIR_ERRAPPNOW:
case REDIR_READ:
case REDIR_READWRITE:
case REDIR_HERESTR:
case REDIR_MERGEIN:
case REDIR_MERGEOUT:
case REDIR_INPIPE:
case REDIR_OUTPIPE:
if (f->varid) {
taddchr('{');
taddstr(f->varid);
taddchr('}');
} else if (f->fd1 != (IS_READFD(f->type) ? 0 : 1))
taddchr('0' + f->fd1);
if (f->type == REDIR_HERESTR &&
(f->flags & REDIRF_FROM_HEREDOC)) {
if (tnewlins) {
/*
* Strings that came from here-documents are converted
* to here strings without quotation, so convert them
* back.
*/
taddstr(fstr[REDIR_HEREDOC]);
taddstr(f->here_terminator);
taddpending(f->name, f->munged_here_terminator);
} else {
int fnamelen, sav;
taddstr(fstr[REDIR_HERESTR]);
/*
* Just a quick and dirty representation.
* Remove a terminating newline, if any.
*/
fnamelen = strlen(f->name);
if (fnamelen > 0 && f->name[fnamelen-1] == '\n') {
sav = 1;
f->name[fnamelen-1] = '\0';
} else
sav = 0;
/*
* Strings that came from here-documents are converted
* to here strings without quotation, so add that
* now. If tokens are present we need to do double quoting.
*/
if (!has_token(f->name)) {
taddchr('\'');
taddstr(quotestring(f->name, NULL, QT_SINGLE));
taddchr('\'');
} else {
taddchr('"');
taddstr(quotestring(f->name, NULL, QT_DOUBLE));
taddchr('"');
}
if (sav)
f->name[fnamelen-1] = '\n';
}
} else {
taddstr(fstr[f->type]);
if (f->type != REDIR_MERGEIN && f->type != REDIR_MERGEOUT)
taddchr(' ');
taddstr(f->name);
}
taddchr(' ');
break;
#ifdef DEBUG
case REDIR_CLOSE:
DPUTS(1, "BUG: CLOSE in getredirs()");
taddchr(f->fd1 + '0');
taddstr(">&- ");
break;
default:
DPUTS(1, "BUG: unknown redirection in getredirs()");
#endif
}
}
tptr--;
}
static int
bin_zselect(char *nam, char **args, UNUSED(Options ops), UNUSED(int func))
{
#ifdef HAVE_SELECT
int i, fd, fdsetind = 0, fdmax = 0, fdcount;
fd_set fdset[3];
const char fdchar[3] = "rwe";
struct timeval tv, *tvptr = NULL;
char *outarray = "reply", **outdata, **outptr;
char *outhash = NULL;
LinkList fdlist;
for (i = 0; i < 3; i++)
FD_ZERO(fdset+i);
for (; *args; args++) {
char *argptr = *args, *endptr;
zlong tempnum;
if (*argptr == '-') {
for (argptr++; *argptr; argptr++) {
switch (*argptr) {
/*
* Array name for reply, if not $reply.
* This gets set to e.g. `-r 0 -w 1' if 0 is ready
* for reading and 1 is ready for writing.
*/
case 'a':
case 'A':
i = *argptr;
if (argptr[1])
argptr++;
else if (args[1]) {
argptr = *++args;
} else {
zwarnnam(nam, "argument expected after -%c", *argptr);
return 1;
}
if (idigit(*argptr) || !isident(argptr)) {
zwarnnam(nam, "invalid array name: %s", argptr);
return 1;
}
if (i == 'a')
outarray = argptr;
else
outhash = argptr;
/* set argptr to next to last char because of increment */
while (argptr[1])
argptr++;
break;
/* Following numbers indicate fd's for reading */
case 'r':
fdsetind = 0;
break;
/* Following numbers indicate fd's for writing */
case 'w':
fdsetind = 1;
break;
/* Following numbers indicate fd's for errors */
case 'e':
fdsetind = 2;
break;
/*
* Get a timeout value in hundredths of a second
* (same units as KEYTIMEOUT). 0 means just poll.
* If not given, blocks indefinitely.
*/
case 't':
if (argptr[1])
argptr++;
else if (args[1]) {
argptr = *++args;
} else {
zwarnnam(nam, "argument expected after -%c", *argptr);
return 1;
}
if (!idigit(*argptr)) {
zwarnnam(nam, "number expected after -t");
return 1;
}
tempnum = zstrtol(argptr, &endptr, 10);
if (*endptr) {
zwarnnam(nam, "garbage after -t argument: %s",
endptr);
return 1;
}
/* timevalue now active */
tvptr = &tv;
tv.tv_sec = (long)(tempnum / 100);
tv.tv_usec = (long)(tempnum % 100) * 10000L;
/* remember argptr is incremented at end of loop */
argptr = endptr - 1;
break;
/* Digits following option without arguments are fd's. */
default:
if (handle_digits(nam, argptr, fdset+fdsetind,
&fdmax))
return 1;
}
}
} else if (handle_digits(nam, argptr, fdset+fdsetind, &fdmax))
return 1;
}
errno = 0;
do {
i = select(fdmax, (SELECT_ARG_2_T)fdset, (SELECT_ARG_2_T)(fdset+1),
(SELECT_ARG_2_T)(fdset+2), tvptr);
} while (i < 0 && errno == EINTR && !errflag);
if (i <= 0) {
if (i < 0)
zwarnnam(nam, "error on select: %e", errno);
/* else no fd's set. Presumably a timeout. */
return 1;
}
/*
* Make a linked list of all file descriptors which are ready.
* These go into an array preceded by -r, -w or -e for read, write,
* error as appropriate. Typically there will only be one set
* so this looks rather like overkill.
*/
fdlist = znewlinklist();
for (i = 0; i < 3; i++) {
int doneit = 0;
for (fd = 0; fd < fdmax; fd++) {
if (FD_ISSET(fd, fdset+i)) {
char buf[BDIGBUFSIZE];
if (outhash) {
/*
* Key/value pairs; keys are fd's (as strings),
* value is a (possibly improper) subset of "rwe".
*/
LinkNode nptr;
int found = 0;
convbase(buf, fd, 10);
for (nptr = firstnode(fdlist); nptr;
nptr = nextnode(nextnode(nptr))) {
if (!strcmp((char *)getdata(nptr), buf)) {
/* Already there, add new character. */
void **dataptr = getaddrdata(nextnode(nptr));
char *data = (char *)*dataptr, *ptr;
found = 1;
if (!strchr(data, fdchar[i])) {
strcpy(buf, data);
for (ptr = buf; *ptr; ptr++)
;
*ptr++ = fdchar[i];
*ptr = '\0';
zsfree(data);
*dataptr = ztrdup(buf);
}
break;
}
}
if (!found) {
/* Add new key/value pair. */
zaddlinknode(fdlist, ztrdup(buf));
buf[0] = fdchar[i];
buf[1] = '\0';
zaddlinknode(fdlist, ztrdup(buf));
}
} else {
/* List of fd's preceded by -r, -w, -e. */
if (!doneit) {
buf[0] = '-';
buf[1] = fdchar[i];
buf[2] = 0;
zaddlinknode(fdlist, ztrdup(buf));
doneit = 1;
}
convbase(buf, fd, 10);
zaddlinknode(fdlist, ztrdup(buf));
}
}
}
}
/* convert list to array */
fdcount = countlinknodes(fdlist);
outptr = outdata = (char **)zalloc((fdcount+1)*sizeof(char *));
while (nonempty(fdlist))
*outptr++ = getlinknode(fdlist);
*outptr = NULL;
/* and store in array parameter */
if (outhash)
sethparam(outhash, outdata);
else
setaparam(outarray, outdata);
freelinklist(fdlist, NULL);
return 0;
#else
/* TODO: use poll */
zerrnam(nam, "your system does not implement the select system call.");
return 2;
#endif
}
static int
bin_sched(char *nam, char **argv, UNUSED(Options ops), UNUSED(int func))
{
char *s, **argptr;
time_t t;
long h, m, sec;
struct tm *tm;
struct schedcmd *sch, *sch2, *schl;
int sn, flags = 0;
/* If the argument begins with a -, remove the specified item from the
schedule. */
for (argptr = argv; *argptr && **argptr == '-'; argptr++) {
char *arg = *argptr + 1;
if (idigit(*arg)) {
sn = atoi(arg);
if (!sn) {
zwarnnam("sched", "usage for delete: sched -<item#>.");
return 1;
}
for (schl = NULL, sch = schedcmds, sn--;
sch && sn; sch = (schl = sch)->next, sn--);
if (!sch) {
zwarnnam("sched", "not that many entries");
return 1;
}
if (schl)
schl->next = sch->next;
else {
scheddeltimed();
schedcmds = sch->next;
if (schedcmds) {
DPUTS(timedfns && firstnode(timedfns), "BUG: already timed fn (2)");
schedaddtimed(schedcmds->time);
}
}
zsfree(sch->cmd);
zfree(sch, sizeof(struct schedcmd));
return 0;
} else if (*arg == '-') {
/* end of options */
argptr++;
break;
} else if (!strcmp(arg, "o")) {
flags |= SCHEDFLAG_TRASH_ZLE;
} else {
if (*arg)
zwarnnam(nam, "bad option: -%c", *arg);
else
zwarnnam(nam, "option expected");
return 1;
}
}
/* given no arguments, display the schedule list */
if (!*argptr) {
for (sn = 1, sch = schedcmds; sch; sch = sch->next, sn++) {
char tbuf[60], *flagstr, *endstr;
time_t t;
struct tm *tmp;
t = sch->time;
tmp = localtime(&t);
ztrftime(tbuf, 40, "%a %b %e %k:%M:%S", tmp, 0L);
if (sch->flags & SCHEDFLAG_TRASH_ZLE)
flagstr = "-o ";
else
flagstr = "";
if (*sch->cmd == '-')
endstr = "-- ";
else
endstr = "";
printf("%3d %s %s%s%s\n", sn, tbuf, flagstr, endstr, sch->cmd);
}
return 0;
} else if (!argptr[1]) {
/* other than the two cases above, sched *
*requires at least two arguments */
zwarnnam("sched", "not enough arguments");
return 1;
}
/* The first argument specifies the time to schedule the command for. The
remaining arguments form the command. */
s = *argptr++;
if (*s == '+') {
/*
* + introduces a relative time. The rest of the argument may be an
* hour:minute offset from the current time. Once the hour and minute
* numbers have been extracted, and the format verified, the resulting
* offset is simply added to the current time.
*/
zlong zl = zstrtol(s + 1, &s, 10);
if (*s == ':') {
m = (long)zstrtol(s + 1, &s, 10);
if (*s == ':')
sec = (long)zstrtol(s + 1, &s, 10);
else
sec = 0;
if (*s) {
zwarnnam("sched", "bad time specifier");
return 1;
}
t = time(NULL) + (long)zl * 3600 + m * 60 + sec;
} else if (!*s) {
/*
* Alternatively, it may simply be a number of seconds.
* This is here for consistency with absolute times.
*/
t = time(NULL) + (time_t)zl;
} else {
zwarnnam("sched", "bad time specifier");
return 1;
}
} else {
/*
* If there is no +, an absolute time must have been given.
* This may be in hour:minute format, optionally followed by a string
* starting with `a' or `p' (for a.m. or p.m.). Characters after the
* `a' or `p' are ignored.
*/
zlong zl = zstrtol(s, &s, 10);
if (*s == ':') {
h = (long)zl;
m = (long)zstrtol(s + 1, &s, 10);
if (*s == ':')
sec = (long)zstrtol(s + 1, &s, 10);
else
sec = 0;
if (*s && *s != 'a' && *s != 'A' && *s != 'p' && *s != 'P') {
zwarnnam("sched", "bad time specifier");
return 1;
}
t = time(NULL);
tm = localtime(&t);
t -= tm->tm_sec + tm->tm_min * 60 + tm->tm_hour * 3600;
if (*s == 'p' || *s == 'P')
h += 12;
t += h * 3600 + m * 60 + sec;
/*
* If the specified time is before the current time, it must refer
* to tomorrow.
*/
if (t < time(NULL))
t += 3600 * 24;
} else if (!*s) {
/*
* Otherwise, it must be a raw time specifier.
*/
t = (long)zl;
} else {
zwarnnam("sched", "bad time specifier");
return 1;
}
}
/* The time has been calculated; now add the new entry to the linked list
of scheduled commands. */
sch = (struct schedcmd *) zalloc(sizeof *sch);
sch->time = t;
sch->cmd = zjoin(argptr, ' ', 0);
sch->flags = flags;
/* Insert into list in time order */
if (schedcmds) {
if (sch->time < schedcmds->time) {
scheddeltimed();
sch->next = schedcmds;
schedcmds = sch;
DPUTS(timedfns && firstnode(timedfns), "BUG: already timed fn (3)");
schedaddtimed(t);
} else {
for (sch2 = schedcmds;
sch2->next && sch2->next->time < sch->time;
sch2 = sch2->next)
;
sch->next = sch2->next;
sch2->next = sch;
}
} else {
sch->next = NULL;
schedcmds = sch;
DPUTS(timedfns && firstnode(timedfns), "BUG: already timed fn (4)");
schedaddtimed(t);
}
return 0;
}
int
execfor(Estate state, int do_exec)
{
Wordcode end, loop;
wordcode code = state->pc[-1];
int iscond = (WC_FOR_TYPE(code) == WC_FOR_COND), ctok = 0, atok = 0;
int last = 0;
char *name, *str, *cond = NULL, *advance = NULL;
zlong val = 0;
LinkList vars = NULL, args = NULL;
int old_simple_pline = simple_pline;
/* See comments in execwhile() */
simple_pline = 1;
end = state->pc + WC_FOR_SKIP(code);
if (iscond) {
str = dupstring(ecgetstr(state, EC_NODUP, NULL));
singsub(&str);
if (isset(XTRACE)) {
char *str2 = dupstring(str);
untokenize(str2);
printprompt4();
fprintf(xtrerr, "%s\n", str2);
fflush(xtrerr);
}
if (!errflag) {
matheval(str);
}
if (errflag) {
state->pc = end;
simple_pline = old_simple_pline;
return 1;
}
cond = ecgetstr(state, EC_NODUP, &ctok);
advance = ecgetstr(state, EC_NODUP, &atok);
} else {
vars = ecgetlist(state, *state->pc++, EC_NODUP, NULL);
if (WC_FOR_TYPE(code) == WC_FOR_LIST) {
int htok = 0;
if (!(args = ecgetlist(state, *state->pc++, EC_DUPTOK, &htok))) {
state->pc = end;
simple_pline = old_simple_pline;
return 0;
}
if (htok) {
execsubst(args);
if (errflag) {
state->pc = end;
simple_pline = old_simple_pline;
return 1;
}
}
} else {
char **x;
args = newlinklist();
for (x = pparams; *x; x++)
addlinknode(args, dupstring(*x));
}
}
if (!args || empty(args))
lastval = 0;
loops++;
pushheap();
cmdpush(CS_FOR);
loop = state->pc;
while (!last) {
if (iscond) {
if (ctok) {
str = dupstring(cond);
singsub(&str);
} else
str = cond;
if (!errflag) {
while (iblank(*str))
str++;
if (*str) {
if (isset(XTRACE)) {
printprompt4();
fprintf(xtrerr, "%s\n", str);
fflush(xtrerr);
}
val = mathevali(str);
} else
val = 1;
}
if (errflag) {
if (breaks)
breaks--;
lastval = 1;
break;
}
if (!val)
break;
} else {
LinkNode node;
int count = 0;
for (node = firstnode(vars); node; incnode(node))
{
name = (char *)getdata(node);
if (!args || !(str = (char *) ugetnode(args)))
{
if (count) {
str = "";
last = 1;
} else
break;
}
if (isset(XTRACE)) {
printprompt4();
fprintf(xtrerr, "%s=%s\n", name, str);
fflush(xtrerr);
}
setsparam(name, ztrdup(str));
count++;
}
if (!count)
break;
}
state->pc = loop;
execlist(state, 1, do_exec && args && empty(args));
if (breaks) {
breaks--;
if (breaks || !contflag)
break;
contflag = 0;
}
if (retflag)
break;
if (iscond && !errflag) {
if (atok) {
str = dupstring(advance);
singsub(&str);
} else
str = advance;
if (isset(XTRACE)) {
printprompt4();
fprintf(xtrerr, "%s\n", str);
fflush(xtrerr);
}
if (!errflag)
matheval(str);
}
if (errflag) {
if (breaks)
breaks--;
lastval = 1;
break;
}
freeheap();
}
popheap();
cmdpop();
loops--;
simple_pline = old_simple_pline;
state->pc = end;
return lastval;
}
int
execselect(Estate state, UNUSED(int do_exec))
{
Wordcode end, loop;
wordcode code = state->pc[-1];
char *str, *s, *name;
LinkNode n;
int i, usezle;
FILE *inp;
size_t more;
LinkList args;
int old_simple_pline = simple_pline;
/* See comments in execwhile() */
simple_pline = 1;
end = state->pc + WC_FOR_SKIP(code);
name = ecgetstr(state, EC_NODUP, NULL);
if (WC_SELECT_TYPE(code) == WC_SELECT_PPARAM) {
char **x;
args = newlinklist();
for (x = pparams; *x; x++)
addlinknode(args, dupstring(*x));
} else {
int htok = 0;
if (!(args = ecgetlist(state, *state->pc++, EC_DUPTOK, &htok))) {
state->pc = end;
simple_pline = old_simple_pline;
return 0;
}
if (htok) {
execsubst(args);
if (errflag) {
state->pc = end;
simple_pline = old_simple_pline;
return 1;
}
}
}
if (!args || empty(args)) {
state->pc = end;
simple_pline = old_simple_pline;
return 0;
}
loops++;
pushheap();
cmdpush(CS_SELECT);
usezle = interact && SHTTY != -1 && isset(USEZLE);
inp = fdopen(dup(usezle ? SHTTY : 0), "r");
more = selectlist(args, 0);
loop = state->pc;
for (;;) {
for (;;) {
if (empty(bufstack)) {
if (usezle) {
int oef = errflag;
isfirstln = 1;
str = zleentry(ZLE_CMD_READ, &prompt3, NULL,
0, ZLCON_SELECT);
if (errflag)
str = NULL;
/* Keep any user interrupt error status */
errflag = oef | (errflag & ERRFLAG_INT);
} else {
str = promptexpand(prompt3, 0, NULL, NULL, NULL);
zputs(str, stderr);
free(str);
fflush(stderr);
str = fgets(zhalloc(256), 256, inp);
}
} else
str = (char *)getlinknode(bufstack);
if (!str && !errflag)
setsparam("REPLY", ztrdup("")); /* EOF (user pressed Ctrl+D) */
if (!str || errflag) {
if (breaks)
breaks--;
fprintf(stderr, "\n");
fflush(stderr);
goto done;
}
if ((s = strchr(str, '\n')))
*s = '\0';
if (*str)
break;
more = selectlist(args, more);
}
setsparam("REPLY", ztrdup(str));
i = atoi(str);
if (!i)
str = "";
else {
for (i--, n = firstnode(args); n && i; incnode(n), i--);
if (n)
str = (char *) getdata(n);
else
str = "";
}
setsparam(name, ztrdup(str));
state->pc = loop;
execlist(state, 1, 0);
freeheap();
if (breaks) {
breaks--;
if (breaks || !contflag)
break;
contflag = 0;
}
if (retflag || errflag)
break;
}
done:
cmdpop();
popheap();
fclose(inp);
loops--;
simple_pline = old_simple_pline;
state->pc = end;
return lastval;
}
static int
bin_ztcp(char *nam, char **args, Options ops, UNUSED(int func))
{
int herrno, err=1, destport, force=0, verbose=0, test=0, targetfd=0;
ZSOCKLEN_T len;
char **addrp, *desthost;
const char *localname, *remotename;
struct hostent *zthost = NULL, *ztpeer = NULL;
struct servent *srv;
Tcp_session sess = NULL;
if (OPT_ISSET(ops,'f'))
force = 1;
if (OPT_ISSET(ops,'v'))
verbose = 1;
if (OPT_ISSET(ops,'t'))
test = 1;
if (OPT_ISSET(ops,'d')) {
targetfd = atoi(OPT_ARG(ops,'d'));
if (!targetfd) {
zwarnnam(nam, "%s is an invalid argument to -d", OPT_ARG(ops,'d'));
return 1;
}
}
if (OPT_ISSET(ops,'c')) {
if (!args[0]) {
tcp_cleanup();
}
else {
targetfd = atoi(args[0]);
sess = zts_byfd(targetfd);
if(!targetfd) {
zwarnnam(nam, "%s is an invalid argument to -c", args[0]);
return 1;
}
if (sess)
{
if ((sess->flags & ZTCP_ZFTP) && !force)
{
zwarnnam(nam, "use -f to force closure of a zftp control connection");
return 1;
}
tcp_close(sess);
return 0;
}
else
{
zwarnnam(nam, "fd %s not found in tcp table", args[0]);
return 1;
}
}
}
else if (OPT_ISSET(ops,'l')) {
int lport = 0;
if (!args[0]) {
zwarnnam(nam, "-l requires an argument");
return 1;
}
srv = getservbyname(args[0], "tcp");
if (srv)
lport = srv->s_port;
else
lport = htons(atoi(args[0]));
if (!lport) { zwarnnam(nam, "bad service name or port number");
return 1;
}
sess = tcp_socket(PF_INET, SOCK_STREAM, 0, ZTCP_LISTEN);
if (!sess) {
zwarnnam(nam, "unable to allocate a TCP session slot");
return 1;
}
#ifdef SO_OOBINLINE
len = 1;
setsockopt(sess->fd, SOL_SOCKET, SO_OOBINLINE, (char *)&len, sizeof(len));
#endif
if (!zsh_inet_aton("0.0.0.0", &(sess->sock.in.sin_addr)))
{
zwarnnam(nam, "bad address: %s", "0.0.0.0");
return 1;
}
sess->sock.in.sin_family = AF_INET;
sess->sock.in.sin_port = lport;
if (bind(sess->fd, (struct sockaddr *)&sess->sock.in, sizeof(struct sockaddr_in)))
{
char buf[DIGBUFSIZE];
convbase(buf, (zlong)ntohs(lport), 10);
zwarnnam(nam, "could not bind to port %s: %e", buf, errno);
tcp_close(sess);
return 1;
}
if (listen(sess->fd, 1))
{
zwarnnam(nam, "could not listen on socket: %e", errno);
tcp_close(sess);
return 1;
}
if (targetfd) {
sess->fd = redup(sess->fd, targetfd);
}
else {
/* move the fd since no one will want to read from it */
sess->fd = movefd(sess->fd);
}
if (sess->fd == -1) {
zwarnnam(nam, "cannot duplicate fd %d: %e", sess->fd, errno);
tcp_close(sess);
return 1;
}
setiparam_no_convert("REPLY", (zlong)sess->fd);
if (verbose)
printf("%d listener is on fd %d\n", ntohs(sess->sock.in.sin_port), sess->fd);
return 0;
}
else if (OPT_ISSET(ops,'a'))
{
int lfd, rfd;
if (!args[0]) {
zwarnnam(nam, "-a requires an argument");
return 1;
}
lfd = atoi(args[0]);
if (!lfd) {
zwarnnam(nam, "invalid numerical argument");
return 1;
}
sess = zts_byfd(lfd);
if (!sess) {
zwarnnam(nam, "fd %s is not registered as a tcp connection", args[0]);
return 1;
}
if (!(sess->flags & ZTCP_LISTEN))
{
zwarnnam(nam, "tcp connection not a listener");
return 1;
}
if (test) {
#if defined(HAVE_POLL) || defined(HAVE_SELECT)
# ifdef HAVE_POLL
struct pollfd pfd;
int ret;
pfd.fd = lfd;
pfd.events = POLLIN;
if ((ret = poll(&pfd, 1, 0)) == 0) return 1;
else if (ret == -1)
{
zwarnnam(nam, "poll error: %e", errno);
return 1;
}
# else
fd_set rfds;
struct timeval tv;
int ret;
FD_ZERO(&rfds);
FD_SET(lfd, &rfds);
tv.tv_sec = 0;
tv.tv_usec = 0;
if ((ret = select(lfd+1, &rfds, NULL, NULL, &tv)) == 0) return 1;
else if (ret == -1)
{
zwarnnam(nam, "select error: %e", errno);
return 1;
}
# endif
#else
zwarnnam(nam, "not currently supported");
return 1;
#endif
}
sess = zts_alloc(ZTCP_INBOUND);
len = sizeof(sess->peer.in);
do {
rfd = accept(lfd, (struct sockaddr *)&sess->peer.in, &len);
} while (rfd < 0 && errno == EINTR && !errflag);
if (rfd == -1) {
zwarnnam(nam, "could not accept connection: %e", errno);
tcp_close(sess);
return 1;
}
/* redup expects fd is already registered */
addmodulefd(rfd, FDT_MODULE);
if (targetfd) {
sess->fd = redup(rfd, targetfd);
if (sess->fd < 0) {
zerrnam(nam, "could not duplicate socket fd to %d: %e", targetfd, errno);
return 1;
}
}
else {
sess->fd = rfd;
}
setiparam_no_convert("REPLY", (zlong)sess->fd);
if (verbose)
printf("%d is on fd %d\n", ntohs(sess->peer.in.sin_port), sess->fd);
}
else
{
if (!args[0]) {
LinkNode node;
for(node = firstnode(ztcp_sessions); node; incnode(node))
{
sess = (Tcp_session)getdata(node);
if (sess->fd != -1)
{
zthost = gethostbyaddr((const void *)&(sess->sock.in.sin_addr), sizeof(sess->sock.in.sin_addr), AF_INET);
if (zthost)
localname = zthost->h_name;
else
localname = inet_ntoa(sess->sock.in.sin_addr);
ztpeer = gethostbyaddr((const void *)&(sess->peer.in.sin_addr), sizeof(sess->peer.in.sin_addr), AF_INET);
if (ztpeer)
remotename = ztpeer->h_name;
else
remotename = inet_ntoa(sess->peer.in.sin_addr);
if (OPT_ISSET(ops,'L')) {
int schar;
if (sess->flags & ZTCP_ZFTP)
schar = 'Z';
else if (sess->flags & ZTCP_LISTEN)
schar = 'L';
else if (sess->flags & ZTCP_INBOUND)
schar = 'I';
else
schar = 'O';
printf("%d %c %s %d %s %d\n",
sess->fd, schar,
localname, ntohs(sess->sock.in.sin_port),
remotename, ntohs(sess->peer.in.sin_port));
} else {
printf("%s:%d %s %s:%d is on fd %d%s\n",
localname, ntohs(sess->sock.in.sin_port),
((sess->flags & ZTCP_LISTEN) ? "-<" :
((sess->flags & ZTCP_INBOUND) ? "<-" : "->")),
remotename, ntohs(sess->peer.in.sin_port),
sess->fd,
(sess->flags & ZTCP_ZFTP) ? " ZFTP" : "");
}
}
}
return 0;
}
else if (!args[1]) {
destport = htons(23);
}
else {
srv = getservbyname(args[1],"tcp");
if (srv)
destport = srv->s_port;
else
destport = htons(atoi(args[1]));
}
desthost = ztrdup(args[0]);
zthost = zsh_getipnodebyname(desthost, AF_INET, 0, &herrno);
if (!zthost || errflag) {
zwarnnam(nam, "host resolution failure: %s", desthost);
zsfree(desthost);
return 1;
}
sess = tcp_socket(PF_INET, SOCK_STREAM, 0, 0);
if (!sess) {
zwarnnam(nam, "unable to allocate a TCP session slot");
zsfree(desthost);
return 1;
}
#ifdef SO_OOBINLINE
len = 1;
setsockopt(sess->fd, SOL_SOCKET, SO_OOBINLINE, (char *)&len, sizeof(len));
#endif
if (sess->fd < 0) {
zwarnnam(nam, "socket creation failed: %e", errno);
zsfree(desthost);
zts_delete(sess);
return 1;
}
for (addrp = zthost->h_addr_list; err && *addrp; addrp++) {
if (zthost->h_length != 4)
zwarnnam(nam, "address length mismatch");
do {
err = tcp_connect(sess, *addrp, zthost, destport);
} while (err && errno == EINTR && !errflag);
}
if (err) {
zwarnnam(nam, "connection failed: %e", errno);
tcp_close(sess);
zsfree(desthost);
return 1;
}
else
{
if (targetfd) {
sess->fd = redup(sess->fd, targetfd);
if (sess->fd < 0) {
zerrnam(nam, "could not duplicate socket fd to %d: %e", targetfd, errno);
zsfree(desthost);
tcp_close(sess);
return 1;
}
}
setiparam_no_convert("REPLY", (zlong)sess->fd);
if (verbose)
printf("%s:%d is now on fd %d\n",
desthost, destport, sess->fd);
}
zsfree(desthost);
}
return 0;
}
static int
raw_getbyte(long do_keytmout, char *cptr)
{
int ret;
struct ztmout tmout;
#if defined(HAS_TIO) && \
(defined(sun) || (!defined(HAVE_POLL) && !defined(HAVE_SELECT)))
struct ttyinfo ti;
#endif
#ifndef HAVE_POLL
# ifdef HAVE_SELECT
fd_set foofd, errfd;
FD_ZERO(&errfd);
# endif
#endif
calc_timeout(&tmout, do_keytmout);
/*
* Handle timeouts and watched fd's. If a watched fd or a function
* timeout triggers we restart any key timeout. This is likely to
* be harmless: the combination is extremely rare and a function
* is likely to occupy the user for a little while anyway. We used
* to make timeouts take precedence, but we can't now that the
* timeouts may be external, so we may have both a permanent watched
* fd and a long-term timeout.
*/
if ((nwatch || tmout.tp != ZTM_NONE)) {
#if defined(HAVE_SELECT) || defined(HAVE_POLL)
int i, errtry = 0, selret;
# ifdef HAVE_POLL
int nfds;
struct pollfd *fds;
# endif
# if defined(HAS_TIO) && defined(sun)
/*
* Yes, I know this is complicated. Yes, I know we
* already have three bits of code to poll the terminal
* down below. No, I don't want to do this either.
* However, it turns out on certain OSes, specifically
* Solaris, that you can't poll typeahead for love nor
* money without actually trying to read it. But
* if we are trying to select (and we need to if we
* are watching other fd's) we won't pick that up.
* So we just try and read it without blocking in
* the time-honoured (i.e. absurdly baroque) termios
* fashion.
*/
gettyinfo(&ti);
ti.tio.c_cc[VMIN] = 0;
settyinfo(&ti);
winch_unblock();
ret = read(SHTTY, cptr, 1);
winch_block();
ti.tio.c_cc[VMIN] = 1;
settyinfo(&ti);
if (ret > 0)
return 1;
# endif
# ifdef HAVE_POLL
nfds = 1 + nwatch;
/* First pollfd is SHTTY, following are the nwatch fds */
fds = zalloc(sizeof(struct pollfd) * nfds);
fds[0].fd = SHTTY;
/*
* POLLIN, POLLIN, POLLIN,
* Keep those fd's POLLIN...
*/
fds[0].events = POLLIN;
for (i = 0; i < nwatch; i++) {
fds[i+1].fd = watch_fds[i].fd;
fds[i+1].events = POLLIN;
}
# endif
for (;;) {
# ifdef HAVE_POLL
int poll_timeout;
if (tmout.tp != ZTM_NONE)
poll_timeout = tmout.exp100ths * 10;
else
poll_timeout = -1;
winch_unblock();
selret = poll(fds, errtry ? 1 : nfds, poll_timeout);
winch_block();
# else
int fdmax = SHTTY;
struct timeval *tvptr;
struct timeval expire_tv;
FD_ZERO(&foofd);
FD_SET(SHTTY, &foofd);
if (!errtry) {
for (i = 0; i < nwatch; i++) {
int fd = watch_fds[i].fd;
if (FD_ISSET(fd, &errfd))
continue;
FD_SET(fd, &foofd);
if (fd > fdmax)
fdmax = fd;
}
}
FD_ZERO(&errfd);
if (tmout.tp != ZTM_NONE) {
expire_tv.tv_sec = tmout.exp100ths / 100;
expire_tv.tv_usec = (tmout.exp100ths % 100) * 10000L;
tvptr = &expire_tv;
}
else
tvptr = NULL;
winch_unblock();
selret = select(fdmax+1, (SELECT_ARG_2_T) & foofd,
NULL, NULL, tvptr);
winch_block();
# endif
/*
* Make sure a user interrupt gets passed on straight away.
*/
if (selret < 0 && (errflag || retflag || breaks || exit_pending))
break;
/*
* Try to avoid errors on our special fd's from
* messing up reads from the terminal. Try first
* with all fds, then try unsetting the special ones.
*/
if (selret < 0 && !errtry) {
errtry = 1;
continue;
}
if (selret == 0) {
/*
* Nothing ready and no error, so we timed out.
*/
switch (tmout.tp) {
case ZTM_NONE:
/* keeps compiler happy if not debugging */
#ifdef DEBUG
dputs("BUG: timeout fired with no timeout set.");
#endif
/* treat as if a key timeout triggered */
/*FALLTHROUGH*/
case ZTM_KEY:
/* Special value -2 signals nothing ready */
selret = -2;
break;
case ZTM_FUNC:
while (firstnode(timedfns)) {
Timedfn tfdat = (Timedfn)getdata(firstnode(timedfns));
/*
* It's possible a previous function took
* a long time to run (though it can't
* call zle recursively), so recalculate
* the time on each iteration.
*/
time_t now = time(NULL);
if (tfdat->when > now)
break;
tfdat->func();
}
/* Function may have messed up the display */
if (resetneeded)
zrefresh();
/* We need to recalculate the timeout */
/*FALLTHROUGH*/
case ZTM_MAX:
/*
* Reached the limit of our range, but not the
* actual timeout; recalculate the timeout.
* We're cheating with the key timeout here:
* if one clashed with a function timeout we
* reconsider the key timeout from scratch.
* The effect of this is microscopic.
*/
calc_timeout(&tmout, do_keytmout);
break;
}
/*
* If we handled the timeout successfully,
* carry on.
*/
if (selret == 0)
continue;
}
/* If error or unhandled timeout, give up. */
if (selret < 0)
break;
/*
* If there's user input handle it straight away.
* This improves the user's ability to handle exceptional
* conditions like runaway output.
*/
if (
# ifdef HAVE_POLL
(fds[0].revents & POLLIN)
# else
FD_ISSET(SHTTY, &foofd)
# endif
)
break;
if (nwatch && !errtry) {
/*
* Copy the details of the watch fds in case the
* user decides to delete one from inside the
* handler function.
*/
int lnwatch = nwatch;
Watch_fd lwatch_fds = zalloc(lnwatch*sizeof(struct watch_fd));
memcpy(lwatch_fds, watch_fds, lnwatch*sizeof(struct watch_fd));
for (i = 0; i < lnwatch; i++)
lwatch_fds[i].func = ztrdup(lwatch_fds[i].func);
for (i = 0; i < lnwatch; i++) {
Watch_fd lwatch_fd = lwatch_fds + i;
if (
# ifdef HAVE_POLL
(fds[i+1].revents & (POLLIN|POLLERR|POLLHUP|POLLNVAL))
# else
FD_ISSET(lwatch_fd->fd, &foofd) ||
FD_ISSET(lwatch_fd->fd, &errfd)
# endif
) {
/* Handle the fd. */
char *fdbuf;
{
char buf[BDIGBUFSIZE];
convbase(buf, lwatch_fd->fd, 10);
fdbuf = ztrdup(buf);
}
if (lwatch_fd->widget) {
zlecallhook(lwatch_fd->func, fdbuf);
zsfree(fdbuf);
} else {
LinkList funcargs = znewlinklist();
zaddlinknode(funcargs, ztrdup(lwatch_fd->func));
zaddlinknode(funcargs, fdbuf);
# ifdef HAVE_POLL
# ifdef POLLERR
if (fds[i+1].revents & POLLERR)
zaddlinknode(funcargs, ztrdup("err"));
# endif
# ifdef POLLHUP
if (fds[i+1].revents & POLLHUP)
zaddlinknode(funcargs, ztrdup("hup"));
# endif
# ifdef POLLNVAL
if (fds[i+1].revents & POLLNVAL)
zaddlinknode(funcargs, ztrdup("nval"));
# endif
# else
if (FD_ISSET(lwatch_fd->fd, &errfd))
zaddlinknode(funcargs, ztrdup("err"));
# endif
callhookfunc(lwatch_fd->func, funcargs, 0, NULL);
freelinklist(funcargs, freestr);
}
if (errflag) {
/* No sensible way of handling errors here */
errflag &= ~ERRFLAG_ERROR;
/*
* Paranoia: don't run the hooks again this
* time.
*/
errtry = 1;
}
}
}
/* Function may have invalidated the display. */
if (resetneeded)
zrefresh();
for (i = 0; i < lnwatch; i++)
zsfree(lwatch_fds[i].func);
zfree(lwatch_fds, lnwatch*sizeof(struct watch_fd));
# ifdef HAVE_POLL
/* Function may have added or removed handlers */
nfds = 1 + nwatch;
if (nfds > 1) {
fds = zrealloc(fds, sizeof(struct pollfd) * nfds);
for (i = 0; i < nwatch; i++) {
/*
* This is imperfect because it assumes fds[] and
* watch_fds[] remain in sync, which may be false
* if handlers are shuffled. However, it should
* be harmless (e.g., produce one extra pass of
* the loop) in the event they fall out of sync.
*/
if (fds[i+1].fd == watch_fds[i].fd &&
(fds[i+1].revents & (POLLERR|POLLHUP|POLLNVAL))) {
fds[i+1].events = 0; /* Don't poll this */
} else {
fds[i+1].fd = watch_fds[i].fd;
fds[i+1].events = POLLIN;
}
fds[i+1].revents = 0;
}
}
# endif
}
}
# ifdef HAVE_POLL
zfree(fds, sizeof(struct pollfd) * nfds);
# endif
if (selret < 0)
return selret;
#else
# ifdef HAS_TIO
ti = shttyinfo;
ti.tio.c_lflag &= ~ICANON;
ti.tio.c_cc[VMIN] = 0;
ti.tio.c_cc[VTIME] = tmout.exp100ths / 10;
# ifdef HAVE_TERMIOS_H
tcsetattr(SHTTY, TCSANOW, &ti.tio);
# else
ioctl(SHTTY, TCSETA, &ti.tio);
# endif
winch_unblock();
ret = read(SHTTY, cptr, 1);
winch_block();
# ifdef HAVE_TERMIOS_H
tcsetattr(SHTTY, TCSANOW, &shttyinfo.tio);
# else
ioctl(SHTTY, TCSETA, &shttyinfo.tio);
# endif
return (ret <= 0) ? ret : *cptr;
# endif
#endif
}
winch_unblock();
ret = read(SHTTY, cptr, 1);
winch_block();
return ret;
}
static mnumber
callmathfunc(char *o)
{
MathFunc f;
char *a, *n;
static mnumber dummy;
n = a = dupstring(o);
while (*a != '(')
a++;
*a++ = '\0';
a[strlen(a) - 1] = '\0';
if ((f = getmathfunc(n, 1))) {
if (f->flags & MFF_STR) {
return f->sfunc(n, a, f->funcid);
} else {
int argc = 0;
mnumber *argv = NULL, *q, marg;
LinkList l = newlinklist();
LinkNode node;
if (f->flags & MFF_USERFUNC) {
/* first argument is function name: always use mathfunc */
addlinknode(l, n);
}
while (iblank(*a))
a++;
while (*a) {
if (*a) {
argc++;
if (f->flags & MFF_USERFUNC) {
/* need to pass strings */
char *str;
marg = mathevall(a, MPREC_ARG, &a);
if (marg.type & MN_FLOAT) {
/* convfloat is off the heap */
str = convfloat(marg.u.d, 0, 0, NULL);
} else {
char buf[BDIGBUFSIZE];
convbase(buf, marg.u.l, 10);
str = dupstring(buf);
}
addlinknode(l, str);
} else {
q = (mnumber *) zhalloc(sizeof(mnumber));
*q = mathevall(a, MPREC_ARG, &a);
addlinknode(l, q);
}
if (errflag || mtok != COMMA)
break;
}
}
if (*a && !errflag)
zerr("bad math expression: illegal character: %c", *a);
if (!errflag) {
if (argc >= f->minargs && (f->maxargs < 0 ||
argc <= f->maxargs)) {
if (f->flags & MFF_USERFUNC) {
char *shfnam = f->module ? f->module : n;
Shfunc shfunc = getshfunc(shfnam);
if (!shfunc)
zerr("no such function: %s", shfnam);
else {
doshfunc(shfunc, l, 1);
return lastmathval;
}
} else {
if (argc) {
q = argv =
(mnumber *)zhalloc(argc * sizeof(mnumber));
for (node = firstnode(l); node; incnode(node))
*q++ = *(mnumber *)getdata(node);
}
return f->nfunc(n, argc, argv, f->funcid);
}
} else
zerr("wrong number of arguments: %s", o);
}
}
} else {
zerr("unknown function: %s", n);
}
dummy.type = MN_INTEGER;
dummy.u.l = 0;
return dummy;
}
