/* * Either execute a command by calling the shell or start a new shell */ int mch_call_shell( char_u *cmd, int options) /* SHELL_, see vim.h */ { int x; int tmode = cur_tmode; out_flush(); #ifdef MCH_WRITE_DUMP if (fdDump) { fprintf(fdDump, "mch_call_shell(\"%s\", %d)\n", cmd, options); fflush(fdDump); } #endif /* * Catch all deadly signals while running the external command, because a * CTRL-C, Ctrl-Break or illegal instruction might otherwise kill us. */ signal(SIGINT, SIG_IGN); signal(SIGILL, SIG_IGN); signal(SIGFPE, SIG_IGN); signal(SIGSEGV, SIG_IGN); signal(SIGTERM, SIG_IGN); signal(SIGABRT, SIG_IGN); if (options & SHELL_COOKED) settmode(TMODE_COOK); /* set to normal mode */ if (cmd == NULL) { x = mch_system(p_sh, options); } else { /* we use "command" or "cmd" to start the shell; slow but easy */ char_u *newcmd; newcmd = lalloc( STRLEN(p_sh) + STRLEN(p_shcf) + STRLEN(cmd) + 10, TRUE); if (newcmd != NULL) { if (STRNICMP(cmd, "start ", 6) == 0) { sprintf((char *)newcmd, "%s\0", cmd+6); if (WinExec((LPCSTR)newcmd, SW_SHOWNORMAL) > 31) x = 0; else x = -1; } else { sprintf((char *)newcmd, "%s%s %s %s", "", p_sh, p_shcf, cmd); x = mch_system((char *)newcmd, options); } vim_free(newcmd); } } if (tmode == TMODE_RAW) settmode(TMODE_RAW); /* set to raw mode */ if (x && !(options & SHELL_SILENT) && !emsg_silent) { smsg(_("shell returned %d"), x); msg_putchar('\n'); } #ifdef FEAT_TITLE resettitle(); #endif signal(SIGINT, SIG_DFL); signal(SIGILL, SIG_DFL); signal(SIGFPE, SIG_DFL); signal(SIGSEGV, SIG_DFL); signal(SIGTERM, SIG_DFL); signal(SIGABRT, SIG_DFL); return x; }
int os_call_shell(char_u *cmd, ShellOpts opts, char_u *extra_shell_arg) { uv_stdio_container_t proc_stdio[3]; uv_process_options_t proc_opts; uv_process_t proc; uv_pipe_t proc_stdin, proc_stdout; uv_write_t write_req; int expected_exits = 1; ProcessData pdata = { .reading = false, .exited = 0, .old_mode = cur_tmode, .old_state = State, .shell_stdin = (uv_stream_t *)&proc_stdin, .wbuffer = NULL, }; out_flush(); if (opts & kShellOptCooked) { // set to normal mode settmode(TMODE_COOK); } // While the child is running, ignore terminating signals signal_reject_deadly(); // Create argv for `uv_spawn` // TODO(tarruda): we can use a static buffer for small argument vectors. 1024 // bytes should be enough for most of the commands and if more is necessary // we can allocate a another buffer proc_opts.args = shell_build_argv(cmd, extra_shell_arg); proc_opts.file = proc_opts.args[0]; proc_opts.exit_cb = exit_cb; // Initialize libuv structures proc_opts.stdio = proc_stdio; proc_opts.stdio_count = 3; // Hide window on Windows :) proc_opts.flags = UV_PROCESS_WINDOWS_HIDE; proc_opts.cwd = NULL; proc_opts.env = NULL; // The default is to inherit all standard file descriptors(this will change // when the UI is moved to an external process) proc_stdio[0].flags = UV_INHERIT_FD; proc_stdio[0].data.fd = 0; proc_stdio[1].flags = UV_INHERIT_FD; proc_stdio[1].data.fd = 1; proc_stdio[2].flags = UV_INHERIT_FD; proc_stdio[2].data.fd = 2; if (opts & (kShellOptHideMess | kShellOptExpand)) { // Ignore the shell stdio(redirects to /dev/null on unixes) proc_stdio[0].flags = UV_IGNORE; proc_stdio[1].flags = UV_IGNORE; proc_stdio[2].flags = UV_IGNORE; } else { State = EXTERNCMD; if (opts & kShellOptWrite) { // Write from the current buffer into the process stdin uv_pipe_init(uv_default_loop(), &proc_stdin, 0); write_req.data = &pdata; proc_stdio[0].flags = UV_CREATE_PIPE | UV_READABLE_PIPE; proc_stdio[0].data.stream = (uv_stream_t *)&proc_stdin; } if (opts & kShellOptRead) { // Read from the process stdout into the current buffer uv_pipe_init(uv_default_loop(), &proc_stdout, 0); proc_stdout.data = &pdata; proc_stdio[1].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE; proc_stdio[1].data.stream = (uv_stream_t *)&proc_stdout; ga_init(&pdata.ga, 1, BUFFER_LENGTH); } } if (uv_spawn(uv_default_loop(), &proc, &proc_opts)) { // Failed, probably due to `sh` not being executable if (!emsg_silent) { MSG_PUTS(_("\nCannot execute shell ")); msg_outtrans(p_sh); msg_putchar('\n'); } return proc_cleanup_exit(&pdata, &proc_opts, opts); } // Assign the flag address after `proc` is initialized by `uv_spawn` proc.data = &pdata; if (opts & kShellOptWrite) { // Queue everything for writing to the shell stdin write_selection(&write_req); expected_exits++; } if (opts & kShellOptRead) { // Start the read stream for the shell stdout uv_read_start((uv_stream_t *)&proc_stdout, alloc_cb, read_cb); expected_exits++; } // Keep running the loop until all three handles are completely closed while (pdata.exited < expected_exits) { uv_run(uv_default_loop(), UV_RUN_ONCE); if (got_int) { // Forward SIGINT to the shell // TODO(tarruda): for now this is only needed if the terminal is in raw // mode, but when the UI is externalized we'll also need it, so leave it // here uv_process_kill(&proc, SIGINT); got_int = false; } } if (opts & kShellOptRead) { if (pdata.ga.ga_len > 0) { // If there's an unfinished line in the growable array, append it now. append_ga_line(&pdata.ga); // remember that the NL was missing curbuf->b_no_eol_lnum = curwin->w_cursor.lnum; } else { curbuf->b_no_eol_lnum = 0; } ga_clear(&pdata.ga); } if (opts & kShellOptWrite) { free(pdata.wbuffer); } return proc_cleanup_exit(&pdata, &proc_opts, opts); } static int tokenize(char_u *str, char **argv) { int argc = 0, len; char_u *p = str; while (*p != '\0') { len = word_length(p); if (argv != NULL) { // Fill the slot argv[argc] = xmalloc(len + 1); memcpy(argv[argc], p, len); argv[argc][len] = '\0'; } argc++; p += len; p = skipwhite(p); } return argc; }
/// Calls the user shell for running a command, interactive session or /// wildcard expansion. It uses the shell set in the `sh` option. /// /// @param cmd The command to be executed. If NULL it will run an interactive /// shell /// @param opts Various options that control how the shell will work /// @param extra_arg Extra argument to be passed to the shell int os_call_shell(char_u *cmd, ShellOpts opts, char_u *extra_arg) { DynamicBuffer input = DYNAMIC_BUFFER_INIT; char *output = NULL, **output_ptr = NULL; int current_state = State, old_mode = cur_tmode; bool forward_output = true; out_flush(); if (opts & kShellOptCooked) { settmode(TMODE_COOK); } // While the child is running, ignore terminating signals signal_reject_deadly(); if (opts & (kShellOptHideMess | kShellOptExpand)) { forward_output = false; } else { State = EXTERNCMD; if (opts & kShellOptWrite) { read_input(&input); } if (opts & kShellOptRead) { output_ptr = &output; forward_output = false; } } size_t nread; int status = shell((const char *)cmd, (const char *)extra_arg, input.data, input.len, output_ptr, &nread, emsg_silent, forward_output); if (input.data) { free(input.data); } if (output) { write_output(output, nread); free(output); } if (!emsg_silent && status != 0 && !(opts & kShellOptSilent)) { MSG_PUTS(_("\nshell returned ")); msg_outnum(status); msg_putchar('\n'); } if (old_mode == TMODE_RAW) { // restore mode settmode(TMODE_RAW); } State = current_state; signal_accept_deadly(); return status; }