bool pal::get_default_servicing_directory(string_t* recv) { recv->clear(); pal::string_t ext; if (pal::getenv(_X("CORE_SERVICING"), &ext) && pal::realpath(&ext)) { // We should have the path in ext. trace::info(_X("Realpath CORE_SERVICING [%s]"), ext.c_str()); } if (!pal::directory_exists(ext)) { trace::info(_X("Directory core servicing at [%s] was not specified or found"), ext.c_str()); ext.clear(); append_path(&ext, _X("opt")); append_path(&ext, _X("coreservicing")); if (!pal::directory_exists(ext)) { trace::info(_X("Fallback directory core servicing at [%s] was not found"), ext.c_str()); return false; } } if (access(ext.c_str(), R_OK) != 0) { trace::info(_X("Directory core servicing at [%s] was not ACL-ed properly"), ext.c_str()); } recv->assign(ext); trace::info(_X("Using core servicing at [%s]"), ext.c_str()); return true; }
bool hostpolicy_exists_in_svc(pal::string_t* resolved_dir) { pal::string_t svc_dir; if (!pal::getenv(_X("DOTNET_SERVICING"), &svc_dir)) { trace::verbose(_X("Servicing root doesn't exist")); return false; } pal::string_t rel_dir = _STRINGIFY(HOST_POLICY_PKG_REL_DIR); if (DIR_SEPARATOR != '/') { replace_char(&rel_dir, '/', DIR_SEPARATOR); } pal::string_t path = svc_dir; append_path(&path, _STRINGIFY(HOST_POLICY_PKG_NAME)); append_path(&path, _STRINGIFY(HOST_POLICY_PKG_VER)); append_path(&path, rel_dir.c_str()); append_path(&path, LIBHOSTPOLICY_NAME); if (!pal::realpath(&path)) { trace::verbose(_X("Servicing root ::realpath(%s) doesn't exist"), path.c_str()); return false; } if (library_exists_in_dir(path, LIBHOSTPOLICY_NAME, nullptr)) { resolved_dir->assign(path); trace::verbose(_X("[%s] exists in servicing [%s]"), LIBHOSTPOLICY_NAME, path.c_str()); return true; } trace::verbose(_X("[%s] doesn't exist in servicing [%s]"), LIBHOSTPOLICY_NAME, path.c_str()); return false; }
/** * Given a directory and a version, find if the package relative * dir under the given directory contains hostpolicy.dll */ bool to_hostpolicy_package_dir(const pal::string_t& dir, const pal::string_t& version, pal::string_t* candidate) { assert(!version.empty()); candidate->clear(); // Ensure the relative dir contains platform directory separators. pal::string_t rel_dir = _STRINGIFY(HOST_POLICY_PKG_REL_DIR); if (DIR_SEPARATOR != '/') { replace_char(&rel_dir, '/', DIR_SEPARATOR); } // Construct the path to directory containing hostpolicy. pal::string_t path = dir; append_path(&path, _STRINGIFY(HOST_POLICY_PKG_NAME)); // package name append_path(&path, version.c_str()); // package version append_path(&path, rel_dir.c_str()); // relative dir containing hostpolicy library // Check if "path" contains the required library. if (!library_exists_in_dir(path, LIBHOSTPOLICY_NAME, nullptr)) { trace::verbose(_X("Did not find %s in directory %s"), LIBHOSTPOLICY_NAME, path.c_str()); return false; } // "path" contains the directory containing hostpolicy library. *candidate = path; trace::verbose(_X("Found %s in directory %s"), LIBHOSTPOLICY_NAME, path.c_str()); return true; }
bool deps_resolver_t::try_roll_forward(const deps_entry_t& entry, const pal::string_t& probe_dir, bool patch_roll_fwd, bool prerelease_roll_fwd, pal::string_t* candidate) { trace::verbose(_X("Attempting a roll forward for [%s/%s/%s] in [%s]"), entry.library_name.c_str(), entry.library_version.c_str(), entry.relative_path.c_str(), probe_dir.c_str()); const pal::string_t& lib_ver = entry.library_version; fx_ver_t cur_ver(-1, -1, -1); if (!fx_ver_t::parse(lib_ver, &cur_ver, false)) { trace::verbose(_X("No roll forward as specified version [%s] could not be parsed"), lib_ver.c_str()); return false; } pal::string_t path = probe_dir; append_path(&path, entry.library_name.c_str()); pal::string_t max_str = lib_ver; if (cur_ver.is_prerelease() && prerelease_roll_fwd) { pal::string_t maj_min_pat_star = cur_ver.prerelease_glob(); pal::string_t cache_key = path; append_path(&cache_key, maj_min_pat_star.c_str()); if (m_prerelease_roll_forward_cache.count(cache_key)) { max_str = m_prerelease_roll_forward_cache[cache_key]; trace::verbose(_X("Found cached roll forward version [%s] -> [%s]"), lib_ver.c_str(), max_str.c_str()); } else { try_prerelease_roll_forward_in_dir(path, cur_ver, &max_str); m_prerelease_roll_forward_cache[cache_key] = max_str; } } if (!cur_ver.is_prerelease() && patch_roll_fwd) { // Extract glob string of the form: 1.0.* from the version 1.0.0-prerelease-00001. pal::string_t maj_min_star = cur_ver.patch_glob(); pal::string_t cache_key = path; append_path(&cache_key, maj_min_star.c_str()); if (m_patch_roll_forward_cache.count(cache_key)) { max_str = m_patch_roll_forward_cache[cache_key]; trace::verbose(_X("Found cached roll forward version [%s] -> [%s]"), lib_ver.c_str(), max_str.c_str()); } else { try_patch_roll_forward_in_dir(path, cur_ver, &max_str); m_patch_roll_forward_cache[cache_key] = max_str; } } append_path(&path, max_str.c_str()); return entry.to_rel_path(path, candidate); }
bool pal::find_coreclr(pal::string_t* recv) { pal::string_t candidate; // Try %LocalAppData%\dotnet if (pal::getenv(_X("LocalAppData"), &candidate)) { append_path(&candidate, _X("dotnet")); append_path(&candidate, _X("runtime")); append_path(&candidate, _X("coreclr")); if (coreclr_exists_in_dir(candidate)) { recv->assign(candidate); return true; } } // Try %ProgramFiles%. Note this works for both x86 and x64/wow64 as per: // https://msdn.microsoft.com/en-us/library/windows/desktop/aa384274(v=vs.85).aspx // candidate.clear(); getenv clears it. if (pal::getenv(_X("ProgramFiles"), &candidate)) { append_path(&candidate, _X("dotnet")); append_path(&candidate, _X("bin")); if (coreclr_exists_in_dir(candidate)) { recv->assign(candidate); return true; } } return false; }
void tpafile::write_tpa_list(pal::string_t& output) { std::set<pal::string_t> items; for (auto entry : m_entries) { if (pal::strcmp(entry.asset_type.c_str(), _X("runtime")) == 0 && items.find(entry.asset_name) == items.end()) { // Resolve the full path for (auto search_path : m_package_search_paths) { pal::string_t candidate; candidate.reserve(search_path.length() + entry.library_name.length() + entry.library_version.length() + entry.relative_path.length() + 3); candidate.append(search_path); append_path(candidate, entry.library_name.c_str()); append_path(candidate, entry.library_version.c_str()); append_path(candidate, entry.relative_path.c_str()); if (pal::file_exists(candidate)) { trace::verbose(_X("adding tpa entry: %s"), candidate.c_str()); output.append(candidate); output.push_back(PATH_SEPARATOR); items.insert(entry.asset_name); break; } } } } }
bool pal::get_default_breadcrumb_store(string_t* recv) { recv->clear(); pal::string_t ext; if (pal::getenv(_X("CORE_BREADCRUMBS"), &ext) && pal::realpath(&ext)) { // We should have the path in ext. trace::info(_X("Realpath CORE_BREADCRUMBS [%s]"), ext.c_str()); } if (!pal::directory_exists(ext)) { trace::info(_X("Directory core breadcrumbs [%s] was not specified or found"), ext.c_str()); ext.clear(); append_path(&ext, _X("opt")); append_path(&ext, _X("corebreadcrumbs")); if (!pal::directory_exists(ext)) { trace::info(_X("Fallback directory core breadcrumbs at [%s] was not found"), ext.c_str()); return false; } } if (access(ext.c_str(), (R_OK | W_OK)) != 0) { trace::info(_X("Breadcrumb store [%s] is not ACL-ed with rw-"), ext.c_str()); } recv->assign(ext); return true; }
void deps_resolver_t::setup_probe_config( const corehost_init_t* init, const runtime_config_t& config, const arguments_t& args) { if (pal::directory_exists(args.dotnet_extensions)) { pal::string_t ext_ni = args.dotnet_extensions; append_path(&ext_ni, get_arch()); if (pal::directory_exists(ext_ni)) { // Servicing NI probe. m_probes.push_back(probe_config_t::svc_ni(ext_ni, config.get_patch_roll_fwd(), config.get_prerelease_roll_fwd())); } // Servicing normal probe. m_probes.push_back(probe_config_t::svc(args.dotnet_extensions, config.get_patch_roll_fwd(), config.get_prerelease_roll_fwd())); } if (pal::directory_exists(args.dotnet_packages_cache)) { pal::string_t ni_packages_cache = args.dotnet_packages_cache; append_path(&ni_packages_cache, get_arch()); if (pal::directory_exists(ni_packages_cache)) { // Packages cache NI probe m_probes.push_back(probe_config_t::cache_ni(ni_packages_cache)); } // Packages cache probe m_probes.push_back(probe_config_t::cache(args.dotnet_packages_cache)); } if (pal::directory_exists(m_fx_dir)) { // FX probe m_probes.push_back(probe_config_t::fx(m_fx_dir, m_fx_deps.get())); } for (const auto& probe : m_additional_probes) { // Additional paths bool patch_roll_fwd = config.get_patch_roll_fwd(); bool prerelease_roll_fwd = config.get_prerelease_roll_fwd(); m_probes.push_back(probe_config_t::additional(probe, patch_roll_fwd, prerelease_roll_fwd)); } if (trace::is_enabled()) { trace::verbose(_X("-- Listing probe configurations...")); for (const auto& pc : m_probes) { pc.print(); } } }
void deps_resolver_t::setup_probe_config( const hostpolicy_init_t& init, const arguments_t& args) { if (pal::directory_exists(args.core_servicing)) { pal::string_t ext_ni = args.core_servicing; append_path(&ext_ni, get_arch()); if (pal::directory_exists(ext_ni)) { // Servicing NI probe. m_probes.push_back(probe_config_t::svc_ni(ext_ni, false, false)); } // Servicing normal probe. pal::string_t ext_pkgs = args.core_servicing; append_path(&ext_pkgs, _X("pkgs")); m_probes.push_back(probe_config_t::svc(ext_pkgs, false, false)); } if (pal::directory_exists(args.dotnet_packages_cache)) { pal::string_t ni_packages_cache = args.dotnet_packages_cache; append_path(&ni_packages_cache, get_arch()); if (pal::directory_exists(ni_packages_cache)) { // Packages cache NI probe m_probes.push_back(probe_config_t::cache_ni(ni_packages_cache)); } // Packages cache probe m_probes.push_back(probe_config_t::cache(args.dotnet_packages_cache)); } if (pal::directory_exists(m_fx_dir)) { // FX probe m_probes.push_back(probe_config_t::fx(m_fx_dir, m_fx_deps.get())); } for (const auto& probe : m_additional_probes) { // Additional paths m_probes.push_back(probe_config_t::additional(probe)); } if (trace::is_enabled()) { trace::verbose(_X("-- Listing probe configurations...")); for (const auto& pc : m_probes) { pc.print(); } } }
bool pal::get_default_packages_directory(pal::string_t* recv) { recv->clear(); if (!pal::getenv("HOME", recv)) { return false; } append_path(&*recv, _X(".nuget")); append_path(&*recv, _X("packages")); return true; }
// Parse commandline settings static inline void parse_cli_settings(int argc, const char *argv[]) { config.paths = CFArrayCreateMutable(NULL, (CFIndex)0, &kCFTypeArrayCallBacks); for (int i = 1; i < argc; i++) { if (strcmp(argv[i], "--since-when") == 0) { config.sinceWhen = strtoull(argv[++i], NULL, 0); } else if (strcmp(argv[i], "--latency") == 0) { config.latency = strtod(argv[++i], NULL); } else if (strcmp(argv[i], "--no-defer") == 0) { config.flags |= kFSEventStreamCreateFlagNoDefer; } else if (strcmp(argv[i], "--watch-root") == 0) { config.flags |= kFSEventStreamCreateFlagWatchRoot; } else if (strcmp(argv[i], "--ignore-self") == 0) { #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1060 config.flags |= kFSEventStreamCreateFlagIgnoreSelf; #else fprintf(stderr, "MacOSX10.6.sdk is required for --ignore-self\n"); #endif } else { append_path(argv[i]); } } if (CFArrayGetCount(config.paths) == 0) { append_path("."); } #ifdef DEBUG fprintf(stderr, "config.sinceWhen %llu\n", config.sinceWhen); fprintf(stderr, "config.latency %f\n", config.latency); fprintf(stderr, "config.flags %#.8x\n", config.flags); fprintf(stderr, "config.paths\n"); long numpaths = CFArrayGetCount(config.paths); for (long i = 0; i < numpaths; i++) { char path[PATH_MAX]; CFStringGetCString(CFArrayGetValueAtIndex(config.paths, i), path, PATH_MAX, kCFStringEncodingUTF8); fprintf(stderr, " %s\n", path); } fprintf(stderr, "\n"); fflush(stderr); #endif }
bool servicing_index_t::find_redirection( const pal::string_t& package_name, const pal::string_t& package_version, const pal::string_t& package_relative, pal::string_t* redirection) { ensure_redirections(); redirection->clear(); if (m_redirections.empty()) { return false; } pal::stringstream_t stream; stream << package_name << _X("|") << package_version << _X("|") << package_relative; auto iter = m_redirections.find(stream.str()); if (iter != m_redirections.end()) { pal::string_t ni_root = m_patch_root; append_path(&ni_root, get_arch()); // First prefer the architecture specific NI image. pal::string_t paths[2] = { ni_root, m_patch_root }; for (pal::string_t& full_path : paths) { append_path(&full_path, iter->second.c_str()); if (pal::file_exists(full_path)) { *redirection = full_path; if (trace::is_enabled()) { pal::string_t stream_str = stream.str(); trace::verbose(_X("Servicing %s with %s"), stream_str.c_str(), redirection->c_str()); } return true; } trace::verbose(_X("Serviced file %s doesn't exist"), full_path.c_str()); } } if (trace::is_enabled()) { auto stream_str = stream.str(); trace::verbose(_X("Entry %s not serviced or file doesn't exist"), stream_str.c_str()); } return false; }
void get_runtime_config_paths(const pal::string_t& path, const pal::string_t& name, pal::string_t* cfg, pal::string_t* dev_cfg) { auto json_path = path; auto json_name = name + _X(".runtimeconfig.json"); append_path(&json_path, json_name.c_str()); cfg->assign(json_path); auto dev_json_path = path; auto dev_json_name = name + _X(".runtimeconfig.dev.json"); append_path(&dev_json_path, dev_json_name.c_str()); dev_cfg->assign(dev_json_path); trace::verbose(_X("Runtime config is cfg=%s dev=%s"), json_path.c_str(), dev_json_path.c_str()); }
pal::string_t fx_muxer_t::resolve_fx_dir(const pal::string_t& muxer_dir, runtime_config_t* runtime) { trace::verbose(_X("--- Resolving FX directory from muxer dir [%s]"), muxer_dir.c_str()); const auto fx_name = runtime->get_fx_name(); const auto fx_ver = runtime->get_fx_version(); const auto roll_fwd = runtime->get_fx_roll_fwd(); fx_ver_t specified(-1, -1, -1); if (!fx_ver_t::parse(fx_ver, &specified, false)) { trace::error(_X("The specified runtimeconfig.json version [%s] could not be parsed"), fx_ver.c_str()); return pal::string_t(); } auto fx_dir = muxer_dir; append_path(&fx_dir, _X("shared")); append_path(&fx_dir, fx_name.c_str()); // If not roll forward or if pre-release, just return. if (!roll_fwd || specified.is_prerelease()) { trace::verbose(_X("Did not roll forward because rollfwd=%d and [%s] is prerelease=%d"), roll_fwd, fx_ver.c_str(), specified.is_prerelease()); append_path(&fx_dir, fx_ver.c_str()); } else { trace::verbose(_X("Attempting production FX roll forward starting from [%s]"), fx_ver.c_str()); std::vector<pal::string_t> list; pal::readdir(fx_dir, &list); fx_ver_t max_specified = specified; for (const auto& version : list) { trace::verbose(_X("Inspecting version... [%s]"), version.c_str()); fx_ver_t ver(-1, -1, -1); if (fx_ver_t::parse(version, &ver, true) && ver.get_major() == max_specified.get_major() && ver.get_minor() == max_specified.get_minor()) { max_specified.set_patch(std::max(ver.get_patch(), max_specified.get_patch())); } } pal::string_t max_specified_str = max_specified.as_str(); append_path(&fx_dir, max_specified_str.c_str()); } trace::verbose(_X("Chose FX version [%s]"), fx_dir.c_str()); return fx_dir; }
void deps_resolver_t::setup_probe_config( const arguments_t& args) { if (pal::directory_exists(args.core_servicing)) { pal::string_t ext_ni = args.core_servicing; append_path(&ext_ni, get_arch()); if (pal::directory_exists(ext_ni)) { // Servicing NI probe. m_probes.push_back(probe_config_t::svc_ni(ext_ni)); } // Servicing normal probe. pal::string_t ext_pkgs = args.core_servicing; append_path(&ext_pkgs, _X("pkgs")); m_probes.push_back(probe_config_t::svc(ext_pkgs)); } // The published deps directory to be probed: either app or FX directory. // The probe directory will be available at probe time. m_probes.push_back(probe_config_t::published_deps_dir()); // The framework locations, starting with highest level framework. for (int i = 1; i < m_fx_definitions.size(); ++i) { if (pal::directory_exists(m_fx_definitions[i]->get_dir())) { m_probes.push_back(probe_config_t::fx(m_fx_definitions[i]->get_dir(), &m_fx_definitions[i]->get_deps(), i)); } } setup_shared_store_probes(args); for (const auto& probe : m_additional_probes) { // Additional paths m_probes.push_back(probe_config_t::lookup(probe)); } if (trace::is_enabled()) { trace::verbose(_X("-- Listing probe configurations...")); for (const auto& pc : m_probes) { pc.print(); } } }
pal::string_t get_runtime_config_from_file(const pal::string_t& file, pal::string_t* dev_cfg) { auto name = get_filename_without_ext(file); auto json_name = name + _X(".runtimeconfig.json"); auto dev_json_name = name + _X(".runtimeconfig.dev.json"); auto json_path = get_directory(file); auto dev_json_path = json_path; append_path(&json_path, json_name.c_str()); append_path(&dev_json_path, dev_json_name.c_str()); trace::verbose(_X("Runtime config is cfg=%s dev=%s"), json_path.c_str(), dev_json_path.c_str()); dev_cfg->assign(dev_json_path); return json_path; }
bool saim_storage__initialize(saim_storage * storage) { char buffer[260]; saim_set_node *node, *nil; saim_region_map_pair * pair; saim_storage_info_pair * info_pair; initialize_result_t result; append_path(buffer, "regions.omrh"); saim_regions_header_file__create(&storage->regions_header_file, buffer); append_path(buffer, "data.om"); saim_storage_info__create(&storage->main_info); saim_storage_file__create(&storage->main_info.file, buffer, storage->hash_value, kMaxMainFileSize); if (saim_storage__initialize_file(storage, &storage->main_info) == kStorage_Failed) return false; if (!saim_storage__initialize_regions_header_file(storage)) return false; // Initialize region files nil = storage->region_map.set->nil; node = saim_set_get_first(storage->region_map.set); while (node != nil) { pair = (saim_region_map_pair *)node->data; info_pair = SAIM_MALLOC(sizeof(saim_storage_info_pair)); saim_storage_info_pair__create(info_pair); saim_string_set(&info_pair->name, &pair->name); saim_storage_file__create(&info_pair->info.file, pair->info.filename.data, storage->hash_value, kMaxRegionFileSize); saim_storage_info_map__insert(&storage->saim_region_info__map, info_pair); result = saim_storage__initialize_file(storage, &info_pair->info); if (result == kStorage_Failed) // offsets & list return false; if (result == kStorage_Regenerated) // region storage file has been corrupted { fprintf(stderr, "saim: region '%s' storage file has been broken\n", pair->name.data); pair->info.status = kRegion_Invalid; // Update header file information if (!saim_regions_header_file__update(&storage->regions_header_file, &storage->region_map)) return false; } if (pair->info.status == kRegion_Invalid) { fprintf(stderr, "saim: region '%s' is invalid\n", pair->name.data); } node = saim_set_get_next(storage->region_map.set, node); } saim_storage__initialize_key_set(storage); return true; }
static BOOL add_launcher( const WCHAR *folder, const WCHAR *filename, int len_filename ) { struct launcher *launcher; IShellLinkW *link; if (nb_launchers == nb_allocated) { unsigned int count = nb_allocated * 2; struct launcher **tmp = HeapReAlloc( GetProcessHeap(), 0, launchers, count * sizeof(*tmp) ); if (!tmp) return FALSE; launchers = tmp; nb_allocated = count; } if (!(launcher = HeapAlloc( GetProcessHeap(), 0, sizeof(*launcher) ))) return FALSE; if (!(launcher->path = append_path( folder, filename, len_filename ))) goto error; if (!(link = load_shelllink( launcher->path ))) goto error; launcher->icon = extract_icon( link ); launcher->title = build_title( filename, len_filename ); IShellLinkW_Release( link ); if (launcher->icon && launcher->title) { launchers[nb_launchers++] = launcher; return TRUE; } HeapFree( GetProcessHeap(), 0, launcher->title ); DestroyIcon( launcher->icon ); error: HeapFree( GetProcessHeap(), 0, launcher->path ); HeapFree( GetProcessHeap(), 0, launcher ); return FALSE; }
// ----------------------------------------------------------------------------- // Given a "base" directory, yield the local path of this file // // Parameters: // base - The base directory to look for the relative path of this entry // str - If the method returns true, contains the file path for this deps // entry relative to the "base" directory // // Returns: // If the file exists in the path relative to the "base" directory. // bool deps_entry_t::to_dir_path(const pal::string_t& base, pal::string_t* str) const { if (asset_type == asset_types::resources) { pal::string_t pal_relative_path = relative_path; if (_X('/') != DIR_SEPARATOR) { replace_char(&pal_relative_path, _X('/'), DIR_SEPARATOR); } // Resources are represented as "<ietf-code>/<ResourceAssemblyName.dll>" in the deps.json. // The <ietf-code> is the "directory" in the pal_relative_path below, so extract it. pal::string_t ietf_dir = get_directory(pal_relative_path); pal::string_t ietf = ietf_dir; // get_directory returns with DIR_SEPERATOR appended that we need to remove. auto sep_pos = ietf.find_last_of(DIR_SEPARATOR); if (sep_pos != pal::string_t::npos) { ietf = ietf.erase(sep_pos, pal::string_t::npos); } pal::string_t base_ietf_dir = base; append_path(&base_ietf_dir, ietf.c_str()); trace::verbose(_X("Detected a resource asset, will query dir/ietf-tag/resource base: %s asset: %s"), base_ietf_dir.c_str(), asset_name.c_str()); return to_path(base_ietf_dir, true, str); } return to_path(base, true, str); }
int os_get_absolute_path(char_u *fname, char_u *buf, int len, int force) { char_u *p; *buf = NUL; char relative_directory[len]; char *end_of_path = (char *) fname; // expand it if forced or not an absolute path if (force || !os_is_absolute_path(fname)) { if ((p = vim_strrchr(fname, '/')) != NULL) { STRNCPY(relative_directory, fname, p-fname); relative_directory[p-fname] = NUL; end_of_path = (char *) (p + 1); } else { relative_directory[0] = NUL; end_of_path = (char *) fname; } if (FAIL == os_full_dir_name(relative_directory, (char *) buf, len)) { return FAIL; } } return append_path((char *) buf, (char *) end_of_path, len); }
void command_rput(int sfd_client, struct packet* chp) { static char lpwd[LENBUFFER]; if(!getcwd(lpwd, sizeof lpwd)) er("getcwd()", 0); DIR* d = opendir(lpwd); if(!d) er("opendir()", (int) d); struct dirent* e; struct command* cmd = (struct command*) malloc(sizeof(struct command)); cmd->id = RPUT; cmd->npaths = 0; cmd->paths = NULL; while((e = readdir(d)) != NULL) if(e->d_type == 8) append_path(cmd, e->d_name); else if(e->d_type == 4 && strcmp(e->d_name, ".") && strcmp(e->d_name, "..")) { command_mkdir(sfd_client, chp, e->d_name); command_cd(sfd_client, chp, e->d_name); command_lcd(e->d_name); command_rput(sfd_client, chp); command_cd(sfd_client, chp, ".."); command_lcd(".."); } closedir(d); command_mput(sfd_client, chp, cmd->npaths, cmd->paths); }
bool coreclr_exists_in_dir(const pal::string_t& candidate) { pal::string_t test(candidate); append_path(&test, LIBCORECLR_NAME); trace::verbose(_X("Checking if CoreCLR path exists=[%s]"), test.c_str()); return pal::file_exists(test); }
uri_builder &uri_builder::append(const http::uri &relative_uri) { append_path(relative_uri.path()); append_query(relative_uri.query()); this->set_fragment(this->fragment() + relative_uri.fragment()); return *this; }
// ----------------------------------------------------------------------------- // Given a "base" directory, yield the relative path of this file in the package // layout. // // Parameters: // base - The base directory to look for the relative path of this entry // str - If the method returns true, contains the file path for this deps // entry relative to the "base" directory // // Returns: // If the file exists in the path relative to the "base" directory. // bool deps_entry_t::to_full_path(const pal::string_t& base, pal::string_t* str) const { str->clear(); // Base directory must be present to obtain full path if (base.empty()) { return false; } pal::string_t new_base = base; append_path(&new_base, library_name.c_str()); append_path(&new_base, library_version.c_str()); return to_rel_path(new_base, str); }
bool pal::get_default_breadcrumb_store(string_t* recv) { recv->clear(); pal::string_t prog_dat; if (!get_file_path_from_env(_X("ProgramData"), &prog_dat)) { // We should have the path in prog_dat. trace::verbose(_X("Failed to read default breadcrumb store [%s]"), prog_dat.c_str()); return false; } recv->assign(prog_dat); append_path(recv, _X("Microsoft")); append_path(recv, _X("NetFramework")); append_path(recv, _X("BreadcrumbStore")); return true; }
bool pal::get_default_breadcrumb_store(string_t* recv) { recv->clear(); pal::char_t* prog_dat; HRESULT hr = ::SHGetKnownFolderPath(FOLDERID_ProgramData, 0, NULL, &prog_dat); if (hr != S_OK) { trace::verbose(_X("Failed to read default breadcrumb store 0x%X"), hr); return false; } recv->assign(prog_dat); append_path(recv, _X("Microsoft")); append_path(recv, _X("NetFramework")); append_path(recv, _X("BreadcrumbStore")); return true; }
bool get_global_shared_store_dirs(std::vector<pal::string_t>* dirs, const pal::string_t& arch, const pal::string_t& tfm) { std::vector<pal::string_t> global_dirs; if (!pal::get_global_dotnet_dirs(&global_dirs)) { return false; } for (pal::string_t dir : global_dirs) { append_path(&dir, RUNTIME_STORE_DIRECTORY_NAME); append_path(&dir, arch.c_str()); append_path(&dir, tfm.c_str()); dirs->push_back(dir); } return true; }
void tpafile::write_native_paths(pal::string_t& output) { std::set<pal::string_t> items; for (auto search_path : m_native_search_paths) { if (items.find(search_path) == items.end()) { trace::verbose(_X("adding native search path: %s"), search_path.c_str()); output.append(search_path); output.push_back(PATH_SEPARATOR); items.insert(search_path); } } for (auto entry : m_entries) { auto dir = entry.relative_path.substr(0, entry.relative_path.find_last_of(DIR_SEPARATOR)); if (pal::strcmp(entry.asset_type.c_str(), _X("native")) == 0 && items.find(dir) == items.end()) { // Resolve the full path for (auto search_path : m_package_search_paths) { pal::string_t candidate; candidate.reserve(search_path.length() + entry.library_name.length() + entry.library_version.length() + dir.length() + 3); candidate.append(search_path); append_path(candidate, entry.library_name.c_str()); append_path(candidate, entry.library_version.c_str()); append_path(candidate, get_directory(entry.relative_path).c_str()); if (pal::file_exists(candidate)) { trace::verbose(_X("adding native search path: %s"), candidate.c_str()); output.append(candidate); output.push_back(PATH_SEPARATOR); items.insert(dir); break; } } } } }
bool pal::get_default_servicing_directory(string_t* recv) { if (!get_wow_mode_program_files(recv)) { return false; } append_path(recv, _X("coreservicing")); return true; }
void saim_storage__generate_region_file_name(saim_storage * storage, char* buffer) { unsigned int id; char filename[30]; id = storage->regions_header_file.unique_id; sprintf(filename, "%u.omr", id); append_path(buffer, filename); }