#include "expect_cf.h"
#include <stdio.h>
#include <setjmp.h>
#ifdef HAVE_INTTYPES_H
# include <inttypes.h>
#endif
#include <sys/types.h>
#include <sys/ioctl.h>
#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
# include <sys/time.h>
# else
# include <time.h>
# endif
#endif
#ifdef CRAY
# ifndef TCSETCTTY
# if defined(HAVE_TERMIOS)
# include <termios.h>
# else
# include <termio.h>
# endif
# endif
#endif
#ifdef HAVE_SYS_FCNTL_H
# include <sys/fcntl.h>
#else
# include <fcntl.h>
#endif
#ifdef HAVE_STRREDIR_H
#include <sys/strredir.h>
# ifdef SRIOCSREDIR
# undef TIOCCONS
# endif
#endif
#include <signal.h>
#include "string.h"
#include <errno.h>
#ifdef NO_STDLIB_H
#ifndef _STDLIB
#define _STDLIB
#include <tcl.h>
extern void abort _ANSI_ARGS_((void));
extern double atof _ANSI_ARGS_((CONST char *string));
extern int atoi _ANSI_ARGS_((CONST char *string));
extern long atol _ANSI_ARGS_((CONST char *string));
extern char * calloc _ANSI_ARGS_((unsigned int numElements,
unsigned int size));
extern void exit _ANSI_ARGS_((int status));
extern int free _ANSI_ARGS_((char *blockPtr));
extern char * getenv _ANSI_ARGS_((CONST char *name));
extern char * malloc _ANSI_ARGS_((unsigned int numBytes));
extern void qsort _ANSI_ARGS_((VOID *base, int n, int size,
int (*compar)(CONST VOID *element1, CONST VOID
*element2)));
extern char * realloc _ANSI_ARGS_((char *ptr, unsigned int numBytes));
extern double strtod _ANSI_ARGS_((CONST char *string, char **endPtr));
extern long strtol _ANSI_ARGS_((CONST char *string, char **endPtr,
int base));
extern unsigned long strtoul _ANSI_ARGS_((CONST char *string,
char **endPtr, int base));
#endif
#else
#include <stdlib.h>
#endif
#include "expect.h"
#define TclRegError exp_TclRegError
#if 0
#include "tclInt.h"
#include "tclPort.h"
#endif
static char *errMsg = NULL;
#define END 0
#define BOL 1
#define EOL 2
#define ANY 3
#define ANYOF 4
#define ANYBUT 5
#define BRANCH 6
#define BACK 7
#define EXACTLY 8
#define NOTHING 9
#define STAR 10
#define PLUS 11
#define OPEN 20
#define CLOSE (OPEN+NSUBEXP)
#define OP(p) (*(p))
#define NEXT(p) (((*((p)+1)&0377)<<8) + (*((p)+2)&0377))
#define OPERAND(p) ((p) + 3)
#ifndef CHARBITS
#define UCHARAT(p) ((int)*(unsigned char *)(p))
#else
#define UCHARAT(p) ((int)*(p)&CHARBITS)
#endif
#define FAIL(m) { TclRegError(m); return(NULL); }
#define ISMULT(c) ((c) == '*' || (c) == '+' || (c) == '?')
#define META "^$.[()|?+*\\"
#define HASWIDTH 01
#define SIMPLE 02
#define SPSTART 04
#define WORST 0
struct regcomp_state {
char *regparse;
int regnpar;
char *regcode;
long regsize;
};
static char regdummy;
#define MAGIC 0234
static char * reg _ANSI_ARGS_((int paren, int *flagp,
struct regcomp_state *rcstate));
static char * regatom _ANSI_ARGS_((int *flagp,
struct regcomp_state *rcstate));
static char * regbranch _ANSI_ARGS_((int *flagp,
struct regcomp_state *rcstate));
static void regc _ANSI_ARGS_((int b,
struct regcomp_state *rcstate));
static void reginsert _ANSI_ARGS_((int op, char *opnd,
struct regcomp_state *rcstate));
static char * regnext _ANSI_ARGS_((char *p));
static char * regnode _ANSI_ARGS_((int op,
struct regcomp_state *rcstate));
static void regoptail _ANSI_ARGS_((char *p, char *val));
static char * regpiece _ANSI_ARGS_((int *flagp,
struct regcomp_state *rcstate));
static void regtail _ANSI_ARGS_((char *p, char *val));
#ifdef STRCSPN
static int strcspn _ANSI_ARGS_((char *s1, char *s2));
#endif
regexp *
TclRegComp(exp)
char *exp;
{
register regexp *r;
register char *scan;
register char *longest;
register int len;
int flags;
struct regcomp_state state;
struct regcomp_state *rcstate= &state;
if (exp == NULL)
FAIL("NULL argument");
rcstate->regparse = exp;
rcstate->regnpar = 1;
rcstate->regsize = 0L;
rcstate->regcode = ®dummy;
regc(MAGIC, rcstate);
if (reg(0, &flags, rcstate) == NULL)
return(NULL);
if (rcstate->regsize >= 32767L)
FAIL("regexp too big");
r = (regexp *)ckalloc(sizeof(regexp) + (unsigned)rcstate->regsize);
if (r == NULL)
FAIL("out of space");
rcstate->regparse = exp;
rcstate->regnpar = 1;
rcstate->regcode = r->program;
regc(MAGIC, rcstate);
if (reg(0, &flags, rcstate) == NULL)
return(NULL);
r->regstart = '\0';
r->reganch = 0;
r->regmust = NULL;
r->regmlen = 0;
scan = r->program+1;
if (OP(regnext(scan)) == END) {
scan = OPERAND(scan);
if (OP(scan) == EXACTLY)
r->regstart = *OPERAND(scan);
else if (OP(scan) == BOL)
r->reganch++;
if (flags&SPSTART) {
longest = NULL;
len = 0;
for (; scan != NULL; scan = regnext(scan))
if (OP(scan) == EXACTLY && ((int) strlen(OPERAND(scan))) >= len) {
longest = OPERAND(scan);
len = strlen(OPERAND(scan));
}
r->regmust = longest;
r->regmlen = len;
}
}
return(r);
}
static char *
reg(paren, flagp, rcstate)
int paren;
int *flagp;
struct regcomp_state *rcstate;
{
register char *ret;
register char *br;
register char *ender;
register int parno = 0;
int flags;
*flagp = HASWIDTH;
if (paren) {
if (rcstate->regnpar >= NSUBEXP)
FAIL("too many ()");
parno = rcstate->regnpar;
rcstate->regnpar++;
ret = regnode(OPEN+parno,rcstate);
} else
ret = NULL;
br = regbranch(&flags,rcstate);
if (br == NULL)
return(NULL);
if (ret != NULL)
regtail(ret, br);
else
ret = br;
if (!(flags&HASWIDTH))
*flagp &= ~HASWIDTH;
*flagp |= flags&SPSTART;
while (*rcstate->regparse == '|') {
rcstate->regparse++;
br = regbranch(&flags,rcstate);
if (br == NULL)
return(NULL);
regtail(ret, br);
if (!(flags&HASWIDTH))
*flagp &= ~HASWIDTH;
*flagp |= flags&SPSTART;
}
ender = regnode((paren) ? CLOSE+parno : END,rcstate);
regtail(ret, ender);
for (br = ret; br != NULL; br = regnext(br))
regoptail(br, ender);
if (paren && *rcstate->regparse++ != ')') {
FAIL("unmatched ()");
} else if (!paren && *rcstate->regparse != '\0') {
if (*rcstate->regparse == ')') {
FAIL("unmatched ()");
} else
FAIL("junk on end");
}
return(ret);
}
static char *
regbranch(flagp, rcstate)
int *flagp;
struct regcomp_state *rcstate;
{
register char *ret;
register char *chain;
register char *latest;
int flags;
*flagp = WORST;
ret = regnode(BRANCH,rcstate);
chain = NULL;
while (*rcstate->regparse != '\0' && *rcstate->regparse != '|' &&
*rcstate->regparse != ')') {
latest = regpiece(&flags, rcstate);
if (latest == NULL)
return(NULL);
*flagp |= flags&HASWIDTH;
if (chain == NULL)
*flagp |= flags&SPSTART;
else
regtail(chain, latest);
chain = latest;
}
if (chain == NULL)
(void) regnode(NOTHING,rcstate);
return(ret);
}
static char *
regpiece(flagp, rcstate)
int *flagp;
struct regcomp_state *rcstate;
{
register char *ret;
register char op;
register char *next;
int flags;
ret = regatom(&flags,rcstate);
if (ret == NULL)
return(NULL);
op = *rcstate->regparse;
if (!ISMULT(op)) {
*flagp = flags;
return(ret);
}
if (!(flags&HASWIDTH) && op != '?')
FAIL("*+ operand could be empty");
*flagp = (op != '+') ? (WORST|SPSTART) : (WORST|HASWIDTH);
if (op == '*' && (flags&SIMPLE))
reginsert(STAR, ret, rcstate);
else if (op == '*') {
reginsert(BRANCH, ret, rcstate);
regoptail(ret, regnode(BACK,rcstate));
regoptail(ret, ret);
regtail(ret, regnode(BRANCH,rcstate));
regtail(ret, regnode(NOTHING,rcstate));
} else if (op == '+' && (flags&SIMPLE))
reginsert(PLUS, ret, rcstate);
else if (op == '+') {
next = regnode(BRANCH,rcstate);
regtail(ret, next);
regtail(regnode(BACK,rcstate), ret);
regtail(next, regnode(BRANCH,rcstate));
regtail(ret, regnode(NOTHING,rcstate));
} else if (op == '?') {
reginsert(BRANCH, ret, rcstate);
regtail(ret, regnode(BRANCH,rcstate));
next = regnode(NOTHING,rcstate);
regtail(ret, next);
regoptail(ret, next);
}
rcstate->regparse++;
if (ISMULT(*rcstate->regparse))
FAIL("nested *?+");
return(ret);
}
static char *
regatom(flagp, rcstate)
int *flagp;
struct regcomp_state *rcstate;
{
register char *ret;
int flags;
*flagp = WORST;
switch (*rcstate->regparse++) {
case '^':
ret = regnode(BOL,rcstate);
break;
case '$':
ret = regnode(EOL,rcstate);
break;
case '.':
ret = regnode(ANY,rcstate);
*flagp |= HASWIDTH|SIMPLE;
break;
case '[': {
register int clss;
register int classend;
if (*rcstate->regparse == '^') {
ret = regnode(ANYBUT,rcstate);
rcstate->regparse++;
} else
ret = regnode(ANYOF,rcstate);
if (*rcstate->regparse == ']' || *rcstate->regparse == '-')
regc(*rcstate->regparse++,rcstate);
while (*rcstate->regparse != '\0' && *rcstate->regparse != ']') {
if (*rcstate->regparse == '-') {
rcstate->regparse++;
if (*rcstate->regparse == ']' || *rcstate->regparse == '\0')
regc('-',rcstate);
else {
clss = UCHARAT(rcstate->regparse-2)+1;
classend = UCHARAT(rcstate->regparse);
if (clss > classend+1)
FAIL("invalid [] range");
for (; clss <= classend; clss++)
regc((char)clss,rcstate);
rcstate->regparse++;
}
} else
regc(*rcstate->regparse++,rcstate);
}
regc('\0',rcstate);
if (*rcstate->regparse != ']')
FAIL("unmatched []");
rcstate->regparse++;
*flagp |= HASWIDTH|SIMPLE;
}
break;
case '(':
ret = reg(1, &flags, rcstate);
if (ret == NULL)
return(NULL);
*flagp |= flags&(HASWIDTH|SPSTART);
break;
case '\0':
case '|':
case ')':
FAIL("internal urp");
case '?':
case '+':
case '*':
FAIL("?+* follows nothing");
case '\\':
if (*rcstate->regparse == '\0')
FAIL("trailing \\");
ret = regnode(EXACTLY,rcstate);
regc(*rcstate->regparse++,rcstate);
regc('\0',rcstate);
*flagp |= HASWIDTH|SIMPLE;
break;
default: {
register int len;
register char ender;
rcstate->regparse--;
len = strcspn(rcstate->regparse, META);
if (len <= 0)
FAIL("internal disaster");
ender = *(rcstate->regparse+len);
if (len > 1 && ISMULT(ender))
len--;
*flagp |= HASWIDTH;
if (len == 1)
*flagp |= SIMPLE;
ret = regnode(EXACTLY,rcstate);
while (len > 0) {
regc(*rcstate->regparse++,rcstate);
len--;
}
regc('\0',rcstate);
}
break;
}
return(ret);
}
static char *
regnode(op, rcstate)
int op;
struct regcomp_state *rcstate;
{
register char *ret;
register char *ptr;
ret = rcstate->regcode;
if (ret == ®dummy) {
rcstate->regsize += 3;
return(ret);
}
ptr = ret;
*ptr++ = (char)op;
*ptr++ = '\0';
*ptr++ = '\0';
rcstate->regcode = ptr;
return(ret);
}
static void
regc(b, rcstate)
int b;
struct regcomp_state *rcstate;
{
if (rcstate->regcode != ®dummy)
*rcstate->regcode++ = (char)b;
else
rcstate->regsize++;
}
static void
reginsert(op, opnd, rcstate)
int op;
char *opnd;
struct regcomp_state *rcstate;
{
register char *src;
register char *dst;
register char *place;
if (rcstate->regcode == ®dummy) {
rcstate->regsize += 3;
return;
}
src = rcstate->regcode;
rcstate->regcode += 3;
dst = rcstate->regcode;
while (src > opnd)
*--dst = *--src;
place = opnd;
*place++ = (char)op;
*place++ = '\0';
*place = '\0';
}
static void
regtail(p, val)
char *p;
char *val;
{
register char *scan;
register char *temp;
register int offset;
if (p == ®dummy)
return;
scan = p;
for (;;) {
temp = regnext(scan);
if (temp == NULL)
break;
scan = temp;
}
if (OP(scan) == BACK)
offset = scan - val;
else
offset = val - scan;
*(scan+1) = (char)((offset>>8)&0377);
*(scan+2) = (char)(offset&0377);
}
static void
regoptail(p, val)
char *p;
char *val;
{
if (p == NULL || p == ®dummy || OP(p) != BRANCH)
return;
regtail(OPERAND(p), val);
}
struct regexec_state {
char *reginput;
char *regbol;
char **regstartp;
char **regendp;
};
static int regtry _ANSI_ARGS_((regexp *prog, char *string,
struct regexec_state *restate));
static int regmatch _ANSI_ARGS_((char *prog,
struct regexec_state *restate));
static int regrepeat _ANSI_ARGS_((char *p,
struct regexec_state *restate));
#ifdef DEBUG
int regnarrate = 0;
void regdump _ANSI_ARGS_((regexp *r));
static char *regprop _ANSI_ARGS_((char *op));
#endif
int
TclRegExec(prog, string, start)
register regexp *prog;
register char *string;
char *start;
{
register char *s;
struct regexec_state state;
struct regexec_state *restate= &state;
if (prog == NULL || string == NULL) {
TclRegError("NULL parameter");
return(0);
}
if (UCHARAT(prog->program) != MAGIC) {
TclRegError("corrupted program");
return(0);
}
if (prog->regmust != NULL) {
s = string;
while ((s = strchr(s, prog->regmust[0])) != NULL) {
if (strncmp(s, prog->regmust, (size_t) prog->regmlen)
== 0)
break;
s++;
}
if (s == NULL)
return(0);
}
restate->regbol = start;
if (prog->reganch)
return(regtry(prog, string, restate));
s = string;
if (prog->regstart != '\0')
while ((s = strchr(s, prog->regstart)) != NULL) {
if (regtry(prog, s, restate))
return(1);
s++;
}
else
do {
if (regtry(prog, s, restate))
return(1);
} while (*s++ != '\0');
return(0);
}
static int
regtry(prog, string, restate)
regexp *prog;
char *string;
struct regexec_state *restate;
{
register int i;
register char **sp;
register char **ep;
restate->reginput = string;
restate->regstartp = prog->startp;
restate->regendp = prog->endp;
sp = prog->startp;
ep = prog->endp;
for (i = NSUBEXP; i > 0; i--) {
*sp++ = NULL;
*ep++ = NULL;
}
if (regmatch(prog->program + 1,restate)) {
prog->startp[0] = string;
prog->endp[0] = restate->reginput;
return(1);
} else
return(0);
}
static int
regmatch(prog, restate)
char *prog;
struct regexec_state *restate;
{
register char *scan;
char *next;
scan = prog;
#ifdef DEBUG
if (scan != NULL && regnarrate)
fprintf(stderr, "%s(\n", regprop(scan));
#endif
while (scan != NULL) {
#ifdef DEBUG
if (regnarrate)
fprintf(stderr, "%s...\n", regprop(scan));
#endif
next = regnext(scan);
switch (OP(scan)) {
case BOL:
if (restate->reginput != restate->regbol) {
return 0;
}
break;
case EOL:
if (*restate->reginput != '\0') {
return 0;
}
break;
case ANY:
if (*restate->reginput == '\0') {
return 0;
}
restate->reginput++;
break;
case EXACTLY: {
register int len;
register char *opnd;
opnd = OPERAND(scan);
if (*opnd != *restate->reginput) {
return 0 ;
}
len = strlen(opnd);
if (len > 1 && strncmp(opnd, restate->reginput, (size_t) len)
!= 0) {
return 0;
}
restate->reginput += len;
break;
}
case ANYOF:
if (*restate->reginput == '\0'
|| strchr(OPERAND(scan), *restate->reginput) == NULL) {
return 0;
}
restate->reginput++;
break;
case ANYBUT:
if (*restate->reginput == '\0'
|| strchr(OPERAND(scan), *restate->reginput) != NULL) {
return 0;
}
restate->reginput++;
break;
case NOTHING:
break;
case BACK:
break;
case OPEN+1:
case OPEN+2:
case OPEN+3:
case OPEN+4:
case OPEN+5:
case OPEN+6:
case OPEN+7:
case OPEN+8:
case OPEN+9: {
register int no;
register char *save;
doOpen:
no = OP(scan) - OPEN;
save = restate->reginput;
if (regmatch(next,restate)) {
if (restate->regstartp[no] == NULL) {
restate->regstartp[no] = save;
}
return 1;
} else {
return 0;
}
}
case CLOSE+1:
case CLOSE+2:
case CLOSE+3:
case CLOSE+4:
case CLOSE+5:
case CLOSE+6:
case CLOSE+7:
case CLOSE+8:
case CLOSE+9: {
register int no;
register char *save;
doClose:
no = OP(scan) - CLOSE;
save = restate->reginput;
if (regmatch(next,restate)) {
if (restate->regendp[no] == NULL)
restate->regendp[no] = save;
return 1;
} else {
return 0;
}
}
case BRANCH: {
register char *save;
if (OP(next) != BRANCH) {
next = OPERAND(scan);
} else {
do {
save = restate->reginput;
if (regmatch(OPERAND(scan),restate))
return(1);
restate->reginput = save;
scan = regnext(scan);
} while (scan != NULL && OP(scan) == BRANCH);
return 0;
}
break;
}
case STAR:
case PLUS: {
register char nextch;
register int no;
register char *save;
register int min;
nextch = '\0';
if (OP(next) == EXACTLY)
nextch = *OPERAND(next);
min = (OP(scan) == STAR) ? 0 : 1;
save = restate->reginput;
no = regrepeat(OPERAND(scan),restate);
while (no >= min) {
if (nextch == '\0' || *restate->reginput == nextch)
if (regmatch(next,restate))
return(1);
no--;
restate->reginput = save + no;
}
return(0);
}
case END:
return(1);
default:
if (OP(scan) > OPEN && OP(scan) < OPEN+NSUBEXP) {
goto doOpen;
} else if (OP(scan) > CLOSE && OP(scan) < CLOSE+NSUBEXP) {
goto doClose;
}
TclRegError("memory corruption");
return 0;
}
scan = next;
}
TclRegError("corrupted pointers");
return(0);
}
static int
regrepeat(p, restate)
char *p;
struct regexec_state *restate;
{
register int count = 0;
register char *scan;
register char *opnd;
scan = restate->reginput;
opnd = OPERAND(p);
switch (OP(p)) {
case ANY:
count = strlen(scan);
scan += count;
break;
case EXACTLY:
while (*opnd == *scan) {
count++;
scan++;
}
break;
case ANYOF:
while (*scan != '\0' && strchr(opnd, *scan) != NULL) {
count++;
scan++;
}
break;
case ANYBUT:
while (*scan != '\0' && strchr(opnd, *scan) == NULL) {
count++;
scan++;
}
break;
default:
TclRegError("internal foulup");
count = 0;
break;
}
restate->reginput = scan;
return(count);
}
static char *
regnext(p)
register char *p;
{
register int offset;
if (p == ®dummy)
return(NULL);
offset = NEXT(p);
if (offset == 0)
return(NULL);
if (OP(p) == BACK)
return(p-offset);
else
return(p+offset);
}
#ifdef DEBUG
static char *regprop();
void
regdump(r)
regexp *r;
{
register char *s;
register char op = EXACTLY;
register char *next;
s = r->program + 1;
while (op != END) {
op = OP(s);
printf("%2d%s", s-r->program, regprop(s));
next = regnext(s);
if (next == NULL)
printf("(0)");
else
printf("(%d)", (s-r->program)+(next-s));
s += 3;
if (op == ANYOF || op == ANYBUT || op == EXACTLY) {
while (*s != '\0') {
putchar(*s);
s++;
}
s++;
}
putchar('\n');
}
if (r->regstart != '\0')
printf("start `%c' ", r->regstart);
if (r->reganch)
printf("anchored ");
if (r->regmust != NULL)
printf("must have \"%s\"", r->regmust);
printf("\n");
}
static char *
regprop(op)
char *op;
{
register char *p;
static char buf[50];
(void) strcpy(buf, ":");
switch (OP(op)) {
case BOL:
p = "BOL";
break;
case EOL:
p = "EOL";
break;
case ANY:
p = "ANY";
break;
case ANYOF:
p = "ANYOF";
break;
case ANYBUT:
p = "ANYBUT";
break;
case BRANCH:
p = "BRANCH";
break;
case EXACTLY:
p = "EXACTLY";
break;
case NOTHING:
p = "NOTHING";
break;
case BACK:
p = "BACK";
break;
case END:
p = "END";
break;
case OPEN+1:
case OPEN+2:
case OPEN+3:
case OPEN+4:
case OPEN+5:
case OPEN+6:
case OPEN+7:
case OPEN+8:
case OPEN+9:
sprintf(buf+strlen(buf), "OPEN%d", OP(op)-OPEN);
p = NULL;
break;
case CLOSE+1:
case CLOSE+2:
case CLOSE+3:
case CLOSE+4:
case CLOSE+5:
case CLOSE+6:
case CLOSE+7:
case CLOSE+8:
case CLOSE+9:
sprintf(buf+strlen(buf), "CLOSE%d", OP(op)-CLOSE);
p = NULL;
break;
case STAR:
p = "STAR";
break;
case PLUS:
p = "PLUS";
break;
default:
if (OP(op) > OPEN && OP(op) < OPEN+NSUBEXP) {
sprintf(buf+strlen(buf), "OPEN%d", OP(op)-OPEN);
p = NULL;
break;
} else if (OP(op) > CLOSE && OP(op) < CLOSE+NSUBEXP) {
sprintf(buf+strlen(buf), "CLOSE%d", OP(op)-CLOSE);
p = NULL;
} else {
TclRegError("corrupted opcode");
}
break;
}
if (p != NULL)
(void) strcat(buf, p);
return(buf);
}
#endif
#ifdef STRCSPN
static int
strcspn(s1, s2)
char *s1;
char *s2;
{
register char *scan1;
register char *scan2;
register int count;
count = 0;
for (scan1 = s1; *scan1 != '\0'; scan1++) {
for (scan2 = s2; *scan2 != '\0';)
if (*scan1 == *scan2++)
return(count);
count++;
}
return(count);
}
#endif
void
exp_TclRegError(string)
char *string;
{
errMsg = string;
}
char *
TclGetRegError()
{
return errMsg;
}
static
char *
Tcl_ErrnoMsg(err)
int err;
{
switch (err) {
#ifdef E2BIG
case E2BIG: return "argument list too long";
#endif
#ifdef EACCES
case EACCES: return "permission denied";
#endif
#ifdef EADDRINUSE
case EADDRINUSE: return "address already in use";
#endif
#ifdef EADDRNOTAVAIL
case EADDRNOTAVAIL: return "can't assign requested address";
#endif
#ifdef EADV
case EADV: return "advertise error";
#endif
#ifdef EAFNOSUPPORT
case EAFNOSUPPORT: return "address family not supported by protocol family";
#endif
#ifdef EAGAIN
case EAGAIN: return "resource temporarily unavailable";
#endif
#ifdef EALIGN
case EALIGN: return "EALIGN";
#endif
#if defined(EALREADY) && (!defined(EBUSY) || (EALREADY != EBUSY ))
case EALREADY: return "operation already in progress";
#endif
#ifdef EBADE
case EBADE: return "bad exchange descriptor";
#endif
#ifdef EBADF
case EBADF: return "bad file number";
#endif
#ifdef EBADFD
case EBADFD: return "file descriptor in bad state";
#endif
#ifdef EBADMSG
case EBADMSG: return "not a data message";
#endif
#ifdef EBADR
case EBADR: return "bad request descriptor";
#endif
#ifdef EBADRPC
case EBADRPC: return "RPC structure is bad";
#endif
#ifdef EBADRQC
case EBADRQC: return "bad request code";
#endif
#ifdef EBADSLT
case EBADSLT: return "invalid slot";
#endif
#ifdef EBFONT
case EBFONT: return "bad font file format";
#endif
#ifdef EBUSY
case EBUSY: return "file busy";
#endif
#ifdef ECHILD
case ECHILD: return "no children";
#endif
#ifdef ECHRNG
case ECHRNG: return "channel number out of range";
#endif
#ifdef ECOMM
case ECOMM: return "communication error on send";
#endif
#ifdef ECONNABORTED
case ECONNABORTED: return "software caused connection abort";
#endif
#ifdef ECONNREFUSED
case ECONNREFUSED: return "connection refused";
#endif
#ifdef ECONNRESET
case ECONNRESET: return "connection reset by peer";
#endif
#if defined(EDEADLK) && (!defined(EWOULDBLOCK) || (EDEADLK != EWOULDBLOCK))
case EDEADLK: return "resource deadlock avoided";
#endif
#if defined(EDEADLOCK) && (!defined(EDEADLK) || (EDEADLOCK != EDEADLK))
case EDEADLOCK: return "resource deadlock avoided";
#endif
#ifdef EDESTADDRREQ
case EDESTADDRREQ: return "destination address required";
#endif
#ifdef EDIRTY
case EDIRTY: return "mounting a dirty fs w/o force";
#endif
#ifdef EDOM
case EDOM: return "math argument out of range";
#endif
#ifdef EDOTDOT
case EDOTDOT: return "cross mount point";
#endif
#ifdef EDQUOT
case EDQUOT: return "disk quota exceeded";
#endif
#ifdef EDUPPKG
case EDUPPKG: return "duplicate package name";
#endif
#ifdef EEXIST
case EEXIST: return "file already exists";
#endif
#ifdef EFAULT
case EFAULT: return "bad address in system call argument";
#endif
#ifdef EFBIG
case EFBIG: return "file too large";
#endif
#ifdef EHOSTDOWN
case EHOSTDOWN: return "host is down";
#endif
#ifdef EHOSTUNREACH
case EHOSTUNREACH: return "host is unreachable";
#endif
#if defined(EIDRM) && (!defined(EINPROGRESS) || (EIDRM != EINPROGRESS))
case EIDRM: return "identifier removed";
#endif
#ifdef EINIT
case EINIT: return "initialization error";
#endif
#ifdef EINPROGRESS
case EINPROGRESS: return "operation now in progress";
#endif
#ifdef EINTR
case EINTR: return "interrupted system call";
#endif
#ifdef EINVAL
case EINVAL: return "invalid argument";
#endif
#ifdef EIO
case EIO: return "I/O error";
#endif
#ifdef EISCONN
case EISCONN: return "socket is already connected";
#endif
#ifdef EISDIR
case EISDIR: return "illegal operation on a directory";
#endif
#ifdef EISNAME
case EISNAM: return "is a name file";
#endif
#ifdef ELBIN
case ELBIN: return "ELBIN";
#endif
#ifdef EL2HLT
case EL2HLT: return "level 2 halted";
#endif
#ifdef EL2NSYNC
case EL2NSYNC: return "level 2 not synchronized";
#endif
#ifdef EL3HLT
case EL3HLT: return "level 3 halted";
#endif
#ifdef EL3RST
case EL3RST: return "level 3 reset";
#endif
#ifdef ELIBACC
case ELIBACC: return "can not access a needed shared library";
#endif
#ifdef ELIBBAD
case ELIBBAD: return "accessing a corrupted shared library";
#endif
#ifdef ELIBEXEC
case ELIBEXEC: return "can not exec a shared library directly";
#endif
#ifdef ELIBMAX
case ELIBMAX: return
"attempting to link in more shared libraries than system limit";
#endif
#ifdef ELIBSCN
case ELIBSCN: return ".lib section in a.out corrupted";
#endif
#ifdef ELNRNG
case ELNRNG: return "link number out of range";
#endif
#if defined(ELOOP) && (!defined(ENOENT) || (ELOOP != ENOENT))
case ELOOP: return "too many levels of symbolic links";
#endif
#ifdef EMFILE
case EMFILE: return "too many open files";
#endif
#ifdef EMLINK
case EMLINK: return "too many links";
#endif
#ifdef EMSGSIZE
case EMSGSIZE: return "message too long";
#endif
#ifdef EMULTIHOP
case EMULTIHOP: return "multihop attempted";
#endif
#ifdef ENAMETOOLONG
case ENAMETOOLONG: return "file name too long";
#endif
#ifdef ENAVAIL
case ENAVAIL: return "not available";
#endif
#ifdef ENET
case ENET: return "ENET";
#endif
#ifdef ENETDOWN
case ENETDOWN: return "network is down";
#endif
#ifdef ENETRESET
case ENETRESET: return "network dropped connection on reset";
#endif
#ifdef ENETUNREACH
case ENETUNREACH: return "network is unreachable";
#endif
#ifdef ENFILE
case ENFILE: return "file table overflow";
#endif
#ifdef ENOANO
case ENOANO: return "anode table overflow";
#endif
#if defined(ENOBUFS) && (!defined(ENOSR) || (ENOBUFS != ENOSR))
case ENOBUFS: return "no buffer space available";
#endif
#ifdef ENOCSI
case ENOCSI: return "no CSI structure available";
#endif
#if defined(ENODATA) && (!defined(ECONNREFUSED) || (ENODATA != ECONNREFUSED))
case ENODATA: return "no data available";
#endif
#ifdef ENODEV
case ENODEV: return "no such device";
#endif
#ifdef ENOENT
case ENOENT: return "no such file or directory";
#endif
#ifdef ENOEXEC
case ENOEXEC: return "exec format error";
#endif
#ifdef ENOLCK
case ENOLCK: return "no locks available";
#endif
#ifdef ENOLINK
case ENOLINK: return "link has be severed";
#endif
#ifdef ENOMEM
case ENOMEM: return "not enough memory";
#endif
#ifdef ENOMSG
case ENOMSG: return "no message of desired type";
#endif
#ifdef ENONET
case ENONET: return "machine is not on the network";
#endif
#ifdef ENOPKG
case ENOPKG: return "package not installed";
#endif
#ifdef ENOPROTOOPT
case ENOPROTOOPT: return "bad proocol option";
#endif
#ifdef ENOSPC
case ENOSPC: return "no space left on device";
#endif
#if defined(ENOSR) && (!defined(ENAMETOOLONG) || (ENAMETOOLONG != ENOSR))
case ENOSR: return "out of stream resources";
#endif
#if defined(ENOSTR) && (!defined(ENOTTY) || (ENOTTY != ENOSTR))
case ENOSTR: return "not a stream device";
#endif
#ifdef ENOSYM
case ENOSYM: return "unresolved symbol name";
#endif
#ifdef ENOSYS
case ENOSYS: return "function not implemented";
#endif
#ifdef ENOTBLK
case ENOTBLK: return "block device required";
#endif
#ifdef ENOTCONN
case ENOTCONN: return "socket is not connected";
#endif
#ifdef ENOTDIR
case ENOTDIR: return "not a directory";
#endif
#if defined(ENOTEMPTY) && (!defined(EEXIST) || (ENOTEMPTY != EEXIST))
case ENOTEMPTY: return "directory not empty";
#endif
#ifdef ENOTNAM
case ENOTNAM: return "not a name file";
#endif
#ifdef ENOTSOCK
case ENOTSOCK: return "socket operation on non-socket";
#endif
#ifdef ENOTSUP
case ENOTSUP: return "operation not supported";
#endif
#ifdef ENOTTY
case ENOTTY: return "inappropriate device for ioctl";
#endif
#ifdef ENOTUNIQ
case ENOTUNIQ: return "name not unique on network";
#endif
#ifdef ENXIO
case ENXIO: return "no such device or address";
#endif
#if defined(EOPNOTSUPP) && (!defined(ENOTSUP) || (ENOTSUP != EOPNOTSUPP))
case EOPNOTSUPP: return "operation not supported on socket";
#endif
#ifdef EPERM
case EPERM: return "not owner";
#endif
#if defined(EPFNOSUPPORT) && (!defined(ENOLCK) || (ENOLCK != EPFNOSUPPORT))
case EPFNOSUPPORT: return "protocol family not supported";
#endif
#ifdef EPIPE
case EPIPE: return "broken pipe";
#endif
#ifdef EPROCLIM
case EPROCLIM: return "too many processes";
#endif
#ifdef EPROCUNAVAIL
case EPROCUNAVAIL: return "bad procedure for program";
#endif
#ifdef EPROGMISMATCH
case EPROGMISMATCH: return "program version wrong";
#endif
#ifdef EPROGUNAVAIL
case EPROGUNAVAIL: return "RPC program not available";
#endif
#ifdef EPROTO
case EPROTO: return "protocol error";
#endif
#ifdef EPROTONOSUPPORT
case EPROTONOSUPPORT: return "protocol not suppored";
#endif
#ifdef EPROTOTYPE
case EPROTOTYPE: return "protocol wrong type for socket";
#endif
#ifdef ERANGE
case ERANGE: return "math result unrepresentable";
#endif
#if defined(EREFUSED) && (!defined(ECONNREFUSED) || (EREFUSED != ECONNREFUSED))
case EREFUSED: return "EREFUSED";
#endif
#ifdef EREMCHG
case EREMCHG: return "remote address changed";
#endif
#ifdef EREMDEV
case EREMDEV: return "remote device";
#endif
#ifdef EREMOTE
case EREMOTE: return "pathname hit remote file system";
#endif
#ifdef EREMOTEIO
case EREMOTEIO: return "remote i/o error";
#endif
#ifdef EREMOTERELEASE
case EREMOTERELEASE: return "EREMOTERELEASE";
#endif
#ifdef EROFS
case EROFS: return "read-only file system";
#endif
#ifdef ERPCMISMATCH
case ERPCMISMATCH: return "RPC version is wrong";
#endif
#ifdef ERREMOTE
case ERREMOTE: return "object is remote";
#endif
#ifdef ESHUTDOWN
case ESHUTDOWN: return "can't send afer socket shutdown";
#endif
#ifdef ESOCKTNOSUPPORT
case ESOCKTNOSUPPORT: return "socket type not supported";
#endif
#ifdef ESPIPE
case ESPIPE: return "invalid seek";
#endif
#ifdef ESRCH
case ESRCH: return "no such process";
#endif
#ifdef ESRMNT
case ESRMNT: return "srmount error";
#endif
#ifdef ESTALE
case ESTALE: return "stale remote file handle";
#endif
#ifdef ESUCCESS
case ESUCCESS: return "Error 0";
#endif
#if defined(ETIME) && (!defined(ELOOP) || (ETIME != ELOOP))
case ETIME: return "timer expired";
#endif
#if defined(ETIMEDOUT) && (!defined(ENOSTR) || (ETIMEDOUT != ENOSTR))
case ETIMEDOUT: return "connection timed out";
#endif
#ifdef ETOOMANYREFS
case ETOOMANYREFS: return "too many references: can't splice";
#endif
#ifdef ETXTBSY
case ETXTBSY: return "text file or pseudo-device busy";
#endif
#ifdef EUCLEAN
case EUCLEAN: return "structure needs cleaning";
#endif
#ifdef EUNATCH
case EUNATCH: return "protocol driver not attached";
#endif
#ifdef EUSERS
case EUSERS: return "too many users";
#endif
#ifdef EVERSION
case EVERSION: return "version mismatch";
#endif
#if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
case EWOULDBLOCK: return "operation would block";
#endif
#ifdef EXDEV
case EXDEV: return "cross-domain link";
#endif
#ifdef EXFULL
case EXFULL: return "message tables full";
#endif
default:
#ifdef NO_STRERROR
return "unknown POSIX error";
#else
return strerror(errno);
#endif
}
}
static
void
expDiagLogU(str)
char *str;
{
if (exp_is_debugging) {
fprintf(stderr,str);
if (exp_logfile) fprintf(exp_logfile,str);
}
}
#include "expect.h"
#include "exp_int.h"
static
int
Exp_StringMatch2(string,pattern)
register char *string;
register char *pattern;
{
char c2;
int match = 0;
while (1) {
if (*pattern == 0) {
return match;
}
if ((*pattern == '$') && (pattern[1] == 0)) {
if (*string == 0) return(match);
else return(-1);
}
if (*pattern == '*') {
int head_len;
char *tail;
pattern += 1;
if (*pattern == 0) {
return(strlen(string)+match);
}
head_len = strlen(string);
tail = string + head_len;
while (head_len >= 0) {
int rc;
if (-1 != (rc = Exp_StringMatch2(tail, pattern))) {
return rc + match + head_len;
}
tail--;
head_len--;
}
return -1;
}
if (*string == 0) return -1;
if (*pattern == '?') {
goto thisCharOK;
}
if (*pattern == '[') {
pattern += 1;
while (1) {
if ((*pattern == ']') || (*pattern == 0)) {
return -1;
}
if (*pattern == *string) {
break;
}
if (pattern[1] == '-') {
c2 = pattern[2];
if (c2 == 0) {
return -1;
}
if ((*pattern <= *string) && (c2 >= *string)) {
break;
}
if ((*pattern >= *string) && (c2 <= *string)) {
break;
}
pattern += 2;
}
pattern += 1;
}
while (*pattern != ']') {
if (*pattern == 0) {
pattern--;
break;
}
pattern += 1;
}
goto thisCharOK;
}
if (*pattern == '\\') {
pattern += 1;
if (*pattern == 0) {
return -1;
}
}
if (*pattern != *string) {
return -1;
}
thisCharOK: pattern += 1;
string += 1;
match++;
}
}
static
int
Exp_StringMatch(string, pattern,offset)
char *string;
char *pattern;
int *offset;
{
char *s;
int sm;
int caret = FALSE;
int star = FALSE;
*offset = 0;
if (pattern[0] == '^') {
caret = TRUE;
pattern++;
} else if (pattern[0] == '*') {
star = TRUE;
}
sm = Exp_StringMatch2(string,pattern);
if (sm >= 0) return(sm);
if (caret) return -1;
if (star) return -1;
if (*string == '\0') return -1;
for (s = string+1;*s;s++) {
sm = Exp_StringMatch2(s,pattern);
if (sm != -1) {
*offset = s-string;
return(sm);
}
}
return -1;
}
#define EXP_MATCH_MAX 2000
char *exp_buffer = 0;
char *exp_buffer_end = 0;
char *exp_match = 0;
char *exp_match_end = 0;
int exp_match_max = EXP_MATCH_MAX;
int exp_full_buffer = FALSE;
int exp_remove_nulls = TRUE;
int exp_timeout = 10;
int exp_pty_timeout = 5;
int exp_autoallocpty = TRUE;
int exp_pty[2];
int exp_pid;
char *exp_stty_init = 0;
int exp_ttycopy = TRUE;
int exp_ttyinit = TRUE;
int exp_console = FALSE;
void (*exp_child_exec_prelude)() = 0;
void (*exp_close_in_child)() = 0;
#ifdef HAVE_SIGLONGJMP
sigjmp_buf exp_readenv;
#else
jmp_buf exp_readenv;
#endif
int exp_reading = FALSE;
int exp_is_debugging = FALSE;
FILE *exp_debugfile = 0;
FILE *exp_logfile = 0;
int exp_logfile_all = FALSE;
int exp_loguser = TRUE;
char *exp_printify();
int exp_getptymaster();
int exp_getptyslave();
#define sysreturn(x) return(errno = x, -1)
void exp_init_pty();
static unsigned int bufsiz = 2*EXP_MATCH_MAX;
static struct f {
int valid;
char *buffer;
char *buffer_end;
char *match_end;
int msize;
} *fs = 0;
static int fd_alloc_max = -1;
static struct f *
fdfp2f(fd,fp)
int fd;
FILE *fp;
{
if (fd == -1) return(fs + fileno(fp));
else return(fs + fd);
}
static struct f *
fd_new(fd)
int fd;
{
int i, low;
struct f *fp;
struct f *newfs;
if (fd > fd_alloc_max) {
if (!fs) {
newfs = (struct f *)malloc(sizeof(struct f)*(fd+1));
low = 0;
} else {
newfs = (struct f *)realloc((char *)fs,sizeof(struct f)*(fd+1));
low = fd_alloc_max+1;
}
fs = newfs;
fd_alloc_max = fd;
for (i = low; i <= fd_alloc_max; i++) {
fs[i].valid = FALSE;
}
}
fp = fs+fd;
if (!fp->valid) {
fp->buffer = malloc((unsigned)(bufsiz+1));
if (!fp->buffer) return 0;
fp->msize = bufsiz;
fp->valid = TRUE;
}
fp->buffer_end = fp->buffer;
fp->match_end = fp->buffer;
return fp;
}
static
void
exp_setpgrp()
{
#ifdef MIPS_BSD
# include <sysv/sys.s>
syscall(SYS_setpgrp);
#endif
#ifdef SETPGRP_VOID
(void) setpgrp();
#else
(void) setpgrp(0,0);
#endif
}
int
exp_spawnv(file,argv)
char *file;
char *argv[];
{
int cc;
int errorfd;
int ttyfd;
int sync_fds[2];
int sync2_fds[2];
int status_pipe[2];
int child_errno;
char sync_byte;
#ifdef PTYTRAP_DIES
int slave_write_ioctls = 1;
#endif
static int first_time = TRUE;
if (first_time) {
first_time = FALSE;
exp_init_pty();
exp_init_tty();
expDiagLogPtrSet(expDiagLogU);
expErrnoMsgSet(Tcl_ErrnoMsg);
}
if (!file || !argv) sysreturn(EINVAL);
if (!argv[0] || strcmp(file,argv[0])) {
exp_debuglog("expect: warning: file (%s) != argv[0] (%s)\n",
file,
argv[0]?argv[0]:"");
}
#ifdef PTYTRAP_DIES
#if defined(TIOCSCTTY) && !defined(CIBAUD) && !defined(sun) && !defined(hp9000s300)
slave_write_ioctls++;
#endif
#endif
if (exp_autoallocpty) {
if (0 > (exp_pty[0] = exp_getptymaster())) sysreturn(ENODEV);
}
fcntl(exp_pty[0],F_SETFD,1);
#ifdef PTYTRAP_DIES
exp_slave_control(exp_pty[0],1);*/
#endif
if (!fd_new(exp_pty[0])) {
errno = ENOMEM;
return -1;
}
if (-1 == (pipe(sync_fds))) {
return -1;
}
if (-1 == (pipe(sync2_fds))) {
close(sync_fds[0]);
close(sync_fds[1]);
return -1;
}
if (-1 == pipe(status_pipe)) {
close(sync_fds[0]);
close(sync_fds[1]);
close(sync2_fds[0]);
close(sync2_fds[1]);
return -1;
}
if ((exp_pid = fork()) == -1) return(-1);
if (exp_pid) {
close(sync_fds[1]);
close(sync2_fds[0]);
close(status_pipe[1]);
if (!exp_autoallocpty) close(exp_pty[1]);
#ifdef PTYTRAP_DIES
#ifdef HAVE_PTYTRAP
if (exp_autoallocpty) {
while (slave_write_ioctls) {
int cc;
cc = exp_wait_for_slave_open(exp_pty[0]);
#if defined(TIOCSCTTY) && !defined(CIBAUD) && !defined(sun) && !defined(hp9000s300)
if (cc == TIOCSCTTY) slave_write_ioctls = 0;
#endif
if (cc & IOC_IN) slave_write_ioctls--;
else if (cc == -1) {
printf("failed to trap slave pty");
return -1;
}
}
}
#endif
#endif
exp_debuglog("parent: waiting for sync byte\r\n");
cc = read(sync_fds[0],&sync_byte,1);
if (cc == -1) {
exp_errorlog("parent sync byte read: %s\r\n",Tcl_ErrnoMsg(errno));
return -1;
}
exp_slave_control(exp_pty[0],1);
exp_debuglog("parent: telling child to go ahead\r\n");
cc = write(sync2_fds[1]," ",1);
if (cc == -1) {
exp_errorlog("parent sync byte write: %s\r\n",Tcl_ErrnoMsg(errno));
return -1;
}
exp_debuglog("parent: now unsynchronized from child\r\n");
close(sync_fds[0]);
close(sync2_fds[1]);
retry:
switch (read(status_pipe[0],&child_errno,sizeof child_errno)) {
case -1:
if (errno == EINTR) goto retry;
child_errno = errno;
break;
case 0:
child_errno = 0;
break;
default:
waitpid(exp_pid, NULL, 0);
errno = child_errno;
exp_pty[0] = -1;
}
close(status_pipe[0]);
return(exp_pty[0]);
}
close(sync_fds[0]);
close(sync2_fds[1]);
close(status_pipe[0]);
fcntl(status_pipe[1],F_SETFD,1);
#ifdef CRAY
(void) close(exp_pty[0]);
#endif
#if defined(POSIX) && !defined(ultrix)
#define DO_SETSID
#endif
#ifdef __convex__
#define DO_SETSID
#endif
#ifdef DO_SETSID
setsid();
#else
#ifdef SYSV3
#ifndef CRAY
exp_setpgrp();
#endif
#else
exp_setpgrp();
#ifdef TIOCNOTTY
ttyfd = open("/dev/tty", O_RDWR);
if (ttyfd >= 0) {
(void) ioctl(ttyfd, TIOCNOTTY, (char *)0);
(void) close(ttyfd);
}
#endif
#endif
#endif
errorfd = fcntl(2,F_DUPFD,3);
#define restore_error_fd {close(2);fcntl(errorfd,F_DUPFD,2);}
if (exp_autoallocpty) {
close(0);
close(1);
close(2);
if (0 > (exp_pty[1] = exp_getptyslave(exp_ttycopy,exp_ttyinit,
exp_stty_init))) {
restore_error_fd
fprintf(stderr,"open(slave pty): %s\n",Tcl_ErrnoMsg(errno));
exit(-1);
}
if (exp_pty[1] != 0) {
restore_error_fd
fprintf(stderr,"exp_getptyslave: slave = %d but expected 0\n",
exp_pty[1]);
exit(-1);
}
} else {
if (exp_pty[1] != 0) {
close(0); fcntl(exp_pty[1],F_DUPFD,0);
}
close(1); fcntl(0,F_DUPFD,1);
close(2); fcntl(0,F_DUPFD,1);
close(exp_pty[1]);
}
#if defined(TIOCSCTTY) && !defined(sun) && !defined(hpux)
#ifdef __QNX__
if (tcsetct(0, getpid()) == -1) {
restore_error_fd
expErrorLog("failed to get controlling terminal using TIOCSCTTY");
exit(-1);
}
#else
(void) ioctl(0,TIOCSCTTY,(char *)0);
#endif
#endif
#ifdef CRAY
(void) setsid();
(void) ioctl(0,TCSETCTTY,0);
(void) close(0);
if (open("/dev/tty", O_RDWR) < 0) {
restore_error_fd
fprintf(stderr,"open(/dev/tty): %s\r\n",Tcl_ErrnoMsg(errno));
exit(-1);
}
(void) close(1);
(void) close(2);
(void) dup(0);
(void) dup(0);
setptyutmp();
#ifdef _CRAY2
if ((pid = fork()) == -1) {
restore_error_fd
fprintf(stderr,"second fork: %s\r\n",Tcl_ErrnoMsg(errno));
exit(-1);
}
if (pid) {
int status;
int timeout;
char *t;
timeout = exp_pty_timeout;
while (wait(&status) < 0 && errno == EINTR)
;
sleep(timeout);
if (WIFSIGNALED(status))
kill(getpid(), WTERMSIG(status));
exit(WEXITSTATUS(status));
}
#endif
#endif
if (exp_console) {
#ifdef SRIOCSREDIR
int fd;
if ((fd = open("/dev/console", O_RDONLY)) == -1) {
restore_error_fd
fprintf(stderr, "spawn %s: cannot open console, check permissions of /dev/console\n",argv[0]);
exit(-1);
}
if (ioctl(fd, SRIOCSREDIR, 0) == -1) {
restore_error_fd
fprintf(stderr, "spawn %s: cannot redirect console, check permissions of /dev/console\n",argv[0]);
}
close(fd);
#endif
#ifdef TIOCCONS
int on = 1;
if (ioctl(0,TIOCCONS,(char *)&on) == -1) {
restore_error_fd
fprintf(stderr, "spawn %s: cannot open console, check permissions of /dev/console\n",argv[0]);
exit(-1);
}
#endif
}
cc = write(sync_fds[1]," ",1);
if (cc == -1) {
restore_error_fd
fprintf(stderr,"child: sync byte write: %s\r\n",Tcl_ErrnoMsg(errno));
exit(-1);
}
close(sync_fds[1]);
cc = read(sync2_fds[0],&sync_byte,1);
if (cc == -1) {
restore_error_fd
exp_errorlog("child: sync byte read: %s\r\n",Tcl_ErrnoMsg(errno));
exit(-1);
}
close(sync2_fds[0]);
if (exp_close_in_child) (*exp_close_in_child)();
if (exp_child_exec_prelude) (*exp_child_exec_prelude)();
(void) execvp(file,argv);
write(status_pipe[1], &errno, sizeof errno);
exit(-1);
}
int
exp_spawnl TCL_VARARGS_DEF(char *,arg1)
{
va_list args;
int i;
char *arg, **argv;
arg = TCL_VARARGS_START(char *,arg1,args);
for (i=1;;i++) {
arg = va_arg(args,char *);
if (!arg) break;
}
va_end(args);
if (i == 0) sysreturn(EINVAL);
if (!(argv = (char **)malloc((i+1)*sizeof(char *)))) sysreturn(ENOMEM);
argv[0] = TCL_VARARGS_START(char *,arg1,args);
for (i=1;;i++) {
argv[i] = va_arg(args,char *);
if (!argv[i]) break;
}
i = exp_spawnv(argv[0],argv+1);
free((char *)argv);
return(i);
}
int
exp_spawnfd(fd)
int fd;
{
if (!fd_new(fd)) {
errno = ENOMEM;
return -1;
}
return fd;
}
static int
rm_nulls(s,c)
char *s;
int c;
{
char *s2 = s;
int count = 0;
int i;
for (i=0;i<c;i++,s++) {
if (0 == *s) {
count++;
continue;
}
if (count) *s2 = *s;
s2++;
}
return(count);
}
static int i_read_errno;
static void
sigalarm_handler(n)
int n;
{
#ifdef REARM_SIG
signal(SIGALRM,sigalarm_handler);
#endif
#ifdef HAVE_SIGLONGJMP
siglongjmp(exp_readenv,1);
#else
longjmp(exp_readenv,1);
#endif
}
static int
i_read(fd,fp,buffer,length,timeout)
int fd;
FILE *fp;
char *buffer;
int length;
int timeout;
{
int cc = -2;
if (timeout > 0) alarm(timeout);
#ifdef HAVE_SIGLONGJMP
if (EXP_ABORT != sigsetjmp(exp_readenv,1)) {
#else
if (EXP_ABORT != setjmp(exp_readenv)) {
#endif
exp_reading = TRUE;
if (fd == -1) {
int c;
c = getc(fp);
if (c == EOF) {
if (feof(fp)) cc = 0;
else cc = -1;
} else {
buffer[0] = c;
cc = 1;
}
} else {
#ifndef HAVE_PTYTRAP
cc = read(fd,buffer,length);
#else
# include <sys/ptyio.h>
fd_set rdrs;
fd_set excep;
restart:
FD_ZERO(&rdrs);
FD_ZERO(&excep);
FD_SET(fd,&rdrs);
FD_SET(fd,&excep);
if (-1 == (cc = select(fd+1,
(SELECT_MASK_TYPE *)&rdrs,
(SELECT_MASK_TYPE *)0,
(SELECT_MASK_TYPE *)&excep,
(struct timeval *)0))) {
if (errno == EINTR) goto restart;
}
if (FD_ISSET(fd,&rdrs)) {
cc = read(fd,buffer,length);
} else if (FD_ISSET(fd,&excep)) {
struct request_info ioctl_info;
ioctl(fd,TIOCREQCHECK,&ioctl_info);
if (ioctl_info.request == TIOCCLOSE) {
cc = 0;
} else {
ioctl(fd, TIOCREQSET, &ioctl_info);
goto restart;
}
}
#endif
}
#if 0
else {
if (!(cc = fread(buffer,1,length,fp))) {
if (ferror(fp)) cc = -1;
}
}
#endif
i_read_errno = errno;
}
exp_reading = FALSE;
if (timeout > 0) alarm(0);
return(cc);
}
static int
expectv(fd,fp,ecases)
int fd;
FILE *fp;
struct exp_case *ecases;
{
int cc = 0;
int buf_length;
int old_length;
int first_time = TRUE;
int polled = 0;
struct exp_case *ec;
time_t current_time;
time_t end_time;
int remtime;
struct f *f;
int return_val;
int sys_error = 0;
#define return_normally(x) {return_val = x; goto cleanup;}
#define return_errno(x) {sys_error = x; goto cleanup;}
f = fdfp2f(fd,fp);
if (!f) return_errno(ENOMEM);
exp_buffer = f->buffer;
exp_buffer_end = f->buffer_end;
exp_match_end = f->match_end;
buf_length = exp_buffer_end - exp_match_end;
if (buf_length) {
memmove(exp_buffer,exp_match_end,buf_length);
}
exp_buffer_end = exp_buffer + buf_length;
*exp_buffer_end = '\0';
if (!ecases) return_errno(EINVAL);
for (ec=ecases;ec->type != exp_end;ec++) {
if ((ec->type == exp_regexp) && !ec->re) {
TclRegError((char *)0);
if (!(ec->re = TclRegComp(ec->pattern))) {
fprintf(stderr,"regular expression %s is bad: %s",ec->pattern,TclGetRegError());
return_errno(EINVAL);
}
}
}
bufsiz = 2*exp_match_max;
if (f->msize != bufsiz) {
if (buf_length > bufsiz) {
memmove(exp_buffer,exp_buffer+(buf_length - bufsiz)+1,
bufsiz-1);
buf_length = bufsiz-1;
}
exp_buffer = realloc(exp_buffer,bufsiz+1);
if (!exp_buffer) return_errno(ENOMEM);
exp_buffer[buf_length] = '\0';
exp_buffer_end = exp_buffer + buf_length;
f->msize = bufsiz;
}
if (fd == -1) fflush(fp);
if (exp_timeout != -1) signal(SIGALRM,sigalarm_handler);
remtime = exp_timeout;
time(¤t_time);
end_time = current_time + remtime;
for (;;) {
if (buf_length == bufsiz) {
int first_half, second_half;
if (exp_full_buffer) {
exp_debuglog("expect: full buffer\r\n");
exp_match = exp_buffer;
exp_match_end = exp_buffer + buf_length;
exp_buffer_end = exp_match_end;
return_normally(EXP_FULLBUFFER);
}
first_half = bufsiz/2;
second_half = bufsiz - first_half;
memcpy(exp_buffer,exp_buffer+first_half,second_half);
buf_length = second_half;
exp_buffer_end = exp_buffer + second_half;
}
if (first_time) {
first_time = FALSE;
goto after_read;
}
if ((exp_timeout >= 0) && ((remtime < 0) || polled)) {
exp_debuglog("expect: timeout\r\n");
exp_match_end = exp_buffer;
return_normally(EXP_TIMEOUT);
}
if (exp_timeout == 0) {
polled = 1;
}
cc = i_read(fd,fp,
exp_buffer_end,
bufsiz - buf_length,
remtime);
if (cc == 0) {
exp_debuglog("expect: eof\r\n");
return_normally(EXP_EOF);
} else if (cc == -1) {
if (i_read_errno == EIO) {
exp_debuglog("expect: eof\r\n");
return_normally(EXP_EOF);
}
exp_debuglog("expect: error (errno = %d)\r\n",i_read_errno);
return_errno(i_read_errno);
} else if (cc == -2) {
exp_debuglog("expect: timeout\r\n");
exp_match_end = exp_buffer;
return_normally(EXP_TIMEOUT);
}
old_length = buf_length;
buf_length += cc;
exp_buffer_end += buf_length;
if (exp_logfile_all || (exp_loguser && exp_logfile)) {
fwrite(exp_buffer + old_length,1,cc,exp_logfile);
}
if (exp_loguser) fwrite(exp_buffer + old_length,1,cc,stdout);
if (exp_debugfile) fwrite(exp_buffer + old_length,1,cc,exp_debugfile);
if (exp_debugfile) fflush(exp_debugfile);
if (exp_loguser) {
fflush(stdout);
if (exp_logfile) fflush(exp_logfile);
}
if (exp_remove_nulls) {
buf_length -= rm_nulls(exp_buffer + old_length, cc);
}
exp_buffer_end = exp_buffer + buf_length;
*exp_buffer_end = '\0';
exp_match_end = exp_buffer;
after_read:
exp_debuglog("expect: does {%s} match ",exp_printify(exp_buffer));
for (ec=ecases;ec->type != exp_end;ec++) {
int matched = -1;
exp_debuglog("{%s}? ",exp_printify(ec->pattern));
if (ec->type == exp_glob) {
int offset;
matched = Exp_StringMatch(exp_buffer,ec->pattern,&offset);
if (matched >= 0) {
exp_match = exp_buffer + offset;
exp_match_end = exp_match + matched;
}
} else if (ec->type == exp_exact) {
char *p = strstr(exp_buffer,ec->pattern);
if (p) {
matched = 1;
exp_match = p;
exp_match_end = p + strlen(ec->pattern);
}
} else if (ec->type == exp_null) {
char *p;
for (p=exp_buffer;p<exp_buffer_end;p++) {
if (*p == 0) {
matched = 1;
exp_match = p;
exp_match_end = p+1;
}
}
} else {
TclRegError((char *)0);
if (TclRegExec(ec->re,exp_buffer,exp_buffer)) {
matched = 1;
exp_match = ec->re->startp[0];
exp_match_end = ec->re->endp[0];
} else if (TclGetRegError()) {
fprintf(stderr,"r.e. match (pattern %s) failed: %s",ec->pattern,TclGetRegError());
}
}
if (matched != -1) {
exp_debuglog("yes\nexp_buffer is {%s}\n",
exp_printify(exp_buffer));
return_normally(ec->value);
} else exp_debuglog("no\n");
}
if (exp_timeout > 0) {
time(¤t_time);
remtime = end_time - current_time;
}
}
cleanup:
f->buffer = exp_buffer;
f->buffer_end = exp_buffer_end;
f->match_end = exp_match_end;
if (fd == -1) fflush(fp);
if (sys_error) {
errno = sys_error;
return -1;
}
return return_val;
}
int
exp_fexpectv(fp,ecases)
FILE *fp;
struct exp_case *ecases;
{
return(expectv(-1,fp,ecases));
}
int
exp_expectv(fd,ecases)
int fd;
struct exp_case *ecases;
{
return(expectv(fd,(FILE *)0,ecases));
}
int
exp_expectl TCL_VARARGS_DEF(int,arg1)
{
va_list args;
int fd;
struct exp_case *ec, *ecases;
int i;
enum exp_type type;
fd = TCL_VARARGS_START(int,arg1,args);
for (i=0;;i++) {
type = va_arg(args,enum exp_type);
if (type == exp_end) break;
if ((int)type < 0 || (int)type >= (int)exp_bogus) {
fprintf(stderr,"bad type (set %d) in exp_expectl\n",i);
sysreturn(EINVAL);
}
va_arg(args,char *);
if (type == exp_compiled) {
va_arg(args,regexp *);
}
va_arg(args,int);
}
va_end(args);
if (!(ecases = (struct exp_case *)
malloc((1+i)*sizeof(struct exp_case))))
sysreturn(ENOMEM);
fd = TCL_VARARGS_START(int,arg1,args);
for (ec=ecases;;ec++) {
ec->type = va_arg(args,enum exp_type);
if (ec->type == exp_end) break;
ec->pattern = va_arg(args,char *);
if (ec->type == exp_compiled) {
ec->re = va_arg(args,regexp *);
} else {
ec->re = 0;
}
ec->value = va_arg(args,int);
}
va_end(args);
i = expectv(fd,(FILE *)0,ecases);
for (ec=ecases;ec->type != exp_end;ec++) {
if (ec->type == exp_regexp) {
free((char *)ec->re);
}
}
free((char *)ecases);
return(i);
}
int
exp_fexpectl TCL_VARARGS_DEF(FILE *,arg1)
{
va_list args;
FILE *fp;
struct exp_case *ec, *ecases;
int i;
enum exp_type type;
fp = TCL_VARARGS_START(FILE *,arg1,args);
for (i=0;;i++) {
type = va_arg(args,enum exp_type);
if (type == exp_end) break;
if ((int)type < 0 || (int)type >= (int)exp_bogus) {
fprintf(stderr,"bad type (set %d) in exp_expectl\n",i);
sysreturn(EINVAL);
}
va_arg(args,char *);
if (type == exp_compiled) {
va_arg(args,regexp *);
}
va_arg(args,int);
}
va_end(args);
if (!(ecases = (struct exp_case *)
malloc((1+i)*sizeof(struct exp_case))))
sysreturn(ENOMEM);
#if 0
va_start(args);
va_arg(args,FILE *);
#endif
(void) TCL_VARARGS_START(FILE *,arg1,args);
for (ec=ecases;;ec++) {
ec->type = va_arg(args,enum exp_type);
if (ec->type == exp_end) break;
ec->pattern = va_arg(args,char *);
if (ec->type == exp_compiled) {
ec->re = va_arg(args,regexp *);
} else {
ec->re = 0;
}
ec->value = va_arg(args,int);
}
va_end(args);
i = expectv(-1,fp,ecases);
for (ec=ecases;ec->type != exp_end;ec++) {
if (ec->type == exp_regexp) {
free((char *)ec->re);
}
}
free((char *)ecases);
return(i);
}
FILE *
exp_popen(program)
char *program;
{
FILE *fp;
int ec;
if (0 > (ec = exp_spawnl("sh","sh","-c",program,(char *)0))) return(0);
if (!(fp = fdopen(ec,"r+"))) return(0);
setbuf(fp,(char *)0);
return(fp);
}
int
exp_disconnect()
{
int ttyfd;
#ifndef EALREADY
#define EALREADY 37
#endif
if (exp_disconnected) sysreturn(EALREADY);
exp_disconnected = TRUE;
freopen("/dev/null","r",stdin);
freopen("/dev/null","w",stdout);
freopen("/dev/null","w",stderr);
#ifdef POSIX
setsid();
#else
#ifdef SYSV3
exp_setpgrp();
signal(SIGHUP,SIG_IGN);
if (fork()) exit(0);
#else
exp_setpgrp();
#ifdef TIOCNOTTY
ttyfd = open("/dev/tty", O_RDWR);
if (ttyfd >= 0) {
(void) ioctl(ttyfd, TIOCNOTTY, (char *)0);
(void) close(ttyfd);
}
#endif
#endif
#endif
return(0);
}
void
exp_debuglog TCL_VARARGS_DEF(char *,arg1)
{
char *fmt;
va_list args;
fmt = TCL_VARARGS_START(char *,arg1,args);
if (exp_debugfile) vfprintf(exp_debugfile,fmt,args);
if (exp_is_debugging) {
vfprintf(stderr,fmt,args);
if (exp_logfile) vfprintf(exp_logfile,fmt,args);
}
va_end(args);
}
void
exp_errorlog TCL_VARARGS_DEF(char *,arg1)
{
char *fmt;
va_list args;
fmt = TCL_VARARGS_START(char *,arg1,args);
vfprintf(stderr,fmt,args);
if (exp_debugfile) vfprintf(exp_debugfile,fmt,args);
if (exp_logfile) vfprintf(exp_logfile,fmt,args);
va_end(args);
}
#include <ctype.h>
char *
exp_printify(s)
char *s;
{
static int destlen = 0;
static char *dest = 0;
char *d;
unsigned int need;
if (s == 0) return("<null>");
need = strlen(s)*4 + 1;
if (need > destlen) {
if (dest) ckfree(dest);
dest = ckalloc(need);
destlen = need;
}
for (d = dest;*s;s++) {
if (*s == '\r') {
strcpy(d,"\\r"); d += 2;
} else if (*s == '\n') {
strcpy(d,"\\n"); d += 2;
} else if (*s == '\t') {
strcpy(d,"\\t"); d += 2;
} else if (isascii(*s) && isprint(*s)) {
*d = *s; d += 1;
} else {
sprintf(d,"\\x%02x",*s & 0xff); d += 4;
}
}
*d = '\0';
return(dest);
}