int main(int argc , char ** argv) {
char * cwd = util_alloc_cwd( );
char * path1 = argv[1];
char * path2 = argv[2];
{
path_stack_type * path_stack = path_stack_alloc();
path_stack_push_cwd( path_stack );
if (path_stack_push( path_stack , "NotExist-1111"))
test_error_exit("Pushed unexisting path\n");
if (!path_stack_push( path_stack, path1 ))
test_error_exit("Failed to push:%s \n",path1 );
util_chdir( path2 );
if (util_is_cwd( path1 ))
test_error_exit("Failed to chdir(%s) \n",path2 );
{
if (path_stack_size( path_stack ) != 2)
test_error_exit("Wrong stack size");
if (strcmp( path1 , path_stack_peek( path_stack )) != 0)
test_error_exit("peek error");
}
path_stack_pop( path_stack );
printf("After pop: cwd:%s path1:%s \n",util_alloc_cwd() , path1);
if (!util_is_cwd( path1 ))
test_error_exit("path_stack_pop failed \n");
path_stack_pop( path_stack );
if (!util_is_cwd( cwd ))
test_error_exit("path_stack_pop failed \n");
if (path_stack_size( path_stack ) != 0)
test_error_exit("Wrong stack size");
if (!path_stack_push(path_stack , NULL))
test_error_exit("Hmmm - push(NULL) failed \n");
if (path_stack_size( path_stack ) != 1)
test_error_exit("Wrong stack size");
path_stack_pop( path_stack );
path_stack_free( path_stack);
}
exit(0);
}
int
imap4d_session_setup0 ()
{
real_homedir = mu_normalize_path (mu_strdup (auth_data->dir));
if (imap4d_check_home_dir (real_homedir, auth_data->uid, auth_data->gid))
return 1;
if (modify_homedir)
{
int rc;
mu_vartab_t vtab;
char *expr = mu_tilde_expansion (modify_homedir, "/", real_homedir);
mu_vartab_create (&vtab);
mu_vartab_define (vtab, "user", auth_data->name, 0);
mu_vartab_define (vtab, "home", real_homedir, 0);
rc = mu_vartab_expand (vtab, expr, &imap4d_homedir);
mu_vartab_destroy (&vtab);
free (expr);
if (rc)
{
free (real_homedir);
mu_diag_funcall (MU_DIAG_ERROR, "mu_vartab_expand",
modify_homedir, rc);
return 1;
}
}
else
imap4d_homedir = strdup (real_homedir);
if (strcmp (imap4d_homedir, real_homedir)
&& imap4d_check_home_dir (imap4d_homedir,
auth_data->uid, auth_data->gid))
{
free (imap4d_homedir);
free (real_homedir);
return 1;
}
if (auth_data->change_uid)
setuid (auth_data->uid);
util_chdir (imap4d_homedir);
namespace_init_session (imap4d_homedir);
mu_diag_output (MU_DIAG_INFO,
_("user `%s' logged in (source: %s)"), auth_data->name,
auth_data->source);
return 0;
}
static int dir_removebusy(const char *basepath)
{
char path[MAXSIZ_PATH];
sprintf (path,"%s/dir",basepath);
Rdir_spcent.verbose ("Creating directory %s\n",path);
/* #Specification: utstgen / removing a busy directory
A check is done that a busy directory can't be removed.
Here is the sequence we test. It must fail with EBUSY.
mkdir dir
cd dir
rm ../dir
*/
if (util_mkdir(path,0777,Rdir_removebusy,0)!=-1){
char curdir[MAXSIZ_PATH];
getcwd(curdir,sizeof(curdir)-1);
if (util_chdir(path,Rdir_removebusy,0)!=-1){
util_rmdir (path,Rdir_removebusy,EBUSY);
util_chdir (curdir,Rdir_removebusy,0);
}
util_rmdir (path,Rdir_removebusy,0);
}
return Rdir_removebusy.getnberr();
}
int main (int argc, char ** argv) {
text_splash();
init_debug(argv[0]);
printf("\n");
printf("Documentation : %s \n","http://ert.nr.no");
printf("git commit : %s \n",ert_version_get_git_commit( ));
printf("compile time : %s \n",ert_version_get_build_time( ));
printf("site config : %s \n", site_config_get_location());
enkf_main_install_SIGNALS(); /* Signals common to both tui and gui. */
signal(SIGINT, util_abort_signal); /* Control C - tui only. */
if (argc < 2) {
enkf_usage();
exit(1);
} else {
const char * model_config_file = argv[1];
stringlist_type * workflow_list = stringlist_alloc_new();
parse_workflows(argc, argv, workflow_list);
if (!(util_entry_readable(model_config_file) && util_is_file(model_config_file)))
util_exit("Can not read file %s - exiting \n", model_config_file);
{
char * abs_config = util_alloc_realpath(model_config_file);
printf("model config : %s \n\n", abs_config);
free(abs_config);
}
enkf_welcome(model_config_file);
{
res_config_type * res_config = res_config_alloc_load(model_config_file);
util_chdir( res_config_get_config_directory( res_config ));
{
enkf_main_type * enkf_main = enkf_main_alloc(res_config, true, true);
enkf_main_run_workflows(enkf_main, workflow_list);
enkf_tui_main_menu(enkf_main);
enkf_main_free(enkf_main);
res_config_free(res_config);
}
}
stringlist_free(workflow_list);
util_abort_free_version_info(); /* No f*****g leaks ... */
}
exit(0);
}
int main(int argc , char ** argv) {
#ifdef ERT_LINUX
const char * rel_path = "rel/path";
const char * rel_true = "rel/path/XXX";
const char * path_true1 = "rel/path/XXX";
#endif
test_work_area_type * work_area = test_work_area_alloc( "config_path_elm" );
const char * root = test_work_area_get_cwd( work_area );
char * abs_path = util_alloc_filename( root , "rel/path" , NULL);
char * abs_true = util_alloc_filename( root , "rel/path/XXX" , NULL);
char * path_true2 = util_alloc_filename( root , "rel/path/XXX" , NULL);
util_chdir( test_work_area_get_original_cwd( work_area ));
config_root_path_type * root_path = config_root_path_alloc( root );
{
config_path_elm_type * path_elm = config_path_elm_alloc( root_path , rel_path );
test_assert_string_equal( config_path_elm_get_relpath( path_elm ) , rel_path );
test_assert_string_equal( config_path_elm_get_abspath( path_elm ) , abs_path );
test_assert_string_equal( config_path_elm_alloc_relpath( path_elm , "XXX" ) , rel_true);
test_assert_string_equal( config_path_elm_alloc_abspath( path_elm , "XXX" ) , abs_true);
test_assert_string_equal( config_path_elm_alloc_path( path_elm , "XXX" ) , path_true2 );
config_path_elm_free( path_elm );
}
{
config_path_elm_type * path_elm = config_path_elm_alloc( root_path , abs_path );
test_assert_string_equal( config_path_elm_get_relpath( path_elm ) , rel_path );
test_assert_string_equal( config_path_elm_get_abspath( path_elm ) , abs_path );
test_assert_string_equal( config_path_elm_alloc_relpath( path_elm , "XXX" ) , rel_true);
test_assert_string_equal( config_path_elm_alloc_abspath( path_elm , "XXX" ) , abs_true);
test_assert_string_equal( config_path_elm_alloc_path( path_elm , "XXX" ) , path_true2 );
config_path_elm_free( path_elm );
}
config_root_path_free( root_path );
util_chdir( root );
root_path = config_root_path_alloc( NULL );
{
config_path_elm_type * path_elm = config_path_elm_alloc( root_path , rel_path );
test_assert_string_equal( config_path_elm_get_relpath( path_elm ) , rel_path );
test_assert_string_equal( config_path_elm_get_abspath( path_elm ) , abs_path );
test_assert_string_equal( config_path_elm_alloc_relpath( path_elm , "XXX" ) , rel_true);
test_assert_string_equal( config_path_elm_alloc_abspath( path_elm , "XXX" ) , abs_true);
test_assert_string_equal( config_path_elm_alloc_path( path_elm , "XXX" ) , path_true1 );
config_path_elm_free( path_elm );
}
exit(0);
}
pid_t util_fork_exec(const char * executable , int argc , const char ** argv ,
bool blocking , const char * target_file , const char * run_path ,
const char * stdin_file , const char * stdout_file , const char * stderr_file) {
const char ** __argv = NULL;
pid_t child_pid;
if (target_file != NULL && blocking == false)
util_abort("%s: When giving a target_file != NULL - you must use the blocking semantics. \n",__func__);
child_pid = fork();
if (child_pid == -1) {
fprintf(stderr,"Error: %s(%d) \n",strerror(errno) , errno);
util_abort("%s: fork() failed when trying to run external command:%s \n",__func__ , executable);
}
if (child_pid == 0) {
/* This is the child */
int iarg;
nice(19); /* Remote process is run with nice(19). */
if (run_path != NULL) {
if (util_chdir(run_path) != 0)
util_abort("%s: failed to change to directory:%s %s \n",__func__ , run_path , strerror(errno));
}
if (stdout_file != NULL)
__util_redirect(1 , stdout_file , O_WRONLY | O_TRUNC | O_CREAT);
if (stderr_file != NULL)
__util_redirect(2 , stderr_file , O_WRONLY | O_TRUNC | O_CREAT);
if (stdin_file != NULL)
__util_redirect(0 , stdin_file , O_RDONLY);
__argv = util_malloc((argc + 2) * sizeof * __argv );
__argv[0] = executable;
for (iarg = 0; iarg < argc; iarg++)
__argv[iarg+1] = argv[iarg];
__argv[argc + 1] = NULL;
/*
If executable is an absolute path, it is invoked directly,
otherwise PATH is used to locate the executable.
*/
execvp( executable , (char **) __argv);
/*
Exec should *NOT* return - if this code is executed
the exec??? function has indeed returned, and this is
an error.
*/
util_abort("%s: failed to execute external command: \'%s\': %s \n",__func__ , executable , strerror(errno));
} else {
/* Parent */
if (blocking) {
waitpid(child_pid , NULL , 0);
if (target_file != NULL)
if (!util_file_exists(target_file))
util_abort("%s: %s failed to produce target_file:%s aborting \n",__func__ , executable , target_file);
}
}
util_safe_free( __argv );
return child_pid;
}
