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. */ }