#include "mega-dylib-utils.h"
#include "MachOFileAbstraction.hpp"
#include "Trie.hpp"
#include <dirent.h>
#include <sys/errno.h>
#include <sys/fcntl.h>
#include <sys/param.h>
#include <mach-o/loader.h>
#include <mach-o/fat.h>
#include <mach-o/dyld.h>
#include <assert.h>
#include <Availability.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <System/sys/csr.h>
#include "dyld_cache_config.h"
#include "OptimizerBranches.h"
#include "CacheFileAbstraction.hpp"
#include "mega-dylib-utils.h"
#include "Logging.h"
extern "C" int rootless_check_trusted(const char *path);
extern "C" int rootless_check_trusted_fd(int fd) __attribute__((weak_import));
static bool rootlessEnabled;
static dispatch_once_t onceToken;
bool isProtectedBySIP(const std::string& path, int fd)
{
bool isProtected = false;
dispatch_once(&onceToken, ^{
rootlessEnabled = csr_check(CSR_ALLOW_UNRESTRICTED_FS);
});
if (!rootlessEnabled)
return false;
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200
if ( (fd != -1) && (&rootless_check_trusted_fd != NULL) )
isProtected = (rootless_check_trusted_fd(fd) == 0);
else
#endif
if ( &rootless_check_trusted != NULL )
isProtected = (rootless_check_trusted(path.c_str()) == 0);
return isProtected;
}
std::string toolDir()
{
char buffer[PATH_MAX];
uint32_t bufsize = PATH_MAX;
int result = _NSGetExecutablePath(buffer, &bufsize);
if ( result == 0 ) {
std::string path = buffer;
size_t pos = path.rfind('/');
if ( pos != std::string::npos )
return path.substr(0,pos+1);
}
warning("tool directory not found");
return "/tmp/";
}
std::string baspath(const std::string& path)
{
std::string::size_type slash_pos = path.rfind("/");
if (slash_pos != std::string::npos) {
slash_pos++;
return path.substr(slash_pos);
} else {
return path;
}
}
std::string dirpath(const std::string& path)
{
std::string::size_type slash_pos = path.rfind("/");
if (slash_pos != std::string::npos) {
slash_pos++;
return path.substr(0, slash_pos);
} else {
char cwd[MAXPATHLEN];
(void)getcwd(cwd, MAXPATHLEN);
return cwd;
}
}
std::string normalize_absolute_file_path(const std::string &path) {
std::vector<std::string> components;
std::vector<std::string> processed_components;
std::stringstream ss(path);
std::string retval;
std::string item;
while (std::getline(ss, item, '/')) {
components.push_back(item);
}
if (components[0] == ".") {
retval = ".";
}
for (auto& component : components) {
if (component.empty() || component == ".")
continue;
else if (component == ".." && processed_components.size())
processed_components.pop_back();
else
processed_components.push_back(component);
}
for (auto & component : processed_components) {
retval = retval + "/" + component;
}
return retval;
}
FileCache fileCache;
FileCache::FileCache(void) {
cache_queue = dispatch_queue_create("com.apple.dyld.cache.cache", DISPATCH_QUEUE_SERIAL);
}
void FileCache::preflightCache(const std::unordered_set<std::string>& paths) {
for (auto &path : paths) {
preflightCache(path);
}
}
void FileCache::preflightCache(const std::string& path)
{
cacheBuilderDispatchAsync(cache_queue, [=] {
std::string normalizedPath = normalize_absolute_file_path(path);
if (entries.count(normalizedPath) == 0) {
fill(normalizedPath);
}
});
}
std::tuple<uint8_t *, struct stat, bool> FileCache::cacheLoad(const std::string path) {
std::string normalizedPath = normalize_absolute_file_path(path);
cacheBuilderDispatchSync(cache_queue, [=] {
if ( entries.count(normalizedPath) == 0 )
fill(normalizedPath);
});
return entries[normalizedPath];
}
void FileCache::fill(const std::string& path) {
struct stat stat_buf;
int fd = ::open(path.c_str(), O_RDONLY, 0);
if ( fd == -1 ) {
verboseLog("can't open file '%s', errno=%d", path.c_str(), errno);
entries[path] = std::make_tuple((uint8_t*)(-1), stat_buf, false);
return;
}
if ( fstat(fd, &stat_buf) == -1) {
verboseLog("can't stat open file '%s', errno=%d", path.c_str(), errno);
entries[path] = std::make_tuple((uint8_t*)(-1), stat_buf, false);
::close(fd);
return;
}
if ( stat_buf.st_size < 4096 ) {
verboseLog("file too small '%s'", path.c_str());
entries[path] = std::make_tuple((uint8_t*)(-1), stat_buf, false);
::close(fd);
return;
}
bool rootlessProtected = isProtectedBySIP(path, fd);
void* buffer_ptr = mmap(NULL, stat_buf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (buffer_ptr == MAP_FAILED) {
verboseLog("mmap() for shared cache at %s failed, errno=%d", path.c_str(), errno);
entries[path] = std::make_tuple((uint8_t*)(-1), stat_buf, false);
::close(fd);
return;
}
entries[path] = std::make_tuple((uint8_t*)buffer_ptr, stat_buf, rootlessProtected);
::close(fd);
}