/**
Returns a description for the specified function
*/
static const wchar_t *complete_function_desc( const wchar_t *fn )
{
const wchar_t *res = function_get_desc( fn );
if( !res )
res = function_get_definition( fn );
return res;
}
void exec( job_t *j )
{
process_t *p;
pid_t pid;
int mypipe[2];
sigset_t chldset;
int skip_fork;
io_data_t pipe_read, pipe_write;
io_data_t *tmp;
io_data_t *io_buffer =0;
/*
Set to 1 if something goes wrong while exec:ing the job, in
which case the cleanup code will kick in.
*/
int exec_error=0;
int needs_keepalive = 0;
process_t keepalive;
CHECK( j, );
CHECK_BLOCK();
if( no_exec )
return;
sigemptyset( &chldset );
sigaddset( &chldset, SIGCHLD );
debug( 4, L"Exec job '%ls' with id %d", j->command, j->job_id );
if( block_io )
{
if( j->io )
{
j->io = io_add( io_duplicate( j, block_io), j->io );
}
else
{
j->io=io_duplicate( j, block_io);
}
}
io_data_t *input_redirect;
for( input_redirect = j->io; input_redirect; input_redirect = input_redirect->next )
{
if( (input_redirect->io_mode == IO_BUFFER) &&
input_redirect->is_input )
{
/*
Input redirection - create a new gobetween process to take
care of buffering
*/
process_t *fake = halloc( j, sizeof(process_t) );
fake->type = INTERNAL_BUFFER;
fake->pipe_write_fd = 1;
j->first_process->pipe_read_fd = input_redirect->fd;
fake->next = j->first_process;
j->first_process = fake;
break;
}
}
if( j->first_process->type==INTERNAL_EXEC )
{
/*
Do a regular launch - but without forking first...
*/
signal_block();
/*
setup_child_process makes sure signals are properly set
up. It will also call signal_unblock
*/
if( !setup_child_process( j, 0 ) )
{
/*
launch_process _never_ returns
*/
launch_process( j->first_process );
}
else
{
job_set_flag( j, JOB_CONSTRUCTED, 1 );
j->first_process->completed=1;
return;
}
}
pipe_read.fd=0;
pipe_write.fd=1;
pipe_read.io_mode=IO_PIPE;
pipe_read.param1.pipe_fd[0] = -1;
pipe_read.param1.pipe_fd[1] = -1;
pipe_read.is_input = 1;
pipe_write.io_mode=IO_PIPE;
pipe_write.is_input = 0;
pipe_read.next=0;
pipe_write.next=0;
pipe_write.param1.pipe_fd[0]=pipe_write.param1.pipe_fd[1]=-1;
j->io = io_add( j->io, &pipe_write );
signal_block();
/*
See if we need to create a group keepalive process. This is
a process that we create to make sure that the process group
doesn't die accidentally, and is often needed when a
builtin/block/function is inside a pipeline, since that
usually means we have to wait for one program to exit before
continuing in the pipeline, causing the group leader to
exit.
*/
if( job_get_flag( j, JOB_CONTROL ) )
{
for( p=j->first_process; p; p = p->next )
{
if( p->type != EXTERNAL )
{
if( p->next )
{
needs_keepalive = 1;
break;
}
if( p != j->first_process )
{
needs_keepalive = 1;
break;
}
}
}
}
if( needs_keepalive )
{
keepalive.pid = exec_fork();
if( keepalive.pid == 0 )
{
keepalive.pid = getpid();
set_child_group( j, &keepalive, 1 );
pause();
exit(0);
}
else
{
set_child_group( j, &keepalive, 0 );
}
}
/*
This loop loops over every process_t in the job, starting it as
appropriate. This turns out to be rather complex, since a
process_t can be one of many rather different things.
The loop also has to handle pipelining between the jobs.
*/
for( p=j->first_process; p; p = p->next )
{
mypipe[1]=-1;
skip_fork=0;
pipe_write.fd = p->pipe_write_fd;
pipe_read.fd = p->pipe_read_fd;
// debug( 0, L"Pipe created from fd %d to fd %d", pipe_write.fd, pipe_read.fd );
/*
This call is used so the global environment variable array
is regenerated, if needed, before the fork. That way, we
avoid a lot of duplicate work where EVERY child would need
to generate it, since that result would not get written
back to the parent. This call could be safely removed, but
it would result in slightly lower performance - at least on
uniprocessor systems.
*/
if( p->type == EXTERNAL )
env_export_arr( 1 );
/*
Set up fd:s that will be used in the pipe
*/
if( p == j->first_process->next )
{
j->io = io_add( j->io, &pipe_read );
}
if( p->next )
{
// debug( 1, L"%ls|%ls" , p->argv[0], p->next->argv[0]);
if( exec_pipe( mypipe ) == -1 )
{
debug( 1, PIPE_ERROR );
wperror (L"pipe");
exec_error=1;
break;
}
memcpy( pipe_write.param1.pipe_fd, mypipe, sizeof(int)*2);
}
else
{
/*
This is the last element of the pipeline.
Remove the io redirection for pipe output.
*/
j->io = io_remove( j->io, &pipe_write );
}
switch( p->type )
{
case INTERNAL_FUNCTION:
{
const wchar_t * orig_def;
wchar_t * def=0;
array_list_t *named_arguments;
int shadows;
/*
Calls to function_get_definition might need to
source a file as a part of autoloading, hence there
must be no blocks.
*/
signal_unblock();
orig_def = function_get_definition( p->argv[0] );
named_arguments = function_get_named_arguments( p->argv[0] );
shadows = function_get_shadows( p->argv[0] );
signal_block();
if( orig_def )
{
def = halloc_register( j, wcsdup(orig_def) );
}
if( def == 0 )
{
debug( 0, _( L"Unknown function '%ls'" ), p->argv[0] );
break;
}
parser_push_block( shadows?FUNCTION_CALL:FUNCTION_CALL_NO_SHADOW );
current_block->param2.function_call_process = p;
current_block->param1.function_call_name = halloc_register( current_block, wcsdup( p->argv[0] ) );
/*
set_argv might trigger an event
handler, hence we need to unblock
signals.
*/
signal_unblock();
parse_util_set_argv( p->argv+1, named_arguments );
signal_block();
parser_forbid_function( p->argv[0] );
if( p->next )
{
io_buffer = io_buffer_create( 0 );
j->io = io_add( j->io, io_buffer );
}
internal_exec_helper( def, TOP, j->io );
parser_allow_function();
parser_pop_block();
break;
}
case INTERNAL_BLOCK:
{
if( p->next )
{
io_buffer = io_buffer_create( 0 );
j->io = io_add( j->io, io_buffer );
}
internal_exec_helper( p->argv[0], TOP, j->io );
break;
}
case INTERNAL_BUILTIN:
{
int builtin_stdin=0;
int fg;
int close_stdin=0;
/*
If this is the first process, check the io
redirections and see where we should be reading
from.
*/
if( p == j->first_process )
{
io_data_t *in = io_get( j->io, 0 );
if( in )
{
switch( in->io_mode )
{
case IO_FD:
{
builtin_stdin = in->param1.old_fd;
break;
}
case IO_PIPE:
{
builtin_stdin = in->param1.pipe_fd[0];
break;
}
case IO_FILE:
{
builtin_stdin=wopen( in->param1.filename,
in->param2.flags, OPEN_MASK );
if( builtin_stdin == -1 )
{
debug( 1,
FILE_ERROR,
in->param1.filename );
wperror( L"open" );
}
else
{
close_stdin = 1;
}
break;
}
case IO_CLOSE:
{
/*
FIXME:
When
requesting
that
stdin
be
closed,
we
really
don't
do
anything. How
should
this
be
handled?
*/
builtin_stdin = -1;
break;
}
default:
{
builtin_stdin=-1;
debug( 1,
_( L"Unknown input redirection type %d" ),
in->io_mode);
break;
}
}
}
}
else
{
builtin_stdin = pipe_read.param1.pipe_fd[0];
}
if( builtin_stdin == -1 )
{
exec_error=1;
break;
}
else
{
int old_out = builtin_out_redirect;
int old_err = builtin_err_redirect;
/*
Since this may be the foreground job, and since
a builtin may execute another foreground job,
we need to pretend to suspend this job while
running the builtin, in order to avoid a
situation where two jobs are running at once.
The reason this is done here, and not by the
relevant builtins, is that this way, the
builtin does not need to know what job it is
part of. It could probably figure that out by
walking the job list, but it seems more robust
to make exec handle things.
*/
builtin_push_io( builtin_stdin );
builtin_out_redirect = has_fd( j->io, 1 );
builtin_err_redirect = has_fd( j->io, 2 );
fg = job_get_flag( j, JOB_FOREGROUND );
job_set_flag( j, JOB_FOREGROUND, 0 );
signal_unblock();
p->status = builtin_run( p->argv, j->io );
builtin_out_redirect=old_out;
builtin_err_redirect=old_err;
signal_block();
/*
Restore the fg flag, which is temporarily set to
false during builtin execution so as not to confuse
some job-handling builtins.
*/
job_set_flag( j, JOB_FOREGROUND, fg );
}
/*
If stdin has been redirected, close the redirection
stream.
*/
if( close_stdin )
{
exec_close( builtin_stdin );
}
break;
}
}
if( exec_error )
{
break;
}
switch( p->type )
{
case INTERNAL_BLOCK:
case INTERNAL_FUNCTION:
{
int status = proc_get_last_status();
/*
Handle output from a block or function. This usually
means do nothing, but in the case of pipes, we have
to buffer such io, since otherwise the internal pipe
buffer might overflow.
*/
if( !io_buffer )
{
/*
No buffer, so we exit directly. This means we
have to manually set the exit status.
*/
if( p->next == 0 )
{
proc_set_last_status( job_get_flag( j, JOB_NEGATE )?(!status):status);
}
p->completed = 1;
break;
}
j->io = io_remove( j->io, io_buffer );
io_buffer_read( io_buffer );
if( io_buffer->param2.out_buffer->used != 0 )
{
pid = exec_fork();
if( pid == 0 )
{
/*
This is the child process. Write out the contents of the pipeline.
*/
p->pid = getpid();
setup_child_process( j, p );
exec_write_and_exit(io_buffer->fd,
io_buffer->param2.out_buffer->buff,
io_buffer->param2.out_buffer->used,
status);
}
else
{
/*
This is the parent process. Store away
information on the child, and possibly give
it control over the terminal.
*/
p->pid = pid;
set_child_group( j, p, 0 );
}
}
else
{
if( p->next == 0 )
{
proc_set_last_status( job_get_flag( j, JOB_NEGATE )?(!status):status);
}
p->completed = 1;
}
io_buffer_destroy( io_buffer );
io_buffer=0;
break;
}
case INTERNAL_BUFFER:
{
pid = exec_fork();
if( pid == 0 )
{
/*
This is the child process. Write out the
contents of the pipeline.
*/
p->pid = getpid();
setup_child_process( j, p );
exec_write_and_exit( 1,
input_redirect->param2.out_buffer->buff,
input_redirect->param2.out_buffer->used,
0);
}
else
{
/*
This is the parent process. Store away
information on the child, and possibly give
it control over the terminal.
*/
p->pid = pid;
set_child_group( j, p, 0 );
}
break;
}
case INTERNAL_BUILTIN:
{
int skip_fork;
/*
Handle output from builtin commands. In the general
case, this means forking of a worker process, that
will write out the contents of the stdout and stderr
buffers to the correct file descriptor. Since
forking is expensive, fish tries to avoid it wehn
possible.
*/
/*
If a builtin didn't produce any output, and it is
not inside a pipeline, there is no need to fork
*/
skip_fork =
( !sb_out->used ) &&
( !sb_err->used ) &&
( !p->next );
/*
If the output of a builtin is to be sent to an internal
buffer, there is no need to fork. This helps out the
performance quite a bit in complex completion code.
*/
io_data_t *io = io_get( j->io, 1 );
int buffer_stdout = io && io->io_mode == IO_BUFFER;
if( ( !sb_err->used ) &&
( !p->next ) &&
( sb_out->used ) &&
( buffer_stdout ) )
{
char *res = wcs2str( (wchar_t *)sb_out->buff );
b_append( io->param2.out_buffer, res, strlen( res ) );
skip_fork = 1;
free( res );
}
for( io = j->io; io; io=io->next )
{
if( io->io_mode == IO_FILE && wcscmp(io->param1.filename, L"/dev/null" ))
{
skip_fork = 0;
}
}
if( skip_fork )
{
p->completed=1;
if( p->next == 0 )
{
debug( 3, L"Set status of %ls to %d using short circut", j->command, p->status );
int status = proc_format_status(p->status);
proc_set_last_status( job_get_flag( j, JOB_NEGATE )?(!status):status );
}
break;
}
/*
Ok, unfortunatly, we have to do a real fork. Bummer.
*/
pid = exec_fork();
if( pid == 0 )
{
/*
This is the child process. Setup redirections,
print correct output to stdout and stderr, and
then exit.
*/
p->pid = getpid();
setup_child_process( j, p );
do_builtin_io( sb_out->used ? (wchar_t *)sb_out->buff : 0, sb_err->used ? (wchar_t *)sb_err->buff : 0 );
exit( p->status );
}
else
{
/*
This is the parent process. Store away
information on the child, and possibly give
it control over the terminal.
*/
p->pid = pid;
set_child_group( j, p, 0 );
}
break;
}
case EXTERNAL:
{
pid = exec_fork();
if( pid == 0 )
{
/*
This is the child process.
*/
p->pid = getpid();
setup_child_process( j, p );
launch_process( p );
/*
launch_process _never_ returns...
*/
}
else
{
/*
This is the parent process. Store away
information on the child, and possibly fice
it control over the terminal.
*/
p->pid = pid;
set_child_group( j, p, 0 );
}
break;
}
}
if( p->type == INTERNAL_BUILTIN )
builtin_pop_io();
/*
Close the pipe the current process uses to read from the
previous process_t
*/
if( pipe_read.param1.pipe_fd[0] >= 0 )
exec_close( pipe_read.param1.pipe_fd[0] );
/*
Set up the pipe the next process uses to read from the
current process_t
*/
if( p->next )
pipe_read.param1.pipe_fd[0] = mypipe[0];
/*
If there is a next process in the pipeline, close the
output end of the current pipe (the surrent child
subprocess already has a copy of the pipe - this makes sure
we don't leak file descriptors either in the shell or in
the children).
*/
if( p->next )
{
exec_close(mypipe[1]);
}
}
/*
The keepalive process is no longer needed, so we terminate it
with extreme prejudice
*/
if( needs_keepalive )
{
kill( keepalive.pid, SIGKILL );
}
signal_unblock();
debug( 3, L"Job is constructed" );
j->io = io_remove( j->io, &pipe_read );
for( tmp = block_io; tmp; tmp=tmp->next )
j->io = io_remove( j->io, tmp );
job_set_flag( j, JOB_CONSTRUCTED, 1 );
if( !job_get_flag( j, JOB_FOREGROUND ) )
{
proc_last_bg_pid = j->pgid;
}
if( !exec_error )
{
job_continue (j, 0);
}
}
/// Return a definition of the specified function. Used by the functions builtin.
static wcstring functions_def(const wcstring &name) {
CHECK(!name.empty(), L""); //!OCLINT(multiple unary operator)
wcstring out;
wcstring desc, def;
function_get_desc(name, desc);
function_get_definition(name, def);
std::vector<std::shared_ptr<event_handler_t>> ev = event_get_function_handlers(name);
out.append(L"function ");
// Typically we prefer to specify the function name first, e.g. "function foo --description bar"
// But If the function name starts with a -, we'll need to output it after all the options.
bool defer_function_name = (name.at(0) == L'-');
if (!defer_function_name) {
out.append(escape_string(name, true));
}
if (!desc.empty()) {
wcstring esc_desc = escape_string(desc, true);
out.append(L" --description ");
out.append(esc_desc);
}
auto props = function_get_properties(name);
assert(props && "Should have function properties");
if (!props->shadow_scope) {
out.append(L" --no-scope-shadowing");
}
for (const auto &next : ev) {
const event_description_t &d = next->desc;
switch (d.type) {
case event_type_t::signal: {
append_format(out, L" --on-signal %ls", sig2wcs(d.param1.signal));
break;
}
case event_type_t::variable: {
append_format(out, L" --on-variable %ls", d.str_param1.c_str());
break;
}
case event_type_t::exit: {
if (d.param1.pid > 0)
append_format(out, L" --on-process-exit %d", d.param1.pid);
else
append_format(out, L" --on-job-exit %d", -d.param1.pid);
break;
}
case event_type_t::job_exit: {
const job_t *j = job_t::from_job_id(d.param1.job_id);
if (j) append_format(out, L" --on-job-exit %d", j->pgid);
break;
}
case event_type_t::generic: {
append_format(out, L" --on-event %ls", d.str_param1.c_str());
break;
}
case event_type_t::any:
default: {
DIE("unexpected next->type");
break;
}
}
}
const wcstring_list_t &named = props->named_arguments;
if (!named.empty()) {
append_format(out, L" --argument");
for (const auto &name : named) {
append_format(out, L" %ls", name.c_str());
}
}
// Output the function name if we deferred it.
if (defer_function_name) {
out.append(L" -- ");
out.append(escape_string(name, true));
}
// Output any inherited variables as `set -l` lines.
std::map<wcstring, env_var_t> inherit_vars = function_get_inherit_vars(name);
for (const auto &kv : inherit_vars) {
wcstring_list_t lst;
kv.second.to_list(lst);
// This forced tab is crummy, but we don't know what indentation style the function uses.
append_format(out, L"\n\tset -l %ls", kv.first.c_str());
for (const auto &arg : lst) {
wcstring earg = escape_string(arg, ESCAPE_ALL);
out.push_back(L' ');
out.append(earg);
}
}
// This forced tab is sort of crummy - not all functions start with a tab.
append_format(out, L"\n\t%ls", def.c_str());
// Append a newline before the 'end', unless there already is one there.
if (!string_suffixes_string(L"\n", def)) {
out.push_back(L'\n');
}
out.append(L"end\n");
return out;
}