Loading...
--- dyld/dyld-733.6/dyld3/PathOverrides.cpp
+++ dyld/dyld-551.4/dyld3/PathOverrides.cpp
@@ -30,18 +30,14 @@
#include <mach/mach.h>
#include <sys/stat.h>
#include <fcntl.h>
-#include <limits.h>
#include <sys/errno.h>
#include <unistd.h>
-#include <initializer_list>
-
#include "PathOverrides.h"
namespace dyld3 {
-namespace closure {
#if BUILDING_LIBDYLD
PathOverrides gPathOverrides;
@@ -59,47 +55,35 @@
return NULL;
}
-
-void PathOverrides::setFallbackPathHandling(FallbackPathMode mode)
-{
- _fallbackPathMode = mode;
-}
-
-void PathOverrides::setEnvVars(const char* envp[], const MachOFile* mainExe, const char* mainExePath)
+
+#if DYLD_IN_PROCESS
+void PathOverrides::setEnvVars(const char* envp[])
{
for (const char** p = envp; *p != NULL; p++) {
- addEnvVar(*p, false);
- }
- if ( mainExe != nullptr )
- setMainExecutable(mainExe, mainExePath);
-}
-
-void PathOverrides::setMainExecutable(const dyld3::MachOFile* mainExe, const char* mainExePath)
-{
- assert(mainExe != nullptr);
- assert(mainExe->isMainExecutable());
- // process any LC_DYLD_ENVIRONMENT load commands in main executable
- mainExe->forDyldEnv(^(const char* envVar, bool& stop) {
- addEnvVar(envVar, true);
- });
-}
-
+ addEnvVar(*p);
+ }
+}
+
+#else
+PathOverrides::PathOverrides(const std::vector<std::string>& env)
+{
+ for (const std::string& envVar : env) {
+ addEnvVar(envVar.c_str());
+ }
+}
+#endif
#if !BUILDING_LIBDYLD
// libdyld is never unloaded
PathOverrides::~PathOverrides()
{
+ freeArray(_dylibPathOverrides);
+ freeArray(_frameworkPathOverrides);
+ freeArray(_frameworkPathFallbacks);
+ freeArray(_dylibPathFallbacks);
}
#endif
-void PathOverrides::forEachInsertedDylib(void (^handler)(const char* dylibPath, bool &stop)) const
-{
- if ( _insertedDylibs != nullptr ) {
- forEachInColonList(_insertedDylibs, nullptr, ^(const char* path, bool &stop) {
- handler(path, stop);
- });
- }
-}
void PathOverrides::handleEnvVar(const char* key, const char* value, void (^handler)(const char* envVar)) const
{
@@ -113,149 +97,165 @@
handler(buffer);
}
-// Note, this method only returns variables set on the environment, not those from the load command
+void PathOverrides::handleListEnvVar(const char* key, const char** list, void (^handler)(const char* envVar)) const
+{
+ if ( list == nullptr )
+ return;
+ size_t allocSize = strlen(key) + 2;
+ for (const char** lp=list; *lp != nullptr; ++lp)
+ allocSize += strlen(*lp)+1;
+ char buffer[allocSize];
+ strlcpy(buffer, key, allocSize);
+ strlcat(buffer, "=", allocSize);
+ bool needColon = false;
+ for (const char** lp=list; *lp != nullptr; ++lp) {
+ if ( needColon )
+ strlcat(buffer, ":", allocSize);
+ strlcat(buffer, *lp, allocSize);
+ needColon = true;
+ }
+ handler(buffer);
+}
+
void PathOverrides::forEachEnvVar(void (^handler)(const char* envVar)) const
{
- handleEnvVar("DYLD_LIBRARY_PATH", _dylibPathOverridesEnv, handler);
- handleEnvVar("DYLD_FRAMEWORK_PATH", _frameworkPathOverridesEnv, handler);
- handleEnvVar("DYLD_FALLBACK_FRAMEWORK_PATH", _frameworkPathFallbacksEnv, handler);
- handleEnvVar("DYLD_FALLBACK_LIBRARY_PATH", _dylibPathFallbacksEnv, handler);
- handleEnvVar("DYLD_INSERT_LIBRARIES", _insertedDylibs, handler);
- handleEnvVar("DYLD_IMAGE_SUFFIX", _imageSuffix, handler);
- handleEnvVar("DYLD_ROOT_PATH", _rootPath, handler);
-}
-
-// Note, this method only returns variables set on the executable load command, not those from the environment
-void PathOverrides::forEachExecutableEnvVar(void (^handler)(const char* envVar)) const
-{
- handleEnvVar("DYLD_LIBRARY_PATH", _dylibPathOverridesExeLC, handler);
- handleEnvVar("DYLD_FRAMEWORK_PATH", _frameworkPathOverridesExeLC, handler);
- handleEnvVar("DYLD_FALLBACK_FRAMEWORK_PATH", _frameworkPathFallbacksExeLC, handler);
- handleEnvVar("DYLD_FALLBACK_LIBRARY_PATH", _dylibPathFallbacksExeLC, handler);
-}
-
-const char* PathOverrides::addString(const char* str)
-{
- if ( _pathPool == nullptr )
- _pathPool = PathPool::allocate();
- return _pathPool->add(str);
-}
-
-void PathOverrides::setString(const char*& var, const char* value)
-{
- if ( var == nullptr ) {
- var = addString(value);
+ handleListEnvVar("DYLD_LIBRARY_PATH", _dylibPathOverrides, handler);
+ handleListEnvVar("DYLD_FRAMEWORK_PATH", _frameworkPathOverrides, handler);
+ handleListEnvVar("DYLD_FALLBACK_FRAMEWORK_PATH", _frameworkPathFallbacks, handler);
+ handleListEnvVar("DYLD_FALLBACK_LIBRARY_PATH", _dylibPathFallbacks, handler);
+ handleListEnvVar("DYLD_INSERT_LIBRARIES", _insertedDylibs, handler);
+ handleEnvVar( "DYLD_IMAGE_SUFFIX", _imageSuffix, handler);
+ handleEnvVar( "DYLD_ROOT_PATH", _rootPath, handler);
+}
+
+uint32_t PathOverrides::envVarCount() const
+{
+ uint32_t count = 0;
+ if ( _dylibPathOverrides != nullptr )
+ ++count;
+ if ( _frameworkPathOverrides != nullptr )
+ ++count;
+ if ( _frameworkPathFallbacks != nullptr )
+ ++count;
+ if ( _dylibPathFallbacks != nullptr )
+ ++count;
+ if ( _insertedDylibs != nullptr )
+ ++count;
+ if ( _imageSuffix != nullptr )
+ ++count;
+ if ( _rootPath != nullptr )
+ ++count;
+ return count;
+}
+
+void PathOverrides::forEachInsertedDylib(void (^handler)(const char* dylibPath)) const
+{
+ if ( _insertedDylibs == nullptr )
return;
- }
- // string already in use, build new appended string
- char tmp[strlen(var)+strlen(value)+2];
- strcpy(tmp, var);
- strcat(tmp, ":");
- strcat(tmp, value);
- var = addString(tmp);
-}
-
-void PathOverrides::addEnvVar(const char* keyEqualsValue, bool forExecutable)
-{
- // We have to make a copy of the env vars because the dyld
- // semantics is that the env vars are only looked at once
- // at launch (using setenv() at runtime does not change dyld behavior).
+ for (const char** lp=_insertedDylibs; *lp != nullptr; ++lp)
+ handler(*lp);
+}
+
+void PathOverrides::addEnvVar(const char* keyEqualsValue)
+{
const char* equals = strchr(keyEqualsValue, '=');
if ( equals != NULL ) {
- if ( strncmp(keyEqualsValue, "DYLD_LIBRARY_PATH", 17) == 0 ) {
- setString(forExecutable ? _dylibPathOverridesExeLC : _dylibPathOverridesEnv, &keyEqualsValue[18]);
- }
- else if ( strncmp(keyEqualsValue, "DYLD_FRAMEWORK_PATH", 19) == 0 ) {
- setString(forExecutable ? _frameworkPathOverridesExeLC : _frameworkPathOverridesEnv, &keyEqualsValue[20]);
- }
- else if ( strncmp(keyEqualsValue, "DYLD_FALLBACK_FRAMEWORK_PATH", 28) == 0 ) {
- setString(forExecutable ? _frameworkPathFallbacksExeLC : _frameworkPathFallbacksEnv, &keyEqualsValue[29]);
- }
- else if ( strncmp(keyEqualsValue, "DYLD_FALLBACK_LIBRARY_PATH", 26) == 0 ) {
- setString(forExecutable ? _dylibPathFallbacksExeLC : _dylibPathFallbacksEnv, &keyEqualsValue[27]);
- }
- else if ( strncmp(keyEqualsValue, "DYLD_INSERT_LIBRARIES", 21) == 0 ) {
- setString(_insertedDylibs, &keyEqualsValue[22]);
- }
- else if ( strncmp(keyEqualsValue, "DYLD_IMAGE_SUFFIX", 17) == 0 ) {
- setString(_imageSuffix, &keyEqualsValue[18]);
- }
- else if ( strncmp(keyEqualsValue, "DYLD_ROOT_PATH", 14) == 0 ) {
- setString(_rootPath, &keyEqualsValue[15]);
- }
- }
-}
-
-void PathOverrides::forEachInColonList(const char* list1, const char* list2, void (^handler)(const char* path, bool& stop))
-{
- for (const char* list : { list1, list2 }) {
- if (list == nullptr)
+ const char* value = &equals[1];
+ const size_t keyLen = equals-keyEqualsValue;
+ char key[keyLen+1];
+ strncpy(key, keyEqualsValue, keyLen);
+ key[keyLen] = '\0';
+ if ( strcmp(key, "DYLD_LIBRARY_PATH") == 0 ) {
+ _dylibPathOverrides = parseColonListIntoArray(value);
+ }
+ else if ( strcmp(key, "DYLD_FRAMEWORK_PATH") == 0 ) {
+ _frameworkPathOverrides = parseColonListIntoArray(value);
+ }
+ else if ( strcmp(key, "DYLD_FALLBACK_FRAMEWORK_PATH") == 0 ) {
+ _frameworkPathFallbacks = parseColonListIntoArray(value);
+ }
+ else if ( strcmp(key, "DYLD_FALLBACK_LIBRARY_PATH") == 0 ) {
+ _dylibPathFallbacks = parseColonListIntoArray(value);
+ }
+ else if ( strcmp(key, "DYLD_INSERT_LIBRARIES") == 0 ) {
+ _insertedDylibs = parseColonListIntoArray(value);
+ }
+ else if ( strcmp(key, "DYLD_IMAGE_SUFFIX") == 0 ) {
+ _imageSuffix = value;
+ }
+ else if ( strcmp(key, "DYLD_ROOT_PATH") == 0 ) {
+ _rootPath = value;
+ }
+ }
+}
+
+void PathOverrides::forEachInColonList(const char* list, void (^handler)(const char* path))
+{
+ char buffer[strlen(list)+1];
+ const char* t = list;
+ for (const char* s=list; *s != '\0'; ++s) {
+ if (*s != ':')
continue;
- char buffer[strlen(list)+1];
- const char* t = list;
- bool stop = false;
- for (const char* s=list; *s != '\0'; ++s) {
- if (*s != ':')
- continue;
- size_t len = s - t;
- memcpy(buffer, t, len);
- buffer[len] = '\0';
- handler(buffer, stop);
+ size_t len = s - t;
+ memcpy(buffer, t, len);
+ buffer[len] = '\0';
+ handler(buffer);
+ t = s+1;
+ }
+ handler(t);
+}
+
+const char** PathOverrides::parseColonListIntoArray(const char* list)
+{
+ __block int count = 1;
+ forEachInColonList(list, ^(const char* path) {
+ ++count;
+ });
+ const char** array = (const char**)malloc(count*sizeof(char*));
+ __block const char** p = array;
+ forEachInColonList(list, ^(const char* path) {
+ *p++ = strdup(path);
+ });
+ *p = nullptr;
+ return array;
+}
+
+void PathOverrides::freeArray(const char** array)
+{
+ if ( array == nullptr )
+ return;
+
+ for (const char** p=array; *p != nullptr; ++p) {
+ free((void*)*p);
+ }
+ free(array);
+}
+
+void PathOverrides::forEachDylibFallback(Platform platform, void (^handler)(const char* fallbackDir, bool& stop)) const
+{
+ bool stop = false;
+ if ( _dylibPathFallbacks != nullptr ) {
+ for (const char** fp=_dylibPathFallbacks; *fp != nullptr; ++fp) {
+ handler(*fp, stop);
if ( stop )
return;
- t = s+1;
- }
- handler(t, stop);
- if (stop)
- return;
- }
-}
-
-void PathOverrides::forEachDylibFallback(Platform platform, void (^handler)(const char* fallbackDir, bool& stop)) const
-{
- __block bool stop = false;
- if ( (_dylibPathFallbacksEnv != nullptr) || (_dylibPathFallbacksExeLC != nullptr) ) {
- forEachInColonList(_dylibPathFallbacksEnv, _dylibPathFallbacksExeLC, ^(const char* pth, bool& innerStop) {
- handler(pth, innerStop);
- if ( innerStop )
- stop = true;
- });
+ }
}
else {
switch ( platform ) {
case Platform::macOS:
- switch ( _fallbackPathMode ) {
- case FallbackPathMode::classic:
- // "$HOME/lib"
- handler("/usr/local/lib", stop);
- if ( stop )
- break;
- [[clang::fallthrough]];
- case FallbackPathMode::restricted:
- handler("/usr/lib", stop);
- break;
- case FallbackPathMode::none:
- break;
- }
+ // "$HOME/lib"
+ handler("/usr/local/lib", stop); // FIXME: not for restricted processes
+ if ( !stop )
+ handler("/usr/lib", stop);
break;
case Platform::iOS:
case Platform::watchOS:
case Platform::tvOS:
case Platform::bridgeOS:
- case Platform::driverKit:
case Platform::unknown:
- if ( _fallbackPathMode != FallbackPathMode::none ) {
- handler("/usr/local/lib", stop);
- if ( stop )
- break;
- }
- // fall into /usr/lib case
- [[clang::fallthrough]];
- case Platform::iOSMac:
- case Platform::iOS_simulator:
- case Platform::watchOS_simulator:
- case Platform::tvOS_simulator:
- if ( _fallbackPathMode != FallbackPathMode::none )
+ handler("/usr/local/lib", stop);
+ if ( !stop )
handler("/usr/lib", stop);
break;
}
@@ -264,161 +264,96 @@
void PathOverrides::forEachFrameworkFallback(Platform platform, void (^handler)(const char* fallbackDir, bool& stop)) const
{
- __block bool stop = false;
- if ( (_frameworkPathFallbacksEnv != nullptr) || (_frameworkPathFallbacksExeLC != nullptr) ) {
- forEachInColonList(_frameworkPathFallbacksEnv, _frameworkPathFallbacksExeLC, ^(const char* pth, bool& innerStop) {
- handler(pth, innerStop);
- if ( innerStop )
- stop = true;
- });
+ bool stop = false;
+ if ( _frameworkPathFallbacks != nullptr ) {
+ for (const char** fp=_frameworkPathFallbacks; *fp != nullptr; ++fp) {
+ handler(*fp, stop);
+ if ( stop )
+ return;
+ }
}
else {
switch ( platform ) {
case Platform::macOS:
- switch ( _fallbackPathMode ) {
- case FallbackPathMode::classic:
- // "$HOME/Library/Frameworks"
- handler("/Library/Frameworks", stop);
- if ( stop )
- break;
- // "/Network/Library/Frameworks"
- // fall thru
- [[clang::fallthrough]];
- case FallbackPathMode::restricted:
- handler("/System/Library/Frameworks", stop);
- break;
- case FallbackPathMode::none:
- break;
- }
+ // "$HOME/Library/Frameworks"
+ handler("/Library/Frameworks", stop); // FIXME: not for restricted processes
+ // "/Network/Library/Frameworks"
+ if ( !stop )
+ handler("/System/Library/Frameworks", stop);
break;
case Platform::iOS:
case Platform::watchOS:
case Platform::tvOS:
case Platform::bridgeOS:
- case Platform::iOSMac:
- case Platform::iOS_simulator:
- case Platform::watchOS_simulator:
- case Platform::tvOS_simulator:
- case Platform::driverKit:
case Platform::unknown:
- if ( _fallbackPathMode != FallbackPathMode::none )
- handler("/System/Library/Frameworks", stop);
+ handler("/System/Library/Frameworks", stop);
break;
}
}
}
-
-//
-// copy path and add suffix to result
-//
-// /path/foo.dylib _debug => /path/foo_debug.dylib
-// foo.dylib _debug => foo_debug.dylib
-// foo _debug => foo_debug
-// /path/bar _debug => /path/bar_debug
-// /path/bar.A.dylib _debug => /path/bar.A_debug.dylib
-//
-void PathOverrides::addSuffix(const char* path, const char* suffix, char* result) const
-{
- strcpy(result, path);
-
- // find last slash
- char* start = strrchr(result, '/');
- if ( start != NULL )
- start++;
- else
- start = result;
-
- // find last dot after last slash
- char* dot = strrchr(start, '.');
- if ( dot != NULL ) {
- strcpy(dot, suffix);
- strcat(&dot[strlen(suffix)], &path[dot-result]);
+void PathOverrides::forEachPathVariant(const char* initialPath,
+#if !DYLD_IN_PROCESS
+ Platform platform,
+#endif
+ void (^handler)(const char* possiblePath, bool& stop)) const
+{
+#if DYLD_IN_PROCESS
+ Platform platform = MachOParser::currentPlatform();
+#endif
+ __block bool stop = false;
+
+ // check for overrides
+ const char* frameworkPartialPath = getFrameworkPartialPath(initialPath);
+ if ( frameworkPartialPath != nullptr ) {
+ const size_t frameworkPartialPathLen = strlen(frameworkPartialPath);
+ // look at each DYLD_FRAMEWORK_PATH directory
+ if ( _frameworkPathOverrides != nullptr ) {
+ for (const char** fp=_frameworkPathOverrides; *fp != nullptr; ++fp) {
+ char npath[strlen(*fp)+frameworkPartialPathLen+8];
+ strcpy(npath, *fp);
+ strcat(npath, "/");
+ strcat(npath, frameworkPartialPath);
+ handler(npath, stop);
+ if ( stop )
+ return;
+ }
+ }
}
else {
- strcat(result, suffix);
- }
-}
-
-void PathOverrides::forEachImageSuffix(const char* path, bool isFallbackPath, bool pathIsInDyldCacheWhichCannotBeOverridden, bool& stop, void (^handler)(const char* possiblePath, bool isFallbackPath, bool& stop)) const
-{
- if ( (_imageSuffix == nullptr) || pathIsInDyldCacheWhichCannotBeOverridden ) {
- handler(path, isFallbackPath, stop);
- }
- else {
- forEachInColonList(_imageSuffix, nullptr, ^(const char* suffix, bool& innerStop) {
- char npath[strlen(path)+strlen(suffix)+8];
- addSuffix(path, suffix, npath);
- handler(npath, isFallbackPath, innerStop);
- if ( innerStop )
- stop = true;
- });
- if ( !stop )
- handler(path, isFallbackPath, stop);
- }
-}
-
-void PathOverrides::forEachPathVariant(const char* initialPath, bool pathIsInDyldCacheWhichCannotBeOverridden, void (^handler)(const char* possiblePath, bool isFallbackPath, bool& stop), Platform platform) const
-{
- __block bool stop = false;
-
-
- if ( !pathIsInDyldCacheWhichCannotBeOverridden ) {
- // check for overrides
- const char* frameworkPartialPath = getFrameworkPartialPath(initialPath);
- if ( frameworkPartialPath != nullptr ) {
- const size_t frameworkPartialPathLen = strlen(frameworkPartialPath);
- // look at each DYLD_FRAMEWORK_PATH directory
- if ( (_frameworkPathOverridesEnv != nullptr) || (_frameworkPathOverridesExeLC != nullptr) ) {
- forEachInColonList(_frameworkPathOverridesEnv, _frameworkPathOverridesExeLC, ^(const char* frDir, bool &innerStop) {
- char npath[strlen(frDir)+frameworkPartialPathLen+8];
- strcpy(npath, frDir);
- strcat(npath, "/");
- strcat(npath, frameworkPartialPath);
- forEachImageSuffix(npath, false, pathIsInDyldCacheWhichCannotBeOverridden, innerStop, handler);
- if ( innerStop )
- stop = true;
- });
+ const char* libraryLeafName = getLibraryLeafName(initialPath);
+ const size_t libraryLeafNameLen = strlen(libraryLeafName);
+ // look at each DYLD_LIBRARY_PATH directory
+ if ( _dylibPathOverrides != nullptr ) {
+ for (const char** lp=_dylibPathOverrides; *lp != nullptr; ++lp) {
+ char libpath[strlen(*lp)+libraryLeafNameLen+8];
+ strcpy(libpath, *lp);
+ strcat(libpath, "/");
+ strcat(libpath, libraryLeafName);
+ handler(libpath, stop);
+ if ( stop )
+ return;
}
}
- else {
- const char* libraryLeafName = getLibraryLeafName(initialPath);
- const size_t libraryLeafNameLen = strlen(libraryLeafName);
- // look at each DYLD_LIBRARY_PATH directory
- if ( (_dylibPathOverridesEnv != nullptr) || (_dylibPathOverridesExeLC != nullptr) ) {
- forEachInColonList(_dylibPathOverridesEnv, _dylibPathOverridesExeLC, ^(const char* libDir, bool &innerStop) {
- char npath[strlen(libDir)+libraryLeafNameLen+8];
- strcpy(npath, libDir);
- strcat(npath, "/");
- strcat(npath, libraryLeafName);
- forEachImageSuffix(npath, false, pathIsInDyldCacheWhichCannotBeOverridden, innerStop, handler);
- if ( innerStop )
- stop = true;
- });
- }
- }
- if ( stop )
- return;
}
// try original path
- forEachImageSuffix(initialPath, false, pathIsInDyldCacheWhichCannotBeOverridden, stop, handler);
+ handler(initialPath, stop);
if ( stop )
return;
// check fallback paths
- if ( const char* frameworkPartialPath = getFrameworkPartialPath(initialPath) ) {
+ if ( frameworkPartialPath != nullptr ) {
const size_t frameworkPartialPathLen = strlen(frameworkPartialPath);
// look at each DYLD_FALLBACK_FRAMEWORK_PATH directory
- bool usesDefaultFallbackPaths = (_frameworkPathFallbacksEnv == nullptr) && (_frameworkPathFallbacksExeLC == nullptr);
forEachFrameworkFallback(platform, ^(const char* dir, bool& innerStop) {
char npath[strlen(dir)+frameworkPartialPathLen+8];
strcpy(npath, dir);
strcat(npath, "/");
strcat(npath, frameworkPartialPath);
- forEachImageSuffix(npath, usesDefaultFallbackPaths, pathIsInDyldCacheWhichCannotBeOverridden, innerStop, handler);
+ handler(npath, innerStop);
if ( innerStop )
- stop = true;
+ stop = innerStop;
});
}
@@ -426,15 +361,14 @@
const char* libraryLeafName = getLibraryLeafName(initialPath);
const size_t libraryLeafNameLen = strlen(libraryLeafName);
// look at each DYLD_FALLBACK_LIBRARY_PATH directory
- bool usesDefaultFallbackPaths = (_dylibPathFallbacksEnv == nullptr) && (_dylibPathFallbacksExeLC == nullptr);
forEachDylibFallback(platform, ^(const char* dir, bool& innerStop) {
char libpath[strlen(dir)+libraryLeafNameLen+8];
strcpy(libpath, dir);
strcat(libpath, "/");
strcat(libpath, libraryLeafName);
- forEachImageSuffix(libpath, usesDefaultFallbackPaths, pathIsInDyldCacheWhichCannotBeOverridden, innerStop, handler);
+ handler(libpath, innerStop);
if ( innerStop )
- stop = true;
+ stop = innerStop;
});
}
}
@@ -494,59 +428,6 @@
return path;
}
-
-
-//////////////////////////// PathPool ////////////////////////////////////////
-
-
-PathPool* PathPool::allocate()
-{
- vm_address_t addr;
- ::vm_allocate(mach_task_self(), &addr, kAllocationSize, VM_FLAGS_ANYWHERE);
- PathPool* p = (PathPool*)addr;
- p->_next = nullptr;
- p->_current = &(p->_buffer[0]);
- p->_bytesFree = kAllocationSize - sizeof(PathPool);
- return p;
-}
-
-void PathPool::deallocate(PathPool* pool) {
- do {
- PathPool* next = pool->_next;
- ::vm_deallocate(mach_task_self(), (vm_address_t)pool, kAllocationSize);
- pool = next;
- } while (pool);
-}
-
-const char* PathPool::add(const char* path)
-{
- size_t len = strlen(path) + 1;
- if ( len < _bytesFree ) {
- char* result = _current;
- strcpy(_current, path);
- _current += len;
- _bytesFree -= len;
- return result;
- }
- if ( _next == nullptr )
- _next = allocate();
- return _next->add(path);
-}
-
-void PathPool::forEachPath(void (^handler)(const char* path))
-{
- for (const char* s = _buffer; s < _current; ++s) {
- handler(s);
- s += strlen(s);
- }
-
- if ( _next != nullptr )
- _next->forEachPath(handler);
-}
-
-
-
-} // namespace closure
} // namespace dyld3