xref: /illumos-gate/usr/src/cmd/sgs/rtld/common/util.c (revision b71d513a)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
55aefb655Srie  * Common Development and Distribution License (the "License").
65aefb655Srie  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
21fb1354edSrie 
227c478bd9Sstevel@tonic-gate /*
237c478bd9Sstevel@tonic-gate  *	Copyright (c) 1988 AT&T
247c478bd9Sstevel@tonic-gate  *	  All Rights Reserved
257c478bd9Sstevel@tonic-gate  *
26cce0e03bSab  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
277c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
287c478bd9Sstevel@tonic-gate  */
297c478bd9Sstevel@tonic-gate #pragma ident	"%Z%%M%	%I%	%E% SMI"
307c478bd9Sstevel@tonic-gate 
317c478bd9Sstevel@tonic-gate /*
327c478bd9Sstevel@tonic-gate  * Utility routines for run-time linker.  some are duplicated here from libc
337c478bd9Sstevel@tonic-gate  * (with different names) to avoid name space collisions.
347c478bd9Sstevel@tonic-gate  */
357c478bd9Sstevel@tonic-gate #include	"_synonyms.h"
367c478bd9Sstevel@tonic-gate #include	<stdio.h>
377c478bd9Sstevel@tonic-gate #include	<sys/types.h>
387c478bd9Sstevel@tonic-gate #include	<sys/mman.h>
397c478bd9Sstevel@tonic-gate #include	<sys/lwp.h>
407c478bd9Sstevel@tonic-gate #include	<sys/debug.h>
417c478bd9Sstevel@tonic-gate #include	<stdarg.h>
427c478bd9Sstevel@tonic-gate #include	<fcntl.h>
437c478bd9Sstevel@tonic-gate #include	<string.h>
447c478bd9Sstevel@tonic-gate #include	<ctype.h>
457c478bd9Sstevel@tonic-gate #include	<dlfcn.h>
467c478bd9Sstevel@tonic-gate #include	<unistd.h>
477c478bd9Sstevel@tonic-gate #include	<stdlib.h>
487c478bd9Sstevel@tonic-gate #include	<sys/auxv.h>
495aefb655Srie #include	<debug.h>
505aefb655Srie #include	<conv.h>
517c478bd9Sstevel@tonic-gate #include	"_rtld.h"
527c478bd9Sstevel@tonic-gate #include	"_audit.h"
5310a4fa49Srie #include	"_elf.h"
547c478bd9Sstevel@tonic-gate #include	"msg.h"
557c478bd9Sstevel@tonic-gate 
567c478bd9Sstevel@tonic-gate static int ld_flags_env(const char *, Word *, Word *, uint_t, int);
577c478bd9Sstevel@tonic-gate 
587c478bd9Sstevel@tonic-gate /*
597c478bd9Sstevel@tonic-gate  * All error messages go through eprintf().  During process initialization these
607c478bd9Sstevel@tonic-gate  * messages should be directed to the standard error, however once control has
617c478bd9Sstevel@tonic-gate  * been passed to the applications code these messages should be stored in an
627c478bd9Sstevel@tonic-gate  * internal buffer for use with dlerror().  Note, fatal error conditions that
637c478bd9Sstevel@tonic-gate  * may occur while running the application will still cause a standard error
647c478bd9Sstevel@tonic-gate  * message, see rtldexit() in this file for details.
657c478bd9Sstevel@tonic-gate  * The `application' flag serves to indicate the transition between process
667c478bd9Sstevel@tonic-gate  * initialization and when the applications code is running.
677c478bd9Sstevel@tonic-gate  */
687c478bd9Sstevel@tonic-gate 
697c478bd9Sstevel@tonic-gate /*
707c478bd9Sstevel@tonic-gate  * Null function used as place where a debugger can set a breakpoint.
717c478bd9Sstevel@tonic-gate  */
727c478bd9Sstevel@tonic-gate void
735aefb655Srie rtld_db_dlactivity(Lm_list *lml)
747c478bd9Sstevel@tonic-gate {
755aefb655Srie 	DBG_CALL(Dbg_util_dbnotify(lml, r_debug.rtd_rdebug.r_rdevent,
765aefb655Srie 	    r_debug.rtd_rdebug.r_state));
777c478bd9Sstevel@tonic-gate }
787c478bd9Sstevel@tonic-gate 
797c478bd9Sstevel@tonic-gate /*
807c478bd9Sstevel@tonic-gate  * Null function used as place where debugger can set a pre .init
817c478bd9Sstevel@tonic-gate  * processing breakpoint.
827c478bd9Sstevel@tonic-gate  */
837c478bd9Sstevel@tonic-gate void
845aefb655Srie rtld_db_preinit(Lm_list *lml)
857c478bd9Sstevel@tonic-gate {
865aefb655Srie 	DBG_CALL(Dbg_util_dbnotify(lml, r_debug.rtd_rdebug.r_rdevent,
875aefb655Srie 	    r_debug.rtd_rdebug.r_state));
887c478bd9Sstevel@tonic-gate }
897c478bd9Sstevel@tonic-gate 
907c478bd9Sstevel@tonic-gate /*
917c478bd9Sstevel@tonic-gate  * Null function used as place where debugger can set a post .init
927c478bd9Sstevel@tonic-gate  * processing breakpoint.
937c478bd9Sstevel@tonic-gate  */
947c478bd9Sstevel@tonic-gate void
955aefb655Srie rtld_db_postinit(Lm_list *lml)
967c478bd9Sstevel@tonic-gate {
975aefb655Srie 	DBG_CALL(Dbg_util_dbnotify(lml, r_debug.rtd_rdebug.r_rdevent,
985aefb655Srie 	    r_debug.rtd_rdebug.r_state));
997c478bd9Sstevel@tonic-gate }
1007c478bd9Sstevel@tonic-gate 
1017c478bd9Sstevel@tonic-gate /*
1027c478bd9Sstevel@tonic-gate  * Debugger Event Notification
1037c478bd9Sstevel@tonic-gate  *
1047c478bd9Sstevel@tonic-gate  * This function centralizes all debugger event notification (ala rtld_db).
1057c478bd9Sstevel@tonic-gate  *
1067c478bd9Sstevel@tonic-gate  * There's a simple intent, focused on insuring the primary link-map control
1077c478bd9Sstevel@tonic-gate  * list (or each link-map list) is consistent, and the indication that objects
1087c478bd9Sstevel@tonic-gate  * have been added or deleted from this list.  Although an RD_ADD and RD_DELETE
1097c478bd9Sstevel@tonic-gate  * event are posted for each of these, most debuggers don't care, as their
1107c478bd9Sstevel@tonic-gate  * view is that these events simply convey an "inconsistent" state.
1117c478bd9Sstevel@tonic-gate  *
1127c478bd9Sstevel@tonic-gate  * We also don't want to trigger multiple RD_ADD/RD_DELETE events any time we
1137c478bd9Sstevel@tonic-gate  * enter ld.so.1.
1147c478bd9Sstevel@tonic-gate  *
1157c478bd9Sstevel@tonic-gate  * With auditors, we may be in the process of relocating a collection of
1167c478bd9Sstevel@tonic-gate  * objects, and will leave() ld.so.1 to call the auditor.  At this point we
1177c478bd9Sstevel@tonic-gate  * must indicate an RD_CONSISTENT event, but librtld_db will not report an
1187c478bd9Sstevel@tonic-gate  * object to the debuggers until relocation processing has been completed on it.
1197c478bd9Sstevel@tonic-gate  * To allow for the collection of these objects that are pending relocation, an
1207c478bd9Sstevel@tonic-gate  * RD_ADD event is set after completing a series of relocations on the primary
1217c478bd9Sstevel@tonic-gate  * link-map control list.
1227c478bd9Sstevel@tonic-gate  *
1237c478bd9Sstevel@tonic-gate  * Set an RD_ADD/RD_DELETE event and indicate that an RD_CONSISTENT event is
1247c478bd9Sstevel@tonic-gate  * required later (LML_FLG_DBNOTIF):
1257c478bd9Sstevel@tonic-gate  *
1267c478bd9Sstevel@tonic-gate  *  i	the first time we add or delete an object to the primary link-map
1277c478bd9Sstevel@tonic-gate  *	control list.
1287c478bd9Sstevel@tonic-gate  *  ii	the first time we move a secondary link-map control list to the primary
1297c478bd9Sstevel@tonic-gate  *	link-map control list (effectively, this is like adding a group of
1307c478bd9Sstevel@tonic-gate  *	objects to the primary link-map control list).
1317c478bd9Sstevel@tonic-gate  *
1327c478bd9Sstevel@tonic-gate  * Set an RD_CONSISTENT event when it is required (LML_FLG_DBNOTIF is set) and
1337c478bd9Sstevel@tonic-gate  *
1347c478bd9Sstevel@tonic-gate  *  i	each time we leave the runtime linker.
1357c478bd9Sstevel@tonic-gate  */
1367c478bd9Sstevel@tonic-gate void
1377c478bd9Sstevel@tonic-gate rd_event(Lm_list *lml, rd_event_e event, r_state_e state)
1387c478bd9Sstevel@tonic-gate {
13910a4fa49Srie 	void	(*fptr)(Lm_list *);
1407c478bd9Sstevel@tonic-gate 
1417c478bd9Sstevel@tonic-gate 	switch (event) {
1427c478bd9Sstevel@tonic-gate 	case RD_PREINIT:
1437c478bd9Sstevel@tonic-gate 		fptr = rtld_db_preinit;
1447c478bd9Sstevel@tonic-gate 		break;
1457c478bd9Sstevel@tonic-gate 	case RD_POSTINIT:
1467c478bd9Sstevel@tonic-gate 		fptr = rtld_db_postinit;
1477c478bd9Sstevel@tonic-gate 		break;
1487c478bd9Sstevel@tonic-gate 	case RD_DLACTIVITY:
1497c478bd9Sstevel@tonic-gate 		switch (state) {
1507c478bd9Sstevel@tonic-gate 		case RT_CONSISTENT:
1517c478bd9Sstevel@tonic-gate 			lml->lm_flags &= ~LML_FLG_DBNOTIF;
1527c478bd9Sstevel@tonic-gate 
1537c478bd9Sstevel@tonic-gate 			/*
1547c478bd9Sstevel@tonic-gate 			 * Do we need to send a notification?
1557c478bd9Sstevel@tonic-gate 			 */
1567c478bd9Sstevel@tonic-gate 			if ((rtld_flags & RT_FL_DBNOTIF) == 0)
1577c478bd9Sstevel@tonic-gate 				return;
1587c478bd9Sstevel@tonic-gate 			rtld_flags &= ~RT_FL_DBNOTIF;
1597c478bd9Sstevel@tonic-gate 			break;
1607c478bd9Sstevel@tonic-gate 		case RT_ADD:
1617c478bd9Sstevel@tonic-gate 		case RT_DELETE:
1627c478bd9Sstevel@tonic-gate 			lml->lm_flags |= LML_FLG_DBNOTIF;
1637c478bd9Sstevel@tonic-gate 
1647c478bd9Sstevel@tonic-gate 			/*
1657c478bd9Sstevel@tonic-gate 			 * If we are already in an inconsistent state, no
1667c478bd9Sstevel@tonic-gate 			 * notification is required.
1677c478bd9Sstevel@tonic-gate 			 */
1687c478bd9Sstevel@tonic-gate 			if (rtld_flags & RT_FL_DBNOTIF)
1697c478bd9Sstevel@tonic-gate 				return;
1707c478bd9Sstevel@tonic-gate 			rtld_flags |= RT_FL_DBNOTIF;
1717c478bd9Sstevel@tonic-gate 			break;
1727c478bd9Sstevel@tonic-gate 		};
1737c478bd9Sstevel@tonic-gate 		fptr = rtld_db_dlactivity;
1747c478bd9Sstevel@tonic-gate 		break;
1757c478bd9Sstevel@tonic-gate 	default:
1767c478bd9Sstevel@tonic-gate 		/*
1777c478bd9Sstevel@tonic-gate 		 * RD_NONE - do nothing
1787c478bd9Sstevel@tonic-gate 		 */
1797c478bd9Sstevel@tonic-gate 		break;
1807c478bd9Sstevel@tonic-gate 	};
1817c478bd9Sstevel@tonic-gate 
1827c478bd9Sstevel@tonic-gate 	/*
1837c478bd9Sstevel@tonic-gate 	 * Set event state and call 'notification' function.
1847c478bd9Sstevel@tonic-gate 	 *
1857c478bd9Sstevel@tonic-gate 	 * The debugging clients have previously been told about these
1867c478bd9Sstevel@tonic-gate 	 * notification functions and have set breakpoints on them if they
1877c478bd9Sstevel@tonic-gate 	 * are interested in the notification.
1887c478bd9Sstevel@tonic-gate 	 */
1897c478bd9Sstevel@tonic-gate 	r_debug.rtd_rdebug.r_state = state;
1907c478bd9Sstevel@tonic-gate 	r_debug.rtd_rdebug.r_rdevent = event;
1915aefb655Srie 	fptr(lml);
1927c478bd9Sstevel@tonic-gate 	r_debug.rtd_rdebug.r_rdevent = RD_NONE;
1937c478bd9Sstevel@tonic-gate }
1947c478bd9Sstevel@tonic-gate 
19502ca3e02Srie #if	defined(__sparc) || defined(__x86)
1967c478bd9Sstevel@tonic-gate /*
1977c478bd9Sstevel@tonic-gate  * Stack Cleanup.
1987c478bd9Sstevel@tonic-gate  *
1997c478bd9Sstevel@tonic-gate  * This function is invoked to 'remove' arguments that were passed in on the
2007c478bd9Sstevel@tonic-gate  * stack.  This is most likely if ld.so.1 was invoked directly.  In that case
2017c478bd9Sstevel@tonic-gate  * we want to remove ld.so.1 as well as it's arguments from the argv[] array.
2027c478bd9Sstevel@tonic-gate  * Which means we then need to slide everything above it on the stack down
2037c478bd9Sstevel@tonic-gate  * accordingly.
2047c478bd9Sstevel@tonic-gate  *
20502ca3e02Srie  * While the stack layout is platform specific - it just so happens that __x86,
20602ca3e02Srie  * and __sparc platforms share the following initial stack layout.
2077c478bd9Sstevel@tonic-gate  *
2087c478bd9Sstevel@tonic-gate  *	!_______________________!  high addresses
2097c478bd9Sstevel@tonic-gate  *	!			!
2107c478bd9Sstevel@tonic-gate  *	!	Information	!
2117c478bd9Sstevel@tonic-gate  *	!	Block		!
2127c478bd9Sstevel@tonic-gate  *	!	(size varies)	!
2137c478bd9Sstevel@tonic-gate  *	!_______________________!
2147c478bd9Sstevel@tonic-gate  *	!	0 word		!
2157c478bd9Sstevel@tonic-gate  *	!_______________________!
2167c478bd9Sstevel@tonic-gate  *	!	Auxiliary	!
2177c478bd9Sstevel@tonic-gate  *	!	vector		!
2187c478bd9Sstevel@tonic-gate  *	!	2 word entries	!
2197c478bd9Sstevel@tonic-gate  *	!			!
2207c478bd9Sstevel@tonic-gate  *	!_______________________!
2217c478bd9Sstevel@tonic-gate  *	!	0 word		!
2227c478bd9Sstevel@tonic-gate  *	!_______________________!
2237c478bd9Sstevel@tonic-gate  *	!	Environment	!
2247c478bd9Sstevel@tonic-gate  *	!	pointers	!
2257c478bd9Sstevel@tonic-gate  *	!	...		!
2267c478bd9Sstevel@tonic-gate  *	!	(one word each)	!
2277c478bd9Sstevel@tonic-gate  *	!_______________________!
2287c478bd9Sstevel@tonic-gate  *	!	0 word		!
2297c478bd9Sstevel@tonic-gate  *	!_______________________!
2307c478bd9Sstevel@tonic-gate  *	!	Argument	! low addresses
2317c478bd9Sstevel@tonic-gate  *	!	pointers	!
2327c478bd9Sstevel@tonic-gate  *	!	Argc words	!
2337c478bd9Sstevel@tonic-gate  *	!_______________________!
2347c478bd9Sstevel@tonic-gate  *	!			!
2357c478bd9Sstevel@tonic-gate  *	!	Argc		!
2367c478bd9Sstevel@tonic-gate  *	!_______________________!
2377c478bd9Sstevel@tonic-gate  *	!	...		!
2387c478bd9Sstevel@tonic-gate  *
2397c478bd9Sstevel@tonic-gate  */
2407c478bd9Sstevel@tonic-gate static void
24141072f3cSrie stack_cleanup(char **argv, char ***envp, auxv_t **auxv, int rmcnt)
2427c478bd9Sstevel@tonic-gate {
24341072f3cSrie 	int		ndx;
2447c478bd9Sstevel@tonic-gate 	long		*argc;
24541072f3cSrie 	char		**oargv, **nargv;
24641072f3cSrie 	char		**oenvp, **nenvp;
24741072f3cSrie 	auxv_t		*oauxv, *nauxv;
2487c478bd9Sstevel@tonic-gate 
2497c478bd9Sstevel@tonic-gate 	/*
25041072f3cSrie 	 * Slide ARGV[] and update argc.  The argv pointer remains the same,
25141072f3cSrie 	 * however slide the applications arguments over the arguments to
25241072f3cSrie 	 * ld.so.1.
2537c478bd9Sstevel@tonic-gate 	 */
25441072f3cSrie 	nargv = &argv[0];
25541072f3cSrie 	oargv = &argv[rmcnt];
25641072f3cSrie 
25741072f3cSrie 	for (ndx = 0; oargv[ndx]; ndx++)
25841072f3cSrie 		nargv[ndx] = oargv[ndx];
25941072f3cSrie 	nargv[ndx] = oargv[ndx];
26041072f3cSrie 
26141072f3cSrie 	argc = (long *)((uintptr_t)argv - sizeof (long *));
2627c478bd9Sstevel@tonic-gate 	*argc -= rmcnt;
2637c478bd9Sstevel@tonic-gate 
2647c478bd9Sstevel@tonic-gate 	/*
26541072f3cSrie 	 * Slide ENVP[], and update the environment array pointer.
2667c478bd9Sstevel@tonic-gate 	 */
26741072f3cSrie 	ndx++;
26841072f3cSrie 	nenvp = &nargv[ndx];
26941072f3cSrie 	oenvp = &oargv[ndx];
27041072f3cSrie 	*envp = nenvp;
27141072f3cSrie 
27241072f3cSrie 	for (ndx = 0; oenvp[ndx]; ndx++)
27341072f3cSrie 		nenvp[ndx] = oenvp[ndx];
27441072f3cSrie 	nenvp[ndx] = oenvp[ndx];
2757c478bd9Sstevel@tonic-gate 
2767c478bd9Sstevel@tonic-gate 	/*
27741072f3cSrie 	 * Slide AUXV[], and update the aux vector pointer.
2787c478bd9Sstevel@tonic-gate 	 */
27941072f3cSrie 	ndx++;
28041072f3cSrie 	nauxv = (auxv_t *)&nenvp[ndx];
28141072f3cSrie 	oauxv = (auxv_t *)&oenvp[ndx];
28241072f3cSrie 	*auxv = nauxv;
28341072f3cSrie 
28441072f3cSrie 	for (ndx = 0; (oauxv[ndx].a_type != AT_NULL); ndx++)
28541072f3cSrie 		nauxv[ndx] = oauxv[ndx];
28641072f3cSrie 	nauxv[ndx] = oauxv[ndx];
2877c478bd9Sstevel@tonic-gate }
2887c478bd9Sstevel@tonic-gate #else
2897c478bd9Sstevel@tonic-gate /*
2907c478bd9Sstevel@tonic-gate  * Verify that the above routine is appropriate for any new platforms.
2917c478bd9Sstevel@tonic-gate  */
2927c478bd9Sstevel@tonic-gate #error	unsupported architecture!
2937c478bd9Sstevel@tonic-gate #endif
2947c478bd9Sstevel@tonic-gate 
2957c478bd9Sstevel@tonic-gate /*
29641072f3cSrie  * The only command line argument recognized is -e, followed by a runtime
29741072f3cSrie  * linker environment variable.
2987c478bd9Sstevel@tonic-gate  */
2997c478bd9Sstevel@tonic-gate int
30041072f3cSrie rtld_getopt(char **argv, char ***envp, auxv_t **auxv, Word *lmflags,
30141072f3cSrie     Word *lmtflags, int aout)
3027c478bd9Sstevel@tonic-gate {
30341072f3cSrie 	int	ndx;
3047c478bd9Sstevel@tonic-gate 
30541072f3cSrie 	for (ndx = 1; argv[ndx]; ndx++) {
3067c478bd9Sstevel@tonic-gate 		char	*str;
3077c478bd9Sstevel@tonic-gate 
30841072f3cSrie 		if (argv[ndx][0] != '-')
3097c478bd9Sstevel@tonic-gate 			break;
3107c478bd9Sstevel@tonic-gate 
31141072f3cSrie 		if (argv[ndx][1] == '\0') {
31241072f3cSrie 			ndx++;
3137c478bd9Sstevel@tonic-gate 			break;
3147c478bd9Sstevel@tonic-gate 		}
3157c478bd9Sstevel@tonic-gate 
31641072f3cSrie 		if (argv[ndx][1] != 'e')
31741072f3cSrie 			return (1);
3187c478bd9Sstevel@tonic-gate 
31941072f3cSrie 		if (argv[ndx][2] == '\0') {
32041072f3cSrie 			ndx++;
32141072f3cSrie 			if (argv[ndx] == NULL)
32241072f3cSrie 				return (1);
32341072f3cSrie 			str = argv[ndx];
3247c478bd9Sstevel@tonic-gate 		} else
32541072f3cSrie 			str = &argv[ndx][2];
3267c478bd9Sstevel@tonic-gate 
32741072f3cSrie 		/*
32841072f3cSrie 		 * If the environment variable starts with LD_, strip the LD_.
32941072f3cSrie 		 * Otherwise, take things as is.
33041072f3cSrie 		 */
33141072f3cSrie 		if ((str[0] == 'L') && (str[1] == 'D') && (str[2] == '_') &&
33241072f3cSrie 		    (str[3] != '\0'))
33341072f3cSrie 			str += 3;
3347c478bd9Sstevel@tonic-gate 		if (ld_flags_env(str, lmflags, lmtflags, 0, aout) == 1)
3357c478bd9Sstevel@tonic-gate 			return (1);
3367c478bd9Sstevel@tonic-gate 	}
3377c478bd9Sstevel@tonic-gate 
33841072f3cSrie 	/*
33941072f3cSrie 	 * Make sure an object file has been specified.
34041072f3cSrie 	 */
34141072f3cSrie 	if (argv[ndx] == 0)
3427c478bd9Sstevel@tonic-gate 		return (1);
3437c478bd9Sstevel@tonic-gate 
3447c478bd9Sstevel@tonic-gate 	/*
3457c478bd9Sstevel@tonic-gate 	 * Having gotten the arguments, clean ourselves off of the stack.
3467c478bd9Sstevel@tonic-gate 	 */
34741072f3cSrie 	stack_cleanup(argv, envp, auxv, ndx);
3487c478bd9Sstevel@tonic-gate 	return (0);
3497c478bd9Sstevel@tonic-gate }
3507c478bd9Sstevel@tonic-gate 
3517c478bd9Sstevel@tonic-gate /*
3527c478bd9Sstevel@tonic-gate  * Compare function for FullpathNode AVL tree.
3537c478bd9Sstevel@tonic-gate  */
3547c478bd9Sstevel@tonic-gate static int
3557c478bd9Sstevel@tonic-gate fpavl_compare(const void * n1, const void * n2)
3567c478bd9Sstevel@tonic-gate {
3577c478bd9Sstevel@tonic-gate 	uint_t		hash1, hash2;
3587c478bd9Sstevel@tonic-gate 	const char	*st1, *st2;
3597c478bd9Sstevel@tonic-gate 	int		rc;
3607c478bd9Sstevel@tonic-gate 
3617c478bd9Sstevel@tonic-gate 	hash1 = ((FullpathNode *)n1)->fpn_hash;
3627c478bd9Sstevel@tonic-gate 	hash2 = ((FullpathNode *)n2)->fpn_hash;
3637c478bd9Sstevel@tonic-gate 
3647c478bd9Sstevel@tonic-gate 	if (hash1 > hash2)
3657c478bd9Sstevel@tonic-gate 		return (1);
3667c478bd9Sstevel@tonic-gate 	if (hash1 < hash2)
3677c478bd9Sstevel@tonic-gate 		return (-1);
3687c478bd9Sstevel@tonic-gate 
3697c478bd9Sstevel@tonic-gate 	st1 = ((FullpathNode *)n1)->fpn_name;
3707c478bd9Sstevel@tonic-gate 	st2 = ((FullpathNode *)n2)->fpn_name;
3717c478bd9Sstevel@tonic-gate 
3727c478bd9Sstevel@tonic-gate 	rc = strcmp(st1, st2);
3737c478bd9Sstevel@tonic-gate 	if (rc > 0)
3747c478bd9Sstevel@tonic-gate 		return (1);
3757c478bd9Sstevel@tonic-gate 	if (rc < 0)
3767c478bd9Sstevel@tonic-gate 		return (-1);
3777c478bd9Sstevel@tonic-gate 	return (0);
3787c478bd9Sstevel@tonic-gate }
3797c478bd9Sstevel@tonic-gate 
3807c478bd9Sstevel@tonic-gate 
3817c478bd9Sstevel@tonic-gate /*
38224a6229eSrie  * Determine if a given pathname has already been loaded in the AVL tree.
3837c478bd9Sstevel@tonic-gate  * If the pathname does not exist in the AVL tree, the next insertion point
3847c478bd9Sstevel@tonic-gate  * is deposited in "where".  This value can be used by fpavl_insert() to
3857c478bd9Sstevel@tonic-gate  * expedite the insertion.
3867c478bd9Sstevel@tonic-gate  */
3877c478bd9Sstevel@tonic-gate Rt_map *
3887c478bd9Sstevel@tonic-gate fpavl_loaded(Lm_list *lml, const char *name, avl_index_t *where)
3897c478bd9Sstevel@tonic-gate {
3907c478bd9Sstevel@tonic-gate 	FullpathNode	fpn, *fpnp;
3917c478bd9Sstevel@tonic-gate 	avl_tree_t	*avlt;
3927c478bd9Sstevel@tonic-gate 
3937c478bd9Sstevel@tonic-gate 	/*
3947c478bd9Sstevel@tonic-gate 	 * Create the avl tree if required.
3957c478bd9Sstevel@tonic-gate 	 */
3967c478bd9Sstevel@tonic-gate 	if ((avlt = lml->lm_fpavl) == NULL) {
3977c478bd9Sstevel@tonic-gate 		if ((avlt = calloc(sizeof (avl_tree_t), 1)) == 0)
3987c478bd9Sstevel@tonic-gate 			return (0);
3997c478bd9Sstevel@tonic-gate 		avl_create(avlt, fpavl_compare, sizeof (FullpathNode),
4007c478bd9Sstevel@tonic-gate 		    SGSOFFSETOF(FullpathNode, fpn_avl));
4017c478bd9Sstevel@tonic-gate 		lml->lm_fpavl = avlt;
4027c478bd9Sstevel@tonic-gate 	}
4037c478bd9Sstevel@tonic-gate 
4047c478bd9Sstevel@tonic-gate 	fpn.fpn_name = name;
4057c478bd9Sstevel@tonic-gate 	fpn.fpn_hash = sgs_str_hash(name);
4067c478bd9Sstevel@tonic-gate 
4077c478bd9Sstevel@tonic-gate 	if ((fpnp = avl_find(lml->lm_fpavl, &fpn, where)) == NULL)
4087c478bd9Sstevel@tonic-gate 		return (NULL);
4097c478bd9Sstevel@tonic-gate 
4107c478bd9Sstevel@tonic-gate 	return (fpnp->fpn_lmp);
4117c478bd9Sstevel@tonic-gate }
4127c478bd9Sstevel@tonic-gate 
4137c478bd9Sstevel@tonic-gate 
4147c478bd9Sstevel@tonic-gate /*
41524a6229eSrie  * Insert a name into the FullpathNode AVL tree for the link-map list.  The
41624a6229eSrie  * objects NAME() is the path that would have originally been searched for, and
41724a6229eSrie  * is therefore the name to associate with any "where" value.  If the object has
4187c478bd9Sstevel@tonic-gate  * a different PATHNAME(), perhaps because it has resolved to a different file
4197c478bd9Sstevel@tonic-gate  * (see fullpath), then this name is recorded also.  See load_file().
4207c478bd9Sstevel@tonic-gate  */
4217c478bd9Sstevel@tonic-gate int
4227c478bd9Sstevel@tonic-gate fpavl_insert(Lm_list *lml, Rt_map *lmp, const char *name, avl_index_t where)
4237c478bd9Sstevel@tonic-gate {
4247c478bd9Sstevel@tonic-gate 	FullpathNode	*fpnp;
4257c478bd9Sstevel@tonic-gate 
4267c478bd9Sstevel@tonic-gate 	if (where == 0) {
4277c478bd9Sstevel@tonic-gate 		/* LINTED */
4287c478bd9Sstevel@tonic-gate 		Rt_map	*_lmp = fpavl_loaded(lml, name, &where);
4297c478bd9Sstevel@tonic-gate 
4307c478bd9Sstevel@tonic-gate 		/*
4317c478bd9Sstevel@tonic-gate 		 * We better not get a hit now, we do not want duplicates in
4327c478bd9Sstevel@tonic-gate 		 * the tree.
4337c478bd9Sstevel@tonic-gate 		 */
4347c478bd9Sstevel@tonic-gate 		ASSERT(_lmp == 0);
4357c478bd9Sstevel@tonic-gate 	}
4367c478bd9Sstevel@tonic-gate 
4377c478bd9Sstevel@tonic-gate 	/*
4387c478bd9Sstevel@tonic-gate 	 * Insert new node in tree
4397c478bd9Sstevel@tonic-gate 	 */
4407c478bd9Sstevel@tonic-gate 	if ((fpnp = calloc(sizeof (FullpathNode), 1)) == 0)
4417c478bd9Sstevel@tonic-gate 		return (0);
4427c478bd9Sstevel@tonic-gate 
4437c478bd9Sstevel@tonic-gate 	fpnp->fpn_name = name;
4447c478bd9Sstevel@tonic-gate 	fpnp->fpn_hash = sgs_str_hash(name);
4457c478bd9Sstevel@tonic-gate 	fpnp->fpn_lmp = lmp;
4467c478bd9Sstevel@tonic-gate 
447cce0e03bSab 	if (aplist_append(&FPNODE(lmp), fpnp, AL_CNT_FPNODE) == NULL) {
4487c478bd9Sstevel@tonic-gate 		free(fpnp);
4497c478bd9Sstevel@tonic-gate 		return (0);
4507c478bd9Sstevel@tonic-gate 	}
4517c478bd9Sstevel@tonic-gate 
4527c478bd9Sstevel@tonic-gate 	ASSERT(lml->lm_fpavl != NULL);
4537c478bd9Sstevel@tonic-gate 	avl_insert(lml->lm_fpavl, fpnp, where);
4547c478bd9Sstevel@tonic-gate 	return (1);
4557c478bd9Sstevel@tonic-gate }
4567c478bd9Sstevel@tonic-gate 
4577c478bd9Sstevel@tonic-gate /*
45824a6229eSrie  * Remove an object from the Fullpath AVL tree.  Note, this is called *before*
4597c478bd9Sstevel@tonic-gate  * the objects link-map is torn down (remove_so), which is where any NAME() and
4607c478bd9Sstevel@tonic-gate  * PATHNAME() strings will be deallocated.
4617c478bd9Sstevel@tonic-gate  */
4627c478bd9Sstevel@tonic-gate void
4637c478bd9Sstevel@tonic-gate fpavl_remove(Rt_map *lmp)
4647c478bd9Sstevel@tonic-gate {
465cce0e03bSab 	FullpathNode	*fpnp;
466cce0e03bSab 	Aliste		idx;
4677c478bd9Sstevel@tonic-gate 
468cce0e03bSab 	for (APLIST_TRAVERSE(FPNODE(lmp), idx, fpnp)) {
4697c478bd9Sstevel@tonic-gate 		avl_remove(LIST(lmp)->lm_fpavl, fpnp);
4707c478bd9Sstevel@tonic-gate 		free(fpnp);
4717c478bd9Sstevel@tonic-gate 	}
4727c478bd9Sstevel@tonic-gate 	free(FPNODE(lmp));
473cce0e03bSab 	FPNODE(lmp) = NULL;
4747c478bd9Sstevel@tonic-gate }
4757c478bd9Sstevel@tonic-gate 
4767c478bd9Sstevel@tonic-gate 
4777c478bd9Sstevel@tonic-gate /*
4787c478bd9Sstevel@tonic-gate  * Prior to calling an object, either via a .plt or through dlsym(), make sure
4797c478bd9Sstevel@tonic-gate  * its .init has fired.  Through topological sorting, ld.so.1 attempts to fire
4807c478bd9Sstevel@tonic-gate  * init's in the correct order, however, this order is typically based on needed
4817c478bd9Sstevel@tonic-gate  * dependencies and non-lazy relocation bindings.  Lazy relocations (.plts) can
4827c478bd9Sstevel@tonic-gate  * still occur and result in bindings that were not captured during topological
4837c478bd9Sstevel@tonic-gate  * sorting.  This routine compensates for this lack of binding information, and
4847c478bd9Sstevel@tonic-gate  * provides for dynamic .init firing.
4857c478bd9Sstevel@tonic-gate  */
4867c478bd9Sstevel@tonic-gate void
4877c478bd9Sstevel@tonic-gate is_dep_init(Rt_map * dlmp, Rt_map * clmp)
4887c478bd9Sstevel@tonic-gate {
4897c478bd9Sstevel@tonic-gate 	Rt_map **	tobj;
4907c478bd9Sstevel@tonic-gate 
4917c478bd9Sstevel@tonic-gate 	/*
4927c478bd9Sstevel@tonic-gate 	 * If the caller is an auditor, and the destination isn't, then don't
4937c478bd9Sstevel@tonic-gate 	 * run any .inits (see comments in load_completion()).
4947c478bd9Sstevel@tonic-gate 	 */
4957c478bd9Sstevel@tonic-gate 	if ((LIST(clmp)->lm_flags & LML_FLG_NOAUDIT) &&
4967c478bd9Sstevel@tonic-gate 	    (LIST(clmp) != LIST(dlmp)))
4977c478bd9Sstevel@tonic-gate 		return;
4987c478bd9Sstevel@tonic-gate 
4997c478bd9Sstevel@tonic-gate 	if ((dlmp == clmp) || (rtld_flags & (RT_FL_BREADTH | RT_FL_INITFIRST)))
5007c478bd9Sstevel@tonic-gate 		return;
5017c478bd9Sstevel@tonic-gate 
5027c478bd9Sstevel@tonic-gate 	if ((FLAGS(dlmp) & (FLG_RT_RELOCED | FLG_RT_INITDONE)) ==
5037c478bd9Sstevel@tonic-gate 	    (FLG_RT_RELOCED | FLG_RT_INITDONE))
5047c478bd9Sstevel@tonic-gate 		return;
5057c478bd9Sstevel@tonic-gate 
5067c478bd9Sstevel@tonic-gate 	if ((FLAGS(dlmp) & (FLG_RT_RELOCED | FLG_RT_INITCALL)) ==
5077c478bd9Sstevel@tonic-gate 	    (FLG_RT_RELOCED | FLG_RT_INITCALL)) {
5085aefb655Srie 		DBG_CALL(Dbg_util_no_init(dlmp));
5097c478bd9Sstevel@tonic-gate 		return;
5107c478bd9Sstevel@tonic-gate 	}
5117c478bd9Sstevel@tonic-gate 
5127c478bd9Sstevel@tonic-gate 	if ((tobj = calloc(2, sizeof (Rt_map *))) != NULL) {
5137c478bd9Sstevel@tonic-gate 		tobj[0] = dlmp;
5147c478bd9Sstevel@tonic-gate 		call_init(tobj, DBG_INIT_DYN);
5157c478bd9Sstevel@tonic-gate 	}
5167c478bd9Sstevel@tonic-gate }
5177c478bd9Sstevel@tonic-gate 
5187c478bd9Sstevel@tonic-gate /*
5197c478bd9Sstevel@tonic-gate  * In a threaded environment insure the thread responsible for loading an object
5207c478bd9Sstevel@tonic-gate  * has completed .init processing for that object before any new thread is
5217c478bd9Sstevel@tonic-gate  * allowed to access the object.  This check is only valid with libthread
5227c478bd9Sstevel@tonic-gate  * TI_VERSION 2, where ld.so.1 implements locking through low level mutexes.
5237c478bd9Sstevel@tonic-gate  *
5247c478bd9Sstevel@tonic-gate  * When a new link-map is created, the thread that causes it to be loaded is
5257c478bd9Sstevel@tonic-gate  * identified by THREADID(dlmp).  Compare this with the current thread to
5267c478bd9Sstevel@tonic-gate  * determine if it must be blocked.
5277c478bd9Sstevel@tonic-gate  *
5287c478bd9Sstevel@tonic-gate  * NOTE, there are a number of instances (typically only for .plt processing)
5297c478bd9Sstevel@tonic-gate  * where we must skip this test:
5307c478bd9Sstevel@tonic-gate  *
5317c478bd9Sstevel@tonic-gate  *   .	any thread id of 0 - threads that call thr_exit() may be in this state
5327c478bd9Sstevel@tonic-gate  *	thus we can't deduce what tid they used to be.  Also some of the
5337c478bd9Sstevel@tonic-gate  *	lib/libthread worker threads have this id and must bind (to themselves
5347c478bd9Sstevel@tonic-gate  *	or libc) for libthread to function.
5357c478bd9Sstevel@tonic-gate  *
5367c478bd9Sstevel@tonic-gate  *   .	libthread itself binds to libc, and as libthread is INITFIRST
5377c478bd9Sstevel@tonic-gate  *	libc's .init can't have fired yet.  Luckly libc's .init is not required
5387c478bd9Sstevel@tonic-gate  *	by libthreads binding.
5397c478bd9Sstevel@tonic-gate  *
5407c478bd9Sstevel@tonic-gate  *   .	if the caller is an auditor, and the destination isn't, then don't
5417c478bd9Sstevel@tonic-gate  *	block (see comments in load_completion()).
5427c478bd9Sstevel@tonic-gate  */
5437c478bd9Sstevel@tonic-gate void
5447c478bd9Sstevel@tonic-gate is_dep_ready(Rt_map * dlmp, Rt_map * clmp, int what)
5457c478bd9Sstevel@tonic-gate {
5467c478bd9Sstevel@tonic-gate 	thread_t	tid;
5477c478bd9Sstevel@tonic-gate 
5487c478bd9Sstevel@tonic-gate 	if ((LIST(clmp)->lm_flags & LML_FLG_NOAUDIT) &&
5497c478bd9Sstevel@tonic-gate 	    (LIST(clmp) != LIST(dlmp)))
5507c478bd9Sstevel@tonic-gate 		return;
5517c478bd9Sstevel@tonic-gate 
5527c478bd9Sstevel@tonic-gate 	if ((rtld_flags & RT_FL_CONCUR) &&
5537c478bd9Sstevel@tonic-gate 	    ((FLAGS(dlmp) & FLG_RT_INITDONE) == 0) &&
5547c478bd9Sstevel@tonic-gate 	    ((FLAGS(clmp) & FLG_RT_INITFRST) == 0) &&
5557c478bd9Sstevel@tonic-gate 	    ((tid = rt_thr_self()) != 0) && (THREADID(dlmp) != tid)) {
5567c478bd9Sstevel@tonic-gate 		while ((FLAGS(dlmp) & FLG_RT_INITDONE) == 0) {
5577c478bd9Sstevel@tonic-gate 			FLAGS1(dlmp) |= FL1_RT_INITWAIT;
5585aefb655Srie 			DBG_CALL(Dbg_util_wait(clmp, dlmp, what));
5597c478bd9Sstevel@tonic-gate 			(void) rt_cond_wait(CONDVAR(dlmp), &rtldlock);
5607c478bd9Sstevel@tonic-gate 		}
5617c478bd9Sstevel@tonic-gate 	}
5627c478bd9Sstevel@tonic-gate }
5637c478bd9Sstevel@tonic-gate 
5647c478bd9Sstevel@tonic-gate /*
5657c478bd9Sstevel@tonic-gate  * Execute .{preinit|init|fini}array sections
5667c478bd9Sstevel@tonic-gate  */
5677c478bd9Sstevel@tonic-gate void
5685aefb655Srie call_array(Addr *array, uint_t arraysz, Rt_map *lmp, Word shtype)
5697c478bd9Sstevel@tonic-gate {
5705aefb655Srie 	int	start, stop, incr, ndx;
5717c478bd9Sstevel@tonic-gate 	uint_t	arraycnt = (uint_t)(arraysz / sizeof (Addr));
5727c478bd9Sstevel@tonic-gate 
5737c478bd9Sstevel@tonic-gate 	if (array == NULL)
5747c478bd9Sstevel@tonic-gate 		return;
5757c478bd9Sstevel@tonic-gate 
5767c478bd9Sstevel@tonic-gate 	/*
5777c478bd9Sstevel@tonic-gate 	 * initarray & preinitarray are walked from beginning to end - while
5787c478bd9Sstevel@tonic-gate 	 * finiarray is walked from end to beginning.
5797c478bd9Sstevel@tonic-gate 	 */
5807c478bd9Sstevel@tonic-gate 	if (shtype == SHT_FINI_ARRAY) {
5817c478bd9Sstevel@tonic-gate 		start = arraycnt - 1;
5827c478bd9Sstevel@tonic-gate 		stop = incr = -1;
5837c478bd9Sstevel@tonic-gate 	} else {
5847c478bd9Sstevel@tonic-gate 		start = 0;
5857c478bd9Sstevel@tonic-gate 		stop = arraycnt;
5867c478bd9Sstevel@tonic-gate 		incr = 1;
5877c478bd9Sstevel@tonic-gate 	}
5887c478bd9Sstevel@tonic-gate 
5897c478bd9Sstevel@tonic-gate 	/*
5907c478bd9Sstevel@tonic-gate 	 * Call the .*array[] entries
5917c478bd9Sstevel@tonic-gate 	 */
5925aefb655Srie 	for (ndx = start; ndx != stop; ndx += incr) {
59310a4fa49Srie 		void (*fptr)(void) = (void(*)())array[ndx];
5947c478bd9Sstevel@tonic-gate 
5955aefb655Srie 		DBG_CALL(Dbg_util_call_array(lmp, (void *)fptr, ndx, shtype));
5967c478bd9Sstevel@tonic-gate 
5977c478bd9Sstevel@tonic-gate 		leave(LIST(lmp));
5987c478bd9Sstevel@tonic-gate 		(*fptr)();
5997c478bd9Sstevel@tonic-gate 		(void) enter();
6007c478bd9Sstevel@tonic-gate 	}
6017c478bd9Sstevel@tonic-gate }
6027c478bd9Sstevel@tonic-gate 
6037c478bd9Sstevel@tonic-gate 
6047c478bd9Sstevel@tonic-gate /*
6057c478bd9Sstevel@tonic-gate  * Execute any .init sections.  These are passed to us in an lmp array which
6067c478bd9Sstevel@tonic-gate  * (by default) will have been sorted.
6077c478bd9Sstevel@tonic-gate  */
6087c478bd9Sstevel@tonic-gate void
6097c478bd9Sstevel@tonic-gate call_init(Rt_map ** tobj, int flag)
6107c478bd9Sstevel@tonic-gate {
6117c478bd9Sstevel@tonic-gate 	Rt_map **	_tobj, ** _nobj;
6127c478bd9Sstevel@tonic-gate 	static List	pending = { NULL, NULL };
6137c478bd9Sstevel@tonic-gate 
6147c478bd9Sstevel@tonic-gate 	/*
6157c478bd9Sstevel@tonic-gate 	 * If we're in the middle of an INITFIRST, this must complete before
6167c478bd9Sstevel@tonic-gate 	 * any new init's are fired.  In this case add the object list to the
6177c478bd9Sstevel@tonic-gate 	 * pending queue and return.  We'll pick up the queue after any
6187c478bd9Sstevel@tonic-gate 	 * INITFIRST objects have their init's fired.
6197c478bd9Sstevel@tonic-gate 	 */
6207c478bd9Sstevel@tonic-gate 	if (rtld_flags & RT_FL_INITFIRST) {
6217c478bd9Sstevel@tonic-gate 		(void) list_append(&pending, tobj);
6227c478bd9Sstevel@tonic-gate 		return;
6237c478bd9Sstevel@tonic-gate 	}
6247c478bd9Sstevel@tonic-gate 
6257c478bd9Sstevel@tonic-gate 	/*
6267c478bd9Sstevel@tonic-gate 	 * Traverse the tobj array firing each objects init.
6277c478bd9Sstevel@tonic-gate 	 */
6287c478bd9Sstevel@tonic-gate 	for (_tobj = _nobj = tobj, _nobj++; *_tobj != NULL; _tobj++, _nobj++) {
6297c478bd9Sstevel@tonic-gate 		Rt_map *	lmp = *_tobj;
630dffec89cSrie 		void (*		iptr)() = INIT(lmp);
6317c478bd9Sstevel@tonic-gate 
6327c478bd9Sstevel@tonic-gate 		if (FLAGS(lmp) & FLG_RT_INITCALL)
6337c478bd9Sstevel@tonic-gate 			continue;
6347c478bd9Sstevel@tonic-gate 
6357c478bd9Sstevel@tonic-gate 		FLAGS(lmp) |= FLG_RT_INITCALL;
6367c478bd9Sstevel@tonic-gate 
6377c478bd9Sstevel@tonic-gate 		/*
6387c478bd9Sstevel@tonic-gate 		 * Establish an initfirst state if necessary - no other inits
639dffec89cSrie 		 * will be fired (because of additional relocation bindings)
640dffec89cSrie 		 * when in this state.
6417c478bd9Sstevel@tonic-gate 		 */
6427c478bd9Sstevel@tonic-gate 		if (FLAGS(lmp) & FLG_RT_INITFRST)
6437c478bd9Sstevel@tonic-gate 			rtld_flags |= RT_FL_INITFIRST;
6447c478bd9Sstevel@tonic-gate 
6457c478bd9Sstevel@tonic-gate 		if (INITARRAY(lmp) || iptr) {
646cce0e03bSab 			Aliste		idx;
647cce0e03bSab 			Bnd_desc 	*bdp;
6487c478bd9Sstevel@tonic-gate 
6497c478bd9Sstevel@tonic-gate 			/*
6507c478bd9Sstevel@tonic-gate 			 * Make sure that all dependencies that have been
6517c478bd9Sstevel@tonic-gate 			 * relocated to are initialized before this objects
6527c478bd9Sstevel@tonic-gate 			 * .init is executed.  This insures that a dependency
6537c478bd9Sstevel@tonic-gate 			 * on an external item that must first be initialized
6547c478bd9Sstevel@tonic-gate 			 * by its associated object is satisfied.
6557c478bd9Sstevel@tonic-gate 			 */
656cce0e03bSab 			for (APLIST_TRAVERSE(DEPENDS(lmp), idx, bdp)) {
6577c478bd9Sstevel@tonic-gate 				if ((bdp->b_flags & BND_REFER) == 0)
6587c478bd9Sstevel@tonic-gate 					continue;
6597c478bd9Sstevel@tonic-gate 				is_dep_ready(bdp->b_depend, lmp, DBG_WAIT_INIT);
6607c478bd9Sstevel@tonic-gate 			}
6615aefb655Srie 			DBG_CALL(Dbg_util_call_init(lmp, flag));
6627c478bd9Sstevel@tonic-gate 		}
6637c478bd9Sstevel@tonic-gate 
6647c478bd9Sstevel@tonic-gate 		if (iptr) {
6657c478bd9Sstevel@tonic-gate 			leave(LIST(lmp));
6667c478bd9Sstevel@tonic-gate 			(*iptr)();
6677c478bd9Sstevel@tonic-gate 			(void) enter();
6687c478bd9Sstevel@tonic-gate 		}
6697c478bd9Sstevel@tonic-gate 
6707c478bd9Sstevel@tonic-gate 		call_array(INITARRAY(lmp), INITARRAYSZ(lmp), lmp,
6717c478bd9Sstevel@tonic-gate 		    SHT_INIT_ARRAY);
6727c478bd9Sstevel@tonic-gate 
6737c478bd9Sstevel@tonic-gate 		if (INITARRAY(lmp) || iptr)
6745aefb655Srie 			DBG_CALL(Dbg_util_call_init(lmp, DBG_INIT_DONE));
6757c478bd9Sstevel@tonic-gate 
6767c478bd9Sstevel@tonic-gate 		/*
6777c478bd9Sstevel@tonic-gate 		 * Set the initdone flag regardless of whether this object
6787c478bd9Sstevel@tonic-gate 		 * actually contains an .init section.  This flag prevents us
6797c478bd9Sstevel@tonic-gate 		 * from processing this section again for an .init and also
6807c478bd9Sstevel@tonic-gate 		 * signifies that a .fini must be called should it exist.
6817c478bd9Sstevel@tonic-gate 		 * Clear the sort field for use in later .fini processing.
6827c478bd9Sstevel@tonic-gate 		 */
6837c478bd9Sstevel@tonic-gate 		FLAGS(lmp) |= FLG_RT_INITDONE;
684dffec89cSrie 		SORTVAL(lmp) = -1;
6857c478bd9Sstevel@tonic-gate 
6867c478bd9Sstevel@tonic-gate 		/*
6877c478bd9Sstevel@tonic-gate 		 * Wake anyone up who might be waiting on this .init.
6887c478bd9Sstevel@tonic-gate 		 */
6897c478bd9Sstevel@tonic-gate 		if (FLAGS1(lmp) & FL1_RT_INITWAIT) {
6905aefb655Srie 			DBG_CALL(Dbg_util_broadcast(lmp));
6917c478bd9Sstevel@tonic-gate 			(void) rt_cond_broadcast(CONDVAR(lmp));
6927c478bd9Sstevel@tonic-gate 			FLAGS1(lmp) &= ~FL1_RT_INITWAIT;
6937c478bd9Sstevel@tonic-gate 		}
6947c478bd9Sstevel@tonic-gate 
6957c478bd9Sstevel@tonic-gate 		/*
6967c478bd9Sstevel@tonic-gate 		 * If we're firing an INITFIRST object, and other objects must
6977c478bd9Sstevel@tonic-gate 		 * be fired which are not INITFIRST, make sure we grab any
6987c478bd9Sstevel@tonic-gate 		 * pending objects that might have been delayed as this
6997c478bd9Sstevel@tonic-gate 		 * INITFIRST was processed.
7007c478bd9Sstevel@tonic-gate 		 */
7017c478bd9Sstevel@tonic-gate 		if ((rtld_flags & RT_FL_INITFIRST) &&
7027c478bd9Sstevel@tonic-gate 		    ((*_nobj == NULL) || !(FLAGS(*_nobj) & FLG_RT_INITFRST))) {
7037c478bd9Sstevel@tonic-gate 			Listnode *	lnp;
7047c478bd9Sstevel@tonic-gate 			Rt_map **	pobj;
7057c478bd9Sstevel@tonic-gate 
7067c478bd9Sstevel@tonic-gate 			rtld_flags &= ~RT_FL_INITFIRST;
7077c478bd9Sstevel@tonic-gate 
7087c478bd9Sstevel@tonic-gate 			while ((lnp = pending.head) != NULL) {
7097c478bd9Sstevel@tonic-gate 				if ((pending.head = lnp->next) == NULL)
7107c478bd9Sstevel@tonic-gate 					pending.tail = NULL;
7117c478bd9Sstevel@tonic-gate 				pobj = lnp->data;
7127c478bd9Sstevel@tonic-gate 				free(lnp);
7137c478bd9Sstevel@tonic-gate 
7147c478bd9Sstevel@tonic-gate 				call_init(pobj, DBG_INIT_PEND);
7157c478bd9Sstevel@tonic-gate 			}
7167c478bd9Sstevel@tonic-gate 		}
7177c478bd9Sstevel@tonic-gate 	}
7187c478bd9Sstevel@tonic-gate 	free(tobj);
7197c478bd9Sstevel@tonic-gate }
7207c478bd9Sstevel@tonic-gate 
7217c478bd9Sstevel@tonic-gate /*
7227c478bd9Sstevel@tonic-gate  * Function called by atexit(3C).  Calls all .fini sections related with the
7237c478bd9Sstevel@tonic-gate  * mains dependent shared libraries in the order in which the shared libraries
7247c478bd9Sstevel@tonic-gate  * have been loaded.  Skip any .fini defined in the main executable, as this
7257c478bd9Sstevel@tonic-gate  * will be called by crt0 (main was never marked as initdone).
7267c478bd9Sstevel@tonic-gate  */
7277c478bd9Sstevel@tonic-gate void
7287c478bd9Sstevel@tonic-gate call_fini(Lm_list * lml, Rt_map ** tobj)
7297c478bd9Sstevel@tonic-gate {
730dffec89cSrie 	Rt_map **_tobj;
7317c478bd9Sstevel@tonic-gate 
7327c478bd9Sstevel@tonic-gate 	for (_tobj = tobj; *_tobj != NULL; _tobj++) {
733cce0e03bSab 		Rt_map		*clmp, * lmp = *_tobj;
734cce0e03bSab 		Aliste		idx;
735cce0e03bSab 		Bnd_desc	*bdp;
7367c478bd9Sstevel@tonic-gate 
7377c478bd9Sstevel@tonic-gate 		/*
7387c478bd9Sstevel@tonic-gate 		 * If concurrency checking isn't enabled only fire .fini if
7397c478bd9Sstevel@tonic-gate 		 * .init has completed.  We collect all .fini sections of
7407c478bd9Sstevel@tonic-gate 		 * objects that had their .init collected, but that doesn't
7417c478bd9Sstevel@tonic-gate 		 * mean at the time that the .init had completed.
7427c478bd9Sstevel@tonic-gate 		 */
7437c478bd9Sstevel@tonic-gate 		if ((rtld_flags & RT_FL_CONCUR) ||
7447c478bd9Sstevel@tonic-gate 		    (FLAGS(lmp) & FLG_RT_INITDONE)) {
74510a4fa49Srie 			void	(*fptr)(void) = FINI(lmp);
7467c478bd9Sstevel@tonic-gate 
7477c478bd9Sstevel@tonic-gate 			if (FINIARRAY(lmp) || fptr) {
7487c478bd9Sstevel@tonic-gate 				/*
7497c478bd9Sstevel@tonic-gate 				 * If concurrency checking is enabled make sure
7507c478bd9Sstevel@tonic-gate 				 * this object's .init is completed before
7517c478bd9Sstevel@tonic-gate 				 * calling any .fini.
7527c478bd9Sstevel@tonic-gate 				 */
7537c478bd9Sstevel@tonic-gate 				is_dep_ready(lmp, lmp, DBG_WAIT_FINI);
7545aefb655Srie 				DBG_CALL(Dbg_util_call_fini(lmp));
7557c478bd9Sstevel@tonic-gate 			}
7567c478bd9Sstevel@tonic-gate 
7575aefb655Srie 			call_array(FINIARRAY(lmp), FINIARRAYSZ(lmp), lmp,
7585aefb655Srie 			    SHT_FINI_ARRAY);
7597c478bd9Sstevel@tonic-gate 
7607c478bd9Sstevel@tonic-gate 			if (fptr) {
7617c478bd9Sstevel@tonic-gate 				leave(LIST(lmp));
7627c478bd9Sstevel@tonic-gate 				(*fptr)();
7637c478bd9Sstevel@tonic-gate 				(void) enter();
7647c478bd9Sstevel@tonic-gate 			}
7657c478bd9Sstevel@tonic-gate 		}
7667c478bd9Sstevel@tonic-gate 
767dffec89cSrie 		/*
768dffec89cSrie 		 * Skip main, this is explicitly called last in atexit_fini().
769dffec89cSrie 		 */
770dffec89cSrie 		if (FLAGS(lmp) & FLG_RT_ISMAIN)
771dffec89cSrie 			continue;
772dffec89cSrie 
7737c478bd9Sstevel@tonic-gate 		/*
7747c478bd9Sstevel@tonic-gate 		 * Audit `close' operations at this point.  The library has
7757c478bd9Sstevel@tonic-gate 		 * exercised its last instructions (regardless of whether it
7767c478bd9Sstevel@tonic-gate 		 * will be unmapped or not).
7777c478bd9Sstevel@tonic-gate 		 *
7787c478bd9Sstevel@tonic-gate 		 * First call any global auditing.
7797c478bd9Sstevel@tonic-gate 		 */
7807c478bd9Sstevel@tonic-gate 		if (lml->lm_tflags & LML_TFLG_AUD_OBJCLOSE)
7817c478bd9Sstevel@tonic-gate 			_audit_objclose(&(auditors->ad_list), lmp);
7827c478bd9Sstevel@tonic-gate 
7837c478bd9Sstevel@tonic-gate 		/*
7847c478bd9Sstevel@tonic-gate 		 * Finally determine whether this object has local auditing
7857c478bd9Sstevel@tonic-gate 		 * requirements by inspecting itself and then its dependencies.
7867c478bd9Sstevel@tonic-gate 		 */
7877c478bd9Sstevel@tonic-gate 		if ((lml->lm_flags & LML_FLG_LOCAUDIT) == 0)
7887c478bd9Sstevel@tonic-gate 			continue;
7897c478bd9Sstevel@tonic-gate 
7907c478bd9Sstevel@tonic-gate 		if (FLAGS1(lmp) & LML_TFLG_AUD_OBJCLOSE)
7917c478bd9Sstevel@tonic-gate 			_audit_objclose(&(AUDITORS(lmp)->ad_list), lmp);
7927c478bd9Sstevel@tonic-gate 
793cce0e03bSab 		for (APLIST_TRAVERSE(CALLERS(lmp), idx, bdp)) {
7947c478bd9Sstevel@tonic-gate 			clmp = bdp->b_caller;
7957c478bd9Sstevel@tonic-gate 
7967c478bd9Sstevel@tonic-gate 			if (FLAGS1(clmp) & LML_TFLG_AUD_OBJCLOSE) {
797a953e2b1Srie 				_audit_objclose(&(AUDITORS(clmp)->ad_list),
798a953e2b1Srie 				    lmp);
799a953e2b1Srie 				break;
8007c478bd9Sstevel@tonic-gate 			}
8017c478bd9Sstevel@tonic-gate 		}
8027c478bd9Sstevel@tonic-gate 	}
8035aefb655Srie 	DBG_CALL(Dbg_bind_plt_summary(lml, M_MACH, pltcnt21d, pltcnt24d,
8045aefb655Srie 	    pltcntu32, pltcntu44, pltcntfull, pltcntfar));
8057c478bd9Sstevel@tonic-gate 
8067c478bd9Sstevel@tonic-gate 	free(tobj);
8077c478bd9Sstevel@tonic-gate }
8087c478bd9Sstevel@tonic-gate 
8097c478bd9Sstevel@tonic-gate void
8107c478bd9Sstevel@tonic-gate atexit_fini()
8117c478bd9Sstevel@tonic-gate {
8127c478bd9Sstevel@tonic-gate 	Rt_map **	tobj, * lmp;
8137c478bd9Sstevel@tonic-gate 	Lm_list *	lml;
8147c478bd9Sstevel@tonic-gate 	Listnode *	lnp;
8157c478bd9Sstevel@tonic-gate 
8167c478bd9Sstevel@tonic-gate 	(void) enter();
8177c478bd9Sstevel@tonic-gate 
8187c478bd9Sstevel@tonic-gate 	rtld_flags |= RT_FL_ATEXIT;
8197c478bd9Sstevel@tonic-gate 
8207c478bd9Sstevel@tonic-gate 	lml = &lml_main;
821dffec89cSrie 	lml->lm_flags |= LML_FLG_ATEXIT;
822883c6d49Srie 	lml->lm_flags &= ~LML_FLG_INTRPOSETSORT;
8237c478bd9Sstevel@tonic-gate 	lmp = (Rt_map *)lml->lm_head;
8247c478bd9Sstevel@tonic-gate 
8257c478bd9Sstevel@tonic-gate 	/*
8267c478bd9Sstevel@tonic-gate 	 * Display any objects that haven't been referenced so far.
8277c478bd9Sstevel@tonic-gate 	 */
8287c478bd9Sstevel@tonic-gate 	unused(lml);
8297c478bd9Sstevel@tonic-gate 
8307c478bd9Sstevel@tonic-gate 	/*
8317c478bd9Sstevel@tonic-gate 	 * Reverse topologically sort the main link-map for .fini execution.
8327c478bd9Sstevel@tonic-gate 	 */
8337c478bd9Sstevel@tonic-gate 	if (((tobj = tsort(lmp, lml->lm_obj, RT_SORT_FWD)) != 0) &&
8347c478bd9Sstevel@tonic-gate 	    (tobj != (Rt_map **)S_ERROR))
8357c478bd9Sstevel@tonic-gate 		call_fini(lml, tobj);
8367c478bd9Sstevel@tonic-gate 
8377c478bd9Sstevel@tonic-gate 	/*
838dffec89cSrie 	 * Add an explicit close to main and ld.so.1.  Although main's .fini is
839dffec89cSrie 	 * collected in call_fini() to provide for FINITARRAY processing, its
840dffec89cSrie 	 * audit_objclose is explicitly skipped.  This provides for it to be
841dffec89cSrie 	 * called last, here.  This is the reverse of the explicit calls to
842dffec89cSrie 	 * audit_objopen() made in setup().
8437c478bd9Sstevel@tonic-gate 	 */
8447c478bd9Sstevel@tonic-gate 	if ((lml->lm_tflags | FLAGS1(lmp)) & LML_TFLG_AUD_MASK) {
8457c478bd9Sstevel@tonic-gate 		audit_objclose(lmp, (Rt_map *)lml_rtld.lm_head);
846dffec89cSrie 		audit_objclose(lmp, lmp);
8477c478bd9Sstevel@tonic-gate 	}
8487c478bd9Sstevel@tonic-gate 
8497c478bd9Sstevel@tonic-gate 	/*
8507c478bd9Sstevel@tonic-gate 	 * Now that all .fini code has been run, see what unreferenced objects
8517c478bd9Sstevel@tonic-gate 	 * remain.  Any difference between this and the above unused() would
8527c478bd9Sstevel@tonic-gate 	 * indicate an object is only being used for .fini processing, which
8537c478bd9Sstevel@tonic-gate 	 * might be fine, but might also indicate an overhead whose removal
8547c478bd9Sstevel@tonic-gate 	 * would be worth considering.
8557c478bd9Sstevel@tonic-gate 	 */
8567c478bd9Sstevel@tonic-gate 	unused(lml);
8577c478bd9Sstevel@tonic-gate 
8587c478bd9Sstevel@tonic-gate 	/*
8597c478bd9Sstevel@tonic-gate 	 * Traverse any alternative link-map lists.
8607c478bd9Sstevel@tonic-gate 	 */
8617c478bd9Sstevel@tonic-gate 	for (LIST_TRAVERSE(&dynlm_list, lnp, lml)) {
86210a4fa49Srie 		/*
86310a4fa49Srie 		 * Ignore the base-link-map list, which has already been
86410a4fa49Srie 		 * processed, and the runtime linkers link-map list, which is
86510a4fa49Srie 		 * typically processed last.
86610a4fa49Srie 		 */
8677c478bd9Sstevel@tonic-gate 		if (lml->lm_flags & (LML_FLG_BASELM | LML_FLG_RTLDLM))
8687c478bd9Sstevel@tonic-gate 			continue;
8697c478bd9Sstevel@tonic-gate 
8707c478bd9Sstevel@tonic-gate 		if ((lmp = (Rt_map *)lml->lm_head) == 0)
8717c478bd9Sstevel@tonic-gate 			continue;
8727c478bd9Sstevel@tonic-gate 
873dffec89cSrie 		lml->lm_flags |= LML_FLG_ATEXIT;
874883c6d49Srie 		lml->lm_flags &= ~LML_FLG_INTRPOSETSORT;
875dffec89cSrie 
8767c478bd9Sstevel@tonic-gate 		/*
8777c478bd9Sstevel@tonic-gate 		 * Reverse topologically sort the link-map for .fini execution.
8787c478bd9Sstevel@tonic-gate 		 */
8797c478bd9Sstevel@tonic-gate 		if (((tobj = tsort(lmp, lml->lm_obj, RT_SORT_FWD)) != 0) &&
8807c478bd9Sstevel@tonic-gate 		    (tobj != (Rt_map **)S_ERROR))
8817c478bd9Sstevel@tonic-gate 			call_fini(lml, tobj);
8827c478bd9Sstevel@tonic-gate 
8837c478bd9Sstevel@tonic-gate 		unused(lml);
8847c478bd9Sstevel@tonic-gate 	}
8857c478bd9Sstevel@tonic-gate 
8867c478bd9Sstevel@tonic-gate 	/*
8877c478bd9Sstevel@tonic-gate 	 * Finally reverse topologically sort the runtime linkers link-map for
8887c478bd9Sstevel@tonic-gate 	 * .fini execution.
8897c478bd9Sstevel@tonic-gate 	 */
8907c478bd9Sstevel@tonic-gate 	lml = &lml_rtld;
891dffec89cSrie 	lml->lm_flags |= LML_FLG_ATEXIT;
892883c6d49Srie 	lml->lm_flags &= ~LML_FLG_INTRPOSETSORT;
8937c478bd9Sstevel@tonic-gate 	lmp = (Rt_map *)lml->lm_head;
8947c478bd9Sstevel@tonic-gate 
8957c478bd9Sstevel@tonic-gate 	if (((tobj = tsort(lmp, lml->lm_obj, RT_SORT_FWD)) != 0) &&
8967c478bd9Sstevel@tonic-gate 	    (tobj != (Rt_map **)S_ERROR))
8977c478bd9Sstevel@tonic-gate 		call_fini(lml, tobj);
8987c478bd9Sstevel@tonic-gate 
8997c478bd9Sstevel@tonic-gate 	leave(&lml_main);
9007c478bd9Sstevel@tonic-gate }
9017c478bd9Sstevel@tonic-gate 
9027c478bd9Sstevel@tonic-gate 
9037c478bd9Sstevel@tonic-gate /*
9047c478bd9Sstevel@tonic-gate  * This routine is called to complete any runtime linker activity which may have
9057c478bd9Sstevel@tonic-gate  * resulted in objects being loaded.  This is called from all user entry points
9067c478bd9Sstevel@tonic-gate  * and from any internal dl*() requests.
9077c478bd9Sstevel@tonic-gate  */
9087c478bd9Sstevel@tonic-gate void
9097247f888Srie load_completion(Rt_map *nlmp)
9107c478bd9Sstevel@tonic-gate {
9117c478bd9Sstevel@tonic-gate 	Rt_map	**tobj = 0;
9127247f888Srie 	Lm_list	*nlml;
9137c478bd9Sstevel@tonic-gate 
9147c478bd9Sstevel@tonic-gate 	/*
9157c478bd9Sstevel@tonic-gate 	 * Establish any .init processing.  Note, in a world of lazy loading,
9167c478bd9Sstevel@tonic-gate 	 * objects may have been loaded regardless of whether the users request
9177c478bd9Sstevel@tonic-gate 	 * was fulfilled (i.e., a dlsym() request may have failed to find a
9187c478bd9Sstevel@tonic-gate 	 * symbol but objects might have been loaded during its search).  Thus,
9197c478bd9Sstevel@tonic-gate 	 * any tsorting starts from the nlmp (new link-maps) pointer and not
9207c478bd9Sstevel@tonic-gate 	 * necessarily from the link-map that may have satisfied the request.
9217c478bd9Sstevel@tonic-gate 	 *
92210a4fa49Srie 	 * Note, the primary link-map has an initialization phase where dynamic
92310a4fa49Srie 	 * .init firing is suppressed.  This provides for a simple and clean
92410a4fa49Srie 	 * handshake with the primary link-maps libc, which is important for
92510a4fa49Srie 	 * establishing uberdata.  In addition, auditors often obtain handles
92610a4fa49Srie 	 * to primary link-map objects as the objects are loaded, so as to
92710a4fa49Srie 	 * inspect the link-map for symbols.  This inspection is allowed without
92810a4fa49Srie 	 * running any code on the primary link-map, as running this code may
92910a4fa49Srie 	 * reenter the auditor, who may not yet have finished its own
9307c478bd9Sstevel@tonic-gate 	 * initialization.
9317c478bd9Sstevel@tonic-gate 	 */
93210a4fa49Srie 	if (nlmp)
93310a4fa49Srie 		nlml = LIST(nlmp);
93410a4fa49Srie 
935*b71d513aSedp 	if (nlmp && nlml->lm_init && ((nlml != &lml_main) ||
936*b71d513aSedp 	    (rtld_flags2 & (RT_FL2_PLMSETUP | RT_FL2_NOPLM)))) {
937dffec89cSrie 		if ((tobj = tsort(nlmp, LIST(nlmp)->lm_init,
938dffec89cSrie 		    RT_SORT_REV)) == (Rt_map **)S_ERROR)
9397c478bd9Sstevel@tonic-gate 			tobj = 0;
9407c478bd9Sstevel@tonic-gate 	}
9417c478bd9Sstevel@tonic-gate 
94210a4fa49Srie 	/*
94310a4fa49Srie 	 * Make sure any alternative link-map retrieves any external interfaces
94410a4fa49Srie 	 * and initializes threads.
94510a4fa49Srie 	 */
94610a4fa49Srie 	if (nlmp && (nlml != &lml_main)) {
94710a4fa49Srie 		(void) rt_get_extern(nlml, nlmp);
94810a4fa49Srie 		rt_thr_init(nlml);
94910a4fa49Srie 	}
95010a4fa49Srie 
95110a4fa49Srie 	/*
95210a4fa49Srie 	 * Traverse the list of new link-maps and register any dynamic TLS.
95310a4fa49Srie 	 * This storage is established for any objects not on the primary
95410a4fa49Srie 	 * link-map, and for any objects added to the primary link-map after
95510a4fa49Srie 	 * static TLS has been registered.
95610a4fa49Srie 	 */
957*b71d513aSedp 	if (nlmp && nlml->lm_tls && ((nlml != &lml_main) ||
958*b71d513aSedp 	    (rtld_flags2 & (RT_FL2_PLMSETUP | RT_FL2_NOPLM)))) {
95910a4fa49Srie 		Rt_map	*lmp;
96010a4fa49Srie 
96110a4fa49Srie 		for (lmp = nlmp; lmp; lmp = (Rt_map *)NEXT(lmp)) {
96210a4fa49Srie 			if (PTTLS(lmp) && PTTLS(lmp)->p_memsz)
96310a4fa49Srie 				tls_modaddrem(lmp, TM_FLG_MODADD);
96410a4fa49Srie 		}
96510a4fa49Srie 		nlml->lm_tls = 0;
96610a4fa49Srie 	}
96710a4fa49Srie 
9687c478bd9Sstevel@tonic-gate 	/*
9697c478bd9Sstevel@tonic-gate 	 * Fire any .init's.
9707c478bd9Sstevel@tonic-gate 	 */
9717c478bd9Sstevel@tonic-gate 	if (tobj)
9727c478bd9Sstevel@tonic-gate 		call_init(tobj, DBG_INIT_SORT);
9737c478bd9Sstevel@tonic-gate }
9747c478bd9Sstevel@tonic-gate 
9757c478bd9Sstevel@tonic-gate /*
9767c478bd9Sstevel@tonic-gate  * Append an item to the specified list, and return a pointer to the list
9777c478bd9Sstevel@tonic-gate  * node created.
9787c478bd9Sstevel@tonic-gate  */
9797c478bd9Sstevel@tonic-gate Listnode *
9807c478bd9Sstevel@tonic-gate list_append(List *lst, const void *item)
9817c478bd9Sstevel@tonic-gate {
9827c478bd9Sstevel@tonic-gate 	Listnode *	_lnp;
9837c478bd9Sstevel@tonic-gate 
9847c478bd9Sstevel@tonic-gate 	if ((_lnp = malloc(sizeof (Listnode))) == 0)
9857c478bd9Sstevel@tonic-gate 		return (0);
9867c478bd9Sstevel@tonic-gate 
9877c478bd9Sstevel@tonic-gate 	_lnp->data = (void *)item;
9887c478bd9Sstevel@tonic-gate 	_lnp->next = NULL;
9897c478bd9Sstevel@tonic-gate 
9907c478bd9Sstevel@tonic-gate 	if (lst->head == NULL)
9917c478bd9Sstevel@tonic-gate 		lst->tail = lst->head = _lnp;
9927c478bd9Sstevel@tonic-gate 	else {
9937c478bd9Sstevel@tonic-gate 		lst->tail->next = _lnp;
9947c478bd9Sstevel@tonic-gate 		lst->tail = lst->tail->next;
9957c478bd9Sstevel@tonic-gate 	}
9967c478bd9Sstevel@tonic-gate 	return (_lnp);
9977c478bd9Sstevel@tonic-gate }
9987c478bd9Sstevel@tonic-gate 
9997c478bd9Sstevel@tonic-gate 
10007c478bd9Sstevel@tonic-gate /*
10017c478bd9Sstevel@tonic-gate  * Add an item after specified listnode, and return a pointer to the list
10027c478bd9Sstevel@tonic-gate  * node created.
10037c478bd9Sstevel@tonic-gate  */
10047c478bd9Sstevel@tonic-gate Listnode *
10057c478bd9Sstevel@tonic-gate list_insert(List *lst, const void *item, Listnode *lnp)
10067c478bd9Sstevel@tonic-gate {
10077c478bd9Sstevel@tonic-gate 	Listnode *	_lnp;
10087c478bd9Sstevel@tonic-gate 
10097c478bd9Sstevel@tonic-gate 	if ((_lnp = malloc(sizeof (Listnode))) == (Listnode *)0)
10107c478bd9Sstevel@tonic-gate 		return (0);
10117c478bd9Sstevel@tonic-gate 
10127c478bd9Sstevel@tonic-gate 	_lnp->data = (void *)item;
10137c478bd9Sstevel@tonic-gate 	_lnp->next = lnp->next;
10147c478bd9Sstevel@tonic-gate 	if (_lnp->next == NULL)
10157c478bd9Sstevel@tonic-gate 		lst->tail = _lnp;
10167c478bd9Sstevel@tonic-gate 	lnp->next = _lnp;
10177c478bd9Sstevel@tonic-gate 	return (_lnp);
10187c478bd9Sstevel@tonic-gate }
10197c478bd9Sstevel@tonic-gate 
10207c478bd9Sstevel@tonic-gate /*
10217c478bd9Sstevel@tonic-gate  * Prepend an item to the specified list, and return a pointer to the
10227c478bd9Sstevel@tonic-gate  * list node created.
10237c478bd9Sstevel@tonic-gate  */
10247c478bd9Sstevel@tonic-gate Listnode *
10257c478bd9Sstevel@tonic-gate list_prepend(List * lst, const void * item)
10267c478bd9Sstevel@tonic-gate {
10277c478bd9Sstevel@tonic-gate 	Listnode *	_lnp;
10287c478bd9Sstevel@tonic-gate 
10297c478bd9Sstevel@tonic-gate 	if ((_lnp = malloc(sizeof (Listnode))) == (Listnode *)0)
10307c478bd9Sstevel@tonic-gate 		return (0);
10317c478bd9Sstevel@tonic-gate 
10327c478bd9Sstevel@tonic-gate 	_lnp->data = (void *)item;
10337c478bd9Sstevel@tonic-gate 
10347c478bd9Sstevel@tonic-gate 	if (lst->head == NULL) {
10357c478bd9Sstevel@tonic-gate 		_lnp->next = NULL;
10367c478bd9Sstevel@tonic-gate 		lst->tail = lst->head = _lnp;
10377c478bd9Sstevel@tonic-gate 	} else {
10387c478bd9Sstevel@tonic-gate 		_lnp->next = lst->head;
10397c478bd9Sstevel@tonic-gate 		lst->head = _lnp;
10407c478bd9Sstevel@tonic-gate 	}
10417c478bd9Sstevel@tonic-gate 	return (_lnp);
10427c478bd9Sstevel@tonic-gate }
10437c478bd9Sstevel@tonic-gate 
10447c478bd9Sstevel@tonic-gate 
10457c478bd9Sstevel@tonic-gate /*
10467c478bd9Sstevel@tonic-gate  * Delete a 'listnode' from a list.
10477c478bd9Sstevel@tonic-gate  */
10487c478bd9Sstevel@tonic-gate void
104902ca3e02Srie list_delete(List *lst, void *item)
10507c478bd9Sstevel@tonic-gate {
105102ca3e02Srie 	Listnode	*clnp, *plnp;
10527c478bd9Sstevel@tonic-gate 
10537c478bd9Sstevel@tonic-gate 	for (plnp = NULL, clnp = lst->head; clnp; clnp = clnp->next) {
10547c478bd9Sstevel@tonic-gate 		if (item == clnp->data)
10557c478bd9Sstevel@tonic-gate 			break;
10567c478bd9Sstevel@tonic-gate 		plnp = clnp;
10577c478bd9Sstevel@tonic-gate 	}
10587c478bd9Sstevel@tonic-gate 
10597c478bd9Sstevel@tonic-gate 	if (clnp == 0)
10607c478bd9Sstevel@tonic-gate 		return;
10617c478bd9Sstevel@tonic-gate 
10627c478bd9Sstevel@tonic-gate 	if (lst->head == clnp)
10637c478bd9Sstevel@tonic-gate 		lst->head = clnp->next;
10647c478bd9Sstevel@tonic-gate 	if (lst->tail == clnp)
10657c478bd9Sstevel@tonic-gate 		lst->tail = plnp;
10667c478bd9Sstevel@tonic-gate 
10677c478bd9Sstevel@tonic-gate 	if (plnp)
10687c478bd9Sstevel@tonic-gate 		plnp->next = clnp->next;
10697c478bd9Sstevel@tonic-gate 
10707c478bd9Sstevel@tonic-gate 	free(clnp);
10717c478bd9Sstevel@tonic-gate }
10727c478bd9Sstevel@tonic-gate 
10737c478bd9Sstevel@tonic-gate /*
10747c478bd9Sstevel@tonic-gate  * Append an item to the specified link map control list.
10757c478bd9Sstevel@tonic-gate  */
10767c478bd9Sstevel@tonic-gate void
10777c478bd9Sstevel@tonic-gate lm_append(Lm_list *lml, Aliste lmco, Rt_map *lmp)
10787c478bd9Sstevel@tonic-gate {
10797c478bd9Sstevel@tonic-gate 	Lm_cntl	*lmc;
10807c478bd9Sstevel@tonic-gate 	int	add = 1;
10817c478bd9Sstevel@tonic-gate 
10827c478bd9Sstevel@tonic-gate 	/*
10837c478bd9Sstevel@tonic-gate 	 * Indicate that this link-map list has a new object.
10847c478bd9Sstevel@tonic-gate 	 */
10857c478bd9Sstevel@tonic-gate 	(lml->lm_obj)++;
10867c478bd9Sstevel@tonic-gate 
10877c478bd9Sstevel@tonic-gate 	/*
108812b8e62eSrie 	 * If we're about to add a new object to the main link-map control list,
108912b8e62eSrie 	 * alert the debuggers that we are about to mess with this list.
109012b8e62eSrie 	 * Additions of individual objects to the main link-map control list
109112b8e62eSrie 	 * occur during initial setup as the applications immediate dependencies
109212b8e62eSrie 	 * are loaded.  Individual objects are also loaded on the main link-map
109312b8e62eSrie 	 * control list of new alternative link-map control lists.
10947c478bd9Sstevel@tonic-gate 	 */
1095cce0e03bSab 	if ((lmco == ALIST_OFF_DATA) &&
1096cce0e03bSab 	    ((lml->lm_flags & LML_FLG_DBNOTIF) == 0))
109712b8e62eSrie 		rd_event(lml, RD_DLACTIVITY, RT_ADD);
10987c478bd9Sstevel@tonic-gate 
10997c478bd9Sstevel@tonic-gate 	/* LINTED */
1100cce0e03bSab 	lmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, lmco);
11017c478bd9Sstevel@tonic-gate 
11027c478bd9Sstevel@tonic-gate 	/*
11037c478bd9Sstevel@tonic-gate 	 * A link-map list header points to one of more link-map control lists
11047c478bd9Sstevel@tonic-gate 	 * (see include/rtld.h).  The initial list, pointed to by lm_cntl, is
11057c478bd9Sstevel@tonic-gate 	 * the list of relocated objects.  Other lists maintain objects that
11067c478bd9Sstevel@tonic-gate 	 * are still being analyzed or relocated.  This list provides the core
11077c478bd9Sstevel@tonic-gate 	 * link-map list information used by all ld.so.1 routines.
11087c478bd9Sstevel@tonic-gate 	 */
11097c478bd9Sstevel@tonic-gate 	if (lmc->lc_head == NULL) {
11107c478bd9Sstevel@tonic-gate 		/*
11117c478bd9Sstevel@tonic-gate 		 * If this is the first link-map for the given control list,
11127c478bd9Sstevel@tonic-gate 		 * initialize the list.
11137c478bd9Sstevel@tonic-gate 		 */
11147c478bd9Sstevel@tonic-gate 		lmc->lc_head = lmc->lc_tail = lmp;
11157c478bd9Sstevel@tonic-gate 		add = 0;
11167c478bd9Sstevel@tonic-gate 
11179a411307Srie 	} else if (FLAGS(lmp) & FLG_RT_OBJINTPO) {
11187c478bd9Sstevel@tonic-gate 		Rt_map	*tlmp;
11197c478bd9Sstevel@tonic-gate 
11207c478bd9Sstevel@tonic-gate 		/*
11217c478bd9Sstevel@tonic-gate 		 * If this is an interposer then append the link-map following
11227c478bd9Sstevel@tonic-gate 		 * any other interposers (these are objects that have been
11237c478bd9Sstevel@tonic-gate 		 * previously preloaded, or were identified with -z interpose).
11247c478bd9Sstevel@tonic-gate 		 * Interposers can only be inserted on the first link-map
11257c478bd9Sstevel@tonic-gate 		 * control list, as once relocation has started, interposition
11267c478bd9Sstevel@tonic-gate 		 * from new interposers can't be guaranteed.
11277c478bd9Sstevel@tonic-gate 		 *
11287c478bd9Sstevel@tonic-gate 		 * NOTE: We do not interpose on the head of a list.  This model
11297c478bd9Sstevel@tonic-gate 		 * evolved because dynamic executables have already been fully
11307c478bd9Sstevel@tonic-gate 		 * relocated within themselves and thus can't be interposed on.
11317c478bd9Sstevel@tonic-gate 		 * Nowadays it's possible to have shared objects at the head of
11327c478bd9Sstevel@tonic-gate 		 * a list, which conceptually means they could be interposed on.
11337c478bd9Sstevel@tonic-gate 		 * But, shared objects can be created via dldump() and may only
11347c478bd9Sstevel@tonic-gate 		 * be partially relocated (just relatives), in which case they
11357c478bd9Sstevel@tonic-gate 		 * are interposable, but are marked as fixed (ET_EXEC).
11367c478bd9Sstevel@tonic-gate 		 *
11377c478bd9Sstevel@tonic-gate 		 * Thus we really don't have a clear method of deciding when the
11387c478bd9Sstevel@tonic-gate 		 * head of a link-map is interposable.  So, to be consistent,
11397c478bd9Sstevel@tonic-gate 		 * for now only add interposers after the link-map lists head
11407c478bd9Sstevel@tonic-gate 		 * object.
11417c478bd9Sstevel@tonic-gate 		 */
11427c478bd9Sstevel@tonic-gate 		for (tlmp = (Rt_map *)NEXT(lmc->lc_head); tlmp;
11437c478bd9Sstevel@tonic-gate 		    tlmp = (Rt_map *)NEXT(tlmp)) {
11447c478bd9Sstevel@tonic-gate 
11459a411307Srie 			if (FLAGS(tlmp) & FLG_RT_OBJINTPO)
11467c478bd9Sstevel@tonic-gate 				continue;
11477c478bd9Sstevel@tonic-gate 
11487c478bd9Sstevel@tonic-gate 			/*
11497c478bd9Sstevel@tonic-gate 			 * Insert the new link-map before this non-interposer,
11507c478bd9Sstevel@tonic-gate 			 * and indicate an interposer is found.
11517c478bd9Sstevel@tonic-gate 			 */
11527c478bd9Sstevel@tonic-gate 			NEXT((Rt_map *)PREV(tlmp)) = (Link_map *)lmp;
11537c478bd9Sstevel@tonic-gate 			PREV(lmp) = PREV(tlmp);
11547c478bd9Sstevel@tonic-gate 
11557c478bd9Sstevel@tonic-gate 			NEXT(lmp) = (Link_map *)tlmp;
11567c478bd9Sstevel@tonic-gate 			PREV(tlmp) = (Link_map *)lmp;
11577c478bd9Sstevel@tonic-gate 
11587c478bd9Sstevel@tonic-gate 			lmc->lc_flags |= LMC_FLG_REANALYZE;
11597c478bd9Sstevel@tonic-gate 			add = 0;
11607c478bd9Sstevel@tonic-gate 			break;
11617c478bd9Sstevel@tonic-gate 		}
11627c478bd9Sstevel@tonic-gate 	}
11637c478bd9Sstevel@tonic-gate 
11647c478bd9Sstevel@tonic-gate 	/*
11657c478bd9Sstevel@tonic-gate 	 * Fall through to appending the new link map to the tail of the list.
11667c478bd9Sstevel@tonic-gate 	 * If we're processing the initial objects of this link-map list, add
11677c478bd9Sstevel@tonic-gate 	 * them to the backward compatibility list.
11687c478bd9Sstevel@tonic-gate 	 */
11697c478bd9Sstevel@tonic-gate 	if (add) {
11707c478bd9Sstevel@tonic-gate 		NEXT(lmc->lc_tail) = (Link_map *)lmp;
11717c478bd9Sstevel@tonic-gate 		PREV(lmp) = (Link_map *)lmc->lc_tail;
11727c478bd9Sstevel@tonic-gate 		lmc->lc_tail = lmp;
11737c478bd9Sstevel@tonic-gate 	}
11747c478bd9Sstevel@tonic-gate 
11757c478bd9Sstevel@tonic-gate 	/*
11767c478bd9Sstevel@tonic-gate 	 * Having added this link-map to a control list, indicate which control
11777c478bd9Sstevel@tonic-gate 	 * list the link-map belongs to.  Note, control list information is
11787c478bd9Sstevel@tonic-gate 	 * always maintained as an offset, as the Alist can be reallocated.
11797c478bd9Sstevel@tonic-gate 	 */
11807c478bd9Sstevel@tonic-gate 	CNTL(lmp) = lmco;
11817c478bd9Sstevel@tonic-gate 
11827c478bd9Sstevel@tonic-gate 	/*
11837c478bd9Sstevel@tonic-gate 	 * Indicate if an interposer is found.  Note that the first object on a
11847c478bd9Sstevel@tonic-gate 	 * link-map can be explicitly defined as an interposer so that it can
11857c478bd9Sstevel@tonic-gate 	 * provide interposition over direct binding requests.
11867c478bd9Sstevel@tonic-gate 	 */
11879a411307Srie 	if (FLAGS(lmp) & MSK_RT_INTPOSE)
11887c478bd9Sstevel@tonic-gate 		lml->lm_flags |= LML_FLG_INTRPOSE;
11897c478bd9Sstevel@tonic-gate 
11907c478bd9Sstevel@tonic-gate 	/*
11917c478bd9Sstevel@tonic-gate 	 * For backward compatibility with debuggers, the link-map list contains
11927c478bd9Sstevel@tonic-gate 	 * pointers to the main control list.
11937c478bd9Sstevel@tonic-gate 	 */
1194cce0e03bSab 	if (lmco == ALIST_OFF_DATA) {
11957c478bd9Sstevel@tonic-gate 		lml->lm_head = lmc->lc_head;
11967c478bd9Sstevel@tonic-gate 		lml->lm_tail = lmc->lc_tail;
11977c478bd9Sstevel@tonic-gate 	}
11987c478bd9Sstevel@tonic-gate }
11997c478bd9Sstevel@tonic-gate 
12007c478bd9Sstevel@tonic-gate /*
12017c478bd9Sstevel@tonic-gate  * Delete an item from the specified link map control list.
12027c478bd9Sstevel@tonic-gate  */
12037c478bd9Sstevel@tonic-gate void
12047c478bd9Sstevel@tonic-gate lm_delete(Lm_list *lml, Rt_map *lmp)
12057c478bd9Sstevel@tonic-gate {
12067c478bd9Sstevel@tonic-gate 	Lm_cntl	*lmc;
12077c478bd9Sstevel@tonic-gate 
12087c478bd9Sstevel@tonic-gate 	/*
12097c478bd9Sstevel@tonic-gate 	 * If the control list pointer hasn't been initialized, this object
12107c478bd9Sstevel@tonic-gate 	 * never got added to a link-map list.
12117c478bd9Sstevel@tonic-gate 	 */
12127c478bd9Sstevel@tonic-gate 	if (CNTL(lmp) == 0)
12137c478bd9Sstevel@tonic-gate 		return;
12147c478bd9Sstevel@tonic-gate 
12157c478bd9Sstevel@tonic-gate 	/*
121612b8e62eSrie 	 * If we're about to delete an object from the main link-map control
121712b8e62eSrie 	 * list, alert the debuggers that we are about to mess with this list.
12187c478bd9Sstevel@tonic-gate 	 */
1219cce0e03bSab 	if ((CNTL(lmp) == ALIST_OFF_DATA) &&
1220cce0e03bSab 	    ((lml->lm_flags & LML_FLG_DBNOTIF) == 0))
12217c478bd9Sstevel@tonic-gate 		rd_event(lml, RD_DLACTIVITY, RT_DELETE);
12227c478bd9Sstevel@tonic-gate 
12237c478bd9Sstevel@tonic-gate 	/* LINTED */
1224cce0e03bSab 	lmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, CNTL(lmp));
12257c478bd9Sstevel@tonic-gate 
12267c478bd9Sstevel@tonic-gate 	if (lmc->lc_head == lmp)
12277c478bd9Sstevel@tonic-gate 		lmc->lc_head = (Rt_map *)NEXT(lmp);
12287c478bd9Sstevel@tonic-gate 	else
12297c478bd9Sstevel@tonic-gate 		NEXT((Rt_map *)PREV(lmp)) = (void *)NEXT(lmp);
12307c478bd9Sstevel@tonic-gate 
12317c478bd9Sstevel@tonic-gate 	if (lmc->lc_tail == lmp)
12327c478bd9Sstevel@tonic-gate 		lmc->lc_tail = (Rt_map *)PREV(lmp);
12337c478bd9Sstevel@tonic-gate 	else
12347c478bd9Sstevel@tonic-gate 		PREV((Rt_map *)NEXT(lmp)) = PREV(lmp);
12357c478bd9Sstevel@tonic-gate 
12367c478bd9Sstevel@tonic-gate 	/*
12377c478bd9Sstevel@tonic-gate 	 * For backward compatibility with debuggers, the link-map list contains
12387c478bd9Sstevel@tonic-gate 	 * pointers to the main control list.
12397c478bd9Sstevel@tonic-gate 	 */
1240cce0e03bSab 	if (lmc == (Lm_cntl *)&lml->lm_lists->al_data) {
12417c478bd9Sstevel@tonic-gate 		lml->lm_head = lmc->lc_head;
12427c478bd9Sstevel@tonic-gate 		lml->lm_tail = lmc->lc_tail;
12437c478bd9Sstevel@tonic-gate 	}
12447c478bd9Sstevel@tonic-gate 
12457c478bd9Sstevel@tonic-gate 	/*
12467c478bd9Sstevel@tonic-gate 	 * Indicate we have one less object on this control list.
12477c478bd9Sstevel@tonic-gate 	 */
12487c478bd9Sstevel@tonic-gate 	(lml->lm_obj)--;
12497c478bd9Sstevel@tonic-gate }
12507c478bd9Sstevel@tonic-gate 
12517c478bd9Sstevel@tonic-gate /*
12527c478bd9Sstevel@tonic-gate  * Move a link-map control list to another.  Objects that are being relocated
12537c478bd9Sstevel@tonic-gate  * are maintained on secondary control lists.  Once their relocation is
12547c478bd9Sstevel@tonic-gate  * complete, the entire list is appended to the previous control list, as this
12557c478bd9Sstevel@tonic-gate  * list must have been the trigger for generating the new control list.
12567c478bd9Sstevel@tonic-gate  */
12577c478bd9Sstevel@tonic-gate void
12587c478bd9Sstevel@tonic-gate lm_move(Lm_list *lml, Aliste nlmco, Aliste plmco, Lm_cntl *nlmc, Lm_cntl *plmc)
12597c478bd9Sstevel@tonic-gate {
12607c478bd9Sstevel@tonic-gate 	Rt_map	*lmp;
12617c478bd9Sstevel@tonic-gate 
12627c478bd9Sstevel@tonic-gate 	/*
126312b8e62eSrie 	 * If we're about to add a new family of objects to the main link-map
126412b8e62eSrie 	 * control list, alert the debuggers that we are about to mess with this
126512b8e62eSrie 	 * list.  Additions of object families to the main link-map control
126612b8e62eSrie 	 * list occur during lazy loading, filtering and dlopen().
12677c478bd9Sstevel@tonic-gate 	 */
1268cce0e03bSab 	if ((plmco == ALIST_OFF_DATA) &&
1269cce0e03bSab 	    ((lml->lm_flags & LML_FLG_DBNOTIF) == 0))
12707c478bd9Sstevel@tonic-gate 		rd_event(lml, RD_DLACTIVITY, RT_ADD);
12717c478bd9Sstevel@tonic-gate 
127212b8e62eSrie 	DBG_CALL(Dbg_file_cntl(lml, nlmco, plmco));
127312b8e62eSrie 
12747c478bd9Sstevel@tonic-gate 	/*
12757c478bd9Sstevel@tonic-gate 	 * Indicate each new link-map has been moved to the previous link-map
12767c478bd9Sstevel@tonic-gate 	 * control list.
12777c478bd9Sstevel@tonic-gate 	 */
12787c478bd9Sstevel@tonic-gate 	for (lmp = nlmc->lc_head; lmp; lmp = (Rt_map *)NEXT(lmp))
12797c478bd9Sstevel@tonic-gate 		CNTL(lmp) = plmco;
12807c478bd9Sstevel@tonic-gate 
12817c478bd9Sstevel@tonic-gate 	/*
12827c478bd9Sstevel@tonic-gate 	 * Move the new link-map control list, to the callers link-map control
12837c478bd9Sstevel@tonic-gate 	 * list.
12847c478bd9Sstevel@tonic-gate 	 */
12857c478bd9Sstevel@tonic-gate 	if (plmc->lc_head == 0) {
12867c478bd9Sstevel@tonic-gate 		plmc->lc_head = nlmc->lc_head;
12877c478bd9Sstevel@tonic-gate 		PREV(nlmc->lc_head) = 0;
12887c478bd9Sstevel@tonic-gate 	} else {
12897c478bd9Sstevel@tonic-gate 		NEXT(plmc->lc_tail) = (Link_map *)nlmc->lc_head;
12907c478bd9Sstevel@tonic-gate 		PREV(nlmc->lc_head) = (Link_map *)plmc->lc_tail;
12917c478bd9Sstevel@tonic-gate 	}
12927c478bd9Sstevel@tonic-gate 
12937c478bd9Sstevel@tonic-gate 	plmc->lc_tail = nlmc->lc_tail;
12947c478bd9Sstevel@tonic-gate 	nlmc->lc_head = nlmc->lc_tail = 0;
12957c478bd9Sstevel@tonic-gate 
12967c478bd9Sstevel@tonic-gate 	/*
12977c478bd9Sstevel@tonic-gate 	 * For backward compatibility with debuggers, the link-map list contains
12987c478bd9Sstevel@tonic-gate 	 * pointers to the main control list.
12997c478bd9Sstevel@tonic-gate 	 */
1300cce0e03bSab 	if (plmco == ALIST_OFF_DATA) {
13017c478bd9Sstevel@tonic-gate 		lml->lm_head = plmc->lc_head;
13027c478bd9Sstevel@tonic-gate 		lml->lm_tail = plmc->lc_tail;
13037c478bd9Sstevel@tonic-gate 	}
13047c478bd9Sstevel@tonic-gate }
13057c478bd9Sstevel@tonic-gate 
13067c478bd9Sstevel@tonic-gate /*
13077c478bd9Sstevel@tonic-gate  * Environment variables can have a variety of defined permutations, and thus
13087c478bd9Sstevel@tonic-gate  * the following infrastructure exists to allow this variety and to select the
13097c478bd9Sstevel@tonic-gate  * required definition.
13107c478bd9Sstevel@tonic-gate  *
13117c478bd9Sstevel@tonic-gate  * Environment variables can be defined as 32- or 64-bit specific, and if so
13127c478bd9Sstevel@tonic-gate  * they will take precedence over any instruction set neutral form.  Typically
13137c478bd9Sstevel@tonic-gate  * this is only useful when the environment value is an informational string.
13147c478bd9Sstevel@tonic-gate  *
13157c478bd9Sstevel@tonic-gate  * Environment variables may be obtained from the standard user environment or
13167c478bd9Sstevel@tonic-gate  * from a configuration file.  The latter provides a fallback if no user
13177c478bd9Sstevel@tonic-gate  * environment setting is found, and can take two forms:
13187c478bd9Sstevel@tonic-gate  *
13197c478bd9Sstevel@tonic-gate  *  .	a replaceable definition - this will be used if no user environment
13207c478bd9Sstevel@tonic-gate  *	setting has been seen, or
13217c478bd9Sstevel@tonic-gate  *
13227c478bd9Sstevel@tonic-gate  *  .	an permanent definition - this will be used no matter what user
13237c478bd9Sstevel@tonic-gate  *	environment setting is seen.  In the case of list variables it will be
13247c478bd9Sstevel@tonic-gate  *	appended to any process environment setting seen.
13257c478bd9Sstevel@tonic-gate  *
13267c478bd9Sstevel@tonic-gate  * Environment variables can be defined without a value (ie. LD_XXXX=) so as to
13277c478bd9Sstevel@tonic-gate  * override any replaceable environment variables from a configuration file.
13287c478bd9Sstevel@tonic-gate  */
13297c478bd9Sstevel@tonic-gate static	u_longlong_t		rplgen;		/* replaceable generic */
13307c478bd9Sstevel@tonic-gate 						/*	variables */
13317c478bd9Sstevel@tonic-gate static	u_longlong_t		rplisa;		/* replaceable ISA specific */
13327c478bd9Sstevel@tonic-gate 						/*	variables */
13337c478bd9Sstevel@tonic-gate static	u_longlong_t		prmgen;		/* permanent generic */
13347c478bd9Sstevel@tonic-gate 						/*	variables */
13357c478bd9Sstevel@tonic-gate static	u_longlong_t		prmisa;		/* permanent ISA specific */
13367c478bd9Sstevel@tonic-gate 						/*	variables */
13377c478bd9Sstevel@tonic-gate 
13387c478bd9Sstevel@tonic-gate /*
13397c478bd9Sstevel@tonic-gate  * Classify an environment variables type.
13407c478bd9Sstevel@tonic-gate  */
13417c478bd9Sstevel@tonic-gate #define	ENV_TYP_IGNORE		0x1		/* ignore - variable is for */
13427c478bd9Sstevel@tonic-gate 						/*	the wrong ISA */
13437c478bd9Sstevel@tonic-gate #define	ENV_TYP_ISA		0x2		/* variable is ISA specific */
13447c478bd9Sstevel@tonic-gate #define	ENV_TYP_CONFIG		0x4		/* variable obtained from a */
13457c478bd9Sstevel@tonic-gate 						/*	config file */
13467c478bd9Sstevel@tonic-gate #define	ENV_TYP_PERMANT		0x8		/* variable is permanent */
13477c478bd9Sstevel@tonic-gate 
13487c478bd9Sstevel@tonic-gate /*
13497c478bd9Sstevel@tonic-gate  * Identify all environment variables.
13507c478bd9Sstevel@tonic-gate  */
13517c478bd9Sstevel@tonic-gate #define	ENV_FLG_AUDIT		0x0000000001ULL
13527c478bd9Sstevel@tonic-gate #define	ENV_FLG_AUDIT_ARGS	0x0000000002ULL
13537c478bd9Sstevel@tonic-gate #define	ENV_FLG_BIND_NOW	0x0000000004ULL
13547c478bd9Sstevel@tonic-gate #define	ENV_FLG_BIND_NOT	0x0000000008ULL
13557c478bd9Sstevel@tonic-gate #define	ENV_FLG_BINDINGS	0x0000000010ULL
13567c478bd9Sstevel@tonic-gate #define	ENV_FLG_CONCURRENCY	0x0000000020ULL
13577c478bd9Sstevel@tonic-gate #define	ENV_FLG_CONFGEN		0x0000000040ULL
13587c478bd9Sstevel@tonic-gate #define	ENV_FLG_CONFIG		0x0000000080ULL
13597c478bd9Sstevel@tonic-gate #define	ENV_FLG_DEBUG		0x0000000100ULL
13607c478bd9Sstevel@tonic-gate #define	ENV_FLG_DEBUG_OUTPUT	0x0000000200ULL
13617c478bd9Sstevel@tonic-gate #define	ENV_FLG_DEMANGLE	0x0000000400ULL
13627c478bd9Sstevel@tonic-gate #define	ENV_FLG_FLAGS		0x0000000800ULL
13637c478bd9Sstevel@tonic-gate #define	ENV_FLG_INIT		0x0000001000ULL
13647c478bd9Sstevel@tonic-gate #define	ENV_FLG_LIBPATH		0x0000002000ULL
13657c478bd9Sstevel@tonic-gate #define	ENV_FLG_LOADAVAIL	0x0000004000ULL
13667c478bd9Sstevel@tonic-gate #define	ENV_FLG_LOADFLTR	0x0000008000ULL
13677c478bd9Sstevel@tonic-gate #define	ENV_FLG_NOAUDIT		0x0000010000ULL
13687c478bd9Sstevel@tonic-gate #define	ENV_FLG_NOAUXFLTR	0x0000020000ULL
13697c478bd9Sstevel@tonic-gate #define	ENV_FLG_NOBAPLT		0x0000040000ULL
13707c478bd9Sstevel@tonic-gate #define	ENV_FLG_NOCONFIG	0x0000080000ULL
13717c478bd9Sstevel@tonic-gate #define	ENV_FLG_NODIRCONFIG	0x0000100000ULL
13727c478bd9Sstevel@tonic-gate #define	ENV_FLG_NODIRECT	0x0000200000ULL
13737c478bd9Sstevel@tonic-gate #define	ENV_FLG_NOENVCONFIG	0x0000400000ULL
13747c478bd9Sstevel@tonic-gate #define	ENV_FLG_NOLAZY		0x0000800000ULL
13757c478bd9Sstevel@tonic-gate #define	ENV_FLG_NOOBJALTER	0x0001000000ULL
13767c478bd9Sstevel@tonic-gate #define	ENV_FLG_NOVERSION	0x0002000000ULL
13777c478bd9Sstevel@tonic-gate #define	ENV_FLG_PRELOAD		0x0004000000ULL
13787c478bd9Sstevel@tonic-gate #define	ENV_FLG_PROFILE		0x0008000000ULL
13797c478bd9Sstevel@tonic-gate #define	ENV_FLG_PROFILE_OUTPUT	0x0010000000ULL
13807c478bd9Sstevel@tonic-gate #define	ENV_FLG_SIGNAL		0x0020000000ULL
13817c478bd9Sstevel@tonic-gate #define	ENV_FLG_TRACE_OBJS	0x0040000000ULL
13827c478bd9Sstevel@tonic-gate #define	ENV_FLG_TRACE_PTHS	0x0080000000ULL
13837c478bd9Sstevel@tonic-gate #define	ENV_FLG_UNREF		0x0100000000ULL
13847c478bd9Sstevel@tonic-gate #define	ENV_FLG_UNUSED		0x0200000000ULL
13857c478bd9Sstevel@tonic-gate #define	ENV_FLG_VERBOSE		0x0400000000ULL
13867c478bd9Sstevel@tonic-gate #define	ENV_FLG_WARN		0x0800000000ULL
13877c478bd9Sstevel@tonic-gate #define	ENV_FLG_NOFLTCONFIG	0x1000000000ULL
1388dffec89cSrie #define	ENV_FLG_BIND_LAZY	0x2000000000ULL
1389df4628cbSrie #define	ENV_FLG_NOUNRESWEAK	0x4000000000ULL
1390dae2dfb7Srie #define	ENV_FLG_NOPAREXT	0x8000000000ULL
13917c478bd9Sstevel@tonic-gate 
13927c478bd9Sstevel@tonic-gate #ifdef	SIEBEL_DISABLE
13937c478bd9Sstevel@tonic-gate #define	ENV_FLG_FIX_1		0x8000000000ULL
13947c478bd9Sstevel@tonic-gate #endif
13957c478bd9Sstevel@tonic-gate 
13967c478bd9Sstevel@tonic-gate #define	SEL_REPLACE		0x0001
13977c478bd9Sstevel@tonic-gate #define	SEL_PERMANT		0x0002
13987c478bd9Sstevel@tonic-gate #define	SEL_ACT_RT		0x0100	/* setting rtld_flags */
13997c478bd9Sstevel@tonic-gate #define	SEL_ACT_RT2		0x0200	/* setting rtld_flags2 */
14007c478bd9Sstevel@tonic-gate #define	SEL_ACT_STR		0x0400	/* setting string value */
14017c478bd9Sstevel@tonic-gate #define	SEL_ACT_LML		0x0800	/* setting lml_flags */
14027c478bd9Sstevel@tonic-gate #define	SEL_ACT_LMLT		0x1000	/* setting lml_tflags */
14037c478bd9Sstevel@tonic-gate #define	SEL_ACT_SPEC_1		0x2000	/* For FLG_{FLAGS, LIBPATH} */
14047c478bd9Sstevel@tonic-gate #define	SEL_ACT_SPEC_2		0x4000	/* need special handling */
14057c478bd9Sstevel@tonic-gate 
14067c478bd9Sstevel@tonic-gate /*
14077c478bd9Sstevel@tonic-gate  * Pattern match an LD_XXXX environment variable.  s1 points to the XXXX part
14087c478bd9Sstevel@tonic-gate  * and len specifies its length (comparing a strings length before the string
14097c478bd9Sstevel@tonic-gate  * itself speed things up).  s2 points to the token itself which has already
14107c478bd9Sstevel@tonic-gate  * had any leading white-space removed.
14117c478bd9Sstevel@tonic-gate  */
14127c478bd9Sstevel@tonic-gate static void
14137c478bd9Sstevel@tonic-gate ld_generic_env(const char *s1, size_t len, const char *s2, Word *lmflags,
14147c478bd9Sstevel@tonic-gate     Word *lmtflags, uint_t env_flags, int aout)
14157c478bd9Sstevel@tonic-gate {
14167c478bd9Sstevel@tonic-gate 	u_longlong_t	variable = 0;
141710a4fa49Srie 	ushort_t	select = 0;
141810a4fa49Srie 	const char	**str;
141910a4fa49Srie 	Word		val = 0;
14207c478bd9Sstevel@tonic-gate 
14217c478bd9Sstevel@tonic-gate 	/*
14227c478bd9Sstevel@tonic-gate 	 * Determine whether we're dealing with a replaceable or permanent
14237c478bd9Sstevel@tonic-gate 	 * string.
14247c478bd9Sstevel@tonic-gate 	 */
14257c478bd9Sstevel@tonic-gate 	if (env_flags & ENV_TYP_PERMANT) {
14267c478bd9Sstevel@tonic-gate 		/*
14277c478bd9Sstevel@tonic-gate 		 * If the string is from a configuration file and defined as
14287c478bd9Sstevel@tonic-gate 		 * permanent, assign it as permanent.
14297c478bd9Sstevel@tonic-gate 		 */
14307c478bd9Sstevel@tonic-gate 		select |= SEL_PERMANT;
14317c478bd9Sstevel@tonic-gate 	} else
14327c478bd9Sstevel@tonic-gate 		select |= SEL_REPLACE;
14337c478bd9Sstevel@tonic-gate 
14347c478bd9Sstevel@tonic-gate 	/*
14357c478bd9Sstevel@tonic-gate 	 * Parse the variable given.
14367c478bd9Sstevel@tonic-gate 	 *
14377c478bd9Sstevel@tonic-gate 	 * The LD_AUDIT family.
14387c478bd9Sstevel@tonic-gate 	 */
14397c478bd9Sstevel@tonic-gate 	if (*s1 == 'A') {
14407c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_AUDIT_SIZE) && (strncmp(s1,
14417c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_AUDIT), MSG_LD_AUDIT_SIZE) == 0)) {
14427c478bd9Sstevel@tonic-gate 			/*
14437c478bd9Sstevel@tonic-gate 			 * Replaceable and permanent audit objects can exist.
14447c478bd9Sstevel@tonic-gate 			 */
14457c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_STR;
1446fa034d7fSseizo 			if (select & SEL_REPLACE)
1447fa034d7fSseizo 				str = &rpl_audit;
1448fa034d7fSseizo 			else {
1449fa034d7fSseizo 				str = &prm_audit;
1450fa034d7fSseizo 				rpl_audit = 0;
1451fa034d7fSseizo 			}
14527c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_AUDIT;
14537c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_AUDIT_ARGS_SIZE) &&
14547c478bd9Sstevel@tonic-gate 		    (strncmp(s1, MSG_ORIG(MSG_LD_AUDIT_ARGS),
14557c478bd9Sstevel@tonic-gate 		    MSG_LD_AUDIT_ARGS_SIZE) == 0)) {
14567c478bd9Sstevel@tonic-gate 			/*
14577c478bd9Sstevel@tonic-gate 			 * A specialized variable for plt_exit() use, not
14587c478bd9Sstevel@tonic-gate 			 * documented for general use.
14597c478bd9Sstevel@tonic-gate 			 */
14607c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_2;
14617c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_AUDIT_ARGS;
14627c478bd9Sstevel@tonic-gate 		}
14637c478bd9Sstevel@tonic-gate 	}
14647c478bd9Sstevel@tonic-gate 	/*
14657c478bd9Sstevel@tonic-gate 	 * The LD_BIND family and LD_BREADTH (historic).
14667c478bd9Sstevel@tonic-gate 	 */
14677c478bd9Sstevel@tonic-gate 	else if (*s1 == 'B') {
1468dffec89cSrie 		if ((len == MSG_LD_BIND_LAZY_SIZE) && (strncmp(s1,
1469dffec89cSrie 		    MSG_ORIG(MSG_LD_BIND_LAZY),
1470dffec89cSrie 		    MSG_LD_BIND_LAZY_SIZE) == 0)) {
1471dffec89cSrie 			select |= SEL_ACT_RT2;
1472dffec89cSrie 			val = RT_FL2_BINDLAZY;
1473dffec89cSrie 			variable = ENV_FLG_BIND_LAZY;
1474dffec89cSrie 		} else if ((len == MSG_LD_BIND_NOW_SIZE) && (strncmp(s1,
14757c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_BIND_NOW), MSG_LD_BIND_NOW_SIZE) == 0)) {
14767c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT2;
14777c478bd9Sstevel@tonic-gate 			val = RT_FL2_BINDNOW;
14787c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_BIND_NOW;
14797c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_BIND_NOT_SIZE) && (strncmp(s1,
14807c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_BIND_NOT), MSG_LD_BIND_NOT_SIZE) == 0)) {
14817c478bd9Sstevel@tonic-gate 			/*
14827c478bd9Sstevel@tonic-gate 			 * Another trick, enabled to help debug AOUT
14837c478bd9Sstevel@tonic-gate 			 * applications under BCP, but not documented for
14847c478bd9Sstevel@tonic-gate 			 * general use.
14857c478bd9Sstevel@tonic-gate 			 */
14867c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
14877c478bd9Sstevel@tonic-gate 			val = RT_FL_NOBIND;
14887c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_BIND_NOT;
14897c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_BINDINGS_SIZE) && (strncmp(s1,
14907c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_BINDINGS), MSG_LD_BINDINGS_SIZE) == 0)) {
14917c478bd9Sstevel@tonic-gate 			/*
14927c478bd9Sstevel@tonic-gate 			 * This variable is simply for backward compatibility.
14937c478bd9Sstevel@tonic-gate 			 * If this and LD_DEBUG are both specified, only one of
14947c478bd9Sstevel@tonic-gate 			 * the strings is going to get processed.
14957c478bd9Sstevel@tonic-gate 			 */
14967c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_2;
14977c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_BINDINGS;
14987c478bd9Sstevel@tonic-gate #ifndef LD_BREADTH_DISABLED
14997c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_BREADTH_SIZE) && (strncmp(s1,
15007c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_BREADTH), MSG_LD_BREADTH_SIZE) == 0)) {
15017c478bd9Sstevel@tonic-gate 			/*
15027c478bd9Sstevel@tonic-gate 			 * Besides some old patches this is no longer available.
15037c478bd9Sstevel@tonic-gate 			 */
15047c478bd9Sstevel@tonic-gate 			rtld_flags |= RT_FL_BREADTH;
15057c478bd9Sstevel@tonic-gate 			return;
15067c478bd9Sstevel@tonic-gate #endif
15077c478bd9Sstevel@tonic-gate 		}
15087c478bd9Sstevel@tonic-gate 	}
15097c478bd9Sstevel@tonic-gate 	/*
15107c478bd9Sstevel@tonic-gate 	 * LD_CONCURRENCY and LD_CONFIG family.
15117c478bd9Sstevel@tonic-gate 	 */
15127c478bd9Sstevel@tonic-gate 	else if (*s1 == 'C') {
15137c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_CONCURRENCY_SIZE) && (strncmp(s1,
15147c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_CONCURRENCY),
15157c478bd9Sstevel@tonic-gate 		    MSG_LD_CONCURRENCY_SIZE) == 0)) {
15167c478bd9Sstevel@tonic-gate 			/*
15177c478bd9Sstevel@tonic-gate 			 * Waiting in the wings, as concurrency checking isn't
15187c478bd9Sstevel@tonic-gate 			 * yet enabled.
15197c478bd9Sstevel@tonic-gate 			 */
15207c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_2;
15217c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_CONCURRENCY;
15227c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_CONFGEN_SIZE) && (strncmp(s1,
15237c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_CONFGEN), MSG_LD_CONFGEN_SIZE) == 0)) {
15247c478bd9Sstevel@tonic-gate 			/*
15257c478bd9Sstevel@tonic-gate 			 * Set by crle(1) to indicate it's building a
15267c478bd9Sstevel@tonic-gate 			 * configuration file, not documented for general use.
15277c478bd9Sstevel@tonic-gate 			 */
15287c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_2;
15297c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_CONFGEN;
15307c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_CONFIG_SIZE) && (strncmp(s1,
15317c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_CONFIG), MSG_LD_CONFIG_SIZE) == 0)) {
15327c478bd9Sstevel@tonic-gate 			/*
15337c478bd9Sstevel@tonic-gate 			 * Secure applications must use a default configuration
15347c478bd9Sstevel@tonic-gate 			 * file.  A setting from a configuration file doesn't
15357c478bd9Sstevel@tonic-gate 			 * make sense (given we must be reading a configuration
15367c478bd9Sstevel@tonic-gate 			 * file to have gotten this).
15377c478bd9Sstevel@tonic-gate 			 */
15387c478bd9Sstevel@tonic-gate 			if ((rtld_flags & RT_FL_SECURE) ||
15397c478bd9Sstevel@tonic-gate 			    (env_flags & ENV_TYP_CONFIG))
15407c478bd9Sstevel@tonic-gate 				return;
15417c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_STR;
15427c478bd9Sstevel@tonic-gate 			str = &config->c_name;
15437c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_CONFIG;
15447c478bd9Sstevel@tonic-gate 		}
15457c478bd9Sstevel@tonic-gate 	}
15467c478bd9Sstevel@tonic-gate 	/*
15477c478bd9Sstevel@tonic-gate 	 * The LD_DEBUG family and LD_DEMANGLE.
15487c478bd9Sstevel@tonic-gate 	 */
15497c478bd9Sstevel@tonic-gate 	else if (*s1 == 'D') {
15507c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_DEBUG_SIZE) && (strncmp(s1,
15517c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_DEBUG), MSG_LD_DEBUG_SIZE) == 0)) {
15527c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_STR;
1553fa034d7fSseizo 			if (select & SEL_REPLACE)
1554fa034d7fSseizo 				str = &rpl_debug;
1555fa034d7fSseizo 			else {
1556fa034d7fSseizo 				str = &prm_debug;
1557fa034d7fSseizo 				rpl_debug = 0;
1558fa034d7fSseizo 			}
15597c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_DEBUG;
15607c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_DEBUG_OUTPUT_SIZE) && (strncmp(s1,
15617c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_DEBUG_OUTPUT),
15627c478bd9Sstevel@tonic-gate 		    MSG_LD_DEBUG_OUTPUT_SIZE) == 0)) {
15637c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_STR;
15647c478bd9Sstevel@tonic-gate 			str = &dbg_file;
15657c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_DEBUG_OUTPUT;
15667c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_DEMANGLE_SIZE) && (strncmp(s1,
15677c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_DEMANGLE), MSG_LD_DEMANGLE_SIZE) == 0)) {
15687c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
15697c478bd9Sstevel@tonic-gate 			val = RT_FL_DEMANGLE;
15707c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_DEMANGLE;
15717c478bd9Sstevel@tonic-gate 		}
15727c478bd9Sstevel@tonic-gate 	}
15737c478bd9Sstevel@tonic-gate 	/*
15747c478bd9Sstevel@tonic-gate 	 * LD_FLAGS - collect the best variable definition.  On completion of
15757c478bd9Sstevel@tonic-gate 	 * environment variable processing pass the result to ld_flags_env()
15767c478bd9Sstevel@tonic-gate 	 * where they'll be decomposed and passed back to this routine.
15777c478bd9Sstevel@tonic-gate 	 */
15787c478bd9Sstevel@tonic-gate 	else if (*s1 == 'F') {
15797c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_FLAGS_SIZE) && (strncmp(s1,
15807c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_FLAGS), MSG_LD_FLAGS_SIZE) == 0)) {
15817c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_1;
1582fa034d7fSseizo 			if (select & SEL_REPLACE)
1583fa034d7fSseizo 				str = &rpl_ldflags;
1584fa034d7fSseizo 			else {
1585fa034d7fSseizo 				str = &prm_ldflags;
1586fa034d7fSseizo 				rpl_ldflags = 0;
1587fa034d7fSseizo 			}
15887c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_FLAGS;
15897c478bd9Sstevel@tonic-gate 		}
15907c478bd9Sstevel@tonic-gate 	}
15917c478bd9Sstevel@tonic-gate 	/*
15927c478bd9Sstevel@tonic-gate 	 * LD_INIT (internal, used by ldd(1)).
15937c478bd9Sstevel@tonic-gate 	 */
15947c478bd9Sstevel@tonic-gate 	else if (*s1 == 'I') {
15957c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_INIT_SIZE) && (strncmp(s1,
15967c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_INIT), MSG_LD_INIT_SIZE) == 0)) {
15977c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LML;
15987c478bd9Sstevel@tonic-gate 			val = LML_FLG_TRC_INIT;
15997c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_INIT;
16007c478bd9Sstevel@tonic-gate 		}
16017c478bd9Sstevel@tonic-gate 	}
16027c478bd9Sstevel@tonic-gate 	/*
16037c478bd9Sstevel@tonic-gate 	 * The LD_LIBRARY_PATH and LD_LOAD families.
16047c478bd9Sstevel@tonic-gate 	 */
16057c478bd9Sstevel@tonic-gate 	else if (*s1 == 'L') {
16067c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_LIBPATH_SIZE) && (strncmp(s1,
16077c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_LIBPATH), MSG_LD_LIBPATH_SIZE) == 0)) {
16087c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_1;
1609fa034d7fSseizo 			if (select & SEL_REPLACE)
1610fa034d7fSseizo 				str = &rpl_libpath;
1611fa034d7fSseizo 			else {
1612fa034d7fSseizo 				str = &prm_libpath;
1613fa034d7fSseizo 				rpl_libpath = 0;
1614fa034d7fSseizo 			}
16157c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_LIBPATH;
16167c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_LOADAVAIL_SIZE) && (strncmp(s1,
16177c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_LOADAVAIL), MSG_LD_LOADAVAIL_SIZE) == 0)) {
16187c478bd9Sstevel@tonic-gate 			/*
16197c478bd9Sstevel@tonic-gate 			 * Internal use by crle(1), not documented for general
16207c478bd9Sstevel@tonic-gate 			 * use.
16217c478bd9Sstevel@tonic-gate 			 */
16227c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LML;
16237c478bd9Sstevel@tonic-gate 			val = LML_FLG_LOADAVAIL;
16247c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_LOADAVAIL;
16257c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_LOADFLTR_SIZE) && (strncmp(s1,
16267c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_LOADFLTR), MSG_LD_LOADFLTR_SIZE) == 0)) {
16277c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_2;
16287c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_LOADFLTR;
16297c478bd9Sstevel@tonic-gate 		}
16307c478bd9Sstevel@tonic-gate 	}
16317c478bd9Sstevel@tonic-gate 	/*
16327c478bd9Sstevel@tonic-gate 	 * The LD_NO family.
16337c478bd9Sstevel@tonic-gate 	 */
16347c478bd9Sstevel@tonic-gate 	else if (*s1 == 'N') {
16357c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_NOAUDIT_SIZE) && (strncmp(s1,
16367c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOAUDIT), MSG_LD_NOAUDIT_SIZE) == 0)) {
16377c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
16387c478bd9Sstevel@tonic-gate 			val = RT_FL_NOAUDIT;
16397c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOAUDIT;
16407c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NOAUXFLTR_SIZE) && (strncmp(s1,
16417c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOAUXFLTR), MSG_LD_NOAUXFLTR_SIZE) == 0)) {
16427c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
16437c478bd9Sstevel@tonic-gate 			val = RT_FL_NOAUXFLTR;
16447c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOAUXFLTR;
16457c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NOBAPLT_SIZE) && (strncmp(s1,
16467c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOBAPLT), MSG_LD_NOBAPLT_SIZE) == 0)) {
16477c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
16487c478bd9Sstevel@tonic-gate 			val = RT_FL_NOBAPLT;
16497c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOBAPLT;
16507c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NOCONFIG_SIZE) && (strncmp(s1,
16517c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOCONFIG), MSG_LD_NOCONFIG_SIZE) == 0)) {
16527c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
16537c478bd9Sstevel@tonic-gate 			val = RT_FL_NOCFG;
16547c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOCONFIG;
16557c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NODIRCONFIG_SIZE) && (strncmp(s1,
16567c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NODIRCONFIG),
16577c478bd9Sstevel@tonic-gate 		    MSG_LD_NODIRCONFIG_SIZE) == 0)) {
16587c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
16597c478bd9Sstevel@tonic-gate 			val = RT_FL_NODIRCFG;
16607c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NODIRCONFIG;
16617c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NODIRECT_SIZE) && (strncmp(s1,
16627c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NODIRECT), MSG_LD_NODIRECT_SIZE) == 0)) {
16637c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LMLT;
16647c478bd9Sstevel@tonic-gate 			val = LML_TFLG_NODIRECT;
16657c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NODIRECT;
16667c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NOENVCONFIG_SIZE) && (strncmp(s1,
16677c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOENVCONFIG),
16687c478bd9Sstevel@tonic-gate 		    MSG_LD_NOENVCONFIG_SIZE) == 0)) {
16697c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
16707c478bd9Sstevel@tonic-gate 			val = RT_FL_NOENVCFG;
16717c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOENVCONFIG;
16727c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NOFLTCONFIG_SIZE) && (strncmp(s1,
16737c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOFLTCONFIG),
16747c478bd9Sstevel@tonic-gate 		    MSG_LD_NOFLTCONFIG_SIZE) == 0)) {
16757c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT2;
16767c478bd9Sstevel@tonic-gate 			val = RT_FL2_NOFLTCFG;
16777c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOFLTCONFIG;
16787c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NOLAZY_SIZE) && (strncmp(s1,
16797c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOLAZY), MSG_LD_NOLAZY_SIZE) == 0)) {
16807c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LMLT;
16817c478bd9Sstevel@tonic-gate 			val = LML_TFLG_NOLAZYLD;
16827c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOLAZY;
16837c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NOOBJALTER_SIZE) && (strncmp(s1,
16847c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOOBJALTER),
16857c478bd9Sstevel@tonic-gate 		    MSG_LD_NOOBJALTER_SIZE) == 0)) {
16867c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
16877c478bd9Sstevel@tonic-gate 			val = RT_FL_NOOBJALT;
16887c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOOBJALTER;
16897c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NOVERSION_SIZE) && (strncmp(s1,
16907c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOVERSION), MSG_LD_NOVERSION_SIZE) == 0)) {
16917c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
16927c478bd9Sstevel@tonic-gate 			val = RT_FL_NOVERSION;
16937c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOVERSION;
1694df4628cbSrie 		} else if ((len == MSG_LD_NOUNRESWEAK_SIZE) && (strncmp(s1,
1695df4628cbSrie 		    MSG_ORIG(MSG_LD_NOUNRESWEAK),
1696df4628cbSrie 		    MSG_LD_NOUNRESWEAK_SIZE) == 0)) {
1697df4628cbSrie 			/*
1698df4628cbSrie 			 * LD_NOUNRESWEAK (internal, used by ldd(1)).
1699df4628cbSrie 			 */
1700df4628cbSrie 			select |= SEL_ACT_LML;
1701df4628cbSrie 			val = LML_FLG_TRC_NOUNRESWEAK;
1702df4628cbSrie 			variable = ENV_FLG_NOUNRESWEAK;
1703dae2dfb7Srie 		} else if ((len == MSG_LD_NOPAREXT_SIZE) && (strncmp(s1,
1704dae2dfb7Srie 		    MSG_ORIG(MSG_LD_NOPAREXT), MSG_LD_NOPAREXT_SIZE) == 0)) {
1705dae2dfb7Srie 			select |= SEL_ACT_LML;
1706dae2dfb7Srie 			val = LML_FLG_TRC_NOPAREXT;
1707dae2dfb7Srie 			variable = ENV_FLG_NOPAREXT;
17087c478bd9Sstevel@tonic-gate 		}
17097c478bd9Sstevel@tonic-gate 	}
17107c478bd9Sstevel@tonic-gate 	/*
17117c478bd9Sstevel@tonic-gate 	 * LD_ORIGIN.
17127c478bd9Sstevel@tonic-gate 	 */
17137c478bd9Sstevel@tonic-gate 	else if (*s1 == 'O') {
17147c478bd9Sstevel@tonic-gate #ifndef	EXPAND_RELATIVE
17157c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_ORIGIN_SIZE) && (strncmp(s1,
17167c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_ORIGIN), MSG_LD_ORIGIN_SIZE) == 0)) {
17177c478bd9Sstevel@tonic-gate 			/*
17187c478bd9Sstevel@tonic-gate 			 * Besides some old patches this is no longer required.
17197c478bd9Sstevel@tonic-gate 			 */
17207c478bd9Sstevel@tonic-gate 			rtld_flags |= RT_FL_RELATIVE;
17217c478bd9Sstevel@tonic-gate 		}
17227c478bd9Sstevel@tonic-gate #endif
17237c478bd9Sstevel@tonic-gate 		return;
17247c478bd9Sstevel@tonic-gate 	}
17257c478bd9Sstevel@tonic-gate 	/*
17267c478bd9Sstevel@tonic-gate 	 * LD_PRELOAD and LD_PROFILE family.
17277c478bd9Sstevel@tonic-gate 	 */
17287c478bd9Sstevel@tonic-gate 	else if (*s1 == 'P') {
17297c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_PRELOAD_SIZE) && (strncmp(s1,
17307c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_PRELOAD), MSG_LD_PRELOAD_SIZE) == 0)) {
17317c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_STR;
1732fa034d7fSseizo 			if (select & SEL_REPLACE)
1733fa034d7fSseizo 				str = &rpl_preload;
1734fa034d7fSseizo 			else  {
1735fa034d7fSseizo 				str = &prm_preload;
1736fa034d7fSseizo 				rpl_preload = 0;
1737fa034d7fSseizo 			}
17387c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_PRELOAD;
17397c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_PROFILE_SIZE) && (strncmp(s1,
17407c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_PROFILE), MSG_LD_PROFILE_SIZE) == 0)) {
17417c478bd9Sstevel@tonic-gate 			/*
17427c478bd9Sstevel@tonic-gate 			 * Only one user library can be profiled at a time.
17437c478bd9Sstevel@tonic-gate 			 */
17447c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_2;
17457c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_PROFILE;
17467c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_PROFILE_OUTPUT_SIZE) && (strncmp(s1,
17477c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_PROFILE_OUTPUT),
17487c478bd9Sstevel@tonic-gate 		    MSG_LD_PROFILE_OUTPUT_SIZE) == 0)) {
17497c478bd9Sstevel@tonic-gate 			/*
17507c478bd9Sstevel@tonic-gate 			 * Only one user library can be profiled at a time.
17517c478bd9Sstevel@tonic-gate 			 */
17527c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_STR;
17537c478bd9Sstevel@tonic-gate 			str = &profile_out;
17547c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_PROFILE_OUTPUT;
17557c478bd9Sstevel@tonic-gate 		}
17567c478bd9Sstevel@tonic-gate 	}
17577c478bd9Sstevel@tonic-gate 	/*
17587c478bd9Sstevel@tonic-gate 	 * LD_SIGNAL.
17597c478bd9Sstevel@tonic-gate 	 */
17607c478bd9Sstevel@tonic-gate 	else if (*s1 == 'S') {
17617c478bd9Sstevel@tonic-gate 		if (rtld_flags & RT_FL_SECURE)
17627c478bd9Sstevel@tonic-gate 			return;
17637c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_SIGNAL_SIZE) &&
17647c478bd9Sstevel@tonic-gate 		    (strncmp(s1, MSG_ORIG(MSG_LD_SIGNAL),
17657c478bd9Sstevel@tonic-gate 		    MSG_LD_SIGNAL_SIZE) == 0)) {
17667c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_2;
17677c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_SIGNAL;
17687c478bd9Sstevel@tonic-gate 		}
17697c478bd9Sstevel@tonic-gate 	}
17707c478bd9Sstevel@tonic-gate 	/*
17711d1fba8aSrie 	 * The LD_TRACE family (internal, used by ldd(1)).  This definition is
17721d1fba8aSrie 	 * the key to enabling all other ldd(1) specific environment variables.
17731d1fba8aSrie 	 * In case an auditor is called, which in turn might exec(2) a
17741d1fba8aSrie 	 * subprocess, this variable is disabled, so that any subprocess
17751d1fba8aSrie 	 * escapes ldd(1) processing.
17767c478bd9Sstevel@tonic-gate 	 */
17777c478bd9Sstevel@tonic-gate 	else if (*s1 == 'T') {
17787c478bd9Sstevel@tonic-gate 		if (((len == MSG_LD_TRACE_OBJS_SIZE) &&
17797c478bd9Sstevel@tonic-gate 		    (strncmp(s1, MSG_ORIG(MSG_LD_TRACE_OBJS),
17807c478bd9Sstevel@tonic-gate 		    MSG_LD_TRACE_OBJS_SIZE) == 0)) ||
17817c478bd9Sstevel@tonic-gate 		    ((len == MSG_LD_TRACE_OBJS_E_SIZE) &&
17827c478bd9Sstevel@tonic-gate 		    (((strncmp(s1, MSG_ORIG(MSG_LD_TRACE_OBJS_E),
17837c478bd9Sstevel@tonic-gate 		    MSG_LD_TRACE_OBJS_E_SIZE) == 0) && !aout) ||
17847c478bd9Sstevel@tonic-gate 		    ((strncmp(s1, MSG_ORIG(MSG_LD_TRACE_OBJS_A),
17857c478bd9Sstevel@tonic-gate 		    MSG_LD_TRACE_OBJS_A_SIZE) == 0) && aout)))) {
17861d1fba8aSrie 			char	*s0 = (char *)s1;
17871d1fba8aSrie 
17887c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_2;
17897c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_TRACE_OBJS;
17901d1fba8aSrie 
179102ca3e02Srie #if	defined(__sparc) || defined(__x86)
17921d1fba8aSrie 			/*
17931d1fba8aSrie 			 * The simplest way to "disable" this variable is to
17941d1fba8aSrie 			 * truncate this string to "LD_'\0'". This string is
17951d1fba8aSrie 			 * ignored by any ld.so.1 environment processing.
17961d1fba8aSrie 			 * Use of such interfaces as unsetenv(3c) are overkill,
17971d1fba8aSrie 			 * and would drag too much libc implementation detail
17981d1fba8aSrie 			 * into ld.so.1.
17991d1fba8aSrie 			 */
1800a953e2b1Srie 			*s0 = '\0';
18011d1fba8aSrie #else
18021d1fba8aSrie /*
18031d1fba8aSrie  * Verify that the above write is appropriate for any new platforms.
18041d1fba8aSrie  */
18051d1fba8aSrie #error	unsupported architecture!
18061d1fba8aSrie #endif
18077c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_TRACE_PTHS_SIZE) && (strncmp(s1,
18087c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_TRACE_PTHS),
18097c478bd9Sstevel@tonic-gate 		    MSG_LD_TRACE_PTHS_SIZE) == 0)) {
18107c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LML;
18117c478bd9Sstevel@tonic-gate 			val = LML_FLG_TRC_SEARCH;
18127c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_TRACE_PTHS;
18137c478bd9Sstevel@tonic-gate 		}
18147c478bd9Sstevel@tonic-gate 	}
18157c478bd9Sstevel@tonic-gate 	/*
18167c478bd9Sstevel@tonic-gate 	 * LD_UNREF and LD_UNUSED (internal, used by ldd(1)).
18177c478bd9Sstevel@tonic-gate 	 */
18187c478bd9Sstevel@tonic-gate 	else if (*s1 == 'U') {
18197c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_UNREF_SIZE) && (strncmp(s1,
18207c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_UNREF), MSG_LD_UNREF_SIZE) == 0)) {
18217c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LML;
18227c478bd9Sstevel@tonic-gate 			val = LML_FLG_TRC_UNREF;
18237c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_UNREF;
18247c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_UNUSED_SIZE) && (strncmp(s1,
18257c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_UNUSED), MSG_LD_UNUSED_SIZE) == 0)) {
18267c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LML;
18277c478bd9Sstevel@tonic-gate 			val = LML_FLG_TRC_UNUSED;
18287c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_UNUSED;
18297c478bd9Sstevel@tonic-gate 		}
18307c478bd9Sstevel@tonic-gate 	}
18317c478bd9Sstevel@tonic-gate 	/*
18327c478bd9Sstevel@tonic-gate 	 * LD_VERBOSE (internal, used by ldd(1)).
18337c478bd9Sstevel@tonic-gate 	 */
18347c478bd9Sstevel@tonic-gate 	else if (*s1 == 'V') {
18357c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_VERBOSE_SIZE) && (strncmp(s1,
18367c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_VERBOSE), MSG_LD_VERBOSE_SIZE) == 0)) {
18377c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LML;
18387c478bd9Sstevel@tonic-gate 			val = LML_FLG_TRC_VERBOSE;
18397c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_VERBOSE;
18407c478bd9Sstevel@tonic-gate 		}
18417c478bd9Sstevel@tonic-gate 	}
18427c478bd9Sstevel@tonic-gate 	/*
18437c478bd9Sstevel@tonic-gate 	 * LD_WARN (internal, used by ldd(1)).
18447c478bd9Sstevel@tonic-gate 	 */
18457c478bd9Sstevel@tonic-gate 	else if (*s1 == 'W') {
18467c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_WARN_SIZE) && (strncmp(s1,
18477c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_WARN), MSG_LD_WARN_SIZE) == 0)) {
18487c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LML;
18497c478bd9Sstevel@tonic-gate 			val = LML_FLG_TRC_WARN;
18507c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_WARN;
18517c478bd9Sstevel@tonic-gate 		}
18527c478bd9Sstevel@tonic-gate #ifdef	SIEBEL_DISABLE
18537c478bd9Sstevel@tonic-gate 	}
18547c478bd9Sstevel@tonic-gate 	/*
18557c478bd9Sstevel@tonic-gate 	 * LD__FIX__ (undocumented, enable future technology that can't be
18567c478bd9Sstevel@tonic-gate 	 * delivered in a patch release).
18577c478bd9Sstevel@tonic-gate 	 */
18587c478bd9Sstevel@tonic-gate 	else if (*s1 == '_') {
18597c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_FIX_1_SIZE) && (strncmp(s1,
18607c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_FIX_1), MSG_LD_FIX_1_SIZE) == 0)) {
18617c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
18627c478bd9Sstevel@tonic-gate 			val = RT_FL_DISFIX_1;
18637c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_FIX_1;
18647c478bd9Sstevel@tonic-gate 		}
18657c478bd9Sstevel@tonic-gate #endif
18667c478bd9Sstevel@tonic-gate 	}
18677c478bd9Sstevel@tonic-gate 	if (variable == 0)
18687c478bd9Sstevel@tonic-gate 		return;
18697c478bd9Sstevel@tonic-gate 
18707c478bd9Sstevel@tonic-gate 	/*
18717c478bd9Sstevel@tonic-gate 	 * If the variable is already processed with ISA specific variable,
18727c478bd9Sstevel@tonic-gate 	 * no further processing needed.
18737c478bd9Sstevel@tonic-gate 	 */
18747c478bd9Sstevel@tonic-gate 	if (((select & SEL_REPLACE) && (rplisa & variable)) ||
18757c478bd9Sstevel@tonic-gate 	    ((select & SEL_PERMANT) && (prmisa & variable)))
18767c478bd9Sstevel@tonic-gate 		return;
18777c478bd9Sstevel@tonic-gate 
18787c478bd9Sstevel@tonic-gate 	/*
1879fa034d7fSseizo 	 * Now mark the appropriate variables.
1880fa034d7fSseizo 	 * If the replaceable variable is already set, then the
1881fa034d7fSseizo 	 * process environment variable must be set. Any replaceable
1882fa034d7fSseizo 	 * variable specified in a configuration file can be ignored.
18837c478bd9Sstevel@tonic-gate 	 */
18847c478bd9Sstevel@tonic-gate 	if (env_flags & ENV_TYP_ISA) {
18857c478bd9Sstevel@tonic-gate 		/*
18867c478bd9Sstevel@tonic-gate 		 * This is ISA setting. We do the setting
18877c478bd9Sstevel@tonic-gate 		 * even if s2 is NULL.
18887c478bd9Sstevel@tonic-gate 		 * If s2 is NULL, we might need to undo
18897c478bd9Sstevel@tonic-gate 		 * the setting.
18907c478bd9Sstevel@tonic-gate 		 */
18917c478bd9Sstevel@tonic-gate 		if (select & SEL_REPLACE) {
1892fa034d7fSseizo 			if (rplisa & variable)
1893fa034d7fSseizo 				return;
18947c478bd9Sstevel@tonic-gate 			rplisa |= variable;
18957c478bd9Sstevel@tonic-gate 		} else {
18967c478bd9Sstevel@tonic-gate 			prmisa |= variable;
18977c478bd9Sstevel@tonic-gate 		}
18987c478bd9Sstevel@tonic-gate 	} else if (s2) {
18997c478bd9Sstevel@tonic-gate 		/*
19007c478bd9Sstevel@tonic-gate 		 * This is non0-ISA setting
19017c478bd9Sstevel@tonic-gate 		 */
19027c478bd9Sstevel@tonic-gate 		if (select & SEL_REPLACE) {
1903fa034d7fSseizo 			if (rplgen & variable)
1904fa034d7fSseizo 				return;
19057c478bd9Sstevel@tonic-gate 			rplgen |= variable;
19067c478bd9Sstevel@tonic-gate 		} else
19077c478bd9Sstevel@tonic-gate 			prmgen |= variable;
19087c478bd9Sstevel@tonic-gate 	} else
19097c478bd9Sstevel@tonic-gate 		/*
19107c478bd9Sstevel@tonic-gate 		 * This is non-ISA setting which
19117c478bd9Sstevel@tonic-gate 		 * can be ignored.
19127c478bd9Sstevel@tonic-gate 		 */
19137c478bd9Sstevel@tonic-gate 		return;
19147c478bd9Sstevel@tonic-gate 
19157c478bd9Sstevel@tonic-gate 	/*
19167c478bd9Sstevel@tonic-gate 	 * Now perform the setting.
19177c478bd9Sstevel@tonic-gate 	 */
19187c478bd9Sstevel@tonic-gate 	if (select & SEL_ACT_RT) {
19197c478bd9Sstevel@tonic-gate 		if (s2)
19207c478bd9Sstevel@tonic-gate 			rtld_flags |= val;
19217c478bd9Sstevel@tonic-gate 		else
19227c478bd9Sstevel@tonic-gate 			rtld_flags &= ~val;
19237c478bd9Sstevel@tonic-gate 	} else if (select & SEL_ACT_RT2) {
19247c478bd9Sstevel@tonic-gate 		if (s2)
19257c478bd9Sstevel@tonic-gate 			rtld_flags2 |= val;
19267c478bd9Sstevel@tonic-gate 		else
19277c478bd9Sstevel@tonic-gate 			rtld_flags2 &= ~val;
19287c478bd9Sstevel@tonic-gate 	} else if (select & SEL_ACT_STR)
19297c478bd9Sstevel@tonic-gate 		*str = s2;
19307c478bd9Sstevel@tonic-gate 	else if (select & SEL_ACT_LML) {
19317c478bd9Sstevel@tonic-gate 		if (s2)
19327c478bd9Sstevel@tonic-gate 			*lmflags |= val;
19337c478bd9Sstevel@tonic-gate 		else
19347c478bd9Sstevel@tonic-gate 			*lmflags &= ~val;
19357c478bd9Sstevel@tonic-gate 	} else if (select & SEL_ACT_LMLT) {
19367c478bd9Sstevel@tonic-gate 		if (s2)
19377c478bd9Sstevel@tonic-gate 			*lmtflags |= val;
19387c478bd9Sstevel@tonic-gate 		else
19397c478bd9Sstevel@tonic-gate 			*lmtflags &= ~val;
19407c478bd9Sstevel@tonic-gate 	} else if (select & SEL_ACT_SPEC_1) {
19417c478bd9Sstevel@tonic-gate 		/*
19427c478bd9Sstevel@tonic-gate 		 * variable is either ENV_FLG_FLAGS or ENV_FLG_LIBPATH
19437c478bd9Sstevel@tonic-gate 		 */
19447c478bd9Sstevel@tonic-gate 		*str = s2;
19457c478bd9Sstevel@tonic-gate 		if ((select & SEL_REPLACE) && (env_flags & ENV_TYP_CONFIG)) {
19467c478bd9Sstevel@tonic-gate 			if (s2) {
19477c478bd9Sstevel@tonic-gate 				if (variable == ENV_FLG_FLAGS)
19487c478bd9Sstevel@tonic-gate 					env_info |= ENV_INF_FLAGCFG;
19497c478bd9Sstevel@tonic-gate 				else
19507c478bd9Sstevel@tonic-gate 					env_info |= ENV_INF_PATHCFG;
19517c478bd9Sstevel@tonic-gate 			} else {
19527c478bd9Sstevel@tonic-gate 				if (variable == ENV_FLG_FLAGS)
19537c478bd9Sstevel@tonic-gate 					env_info &= ~ENV_INF_FLAGCFG;
19547c478bd9Sstevel@tonic-gate 				else
19557c478bd9Sstevel@tonic-gate 					env_info &= ~ENV_INF_PATHCFG;
19567c478bd9Sstevel@tonic-gate 			}
19577c478bd9Sstevel@tonic-gate 		}
19587c478bd9Sstevel@tonic-gate 	} else if (select & SEL_ACT_SPEC_2) {
19597c478bd9Sstevel@tonic-gate 		/*
19607c478bd9Sstevel@tonic-gate 		 * variables can be: ENV_FLG_
19617c478bd9Sstevel@tonic-gate 		 * 	AUDIT_ARGS, BINDING, CONCURRENCY, CONFGEN,
19627c478bd9Sstevel@tonic-gate 		 *	LOADFLTR, PROFILE, SIGNAL, TRACE_OBJS
19637c478bd9Sstevel@tonic-gate 		 */
19647c478bd9Sstevel@tonic-gate 		if (variable == ENV_FLG_AUDIT_ARGS) {
19657c478bd9Sstevel@tonic-gate 			if (s2) {
19667c478bd9Sstevel@tonic-gate 				audit_argcnt = atoi(s2);
19677c478bd9Sstevel@tonic-gate 				audit_argcnt += audit_argcnt % 2;
19687c478bd9Sstevel@tonic-gate 			} else
19697c478bd9Sstevel@tonic-gate 				audit_argcnt = 0;
19707c478bd9Sstevel@tonic-gate 		} else if (variable == ENV_FLG_BINDINGS) {
19717c478bd9Sstevel@tonic-gate 			if (s2)
19727c478bd9Sstevel@tonic-gate 				rpl_debug = MSG_ORIG(MSG_TKN_BINDINGS);
19737c478bd9Sstevel@tonic-gate 			else
19747c478bd9Sstevel@tonic-gate 				rpl_debug = 0;
19757c478bd9Sstevel@tonic-gate 		} else if (variable == ENV_FLG_CONCURRENCY) {
19767c478bd9Sstevel@tonic-gate 			if (s2)
19777c478bd9Sstevel@tonic-gate 				rtld_flags &= ~RT_FL_NOCONCUR;
19787c478bd9Sstevel@tonic-gate 			else
19797c478bd9Sstevel@tonic-gate 				rtld_flags |= RT_FL_NOCONCUR;
19807c478bd9Sstevel@tonic-gate 		} else if (variable == ENV_FLG_CONFGEN) {
19817c478bd9Sstevel@tonic-gate 			if (s2) {
19827c478bd9Sstevel@tonic-gate 				rtld_flags |= RT_FL_CONFGEN;
19837c478bd9Sstevel@tonic-gate 				*lmflags |= LML_FLG_IGNRELERR;
19847c478bd9Sstevel@tonic-gate 			} else {
19857c478bd9Sstevel@tonic-gate 				rtld_flags &= ~RT_FL_CONFGEN;
19867c478bd9Sstevel@tonic-gate 				*lmflags &= ~LML_FLG_IGNRELERR;
19877c478bd9Sstevel@tonic-gate 			}
19887c478bd9Sstevel@tonic-gate 		} else if (variable == ENV_FLG_LOADFLTR) {
19897c478bd9Sstevel@tonic-gate 			if (s2) {
19907c478bd9Sstevel@tonic-gate 				*lmtflags |= LML_TFLG_LOADFLTR;
19917c478bd9Sstevel@tonic-gate 				if (*s2 == '2')
19927c478bd9Sstevel@tonic-gate 					rtld_flags |= RT_FL_WARNFLTR;
19937c478bd9Sstevel@tonic-gate 			} else {
19947c478bd9Sstevel@tonic-gate 				*lmtflags &= ~LML_TFLG_LOADFLTR;
19957c478bd9Sstevel@tonic-gate 				rtld_flags &= ~RT_FL_WARNFLTR;
19967c478bd9Sstevel@tonic-gate 			}
19977c478bd9Sstevel@tonic-gate 		} else if (variable == ENV_FLG_PROFILE) {
19987c478bd9Sstevel@tonic-gate 			profile_name = s2;
19997c478bd9Sstevel@tonic-gate 			if (s2) {
20007c478bd9Sstevel@tonic-gate 				if (strcmp(s2, MSG_ORIG(MSG_FIL_RTLD)) == 0) {
20017c478bd9Sstevel@tonic-gate 					return;
20027c478bd9Sstevel@tonic-gate 				}
2003a953e2b1Srie 				/* BEGIN CSTYLED */
20047c478bd9Sstevel@tonic-gate 				if (rtld_flags & RT_FL_SECURE) {
20057c478bd9Sstevel@tonic-gate 					profile_lib =
20067c478bd9Sstevel@tonic-gate #if	defined(_ELF64)
20077c478bd9Sstevel@tonic-gate 					    MSG_ORIG(MSG_PTH_LDPROFSE_64);
20087c478bd9Sstevel@tonic-gate #else
20097c478bd9Sstevel@tonic-gate 					    MSG_ORIG(MSG_PTH_LDPROFSE);
20107c478bd9Sstevel@tonic-gate #endif
20117c478bd9Sstevel@tonic-gate 				} else {
20127c478bd9Sstevel@tonic-gate 					profile_lib =
20137c478bd9Sstevel@tonic-gate #if	defined(_ELF64)
20147c478bd9Sstevel@tonic-gate 					    MSG_ORIG(MSG_PTH_LDPROF_64);
20157c478bd9Sstevel@tonic-gate #else
20167c478bd9Sstevel@tonic-gate 					    MSG_ORIG(MSG_PTH_LDPROF);
20177c478bd9Sstevel@tonic-gate #endif
20187c478bd9Sstevel@tonic-gate 				}
2019a953e2b1Srie 				/* END CSTYLED */
20207c478bd9Sstevel@tonic-gate 			} else
20217c478bd9Sstevel@tonic-gate 				profile_lib = 0;
20227c478bd9Sstevel@tonic-gate 		} else if (variable == ENV_FLG_SIGNAL) {
20237c478bd9Sstevel@tonic-gate 			killsig = s2 ? atoi(s2) : SIGKILL;
20247c478bd9Sstevel@tonic-gate 		} else if (variable == ENV_FLG_TRACE_OBJS) {
20257c478bd9Sstevel@tonic-gate 			if (s2) {
20267c478bd9Sstevel@tonic-gate 				*lmflags |= LML_FLG_TRC_ENABLE;
20277c478bd9Sstevel@tonic-gate 				if (*s2 == '2')
20287c478bd9Sstevel@tonic-gate 					*lmflags |= LML_FLG_TRC_LDDSTUB;
20297c478bd9Sstevel@tonic-gate 			} else
20307c478bd9Sstevel@tonic-gate 				*lmflags &=
2031a953e2b1Srie 				    ~(LML_FLG_TRC_ENABLE|LML_FLG_TRC_LDDSTUB);
20327c478bd9Sstevel@tonic-gate 		}
20337c478bd9Sstevel@tonic-gate 	}
20347c478bd9Sstevel@tonic-gate }
20357c478bd9Sstevel@tonic-gate 
20367c478bd9Sstevel@tonic-gate /*
20377c478bd9Sstevel@tonic-gate  * Determine whether we have an architecture specific environment variable.
20387c478bd9Sstevel@tonic-gate  * If we do, and we're the wrong architecture, it'll just get ignored.
20397c478bd9Sstevel@tonic-gate  * Otherwise the variable is processed in it's architecture neutral form.
20407c478bd9Sstevel@tonic-gate  */
20417c478bd9Sstevel@tonic-gate static int
20427c478bd9Sstevel@tonic-gate ld_arch_env(const char *s1, size_t *len)
20437c478bd9Sstevel@tonic-gate {
20447c478bd9Sstevel@tonic-gate 	size_t	_len = *len - 3;
20457c478bd9Sstevel@tonic-gate 
20467c478bd9Sstevel@tonic-gate 	if (s1[_len++] == '_') {
20477c478bd9Sstevel@tonic-gate 		if ((s1[_len] == '3') && (s1[_len + 1] == '2')) {
20487c478bd9Sstevel@tonic-gate #if	defined(_ELF64)
20497c478bd9Sstevel@tonic-gate 			return (ENV_TYP_IGNORE);
20507c478bd9Sstevel@tonic-gate #else
20517c478bd9Sstevel@tonic-gate 			*len = *len - 3;
20527c478bd9Sstevel@tonic-gate 			return (ENV_TYP_ISA);
20537c478bd9Sstevel@tonic-gate #endif
20547c478bd9Sstevel@tonic-gate 		}
20557c478bd9Sstevel@tonic-gate 		if ((s1[_len] == '6') && (s1[_len + 1] == '4')) {
20567c478bd9Sstevel@tonic-gate #if	defined(_ELF64)
20577c478bd9Sstevel@tonic-gate 			*len = *len - 3;
20587c478bd9Sstevel@tonic-gate 			return (ENV_TYP_ISA);
20597c478bd9Sstevel@tonic-gate #else
20607c478bd9Sstevel@tonic-gate 			return (ENV_TYP_IGNORE);
20617c478bd9Sstevel@tonic-gate #endif
20627c478bd9Sstevel@tonic-gate 		}
20637c478bd9Sstevel@tonic-gate 	}
20647c478bd9Sstevel@tonic-gate 	return (0);
20657c478bd9Sstevel@tonic-gate }
20667c478bd9Sstevel@tonic-gate 
20677c478bd9Sstevel@tonic-gate 
20687c478bd9Sstevel@tonic-gate /*
20697c478bd9Sstevel@tonic-gate  * Process an LD_FLAGS environment variable.  The value can be a comma
20707c478bd9Sstevel@tonic-gate  * separated set of tokens, which are sent (in upper case) into the generic
20717c478bd9Sstevel@tonic-gate  * LD_XXXX environment variable engine.  For example:
20727c478bd9Sstevel@tonic-gate  *
20737c478bd9Sstevel@tonic-gate  *	LD_FLAGS=bind_now		->	LD_BIND_NOW=1
20747c478bd9Sstevel@tonic-gate  *	LD_FLAGS=library_path=/foo:.	->	LD_LIBRARY_PATH=/foo:.
20757c478bd9Sstevel@tonic-gate  *	LD_FLAGS=debug=files:detail	->	LD_DEBUG=files:detail
20767c478bd9Sstevel@tonic-gate  * or
20777c478bd9Sstevel@tonic-gate  *	LD_FLAGS=bind_now,library_path=/foo:.,debug=files:detail
20787c478bd9Sstevel@tonic-gate  */
20797c478bd9Sstevel@tonic-gate static int
20807c478bd9Sstevel@tonic-gate ld_flags_env(const char *str, Word *lmflags, Word *lmtflags,
20817c478bd9Sstevel@tonic-gate     uint_t env_flags, int aout)
20827c478bd9Sstevel@tonic-gate {
20837c478bd9Sstevel@tonic-gate 	char	*nstr, *sstr, *estr = 0;
20847c478bd9Sstevel@tonic-gate 	size_t	nlen, len;
20857c478bd9Sstevel@tonic-gate 
20867c478bd9Sstevel@tonic-gate 	if (str == 0)
20877c478bd9Sstevel@tonic-gate 		return (0);
20887c478bd9Sstevel@tonic-gate 
20897c478bd9Sstevel@tonic-gate 	/*
20907c478bd9Sstevel@tonic-gate 	 * Create a new string as we're going to transform the token(s) into
20917c478bd9Sstevel@tonic-gate 	 * uppercase and separate tokens with nulls.
20927c478bd9Sstevel@tonic-gate 	 */
20937c478bd9Sstevel@tonic-gate 	len = strlen(str);
20947c478bd9Sstevel@tonic-gate 	if ((nstr = malloc(len + 1)) == 0)
20957c478bd9Sstevel@tonic-gate 		return (1);
20967c478bd9Sstevel@tonic-gate 	(void) strcpy(nstr, str);
20977c478bd9Sstevel@tonic-gate 
20987c478bd9Sstevel@tonic-gate 	for (sstr = nstr; sstr; sstr++, len--) {
20997c478bd9Sstevel@tonic-gate 		int	flags;
21007c478bd9Sstevel@tonic-gate 
21017c478bd9Sstevel@tonic-gate 		if ((*sstr != '\0') && (*sstr != ',')) {
21027c478bd9Sstevel@tonic-gate 			if (estr == 0) {
21037c478bd9Sstevel@tonic-gate 				if (*sstr == '=')
21047c478bd9Sstevel@tonic-gate 					estr = sstr;
21057c478bd9Sstevel@tonic-gate 				else {
21067c478bd9Sstevel@tonic-gate 					/*
21077c478bd9Sstevel@tonic-gate 					 * Translate token to uppercase.  Don't
21087c478bd9Sstevel@tonic-gate 					 * use toupper(3C) as including this
21097c478bd9Sstevel@tonic-gate 					 * code doubles the size of ld.so.1.
21107c478bd9Sstevel@tonic-gate 					 */
21117c478bd9Sstevel@tonic-gate 					if ((*sstr >= 'a') && (*sstr <= 'z'))
21127c478bd9Sstevel@tonic-gate 						*sstr = *sstr - ('a' - 'A');
21137c478bd9Sstevel@tonic-gate 				}
21147c478bd9Sstevel@tonic-gate 			}
21157c478bd9Sstevel@tonic-gate 			continue;
21167c478bd9Sstevel@tonic-gate 		}
21177c478bd9Sstevel@tonic-gate 
21187c478bd9Sstevel@tonic-gate 		*sstr = '\0';
21197c478bd9Sstevel@tonic-gate 		if (estr) {
21207c478bd9Sstevel@tonic-gate 			nlen = estr - nstr;
21217c478bd9Sstevel@tonic-gate 			if ((*++estr == '\0') || (*estr == ','))
21227c478bd9Sstevel@tonic-gate 				estr = 0;
21237c478bd9Sstevel@tonic-gate 		} else
21247c478bd9Sstevel@tonic-gate 			nlen = sstr - nstr;
21257c478bd9Sstevel@tonic-gate 
21267c478bd9Sstevel@tonic-gate 		/*
21277c478bd9Sstevel@tonic-gate 		 * Fabricate a boolean definition for any unqualified variable.
21287c478bd9Sstevel@tonic-gate 		 * Thus LD_FLAGS=bind_now is represented as BIND_NOW=(null).
21297c478bd9Sstevel@tonic-gate 		 * The value is sufficient to assert any boolean variables, plus
21307c478bd9Sstevel@tonic-gate 		 * the term "(null)" is specifically chosen in case someone
21317c478bd9Sstevel@tonic-gate 		 * mistakenly supplies something like LD_FLAGS=library_path.
21327c478bd9Sstevel@tonic-gate 		 */
21337c478bd9Sstevel@tonic-gate 		if (estr == 0)
21347c478bd9Sstevel@tonic-gate 			estr = (char *)MSG_INTL(MSG_STR_NULL);
21357c478bd9Sstevel@tonic-gate 
21367c478bd9Sstevel@tonic-gate 		/*
21377c478bd9Sstevel@tonic-gate 		 * Determine whether the environment variable is 32- or 64-bit
21387c478bd9Sstevel@tonic-gate 		 * specific.  The length, len, will reflect the architecture
21397c478bd9Sstevel@tonic-gate 		 * neutral portion of the string.
21407c478bd9Sstevel@tonic-gate 		 */
21417c478bd9Sstevel@tonic-gate 		if ((flags = ld_arch_env(nstr, &nlen)) != ENV_TYP_IGNORE) {
21427c478bd9Sstevel@tonic-gate 			ld_generic_env(nstr, nlen, estr, lmflags,
21437c478bd9Sstevel@tonic-gate 			    lmtflags, (env_flags | flags), aout);
21447c478bd9Sstevel@tonic-gate 		}
21457c478bd9Sstevel@tonic-gate 		if (len == 0)
21467c478bd9Sstevel@tonic-gate 			return (0);
21477c478bd9Sstevel@tonic-gate 
21487c478bd9Sstevel@tonic-gate 		nstr = sstr + 1;
21497c478bd9Sstevel@tonic-gate 		estr = 0;
21507c478bd9Sstevel@tonic-gate 	}
21517c478bd9Sstevel@tonic-gate 	return (0);
21527c478bd9Sstevel@tonic-gate }
21537c478bd9Sstevel@tonic-gate 
21547c478bd9Sstevel@tonic-gate 
21557c478bd9Sstevel@tonic-gate /*
21567c478bd9Sstevel@tonic-gate  * Process a single environment string.  Only strings starting with `LD_' are
21577c478bd9Sstevel@tonic-gate  * reserved for our use.  By convention, all strings should be of the form
21587c478bd9Sstevel@tonic-gate  * `LD_XXXX=', if the string is followed by a non-null value the appropriate
21597c478bd9Sstevel@tonic-gate  * functionality is enabled.  Also pick off applicable locale variables.
21607c478bd9Sstevel@tonic-gate  */
21617c478bd9Sstevel@tonic-gate #define	LOC_LANG	1
21627c478bd9Sstevel@tonic-gate #define	LOC_MESG	2
21637c478bd9Sstevel@tonic-gate #define	LOC_ALL		3
21647c478bd9Sstevel@tonic-gate 
21657c478bd9Sstevel@tonic-gate static void
21667c478bd9Sstevel@tonic-gate ld_str_env(const char *s1, Word *lmflags, Word *lmtflags, uint_t env_flags,
21677c478bd9Sstevel@tonic-gate     int aout)
21687c478bd9Sstevel@tonic-gate {
21697c478bd9Sstevel@tonic-gate 	const char	*s2;
217010a4fa49Srie 	static		size_t	loc = 0;
21717c478bd9Sstevel@tonic-gate 
21727c478bd9Sstevel@tonic-gate 	if (*s1++ != 'L')
21737c478bd9Sstevel@tonic-gate 		return;
21747c478bd9Sstevel@tonic-gate 
21757c478bd9Sstevel@tonic-gate 	/*
21767c478bd9Sstevel@tonic-gate 	 * See if we have any locale environment settings.  These environment
21777c478bd9Sstevel@tonic-gate 	 * variables have a precedence, LC_ALL is higher than LC_MESSAGES which
21787c478bd9Sstevel@tonic-gate 	 * is higher than LANG.
21797c478bd9Sstevel@tonic-gate 	 */
21807c478bd9Sstevel@tonic-gate 	s2 = s1;
21817c478bd9Sstevel@tonic-gate 	if ((*s2++ == 'C') && (*s2++ == '_') && (*s2 != '\0')) {
21827c478bd9Sstevel@tonic-gate 		if (strncmp(s2, MSG_ORIG(MSG_LC_ALL), MSG_LC_ALL_SIZE) == 0) {
21837c478bd9Sstevel@tonic-gate 			s2 += MSG_LC_ALL_SIZE;
21847c478bd9Sstevel@tonic-gate 			if ((*s2 != '\0') && (loc < LOC_ALL)) {
218510a4fa49Srie 				glcs[CI_LCMESSAGES].lc_un.lc_ptr = (char *)s2;
21867c478bd9Sstevel@tonic-gate 				loc = LOC_ALL;
21877c478bd9Sstevel@tonic-gate 			}
21887c478bd9Sstevel@tonic-gate 		} else if (strncmp(s2, MSG_ORIG(MSG_LC_MESSAGES),
21897c478bd9Sstevel@tonic-gate 		    MSG_LC_MESSAGES_SIZE) == 0) {
21907c478bd9Sstevel@tonic-gate 			s2 += MSG_LC_MESSAGES_SIZE;
21917c478bd9Sstevel@tonic-gate 			if ((*s2 != '\0') && (loc < LOC_MESG)) {
219210a4fa49Srie 				glcs[CI_LCMESSAGES].lc_un.lc_ptr = (char *)s2;
21937c478bd9Sstevel@tonic-gate 				loc = LOC_MESG;
21947c478bd9Sstevel@tonic-gate 			}
21957c478bd9Sstevel@tonic-gate 		}
21967c478bd9Sstevel@tonic-gate 		return;
21977c478bd9Sstevel@tonic-gate 	}
21987c478bd9Sstevel@tonic-gate 
21997c478bd9Sstevel@tonic-gate 	s2 = s1;
22007c478bd9Sstevel@tonic-gate 	if ((*s2++ == 'A') && (*s2++ == 'N') && (*s2++ == 'G') &&
22017c478bd9Sstevel@tonic-gate 	    (*s2++ == '=') && (*s2 != '\0') && (loc < LOC_LANG)) {
220210a4fa49Srie 		glcs[CI_LCMESSAGES].lc_un.lc_ptr = (char *)s2;
22037c478bd9Sstevel@tonic-gate 		loc = LOC_LANG;
22047c478bd9Sstevel@tonic-gate 		return;
22057c478bd9Sstevel@tonic-gate 	}
22067c478bd9Sstevel@tonic-gate 
22077c478bd9Sstevel@tonic-gate 	/*
22087c478bd9Sstevel@tonic-gate 	 * Pick off any LD_XXXX environment variables.
22097c478bd9Sstevel@tonic-gate 	 */
22107c478bd9Sstevel@tonic-gate 	if ((*s1++ == 'D') && (*s1++ == '_') && (*s1 != '\0')) {
22117c478bd9Sstevel@tonic-gate 		size_t	len;
22127c478bd9Sstevel@tonic-gate 		int	flags;
22137c478bd9Sstevel@tonic-gate 
22149acbbeafSnn 		/*
22159acbbeafSnn 		 * In a branded process we must ignore all LD_XXXX env vars
22169acbbeafSnn 		 * because they are intended for the brand's linker.
22179acbbeafSnn 		 * To affect the Solaris linker, use LD_BRAND_XXXX instead.
22189acbbeafSnn 		 */
22199acbbeafSnn 		if (rtld_flags2 & RT_FL2_BRANDED) {
22209acbbeafSnn 			if (strncmp(s1, MSG_ORIG(MSG_LD_BRAND_PREFIX),
22219acbbeafSnn 			    MSG_LD_BRAND_PREFIX_SIZE) != 0)
22229acbbeafSnn 				return;
22239acbbeafSnn 			s1 += MSG_LD_BRAND_PREFIX_SIZE;
22249acbbeafSnn 		}
22259acbbeafSnn 
22267c478bd9Sstevel@tonic-gate 		/*
22277c478bd9Sstevel@tonic-gate 		 * Environment variables with no value (ie. LD_XXXX=) typically
22287c478bd9Sstevel@tonic-gate 		 * have no impact, however if environment variables are defined
22297c478bd9Sstevel@tonic-gate 		 * within a configuration file, these null user settings can be
22307c478bd9Sstevel@tonic-gate 		 * used to disable any configuration replaceable definitions.
22317c478bd9Sstevel@tonic-gate 		 */
22327c478bd9Sstevel@tonic-gate 		if ((s2 = strchr(s1, '=')) == 0) {
22337c478bd9Sstevel@tonic-gate 			len = strlen(s1);
22347c478bd9Sstevel@tonic-gate 			s2 = 0;
22357c478bd9Sstevel@tonic-gate 		} else if (*++s2 == '\0') {
22367c478bd9Sstevel@tonic-gate 			len = strlen(s1) - 1;
22377c478bd9Sstevel@tonic-gate 			s2 = 0;
22387c478bd9Sstevel@tonic-gate 		} else {
22397c478bd9Sstevel@tonic-gate 			len = s2 - s1 - 1;
22407c478bd9Sstevel@tonic-gate 			while (isspace(*s2))
22417c478bd9Sstevel@tonic-gate 				s2++;
22427c478bd9Sstevel@tonic-gate 		}
22437c478bd9Sstevel@tonic-gate 
22447c478bd9Sstevel@tonic-gate 		/*
22457c478bd9Sstevel@tonic-gate 		 * Determine whether the environment variable is 32- or 64-bit
22467c478bd9Sstevel@tonic-gate 		 * specific.  The length, len, will reflect the architecture
22477c478bd9Sstevel@tonic-gate 		 * neutral portion of the string.
22487c478bd9Sstevel@tonic-gate 		 */
22497c478bd9Sstevel@tonic-gate 		if ((flags = ld_arch_env(s1, &len)) == ENV_TYP_IGNORE)
22507c478bd9Sstevel@tonic-gate 			return;
22517c478bd9Sstevel@tonic-gate 		env_flags |= flags;
22527c478bd9Sstevel@tonic-gate 
22537c478bd9Sstevel@tonic-gate 		ld_generic_env(s1, len, s2, lmflags, lmtflags, env_flags, aout);
22547c478bd9Sstevel@tonic-gate 	}
22557c478bd9Sstevel@tonic-gate }
22567c478bd9Sstevel@tonic-gate 
22577c478bd9Sstevel@tonic-gate /*
22587c478bd9Sstevel@tonic-gate  * Internal getenv routine.  Called immediately after ld.so.1 initializes
22597c478bd9Sstevel@tonic-gate  * itself.
22607c478bd9Sstevel@tonic-gate  */
22617c478bd9Sstevel@tonic-gate int
22627c478bd9Sstevel@tonic-gate readenv_user(const char ** envp, Word *lmflags, Word *lmtflags, int aout)
22637c478bd9Sstevel@tonic-gate {
226410a4fa49Srie 	char	*locale;
226510a4fa49Srie 
22667c478bd9Sstevel@tonic-gate 	if (envp == (const char **)0)
22677c478bd9Sstevel@tonic-gate 		return (0);
22687c478bd9Sstevel@tonic-gate 
22697c478bd9Sstevel@tonic-gate 	while (*envp != (const char *)0)
22707c478bd9Sstevel@tonic-gate 		ld_str_env(*envp++, lmflags, lmtflags, 0, aout);
22717c478bd9Sstevel@tonic-gate 
22727c478bd9Sstevel@tonic-gate 	/*
22737c478bd9Sstevel@tonic-gate 	 * Having collected the best representation of any LD_FLAGS, process
22747c478bd9Sstevel@tonic-gate 	 * these strings.
22757c478bd9Sstevel@tonic-gate 	 */
22767c478bd9Sstevel@tonic-gate 	if (ld_flags_env(rpl_ldflags, lmflags, lmtflags, 0, aout) == 1)
22777c478bd9Sstevel@tonic-gate 		return (1);
22787c478bd9Sstevel@tonic-gate 
22797c478bd9Sstevel@tonic-gate 	/*
22807c478bd9Sstevel@tonic-gate 	 * Don't allow environment controlled auditing when tracing or if
22817c478bd9Sstevel@tonic-gate 	 * explicitly disabled.  Trigger all tracing modes from
22827c478bd9Sstevel@tonic-gate 	 * LML_FLG_TRC_ENABLE.
22837c478bd9Sstevel@tonic-gate 	 */
22847c478bd9Sstevel@tonic-gate 	if ((*lmflags & LML_FLG_TRC_ENABLE) || (rtld_flags & RT_FL_NOAUDIT))
22857c478bd9Sstevel@tonic-gate 		rpl_audit = profile_lib = profile_name = 0;
22867c478bd9Sstevel@tonic-gate 	if ((*lmflags & LML_FLG_TRC_ENABLE) == 0)
22877c478bd9Sstevel@tonic-gate 		*lmflags &= ~LML_MSK_TRC;
22887c478bd9Sstevel@tonic-gate 
2289dffec89cSrie 	/*
2290dffec89cSrie 	 * If both LD_BIND_NOW and LD_BIND_LAZY are specified, the former wins.
2291dffec89cSrie 	 */
2292dffec89cSrie 	if ((rtld_flags2 & (RT_FL2_BINDNOW | RT_FL2_BINDLAZY)) ==
2293dffec89cSrie 	    (RT_FL2_BINDNOW | RT_FL2_BINDLAZY))
2294dffec89cSrie 		rtld_flags2 &= ~RT_FL2_BINDLAZY;
2295dffec89cSrie 
2296dae2dfb7Srie 	/*
2297dae2dfb7Srie 	 * When using ldd(1) -r or -d against an executable, assert -p.
2298dae2dfb7Srie 	 */
2299dae2dfb7Srie 	if ((*lmflags &
2300dae2dfb7Srie 	    (LML_FLG_TRC_WARN | LML_FLG_TRC_LDDSTUB)) == LML_FLG_TRC_WARN)
2301dae2dfb7Srie 		*lmflags |= LML_FLG_TRC_NOPAREXT;
2302dae2dfb7Srie 
23037c478bd9Sstevel@tonic-gate 	/*
23047c478bd9Sstevel@tonic-gate 	 * If we have a locale setting make sure its worth processing further.
23051d6b7ad8Srie 	 * C and POSIX locales don't need any processing.  In addition, to
23061d6b7ad8Srie 	 * ensure no one escapes the /usr/lib/locale hierarchy, don't allow
23071d6b7ad8Srie 	 * the locale to contain a segment that leads upward in the file system
23081d6b7ad8Srie 	 * hierarchy (i.e. no '..' segments).   Given that we'll be confined to
23091d6b7ad8Srie 	 * the /usr/lib/locale hierarchy, there is no need to extensively
23101d6b7ad8Srie 	 * validate the mode or ownership of any message file (as libc's
23111d6b7ad8Srie 	 * generic handling of message files does).  Duplicate the string so
23121d6b7ad8Srie 	 * that new locale setting can generically cleanup any previous locales.
23137c478bd9Sstevel@tonic-gate 	 */
231410a4fa49Srie 	if ((locale = glcs[CI_LCMESSAGES].lc_un.lc_ptr) != 0) {
23157c478bd9Sstevel@tonic-gate 		if (((*locale == 'C') && (*(locale + 1) == '\0')) ||
23161d6b7ad8Srie 		    (strcmp(locale, MSG_ORIG(MSG_TKN_POSIX)) == 0) ||
23171d6b7ad8Srie 		    (strstr(locale, MSG_ORIG(MSG_TKN_DOTDOT)) != NULL))
231810a4fa49Srie 			glcs[CI_LCMESSAGES].lc_un.lc_ptr = 0;
23197c478bd9Sstevel@tonic-gate 		else
232010a4fa49Srie 			glcs[CI_LCMESSAGES].lc_un.lc_ptr = strdup(locale);
23217c478bd9Sstevel@tonic-gate 	}
23227c478bd9Sstevel@tonic-gate 	return (0);
23237c478bd9Sstevel@tonic-gate }
23247c478bd9Sstevel@tonic-gate 
23257c478bd9Sstevel@tonic-gate /*
23267c478bd9Sstevel@tonic-gate  * Configuration environment processing.  Called after the a.out has been
23277c478bd9Sstevel@tonic-gate  * processed (as the a.out can specify its own configuration file).
23287c478bd9Sstevel@tonic-gate  */
23297c478bd9Sstevel@tonic-gate int
23307c478bd9Sstevel@tonic-gate readenv_config(Rtc_env * envtbl, Addr addr, int aout)
23317c478bd9Sstevel@tonic-gate {
23327c478bd9Sstevel@tonic-gate 	Word *	lmflags = &(lml_main.lm_flags);
23337c478bd9Sstevel@tonic-gate 	Word *	lmtflags = &(lml_main.lm_tflags);
23347c478bd9Sstevel@tonic-gate 
23357c478bd9Sstevel@tonic-gate 	if (envtbl == (Rtc_env *)0)
23367c478bd9Sstevel@tonic-gate 		return (0);
23377c478bd9Sstevel@tonic-gate 
23387c478bd9Sstevel@tonic-gate 	while (envtbl->env_str) {
23397c478bd9Sstevel@tonic-gate 		uint_t	env_flags = ENV_TYP_CONFIG;
23407c478bd9Sstevel@tonic-gate 
23417c478bd9Sstevel@tonic-gate 		if (envtbl->env_flags & RTC_ENV_PERMANT)
23427c478bd9Sstevel@tonic-gate 			env_flags |= ENV_TYP_PERMANT;
23437c478bd9Sstevel@tonic-gate 
23447c478bd9Sstevel@tonic-gate 		ld_str_env((const char *)(envtbl->env_str + addr),
23457c478bd9Sstevel@tonic-gate 		    lmflags, lmtflags, env_flags, 0);
23467c478bd9Sstevel@tonic-gate 		envtbl++;
23477c478bd9Sstevel@tonic-gate 	}
23487c478bd9Sstevel@tonic-gate 
23497c478bd9Sstevel@tonic-gate 	/*
23507c478bd9Sstevel@tonic-gate 	 * Having collected the best representation of any LD_FLAGS, process
23517c478bd9Sstevel@tonic-gate 	 * these strings.
23527c478bd9Sstevel@tonic-gate 	 */
23537c478bd9Sstevel@tonic-gate 	if (ld_flags_env(rpl_ldflags, lmflags, lmtflags, 0, aout) == 1)
23547c478bd9Sstevel@tonic-gate 		return (1);
23557c478bd9Sstevel@tonic-gate 	if (ld_flags_env(prm_ldflags, lmflags, lmtflags, ENV_TYP_CONFIG,
23567c478bd9Sstevel@tonic-gate 	    aout) == 1)
23577c478bd9Sstevel@tonic-gate 		return (1);
23587c478bd9Sstevel@tonic-gate 
23597c478bd9Sstevel@tonic-gate 	/*
23607c478bd9Sstevel@tonic-gate 	 * Don't allow environment controlled auditing when tracing or if
23617c478bd9Sstevel@tonic-gate 	 * explicitly disabled.  Trigger all tracing modes from
23627c478bd9Sstevel@tonic-gate 	 * LML_FLG_TRC_ENABLE.
23637c478bd9Sstevel@tonic-gate 	 */
23647c478bd9Sstevel@tonic-gate 	if ((*lmflags & LML_FLG_TRC_ENABLE) || (rtld_flags & RT_FL_NOAUDIT))
23657c478bd9Sstevel@tonic-gate 		prm_audit = profile_lib = profile_name = 0;
23667c478bd9Sstevel@tonic-gate 	if ((*lmflags & LML_FLG_TRC_ENABLE) == 0)
23677c478bd9Sstevel@tonic-gate 		*lmflags &= ~LML_MSK_TRC;
23687c478bd9Sstevel@tonic-gate 
23697c478bd9Sstevel@tonic-gate 	return (0);
23707c478bd9Sstevel@tonic-gate }
23717c478bd9Sstevel@tonic-gate 
23727c478bd9Sstevel@tonic-gate int
23737c478bd9Sstevel@tonic-gate dowrite(Prfbuf * prf)
23747c478bd9Sstevel@tonic-gate {
23757c478bd9Sstevel@tonic-gate 	/*
23767c478bd9Sstevel@tonic-gate 	 * We do not have a valid file descriptor, so we are unable
23777c478bd9Sstevel@tonic-gate 	 * to flush the buffer.
23787c478bd9Sstevel@tonic-gate 	 */
23797c478bd9Sstevel@tonic-gate 	if (prf->pr_fd == -1)
23807c478bd9Sstevel@tonic-gate 		return (0);
23817c478bd9Sstevel@tonic-gate 	(void) write(prf->pr_fd, prf->pr_buf, prf->pr_cur - prf->pr_buf);
23827c478bd9Sstevel@tonic-gate 	prf->pr_cur = prf->pr_buf;
23837c478bd9Sstevel@tonic-gate 	return (1);
23847c478bd9Sstevel@tonic-gate }
23857c478bd9Sstevel@tonic-gate 
23867c478bd9Sstevel@tonic-gate /*
23877c478bd9Sstevel@tonic-gate  * Simplified printing.  The following conversion specifications are supported:
23887c478bd9Sstevel@tonic-gate  *
23897c478bd9Sstevel@tonic-gate  *	% [#] [-] [min field width] [. precision] s|d|x|c
23907c478bd9Sstevel@tonic-gate  *
23917c478bd9Sstevel@tonic-gate  *
23927c478bd9Sstevel@tonic-gate  * dorprf takes the output buffer in the form of Prfbuf which permits
23937c478bd9Sstevel@tonic-gate  * the verification of the output buffer size and the concatenation
23947c478bd9Sstevel@tonic-gate  * of data to an already existing output buffer.  The Prfbuf
23957c478bd9Sstevel@tonic-gate  * structure contains the following:
23967c478bd9Sstevel@tonic-gate  *
23977c478bd9Sstevel@tonic-gate  *  pr_buf	pointer to the beginning of the output buffer.
23987c478bd9Sstevel@tonic-gate  *  pr_cur	pointer to the next available byte in the output buffer.  By
23997c478bd9Sstevel@tonic-gate  *		setting pr_cur ahead of pr_buf you can append to an already
24007c478bd9Sstevel@tonic-gate  *		existing buffer.
24017c478bd9Sstevel@tonic-gate  *  pr_len	the size of the output buffer.  By setting pr_len to '0' you
24027c478bd9Sstevel@tonic-gate  *		disable protection from overflows in the output buffer.
24037c478bd9Sstevel@tonic-gate  *  pr_fd	a pointer to the file-descriptor the buffer will eventually be
24047c478bd9Sstevel@tonic-gate  *		output to.  If pr_fd is set to '-1' then it's assumed there is
24051d6b7ad8Srie  *		no output buffer, and doprf() will return with an error to
24061d6b7ad8Srie  *		indicate an output buffer overflow.  If pr_fd is > -1 then when
24071d6b7ad8Srie  *		the output buffer is filled it will be flushed to pr_fd and will
24081d6b7ad8Srie  *		then be	available for additional data.
24097c478bd9Sstevel@tonic-gate  */
24107c478bd9Sstevel@tonic-gate #define	FLG_UT_MINUS	0x0001	/* - */
24117c478bd9Sstevel@tonic-gate #define	FLG_UT_SHARP	0x0002	/* # */
24127c478bd9Sstevel@tonic-gate #define	FLG_UT_DOTSEEN	0x0008	/* dot appeared in format spec */
24137c478bd9Sstevel@tonic-gate 
24147c478bd9Sstevel@tonic-gate /*
241510a4fa49Srie  * This macro is for use from within doprf only.  It is to be used for checking
241610a4fa49Srie  * the output buffer size and placing characters into the buffer.
24177c478bd9Sstevel@tonic-gate  */
24187c478bd9Sstevel@tonic-gate #define	PUTC(c) \
24197c478bd9Sstevel@tonic-gate 	{ \
242010a4fa49Srie 		char tmpc; \
24217c478bd9Sstevel@tonic-gate 		\
24227c478bd9Sstevel@tonic-gate 		tmpc = (c); \
242310a4fa49Srie 		if (bufsiz && (bp >= bufend)) { \
24247c478bd9Sstevel@tonic-gate 			prf->pr_cur = bp; \
24257c478bd9Sstevel@tonic-gate 			if (dowrite(prf) == 0) \
24267c478bd9Sstevel@tonic-gate 				return (0); \
24277c478bd9Sstevel@tonic-gate 			bp = prf->pr_cur; \
24287c478bd9Sstevel@tonic-gate 		} \
24297c478bd9Sstevel@tonic-gate 		*bp++ = tmpc; \
24307c478bd9Sstevel@tonic-gate 	}
24317c478bd9Sstevel@tonic-gate 
24321d6b7ad8Srie /*
24331d6b7ad8Srie  * Define a local buffer size for building a numeric value - large enough to
24341d6b7ad8Srie  * hold a 64-bit value.
24351d6b7ad8Srie  */
2436051d39bbSrie #define	NUM_SIZE	22
24371d6b7ad8Srie 
24387c478bd9Sstevel@tonic-gate size_t
24397c478bd9Sstevel@tonic-gate doprf(const char *format, va_list args, Prfbuf *prf)
24407c478bd9Sstevel@tonic-gate {
24417c478bd9Sstevel@tonic-gate 	char	c;
24427c478bd9Sstevel@tonic-gate 	char	*bp = prf->pr_cur;
24437c478bd9Sstevel@tonic-gate 	char	*bufend = prf->pr_buf + prf->pr_len;
24447c478bd9Sstevel@tonic-gate 	size_t	bufsiz = prf->pr_len;
24457c478bd9Sstevel@tonic-gate 
24467c478bd9Sstevel@tonic-gate 	while ((c = *format++) != '\0') {
24477c478bd9Sstevel@tonic-gate 		if (c != '%') {
24487c478bd9Sstevel@tonic-gate 			PUTC(c);
24497c478bd9Sstevel@tonic-gate 		} else {
24507c478bd9Sstevel@tonic-gate 			int	base = 0, flag = 0, width = 0, prec = 0;
24517c478bd9Sstevel@tonic-gate 			size_t	_i;
24527c478bd9Sstevel@tonic-gate 			int	_c, _n;
24537c478bd9Sstevel@tonic-gate 			char	*_s;
24547c478bd9Sstevel@tonic-gate 			int	ls = 0;
24557c478bd9Sstevel@tonic-gate again:
24567c478bd9Sstevel@tonic-gate 			c = *format++;
24577c478bd9Sstevel@tonic-gate 			switch (c) {
24587c478bd9Sstevel@tonic-gate 			case '-':
24597c478bd9Sstevel@tonic-gate 				flag |= FLG_UT_MINUS;
24607c478bd9Sstevel@tonic-gate 				goto again;
24617c478bd9Sstevel@tonic-gate 			case '#':
24627c478bd9Sstevel@tonic-gate 				flag |= FLG_UT_SHARP;
24637c478bd9Sstevel@tonic-gate 				goto again;
24647c478bd9Sstevel@tonic-gate 			case '.':
24657c478bd9Sstevel@tonic-gate 				flag |= FLG_UT_DOTSEEN;
24667c478bd9Sstevel@tonic-gate 				goto again;
24677c478bd9Sstevel@tonic-gate 			case '0':
24687c478bd9Sstevel@tonic-gate 			case '1':
24697c478bd9Sstevel@tonic-gate 			case '2':
24707c478bd9Sstevel@tonic-gate 			case '3':
24717c478bd9Sstevel@tonic-gate 			case '4':
24727c478bd9Sstevel@tonic-gate 			case '5':
24737c478bd9Sstevel@tonic-gate 			case '6':
24747c478bd9Sstevel@tonic-gate 			case '7':
24757c478bd9Sstevel@tonic-gate 			case '8':
24767c478bd9Sstevel@tonic-gate 			case '9':
24777c478bd9Sstevel@tonic-gate 				if (flag & FLG_UT_DOTSEEN)
24787c478bd9Sstevel@tonic-gate 					prec = (prec * 10) + c - '0';
24797c478bd9Sstevel@tonic-gate 				else
24807c478bd9Sstevel@tonic-gate 					width = (width * 10) + c - '0';
24817c478bd9Sstevel@tonic-gate 				goto again;
24827c478bd9Sstevel@tonic-gate 			case 'x':
24837c478bd9Sstevel@tonic-gate 			case 'X':
24847c478bd9Sstevel@tonic-gate 				base = 16;
24857c478bd9Sstevel@tonic-gate 				break;
24867c478bd9Sstevel@tonic-gate 			case 'd':
24877c478bd9Sstevel@tonic-gate 			case 'D':
24887c478bd9Sstevel@tonic-gate 			case 'u':
24897c478bd9Sstevel@tonic-gate 				base = 10;
24907c478bd9Sstevel@tonic-gate 				flag &= ~FLG_UT_SHARP;
24917c478bd9Sstevel@tonic-gate 				break;
24927c478bd9Sstevel@tonic-gate 			case 'l':
24937c478bd9Sstevel@tonic-gate 				base = 10;
24947c478bd9Sstevel@tonic-gate 				ls++; /* number of l's (long or long long) */
24957c478bd9Sstevel@tonic-gate 				if ((*format == 'l') ||
24967c478bd9Sstevel@tonic-gate 				    (*format == 'd') || (*format == 'D') ||
24977c478bd9Sstevel@tonic-gate 				    (*format == 'x') || (*format == 'X') ||
24987c478bd9Sstevel@tonic-gate 				    (*format == 'o') || (*format == 'O'))
24997c478bd9Sstevel@tonic-gate 					goto again;
25007c478bd9Sstevel@tonic-gate 				break;
25017c478bd9Sstevel@tonic-gate 			case 'o':
25027c478bd9Sstevel@tonic-gate 			case 'O':
25037c478bd9Sstevel@tonic-gate 				base = 8;
25047c478bd9Sstevel@tonic-gate 				break;
25057c478bd9Sstevel@tonic-gate 			case 'c':
25067c478bd9Sstevel@tonic-gate 				_c = va_arg(args, int);
25077c478bd9Sstevel@tonic-gate 
25087c478bd9Sstevel@tonic-gate 				for (_i = 24; _i > 0; _i -= 8) {
25097c478bd9Sstevel@tonic-gate 					if ((c = ((_c >> _i) & 0x7f)) != 0) {
25107c478bd9Sstevel@tonic-gate 						PUTC(c);
25117c478bd9Sstevel@tonic-gate 					}
25127c478bd9Sstevel@tonic-gate 				}
25137c478bd9Sstevel@tonic-gate 				if ((c = ((_c >> _i) & 0x7f)) != 0) {
25147c478bd9Sstevel@tonic-gate 					PUTC(c);
25157c478bd9Sstevel@tonic-gate 				}
25167c478bd9Sstevel@tonic-gate 				break;
25177c478bd9Sstevel@tonic-gate 			case 's':
25187c478bd9Sstevel@tonic-gate 				_s = va_arg(args, char *);
25197c478bd9Sstevel@tonic-gate 				_i = strlen(_s);
25207c478bd9Sstevel@tonic-gate 				/* LINTED */
25217c478bd9Sstevel@tonic-gate 				_n = (int)(width - _i);
25227c478bd9Sstevel@tonic-gate 				if (!prec)
25237c478bd9Sstevel@tonic-gate 					/* LINTED */
25247c478bd9Sstevel@tonic-gate 					prec = (int)_i;
25257c478bd9Sstevel@tonic-gate 
25267c478bd9Sstevel@tonic-gate 				if (width && !(flag & FLG_UT_MINUS)) {
25277c478bd9Sstevel@tonic-gate 					while (_n-- > 0)
25287c478bd9Sstevel@tonic-gate 						PUTC(' ');
25297c478bd9Sstevel@tonic-gate 				}
25307c478bd9Sstevel@tonic-gate 				while (((c = *_s++) != 0) && prec--) {
25317c478bd9Sstevel@tonic-gate 					PUTC(c);
25327c478bd9Sstevel@tonic-gate 				}
25337c478bd9Sstevel@tonic-gate 				if (width && (flag & FLG_UT_MINUS)) {
25347c478bd9Sstevel@tonic-gate 					while (_n-- > 0)
25357c478bd9Sstevel@tonic-gate 						PUTC(' ');
25367c478bd9Sstevel@tonic-gate 				}
25377c478bd9Sstevel@tonic-gate 				break;
25387c478bd9Sstevel@tonic-gate 			case '%':
25397c478bd9Sstevel@tonic-gate 				PUTC('%');
25407c478bd9Sstevel@tonic-gate 				break;
25417c478bd9Sstevel@tonic-gate 			default:
25427c478bd9Sstevel@tonic-gate 				break;
25437c478bd9Sstevel@tonic-gate 			}
25447c478bd9Sstevel@tonic-gate 
25457c478bd9Sstevel@tonic-gate 			/*
25467c478bd9Sstevel@tonic-gate 			 * Numeric processing
25477c478bd9Sstevel@tonic-gate 			 */
25487c478bd9Sstevel@tonic-gate 			if (base) {
25491d6b7ad8Srie 				char		local[NUM_SIZE];
25501d6b7ad8Srie 				size_t		ssize = 0, psize = 0;
25517c478bd9Sstevel@tonic-gate 				const char	*string =
2552a953e2b1Srie 				    MSG_ORIG(MSG_STR_HEXNUM);
25537c478bd9Sstevel@tonic-gate 				const char	*prefix =
2554a953e2b1Srie 				    MSG_ORIG(MSG_STR_EMPTY);
25557c478bd9Sstevel@tonic-gate 				u_longlong_t	num;
25567c478bd9Sstevel@tonic-gate 
25577c478bd9Sstevel@tonic-gate 				switch (ls) {
25587c478bd9Sstevel@tonic-gate 				case 0:	/* int */
25597c478bd9Sstevel@tonic-gate 					num = (u_longlong_t)
25607c478bd9Sstevel@tonic-gate 					    va_arg(args, uint_t);
25617c478bd9Sstevel@tonic-gate 					break;
25627c478bd9Sstevel@tonic-gate 				case 1:	/* long */
25637c478bd9Sstevel@tonic-gate 					num = (u_longlong_t)
25647c478bd9Sstevel@tonic-gate 					    va_arg(args, ulong_t);
25657c478bd9Sstevel@tonic-gate 					break;
25667c478bd9Sstevel@tonic-gate 				case 2:	/* long long */
25677c478bd9Sstevel@tonic-gate 					num = va_arg(args, u_longlong_t);
25687c478bd9Sstevel@tonic-gate 					break;
25697c478bd9Sstevel@tonic-gate 				}
25707c478bd9Sstevel@tonic-gate 
25717c478bd9Sstevel@tonic-gate 				if (flag & FLG_UT_SHARP) {
25727c478bd9Sstevel@tonic-gate 					if (base == 16) {
25737c478bd9Sstevel@tonic-gate 						prefix = MSG_ORIG(MSG_STR_HEX);
25747c478bd9Sstevel@tonic-gate 						psize = 2;
25757c478bd9Sstevel@tonic-gate 					} else {
25767c478bd9Sstevel@tonic-gate 						prefix = MSG_ORIG(MSG_STR_ZERO);
25777c478bd9Sstevel@tonic-gate 						psize = 1;
25787c478bd9Sstevel@tonic-gate 					}
25797c478bd9Sstevel@tonic-gate 				}
25807c478bd9Sstevel@tonic-gate 				if ((base == 10) && (long)num < 0) {
25817c478bd9Sstevel@tonic-gate 					prefix = MSG_ORIG(MSG_STR_NEGATE);
25827c478bd9Sstevel@tonic-gate 					psize = MSG_STR_NEGATE_SIZE;
25837c478bd9Sstevel@tonic-gate 					num = (u_longlong_t)(-(longlong_t)num);
25847c478bd9Sstevel@tonic-gate 				}
25857c478bd9Sstevel@tonic-gate 
25867c478bd9Sstevel@tonic-gate 				/*
25877c478bd9Sstevel@tonic-gate 				 * Convert the numeric value into a local
25887c478bd9Sstevel@tonic-gate 				 * string (stored in reverse order).
25897c478bd9Sstevel@tonic-gate 				 */
25907c478bd9Sstevel@tonic-gate 				_s = local;
25917c478bd9Sstevel@tonic-gate 				do {
25927c478bd9Sstevel@tonic-gate 					*_s++ = string[num % base];
25937c478bd9Sstevel@tonic-gate 					num /= base;
25947c478bd9Sstevel@tonic-gate 					ssize++;
25957c478bd9Sstevel@tonic-gate 				} while (num);
25967c478bd9Sstevel@tonic-gate 
25971d6b7ad8Srie 				ASSERT(ssize < sizeof (local));
25981d6b7ad8Srie 
25997c478bd9Sstevel@tonic-gate 				/*
26007c478bd9Sstevel@tonic-gate 				 * Provide any precision or width padding.
26017c478bd9Sstevel@tonic-gate 				 */
26027c478bd9Sstevel@tonic-gate 				if (prec) {
26037c478bd9Sstevel@tonic-gate 					/* LINTED */
26047c478bd9Sstevel@tonic-gate 					_n = (int)(prec - ssize);
26051d6b7ad8Srie 					while ((_n-- > 0) &&
26061d6b7ad8Srie 					    (ssize < sizeof (local))) {
26077c478bd9Sstevel@tonic-gate 						*_s++ = '0';
26087c478bd9Sstevel@tonic-gate 						ssize++;
26097c478bd9Sstevel@tonic-gate 					}
26107c478bd9Sstevel@tonic-gate 				}
26117c478bd9Sstevel@tonic-gate 				if (width && !(flag & FLG_UT_MINUS)) {
26127c478bd9Sstevel@tonic-gate 					/* LINTED */
26137c478bd9Sstevel@tonic-gate 					_n = (int)(width - ssize - psize);
26147c478bd9Sstevel@tonic-gate 					while (_n-- > 0) {
26157c478bd9Sstevel@tonic-gate 						PUTC(' ');
26167c478bd9Sstevel@tonic-gate 					}
26177c478bd9Sstevel@tonic-gate 				}
26187c478bd9Sstevel@tonic-gate 
26197c478bd9Sstevel@tonic-gate 				/*
26207c478bd9Sstevel@tonic-gate 				 * Print any prefix and the numeric string
26217c478bd9Sstevel@tonic-gate 				 */
26227c478bd9Sstevel@tonic-gate 				while (*prefix)
26237c478bd9Sstevel@tonic-gate 					PUTC(*prefix++);
26247c478bd9Sstevel@tonic-gate 				do {
26257c478bd9Sstevel@tonic-gate 					PUTC(*--_s);
26267c478bd9Sstevel@tonic-gate 				} while (_s > local);
26277c478bd9Sstevel@tonic-gate 
26287c478bd9Sstevel@tonic-gate 				/*
26297c478bd9Sstevel@tonic-gate 				 * Provide any width padding.
26307c478bd9Sstevel@tonic-gate 				 */
26317c478bd9Sstevel@tonic-gate 				if (width && (flag & FLG_UT_MINUS)) {
26327c478bd9Sstevel@tonic-gate 					/* LINTED */
26337c478bd9Sstevel@tonic-gate 					_n = (int)(width - ssize - psize);
26347c478bd9Sstevel@tonic-gate 					while (_n-- > 0)
26357c478bd9Sstevel@tonic-gate 						PUTC(' ');
26367c478bd9Sstevel@tonic-gate 				}
26377c478bd9Sstevel@tonic-gate 			}
26387c478bd9Sstevel@tonic-gate 		}
26397c478bd9Sstevel@tonic-gate 	}
264010a4fa49Srie 
26417c478bd9Sstevel@tonic-gate 	PUTC('\0');
26427c478bd9Sstevel@tonic-gate 	prf->pr_cur = bp;
26437c478bd9Sstevel@tonic-gate 	return (1);
26447c478bd9Sstevel@tonic-gate }
26457c478bd9Sstevel@tonic-gate 
26467c478bd9Sstevel@tonic-gate static int
26477c478bd9Sstevel@tonic-gate doprintf(const char *format, va_list args, Prfbuf *prf)
26487c478bd9Sstevel@tonic-gate {
26497c478bd9Sstevel@tonic-gate 	char	*ocur = prf->pr_cur;
26507c478bd9Sstevel@tonic-gate 
26517c478bd9Sstevel@tonic-gate 	if (doprf(format, args, prf) == 0)
26527c478bd9Sstevel@tonic-gate 		return (0);
26537c478bd9Sstevel@tonic-gate 	/* LINTED */
26547c478bd9Sstevel@tonic-gate 	return ((int)(prf->pr_cur - ocur));
26557c478bd9Sstevel@tonic-gate }
26567c478bd9Sstevel@tonic-gate 
26577c478bd9Sstevel@tonic-gate /* VARARGS2 */
26587c478bd9Sstevel@tonic-gate int
26597c478bd9Sstevel@tonic-gate sprintf(char *buf, const char *format, ...)
26607c478bd9Sstevel@tonic-gate {
26617c478bd9Sstevel@tonic-gate 	va_list	args;
26627c478bd9Sstevel@tonic-gate 	int	len;
26637c478bd9Sstevel@tonic-gate 	Prfbuf	prf;
26647c478bd9Sstevel@tonic-gate 
26657c478bd9Sstevel@tonic-gate 	va_start(args, format);
26667c478bd9Sstevel@tonic-gate 	prf.pr_buf = prf.pr_cur = buf;
26677c478bd9Sstevel@tonic-gate 	prf.pr_len = 0;
26687c478bd9Sstevel@tonic-gate 	prf.pr_fd = -1;
26697c478bd9Sstevel@tonic-gate 	len = doprintf(format, args, &prf);
26707c478bd9Sstevel@tonic-gate 	va_end(args);
26717c478bd9Sstevel@tonic-gate 
26727c478bd9Sstevel@tonic-gate 	/*
26737c478bd9Sstevel@tonic-gate 	 * sprintf() return value excludes the terminating null byte.
26747c478bd9Sstevel@tonic-gate 	 */
26757c478bd9Sstevel@tonic-gate 	return (len - 1);
26767c478bd9Sstevel@tonic-gate }
26777c478bd9Sstevel@tonic-gate 
26787c478bd9Sstevel@tonic-gate /* VARARGS3 */
26797c478bd9Sstevel@tonic-gate int
26807c478bd9Sstevel@tonic-gate snprintf(char *buf, size_t n, const char *format, ...)
26817c478bd9Sstevel@tonic-gate {
26827c478bd9Sstevel@tonic-gate 	va_list	args;
26837c478bd9Sstevel@tonic-gate 	int	len;
26847c478bd9Sstevel@tonic-gate 	Prfbuf	prf;
26857c478bd9Sstevel@tonic-gate 
26867c478bd9Sstevel@tonic-gate 	va_start(args, format);
26877c478bd9Sstevel@tonic-gate 	prf.pr_buf = prf.pr_cur = buf;
26887c478bd9Sstevel@tonic-gate 	prf.pr_len = n;
26897c478bd9Sstevel@tonic-gate 	prf.pr_fd = -1;
26907c478bd9Sstevel@tonic-gate 	len = doprintf(format, args, &prf);
26917c478bd9Sstevel@tonic-gate 	va_end(args);
26927c478bd9Sstevel@tonic-gate 
26937c478bd9Sstevel@tonic-gate 	return (len);
26947c478bd9Sstevel@tonic-gate }
26957c478bd9Sstevel@tonic-gate 
26967c478bd9Sstevel@tonic-gate /* VARARGS2 */
26977c478bd9Sstevel@tonic-gate int
26987c478bd9Sstevel@tonic-gate bufprint(Prfbuf *prf, const char *format, ...)
26997c478bd9Sstevel@tonic-gate {
27007c478bd9Sstevel@tonic-gate 	va_list	args;
27017c478bd9Sstevel@tonic-gate 	int	len;
27027c478bd9Sstevel@tonic-gate 
27037c478bd9Sstevel@tonic-gate 	va_start(args, format);
27047c478bd9Sstevel@tonic-gate 	len = doprintf(format, args, prf);
27057c478bd9Sstevel@tonic-gate 	va_end(args);
27067c478bd9Sstevel@tonic-gate 
27077c478bd9Sstevel@tonic-gate 	return (len);
27087c478bd9Sstevel@tonic-gate }
27097c478bd9Sstevel@tonic-gate 
27107c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/
27117c478bd9Sstevel@tonic-gate int
27127c478bd9Sstevel@tonic-gate printf(const char *format, ...)
27137c478bd9Sstevel@tonic-gate {
27147c478bd9Sstevel@tonic-gate 	va_list	args;
27157c478bd9Sstevel@tonic-gate 	char 	buffer[ERRSIZE];
27167c478bd9Sstevel@tonic-gate 	Prfbuf	prf;
27177c478bd9Sstevel@tonic-gate 
27187c478bd9Sstevel@tonic-gate 	va_start(args, format);
27197c478bd9Sstevel@tonic-gate 	prf.pr_buf = prf.pr_cur = buffer;
27207c478bd9Sstevel@tonic-gate 	prf.pr_len = ERRSIZE;
27217c478bd9Sstevel@tonic-gate 	prf.pr_fd = 1;
27227c478bd9Sstevel@tonic-gate 	(void) doprf(format, args, &prf);
27237c478bd9Sstevel@tonic-gate 	va_end(args);
27247c478bd9Sstevel@tonic-gate 	/*
27257c478bd9Sstevel@tonic-gate 	 * Trim trailing '\0' form buffer
27267c478bd9Sstevel@tonic-gate 	 */
27277c478bd9Sstevel@tonic-gate 	prf.pr_cur--;
27287c478bd9Sstevel@tonic-gate 	return (dowrite(&prf));
27297c478bd9Sstevel@tonic-gate }
27307c478bd9Sstevel@tonic-gate 
27317c478bd9Sstevel@tonic-gate static char	errbuf[ERRSIZE], *nextptr = errbuf, *prevptr = 0;
27327c478bd9Sstevel@tonic-gate 
27335aefb655Srie /*PRINTFLIKE3*/
27347c478bd9Sstevel@tonic-gate void
27355aefb655Srie eprintf(Lm_list *lml, Error error, const char *format, ...)
27367c478bd9Sstevel@tonic-gate {
27377c478bd9Sstevel@tonic-gate 	va_list		args;
27387c478bd9Sstevel@tonic-gate 	int		overflow = 0;
27397c478bd9Sstevel@tonic-gate 	static int	lock = 0;
27407c478bd9Sstevel@tonic-gate 	Prfbuf		prf;
27417c478bd9Sstevel@tonic-gate 
27427c478bd9Sstevel@tonic-gate 	if (lock || (nextptr == (errbuf + ERRSIZE)))
27437c478bd9Sstevel@tonic-gate 		return;
27447c478bd9Sstevel@tonic-gate 
27457c478bd9Sstevel@tonic-gate 	/*
27467c478bd9Sstevel@tonic-gate 	 * Note: this lock is here to prevent the same thread from recursively
27477c478bd9Sstevel@tonic-gate 	 * entering itself during a eprintf.  ie: during eprintf malloc() fails
27487c478bd9Sstevel@tonic-gate 	 * and we try and call eprintf ... and then malloc() fails ....
27497c478bd9Sstevel@tonic-gate 	 */
27507c478bd9Sstevel@tonic-gate 	lock = 1;
27517c478bd9Sstevel@tonic-gate 
27527c478bd9Sstevel@tonic-gate 	/*
27537c478bd9Sstevel@tonic-gate 	 * If we have completed startup initialization, all error messages
27547c478bd9Sstevel@tonic-gate 	 * must be saved.  These are reported through dlerror().  If we're
27557c478bd9Sstevel@tonic-gate 	 * still in the initialization stage, output the error directly and
27567c478bd9Sstevel@tonic-gate 	 * add a newline.
27577c478bd9Sstevel@tonic-gate 	 */
27587c478bd9Sstevel@tonic-gate 	va_start(args, format);
27597c478bd9Sstevel@tonic-gate 
27607c478bd9Sstevel@tonic-gate 	prf.pr_buf = prf.pr_cur = nextptr;
27617c478bd9Sstevel@tonic-gate 	prf.pr_len = ERRSIZE - (nextptr - errbuf);
27627c478bd9Sstevel@tonic-gate 
27637c478bd9Sstevel@tonic-gate 	if (!(rtld_flags & RT_FL_APPLIC))
27647c478bd9Sstevel@tonic-gate 		prf.pr_fd = 2;
27657c478bd9Sstevel@tonic-gate 	else
27667c478bd9Sstevel@tonic-gate 		prf.pr_fd = -1;
27677c478bd9Sstevel@tonic-gate 
27687c478bd9Sstevel@tonic-gate 	if (error > ERR_NONE) {
27697c478bd9Sstevel@tonic-gate 		if ((error == ERR_FATAL) && (rtld_flags2 & RT_FL2_FTL2WARN))
27707c478bd9Sstevel@tonic-gate 			error = ERR_WARNING;
27717c478bd9Sstevel@tonic-gate 		if (error == ERR_WARNING) {
27727c478bd9Sstevel@tonic-gate 			if (err_strs[ERR_WARNING] == 0)
2773a953e2b1Srie 				err_strs[ERR_WARNING] =
2774a953e2b1Srie 				    MSG_INTL(MSG_ERR_WARNING);
27757c478bd9Sstevel@tonic-gate 		} else if (error == ERR_FATAL) {
27767c478bd9Sstevel@tonic-gate 			if (err_strs[ERR_FATAL] == 0)
2777a953e2b1Srie 				err_strs[ERR_FATAL] = MSG_INTL(MSG_ERR_FATAL);
27787c478bd9Sstevel@tonic-gate 		} else if (error == ERR_ELF) {
27797c478bd9Sstevel@tonic-gate 			if (err_strs[ERR_ELF] == 0)
2780a953e2b1Srie 				err_strs[ERR_ELF] = MSG_INTL(MSG_ERR_ELF);
27817c478bd9Sstevel@tonic-gate 		}
278241072f3cSrie 		if (procname) {
278341072f3cSrie 			if (bufprint(&prf, MSG_ORIG(MSG_STR_EMSGFOR1),
278441072f3cSrie 			    rtldname, procname, err_strs[error]) == 0)
278541072f3cSrie 				overflow = 1;
27867c478bd9Sstevel@tonic-gate 		} else {
278741072f3cSrie 			if (bufprint(&prf, MSG_ORIG(MSG_STR_EMSGFOR2),
278841072f3cSrie 			    rtldname, err_strs[error]) == 0)
278941072f3cSrie 				overflow = 1;
279041072f3cSrie 		}
279141072f3cSrie 		if (overflow == 0) {
27927c478bd9Sstevel@tonic-gate 			/*
27937c478bd9Sstevel@tonic-gate 			 * Remove the terminating '\0'.
27947c478bd9Sstevel@tonic-gate 			 */
27957c478bd9Sstevel@tonic-gate 			prf.pr_cur--;
27967c478bd9Sstevel@tonic-gate 		}
27977c478bd9Sstevel@tonic-gate 	}
27987c478bd9Sstevel@tonic-gate 
27997c478bd9Sstevel@tonic-gate 	if ((overflow == 0) && doprf(format, args, &prf) == 0)
28007c478bd9Sstevel@tonic-gate 		overflow = 1;
28017c478bd9Sstevel@tonic-gate 
28027c478bd9Sstevel@tonic-gate 	/*
28037c478bd9Sstevel@tonic-gate 	 * If this is an ELF error, it will have been generated by a support
28047c478bd9Sstevel@tonic-gate 	 * object that has a dependency on libelf.  ld.so.1 doesn't generate any
28057c478bd9Sstevel@tonic-gate 	 * ELF error messages as it doesn't interact with libelf.  Determine the
28067c478bd9Sstevel@tonic-gate 	 * ELF error string.
28077c478bd9Sstevel@tonic-gate 	 */
28087c478bd9Sstevel@tonic-gate 	if ((overflow == 0) && (error == ERR_ELF)) {
28097c478bd9Sstevel@tonic-gate 		static int		(*elfeno)() = 0;
28107c478bd9Sstevel@tonic-gate 		static const char	*(*elfemg)();
28117c478bd9Sstevel@tonic-gate 		const char		*emsg;
28127c478bd9Sstevel@tonic-gate 		Rt_map			*dlmp, *lmp = lml_rtld.lm_head;
28137c478bd9Sstevel@tonic-gate 
28147c478bd9Sstevel@tonic-gate 		if (NEXT(lmp) && (elfeno == 0)) {
28157c478bd9Sstevel@tonic-gate 			if (((elfemg = (const char *(*)())dlsym_intn(RTLD_NEXT,
28167c478bd9Sstevel@tonic-gate 			    MSG_ORIG(MSG_SYM_ELFERRMSG), lmp, &dlmp)) == 0) ||
28177c478bd9Sstevel@tonic-gate 			    ((elfeno = (int (*)())dlsym_intn(RTLD_NEXT,
28187c478bd9Sstevel@tonic-gate 			    MSG_ORIG(MSG_SYM_ELFERRNO), lmp, &dlmp)) == 0))
28197c478bd9Sstevel@tonic-gate 				elfeno = 0;
28207c478bd9Sstevel@tonic-gate 		}
28217c478bd9Sstevel@tonic-gate 
28227c478bd9Sstevel@tonic-gate 		/*
28237c478bd9Sstevel@tonic-gate 		 * Lookup the message; equivalent to elf_errmsg(elf_errno()).
28247c478bd9Sstevel@tonic-gate 		 */
28257c478bd9Sstevel@tonic-gate 		if (elfeno && ((emsg = (* elfemg)((* elfeno)())) != 0)) {
28267c478bd9Sstevel@tonic-gate 			prf.pr_cur--;
28277c478bd9Sstevel@tonic-gate 			if (bufprint(&prf, MSG_ORIG(MSG_STR_EMSGFOR2),
28287c478bd9Sstevel@tonic-gate 			    emsg) == 0)
28297c478bd9Sstevel@tonic-gate 				overflow = 1;
28307c478bd9Sstevel@tonic-gate 		}
28317c478bd9Sstevel@tonic-gate 	}
28327c478bd9Sstevel@tonic-gate 
28337c478bd9Sstevel@tonic-gate 	/*
28347c478bd9Sstevel@tonic-gate 	 * Push out any message that's been built.  Note, in the case of an
28357c478bd9Sstevel@tonic-gate 	 * overflow condition, this message may be incomplete, in which case
28367c478bd9Sstevel@tonic-gate 	 * make sure any partial string is null terminated.
28377c478bd9Sstevel@tonic-gate 	 */
28387c478bd9Sstevel@tonic-gate 	if (overflow)
28397c478bd9Sstevel@tonic-gate 		*(prf.pr_cur) = '\0';
28407c478bd9Sstevel@tonic-gate 	if ((rtld_flags & (RT_FL_APPLIC | RT_FL_SILENCERR)) == 0) {
28417c478bd9Sstevel@tonic-gate 		*(prf.pr_cur - 1) = '\n';
28427c478bd9Sstevel@tonic-gate 		(void) dowrite(&prf);
28437c478bd9Sstevel@tonic-gate 	}
28447c478bd9Sstevel@tonic-gate 
28455aefb655Srie 	DBG_CALL(Dbg_util_str(lml, nextptr));
28467c478bd9Sstevel@tonic-gate 	va_end(args);
28477c478bd9Sstevel@tonic-gate 
28487c478bd9Sstevel@tonic-gate 	/*
28497c478bd9Sstevel@tonic-gate 	 * Determine if there was insufficient space left in the buffer to
28507c478bd9Sstevel@tonic-gate 	 * complete the message.  If so, we'll have printed out as much as had
28517c478bd9Sstevel@tonic-gate 	 * been processed if we're not yet executing the application.
28527c478bd9Sstevel@tonic-gate 	 * Otherwise, there will be some debugging diagnostic indicating
28537c478bd9Sstevel@tonic-gate 	 * as much of the error message as possible.  Write out a final buffer
28547c478bd9Sstevel@tonic-gate 	 * overflow diagnostic - unlocalized, so we don't chance more errors.
28557c478bd9Sstevel@tonic-gate 	 */
28567c478bd9Sstevel@tonic-gate 	if (overflow) {
28577c478bd9Sstevel@tonic-gate 		char	*str = (char *)MSG_INTL(MSG_EMG_BUFOVRFLW);
28587c478bd9Sstevel@tonic-gate 
28597c478bd9Sstevel@tonic-gate 		if ((rtld_flags & RT_FL_SILENCERR) == 0) {
28607c478bd9Sstevel@tonic-gate 			lasterr = str;
28617c478bd9Sstevel@tonic-gate 
28627c478bd9Sstevel@tonic-gate 			if ((rtld_flags & RT_FL_APPLIC) == 0) {
28637c478bd9Sstevel@tonic-gate 				(void) write(2, str, strlen(str));
28647c478bd9Sstevel@tonic-gate 				(void) write(2, MSG_ORIG(MSG_STR_NL),
28657c478bd9Sstevel@tonic-gate 				    MSG_STR_NL_SIZE);
28667c478bd9Sstevel@tonic-gate 			}
28677c478bd9Sstevel@tonic-gate 		}
28685aefb655Srie 		DBG_CALL(Dbg_util_str(lml, str));
28697c478bd9Sstevel@tonic-gate 
28707c478bd9Sstevel@tonic-gate 		lock = 0;
28717c478bd9Sstevel@tonic-gate 		nextptr = errbuf + ERRSIZE;
28727c478bd9Sstevel@tonic-gate 		return;
28737c478bd9Sstevel@tonic-gate 	}
28747c478bd9Sstevel@tonic-gate 
28757c478bd9Sstevel@tonic-gate 	/*
28767c478bd9Sstevel@tonic-gate 	 * If the application has started, then error messages are being saved
28777c478bd9Sstevel@tonic-gate 	 * for retrieval by dlerror(), or possible flushing from rtldexit() in
28787c478bd9Sstevel@tonic-gate 	 * the case of a fatal error.  In this case, establish the next error
28797c478bd9Sstevel@tonic-gate 	 * pointer.  If we haven't started the application, the whole message
28807c478bd9Sstevel@tonic-gate 	 * buffer can be reused.
28817c478bd9Sstevel@tonic-gate 	 */
28827c478bd9Sstevel@tonic-gate 	if ((rtld_flags & RT_FL_SILENCERR) == 0) {
28837c478bd9Sstevel@tonic-gate 		lasterr = nextptr;
28847c478bd9Sstevel@tonic-gate 
28857c478bd9Sstevel@tonic-gate 		/*
28867c478bd9Sstevel@tonic-gate 		 * Note, should we encounter an error such as ENOMEM, there may
28877c478bd9Sstevel@tonic-gate 		 * be a number of the same error messages (ie. an operation
28887c478bd9Sstevel@tonic-gate 		 * fails with ENOMEM, and then the attempts to construct the
28897c478bd9Sstevel@tonic-gate 		 * error message itself, which incurs additional ENOMEM errors).
28907c478bd9Sstevel@tonic-gate 		 * Compare any previous error message with the one we've just
28917c478bd9Sstevel@tonic-gate 		 * created to prevent any duplication clutter.
28927c478bd9Sstevel@tonic-gate 		 */
28937c478bd9Sstevel@tonic-gate 		if ((rtld_flags & RT_FL_APPLIC) &&
28947c478bd9Sstevel@tonic-gate 		    ((prevptr == 0) || (strcmp(prevptr, nextptr) != 0))) {
28957c478bd9Sstevel@tonic-gate 			prevptr = nextptr;
28967c478bd9Sstevel@tonic-gate 			nextptr = prf.pr_cur;
28977c478bd9Sstevel@tonic-gate 			*nextptr = '\0';
28987c478bd9Sstevel@tonic-gate 		}
28997c478bd9Sstevel@tonic-gate 	}
29007c478bd9Sstevel@tonic-gate 	lock = 0;
29017c478bd9Sstevel@tonic-gate }
29027c478bd9Sstevel@tonic-gate 
29037c478bd9Sstevel@tonic-gate 
29047c478bd9Sstevel@tonic-gate #if	DEBUG
29057c478bd9Sstevel@tonic-gate /*
29067c478bd9Sstevel@tonic-gate  * Provide assfail() for ASSERT() statements,
29077c478bd9Sstevel@tonic-gate  * see <sys/debug.h> for further details.
29087c478bd9Sstevel@tonic-gate  */
29097c478bd9Sstevel@tonic-gate int
29107c478bd9Sstevel@tonic-gate assfail(const char *a, const char *f, int l)
29117c478bd9Sstevel@tonic-gate {
29127c478bd9Sstevel@tonic-gate 	(void) printf("assertion failed: %s, file: %s, line: %d\n", a, f, l);
29137c478bd9Sstevel@tonic-gate 	(void) _lwp_kill(_lwp_self(), SIGABRT);
29147c478bd9Sstevel@tonic-gate 	return (0);
29157c478bd9Sstevel@tonic-gate }
29167c478bd9Sstevel@tonic-gate #endif
29177c478bd9Sstevel@tonic-gate 
29187c478bd9Sstevel@tonic-gate /*
29197c478bd9Sstevel@tonic-gate  * Exit.  If we arrive here with a non zero status it's because of a fatal
29207c478bd9Sstevel@tonic-gate  * error condition (most commonly a relocation error).  If the application has
29217c478bd9Sstevel@tonic-gate  * already had control, then the actual fatal error message will have been
29227c478bd9Sstevel@tonic-gate  * recorded in the dlerror() message buffer.  Print the message before really
29237c478bd9Sstevel@tonic-gate  * exiting.
29247c478bd9Sstevel@tonic-gate  */
29257c478bd9Sstevel@tonic-gate void
29267c478bd9Sstevel@tonic-gate rtldexit(Lm_list * lml, int status)
29277c478bd9Sstevel@tonic-gate {
29287c478bd9Sstevel@tonic-gate 	if (status) {
29297c478bd9Sstevel@tonic-gate 		if (rtld_flags & RT_FL_APPLIC) {
29307c478bd9Sstevel@tonic-gate 			/*
29317c478bd9Sstevel@tonic-gate 			 * If the error buffer has been used, write out all
29327c478bd9Sstevel@tonic-gate 			 * pending messages - lasterr is simply a pointer to
29337c478bd9Sstevel@tonic-gate 			 * the last message in this buffer.  However, if the
29347c478bd9Sstevel@tonic-gate 			 * buffer couldn't be created at all, lasterr points
29357c478bd9Sstevel@tonic-gate 			 * to a constant error message string.
29367c478bd9Sstevel@tonic-gate 			 */
29377c478bd9Sstevel@tonic-gate 			if (*errbuf) {
29387c478bd9Sstevel@tonic-gate 				char	*errptr = errbuf;
29397c478bd9Sstevel@tonic-gate 				char	*errend = errbuf + ERRSIZE;
29407c478bd9Sstevel@tonic-gate 
29417c478bd9Sstevel@tonic-gate 				while ((errptr < errend) && *errptr) {
29427c478bd9Sstevel@tonic-gate 					size_t	size = strlen(errptr);
29437c478bd9Sstevel@tonic-gate 					(void) write(2, errptr, size);
29447c478bd9Sstevel@tonic-gate 					(void) write(2, MSG_ORIG(MSG_STR_NL),
29457c478bd9Sstevel@tonic-gate 					    MSG_STR_NL_SIZE);
29467c478bd9Sstevel@tonic-gate 					errptr += (size + 1);
29477c478bd9Sstevel@tonic-gate 				}
29487c478bd9Sstevel@tonic-gate 			}
29497c478bd9Sstevel@tonic-gate 			if (lasterr && ((lasterr < errbuf) ||
29507c478bd9Sstevel@tonic-gate 			    (lasterr > (errbuf + ERRSIZE)))) {
29517c478bd9Sstevel@tonic-gate 				(void) write(2, lasterr, strlen(lasterr));
29527c478bd9Sstevel@tonic-gate 				(void) write(2, MSG_ORIG(MSG_STR_NL),
29537c478bd9Sstevel@tonic-gate 				    MSG_STR_NL_SIZE);
29547c478bd9Sstevel@tonic-gate 			}
29557c478bd9Sstevel@tonic-gate 		}
29567c478bd9Sstevel@tonic-gate 		leave(lml);
29577c478bd9Sstevel@tonic-gate 		(void) _lwp_kill(_lwp_self(), killsig);
29587c478bd9Sstevel@tonic-gate 	}
29597c478bd9Sstevel@tonic-gate 	_exit(status);
29607c478bd9Sstevel@tonic-gate }
29617c478bd9Sstevel@tonic-gate 
29627c478bd9Sstevel@tonic-gate /*
29637c478bd9Sstevel@tonic-gate  * Routines to co-ordinate the opening of /dev/zero and /proc.
29647c478bd9Sstevel@tonic-gate  * dz_fd is exported for possible use by libld.so, and to insure it gets
29657c478bd9Sstevel@tonic-gate  * closed on leaving ld.so.1.
29667c478bd9Sstevel@tonic-gate  */
29677c478bd9Sstevel@tonic-gate int	dz_fd = FD_UNAVAIL;
29687c478bd9Sstevel@tonic-gate 
29697c478bd9Sstevel@tonic-gate void
29707c478bd9Sstevel@tonic-gate dz_init(int fd)
29717c478bd9Sstevel@tonic-gate {
29727c478bd9Sstevel@tonic-gate 	dz_fd = fd;
29737c478bd9Sstevel@tonic-gate }
29747c478bd9Sstevel@tonic-gate 
29757c478bd9Sstevel@tonic-gate 
29767c478bd9Sstevel@tonic-gate /*
29777c478bd9Sstevel@tonic-gate  * mmap() a page from MAP_ANON
29787c478bd9Sstevel@tonic-gate  *
29797c478bd9Sstevel@tonic-gate  * Note: MAP_ANON is only on Solaris8++, we use this routine to
29807c478bd9Sstevel@tonic-gate  *       not only mmap(MAP_ANON) but to also probe if it is available
29817c478bd9Sstevel@tonic-gate  *	 on the current OS.
29827c478bd9Sstevel@tonic-gate  */
29837c478bd9Sstevel@tonic-gate Am_ret
29845aefb655Srie anon_map(Lm_list *lml, caddr_t *addr, size_t len, int prot, int flags)
29857c478bd9Sstevel@tonic-gate {
29867c478bd9Sstevel@tonic-gate #if defined(MAP_ANON)
29877c478bd9Sstevel@tonic-gate 	static int	noanon = 0;
29887c478bd9Sstevel@tonic-gate 	caddr_t		va;
29897c478bd9Sstevel@tonic-gate 
29907c478bd9Sstevel@tonic-gate 	if (noanon == 0) {
29917c478bd9Sstevel@tonic-gate 		if ((va = (caddr_t)mmap(*addr, len, prot,
29927c478bd9Sstevel@tonic-gate 		    (flags | MAP_ANON), -1, 0)) != MAP_FAILED) {
29937c478bd9Sstevel@tonic-gate 			*addr = va;
29947c478bd9Sstevel@tonic-gate 			return (AM_OK);
29957c478bd9Sstevel@tonic-gate 		}
29967c478bd9Sstevel@tonic-gate 
29977c478bd9Sstevel@tonic-gate 		if ((errno != EBADF) && (errno != EINVAL)) {
29987c478bd9Sstevel@tonic-gate 			int	err = errno;
29995aefb655Srie 			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_MMAPANON),
30007c478bd9Sstevel@tonic-gate 			    MSG_ORIG(MSG_PTH_DEVZERO), strerror(err));
30017c478bd9Sstevel@tonic-gate 			return (AM_ERROR);
30027c478bd9Sstevel@tonic-gate 		} else
30037c478bd9Sstevel@tonic-gate 			noanon = 1;
30047c478bd9Sstevel@tonic-gate 	}
30057c478bd9Sstevel@tonic-gate #endif
30067c478bd9Sstevel@tonic-gate 	return (AM_NOSUP);
30077c478bd9Sstevel@tonic-gate }
30087c478bd9Sstevel@tonic-gate 
30097c478bd9Sstevel@tonic-gate /*
30107c478bd9Sstevel@tonic-gate  * Map anonymous memory from /dev/zero, or via MAP_ANON.
30117c478bd9Sstevel@tonic-gate  *
30127c478bd9Sstevel@tonic-gate  * (MAP_ANON only appears on Solaris 8, so we need fall-back
30137c478bd9Sstevel@tonic-gate  * behavior for older systems.)
30147c478bd9Sstevel@tonic-gate  */
30157c478bd9Sstevel@tonic-gate caddr_t
30165aefb655Srie dz_map(Lm_list *lml, caddr_t addr, size_t len, int prot, int flags)
30177c478bd9Sstevel@tonic-gate {
30187c478bd9Sstevel@tonic-gate 	caddr_t	va;
30197c478bd9Sstevel@tonic-gate 	int	err;
30207c478bd9Sstevel@tonic-gate 	Am_ret	amret;
30217c478bd9Sstevel@tonic-gate 
30225aefb655Srie 	amret = anon_map(lml, &addr, len, prot, flags);
30237c478bd9Sstevel@tonic-gate 
30247c478bd9Sstevel@tonic-gate 	if (amret == AM_OK)
30257c478bd9Sstevel@tonic-gate 		return (addr);
30267c478bd9Sstevel@tonic-gate 	if (amret == AM_ERROR)
30277c478bd9Sstevel@tonic-gate 		return (MAP_FAILED);
30287c478bd9Sstevel@tonic-gate 
30297c478bd9Sstevel@tonic-gate 	/* amret == AM_NOSUP -> fallback to a devzero mmaping */
30307c478bd9Sstevel@tonic-gate 
30317c478bd9Sstevel@tonic-gate 	if (dz_fd == FD_UNAVAIL) {
30327c478bd9Sstevel@tonic-gate 		if ((dz_fd = open(MSG_ORIG(MSG_PTH_DEVZERO),
30337c478bd9Sstevel@tonic-gate 		    O_RDONLY)) == FD_UNAVAIL) {
30347c478bd9Sstevel@tonic-gate 			err = errno;
30355aefb655Srie 			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN),
30367c478bd9Sstevel@tonic-gate 			    MSG_ORIG(MSG_PTH_DEVZERO), strerror(err));
30377c478bd9Sstevel@tonic-gate 			return (MAP_FAILED);
30387c478bd9Sstevel@tonic-gate 		}
30397c478bd9Sstevel@tonic-gate 	}
30407c478bd9Sstevel@tonic-gate 
30417c478bd9Sstevel@tonic-gate 	if ((va = mmap(addr, len, prot, flags, dz_fd, 0)) == MAP_FAILED) {
30427c478bd9Sstevel@tonic-gate 		err = errno;
30435aefb655Srie 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_MMAP),
30447c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_PTH_DEVZERO), strerror(err));
30457c478bd9Sstevel@tonic-gate 	}
30467c478bd9Sstevel@tonic-gate 	return (va);
30477c478bd9Sstevel@tonic-gate }
30487c478bd9Sstevel@tonic-gate 
30497c478bd9Sstevel@tonic-gate static int	pr_fd = FD_UNAVAIL;
30507c478bd9Sstevel@tonic-gate 
30517c478bd9Sstevel@tonic-gate int
30525aefb655Srie pr_open(Lm_list *lml)
30537c478bd9Sstevel@tonic-gate {
30547c478bd9Sstevel@tonic-gate 	char	proc[16];
30557c478bd9Sstevel@tonic-gate 
30567c478bd9Sstevel@tonic-gate 	if (pr_fd == FD_UNAVAIL) {
30577c478bd9Sstevel@tonic-gate 		(void) snprintf(proc, 16, MSG_ORIG(MSG_FMT_PROC),
3058a953e2b1Srie 		    (int)getpid());
30597c478bd9Sstevel@tonic-gate 		if ((pr_fd = open(proc, O_RDONLY)) == FD_UNAVAIL) {
30607c478bd9Sstevel@tonic-gate 			int	err = errno;
30617c478bd9Sstevel@tonic-gate 
30625aefb655Srie 			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN), proc,
30637c478bd9Sstevel@tonic-gate 			    strerror(err));
30647c478bd9Sstevel@tonic-gate 		}
30657c478bd9Sstevel@tonic-gate 	}
30667c478bd9Sstevel@tonic-gate 	return (pr_fd);
30677c478bd9Sstevel@tonic-gate }
30687c478bd9Sstevel@tonic-gate 
30697c478bd9Sstevel@tonic-gate static int	nu_fd = FD_UNAVAIL;
30707c478bd9Sstevel@tonic-gate 
30717c478bd9Sstevel@tonic-gate caddr_t
30725aefb655Srie nu_map(Lm_list *lml, caddr_t addr, size_t len, int prot, int flags)
30737c478bd9Sstevel@tonic-gate {
30747c478bd9Sstevel@tonic-gate 	caddr_t	va;
30757c478bd9Sstevel@tonic-gate 	int	err;
30767c478bd9Sstevel@tonic-gate 
30777c478bd9Sstevel@tonic-gate 	if (nu_fd == FD_UNAVAIL) {
30787c478bd9Sstevel@tonic-gate 		if ((nu_fd = open(MSG_ORIG(MSG_PTH_DEVNULL),
30797c478bd9Sstevel@tonic-gate 		    O_RDONLY)) == FD_UNAVAIL) {
30807c478bd9Sstevel@tonic-gate 			err = errno;
30815aefb655Srie 			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN),
30827c478bd9Sstevel@tonic-gate 			    MSG_ORIG(MSG_PTH_DEVNULL), strerror(err));
30837c478bd9Sstevel@tonic-gate 			return (MAP_FAILED);
30847c478bd9Sstevel@tonic-gate 		}
30857c478bd9Sstevel@tonic-gate 	}
30867c478bd9Sstevel@tonic-gate 
30877c478bd9Sstevel@tonic-gate 	if ((va = (caddr_t)mmap(addr, len, prot, flags, nu_fd, 0)) ==
30887c478bd9Sstevel@tonic-gate 	    MAP_FAILED) {
30897c478bd9Sstevel@tonic-gate 		err = errno;
30905aefb655Srie 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_MMAP),
30917c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_PTH_DEVNULL), strerror(err));
30927c478bd9Sstevel@tonic-gate 	}
30937c478bd9Sstevel@tonic-gate 	return (va);
30947c478bd9Sstevel@tonic-gate }
30957c478bd9Sstevel@tonic-gate 
30967c478bd9Sstevel@tonic-gate /*
309775e7992aSrie  * Generic entry point from user code - simply grabs a lock, and bumps the
309875e7992aSrie  * entrance count.
30997c478bd9Sstevel@tonic-gate  */
31007c478bd9Sstevel@tonic-gate int
31017c478bd9Sstevel@tonic-gate enter(void)
31027c478bd9Sstevel@tonic-gate {
31037c478bd9Sstevel@tonic-gate 	if (rt_bind_guard(THR_FLG_RTLD)) {
31047c478bd9Sstevel@tonic-gate 		(void) rt_mutex_lock(&rtldlock);
310575e7992aSrie 		ld_entry_cnt++;
31067c478bd9Sstevel@tonic-gate 		return (1);
31077c478bd9Sstevel@tonic-gate 	}
31087c478bd9Sstevel@tonic-gate 	return (0);
31097c478bd9Sstevel@tonic-gate }
31107c478bd9Sstevel@tonic-gate 
31117c478bd9Sstevel@tonic-gate /*
31127c478bd9Sstevel@tonic-gate  * Generate diagnostics as to whether an object has been used.  A symbolic
31137c478bd9Sstevel@tonic-gate  * reference that gets bound to an object marks it as used.  Dependencies that
31147c478bd9Sstevel@tonic-gate  * are unused when RTLD_NOW is in effect should be removed from future builds
31157c478bd9Sstevel@tonic-gate  * of an object.  Dependencies that are unused without RTLD_NOW in effect are
31167c478bd9Sstevel@tonic-gate  * candidates for lazy-loading.
31177c478bd9Sstevel@tonic-gate  * Unreferenced objects identify objects that are defined as dependencies but
31187c478bd9Sstevel@tonic-gate  * are unreferenced by the caller (they may however be referenced by other
31197c478bd9Sstevel@tonic-gate  * objects within the process, and therefore don't qualify as completely unused.
31207c478bd9Sstevel@tonic-gate  */
31217c478bd9Sstevel@tonic-gate void
31227c478bd9Sstevel@tonic-gate unused(Lm_list *lml)
31237c478bd9Sstevel@tonic-gate {
31247c478bd9Sstevel@tonic-gate 	Rt_map		*lmp;
31257c478bd9Sstevel@tonic-gate 	int		nl = 0;
31267c478bd9Sstevel@tonic-gate 	Word		tracing;
31277c478bd9Sstevel@tonic-gate 
31287c478bd9Sstevel@tonic-gate 	/*
31297c478bd9Sstevel@tonic-gate 	 * If we're not tracing unused references or dependencies, or debugging
31307c478bd9Sstevel@tonic-gate 	 * there's nothing to do.
31317c478bd9Sstevel@tonic-gate 	 */
31327c478bd9Sstevel@tonic-gate 	tracing = lml->lm_flags & (LML_FLG_TRC_UNREF | LML_FLG_TRC_UNUSED);
31337c478bd9Sstevel@tonic-gate 
31345aefb655Srie 	if ((tracing == 0) && (DBG_ENABLED == 0))
31357c478bd9Sstevel@tonic-gate 		return;
31367c478bd9Sstevel@tonic-gate 
31377c478bd9Sstevel@tonic-gate 	/*
31387c478bd9Sstevel@tonic-gate 	 * Traverse the link-maps looking for unreferenced or unused
31397c478bd9Sstevel@tonic-gate 	 * dependencies.  Ignore the first object on a link-map list, as this
31407c478bd9Sstevel@tonic-gate 	 * is effectively always used.
31417c478bd9Sstevel@tonic-gate 	 */
31427c478bd9Sstevel@tonic-gate 	for (lmp = (Rt_map *)NEXT(lml->lm_head); lmp;
31437c478bd9Sstevel@tonic-gate 	    lmp = (Rt_map *)NEXT(lmp)) {
31447c478bd9Sstevel@tonic-gate 		/*
31457c478bd9Sstevel@tonic-gate 		 * If tracing unreferenced objects, or under debugging,
31467c478bd9Sstevel@tonic-gate 		 * determine whether any of this objects callers haven't
31477c478bd9Sstevel@tonic-gate 		 * referenced it.
31487c478bd9Sstevel@tonic-gate 		 */
31495aefb655Srie 		if ((tracing & LML_FLG_TRC_UNREF) || DBG_ENABLED) {
3150cce0e03bSab 			Bnd_desc	*bdp;
3151cce0e03bSab 			Aliste		idx;
31527c478bd9Sstevel@tonic-gate 
3153cce0e03bSab 			for (APLIST_TRAVERSE(CALLERS(lmp), idx, bdp)) {
31547c478bd9Sstevel@tonic-gate 				Rt_map *	clmp;
31557c478bd9Sstevel@tonic-gate 
31567c478bd9Sstevel@tonic-gate 				if (bdp->b_flags & BND_REFER)
31577c478bd9Sstevel@tonic-gate 					continue;
31587c478bd9Sstevel@tonic-gate 
31597c478bd9Sstevel@tonic-gate 				clmp = bdp->b_caller;
31607c478bd9Sstevel@tonic-gate 				if (FLAGS1(clmp) & FL1_RT_LDDSTUB)
31617c478bd9Sstevel@tonic-gate 					continue;
31627c478bd9Sstevel@tonic-gate 
3163a953e2b1Srie 				/* BEGIN CSTYLED */
31647c478bd9Sstevel@tonic-gate 				if (nl++ == 0) {
31657c478bd9Sstevel@tonic-gate 					if (tracing & LML_FLG_TRC_UNREF)
31667c478bd9Sstevel@tonic-gate 					    (void) printf(MSG_ORIG(MSG_STR_NL));
31677c478bd9Sstevel@tonic-gate 					else
31685aefb655Srie 					    DBG_CALL(Dbg_util_nl(lml,
31695aefb655Srie 						DBG_NL_STD));
31707c478bd9Sstevel@tonic-gate 				}
31717c478bd9Sstevel@tonic-gate 
31727c478bd9Sstevel@tonic-gate 				if (tracing & LML_FLG_TRC_UNREF)
31737c478bd9Sstevel@tonic-gate 				    (void) printf(MSG_INTL(MSG_LDD_UNREF_FMT),
31747c478bd9Sstevel@tonic-gate 					NAME(lmp), NAME(clmp));
31757c478bd9Sstevel@tonic-gate 				else
31765aefb655Srie 				    DBG_CALL(Dbg_unused_unref(lmp, NAME(clmp)));
3177a953e2b1Srie 				/* END CSTYLED */
31787c478bd9Sstevel@tonic-gate 			}
31797c478bd9Sstevel@tonic-gate 		}
31807c478bd9Sstevel@tonic-gate 
31817c478bd9Sstevel@tonic-gate 		/*
31827c478bd9Sstevel@tonic-gate 		 * If tracing unused objects simply display those objects that
31837c478bd9Sstevel@tonic-gate 		 * haven't been referenced by anyone.
31847c478bd9Sstevel@tonic-gate 		 */
31857c478bd9Sstevel@tonic-gate 		if (FLAGS1(lmp) & FL1_RT_USED)
31867c478bd9Sstevel@tonic-gate 			continue;
31877c478bd9Sstevel@tonic-gate 
31887c478bd9Sstevel@tonic-gate 		if (nl++ == 0) {
31897c478bd9Sstevel@tonic-gate 			if (tracing)
31907c478bd9Sstevel@tonic-gate 				(void) printf(MSG_ORIG(MSG_STR_NL));
31917c478bd9Sstevel@tonic-gate 			else
31925aefb655Srie 				DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD));
31937c478bd9Sstevel@tonic-gate 		}
31947c478bd9Sstevel@tonic-gate 		if (CYCGROUP(lmp)) {
31957c478bd9Sstevel@tonic-gate 			if (tracing)
31967c478bd9Sstevel@tonic-gate 				(void) printf(MSG_INTL(MSG_LDD_UNCYC_FMT),
31977c478bd9Sstevel@tonic-gate 				    NAME(lmp), CYCGROUP(lmp));
31987c478bd9Sstevel@tonic-gate 			else
31995aefb655Srie 				DBG_CALL(Dbg_unused_file(lml, NAME(lmp), 0,
32007c478bd9Sstevel@tonic-gate 				    CYCGROUP(lmp)));
32017c478bd9Sstevel@tonic-gate 		} else {
32027c478bd9Sstevel@tonic-gate 			if (tracing)
32037c478bd9Sstevel@tonic-gate 				(void) printf(MSG_INTL(MSG_LDD_UNUSED_FMT),
32047c478bd9Sstevel@tonic-gate 				    NAME(lmp));
32057c478bd9Sstevel@tonic-gate 			else
32065aefb655Srie 				DBG_CALL(Dbg_unused_file(lml, NAME(lmp), 0, 0));
32077c478bd9Sstevel@tonic-gate 		}
32087c478bd9Sstevel@tonic-gate 	}
32097c478bd9Sstevel@tonic-gate 
32105aefb655Srie 	DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD));
32117c478bd9Sstevel@tonic-gate }
32127c478bd9Sstevel@tonic-gate 
32137c478bd9Sstevel@tonic-gate /*
32147c478bd9Sstevel@tonic-gate  * Initialization routine for the Fmap structure.  If the fmap structure is
32157c478bd9Sstevel@tonic-gate  * already in use, any mapping is released.  The structure is then initialized
32167c478bd9Sstevel@tonic-gate  * in preparation for further use.
32177c478bd9Sstevel@tonic-gate  */
32187c478bd9Sstevel@tonic-gate void
32197c478bd9Sstevel@tonic-gate fmap_setup()
32207c478bd9Sstevel@tonic-gate {
32217c478bd9Sstevel@tonic-gate #if defined(MAP_ALIGN)
32227c478bd9Sstevel@tonic-gate 	/*
32237c478bd9Sstevel@tonic-gate 	 * If MAP_ALIGN is set, the fm_addr has been seeded with an alignment
32247c478bd9Sstevel@tonic-gate 	 * value.  Otherwise, if fm_addr is non-null it indicates a mapping that
32257c478bd9Sstevel@tonic-gate 	 * should now be freed.
32267c478bd9Sstevel@tonic-gate 	 */
32277c478bd9Sstevel@tonic-gate 	if (fmap->fm_maddr && ((fmap->fm_mflags & MAP_ALIGN) == 0))
32287c478bd9Sstevel@tonic-gate 		(void) munmap((caddr_t)fmap->fm_maddr, fmap->fm_msize);
32297c478bd9Sstevel@tonic-gate 
32307c478bd9Sstevel@tonic-gate 	/*
32317c478bd9Sstevel@tonic-gate 	 * Providing we haven't determined that this system doesn't support
32327c478bd9Sstevel@tonic-gate 	 * MAP_ALIGN, initialize the mapping address with the default segment
32337c478bd9Sstevel@tonic-gate 	 * alignment.
32347c478bd9Sstevel@tonic-gate 	 */
32357c478bd9Sstevel@tonic-gate 	if ((rtld_flags2 & RT_FL2_NOMALIGN) == 0) {
32367c478bd9Sstevel@tonic-gate 		fmap->fm_maddr = (char *)M_SEGM_ALIGN;
32377c478bd9Sstevel@tonic-gate 		fmap->fm_mflags = MAP_PRIVATE | MAP_ALIGN;
32387c478bd9Sstevel@tonic-gate 	} else {
32397c478bd9Sstevel@tonic-gate 		fmap->fm_maddr = 0;
32407c478bd9Sstevel@tonic-gate 		fmap->fm_mflags = MAP_PRIVATE;
32417c478bd9Sstevel@tonic-gate 	}
32427c478bd9Sstevel@tonic-gate #else
32437c478bd9Sstevel@tonic-gate 	if (fmap->fm_maddr)
32447c478bd9Sstevel@tonic-gate 		(void) munmap((caddr_t)fmap->fm_maddr, fmap->fm_msize);
3245fb1354edSrie 
32467c478bd9Sstevel@tonic-gate 	fmap->fm_maddr = 0;
32477c478bd9Sstevel@tonic-gate 	fmap->fm_mflags = MAP_PRIVATE;
32487c478bd9Sstevel@tonic-gate #endif
32497c478bd9Sstevel@tonic-gate 
3250a953e2b1Srie 	fmap->fm_msize = FMAP_SIZE;
32517c478bd9Sstevel@tonic-gate 	fmap->fm_hwptr = 0;
32527c478bd9Sstevel@tonic-gate }
32537c478bd9Sstevel@tonic-gate 
32547c478bd9Sstevel@tonic-gate /*
32557c478bd9Sstevel@tonic-gate  * Generic cleanup routine called prior to returning control to the user.
32567c478bd9Sstevel@tonic-gate  * Insures that any ld.so.1 specific file descriptors or temporary mapping are
32577c478bd9Sstevel@tonic-gate  * released, and any locks dropped.
32587c478bd9Sstevel@tonic-gate  */
32597c478bd9Sstevel@tonic-gate void
326012b8e62eSrie leave(Lm_list *lml)
32617c478bd9Sstevel@tonic-gate {
326212b8e62eSrie 	Lm_list	*elml = lml;
3263cce0e03bSab 	Rt_map	*clmp;
3264cce0e03bSab 	Aliste	idx;
326512b8e62eSrie 
32667c478bd9Sstevel@tonic-gate 	/*
326712b8e62eSrie 	 * Alert the debuggers that the link-maps are consistent.  Note, in the
326812b8e62eSrie 	 * case of tearing down a whole link-map list, lml will be null.  In
326912b8e62eSrie 	 * this case use the main link-map list to test for a notification.
32707c478bd9Sstevel@tonic-gate 	 */
327112b8e62eSrie 	if (elml == 0)
327212b8e62eSrie 		elml = &lml_main;
327312b8e62eSrie 	if (elml->lm_flags & LML_FLG_DBNOTIF)
327412b8e62eSrie 		rd_event(elml, RD_DLACTIVITY, RT_CONSISTENT);
32757c478bd9Sstevel@tonic-gate 
32767247f888Srie 	/*
32777247f888Srie 	 * Alert any auditors that the link-maps are consistent.
32787247f888Srie 	 */
3279cce0e03bSab 	for (APLIST_TRAVERSE(elml->lm_actaudit, idx, clmp)) {
3280cce0e03bSab 		audit_activity(clmp, LA_ACT_CONSISTENT);
32817247f888Srie 
3282cce0e03bSab 		aplist_delete(elml->lm_actaudit, &idx);
32837247f888Srie 	}
32847247f888Srie 
32857c478bd9Sstevel@tonic-gate 	if (dz_fd != FD_UNAVAIL) {
32867c478bd9Sstevel@tonic-gate 		(void) close(dz_fd);
32877c478bd9Sstevel@tonic-gate 		dz_fd = FD_UNAVAIL;
32887c478bd9Sstevel@tonic-gate 	}
32897c478bd9Sstevel@tonic-gate 
32907c478bd9Sstevel@tonic-gate 	if (pr_fd != FD_UNAVAIL) {
32917c478bd9Sstevel@tonic-gate 		(void) close(pr_fd);
32927c478bd9Sstevel@tonic-gate 		pr_fd = FD_UNAVAIL;
32937c478bd9Sstevel@tonic-gate 	}
32947c478bd9Sstevel@tonic-gate 
32957c478bd9Sstevel@tonic-gate 	if (nu_fd != FD_UNAVAIL) {
32967c478bd9Sstevel@tonic-gate 		(void) close(nu_fd);
32977c478bd9Sstevel@tonic-gate 		nu_fd = FD_UNAVAIL;
32987c478bd9Sstevel@tonic-gate 	}
32997c478bd9Sstevel@tonic-gate 
33007c478bd9Sstevel@tonic-gate 	fmap_setup();
33017c478bd9Sstevel@tonic-gate 
33027c478bd9Sstevel@tonic-gate 	/*
33037c478bd9Sstevel@tonic-gate 	 * Reinitialize error message pointer, and any overflow indication.
33047c478bd9Sstevel@tonic-gate 	 */
33057c478bd9Sstevel@tonic-gate 	nextptr = errbuf;
33067c478bd9Sstevel@tonic-gate 	prevptr = 0;
33077c478bd9Sstevel@tonic-gate 
33087c478bd9Sstevel@tonic-gate 	/*
33097c478bd9Sstevel@tonic-gate 	 * Don't drop our lock if we are running on our link-map list as
33107c478bd9Sstevel@tonic-gate 	 * there's little point in doing so since we are single-threaded.
33117c478bd9Sstevel@tonic-gate 	 *
33127c478bd9Sstevel@tonic-gate 	 * LML_FLG_HOLDLOCK is set for:
33137c478bd9Sstevel@tonic-gate 	 *	*) The ld.so.1's link-map list.
33147c478bd9Sstevel@tonic-gate 	 *	*) The auditor's link-map if the environment is
33157c478bd9Sstevel@tonic-gate 	 *	   libc/libthread un-unified.
33167c478bd9Sstevel@tonic-gate 	 */
33177c478bd9Sstevel@tonic-gate 	if (lml && (lml->lm_flags & LML_FLG_HOLDLOCK))
33187c478bd9Sstevel@tonic-gate 		return;
33197c478bd9Sstevel@tonic-gate 
33207c478bd9Sstevel@tonic-gate 	if (rt_bind_clear(0) & THR_FLG_RTLD) {
33217c478bd9Sstevel@tonic-gate 		(void) rt_mutex_unlock(&rtldlock);
33227c478bd9Sstevel@tonic-gate 		(void) rt_bind_clear(THR_FLG_RTLD);
33237c478bd9Sstevel@tonic-gate 	}
33247c478bd9Sstevel@tonic-gate }
33257c478bd9Sstevel@tonic-gate 
33267c478bd9Sstevel@tonic-gate int
332760758829Srie callable(Rt_map *clmp, Rt_map *dlmp, Grp_hdl *ghp, uint_t slflags)
33287c478bd9Sstevel@tonic-gate {
3329cce0e03bSab 	APlist		*calp, *dalp;
3330cce0e03bSab 	Aliste		idx1, idx2;
3331cce0e03bSab 	Grp_hdl		*ghp1, *ghp2;
33327c478bd9Sstevel@tonic-gate 
33337c478bd9Sstevel@tonic-gate 	/*
33347c478bd9Sstevel@tonic-gate 	 * An object can always find symbols within itself.
33357c478bd9Sstevel@tonic-gate 	 */
33367c478bd9Sstevel@tonic-gate 	if (clmp == dlmp)
33377c478bd9Sstevel@tonic-gate 		return (1);
33387c478bd9Sstevel@tonic-gate 
333960758829Srie 	/*
334060758829Srie 	 * The search for a singleton must look in every loaded object.
334160758829Srie 	 */
334260758829Srie 	if (slflags & LKUP_SINGLETON)
334360758829Srie 		return (1);
334460758829Srie 
33457c478bd9Sstevel@tonic-gate 	/*
33467c478bd9Sstevel@tonic-gate 	 * Don't allow an object to bind to an object that is being deleted
33477c478bd9Sstevel@tonic-gate 	 * unless the binder is also being deleted.
33487c478bd9Sstevel@tonic-gate 	 */
33497c478bd9Sstevel@tonic-gate 	if ((FLAGS(dlmp) & FLG_RT_DELETE) &&
33507c478bd9Sstevel@tonic-gate 	    ((FLAGS(clmp) & FLG_RT_DELETE) == 0))
33517c478bd9Sstevel@tonic-gate 		return (0);
33527c478bd9Sstevel@tonic-gate 
33537c478bd9Sstevel@tonic-gate 	/*
33547c478bd9Sstevel@tonic-gate 	 * An object with world access can always bind to an object with global
33557c478bd9Sstevel@tonic-gate 	 * visibility.
33567c478bd9Sstevel@tonic-gate 	 */
33577c478bd9Sstevel@tonic-gate 	if ((MODE(clmp) & RTLD_WORLD) && (MODE(dlmp) & RTLD_GLOBAL))
33587c478bd9Sstevel@tonic-gate 		return (1);
33597c478bd9Sstevel@tonic-gate 
33607c478bd9Sstevel@tonic-gate 	/*
33617c478bd9Sstevel@tonic-gate 	 * An object with local access can only bind to an object that is a
33627c478bd9Sstevel@tonic-gate 	 * member of the same group.
33637c478bd9Sstevel@tonic-gate 	 */
33647c478bd9Sstevel@tonic-gate 	if (((MODE(clmp) & RTLD_GROUP) == 0) ||
3365cce0e03bSab 	    ((calp = GROUPS(clmp)) == NULL) || ((dalp = GROUPS(dlmp)) == NULL))
33667c478bd9Sstevel@tonic-gate 		return (0);
33677c478bd9Sstevel@tonic-gate 
33687c478bd9Sstevel@tonic-gate 	/*
33697c478bd9Sstevel@tonic-gate 	 * Traverse the list of groups the caller is a part of.
33707c478bd9Sstevel@tonic-gate 	 */
3371cce0e03bSab 	for (APLIST_TRAVERSE(calp, idx1, ghp1)) {
33727c478bd9Sstevel@tonic-gate 		/*
33737c478bd9Sstevel@tonic-gate 		 * If we're testing for the ability of two objects to bind to
33747c478bd9Sstevel@tonic-gate 		 * each other regardless of a specific group, ignore that group.
33757c478bd9Sstevel@tonic-gate 		 */
3376cce0e03bSab 		if (ghp && (ghp1 == ghp))
33777c478bd9Sstevel@tonic-gate 			continue;
33787c478bd9Sstevel@tonic-gate 
33797c478bd9Sstevel@tonic-gate 		/*
33807c478bd9Sstevel@tonic-gate 		 * Traverse the list of groups the destination is a part of.
33817c478bd9Sstevel@tonic-gate 		 */
3382cce0e03bSab 		for (APLIST_TRAVERSE(dalp, idx2, ghp2)) {
3383efb9e8b8Srie 			Grp_desc	*gdp;
3384cce0e03bSab 			Aliste		idx3;
3385efb9e8b8Srie 
3386cce0e03bSab 			if (ghp1 != ghp2)
3387efb9e8b8Srie 				continue;
3388efb9e8b8Srie 
3389efb9e8b8Srie 			/*
3390efb9e8b8Srie 			 * Make sure the relationship between the destination
3391efb9e8b8Srie 			 * and the caller provide symbols for relocation.
3392efb9e8b8Srie 			 * Parents are maintained as callers, but unless the
3393efb9e8b8Srie 			 * destination object was opened with RTLD_PARENT, the
3394efb9e8b8Srie 			 * parent doesn't provide symbols for the destination
3395efb9e8b8Srie 			 * to relocate against.
3396efb9e8b8Srie 			 */
3397cce0e03bSab 			for (ALIST_TRAVERSE(ghp2->gh_depends, idx3, gdp)) {
3398efb9e8b8Srie 				if (dlmp != gdp->gd_depend)
3399efb9e8b8Srie 					continue;
3400efb9e8b8Srie 
3401efb9e8b8Srie 				if (gdp->gd_flags & GPD_RELOC)
3402efb9e8b8Srie 					return (1);
3403efb9e8b8Srie 			}
34047c478bd9Sstevel@tonic-gate 		}
34057c478bd9Sstevel@tonic-gate 	}
34067c478bd9Sstevel@tonic-gate 	return (0);
34077c478bd9Sstevel@tonic-gate }
34087c478bd9Sstevel@tonic-gate 
34097c478bd9Sstevel@tonic-gate /*
34107c478bd9Sstevel@tonic-gate  * Initialize the environ symbol.  Traditionally this is carried out by the crt
34117c478bd9Sstevel@tonic-gate  * code prior to jumping to main.  However, init sections get fired before this
34127c478bd9Sstevel@tonic-gate  * variable is initialized, so ld.so.1 sets this directly from the AUX vector
34137c478bd9Sstevel@tonic-gate  * information.  In addition, a process may have multiple link-maps (ld.so.1's
34147c478bd9Sstevel@tonic-gate  * debugging and preloading objects), and link auditing, and each may need an
34157c478bd9Sstevel@tonic-gate  * environ variable set.
34167c478bd9Sstevel@tonic-gate  *
34177c478bd9Sstevel@tonic-gate  * This routine is called after a relocation() pass, and thus provides for:
34187c478bd9Sstevel@tonic-gate  *
34197c478bd9Sstevel@tonic-gate  *  o	setting environ on the main link-map after the initial application and
34207c478bd9Sstevel@tonic-gate  *	its dependencies have been established.  Typically environ lives in the
34217c478bd9Sstevel@tonic-gate  *	application (provided by its crt), but in older applications it might
34227c478bd9Sstevel@tonic-gate  *	be in libc.  Who knows what's expected of applications not built on
34237c478bd9Sstevel@tonic-gate  *	Solaris.
34247c478bd9Sstevel@tonic-gate  *
34257c478bd9Sstevel@tonic-gate  *  o	after loading a new shared object.  We can add shared objects to various
34267c478bd9Sstevel@tonic-gate  *	link-maps, and any link-map dependencies requiring getopt() require
34277c478bd9Sstevel@tonic-gate  *	their own environ.  In addition, lazy loading might bring in the
342841072f3cSrie  *	supplier of environ (libc used to be a lazy loading candidate) after
342941072f3cSrie  *	the link-map has been established and other objects are present.
34307c478bd9Sstevel@tonic-gate  *
34317c478bd9Sstevel@tonic-gate  * This routine handles all these scenarios, without adding unnecessary overhead
34327c478bd9Sstevel@tonic-gate  * to ld.so.1.
34337c478bd9Sstevel@tonic-gate  */
34347c478bd9Sstevel@tonic-gate void
34357c478bd9Sstevel@tonic-gate set_environ(Lm_list *lml)
34367c478bd9Sstevel@tonic-gate {
343775e7992aSrie 	Rt_map		*dlmp;
343875e7992aSrie 	Sym		*sym;
34397c478bd9Sstevel@tonic-gate 	Slookup		sl;
34407c478bd9Sstevel@tonic-gate 	uint_t		binfo;
34417c478bd9Sstevel@tonic-gate 
344275e7992aSrie 	/*
344375e7992aSrie 	 * Initialize the symbol lookup data structure.
344475e7992aSrie 	 */
344575e7992aSrie 	SLOOKUP_INIT(sl, MSG_ORIG(MSG_SYM_ENVIRON), lml->lm_head, lml->lm_head,
344675e7992aSrie 	    ld_entry_cnt, 0, 0, 0, 0, LKUP_WEAK);
34477c478bd9Sstevel@tonic-gate 
34487c478bd9Sstevel@tonic-gate 	if (sym = LM_LOOKUP_SYM(lml->lm_head)(&sl, &dlmp, &binfo)) {
344941072f3cSrie 		lml->lm_environ = (char ***)sym->st_value;
34507c478bd9Sstevel@tonic-gate 
34517c478bd9Sstevel@tonic-gate 		if (!(FLAGS(dlmp) & FLG_RT_FIXED))
345241072f3cSrie 			lml->lm_environ =
345341072f3cSrie 			    (char ***)((uintptr_t)lml->lm_environ +
345441072f3cSrie 			    (uintptr_t)ADDR(dlmp));
345541072f3cSrie 		*(lml->lm_environ) = (char **)environ;
34567c478bd9Sstevel@tonic-gate 		lml->lm_flags |= LML_FLG_ENVIRON;
34577c478bd9Sstevel@tonic-gate 	}
34587c478bd9Sstevel@tonic-gate }
34597c478bd9Sstevel@tonic-gate 
34607c478bd9Sstevel@tonic-gate /*
34617c478bd9Sstevel@tonic-gate  * Determine whether we have a secure executable.  Uid and gid information
34627c478bd9Sstevel@tonic-gate  * can be passed to us via the aux vector, however if these values are -1
34637c478bd9Sstevel@tonic-gate  * then use the appropriate system call to obtain them.
34647c478bd9Sstevel@tonic-gate  *
34657c478bd9Sstevel@tonic-gate  *  o	If the user is the root they can do anything
34667c478bd9Sstevel@tonic-gate  *
34677c478bd9Sstevel@tonic-gate  *  o	If the real and effective uid's don't match, or the real and
34687c478bd9Sstevel@tonic-gate  *	effective gid's don't match then this is determined to be a `secure'
34697c478bd9Sstevel@tonic-gate  *	application.
34707c478bd9Sstevel@tonic-gate  *
34717c478bd9Sstevel@tonic-gate  * This function is called prior to any dependency processing (see _setup.c).
34727c478bd9Sstevel@tonic-gate  * Any secure setting will remain in effect for the life of the process.
34737c478bd9Sstevel@tonic-gate  */
34747c478bd9Sstevel@tonic-gate void
34757c478bd9Sstevel@tonic-gate security(uid_t uid, uid_t euid, gid_t gid, gid_t egid, int auxflags)
34767c478bd9Sstevel@tonic-gate {
34777c478bd9Sstevel@tonic-gate #ifdef AT_SUN_AUXFLAGS
34787c478bd9Sstevel@tonic-gate 	if (auxflags != -1) {
34797c478bd9Sstevel@tonic-gate 		if ((auxflags & AF_SUN_SETUGID) != 0)
34807c478bd9Sstevel@tonic-gate 			rtld_flags |= RT_FL_SECURE;
34817c478bd9Sstevel@tonic-gate 		return;
34827c478bd9Sstevel@tonic-gate 	}
34837c478bd9Sstevel@tonic-gate #endif
3484a953e2b1Srie 	if (uid == (uid_t)-1)
34857c478bd9Sstevel@tonic-gate 		uid = getuid();
34867c478bd9Sstevel@tonic-gate 	if (uid) {
3487a953e2b1Srie 		if (euid == (uid_t)-1)
34887c478bd9Sstevel@tonic-gate 			euid = geteuid();
34897c478bd9Sstevel@tonic-gate 		if (uid != euid)
34907c478bd9Sstevel@tonic-gate 			rtld_flags |= RT_FL_SECURE;
34917c478bd9Sstevel@tonic-gate 		else {
3492a953e2b1Srie 			if (gid == (gid_t)-1)
34937c478bd9Sstevel@tonic-gate 				gid = getgid();
3494a953e2b1Srie 			if (egid == (gid_t)-1)
34957c478bd9Sstevel@tonic-gate 				egid = getegid();
34967c478bd9Sstevel@tonic-gate 			if (gid != egid)
34977c478bd9Sstevel@tonic-gate 				rtld_flags |= RT_FL_SECURE;
34987c478bd9Sstevel@tonic-gate 		}
34997c478bd9Sstevel@tonic-gate 	}
35007c478bd9Sstevel@tonic-gate }
35017c478bd9Sstevel@tonic-gate 
35027c478bd9Sstevel@tonic-gate /*
35037c478bd9Sstevel@tonic-gate  * _REENTRANT code gets errno redefined to a function so provide for return
35047c478bd9Sstevel@tonic-gate  * of the thread errno if applicable.  This has no meaning in ld.so.1 which
35057c478bd9Sstevel@tonic-gate  * is basically singled threaded.  Provide the interface for our dependencies.
35067c478bd9Sstevel@tonic-gate  */
35077c478bd9Sstevel@tonic-gate #undef errno
35087c478bd9Sstevel@tonic-gate #pragma weak _private___errno = ___errno
35097c478bd9Sstevel@tonic-gate int *
35107c478bd9Sstevel@tonic-gate ___errno()
35117c478bd9Sstevel@tonic-gate {
35127c478bd9Sstevel@tonic-gate 	extern	int	errno;
35137c478bd9Sstevel@tonic-gate 
35147c478bd9Sstevel@tonic-gate 	return (&errno);
35157c478bd9Sstevel@tonic-gate }
35167c478bd9Sstevel@tonic-gate 
35177c478bd9Sstevel@tonic-gate /*
35187c478bd9Sstevel@tonic-gate  * The interface with the c library which is supplied through libdl.so.1.
35197c478bd9Sstevel@tonic-gate  * A non-null argument allows a function pointer array to be passed to us which
35207c478bd9Sstevel@tonic-gate  * is used to re-initialize the linker libc table.
35217c478bd9Sstevel@tonic-gate  */
35227c478bd9Sstevel@tonic-gate void
35237c478bd9Sstevel@tonic-gate _ld_libc(void * ptr)
35247c478bd9Sstevel@tonic-gate {
35257c478bd9Sstevel@tonic-gate 	get_lcinterface(_caller(caller(), CL_EXECDEF), (Lc_interface *)ptr);
35267c478bd9Sstevel@tonic-gate }
35277c478bd9Sstevel@tonic-gate 
35287c478bd9Sstevel@tonic-gate /*
35297c478bd9Sstevel@tonic-gate  * Determine whether a symbol name should be demangled.
35307c478bd9Sstevel@tonic-gate  */
35317c478bd9Sstevel@tonic-gate const char *
35327c478bd9Sstevel@tonic-gate demangle(const char *name)
35337c478bd9Sstevel@tonic-gate {
35347c478bd9Sstevel@tonic-gate 	if (rtld_flags & RT_FL_DEMANGLE)
35355aefb655Srie 		return (conv_demangle_name(name));
35367c478bd9Sstevel@tonic-gate 	else
35377c478bd9Sstevel@tonic-gate 		return (name);
35387c478bd9Sstevel@tonic-gate }
3539