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);
}
