1/*	$OpenBSD: library_subr.c,v 1.55 2023/04/27 12:27:56 robert Exp $ */
2
3/*
4 * Copyright (c) 2002 Dale Rahn
5 * Copyright (c) 1998 Per Fogelstrom, Opsycon AB
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
17 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 */
29
30#define _DYN_LOADER
31
32#include <sys/types.h>
33#include <sys/queue.h>
34#include <limits.h>
35#include <dirent.h>
36
37#include "util.h"
38#include "resolve.h"
39#include "dir.h"
40#include "sod.h"
41
42char * _dl_default_path[2] = { "/usr/lib", NULL };
43
44
45/* STATIC DATA */
46struct dlochld _dlopened_child_list;
47
48
49/*
50 * _dl_match_file()
51 *
52 * This function determines if a given name matches what is specified
53 * in a struct sod. The major must match exactly, and the minor must
54 * be same or larger.
55 *
56 * sodp is updated with the minor if this matches.
57 */
58
59int
60_dl_match_file(struct sod *sodp, const char *name, int namelen)
61{
62	int match;
63	struct sod lsod;
64	const char *lname;
65
66	lname = name;
67	if (sodp->sod_library) {
68		if (_dl_strncmp(name, "lib", 3))
69			return 0;
70		lname += 3;
71	}
72	if (_dl_strncmp(lname, (char *)sodp->sod_name,
73	    _dl_strlen((char *)sodp->sod_name)))
74		return 0;
75
76	_dl_build_sod(name, &lsod);
77
78	match = 0;
79	if ((_dl_strcmp((char *)lsod.sod_name, (char *)sodp->sod_name) == 0) &&
80	    (lsod.sod_library == sodp->sod_library) &&
81	    ((sodp->sod_major == -1) || (sodp->sod_major == lsod.sod_major)) &&
82	    ((sodp->sod_minor == -1) ||
83	    (lsod.sod_minor >= sodp->sod_minor))) {
84		match = 1;
85
86		/* return version matched */
87		sodp->sod_major = lsod.sod_major;
88		sodp->sod_minor = lsod.sod_minor;
89	}
90	_dl_free((char *)lsod.sod_name);
91	return match;
92}
93
94/*
95 * _dl_cmp_sod()
96 *
97 * This function compares sod structs. The major must match exactly,
98 * and the minor must be same or larger.
99 *
100 * sodp is updated with the minor if this matches.
101 */
102
103static int
104_dl_cmp_sod(struct sod *sodp, const struct sod *lsod)
105{
106	int match;
107
108	match = 1;
109	if ((_dl_strcmp((char *)lsod->sod_name, (char *)sodp->sod_name) == 0) &&
110	    (lsod->sod_library == sodp->sod_library) &&
111	    ((sodp->sod_major == -1) || (sodp->sod_major == lsod->sod_major)) &&
112	    ((sodp->sod_minor == -1) ||
113	    (lsod->sod_minor >= sodp->sod_minor))) {
114		match = 0;
115
116		/* return version matched */
117		sodp->sod_major = lsod->sod_major;
118		sodp->sod_minor = lsod->sod_minor;
119	}
120	return match;
121}
122
123char _dl_hint_store[PATH_MAX];
124
125char *
126_dl_find_shlib(struct sod *sodp, char **searchpath, int nohints)
127{
128	char *hint, **pp;
129	struct dirent *dp;
130	int match, len;
131	_dl_DIR *dd;
132	struct sod tsod, bsod;		/* transient and best sod */
133
134	/* if we are to search default directories, and hints
135	 * are not to be used, search the standard path from ldconfig
136	 * (_dl_hint_search_path) or use the default path
137	 */
138	if (nohints)
139		goto nohints;
140
141	if (searchpath == NULL) {
142		/* search 'standard' locations, find any match in the hints */
143		hint = _dl_findhint((char *)sodp->sod_name, sodp->sod_major,
144		    sodp->sod_minor, NULL);
145		if (hint)
146			return hint;
147	} else {
148		/* search hints requesting matches for only
149		 * the searchpath directories,
150		 */
151		for (pp = searchpath; *pp != NULL; pp++) {
152			hint = _dl_findhint((char *)sodp->sod_name,
153			    sodp->sod_major, sodp->sod_minor, *pp);
154			if (hint != NULL)
155				return hint;
156		}
157	}
158
159	/*
160	 * For each directory in the searchpath, read the directory
161	 * entries looking for a match to sod. filename compare is
162	 * done by _dl_match_file()
163	 */
164nohints:
165	if (searchpath == NULL) {
166		if (_dl_hint_search_path != NULL)
167			searchpath = _dl_hint_search_path;
168		else
169			searchpath = _dl_default_path;
170	}
171	_dl_memset(&bsod, 0, sizeof(bsod));
172	for (pp = searchpath; *pp != NULL; pp++) {
173		if ((dd = _dl_opendir(*pp)) != NULL) {
174			match = 0;
175			while ((dp = _dl_readdir(dd)) != NULL) {
176				tsod = *sodp;
177				if (_dl_match_file(&tsod, dp->d_name,
178				    dp->d_namlen)) {
179					/*
180					 * When a match is found, tsod is
181					 * updated with the major+minor found.
182					 * This version is compared with the
183					 * largest so far (kept in bsod),
184					 * and saved if larger.
185					 */
186					if (!match ||
187					    tsod.sod_major == -1 ||
188					    tsod.sod_major > bsod.sod_major ||
189					    ((tsod.sod_major ==
190					    bsod.sod_major) &&
191					    tsod.sod_minor > bsod.sod_minor)) {
192						bsod = tsod;
193						match = 1;
194						len = _dl_strlcpy(
195						    _dl_hint_store, *pp,
196						    PATH_MAX);
197						if (pp[0][len-1] != '/') {
198							_dl_hint_store[len] =
199							    '/';
200							len++;
201						}
202						_dl_strlcpy(
203						    &_dl_hint_store[len],
204						    dp->d_name,
205						    PATH_MAX-len);
206						if (tsod.sod_major == -1)
207							break;
208					}
209				}
210			}
211			_dl_closedir(dd);
212			if (match) {
213				*sodp = bsod;
214				return (_dl_hint_store);
215			}
216		}
217	}
218	return NULL;
219}
220
221static elf_object_t *
222_dl_lookup_object(const char *req_name, struct sod *req_sod)
223{
224	elf_object_t *object = _dl_objects;
225
226	while (object) {
227		char *soname;
228
229		if (_dl_cmp_sod(req_sod, &object->sod) == 0)
230			return(object);
231
232		soname = (char *)object->Dyn.info[DT_SONAME];
233		if (soname != NULL) {
234			if (_dl_strcmp(req_name, soname) == 0)
235				return(object);
236		}
237
238		object = object->next;
239	}
240
241	return(NULL);
242}
243
244void
245_dl_handle_already_loaded(elf_object_t *object, int flags)
246{
247	object->obj_flags |= flags & DF_1_GLOBAL;
248	if (_dl_loading_object == NULL)
249		_dl_loading_object = object;
250	if (object->load_object != _dl_objects &&
251	    object->load_object != _dl_loading_object) {
252		_dl_link_grpref(object->load_object, _dl_loading_object);
253	}
254}
255
256static elf_object_t *
257_dl_find_loaded_shlib(const char *req_name, struct sod req_sod, int flags)
258{
259	elf_object_t *object;
260
261	object = _dl_lookup_object(req_name, &req_sod);
262
263	/* if not found retry with any minor */
264	if (object == NULL && req_sod.sod_library && req_sod.sod_minor != -1) {
265		short orig_minor = req_sod.sod_minor;
266		req_sod.sod_minor = -1;
267		object = _dl_lookup_object(req_name, &req_sod);
268
269		if (object != NULL && req_sod.sod_minor < orig_minor)
270			_dl_printf("warning: lib%s.so.%d.%d: "
271			    "minor version >= %d expected, "
272			    "using it anyway\n",
273			    req_sod.sod_name, req_sod.sod_major,
274			    req_sod.sod_minor, orig_minor);
275	}
276
277	if (object)
278		_dl_handle_already_loaded(object, flags);
279
280	return (object);
281}
282
283/*
284 *  Load a shared object. Search order is:
285 *      First check loaded objects for a matching shlib, otherwise:
286 *
287 *	If the name contains a '/' use only the path preceding the
288 *	library name and do not continue on to other methods if not
289 *	found.
290 *	   search hints for match in path preceding library name
291 *	     this will only match specific library version.
292 *	   search path preceding library name
293 *	     this will find largest minor version in path provided
294 *
295 *	Otherwise, the name doesn't contain a '/':
296 *	search hints for the specific library version, trying in turn
297 *	paths from the following:
298 *	  - the LD_LIBRARY_PATH environment variable (if set)
299 *	  - the library's own DT_RUNPATH
300 *	  - if DT_RUNPATH wasn't set, then:
301 *	    - the library's own DT_RPATH
302 *	    - the executable's own DT_RPATH
303 *	  - the default search path set by ldconfig, or /usr/lib if unset
304 *
305 *	If the hints doesn't have an exact match, then we search
306 *	that exact same list of directories again, looking for a
307 *	lib with the correct major version.  If we find a match on
308 *	the major, then we take the match *in that directory* which
309 *	has the largest minor version
310 */
311
312elf_object_t *
313_dl_load_shlib(const char *libname, elf_object_t *parent, int type, int flags,
314    int nodelete)
315{
316	int try_any_minor, ignore_hints;
317	struct sod sod, req_sod;
318	elf_object_t *object = NULL;
319	char *hint;
320
321	try_any_minor = 0;
322	ignore_hints = 0;
323
324	if (_dl_strchr(libname, '/')) {
325		char *paths[2];
326		char *lpath, *lname;
327		lpath = _dl_strdup(libname);
328		if (lpath == NULL)
329			_dl_oom();
330		lname = _dl_strrchr(lpath, '/');
331		if (lname == NULL) {
332			_dl_free(lpath);
333			_dl_errno = DL_NOT_FOUND;
334			return (object);
335		}
336		*lname = '\0';
337		lname++;
338		if (*lname  == '\0') {
339			_dl_free(lpath);
340			_dl_errno = DL_NOT_FOUND;
341			return (object);
342		}
343
344		_dl_build_sod(lname, &sod);
345		req_sod = sod;
346
347		paths[0] = lpath;
348		paths[1] = NULL;
349fullpathagain:
350		hint = _dl_find_shlib(&req_sod, paths, ignore_hints);
351		if (hint != NULL)
352			goto fullpathdone;
353
354		if (try_any_minor == 0) {
355			try_any_minor = 1;
356			ignore_hints = 1;
357			req_sod.sod_minor = -1;
358			goto fullpathagain;
359		}
360		_dl_errno = DL_NOT_FOUND;
361fullpathdone:
362		_dl_free(lpath);
363		goto done;
364	}
365
366	_dl_build_sod(libname, &sod);
367	req_sod = sod;
368
369	object = _dl_find_loaded_shlib(libname, req_sod, flags);
370	if (object) {
371		_dl_free((char *)sod.sod_name);
372		return (object);
373	}
374
375again:
376	/* No '/' in name. Scan the known places, LD_LIBRARY_PATH first.  */
377	if (_dl_libpath != NULL) {
378		hint = _dl_find_shlib(&req_sod, _dl_libpath, ignore_hints);
379		if (hint != NULL)
380			goto done;
381	}
382
383	/* Check DT_RUNPATH */
384	if (parent->runpath != NULL) {
385		hint = _dl_find_shlib(&req_sod, parent->runpath, ignore_hints);
386		if (hint != NULL)
387			goto done;
388	} else {
389		/*
390		 * If DT_RUNPATH wasn't set then first check DT_RPATH,
391		 * followed by the main program's DT_RPATH.
392		 */
393		if (parent->rpath != NULL) {
394			hint = _dl_find_shlib(&req_sod, parent->rpath,
395			    ignore_hints);
396			if (hint != NULL)
397				goto done;
398		}
399		if (parent != _dl_objects && _dl_objects->rpath != NULL) {
400			hint = _dl_find_shlib(&req_sod, _dl_objects->rpath,
401			    ignore_hints);
402			if (hint != NULL)
403				goto done;
404		}
405	}
406
407	/* check 'standard' locations */
408	hint = _dl_find_shlib(&req_sod, NULL, ignore_hints);
409	if (hint != NULL)
410		goto done;
411
412	if (try_any_minor == 0) {
413		try_any_minor = 1;
414		ignore_hints = 1;
415		req_sod.sod_minor = -1;
416		goto again;
417	}
418	_dl_errno = DL_NOT_FOUND;
419done:
420	if (hint != NULL) {
421		if (req_sod.sod_minor < sod.sod_minor)
422			_dl_printf("warning: lib%s.so.%d.%d: "
423			    "minor version >= %d expected, "
424			    "using it anyway\n",
425			    sod.sod_name, sod.sod_major,
426			    req_sod.sod_minor, sod.sod_minor);
427		object = _dl_tryload_shlib(hint, type, flags, nodelete);
428	}
429	_dl_free((char *)sod.sod_name);
430	return(object);
431}
432
433
434void
435_dl_link_dlopen(elf_object_t *dep)
436{
437	struct dep_node *n;
438
439	dep->opencount++;
440
441	if (OBJECT_DLREF_CNT(dep) > 1)
442		return;
443
444	n = _dl_malloc(sizeof *n);
445	if (n == NULL)
446		_dl_oom();
447
448	n->data = dep;
449	TAILQ_INSERT_TAIL(&_dlopened_child_list, n, next_sib);
450
451	DL_DEB(("linking %s as dlopen()ed\n", dep->load_name));
452}
453
454static void
455_dl_child_refcnt_decrement(elf_object_t *object)
456{
457	struct object_vector vec;
458	int i;
459
460	object->refcount--;
461	if (OBJECT_REF_CNT(object) == 0)
462		for (vec = object->child_vec, i = 0; i < vec.len; i++)
463			_dl_child_refcnt_decrement(vec.vec[i]);
464}
465
466void
467_dl_notify_unload_shlib(elf_object_t *object)
468{
469	struct object_vector vec;
470	struct dep_node *n;
471	int i;
472
473	if (OBJECT_REF_CNT(object) == 0)
474		for (vec = object->child_vec, i = 0; i < vec.len; i++)
475			_dl_child_refcnt_decrement(vec.vec[i]);
476
477	if (OBJECT_DLREF_CNT(object) == 0) {
478		while ((n = TAILQ_FIRST(&object->grpref_list)) != NULL) {
479			TAILQ_REMOVE(&object->grpref_list, n, next_sib);
480			n->data->grprefcount--;
481			_dl_notify_unload_shlib(n->data);
482			_dl_free(n);
483		}
484	}
485}
486
487void
488_dl_unload_dlopen(void)
489{
490	struct dep_node *node;
491
492	TAILQ_FOREACH_REVERSE(node, &_dlopened_child_list, dlochld, next_sib) {
493		/* dont dlclose the main program */
494		if (node->data == _dl_objects)
495			continue;
496
497		while (node->data->opencount > 0) {
498			node->data->opencount--;
499			_dl_notify_unload_shlib(node->data);
500			_dl_run_all_dtors();
501		}
502	}
503}
504
505void
506_dl_link_grpref(elf_object_t *load_group, elf_object_t *load_object)
507{
508	struct dep_node *n;
509
510	n = _dl_malloc(sizeof *n);
511	if (n == NULL)
512		_dl_oom();
513	n->data = load_group;
514	TAILQ_INSERT_TAIL(&load_object->grpref_list, n, next_sib);
515	load_group->grprefcount++;
516}
517
518void
519_dl_link_child(elf_object_t *dep, elf_object_t *p)
520{
521	int i;
522
523	i = p->child_vec.len++;
524	if (i == p->child_vec.alloc)
525		_dl_die("child appeared  %d > %d", p->child_vec.len,
526		    p->child_vec.alloc);
527	p->child_vec.vec[i] = dep;
528
529	dep->refcount++;
530
531	DL_DEB(("linking dep %s as child of %s\n", dep->load_name,
532	    p->load_name));
533}
534
535void
536object_vec_grow(struct object_vector *vec, int more)
537{
538	vec->alloc += more;
539	vec->vec = _dl_reallocarray(vec->vec, vec->alloc, sizeof(*vec->vec));
540	if (vec->vec == NULL)
541		_dl_oom();
542}
543
544/* Generation number of the current grpsym insertion/caching */
545static unsigned int _dl_grpsym_gen = 0;
546
547void
548_dl_link_grpsym(elf_object_t *object)
549{
550	struct object_vector *vec;
551	int len;
552
553	if (object->grpsym_gen == _dl_grpsym_gen)
554		return;
555	object->grpsym_gen = _dl_grpsym_gen;
556
557	vec = &_dl_loading_object->grpsym_vec;
558	len = vec->len++;
559	if (len >= vec->alloc)
560		_dl_die("more grpsym than objects?!  %d > %d", vec->len,
561		    vec->alloc);
562	vec->vec[len] = object;
563}
564
565void
566_dl_cache_grpsym_list_setup(elf_object_t *object)
567{
568	struct object_vector *vec;
569	int next;
570
571	_dl_grpsym_gen += 1;
572
573	if (_dl_grpsym_gen == 0) {
574		/*
575		 * If the count rolls over, reset all counters so
576		 * we don't get accidental collision.
577		 */
578		elf_object_t *walkobj;
579		for (walkobj = _dl_objects;
580		    walkobj != NULL;
581		    walkobj = walkobj->next) {
582			walkobj->grpsym_gen = 0;
583		}
584		_dl_grpsym_gen = 1;
585	}
586
587	/*
588	 * grpsym_vec is a vector of all child libs of the
589	 * _dl_loading_object with no dups. The order is equivalent
590	 * to a breadth-first traversal of the child list without dups.
591	 */
592
593	vec = &object->grpsym_vec;
594	object_vec_grow(vec, object_count);
595	next = 0;
596
597	/* add first object manually */
598	_dl_link_grpsym(object);
599
600	while (next < vec->len) {
601		struct object_vector child_vec;
602		int i;
603
604		child_vec = vec->vec[next++]->child_vec;
605		for (i = 0; i < child_vec.len; i++)
606			_dl_link_grpsym(child_vec.vec[i]);
607	}
608}
609