xref: /titanic_50/usr/src/cmd/sgs/libld/common/ldlibs.c (revision faac71c002f7c7a98741f991b25937b24f309df0)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  *	Copyright (c) 1988 AT&T
24  *	  All Rights Reserved
25  *
26  * Copyright (c) 1992, 2010, Oracle and/or its affiliates. All rights reserved.
27  */
28 /*
29  * Copyright (c) 2012, Joyent, Inc.  All rights reserved.
30  */
31 
32 /*
33  * Library processing
34  */
35 #include	<stdio.h>
36 #include	<unistd.h>
37 #include	<fcntl.h>
38 #include	<string.h>
39 #include	<limits.h>
40 #include	<errno.h>
41 #include	<debug.h>
42 #include	<sys/sysmacros.h>
43 #include	"msg.h"
44 #include	"_libld.h"
45 
46 /*
47  * Define a list index for "-L" processing.  By default, "-L" search paths are
48  * inserted at the beginning of the associated search list.  However, should a
49  * ";" be discovered in a LD_LIBRARY_PATH listing, then any new "-L" search
50  * paths are inserted following the ";".
51  */
52 static Aliste	Lidx = 0;
53 
54 /*
55  * Function to handle -YL and -YU substitutions in LIBPATH.  It's probably
56  * very unlikely that the link-editor will ever see this, as any use of these
57  * options is normally processed by the compiler driver first and the finished
58  * -YP string is sent to us.  The fact that these two options are not even
59  * documented anymore makes it even more unlikely this processing will occur.
60  */
61 static char *
62 compat_YL_YU(Ofl_desc *ofl, char *path, int index)
63 {
64 	if (index == YLDIR) {
65 		if (Llibdir) {
66 			/*
67 			 * User supplied "-YL,libdir", this is the pathname that
68 			 * corresponds for compatibility to -YL (as defined in
69 			 * sgs/include/paths.h)
70 			 */
71 			DBG_CALL(Dbg_libs_ylu(ofl->ofl_lml, Llibdir,
72 			    path, index));
73 			return (Llibdir);
74 		}
75 	} else if (index == YUDIR) {
76 		if (Ulibdir) {
77 			/*
78 			 * User supplied "-YU,libdir", this is the pathname that
79 			 * corresponds for compatibility to -YU (as defined in
80 			 * sgs/include/paths.h)
81 			 */
82 			DBG_CALL(Dbg_libs_ylu(ofl->ofl_lml, Ulibdir,
83 			    path, index));
84 			return (Ulibdir);
85 		}
86 	}
87 	return (path);
88 }
89 
90 static char *
91 process_lib_path(Ofl_desc *ofl, APlist **apl, char *path, Boolean subsflag)
92 {
93 	int	i;
94 	char	*cp;
95 	Boolean	seenflg = FALSE;
96 	char	*dot = (char *)MSG_ORIG(MSG_STR_DOT);
97 
98 	for (i = YLDIR; i; i++) {
99 		cp = strpbrk(path, MSG_ORIG(MSG_STR_PATHTOK));
100 		if (cp == NULL) {
101 			if (*path == '\0') {
102 				if (seenflg)
103 					if (aplist_append(apl, (subsflag ?
104 					    compat_YL_YU(ofl, dot, i) : dot),
105 					    AL_CNT_OFL_LIBDIRS) == NULL)
106 						return ((char *)S_ERROR);
107 
108 			} else if (aplist_append(apl, (subsflag ?
109 			    compat_YL_YU(ofl, path, i) : path),
110 			    AL_CNT_OFL_LIBDIRS) == NULL) {
111 				return ((char *)S_ERROR);
112 			}
113 			return (cp);
114 		}
115 
116 		if (*cp == ':') {
117 			*cp = '\0';
118 			if (cp == path) {
119 				if (aplist_append(apl, (subsflag ?
120 				    compat_YL_YU(ofl, dot, i) : dot),
121 				    AL_CNT_OFL_LIBDIRS) == NULL)
122 					return ((char *)S_ERROR);
123 
124 			} else if (aplist_append(apl, (subsflag ?
125 			    compat_YL_YU(ofl, path, i) : path),
126 			    AL_CNT_OFL_LIBDIRS) == NULL) {
127 				return ((char *)S_ERROR);
128 			}
129 			path = cp + 1;
130 			seenflg = TRUE;
131 			continue;
132 		}
133 
134 		/* case ";" */
135 
136 		if (cp != path) {
137 			if (aplist_append(apl, (subsflag ?
138 			    compat_YL_YU(ofl, path, i) : path),
139 			    AL_CNT_OFL_LIBDIRS) == NULL)
140 				return ((char *)S_ERROR);
141 		} else {
142 			if (seenflg)
143 				if (aplist_append(apl, (subsflag ?
144 				    compat_YL_YU(ofl, dot, i) : dot),
145 				    AL_CNT_OFL_LIBDIRS) == NULL)
146 					return ((char *)S_ERROR);
147 		}
148 		return (cp);
149 	}
150 	/* NOTREACHED */
151 	return (NULL);	/* keep gcc happy */
152 }
153 
154 /*
155  * adds the indicated path to those to be searched for libraries.
156  */
157 uintptr_t
158 ld_add_libdir(Ofl_desc *ofl, const char *path)
159 {
160 	if (aplist_insert(&ofl->ofl_ulibdirs, path,
161 	    AL_CNT_OFL_LIBDIRS, Lidx++) == NULL)
162 		return (S_ERROR);
163 
164 	/*
165 	 * As -l and -L options can be interspersed, print the library
166 	 * search paths each time a new path is added.
167 	 */
168 	DBG_CALL(Dbg_libs_update(ofl->ofl_lml, ofl->ofl_ulibdirs,
169 	    ofl->ofl_dlibdirs));
170 	return (1);
171 }
172 
173 /*
174  * Process a required library.  Combine the directory and filename, and then
175  * append either a `.so' or `.a' suffix and try opening the associated pathname.
176  */
177 static uintptr_t
178 find_lib_name(const char *dir, const char *file, Ofl_desc *ofl, Rej_desc *rej,
179     ofl_flag_t flags)
180 {
181 	int		fd;
182 	size_t		dlen;
183 	char		*_path, path[PATH_MAX + 2];
184 	const char	*_dir = dir;
185 	uintptr_t	open_ret;
186 
187 	/*
188 	 * Determine the size of the directory.  The directory and filename are
189 	 * concatenated into the local buffer which is purposely larger than
190 	 * PATH_MAX.  Should a pathname be created that exceeds the system
191 	 * limit, the open() will catch it, and a suitable rejection message is
192 	 * saved.
193 	 */
194 	if ((dlen = strlen(dir)) == 0) {
195 		_dir = (char *)MSG_ORIG(MSG_STR_DOT);
196 		dlen = 1;
197 	}
198 	dlen++;
199 
200 	/*
201 	 * If we are in dynamic mode try and open the associated shared object.
202 	 */
203 	if (ofl->ofl_flags & FLG_OF_DYNLIBS) {
204 		(void) snprintf(path, (PATH_MAX + 2), MSG_ORIG(MSG_STR_LIB_SO),
205 		    _dir, file);
206 		DBG_CALL(Dbg_libs_l(ofl->ofl_lml, file, path));
207 		if ((fd = open(path, O_RDONLY)) != -1) {
208 
209 			if ((_path = libld_malloc(strlen(path) + 1)) == NULL)
210 				return (S_ERROR);
211 			(void) strcpy(_path, path);
212 
213 			open_ret = ld_process_open(_path, &_path[dlen], &fd,
214 			    ofl, FLG_IF_NEEDED, rej, NULL);
215 			if (fd != -1)
216 				(void) close(fd);
217 			if (open_ret != 0 && (flags & FLG_OF_ADEFLIB))
218 				ld_eprintf(ofl, ERR_WARNING,
219 				    MSG_INTL(MSG_ARG_ASSDEFLIB_FOUND), dir,
220 				    file);
221 			return (open_ret);
222 
223 		} else if (errno != ENOENT) {
224 			/*
225 			 * If the open() failed for anything other than the
226 			 * file not existing, record the error condition.
227 			 */
228 			rej->rej_type = SGS_REJ_STR;
229 			rej->rej_str = strerror(errno);
230 			rej->rej_name = strdup(path);
231 		}
232 	}
233 
234 	/*
235 	 * If we are not in dynamic mode, or a shared object could not be
236 	 * located, try and open the associated archive.
237 	 */
238 	(void) snprintf(path, (PATH_MAX + 2), MSG_ORIG(MSG_STR_LIB_A),
239 	    _dir, file);
240 	DBG_CALL(Dbg_libs_l(ofl->ofl_lml, file, path));
241 	if ((fd = open(path, O_RDONLY)) != -1) {
242 
243 		if ((_path = libld_malloc(strlen(path) + 1)) == NULL)
244 			return (S_ERROR);
245 		(void) strcpy(_path, path);
246 
247 		open_ret = ld_process_open(_path, &_path[dlen], &fd, ofl,
248 		    FLG_IF_NEEDED, rej, NULL);
249 		if (fd != -1)
250 			(void) close(fd);
251 		return (open_ret);
252 
253 	} else if (errno != ENOENT) {
254 		/*
255 		 * If the open() failed for anything other than the
256 		 * file not existing, record the error condition.
257 		 */
258 		rej->rej_type = SGS_REJ_STR;
259 		rej->rej_str = strerror(errno);
260 		rej->rej_name = strdup(path);
261 	}
262 
263 	return (0);
264 }
265 
266 /*
267  * Take the abbreviated name of a library file (from -lfoo) and searches for the
268  * library.  The search path rules are:
269  *
270  *	o	use any user supplied paths, i.e. LD_LIBRARY_PATH and -L, then
271  *
272  *	o	use the default directories, i.e. LIBPATH or -YP.
273  *
274  * If we are in dynamic mode and -Bstatic is not in effect, first look for a
275  * shared object with full name: path/libfoo.so; then [or else] look for an
276  * archive with name: path/libfoo.a.  If no file is found, it's a fatal error,
277  * otherwise process the file appropriately depending on its type.
278  *
279  * If we end up using the default directories and -z assert-deflib has been
280  * turned on, then we pass that information down into find_lib_name which will
281  * warn appropriately if we find a shared object.
282  */
283 uintptr_t
284 ld_find_library(const char *name, Ofl_desc *ofl)
285 {
286 	Aliste		idx;
287 	char		*path;
288 	uintptr_t	open_ret;
289 	Rej_desc	rej = { 0 };
290 	ofl_flag_t	flags = 0;
291 
292 	/*
293 	 * Search for this file in any user defined directories.
294 	 */
295 	for (APLIST_TRAVERSE(ofl->ofl_ulibdirs, idx, path)) {
296 		Rej_desc	_rej = { 0 };
297 
298 		if ((open_ret = find_lib_name(path, name, ofl, &_rej,
299 		    flags)) == 0) {
300 			if (_rej.rej_type && (rej.rej_type == 0))
301 				rej = _rej;
302 			continue;
303 		}
304 		return (open_ret);
305 	}
306 
307 	if (ofl->ofl_flags & FLG_OF_ADEFLIB) {
308 		flags |= FLG_OF_ADEFLIB;
309 		for (APLIST_TRAVERSE(ofl->ofl_assdeflib, idx, path)) {
310 			if (strncmp(name, path + MSG_STR_LIB_SIZE,
311 			    MAX(strlen(path + MSG_STR_LIB_SIZE) -
312 			    MSG_STR_SOEXT_SIZE, strlen(name))) == 0) {
313 				flags &= ~FLG_OF_ADEFLIB;
314 				break;
315 			}
316 		}
317 	}
318 
319 	/*
320 	 * Finally try the default library search directories.
321 	 */
322 	for (APLIST_TRAVERSE(ofl->ofl_dlibdirs, idx, path)) {
323 		Rej_desc	_rej = { 0 };
324 
325 		if ((open_ret = find_lib_name(path, name, ofl, &_rej,
326 		    flags)) == 0) {
327 			if (_rej.rej_type && (rej.rej_type == 0))
328 				rej = _rej;
329 			continue;
330 		}
331 
332 		return (open_ret);
333 	}
334 
335 	/*
336 	 * If we've got this far we haven't found a shared object or archive.
337 	 * If an object was found, but was rejected for some reason, print a
338 	 * diagnostic to that effect, otherwise generate a generic "not found"
339 	 * diagnostic.
340 	 */
341 	if (rej.rej_type) {
342 		Conv_reject_desc_buf_t rej_buf;
343 
344 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(reject[rej.rej_type]),
345 		    rej.rej_name ? rej.rej_name : MSG_INTL(MSG_STR_UNKNOWN),
346 		    conv_reject_desc(&rej, &rej_buf, ld_targ.t_m.m_mach));
347 	} else {
348 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_LIB_NOTFOUND), name);
349 	}
350 
351 	return (0);
352 }
353 
354 /*
355  * Inspect the LD_LIBRARY_PATH variable (if the -i options has not been
356  * specified), and set up the directory list from which to search for
357  * libraries.  From the man page:
358  *
359  *	LD_LIBRARY_PATH=dirlist1;dirlist2
360  * and
361  *	ld ... -Lpath1 ... -Lpathn ...
362  *
363  * results in a search order of:
364  *
365  *	dirlist1 path1 ... pathn dirlist2 LIBPATH
366  *
367  * If LD_LIBRARY_PATH has no `;' specified, the pathname(s) supplied are
368  * all taken as dirlist2.
369  */
370 uintptr_t
371 ld_lib_setup(Ofl_desc *ofl)
372 {
373 	char	*path, *cp = NULL;
374 
375 	/*
376 	 * Determine whether an LD_LIBRARY_PATH setting is in effect.
377 	 */
378 	if (!(ofl->ofl_flags & FLG_OF_IGNENV)) {
379 #if	defined(_ELF64)
380 		if ((cp = getenv(MSG_ORIG(MSG_LD_LIBPATH_64))) == NULL)
381 #else
382 		if ((cp = getenv(MSG_ORIG(MSG_LD_LIBPATH_32))) == NULL)
383 #endif
384 			cp  = getenv(MSG_ORIG(MSG_LD_LIBPATH));
385 	}
386 
387 	if (cp && cp[0]) {
388 		if ((path = libld_malloc(strlen(cp) + 1)) == NULL)
389 			return (S_ERROR);
390 		(void) strcpy(path, cp);
391 		DBG_CALL(Dbg_libs_path(ofl->ofl_lml, path, LA_SER_DEFAULT, 0));
392 
393 		/*
394 		 * Process the first path string (anything up to a null or
395 		 * a `;');
396 		 */
397 		path = process_lib_path(ofl, &ofl->ofl_ulibdirs, path, FALSE);
398 
399 
400 		/*
401 		 * By default, -L paths are prepended to the library search
402 		 * path list, because Lidx == 0.  If a ';' is seen within an
403 		 * LD_LIBRARY_PATH string, change the insert index so that -L
404 		 * paths are added following the ';'.
405 		 */
406 		if (path) {
407 			Lidx = aplist_nitems(ofl->ofl_ulibdirs);
408 			*path = '\0';
409 			++path;
410 			cp = process_lib_path(ofl, &ofl->ofl_ulibdirs, path,
411 			    FALSE);
412 			if (cp == (char *)S_ERROR)
413 				return (S_ERROR);
414 			else if (cp)
415 				ld_eprintf(ofl, ERR_WARNING,
416 				    MSG_INTL(MSG_LIB_MALFORM));
417 		}
418 	}
419 
420 	/*
421 	 * Add the default LIBPATH or any -YP supplied path.
422 	 */
423 	DBG_CALL(Dbg_libs_yp(ofl->ofl_lml, Plibpath));
424 	cp = process_lib_path(ofl, &ofl->ofl_dlibdirs, Plibpath, TRUE);
425 	if (cp == (char *)S_ERROR)
426 		return (S_ERROR);
427 	else if (cp) {
428 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_LIB_BADYP));
429 		return (S_ERROR);
430 	}
431 	DBG_CALL(Dbg_libs_init(ofl->ofl_lml, ofl->ofl_ulibdirs,
432 	    ofl->ofl_dlibdirs));
433 	return (1);
434 }
435