[apple/dyld.git] / dyld3 / PathOverrides.cpp

/*
 * Copyright (c) 2017 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */


#include <stdint.h>
#include <string.h>
#include <assert.h>
#include <uuid/uuid.h>
#include <mach/mach.h>
#include <sys/stat.h> 
#include <fcntl.h>
#include <sys/errno.h>
#include <unistd.h>

#include "PathOverrides.h"


namespace dyld3 {

#if BUILDING_LIBDYLD
PathOverrides   gPathOverrides;
#endif


// based on ANSI-C strstr()
static const char* strrstr(const char* str, const char* sub) 
{
    const size_t sublen = strlen(sub);
    for(const char* p = &str[strlen(str)]; p != str; --p) {
        if ( strncmp(p, sub, sublen) == 0 )
            return p;
    }
    return NULL;
}


#if DYLD_IN_PROCESS
void PathOverrides::setEnvVars(const char* envp[])
{
    for (const char** p = envp; *p != NULL; p++) {
        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::handleEnvVar(const char* key, const char* value, void (^handler)(const char* envVar)) const
{
    if ( value == nullptr )
        return;
    size_t allocSize = strlen(key) + strlen(value) + 2;
    char buffer[allocSize];
    strlcpy(buffer, key, allocSize);
    strlcat(buffer, "=", allocSize);
    strlcat(buffer, value, allocSize);
    handler(buffer);
}

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
{
    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;
    for (const char** lp=_insertedDylibs; *lp != nullptr; ++lp)
        handler(*lp);
}

void PathOverrides::addEnvVar(const char* keyEqualsValue)
{
    const char* equals = strchr(keyEqualsValue, '=');
    if ( equals != NULL ) {
        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;
        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;
        }
    }
    else {
        switch ( platform ) {
            case Platform::macOS:
                // "$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::unknown:
                handler("/usr/local/lib", stop);
                if ( !stop )
                    handler("/usr/lib", stop);
                break;
        }
    }
}

void PathOverrides::forEachFrameworkFallback(Platform platform, void (^handler)(const char* fallbackDir, bool& stop)) const
{
    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:
                // "$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::unknown:
                handler("/System/Library/Frameworks", stop);
                break;
        }
    }
}

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

    // try original path
    handler(initialPath, stop);
    if ( stop )
        return;

    // check fallback paths
    if ( frameworkPartialPath != nullptr ) {
        const size_t frameworkPartialPathLen = strlen(frameworkPartialPath);
        // look at each DYLD_FALLBACK_FRAMEWORK_PATH directory
        forEachFrameworkFallback(platform, ^(const char* dir, bool& innerStop) {
            char npath[strlen(dir)+frameworkPartialPathLen+8];
            strcpy(npath, dir);
            strcat(npath, "/");
            strcat(npath, frameworkPartialPath);
            handler(npath, innerStop);
            if ( innerStop )
                stop = innerStop;
        });

    }
   else {
        const char* libraryLeafName = getLibraryLeafName(initialPath);
        const size_t libraryLeafNameLen = strlen(libraryLeafName);
        // look at each DYLD_FALLBACK_LIBRARY_PATH directory
        forEachDylibFallback(platform, ^(const char* dir, bool& innerStop) {
            char libpath[strlen(dir)+libraryLeafNameLen+8];
            strcpy(libpath, dir);
            strcat(libpath, "/");
            strcat(libpath, libraryLeafName);
            handler(libpath, innerStop);
            if ( innerStop )
                stop = innerStop;
        });
    }
}


//
// Find framework path
//
//  /path/foo.framework/foo                             =>   foo.framework/foo    
//  /path/foo.framework/Versions/A/foo                  =>   foo.framework/Versions/A/foo
//  /path/foo.framework/Frameworks/bar.framework/bar    =>   bar.framework/bar
//  /path/foo.framework/Libraries/bar.dylb              =>   NULL
//  /path/foo.framework/bar                             =>   NULL
//
// Returns nullptr if not a framework path
//
const char* PathOverrides::getFrameworkPartialPath(const char* path) const
{
    const char* dirDot = strrstr(path, ".framework/");
    if ( dirDot != nullptr ) {
        const char* dirStart = dirDot;
        for ( ; dirStart >= path; --dirStart) {
            if ( (*dirStart == '/') || (dirStart == path) ) {
                const char* frameworkStart = &dirStart[1];
                if ( dirStart == path )
                    --frameworkStart;
                size_t len = dirDot - frameworkStart;
                char framework[len+1];
                strncpy(framework, frameworkStart, len);
                framework[len] = '\0';
                const char* leaf = strrchr(path, '/');
                if ( leaf != nullptr ) {
                    if ( strcmp(framework, &leaf[1]) == 0 ) {
                        return frameworkStart;
                    }
                    if (  _imageSuffix != nullptr ) {
                        // some debug frameworks have install names that end in _debug
                        if ( strncmp(framework, &leaf[1], len) == 0 ) {
                            if ( strcmp( _imageSuffix, &leaf[len+1]) == 0 )
                                return frameworkStart;
                        }
                    }
                }
            }
        }
    }
    return nullptr;
}


const char* PathOverrides::getLibraryLeafName(const char* path)
{
    const char* start = strrchr(path, '/');
    if ( start != nullptr )
        return &start[1];
    else
        return path;
}

} // namespace dyld3
Commit	Line	Data
10b92d3b A	1	/*
	2	* Copyright (c) 2017 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. Please obtain a copy of the License at
	10	* http://www.opensource.apple.com/apsl/ and read it before using this
	11	* file.
	12	*
	13	* The Original Code and all software distributed under the License are
	14	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	15	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	16	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	18	* Please see the License for the specific language governing rights and
	19	* limitations under the License.
	20	*
	21	* @APPLE_LICENSE_HEADER_END@
	22	*/
	23
	24
	25
	26	#include <stdint.h>
	27	#include <string.h>
	28	#include <assert.h>
	29	#include <uuid/uuid.h>
	30	#include <mach/mach.h>
	31	#include <sys/stat.h>
	32	#include <fcntl.h>
	33	#include <sys/errno.h>
	34	#include <unistd.h>
	35
	36	#include "PathOverrides.h"
	37
	38
	39
	40	namespace dyld3 {
	41
	42	#if BUILDING_LIBDYLD
	43	PathOverrides gPathOverrides;
	44	#endif
	45
	46
	47	// based on ANSI-C strstr()
	48	static const char* strrstr(const char* str, const char* sub)
	49	{
	50	const size_t sublen = strlen(sub);
	51	for(const char* p = &str[strlen(str)]; p != str; --p) {
	52	if ( strncmp(p, sub, sublen) == 0 )
	53	return p;
	54	}
	55	return NULL;
	56	}
	57
	58
	59	#if DYLD_IN_PROCESS
	60	void PathOverrides::setEnvVars(const char* envp[])
	61	{
	62	for (const char** p = envp; *p != NULL; p++) {
	63	addEnvVar(*p);
	64	}
65	}
66
67	#else
68	PathOverrides::PathOverrides(const std::vector<std::string>& env)
69	{
70	for (const std::string& envVar : env) {
71	addEnvVar(envVar.c_str());
72	}
73	}
74	#endif
75
76	#if !BUILDING_LIBDYLD
77	// libdyld is never unloaded
78	PathOverrides::~PathOverrides()
79	{
80	freeArray(_dylibPathOverrides);
81	freeArray(_frameworkPathOverrides);
82	freeArray(_frameworkPathFallbacks);
83	freeArray(_dylibPathFallbacks);
84	}
85	#endif
86
87
88	void PathOverrides::handleEnvVar(const char* key, const char* value, void (^handler)(const char* envVar)) const
89	{
90	if ( value == nullptr )
91	return;
92	size_t allocSize = strlen(key) + strlen(value) + 2;
93	char buffer[allocSize];
94	strlcpy(buffer, key, allocSize);
95	strlcat(buffer, "=", allocSize);
96	strlcat(buffer, value, allocSize);
97	handler(buffer);
98	}
99
100	void PathOverrides::handleListEnvVar(const char* key, const char** list, void (^handler)(const char* envVar)) const
101	{
102	if ( list == nullptr )
103	return;
104	size_t allocSize = strlen(key) + 2;
105	for (const char** lp=list; *lp != nullptr; ++lp)
106	allocSize += strlen(*lp)+1;
107	char buffer[allocSize];
108	strlcpy(buffer, key, allocSize);
109	strlcat(buffer, "=", allocSize);
110	bool needColon = false;
111	for (const char** lp=list; *lp != nullptr; ++lp) {
112	if ( needColon )
113	strlcat(buffer, ":", allocSize);
114	strlcat(buffer, *lp, allocSize);
115	needColon = true;
116	}
117	handler(buffer);
118	}
119
120	void PathOverrides::forEachEnvVar(void (^handler)(const char* envVar)) const
121	{
122	handleListEnvVar("DYLD_LIBRARY_PATH", _dylibPathOverrides, handler);
123	handleListEnvVar("DYLD_FRAMEWORK_PATH", _frameworkPathOverrides, handler);
124	handleListEnvVar("DYLD_FALLBACK_FRAMEWORK_PATH", _frameworkPathFallbacks, handler);
125	handleListEnvVar("DYLD_FALLBACK_LIBRARY_PATH", _dylibPathFallbacks, handler);
126	handleListEnvVar("DYLD_INSERT_LIBRARIES", _insertedDylibs, handler);
127	handleEnvVar( "DYLD_IMAGE_SUFFIX", _imageSuffix, handler);
128	handleEnvVar( "DYLD_ROOT_PATH", _rootPath, handler);
129	}
130
131	uint32_t PathOverrides::envVarCount() const
132	{
133	uint32_t count = 0;
134	if ( _dylibPathOverrides != nullptr )
135	++count;
136	if ( _frameworkPathOverrides != nullptr )
137	++count;
138	if ( _frameworkPathFallbacks != nullptr )
139	++count;
140	if ( _dylibPathFallbacks != nullptr )
141	++count;
142	if ( _insertedDylibs != nullptr )
143	++count;
144	if ( _imageSuffix != nullptr )
145	++count;
146	if ( _rootPath != nullptr )
147	++count;
148	return count;
149	}
150
151	void PathOverrides::forEachInsertedDylib(void (^handler)(const char* dylibPath)) const
152	{
153	if ( _insertedDylibs == nullptr )
154	return;
155	for (const char** lp=_insertedDylibs; *lp != nullptr; ++lp)
156	handler(*lp);
157	}
158
159	void PathOverrides::addEnvVar(const char* keyEqualsValue)
160	{
161	const char* equals = strchr(keyEqualsValue, '=');
162	if ( equals != NULL ) {
163	const char* value = &equals[1];
164	const size_t keyLen = equals-keyEqualsValue;
165	char key[keyLen+1];
166	strncpy(key, keyEqualsValue, keyLen);
167	key[keyLen] = '\0';
168	if ( strcmp(key, "DYLD_LIBRARY_PATH") == 0 ) {
169	_dylibPathOverrides = parseColonListIntoArray(value);
170	}
171	else if ( strcmp(key, "DYLD_FRAMEWORK_PATH") == 0 ) {
172	_frameworkPathOverrides = parseColonListIntoArray(value);
173	}
174	else if ( strcmp(key, "DYLD_FALLBACK_FRAMEWORK_PATH") == 0 ) {
175	_frameworkPathFallbacks = parseColonListIntoArray(value);
176	}
177	else if ( strcmp(key, "DYLD_FALLBACK_LIBRARY_PATH") == 0 ) {
178	_dylibPathFallbacks = parseColonListIntoArray(value);
179	}
180	else if ( strcmp(key, "DYLD_INSERT_LIBRARIES") == 0 ) {
181	_insertedDylibs = parseColonListIntoArray(value);
182	}
183	else if ( strcmp(key, "DYLD_IMAGE_SUFFIX") == 0 ) {
184	_imageSuffix = value;
185	}
186	else if ( strcmp(key, "DYLD_ROOT_PATH") == 0 ) {
187	_rootPath = value;
188	}
189	}
190	}
191
192	void PathOverrides::forEachInColonList(const char* list, void (^handler)(const char* path))
193	{
194	char buffer[strlen(list)+1];
195	const char* t = list;
196	for (const char* s=list; *s != '\0'; ++s) {
197	if (*s != ':')
198	continue;
199	size_t len = s - t;
200	memcpy(buffer, t, len);
201	buffer[len] = '\0';
202	handler(buffer);
203	t = s+1;
204	}
205	handler(t);
206	}
207
208	const char** PathOverrides::parseColonListIntoArray(const char* list)
209	{
210	__block int count = 1;
211	forEachInColonList(list, ^(const char* path) {
212	++count;
213	});
214	const char array = (const char)malloc(countsizeof(char));
215	__block const char** p = array;
216	forEachInColonList(list, ^(const char* path) {
217	*p++ = strdup(path);
218	});
219	*p = nullptr;
220	return array;
221	}
222
223	void PathOverrides::freeArray(const char** array)
224	{
225	if ( array == nullptr )
226	return;
227
228	for (const char** p=array; *p != nullptr; ++p) {
229	free((void)p);
230	}
231	free(array);
232	}
233
234	void PathOverrides::forEachDylibFallback(Platform platform, void (^handler)(const char* fallbackDir, bool& stop)) const
235	{
236	bool stop = false;
237	if ( _dylibPathFallbacks != nullptr ) {
238	for (const char** fp=_dylibPathFallbacks; *fp != nullptr; ++fp) {
239	handler(*fp, stop);
240	if ( stop )
241	return;
242	}
243	}
244	else {
245	switch ( platform ) {
246	case Platform::macOS:
247	// "$HOME/lib"
248	handler("/usr/local/lib", stop); // FIXME: not for restricted processes
249	if ( !stop )
250	handler("/usr/lib", stop);
251	break;
252	case Platform::iOS:
253	case Platform::watchOS:
254	case Platform::tvOS:
255	case Platform::bridgeOS:
256	case Platform::unknown:
257	handler("/usr/local/lib", stop);
258	if ( !stop )
259	handler("/usr/lib", stop);
260	break;
261	}
262	}
263	}
264
265	void PathOverrides::forEachFrameworkFallback(Platform platform, void (^handler)(const char* fallbackDir, bool& stop)) const
266	{
267	bool stop = false;
268	if ( _frameworkPathFallbacks != nullptr ) {
269	for (const char** fp=_frameworkPathFallbacks; *fp != nullptr; ++fp) {
270	handler(*fp, stop);
271	if ( stop )
272	return;
273	}
274	}
275	else {
276	switch ( platform ) {
277	case Platform::macOS:
278	// "$HOME/Library/Frameworks"
279	handler("/Library/Frameworks", stop); // FIXME: not for restricted processes
280	// "/Network/Library/Frameworks"
281	if ( !stop )
282	handler("/System/Library/Frameworks", stop);
283	break;
284	case Platform::iOS:
285	case Platform::watchOS:
286	case Platform::tvOS:
287	case Platform::bridgeOS:
288	case Platform::unknown:
289	handler("/System/Library/Frameworks", stop);
290	break;
291	}
292	}
293	}
294
295	void PathOverrides::forEachPathVariant(const char* initialPath,
296	#if !DYLD_IN_PROCESS
297	Platform platform,
298	#endif
299	void (^handler)(const char* possiblePath, bool& stop)) const
300	{
301	#if DYLD_IN_PROCESS
302	Platform platform = MachOParser::currentPlatform();
303	#endif
304	__block bool stop = false;
305
306	// check for overrides
307	const char* frameworkPartialPath = getFrameworkPartialPath(initialPath);
308	if ( frameworkPartialPath != nullptr ) {
309	const size_t frameworkPartialPathLen = strlen(frameworkPartialPath);
310	// look at each DYLD_FRAMEWORK_PATH directory
311	if ( _frameworkPathOverrides != nullptr ) {
312	for (const char** fp=_frameworkPathOverrides; *fp != nullptr; ++fp) {
313	char npath[strlen(*fp)+frameworkPartialPathLen+8];
314	strcpy(npath, *fp);
315	strcat(npath, "/");
316	strcat(npath, frameworkPartialPath);
317	handler(npath, stop);
318	if ( stop )
319	return;
320	}
321	}
322	}
323	else {
324	const char* libraryLeafName = getLibraryLeafName(initialPath);
325	const size_t libraryLeafNameLen = strlen(libraryLeafName);
326	// look at each DYLD_LIBRARY_PATH directory
327	if ( _dylibPathOverrides != nullptr ) {
328	for (const char** lp=_dylibPathOverrides; *lp != nullptr; ++lp) {
329	char libpath[strlen(*lp)+libraryLeafNameLen+8];
330	strcpy(libpath, *lp);
331	strcat(libpath, "/");
332	strcat(libpath, libraryLeafName);
333	handler(libpath, stop);
334	if ( stop )
335	return;
336	}
337	}
338	}
339
340	// try original path
341	handler(initialPath, stop);
342	if ( stop )
343	return;
344
345	// check fallback paths
346	if ( frameworkPartialPath != nullptr ) {
347	const size_t frameworkPartialPathLen = strlen(frameworkPartialPath);
348	// look at each DYLD_FALLBACK_FRAMEWORK_PATH directory
349	forEachFrameworkFallback(platform, ^(const char* dir, bool& innerStop) {
350	char npath[strlen(dir)+frameworkPartialPathLen+8];
351	strcpy(npath, dir);
352	strcat(npath, "/");
353	strcat(npath, frameworkPartialPath);
354	handler(npath, innerStop);
355	if ( innerStop )
356	stop = innerStop;
357	});
358
359	}
360	else {
361	const char* libraryLeafName = getLibraryLeafName(initialPath);
362	const size_t libraryLeafNameLen = strlen(libraryLeafName);
363	// look at each DYLD_FALLBACK_LIBRARY_PATH directory
364	forEachDylibFallback(platform, ^(const char* dir, bool& innerStop) {
365	char libpath[strlen(dir)+libraryLeafNameLen+8];
366	strcpy(libpath, dir);
367	strcat(libpath, "/");
368	strcat(libpath, libraryLeafName);
369	handler(libpath, innerStop);
370	if ( innerStop )
371	stop = innerStop;
372	});
373	}
374	}
375
376
377	//
378	// Find framework path
379	//
380	// /path/foo.framework/foo => foo.framework/foo
381	// /path/foo.framework/Versions/A/foo => foo.framework/Versions/A/foo
382	// /path/foo.framework/Frameworks/bar.framework/bar => bar.framework/bar
383	// /path/foo.framework/Libraries/bar.dylb => NULL
384	// /path/foo.framework/bar => NULL
385	//
386	// Returns nullptr if not a framework path
387	//
388	const char* PathOverrides::getFrameworkPartialPath(const char* path) const
389	{
390	const char* dirDot = strrstr(path, ".framework/");
391	if ( dirDot != nullptr ) {
392	const char* dirStart = dirDot;
393	for ( ; dirStart >= path; --dirStart) {
394	if ( (*dirStart == '/') \|\| (dirStart == path) ) {
395	const char* frameworkStart = &dirStart[1];
396	if ( dirStart == path )
397	--frameworkStart;
398	size_t len = dirDot - frameworkStart;
399	char framework[len+1];
400	strncpy(framework, frameworkStart, len);
401	framework[len] = '\0';
402	const char* leaf = strrchr(path, '/');
403	if ( leaf != nullptr ) {
404	if ( strcmp(framework, &leaf[1]) == 0 ) {
405	return frameworkStart;
406	}
407	if ( _imageSuffix != nullptr ) {
408	// some debug frameworks have install names that end in _debug
409	if ( strncmp(framework, &leaf[1], len) == 0 ) {
410	if ( strcmp( _imageSuffix, &leaf[len+1]) == 0 )
411	return frameworkStart;
412	}
413	}
414	}
415	}
416	}
417	}
418	return nullptr;
419	}
420
421
422	const char* PathOverrides::getLibraryLeafName(const char* path)
423	{
424	const char* start = strrchr(path, '/');
425	if ( start != nullptr )
426	return &start[1];
427	else
428	return path;
429	}
430
431	} // namespace dyld3
432
433
434
435
436