uid_t * util_alloc_file_users( const char * filename , int * __num_users) {
const char * lsof_executable = "/usr/sbin/lsof";
int buffer_size = 8;
int num_users = 0;
uid_t * users = util_malloc( sizeof * users * buffer_size );
char * tmp_file = util_alloc_tmp_file("/tmp" , "lsof" , false);
util_fork_exec(lsof_executable , 2 , (const char *[2]) {"-F" , filename }, true , NULL , NULL , NULL , tmp_file , NULL);
static bool util_addr2line_lookup__(const void * bt_addr , char ** func_name , char ** file_name , int * line_nr, bool subtract_base_adress) {
*func_name = NULL; // If dladdr() succeeds, but addr2line fails the func_name pointer will be set, but the function will return false anyway.
*file_name = NULL;
*line_nr = 0;
{
bool address_found = false;
Dl_info dl_info;
#if defined(__APPLE__)
return false;
#else
if (dladdr(bt_addr , &dl_info)) {
const char * executable = dl_info.dli_fname;
*func_name = util_alloc_string_copy( dl_info.dli_sname );
if (util_file_exists( executable )) {
char *stdout_file = util_alloc_tmp_file("/tmp" , "addr2line" , true);
/* 1: Run addr2line application */
{
char ** argv = util_calloc(3 , sizeof * argv );
argv[0] = util_alloc_string_copy("--functions");
argv[1] = util_alloc_sprintf("--exe=%s" , executable );
{
char * rel_address = (char *) bt_addr;
if (subtract_base_adress)
rel_address -= (size_t) dl_info.dli_fbase;
argv[2] = util_alloc_sprintf("%p" , (void *) rel_address);
}
util_spawn_blocking("addr2line", 3, (const char **) argv, stdout_file, NULL);
util_free_stringlist(argv , 3);
}
/* 2: Parse stdout output */
{
bool at_eof;
FILE * stream = util_fopen(stdout_file , "r");
char * tmp_fname = util_fscanf_alloc_line(stream , &at_eof);
if (strcmp(tmp_fname , UNDEFINED_FUNCTION) != 0) {
char * stdout_file_name = util_fscanf_alloc_line(stream , &at_eof);
char * line_string = NULL;
util_binary_split_string( stdout_file_name , ":" , false , file_name , &line_string);
if (line_string && util_sscanf_int( line_string , line_nr))
address_found = true;
free( stdout_file_name );
util_safe_free( line_string );
}
free( tmp_fname );
fclose(stream);
}
util_unlink_existing(stdout_file);
free( stdout_file );
}
}
return address_found;
#endif
}
}
void subst_list_filter_file(const subst_list_type * subst_list , const char * src_file , const char * target_file) {
char * backup_file = NULL;
buffer_type * buffer = buffer_fread_alloc( src_file );
buffer_fseek( buffer , 0 , SEEK_END ); /* Ensure that the buffer is a \0 terminated string. */
buffer_fwrite_char( buffer , '\0');
/*****************************************************************/
/* Backup file ?? */
if (util_same_file(src_file , target_file)) {
char * backup_prefix = util_alloc_sprintf("%s-%s" , src_file , __func__);
backup_file = util_alloc_tmp_file("/tmp" , backup_prefix , false);
free(backup_prefix);
}
/* Writing backup file */
if (backup_file != NULL) {
FILE * stream = util_fopen(backup_file , "w");
buffer_stream_fwrite_n( buffer , 0 , -1 , stream ); /* -1: Do not write the trailing \0. */
fclose(stream);
}
/* Doing the actual update */
subst_list_update_buffer(subst_list , buffer);
/* Writing updated file */
{
FILE * stream = util_mkdir_fopen(target_file , "w");
buffer_stream_fwrite_n( buffer , 0 , -1 , stream ); /* -1: Do not write the trailing \0. */
fclose(stream);
}
/* OK - all went hunka dory - unlink the backup file and leave the building. */
if (backup_file != NULL) {
remove( backup_file );
free( backup_file );
}
free(buffer);
}
static void util_addr2line_lookup(const char * executable , const char * bt_symbol , char ** func_name , char ** file_line) {
char *tmp_file = util_alloc_tmp_file("/tmp" , "addr2line" , true);
char * adress;
{
int start_pos = 0;
int end_pos;
while ( bt_symbol[start_pos] != '[')
start_pos++;
end_pos = start_pos;
while ( bt_symbol[end_pos] != ']')
end_pos++;
adress = util_alloc_substring_copy( bt_symbol , start_pos + 1 , end_pos - start_pos - 1 );
}
{
char ** argv;
argv = util_calloc(3 , sizeof * argv );
argv[0] = util_alloc_string_copy("--functions");
argv[1] = util_alloc_sprintf("--exe=%s" , executable);
argv[2] = util_alloc_string_copy(adress);
util_fork_exec("addr2line" , 3 , (const char **) argv , true , NULL , NULL , NULL , tmp_file , NULL);
util_free_stringlist(argv , 3);
}
{
bool at_eof;
FILE * stream = util_fopen(tmp_file , "r");
*func_name = util_fscanf_alloc_line(stream , &at_eof);
*file_line = util_fscanf_alloc_line(stream , &at_eof);
fclose(stream);
}
util_unlink_existing(tmp_file);
free(adress);
free(tmp_file);
}
bool workflow_try_compile( workflow_type * script , const subst_list_type * context) {
if (util_file_exists( script->src_file )) {
const char * src_file = script->src_file;
char * tmp_file = NULL;
bool update = false;
if (context != NULL) {
tmp_file = util_alloc_tmp_file("/tmp" , "ert-workflow" , false );
update = subst_list_filter_file( context , script->src_file , tmp_file );
if (update) {
script->compiled = false;
src_file = tmp_file;
} else {
remove( tmp_file );
free( tmp_file );
tmp_file = NULL;
}
}
{
time_t src_mtime = util_file_mtime( script->src_file );
if (script->compiled) {
if (util_difftime_seconds( src_mtime , script->compile_time ) > 0 )
return true;
else {
// Script has been compiled succesfully, but then changed afterwards.
// We try to recompile; if that fails we are left with 'nothing'.
}
}
}
{
// Try to compile
config_parser_type * config_compiler = workflow_joblist_get_compiler( script->joblist );
script->compiled = false;
workflow_clear( script );
{
config_content_type * content = config_parse( config_compiler , src_file , WORKFLOW_COMMENT_STRING , WORKFLOW_INCLUDE , NULL , CONFIG_UNRECOGNIZED_ERROR , true );
if (config_content_is_valid( content )) {
int cmd_line;
for (cmd_line = 0; cmd_line < config_content_get_size(content); cmd_line++) {
const config_content_node_type * node = config_content_iget_node( content , cmd_line );
const char * jobname = config_content_node_get_kw( node );
const workflow_job_type * job = workflow_joblist_get_job( script->joblist , jobname );
cmd_type * cmd = cmd_alloc( job , config_content_node_get_stringlist( node ));
workflow_add_cmd( script , cmd );
}
script->compiled = true;
} else
workflow_store_error( script , config_content_get_errors( content ));
config_content_free( content );
}
}
if (tmp_file != NULL) {
if (script->compiled)
remove( tmp_file );
free( tmp_file );
}
}
// It is legal to remove the script after successfull compilation but
// then the context will not be applied at subsequent invocations.
return script->compiled;
}
