int ber_pvt_vsnprintf( char *str, size_t n, const char *fmt, va_list ap )
{
int fds[2], res;
FILE *f;
RETSIGTYPE (*sig)();
if (pipe( fds )) return -1;
f = fdopen( fds[1], "w" );
if ( !f ) {
close( fds[1] );
close( fds[0] );
return -1;
}
setvbuf( f, str, _IOFBF, n );
sig = signal( SIGPIPE, SIG_IGN );
close( fds[0] );
res = vfprintf( f, fmt, ap );
fclose( f );
signal( SIGPIPE, sig );
if ( res > 0 && res < n ) {
res = vsprintf( str, fmt, ap );
}
return res;
}
int
OpenPTY(char **ttyn)
{
int f;
char *m;
char *(ptsname(int));
int unlockpt(int);
int grantpt(int);
RETSIGTYPE (*sigcld) SIGPROTOARG;
/* used for opening a new pty-pair: */
static char TtyName[32];
if ((f = open("/dev/ptmx", O_RDWR | O_NOCTTY | O_EXTRA, 0)) == -1)
return -1;
/*
* SIGCHLD set to SIG_DFL for grantpt() because it fork()s and
* exec()s pt_chmod
*/
sigcld = signal(SIGCHLD, SIG_DFL);
if ((m = ptsname(f)) == NULL || grantpt(f) || unlockpt(f))
{
signal(SIGCHLD, sigcld);
close(f);
return -1;
}
signal(SIGCHLD, sigcld);
vim_strncpy((char_u *)TtyName, (char_u *)m, sizeof(TtyName) - 1);
initmaster(f);
*ttyn = TtyName;
return f;
}
/* Write LENGTH bytes from BUFFER to remote tape connection HANDLE.
Return the number of bytes written. */
size_t
rmt_write (int handle, char *buffer, size_t length)
{
char command_buffer[COMMAND_BUFFER_SIZE];
RETSIGTYPE (*pipe_handler) ();
size_t written;
sprintf (command_buffer, "W%lu\n", (unsigned long) length);
if (do_command (handle, command_buffer) == -1)
return 0;
pipe_handler = signal (SIGPIPE, SIG_IGN);
written = full_write (WRITE_SIDE (handle), buffer, length);
signal (SIGPIPE, pipe_handler);
if (written == length)
{
long int r = get_status (handle);
if (r < 0)
return 0;
if (r == length)
return length;
written = r;
}
/* Write error. */
_rmt_shutdown (handle, EIO);
return written;
}
/* Attempt to perform the remote tape command specified in BUFFER on
remote tape connection HANDLE. Return 0 if successful, -1 on
error. */
static int
do_command (int handle, const char *buffer)
{
/* Save the current pipe handler and try to make the request. */
size_t length = strlen (buffer);
RETSIGTYPE (*pipe_handler) () = signal (SIGPIPE, SIG_IGN);
ssize_t written = full_write (WRITE_SIDE (handle), buffer, length);
signal (SIGPIPE, pipe_handler);
if (written == length)
return 0;
/* Something went wrong. Close down and go home. */
_rmt_shutdown (handle, EIO);
return -1;
}
int
OpenPTY(char **ttyn)
{
int f;
char *name;
RETSIGTYPE (*sigcld) SIGPROTOARG;
/*
* SIGCHLD set to SIG_DFL for _getpty() because it may fork() and
* exec() /usr/adm/mkpts
*/
sigcld = signal(SIGCHLD, SIG_DFL);
name = _getpty(&f, O_RDWR | O_NONBLOCK | O_EXTRA, 0600, 0);
signal(SIGCHLD, sigcld);
if (name == 0)
return -1;
initmaster(f);
*ttyn = name;
return f;
}
static int
do_command (int file_descriptor, const char *buf)
{
register int buflen;
RETSIGTYPE (*pipe_handler) ();
/* Save the current pipe handler and try to make the request. */
pipe_handler = signal (SIGPIPE, SIG_IGN);
buflen = strlen (buf);
if (write (WRITE (file_descriptor), buf, (size_t) buflen) == buflen)
{
signal (SIGPIPE, pipe_handler);
return 0;
}
/* Something went wrong. Close down and go home. */
signal (SIGPIPE, pipe_handler);
_rmt_shutdown (file_descriptor);
errno = EIO;
return -1;
}
int
__rmt_write (int file_descriptor, char *buf, unsigned int nbyte)
{
char command_buffer[CMDBUFSIZE];
RETSIGTYPE (*pipe_handler) ();
sprintf (command_buffer, "W%d\n", nbyte);
if (do_command (file_descriptor, command_buffer) == -1)
return -1;
pipe_handler = signal (SIGPIPE, SIG_IGN);
if (write (WRITE (file_descriptor), buf, nbyte) == nbyte)
{
signal (SIGPIPE, pipe_handler);
return get_status (file_descriptor);
}
/* Write error. */
signal (SIGPIPE, pipe_handler);
_rmt_shutdown (file_descriptor);
errno = EIO;
return -1;
}
int
main (int argc, char **argv)
{
char *name;
char **prog_argv = NULL;
struct bfd *prog_bfd;
enum sim_stop reason;
int sigrc = 0;
int single_step = 0;
RETSIGTYPE (*prev_sigint) ();
myname = argv[0] + strlen (argv[0]);
while (myname > argv[0] && myname[-1] != '/')
--myname;
/* INTERNAL: When MYNAME is `step', single step the simulator
instead of allowing it to run free. The sole purpose of this
HACK is to allow the sim_resume interface's step argument to be
tested without having to build/run gdb. */
if (strlen (myname) > 4 && strcmp (myname - 4, "step") == 0)
{
single_step = 1;
}
/* Create an instance of the simulator. */
default_callback.init (&default_callback);
sd = sim_open (SIM_OPEN_STANDALONE, &default_callback, NULL, argv);
if (sd == 0)
exit (1);
if (STATE_MAGIC (sd) != SIM_MAGIC_NUMBER)
{
fprintf (stderr, "Internal error - bad magic number in simulator struct\n");
abort ();
}
/* We can't set the endianness in the callback structure until
sim_config is called, which happens in sim_open. */
default_callback.target_endian
= (CURRENT_TARGET_BYTE_ORDER == BIG_ENDIAN
? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
/* Was there a program to run? */
prog_argv = STATE_PROG_ARGV (sd);
prog_bfd = STATE_PROG_BFD (sd);
if (prog_argv == NULL || *prog_argv == NULL)
usage ();
name = *prog_argv;
/* For simulators that don't open prog during sim_open() */
if (prog_bfd == NULL)
{
prog_bfd = bfd_openr (name, 0);
if (prog_bfd == NULL)
{
fprintf (stderr, "%s: can't open \"%s\": %s\n",
myname, name, bfd_errmsg (bfd_get_error ()));
exit (1);
}
if (!bfd_check_format (prog_bfd, bfd_object))
{
fprintf (stderr, "%s: \"%s\" is not an object file: %s\n",
myname, name, bfd_errmsg (bfd_get_error ()));
exit (1);
}
}
if (STATE_VERBOSE_P (sd))
printf ("%s %s\n", myname, name);
/* Load the program into the simulator. */
if (sim_load (sd, name, prog_bfd, 0) == SIM_RC_FAIL)
exit (1);
/* Prepare the program for execution. */
#ifdef HAVE_ENVIRON
sim_create_inferior (sd, prog_bfd, prog_argv, environ);
#else
sim_create_inferior (sd, prog_bfd, prog_argv, NULL);
#endif
/* To accommodate relative file paths, chdir to sysroot now. We
mustn't do this until BFD has opened the program, else we wouldn't
find the executable if it has a relative file path. */
if (simulator_sysroot[0] != '\0' && chdir (simulator_sysroot) < 0)
{
fprintf (stderr, "%s: can't change directory to \"%s\"\n",
myname, simulator_sysroot);
exit (1);
}
/* Run/Step the program. */
if (single_step)
{
do
{
prev_sigint = signal (SIGINT, cntrl_c);
sim_resume (sd, 1/*step*/, 0);
signal (SIGINT, prev_sigint);
sim_stop_reason (sd, &reason, &sigrc);
if ((reason == sim_stopped) &&
(sigrc == sim_signal_to_host (sd, SIM_SIGINT)))
break; /* exit on control-C */
}
/* remain on breakpoint or signals in oe mode*/
while (((reason == sim_signalled) &&
(sigrc == sim_signal_to_host (sd, SIM_SIGTRAP))) ||
((reason == sim_stopped) &&
(STATE_ENVIRONMENT (sd) == OPERATING_ENVIRONMENT)));
}
else
{
do
{
#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
struct sigaction sa, osa;
sa.sa_handler = cntrl_c;
sigemptyset (&sa.sa_mask);
sa.sa_flags = 0;
sigaction (SIGINT, &sa, &osa);
prev_sigint = osa.sa_handler;
#else
prev_sigint = signal (SIGINT, cntrl_c);
#endif
sim_resume (sd, 0, sigrc);
signal (SIGINT, prev_sigint);
sim_stop_reason (sd, &reason, &sigrc);
if ((reason == sim_stopped) &&
(sigrc == sim_signal_to_host (sd, SIM_SIGINT)))
break; /* exit on control-C */
/* remain on signals in oe mode */
} while ((reason == sim_stopped) &&
(STATE_ENVIRONMENT (sd) == OPERATING_ENVIRONMENT));
}
/* Print any stats the simulator collected. */
if (STATE_VERBOSE_P (sd))
sim_info (sd, 0);
/* Shutdown the simulator. */
sim_close (sd, 0);
/* If reason is sim_exited, then sigrc holds the exit code which we want
to return. If reason is sim_stopped or sim_signalled, then sigrc holds
the signal that the simulator received; we want to return that to
indicate failure. */
/* Why did we stop? */
switch (reason)
{
case sim_signalled:
case sim_stopped:
if (sigrc != 0)
fprintf (stderr, "program stopped with signal %d.\n", sigrc);
break;
case sim_exited:
break;
default:
fprintf (stderr, "program in undefined state (%d:%d)\n", reason, sigrc);
break;
}
return sigrc;
}
#if defined(SIGWINCH)
static RETSIGTYPE sig_winch __ARGS(SIGPROTOARG);
#endif
#if defined(SIGINT)
static RETSIGTYPE catch_sigint __ARGS(SIGPROTOARG);
#endif
#if defined(SIGPWR)
static RETSIGTYPE catch_sigpwr __ARGS(SIGPROTOARG);
#endif
static RETSIGTYPE deathtrap __ARGS(SIGPROTOARG);
static void catch_int_signal __ARGS((void));
static void set_signals __ARGS((void));
static void catch_signals __ARGS(
(RETSIGTYPE (*func_deadly)(), RETSIGTYPE (*func_other)()));
static int have_wildcard __ARGS((int, char_u **));
static int have_dollars __ARGS((int, char_u **));
static int save_patterns __ARGS((int num_pat, char_u **pat, int *num_file,
char_u ***file));
#ifndef SIG_ERR
# define SIG_ERR ((RETSIGTYPE (*)())-1)
#endif
/* volatile because it is used in signal handler sig_winch(). */
static volatile int do_resize = FALSE;
static char_u *extra_shell_arg = NULL;
static int show_shell_mess = TRUE;
/* volatile because it is used in signal handler deathtrap(). */
char *getpass(const char *prompt)
{
FILE *infp;
FILE *outfp;
static char buf[INPUT_BUFFER];
RETSIGTYPE (*sigint)();
RETSIGTYPE (*sigtstp)();
size_t bytes_read;
int infd;
int outfd;
#ifdef HAVE_TERMIOS_H
struct termios orig;
struct termios noecho;
#else
# ifdef HAVE_TERMIO_H
struct termio orig;
struct termio noecho;
# else
# endif
#endif
sigint = signal(SIGINT, SIG_IGN);
sigtstp = signal(SIGTSTP, SIG_IGN);
if( (infp=fopen("/dev/tty", "r")) == NULL )
{
infp = stdin;
}
if( (outfp=fopen("/dev/tty", "w")) == NULL )
{
outfp = stderr;
}
infd = fileno(infp);
outfd = fileno(outfp);
/* dissable echo */
#ifdef HAVE_TERMIOS_H
if(tcgetattr(outfd, &orig) != 0)
{
perror("tcgetattr");
}
noecho = orig;
noecho.c_lflag &= ~ECHO;
if(tcsetattr(outfd, TCSANOW, &noecho) != 0)
{
perror("tcgetattr");
}
#else
# ifdef HAVE_TERMIO_H
if(ioctl(outfd, TCGETA, &orig) != 0)
{
perror("ioctl");
}
noecho = orig;
noecho.c_lflag &= ~ECHO;
if(ioctl(outfd, TCSETA, &noecho) != 0)
{
perror("ioctl");
}
# else
# endif
#endif
fputs(prompt, outfp);
fflush(outfp);
bytes_read=read(infd, buf, INPUT_BUFFER);
buf[bytes_read > 0 ? (bytes_read -1) : 0] = '\0';
/* print a new line if needed */
#ifdef HAVE_TERMIOS_H
fputs("\n", outfp);
#else
# ifdef HAVE_TERMIO_H
fputs("\n", outfp);
# else
# endif
#endif
/*
* reset term charectaristics, use TCSAFLUSH incase the
* user types more than INPUT_BUFFER
*/
#ifdef HAVE_TERMIOS_H
if(tcsetattr(outfd, TCSAFLUSH, &orig) != 0)
{
perror("tcgetattr");
}
#else
# ifdef HAVE_TERMIO_H
if(ioctl(outfd, TCSETA, &orig) != 0)
{
perror("ioctl");
}
# else
# endif
#endif
signal(SIGINT, sigint);
signal(SIGTSTP, sigtstp);
return(buf);
}
static SIM_RC
dv_sockser_init (SIM_DESC sd)
{
struct hostent *hostent;
struct sockaddr_in sockaddr;
char hostname[100];
const char *port_str;
int tmp,port;
if (STATE_ENVIRONMENT (sd) != OPERATING_ENVIRONMENT
|| sockser_addr == NULL)
return SIM_RC_OK;
if (*sockser_addr == '/')
{
/* support for these can come later */
sim_io_eprintf (sd, "sockser init: unix domain sockets not supported: `%s'\n",
sockser_addr);
return SIM_RC_FAIL;
}
port_str = strchr (sockser_addr, ':');
if (!port_str)
{
sim_io_eprintf (sd, "sockser init: missing port number: `%s'\n",
sockser_addr);
return SIM_RC_FAIL;
}
tmp = port_str - sockser_addr;
if (tmp >= sizeof hostname)
tmp = sizeof (hostname) - 1;
strncpy (hostname, sockser_addr, tmp);
hostname[tmp] = '\000';
port = atoi (port_str + 1);
hostent = gethostbyname (hostname);
if (! hostent)
{
sim_io_eprintf (sd, "sockser init: unknown host: %s\n",
hostname);
return SIM_RC_FAIL;
}
sockser_listen_fd = socket (PF_INET, SOCK_STREAM, 0);
if (sockser_listen_fd < 0)
{
sim_io_eprintf (sd, "sockser init: unable to get socket: %s\n",
strerror (errno));
return SIM_RC_FAIL;
}
sockaddr.sin_family = PF_INET;
sockaddr.sin_port = htons(port);
memcpy (&sockaddr.sin_addr.s_addr, hostent->h_addr,
sizeof (struct in_addr));
tmp = 1;
if (setsockopt (sockser_listen_fd, SOL_SOCKET, SO_REUSEADDR, (void*)& tmp, sizeof(tmp)) < 0)
{
sim_io_eprintf (sd, "sockser init: unable to set SO_REUSEADDR: %s\n",
strerror (errno));
}
if (bind (sockser_listen_fd, (struct sockaddr *) &sockaddr, sizeof (sockaddr)) < 0)
{
sim_io_eprintf (sd, "sockser init: unable to bind socket address: %s\n",
strerror (errno));
close (sockser_listen_fd);
sockser_listen_fd = -1;
return SIM_RC_FAIL;
}
if (listen (sockser_listen_fd, 1) < 0)
{
sim_io_eprintf (sd, "sockser init: unable to set up listener: %s\n",
strerror (errno));
close (sockser_listen_fd);
sockser_listen_fd = -1;
return SIM_RC_OK;
}
/* Handle writes to missing client -> SIGPIPE.
??? Need a central signal management module. */
{
RETSIGTYPE (*orig) ();
orig = signal (SIGPIPE, SIG_IGN);
/* If a handler is already set up, don't mess with it. */
if (orig != SIG_DFL && orig != SIG_IGN)
signal (SIGPIPE, orig);
}
return SIM_RC_OK;
}
int
run_exec (const char *stin, const char *stout, const char *sterr, int flags)
{
int shin, shout, sherr;
int mode_out, mode_err;
int status;
int rc = -1;
int rerrno = 0;
int pid, w;
#ifdef POSIX_SIGNALS
sigset_t sigset_mask, sigset_omask;
struct sigaction act, iact, qact;
#else
#ifdef BSD_SIGNALS
int mask;
struct sigvec vec, ivec, qvec;
#else
RETSIGTYPE (*istat) (), (*qstat) ();
#endif
#endif
if (trace)
{
cvs_outerr (
#ifdef SERVER_SUPPORT
server_active ? "S" :
#endif
" ", 1);
cvs_outerr (" -> system (", 0);
run_print (stderr);
cvs_outerr (")\n", 0);
}
if (noexec && (flags & RUN_REALLY) == 0)
return 0;
/* make sure that we are null terminated, since we didn't calloc */
run_add_arg (NULL);
/* setup default file descriptor numbers */
shin = 0;
shout = 1;
sherr = 2;
/* set the file modes for stdout and stderr */
mode_out = mode_err = O_WRONLY | O_CREAT;
mode_out |= ((flags & RUN_STDOUT_APPEND) ? O_APPEND : O_TRUNC);
mode_err |= ((flags & RUN_STDERR_APPEND) ? O_APPEND : O_TRUNC);
if (stin && (shin = open (stin, O_RDONLY)) == -1)
{
rerrno = errno;
error (0, errno, "cannot open %s for reading (prog %s)",
stin, run_argv[0]);
goto out0;
}
if (stout && (shout = open (stout, mode_out, 0666)) == -1)
{
rerrno = errno;
error (0, errno, "cannot open %s for writing (prog %s)",
stout, run_argv[0]);
goto out1;
}
if (sterr && (flags & RUN_COMBINED) == 0)
{
if ((sherr = open (sterr, mode_err, 0666)) == -1)
{
rerrno = errno;
error (0, errno, "cannot open %s for writing (prog %s)",
sterr, run_argv[0]);
goto out2;
}
}
/* Make sure we don't flush this twice, once in the subprocess. */
cvs_flushout();
cvs_flusherr();
/* The output files, if any, are now created. Do the fork and dups.
We use vfork not so much for a performance boost (the
performance boost, if any, is modest on most modern unices),
but for the sake of systems without a memory management unit,
which find it difficult or impossible to implement fork at all
(e.g. Amiga). The other solution is spawn (see
windows-NT/run.c). */
#ifdef HAVE_VFORK
pid = vfork ();
#else
pid = fork ();
#endif
if (pid == 0)
{
#ifdef SETXID_SUPPORT
if (flags & RUN_UNSETXID) {
(void) setgid (getgid ());
(void) setuid (getuid ());
}
#endif
if (shin != 0)
{
(void) dup2 (shin, 0);
(void) close (shin);
}
if (shout != 1)
{
(void) dup2 (shout, 1);
(void) close (shout);
}
if (flags & RUN_COMBINED)
(void) dup2 (1, 2);
else if (sherr != 2)
{
(void) dup2 (sherr, 2);
(void) close (sherr);
}
#ifdef SETXID_SUPPORT
/*
** This prevents a user from creating a privileged shell
** from the text editor when the SETXID_SUPPORT option is selected.
*/
if (!strcmp (run_argv[0], Editor) && setegid (getgid ()))
{
error (0, errno, "cannot set egid to gid");
_exit (127);
}
#endif
/* dup'ing is done. try to run it now */
(void) execvp (run_argv[0], run_argv);
error (0, errno, "cannot exec %s", run_argv[0]);
_exit (127);
}
else if (pid == -1)
{
rerrno = errno;
goto out;
}
/* the parent. Ignore some signals for now */
#ifdef POSIX_SIGNALS
if (flags & RUN_SIGIGNORE)
{
act.sa_handler = SIG_IGN;
(void) sigemptyset (&act.sa_mask);
act.sa_flags = 0;
(void) sigaction (SIGINT, &act, &iact);
(void) sigaction (SIGQUIT, &act, &qact);
}
else
{
(void) sigemptyset (&sigset_mask);
(void) sigaddset (&sigset_mask, SIGINT);
(void) sigaddset (&sigset_mask, SIGQUIT);
(void) sigprocmask (SIG_SETMASK, &sigset_mask, &sigset_omask);
}
#else
#ifdef BSD_SIGNALS
if (flags & RUN_SIGIGNORE)
{
memset (&vec, 0, sizeof vec);
vec.sv_handler = SIG_IGN;
(void) sigvec (SIGINT, &vec, &ivec);
(void) sigvec (SIGQUIT, &vec, &qvec);
}
else
mask = sigblock (sigmask (SIGINT) | sigmask (SIGQUIT));
#else
istat = signal (SIGINT, SIG_IGN);
qstat = signal (SIGQUIT, SIG_IGN);
#endif
#endif
/* wait for our process to die and munge return status */
#ifdef POSIX_SIGNALS
while ((w = waitpid (pid, &status, 0)) == -1 && errno == EINTR)
;
#else
while ((w = wait (&status)) != pid)
{
if (w == -1 && errno != EINTR)
break;
}
#endif
if (w == -1)
{
rc = -1;
rerrno = errno;
}
#ifndef VMS /* status is return status */
else if (WIFEXITED (status))
rc = WEXITSTATUS (status);
else if (WIFSIGNALED (status))
{
if (WTERMSIG (status) == SIGPIPE)
error (1, 0, "broken pipe");
rc = 2;
}
else
rc = 1;
#else /* VMS */
rc = WEXITSTATUS (status);
#endif /* VMS */
/* restore the signals */
#ifdef POSIX_SIGNALS
if (flags & RUN_SIGIGNORE)
{
(void) sigaction (SIGINT, &iact, NULL);
(void) sigaction (SIGQUIT, &qact, NULL);
}
else
(void) sigprocmask (SIG_SETMASK, &sigset_omask, NULL);
#else
#ifdef BSD_SIGNALS
if (flags & RUN_SIGIGNORE)
{
(void) sigvec (SIGINT, &ivec, NULL);
(void) sigvec (SIGQUIT, &qvec, NULL);
}
else
(void) sigsetmask (mask);
#else
(void) signal (SIGINT, istat);
(void) signal (SIGQUIT, qstat);
#endif
#endif
/* cleanup the open file descriptors */
out:
if (sterr)
(void) close (sherr);
else
/* ensure things are received by the parent in the correct order
* relative to the protocol pipe
*/
cvs_flusherr();
out2:
if (stout)
(void) close (shout);
else
/* ensure things are received by the parent in the correct order
* relative to the protocol pipe
*/
cvs_flushout();
out1:
if (stin)
(void) close (shin);
out0:
if (rerrno)
errno = rerrno;
return rc;
}
int
main(int argc, char **argv)
{
const char *name_of_file;
char *arg_;
psim_status status;
device *root = psim_tree();
/* parse the arguments */
argv = psim_options(root, argv + 1);
if (argv[0] == NULL) {
if (ppc_trace[trace_opts]) {
print_options ();
return 0;
} else {
psim_usage(0, 0);
}
}
name_of_file = argv[0];
if (ppc_trace[trace_opts])
print_options ();
/* create the simulator */
simulation = psim_create(name_of_file, root);
/* fudge the environment so that _=prog-name */
arg_ = (char*)zalloc(strlen(argv[0]) + strlen("_=") + 1);
strcpy(arg_, "_=");
strcat(arg_, argv[0]);
putenv(arg_);
/* initialize it */
psim_init(simulation);
psim_stack(simulation, argv, environ);
{
RETSIGTYPE (*prev) ();
prev = signal(SIGINT, cntrl_c);
psim_run(simulation);
signal(SIGINT, prev);
}
/* any final clean up */
if (ppc_trace[trace_print_info])
psim_print_info (simulation, ppc_trace[trace_print_info]);
/* why did we stop */
status = psim_get_status(simulation);
switch (status.reason) {
case was_continuing:
error("psim: continuing while stopped!\n");
return 0;
case was_trap:
error("psim: no trap insn\n");
return 0;
case was_exited:
return status.signal;
case was_signalled:
printf ("%s: Caught signal %d at address 0x%lx\n",
name_of_file, (int)status.signal,
(long)status.program_counter);
return status.signal;
default:
error("unknown halt condition\n");
return 0;
}
}
/*
* pipe_callback - handle pine-specific pipe setup like child
* signal handler and possibly any display stuff
* BUG: this function should probably be in a "alpine/pipe.c"
*/
void
pipe_callback(PIPE_S *syspipe, int flags, void *data)
{
#ifdef _WINDOWS
bitmap_t bitmap;
#endif
if(flags & OSB_PRE_OPEN) {
dprint((5, "Opening pipe: (%s%s%s%s%s%s)\n",
(syspipe->mode & PIPE_WRITE) ? "W":"", (syspipe->mode & PIPE_READ) ? "R":"",
(syspipe->mode & PIPE_NOSHELL) ? "N":"", (syspipe->mode & PIPE_PROT) ? "P":"",
(syspipe->mode & PIPE_USER) ? "U":"", (syspipe->mode & PIPE_RESET) ? "T":""));
#ifdef _WINDOWS
q_status_message(SM_ORDER, 0, 0,
"Waiting for called program to finish...");
flush_status_messages(1);
setbitmap(bitmap);
draw_keymenu(&pipe_cancel_keymenu, bitmap, ps_global->ttyo->screen_cols,
1-FOOTER_ROWS(ps_global), 0, FirstMenu);
#else /* UNIX */
if(!(syspipe->mode & (PIPE_WRITE | PIPE_READ)) && !(syspipe->mode & PIPE_SILENT)) {
flush_status_messages(0); /* just clean up display */
ClearScreen();
fflush(stdout);
}
if(syspipe->mode & PIPE_RESET)
ttyfix(0);
#ifdef SIGCHLD
/*
* Prepare for demise of child. Use SIGCHLD if it's available so
* we can do useful things, like keep the IMAP stream alive, while
* we're waiting on the child. The handler may have been changed by
* something in the composer, in particular, by an alt_editor call.
* So we need to re-set it to child_signal and then set it back
* when we're done.
*/
child_signalled = child_jump = 0;
syspipe->chld = signal(SIGCHLD, child_signal);
#endif
#endif /* UNIX */
}
else if(flags & OSB_POST_OPEN) {
#ifdef _WINDOWS
clearfooter(ps_global);
ps_global->mangled_footer = 1;
if((int) data == -2)
q_status_message1(SM_ORDER, 2, 3, "Ignoring completion of %s", syspipe->command);
#else /* UNIX */
if(!(syspipe->mode & (PIPE_WRITE | PIPE_READ)) && !(syspipe->mode & PIPE_SILENT)) {
ClearScreen();
ps_global->mangled_screen = 1;
}
if(syspipe->mode & PIPE_RESET)
ttyfix(1);
#ifdef SIGCHLD
(void) signal(SIGCHLD, SIG_DFL);
#endif
#endif /* UNIX */
}
else if(flags & OSB_PRE_CLOSE) {
#ifdef SIGCHLD
/*
* this is here so close_system_pipe so it has something
* to do while we're waiting on the other end of the
* pipe to complete. When we're in the background for
* a shell, the the side effect is pinging
*/
RETSIGTYPE (*alarm_sig)();
int old_cue = F_ON(F_SHOW_DELAY_CUE, ps_global);
/*
* remember the current SIGALRM handler, and make sure it's
* installed when we're finished just in case the longjmp
* out of the SIGCHLD handler caused sleep() to lose it.
* Don't pay any attention to that man behind the curtain.
*/
alarm_sig = signal(SIGALRM, SIG_IGN);
(void) F_SET(F_SHOW_DELAY_CUE, ps_global, 0);
ps_global->noshow_timeout = 1;
while(!child_signalled) {
/* wake up and prod server */
if(!(syspipe->mode & PIPE_NONEWMAIL))
new_mail(0, 2,
(syspipe->mode & PIPE_RESET) ? NM_NONE : NM_DEFER_SORT);
if(!child_signalled) {
if(setjmp(child_state) == 0) {
child_jump = 1; /* prepare to wake up */
sleep(600); /* give it 5mins to happend */
}
else
our_sigunblock(SIGCHLD);
}
child_jump = 0;
}
ps_global->noshow_timeout = 0;
F_SET(F_SHOW_DELAY_CUE, ps_global, old_cue);
(void) signal(SIGALRM, alarm_sig);
(void) signal(SIGCHLD, syspipe->chld);
#endif
}
else if(flags & OSB_POST_CLOSE) {
if(syspipe->mode & PIPE_RESET) /* restore our tty modes */
ttyfix(1);
if(!(syspipe->mode & (PIPE_WRITE | PIPE_READ | PIPE_SILENT))) {
ClearScreen(); /* No I/O to forked child */
ps_global->mangled_screen = 1;
}
}
}
static char *
prompt_password(const char *prompt, int with_echo)
{
static char nostring[1] = "";
static char *return_value;
volatile int tty_opened;
static FILE *ifp, *ofp;
volatile int is_tty;
#ifdef HAVE_SIGACTION
struct sigaction old_sigact;
#else
RETSIGTYPE (*old_signal)();
#endif
TERMIO old_modes;
int max_asterisks = getdef_num("GETPASS_ASTERISKS", -1);
/*
* set a flag so the SIGINT signal can be re-sent if it
* is caught
*/
sig_caught = 0;
return_value = NULL;
tty_opened = 0;
/*
* if /dev/tty can't be opened, getpass() needs to read
* from stdin and write to stderr instead.
*/
if (!(ifp = fopen("/dev/tty", "r+"))) {
ifp = stdin;
ofp = stderr;
} else {
ofp = ifp;
tty_opened = 1;
}
setbuf(ifp, (char *) 0);
/*
* the current tty modes must be saved so they can be
* restored later on. echo will be turned off, except
* for the newline character
*/
is_tty = 1;
if (GTTY(fileno(ifp), &old_modes)) {
is_tty = 0;
#if 0 /* to make getpass work with redirected stdin */
return_value = NULL;
goto out2;
#endif
}
#ifdef USE_SETJMP
/*
* If we get a SIGINT, sig_catch() will jump here -
* no need to press Enter after Ctrl-C.
*/
if (sigsetjmp(intr, 1))
goto out;
#endif
#ifdef HAVE_SIGACTION
sigact.sa_handler = sig_catch;
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = 0;
sigaction(SIGINT, &sigact, &old_sigact);
#else
old_signal = signal(SIGINT, sig_catch);
#endif
if (is_tty) {
TERMIO new_modes = old_modes;
if (max_asterisks < 0)
new_modes.c_lflag |= ICANON;
else
new_modes.c_lflag &= ~(ICANON);
if (with_echo)
new_modes.c_lflag |= (ECHO | ECHOE | ECHOK);
else
new_modes.c_lflag &= ~(ECHO | ECHOE | ECHOK);
new_modes.c_lflag |= ECHONL;
if (STTY(fileno(ifp), &new_modes))
goto out;
}
/*
* the prompt is output, and the response read without
* echoing. the trailing newline must be removed. if
* the fgets() returns an error, a NULL pointer is
* returned.
*/
if ((fputs(prompt, ofp) != EOF) && (fflush(ofp) != EOF))
return_value = readpass(ifp, ofp, with_echo, max_asterisks);
out:
/*
* the old SIGINT handler is restored after the tty
* modes. then /dev/tty is closed if it was opened in
* the beginning. finally, if a signal was caught it
* is sent to this process for normal processing.
*/
if (is_tty) {
if (STTY(fileno(ifp), &old_modes))
return_value = NULL;
}
#ifdef HAVE_SIGACTION
(void) sigaction (SIGINT, &old_sigact, NULL);
#else
(void) signal (SIGINT, old_signal);
#endif
#if 0
out2:
#endif
if (tty_opened)
(void) fclose(ifp);
if (sig_caught) {
kill(getpid(), SIGINT);
return_value = NULL;
}
if (!return_value) {
nostring[0] = '\0';
return_value = nostring;
}
return return_value;
}
static VALUE
rg_m_init(int argc, VALUE *argv, VALUE self)
{
gint i, gargc;
VALUE argary;
char** gargv;
VALUE progname;
if (_initialized)
return self;
else
_initialized = TRUE;
rb_scan_args(argc, argv, "01", &argary);
if (NIL_P(argary)){
argary = rb_const_get(rb_cObject, rb_intern("ARGV"));
gargc = RARRAY_LEN(argary);
} else {
Check_Type(argary, T_ARRAY);
gargc = RARRAY_LEN(argary);
}
gargv = ALLOCA_N(char *, gargc + 1);
progname = rb_gv_get("$0");
gargv[0] = (char *)RVAL2CSTR(progname);
for (i = 0; i < gargc; i++)
if (TYPE(RARRAY_PTR(argary)[i]) == T_STRING)
gargv[i+1] = (char *)RVAL2CSTR(RARRAY_PTR(argary)[i]);
else
gargv[i+1] = (char *)"";
gargc++;
{
gboolean is_initialized;
/* Gdk modifies sighandlers, sigh */
#ifdef NT
RETSIGTYPE (*sigfunc[3])();
#else
RETSIGTYPE (*sigfunc[7])();
#endif
#ifdef NT
sigfunc[0] = signal(SIGINT, SIG_IGN);
sigfunc[1] = signal(SIGSEGV, SIG_IGN);
sigfunc[2] = signal(SIGTERM, SIG_IGN);
#else
sigfunc[0] = signal(SIGHUP, SIG_IGN);
sigfunc[1] = signal(SIGINT, SIG_IGN);
sigfunc[2] = signal(SIGQUIT, SIG_IGN);
sigfunc[3] = signal(SIGBUS, SIG_IGN);
sigfunc[4] = signal(SIGSEGV, SIG_IGN);
sigfunc[5] = signal(SIGPIPE, SIG_IGN);
sigfunc[6] = signal(SIGTERM, SIG_IGN);
#endif
is_initialized = gtk_init_check(&gargc, &gargv);
if (! is_initialized) {
const char *display_name_arg = gdk_get_display_arg_name();
display_name_arg = display_name_arg ? display_name_arg : g_getenv("DISPLAY");
rb_raise(rbgtk_eGtkInitError, "Cannot open display: %s",
display_name_arg ? display_name_arg : " ");
}
setlocale(LC_NUMERIC, "C");
#ifdef NT
signal(SIGINT, (SignalFunc)sigfunc[0]);
signal(SIGSEGV, (SignalFunc)sigfunc[1]);
signal(SIGTERM, (SignalFunc)sigfunc[2]);
#else
signal(SIGHUP, sigfunc[0]);
signal(SIGINT, sigfunc[1]);
signal(SIGQUIT, sigfunc[2]);
signal(SIGBUS, sigfunc[3]);
signal(SIGSEGV, sigfunc[4]);
signal(SIGPIPE, sigfunc[5]);
signal(SIGTERM, sigfunc[6]);
#endif
}
return self;
}
