void execnt_unit_test()
{
#if !defined(NDEBUG)
/* vc6 preprocessor is broken, so assert with these strings gets
* confused. Use a table instead.
*/
typedef struct test { char* command; int result; } test;
test tests[] = {
{ "x", 0 },
{ "x\n ", 0 },
{ "x\ny", 1 },
{ "x\n\n y", 1 },
{ "echo x > foo.bar", 1 },
{ "echo x < foo.bar", 1 },
{ "echo x \">\" foo.bar", 0 },
{ "echo x \"<\" foo.bar", 0 },
{ "echo x \\\">\\\" foo.bar", 1 },
{ "echo x \\\"<\\\" foo.bar", 1 }
};
int i;
for ( i = 0; i < sizeof(tests)/sizeof(*tests); ++i)
{
assert( !can_spawn( tests[i].command ) == tests[i].result );
}
{
char* long_command = malloc(MAXLINE + 10);
assert( long_command != 0 );
memset( long_command, 'x', MAXLINE + 9 );
long_command[MAXLINE + 9] = 0;
assert( can_spawn( long_command ) == MAXLINE + 9);
free( long_command );
}
{
/* Work around vc6 bug; it doesn't like escaped string
* literals inside assert
*/
char** argv = string_to_args("\"g++\" -c -I\"Foobar\"");
char const expected[] = "-c -I\"Foobar\"";
assert(!strcmp(argv[0], "g++"));
assert(!strcmp(argv[1], expected));
free_argv(argv);
}
#endif
}
/* This reads a line from the proc file. This line will contain arguments to process. */
static void
xpad_app_read_from_proc_file (void)
{
gint client_fd, size;
gint argc;
gchar **argv;
gchar *args;
struct sockaddr_un client;
socklen_t client_len;
size_t bytes;
/* accept waiting connection */
client_len = sizeof (client);
client_fd = accept (server_fd, (struct sockaddr *) &client, &client_len);
if (client_fd == -1)
return;
/* get size of args */
bytes = read (client_fd, &size, sizeof (size));
if (bytes != sizeof(size))
goto close_client_fd;
/* alloc memory */
args = (gchar *) g_malloc (size);
if (!args)
goto close_client_fd;
/* read args */
bytes = read (client_fd, args, size);
if (bytes < size)
goto close_client_fd;
argc = string_to_args (args, &argv);
g_free (args);
/* here we redirect singleton->priv->output to the socket */
output = fdopen (client_fd, "w");
if (!process_remote_args (&argc, &argv, TRUE))
{
/* if there were no non-local arguments, insert --new as argument */
gint c = 2;
gchar **v = g_malloc (sizeof (gchar *) * c);
v[0] = PACKAGE;
v[1] = "--new";
process_remote_args (&c, &v, TRUE);
g_free (v);
}
/* restore standard singleton->priv->output */
fclose (output);
output = stdout;
g_strfreev (argv);
return;
close_client_fd:
close (client_fd);
}
void exec_cmd
(
char * command,
void (* func)( void * closure, int status, timing_info *, char * invoked_command, char * command_output ),
void * closure,
LIST * shell,
char * action,
char * target
)
{
int slot;
int raw_cmd = 0 ;
char * argv_static[ MAXARGC + 1 ]; /* +1 for NULL */
char * * argv = argv_static;
char * p;
char * command_orig = command;
/* Check to see if we need to hack around the line-length limitation. Look
* for a JAMSHELL setting of "%", indicating that the command should be
* invoked directly.
*/
if ( shell && !strcmp( shell->string, "%" ) && !list_next( shell ) )
{
raw_cmd = 1;
shell = 0;
}
/* Find a slot in the running commands table for this one. */
for ( slot = 0; slot < MAXJOBS; ++slot )
if ( !cmdtab[ slot ].pi.hProcess )
break;
if ( slot == MAXJOBS )
{
printf( "no slots for child!\n" );
exit( EXITBAD );
}
/* Compute the name of a temp batch file, for possible use. */
if ( !cmdtab[ slot ].tempfile_bat )
{
char const * tempdir = path_tmpdir();
DWORD procID = GetCurrentProcessId();
/* SVA - allocate 64 bytes extra just to be safe. */
cmdtab[ slot ].tempfile_bat = BJAM_MALLOC_ATOMIC( strlen( tempdir ) + 64 );
sprintf( cmdtab[ slot ].tempfile_bat, "%s\\jam%d-%02d.bat",
tempdir, procID, slot );
}
/* Trim leading, -ending- white space */
while ( *( command + 1 ) && isspace( *command ) )
++command;
/* Write to .BAT file unless the line would be too long and it meets the
* other spawnability criteria.
*/
if ( raw_cmd && ( can_spawn( command ) >= MAXLINE ) )
{
if ( DEBUG_EXECCMD )
printf("Executing raw command directly\n");
}
else
{
FILE * f = 0;
int tries = 0;
raw_cmd = 0;
/* Write command to bat file. For some reason this open can fail
* intermitently. But doing some retries works. Most likely this is due
* to a previously existing file of the same name that happens to be
* opened by an active virus scanner. Pointed out and fixed by Bronek
* Kozicki.
*/
for ( ; !f && ( tries < 4 ); ++tries )
{
f = fopen( cmdtab[ slot ].tempfile_bat, "w" );
if ( !f && ( tries < 4 ) ) Sleep( 250 );
}
if ( !f )
{
printf( "failed to write command file!\n" );
exit( EXITBAD );
}
fputs( command, f );
fclose( f );
command = cmdtab[ slot ].tempfile_bat;
if ( DEBUG_EXECCMD )
{
if ( shell )
printf( "using user-specified shell: %s", shell->string );
else
printf( "Executing through .bat file\n" );
}
}
/* Formulate argv; If shell was defined, be prepared for % and ! subs.
* Otherwise, use stock cmd.exe.
*/
if ( shell )
{
int i;
char jobno[ 4 ];
int gotpercent = 0;
sprintf( jobno, "%d", slot + 1 );
for ( i = 0; shell && ( i < MAXARGC ); ++i, shell = list_next( shell ) )
{
switch ( shell->string[ 0 ] )
{
case '%': argv[ i ] = command; ++gotpercent; break;
case '!': argv[ i ] = jobno; break;
default : argv[ i ] = shell->string;
}
if ( DEBUG_EXECCMD )
printf( "argv[%d] = '%s'\n", i, argv[ i ] );
}
if ( !gotpercent )
argv[ i++ ] = command;
argv[ i ] = 0;
}
else if ( raw_cmd )
{
argv = string_to_args( command );
}
else
{
argv[ 0 ] = "cmd.exe";
argv[ 1 ] = "/Q/C"; /* anything more is non-portable */
argv[ 2 ] = command;
argv[ 3 ] = 0;
}
/* Catch interrupts whenever commands are running. */
if ( !cmdsrunning++ )
istat = signal( SIGINT, onintr );
/* Start the command. */
{
SECURITY_ATTRIBUTES sa
= { sizeof( SECURITY_ATTRIBUTES ), 0, 0 };
SECURITY_DESCRIPTOR sd;
STARTUPINFO si
= { sizeof( STARTUPINFO ), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
string cmd;
/* Init the security data. */
InitializeSecurityDescriptor( &sd, SECURITY_DESCRIPTOR_REVISION );
SetSecurityDescriptorDacl( &sd, TRUE, NULL, FALSE );
sa.lpSecurityDescriptor = &sd;
sa.bInheritHandle = TRUE;
/* Create the stdout, which is also the merged out + err, pipe. */
if ( !CreatePipe( &cmdtab[ slot ].pipe_out[ 0 ],
&cmdtab[ slot ].pipe_out[ 1 ], &sa, 0 ) )
{
perror( "CreatePipe" );
exit( EXITBAD );
}
/* Create the stdout, which is also the merged out+err, pipe. */
if ( globs.pipe_action == 2 )
{
if ( !CreatePipe( &cmdtab[ slot ].pipe_err[ 0 ],
&cmdtab[ slot ].pipe_err[ 1 ], &sa, 0 ) )
{
perror( "CreatePipe" );
exit( EXITBAD );
}
}
/* Set handle inheritance off for the pipe ends the parent reads from. */
SetHandleInformation( cmdtab[ slot ].pipe_out[ 0 ], HANDLE_FLAG_INHERIT, 0 );
if ( globs.pipe_action == 2 )
SetHandleInformation( cmdtab[ slot ].pipe_err[ 0 ], HANDLE_FLAG_INHERIT, 0 );
/* Hide the child window, if any. */
si.dwFlags |= STARTF_USESHOWWINDOW;
si.wShowWindow = SW_HIDE;
/* Set the child outputs to the pipes. */
si.dwFlags |= STARTF_USESTDHANDLES;
si.hStdOutput = cmdtab[ slot ].pipe_out[ 1 ];
if ( globs.pipe_action == 2 )
{
/* Pipe stderr to the action error output. */
si.hStdError = cmdtab[ slot ].pipe_err[ 1 ];
}
else if ( globs.pipe_action == 1 )
{
/* Pipe stderr to the console error output. */
si.hStdError = GetStdHandle( STD_ERROR_HANDLE );
}
else
{
/* Pipe stderr to the action merged output. */
si.hStdError = cmdtab[ slot ].pipe_out[ 1 ];
}
/* Let the child inherit stdin, as some commands assume it's available. */
si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
/* Save the operation for exec_wait() to find. */
cmdtab[ slot ].func = func;
cmdtab[ slot ].closure = closure;
if ( action && target )
{
string_copy( &cmdtab[ slot ].action, action );
string_copy( &cmdtab[ slot ].target, target );
}
else
{
string_free( &cmdtab[ slot ].action );
string_new ( &cmdtab[ slot ].action );
string_free( &cmdtab[ slot ].target );
string_new ( &cmdtab[ slot ].target );
}
string_copy( &cmdtab[ slot ].command, command_orig );
/* Put together the command we run. */
{
char * * argp = argv;
string_new( &cmd );
string_copy( &cmd, *(argp++) );
while ( *argp )
{
string_push_back( &cmd, ' ' );
string_append( &cmd, *(argp++) );
}
}
/* Create output buffers. */
string_new( &cmdtab[ slot ].buffer_out );
string_new( &cmdtab[ slot ].buffer_err );
/* Run the command by creating a sub-process for it. */
if (
! CreateProcess(
NULL , /* application name */
cmd.value , /* command line */
NULL , /* process attributes */
NULL , /* thread attributes */
TRUE , /* inherit handles */
CREATE_NEW_PROCESS_GROUP, /* create flags */
NULL , /* env vars, null inherits env */
NULL , /* current dir, null is our */
/* current dir */
&si , /* startup info */
&cmdtab[ slot ].pi /* child process info, if created */
)
)
{
perror( "CreateProcess" );
exit( EXITBAD );
}
/* Clean up temporary stuff. */
string_free( &cmd );
}
/* Wait until we are under the limit of concurrent commands. Do not trust
* globs.jobs alone.
*/
while ( ( cmdsrunning >= MAXJOBS ) || ( cmdsrunning >= globs.jobs ) )
if ( !exec_wait() )
break;
if ( argv != argv_static )
free_argv( argv );
}
void
execcmd(
char *string,
void (*func)( void *closure, int status, timing_info* ),
void *closure,
LIST *shell )
{
int pid;
int slot;
int raw_cmd = 0 ;
char *argv_static[ MAXARGC + 1 ]; /* +1 for NULL */
char **argv = argv_static;
char *p;
/* Check to see if we need to hack around the line-length limitation. */
/* Look for a JAMSHELL setting of "%", indicating that the command
* should be invoked directly */
if ( shell && !strcmp(shell->string,"%") && !list_next(shell) )
{
raw_cmd = 1;
shell = 0;
}
if ( !is_win95_defined )
set_is_win95();
/* Find a slot in the running commands table for this one. */
if ( is_win95 )
{
/* only synchronous spans are supported on Windows 95/98 */
slot = 0;
}
else
{
for( slot = 0; slot < MAXJOBS; slot++ )
if( !cmdtab[ slot ].pid )
break;
}
if( slot == MAXJOBS )
{
printf( "no slots for child!\n" );
exit( EXITBAD );
}
if( !cmdtab[ slot ].tempfile )
{
const char *tempdir = path_tmpdir();
DWORD procID = GetCurrentProcessId();
/* SVA - allocate 64 other just to be safe */
cmdtab[ slot ].tempfile = malloc( strlen( tempdir ) + 64 );
if ( DEBUG_PROFILE )
profile_memory( strlen( tempdir ) + 64 );
sprintf( cmdtab[ slot ].tempfile, "%s\\jam%d-%02d.bat",
tempdir, procID, slot );
}
/* Trim leading, ending white space */
while( isspace( *string ) )
++string;
/* Write to .BAT file unless the line would be too long and it
* meets the other spawnability criteria.
*/
if( raw_cmd && can_spawn( string ) >= MAXLINE )
{
if( DEBUG_EXECCMD )
printf("Executing raw command directly\n");
}
else
{
FILE *f = 0;
int tries = 0;
raw_cmd = 0;
/* Write command to bat file. For some reason this open can
fails intermitently. But doing some retries works. Most likely
this is due to a previously existing file of the same name that
happens to be opened by an active virus scanner. Pointed out,
and fix by Bronek Kozicki. */
for (; !f && tries < 4; ++tries)
{
f = fopen( cmdtab[ slot ].tempfile, "w" );
if ( !f && tries < 4 ) Sleep( 250 );
}
if (!f)
{
printf( "failed to write command file!\n" );
exit( EXITBAD );
}
fputs( string, f );
fclose( f );
string = cmdtab[ slot ].tempfile;
if( DEBUG_EXECCMD )
{
if (shell)
printf("using user-specified shell: %s", shell->string);
else
printf("Executing through .bat file\n");
}
}
/* Forumulate argv */
/* If shell was defined, be prepared for % and ! subs. */
/* Otherwise, use stock /bin/sh (on unix) or cmd.exe (on NT). */
if( shell )
{
int i;
char jobno[4];
int gotpercent = 0;
sprintf( jobno, "%d", slot + 1 );
for( i = 0; shell && i < MAXARGC; i++, shell = list_next( shell ) )
{
switch( shell->string[0] )
{
case '%': argv[i] = string; gotpercent++; break;
case '!': argv[i] = jobno; break;
default: argv[i] = shell->string;
}
if( DEBUG_EXECCMD )
printf( "argv[%d] = '%s'\n", i, argv[i] );
}
if( !gotpercent )
argv[i++] = string;
argv[i] = 0;
}
else if (raw_cmd)
{
argv = string_to_args(string);
}
else
{
/* don't worry, this is ignored on Win95/98, see later.. */
argv[0] = "cmd.exe";
argv[1] = "/Q/C"; /* anything more is non-portable */
argv[2] = string;
argv[3] = 0;
}
/* Catch interrupts whenever commands are running. */
if( !cmdsrunning++ )
istat = signal( SIGINT, onintr );
/* Start the command */
/* on Win95, we only do a synchronous call */
if ( is_win95 )
{
static const char* hard_coded[] =
{
"del", "erase", "copy", "mkdir", "rmdir", "cls", "dir",
"ren", "rename", "move", 0
};
const char** keyword;
int len, spawn = 1;
int result;
timing_info time = {0,0};
for ( keyword = hard_coded; keyword[0]; keyword++ )
{
len = strlen( keyword[0] );
if ( strnicmp( string, keyword[0], len ) == 0 &&
!isalnum(string[len]) )
{
/* this is one of the hard coded symbols, use 'system' to run */
/* them.. except for "del"/"erase" */
if ( keyword - hard_coded < 2 )
result = process_del( string );
else
result = system( string );
spawn = 0;
break;
}
}
if (spawn)
{
char** args;
/* convert the string into an array of arguments */
/* we need to take care of double quotes !! */
args = string_to_args( string );
if ( args )
{
#if 0
char** arg;
fprintf( stderr, "%s: ", args[0] );
arg = args+1;
while ( arg[0] )
{
fprintf( stderr, " {%s}", arg[0] );
arg++;
}
fprintf( stderr, "\n" );
#endif
result = spawnvp( P_WAIT, args[0], args );
record_times(result, &time);
free_argv( args );
}
else
result = 1;
}
func( closure, result ? EXEC_CMD_FAIL : EXEC_CMD_OK, &time );
return;
}
if( DEBUG_EXECCMD )
{
char **argp = argv;
printf("Executing command");
while(*argp != 0)
{
printf(" [%s]", *argp);
argp++;
}
printf("\n");
}
/* the rest is for Windows NT only */
/* spawn doesn't like quotes around the command name */
if ( argv[0][0] == '"')
{
int l = strlen(argv[0]);
/* Clobber any closing quote, shortening the string by one
* element */
if (argv[0][l-1] == '"')
argv[0][l-1] = '\0';
/* Move everything *including* the original terminating zero
* back one place in memory, covering up the opening quote */
memmove(argv[0],argv[0]+1,l);
}
if( ( pid = spawnvp( P_NOWAIT, argv[0], argv ) ) == -1 )
{
perror( "spawn" );
exit( EXITBAD );
}
/* Save the operation for execwait() to find. */
cmdtab[ slot ].pid = pid;
cmdtab[ slot ].func = func;
cmdtab[ slot ].closure = closure;
/* Wait until we're under the limit of concurrent commands. */
/* Don't trust globs.jobs alone. */
while( cmdsrunning >= MAXJOBS || cmdsrunning >= globs.jobs )
if( !execwait() )
break;
if (argv != argv_static)
{
free_argv(argv);
}
}
void
execcmd(
char *string,
void (*func)( void *closure, int status ),
void *closure,
LIST *shell )
{
int pid;
int slot;
int raw_cmd = 0 ;
char *argv_static[ MAXARGC + 1 ]; /* +1 for NULL */
char **argv = argv_static;
char *p;
/* Check to see if we need to hack around the line-length limitation. */
/* Look for a JAMSHELL setting of "%", indicating that the command
* should be invoked directly */
if ( shell && !strcmp(shell->string,"%") && !list_next(shell) )
{
raw_cmd = 1;
shell = 0;
}
if ( !is_win95_defined )
set_is_win95();
/* Find a slot in the running commands table for this one. */
if ( is_win95 )
{
/* only synchronous spans are supported on Windows 95/98 */
slot = 0;
}
else
{
for( slot = 0; slot < MAXJOBS; slot++ )
if( !cmdtab[ slot ].pid )
break;
}
if( slot == MAXJOBS )
{
printf( "no slots for child!\n" );
exit( EXITBAD );
}
if( !cmdtab[ slot ].tempfile )
{
const char *tempdir;
DWORD procID;
tempdir = getTempDir();
// SVA - allocate 64 other just to be safe
cmdtab[ slot ].tempfile = malloc( strlen( tempdir ) + 64 );
procID = GetCurrentProcessId();
sprintf( cmdtab[ slot ].tempfile, "%s\\jam%d-%02d.bat",
tempdir, procID, slot );
}
/* Trim leading, ending white space */
while( isspace( *string ) )
++string;
/* If multi line, or too long, or JAMSHELL is set, write to bat file. */
/* Otherwise, exec directly. */
/* Frankly, if it is a single long line I don't think the */
/* command interpreter will do any better -- it will fail. */
if( shell || !raw_cmd // && use_bat_file( string )
)
{
FILE *f;
/* Write command to bat file. */
f = fopen( cmdtab[ slot ].tempfile, "w" );
fputs( string, f );
fclose( f );
string = cmdtab[ slot ].tempfile;
if( DEBUG_EXECCMD )
{
if (shell)
printf("using user-specified shell: %s", shell->string);
else
printf("Executing through .bat file\n");
}
}
else if( DEBUG_EXECCMD )
{
printf("Executing raw command directly\n");
}
/* Forumulate argv */
/* If shell was defined, be prepared for % and ! subs. */
/* Otherwise, use stock /bin/sh (on unix) or cmd.exe (on NT). */
if( shell )
{
int i;
char jobno[4];
int gotpercent = 0;
sprintf( jobno, "%d", slot + 1 );
for( i = 0; shell && i < MAXARGC; i++, shell = list_next( shell ) )
{
switch( shell->string[0] )
{
case '%':
argv[i] = string;
gotpercent++;
break;
case '!':
argv[i] = jobno;
break;
default:
argv[i] = shell->string;
}
if( DEBUG_EXECCMD )
printf( "argv[%d] = '%s'\n", i, argv[i] );
}
if( !gotpercent )
argv[i++] = string;
argv[i] = 0;
}
else if (raw_cmd)
{
int ignored;
argv = string_to_args(string, &ignored);
}
else
{
/* don't worry, this is ignored on Win95/98, see later.. */
argv[0] = "cmd.exe";
argv[1] = "/Q/C"; /* anything more is non-portable */
argv[2] = string;
argv[3] = 0;
}
/* Catch interrupts whenever commands are running. */
if( !cmdsrunning++ )
istat = signal( SIGINT, onintr );
/* Start the command */
/* on Win95, we only do a synchronous call */
if ( is_win95 )
{
static const char* hard_coded[] =
{
"del", "erase", "copy", "mkdir", "rmdir", "cls", "dir",
"ren", "rename", "move", 0
};
const char** keyword;
int len, spawn = 1;
int result;
for ( keyword = hard_coded; keyword[0]; keyword++ )
{
len = strlen( keyword[0] );
if ( strnicmp( string, keyword[0], len ) == 0 &&
!isalnum(string[len]) )
{
/* this is one of the hard coded symbols, use 'system' to run */
/* them.. except for "del"/"erase" */
if ( keyword - hard_coded < 2 )
result = process_del( string );
else
result = system( string );
spawn = 0;
break;
}
}
if (spawn)
{
char** args;
int num_args;
/* convert the string into an array of arguments */
/* we need to take care of double quotes !! */
args = string_to_args( string, &num_args );
if ( args )
{
#if 0
char** arg;
fprintf( stderr, "%s: ", args[0] );
arg = args+1;
while ( arg[0] )
{
fprintf( stderr, " {%s}", arg[0] );
arg++;
}
fprintf( stderr, "\n" );
#endif
result = spawnvp( P_WAIT, args[0], args );
free_args( args );
}
else
result = 1;
}
func( closure, result ? EXEC_CMD_FAIL : EXEC_CMD_OK );
return;
}
if( DEBUG_EXECCMD )
{
char **argp = argv;
printf("Executing command");
while(*argp != 0)
{
printf(" [%s]", *argp);
argp++;
}
printf("\n");
}
/* the rest is for Windows NT only */
/* spawn doesn't like quotes aroudn the command name */
if ( argv[0][0] == '"')
{
int l = strlen(argv[0]);
if (argv[0][l-1] == '"') argv[0][l-1] = '\0';
strcpy(argv[0],argv[0]+1);
}
if( ( pid = spawnvp( P_NOWAIT, argv[0], argv ) ) == -1 )
{
perror( "spawn" );
exit( EXITBAD );
}
/* Save the operation for execwait() to find. */
cmdtab[ slot ].pid = pid;
cmdtab[ slot ].func = func;
cmdtab[ slot ].closure = closure;
/* Wait until we're under the limit of concurrent commands. */
/* Don't trust globs.jobs alone. */
while( cmdsrunning >= MAXJOBS || cmdsrunning >= globs.jobs )
if( !execwait() )
break;
if (argv != argv_static)
{
free_args(argv);
}
}