/*
* Open a file for reading.
*/
int
ffropen(char *fn)
{
int status;
if ((status = fexist(g_pico_fio.name = fn, "r", (off_t *)NULL)) == FIOSUC){
g_pico_fio.flags = FIOINFO_READ;
if((g_pico_fio.fp = our_fopen(g_pico_fio.name, "r")) == NULL)
status = FIOFNF;
}
return (status);
}
/*
* Returns: 0 if all went well, -1 otherwise
*/
int
pipe_close_write(PIPE_S *syspipe)
{
int rv = 0;
if(!syspipe || !syspipe->out.f)
return -1;
#ifdef _WINDOWS
{
unsigned flags = 0;
if(syspipe->mode & PIPE_STDERR)
flags |= MSWIN_EAW_CAPT_STDERR;
rv = fclose(syspipe->out.f);
syspipe->out.f = NULL;
if(syspipe->mode & PIPE_WRITE){
/*
* PIPE_WRITE should always be set if we're trying to close
* the write end.
* PIPE_WRITE can't start process till now, all the others
* will have already run
*/
if(pipe_mswin_exec_wrapper("pipe command", syspipe,
flags, NULL, NULL))
/* some horrible error just occurred */
rv = -1;
else
syspipe->in.f = our_fopen(syspipe->outfile, "rb");
}
else
rv = -1;
}
#else /* UNIX */
rv = fclose(syspipe->out.f) ? -1 : 0;
syspipe->out.f = NULL;
#endif
return(rv);
}
/*----------------------------------------------------------------------
Spawn a child process and optionally connect read/write pipes to it
Args: command -- string to hand the shell
outfile -- address of pointer containing file to receive output
errfile -- address of pointer containing file to receive error output
mode -- mode for type of shell, signal protection etc...
Returns: pointer to alloc'd PIPE_S on success, NULL otherwise
The outfile is either NULL, a pointer to a NULL value, or a pointer
to the requested name for the output file. In the pointer-to-NULL case
the caller doesn't care about the name, but wants to see the pipe's
results so we make one up. It's up to the caller to make sure the
free storage containing the name is cleaned up.
Mode bits serve several purposes.
PIPE_WRITE tells us we need to open a pipe to write the child's
stdin.
PIPE_READ tells us we need to open a pipe to read from the child's
stdout/stderr. *NOTE* Having neither of the above set means
we're not setting up any pipes, just forking the child and exec'ing
the command. Also, this takes precedence over any named outfile.
PIPE_STDERR means we're to tie the childs stderr to the same place
stdout is going. *NOTE* This only makes sense then if PIPE_READ
or an outfile is provided. Also, this takes precedence over any
named errfile.
PIPE_RESET means we reset the terminal mode to what it was before
we started pine and then exec the command. In PC-Pine, _RESET
was a shortcut for just executing a command. We'll try to pay
attention to the above flags to make sure we do the right thing.
PIPE_PROT means to protect the child from the usual nasty signals
that might cause premature death. Otherwise, the default signals are
set so the child can deal with the nasty signals in its own way.
NOT USED UNDER WINDOWS
PIPE_NOSHELL means we're to exec the command without the aid of
a system shell. *NOTE* This negates the affect of PIPE_USER.
NOT USED UNDER WINDOWS
PIPE_USER means we're to try executing the command in the user's
shell. Right now we only look in the environment, but that may get
more sophisticated later.
NOT USED UNDER WINDOWS
PIPE_RUNNOW was added for WINDOWS for the case pipe is called to run
a shell program (like for url viewing). This is the only option
where we don't wait for child termination, and is only obeyed if
PIPE_WRITE and PIPE_READ aren't set
----*/
PIPE_S *
open_system_pipe(char *command, char **outfile, char **errfile, int mode,
int timeout, void (*pipecb_f)(PIPE_S *, int, void *),
void (*piperr_f)(char *))
{
PIPE_S *syspipe = NULL;
#ifdef _WINDOWS
int exit_code = 0;
char cmdbuf[1024];
unsigned flags = 0;
#else
char shellpath[MAXPATH+1], *shell;
int p[2], oparentd = -1, ochildd = -1, iparentd = -1, ichildd = -1;
#endif
#ifdef _WINDOWS
if(mode & PIPE_STDERR)
flags |= MSWIN_EAW_CAPT_STDERR;
/*
* It'll be a lot more difficult to support READing and WRITing.
* This was never supported, and there don't look to be any cases
* that set both of these flags anymore for win32.
*
* errfile could probably be supported pretty easily
*/
if(errfile){
if(piperr_f)
(*piperr_f)("Pipe arg not yet supported: Error File");
return(NULL);
}
if((mode & PIPE_RUNNOW)
&& !(mode & (PIPE_WRITE | PIPE_READ | PIPE_STDERR))){
if(mswin_shell_exec(command, NULL) == 0
&& (syspipe = (PIPE_S *) malloc(sizeof(PIPE_S))) != NULL){
memset(syspipe, 0, sizeof(PIPE_S));
return(syspipe);
}
return(NULL);
}
strncpy(cmdbuf, command, sizeof(cmdbuf));
cmdbuf[sizeof(cmdbuf)-1] = '\0';
if((syspipe = (PIPE_S *) malloc(sizeof(PIPE_S))) == NULL)
return(NULL);
memset(syspipe, 0, sizeof(PIPE_S));
syspipe->mode = mode;
if(!outfile){
syspipe->deloutfile = 1;
if(mode & PIPE_READ){
syspipe->outfile = temp_nam(NULL, "po");
our_unlink(syspipe->outfile);
}
}
else{
if(!*outfile) /* asked for, but not named? */
*outfile = temp_nam(NULL, "po");
our_unlink(*outfile);
syspipe->outfile = (char *) malloc((strlen(*outfile)+1)*sizeof(char));
snprintf(syspipe->outfile, strlen(*outfile)+1, "%s", *outfile);
}
if(mode & PIPE_WRITE){
/*
* Create tmp file to write, spawn child in close_pipe
* after tmp file's written...
*/
syspipe->infile = temp_nam(NULL, "pw");
syspipe->out.f = our_fopen(syspipe->infile, "wb");
syspipe->command = (char *) malloc((strlen(cmdbuf)+1)*sizeof(char));
snprintf(syspipe->command, strlen(cmdbuf)+1, "%s", cmdbuf);
dprint((1, "pipe write: %s", cmdbuf));
}
else if(mode & PIPE_READ){
/*
* Create a tmp file for command result, exec the command
* here into temp file, and return file pointer to it...
*/
syspipe->command = (char *) malloc((strlen(cmdbuf)+1)*sizeof(char));
snprintf(syspipe->command, strlen(cmdbuf)+1, "%s", cmdbuf);
dprint((1, "pipe read: %s", cmdbuf));
if(pipe_mswin_exec_wrapper("pipe command", syspipe,
flags, pipecb_f, piperr_f)){
if(syspipe->outfile){
free((void *) syspipe->outfile);
syspipe->outfile = NULL;
}
zot_pipe(&syspipe);
}
else{
syspipe->in.f = our_fopen(syspipe->outfile, "rb");
syspipe->exit_code = exit_code;
}
}
else{
/* we just run the command taking outfile into account */
syspipe->command = (char *) malloc((strlen(cmdbuf)+1)*sizeof(char));
snprintf(syspipe->command, strlen(cmdbuf)+1, "%s", cmdbuf);
if(pipe_mswin_exec_wrapper("pipe command", syspipe,
flags, pipecb_f, piperr_f)){
if(syspipe->outfile){
free((void *) syspipe->outfile);
syspipe->outfile = NULL;
}
zot_pipe(&syspipe);
}
else
syspipe->exit_code = exit_code;
}
#else /* !_WINDOWS */
if((syspipe = (PIPE_S *) malloc(sizeof(PIPE_S))) == NULL)
return(NULL);
memset(syspipe, 0, sizeof(PIPE_S));
syspipe->mode = mode;
/*
* If we're not using the shell's command parsing smarts, build
* argv by hand...
*/
if(mode & PIPE_NOSHELL){
char **ap, *p;
size_t n;
/* parse the arguments into argv */
for(p = command; *p && isspace((unsigned char)(*p)); p++)
; /* swallow leading ws */
if(*p){
int l = strlen(p);
if((syspipe->args = (char *) malloc((l + 1) * sizeof(char))) != NULL){
strncpy(syspipe->args, p, l);
syspipe->args[l] = '\0';
}
else{
if(piperr_f)
(*piperr_f)(pipe_error_msg("<null>", "execute",
"Can't allocate command string"));
zot_pipe(&syspipe);
return(NULL);
}
}
else{
if(piperr_f)
(*piperr_f)(pipe_error_msg("<null>", "execute",
"No command name found"));
zot_pipe(&syspipe);
return(NULL);
}
for(p = syspipe->args, n = 2; *p; p++) /* count the args */
if(isspace((unsigned char)(*p))
&& *(p+1) && !isspace((unsigned char)(*(p+1))))
n++;
if ((syspipe->argv = ap = (char **)malloc(n * sizeof(char *))) == NULL){
zot_pipe(&syspipe);
return(NULL);
}
memset(syspipe->argv, 0, n * sizeof(char *));
for(p = syspipe->args; *p; ){ /* collect args */
while(*p && isspace((unsigned char)(*p)))
*p++ = '\0';
*ap++ = (*p) ? p : NULL;
while(*p && !isspace((unsigned char)(*p)))
p++;
}
/* make sure argv[0] exists in $PATH */
if(can_access_in_path(getenv("PATH"), syspipe->argv[0],
EXECUTE_ACCESS) < 0){
if(piperr_f)
(*piperr_f)(pipe_error_msg(syspipe->argv[0], "access",
error_description(errno)));
zot_pipe(&syspipe);
return(NULL);
}
}
/* fill in any output filenames */
if(!(mode & PIPE_READ)){
if(outfile && !*outfile)
*outfile = temp_nam(NULL, "pine_p"); /* asked for, but not named? */
if(errfile && !*errfile)
*errfile = temp_nam(NULL, "pine_p"); /* ditto */
}
/* create pipes */
if(mode & (PIPE_WRITE | PIPE_READ)){
if(mode & PIPE_WRITE){
pipe(p); /* alloc pipe to write child */
oparentd = p[STDOUT_FILENO];
ichildd = p[STDIN_FILENO];
}
if(mode & PIPE_READ){
pipe(p); /* alloc pipe to read child */
iparentd = p[STDIN_FILENO];
ochildd = p[STDOUT_FILENO];
}
}
if(pipecb_f) /* let caller prep display */
(*pipecb_f)(syspipe, OSB_PRE_OPEN, NULL);
if((syspipe->pid = vfork()) == 0){
/* reset child's handlers in requested fashion... */
(void)signal(SIGINT, (mode & PIPE_PROT) ? SIG_IGN : SIG_DFL);
(void)signal(SIGQUIT, (mode & PIPE_PROT) ? SIG_IGN : SIG_DFL);
(void)signal(SIGHUP, (mode & PIPE_PROT) ? SIG_IGN : SIG_DFL);
#ifdef SIGCHLD
(void) signal(SIGCHLD, SIG_DFL);
#endif
/* if parent isn't reading, and we have a filename to write */
if(!(mode & PIPE_READ) && outfile){ /* connect output to file */
int output = our_creat(*outfile, 0600);
dup2(output, STDOUT_FILENO);
if(mode & PIPE_STDERR)
dup2(output, STDERR_FILENO);
else if(errfile)
dup2(our_creat(*errfile, 0600), STDERR_FILENO);
}
if(mode & PIPE_WRITE){ /* connect process input */
close(oparentd);
dup2(ichildd, STDIN_FILENO); /* tie stdin to pipe */
close(ichildd);
}
if(mode & PIPE_READ){ /* connect process output */
close(iparentd);
dup2(ochildd, STDOUT_FILENO); /* tie std{out,err} to pipe */
if(mode & PIPE_STDERR)
dup2(ochildd, STDERR_FILENO);
else if(errfile)
dup2(our_creat(*errfile, 0600), STDERR_FILENO);
close(ochildd);
}
if(mode & PIPE_NOSHELL){
execvp(syspipe->argv[0], syspipe->argv);
}
else{
if(mode & PIPE_USER){
char *env, *sh;
if((env = getenv("SHELL")) && (sh = strrchr(env, '/'))){
shell = sh + 1;
strncpy(shellpath, env, sizeof(shellpath)-1);
shellpath[sizeof(shellpath)-1] = '\0';
}
else{
shell = "csh";
strncpy(shellpath, "/bin/csh", sizeof(shellpath)-1);
shellpath[sizeof(shellpath)-1] = '\0';
}
}
else{
shell = "sh";
strncpy(shellpath, "/bin/sh", sizeof(shellpath)-1);
shellpath[sizeof(shellpath)-1] = '\0';
}
execl(shellpath, shell, command ? "-c" : (char *)NULL, fname_to_locale(command), (char *)NULL);
}
fprintf(stderr, "Can't exec %s\nReason: %s",
command, error_description(errno));
_exit(-1);
}
if((child_pid = syspipe->pid) > 0){
syspipe->isig = signal(SIGINT, SIG_IGN); /* Reset handlers to make */
syspipe->qsig = signal(SIGQUIT, SIG_IGN); /* sure we don't come to */
syspipe->hsig = signal(SIGHUP, SIG_IGN); /* a premature end... */
if((syspipe->timeout = timeout) != 0){
syspipe->alrm = signal(SIGALRM, pipe_alarm);
syspipe->old_timeo = alarm(timeout);
}
if(mode & PIPE_WRITE){
close(ichildd);
if(mode & PIPE_DESC)
syspipe->out.d = oparentd;
else
syspipe->out.f = fdopen(oparentd, "w");
}
if(mode & PIPE_READ){
close(ochildd);
if(mode & PIPE_DESC)
syspipe->in.d = iparentd;
else
syspipe->in.f = fdopen(iparentd, "r");
}
}
else{
if(mode & (PIPE_WRITE | PIPE_READ)){
if(mode & PIPE_WRITE){
close(oparentd);
close(ichildd);
}
if(mode & PIPE_READ){
close(iparentd);
close(ochildd);
}
}
if(pipecb_f) /* let caller fixup display */
(*pipecb_f)(syspipe, OSB_POST_OPEN, NULL);
if(outfile && *outfile){
our_unlink(*outfile);
free((void *) *outfile);
*outfile = NULL;
}
if(errfile && *errfile){
our_unlink(*errfile);
free((void *) *errfile);
*errfile = NULL;
}
if(piperr_f)
(*piperr_f)(pipe_error_msg(command, "fork",
error_description(errno)));
zot_pipe(&syspipe);
}
#endif /* UNIX */
return(syspipe);
}
/*----------------------------------------------------------------------
Output line of length len to the display observing embedded attributes
Args: x -- column position on the screen
y -- column position on the screen
line -- text to be output
length -- length of text to be output
Result: text is output
cursor position is updated
----------------------------------------------------------------------*/
void
PutLine0n8b(int x, int y, register char *line, int length, HANDLE_S *handles)
{
unsigned char c;
int is_inv = 0, is_bold = 0, is_uline = 0, is_fg = 0, is_bg = 0;
#ifdef _WINDOWS
int hkey = 0;
#endif
MoveCursor(x,y);
while(length--){
c = (unsigned char) *line++;
if(c == (unsigned char) TAG_EMBED && length){
length--;
switch(*line++){
case TAG_INVON :
StartInverse();
is_inv = 1;
break;
case TAG_INVOFF :
EndInverse();
is_inv = 0;
break;
case TAG_BOLDON :
StartBold();
is_bold = 1;
break;
case TAG_BOLDOFF :
EndBold();
is_bold = 0;
break;
case TAG_ITALICON : /* express italic as uline in terminal */
case TAG_ULINEON :
StartUnderline();
is_uline = 1;
break;
case TAG_ITALICOFF : /* express italic as uline in terminal */
case TAG_ULINEOFF :
EndUnderline();
is_uline = 0;
break;
case TAG_HANDLE :
length -= *line + 1; /* key length plus length tag */
if(handles){
int key, n, current_key = 0;
for(key = 0, n = *line++; n; n--) /* forget Horner? */
key = (key * 10) + (*line++ - '0');
#if _WINDOWS
hkey = key;
#endif
if(handles->using_is_used){
HANDLE_S *h;
for(h = handles; h; h = h->next)
if(h->is_used)
break;
if(h)
current_key = h->key;
}
else
current_key = handles->key;
if(key == current_key){
COLOR_PAIR *curcolor = NULL;
COLOR_PAIR *revcolor = NULL;
if(handles->color_unseen
&& (curcolor = pico_get_cur_color())
&& (colorcmp(curcolor->fg, ps_global->VAR_NORM_FORE_COLOR)
|| colorcmp(curcolor->bg, ps_global->VAR_NORM_BACK_COLOR))
&& (revcolor = apply_rev_color(curcolor,
ps_global->index_color_style)))
(void) pico_set_colorp(revcolor, PSC_NONE);
else{
if(pico_usingcolor() &&
ps_global->VAR_SLCTBL_FORE_COLOR &&
ps_global->VAR_SLCTBL_BACK_COLOR){
pico_set_normal_color();
}
else
EndBold();
StartInverse();
is_inv = 1;
}
if(curcolor)
free_color_pair(&curcolor);
if(revcolor)
free_color_pair(&revcolor);
}
}
else{
/* BUG: complain? */
line += *line + 1;
}
break;
case TAG_FGCOLOR :
if(length < RGBLEN){
dprint((9,
"FGCOLOR not proper length, ignoring\n"));
length = 0;
break;
}
(void)pico_set_fg_color(line);
is_fg = 1;
length -= RGBLEN;
line += RGBLEN;
break;
case TAG_BGCOLOR :
if(length < RGBLEN){
dprint((9,
"BGCOLOR not proper length, ignoring\n"));
length = 0;
break;
}
(void)pico_set_bg_color(line);
is_bg = 1;
length -= RGBLEN;
line += RGBLEN;
break;
case TAG_EMBED: /* literal "embed" char */
Writechar(TAG_EMBED, 0);
break;
case TAG_STRIKEON : /* unsupported text markup */
case TAG_STRIKEOFF :
case TAG_BIGON :
case TAG_BIGOFF :
case TAG_SMALLON :
case TAG_SMALLOFF :
default : /* Eat unrecognized tag - TAG_BIGON, etc */
break;
} /* tag with handle, skip it */
}
else
Writechar(c, 0);
}
#if _WINDOWS_X
if(hkey) {
char *tmp_file = NULL, ext[32], mtype[128];
HANDLE_S *h;
extern HANDLE_S *get_handle (HANDLE_S *, int);
if((h = get_handle(handles, hkey)) && h->type == Attach){
ext[0] = '\0';
strncpy(mtype, body_type_names(h->h.attach->body->type), sizeof(mtype));
mtype[sizeof(mtype)-1] = '\0';
if (h->h.attach->body->subtype) {
strncat (mtype, "/", sizeof(mtype)-strlen(mtype)-1);
mtype[sizeof(mtype)-1] = '\0';
strncat (mtype, h->h.attach->body->subtype, sizeof(mtype)-strlen(mtype)-1);
mtype[sizeof(mtype)-1] = '\0';
}
if(!set_mime_extension_by_type(ext, mtype)){
char *p, *extp = NULL;
if((p = get_filename_parameter(NULL, 0, h->h.attach->body, &extp)) != NULL){
if(extp){
strncpy(ext, extp, sizeof(ext));
ext[sizeof(ext)-1] = '\0';
}
fs_give((void **) &p);
}
}
if(ext[0] && (tmp_file = temp_nam_ext(NULL, "im", ext))){
FILE *f = our_fopen(tmp_file, "w");
mswin_registericon(x, h->key, tmp_file);
fclose(f);
our_unlink(tmp_file);
fs_give((void **)&tmp_file);
}
}
}
#endif
if(is_inv){
dprint((9,
"INVERSE left on at end of line, turning off now\n"));
EndInverse();
}
if(is_bold){
dprint((9,
"BOLD left on at end of line, turning off now\n"));
EndBold();
}
if(is_uline){
dprint((9,
"UNDERLINE left on at end of line, turning off now\n"));
EndUnderline();
}
if(is_fg || is_bg)
pico_set_normal_color();
}
/*
* dfilter - pipe the data from the given storage object thru the
* global display filter and into whatever the putchar's
* function points to.
*
* Input is assumed to be UTF-8.
* That's converted to user's locale and passed to rawcmd.
* That's converted back to UTF-8 and passed through aux_filters.
*/
char *
dfilter(char *rawcmd, STORE_S *input_so, gf_io_t output_pc, FILTLIST_S *aux_filters)
{
char *status = NULL, *cmd, *resultf = NULL, *tmpfile = NULL;
int key = 0, silent = 0;
if((cmd = expand_filter_tokens(rawcmd,NULL,&tmpfile,&resultf,NULL,&key,NULL, &silent)) != NULL){
suspend_busy_cue();
#ifndef _WINDOWS
if(!silent){
ps_global->mangled_screen = 1;
ClearScreen();
}
fflush(stdout);
#endif
/*
* If it was requested that the interaction take place via
* a tmpfile, fill it with text from our input_so, and let
* system_pipe handle the rest. Session key and tmp file
* mode support additions based loosely on a patch
* supplied by Thomas Stroesslin <*****@*****.**>
*/
if(tmpfile){
PIPE_S *filter_pipe;
FILE *fp;
gf_io_t gc, pc;
STORE_S *tmpf_so;
/* write the tmp file */
so_seek(input_so, 0L, 0);
if((tmpf_so = so_get(FileStar, tmpfile, WRITE_ACCESS|OWNER_ONLY|WRITE_TO_LOCALE)) != NULL){
if(key){
so_puts(tmpf_so, filter_session_key());
so_puts(tmpf_so, NEWLINE);
}
/* copy input to tmp file */
gf_set_so_readc(&gc, input_so);
gf_set_so_writec(&pc, tmpf_so);
gf_filter_init();
status = gf_pipe(gc, pc);
gf_clear_so_readc(input_so);
gf_clear_so_writec(tmpf_so);
if(so_give(&tmpf_so) != 0 && status == NULL)
status = error_description(errno);
/* prepare the terminal in case the filter uses it */
if(status == NULL){
if((filter_pipe = open_system_pipe(cmd, NULL, NULL,
PIPE_USER | (silent ? PIPE_SILENT :
(F_ON(F_DISABLE_TERM_RESET_DISP, ps_global) ? 0 : PIPE_RESET)),
0, pipe_callback, NULL)) != NULL){
if(close_system_pipe(&filter_pipe, NULL, pipe_callback) == 0){
/* pull result out of tmp file */
if((fp = our_fopen(tmpfile, "rb")) != NULL){
gf_set_readc(&gc, fp, 0L, FileStar, READ_FROM_LOCALE);
gf_filter_init();
if(aux_filters)
for( ; aux_filters->filter; aux_filters++)
gf_link_filter(aux_filters->filter,
aux_filters->data);
status = gf_pipe(gc, output_pc);
fclose(fp);
}
else
status = "Can't read result of display filter";
}
else
status = "Filter command returned error.";
}
else
status = "Can't open pipe for display filter";
}
our_unlink(tmpfile);
}
else
status = "Can't open display filter tmp file";
}
else if((status = gf_filter(cmd, key ? filter_session_key() : NULL,
input_so, output_pc, aux_filters, silent,
F_ON(F_DISABLE_TERM_RESET_DISP, ps_global),
pipe_callback)) != NULL){
unsigned long ch;
fprintf(stdout,"\r\n%s Hit return to continue.", status);
fflush(stdout);
while((ch = read_char(300)) != ctrl('M') && ch != NO_OP_IDLE)
putchar(BELL);
}
if(resultf){
if(name_file_size(resultf) > 0L)
display_output_file(resultf, "Filter", NULL, DOF_BRIEF);
fs_give((void **)&resultf);
}
resume_busy_cue(0);
#ifndef _WINDOWS
if(!silent)
ClearScreen();
#endif
fs_give((void **)&cmd);
}
return(status);
}
