/* ----------------------------------------------------------------------
Execute the given mailcap test= cmd
Args: cmd -- command to execute
Returns exit status
----*/
int
exec_mailcap_test_cmd(char *cmd)
{
#ifdef _WINDOWS
return((WinExec(cmd, SW_SHOWMINNOACTIVE) < 32) ? 1 : 0);
#else
PIPE_S *syspipe;
return((syspipe = open_system_pipe(cmd, NULL, NULL, PIPE_SILENT, 0,
pipe_callback, NULL))
? close_system_pipe(&syspipe, NULL, pipe_callback) : -1);
#endif
}
/*----------------------------------------------------------------------
Close printer
If we're piping to a spooler close down the pipe and wait for the process
to finish. If we're sending to an attached printer send the escape sequence.
Also let the user know the result of the print
----*/
void
close_printer(void)
{
#ifndef _WINDOWS
if(trailer){
if(*trailer)
fputs(trailer, ps_global->print->fp);
fs_give((void **)&trailer);
}
if(ps_global->print->fp == stdout) {
if(ansi_off)
fputs("\033[4i", stdout);
else
printf("%c", 20); /* aux off for wyse60 */
fflush(stdout);
if(F_OFF(F_PRESERVE_START_STOP, ps_global))
xonxoff_proc(0); /* turn off XON/XOFF */
crlf_proc(0); /* turn off CF->LF xlantion */
} else {
(void) close_system_pipe(&ps_global->print->pipe, NULL, pipe_callback);
display_output_file(ps_global->print->result, "PRINT", NULL, 1);
if(ps_global->print && ps_global->print->result)
fs_give((void **) &ps_global->print->result);
}
#else /* _WINDOWS */
mswin_print_done();
#endif /* _WINDOWS */
if(ps_global->print)
fs_give((void **) &ps_global->print);
q_status_message(SM_ASYNC, 0, 3, "Print command completed");
display_message('x');
}
/* ----------------------------------------------------------------------
Execute the given mailcap command
Args: cmd -- the command to execute
image_file -- the file the data is in
needsterminal -- does this command want to take over the terminal?
----*/
void
exec_mailcap_cmd(MCAP_CMD_S *mc_cmd, char *image_file, int needsterminal)
{
#ifdef _WINDOWS
STARTUPINFO start_info;
PROCESS_INFORMATION proc_info;
WINHAND childProcess;
int success = 0;
char *cmd;
LPTSTR image_file_lpt = NULL;
LPTSTR cmd_lpt = NULL;
/* no special handling yet, but could be used to replace '*' hack */
if(mc_cmd)
cmd = mc_cmd->command;
else
return;
dprint((9, "run_viewer: command=%s\n", cmd ? cmd : "?")) ;
if(image_file)
image_file_lpt = utf8_to_lptstr(image_file);
/* Set to READONLY so the viewer can't try to edit it and keep it around */
if(image_file_lpt)
SetFileAttributes(image_file_lpt, FILE_ATTRIBUTE_READONLY);
if(*cmd == '*' || (*cmd == '\"' && *(cmd+1) == '*')){
/*
* It has been asked that there be the ability to do an
* "Open With..." on attachments like you can from the
* Windows file browser. After looking into this, it
* seems that the only way to do this would be through
* an undocumented hack. Here, we would pass "openas" as
* the verb to mswin_shell_exec (also some changes in
* mswin_shell_exec). Since this is the delicate world
* of attachment handling, it seems right not to rely on
* a hack. The interface wouldn't be too clean anyways,
* as we would have to download the attachment only to
* display the "Open With..." dialog. Go figure, some
* things Microsoft just wants to keep to themselves.
*/
/*
* 2/1/2007. No idea when the above comment was written, but it is
* documented now at least. The below two urls describe the "openas" verb:
*
* http://blogs.msdn.com/oldnewthing/archive/2004/11/26/270710.aspx
* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/
* shellcc/platform/shell/programmersguide/shell_basics/
* shell_basics_extending/context.asp
*/
success = mswin_shell_exec(cmd, &childProcess) == 0;
}
else{
memset(&proc_info, 0, sizeof(proc_info));
memset(&start_info, 0, sizeof(start_info));
start_info.dwFlags = STARTF_FORCEONFEEDBACK;
start_info.wShowWindow = SW_SHOWNORMAL;
if(cmd)
cmd_lpt = utf8_to_lptstr(cmd);
if(CreateProcess(NULL, cmd_lpt, NULL, NULL, FALSE,
CREATE_NEW_CONSOLE | CREATE_NEW_PROCESS_GROUP,
NULL, NULL, &start_info, &proc_info) == TRUE){
q_status_message(SM_ORDER, 0, 4, "VIEWER command completed");
dprint ((3, "CreatProcess(%s) Success.\n",
cmd ? cmd : "?"));
childProcess = proc_info.hProcess;
success = 1;
}
if(cmd_lpt)
fs_give((void **) &cmd_lpt);
}
if(!success){
int rc = (int) GetLastError();
if(image_file_lpt)
SetFileAttributes(image_file_lpt, FILE_ATTRIBUTE_NORMAL);
our_unlink(image_file);
q_status_message2(SM_ORDER, 3, 4, "\007Can't start viewer. %s%s.",
(rc == 2 || rc == 3) ? "Viewer not found: " :
(rc == 8) ? "Not enough memory" : "Windows error ",
(rc == 2 || rc == 3) ? cmd :
(rc == 8) ? "" : int2string(rc));
}
if(image_file_lpt)
fs_give((void **) &image_file_lpt);
#elif OSX_TARGET
char *command = NULL,
*result_file = NULL,
*p;
char **r_file_h;
PIPE_S *syspipe;
int mode;
if(!mc_cmd)
return;
if(mc_cmd->special_handling){
char *rhost;
if(mime_os_specific_access())
osx_launch_special_handling(mc_cmd, image_file);
else{
q_status_message(SM_ORDER, 0, 4, "VIEWER command cancelled");
our_unlink(image_file);
}
}
else {
char *cmd = mc_cmd->command;
size_t l;
l = 32 + strlen(cmd) + (2*strlen(image_file));
p = command = (char *) fs_get((l+1) * sizeof(char));
if(!needsterminal) /* put in background if it doesn't need terminal */
*p++ = '(';
snprintf(p, l+1-(p-command), "%s", cmd);
p += strlen(p);
if(!needsterminal){
if(p-command+2 < l+1){
*p++ = ')';
*p++ = ' ';
*p++ = '&';
}
}
if(p-command < l+1)
*p++ = '\n';
if(p-command < l+1)
*p = '\0';
dprint((9, "exec_mailcap_cmd: command=%s\n",
command ? command : "?"));
mode = PIPE_RESET;
if(needsterminal == 1)
r_file_h = NULL;
else{
mode |= PIPE_WRITE | PIPE_STDERR;
result_file = temp_nam(NULL, "pine_cmd");
r_file_h = &result_file;
}
if(syspipe = open_system_pipe(command, r_file_h, NULL, mode, 0, pipe_callback, NULL)){
close_system_pipe(&syspipe, NULL, pipe_callback);
if(needsterminal == 1)
q_status_message(SM_ORDER, 0, 4, "VIEWER command completed");
else if(needsterminal == 2)
display_output_file(result_file, "VIEWER", " command result", 1);
else
display_output_file(result_file, "VIEWER", " command launched", 1);
}
else
q_status_message1(SM_ORDER, 3, 4, "Cannot spawn command : %s", cmd);
fs_give((void **)&command);
if(result_file)
fs_give((void **)&result_file);
}
#else
char *command = NULL,
*result_file = NULL,
*p, *cmd, *q, *psef;
char **r_file_h;
PIPE_S *syspipe;
int mode;
size_t l;
/* no os-specific command handling */
if(mc_cmd)
cmd = mc_cmd->command;
else
return;
#ifdef PSEFCMD
psef = fs_get((60 + strlen(PSEFCMD) + strlen(image_file))*sizeof(char));
sprintf(psef, "PSEF=`%s | /bin/grep \"%s\" | /bin/grep -v grep`", PSEFCMD, image_file);
q = fs_get((80 + 2*strlen(psef))*sizeof(char)); /* bigger than 62 */
sprintf(q, "/bin/sh -c '(%s; while test -n \"$PSEF\" ; do %s ; sleep %d ; done)' ;", psef, psef, ps_global->sleep);
fs_give((void **) &psef);
#else
q = cpystr("");
#endif /* PSEFCMD */
l = 32 + strlen(cmd) + 2*strlen(image_file) + strlen(q);
p = command = (char *)fs_get((l+1) * sizeof(char));
if(!needsterminal) /* put in background if it doesn't need terminal */
*p++ = '(';
snprintf(p, l+1-(p-command), "%s ; %s rm -f %s", cmd, q, image_file);
fs_give((void **)&q);
command[l] = '\0';
p += strlen(p);
if(!needsterminal && (p-command)+5 < l){
*p++ = ')';
*p++ = ' ';
*p++ = '&';
}
*p++ = '\n';
*p = '\0';
dprint((9, "exec_mailcap_cmd: command=%s\n",
command ? command : "?"));
mode = PIPE_RESET;
if(needsterminal == 1)
r_file_h = NULL;
else{
mode |= PIPE_WRITE | PIPE_STDERR;
result_file = temp_nam(NULL, "pine_cmd");
r_file_h = &result_file;
}
if((syspipe = open_system_pipe(command, r_file_h, NULL, mode, 0, pipe_callback, NULL)) != NULL){
close_system_pipe(&syspipe, NULL, pipe_callback);
if(needsterminal == 1)
q_status_message(SM_ORDER, 0, 4, "VIEWER command completed");
else if(needsterminal == 2)
display_output_file(result_file, "VIEWER", " command result", 1);
else
display_output_file(result_file, "VIEWER", " command launched", 1);
}
else
q_status_message1(SM_ORDER, 3, 4, "Cannot spawn command : %s", cmd);
fs_give((void **)&command);
if(result_file)
fs_give((void **)&result_file);
#endif
}
/*----------------------------------------------------------------------
Suspend Pine. Reset tty and suspend. Suspend is finished when this returns
Args: The pine structure
Result: Execution suspended for a while. Screen will need redrawing
after this is done.
Instead of the usual handling of ^Z by catching a signal, we actually read
the ^Z and then clean up the tty driver, then kill ourself to stop, and
pick up where we left off when execution resumes.
----------------------------------------------------------------------*/
UCS
do_suspend(void)
{
struct pine *pine = ps_global;
time_t now;
UCS retval;
#if defined(DOS) || defined(OS2)
int result, orig_cols, orig_rows;
#else
int isremote;
#endif
#ifdef DOS
static char *shell = NULL;
#define STD_SHELL "COMMAND.COM"
#else
#ifdef OS2
static char *shell = NULL;
#define STD_SHELL "CMD.EXE"
#endif
#endif
if(!have_job_control()) {
bogus_command(ctrl('Z'), F_ON(F_USE_FK, pine) ? "F1" : "?");
return(NO_OP_COMMAND);
}
if(F_OFF(F_CAN_SUSPEND, pine)) {
q_status_message(SM_ORDER | SM_DING, 3, 3,
_("Alpine suspension not enabled - see help text"));
return(NO_OP_COMMAND);
}
#ifdef _WINDOWS
mswin_minimize();
return(NO_OP_COMMAND);
#else
isremote = (ps_global->mail_stream && ps_global->mail_stream->mailbox
&& (*ps_global->mail_stream->mailbox == '{'
|| (*ps_global->mail_stream->mailbox == '*'
&& *(ps_global->mail_stream->mailbox + 1) == '{')));
now = time((time_t *)0);
dprint((1, "\n\n --- %s - SUSPEND ---- %s",
isremote ? "REMOTE" : "LOCAL", ctime(&now)));
ttyfix(0);
#if defined(DOS) || defined(OS2)
suspend_notice("exit");
if (!shell) {
char *p;
if (!((shell = getenv("SHELL")) || (shell = getenv("COMSPEC"))))
shell = STD_SHELL;
shell = cpystr(shell); /* copy in free storage */
for(p = shell; (p = strchr(p, '/')); p++)
*p = '\\';
}
result = system(shell);
#else
if(F_ON(F_SUSPEND_SPAWNS, ps_global)) {
PIPE_S *syspipe;
if((syspipe = open_system_pipe(NULL, NULL, NULL, PIPE_USER|PIPE_RESET,
0, pipe_callback, pipe_report_error)) != NULL) {
suspend_notice("exit");
#ifndef SIGCHLD
if(isremote)
suspend_warning();
#endif
(void) close_system_pipe(&syspipe, NULL, pipe_callback);
}
}
else {
suspend_notice("fg");
if(isremote)
suspend_warning();
stop_process();
}
#endif /* DOS */
now = time((time_t *)0);
dprint((1, "\n\n ---- RETURN FROM SUSPEND ---- %s",
ctime(&now)));
ttyfix(1);
#if defined(DOS) || defined(OS2)
orig_cols = pine->ttyo->screen_cols;
orig_rows = pine->ttyo->screen_rows;
#endif
fix_windsize(pine);
#if defined(DOS) || defined(OS2)
if(orig_cols != pine->ttyo->screen_cols ||
orig_rows != pine->ttyo->screen_rows)
retval = KEY_RESIZE;
else
#endif
retval = ctrl('L');;
#if defined(DOS) || defined(OS2)
if(result == -1)
q_status_message1(SM_ORDER | SM_DING, 3, 4,
_("Error loading \"%s\""), shell);
#endif
if(isremote && !pine_mail_ping(ps_global->mail_stream))
q_status_message(SM_ORDER | SM_DING, 4, 9,
_("Suspended for too long, IMAP connection broken"));
return(retval);
#endif /* !_WINDOWS */
}
/*
* 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);
}
