xtrn.cpp

						(void) ioctl(slave, TIOCSWINSZ,
							(char *)winp);
					return (0);
				}
				(void) close(master);
			}
		}
	}
	errno = ENOENT;	/* out of ptys */
	return (-1);
}

static int forkpty(int *amaster, char *name, termios *termp, winsize *winp)
{
	int master, slave, pid;

	if (openpty(&master, &slave, name, termp, winp) == -1)
		return (-1);
	switch (pid = FORK()) {
	case -1:
		return (-1);
	case 0:
		/*
		 * child
		 */
		(void) close(master);
		login_tty(slave);
		return (0);
	}
	/*
	 * parent
	 */
	*amaster = master;
	(void) close(slave);
	return (pid);
}
#endif /* NEED_FORKPTY */

int sbbs_t::external(const char* cmdline, long mode, const char* startup_dir)
{
	char	str[MAX_PATH+1];
	char	fname[MAX_PATH+1];
	char	fullpath[MAX_PATH+1];
	char	fullcmdline[MAX_PATH+1];
	char*	argv[MAX_ARGS];
	BYTE*	bp;
	BYTE	buf[XTRN_IO_BUF_LEN];
    BYTE 	output_buf[XTRN_IO_BUF_LEN*2];
	ulong	avail;
    ulong	output_len;
	bool	native=false;			// DOS program by default
	bool	rio_abortable_save=rio_abortable;
	int		i;
	bool	data_waiting;
	int		rd;
	int		wr;
	int		argc;
	pid_t	pid;
	int		in_pipe[2];
	int		out_pipe[2];
	int		err_pipe[2];
	fd_set ibits;
	int	high_fd;
	struct timeval timeout;
    BYTE 	wwiv_buf[XTRN_IO_BUF_LEN*2];
    bool	wwiv_flag=false;
 	char* p;

	xtrn_mode = mode;
	lprintf(LOG_DEBUG, "Executing external: %s", cmdline);

	if(startup_dir!=NULL && startup_dir[0] && !isdir(startup_dir)) {
		errormsg(WHERE, ERR_CHK, startup_dir, 0);
		return -1;
	}

	if(startup_dir==NULL)
		startup_dir=nulstr;

	XTRN_LOADABLE_MODULE(cmdline,startup_dir);
	XTRN_LOADABLE_JS_MODULE(cmdline,mode,startup_dir);

	attr(cfg.color[clr_external]);  /* setup default attributes */

	native = native_executable(&cfg, cmdline, mode);

    SAFECOPY(str,cmdline);			/* Set fname to program name only */
	truncstr(str," ");
    SAFECOPY(fname,getfname(str));

	sprintf(fullpath,"%s%s",startup_dir,fname);
	if(startup_dir!=NULL && cmdline[0]!='/' && cmdline[0]!='.' && fexist(fullpath))
		sprintf(fullcmdline,"%s%s",startup_dir,cmdline);
	else
		SAFECOPY(fullcmdline,cmdline);

 	if(native) { // Native (32-bit) external

		// Current environment passed to child process
		sprintf(dszlog,"%sPROTOCOL.LOG",cfg.node_dir);
		setenv("DSZLOG",dszlog,1); 		/* Makes the DSZ LOG active */
		setenv("SBBSNODE",cfg.node_dir,1);
		setenv("SBBSCTRL",cfg.ctrl_dir,1);
		setenv("SBBSDATA",cfg.data_dir,1);
		setenv("SBBSEXEC",cfg.exec_dir,1);
		sprintf(str,"%u",cfg.node_num);
		setenv("SBBSNNUM",str,1);

		/* date/time env vars */
		now = time(NULL);
		struct	tm tm;
		if(localtime_r(&now, &tm) == NULL)
			memset(&tm, 0, sizeof(tm));
		sprintf(str," %02u", tm.tm_mday);
		setenv("DAY", str, /* overwrite */TRUE);
		setenv("WEEKDAY", wday[tm.tm_wday], /* overwrite */TRUE);
		setenv("MONTHNAME", mon[tm.tm_mon], /* overwrite */TRUE);
		sprintf(str, "%02u", tm.tm_mon + 1);
		setenv("MONTH", str, /* overwrite */TRUE);
		sprintf(str,"%u", 1900 + tm.tm_year);
		if(setenv("YEAR", str, /* overwrite */TRUE) != 0)
			errormsg(WHERE,ERR_WRITE,"environment",0);

	} else {
		if(startup->options&BBS_OPT_NO_DOS) {
			lprintf((mode&EX_OFFLINE) ? LOG_ERR : LOG_WARNING, "DOS programs not supported: %s", cmdline);
			bprintf("Sorry, DOS programs are not supported on this node.\r\n");
			return -1;
		}
#if defined(__FreeBSD__)
		/* ToDo: This seems to work for every door except Iron Ox
		   ToDo: Iron Ox is unique in that it runs perfectly from
		   ToDo: tcsh but not at all from anywhere else, complaining
		   ToDo: about corrupt files.  I've ruled out the possibilty
		   ToDo: of it being a terminal mode issue... no other ideas
		   ToDo: come to mind. */

		FILE * doscmdrc;

		sprintf(str,"%s.doscmdrc",cfg.node_dir);
		if((doscmdrc=fopen(str,"w+"))==NULL)  {
			errormsg(WHERE,ERR_CREATE,str,0);
			return(-1);
		}
		if(startup_dir!=NULL && startup_dir[0])
			fprintf(doscmdrc,"assign C: %s\n",startup_dir);
		else
			fprintf(doscmdrc,"assign C: .\n");

		fprintf(doscmdrc,"assign D: %s\n",cfg.node_dir);
		SAFECOPY(str,cfg.exec_dir);
		if((p=strrchr(str,'/'))!=NULL)
			*p=0;
		if((p=strrchr(str,'/'))!=NULL)
			*p=0;
		fprintf(doscmdrc,"assign E: %s\n",str);

		/* setup doscmd env here */
		/* ToDo Note, this assumes that the BBS uses standard dir names */
		fprintf(doscmdrc,"DSZLOG=E:\\node%d\\PROTOCOL.LOG\n",cfg.node_num);
		fprintf(doscmdrc,"SBBSNODE=D:\\\n");
		fprintf(doscmdrc,"SBBSCTRL=E:\\ctrl\\\n");
		fprintf(doscmdrc,"SBBSDATA=E:\\data\\\n");
		fprintf(doscmdrc,"SBBSEXEC=E:\\exec\\\n");
		fprintf(doscmdrc,"SBBSNNUM=%d\n",cfg.node_num);
		fprintf(doscmdrc,"PCBNODE=%d\n",cfg.node_num);
		fprintf(doscmdrc,"PCBDRIVE=D:\n");
		fprintf(doscmdrc,"PCBDIR=\\\n");

		fclose(doscmdrc);
		SAFECOPY(str,fullcmdline);
		sprintf(fullcmdline,"%s -F %s",startup->dosemu_path,str);

#elif defined(__linux__) && defined(USE_DOSEMU)

		/* dosemu integration  --  Ryan Underwood, <nemesis @ icequake.net> */

		FILE *dosemubat;
		int setup_override;
		char tok[MAX_PATH+1];

		char dosemuconf[MAX_PATH+1];
		char dosemubinloc[MAX_PATH+1];
		char virtualconf[75];
		char dosterm[15];
		char log_external[MAX_PATH+1];

		/*  on the Unix side. xtrndir is the parent of the door's startup dir. */
		char xtrndir[MAX_PATH+1];

		/*  on the DOS side.  */
		char xtrndir_dos[MAX_PATH+1];
		char ctrldir_dos[MAX_PATH+1];
		char datadir_dos[MAX_PATH+1];
		char execdir_dos[MAX_PATH+1];

		/* Default locations that can be overridden by
		 * the sysop in emusetup.bat */

		const char nodedrive[] = DOSEMU_NODE_DRIVE;
		const char xtrndrive[] = DOSEMU_XTRN_DRIVE;
		const char ctrldrive[] = DOSEMU_CTRL_DRIVE;
		const char datadrive[] = DOSEMU_DATA_DRIVE;
		const char execdrive[] = DOSEMU_EXEC_DRIVE;

		SAFECOPY(str,startup_dir);
		if(*(p=lastchar(str))=='/')		/* kill trailing slash */
			*p=0;
		if((p=strrchr(str,'/'))!=NULL)  /* kill the last element of the path */
			*p=0;

		SAFECOPY(xtrndir,str);

		/* construct DOS equivalents for the unix directories */

		SAFECOPY(ctrldir_dos,cfg.ctrl_dir);
		REPLACE_CHARS(ctrldir_dos,'/','\\',p);

		p=lastchar(ctrldir_dos);
		if (*p=='\\') *p=0;

		SAFECOPY(datadir_dos,cfg.data_dir);
		REPLACE_CHARS(datadir_dos,'/','\\',p);

		p=lastchar(datadir_dos);
		if (*p=='\\') *p=0;

		SAFECOPY(execdir_dos,cfg.exec_dir);
		REPLACE_CHARS(execdir_dos,'/','\\',p);

		p=lastchar(execdir_dos);
		if (*p=='\\') *p=0;

		SAFECOPY(xtrndir_dos,xtrndir);
		REPLACE_CHARS(xtrndir_dos,'/','\\',p);

		/* check for existence of a dosemu.conf in the door directory.
		 * It is a good idea to be able to use separate configs for each
		 * door. */

		sprintf(str,"%sdosemu.conf",startup_dir);
		if (!fexist(str)) {

		/* If we can't find it in the door dir, look for a global one
		 * in the ctrl dir. */

			sprintf(str,"%sdosemu.conf",cfg.ctrl_dir);
			if (!fexist(str)) {

		/* If we couldn't find either, try for the system one, then
		 * error out. */
				SAFECOPY(str,"/etc/dosemu/dosemu.conf");
				if (!fexist(str)) {

					SAFECOPY(str,"/etc/dosemu.conf");
					if (!fexist(str)) {
						errormsg(WHERE,ERR_READ,str,0);
						return(-1);
					}
					else SAFECOPY(dosemuconf,str);  /* using system conf */
				}
				else SAFECOPY(dosemuconf,str);  /* using system conf */
			}
			else SAFECOPY(dosemuconf,str);   /* using global conf */
		}
		else SAFECOPY(dosemuconf,str);  /* using door-specific conf */

		/* same deal for emusetup.bat. */

		sprintf(str,"%semusetup.bat",startup_dir);
		if (!fexist(str)) {

		/* If we can't find it in the door dir, look for a global one
		 * in the ctrl dir. */

			sprintf(str,"%semusetup.bat",cfg.ctrl_dir);
			if (!fexist(str)) {

		/* If we couldn't find either, set an error condition. */
				setup_override = -1;
			}
			else setup_override = 0;  /* using global bat */
		}
		else setup_override = 1;  /* using door-specific bat */

		/* Create the external bat here to be placed in the node dir. */

		sprintf(str,"%sexternal.bat",cfg.node_dir);
		if(!(dosemubat=fopen(str,"w+"))) {
			errormsg(WHERE,ERR_CREATE,str,0);
			return(-1);
		}

		fprintf(dosemubat,"@echo off\r\n");
		fprintf(dosemubat,"set DSZLOG=%s\\PROTOCOL.LOG\r\n",nodedrive);
		fprintf(dosemubat,"set SBBSNODE=%s\r\n",nodedrive);
		fprintf(dosemubat,"set SBBSNNUM=%d\r\n",cfg.node_num);
		fprintf(dosemubat,"set SBBSCTRL=%s\r\n",ctrldrive);
		fprintf(dosemubat,"set SBBSDATA=%s\r\n",datadrive);
		fprintf(dosemubat,"set SBBSEXEC=%s\r\n",execdrive);
		fprintf(dosemubat,"set PCBNODE=%d\r\n",cfg.node_num);
		fprintf(dosemubat,"set PCBDRIVE=%s\r\n",nodedrive);
		fprintf(dosemubat,"set PCBDIR=\\\r\n");

		// let's do this cleanly like dosemu's default autoexec.bat does -wk42
		/* clear existing redirections on dos side and */
		/* redirect necessary drive letters to unix paths */
		fprintf(dosemubat,"unix -s DOSDRIVE_E\r\n");
		fprintf(dosemubat,"if '%%DOSDRIVE_E%%' == '' goto nodriveE\r\n");
		fprintf(dosemubat,"lredir del %s\r\n",xtrndrive);
		fprintf(dosemubat,":nodriveE\r\n");
		fprintf(dosemubat,"lredir %s linux\\fs%s\r\n",xtrndrive,xtrndir_dos);

		fprintf(dosemubat,"unix -s DOSDRIVE_F\r\n");
		fprintf(dosemubat,"if '%%DOSDRIVE_F%%' == '' goto nodriveF\r\n");
		fprintf(dosemubat,"lredir del %s\r\n",ctrldrive);
		fprintf(dosemubat,":nodriveF\r\n");
		fprintf(dosemubat,"lredir %s linux\\fs%s\r\n",ctrldrive,ctrldir_dos);

		fprintf(dosemubat,"unix -s DOSDRIVE_G\r\n");
		fprintf(dosemubat,"if '%%DOSDRIVE_G%%' == '' goto nodriveG\r\n");
		fprintf(dosemubat,"lredir del %s\r\n",datadrive);
		fprintf(dosemubat,":nodriveG\r\n");
		fprintf(dosemubat,"lredir %s linux\\fs%s\r\n",datadrive,datadir_dos);

		fprintf(dosemubat,"unix -s DOSDRIVE_H\r\n");
		fprintf(dosemubat,"if '%%DOSDRIVE_H%%' == '' goto nodriveH\r\n");
		fprintf(dosemubat,"lredir del %s\r\n",execdrive);
		fprintf(dosemubat,":nodriveH\r\n");
		fprintf(dosemubat,"lredir %s linux\\fs%s\r\n",execdrive,execdir_dos);

		/* change to the drive where the parent of the startup_dir is mounted */
		fprintf(dosemubat,"%s\r\n",xtrndrive);

		const char* gamedir = "";
		if(startup_dir!=NULL && startup_dir[0]) {
			SAFECOPY(str, startup_dir);
			*lastchar(str) = 0;
			gamedir = getfname(str);
		}
		if(*gamedir == 0) {
			lprintf(LOG_ERR, "No startup directory configured for DOS command-line: %s", cmdline);
			return -1;
		}
		fprintf(dosemubat,"cd %s\r\n", gamedir);

		if (setup_override == 1)
			fprintf(dosemubat,"call %s\\%s\\emusetup.bat %s\r\n",xtrndrive,gamedir,cmdline);
		else if (setup_override == 0)
			fprintf(dosemubat,"call %s\\emusetup.bat\r\n",ctrldrive);
		/* if (setup_override == -1) do_nothing */

		/*  Check if it's a bat file, to prepend "call" to the command  */

		SAFECOPY(tok,cmdline);
		truncstr(tok," ");

		p = getfext(tok);  /*  check if it's a bat file  */
		if (p != NULL && stricmp(p, ".bat") == 0)
			fprintf(dosemubat,"call ");  /* if so, "call" it */

		fprintf(dosemubat,"%s\r\n",cmdline);
		fprintf(dosemubat,"exitemu\r\n");

		/* Check the "Stdio Interception" flag from scfg for this door.  If it's
		 * enabled, we enable doorway mode.  Else, it's vmodem for us, unless
		 * it's a timed event.
		 */

		if (!(mode&(EX_STDIO)) && online!=ON_LOCAL)
			SAFECOPY(virtualconf,"-I\"serial { virtual com 1 }\"");
		else
			virtualconf[0] = '\0';

		/* Set the interception bits, since we are always going to want Synchronet
		 * to intercept dos programs under Unix.
		 */

		mode |= EX_STDIO;

		/* See if we have the dosemu link in the door's dir.  If so, use the dosemu
		 * that it points to as our command to execute.  If not, use DOSemuPath.
		 */

		sprintf(str,"%sdosemu.bin",startup_dir);
		if (!fexist(str)) {
			SAFECOPY(dosemubinloc,(cmdstr(startup->dosemu_path,nulstr,nulstr,tok)));
		}
		else {
			SAFECOPY(dosemubinloc,str);
		}

		/* Attempt to keep dosemu from prompting for a disclaimer. */

		sprintf(str, "%s/.dosemu", cfg.ctrl_dir);
		if (!isdir(str)) {
			mkdir(str, 0755);
		}

		strcat(str, "/disclaimer");
		ftouch(str);

		/* Set up the command for dosemu to execute with 'unix -e'. */

		sprintf(str,"%sexternal.bat",nodedrive);

		/* need TERM=linux for maintenance programs to work
		 * (dosemu won't start with no controlling terminal)
		 * Also, redirect stdout to a log if it's a timed event.
		 */

		if (online==ON_LOCAL) {
			SAFECOPY(dosterm,"TERM=linux");
			safe_snprintf(log_external, sizeof(log_external), ">> %sdosevent_%s.log",cfg.logs_dir,fname);
		}
		else {
			dosterm[0]='\0';
			log_external[0] = '\0';
		}

		/* Drum roll. */

		safe_snprintf(fullcmdline, sizeof(fullcmdline),
		// remove unneeded redirection and fix faulty keystroke command -wk42
		"/usr/bin/env %s HOME=%s QUIET=1 DOSDRIVE_D=%s %s -I\"video { none }\" -I'keystroke \"\\r\"' %s -f%s -E%s -o%sdosemu_boot.log %s",
			dosterm,cfg.ctrl_dir,cfg.node_dir,dosemubinloc,virtualconf,dosemuconf,str,cfg.node_dir,log_external);

		fprintf(dosemubat,"REM For debugging: %s\r\n",fullcmdline);
		fclose(dosemubat);

#else
		lprintf((mode&EX_OFFLINE) ? LOG_ERR : LOG_WARNING, "DOS programs not supported: %s", cmdline);
		bprintf("Sorry, DOS programs are not supported on this node.\r\n");

		return(-1);
#endif
	}

	if(!(mode&EX_STDIN)) {
		if(!(mode&EX_STDIN)) {
			if(passthru_thread_running)
				passthru_socket_activate(true);
			else
				pthread_mutex_lock(&input_thread_mutex);
		}
	}

	if(!(mode&EX_NOLOG) && pipe(err_pipe)!=0) {
		errormsg(WHERE,ERR_CREATE,"err_pipe",0);
		return(-1);
	}

	if((mode&EX_STDIO)==EX_STDIO)  {
		struct winsize winsize;
		struct termios term;
		memset(&term,0,sizeof(term));
		cfsetispeed(&term,B19200);
		cfsetospeed(&term,B19200);
		if(mode&EX_BIN)
			cfmakeraw(&term);
		else {
			term.c_iflag = TTYDEF_IFLAG;
			term.c_oflag = TTYDEF_OFLAG;
			term.c_lflag = TTYDEF_LFLAG;
			term.c_cflag = TTYDEF_CFLAG;
			memcpy(term.c_cc,ttydefchars,sizeof(term.c_cc));
		}
		winsize.ws_row=rows;
		winsize.ws_col=cols;
		if((pid=forkpty(&in_pipe[1],NULL,&term,&winsize))==-1) {
			if(!(mode&EX_STDIN)) {
				if(passthru_thread_running)
					passthru_socket_activate(false);
				else
					pthread_mutex_unlock(&input_thread_mutex);
			}
			errormsg(WHERE,ERR_EXEC,fullcmdline,0);
			return(-1);
		}
		out_pipe[0]=in_pipe[1];
	}
	else  {
		if(mode&EX_STDIN)
			if(pipe(in_pipe)!=0) {
				errormsg(WHERE,ERR_CREATE,"in_pipe",0);
				return(-1);
			}
		if(mode&EX_STDOUT)
			if(pipe(out_pipe)!=0) {
				errormsg(WHERE,ERR_CREATE,"out_pipe",0);
				return(-1);
			}


		if((pid=FORK())==-1) {
			if(!(mode&EX_STDIN)) {
				if(passthru_thread_running)
					passthru_socket_activate(false);
				else
					pthread_mutex_unlock(&input_thread_mutex);
			}
			errormsg(WHERE,ERR_EXEC,fullcmdline,0);
			return(-1);
		}
	}
	if(pid==0) {	/* child process */
		/* Give away all privs for good now */
		if(startup->setuid!=NULL)
			startup->setuid(TRUE);

		sigset_t        sigs;
		sigfillset(&sigs);
		sigprocmask(SIG_UNBLOCK,&sigs,NULL);
		if(!(mode&EX_BIN))  {
			if(term_supports(ANSI))
				SAFEPRINTF(term_env,"TERM=%s",startup->xtrn_term_ansi);
			else
				SAFEPRINTF(term_env,"TERM=%s",startup->xtrn_term_dumb);
			putenv(term_env);
		}
#ifdef __FreeBSD__
		if(!native)
			chdir(cfg.node_dir);
		else
#endif
		if(startup_dir!=NULL && startup_dir[0])
			if(chdir(startup_dir)!=0) {
				errormsg(WHERE,ERR_CHDIR,startup_dir,0);
				return(-1);
			}

		if(mode&EX_SH || strcspn(fullcmdline,"<>|;\"")!=strlen(fullcmdline)) {
			argv[0]=comspec;
			argv[1]=(char*)"-c";
			argv[2]=fullcmdline;
			argv[3]=NULL;
		} else {
			argv[0]=fullcmdline;	/* point to the beginning of the string */
			argc=1;
			for(i=0;fullcmdline[i] && argc<MAX_ARGS;i++)	/* Break up command line */
				if(fullcmdline[i]==' ') {
					fullcmdline[i]=0;			/* insert nulls */
					argv[argc++]=fullcmdline+i+1; /* point to the beginning of the next arg */
				}
			argv[argc]=NULL;
		}

		if(mode&EX_STDIN && !(mode&EX_STDOUT))  {
			close(in_pipe[1]);		/* close write-end of pipe */
			dup2(in_pipe[0],0);		/* redirect stdin */
			close(in_pipe[0]);		/* close excess file descriptor */
		}

		if(mode&EX_STDOUT && !(mode&EX_STDIN)) {
			close(out_pipe[0]);		/* close read-end of pipe */
			dup2(out_pipe[1],1);	/* stdout */
			if(!(mode&EX_NOLOG))
				dup2(out_pipe[1],2);	/* stderr */
			close(out_pipe[1]);		/* close excess file descriptor */
		}

		if(!(mode & EX_STDIO)) {
			int fd;

			/* Redirect stdio to /dev/null */
			if ((fd = open(_PATH_DEVNULL, O_RDWR, 0)) != -1) {
				dup2(fd, STDIN_FILENO);
				dup2(fd, STDOUT_FILENO);
				if(!(mode&EX_NOLOG))
					dup2(fd, STDERR_FILENO);
				if (fd > 2)
					close(fd);
			}
		}

		if(mode&EX_BG)	/* background execution, detach child */
		{
			lprintf(LOG_INFO,"Detaching external process");
			daemon(TRUE,FALSE);
   	    }

		if(!(mode&EX_NOLOG)) {
			close(err_pipe[0]);		/* close read-end of pipe */
			dup2(err_pipe[1],2);	/* stderr */
		}

		execvp(argv[0],argv);
		lprintf(LOG_ERR,"!ERROR %d (%s) executing: %s", errno, strerror(errno), argv[0]);
		_exit(-1);	/* should never get here */
	}

	if(strcmp(cmdline, fullcmdline) != 0)
		lprintf(LOG_DEBUG,"Executing cmd-line: %s", fullcmdline);

	/* Disable Ctrl-C checking */
	if(!(mode&EX_OFFLINE))
		rio_abortable=false;

	if(!(mode&EX_NOLOG))
		close(err_pipe[1]);	/* close write-end of pipe */

	if(mode&EX_STDOUT) {
		if(!(mode&EX_STDIN))
			close(out_pipe[1]);	/* close write-end of pipe */
		while(!terminated) {
			if(waitpid(pid, &i, WNOHANG)!=0)	/* child exited */
				break;

			if(mode&EX_CHKTIME)
				gettimeleft();

			if(!online && !(mode&EX_OFFLINE)) {
				logline(LOG_NOTICE,"X!","hung-up in external program");
				break;
			}

			/* Input */
			if(mode&EX_STDIN && RingBufFull(&inbuf)) {
				if((wr=RingBufRead(&inbuf,buf,sizeof(buf)))!=0)
					write(in_pipe[1],buf,wr);
			}

			/* Error Output */
			FD_ZERO(&ibits);
			if(!(mode&EX_NOLOG)) {
				FD_SET(err_pipe[0],&ibits);
				high_fd=err_pipe[0];
			}
			FD_SET(out_pipe[0],&ibits);
			if(!(mode&EX_NOLOG)) {
				if(out_pipe[0]>err_pipe[0])
					high_fd=out_pipe[0];
			} else
				high_fd=out_pipe[0];
			timeout.tv_sec=0;
			timeout.tv_usec=1000;
			bp=buf;
			i=0;
			if(mode&EX_NOLOG)
				select(high_fd+1,&ibits,NULL,NULL,&timeout);
			else {
				while ((select(high_fd+1,&ibits,NULL,NULL,&timeout)>0) && FD_ISSET(err_pipe[0],&ibits) && (i<(int)sizeof(buf)-1))  {
					if((rd=read(err_pipe[0],bp,1))>0)  {
						i+=rd;
						bp++;
						if(*(bp-1)=='\n')
							break;
					}
					else
						break;
					FD_ZERO(&ibits);
					FD_SET(err_pipe[0],&ibits);
					FD_SET(out_pipe[0],&ibits);
					timeout.tv_sec=0;
					timeout.tv_usec=1000;
				}
				if(i > 0) {
					buf[i] = '\0';
					p = (char*)buf;
					truncsp(p);
					SKIP_WHITESPACE(p);
					if(*p)
						lprintf(LOG_NOTICE, "%s: %s", fname, p);
				}

				/* Eat stderr if mode is EX_BIN */
				if(mode&EX_BIN)  {
					bp=buf;
					i=0;
				}
			}

			data_waiting=FD_ISSET(out_pipe[0],&ibits);
			if(i==0 && data_waiting==0)
				continue;

			avail=(RingBufFree(&outbuf)-i)/2;	// Leave room for wwiv/telnet expansion
			if(avail==0) {
#if 0
				lprintf("Node %d !output buffer full (%u bytes)"
						,cfg.node_num,RingBufFull(&outbuf));
#endif
				YIELD();
				continue;
			}

			rd=avail;

			if(rd>((int)sizeof(buf)-i))
				rd=sizeof(buf)-i;

			if(data_waiting)  {
				rd=read(out_pipe[0],bp,rd);
				if(rd<1 && i==0)
					continue;
				if(rd<0)
					rd=0;
			}
			else
				rd=0;

			rd += i;

			if(mode&EX_BIN) {
				if(telnet_mode&TELNET_MODE_OFF) {
					bp=buf;
					output_len=rd;
				}
				else
   	       			output_len = telnet_expand(buf, rd, output_buf, sizeof(output_buf), /* expand_cr: */false, &bp);
			} else {
				if ((mode & EX_STDIO) != EX_STDIO) {
					/* LF to CRLF expansion */
					bp=lf_expand(buf, rd, output_buf, output_len);
				} else if(mode&EX_WWIV) {
					bp=wwiv_expand(buf, rd, wwiv_buf, output_len, useron.misc, wwiv_flag);
					if(output_len > sizeof(wwiv_buf))
						lprintf(LOG_ERR, "WWIV_BUF OVERRUN");
				} else {
					bp=buf;
					output_len=rd;
				}
				if (term_supports(PETSCII))
					petscii_convert(bp, output_len);
			}
			/* Did expansion overrun the output buffer? */
			if(output_len>sizeof(output_buf)) {
				lprintf(LOG_ERR,"OUTPUT_BUF OVERRUN");
				output_len=sizeof(output_buf);
			}

			/* Does expanded size fit in the ring buffer? */
			if(output_len>RingBufFree(&outbuf)) {
				lprintf(LOG_ERR,"output buffer overflow");
				output_len=RingBufFree(&outbuf);
			}

			RingBufWrite(&outbuf, bp, output_len);

		}

		if(waitpid(pid, &i, WNOHANG)==0)  {		// Child still running?
			kill(pid, SIGHUP);					// Tell child user has hung up
			time_t start=time(NULL);			// Wait up to 10 seconds
			while(time(NULL)-start<10) {		// for child to terminate
				if(waitpid(pid, &i, WNOHANG)!=0)
					break;
				mswait(500);
			}
			if(waitpid(pid, &i, WNOHANG)==0)	// Child still running?
				kill(pid, SIGKILL);				// terminate child process
		}
		/* close unneeded descriptors */
		if(mode&EX_STDIN)
			close(in_pipe[1]);
		close(out_pipe[0]);
	}
	if(mode&EX_NOLOG)
		waitpid(pid, &i, 0);
	else {
		while(waitpid(pid, &i, WNOHANG)==0)  {
			FD_ZERO(&ibits);
			FD_SET(err_pipe[0],&ibits);
			timeout.tv_sec=1;
			timeout.tv_usec=0;
			bp=buf;
			i=0;
			while ((select(err_pipe[0]+1,&ibits,NULL,NULL,&timeout)>0) && (i<XTRN_IO_BUF_LEN-1))  {
				if((rd=read(err_pipe[0],bp,1))>0)  {
					i+=rd;
					if(*bp=='\n') {
						buf[i] = '\0';
						p = (char*)buf;
						truncsp(p);
						SKIP_WHITESPACE(p);
						if(*p)
							lprintf(LOG_NOTICE, "%s: %s", fname, p);
						i=0;
						bp=buf;
					}
					else
						bp++;
				}
				else
					break;
			}
			if(i > 0) {
				buf[i] = '\0';
				p = (char*)buf;
				truncsp(p);
				SKIP_WHITESPACE(p);
				if(*p)
					lprintf(LOG_NOTICE, "%s: %s", fname, p);
			}
		}
	}
	if(!(mode&EX_OFFLINE)) {	/* !off-line execution */

		curatr=~0;			// Can't guarantee current attributes
		attr(LIGHTGRAY);	// Force to "normal"

		rio_abortable=rio_abortable_save;	// Restore abortable state

		/* Got back to Text/NVT mode */
		request_telnet_opt(TELNET_DONT,TELNET_BINARY_TX);
	}

	if(!(mode&EX_NOLOG))
		close(err_pipe[0]);

	if(!(mode&EX_STDIN)) {
		if(passthru_thread_running)
			passthru_socket_activate(false);
		else
			pthread_mutex_unlock(&input_thread_mutex);
	}

	return(errorlevel = WEXITSTATUS(i));
}

#endif	/* !WIN32 */

const char* quoted_string(const char* str, char* buf, size_t maxlen)
{
	if(strchr(str,' ')==NULL)
		return(str);
	safe_snprintf(buf,maxlen,"\"%s\"",str);
	return(buf);
}

#define QUOTED_STRING(ch, str, buf, maxlen) \
	((IS_ALPHA(ch) && IS_UPPERCASE(ch)) ? str : quoted_string(str,buf,maxlen))

/*****************************************************************************/
/* Returns command line generated from instr with %c replacements            */
/*****************************************************************************/
char* sbbs_t::cmdstr(const char *instr, const char *fpath, const char *fspec, char *outstr, long mode)
{
	char	str[MAX_PATH+1],*cmd;
    int		i,j,len;

	if(mode == EX_UNSPECIFIED && (*instr == '?' || *instr == '*'))
		mode = EX_NATIVE;

    if(outstr==NULL)
        cmd=cmdstr_output;
    else
        cmd=outstr;
    len=strlen(instr);
	int maxlen = (int)sizeof(cmdstr_output) - 1;
    for(i=j=0; i<len && j < maxlen; i++) {
        if(instr[i]=='%') {
            i++;
            cmd[j]=0;
			int avail = maxlen - j;
			char ch=instr[i];
			if(IS_ALPHA(ch))
				ch=toupper(ch);
            switch(ch) {
                case 'A':   /* User alias */
                    strncat(cmd,QUOTED_STRING(instr[i],useron.alias,str,sizeof(str)), avail);
                    break;
                case 'B':   /* Baud (DTE) Rate */
                    strncat(cmd,ultoa(dte_rate,str,10), avail);
                    break;
                case 'C':   /* Connect Description */
                    strncat(cmd,connection, avail);
                    break;
                case 'D':   /* Connect (DCE) Rate */
                    strncat(cmd,ultoa((ulong)cur_rate,str,10), avail);
                    break;
                case 'E':   /* Estimated Rate */
                    strncat(cmd,ultoa((ulong)cur_cps*10,str,10), avail);
                    break;
                case 'F':   /* File path */
#if defined(__linux__) && defined(USE_DOSEMU)
					if(!(mode & EX_NATIVE)
						&& strncmp(fpath, cfg.node_dir, strlen(cfg.node_dir)) == 0) {
						strncat(cmd, DOSEMU_NODE_DIR, avail);
						strncat(cmd, fpath + strlen(cfg.node_dir), avail);
					}
					else
#endif
						strncat(cmd,QUOTED_STRING(instr[i],fpath,str,sizeof(str)), avail);
                    break;
                case 'G':   /* Temp directory */
#if defined(__linux__) && defined(USE_DOSEMU)
					if(!(mode & EX_NATIVE))
						strncat(cmd, DOSEMU_TEMP_DIR, avail);
					else
#endif
	                    strncat(cmd,cfg.temp_dir, avail);
                    break;
                case 'H':   /* Socket Handle */
                    strncat(cmd,ultoa(client_socket_dup,str,10), avail);
                    break;
                case 'I':   /* IP address */
                    strncat(cmd,cid, avail);
                    break;
                case 'J':
#if defined(__linux__) && defined(USE_DOSEMU)
					if(!(mode & EX_NATIVE))
						strncat(cmd, DOSEMU_DATA_DIR, avail);
					else
#endif
						strncat(cmd,cfg.data_dir, avail);
                    break;
                case 'K':
#if defined(__linux__) && defined(USE_DOSEMU)
					if(!(mode & EX_NATIVE))
						strncat(cmd, DOSEMU_CTRL_DIR, avail);
					else
#endif
	                    strncat(cmd,cfg.ctrl_dir, avail);
                    break;
                case 'L':   /* Lines per message */
                    strncat(cmd,ultoa(cfg.level_linespermsg[useron.level],str,10), avail);
                    break;
                case 'M':   /* Minutes (credits) for user */
                    strncat(cmd,ultoa(useron.min,str,10), avail);
                    break;
                case 'N':   /* Node Directory (same as SBBSNODE environment var) */
#if defined(__linux__) && defined(USE_DOSEMU)
					if(!(mode & EX_NATIVE))
						strncat(cmd, DOSEMU_NODE_DIR, avail);
					else
#endif
	                    strncat(cmd,cfg.node_dir, avail);
                    break;
                case 'O':   /* SysOp */
                    strncat(cmd,QUOTED_STRING(instr[i],cfg.sys_op,str,sizeof(str)), avail);
                    break;
                case 'P':   /* Client protocol */
                    strncat(cmd, passthru_thread_running ? "raw" : client.protocol, avail);
                    break;
                case 'Q':   /* QWK ID */
                    strncat(cmd,cfg.sys_id, avail);
                    break;
                case 'R':   /* Rows */
                    strncat(cmd,ultoa(rows,str,10), avail);
                    break;
                case 'S':   /* File Spec (or Baja command str) or startup-directory */
                    strncat(cmd, fspec, avail);
                    break;
                case 'T':   /* Time left in seconds */
                    gettimeleft();
                    strncat(cmd,ultoa(timeleft,str,10), avail);
                    break;
                case 'U':   /* UART I/O Address (in hex) */
                    strncat(cmd,ultoa(cfg.com_base,str,16), avail);
                    break;
                case 'V':   /* Synchronet Version */
                    sprintf(str,"%s%c",VERSION,REVISION);
					strncat(cmd,str, avail);
                    break;
                case 'W':   /* Columns (width) */
                    strncat(cmd,ultoa(cols,str,10), avail);
                    break;
                case 'X':
                    strncat(cmd,cfg.shell[useron.shell]->code, avail);
                    break;
                case '&':   /* Address of msr */
                    break;
                case 'Y':
                    strncat(cmd,comspec, avail);
                    break;
                case 'Z':
#if defined(__linux__) && defined(USE_DOSEMU)
					if(!(mode & EX_NATIVE))
						strncat(cmd, DOSEMU_TEXT_DIR, avail);
					else
#endif
	                    strncat(cmd,cfg.text_dir, avail);
                    break;
				case '~':	/* DOS-compatible (8.3) filename */
#ifdef _WIN32
					char sfpath[MAX_PATH+1];
					SAFECOPY(sfpath,fpath);
					GetShortPathName(fpath,sfpath,sizeof(sfpath));
					strncat(cmd,sfpath, avail);
#else
                    strncat(cmd,QUOTED_STRING(instr[i],fpath,str,sizeof(str)), avail);
#endif
					break;
                case '!':   /* EXEC Directory */
#if defined(__linux__) && defined(USE_DOSEMU)
					if(!(mode & EX_NATIVE))
						strncat(cmd, DOSEMU_EXEC_DIR, avail);
					else
#endif
	                    strncat(cmd,cfg.exec_dir, avail);
                    break;
                case '@':   /* EXEC Directory for DOS/OS2/Win32, blank for Unix */
#ifndef __unix__
                    strncat(cmd,cfg.exec_dir, avail);
#endif
                    break;

                case '#':   /* Node number (same as SBBSNNUM environment var) */
                    sprintf(str,"%d",cfg.node_num);