| // Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| #include "bin/exe_utils.h" |
| |
| #include "bin/directory.h" |
| #include "bin/file.h" |
| #include "bin/platform.h" |
| #include "platform/utils.h" |
| |
| namespace dart { |
| namespace bin { |
| |
| static bool StartsWithPathSeparator(const char* path, |
| const char* sep, |
| intptr_t sep_length) { |
| return (strncmp(path, sep, sep_length) == 0 |
| #if defined(DART_HOST_OS_WINDOWS) |
| // TODO(aam): GetExecutableName doesn't work reliably on Windows, |
| || *path == '/' |
| #endif |
| ); // NOLINT |
| } |
| |
| // Returns the directory portion of a given path. |
| // |
| // If dir is nullptr, the result must be freed by the caller. Otherwise, the |
| // result is copied into dir. |
| static char* GetDirectoryFromPath(const char* path, char* dir) { |
| const char* sep = File::PathSeparator(); |
| const intptr_t sep_length = strlen(sep); |
| intptr_t path_len = strlen(path); |
| |
| for (intptr_t i = path_len - 1; i >= 0; --i) { |
| const char* str = path + i; |
| if (StartsWithPathSeparator(str, sep, sep_length)) { |
| if (dir != nullptr) { |
| strncpy(dir, path, i); |
| dir[i] = '\0'; |
| return dir; |
| } else { |
| return Utils::StrNDup(path, i + 1); |
| } |
| } |
| } |
| return nullptr; |
| } |
| |
| // Returns the file portion of a given path. Returned string is either |
| // `path` if no path separators are found or `path + separator_loc + sep_length` |
| // if a separator is found. |
| static const char* GetFileNameFromPath(const char* path) { |
| const char* sep = File::PathSeparator(); |
| const intptr_t sep_length = strlen(sep); |
| intptr_t path_len = strlen(path); |
| |
| for (intptr_t i = path_len - 1; i >= 0; --i) { |
| const char* str = path + i; |
| if (StartsWithPathSeparator(str, sep, sep_length)) { |
| return str + sep_length; |
| } |
| } |
| // No path separators, assume that path is a file name. |
| return path; |
| } |
| |
| CStringUniquePtr EXEUtils::GetDirectoryPrefixFromResolvedExeName() { |
| const char* name = nullptr; |
| const int kTargetSize = PATH_MAX; |
| char target[kTargetSize]; |
| intptr_t target_size = |
| Platform::ResolveExecutablePathInto(target, kTargetSize); |
| if (target_size > 0 && target_size < kTargetSize - 1) { |
| target[target_size] = 0; |
| name = target; |
| } |
| if (name == nullptr) { |
| name = Platform::GetExecutableName(); |
| target_size = strlen(name); |
| ASSERT(target_size < kTargetSize); |
| } |
| Namespace* namespc = Namespace::Create(Namespace::Default()); |
| char* result; |
| if (File::GetType(namespc, name, false) == File::kIsLink) { |
| char dir_path[kTargetSize]; |
| // cwd is currently wherever we launched from, so set the cwd to the |
| // directory of the symlink while we try and resolve it. If we don't |
| // do this, we won't be able to properly resolve relative paths. |
| CStringUniquePtr initial_dir_path(Directory::CurrentNoScope()); |
| // We might run into symlinks of symlinks, so make sure we follow the |
| // links all the way. See https://github.com/dart-lang/sdk/issues/41057 for |
| // an example where this happens with brew on MacOS. |
| do { |
| Directory::SetCurrent(namespc, GetDirectoryFromPath(name, dir_path)); |
| // Resolve the link without creating Dart scope String. |
| name = File::LinkTarget(namespc, GetFileNameFromPath(name), target, |
| kTargetSize); |
| if (name == nullptr) { |
| return CStringUniquePtr(Utils::StrDup("")); |
| } |
| } while (File::GetType(namespc, name, false) == File::kIsLink); |
| target_size = strlen(name); |
| |
| char absolute_path[kTargetSize]; |
| |
| // Get the absolute path after we've resolved all the symlinks and before |
| // we reset the cwd, otherwise path resolution will fail. |
| File::GetCanonicalPath(namespc, name, absolute_path, kTargetSize); |
| |
| // Reset cwd to the original value. |
| Directory::SetCurrent(namespc, initial_dir_path.get()); |
| |
| result = GetDirectoryFromPath(absolute_path, nullptr); |
| } else { |
| result = GetDirectoryFromPath(target, nullptr); |
| } |
| namespc->Release(); |
| return CStringUniquePtr(result == nullptr ? Utils::StrDup("") : result); |
| } |
| |
| CStringUniquePtr EXEUtils::GetDirectoryPrefixFromUnresolvedExeName() { |
| const char* exe = Platform::GetExecutableName(); |
| return CStringUniquePtr(exe == nullptr ? nullptr |
| : GetDirectoryFromPath(exe, nullptr)); |
| } |
| |
| #if !defined(DART_HOST_OS_WINDOWS) |
| void EXEUtils::LoadDartProfilerSymbols(const char* argv0) { |
| char* path = reinterpret_cast<char*>(malloc(PATH_MAX + 5)); |
| if (Platform::ResolveExecutablePathInto(path, PATH_MAX) <= 0) return; |
| |
| int len = strlen(path); |
| memcpy(path + len, ".sym", 5); // NOLINT |
| File* file = File::Open(nullptr, path, File::kRead); |
| free(path); |
| if (file == nullptr) return; |
| |
| int64_t size = file->Length(); |
| MappedMemory* mapping = file->Map(File::kReadOnly, 0, size); |
| Dart_AddSymbols(argv0, mapping->address(), size); |
| mapping->Leak(); // Let us delete the object but keep the mapping. |
| delete mapping; |
| file->Release(); |
| } |
| #endif // !defined(DART_HOST_OS_WINDOWS) |
| |
| } // namespace bin |
| } // namespace dart |