void
close_stdin (void)
{
bool fail = false;
/* There is no need to flush stdin if we can determine quickly that stdin's
input buffer is empty; in this case we know that if stdin is seekable,
fseeko (stdin, 0, SEEK_CUR) == lseek (0, 0, SEEK_CUR). */
//if (freadahead (stdin) > 0)
{
/* Only attempt flush if stdin is seekable, as fflush is entitled to
fail on non-seekable streams. */
if (fseek (stdin, 0, SEEK_CUR) == 0 && fflush (stdin) != 0)
fail = true;
}
if (close_stream (stdin) != 0)
fail = true;
if (fail)
{
/* Report failure, but defer exit until after closing stdout,
since the failure report should still be flushed. */
char const *close_error = _("error closing file");
if (file_name)
error (0, errno, "%s: %s", quotearg_colon (file_name),
close_error);
else
error (0, errno, "%s", close_error);
}
close_stdout ();
if (fail)
_exit (exit_failure);
}
Coprocess::~Coprocess ()
{
close_stdin();
close_stdout();
if (proc_handle) {
CloseHandle(proc_handle);
}
}
void output_wrapper_end(parserinfo_cut_t *pinfo) {
if( pinfo ) {
putc_stdout('\n');
puts_stdout(get_close_root());
puts_stdout(get_footwrap());
}
close_stdout();
}
int main(int argc, char **argv) {
signed char op;
parserinfo_ls_t pinfo;
struct option longopts[] = {
{ "version", 0, NULL, LS_VERSION },
{ "help", 0, NULL, LS_HELP },
{ "attributes", 0, NULL, LS_ATTRIBUTES },
{ 0 }
};
progname = "xml-ls";
inputfile = "";
inputline = 0;
if( create_parserinfo_ls(&pinfo) ) {
while( (op = getopt_long(argc, argv, "a",
longopts, NULL)) > -1 ) {
set_option_ls(op, optarg, &pinfo);
}
init_signal_handling(SIGNALS_DEFAULT);
init_file_handling();
open_stdout();
puts_stdout(get_headwrap());
puts_stdout(get_open_root());
stdparse(MAXFILES, argv + optind, (stdparserinfo_t *)&pinfo);
putc_stdout('\n');
puts_stdout(get_close_root());
puts_stdout(get_footwrap());
close_stdout();
exit_file_handling();
exit_signal_handling();
free_parserinfo_ls(&pinfo);
}
return EXIT_SUCCESS;
}
Coprocess::~Coprocess ()
{
close_stdin();
close_stdout();
}
/* Remote control server. */
void
rc_listen (void)
{
char sockpath[128];
pid_t pid;
struct sockaddr_un addr;
int sock, s;
size_t i;
FILE *fp;
XDR xdr, xdr2;
guestfish_hello hello;
guestfish_call call;
guestfish_reply reply;
char **argv;
size_t argc;
memset (&hello, 0, sizeof hello);
memset (&call, 0, sizeof call);
pid = fork ();
if (pid == -1) {
perror ("fork");
exit (EXIT_FAILURE);
}
if (pid > 0) {
/* Parent process. */
if (!remote_control_csh)
printf ("GUESTFISH_PID=%d; export GUESTFISH_PID\n", pid);
else
printf ("setenv GUESTFISH_PID %d\n", pid);
fflush (stdout);
_exit (0);
}
/* Child process.
*
* Create the listening socket for accepting commands.
*
* Unfortunately there is a small but unavoidable race here. We
* don't know the PID until after we've forked, so we cannot be
* sure the socket is created from the point of view of the parent
* (if the child is very slow).
*/
pid = getpid ();
create_sockpath (pid, sockpath, sizeof sockpath, &addr);
sock = socket (AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0);
if (sock == -1) {
perror ("socket");
exit (EXIT_FAILURE);
}
unlink (sockpath);
if (bind (sock, (struct sockaddr *) &addr, sizeof addr) == -1) {
perror (sockpath);
exit (EXIT_FAILURE);
}
if (listen (sock, 4) == -1) {
perror ("listen");
exit (EXIT_FAILURE);
}
/* Read commands and execute them. */
while (!quit) {
/* Before waiting, close stdout and substitute /dev/null. This is
* necessary so that eval `guestfish --listen` doesn't block
* forever.
*/
close_stdout ();
s = accept4 (sock, NULL, NULL, SOCK_CLOEXEC);
if (s == -1)
perror ("accept");
else {
receive_stdout(s);
fp = fdopen (s, "r+");
xdrstdio_create (&xdr, fp, XDR_DECODE);
if (!xdr_guestfish_hello (&xdr, &hello)) {
fprintf (stderr, _("guestfish: protocol error: could not read 'hello' message\n"));
goto error;
}
if (STRNEQ (hello.vers, PACKAGE_VERSION)) {
fprintf (stderr, _("guestfish: protocol error: version mismatch, server version '%s' does not match client version '%s'. The two versions must match exactly.\n"),
PACKAGE_VERSION,
hello.vers);
xdr_free ((xdrproc_t) xdr_guestfish_hello, (char *) &hello);
goto error;
}
xdr_free ((xdrproc_t) xdr_guestfish_hello, (char *) &hello);
while (xdr_guestfish_call (&xdr, &call)) {
/* We have to extend and NULL-terminate the argv array. */
argc = call.args.args_len;
argv = realloc (call.args.args_val, (argc+1) * sizeof (char *));
if (argv == NULL) {
perror ("realloc");
exit (EXIT_FAILURE);
}
call.args.args_val = argv;
argv[argc] = NULL;
if (verbose) {
fprintf (stderr, "guestfish(%d): %s", pid, call.cmd);
for (i = 0; i < argc; ++i)
fprintf (stderr, " %s", argv[i]);
fprintf (stderr, "\n");
}
/* Run the command. */
reply.r = issue_command (call.cmd, argv, NULL, 0);
xdr_free ((xdrproc_t) xdr_guestfish_call, (char *) &call);
/* RHBZ#802389: If the command is quit, close the handle right
* away. Note that the main while loop will exit preventing
* 'g' from being reused.
*/
if (quit) {
guestfs_close (g);
g = NULL;
}
/* Send the reply. */
xdrstdio_create (&xdr2, fp, XDR_ENCODE);
(void) xdr_guestfish_reply (&xdr2, &reply);
xdr_destroy (&xdr2);
/* Exit on error? */
if (call.exit_on_error && reply.r == -1) {
unlink (sockpath);
exit (EXIT_FAILURE);
}
}
error:
xdr_destroy (&xdr); /* NB. This doesn't close 'fp'. */
fclose (fp); /* Closes the underlying socket 's'. */
}
}
unlink (sockpath);
close (sock);
/* This returns to 'fish.c', where it jumps to global cleanups and exits. */
}
