void cleanup_execute_dirs( StringList &list ) { char const *exec_path; list.rewind(); while( (exec_path = list.next()) ) { #if defined(WIN32) dynuser nobody_login; // remove all users matching this prefix nobody_login.cleanup_condor_users("condor-run-"); // get rid of everything in the execute directory Directory execute_dir(exec_path); execute_dir.Rewind(); while ( execute_dir.Next() ) { check_recovery_file( execute_dir.GetFullPath() ); } execute_dir.Remove_Entire_Directory(); #else // if we're using PrivSep, the Switchboard will only allow // us to remove subdirectories of EXECUTE - so we need to // list them and ask the Switchboard to delete each one // pair_strings_vector root_dirs = root_dir_list(); for (pair_strings_vector::const_iterator it=root_dirs.begin(); it != root_dirs.end(); ++it) { const char * exec_path_full = dirscat(it->second.c_str(), exec_path); if(exec_path_full) { dprintf(D_FULLDEBUG, "Looking at %s\n",exec_path_full); } Directory execute_dir( exec_path_full, PRIV_ROOT ); execute_dir.Rewind(); while ( execute_dir.Next() ) { check_recovery_file( execute_dir.GetFullPath() ); } if (privsep_enabled()) { execute_dir.Rewind(); while (execute_dir.Next()) { dprintf(D_FULLDEBUG, "Attempting to remove %s\n",execute_dir.GetFullPath()); privsep_remove_dir(execute_dir.GetFullPath()); } } else { execute_dir.Remove_Entire_Directory(); } delete [] exec_path_full; } #endif } }
void cleanup_execute_dir(int pid, char const *exec_path, bool remove_exec_subdir) { ASSERT( pid ); #if defined(WIN32) MyString buf; dynuser nobody_login; if ( nobody_login.reuse_accounts() == false ) { // before removing subdir, remove any nobody-user account associated // with this starter pid. this account might have been left around // if the starter did not clean up completely. //sprintf(buf,"condor-run-dir_%d",pid); buf.formatstr("condor-run-%d",pid); if ( nobody_login.deleteuser(buf.Value()) ) { dprintf(D_FULLDEBUG,"Removed account %s left by starter\n",buf.Value()); } } // now remove the subdirectory. NOTE: we only remove the // subdirectory _after_ removing the nobody account, because the // existence of the subdirectory persistantly tells us that the // account may still exist [in case the startd blows up as well]. buf.formatstr( "%s\\dir_%d", exec_path, pid ); check_recovery_file( buf.Value() ); Directory dir( buf.Value() ); dir.Remove_Full_Path(buf.Value()); #else /* UNIX */ MyString pid_dir; MyString pid_dir_path; // We're trying to delete a specific subdirectory, either // b/c a starter just exited and we might need to clean up // after it, or because we're in a recursive call. pid_dir.formatstr( "dir_%d", pid ); pid_dir_path.formatstr( "%s/%s", exec_path, pid_dir.Value() ); check_recovery_file( pid_dir_path.Value() ); // if we're using PrivSep, we won't have the permissions // needed to clean up - ask the Switchboard to do it; but // before we do that, use stat to see if there's anything // to clean up and save the Switchboard invocation if not if (privsep_enabled()) { struct stat stat_buf; if (stat(pid_dir_path.Value(), &stat_buf) == -1) { return; } if (!privsep_remove_dir(pid_dir_path.Value())) { dprintf(D_ALWAYS, "privsep_remove_dir failed to remove %s\n", pid_dir_path.Value()); } return; } // Instantiate a directory object pointing at the execute directory pair_strings_vector root_dirs = root_dir_list(); for (pair_strings_vector::const_iterator it=root_dirs.begin(); it != root_dirs.end(); ++it) { const char * exec_path_full = dirscat(it->second.c_str(), exec_path); Directory execute_dir( exec_path_full, PRIV_ROOT ); if (remove_exec_subdir) { // Remove entire subdirectory; used to remove // an encrypted execute directory execute_dir.Remove_Full_Path(exec_path_full); } else { // Look for specific pid_dir subdir if ( execute_dir.Find_Named_Entry( pid_dir.Value() ) ) { // Remove the execute directory execute_dir.Remove_Current_File(); } } delete [] exec_path_full; } #endif /* UNIX */ }
void MachAttributes::compute( amask_t how_much ) { // the startd doesn't normally call the init() method (bug?), // it just starts calling compute, so in order to gurantee that // init happens, we put check here to see if user settings have been initialized if ( ! m_user_settings_init) init_user_settings(); if( IS_STATIC(how_much) && IS_SHARED(how_much) ) { // Since we need real values for them as soon as a // MachAttributes object is instantiated, we handle number // of CPUs and physical memory in the constructor, not // here. -Derek Wright 2/5/99 // Arch, OpSys, FileSystemDomain and UidDomain. Note: // these will always return something, since config() will // insert values if we don't have them in the config file. if( m_arch ) { free( m_arch ); } m_arch = param( "ARCH" ); if( m_opsys ) { free( m_opsys ); } m_opsys = param( "OPSYS" ); m_opsysver = param_integer( "OPSYSVER", 0 ); if( m_opsys_and_ver ) { free( m_opsys_and_ver ); } m_opsys_and_ver = param( "OPSYSANDVER" ); m_opsys_major_ver = param_integer( "OPSYSMAJORVER", 0 ); if( m_opsys_name ) { free( m_opsys_name ); } m_opsys_name = param( "OPSYSNAME" ); if( m_opsys_long_name ) { free( m_opsys_long_name ); } m_opsys_long_name = param( "OPSYSLONGNAME" ); if( m_opsys_short_name ) { free( m_opsys_short_name ); } m_opsys_short_name = param( "OPSYSSHORTNAME" ); if( m_opsys_legacy ) { free( m_opsys_legacy ); } m_opsys_legacy = param( "OPSYSLEGACY" ); // temporary attributes for raw utsname info if( m_utsname_sysname ) { free( m_utsname_sysname ); } if( m_utsname_nodename ) { free( m_utsname_nodename ); } if( m_utsname_release ) { free( m_utsname_release ); } if( m_utsname_version ) { free( m_utsname_version ); } if( m_utsname_machine ) { free( m_utsname_machine ); } m_utsname_sysname = param( "UTSNAME_SYSNAME" ); m_utsname_nodename = param( "UTSNAME_NODENAME" ); m_utsname_release = param( "UTSNAME_RELEASE" ); m_utsname_version = param( "UTSNAME_VERSION" ); m_utsname_machine = param( "UTSNAME_MACHINE" ); if( m_uid_domain ) { free( m_uid_domain ); } m_uid_domain = param( "UID_DOMAIN" ); dprintf( D_FULLDEBUG, "%s = \"%s\"\n", ATTR_UID_DOMAIN, m_uid_domain ); if( m_filesystem_domain ) { free( m_filesystem_domain ); } m_filesystem_domain = param( "FILESYSTEM_DOMAIN" ); dprintf( D_FULLDEBUG, "%s = \"%s\"\n", ATTR_FILE_SYSTEM_DOMAIN, m_filesystem_domain ); m_idle_interval = param_integer( "IDLE_INTERVAL", -1 ); // checkpoint platform signature if (m_ckptpltfrm) { free(m_ckptpltfrm); } const char * ckptpltfrm = param( ATTR_CHECKPOINT_PLATFORM ); if( ckptpltfrm == NULL ) { ckptpltfrm = sysapi_ckptpltfrm(); } m_ckptpltfrm = strdup( ckptpltfrm ); pair_strings_vector root_dirs = root_dir_list(); std::stringstream result; unsigned int chroot_count = 0; for (pair_strings_vector::const_iterator it=root_dirs.begin(); it != root_dirs.end(); ++it, ++chroot_count) { if (chroot_count) { result << ", "; } result << it->first; } if (chroot_count > 1) { std::string result_str = result.str(); dprintf(D_FULLDEBUG, "Named chroots: %s\n", result_str.c_str() ); m_named_chroot = result_str; } } if( IS_UPDATE(how_much) && IS_SHARED(how_much) ) { m_virt_mem = sysapi_swap_space(); dprintf( D_FULLDEBUG, "Swap space: %lu\n", m_virt_mem ); #if defined(WIN32) credd_test(); #endif } if( IS_TIMEOUT(how_much) && IS_SHARED(how_much) ) { m_load = sysapi_load_avg(); sysapi_idle_time( &m_idle, &m_console_idle ); time_t my_timer; struct tm *the_time; time( &my_timer ); the_time = localtime(&my_timer); m_clock_min = (the_time->tm_hour * 60) + the_time->tm_min; m_clock_day = the_time->tm_wday; if (m_last_keypress < my_timer - m_idle) { if (m_idle_interval >= 0) { int duration = my_timer - m_last_keypress; if (duration > m_idle_interval) { if (m_seen_keypress) { dprintf(D_IDLE, "end idle interval of %d sec.\n", duration); } else { dprintf(D_IDLE, "first keyboard event %d sec. after startup\n", duration); } } } m_last_keypress = my_timer; m_seen_keypress = true; } #ifdef WIN32 update_all_WinPerf_results(); #endif AttribValue *pav = NULL; m_lst_dynamic.Rewind(); while ((pav = m_lst_dynamic.Next()) ) { if (pav) { #ifdef WIN32 if ( ! update_WinPerf_Value(pav)) pav->vtype = AttribValue_DataType_Max; // undefined vtype #else if (pav->pquery) { // insert code to update pav from pav->pquery } #endif } } } if( IS_TIMEOUT(how_much) && IS_SUMMED(how_much) ) { m_condor_load = resmgr->sum( &Resource::condor_load ); if( m_condor_load > m_load ) { m_condor_load = m_load; } } }