xref: /illumos-gate/usr/src/cmd/sgs/rtld/common/util.c (revision 08278a5e)
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 /*
2320272c2eSAli Bahrami  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
247c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
257c478bd9Sstevel@tonic-gate  */
267257d1b4Sraf 
277257d1b4Sraf /*
287257d1b4Sraf  *	Copyright (c) 1988 AT&T
297257d1b4Sraf  *	  All Rights Reserved
307257d1b4Sraf  */
317257d1b4Sraf 
327c478bd9Sstevel@tonic-gate /*
337c478bd9Sstevel@tonic-gate  * Utility routines for run-time linker.  some are duplicated here from libc
347c478bd9Sstevel@tonic-gate  * (with different names) to avoid name space collisions.
357c478bd9Sstevel@tonic-gate  */
36*08278a5eSRod Evans #include	<sys/systeminfo.h>
377c478bd9Sstevel@tonic-gate #include	<stdio.h>
382017c965SRod Evans #include	<sys/time.h>
397c478bd9Sstevel@tonic-gate #include	<sys/types.h>
407c478bd9Sstevel@tonic-gate #include	<sys/mman.h>
417c478bd9Sstevel@tonic-gate #include	<sys/lwp.h>
427c478bd9Sstevel@tonic-gate #include	<sys/debug.h>
437c478bd9Sstevel@tonic-gate #include	<stdarg.h>
447c478bd9Sstevel@tonic-gate #include	<fcntl.h>
457c478bd9Sstevel@tonic-gate #include	<string.h>
467c478bd9Sstevel@tonic-gate #include	<dlfcn.h>
477c478bd9Sstevel@tonic-gate #include	<unistd.h>
487c478bd9Sstevel@tonic-gate #include	<stdlib.h>
497c478bd9Sstevel@tonic-gate #include	<sys/auxv.h>
5056deab07SRod Evans #include	<limits.h>
515aefb655Srie #include	<debug.h>
525aefb655Srie #include	<conv.h>
537c478bd9Sstevel@tonic-gate #include	"_rtld.h"
547c478bd9Sstevel@tonic-gate #include	"_audit.h"
5510a4fa49Srie #include	"_elf.h"
567c478bd9Sstevel@tonic-gate #include	"msg.h"
577c478bd9Sstevel@tonic-gate 
587c478bd9Sstevel@tonic-gate static int ld_flags_env(const char *, Word *, Word *, uint_t, int);
597c478bd9Sstevel@tonic-gate 
607c478bd9Sstevel@tonic-gate /*
617c478bd9Sstevel@tonic-gate  * Null function used as place where a debugger can set a breakpoint.
627c478bd9Sstevel@tonic-gate  */
637c478bd9Sstevel@tonic-gate void
645aefb655Srie rtld_db_dlactivity(Lm_list *lml)
657c478bd9Sstevel@tonic-gate {
665aefb655Srie 	DBG_CALL(Dbg_util_dbnotify(lml, r_debug.rtd_rdebug.r_rdevent,
675aefb655Srie 	    r_debug.rtd_rdebug.r_state));
687c478bd9Sstevel@tonic-gate }
697c478bd9Sstevel@tonic-gate 
707c478bd9Sstevel@tonic-gate /*
717c478bd9Sstevel@tonic-gate  * Null function used as place where debugger can set a pre .init
727c478bd9Sstevel@tonic-gate  * processing breakpoint.
737c478bd9Sstevel@tonic-gate  */
747c478bd9Sstevel@tonic-gate void
755aefb655Srie rtld_db_preinit(Lm_list *lml)
767c478bd9Sstevel@tonic-gate {
775aefb655Srie 	DBG_CALL(Dbg_util_dbnotify(lml, r_debug.rtd_rdebug.r_rdevent,
785aefb655Srie 	    r_debug.rtd_rdebug.r_state));
797c478bd9Sstevel@tonic-gate }
807c478bd9Sstevel@tonic-gate 
817c478bd9Sstevel@tonic-gate /*
827c478bd9Sstevel@tonic-gate  * Null function used as place where debugger can set a post .init
837c478bd9Sstevel@tonic-gate  * processing breakpoint.
847c478bd9Sstevel@tonic-gate  */
857c478bd9Sstevel@tonic-gate void
865aefb655Srie rtld_db_postinit(Lm_list *lml)
877c478bd9Sstevel@tonic-gate {
885aefb655Srie 	DBG_CALL(Dbg_util_dbnotify(lml, r_debug.rtd_rdebug.r_rdevent,
895aefb655Srie 	    r_debug.rtd_rdebug.r_state));
907c478bd9Sstevel@tonic-gate }
917c478bd9Sstevel@tonic-gate 
927c478bd9Sstevel@tonic-gate /*
937c478bd9Sstevel@tonic-gate  * Debugger Event Notification
947c478bd9Sstevel@tonic-gate  *
957c478bd9Sstevel@tonic-gate  * This function centralizes all debugger event notification (ala rtld_db).
967c478bd9Sstevel@tonic-gate  *
977c478bd9Sstevel@tonic-gate  * There's a simple intent, focused on insuring the primary link-map control
987c478bd9Sstevel@tonic-gate  * list (or each link-map list) is consistent, and the indication that objects
997c478bd9Sstevel@tonic-gate  * have been added or deleted from this list.  Although an RD_ADD and RD_DELETE
1007c478bd9Sstevel@tonic-gate  * event are posted for each of these, most debuggers don't care, as their
1017c478bd9Sstevel@tonic-gate  * view is that these events simply convey an "inconsistent" state.
1027c478bd9Sstevel@tonic-gate  *
1037c478bd9Sstevel@tonic-gate  * We also don't want to trigger multiple RD_ADD/RD_DELETE events any time we
1047c478bd9Sstevel@tonic-gate  * enter ld.so.1.
1057c478bd9Sstevel@tonic-gate  *
1067c478bd9Sstevel@tonic-gate  * With auditors, we may be in the process of relocating a collection of
1077c478bd9Sstevel@tonic-gate  * objects, and will leave() ld.so.1 to call the auditor.  At this point we
1087c478bd9Sstevel@tonic-gate  * must indicate an RD_CONSISTENT event, but librtld_db will not report an
1097c478bd9Sstevel@tonic-gate  * object to the debuggers until relocation processing has been completed on it.
1107c478bd9Sstevel@tonic-gate  * To allow for the collection of these objects that are pending relocation, an
1117c478bd9Sstevel@tonic-gate  * RD_ADD event is set after completing a series of relocations on the primary
1127c478bd9Sstevel@tonic-gate  * link-map control list.
1137c478bd9Sstevel@tonic-gate  *
1147c478bd9Sstevel@tonic-gate  * Set an RD_ADD/RD_DELETE event and indicate that an RD_CONSISTENT event is
1157c478bd9Sstevel@tonic-gate  * required later (LML_FLG_DBNOTIF):
1167c478bd9Sstevel@tonic-gate  *
1177c478bd9Sstevel@tonic-gate  *  i	the first time we add or delete an object to the primary link-map
1187c478bd9Sstevel@tonic-gate  *	control list.
1197c478bd9Sstevel@tonic-gate  *  ii	the first time we move a secondary link-map control list to the primary
1207c478bd9Sstevel@tonic-gate  *	link-map control list (effectively, this is like adding a group of
1217c478bd9Sstevel@tonic-gate  *	objects to the primary link-map control list).
1227c478bd9Sstevel@tonic-gate  *
1237c478bd9Sstevel@tonic-gate  * Set an RD_CONSISTENT event when it is required (LML_FLG_DBNOTIF is set) and
1247c478bd9Sstevel@tonic-gate  *
1257c478bd9Sstevel@tonic-gate  *  i	each time we leave the runtime linker.
1267c478bd9Sstevel@tonic-gate  */
1277c478bd9Sstevel@tonic-gate void
1287c478bd9Sstevel@tonic-gate rd_event(Lm_list *lml, rd_event_e event, r_state_e state)
1297c478bd9Sstevel@tonic-gate {
13010a4fa49Srie 	void	(*fptr)(Lm_list *);
1317c478bd9Sstevel@tonic-gate 
1327c478bd9Sstevel@tonic-gate 	switch (event) {
1337c478bd9Sstevel@tonic-gate 	case RD_PREINIT:
1347c478bd9Sstevel@tonic-gate 		fptr = rtld_db_preinit;
1357c478bd9Sstevel@tonic-gate 		break;
1367c478bd9Sstevel@tonic-gate 	case RD_POSTINIT:
1377c478bd9Sstevel@tonic-gate 		fptr = rtld_db_postinit;
1387c478bd9Sstevel@tonic-gate 		break;
1397c478bd9Sstevel@tonic-gate 	case RD_DLACTIVITY:
1407c478bd9Sstevel@tonic-gate 		switch (state) {
1417c478bd9Sstevel@tonic-gate 		case RT_CONSISTENT:
1427c478bd9Sstevel@tonic-gate 			lml->lm_flags &= ~LML_FLG_DBNOTIF;
1437c478bd9Sstevel@tonic-gate 
1447c478bd9Sstevel@tonic-gate 			/*
1457c478bd9Sstevel@tonic-gate 			 * Do we need to send a notification?
1467c478bd9Sstevel@tonic-gate 			 */
1477c478bd9Sstevel@tonic-gate 			if ((rtld_flags & RT_FL_DBNOTIF) == 0)
1487c478bd9Sstevel@tonic-gate 				return;
1497c478bd9Sstevel@tonic-gate 			rtld_flags &= ~RT_FL_DBNOTIF;
1507c478bd9Sstevel@tonic-gate 			break;
1517c478bd9Sstevel@tonic-gate 		case RT_ADD:
1527c478bd9Sstevel@tonic-gate 		case RT_DELETE:
1537c478bd9Sstevel@tonic-gate 			lml->lm_flags |= LML_FLG_DBNOTIF;
1547c478bd9Sstevel@tonic-gate 
1557c478bd9Sstevel@tonic-gate 			/*
1567c478bd9Sstevel@tonic-gate 			 * If we are already in an inconsistent state, no
1577c478bd9Sstevel@tonic-gate 			 * notification is required.
1587c478bd9Sstevel@tonic-gate 			 */
1597c478bd9Sstevel@tonic-gate 			if (rtld_flags & RT_FL_DBNOTIF)
1607c478bd9Sstevel@tonic-gate 				return;
1617c478bd9Sstevel@tonic-gate 			rtld_flags |= RT_FL_DBNOTIF;
1627c478bd9Sstevel@tonic-gate 			break;
1637c478bd9Sstevel@tonic-gate 		};
1647c478bd9Sstevel@tonic-gate 		fptr = rtld_db_dlactivity;
1657c478bd9Sstevel@tonic-gate 		break;
1667c478bd9Sstevel@tonic-gate 	default:
1677c478bd9Sstevel@tonic-gate 		/*
1687c478bd9Sstevel@tonic-gate 		 * RD_NONE - do nothing
1697c478bd9Sstevel@tonic-gate 		 */
1707c478bd9Sstevel@tonic-gate 		break;
1717c478bd9Sstevel@tonic-gate 	};
1727c478bd9Sstevel@tonic-gate 
1737c478bd9Sstevel@tonic-gate 	/*
1747c478bd9Sstevel@tonic-gate 	 * Set event state and call 'notification' function.
1757c478bd9Sstevel@tonic-gate 	 *
1767c478bd9Sstevel@tonic-gate 	 * The debugging clients have previously been told about these
1777c478bd9Sstevel@tonic-gate 	 * notification functions and have set breakpoints on them if they
1787c478bd9Sstevel@tonic-gate 	 * are interested in the notification.
1797c478bd9Sstevel@tonic-gate 	 */
1807c478bd9Sstevel@tonic-gate 	r_debug.rtd_rdebug.r_state = state;
1817c478bd9Sstevel@tonic-gate 	r_debug.rtd_rdebug.r_rdevent = event;
1825aefb655Srie 	fptr(lml);
1837c478bd9Sstevel@tonic-gate 	r_debug.rtd_rdebug.r_rdevent = RD_NONE;
1847c478bd9Sstevel@tonic-gate }
1857c478bd9Sstevel@tonic-gate 
18602ca3e02Srie #if	defined(__sparc) || defined(__x86)
1877c478bd9Sstevel@tonic-gate /*
1887c478bd9Sstevel@tonic-gate  * Stack Cleanup.
1897c478bd9Sstevel@tonic-gate  *
1907c478bd9Sstevel@tonic-gate  * This function is invoked to 'remove' arguments that were passed in on the
1917c478bd9Sstevel@tonic-gate  * stack.  This is most likely if ld.so.1 was invoked directly.  In that case
1927c478bd9Sstevel@tonic-gate  * we want to remove ld.so.1 as well as it's arguments from the argv[] array.
1937c478bd9Sstevel@tonic-gate  * Which means we then need to slide everything above it on the stack down
1947c478bd9Sstevel@tonic-gate  * accordingly.
1957c478bd9Sstevel@tonic-gate  *
19602ca3e02Srie  * While the stack layout is platform specific - it just so happens that __x86,
19702ca3e02Srie  * and __sparc platforms share the following initial stack layout.
1987c478bd9Sstevel@tonic-gate  *
1997c478bd9Sstevel@tonic-gate  *	!_______________________!  high addresses
2007c478bd9Sstevel@tonic-gate  *	!			!
2017c478bd9Sstevel@tonic-gate  *	!	Information	!
2027c478bd9Sstevel@tonic-gate  *	!	Block		!
2037c478bd9Sstevel@tonic-gate  *	!	(size varies)	!
2047c478bd9Sstevel@tonic-gate  *	!_______________________!
2057c478bd9Sstevel@tonic-gate  *	!	0 word		!
2067c478bd9Sstevel@tonic-gate  *	!_______________________!
2077c478bd9Sstevel@tonic-gate  *	!	Auxiliary	!
2087c478bd9Sstevel@tonic-gate  *	!	vector		!
2097c478bd9Sstevel@tonic-gate  *	!	2 word entries	!
2107c478bd9Sstevel@tonic-gate  *	!			!
2117c478bd9Sstevel@tonic-gate  *	!_______________________!
2127c478bd9Sstevel@tonic-gate  *	!	0 word		!
2137c478bd9Sstevel@tonic-gate  *	!_______________________!
2147c478bd9Sstevel@tonic-gate  *	!	Environment	!
2157c478bd9Sstevel@tonic-gate  *	!	pointers	!
2167c478bd9Sstevel@tonic-gate  *	!	...		!
2177c478bd9Sstevel@tonic-gate  *	!	(one word each)	!
2187c478bd9Sstevel@tonic-gate  *	!_______________________!
2197c478bd9Sstevel@tonic-gate  *	!	0 word		!
2207c478bd9Sstevel@tonic-gate  *	!_______________________!
2217c478bd9Sstevel@tonic-gate  *	!	Argument	! low addresses
2227c478bd9Sstevel@tonic-gate  *	!	pointers	!
2237c478bd9Sstevel@tonic-gate  *	!	Argc words	!
2247c478bd9Sstevel@tonic-gate  *	!_______________________!
2257c478bd9Sstevel@tonic-gate  *	!			!
2267c478bd9Sstevel@tonic-gate  *	!	Argc		!
2277c478bd9Sstevel@tonic-gate  *	!_______________________!
2287c478bd9Sstevel@tonic-gate  *	!	...		!
2297c478bd9Sstevel@tonic-gate  *
2307c478bd9Sstevel@tonic-gate  */
2317c478bd9Sstevel@tonic-gate static void
23241072f3cSrie stack_cleanup(char **argv, char ***envp, auxv_t **auxv, int rmcnt)
2337c478bd9Sstevel@tonic-gate {
23441072f3cSrie 	int		ndx;
2357c478bd9Sstevel@tonic-gate 	long		*argc;
23641072f3cSrie 	char		**oargv, **nargv;
23741072f3cSrie 	char		**oenvp, **nenvp;
23841072f3cSrie 	auxv_t		*oauxv, *nauxv;
2397c478bd9Sstevel@tonic-gate 
2407c478bd9Sstevel@tonic-gate 	/*
24141072f3cSrie 	 * Slide ARGV[] and update argc.  The argv pointer remains the same,
24241072f3cSrie 	 * however slide the applications arguments over the arguments to
24341072f3cSrie 	 * ld.so.1.
2447c478bd9Sstevel@tonic-gate 	 */
24541072f3cSrie 	nargv = &argv[0];
24641072f3cSrie 	oargv = &argv[rmcnt];
24741072f3cSrie 
24841072f3cSrie 	for (ndx = 0; oargv[ndx]; ndx++)
24941072f3cSrie 		nargv[ndx] = oargv[ndx];
25041072f3cSrie 	nargv[ndx] = oargv[ndx];
25141072f3cSrie 
25241072f3cSrie 	argc = (long *)((uintptr_t)argv - sizeof (long *));
2537c478bd9Sstevel@tonic-gate 	*argc -= rmcnt;
2547c478bd9Sstevel@tonic-gate 
2557c478bd9Sstevel@tonic-gate 	/*
25641072f3cSrie 	 * Slide ENVP[], and update the environment array pointer.
2577c478bd9Sstevel@tonic-gate 	 */
25841072f3cSrie 	ndx++;
25941072f3cSrie 	nenvp = &nargv[ndx];
26041072f3cSrie 	oenvp = &oargv[ndx];
26141072f3cSrie 	*envp = nenvp;
26241072f3cSrie 
26341072f3cSrie 	for (ndx = 0; oenvp[ndx]; ndx++)
26441072f3cSrie 		nenvp[ndx] = oenvp[ndx];
26541072f3cSrie 	nenvp[ndx] = oenvp[ndx];
2667c478bd9Sstevel@tonic-gate 
2677c478bd9Sstevel@tonic-gate 	/*
26841072f3cSrie 	 * Slide AUXV[], and update the aux vector pointer.
2697c478bd9Sstevel@tonic-gate 	 */
27041072f3cSrie 	ndx++;
27141072f3cSrie 	nauxv = (auxv_t *)&nenvp[ndx];
27241072f3cSrie 	oauxv = (auxv_t *)&oenvp[ndx];
27341072f3cSrie 	*auxv = nauxv;
27441072f3cSrie 
27541072f3cSrie 	for (ndx = 0; (oauxv[ndx].a_type != AT_NULL); ndx++)
27641072f3cSrie 		nauxv[ndx] = oauxv[ndx];
27741072f3cSrie 	nauxv[ndx] = oauxv[ndx];
2787c478bd9Sstevel@tonic-gate }
2797c478bd9Sstevel@tonic-gate #else
2807c478bd9Sstevel@tonic-gate /*
2817c478bd9Sstevel@tonic-gate  * Verify that the above routine is appropriate for any new platforms.
2827c478bd9Sstevel@tonic-gate  */
2837c478bd9Sstevel@tonic-gate #error	unsupported architecture!
2847c478bd9Sstevel@tonic-gate #endif
2857c478bd9Sstevel@tonic-gate 
2867c478bd9Sstevel@tonic-gate /*
28741072f3cSrie  * The only command line argument recognized is -e, followed by a runtime
28841072f3cSrie  * linker environment variable.
2897c478bd9Sstevel@tonic-gate  */
2907c478bd9Sstevel@tonic-gate int
29141072f3cSrie rtld_getopt(char **argv, char ***envp, auxv_t **auxv, Word *lmflags,
29241072f3cSrie     Word *lmtflags, int aout)
2937c478bd9Sstevel@tonic-gate {
29441072f3cSrie 	int	ndx;
2957c478bd9Sstevel@tonic-gate 
29641072f3cSrie 	for (ndx = 1; argv[ndx]; ndx++) {
2977c478bd9Sstevel@tonic-gate 		char	*str;
2987c478bd9Sstevel@tonic-gate 
29941072f3cSrie 		if (argv[ndx][0] != '-')
3007c478bd9Sstevel@tonic-gate 			break;
3017c478bd9Sstevel@tonic-gate 
30241072f3cSrie 		if (argv[ndx][1] == '\0') {
30341072f3cSrie 			ndx++;
3047c478bd9Sstevel@tonic-gate 			break;
3057c478bd9Sstevel@tonic-gate 		}
3067c478bd9Sstevel@tonic-gate 
30741072f3cSrie 		if (argv[ndx][1] != 'e')
30841072f3cSrie 			return (1);
3097c478bd9Sstevel@tonic-gate 
31041072f3cSrie 		if (argv[ndx][2] == '\0') {
31141072f3cSrie 			ndx++;
31241072f3cSrie 			if (argv[ndx] == NULL)
31341072f3cSrie 				return (1);
31441072f3cSrie 			str = argv[ndx];
3157c478bd9Sstevel@tonic-gate 		} else
31641072f3cSrie 			str = &argv[ndx][2];
3177c478bd9Sstevel@tonic-gate 
31841072f3cSrie 		/*
31941072f3cSrie 		 * If the environment variable starts with LD_, strip the LD_.
32041072f3cSrie 		 * Otherwise, take things as is.
32141072f3cSrie 		 */
32241072f3cSrie 		if ((str[0] == 'L') && (str[1] == 'D') && (str[2] == '_') &&
32341072f3cSrie 		    (str[3] != '\0'))
32441072f3cSrie 			str += 3;
3257c478bd9Sstevel@tonic-gate 		if (ld_flags_env(str, lmflags, lmtflags, 0, aout) == 1)
3267c478bd9Sstevel@tonic-gate 			return (1);
3277c478bd9Sstevel@tonic-gate 	}
3287c478bd9Sstevel@tonic-gate 
32941072f3cSrie 	/*
33041072f3cSrie 	 * Make sure an object file has been specified.
33141072f3cSrie 	 */
33243d7826aSRod Evans 	if (argv[ndx] == NULL)
3337c478bd9Sstevel@tonic-gate 		return (1);
3347c478bd9Sstevel@tonic-gate 
3357c478bd9Sstevel@tonic-gate 	/*
3367c478bd9Sstevel@tonic-gate 	 * Having gotten the arguments, clean ourselves off of the stack.
3377c478bd9Sstevel@tonic-gate 	 */
33841072f3cSrie 	stack_cleanup(argv, envp, auxv, ndx);
3397c478bd9Sstevel@tonic-gate 	return (0);
3407c478bd9Sstevel@tonic-gate }
3417c478bd9Sstevel@tonic-gate 
3427c478bd9Sstevel@tonic-gate /*
3439aa23310Srie  * Compare function for PathNode AVL tree.
3447c478bd9Sstevel@tonic-gate  */
3457c478bd9Sstevel@tonic-gate static int
3469aa23310Srie pnavl_compare(const void *n1, const void *n2)
3477c478bd9Sstevel@tonic-gate {
3487c478bd9Sstevel@tonic-gate 	uint_t		hash1, hash2;
3497c478bd9Sstevel@tonic-gate 	const char	*st1, *st2;
3507c478bd9Sstevel@tonic-gate 	int		rc;
3517c478bd9Sstevel@tonic-gate 
3529aa23310Srie 	hash1 = ((PathNode *)n1)->pn_hash;
3539aa23310Srie 	hash2 = ((PathNode *)n2)->pn_hash;
3547c478bd9Sstevel@tonic-gate 
3557c478bd9Sstevel@tonic-gate 	if (hash1 > hash2)
3567c478bd9Sstevel@tonic-gate 		return (1);
3577c478bd9Sstevel@tonic-gate 	if (hash1 < hash2)
3587c478bd9Sstevel@tonic-gate 		return (-1);
3597c478bd9Sstevel@tonic-gate 
3609aa23310Srie 	st1 = ((PathNode *)n1)->pn_name;
3619aa23310Srie 	st2 = ((PathNode *)n2)->pn_name;
3627c478bd9Sstevel@tonic-gate 
3637c478bd9Sstevel@tonic-gate 	rc = strcmp(st1, st2);
3647c478bd9Sstevel@tonic-gate 	if (rc > 0)
3657c478bd9Sstevel@tonic-gate 		return (1);
3667c478bd9Sstevel@tonic-gate 	if (rc < 0)
3677c478bd9Sstevel@tonic-gate 		return (-1);
3687c478bd9Sstevel@tonic-gate 	return (0);
3697c478bd9Sstevel@tonic-gate }
3707c478bd9Sstevel@tonic-gate 
3713dbfc803SRod Evans /*
3723dbfc803SRod Evans  * Create an AVL tree.
3733dbfc803SRod Evans  */
3743dbfc803SRod Evans static avl_tree_t *
3753dbfc803SRod Evans pnavl_create(size_t size)
3763dbfc803SRod Evans {
3773dbfc803SRod Evans 	avl_tree_t	*avlt;
3783dbfc803SRod Evans 
3793dbfc803SRod Evans 	if ((avlt = malloc(sizeof (avl_tree_t))) == NULL)
3803dbfc803SRod Evans 		return (NULL);
3813dbfc803SRod Evans 	avl_create(avlt, pnavl_compare, size, SGSOFFSETOF(PathNode, pn_avl));
3823dbfc803SRod Evans 	return (avlt);
3833dbfc803SRod Evans }
3843dbfc803SRod Evans 
385*08278a5eSRod Evans /*
386*08278a5eSRod Evans  * Determine whether a PathNode is recorded.
387*08278a5eSRod Evans  */
388*08278a5eSRod Evans int
389*08278a5eSRod Evans pnavl_recorded(avl_tree_t **pnavl, const char *name, uint_t hash,
390*08278a5eSRod Evans     avl_index_t *where)
391*08278a5eSRod Evans {
392*08278a5eSRod Evans 	PathNode	pn;
393*08278a5eSRod Evans 
394*08278a5eSRod Evans 	/*
395*08278a5eSRod Evans 	 * Create the avl tree if required.
396*08278a5eSRod Evans 	 */
397*08278a5eSRod Evans 	if ((*pnavl == NULL) &&
398*08278a5eSRod Evans 	    ((*pnavl = pnavl_create(sizeof (PathNode))) == NULL))
399*08278a5eSRod Evans 		return (0);
400*08278a5eSRod Evans 
401*08278a5eSRod Evans 	pn.pn_name = name;
402*08278a5eSRod Evans 	if ((pn.pn_hash = hash) == 0)
403*08278a5eSRod Evans 		pn.pn_hash = sgs_str_hash(name);
404*08278a5eSRod Evans 
405*08278a5eSRod Evans 	if (avl_find(*pnavl, &pn, where) == NULL)
406*08278a5eSRod Evans 		return (0);
407*08278a5eSRod Evans 
408*08278a5eSRod Evans 	return (1);
409*08278a5eSRod Evans }
410*08278a5eSRod Evans 
4117c478bd9Sstevel@tonic-gate /*
4129aa23310Srie  * Determine if a pathname has already been recorded on the full path name
4139aa23310Srie  * AVL tree.  This tree maintains a node for each path name that ld.so.1 has
4149aa23310Srie  * successfully loaded.  If the path name does not exist in this AVL tree, then
4159aa23310Srie  * the next insertion point is deposited in "where".  This value can be used by
4169aa23310Srie  * fpavl_insert() to expedite the insertion.
4177c478bd9Sstevel@tonic-gate  */
4187c478bd9Sstevel@tonic-gate Rt_map *
41956deab07SRod Evans fpavl_recorded(Lm_list *lml, const char *name, uint_t hash, avl_index_t *where)
4207c478bd9Sstevel@tonic-gate {
4219aa23310Srie 	FullPathNode	fpn, *fpnp;
4227c478bd9Sstevel@tonic-gate 
4237c478bd9Sstevel@tonic-gate 	/*
4247c478bd9Sstevel@tonic-gate 	 * Create the avl tree if required.
4257c478bd9Sstevel@tonic-gate 	 */
4263dbfc803SRod Evans 	if ((lml->lm_fpavl == NULL) &&
4273dbfc803SRod Evans 	    ((lml->lm_fpavl = pnavl_create(sizeof (FullPathNode))) == NULL))
4283dbfc803SRod Evans 		return (NULL);
4297c478bd9Sstevel@tonic-gate 
4309aa23310Srie 	fpn.fpn_node.pn_name = name;
43156deab07SRod Evans 	if ((fpn.fpn_node.pn_hash = hash) == 0)
43256deab07SRod Evans 		fpn.fpn_node.pn_hash = sgs_str_hash(name);
4337c478bd9Sstevel@tonic-gate 
4347c478bd9Sstevel@tonic-gate 	if ((fpnp = avl_find(lml->lm_fpavl, &fpn, where)) == NULL)
4357c478bd9Sstevel@tonic-gate 		return (NULL);
4367c478bd9Sstevel@tonic-gate 
4377c478bd9Sstevel@tonic-gate 	return (fpnp->fpn_lmp);
4387c478bd9Sstevel@tonic-gate }
4397c478bd9Sstevel@tonic-gate 
4407c478bd9Sstevel@tonic-gate /*
4419aa23310Srie  * Insert a name into the FullPathNode AVL tree for the link-map list.  The
44224a6229eSrie  * objects NAME() is the path that would have originally been searched for, and
44324a6229eSrie  * is therefore the name to associate with any "where" value.  If the object has
4447c478bd9Sstevel@tonic-gate  * a different PATHNAME(), perhaps because it has resolved to a different file
4459aa23310Srie  * (see fullpath()), then this name will be recorded as a separate FullPathNode
4469aa23310Srie  * (see load_file()).
4477c478bd9Sstevel@tonic-gate  */
4487c478bd9Sstevel@tonic-gate int
4497c478bd9Sstevel@tonic-gate fpavl_insert(Lm_list *lml, Rt_map *lmp, const char *name, avl_index_t where)
4507c478bd9Sstevel@tonic-gate {
4519aa23310Srie 	FullPathNode	*fpnp;
45256deab07SRod Evans 	uint_t		hash = sgs_str_hash(name);
4537c478bd9Sstevel@tonic-gate 
4547c478bd9Sstevel@tonic-gate 	if (where == 0) {
4557c478bd9Sstevel@tonic-gate 		/* LINTED */
45656deab07SRod Evans 		Rt_map	*_lmp = fpavl_recorded(lml, name, hash, &where);
4577c478bd9Sstevel@tonic-gate 
4587c478bd9Sstevel@tonic-gate 		/*
4597c478bd9Sstevel@tonic-gate 		 * We better not get a hit now, we do not want duplicates in
4607c478bd9Sstevel@tonic-gate 		 * the tree.
4617c478bd9Sstevel@tonic-gate 		 */
46243d7826aSRod Evans 		ASSERT(_lmp == NULL);
4637c478bd9Sstevel@tonic-gate 	}
4647c478bd9Sstevel@tonic-gate 
4657c478bd9Sstevel@tonic-gate 	/*
4669aa23310Srie 	 * Insert new node in tree.
4677c478bd9Sstevel@tonic-gate 	 */
4683dbfc803SRod Evans 	if ((fpnp = calloc(sizeof (FullPathNode), 1)) == NULL)
4697c478bd9Sstevel@tonic-gate 		return (0);
4707c478bd9Sstevel@tonic-gate 
4719aa23310Srie 	fpnp->fpn_node.pn_name = name;
47256deab07SRod Evans 	fpnp->fpn_node.pn_hash = hash;
4737c478bd9Sstevel@tonic-gate 	fpnp->fpn_lmp = lmp;
4747c478bd9Sstevel@tonic-gate 
475cce0e03bSab 	if (aplist_append(&FPNODE(lmp), fpnp, AL_CNT_FPNODE) == NULL) {
4767c478bd9Sstevel@tonic-gate 		free(fpnp);
4777c478bd9Sstevel@tonic-gate 		return (0);
4787c478bd9Sstevel@tonic-gate 	}
4797c478bd9Sstevel@tonic-gate 
4807c478bd9Sstevel@tonic-gate 	ASSERT(lml->lm_fpavl != NULL);
4817c478bd9Sstevel@tonic-gate 	avl_insert(lml->lm_fpavl, fpnp, where);
4827c478bd9Sstevel@tonic-gate 	return (1);
4837c478bd9Sstevel@tonic-gate }
4847c478bd9Sstevel@tonic-gate 
4857c478bd9Sstevel@tonic-gate /*
48656deab07SRod Evans  * Remove an object from the FullPathNode AVL tree.
4877c478bd9Sstevel@tonic-gate  */
4887c478bd9Sstevel@tonic-gate void
4897c478bd9Sstevel@tonic-gate fpavl_remove(Rt_map *lmp)
4907c478bd9Sstevel@tonic-gate {
4919aa23310Srie 	FullPathNode	*fpnp;
492cce0e03bSab 	Aliste		idx;
4937c478bd9Sstevel@tonic-gate 
494cce0e03bSab 	for (APLIST_TRAVERSE(FPNODE(lmp), idx, fpnp)) {
4957c478bd9Sstevel@tonic-gate 		avl_remove(LIST(lmp)->lm_fpavl, fpnp);
4967c478bd9Sstevel@tonic-gate 		free(fpnp);
4977c478bd9Sstevel@tonic-gate 	}
4987c478bd9Sstevel@tonic-gate 	free(FPNODE(lmp));
499cce0e03bSab 	FPNODE(lmp) = NULL;
5007c478bd9Sstevel@tonic-gate }
5017c478bd9Sstevel@tonic-gate 
5029aa23310Srie /*
503*08278a5eSRod Evans  * Insert a path name into the not-found AVL tree.
504*08278a5eSRod Evans  *
5059aa23310Srie  * This tree maintains a node for each path name that ld.so.1 has explicitly
5069aa23310Srie  * inspected, but has failed to load during a single ld.so.1 operation.  If the
5079aa23310Srie  * path name does not exist in this AVL tree, then the next insertion point is
5089aa23310Srie  * deposited in "where".  This value can be used by nfavl_insert() to expedite
5099aa23310Srie  * the insertion.
5109aa23310Srie  */
5119aa23310Srie void
5129aa23310Srie nfavl_insert(const char *name, avl_index_t where)
5139aa23310Srie {
5149aa23310Srie 	PathNode	*pnp;
51556deab07SRod Evans 	uint_t		hash = sgs_str_hash(name);
5169aa23310Srie 
5179aa23310Srie 	if (where == 0) {
5189aa23310Srie 		/* LINTED */
519*08278a5eSRod Evans 		int	in_nfavl = pnavl_recorded(&nfavl, name, hash, &where);
5209aa23310Srie 
5219aa23310Srie 		/*
5229aa23310Srie 		 * We better not get a hit now, we do not want duplicates in
5239aa23310Srie 		 * the tree.
5249aa23310Srie 		 */
5259aa23310Srie 		ASSERT(in_nfavl == 0);
5269aa23310Srie 	}
5279aa23310Srie 
5289aa23310Srie 	/*
5299aa23310Srie 	 * Insert new node in tree.
5309aa23310Srie 	 */
53156deab07SRod Evans 	if ((pnp = calloc(sizeof (PathNode), 1)) != NULL) {
5329aa23310Srie 		pnp->pn_name = name;
53356deab07SRod Evans 		pnp->pn_hash = hash;
5349aa23310Srie 		avl_insert(nfavl, pnp, where);
5359aa23310Srie 	}
5369aa23310Srie }
5377c478bd9Sstevel@tonic-gate 
5383dbfc803SRod Evans /*
539*08278a5eSRod Evans  * Insert the directory name, of a full path name, into the secure path AVL
5403dbfc803SRod Evans  * tree.
541*08278a5eSRod Evans  *
542*08278a5eSRod Evans  * This tree is used to maintain a list of directories in which the dependencies
543*08278a5eSRod Evans  * of a secure process have been found.  This list provides a fall-back in the
544*08278a5eSRod Evans  * case that a $ORIGIN expansion is deemed insecure, when the expansion results
545*08278a5eSRod Evans  * in a path name that has already provided dependencies.
5463dbfc803SRod Evans  */
5473dbfc803SRod Evans void
5483dbfc803SRod Evans spavl_insert(const char *name)
5493dbfc803SRod Evans {
5503dbfc803SRod Evans 	char		buffer[PATH_MAX], *str;
5513dbfc803SRod Evans 	size_t		size;
5523dbfc803SRod Evans 	avl_index_t	where;
5533dbfc803SRod Evans 	PathNode	*pnp;
554*08278a5eSRod Evans 	uint_t		hash;
5553dbfc803SRod Evans 
5563dbfc803SRod Evans 	/*
5573dbfc803SRod Evans 	 * Separate the directory name from the path name.
5583dbfc803SRod Evans 	 */
5593dbfc803SRod Evans 	if ((str = strrchr(name, '/')) == name)
5603dbfc803SRod Evans 		size = 1;
5613dbfc803SRod Evans 	else
5623dbfc803SRod Evans 		size = str - name;
5633dbfc803SRod Evans 
5643dbfc803SRod Evans 	(void) strncpy(buffer, name, size);
5653dbfc803SRod Evans 	buffer[size] = '\0';
566*08278a5eSRod Evans 	hash = sgs_str_hash(buffer);
5673dbfc803SRod Evans 
5683dbfc803SRod Evans 	/*
5693dbfc803SRod Evans 	 * Determine whether this directory name is already recorded, or if
5703dbfc803SRod Evans 	 * not, 'where" will provide the insertion point for the new string.
5713dbfc803SRod Evans 	 */
572*08278a5eSRod Evans 	if (pnavl_recorded(&spavl, buffer, hash, &where))
5733dbfc803SRod Evans 		return;
5743dbfc803SRod Evans 
5753dbfc803SRod Evans 	/*
5763dbfc803SRod Evans 	 * Insert new node in tree.
5773dbfc803SRod Evans 	 */
57843d7826aSRod Evans 	if ((pnp = calloc(sizeof (PathNode), 1)) != NULL) {
5793dbfc803SRod Evans 		pnp->pn_name = strdup(buffer);
580*08278a5eSRod Evans 		pnp->pn_hash = hash;
5813dbfc803SRod Evans 		avl_insert(spavl, pnp, where);
5823dbfc803SRod Evans 	}
5833dbfc803SRod Evans }
5843dbfc803SRod Evans 
58556deab07SRod Evans /*
58656deab07SRod Evans  * Inspect the generic string AVL tree for the given string.  If the string is
58756deab07SRod Evans  * not present, duplicate it, and insert the string in the AVL tree.  Return the
58856deab07SRod Evans  * duplicated string to the caller.
58956deab07SRod Evans  *
59056deab07SRod Evans  * These strings are maintained for the life of ld.so.1 and represent path
59156deab07SRod Evans  * names, file names, and search paths.  All other AVL trees that maintain
59256deab07SRod Evans  * FullPathNode and not-found path names use the same string pointer
59356deab07SRod Evans  * established for this string.
59456deab07SRod Evans  */
59556deab07SRod Evans static avl_tree_t	*stravl = NULL;
59656deab07SRod Evans static char		*strbuf = NULL;
59756deab07SRod Evans static PathNode		*pnbuf = NULL;
59856deab07SRod Evans static size_t		strsize = 0, pnsize = 0;
59956deab07SRod Evans 
60056deab07SRod Evans const char *
60156deab07SRod Evans stravl_insert(const char *name, uint_t hash, size_t nsize, int substr)
60256deab07SRod Evans {
60356deab07SRod Evans 	char		str[PATH_MAX];
60456deab07SRod Evans 	PathNode	*pnp;
60556deab07SRod Evans 	avl_index_t	where;
60656deab07SRod Evans 
60756deab07SRod Evans 	/*
60856deab07SRod Evans 	 * Create the avl tree if required.
60956deab07SRod Evans 	 */
61056deab07SRod Evans 	if ((stravl == NULL) &&
61156deab07SRod Evans 	    ((stravl = pnavl_create(sizeof (PathNode))) == NULL))
61256deab07SRod Evans 		return (NULL);
61356deab07SRod Evans 
61456deab07SRod Evans 	/*
61556deab07SRod Evans 	 * Determine the string size if not provided by the caller.
61656deab07SRod Evans 	 */
61756deab07SRod Evans 	if (nsize == 0)
61856deab07SRod Evans 		nsize = strlen(name) + 1;
61956deab07SRod Evans 	else if (substr) {
62056deab07SRod Evans 		/*
62156deab07SRod Evans 		 * The string passed to us may be a multiple path string for
62256deab07SRod Evans 		 * which we only need the first component.  Using the provided
62356deab07SRod Evans 		 * size, strip out the required string.
62456deab07SRod Evans 		 */
62556deab07SRod Evans 		(void) strncpy(str, name, nsize);
62656deab07SRod Evans 		str[nsize - 1] = '\0';
62756deab07SRod Evans 		name = str;
62856deab07SRod Evans 	}
62956deab07SRod Evans 
63056deab07SRod Evans 	/*
63156deab07SRod Evans 	 * Allocate a PathNode buffer if one doesn't exist, or any existing
63256deab07SRod Evans 	 * buffer has been used up.
63356deab07SRod Evans 	 */
63456deab07SRod Evans 	if ((pnbuf == NULL) || (sizeof (PathNode) > pnsize)) {
63556deab07SRod Evans 		pnsize = syspagsz;
63656deab07SRod Evans 		if ((pnbuf = dz_map(0, 0, pnsize, (PROT_READ | PROT_WRITE),
63756deab07SRod Evans 		    MAP_PRIVATE)) == MAP_FAILED)
63856deab07SRod Evans 			return (NULL);
63956deab07SRod Evans 	}
64056deab07SRod Evans 	/*
64156deab07SRod Evans 	 * Determine whether this string already exists.
64256deab07SRod Evans 	 */
64356deab07SRod Evans 	pnbuf->pn_name = name;
64456deab07SRod Evans 	if ((pnbuf->pn_hash = hash) == 0)
64556deab07SRod Evans 		pnbuf->pn_hash = sgs_str_hash(name);
64656deab07SRod Evans 
64756deab07SRod Evans 	if ((pnp = avl_find(stravl, pnbuf, &where)) != NULL)
64856deab07SRod Evans 		return (pnp->pn_name);
64956deab07SRod Evans 
65056deab07SRod Evans 	/*
65156deab07SRod Evans 	 * Allocate a string buffer if one does not exist, or if there is
65256deab07SRod Evans 	 * insufficient space for the new string in any existing buffer.
65356deab07SRod Evans 	 */
65456deab07SRod Evans 	if ((strbuf == NULL) || (nsize > strsize)) {
65556deab07SRod Evans 		strsize = S_ROUND(nsize, syspagsz);
65656deab07SRod Evans 
65756deab07SRod Evans 		if ((strbuf = dz_map(0, 0, strsize, (PROT_READ | PROT_WRITE),
65856deab07SRod Evans 		    MAP_PRIVATE)) == MAP_FAILED)
65956deab07SRod Evans 			return (NULL);
66056deab07SRod Evans 	}
66156deab07SRod Evans 
66256deab07SRod Evans 	(void) memcpy(strbuf, name, nsize);
66356deab07SRod Evans 	pnp = pnbuf;
66456deab07SRod Evans 	pnp->pn_name = strbuf;
66556deab07SRod Evans 	avl_insert(stravl, pnp, where);
66656deab07SRod Evans 
66756deab07SRod Evans 	strbuf += nsize;
66856deab07SRod Evans 	strsize -= nsize;
66956deab07SRod Evans 	pnbuf++;
67056deab07SRod Evans 	pnsize -= sizeof (PathNode);
67156deab07SRod Evans 	return (pnp->pn_name);
67256deab07SRod Evans }
67356deab07SRod Evans 
6747c478bd9Sstevel@tonic-gate /*
6757c478bd9Sstevel@tonic-gate  * Prior to calling an object, either via a .plt or through dlsym(), make sure
6767c478bd9Sstevel@tonic-gate  * its .init has fired.  Through topological sorting, ld.so.1 attempts to fire
6777c478bd9Sstevel@tonic-gate  * init's in the correct order, however, this order is typically based on needed
6787c478bd9Sstevel@tonic-gate  * dependencies and non-lazy relocation bindings.  Lazy relocations (.plts) can
6797c478bd9Sstevel@tonic-gate  * still occur and result in bindings that were not captured during topological
6807c478bd9Sstevel@tonic-gate  * sorting.  This routine compensates for this lack of binding information, and
6817c478bd9Sstevel@tonic-gate  * provides for dynamic .init firing.
6827c478bd9Sstevel@tonic-gate  */
6837c478bd9Sstevel@tonic-gate void
6849aa23310Srie is_dep_init(Rt_map *dlmp, Rt_map *clmp)
6857c478bd9Sstevel@tonic-gate {
6869aa23310Srie 	Rt_map	**tobj;
6877c478bd9Sstevel@tonic-gate 
6887c478bd9Sstevel@tonic-gate 	/*
6897c478bd9Sstevel@tonic-gate 	 * If the caller is an auditor, and the destination isn't, then don't
6907c478bd9Sstevel@tonic-gate 	 * run any .inits (see comments in load_completion()).
6917c478bd9Sstevel@tonic-gate 	 */
6927c478bd9Sstevel@tonic-gate 	if ((LIST(clmp)->lm_flags & LML_FLG_NOAUDIT) &&
6937c478bd9Sstevel@tonic-gate 	    (LIST(clmp) != LIST(dlmp)))
6947c478bd9Sstevel@tonic-gate 		return;
6957c478bd9Sstevel@tonic-gate 
69656deab07SRod Evans 	if ((dlmp == clmp) || (rtld_flags & RT_FL_INITFIRST))
6977c478bd9Sstevel@tonic-gate 		return;
6987c478bd9Sstevel@tonic-gate 
6997c478bd9Sstevel@tonic-gate 	if ((FLAGS(dlmp) & (FLG_RT_RELOCED | FLG_RT_INITDONE)) ==
7007c478bd9Sstevel@tonic-gate 	    (FLG_RT_RELOCED | FLG_RT_INITDONE))
7017c478bd9Sstevel@tonic-gate 		return;
7027c478bd9Sstevel@tonic-gate 
7037c478bd9Sstevel@tonic-gate 	if ((FLAGS(dlmp) & (FLG_RT_RELOCED | FLG_RT_INITCALL)) ==
7047c478bd9Sstevel@tonic-gate 	    (FLG_RT_RELOCED | FLG_RT_INITCALL)) {
7055aefb655Srie 		DBG_CALL(Dbg_util_no_init(dlmp));
7067c478bd9Sstevel@tonic-gate 		return;
7077c478bd9Sstevel@tonic-gate 	}
7087c478bd9Sstevel@tonic-gate 
7097c478bd9Sstevel@tonic-gate 	if ((tobj = calloc(2, sizeof (Rt_map *))) != NULL) {
7107c478bd9Sstevel@tonic-gate 		tobj[0] = dlmp;
7117c478bd9Sstevel@tonic-gate 		call_init(tobj, DBG_INIT_DYN);
7127c478bd9Sstevel@tonic-gate 	}
7137c478bd9Sstevel@tonic-gate }
7147c478bd9Sstevel@tonic-gate 
7157c478bd9Sstevel@tonic-gate /*
7167c478bd9Sstevel@tonic-gate  * Execute .{preinit|init|fini}array sections
7177c478bd9Sstevel@tonic-gate  */
7187c478bd9Sstevel@tonic-gate void
7195aefb655Srie call_array(Addr *array, uint_t arraysz, Rt_map *lmp, Word shtype)
7207c478bd9Sstevel@tonic-gate {
7215aefb655Srie 	int	start, stop, incr, ndx;
7227c478bd9Sstevel@tonic-gate 	uint_t	arraycnt = (uint_t)(arraysz / sizeof (Addr));
7237c478bd9Sstevel@tonic-gate 
7247c478bd9Sstevel@tonic-gate 	if (array == NULL)
7257c478bd9Sstevel@tonic-gate 		return;
7267c478bd9Sstevel@tonic-gate 
7277c478bd9Sstevel@tonic-gate 	/*
7287c478bd9Sstevel@tonic-gate 	 * initarray & preinitarray are walked from beginning to end - while
7297c478bd9Sstevel@tonic-gate 	 * finiarray is walked from end to beginning.
7307c478bd9Sstevel@tonic-gate 	 */
7317c478bd9Sstevel@tonic-gate 	if (shtype == SHT_FINI_ARRAY) {
7327c478bd9Sstevel@tonic-gate 		start = arraycnt - 1;
7337c478bd9Sstevel@tonic-gate 		stop = incr = -1;
7347c478bd9Sstevel@tonic-gate 	} else {
7357c478bd9Sstevel@tonic-gate 		start = 0;
7367c478bd9Sstevel@tonic-gate 		stop = arraycnt;
7377c478bd9Sstevel@tonic-gate 		incr = 1;
7387c478bd9Sstevel@tonic-gate 	}
7397c478bd9Sstevel@tonic-gate 
7407c478bd9Sstevel@tonic-gate 	/*
7417c478bd9Sstevel@tonic-gate 	 * Call the .*array[] entries
7427c478bd9Sstevel@tonic-gate 	 */
7435aefb655Srie 	for (ndx = start; ndx != stop; ndx += incr) {
74410a4fa49Srie 		void (*fptr)(void) = (void(*)())array[ndx];
7457c478bd9Sstevel@tonic-gate 
7465aefb655Srie 		DBG_CALL(Dbg_util_call_array(lmp, (void *)fptr, ndx, shtype));
7477c478bd9Sstevel@tonic-gate 
748eccf73c8Srie 		leave(LIST(lmp), 0);
7497c478bd9Sstevel@tonic-gate 		(*fptr)();
750eccf73c8Srie 		(void) enter(0);
7517c478bd9Sstevel@tonic-gate 	}
7527c478bd9Sstevel@tonic-gate }
7537c478bd9Sstevel@tonic-gate 
7547c478bd9Sstevel@tonic-gate 
7557c478bd9Sstevel@tonic-gate /*
7567c478bd9Sstevel@tonic-gate  * Execute any .init sections.  These are passed to us in an lmp array which
7577c478bd9Sstevel@tonic-gate  * (by default) will have been sorted.
7587c478bd9Sstevel@tonic-gate  */
7597c478bd9Sstevel@tonic-gate void
7609aa23310Srie call_init(Rt_map **tobj, int flag)
7617c478bd9Sstevel@tonic-gate {
7629aa23310Srie 	Rt_map		**_tobj, **_nobj;
76357ef7aa9SRod Evans 	static APlist	*pending = NULL;
7647c478bd9Sstevel@tonic-gate 
7657c478bd9Sstevel@tonic-gate 	/*
7667c478bd9Sstevel@tonic-gate 	 * If we're in the middle of an INITFIRST, this must complete before
7677c478bd9Sstevel@tonic-gate 	 * any new init's are fired.  In this case add the object list to the
7687c478bd9Sstevel@tonic-gate 	 * pending queue and return.  We'll pick up the queue after any
7697c478bd9Sstevel@tonic-gate 	 * INITFIRST objects have their init's fired.
7707c478bd9Sstevel@tonic-gate 	 */
7717c478bd9Sstevel@tonic-gate 	if (rtld_flags & RT_FL_INITFIRST) {
77257ef7aa9SRod Evans 		(void) aplist_append(&pending, tobj, AL_CNT_PENDING);
7737c478bd9Sstevel@tonic-gate 		return;
7747c478bd9Sstevel@tonic-gate 	}
7757c478bd9Sstevel@tonic-gate 
7767c478bd9Sstevel@tonic-gate 	/*
7777c478bd9Sstevel@tonic-gate 	 * Traverse the tobj array firing each objects init.
7787c478bd9Sstevel@tonic-gate 	 */
7797c478bd9Sstevel@tonic-gate 	for (_tobj = _nobj = tobj, _nobj++; *_tobj != NULL; _tobj++, _nobj++) {
7809aa23310Srie 		Rt_map	*lmp = *_tobj;
7819aa23310Srie 		void	(*iptr)() = INIT(lmp);
782dde769a2SRod Evans 		uint_t	rtldflags;
7837c478bd9Sstevel@tonic-gate 
7847c478bd9Sstevel@tonic-gate 		if (FLAGS(lmp) & FLG_RT_INITCALL)
7857c478bd9Sstevel@tonic-gate 			continue;
7867c478bd9Sstevel@tonic-gate 
7877c478bd9Sstevel@tonic-gate 		FLAGS(lmp) |= FLG_RT_INITCALL;
7887c478bd9Sstevel@tonic-gate 
789dde769a2SRod Evans 		/*
790dde769a2SRod Evans 		 * It is possible, that during the initial handshake with libc,
791dde769a2SRod Evans 		 * an interposition object has resolved a symbol binding, and
792dde769a2SRod Evans 		 * that this objects .init must be fired.  As we're about to
793dde769a2SRod Evans 		 * run user code, make sure any dynamic linking errors remain
794dde769a2SRod Evans 		 * internal (ie., only obtainable from dlerror()), and are not
795dde769a2SRod Evans 		 * flushed to stderr.
796dde769a2SRod Evans 		 */
797dde769a2SRod Evans 		rtldflags = (rtld_flags & RT_FL_APPLIC) ? 0 : RT_FL_APPLIC;
798dde769a2SRod Evans 		rtld_flags |= rtldflags;
799dde769a2SRod Evans 
8007c478bd9Sstevel@tonic-gate 		/*
8017c478bd9Sstevel@tonic-gate 		 * Establish an initfirst state if necessary - no other inits
802dffec89cSrie 		 * will be fired (because of additional relocation bindings)
803dffec89cSrie 		 * when in this state.
8047c478bd9Sstevel@tonic-gate 		 */
8057c478bd9Sstevel@tonic-gate 		if (FLAGS(lmp) & FLG_RT_INITFRST)
8067c478bd9Sstevel@tonic-gate 			rtld_flags |= RT_FL_INITFIRST;
8077c478bd9Sstevel@tonic-gate 
80856deab07SRod Evans 		if (INITARRAY(lmp) || iptr)
8095aefb655Srie 			DBG_CALL(Dbg_util_call_init(lmp, flag));
8107c478bd9Sstevel@tonic-gate 
8117c478bd9Sstevel@tonic-gate 		if (iptr) {
812eccf73c8Srie 			leave(LIST(lmp), 0);
8137c478bd9Sstevel@tonic-gate 			(*iptr)();
814eccf73c8Srie 			(void) enter(0);
8157c478bd9Sstevel@tonic-gate 		}
8167c478bd9Sstevel@tonic-gate 
8177c478bd9Sstevel@tonic-gate 		call_array(INITARRAY(lmp), INITARRAYSZ(lmp), lmp,
8187c478bd9Sstevel@tonic-gate 		    SHT_INIT_ARRAY);
8197c478bd9Sstevel@tonic-gate 
8207c478bd9Sstevel@tonic-gate 		if (INITARRAY(lmp) || iptr)
8215aefb655Srie 			DBG_CALL(Dbg_util_call_init(lmp, DBG_INIT_DONE));
8227c478bd9Sstevel@tonic-gate 
823dde769a2SRod Evans 		/*
824dde769a2SRod Evans 		 * Return to a non-application setting if necessary.
825dde769a2SRod Evans 		 */
826dde769a2SRod Evans 		rtld_flags &= ~rtldflags;
827dde769a2SRod Evans 
8287c478bd9Sstevel@tonic-gate 		/*
8297c478bd9Sstevel@tonic-gate 		 * Set the initdone flag regardless of whether this object
8307c478bd9Sstevel@tonic-gate 		 * actually contains an .init section.  This flag prevents us
8317c478bd9Sstevel@tonic-gate 		 * from processing this section again for an .init and also
8327c478bd9Sstevel@tonic-gate 		 * signifies that a .fini must be called should it exist.
8337c478bd9Sstevel@tonic-gate 		 * Clear the sort field for use in later .fini processing.
8347c478bd9Sstevel@tonic-gate 		 */
8357c478bd9Sstevel@tonic-gate 		FLAGS(lmp) |= FLG_RT_INITDONE;
836dffec89cSrie 		SORTVAL(lmp) = -1;
8377c478bd9Sstevel@tonic-gate 
8387c478bd9Sstevel@tonic-gate 		/*
8397c478bd9Sstevel@tonic-gate 		 * If we're firing an INITFIRST object, and other objects must
8407c478bd9Sstevel@tonic-gate 		 * be fired which are not INITFIRST, make sure we grab any
8417c478bd9Sstevel@tonic-gate 		 * pending objects that might have been delayed as this
8427c478bd9Sstevel@tonic-gate 		 * INITFIRST was processed.
8437c478bd9Sstevel@tonic-gate 		 */
8447c478bd9Sstevel@tonic-gate 		if ((rtld_flags & RT_FL_INITFIRST) &&
8457c478bd9Sstevel@tonic-gate 		    ((*_nobj == NULL) || !(FLAGS(*_nobj) & FLG_RT_INITFRST))) {
84657ef7aa9SRod Evans 			Aliste	idx;
84757ef7aa9SRod Evans 			Rt_map	**pobj;
8487c478bd9Sstevel@tonic-gate 
8497c478bd9Sstevel@tonic-gate 			rtld_flags &= ~RT_FL_INITFIRST;
8507c478bd9Sstevel@tonic-gate 
85157ef7aa9SRod Evans 			for (APLIST_TRAVERSE(pending, idx, pobj)) {
85257ef7aa9SRod Evans 				aplist_delete(pending, &idx);
8537c478bd9Sstevel@tonic-gate 				call_init(pobj, DBG_INIT_PEND);
8547c478bd9Sstevel@tonic-gate 			}
8557c478bd9Sstevel@tonic-gate 		}
8567c478bd9Sstevel@tonic-gate 	}
8577c478bd9Sstevel@tonic-gate 	free(tobj);
8587c478bd9Sstevel@tonic-gate }
8597c478bd9Sstevel@tonic-gate 
8607c478bd9Sstevel@tonic-gate /*
8617c478bd9Sstevel@tonic-gate  * Function called by atexit(3C).  Calls all .fini sections related with the
8627c478bd9Sstevel@tonic-gate  * mains dependent shared libraries in the order in which the shared libraries
8637c478bd9Sstevel@tonic-gate  * have been loaded.  Skip any .fini defined in the main executable, as this
8647c478bd9Sstevel@tonic-gate  * will be called by crt0 (main was never marked as initdone).
8657c478bd9Sstevel@tonic-gate  */
8667c478bd9Sstevel@tonic-gate void
8677c478bd9Sstevel@tonic-gate call_fini(Lm_list * lml, Rt_map ** tobj)
8687c478bd9Sstevel@tonic-gate {
869dffec89cSrie 	Rt_map **_tobj;
8707c478bd9Sstevel@tonic-gate 
8717c478bd9Sstevel@tonic-gate 	for (_tobj = tobj; *_tobj != NULL; _tobj++) {
872cce0e03bSab 		Rt_map		*clmp, * lmp = *_tobj;
873cce0e03bSab 		Aliste		idx;
874cce0e03bSab 		Bnd_desc	*bdp;
8757c478bd9Sstevel@tonic-gate 
8767c478bd9Sstevel@tonic-gate 		/*
87756deab07SRod Evans 		 * Only fire a .fini if the objects corresponding .init has
87856deab07SRod Evans 		 * completed.  We collect all .fini sections of objects that
87956deab07SRod Evans 		 * had their .init collected, but that doesn't mean that at
88056deab07SRod Evans 		 * the time of collection, that the .init had completed.
8817c478bd9Sstevel@tonic-gate 		 */
88256deab07SRod Evans 		if (FLAGS(lmp) & FLG_RT_INITDONE) {
88310a4fa49Srie 			void	(*fptr)(void) = FINI(lmp);
8847c478bd9Sstevel@tonic-gate 
88556deab07SRod Evans 			if (FINIARRAY(lmp) || fptr)
8865aefb655Srie 				DBG_CALL(Dbg_util_call_fini(lmp));
8877c478bd9Sstevel@tonic-gate 
8885aefb655Srie 			call_array(FINIARRAY(lmp), FINIARRAYSZ(lmp), lmp,
8895aefb655Srie 			    SHT_FINI_ARRAY);
8907c478bd9Sstevel@tonic-gate 
8917c478bd9Sstevel@tonic-gate 			if (fptr) {
892eccf73c8Srie 				leave(LIST(lmp), 0);
8937c478bd9Sstevel@tonic-gate 				(*fptr)();
894eccf73c8Srie 				(void) enter(0);
8957c478bd9Sstevel@tonic-gate 			}
8967c478bd9Sstevel@tonic-gate 		}
8977c478bd9Sstevel@tonic-gate 
898dffec89cSrie 		/*
899dffec89cSrie 		 * Skip main, this is explicitly called last in atexit_fini().
900dffec89cSrie 		 */
901dffec89cSrie 		if (FLAGS(lmp) & FLG_RT_ISMAIN)
902dffec89cSrie 			continue;
903dffec89cSrie 
9047c478bd9Sstevel@tonic-gate 		/*
9057c478bd9Sstevel@tonic-gate 		 * Audit `close' operations at this point.  The library has
9067c478bd9Sstevel@tonic-gate 		 * exercised its last instructions (regardless of whether it
9077c478bd9Sstevel@tonic-gate 		 * will be unmapped or not).
9087c478bd9Sstevel@tonic-gate 		 *
9097c478bd9Sstevel@tonic-gate 		 * First call any global auditing.
9107c478bd9Sstevel@tonic-gate 		 */
9117c478bd9Sstevel@tonic-gate 		if (lml->lm_tflags & LML_TFLG_AUD_OBJCLOSE)
91257ef7aa9SRod Evans 			_audit_objclose(auditors->ad_list, lmp);
9137c478bd9Sstevel@tonic-gate 
9147c478bd9Sstevel@tonic-gate 		/*
9157c478bd9Sstevel@tonic-gate 		 * Finally determine whether this object has local auditing
9167c478bd9Sstevel@tonic-gate 		 * requirements by inspecting itself and then its dependencies.
9177c478bd9Sstevel@tonic-gate 		 */
9187c478bd9Sstevel@tonic-gate 		if ((lml->lm_flags & LML_FLG_LOCAUDIT) == 0)
9197c478bd9Sstevel@tonic-gate 			continue;
9207c478bd9Sstevel@tonic-gate 
92156deab07SRod Evans 		if (AFLAGS(lmp) & LML_TFLG_AUD_OBJCLOSE)
92257ef7aa9SRod Evans 			_audit_objclose(AUDITORS(lmp)->ad_list, lmp);
9237c478bd9Sstevel@tonic-gate 
924cce0e03bSab 		for (APLIST_TRAVERSE(CALLERS(lmp), idx, bdp)) {
9257c478bd9Sstevel@tonic-gate 			clmp = bdp->b_caller;
9267c478bd9Sstevel@tonic-gate 
92756deab07SRod Evans 			if (AFLAGS(clmp) & LML_TFLG_AUD_OBJCLOSE) {
92857ef7aa9SRod Evans 				_audit_objclose(AUDITORS(clmp)->ad_list, lmp);
929a953e2b1Srie 				break;
9307c478bd9Sstevel@tonic-gate 			}
9317c478bd9Sstevel@tonic-gate 		}
9327c478bd9Sstevel@tonic-gate 	}
9335aefb655Srie 	DBG_CALL(Dbg_bind_plt_summary(lml, M_MACH, pltcnt21d, pltcnt24d,
9345aefb655Srie 	    pltcntu32, pltcntu44, pltcntfull, pltcntfar));
9357c478bd9Sstevel@tonic-gate 
9367c478bd9Sstevel@tonic-gate 	free(tobj);
9377c478bd9Sstevel@tonic-gate }
9387c478bd9Sstevel@tonic-gate 
9397c478bd9Sstevel@tonic-gate void
9407c478bd9Sstevel@tonic-gate atexit_fini()
9417c478bd9Sstevel@tonic-gate {
94257ef7aa9SRod Evans 	Rt_map	**tobj, *lmp;
94357ef7aa9SRod Evans 	Lm_list	*lml;
94457ef7aa9SRod Evans 	Aliste	idx;
9457c478bd9Sstevel@tonic-gate 
9468cd45542Sraf 	(void) enter(0);
9477c478bd9Sstevel@tonic-gate 
9487c478bd9Sstevel@tonic-gate 	rtld_flags |= RT_FL_ATEXIT;
9497c478bd9Sstevel@tonic-gate 
9507c478bd9Sstevel@tonic-gate 	lml = &lml_main;
951dffec89cSrie 	lml->lm_flags |= LML_FLG_ATEXIT;
952883c6d49Srie 	lml->lm_flags &= ~LML_FLG_INTRPOSETSORT;
9537c478bd9Sstevel@tonic-gate 	lmp = (Rt_map *)lml->lm_head;
9547c478bd9Sstevel@tonic-gate 
9557c478bd9Sstevel@tonic-gate 	/*
9567c478bd9Sstevel@tonic-gate 	 * Reverse topologically sort the main link-map for .fini execution.
9577c478bd9Sstevel@tonic-gate 	 */
95843d7826aSRod Evans 	if (((tobj = tsort(lmp, lml->lm_obj, RT_SORT_FWD)) != NULL) &&
9597c478bd9Sstevel@tonic-gate 	    (tobj != (Rt_map **)S_ERROR))
9607c478bd9Sstevel@tonic-gate 		call_fini(lml, tobj);
9617c478bd9Sstevel@tonic-gate 
9627c478bd9Sstevel@tonic-gate 	/*
963dffec89cSrie 	 * Add an explicit close to main and ld.so.1.  Although main's .fini is
964dffec89cSrie 	 * collected in call_fini() to provide for FINITARRAY processing, its
965dffec89cSrie 	 * audit_objclose is explicitly skipped.  This provides for it to be
966dffec89cSrie 	 * called last, here.  This is the reverse of the explicit calls to
967dffec89cSrie 	 * audit_objopen() made in setup().
9687c478bd9Sstevel@tonic-gate 	 */
96956deab07SRod Evans 	if ((lml->lm_tflags | AFLAGS(lmp)) & LML_TFLG_AUD_MASK) {
9707c478bd9Sstevel@tonic-gate 		audit_objclose(lmp, (Rt_map *)lml_rtld.lm_head);
971dffec89cSrie 		audit_objclose(lmp, lmp);
9727c478bd9Sstevel@tonic-gate 	}
9737c478bd9Sstevel@tonic-gate 
9747c478bd9Sstevel@tonic-gate 	/*
9757c478bd9Sstevel@tonic-gate 	 * Now that all .fini code has been run, see what unreferenced objects
9769aa23310Srie 	 * remain.
9777c478bd9Sstevel@tonic-gate 	 */
9787c478bd9Sstevel@tonic-gate 	unused(lml);
9797c478bd9Sstevel@tonic-gate 
9807c478bd9Sstevel@tonic-gate 	/*
9817c478bd9Sstevel@tonic-gate 	 * Traverse any alternative link-map lists.
9827c478bd9Sstevel@tonic-gate 	 */
98357ef7aa9SRod Evans 	for (APLIST_TRAVERSE(dynlm_list, idx, lml)) {
98410a4fa49Srie 		/*
98510a4fa49Srie 		 * Ignore the base-link-map list, which has already been
98610a4fa49Srie 		 * processed, and the runtime linkers link-map list, which is
98710a4fa49Srie 		 * typically processed last.
98810a4fa49Srie 		 */
9897c478bd9Sstevel@tonic-gate 		if (lml->lm_flags & (LML_FLG_BASELM | LML_FLG_RTLDLM))
9907c478bd9Sstevel@tonic-gate 			continue;
9917c478bd9Sstevel@tonic-gate 
99243d7826aSRod Evans 		if ((lmp = (Rt_map *)lml->lm_head) == NULL)
9937c478bd9Sstevel@tonic-gate 			continue;
9947c478bd9Sstevel@tonic-gate 
995dffec89cSrie 		lml->lm_flags |= LML_FLG_ATEXIT;
996883c6d49Srie 		lml->lm_flags &= ~LML_FLG_INTRPOSETSORT;
997dffec89cSrie 
9987c478bd9Sstevel@tonic-gate 		/*
9997c478bd9Sstevel@tonic-gate 		 * Reverse topologically sort the link-map for .fini execution.
10007c478bd9Sstevel@tonic-gate 		 */
100143d7826aSRod Evans 		if (((tobj = tsort(lmp, lml->lm_obj, RT_SORT_FWD)) != NULL) &&
10027c478bd9Sstevel@tonic-gate 		    (tobj != (Rt_map **)S_ERROR))
10037c478bd9Sstevel@tonic-gate 			call_fini(lml, tobj);
10047c478bd9Sstevel@tonic-gate 
10057c478bd9Sstevel@tonic-gate 		unused(lml);
10067c478bd9Sstevel@tonic-gate 	}
10077c478bd9Sstevel@tonic-gate 
10087c478bd9Sstevel@tonic-gate 	/*
10097c478bd9Sstevel@tonic-gate 	 * Finally reverse topologically sort the runtime linkers link-map for
10107c478bd9Sstevel@tonic-gate 	 * .fini execution.
10117c478bd9Sstevel@tonic-gate 	 */
10127c478bd9Sstevel@tonic-gate 	lml = &lml_rtld;
1013dffec89cSrie 	lml->lm_flags |= LML_FLG_ATEXIT;
1014883c6d49Srie 	lml->lm_flags &= ~LML_FLG_INTRPOSETSORT;
10157c478bd9Sstevel@tonic-gate 	lmp = (Rt_map *)lml->lm_head;
10167c478bd9Sstevel@tonic-gate 
101743d7826aSRod Evans 	if (((tobj = tsort(lmp, lml->lm_obj, RT_SORT_FWD)) != NULL) &&
10187c478bd9Sstevel@tonic-gate 	    (tobj != (Rt_map **)S_ERROR))
10197c478bd9Sstevel@tonic-gate 		call_fini(lml, tobj);
10207c478bd9Sstevel@tonic-gate 
10218cd45542Sraf 	leave(&lml_main, 0);
10227c478bd9Sstevel@tonic-gate }
10237c478bd9Sstevel@tonic-gate 
10247c478bd9Sstevel@tonic-gate 
10257c478bd9Sstevel@tonic-gate /*
10267c478bd9Sstevel@tonic-gate  * This routine is called to complete any runtime linker activity which may have
10277c478bd9Sstevel@tonic-gate  * resulted in objects being loaded.  This is called from all user entry points
10287c478bd9Sstevel@tonic-gate  * and from any internal dl*() requests.
10297c478bd9Sstevel@tonic-gate  */
10307c478bd9Sstevel@tonic-gate void
10317247f888Srie load_completion(Rt_map *nlmp)
10327c478bd9Sstevel@tonic-gate {
103343d7826aSRod Evans 	Rt_map	**tobj = NULL;
10347247f888Srie 	Lm_list	*nlml;
10357c478bd9Sstevel@tonic-gate 
10367c478bd9Sstevel@tonic-gate 	/*
10377c478bd9Sstevel@tonic-gate 	 * Establish any .init processing.  Note, in a world of lazy loading,
10387c478bd9Sstevel@tonic-gate 	 * objects may have been loaded regardless of whether the users request
10397c478bd9Sstevel@tonic-gate 	 * was fulfilled (i.e., a dlsym() request may have failed to find a
10407c478bd9Sstevel@tonic-gate 	 * symbol but objects might have been loaded during its search).  Thus,
10417c478bd9Sstevel@tonic-gate 	 * any tsorting starts from the nlmp (new link-maps) pointer and not
10427c478bd9Sstevel@tonic-gate 	 * necessarily from the link-map that may have satisfied the request.
10437c478bd9Sstevel@tonic-gate 	 *
104410a4fa49Srie 	 * Note, the primary link-map has an initialization phase where dynamic
104510a4fa49Srie 	 * .init firing is suppressed.  This provides for a simple and clean
104610a4fa49Srie 	 * handshake with the primary link-maps libc, which is important for
104710a4fa49Srie 	 * establishing uberdata.  In addition, auditors often obtain handles
104810a4fa49Srie 	 * to primary link-map objects as the objects are loaded, so as to
104910a4fa49Srie 	 * inspect the link-map for symbols.  This inspection is allowed without
105010a4fa49Srie 	 * running any code on the primary link-map, as running this code may
105110a4fa49Srie 	 * reenter the auditor, who may not yet have finished its own
10527c478bd9Sstevel@tonic-gate 	 * initialization.
10537c478bd9Sstevel@tonic-gate 	 */
105410a4fa49Srie 	if (nlmp)
105510a4fa49Srie 		nlml = LIST(nlmp);
105610a4fa49Srie 
1057b71d513aSedp 	if (nlmp && nlml->lm_init && ((nlml != &lml_main) ||
1058b71d513aSedp 	    (rtld_flags2 & (RT_FL2_PLMSETUP | RT_FL2_NOPLM)))) {
105956deab07SRod Evans 		if ((tobj = tsort(nlmp, nlml->lm_init,
1060dffec89cSrie 		    RT_SORT_REV)) == (Rt_map **)S_ERROR)
106143d7826aSRod Evans 			tobj = NULL;
10627c478bd9Sstevel@tonic-gate 	}
10637c478bd9Sstevel@tonic-gate 
106410a4fa49Srie 	/*
106510a4fa49Srie 	 * Make sure any alternative link-map retrieves any external interfaces
106610a4fa49Srie 	 * and initializes threads.
106710a4fa49Srie 	 */
106810a4fa49Srie 	if (nlmp && (nlml != &lml_main)) {
106910a4fa49Srie 		(void) rt_get_extern(nlml, nlmp);
107010a4fa49Srie 		rt_thr_init(nlml);
107110a4fa49Srie 	}
107210a4fa49Srie 
107310a4fa49Srie 	/*
107410a4fa49Srie 	 * Traverse the list of new link-maps and register any dynamic TLS.
107510a4fa49Srie 	 * This storage is established for any objects not on the primary
107610a4fa49Srie 	 * link-map, and for any objects added to the primary link-map after
107710a4fa49Srie 	 * static TLS has been registered.
107810a4fa49Srie 	 */
1079b71d513aSedp 	if (nlmp && nlml->lm_tls && ((nlml != &lml_main) ||
1080b71d513aSedp 	    (rtld_flags2 & (RT_FL2_PLMSETUP | RT_FL2_NOPLM)))) {
108110a4fa49Srie 		Rt_map	*lmp;
108210a4fa49Srie 
1083cb511613SAli Bahrami 		for (lmp = nlmp; lmp; lmp = NEXT_RT_MAP(lmp)) {
108410a4fa49Srie 			if (PTTLS(lmp) && PTTLS(lmp)->p_memsz)
108510a4fa49Srie 				tls_modaddrem(lmp, TM_FLG_MODADD);
108610a4fa49Srie 		}
108710a4fa49Srie 		nlml->lm_tls = 0;
108810a4fa49Srie 	}
108910a4fa49Srie 
10907c478bd9Sstevel@tonic-gate 	/*
10917c478bd9Sstevel@tonic-gate 	 * Fire any .init's.
10927c478bd9Sstevel@tonic-gate 	 */
10937c478bd9Sstevel@tonic-gate 	if (tobj)
10947c478bd9Sstevel@tonic-gate 		call_init(tobj, DBG_INIT_SORT);
10957c478bd9Sstevel@tonic-gate }
10967c478bd9Sstevel@tonic-gate 
10977c478bd9Sstevel@tonic-gate /*
10987c478bd9Sstevel@tonic-gate  * Append an item to the specified link map control list.
10997c478bd9Sstevel@tonic-gate  */
11007c478bd9Sstevel@tonic-gate void
11017c478bd9Sstevel@tonic-gate lm_append(Lm_list *lml, Aliste lmco, Rt_map *lmp)
11027c478bd9Sstevel@tonic-gate {
11037c478bd9Sstevel@tonic-gate 	Lm_cntl	*lmc;
11047c478bd9Sstevel@tonic-gate 	int	add = 1;
11057c478bd9Sstevel@tonic-gate 
11067c478bd9Sstevel@tonic-gate 	/*
11077c478bd9Sstevel@tonic-gate 	 * Indicate that this link-map list has a new object.
11087c478bd9Sstevel@tonic-gate 	 */
11097c478bd9Sstevel@tonic-gate 	(lml->lm_obj)++;
11107c478bd9Sstevel@tonic-gate 
11117c478bd9Sstevel@tonic-gate 	/*
111212b8e62eSrie 	 * If we're about to add a new object to the main link-map control list,
111312b8e62eSrie 	 * alert the debuggers that we are about to mess with this list.
111412b8e62eSrie 	 * Additions of individual objects to the main link-map control list
111512b8e62eSrie 	 * occur during initial setup as the applications immediate dependencies
111612b8e62eSrie 	 * are loaded.  Individual objects are also loaded on the main link-map
111712b8e62eSrie 	 * control list of new alternative link-map control lists.
11187c478bd9Sstevel@tonic-gate 	 */
1119cce0e03bSab 	if ((lmco == ALIST_OFF_DATA) &&
1120cce0e03bSab 	    ((lml->lm_flags & LML_FLG_DBNOTIF) == 0))
112112b8e62eSrie 		rd_event(lml, RD_DLACTIVITY, RT_ADD);
11227c478bd9Sstevel@tonic-gate 
11237c478bd9Sstevel@tonic-gate 	/* LINTED */
1124cce0e03bSab 	lmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, lmco);
11257c478bd9Sstevel@tonic-gate 
11267c478bd9Sstevel@tonic-gate 	/*
11277c478bd9Sstevel@tonic-gate 	 * A link-map list header points to one of more link-map control lists
11287c478bd9Sstevel@tonic-gate 	 * (see include/rtld.h).  The initial list, pointed to by lm_cntl, is
11297c478bd9Sstevel@tonic-gate 	 * the list of relocated objects.  Other lists maintain objects that
11307c478bd9Sstevel@tonic-gate 	 * are still being analyzed or relocated.  This list provides the core
11317c478bd9Sstevel@tonic-gate 	 * link-map list information used by all ld.so.1 routines.
11327c478bd9Sstevel@tonic-gate 	 */
11337c478bd9Sstevel@tonic-gate 	if (lmc->lc_head == NULL) {
11347c478bd9Sstevel@tonic-gate 		/*
11357c478bd9Sstevel@tonic-gate 		 * If this is the first link-map for the given control list,
11367c478bd9Sstevel@tonic-gate 		 * initialize the list.
11377c478bd9Sstevel@tonic-gate 		 */
11387c478bd9Sstevel@tonic-gate 		lmc->lc_head = lmc->lc_tail = lmp;
11397c478bd9Sstevel@tonic-gate 		add = 0;
11407c478bd9Sstevel@tonic-gate 
11419a411307Srie 	} else if (FLAGS(lmp) & FLG_RT_OBJINTPO) {
11427c478bd9Sstevel@tonic-gate 		Rt_map	*tlmp;
11437c478bd9Sstevel@tonic-gate 
11447c478bd9Sstevel@tonic-gate 		/*
11457c478bd9Sstevel@tonic-gate 		 * If this is an interposer then append the link-map following
11467c478bd9Sstevel@tonic-gate 		 * any other interposers (these are objects that have been
11477c478bd9Sstevel@tonic-gate 		 * previously preloaded, or were identified with -z interpose).
11487c478bd9Sstevel@tonic-gate 		 * Interposers can only be inserted on the first link-map
11497c478bd9Sstevel@tonic-gate 		 * control list, as once relocation has started, interposition
11507c478bd9Sstevel@tonic-gate 		 * from new interposers can't be guaranteed.
11517c478bd9Sstevel@tonic-gate 		 *
11527c478bd9Sstevel@tonic-gate 		 * NOTE: We do not interpose on the head of a list.  This model
11537c478bd9Sstevel@tonic-gate 		 * evolved because dynamic executables have already been fully
11547c478bd9Sstevel@tonic-gate 		 * relocated within themselves and thus can't be interposed on.
11557c478bd9Sstevel@tonic-gate 		 * Nowadays it's possible to have shared objects at the head of
11567c478bd9Sstevel@tonic-gate 		 * a list, which conceptually means they could be interposed on.
11577c478bd9Sstevel@tonic-gate 		 * But, shared objects can be created via dldump() and may only
11587c478bd9Sstevel@tonic-gate 		 * be partially relocated (just relatives), in which case they
11597c478bd9Sstevel@tonic-gate 		 * are interposable, but are marked as fixed (ET_EXEC).
11607c478bd9Sstevel@tonic-gate 		 *
11617c478bd9Sstevel@tonic-gate 		 * Thus we really don't have a clear method of deciding when the
11627c478bd9Sstevel@tonic-gate 		 * head of a link-map is interposable.  So, to be consistent,
11637c478bd9Sstevel@tonic-gate 		 * for now only add interposers after the link-map lists head
11647c478bd9Sstevel@tonic-gate 		 * object.
11657c478bd9Sstevel@tonic-gate 		 */
1166cb511613SAli Bahrami 		for (tlmp = NEXT_RT_MAP(lmc->lc_head); tlmp;
1167cb511613SAli Bahrami 		    tlmp = NEXT_RT_MAP(tlmp)) {
11687c478bd9Sstevel@tonic-gate 
11699a411307Srie 			if (FLAGS(tlmp) & FLG_RT_OBJINTPO)
11707c478bd9Sstevel@tonic-gate 				continue;
11717c478bd9Sstevel@tonic-gate 
11727c478bd9Sstevel@tonic-gate 			/*
11737c478bd9Sstevel@tonic-gate 			 * Insert the new link-map before this non-interposer,
11747c478bd9Sstevel@tonic-gate 			 * and indicate an interposer is found.
11757c478bd9Sstevel@tonic-gate 			 */
1176cb511613SAli Bahrami 			NEXT(PREV_RT_MAP(tlmp)) = (Link_map *)lmp;
11777c478bd9Sstevel@tonic-gate 			PREV(lmp) = PREV(tlmp);
11787c478bd9Sstevel@tonic-gate 
11797c478bd9Sstevel@tonic-gate 			NEXT(lmp) = (Link_map *)tlmp;
11807c478bd9Sstevel@tonic-gate 			PREV(tlmp) = (Link_map *)lmp;
11817c478bd9Sstevel@tonic-gate 
11827c478bd9Sstevel@tonic-gate 			lmc->lc_flags |= LMC_FLG_REANALYZE;
11837c478bd9Sstevel@tonic-gate 			add = 0;
11847c478bd9Sstevel@tonic-gate 			break;
11857c478bd9Sstevel@tonic-gate 		}
11867c478bd9Sstevel@tonic-gate 	}
11877c478bd9Sstevel@tonic-gate 
11887c478bd9Sstevel@tonic-gate 	/*
11897c478bd9Sstevel@tonic-gate 	 * Fall through to appending the new link map to the tail of the list.
11907c478bd9Sstevel@tonic-gate 	 * If we're processing the initial objects of this link-map list, add
11917c478bd9Sstevel@tonic-gate 	 * them to the backward compatibility list.
11927c478bd9Sstevel@tonic-gate 	 */
11937c478bd9Sstevel@tonic-gate 	if (add) {
11947c478bd9Sstevel@tonic-gate 		NEXT(lmc->lc_tail) = (Link_map *)lmp;
11957c478bd9Sstevel@tonic-gate 		PREV(lmp) = (Link_map *)lmc->lc_tail;
11967c478bd9Sstevel@tonic-gate 		lmc->lc_tail = lmp;
11977c478bd9Sstevel@tonic-gate 	}
11987c478bd9Sstevel@tonic-gate 
11997c478bd9Sstevel@tonic-gate 	/*
12007c478bd9Sstevel@tonic-gate 	 * Having added this link-map to a control list, indicate which control
12017c478bd9Sstevel@tonic-gate 	 * list the link-map belongs to.  Note, control list information is
12027c478bd9Sstevel@tonic-gate 	 * always maintained as an offset, as the Alist can be reallocated.
12037c478bd9Sstevel@tonic-gate 	 */
12047c478bd9Sstevel@tonic-gate 	CNTL(lmp) = lmco;
12057c478bd9Sstevel@tonic-gate 
12067c478bd9Sstevel@tonic-gate 	/*
12077c478bd9Sstevel@tonic-gate 	 * Indicate if an interposer is found.  Note that the first object on a
12087c478bd9Sstevel@tonic-gate 	 * link-map can be explicitly defined as an interposer so that it can
12097c478bd9Sstevel@tonic-gate 	 * provide interposition over direct binding requests.
12107c478bd9Sstevel@tonic-gate 	 */
12119a411307Srie 	if (FLAGS(lmp) & MSK_RT_INTPOSE)
12127c478bd9Sstevel@tonic-gate 		lml->lm_flags |= LML_FLG_INTRPOSE;
12137c478bd9Sstevel@tonic-gate 
12147c478bd9Sstevel@tonic-gate 	/*
12157c478bd9Sstevel@tonic-gate 	 * For backward compatibility with debuggers, the link-map list contains
12167c478bd9Sstevel@tonic-gate 	 * pointers to the main control list.
12177c478bd9Sstevel@tonic-gate 	 */
1218cce0e03bSab 	if (lmco == ALIST_OFF_DATA) {
12197c478bd9Sstevel@tonic-gate 		lml->lm_head = lmc->lc_head;
12207c478bd9Sstevel@tonic-gate 		lml->lm_tail = lmc->lc_tail;
12217c478bd9Sstevel@tonic-gate 	}
12227c478bd9Sstevel@tonic-gate }
12237c478bd9Sstevel@tonic-gate 
12247c478bd9Sstevel@tonic-gate /*
12257c478bd9Sstevel@tonic-gate  * Delete an item from the specified link map control list.
12267c478bd9Sstevel@tonic-gate  */
12277c478bd9Sstevel@tonic-gate void
12287c478bd9Sstevel@tonic-gate lm_delete(Lm_list *lml, Rt_map *lmp)
12297c478bd9Sstevel@tonic-gate {
12307c478bd9Sstevel@tonic-gate 	Lm_cntl	*lmc;
12317c478bd9Sstevel@tonic-gate 
12327c478bd9Sstevel@tonic-gate 	/*
12337c478bd9Sstevel@tonic-gate 	 * If the control list pointer hasn't been initialized, this object
12347c478bd9Sstevel@tonic-gate 	 * never got added to a link-map list.
12357c478bd9Sstevel@tonic-gate 	 */
12367c478bd9Sstevel@tonic-gate 	if (CNTL(lmp) == 0)
12377c478bd9Sstevel@tonic-gate 		return;
12387c478bd9Sstevel@tonic-gate 
12397c478bd9Sstevel@tonic-gate 	/*
124012b8e62eSrie 	 * If we're about to delete an object from the main link-map control
124112b8e62eSrie 	 * list, alert the debuggers that we are about to mess with this list.
12427c478bd9Sstevel@tonic-gate 	 */
1243cce0e03bSab 	if ((CNTL(lmp) == ALIST_OFF_DATA) &&
1244cce0e03bSab 	    ((lml->lm_flags & LML_FLG_DBNOTIF) == 0))
12457c478bd9Sstevel@tonic-gate 		rd_event(lml, RD_DLACTIVITY, RT_DELETE);
12467c478bd9Sstevel@tonic-gate 
12477c478bd9Sstevel@tonic-gate 	/* LINTED */
1248cce0e03bSab 	lmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, CNTL(lmp));
12497c478bd9Sstevel@tonic-gate 
12507c478bd9Sstevel@tonic-gate 	if (lmc->lc_head == lmp)
1251cb511613SAli Bahrami 		lmc->lc_head = NEXT_RT_MAP(lmp);
12527c478bd9Sstevel@tonic-gate 	else
1253cb511613SAli Bahrami 		NEXT(PREV_RT_MAP(lmp)) = (void *)NEXT(lmp);
12547c478bd9Sstevel@tonic-gate 
12557c478bd9Sstevel@tonic-gate 	if (lmc->lc_tail == lmp)
1256cb511613SAli Bahrami 		lmc->lc_tail = PREV_RT_MAP(lmp);
12577c478bd9Sstevel@tonic-gate 	else
1258cb511613SAli Bahrami 		PREV(NEXT_RT_MAP(lmp)) = PREV(lmp);
12597c478bd9Sstevel@tonic-gate 
12607c478bd9Sstevel@tonic-gate 	/*
12617c478bd9Sstevel@tonic-gate 	 * For backward compatibility with debuggers, the link-map list contains
12627c478bd9Sstevel@tonic-gate 	 * pointers to the main control list.
12637c478bd9Sstevel@tonic-gate 	 */
1264cce0e03bSab 	if (lmc == (Lm_cntl *)&lml->lm_lists->al_data) {
12657c478bd9Sstevel@tonic-gate 		lml->lm_head = lmc->lc_head;
12667c478bd9Sstevel@tonic-gate 		lml->lm_tail = lmc->lc_tail;
12677c478bd9Sstevel@tonic-gate 	}
12687c478bd9Sstevel@tonic-gate 
12697c478bd9Sstevel@tonic-gate 	/*
12707c478bd9Sstevel@tonic-gate 	 * Indicate we have one less object on this control list.
12717c478bd9Sstevel@tonic-gate 	 */
12727c478bd9Sstevel@tonic-gate 	(lml->lm_obj)--;
12737c478bd9Sstevel@tonic-gate }
12747c478bd9Sstevel@tonic-gate 
12757c478bd9Sstevel@tonic-gate /*
12767c478bd9Sstevel@tonic-gate  * Move a link-map control list to another.  Objects that are being relocated
12777c478bd9Sstevel@tonic-gate  * are maintained on secondary control lists.  Once their relocation is
12787c478bd9Sstevel@tonic-gate  * complete, the entire list is appended to the previous control list, as this
12797c478bd9Sstevel@tonic-gate  * list must have been the trigger for generating the new control list.
12807c478bd9Sstevel@tonic-gate  */
12817c478bd9Sstevel@tonic-gate void
12827c478bd9Sstevel@tonic-gate lm_move(Lm_list *lml, Aliste nlmco, Aliste plmco, Lm_cntl *nlmc, Lm_cntl *plmc)
12837c478bd9Sstevel@tonic-gate {
12847c478bd9Sstevel@tonic-gate 	Rt_map	*lmp;
12857c478bd9Sstevel@tonic-gate 
12867c478bd9Sstevel@tonic-gate 	/*
128712b8e62eSrie 	 * If we're about to add a new family of objects to the main link-map
128812b8e62eSrie 	 * control list, alert the debuggers that we are about to mess with this
128912b8e62eSrie 	 * list.  Additions of object families to the main link-map control
129012b8e62eSrie 	 * list occur during lazy loading, filtering and dlopen().
12917c478bd9Sstevel@tonic-gate 	 */
1292cce0e03bSab 	if ((plmco == ALIST_OFF_DATA) &&
1293cce0e03bSab 	    ((lml->lm_flags & LML_FLG_DBNOTIF) == 0))
12947c478bd9Sstevel@tonic-gate 		rd_event(lml, RD_DLACTIVITY, RT_ADD);
12957c478bd9Sstevel@tonic-gate 
129612b8e62eSrie 	DBG_CALL(Dbg_file_cntl(lml, nlmco, plmco));
129712b8e62eSrie 
12987c478bd9Sstevel@tonic-gate 	/*
12997c478bd9Sstevel@tonic-gate 	 * Indicate each new link-map has been moved to the previous link-map
13007c478bd9Sstevel@tonic-gate 	 * control list.
13017c478bd9Sstevel@tonic-gate 	 */
130256deab07SRod Evans 	for (lmp = nlmc->lc_head; lmp; lmp = NEXT_RT_MAP(lmp)) {
13037c478bd9Sstevel@tonic-gate 		CNTL(lmp) = plmco;
13047c478bd9Sstevel@tonic-gate 
130556deab07SRod Evans 		/*
130656deab07SRod Evans 		 * If these objects are being added to the main link-map
130756deab07SRod Evans 		 * control list, indicate that there are init's available
130856deab07SRod Evans 		 * for harvesting.
130956deab07SRod Evans 		 */
131056deab07SRod Evans 		if (plmco == ALIST_OFF_DATA) {
131156deab07SRod Evans 			lml->lm_init++;
131256deab07SRod Evans 			lml->lm_flags |= LML_FLG_OBJADDED;
131356deab07SRod Evans 		}
131456deab07SRod Evans 	}
131556deab07SRod Evans 
13167c478bd9Sstevel@tonic-gate 	/*
13177c478bd9Sstevel@tonic-gate 	 * Move the new link-map control list, to the callers link-map control
13187c478bd9Sstevel@tonic-gate 	 * list.
13197c478bd9Sstevel@tonic-gate 	 */
13203dbfc803SRod Evans 	if (plmc->lc_head == NULL) {
13217c478bd9Sstevel@tonic-gate 		plmc->lc_head = nlmc->lc_head;
13223dbfc803SRod Evans 		PREV(nlmc->lc_head) = NULL;
13237c478bd9Sstevel@tonic-gate 	} else {
13247c478bd9Sstevel@tonic-gate 		NEXT(plmc->lc_tail) = (Link_map *)nlmc->lc_head;
13257c478bd9Sstevel@tonic-gate 		PREV(nlmc->lc_head) = (Link_map *)plmc->lc_tail;
13267c478bd9Sstevel@tonic-gate 	}
13277c478bd9Sstevel@tonic-gate 
13287c478bd9Sstevel@tonic-gate 	plmc->lc_tail = nlmc->lc_tail;
13293dbfc803SRod Evans 	nlmc->lc_head = nlmc->lc_tail = NULL;
13307c478bd9Sstevel@tonic-gate 
13317c478bd9Sstevel@tonic-gate 	/*
13327c478bd9Sstevel@tonic-gate 	 * For backward compatibility with debuggers, the link-map list contains
13337c478bd9Sstevel@tonic-gate 	 * pointers to the main control list.
13347c478bd9Sstevel@tonic-gate 	 */
1335cce0e03bSab 	if (plmco == ALIST_OFF_DATA) {
13367c478bd9Sstevel@tonic-gate 		lml->lm_head = plmc->lc_head;
13377c478bd9Sstevel@tonic-gate 		lml->lm_tail = plmc->lc_tail;
13387c478bd9Sstevel@tonic-gate 	}
13397c478bd9Sstevel@tonic-gate }
13407c478bd9Sstevel@tonic-gate 
1341dde769a2SRod Evans /*
1342dde769a2SRod Evans  * Create, or assign a link-map control list.  Each link-map list contains a
1343dde769a2SRod Evans  * main control list, which has an Alist offset of ALIST_OFF_DATA (see the
1344dde769a2SRod Evans  * description in include/rtld.h).  During the initial construction of a
1345dde769a2SRod Evans  * process, objects are added to this main control list.  This control list is
1346dde769a2SRod Evans  * never deleted, unless an alternate link-map list has been requested (say for
1347dde769a2SRod Evans  * auditors), and the associated objects could not be loaded or relocated.
1348dde769a2SRod Evans  *
1349dde769a2SRod Evans  * Once relocation has started, any lazy loadable objects, or filtees, are
1350dde769a2SRod Evans  * processed on a new, temporary control list.  Only when these objects have
1351dde769a2SRod Evans  * been fully relocated, are they moved to the main link-map control list.
1352dde769a2SRod Evans  * Once the objects are moved, this temporary control list is deleted (see
1353dde769a2SRod Evans  * remove_cntl()).
1354dde769a2SRod Evans  *
1355dde769a2SRod Evans  * A dlopen() always requires a new temporary link-map control list.
1356dde769a2SRod Evans  * Typically, a dlopen() occurs on a link-map list that had already started
1357dde769a2SRod Evans  * relocation, however, auditors can dlopen() objects on the main link-map
1358dde769a2SRod Evans  * list while under initial construction, before any relocation has begun.
1359dde769a2SRod Evans  * Hence, dlopen() requests are explicitly flagged.
1360dde769a2SRod Evans  */
1361dde769a2SRod Evans Aliste
1362dde769a2SRod Evans create_cntl(Lm_list *lml, int dlopen)
1363dde769a2SRod Evans {
1364dde769a2SRod Evans 	/*
1365dde769a2SRod Evans 	 * If the head link-map object has already been relocated, create a
1366dde769a2SRod Evans 	 * new, temporary, control list.
1367dde769a2SRod Evans 	 */
1368dde769a2SRod Evans 	if (dlopen || (lml->lm_head == NULL) ||
1369dde769a2SRod Evans 	    (FLAGS(lml->lm_head) & FLG_RT_RELOCED)) {
1370dde769a2SRod Evans 		Lm_cntl *lmc;
1371dde769a2SRod Evans 
1372dde769a2SRod Evans 		if ((lmc = alist_append(&lml->lm_lists, NULL, sizeof (Lm_cntl),
1373dde769a2SRod Evans 		    AL_CNT_LMLISTS)) == NULL)
1374dde769a2SRod Evans 			return (NULL);
1375dde769a2SRod Evans 
1376dde769a2SRod Evans 		return ((Aliste)((char *)lmc - (char *)lml->lm_lists));
1377dde769a2SRod Evans 	}
1378dde769a2SRod Evans 
1379dde769a2SRod Evans 	return (ALIST_OFF_DATA);
1380dde769a2SRod Evans }
1381dde769a2SRod Evans 
13827c478bd9Sstevel@tonic-gate /*
13837c478bd9Sstevel@tonic-gate  * Environment variables can have a variety of defined permutations, and thus
13847c478bd9Sstevel@tonic-gate  * the following infrastructure exists to allow this variety and to select the
13857c478bd9Sstevel@tonic-gate  * required definition.
13867c478bd9Sstevel@tonic-gate  *
13877c478bd9Sstevel@tonic-gate  * Environment variables can be defined as 32- or 64-bit specific, and if so
13887c478bd9Sstevel@tonic-gate  * they will take precedence over any instruction set neutral form.  Typically
13897c478bd9Sstevel@tonic-gate  * this is only useful when the environment value is an informational string.
13907c478bd9Sstevel@tonic-gate  *
13917c478bd9Sstevel@tonic-gate  * Environment variables may be obtained from the standard user environment or
13927c478bd9Sstevel@tonic-gate  * from a configuration file.  The latter provides a fallback if no user
13937c478bd9Sstevel@tonic-gate  * environment setting is found, and can take two forms:
13947c478bd9Sstevel@tonic-gate  *
139543d7826aSRod Evans  *  -	a replaceable definition - this will be used if no user environment
13967c478bd9Sstevel@tonic-gate  *	setting has been seen, or
13977c478bd9Sstevel@tonic-gate  *
139843d7826aSRod Evans  *  -	an permanent definition - this will be used no matter what user
13997c478bd9Sstevel@tonic-gate  *	environment setting is seen.  In the case of list variables it will be
14007c478bd9Sstevel@tonic-gate  *	appended to any process environment setting seen.
14017c478bd9Sstevel@tonic-gate  *
14027c478bd9Sstevel@tonic-gate  * Environment variables can be defined without a value (ie. LD_XXXX=) so as to
14037c478bd9Sstevel@tonic-gate  * override any replaceable environment variables from a configuration file.
14047c478bd9Sstevel@tonic-gate  */
14057c478bd9Sstevel@tonic-gate static	u_longlong_t		rplgen;		/* replaceable generic */
14067c478bd9Sstevel@tonic-gate 						/*	variables */
14077c478bd9Sstevel@tonic-gate static	u_longlong_t		rplisa;		/* replaceable ISA specific */
14087c478bd9Sstevel@tonic-gate 						/*	variables */
14097c478bd9Sstevel@tonic-gate static	u_longlong_t		prmgen;		/* permanent generic */
14107c478bd9Sstevel@tonic-gate 						/*	variables */
14117c478bd9Sstevel@tonic-gate static	u_longlong_t		prmisa;		/* permanent ISA specific */
14127c478bd9Sstevel@tonic-gate 						/*	variables */
14137c478bd9Sstevel@tonic-gate 
14147c478bd9Sstevel@tonic-gate /*
14157c478bd9Sstevel@tonic-gate  * Classify an environment variables type.
14167c478bd9Sstevel@tonic-gate  */
14177c478bd9Sstevel@tonic-gate #define	ENV_TYP_IGNORE		0x1		/* ignore - variable is for */
14187c478bd9Sstevel@tonic-gate 						/*	the wrong ISA */
14197c478bd9Sstevel@tonic-gate #define	ENV_TYP_ISA		0x2		/* variable is ISA specific */
14207c478bd9Sstevel@tonic-gate #define	ENV_TYP_CONFIG		0x4		/* variable obtained from a */
14217c478bd9Sstevel@tonic-gate 						/*	config file */
14227c478bd9Sstevel@tonic-gate #define	ENV_TYP_PERMANT		0x8		/* variable is permanent */
14237c478bd9Sstevel@tonic-gate 
14247c478bd9Sstevel@tonic-gate /*
14257c478bd9Sstevel@tonic-gate  * Identify all environment variables.
14267c478bd9Sstevel@tonic-gate  */
1427*08278a5eSRod Evans #define	ENV_FLG_AUDIT		0x0000000000001ULL
1428*08278a5eSRod Evans #define	ENV_FLG_AUDIT_ARGS	0x0000000000002ULL
1429*08278a5eSRod Evans #define	ENV_FLG_BIND_NOW	0x0000000000004ULL
1430*08278a5eSRod Evans #define	ENV_FLG_BIND_NOT	0x0000000000008ULL
1431*08278a5eSRod Evans #define	ENV_FLG_BINDINGS	0x0000000000010ULL
1432*08278a5eSRod Evans #define	ENV_FLG_CONFGEN		0x0000000000020ULL
1433*08278a5eSRod Evans #define	ENV_FLG_CONFIG		0x0000000000040ULL
1434*08278a5eSRod Evans #define	ENV_FLG_DEBUG		0x0000000000080ULL
1435*08278a5eSRod Evans #define	ENV_FLG_DEBUG_OUTPUT	0x0000000000100ULL
1436*08278a5eSRod Evans #define	ENV_FLG_DEMANGLE	0x0000000000200ULL
1437*08278a5eSRod Evans #define	ENV_FLG_FLAGS		0x0000000000400ULL
1438*08278a5eSRod Evans #define	ENV_FLG_INIT		0x0000000000800ULL
1439*08278a5eSRod Evans #define	ENV_FLG_LIBPATH		0x0000000001000ULL
1440*08278a5eSRod Evans #define	ENV_FLG_LOADAVAIL	0x0000000002000ULL
1441*08278a5eSRod Evans #define	ENV_FLG_LOADFLTR	0x0000000004000ULL
1442*08278a5eSRod Evans #define	ENV_FLG_NOAUDIT		0x0000000008000ULL
1443*08278a5eSRod Evans #define	ENV_FLG_NOAUXFLTR	0x0000000010000ULL
1444*08278a5eSRod Evans #define	ENV_FLG_NOBAPLT		0x0000000020000ULL
1445*08278a5eSRod Evans #define	ENV_FLG_NOCONFIG	0x0000000040000ULL
1446*08278a5eSRod Evans #define	ENV_FLG_NODIRCONFIG	0x0000000080000ULL
1447*08278a5eSRod Evans #define	ENV_FLG_NODIRECT	0x0000000100000ULL
1448*08278a5eSRod Evans #define	ENV_FLG_NOENVCONFIG	0x0000000200000ULL
1449*08278a5eSRod Evans #define	ENV_FLG_NOLAZY		0x0000000400000ULL
1450*08278a5eSRod Evans #define	ENV_FLG_NOOBJALTER	0x0000000800000ULL
1451*08278a5eSRod Evans #define	ENV_FLG_NOVERSION	0x0000001000000ULL
1452*08278a5eSRod Evans #define	ENV_FLG_PRELOAD		0x0000002000000ULL
1453*08278a5eSRod Evans #define	ENV_FLG_PROFILE		0x0000004000000ULL
1454*08278a5eSRod Evans #define	ENV_FLG_PROFILE_OUTPUT	0x0000008000000ULL
1455*08278a5eSRod Evans #define	ENV_FLG_SIGNAL		0x0000010000000ULL
1456*08278a5eSRod Evans #define	ENV_FLG_TRACE_OBJS	0x0000020000000ULL
1457*08278a5eSRod Evans #define	ENV_FLG_TRACE_PTHS	0x0000040000000ULL
1458*08278a5eSRod Evans #define	ENV_FLG_UNREF		0x0000080000000ULL
1459*08278a5eSRod Evans #define	ENV_FLG_UNUSED		0x0000100000000ULL
1460*08278a5eSRod Evans #define	ENV_FLG_VERBOSE		0x0000200000000ULL
1461*08278a5eSRod Evans #define	ENV_FLG_WARN		0x0000400000000ULL
1462*08278a5eSRod Evans #define	ENV_FLG_NOFLTCONFIG	0x0000800000000ULL
1463*08278a5eSRod Evans #define	ENV_FLG_BIND_LAZY	0x0001000000000ULL
1464*08278a5eSRod Evans #define	ENV_FLG_NOUNRESWEAK	0x0002000000000ULL
1465*08278a5eSRod Evans #define	ENV_FLG_NOPAREXT	0x0004000000000ULL
1466*08278a5eSRod Evans #define	ENV_FLG_HWCAP		0x0008000000000ULL
1467*08278a5eSRod Evans #define	ENV_FLG_SFCAP		0x0010000000000ULL
1468*08278a5eSRod Evans #define	ENV_FLG_MACHCAP		0x0020000000000ULL
1469*08278a5eSRod Evans #define	ENV_FLG_PLATCAP		0x0040000000000ULL
1470*08278a5eSRod Evans #define	ENV_FLG_CAP_FILES	0x0080000000000ULL
14717c478bd9Sstevel@tonic-gate 
14727c478bd9Sstevel@tonic-gate #define	SEL_REPLACE		0x0001
14737c478bd9Sstevel@tonic-gate #define	SEL_PERMANT		0x0002
14747c478bd9Sstevel@tonic-gate #define	SEL_ACT_RT		0x0100	/* setting rtld_flags */
14757c478bd9Sstevel@tonic-gate #define	SEL_ACT_RT2		0x0200	/* setting rtld_flags2 */
14767c478bd9Sstevel@tonic-gate #define	SEL_ACT_STR		0x0400	/* setting string value */
14777c478bd9Sstevel@tonic-gate #define	SEL_ACT_LML		0x0800	/* setting lml_flags */
14787c478bd9Sstevel@tonic-gate #define	SEL_ACT_LMLT		0x1000	/* setting lml_tflags */
1479635216b6SRod Evans #define	SEL_ACT_SPEC_1		0x2000	/* for FLG_{FLAGS, LIBPATH} */
14807c478bd9Sstevel@tonic-gate #define	SEL_ACT_SPEC_2		0x4000	/* need special handling */
14817c478bd9Sstevel@tonic-gate 
14827c478bd9Sstevel@tonic-gate /*
14837c478bd9Sstevel@tonic-gate  * Pattern match an LD_XXXX environment variable.  s1 points to the XXXX part
14847c478bd9Sstevel@tonic-gate  * and len specifies its length (comparing a strings length before the string
14857c478bd9Sstevel@tonic-gate  * itself speed things up).  s2 points to the token itself which has already
14867c478bd9Sstevel@tonic-gate  * had any leading white-space removed.
14877c478bd9Sstevel@tonic-gate  */
14887c478bd9Sstevel@tonic-gate static void
14897c478bd9Sstevel@tonic-gate ld_generic_env(const char *s1, size_t len, const char *s2, Word *lmflags,
14907c478bd9Sstevel@tonic-gate     Word *lmtflags, uint_t env_flags, int aout)
14917c478bd9Sstevel@tonic-gate {
14927c478bd9Sstevel@tonic-gate 	u_longlong_t	variable = 0;
149310a4fa49Srie 	ushort_t	select = 0;
149410a4fa49Srie 	const char	**str;
149510a4fa49Srie 	Word		val = 0;
14967c478bd9Sstevel@tonic-gate 
14977c478bd9Sstevel@tonic-gate 	/*
14987c478bd9Sstevel@tonic-gate 	 * Determine whether we're dealing with a replaceable or permanent
14997c478bd9Sstevel@tonic-gate 	 * string.
15007c478bd9Sstevel@tonic-gate 	 */
15017c478bd9Sstevel@tonic-gate 	if (env_flags & ENV_TYP_PERMANT) {
15027c478bd9Sstevel@tonic-gate 		/*
15037c478bd9Sstevel@tonic-gate 		 * If the string is from a configuration file and defined as
15047c478bd9Sstevel@tonic-gate 		 * permanent, assign it as permanent.
15057c478bd9Sstevel@tonic-gate 		 */
15067c478bd9Sstevel@tonic-gate 		select |= SEL_PERMANT;
15077c478bd9Sstevel@tonic-gate 	} else
15087c478bd9Sstevel@tonic-gate 		select |= SEL_REPLACE;
15097c478bd9Sstevel@tonic-gate 
15107c478bd9Sstevel@tonic-gate 	/*
15117c478bd9Sstevel@tonic-gate 	 * Parse the variable given.
15127c478bd9Sstevel@tonic-gate 	 *
15137c478bd9Sstevel@tonic-gate 	 * The LD_AUDIT family.
15147c478bd9Sstevel@tonic-gate 	 */
15157c478bd9Sstevel@tonic-gate 	if (*s1 == 'A') {
15167c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_AUDIT_SIZE) && (strncmp(s1,
15177c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_AUDIT), MSG_LD_AUDIT_SIZE) == 0)) {
15187c478bd9Sstevel@tonic-gate 			/*
15197c478bd9Sstevel@tonic-gate 			 * Replaceable and permanent audit objects can exist.
15207c478bd9Sstevel@tonic-gate 			 */
15217c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_STR;
1522dde769a2SRod Evans 			str = (select & SEL_REPLACE) ? &rpl_audit : &prm_audit;
15237c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_AUDIT;
15247c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_AUDIT_ARGS_SIZE) &&
15257c478bd9Sstevel@tonic-gate 		    (strncmp(s1, MSG_ORIG(MSG_LD_AUDIT_ARGS),
15267c478bd9Sstevel@tonic-gate 		    MSG_LD_AUDIT_ARGS_SIZE) == 0)) {
15277c478bd9Sstevel@tonic-gate 			/*
15287c478bd9Sstevel@tonic-gate 			 * A specialized variable for plt_exit() use, not
15297c478bd9Sstevel@tonic-gate 			 * documented for general use.
15307c478bd9Sstevel@tonic-gate 			 */
15317c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_2;
15327c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_AUDIT_ARGS;
15337c478bd9Sstevel@tonic-gate 		}
15347c478bd9Sstevel@tonic-gate 	}
15357c478bd9Sstevel@tonic-gate 	/*
153656deab07SRod Evans 	 * The LD_BIND family.
15377c478bd9Sstevel@tonic-gate 	 */
15387c478bd9Sstevel@tonic-gate 	else if (*s1 == 'B') {
1539dffec89cSrie 		if ((len == MSG_LD_BIND_LAZY_SIZE) && (strncmp(s1,
1540dffec89cSrie 		    MSG_ORIG(MSG_LD_BIND_LAZY),
1541dffec89cSrie 		    MSG_LD_BIND_LAZY_SIZE) == 0)) {
1542dffec89cSrie 			select |= SEL_ACT_RT2;
1543dffec89cSrie 			val = RT_FL2_BINDLAZY;
1544dffec89cSrie 			variable = ENV_FLG_BIND_LAZY;
1545dffec89cSrie 		} else if ((len == MSG_LD_BIND_NOW_SIZE) && (strncmp(s1,
15467c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_BIND_NOW), MSG_LD_BIND_NOW_SIZE) == 0)) {
15477c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT2;
15487c478bd9Sstevel@tonic-gate 			val = RT_FL2_BINDNOW;
15497c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_BIND_NOW;
15507c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_BIND_NOT_SIZE) && (strncmp(s1,
15517c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_BIND_NOT), MSG_LD_BIND_NOT_SIZE) == 0)) {
15527c478bd9Sstevel@tonic-gate 			/*
15537c478bd9Sstevel@tonic-gate 			 * Another trick, enabled to help debug AOUT
15547c478bd9Sstevel@tonic-gate 			 * applications under BCP, but not documented for
15557c478bd9Sstevel@tonic-gate 			 * general use.
15567c478bd9Sstevel@tonic-gate 			 */
15577c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
15587c478bd9Sstevel@tonic-gate 			val = RT_FL_NOBIND;
15597c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_BIND_NOT;
15607c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_BINDINGS_SIZE) && (strncmp(s1,
15617c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_BINDINGS), MSG_LD_BINDINGS_SIZE) == 0)) {
15627c478bd9Sstevel@tonic-gate 			/*
15637c478bd9Sstevel@tonic-gate 			 * This variable is simply for backward compatibility.
15647c478bd9Sstevel@tonic-gate 			 * If this and LD_DEBUG are both specified, only one of
15657c478bd9Sstevel@tonic-gate 			 * the strings is going to get processed.
15667c478bd9Sstevel@tonic-gate 			 */
15677c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_2;
15687c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_BINDINGS;
15697c478bd9Sstevel@tonic-gate 		}
15707c478bd9Sstevel@tonic-gate 	}
15717c478bd9Sstevel@tonic-gate 	/*
1572*08278a5eSRod Evans 	 * LD_CAP_FILES and LD_CONFIG family.
15737c478bd9Sstevel@tonic-gate 	 */
15747c478bd9Sstevel@tonic-gate 	else if (*s1 == 'C') {
1575*08278a5eSRod Evans 		if ((len == MSG_LD_CAP_FILES_SIZE) && (strncmp(s1,
1576*08278a5eSRod Evans 		    MSG_ORIG(MSG_LD_CAP_FILES), MSG_LD_CAP_FILES_SIZE) == 0)) {
1577*08278a5eSRod Evans 			select |= SEL_ACT_STR;
1578*08278a5eSRod Evans 			str = (select & SEL_REPLACE) ?
1579*08278a5eSRod Evans 			    &rpl_cap_files : &prm_cap_files;
1580*08278a5eSRod Evans 			variable = ENV_FLG_CAP_FILES;
1581*08278a5eSRod Evans 		} else if ((len == MSG_LD_CONFGEN_SIZE) && (strncmp(s1,
15827c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_CONFGEN), MSG_LD_CONFGEN_SIZE) == 0)) {
15837c478bd9Sstevel@tonic-gate 			/*
15847c478bd9Sstevel@tonic-gate 			 * Set by crle(1) to indicate it's building a
15857c478bd9Sstevel@tonic-gate 			 * configuration file, not documented for general use.
15867c478bd9Sstevel@tonic-gate 			 */
15877c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_2;
15887c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_CONFGEN;
15897c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_CONFIG_SIZE) && (strncmp(s1,
15907c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_CONFIG), MSG_LD_CONFIG_SIZE) == 0)) {
15917c478bd9Sstevel@tonic-gate 			/*
15927c478bd9Sstevel@tonic-gate 			 * Secure applications must use a default configuration
15937c478bd9Sstevel@tonic-gate 			 * file.  A setting from a configuration file doesn't
15947c478bd9Sstevel@tonic-gate 			 * make sense (given we must be reading a configuration
15957c478bd9Sstevel@tonic-gate 			 * file to have gotten this).
15967c478bd9Sstevel@tonic-gate 			 */
15977c478bd9Sstevel@tonic-gate 			if ((rtld_flags & RT_FL_SECURE) ||
15987c478bd9Sstevel@tonic-gate 			    (env_flags & ENV_TYP_CONFIG))
15997c478bd9Sstevel@tonic-gate 				return;
16007c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_STR;
16017c478bd9Sstevel@tonic-gate 			str = &config->c_name;
16027c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_CONFIG;
16037c478bd9Sstevel@tonic-gate 		}
16047c478bd9Sstevel@tonic-gate 	}
16057c478bd9Sstevel@tonic-gate 	/*
16067c478bd9Sstevel@tonic-gate 	 * The LD_DEBUG family and LD_DEMANGLE.
16077c478bd9Sstevel@tonic-gate 	 */
16087c478bd9Sstevel@tonic-gate 	else if (*s1 == 'D') {
16097c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_DEBUG_SIZE) && (strncmp(s1,
16107c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_DEBUG), MSG_LD_DEBUG_SIZE) == 0)) {
16117c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_STR;
1612dde769a2SRod Evans 			str = (select & SEL_REPLACE) ? &rpl_debug : &prm_debug;
16137c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_DEBUG;
16147c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_DEBUG_OUTPUT_SIZE) && (strncmp(s1,
16157c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_DEBUG_OUTPUT),
16167c478bd9Sstevel@tonic-gate 		    MSG_LD_DEBUG_OUTPUT_SIZE) == 0)) {
16177c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_STR;
16187c478bd9Sstevel@tonic-gate 			str = &dbg_file;
16197c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_DEBUG_OUTPUT;
16207c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_DEMANGLE_SIZE) && (strncmp(s1,
16217c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_DEMANGLE), MSG_LD_DEMANGLE_SIZE) == 0)) {
16227c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
16237c478bd9Sstevel@tonic-gate 			val = RT_FL_DEMANGLE;
16247c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_DEMANGLE;
16257c478bd9Sstevel@tonic-gate 		}
16267c478bd9Sstevel@tonic-gate 	}
16277c478bd9Sstevel@tonic-gate 	/*
16287c478bd9Sstevel@tonic-gate 	 * LD_FLAGS - collect the best variable definition.  On completion of
16297c478bd9Sstevel@tonic-gate 	 * environment variable processing pass the result to ld_flags_env()
16307c478bd9Sstevel@tonic-gate 	 * where they'll be decomposed and passed back to this routine.
16317c478bd9Sstevel@tonic-gate 	 */
16327c478bd9Sstevel@tonic-gate 	else if (*s1 == 'F') {
16337c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_FLAGS_SIZE) && (strncmp(s1,
16347c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_FLAGS), MSG_LD_FLAGS_SIZE) == 0)) {
16357c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_1;
1636dde769a2SRod Evans 			str = (select & SEL_REPLACE) ? &rpl_ldflags :
1637dde769a2SRod Evans 			    &prm_ldflags;
16387c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_FLAGS;
16397c478bd9Sstevel@tonic-gate 		}
16407c478bd9Sstevel@tonic-gate 	}
1641*08278a5eSRod Evans 	/*
1642*08278a5eSRod Evans 	 * LD_HWCAP.
1643*08278a5eSRod Evans 	 */
1644*08278a5eSRod Evans 	else if (*s1 == 'H') {
1645*08278a5eSRod Evans 		if ((len == MSG_LD_HWCAP_SIZE) && (strncmp(s1,
1646*08278a5eSRod Evans 		    MSG_ORIG(MSG_LD_HWCAP), MSG_LD_HWCAP_SIZE) == 0)) {
1647*08278a5eSRod Evans 			select |= SEL_ACT_STR;
1648*08278a5eSRod Evans 			str = (select & SEL_REPLACE) ?
1649*08278a5eSRod Evans 			    &rpl_hwcap : &prm_hwcap;
1650*08278a5eSRod Evans 			variable = ENV_FLG_HWCAP;
1651*08278a5eSRod Evans 		}
1652*08278a5eSRod Evans 	}
16537c478bd9Sstevel@tonic-gate 	/*
16547c478bd9Sstevel@tonic-gate 	 * LD_INIT (internal, used by ldd(1)).
16557c478bd9Sstevel@tonic-gate 	 */
16567c478bd9Sstevel@tonic-gate 	else if (*s1 == 'I') {
16577c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_INIT_SIZE) && (strncmp(s1,
16587c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_INIT), MSG_LD_INIT_SIZE) == 0)) {
16597c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LML;
16607c478bd9Sstevel@tonic-gate 			val = LML_FLG_TRC_INIT;
16617c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_INIT;
16627c478bd9Sstevel@tonic-gate 		}
16637c478bd9Sstevel@tonic-gate 	}
16647c478bd9Sstevel@tonic-gate 	/*
16657c478bd9Sstevel@tonic-gate 	 * The LD_LIBRARY_PATH and LD_LOAD families.
16667c478bd9Sstevel@tonic-gate 	 */
16677c478bd9Sstevel@tonic-gate 	else if (*s1 == 'L') {
16687c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_LIBPATH_SIZE) && (strncmp(s1,
16697c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_LIBPATH), MSG_LD_LIBPATH_SIZE) == 0)) {
16707c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_1;
1671dde769a2SRod Evans 			str = (select & SEL_REPLACE) ? &rpl_libpath :
1672dde769a2SRod Evans 			    &prm_libpath;
16737c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_LIBPATH;
16747c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_LOADAVAIL_SIZE) && (strncmp(s1,
16757c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_LOADAVAIL), MSG_LD_LOADAVAIL_SIZE) == 0)) {
16767c478bd9Sstevel@tonic-gate 			/*
16777c478bd9Sstevel@tonic-gate 			 * Internal use by crle(1), not documented for general
16787c478bd9Sstevel@tonic-gate 			 * use.
16797c478bd9Sstevel@tonic-gate 			 */
16807c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LML;
16817c478bd9Sstevel@tonic-gate 			val = LML_FLG_LOADAVAIL;
16827c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_LOADAVAIL;
16837c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_LOADFLTR_SIZE) && (strncmp(s1,
16847c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_LOADFLTR), MSG_LD_LOADFLTR_SIZE) == 0)) {
16857c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_2;
16867c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_LOADFLTR;
16877c478bd9Sstevel@tonic-gate 		}
16887c478bd9Sstevel@tonic-gate 	}
1689*08278a5eSRod Evans 	/*
1690*08278a5eSRod Evans 	 * LD_MACHCAP.
1691*08278a5eSRod Evans 	 */
1692*08278a5eSRod Evans 	else if (*s1 == 'M') {
1693*08278a5eSRod Evans 		if ((len == MSG_LD_MACHCAP_SIZE) && (strncmp(s1,
1694*08278a5eSRod Evans 		    MSG_ORIG(MSG_LD_MACHCAP), MSG_LD_MACHCAP_SIZE) == 0)) {
1695*08278a5eSRod Evans 			select |= SEL_ACT_STR;
1696*08278a5eSRod Evans 			str = (select & SEL_REPLACE) ?
1697*08278a5eSRod Evans 			    &rpl_machcap : &prm_machcap;
1698*08278a5eSRod Evans 			variable = ENV_FLG_MACHCAP;
1699*08278a5eSRod Evans 		}
1700*08278a5eSRod Evans 	}
17017c478bd9Sstevel@tonic-gate 	/*
17027c478bd9Sstevel@tonic-gate 	 * The LD_NO family.
17037c478bd9Sstevel@tonic-gate 	 */
17047c478bd9Sstevel@tonic-gate 	else if (*s1 == 'N') {
17057c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_NOAUDIT_SIZE) && (strncmp(s1,
17067c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOAUDIT), MSG_LD_NOAUDIT_SIZE) == 0)) {
17077c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
17087c478bd9Sstevel@tonic-gate 			val = RT_FL_NOAUDIT;
17097c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOAUDIT;
17107c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NOAUXFLTR_SIZE) && (strncmp(s1,
17117c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOAUXFLTR), MSG_LD_NOAUXFLTR_SIZE) == 0)) {
17127c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
17137c478bd9Sstevel@tonic-gate 			val = RT_FL_NOAUXFLTR;
17147c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOAUXFLTR;
17157c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NOBAPLT_SIZE) && (strncmp(s1,
17167c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOBAPLT), MSG_LD_NOBAPLT_SIZE) == 0)) {
17177c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
17187c478bd9Sstevel@tonic-gate 			val = RT_FL_NOBAPLT;
17197c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOBAPLT;
17207c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NOCONFIG_SIZE) && (strncmp(s1,
17217c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOCONFIG), MSG_LD_NOCONFIG_SIZE) == 0)) {
17227c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
17237c478bd9Sstevel@tonic-gate 			val = RT_FL_NOCFG;
17247c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOCONFIG;
17257c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NODIRCONFIG_SIZE) && (strncmp(s1,
17267c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NODIRCONFIG),
17277c478bd9Sstevel@tonic-gate 		    MSG_LD_NODIRCONFIG_SIZE) == 0)) {
17287c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
17297c478bd9Sstevel@tonic-gate 			val = RT_FL_NODIRCFG;
17307c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NODIRCONFIG;
17317c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NODIRECT_SIZE) && (strncmp(s1,
17327c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NODIRECT), MSG_LD_NODIRECT_SIZE) == 0)) {
17337c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LMLT;
17347c478bd9Sstevel@tonic-gate 			val = LML_TFLG_NODIRECT;
17357c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NODIRECT;
17367c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NOENVCONFIG_SIZE) && (strncmp(s1,
17377c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOENVCONFIG),
17387c478bd9Sstevel@tonic-gate 		    MSG_LD_NOENVCONFIG_SIZE) == 0)) {
17397c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
17407c478bd9Sstevel@tonic-gate 			val = RT_FL_NOENVCFG;
17417c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOENVCONFIG;
17427c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NOFLTCONFIG_SIZE) && (strncmp(s1,
17437c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOFLTCONFIG),
17447c478bd9Sstevel@tonic-gate 		    MSG_LD_NOFLTCONFIG_SIZE) == 0)) {
17457c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT2;
17467c478bd9Sstevel@tonic-gate 			val = RT_FL2_NOFLTCFG;
17477c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOFLTCONFIG;
17487c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NOLAZY_SIZE) && (strncmp(s1,
17497c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOLAZY), MSG_LD_NOLAZY_SIZE) == 0)) {
17507c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LMLT;
17517c478bd9Sstevel@tonic-gate 			val = LML_TFLG_NOLAZYLD;
17527c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOLAZY;
17537c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NOOBJALTER_SIZE) && (strncmp(s1,
17547c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOOBJALTER),
17557c478bd9Sstevel@tonic-gate 		    MSG_LD_NOOBJALTER_SIZE) == 0)) {
17567c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
17577c478bd9Sstevel@tonic-gate 			val = RT_FL_NOOBJALT;
17587c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOOBJALTER;
17597c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_NOVERSION_SIZE) && (strncmp(s1,
17607c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_NOVERSION), MSG_LD_NOVERSION_SIZE) == 0)) {
17617c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_RT;
17627c478bd9Sstevel@tonic-gate 			val = RT_FL_NOVERSION;
17637c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_NOVERSION;
1764df4628cbSrie 		} else if ((len == MSG_LD_NOUNRESWEAK_SIZE) && (strncmp(s1,
1765df4628cbSrie 		    MSG_ORIG(MSG_LD_NOUNRESWEAK),
1766df4628cbSrie 		    MSG_LD_NOUNRESWEAK_SIZE) == 0)) {
1767df4628cbSrie 			/*
1768df4628cbSrie 			 * LD_NOUNRESWEAK (internal, used by ldd(1)).
1769df4628cbSrie 			 */
1770df4628cbSrie 			select |= SEL_ACT_LML;
1771df4628cbSrie 			val = LML_FLG_TRC_NOUNRESWEAK;
1772df4628cbSrie 			variable = ENV_FLG_NOUNRESWEAK;
1773dae2dfb7Srie 		} else if ((len == MSG_LD_NOPAREXT_SIZE) && (strncmp(s1,
1774dae2dfb7Srie 		    MSG_ORIG(MSG_LD_NOPAREXT), MSG_LD_NOPAREXT_SIZE) == 0)) {
1775dae2dfb7Srie 			select |= SEL_ACT_LML;
1776dae2dfb7Srie 			val = LML_FLG_TRC_NOPAREXT;
1777dae2dfb7Srie 			variable = ENV_FLG_NOPAREXT;
17787c478bd9Sstevel@tonic-gate 		}
17797c478bd9Sstevel@tonic-gate 	}
17807c478bd9Sstevel@tonic-gate 	/*
1781*08278a5eSRod Evans 	 * LD_PLATCAP, LD_PRELOAD and LD_PROFILE family.
17827c478bd9Sstevel@tonic-gate 	 */
17837c478bd9Sstevel@tonic-gate 	else if (*s1 == 'P') {
1784*08278a5eSRod Evans 		if ((len == MSG_LD_PLATCAP_SIZE) && (strncmp(s1,
1785*08278a5eSRod Evans 		    MSG_ORIG(MSG_LD_PLATCAP), MSG_LD_PLATCAP_SIZE) == 0)) {
1786*08278a5eSRod Evans 			select |= SEL_ACT_STR;
1787*08278a5eSRod Evans 			str = (select & SEL_REPLACE) ?
1788*08278a5eSRod Evans 			    &rpl_platcap : &prm_platcap;
1789*08278a5eSRod Evans 			variable = ENV_FLG_PLATCAP;
1790*08278a5eSRod Evans 		} else if ((len == MSG_LD_PRELOAD_SIZE) && (strncmp(s1,
17917c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_PRELOAD), MSG_LD_PRELOAD_SIZE) == 0)) {
17927c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_STR;
1793dde769a2SRod Evans 			str = (select & SEL_REPLACE) ? &rpl_preload :
1794dde769a2SRod Evans 			    &prm_preload;
17957c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_PRELOAD;
17967c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_PROFILE_SIZE) && (strncmp(s1,
17977c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_PROFILE), MSG_LD_PROFILE_SIZE) == 0)) {
17987c478bd9Sstevel@tonic-gate 			/*
17997c478bd9Sstevel@tonic-gate 			 * Only one user library can be profiled at a time.
18007c478bd9Sstevel@tonic-gate 			 */
18017c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_2;
18027c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_PROFILE;
18037c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_PROFILE_OUTPUT_SIZE) && (strncmp(s1,
18047c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_PROFILE_OUTPUT),
18057c478bd9Sstevel@tonic-gate 		    MSG_LD_PROFILE_OUTPUT_SIZE) == 0)) {
18067c478bd9Sstevel@tonic-gate 			/*
18077c478bd9Sstevel@tonic-gate 			 * Only one user library can be profiled at a time.
18087c478bd9Sstevel@tonic-gate 			 */
18097c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_STR;
18107c478bd9Sstevel@tonic-gate 			str = &profile_out;
18117c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_PROFILE_OUTPUT;
18127c478bd9Sstevel@tonic-gate 		}
18137c478bd9Sstevel@tonic-gate 	}
18147c478bd9Sstevel@tonic-gate 	/*
1815*08278a5eSRod Evans 	 * LD_SFCAP and LD_SIGNAL.
18167c478bd9Sstevel@tonic-gate 	 */
18177c478bd9Sstevel@tonic-gate 	else if (*s1 == 'S') {
1818*08278a5eSRod Evans 		if ((len == MSG_LD_SFCAP_SIZE) && (strncmp(s1,
1819*08278a5eSRod Evans 		    MSG_ORIG(MSG_LD_SFCAP), MSG_LD_SFCAP_SIZE) == 0)) {
1820*08278a5eSRod Evans 			select |= SEL_ACT_STR;
1821*08278a5eSRod Evans 			str = (select & SEL_REPLACE) ?
1822*08278a5eSRod Evans 			    &rpl_sfcap : &prm_sfcap;
1823*08278a5eSRod Evans 			variable = ENV_FLG_SFCAP;
1824*08278a5eSRod Evans 		} else if ((len == MSG_LD_SIGNAL_SIZE) &&
18257c478bd9Sstevel@tonic-gate 		    (strncmp(s1, MSG_ORIG(MSG_LD_SIGNAL),
1826*08278a5eSRod Evans 		    MSG_LD_SIGNAL_SIZE) == 0) &&
1827*08278a5eSRod Evans 		    ((rtld_flags & RT_FL_SECURE) == 0)) {
18287c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_2;
18297c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_SIGNAL;
18307c478bd9Sstevel@tonic-gate 		}
18317c478bd9Sstevel@tonic-gate 	}
18327c478bd9Sstevel@tonic-gate 	/*
18331d1fba8aSrie 	 * The LD_TRACE family (internal, used by ldd(1)).  This definition is
18341d1fba8aSrie 	 * the key to enabling all other ldd(1) specific environment variables.
18351d1fba8aSrie 	 * In case an auditor is called, which in turn might exec(2) a
18361d1fba8aSrie 	 * subprocess, this variable is disabled, so that any subprocess
18371d1fba8aSrie 	 * escapes ldd(1) processing.
18387c478bd9Sstevel@tonic-gate 	 */
18397c478bd9Sstevel@tonic-gate 	else if (*s1 == 'T') {
18407c478bd9Sstevel@tonic-gate 		if (((len == MSG_LD_TRACE_OBJS_SIZE) &&
18417c478bd9Sstevel@tonic-gate 		    (strncmp(s1, MSG_ORIG(MSG_LD_TRACE_OBJS),
18427c478bd9Sstevel@tonic-gate 		    MSG_LD_TRACE_OBJS_SIZE) == 0)) ||
18437c478bd9Sstevel@tonic-gate 		    ((len == MSG_LD_TRACE_OBJS_E_SIZE) &&
18447c478bd9Sstevel@tonic-gate 		    (((strncmp(s1, MSG_ORIG(MSG_LD_TRACE_OBJS_E),
18457c478bd9Sstevel@tonic-gate 		    MSG_LD_TRACE_OBJS_E_SIZE) == 0) && !aout) ||
18467c478bd9Sstevel@tonic-gate 		    ((strncmp(s1, MSG_ORIG(MSG_LD_TRACE_OBJS_A),
18477c478bd9Sstevel@tonic-gate 		    MSG_LD_TRACE_OBJS_A_SIZE) == 0) && aout)))) {
18481d1fba8aSrie 			char	*s0 = (char *)s1;
18491d1fba8aSrie 
18507c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_SPEC_2;
18517c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_TRACE_OBJS;
18521d1fba8aSrie 
185302ca3e02Srie #if	defined(__sparc) || defined(__x86)
18541d1fba8aSrie 			/*
18551d1fba8aSrie 			 * The simplest way to "disable" this variable is to
18561d1fba8aSrie 			 * truncate this string to "LD_'\0'". This string is
18571d1fba8aSrie 			 * ignored by any ld.so.1 environment processing.
18581d1fba8aSrie 			 * Use of such interfaces as unsetenv(3c) are overkill,
18591d1fba8aSrie 			 * and would drag too much libc implementation detail
18601d1fba8aSrie 			 * into ld.so.1.
18611d1fba8aSrie 			 */
1862a953e2b1Srie 			*s0 = '\0';
18631d1fba8aSrie #else
18641d1fba8aSrie /*
18651d1fba8aSrie  * Verify that the above write is appropriate for any new platforms.
18661d1fba8aSrie  */
18671d1fba8aSrie #error	unsupported architecture!
18681d1fba8aSrie #endif
18697c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_TRACE_PTHS_SIZE) && (strncmp(s1,
18707c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_TRACE_PTHS),
18717c478bd9Sstevel@tonic-gate 		    MSG_LD_TRACE_PTHS_SIZE) == 0)) {
18727c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LML;
18737c478bd9Sstevel@tonic-gate 			val = LML_FLG_TRC_SEARCH;
18747c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_TRACE_PTHS;
18757c478bd9Sstevel@tonic-gate 		}
18767c478bd9Sstevel@tonic-gate 	}
18777c478bd9Sstevel@tonic-gate 	/*
18787c478bd9Sstevel@tonic-gate 	 * LD_UNREF and LD_UNUSED (internal, used by ldd(1)).
18797c478bd9Sstevel@tonic-gate 	 */
18807c478bd9Sstevel@tonic-gate 	else if (*s1 == 'U') {
18817c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_UNREF_SIZE) && (strncmp(s1,
18827c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_UNREF), MSG_LD_UNREF_SIZE) == 0)) {
18837c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LML;
18847c478bd9Sstevel@tonic-gate 			val = LML_FLG_TRC_UNREF;
18857c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_UNREF;
18867c478bd9Sstevel@tonic-gate 		} else if ((len == MSG_LD_UNUSED_SIZE) && (strncmp(s1,
18877c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_UNUSED), MSG_LD_UNUSED_SIZE) == 0)) {
18887c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LML;
18897c478bd9Sstevel@tonic-gate 			val = LML_FLG_TRC_UNUSED;
18907c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_UNUSED;
18917c478bd9Sstevel@tonic-gate 		}
18927c478bd9Sstevel@tonic-gate 	}
18937c478bd9Sstevel@tonic-gate 	/*
18947c478bd9Sstevel@tonic-gate 	 * LD_VERBOSE (internal, used by ldd(1)).
18957c478bd9Sstevel@tonic-gate 	 */
18967c478bd9Sstevel@tonic-gate 	else if (*s1 == 'V') {
18977c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_VERBOSE_SIZE) && (strncmp(s1,
18987c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_VERBOSE), MSG_LD_VERBOSE_SIZE) == 0)) {
18997c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LML;
19007c478bd9Sstevel@tonic-gate 			val = LML_FLG_TRC_VERBOSE;
19017c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_VERBOSE;
19027c478bd9Sstevel@tonic-gate 		}
19037c478bd9Sstevel@tonic-gate 	}
19047c478bd9Sstevel@tonic-gate 	/*
19057c478bd9Sstevel@tonic-gate 	 * LD_WARN (internal, used by ldd(1)).
19067c478bd9Sstevel@tonic-gate 	 */
19077c478bd9Sstevel@tonic-gate 	else if (*s1 == 'W') {
19087c478bd9Sstevel@tonic-gate 		if ((len == MSG_LD_WARN_SIZE) && (strncmp(s1,
19097c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_LD_WARN), MSG_LD_WARN_SIZE) == 0)) {
19107c478bd9Sstevel@tonic-gate 			select |= SEL_ACT_LML;
19117c478bd9Sstevel@tonic-gate 			val = LML_FLG_TRC_WARN;
19127c478bd9Sstevel@tonic-gate 			variable = ENV_FLG_WARN;
19137c478bd9Sstevel@tonic-gate 		}
19147c478bd9Sstevel@tonic-gate 	}
191556deab07SRod Evans 
19167c478bd9Sstevel@tonic-gate 	if (variable == 0)
19177c478bd9Sstevel@tonic-gate 		return;
19187c478bd9Sstevel@tonic-gate 
19197c478bd9Sstevel@tonic-gate 	/*
1920635216b6SRod Evans 	 * If the variable is already processed with and ISA specific variable,
1921635216b6SRod Evans 	 * no further processing is needed.
19227c478bd9Sstevel@tonic-gate 	 */
19237c478bd9Sstevel@tonic-gate 	if (((select & SEL_REPLACE) && (rplisa & variable)) ||
19247c478bd9Sstevel@tonic-gate 	    ((select & SEL_PERMANT) && (prmisa & variable)))
19257c478bd9Sstevel@tonic-gate 		return;
19267c478bd9Sstevel@tonic-gate 
19277c478bd9Sstevel@tonic-gate 	/*
1928635216b6SRod Evans 	 * Mark the appropriate variables.
19297c478bd9Sstevel@tonic-gate 	 */
19307c478bd9Sstevel@tonic-gate 	if (env_flags & ENV_TYP_ISA) {
19317c478bd9Sstevel@tonic-gate 		/*
1932635216b6SRod Evans 		 * This is an ISA setting.
19337c478bd9Sstevel@tonic-gate 		 */
19347c478bd9Sstevel@tonic-gate 		if (select & SEL_REPLACE) {
1935fa034d7fSseizo 			if (rplisa & variable)
1936fa034d7fSseizo 				return;
19377c478bd9Sstevel@tonic-gate 			rplisa |= variable;
19387c478bd9Sstevel@tonic-gate 		} else {
19397c478bd9Sstevel@tonic-gate 			prmisa |= variable;
19407c478bd9Sstevel@tonic-gate 		}
1941635216b6SRod Evans 	} else {
19427c478bd9Sstevel@tonic-gate 		/*
1943dde769a2SRod Evans 		 * This is a non-ISA setting.
19447c478bd9Sstevel@tonic-gate 		 */
19457c478bd9Sstevel@tonic-gate 		if (select & SEL_REPLACE) {
1946fa034d7fSseizo 			if (rplgen & variable)
1947fa034d7fSseizo 				return;
19487c478bd9Sstevel@tonic-gate 			rplgen |= variable;
19497c478bd9Sstevel@tonic-gate 		} else
19507c478bd9Sstevel@tonic-gate 			prmgen |= variable;
1951635216b6SRod Evans 	}
19527c478bd9Sstevel@tonic-gate 
19537c478bd9Sstevel@tonic-gate 	/*
19547c478bd9Sstevel@tonic-gate 	 * Now perform the setting.
19557c478bd9Sstevel@tonic-gate 	 */
19567c478bd9Sstevel@tonic-gate 	if (select & SEL_ACT_RT) {
19577c478bd9Sstevel@tonic-gate 		if (s2)
19587c478bd9Sstevel@tonic-gate 			rtld_flags |= val;
19597c478bd9Sstevel@tonic-gate 		else
19607c478bd9Sstevel@tonic-gate 			rtld_flags &= ~val;
19617c478bd9Sstevel@tonic-gate 	} else if (select & SEL_ACT_RT2) {
19627c478bd9Sstevel@tonic-gate 		if (s2)
19637c478bd9Sstevel@tonic-gate 			rtld_flags2 |= val;
19647c478bd9Sstevel@tonic-gate 		else
19657c478bd9Sstevel@tonic-gate 			rtld_flags2 &= ~val;
1966635216b6SRod Evans 	} else if (select & SEL_ACT_STR) {
19677c478bd9Sstevel@tonic-gate 		*str = s2;
1968635216b6SRod Evans 	} else if (select & SEL_ACT_LML) {
19697c478bd9Sstevel@tonic-gate 		if (s2)
19707c478bd9Sstevel@tonic-gate 			*lmflags |= val;
19717c478bd9Sstevel@tonic-gate 		else
19727c478bd9Sstevel@tonic-gate 			*lmflags &= ~val;
19737c478bd9Sstevel@tonic-gate 	} else if (select & SEL_ACT_LMLT) {
19747c478bd9Sstevel@tonic-gate 		if (s2)
19757c478bd9Sstevel@tonic-gate 			*lmtflags |= val;
19767c478bd9Sstevel@tonic-gate 		else
19777c478bd9Sstevel@tonic-gate 			*lmtflags &= ~val;
19787c478bd9Sstevel@tonic-gate 	} else if (select & SEL_ACT_SPEC_1) {
19797c478bd9Sstevel@tonic-gate 		/*
19807c478bd9Sstevel@tonic-gate 		 * variable is either ENV_FLG_FLAGS or ENV_FLG_LIBPATH
19817c478bd9Sstevel@tonic-gate 		 */
19827c478bd9Sstevel@tonic-gate 		*str = s2;
19837c478bd9Sstevel@tonic-gate 		if ((select & SEL_REPLACE) && (env_flags & ENV_TYP_CONFIG)) {
19847c478bd9Sstevel@tonic-gate 			if (s2) {
19857c478bd9Sstevel@tonic-gate 				if (variable == ENV_FLG_FLAGS)
19867c478bd9Sstevel@tonic-gate 					env_info |= ENV_INF_FLAGCFG;
19877c478bd9Sstevel@tonic-gate 				else
19887c478bd9Sstevel@tonic-gate 					env_info |= ENV_INF_PATHCFG;
19897c478bd9Sstevel@tonic-gate 			} else {
19907c478bd9Sstevel@tonic-gate 				if (variable == ENV_FLG_FLAGS)
19917c478bd9Sstevel@tonic-gate 					env_info &= ~ENV_INF_FLAGCFG;
19927c478bd9Sstevel@tonic-gate 				else
19937c478bd9Sstevel@tonic-gate 					env_info &= ~ENV_INF_PATHCFG;
19947c478bd9Sstevel@tonic-gate 			}
19957c478bd9Sstevel@tonic-gate 		}
19967c478bd9Sstevel@tonic-gate 	} else if (select & SEL_ACT_SPEC_2) {
19977c478bd9Sstevel@tonic-gate 		/*
19987c478bd9Sstevel@tonic-gate 		 * variables can be: ENV_FLG_
1999635216b6SRod Evans 		 * 	AUDIT_ARGS, BINDING, CONFGEN, LOADFLTR, PROFILE,
2000635216b6SRod Evans 		 *	SIGNAL, TRACE_OBJS
20017c478bd9Sstevel@tonic-gate 		 */
2002635216b6SRod Evans 		switch (variable) {
2003635216b6SRod Evans 		case ENV_FLG_AUDIT_ARGS:
20047c478bd9Sstevel@tonic-gate 			if (s2) {
20057c478bd9Sstevel@tonic-gate 				audit_argcnt = atoi(s2);
20067c478bd9Sstevel@tonic-gate 				audit_argcnt += audit_argcnt % 2;
20077c478bd9Sstevel@tonic-gate 			} else
20087c478bd9Sstevel@tonic-gate 				audit_argcnt = 0;
2009635216b6SRod Evans 			break;
2010635216b6SRod Evans 		case ENV_FLG_BINDINGS:
20117c478bd9Sstevel@tonic-gate 			if (s2)
20127c478bd9Sstevel@tonic-gate 				rpl_debug = MSG_ORIG(MSG_TKN_BINDINGS);
20137c478bd9Sstevel@tonic-gate 			else
201443d7826aSRod Evans 				rpl_debug = NULL;
2015635216b6SRod Evans 			break;
2016635216b6SRod Evans 		case ENV_FLG_CONFGEN:
20177c478bd9Sstevel@tonic-gate 			if (s2) {
20187c478bd9Sstevel@tonic-gate 				rtld_flags |= RT_FL_CONFGEN;
20197c478bd9Sstevel@tonic-gate 				*lmflags |= LML_FLG_IGNRELERR;
20207c478bd9Sstevel@tonic-gate 			} else {
20217c478bd9Sstevel@tonic-gate 				rtld_flags &= ~RT_FL_CONFGEN;
20227c478bd9Sstevel@tonic-gate 				*lmflags &= ~LML_FLG_IGNRELERR;
20237c478bd9Sstevel@tonic-gate 			}
2024635216b6SRod Evans 			break;
2025635216b6SRod Evans 		case ENV_FLG_LOADFLTR:
20267c478bd9Sstevel@tonic-gate 			if (s2) {
20277c478bd9Sstevel@tonic-gate 				*lmtflags |= LML_TFLG_LOADFLTR;
20287c478bd9Sstevel@tonic-gate 				if (*s2 == '2')
20297c478bd9Sstevel@tonic-gate 					rtld_flags |= RT_FL_WARNFLTR;
20307c478bd9Sstevel@tonic-gate 			} else {
20317c478bd9Sstevel@tonic-gate 				*lmtflags &= ~LML_TFLG_LOADFLTR;
20327c478bd9Sstevel@tonic-gate 				rtld_flags &= ~RT_FL_WARNFLTR;
20337c478bd9Sstevel@tonic-gate 			}
2034635216b6SRod Evans 			break;
2035635216b6SRod Evans 		case ENV_FLG_PROFILE:
20367c478bd9Sstevel@tonic-gate 			profile_name = s2;
20377c478bd9Sstevel@tonic-gate 			if (s2) {
20387c478bd9Sstevel@tonic-gate 				if (strcmp(s2, MSG_ORIG(MSG_FIL_RTLD)) == 0) {
20397c478bd9Sstevel@tonic-gate 					return;
20407c478bd9Sstevel@tonic-gate 				}
2041a953e2b1Srie 				/* BEGIN CSTYLED */
20427c478bd9Sstevel@tonic-gate 				if (rtld_flags & RT_FL_SECURE) {
20437c478bd9Sstevel@tonic-gate 					profile_lib =
20447c478bd9Sstevel@tonic-gate #if	defined(_ELF64)
20457c478bd9Sstevel@tonic-gate 					    MSG_ORIG(MSG_PTH_LDPROFSE_64);
20467c478bd9Sstevel@tonic-gate #else
20477c478bd9Sstevel@tonic-gate 					    MSG_ORIG(MSG_PTH_LDPROFSE);
20487c478bd9Sstevel@tonic-gate #endif
20497c478bd9Sstevel@tonic-gate 				} else {
20507c478bd9Sstevel@tonic-gate 					profile_lib =
20517c478bd9Sstevel@tonic-gate #if	defined(_ELF64)
20527c478bd9Sstevel@tonic-gate 					    MSG_ORIG(MSG_PTH_LDPROF_64);
20537c478bd9Sstevel@tonic-gate #else
20547c478bd9Sstevel@tonic-gate 					    MSG_ORIG(MSG_PTH_LDPROF);
20557c478bd9Sstevel@tonic-gate #endif
20567c478bd9Sstevel@tonic-gate 				}
2057a953e2b1Srie 				/* END CSTYLED */
20587c478bd9Sstevel@tonic-gate 			} else
205956deab07SRod Evans 				profile_lib = NULL;
2060635216b6SRod Evans 			break;
2061635216b6SRod Evans 		case ENV_FLG_SIGNAL:
20627c478bd9Sstevel@tonic-gate 			killsig = s2 ? atoi(s2) : SIGKILL;
2063635216b6SRod Evans 			break;
2064635216b6SRod Evans 		case ENV_FLG_TRACE_OBJS:
20657c478bd9Sstevel@tonic-gate 			if (s2) {
20667c478bd9Sstevel@tonic-gate 				*lmflags |= LML_FLG_TRC_ENABLE;
20677c478bd9Sstevel@tonic-gate 				if (*s2 == '2')
20687c478bd9Sstevel@tonic-gate 					*lmflags |= LML_FLG_TRC_LDDSTUB;
20697c478bd9Sstevel@tonic-gate 			} else
20707c478bd9Sstevel@tonic-gate 				*lmflags &=
2071dde769a2SRod Evans 				    ~(LML_FLG_TRC_ENABLE | LML_FLG_TRC_LDDSTUB);
2072635216b6SRod Evans 			break;
20737c478bd9Sstevel@tonic-gate 		}
20747c478bd9Sstevel@tonic-gate 	}
20757c478bd9Sstevel@tonic-gate }
20767c478bd9Sstevel@tonic-gate 
20777c478bd9Sstevel@tonic-gate /*
20787c478bd9Sstevel@tonic-gate  * Determine whether we have an architecture specific environment variable.
20797c478bd9Sstevel@tonic-gate  * If we do, and we're the wrong architecture, it'll just get ignored.
20807c478bd9Sstevel@tonic-gate  * Otherwise the variable is processed in it's architecture neutral form.
20817c478bd9Sstevel@tonic-gate  */
20827c478bd9Sstevel@tonic-gate static int
20837c478bd9Sstevel@tonic-gate ld_arch_env(const char *s1, size_t *len)
20847c478bd9Sstevel@tonic-gate {
20857c478bd9Sstevel@tonic-gate 	size_t	_len = *len - 3;
20867c478bd9Sstevel@tonic-gate 
20877c478bd9Sstevel@tonic-gate 	if (s1[_len++] == '_') {
20887c478bd9Sstevel@tonic-gate 		if ((s1[_len] == '3') && (s1[_len + 1] == '2')) {
20897c478bd9Sstevel@tonic-gate #if	defined(_ELF64)
20907c478bd9Sstevel@tonic-gate 			return (ENV_TYP_IGNORE);
20917c478bd9Sstevel@tonic-gate #else
20927c478bd9Sstevel@tonic-gate 			*len = *len - 3;
20937c478bd9Sstevel@tonic-gate 			return (ENV_TYP_ISA);
20947c478bd9Sstevel@tonic-gate #endif
20957c478bd9Sstevel@tonic-gate 		}
20967c478bd9Sstevel@tonic-gate 		if ((s1[_len] == '6') && (s1[_len + 1] == '4')) {
20977c478bd9Sstevel@tonic-gate #if	defined(_ELF64)
20987c478bd9Sstevel@tonic-gate 			*len = *len - 3;
20997c478bd9Sstevel@tonic-gate 			return (ENV_TYP_ISA);
21007c478bd9Sstevel@tonic-gate #else
21017c478bd9Sstevel@tonic-gate 			return (ENV_TYP_IGNORE);
21027c478bd9Sstevel@tonic-gate #endif
21037c478bd9Sstevel@tonic-gate 		}
21047c478bd9Sstevel@tonic-gate 	}
21057c478bd9Sstevel@tonic-gate 	return (0);
21067c478bd9Sstevel@tonic-gate }
21077c478bd9Sstevel@tonic-gate 
21087c478bd9Sstevel@tonic-gate 
21097c478bd9Sstevel@tonic-gate /*
21107c478bd9Sstevel@tonic-gate  * Process an LD_FLAGS environment variable.  The value can be a comma
21117c478bd9Sstevel@tonic-gate  * separated set of tokens, which are sent (in upper case) into the generic
21127c478bd9Sstevel@tonic-gate  * LD_XXXX environment variable engine.  For example:
21137c478bd9Sstevel@tonic-gate  *
21147c478bd9Sstevel@tonic-gate  *	LD_FLAGS=bind_now		->	LD_BIND_NOW=1
21157c478bd9Sstevel@tonic-gate  *	LD_FLAGS=library_path=/foo:.	->	LD_LIBRARY_PATH=/foo:.
21167c478bd9Sstevel@tonic-gate  *	LD_FLAGS=debug=files:detail	->	LD_DEBUG=files:detail
21177c478bd9Sstevel@tonic-gate  * or
21187c478bd9Sstevel@tonic-gate  *	LD_FLAGS=bind_now,library_path=/foo:.,debug=files:detail
21197c478bd9Sstevel@tonic-gate  */
21207c478bd9Sstevel@tonic-gate static int
21217c478bd9Sstevel@tonic-gate ld_flags_env(const char *str, Word *lmflags, Word *lmtflags,
21227c478bd9Sstevel@tonic-gate     uint_t env_flags, int aout)
21237c478bd9Sstevel@tonic-gate {
21243dbfc803SRod Evans 	char	*nstr, *sstr, *estr = NULL;
21257c478bd9Sstevel@tonic-gate 	size_t	nlen, len;
21267c478bd9Sstevel@tonic-gate 
21273dbfc803SRod Evans 	if (str == NULL)
21287c478bd9Sstevel@tonic-gate 		return (0);
21297c478bd9Sstevel@tonic-gate 
21307c478bd9Sstevel@tonic-gate 	/*
21317c478bd9Sstevel@tonic-gate 	 * Create a new string as we're going to transform the token(s) into
21327c478bd9Sstevel@tonic-gate 	 * uppercase and separate tokens with nulls.
21337c478bd9Sstevel@tonic-gate 	 */
21347c478bd9Sstevel@tonic-gate 	len = strlen(str);
21353dbfc803SRod Evans 	if ((nstr = malloc(len + 1)) == NULL)
21367c478bd9Sstevel@tonic-gate 		return (1);
21377c478bd9Sstevel@tonic-gate 	(void) strcpy(nstr, str);
21387c478bd9Sstevel@tonic-gate 
21397c478bd9Sstevel@tonic-gate 	for (sstr = nstr; sstr; sstr++, len--) {
21407c478bd9Sstevel@tonic-gate 		int	flags;
21417c478bd9Sstevel@tonic-gate 
21427c478bd9Sstevel@tonic-gate 		if ((*sstr != '\0') && (*sstr != ',')) {
21433dbfc803SRod Evans 			if (estr == NULL) {
21447c478bd9Sstevel@tonic-gate 				if (*sstr == '=')
21457c478bd9Sstevel@tonic-gate 					estr = sstr;
21467c478bd9Sstevel@tonic-gate 				else {
21477c478bd9Sstevel@tonic-gate 					/*
21487c478bd9Sstevel@tonic-gate 					 * Translate token to uppercase.  Don't
21497c478bd9Sstevel@tonic-gate 					 * use toupper(3C) as including this
21507c478bd9Sstevel@tonic-gate 					 * code doubles the size of ld.so.1.
21517c478bd9Sstevel@tonic-gate 					 */
21527c478bd9Sstevel@tonic-gate 					if ((*sstr >= 'a') && (*sstr <= 'z'))
21537c478bd9Sstevel@tonic-gate 						*sstr = *sstr - ('a' - 'A');
21547c478bd9Sstevel@tonic-gate 				}
21557c478bd9Sstevel@tonic-gate 			}
21567c478bd9Sstevel@tonic-gate 			continue;
21577c478bd9Sstevel@tonic-gate 		}
21587c478bd9Sstevel@tonic-gate 
21597c478bd9Sstevel@tonic-gate 		*sstr = '\0';
21607c478bd9Sstevel@tonic-gate 		if (estr) {
21617c478bd9Sstevel@tonic-gate 			nlen = estr - nstr;
21627c478bd9Sstevel@tonic-gate 			if ((*++estr == '\0') || (*estr == ','))
216343d7826aSRod Evans 				estr = NULL;
21647c478bd9Sstevel@tonic-gate 		} else
21657c478bd9Sstevel@tonic-gate 			nlen = sstr - nstr;
21667c478bd9Sstevel@tonic-gate 
21677c478bd9Sstevel@tonic-gate 		/*
21687c478bd9Sstevel@tonic-gate 		 * Fabricate a boolean definition for any unqualified variable.
21697c478bd9Sstevel@tonic-gate 		 * Thus LD_FLAGS=bind_now is represented as BIND_NOW=(null).
21707c478bd9Sstevel@tonic-gate 		 * The value is sufficient to assert any boolean variables, plus
21717c478bd9Sstevel@tonic-gate 		 * the term "(null)" is specifically chosen in case someone
21727c478bd9Sstevel@tonic-gate 		 * mistakenly supplies something like LD_FLAGS=library_path.
21737c478bd9Sstevel@tonic-gate 		 */
21743dbfc803SRod Evans 		if (estr == NULL)
21757c478bd9Sstevel@tonic-gate 			estr = (char *)MSG_INTL(MSG_STR_NULL);
21767c478bd9Sstevel@tonic-gate 
21777c478bd9Sstevel@tonic-gate 		/*
21787c478bd9Sstevel@tonic-gate 		 * Determine whether the environment variable is 32- or 64-bit
21797c478bd9Sstevel@tonic-gate 		 * specific.  The length, len, will reflect the architecture
21807c478bd9Sstevel@tonic-gate 		 * neutral portion of the string.
21817c478bd9Sstevel@tonic-gate 		 */
21827c478bd9Sstevel@tonic-gate 		if ((flags = ld_arch_env(nstr, &nlen)) != ENV_TYP_IGNORE) {
21837c478bd9Sstevel@tonic-gate 			ld_generic_env(nstr, nlen, estr, lmflags,
21847c478bd9Sstevel@tonic-gate 			    lmtflags, (env_flags | flags), aout);
21857c478bd9Sstevel@tonic-gate 		}
21867c478bd9Sstevel@tonic-gate 		if (len == 0)
21877c478bd9Sstevel@tonic-gate 			return (0);
21887c478bd9Sstevel@tonic-gate 
21897c478bd9Sstevel@tonic-gate 		nstr = sstr + 1;
219043d7826aSRod Evans 		estr = NULL;
21917c478bd9Sstevel@tonic-gate 	}
21927c478bd9Sstevel@tonic-gate 	return (0);
21937c478bd9Sstevel@tonic-gate }
21947c478bd9Sstevel@tonic-gate 
21957c478bd9Sstevel@tonic-gate 
21967c478bd9Sstevel@tonic-gate /*
21977c478bd9Sstevel@tonic-gate  * Process a single environment string.  Only strings starting with `LD_' are
21987c478bd9Sstevel@tonic-gate  * reserved for our use.  By convention, all strings should be of the form
21997c478bd9Sstevel@tonic-gate  * `LD_XXXX=', if the string is followed by a non-null value the appropriate
22007c478bd9Sstevel@tonic-gate  * functionality is enabled.  Also pick off applicable locale variables.
22017c478bd9Sstevel@tonic-gate  */
22027c478bd9Sstevel@tonic-gate #define	LOC_LANG	1
22037c478bd9Sstevel@tonic-gate #define	LOC_MESG	2
22047c478bd9Sstevel@tonic-gate #define	LOC_ALL		3
22057c478bd9Sstevel@tonic-gate 
22067c478bd9Sstevel@tonic-gate static void
22077c478bd9Sstevel@tonic-gate ld_str_env(const char *s1, Word *lmflags, Word *lmtflags, uint_t env_flags,
22087c478bd9Sstevel@tonic-gate     int aout)
22097c478bd9Sstevel@tonic-gate {
22107c478bd9Sstevel@tonic-gate 	const char	*s2;
221110a4fa49Srie 	static		size_t	loc = 0;
22127c478bd9Sstevel@tonic-gate 
22137c478bd9Sstevel@tonic-gate 	if (*s1++ != 'L')
22147c478bd9Sstevel@tonic-gate 		return;
22157c478bd9Sstevel@tonic-gate 
22167c478bd9Sstevel@tonic-gate 	/*
22177c478bd9Sstevel@tonic-gate 	 * See if we have any locale environment settings.  These environment
22187c478bd9Sstevel@tonic-gate 	 * variables have a precedence, LC_ALL is higher than LC_MESSAGES which
22197c478bd9Sstevel@tonic-gate 	 * is higher than LANG.
22207c478bd9Sstevel@tonic-gate 	 */
22217c478bd9Sstevel@tonic-gate 	s2 = s1;
22227c478bd9Sstevel@tonic-gate 	if ((*s2++ == 'C') && (*s2++ == '_') && (*s2 != '\0')) {
22237c478bd9Sstevel@tonic-gate 		if (strncmp(s2, MSG_ORIG(MSG_LC_ALL), MSG_LC_ALL_SIZE) == 0) {
22247c478bd9Sstevel@tonic-gate 			s2 += MSG_LC_ALL_SIZE;
22257c478bd9Sstevel@tonic-gate 			if ((*s2 != '\0') && (loc < LOC_ALL)) {
222610a4fa49Srie 				glcs[CI_LCMESSAGES].lc_un.lc_ptr = (char *)s2;
22277c478bd9Sstevel@tonic-gate 				loc = LOC_ALL;
22287c478bd9Sstevel@tonic-gate 			}
22297c478bd9Sstevel@tonic-gate 		} else if (strncmp(s2, MSG_ORIG(MSG_LC_MESSAGES),
22307c478bd9Sstevel@tonic-gate 		    MSG_LC_MESSAGES_SIZE) == 0) {
22317c478bd9Sstevel@tonic-gate 			s2 += MSG_LC_MESSAGES_SIZE;
22327c478bd9Sstevel@tonic-gate 			if ((*s2 != '\0') && (loc < LOC_MESG)) {
223310a4fa49Srie 				glcs[CI_LCMESSAGES].lc_un.lc_ptr = (char *)s2;
22347c478bd9Sstevel@tonic-gate 				loc = LOC_MESG;
22357c478bd9Sstevel@tonic-gate 			}
22367c478bd9Sstevel@tonic-gate 		}
22377c478bd9Sstevel@tonic-gate 		return;
22387c478bd9Sstevel@tonic-gate 	}
22397c478bd9Sstevel@tonic-gate 
22407c478bd9Sstevel@tonic-gate 	s2 = s1;
22417c478bd9Sstevel@tonic-gate 	if ((*s2++ == 'A') && (*s2++ == 'N') && (*s2++ == 'G') &&
22427c478bd9Sstevel@tonic-gate 	    (*s2++ == '=') && (*s2 != '\0') && (loc < LOC_LANG)) {
224310a4fa49Srie 		glcs[CI_LCMESSAGES].lc_un.lc_ptr = (char *)s2;
22447c478bd9Sstevel@tonic-gate 		loc = LOC_LANG;
22457c478bd9Sstevel@tonic-gate 		return;
22467c478bd9Sstevel@tonic-gate 	}
22477c478bd9Sstevel@tonic-gate 
22487c478bd9Sstevel@tonic-gate 	/*
22497c478bd9Sstevel@tonic-gate 	 * Pick off any LD_XXXX environment variables.
22507c478bd9Sstevel@tonic-gate 	 */
22517c478bd9Sstevel@tonic-gate 	if ((*s1++ == 'D') && (*s1++ == '_') && (*s1 != '\0')) {
22527c478bd9Sstevel@tonic-gate 		size_t	len;
22537c478bd9Sstevel@tonic-gate 		int	flags;
22547c478bd9Sstevel@tonic-gate 
22559acbbeafSnn 		/*
22569acbbeafSnn 		 * In a branded process we must ignore all LD_XXXX env vars
22579acbbeafSnn 		 * because they are intended for the brand's linker.
22589acbbeafSnn 		 * To affect the Solaris linker, use LD_BRAND_XXXX instead.
22599acbbeafSnn 		 */
22609acbbeafSnn 		if (rtld_flags2 & RT_FL2_BRANDED) {
22619acbbeafSnn 			if (strncmp(s1, MSG_ORIG(MSG_LD_BRAND_PREFIX),
22629acbbeafSnn 			    MSG_LD_BRAND_PREFIX_SIZE) != 0)
22639acbbeafSnn 				return;
22649acbbeafSnn 			s1 += MSG_LD_BRAND_PREFIX_SIZE;
22659acbbeafSnn 		}
22669acbbeafSnn 
22677c478bd9Sstevel@tonic-gate 		/*
22687c478bd9Sstevel@tonic-gate 		 * Environment variables with no value (ie. LD_XXXX=) typically
22697c478bd9Sstevel@tonic-gate 		 * have no impact, however if environment variables are defined
22707c478bd9Sstevel@tonic-gate 		 * within a configuration file, these null user settings can be
22717c478bd9Sstevel@tonic-gate 		 * used to disable any configuration replaceable definitions.
22727c478bd9Sstevel@tonic-gate 		 */
22733dbfc803SRod Evans 		if ((s2 = strchr(s1, '=')) == NULL) {
22747c478bd9Sstevel@tonic-gate 			len = strlen(s1);
227543d7826aSRod Evans 			s2 = NULL;
22767c478bd9Sstevel@tonic-gate 		} else if (*++s2 == '\0') {
22777c478bd9Sstevel@tonic-gate 			len = strlen(s1) - 1;
227843d7826aSRod Evans 			s2 = NULL;
22797c478bd9Sstevel@tonic-gate 		} else {
22807c478bd9Sstevel@tonic-gate 			len = s2 - s1 - 1;
2281e23c41c9SAli Bahrami 			while (conv_strproc_isspace(*s2))
22827c478bd9Sstevel@tonic-gate 				s2++;
22837c478bd9Sstevel@tonic-gate 		}
22847c478bd9Sstevel@tonic-gate 
22857c478bd9Sstevel@tonic-gate 		/*
22867c478bd9Sstevel@tonic-gate 		 * Determine whether the environment variable is 32- or 64-bit
22877c478bd9Sstevel@tonic-gate 		 * specific.  The length, len, will reflect the architecture
22887c478bd9Sstevel@tonic-gate 		 * neutral portion of the string.
22897c478bd9Sstevel@tonic-gate 		 */
22907c478bd9Sstevel@tonic-gate 		if ((flags = ld_arch_env(s1, &len)) == ENV_TYP_IGNORE)
22917c478bd9Sstevel@tonic-gate 			return;
22927c478bd9Sstevel@tonic-gate 		env_flags |= flags;
22937c478bd9Sstevel@tonic-gate 
22947c478bd9Sstevel@tonic-gate 		ld_generic_env(s1, len, s2, lmflags, lmtflags, env_flags, aout);
22957c478bd9Sstevel@tonic-gate 	}
22967c478bd9Sstevel@tonic-gate }
22977c478bd9Sstevel@tonic-gate 
22987c478bd9Sstevel@tonic-gate /*
22997c478bd9Sstevel@tonic-gate  * Internal getenv routine.  Called immediately after ld.so.1 initializes
23007c478bd9Sstevel@tonic-gate  * itself.
23017c478bd9Sstevel@tonic-gate  */
23027c478bd9Sstevel@tonic-gate int
230356deab07SRod Evans readenv_user(const char **envp, Word *lmflags, Word *lmtflags, int aout)
23047c478bd9Sstevel@tonic-gate {
230510a4fa49Srie 	char	*locale;
230610a4fa49Srie 
230756deab07SRod Evans 	if (envp == NULL)
23087c478bd9Sstevel@tonic-gate 		return (0);
23097c478bd9Sstevel@tonic-gate 
231056deab07SRod Evans 	while (*envp != NULL)
23117c478bd9Sstevel@tonic-gate 		ld_str_env(*envp++, lmflags, lmtflags, 0, aout);
23127c478bd9Sstevel@tonic-gate 
23137c478bd9Sstevel@tonic-gate 	/*
23147c478bd9Sstevel@tonic-gate 	 * Having collected the best representation of any LD_FLAGS, process
23157c478bd9Sstevel@tonic-gate 	 * these strings.
23167c478bd9Sstevel@tonic-gate 	 */
23177c478bd9Sstevel@tonic-gate 	if (ld_flags_env(rpl_ldflags, lmflags, lmtflags, 0, aout) == 1)
23187c478bd9Sstevel@tonic-gate 		return (1);
23197c478bd9Sstevel@tonic-gate 
23207c478bd9Sstevel@tonic-gate 	/*
23217c478bd9Sstevel@tonic-gate 	 * Don't allow environment controlled auditing when tracing or if
23227c478bd9Sstevel@tonic-gate 	 * explicitly disabled.  Trigger all tracing modes from
23237c478bd9Sstevel@tonic-gate 	 * LML_FLG_TRC_ENABLE.
23247c478bd9Sstevel@tonic-gate 	 */
23257c478bd9Sstevel@tonic-gate 	if ((*lmflags & LML_FLG_TRC_ENABLE) || (rtld_flags & RT_FL_NOAUDIT))
232656deab07SRod Evans 		rpl_audit = profile_lib = profile_name = NULL;
23277c478bd9Sstevel@tonic-gate 	if ((*lmflags & LML_FLG_TRC_ENABLE) == 0)
23287c478bd9Sstevel@tonic-gate 		*lmflags &= ~LML_MSK_TRC;
23297c478bd9Sstevel@tonic-gate 
2330dffec89cSrie 	/*
2331dffec89cSrie 	 * If both LD_BIND_NOW and LD_BIND_LAZY are specified, the former wins.
2332dffec89cSrie 	 */
2333dffec89cSrie 	if ((rtld_flags2 & (RT_FL2_BINDNOW | RT_FL2_BINDLAZY)) ==
2334dffec89cSrie 	    (RT_FL2_BINDNOW | RT_FL2_BINDLAZY))
2335dffec89cSrie 		rtld_flags2 &= ~RT_FL2_BINDLAZY;
2336dffec89cSrie 
2337dae2dfb7Srie 	/*
2338dae2dfb7Srie 	 * When using ldd(1) -r or -d against an executable, assert -p.
2339dae2dfb7Srie 	 */
2340dae2dfb7Srie 	if ((*lmflags &
2341dae2dfb7Srie 	    (LML_FLG_TRC_WARN | LML_FLG_TRC_LDDSTUB)) == LML_FLG_TRC_WARN)
2342dae2dfb7Srie 		*lmflags |= LML_FLG_TRC_NOPAREXT;
2343dae2dfb7Srie 
23447c478bd9Sstevel@tonic-gate 	/*
23457c478bd9Sstevel@tonic-gate 	 * If we have a locale setting make sure its worth processing further.
23461d6b7ad8Srie 	 * C and POSIX locales don't need any processing.  In addition, to
23471d6b7ad8Srie 	 * ensure no one escapes the /usr/lib/locale hierarchy, don't allow
23481d6b7ad8Srie 	 * the locale to contain a segment that leads upward in the file system
23491d6b7ad8Srie 	 * hierarchy (i.e. no '..' segments).   Given that we'll be confined to
23501d6b7ad8Srie 	 * the /usr/lib/locale hierarchy, there is no need to extensively
23511d6b7ad8Srie 	 * validate the mode or ownership of any message file (as libc's
23521d6b7ad8Srie 	 * generic handling of message files does).  Duplicate the string so
23531d6b7ad8Srie 	 * that new locale setting can generically cleanup any previous locales.
23547c478bd9Sstevel@tonic-gate 	 */
235543d7826aSRod Evans 	if ((locale = glcs[CI_LCMESSAGES].lc_un.lc_ptr) != NULL) {
23567c478bd9Sstevel@tonic-gate 		if (((*locale == 'C') && (*(locale + 1) == '\0')) ||
23571d6b7ad8Srie 		    (strcmp(locale, MSG_ORIG(MSG_TKN_POSIX)) == 0) ||
23581d6b7ad8Srie 		    (strstr(locale, MSG_ORIG(MSG_TKN_DOTDOT)) != NULL))
235943d7826aSRod Evans 			glcs[CI_LCMESSAGES].lc_un.lc_ptr = NULL;
23607c478bd9Sstevel@tonic-gate 		else
236110a4fa49Srie 			glcs[CI_LCMESSAGES].lc_un.lc_ptr = strdup(locale);
23627c478bd9Sstevel@tonic-gate 	}
23637c478bd9Sstevel@tonic-gate 	return (0);
23647c478bd9Sstevel@tonic-gate }
23657c478bd9Sstevel@tonic-gate 
23667c478bd9Sstevel@tonic-gate /*
23677c478bd9Sstevel@tonic-gate  * Configuration environment processing.  Called after the a.out has been
23687c478bd9Sstevel@tonic-gate  * processed (as the a.out can specify its own configuration file).
23697c478bd9Sstevel@tonic-gate  */
23707c478bd9Sstevel@tonic-gate int
23717c478bd9Sstevel@tonic-gate readenv_config(Rtc_env * envtbl, Addr addr, int aout)
23727c478bd9Sstevel@tonic-gate {
23739aa23310Srie 	Word	*lmflags = &(lml_main.lm_flags);
23749aa23310Srie 	Word	*lmtflags = &(lml_main.lm_tflags);
23757c478bd9Sstevel@tonic-gate 
237656deab07SRod Evans 	if (envtbl == NULL)
23777c478bd9Sstevel@tonic-gate 		return (0);
23787c478bd9Sstevel@tonic-gate 
23797c478bd9Sstevel@tonic-gate 	while (envtbl->env_str) {
23807c478bd9Sstevel@tonic-gate 		uint_t	env_flags = ENV_TYP_CONFIG;
23817c478bd9Sstevel@tonic-gate 
23827c478bd9Sstevel@tonic-gate 		if (envtbl->env_flags & RTC_ENV_PERMANT)
23837c478bd9Sstevel@tonic-gate 			env_flags |= ENV_TYP_PERMANT;
23847c478bd9Sstevel@tonic-gate 
23857c478bd9Sstevel@tonic-gate 		ld_str_env((const char *)(envtbl->env_str + addr),
23867c478bd9Sstevel@tonic-gate 		    lmflags, lmtflags, env_flags, 0);
23877c478bd9Sstevel@tonic-gate 		envtbl++;
23887c478bd9Sstevel@tonic-gate 	}
23897c478bd9Sstevel@tonic-gate 
23907c478bd9Sstevel@tonic-gate 	/*
23917c478bd9Sstevel@tonic-gate 	 * Having collected the best representation of any LD_FLAGS, process
23927c478bd9Sstevel@tonic-gate 	 * these strings.
23937c478bd9Sstevel@tonic-gate 	 */
23947c478bd9Sstevel@tonic-gate 	if (ld_flags_env(rpl_ldflags, lmflags, lmtflags, 0, aout) == 1)
23957c478bd9Sstevel@tonic-gate 		return (1);
23967c478bd9Sstevel@tonic-gate 	if (ld_flags_env(prm_ldflags, lmflags, lmtflags, ENV_TYP_CONFIG,
23977c478bd9Sstevel@tonic-gate 	    aout) == 1)
23987c478bd9Sstevel@tonic-gate 		return (1);
23997c478bd9Sstevel@tonic-gate 
24007c478bd9Sstevel@tonic-gate 	/*
24017c478bd9Sstevel@tonic-gate 	 * Don't allow environment controlled auditing when tracing or if
24027c478bd9Sstevel@tonic-gate 	 * explicitly disabled.  Trigger all tracing modes from
24037c478bd9Sstevel@tonic-gate 	 * LML_FLG_TRC_ENABLE.
24047c478bd9Sstevel@tonic-gate 	 */
24057c478bd9Sstevel@tonic-gate 	if ((*lmflags & LML_FLG_TRC_ENABLE) || (rtld_flags & RT_FL_NOAUDIT))
240656deab07SRod Evans 		prm_audit = profile_lib = profile_name = NULL;
24077c478bd9Sstevel@tonic-gate 	if ((*lmflags & LML_FLG_TRC_ENABLE) == 0)
24087c478bd9Sstevel@tonic-gate 		*lmflags &= ~LML_MSK_TRC;
24097c478bd9Sstevel@tonic-gate 
24107c478bd9Sstevel@tonic-gate 	return (0);
24117c478bd9Sstevel@tonic-gate }
24127c478bd9Sstevel@tonic-gate 
24137c478bd9Sstevel@tonic-gate int
24147c478bd9Sstevel@tonic-gate dowrite(Prfbuf * prf)
24157c478bd9Sstevel@tonic-gate {
24167c478bd9Sstevel@tonic-gate 	/*
24177c478bd9Sstevel@tonic-gate 	 * We do not have a valid file descriptor, so we are unable
24187c478bd9Sstevel@tonic-gate 	 * to flush the buffer.
24197c478bd9Sstevel@tonic-gate 	 */
24207c478bd9Sstevel@tonic-gate 	if (prf->pr_fd == -1)
24217c478bd9Sstevel@tonic-gate 		return (0);
24227c478bd9Sstevel@tonic-gate 	(void) write(prf->pr_fd, prf->pr_buf, prf->pr_cur - prf->pr_buf);
24237c478bd9Sstevel@tonic-gate 	prf->pr_cur = prf->pr_buf;
24247c478bd9Sstevel@tonic-gate 	return (1);
24257c478bd9Sstevel@tonic-gate }
24267c478bd9Sstevel@tonic-gate 
24277c478bd9Sstevel@tonic-gate /*
24287c478bd9Sstevel@tonic-gate  * Simplified printing.  The following conversion specifications are supported:
24297c478bd9Sstevel@tonic-gate  *
24307c478bd9Sstevel@tonic-gate  *	% [#] [-] [min field width] [. precision] s|d|x|c
24317c478bd9Sstevel@tonic-gate  *
24327c478bd9Sstevel@tonic-gate  *
24337c478bd9Sstevel@tonic-gate  * dorprf takes the output buffer in the form of Prfbuf which permits
24347c478bd9Sstevel@tonic-gate  * the verification of the output buffer size and the concatenation
24357c478bd9Sstevel@tonic-gate  * of data to an already existing output buffer.  The Prfbuf
24367c478bd9Sstevel@tonic-gate  * structure contains the following:
24377c478bd9Sstevel@tonic-gate  *
24387c478bd9Sstevel@tonic-gate  *  pr_buf	pointer to the beginning of the output buffer.
24397c478bd9Sstevel@tonic-gate  *  pr_cur	pointer to the next available byte in the output buffer.  By
24407c478bd9Sstevel@tonic-gate  *		setting pr_cur ahead of pr_buf you can append to an already
24417c478bd9Sstevel@tonic-gate  *		existing buffer.
24427c478bd9Sstevel@tonic-gate  *  pr_len	the size of the output buffer.  By setting pr_len to '0' you
24437c478bd9Sstevel@tonic-gate  *		disable protection from overflows in the output buffer.
24447c478bd9Sstevel@tonic-gate  *  pr_fd	a pointer to the file-descriptor the buffer will eventually be
24457c478bd9Sstevel@tonic-gate  *		output to.  If pr_fd is set to '-1' then it's assumed there is
24461d6b7ad8Srie  *		no output buffer, and doprf() will return with an error to
24471d6b7ad8Srie  *		indicate an output buffer overflow.  If pr_fd is > -1 then when
24481d6b7ad8Srie  *		the output buffer is filled it will be flushed to pr_fd and will
24491d6b7ad8Srie  *		then be	available for additional data.
24507c478bd9Sstevel@tonic-gate  */
24517c478bd9Sstevel@tonic-gate #define	FLG_UT_MINUS	0x0001	/* - */
24527c478bd9Sstevel@tonic-gate #define	FLG_UT_SHARP	0x0002	/* # */
24537c478bd9Sstevel@tonic-gate #define	FLG_UT_DOTSEEN	0x0008	/* dot appeared in format spec */
24547c478bd9Sstevel@tonic-gate 
24557c478bd9Sstevel@tonic-gate /*
245610a4fa49Srie  * This macro is for use from within doprf only.  It is to be used for checking
245710a4fa49Srie  * the output buffer size and placing characters into the buffer.
24587c478bd9Sstevel@tonic-gate  */
24597c478bd9Sstevel@tonic-gate #define	PUTC(c) \
24607c478bd9Sstevel@tonic-gate 	{ \
246110a4fa49Srie 		char tmpc; \
24627c478bd9Sstevel@tonic-gate 		\
24637c478bd9Sstevel@tonic-gate 		tmpc = (c); \
246410a4fa49Srie 		if (bufsiz && (bp >= bufend)) { \
24657c478bd9Sstevel@tonic-gate 			prf->pr_cur = bp; \
24667c478bd9Sstevel@tonic-gate 			if (dowrite(prf) == 0) \
24677c478bd9Sstevel@tonic-gate 				return (0); \
24687c478bd9Sstevel@tonic-gate 			bp = prf->pr_cur; \
24697c478bd9Sstevel@tonic-gate 		} \
24707c478bd9Sstevel@tonic-gate 		*bp++ = tmpc; \
24717c478bd9Sstevel@tonic-gate 	}
24727c478bd9Sstevel@tonic-gate 
24731d6b7ad8Srie /*
24741d6b7ad8Srie  * Define a local buffer size for building a numeric value - large enough to
24751d6b7ad8Srie  * hold a 64-bit value.
24761d6b7ad8Srie  */
2477051d39bbSrie #define	NUM_SIZE	22
24781d6b7ad8Srie 
24797c478bd9Sstevel@tonic-gate size_t
24807c478bd9Sstevel@tonic-gate doprf(const char *format, va_list args, Prfbuf *prf)
24817c478bd9Sstevel@tonic-gate {
24827c478bd9Sstevel@tonic-gate 	char	c;
24837c478bd9Sstevel@tonic-gate 	char	*bp = prf->pr_cur;
24847c478bd9Sstevel@tonic-gate 	char	*bufend = prf->pr_buf + prf->pr_len;
24857c478bd9Sstevel@tonic-gate 	size_t	bufsiz = prf->pr_len;
24867c478bd9Sstevel@tonic-gate 
24877c478bd9Sstevel@tonic-gate 	while ((c = *format++) != '\0') {
24887c478bd9Sstevel@tonic-gate 		if (c != '%') {
24897c478bd9Sstevel@tonic-gate 			PUTC(c);
24907c478bd9Sstevel@tonic-gate 		} else {
24917c478bd9Sstevel@tonic-gate 			int	base = 0, flag = 0, width = 0, prec = 0;
24927c478bd9Sstevel@tonic-gate 			size_t	_i;
24937c478bd9Sstevel@tonic-gate 			int	_c, _n;
24947c478bd9Sstevel@tonic-gate 			char	*_s;
24957c478bd9Sstevel@tonic-gate 			int	ls = 0;
24967c478bd9Sstevel@tonic-gate again:
24977c478bd9Sstevel@tonic-gate 			c = *format++;
24987c478bd9Sstevel@tonic-gate 			switch (c) {
24997c478bd9Sstevel@tonic-gate 			case '-':
25007c478bd9Sstevel@tonic-gate 				flag |= FLG_UT_MINUS;
25017c478bd9Sstevel@tonic-gate 				goto again;
25027c478bd9Sstevel@tonic-gate 			case '#':
25037c478bd9Sstevel@tonic-gate 				flag |= FLG_UT_SHARP;
25047c478bd9Sstevel@tonic-gate 				goto again;
25057c478bd9Sstevel@tonic-gate 			case '.':
25067c478bd9Sstevel@tonic-gate 				flag |= FLG_UT_DOTSEEN;
25077c478bd9Sstevel@tonic-gate 				goto again;
25087c478bd9Sstevel@tonic-gate 			case '0':
25097c478bd9Sstevel@tonic-gate 			case '1':
25107c478bd9Sstevel@tonic-gate 			case '2':
25117c478bd9Sstevel@tonic-gate 			case '3':
25127c478bd9Sstevel@tonic-gate 			case '4':
25137c478bd9Sstevel@tonic-gate 			case '5':
25147c478bd9Sstevel@tonic-gate 			case '6':
25157c478bd9Sstevel@tonic-gate 			case '7':
25167c478bd9Sstevel@tonic-gate 			case '8':
25177c478bd9Sstevel@tonic-gate 			case '9':
25187c478bd9Sstevel@tonic-gate 				if (flag & FLG_UT_DOTSEEN)
25197c478bd9Sstevel@tonic-gate 					prec = (prec * 10) + c - '0';
25207c478bd9Sstevel@tonic-gate 				else
25217c478bd9Sstevel@tonic-gate 					width = (width * 10) + c - '0';
25227c478bd9Sstevel@tonic-gate 				goto again;
25237c478bd9Sstevel@tonic-gate 			case 'x':
25247c478bd9Sstevel@tonic-gate 			case 'X':
25257c478bd9Sstevel@tonic-gate 				base = 16;
25267c478bd9Sstevel@tonic-gate 				break;
25277c478bd9Sstevel@tonic-gate 			case 'd':
25287c478bd9Sstevel@tonic-gate 			case 'D':
25297c478bd9Sstevel@tonic-gate 			case 'u':
25307c478bd9Sstevel@tonic-gate 				base = 10;
25317c478bd9Sstevel@tonic-gate 				flag &= ~FLG_UT_SHARP;
25327c478bd9Sstevel@tonic-gate 				break;
25337c478bd9Sstevel@tonic-gate 			case 'l':
25347c478bd9Sstevel@tonic-gate 				base = 10;
25357c478bd9Sstevel@tonic-gate 				ls++; /* number of l's (long or long long) */
25367c478bd9Sstevel@tonic-gate 				if ((*format == 'l') ||
25377c478bd9Sstevel@tonic-gate 				    (*format == 'd') || (*format == 'D') ||
25387c478bd9Sstevel@tonic-gate 				    (*format == 'x') || (*format == 'X') ||
253920272c2eSAli Bahrami 				    (*format == 'o') || (*format == 'O') ||
254020272c2eSAli Bahrami 				    (*format == 'u') || (*format == 'U'))
25417c478bd9Sstevel@tonic-gate 					goto again;
25427c478bd9Sstevel@tonic-gate 				break;
25437c478bd9Sstevel@tonic-gate 			case 'o':
25447c478bd9Sstevel@tonic-gate 			case 'O':
25457c478bd9Sstevel@tonic-gate 				base = 8;
25467c478bd9Sstevel@tonic-gate 				break;
25477c478bd9Sstevel@tonic-gate 			case 'c':
25487c478bd9Sstevel@tonic-gate 				_c = va_arg(args, int);
25497c478bd9Sstevel@tonic-gate 
25507c478bd9Sstevel@tonic-gate 				for (_i = 24; _i > 0; _i -= 8) {
25517c478bd9Sstevel@tonic-gate 					if ((c = ((_c >> _i) & 0x7f)) != 0) {
25527c478bd9Sstevel@tonic-gate 						PUTC(c);
25537c478bd9Sstevel@tonic-gate 					}
25547c478bd9Sstevel@tonic-gate 				}
25557c478bd9Sstevel@tonic-gate 				if ((c = ((_c >> _i) & 0x7f)) != 0) {
25567c478bd9Sstevel@tonic-gate 					PUTC(c);
25577c478bd9Sstevel@tonic-gate 				}
25587c478bd9Sstevel@tonic-gate 				break;
25597c478bd9Sstevel@tonic-gate 			case 's':
25607c478bd9Sstevel@tonic-gate 				_s = va_arg(args, char *);
25617c478bd9Sstevel@tonic-gate 				_i = strlen(_s);
25627c478bd9Sstevel@tonic-gate 				/* LINTED */
25637c478bd9Sstevel@tonic-gate 				_n = (int)(width - _i);
25647c478bd9Sstevel@tonic-gate 				if (!prec)
25657c478bd9Sstevel@tonic-gate 					/* LINTED */
25667c478bd9Sstevel@tonic-gate 					prec = (int)_i;
25677c478bd9Sstevel@tonic-gate 
25687c478bd9Sstevel@tonic-gate 				if (width && !(flag & FLG_UT_MINUS)) {
25697c478bd9Sstevel@tonic-gate 					while (_n-- > 0)
25707c478bd9Sstevel@tonic-gate 						PUTC(' ');
25717c478bd9Sstevel@tonic-gate 				}
25727c478bd9Sstevel@tonic-gate 				while (((c = *_s++) != 0) && prec--) {
25737c478bd9Sstevel@tonic-gate 					PUTC(c);
25747c478bd9Sstevel@tonic-gate 				}
25757c478bd9Sstevel@tonic-gate 				if (width && (flag & FLG_UT_MINUS)) {
25767c478bd9Sstevel@tonic-gate 					while (_n-- > 0)
25777c478bd9Sstevel@tonic-gate 						PUTC(' ');
25787c478bd9Sstevel@tonic-gate 				}
25797c478bd9Sstevel@tonic-gate 				break;
25807c478bd9Sstevel@tonic-gate 			case '%':
25817c478bd9Sstevel@tonic-gate 				PUTC('%');
25827c478bd9Sstevel@tonic-gate 				break;
25837c478bd9Sstevel@tonic-gate 			default:
25847c478bd9Sstevel@tonic-gate 				break;
25857c478bd9Sstevel@tonic-gate 			}
25867c478bd9Sstevel@tonic-gate 
25877c478bd9Sstevel@tonic-gate 			/*
25887c478bd9Sstevel@tonic-gate 			 * Numeric processing
25897c478bd9Sstevel@tonic-gate 			 */
25907c478bd9Sstevel@tonic-gate 			if (base) {
25911d6b7ad8Srie 				char		local[NUM_SIZE];
25921d6b7ad8Srie 				size_t		ssize = 0, psize = 0;
25937c478bd9Sstevel@tonic-gate 				const char	*string =
2594a953e2b1Srie 				    MSG_ORIG(MSG_STR_HEXNUM);
25957c478bd9Sstevel@tonic-gate 				const char	*prefix =
2596a953e2b1Srie 				    MSG_ORIG(MSG_STR_EMPTY);
25977c478bd9Sstevel@tonic-gate 				u_longlong_t	num;
25987c478bd9Sstevel@tonic-gate 
25997c478bd9Sstevel@tonic-gate 				switch (ls) {
26007c478bd9Sstevel@tonic-gate 				case 0:	/* int */
26017c478bd9Sstevel@tonic-gate 					num = (u_longlong_t)
26027c478bd9Sstevel@tonic-gate 					    va_arg(args, uint_t);
26037c478bd9Sstevel@tonic-gate 					break;
26047c478bd9Sstevel@tonic-gate 				case 1:	/* long */
26057c478bd9Sstevel@tonic-gate 					num = (u_longlong_t)
26067c478bd9Sstevel@tonic-gate 					    va_arg(args, ulong_t);
26077c478bd9Sstevel@tonic-gate 					break;
26087c478bd9Sstevel@tonic-gate 				case 2:	/* long long */
26097c478bd9Sstevel@tonic-gate 					num = va_arg(args, u_longlong_t);
26107c478bd9Sstevel@tonic-gate 					break;
26117c478bd9Sstevel@tonic-gate 				}
26127c478bd9Sstevel@tonic-gate 
26137c478bd9Sstevel@tonic-gate 				if (flag & FLG_UT_SHARP) {
26147c478bd9Sstevel@tonic-gate 					if (base == 16) {
26157c478bd9Sstevel@tonic-gate 						prefix = MSG_ORIG(MSG_STR_HEX);
26167c478bd9Sstevel@tonic-gate 						psize = 2;
26177c478bd9Sstevel@tonic-gate 					} else {
26187c478bd9Sstevel@tonic-gate 						prefix = MSG_ORIG(MSG_STR_ZERO);
26197c478bd9Sstevel@tonic-gate 						psize = 1;
26207c478bd9Sstevel@tonic-gate 					}
26217c478bd9Sstevel@tonic-gate 				}
26227c478bd9Sstevel@tonic-gate 				if ((base == 10) && (long)num < 0) {
26237c478bd9Sstevel@tonic-gate 					prefix = MSG_ORIG(MSG_STR_NEGATE);
26247c478bd9Sstevel@tonic-gate 					psize = MSG_STR_NEGATE_SIZE;
26257c478bd9Sstevel@tonic-gate 					num = (u_longlong_t)(-(longlong_t)num);
26267c478bd9Sstevel@tonic-gate 				}
26277c478bd9Sstevel@tonic-gate 
26287c478bd9Sstevel@tonic-gate 				/*
26297c478bd9Sstevel@tonic-gate 				 * Convert the numeric value into a local
26307c478bd9Sstevel@tonic-gate 				 * string (stored in reverse order).
26317c478bd9Sstevel@tonic-gate 				 */
26327c478bd9Sstevel@tonic-gate 				_s = local;
26337c478bd9Sstevel@tonic-gate 				do {
26347c478bd9Sstevel@tonic-gate 					*_s++ = string[num % base];
26357c478bd9Sstevel@tonic-gate 					num /= base;
26367c478bd9Sstevel@tonic-gate 					ssize++;
26377c478bd9Sstevel@tonic-gate 				} while (num);
26387c478bd9Sstevel@tonic-gate 
26391d6b7ad8Srie 				ASSERT(ssize < sizeof (local));
26401d6b7ad8Srie 
26417c478bd9Sstevel@tonic-gate 				/*
26427c478bd9Sstevel@tonic-gate 				 * Provide any precision or width padding.
26437c478bd9Sstevel@tonic-gate 				 */
26447c478bd9Sstevel@tonic-gate 				if (prec) {
26457c478bd9Sstevel@tonic-gate 					/* LINTED */
26467c478bd9Sstevel@tonic-gate 					_n = (int)(prec - ssize);
26471d6b7ad8Srie 					while ((_n-- > 0) &&
26481d6b7ad8Srie 					    (ssize < sizeof (local))) {
26497c478bd9Sstevel@tonic-gate 						*_s++ = '0';
26507c478bd9Sstevel@tonic-gate 						ssize++;
26517c478bd9Sstevel@tonic-gate 					}
26527c478bd9Sstevel@tonic-gate 				}
26537c478bd9Sstevel@tonic-gate 				if (width && !(flag & FLG_UT_MINUS)) {
26547c478bd9Sstevel@tonic-gate 					/* LINTED */
26557c478bd9Sstevel@tonic-gate 					_n = (int)(width - ssize - psize);
26567c478bd9Sstevel@tonic-gate 					while (_n-- > 0) {
26577c478bd9Sstevel@tonic-gate 						PUTC(' ');
26587c478bd9Sstevel@tonic-gate 					}
26597c478bd9Sstevel@tonic-gate 				}
26607c478bd9Sstevel@tonic-gate 
26617c478bd9Sstevel@tonic-gate 				/*
26627c478bd9Sstevel@tonic-gate 				 * Print any prefix and the numeric string
26637c478bd9Sstevel@tonic-gate 				 */
26647c478bd9Sstevel@tonic-gate 				while (*prefix)
26657c478bd9Sstevel@tonic-gate 					PUTC(*prefix++);
26667c478bd9Sstevel@tonic-gate 				do {
26677c478bd9Sstevel@tonic-gate 					PUTC(*--_s);
26687c478bd9Sstevel@tonic-gate 				} while (_s > local);
26697c478bd9Sstevel@tonic-gate 
26707c478bd9Sstevel@tonic-gate 				/*
26717c478bd9Sstevel@tonic-gate 				 * Provide any width padding.
26727c478bd9Sstevel@tonic-gate 				 */
26737c478bd9Sstevel@tonic-gate 				if (width && (flag & FLG_UT_MINUS)) {
26747c478bd9Sstevel@tonic-gate 					/* LINTED */
26757c478bd9Sstevel@tonic-gate 					_n = (int)(width - ssize - psize);
26767c478bd9Sstevel@tonic-gate 					while (_n-- > 0)
26777c478bd9Sstevel@tonic-gate 						PUTC(' ');
26787c478bd9Sstevel@tonic-gate 				}
26797c478bd9Sstevel@tonic-gate 			}
26807c478bd9Sstevel@tonic-gate 		}
26817c478bd9Sstevel@tonic-gate 	}
268210a4fa49Srie 
26837c478bd9Sstevel@tonic-gate 	PUTC('\0');
26847c478bd9Sstevel@tonic-gate 	prf->pr_cur = bp;
26857c478bd9Sstevel@tonic-gate 	return (1);
26867c478bd9Sstevel@tonic-gate }
26877c478bd9Sstevel@tonic-gate 
26887c478bd9Sstevel@tonic-gate static int
26897c478bd9Sstevel@tonic-gate doprintf(const char *format, va_list args, Prfbuf *prf)
26907c478bd9Sstevel@tonic-gate {
26917c478bd9Sstevel@tonic-gate 	char	*ocur = prf->pr_cur;
26927c478bd9Sstevel@tonic-gate 
26937c478bd9Sstevel@tonic-gate 	if (doprf(format, args, prf) == 0)
26947c478bd9Sstevel@tonic-gate 		return (0);
26957c478bd9Sstevel@tonic-gate 	/* LINTED */
26967c478bd9Sstevel@tonic-gate 	return ((int)(prf->pr_cur - ocur));
26977c478bd9Sstevel@tonic-gate }
26987c478bd9Sstevel@tonic-gate 
26997c478bd9Sstevel@tonic-gate /* VARARGS2 */
27007c478bd9Sstevel@tonic-gate int
27017c478bd9Sstevel@tonic-gate sprintf(char *buf, const char *format, ...)
27027c478bd9Sstevel@tonic-gate {
27037c478bd9Sstevel@tonic-gate 	va_list	args;
27047c478bd9Sstevel@tonic-gate 	int	len;
27057c478bd9Sstevel@tonic-gate 	Prfbuf	prf;
27067c478bd9Sstevel@tonic-gate 
27077c478bd9Sstevel@tonic-gate 	va_start(args, format);
27087c478bd9Sstevel@tonic-gate 	prf.pr_buf = prf.pr_cur = buf;
27097c478bd9Sstevel@tonic-gate 	prf.pr_len = 0;
27107c478bd9Sstevel@tonic-gate 	prf.pr_fd = -1;
27117c478bd9Sstevel@tonic-gate 	len = doprintf(format, args, &prf);
27127c478bd9Sstevel@tonic-gate 	va_end(args);
27137c478bd9Sstevel@tonic-gate 
27147c478bd9Sstevel@tonic-gate 	/*
27157c478bd9Sstevel@tonic-gate 	 * sprintf() return value excludes the terminating null byte.
27167c478bd9Sstevel@tonic-gate 	 */
27177c478bd9Sstevel@tonic-gate 	return (len - 1);
27187c478bd9Sstevel@tonic-gate }
27197c478bd9Sstevel@tonic-gate 
27207c478bd9Sstevel@tonic-gate /* VARARGS3 */
27217c478bd9Sstevel@tonic-gate int
27227c478bd9Sstevel@tonic-gate snprintf(char *buf, size_t n, const char *format, ...)
27237c478bd9Sstevel@tonic-gate {
27247c478bd9Sstevel@tonic-gate 	va_list	args;
27257c478bd9Sstevel@tonic-gate 	int	len;
27267c478bd9Sstevel@tonic-gate 	Prfbuf	prf;
27277c478bd9Sstevel@tonic-gate 
27287c478bd9Sstevel@tonic-gate 	va_start(args, format);
27297c478bd9Sstevel@tonic-gate 	prf.pr_buf = prf.pr_cur = buf;
27307c478bd9Sstevel@tonic-gate 	prf.pr_len = n;
27317c478bd9Sstevel@tonic-gate 	prf.pr_fd = -1;
27327c478bd9Sstevel@tonic-gate 	len = doprintf(format, args, &prf);
27337c478bd9Sstevel@tonic-gate 	va_end(args);
27347c478bd9Sstevel@tonic-gate 
27357c478bd9Sstevel@tonic-gate 	return (len);
27367c478bd9Sstevel@tonic-gate }
27377c478bd9Sstevel@tonic-gate 
27387c478bd9Sstevel@tonic-gate /* VARARGS2 */
27397c478bd9Sstevel@tonic-gate int
27407c478bd9Sstevel@tonic-gate bufprint(Prfbuf *prf, const char *format, ...)
27417c478bd9Sstevel@tonic-gate {
27427c478bd9Sstevel@tonic-gate 	va_list	args;
27437c478bd9Sstevel@tonic-gate 	int	len;
27447c478bd9Sstevel@tonic-gate 
27457c478bd9Sstevel@tonic-gate 	va_start(args, format);
27467c478bd9Sstevel@tonic-gate 	len = doprintf(format, args, prf);
27477c478bd9Sstevel@tonic-gate 	va_end(args);
27487c478bd9Sstevel@tonic-gate 
27497c478bd9Sstevel@tonic-gate 	return (len);
27507c478bd9Sstevel@tonic-gate }
27517c478bd9Sstevel@tonic-gate 
27527c478bd9Sstevel@tonic-gate /*PRINTFLIKE1*/
27537c478bd9Sstevel@tonic-gate int
27547c478bd9Sstevel@tonic-gate printf(const char *format, ...)
27557c478bd9Sstevel@tonic-gate {
27567c478bd9Sstevel@tonic-gate 	va_list	args;
27577c478bd9Sstevel@tonic-gate 	char 	buffer[ERRSIZE];
27587c478bd9Sstevel@tonic-gate 	Prfbuf	prf;
27597c478bd9Sstevel@tonic-gate 
27607c478bd9Sstevel@tonic-gate 	va_start(args, format);
27617c478bd9Sstevel@tonic-gate 	prf.pr_buf = prf.pr_cur = buffer;
27627c478bd9Sstevel@tonic-gate 	prf.pr_len = ERRSIZE;
27637c478bd9Sstevel@tonic-gate 	prf.pr_fd = 1;
27647c478bd9Sstevel@tonic-gate 	(void) doprf(format, args, &prf);
27657c478bd9Sstevel@tonic-gate 	va_end(args);
27667c478bd9Sstevel@tonic-gate 	/*
27677c478bd9Sstevel@tonic-gate 	 * Trim trailing '\0' form buffer
27687c478bd9Sstevel@tonic-gate 	 */
27697c478bd9Sstevel@tonic-gate 	prf.pr_cur--;
27707c478bd9Sstevel@tonic-gate 	return (dowrite(&prf));
27717c478bd9Sstevel@tonic-gate }
27727c478bd9Sstevel@tonic-gate 
277343d7826aSRod Evans static char	errbuf[ERRSIZE], *nextptr = errbuf, *prevptr = NULL;
27747c478bd9Sstevel@tonic-gate 
277556deab07SRod Evans /*
277656deab07SRod Evans  * All error messages go through eprintf().  During process initialization,
277756deab07SRod Evans  * these messages are directed to the standard error, however once control has
277856deab07SRod Evans  * been passed to the applications code these messages are stored in an internal
277956deab07SRod Evans  * buffer for use with dlerror().  Note, fatal error conditions that may occur
278056deab07SRod Evans  * while running the application will still cause a standard error message, see
278156deab07SRod Evans  * rtldexit() in this file for details.
278256deab07SRod Evans  * The RT_FL_APPLIC flag serves to indicate the transition between process
278356deab07SRod Evans  * initialization and when the applications code is running.
278456deab07SRod Evans  */
27855aefb655Srie /*PRINTFLIKE3*/
27867c478bd9Sstevel@tonic-gate void
27875aefb655Srie eprintf(Lm_list *lml, Error error, const char *format, ...)
27887c478bd9Sstevel@tonic-gate {
27897c478bd9Sstevel@tonic-gate 	va_list		args;
27907c478bd9Sstevel@tonic-gate 	int		overflow = 0;
27917c478bd9Sstevel@tonic-gate 	static int	lock = 0;
27927c478bd9Sstevel@tonic-gate 	Prfbuf		prf;
27937c478bd9Sstevel@tonic-gate 
27947c478bd9Sstevel@tonic-gate 	if (lock || (nextptr == (errbuf + ERRSIZE)))
27957c478bd9Sstevel@tonic-gate 		return;
27967c478bd9Sstevel@tonic-gate 
27977c478bd9Sstevel@tonic-gate 	/*
27987c478bd9Sstevel@tonic-gate 	 * Note: this lock is here to prevent the same thread from recursively
27997c478bd9Sstevel@tonic-gate 	 * entering itself during a eprintf.  ie: during eprintf malloc() fails
28007c478bd9Sstevel@tonic-gate 	 * and we try and call eprintf ... and then malloc() fails ....
28017c478bd9Sstevel@tonic-gate 	 */
28027c478bd9Sstevel@tonic-gate 	lock = 1;
28037c478bd9Sstevel@tonic-gate 
28047c478bd9Sstevel@tonic-gate 	/*
28057c478bd9Sstevel@tonic-gate 	 * If we have completed startup initialization, all error messages
28067c478bd9Sstevel@tonic-gate 	 * must be saved.  These are reported through dlerror().  If we're
28077c478bd9Sstevel@tonic-gate 	 * still in the initialization stage, output the error directly and
28087c478bd9Sstevel@tonic-gate 	 * add a newline.
28097c478bd9Sstevel@tonic-gate 	 */
28107c478bd9Sstevel@tonic-gate 	va_start(args, format);
28117c478bd9Sstevel@tonic-gate 
28127c478bd9Sstevel@tonic-gate 	prf.pr_buf = prf.pr_cur = nextptr;
28137c478bd9Sstevel@tonic-gate 	prf.pr_len = ERRSIZE - (nextptr - errbuf);
28147c478bd9Sstevel@tonic-gate 
28157c478bd9Sstevel@tonic-gate 	if (!(rtld_flags & RT_FL_APPLIC))
28167c478bd9Sstevel@tonic-gate 		prf.pr_fd = 2;
28177c478bd9Sstevel@tonic-gate 	else
28187c478bd9Sstevel@tonic-gate 		prf.pr_fd = -1;
28197c478bd9Sstevel@tonic-gate 
28207c478bd9Sstevel@tonic-gate 	if (error > ERR_NONE) {
28217c478bd9Sstevel@tonic-gate 		if ((error == ERR_FATAL) && (rtld_flags2 & RT_FL2_FTL2WARN))
28227c478bd9Sstevel@tonic-gate 			error = ERR_WARNING;
28237c478bd9Sstevel@tonic-gate 		if (error == ERR_WARNING) {
282443d7826aSRod Evans 			if (err_strs[ERR_WARNING] == NULL)
2825a953e2b1Srie 				err_strs[ERR_WARNING] =
2826a953e2b1Srie 				    MSG_INTL(MSG_ERR_WARNING);
28277c478bd9Sstevel@tonic-gate 		} else if (error == ERR_FATAL) {
282843d7826aSRod Evans 			if (err_strs[ERR_FATAL] == NULL)
2829a953e2b1Srie 				err_strs[ERR_FATAL] = MSG_INTL(MSG_ERR_FATAL);
28307c478bd9Sstevel@tonic-gate 		} else if (error == ERR_ELF) {
283143d7826aSRod Evans 			if (err_strs[ERR_ELF] == NULL)
2832a953e2b1Srie 				err_strs[ERR_ELF] = MSG_INTL(MSG_ERR_ELF);
28337c478bd9Sstevel@tonic-gate 		}
283441072f3cSrie 		if (procname) {
283541072f3cSrie 			if (bufprint(&prf, MSG_ORIG(MSG_STR_EMSGFOR1),
283641072f3cSrie 			    rtldname, procname, err_strs[error]) == 0)
283741072f3cSrie 				overflow = 1;
28387c478bd9Sstevel@tonic-gate 		} else {
283941072f3cSrie 			if (bufprint(&prf, MSG_ORIG(MSG_STR_EMSGFOR2),
284041072f3cSrie 			    rtldname, err_strs[error]) == 0)
284141072f3cSrie 				overflow = 1;
284241072f3cSrie 		}
284341072f3cSrie 		if (overflow == 0) {
28447c478bd9Sstevel@tonic-gate 			/*
28457c478bd9Sstevel@tonic-gate 			 * Remove the terminating '\0'.
28467c478bd9Sstevel@tonic-gate 			 */
28477c478bd9Sstevel@tonic-gate 			prf.pr_cur--;
28487c478bd9Sstevel@tonic-gate 		}
28497c478bd9Sstevel@tonic-gate 	}
28507c478bd9Sstevel@tonic-gate 
28517c478bd9Sstevel@tonic-gate 	if ((overflow == 0) && doprf(format, args, &prf) == 0)
28527c478bd9Sstevel@tonic-gate 		overflow = 1;
28537c478bd9Sstevel@tonic-gate 
28547c478bd9Sstevel@tonic-gate 	/*
28557c478bd9Sstevel@tonic-gate 	 * If this is an ELF error, it will have been generated by a support
28567c478bd9Sstevel@tonic-gate 	 * object that has a dependency on libelf.  ld.so.1 doesn't generate any
28577c478bd9Sstevel@tonic-gate 	 * ELF error messages as it doesn't interact with libelf.  Determine the
28587c478bd9Sstevel@tonic-gate 	 * ELF error string.
28597c478bd9Sstevel@tonic-gate 	 */
28607c478bd9Sstevel@tonic-gate 	if ((overflow == 0) && (error == ERR_ELF)) {
28617c478bd9Sstevel@tonic-gate 		static int		(*elfeno)() = 0;
28627c478bd9Sstevel@tonic-gate 		static const char	*(*elfemg)();
28637c478bd9Sstevel@tonic-gate 		const char		*emsg;
28647c478bd9Sstevel@tonic-gate 		Rt_map			*dlmp, *lmp = lml_rtld.lm_head;
28657c478bd9Sstevel@tonic-gate 
28667c478bd9Sstevel@tonic-gate 		if (NEXT(lmp) && (elfeno == 0)) {
28677c478bd9Sstevel@tonic-gate 			if (((elfemg = (const char *(*)())dlsym_intn(RTLD_NEXT,
286843d7826aSRod Evans 			    MSG_ORIG(MSG_SYM_ELFERRMSG),
286943d7826aSRod Evans 			    lmp, &dlmp)) == NULL) ||
28707c478bd9Sstevel@tonic-gate 			    ((elfeno = (int (*)())dlsym_intn(RTLD_NEXT,
287143d7826aSRod Evans 			    MSG_ORIG(MSG_SYM_ELFERRNO), lmp, &dlmp)) == NULL))
28727c478bd9Sstevel@tonic-gate 				elfeno = 0;
28737c478bd9Sstevel@tonic-gate 		}
28747c478bd9Sstevel@tonic-gate 
28757c478bd9Sstevel@tonic-gate 		/*
28767c478bd9Sstevel@tonic-gate 		 * Lookup the message; equivalent to elf_errmsg(elf_errno()).
28777c478bd9Sstevel@tonic-gate 		 */
287843d7826aSRod Evans 		if (elfeno && ((emsg = (* elfemg)((* elfeno)())) != NULL)) {
28797c478bd9Sstevel@tonic-gate 			prf.pr_cur--;
28807c478bd9Sstevel@tonic-gate 			if (bufprint(&prf, MSG_ORIG(MSG_STR_EMSGFOR2),
28817c478bd9Sstevel@tonic-gate 			    emsg) == 0)
28827c478bd9Sstevel@tonic-gate 				overflow = 1;
28837c478bd9Sstevel@tonic-gate 		}
28847c478bd9Sstevel@tonic-gate 	}
28857c478bd9Sstevel@tonic-gate 
28867c478bd9Sstevel@tonic-gate 	/*
28877c478bd9Sstevel@tonic-gate 	 * Push out any message that's been built.  Note, in the case of an
28887c478bd9Sstevel@tonic-gate 	 * overflow condition, this message may be incomplete, in which case
28897c478bd9Sstevel@tonic-gate 	 * make sure any partial string is null terminated.
28907c478bd9Sstevel@tonic-gate 	 */
28917c478bd9Sstevel@tonic-gate 	if ((rtld_flags & (RT_FL_APPLIC | RT_FL_SILENCERR)) == 0) {
28927c478bd9Sstevel@tonic-gate 		*(prf.pr_cur - 1) = '\n';
28937c478bd9Sstevel@tonic-gate 		(void) dowrite(&prf);
28947c478bd9Sstevel@tonic-gate 	}
289556deab07SRod Evans 	if (overflow)
289656deab07SRod Evans 		*(prf.pr_cur - 1) = '\0';
28977c478bd9Sstevel@tonic-gate 
28985aefb655Srie 	DBG_CALL(Dbg_util_str(lml, nextptr));
28997c478bd9Sstevel@tonic-gate 	va_end(args);
29007c478bd9Sstevel@tonic-gate 
29017c478bd9Sstevel@tonic-gate 	/*
29027c478bd9Sstevel@tonic-gate 	 * Determine if there was insufficient space left in the buffer to
29037c478bd9Sstevel@tonic-gate 	 * complete the message.  If so, we'll have printed out as much as had
29047c478bd9Sstevel@tonic-gate 	 * been processed if we're not yet executing the application.
29057c478bd9Sstevel@tonic-gate 	 * Otherwise, there will be some debugging diagnostic indicating
29067c478bd9Sstevel@tonic-gate 	 * as much of the error message as possible.  Write out a final buffer
29077c478bd9Sstevel@tonic-gate 	 * overflow diagnostic - unlocalized, so we don't chance more errors.
29087c478bd9Sstevel@tonic-gate 	 */
29097c478bd9Sstevel@tonic-gate 	if (overflow) {
29107c478bd9Sstevel@tonic-gate 		char	*str = (char *)MSG_INTL(MSG_EMG_BUFOVRFLW);
29117c478bd9Sstevel@tonic-gate 
29127c478bd9Sstevel@tonic-gate 		if ((rtld_flags & RT_FL_SILENCERR) == 0) {
29137c478bd9Sstevel@tonic-gate 			lasterr = str;
29147c478bd9Sstevel@tonic-gate 
29157c478bd9Sstevel@tonic-gate 			if ((rtld_flags & RT_FL_APPLIC) == 0) {
29167c478bd9Sstevel@tonic-gate 				(void) write(2, str, strlen(str));
29177c478bd9Sstevel@tonic-gate 				(void) write(2, MSG_ORIG(MSG_STR_NL),
29187c478bd9Sstevel@tonic-gate 				    MSG_STR_NL_SIZE);
29197c478bd9Sstevel@tonic-gate 			}
29207c478bd9Sstevel@tonic-gate 		}
29215aefb655Srie 		DBG_CALL(Dbg_util_str(lml, str));
29227c478bd9Sstevel@tonic-gate 
29237c478bd9Sstevel@tonic-gate 		lock = 0;
29247c478bd9Sstevel@tonic-gate 		nextptr = errbuf + ERRSIZE;
29257c478bd9Sstevel@tonic-gate 		return;
29267c478bd9Sstevel@tonic-gate 	}
29277c478bd9Sstevel@tonic-gate 
29287c478bd9Sstevel@tonic-gate 	/*
29297c478bd9Sstevel@tonic-gate 	 * If the application has started, then error messages are being saved
29307c478bd9Sstevel@tonic-gate 	 * for retrieval by dlerror(), or possible flushing from rtldexit() in
29317c478bd9Sstevel@tonic-gate 	 * the case of a fatal error.  In this case, establish the next error
29327c478bd9Sstevel@tonic-gate 	 * pointer.  If we haven't started the application, the whole message
29337c478bd9Sstevel@tonic-gate 	 * buffer can be reused.
29347c478bd9Sstevel@tonic-gate 	 */
29357c478bd9Sstevel@tonic-gate 	if ((rtld_flags & RT_FL_SILENCERR) == 0) {
29367c478bd9Sstevel@tonic-gate 		lasterr = nextptr;
29377c478bd9Sstevel@tonic-gate 
29387c478bd9Sstevel@tonic-gate 		/*
29397c478bd9Sstevel@tonic-gate 		 * Note, should we encounter an error such as ENOMEM, there may
29407c478bd9Sstevel@tonic-gate 		 * be a number of the same error messages (ie. an operation
29417c478bd9Sstevel@tonic-gate 		 * fails with ENOMEM, and then the attempts to construct the
29427c478bd9Sstevel@tonic-gate 		 * error message itself, which incurs additional ENOMEM errors).
29437c478bd9Sstevel@tonic-gate 		 * Compare any previous error message with the one we've just
29447c478bd9Sstevel@tonic-gate 		 * created to prevent any duplication clutter.
29457c478bd9Sstevel@tonic-gate 		 */
29467c478bd9Sstevel@tonic-gate 		if ((rtld_flags & RT_FL_APPLIC) &&
294743d7826aSRod Evans 		    ((prevptr == NULL) || (strcmp(prevptr, nextptr) != 0))) {
29487c478bd9Sstevel@tonic-gate 			prevptr = nextptr;
29497c478bd9Sstevel@tonic-gate 			nextptr = prf.pr_cur;
29507c478bd9Sstevel@tonic-gate 			*nextptr = '\0';
29517c478bd9Sstevel@tonic-gate 		}
29527c478bd9Sstevel@tonic-gate 	}
29537c478bd9Sstevel@tonic-gate 	lock = 0;
29547c478bd9Sstevel@tonic-gate }
29557c478bd9Sstevel@tonic-gate 
29567c478bd9Sstevel@tonic-gate 
29577c478bd9Sstevel@tonic-gate #if	DEBUG
29587c478bd9Sstevel@tonic-gate /*
295956deab07SRod Evans  * Provide assfail() for ASSERT() statements.  See <sys/debug.h> for further
296056deab07SRod Evans  * details.
29617c478bd9Sstevel@tonic-gate  */
29627c478bd9Sstevel@tonic-gate int
29637c478bd9Sstevel@tonic-gate assfail(const char *a, const char *f, int l)
29647c478bd9Sstevel@tonic-gate {
29657c478bd9Sstevel@tonic-gate 	(void) printf("assertion failed: %s, file: %s, line: %d\n", a, f, l);
29667c478bd9Sstevel@tonic-gate 	(void) _lwp_kill(_lwp_self(), SIGABRT);
29677c478bd9Sstevel@tonic-gate 	return (0);
29687c478bd9Sstevel@tonic-gate }
29697c478bd9Sstevel@tonic-gate #endif
29707c478bd9Sstevel@tonic-gate 
29717c478bd9Sstevel@tonic-gate /*
29727c478bd9Sstevel@tonic-gate  * Exit.  If we arrive here with a non zero status it's because of a fatal
29737c478bd9Sstevel@tonic-gate  * error condition (most commonly a relocation error).  If the application has
29747c478bd9Sstevel@tonic-gate  * already had control, then the actual fatal error message will have been
29757c478bd9Sstevel@tonic-gate  * recorded in the dlerror() message buffer.  Print the message before really
29767c478bd9Sstevel@tonic-gate  * exiting.
29777c478bd9Sstevel@tonic-gate  */
29787c478bd9Sstevel@tonic-gate void
29797c478bd9Sstevel@tonic-gate rtldexit(Lm_list * lml, int status)
29807c478bd9Sstevel@tonic-gate {
29817c478bd9Sstevel@tonic-gate 	if (status) {
29827c478bd9Sstevel@tonic-gate 		if (rtld_flags & RT_FL_APPLIC) {
29837c478bd9Sstevel@tonic-gate 			/*
29847c478bd9Sstevel@tonic-gate 			 * If the error buffer has been used, write out all
29857c478bd9Sstevel@tonic-gate 			 * pending messages - lasterr is simply a pointer to
29867c478bd9Sstevel@tonic-gate 			 * the last message in this buffer.  However, if the
29877c478bd9Sstevel@tonic-gate 			 * buffer couldn't be created at all, lasterr points
29887c478bd9Sstevel@tonic-gate 			 * to a constant error message string.
29897c478bd9Sstevel@tonic-gate 			 */
29907c478bd9Sstevel@tonic-gate 			if (*errbuf) {
29917c478bd9Sstevel@tonic-gate 				char	*errptr = errbuf;
29927c478bd9Sstevel@tonic-gate 				char	*errend = errbuf + ERRSIZE;
29937c478bd9Sstevel@tonic-gate 
29947c478bd9Sstevel@tonic-gate 				while ((errptr < errend) && *errptr) {
29957c478bd9Sstevel@tonic-gate 					size_t	size = strlen(errptr);
29967c478bd9Sstevel@tonic-gate 					(void) write(2, errptr, size);
29977c478bd9Sstevel@tonic-gate 					(void) write(2, MSG_ORIG(MSG_STR_NL),
29987c478bd9Sstevel@tonic-gate 					    MSG_STR_NL_SIZE);
29997c478bd9Sstevel@tonic-gate 					errptr += (size + 1);
30007c478bd9Sstevel@tonic-gate 				}
30017c478bd9Sstevel@tonic-gate 			}
30027c478bd9Sstevel@tonic-gate 			if (lasterr && ((lasterr < errbuf) ||
30037c478bd9Sstevel@tonic-gate 			    (lasterr > (errbuf + ERRSIZE)))) {
30047c478bd9Sstevel@tonic-gate 				(void) write(2, lasterr, strlen(lasterr));
30057c478bd9Sstevel@tonic-gate 				(void) write(2, MSG_ORIG(MSG_STR_NL),
30067c478bd9Sstevel@tonic-gate 				    MSG_STR_NL_SIZE);
30077c478bd9Sstevel@tonic-gate 			}
30087c478bd9Sstevel@tonic-gate 		}
30098cd45542Sraf 		leave(lml, 0);
30107c478bd9Sstevel@tonic-gate 		(void) _lwp_kill(_lwp_self(), killsig);
30117c478bd9Sstevel@tonic-gate 	}
30127c478bd9Sstevel@tonic-gate 	_exit(status);
30137c478bd9Sstevel@tonic-gate }
30147c478bd9Sstevel@tonic-gate 
30157c478bd9Sstevel@tonic-gate /*
301656deab07SRod Evans  * Map anonymous memory via MAP_ANON (added in Solaris 8).
30177c478bd9Sstevel@tonic-gate  */
301856deab07SRod Evans void *
30195aefb655Srie dz_map(Lm_list *lml, caddr_t addr, size_t len, int prot, int flags)
30207c478bd9Sstevel@tonic-gate {
30217c478bd9Sstevel@tonic-gate 	caddr_t	va;
30227c478bd9Sstevel@tonic-gate 
302356deab07SRod Evans 	if ((va = (caddr_t)mmap(addr, len, prot,
302456deab07SRod Evans 	    (flags | MAP_ANON), -1, 0)) == MAP_FAILED) {
302556deab07SRod Evans 		int	err = errno;
302656deab07SRod Evans 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_MMAPANON),
302756deab07SRod Evans 		    strerror(err));
30287c478bd9Sstevel@tonic-gate 		return (MAP_FAILED);
30297c478bd9Sstevel@tonic-gate 	}
30307c478bd9Sstevel@tonic-gate 	return (va);
30317c478bd9Sstevel@tonic-gate }
30327c478bd9Sstevel@tonic-gate 
30337c478bd9Sstevel@tonic-gate static int	nu_fd = FD_UNAVAIL;
30347c478bd9Sstevel@tonic-gate 
303556deab07SRod Evans void *
30365aefb655Srie nu_map(Lm_list *lml, caddr_t addr, size_t len, int prot, int flags)
30377c478bd9Sstevel@tonic-gate {
30387c478bd9Sstevel@tonic-gate 	caddr_t	va;
30397c478bd9Sstevel@tonic-gate 	int	err;
30407c478bd9Sstevel@tonic-gate 
30417c478bd9Sstevel@tonic-gate 	if (nu_fd == FD_UNAVAIL) {
30427c478bd9Sstevel@tonic-gate 		if ((nu_fd = open(MSG_ORIG(MSG_PTH_DEVNULL),
30437c478bd9Sstevel@tonic-gate 		    O_RDONLY)) == FD_UNAVAIL) {
30447c478bd9Sstevel@tonic-gate 			err = errno;
30455aefb655Srie 			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN),
30467c478bd9Sstevel@tonic-gate 			    MSG_ORIG(MSG_PTH_DEVNULL), strerror(err));
30477c478bd9Sstevel@tonic-gate 			return (MAP_FAILED);
30487c478bd9Sstevel@tonic-gate 		}
30497c478bd9Sstevel@tonic-gate 	}
30507c478bd9Sstevel@tonic-gate 
30517c478bd9Sstevel@tonic-gate 	if ((va = (caddr_t)mmap(addr, len, prot, flags, nu_fd, 0)) ==
30527c478bd9Sstevel@tonic-gate 	    MAP_FAILED) {
30537c478bd9Sstevel@tonic-gate 		err = errno;
30545aefb655Srie 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_MMAP),
30557c478bd9Sstevel@tonic-gate 		    MSG_ORIG(MSG_PTH_DEVNULL), strerror(err));
30567c478bd9Sstevel@tonic-gate 	}
30577c478bd9Sstevel@tonic-gate 	return (va);
30587c478bd9Sstevel@tonic-gate }
30597c478bd9Sstevel@tonic-gate 
30607c478bd9Sstevel@tonic-gate /*
306175e7992aSrie  * Generic entry point from user code - simply grabs a lock, and bumps the
306275e7992aSrie  * entrance count.
30637c478bd9Sstevel@tonic-gate  */
30647c478bd9Sstevel@tonic-gate int
30658cd45542Sraf enter(int flags)
30667c478bd9Sstevel@tonic-gate {
30678cd45542Sraf 	if (rt_bind_guard(THR_FLG_RTLD | thr_flg_nolock | flags)) {
30688cd45542Sraf 		if (!thr_flg_nolock)
30698cd45542Sraf 			(void) rt_mutex_lock(&rtldlock);
30702017c965SRod Evans 		if (rtld_flags & RT_FL_OPERATION) {
30719aa23310Srie 			ld_entry_cnt++;
30722017c965SRod Evans 
30732017c965SRod Evans 			/*
30742017c965SRod Evans 			 * Reset the diagnostic time information for each new
30752017c965SRod Evans 			 * "operation".  Thus timing diagnostics are relative
30762017c965SRod Evans 			 * to entering ld.so.1.
30772017c965SRod Evans 			 */
30782017c965SRod Evans 			if (DBG_ISTIME() &&
30792017c965SRod Evans 			    (gettimeofday(&DBG_TOTALTIME, NULL) == 0)) {
30802017c965SRod Evans 				DBG_DELTATIME = DBG_TOTALTIME;
30812017c965SRod Evans 				DBG_ONRESET();
30822017c965SRod Evans 			}
30832017c965SRod Evans 		}
30847c478bd9Sstevel@tonic-gate 		return (1);
30857c478bd9Sstevel@tonic-gate 	}
30867c478bd9Sstevel@tonic-gate 	return (0);
30877c478bd9Sstevel@tonic-gate }
30887c478bd9Sstevel@tonic-gate 
30899aa23310Srie /*
30909aa23310Srie  * Determine whether a search path has been used.
30919aa23310Srie  */
30929aa23310Srie static void
309356deab07SRod Evans is_path_used(Lm_list *lml, Word unref, int *nl, Alist *alp, const char *obj)
30949aa23310Srie {
309556deab07SRod Evans 	Pdesc	*pdp;
309656deab07SRod Evans 	Aliste	idx;
309756deab07SRod Evans 
309856deab07SRod Evans 	for (ALIST_TRAVERSE(alp, idx, pdp)) {
30999aa23310Srie 		const char	*fmt, *name;
31009aa23310Srie 
310156deab07SRod Evans 		if ((pdp->pd_plen == 0) || (pdp->pd_flags & PD_FLG_USED))
31029aa23310Srie 			continue;
31039aa23310Srie 
31049aa23310Srie 		/*
31059aa23310Srie 		 * If this pathname originated from an expanded token, use the
31069aa23310Srie 		 * original for any diagnostic output.
31079aa23310Srie 		 */
310856deab07SRod Evans 		if ((name = pdp->pd_oname) == NULL)
310956deab07SRod Evans 			name = pdp->pd_pname;
31109aa23310Srie 
31119aa23310Srie 		if (unref == 0) {
31129aa23310Srie 			if ((*nl)++ == 0)
31139aa23310Srie 				DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD));
311456deab07SRod Evans 			DBG_CALL(Dbg_unused_path(lml, name, pdp->pd_flags,
311556deab07SRod Evans 			    (pdp->pd_flags & PD_FLG_DUPLICAT), obj));
31169aa23310Srie 			continue;
31179aa23310Srie 		}
31189aa23310Srie 
311956deab07SRod Evans 		if (pdp->pd_flags & LA_SER_LIBPATH) {
312056deab07SRod Evans 			if (pdp->pd_flags & LA_SER_CONFIG) {
312156deab07SRod Evans 				if (pdp->pd_flags & PD_FLG_DUPLICAT)
31229aa23310Srie 					fmt = MSG_INTL(MSG_DUP_LDLIBPATHC);
31239aa23310Srie 				else
31249aa23310Srie 					fmt = MSG_INTL(MSG_USD_LDLIBPATHC);
31259aa23310Srie 			} else {
312656deab07SRod Evans 				if (pdp->pd_flags & PD_FLG_DUPLICAT)
31279aa23310Srie 					fmt = MSG_INTL(MSG_DUP_LDLIBPATH);
31289aa23310Srie 				else
31299aa23310Srie 					fmt = MSG_INTL(MSG_USD_LDLIBPATH);
31309aa23310Srie 			}
313156deab07SRod Evans 		} else if (pdp->pd_flags & LA_SER_RUNPATH) {
31329aa23310Srie 			fmt = MSG_INTL(MSG_USD_RUNPATH);
31339aa23310Srie 		} else
31349aa23310Srie 			continue;
31359aa23310Srie 
31369aa23310Srie 		if ((*nl)++ == 0)
31379aa23310Srie 			(void) printf(MSG_ORIG(MSG_STR_NL));
31389aa23310Srie 		(void) printf(fmt, name, obj);
31399aa23310Srie 	}
31409aa23310Srie }
31419aa23310Srie 
31427c478bd9Sstevel@tonic-gate /*
31437c478bd9Sstevel@tonic-gate  * Generate diagnostics as to whether an object has been used.  A symbolic
31447c478bd9Sstevel@tonic-gate  * reference that gets bound to an object marks it as used.  Dependencies that
31457c478bd9Sstevel@tonic-gate  * are unused when RTLD_NOW is in effect should be removed from future builds
31467c478bd9Sstevel@tonic-gate  * of an object.  Dependencies that are unused without RTLD_NOW in effect are
31477c478bd9Sstevel@tonic-gate  * candidates for lazy-loading.
31489aa23310Srie  *
31497c478bd9Sstevel@tonic-gate  * Unreferenced objects identify objects that are defined as dependencies but
31509aa23310Srie  * are unreferenced by the caller.  These unreferenced objects may however be
31519aa23310Srie  * referenced by other objects within the process, and therefore don't qualify
31529aa23310Srie  * as completely unused.  They are still an unnecessary overhead.
31539aa23310Srie  *
31549aa23310Srie  * Unreferenced runpaths are also captured under ldd -U, or "unused,detail"
31559aa23310Srie  * debugging.
31567c478bd9Sstevel@tonic-gate  */
31577c478bd9Sstevel@tonic-gate void
31587c478bd9Sstevel@tonic-gate unused(Lm_list *lml)
31597c478bd9Sstevel@tonic-gate {
31607c478bd9Sstevel@tonic-gate 	Rt_map		*lmp;
31617c478bd9Sstevel@tonic-gate 	int		nl = 0;
31629aa23310Srie 	Word		unref, unuse;
31637c478bd9Sstevel@tonic-gate 
31647c478bd9Sstevel@tonic-gate 	/*
31657c478bd9Sstevel@tonic-gate 	 * If we're not tracing unused references or dependencies, or debugging
31667c478bd9Sstevel@tonic-gate 	 * there's nothing to do.
31677c478bd9Sstevel@tonic-gate 	 */
31689aa23310Srie 	unref = lml->lm_flags & LML_FLG_TRC_UNREF;
31699aa23310Srie 	unuse = lml->lm_flags & LML_FLG_TRC_UNUSED;
31707c478bd9Sstevel@tonic-gate 
31719aa23310Srie 	if ((unref == 0) && (unuse == 0) && (DBG_ENABLED == 0))
31727c478bd9Sstevel@tonic-gate 		return;
31737c478bd9Sstevel@tonic-gate 
31749aa23310Srie 	/*
31759aa23310Srie 	 * Detect unused global search paths.
31769aa23310Srie 	 */
31779aa23310Srie 	if (rpl_libdirs)
31789aa23310Srie 		is_path_used(lml, unref, &nl, rpl_libdirs, config->c_name);
31799aa23310Srie 	if (prm_libdirs)
31809aa23310Srie 		is_path_used(lml, unref, &nl, prm_libdirs, config->c_name);
31819aa23310Srie 
31829aa23310Srie 	nl = 0;
31839aa23310Srie 	lmp = lml->lm_head;
31849aa23310Srie 	if (RLIST(lmp))
31859aa23310Srie 		is_path_used(lml, unref, &nl, RLIST(lmp), NAME(lmp));
31869aa23310Srie 
31877c478bd9Sstevel@tonic-gate 	/*
31887c478bd9Sstevel@tonic-gate 	 * Traverse the link-maps looking for unreferenced or unused
31897c478bd9Sstevel@tonic-gate 	 * dependencies.  Ignore the first object on a link-map list, as this
31909aa23310Srie 	 * is always used.
31917c478bd9Sstevel@tonic-gate 	 */
31929aa23310Srie 	nl = 0;
3193cb511613SAli Bahrami 	for (lmp = NEXT_RT_MAP(lmp); lmp; lmp = NEXT_RT_MAP(lmp)) {
31949aa23310Srie 		/*
31959aa23310Srie 		 * Determine if this object contains any runpaths that have
31969aa23310Srie 		 * not been used.
31979aa23310Srie 		 */
31989aa23310Srie 		if (RLIST(lmp))
31999aa23310Srie 			is_path_used(lml, unref, &nl, RLIST(lmp), NAME(lmp));
32009aa23310Srie 
32017c478bd9Sstevel@tonic-gate 		/*
32027c478bd9Sstevel@tonic-gate 		 * If tracing unreferenced objects, or under debugging,
32037c478bd9Sstevel@tonic-gate 		 * determine whether any of this objects callers haven't
32047c478bd9Sstevel@tonic-gate 		 * referenced it.
32057c478bd9Sstevel@tonic-gate 		 */
32069aa23310Srie 		if (unref || DBG_ENABLED) {
3207cce0e03bSab 			Bnd_desc	*bdp;
3208cce0e03bSab 			Aliste		idx;
32097c478bd9Sstevel@tonic-gate 
3210cce0e03bSab 			for (APLIST_TRAVERSE(CALLERS(lmp), idx, bdp)) {
32119aa23310Srie 				Rt_map	*clmp;
32127c478bd9Sstevel@tonic-gate 
32137c478bd9Sstevel@tonic-gate 				if (bdp->b_flags & BND_REFER)
32147c478bd9Sstevel@tonic-gate 					continue;
32157c478bd9Sstevel@tonic-gate 
32167c478bd9Sstevel@tonic-gate 				clmp = bdp->b_caller;
32177c478bd9Sstevel@tonic-gate 				if (FLAGS1(clmp) & FL1_RT_LDDSTUB)
32187c478bd9Sstevel@tonic-gate 					continue;
32197c478bd9Sstevel@tonic-gate 
3220a953e2b1Srie 				/* BEGIN CSTYLED */
32217c478bd9Sstevel@tonic-gate 				if (nl++ == 0) {
32229aa23310Srie 					if (unref)
32237c478bd9Sstevel@tonic-gate 					    (void) printf(MSG_ORIG(MSG_STR_NL));
32247c478bd9Sstevel@tonic-gate 					else
32255aefb655Srie 					    DBG_CALL(Dbg_util_nl(lml,
32265aefb655Srie 						DBG_NL_STD));
32277c478bd9Sstevel@tonic-gate 				}
32287c478bd9Sstevel@tonic-gate 
32299aa23310Srie 				if (unref)
32307c478bd9Sstevel@tonic-gate 				    (void) printf(MSG_INTL(MSG_LDD_UNREF_FMT),
32317c478bd9Sstevel@tonic-gate 					NAME(lmp), NAME(clmp));
32327c478bd9Sstevel@tonic-gate 				else
32335aefb655Srie 				    DBG_CALL(Dbg_unused_unref(lmp, NAME(clmp)));
3234a953e2b1Srie 				/* END CSTYLED */
32357c478bd9Sstevel@tonic-gate 			}
32367c478bd9Sstevel@tonic-gate 		}
32377c478bd9Sstevel@tonic-gate 
32387c478bd9Sstevel@tonic-gate 		/*
32397c478bd9Sstevel@tonic-gate 		 * If tracing unused objects simply display those objects that
32407c478bd9Sstevel@tonic-gate 		 * haven't been referenced by anyone.
32417c478bd9Sstevel@tonic-gate 		 */
32427c478bd9Sstevel@tonic-gate 		if (FLAGS1(lmp) & FL1_RT_USED)
32437c478bd9Sstevel@tonic-gate 			continue;
32447c478bd9Sstevel@tonic-gate 
32457c478bd9Sstevel@tonic-gate 		if (nl++ == 0) {
32469aa23310Srie 			if (unref || unuse)
32477c478bd9Sstevel@tonic-gate 				(void) printf(MSG_ORIG(MSG_STR_NL));
32487c478bd9Sstevel@tonic-gate 			else
32495aefb655Srie 				DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD));
32507c478bd9Sstevel@tonic-gate 		}
32517c478bd9Sstevel@tonic-gate 		if (CYCGROUP(lmp)) {
32529aa23310Srie 			if (unref || unuse)
32537c478bd9Sstevel@tonic-gate 				(void) printf(MSG_INTL(MSG_LDD_UNCYC_FMT),
32547c478bd9Sstevel@tonic-gate 				    NAME(lmp), CYCGROUP(lmp));
32557c478bd9Sstevel@tonic-gate 			else
32565aefb655Srie 				DBG_CALL(Dbg_unused_file(lml, NAME(lmp), 0,
32577c478bd9Sstevel@tonic-gate 				    CYCGROUP(lmp)));
32587c478bd9Sstevel@tonic-gate 		} else {
32599aa23310Srie 			if (unref || unuse)
32607c478bd9Sstevel@tonic-gate 				(void) printf(MSG_INTL(MSG_LDD_UNUSED_FMT),
32617c478bd9Sstevel@tonic-gate 				    NAME(lmp));
32627c478bd9Sstevel@tonic-gate 			else
32635aefb655Srie 				DBG_CALL(Dbg_unused_file(lml, NAME(lmp), 0, 0));
32647c478bd9Sstevel@tonic-gate 		}
32657c478bd9Sstevel@tonic-gate 	}
32667c478bd9Sstevel@tonic-gate 
32675aefb655Srie 	DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD));
32687c478bd9Sstevel@tonic-gate }
32697c478bd9Sstevel@tonic-gate 
32707c478bd9Sstevel@tonic-gate /*
32717c478bd9Sstevel@tonic-gate  * Generic cleanup routine called prior to returning control to the user.
32727c478bd9Sstevel@tonic-gate  * Insures that any ld.so.1 specific file descriptors or temporary mapping are
32737c478bd9Sstevel@tonic-gate  * released, and any locks dropped.
32747c478bd9Sstevel@tonic-gate  */
32757c478bd9Sstevel@tonic-gate void
32768cd45542Sraf leave(Lm_list *lml, int flags)
32777c478bd9Sstevel@tonic-gate {
327856deab07SRod Evans 	Lm_list		*elml = lml;
327956deab07SRod Evans 	Rt_map		*clmp;
328056deab07SRod Evans 	Aliste		idx;
328112b8e62eSrie 
32827c478bd9Sstevel@tonic-gate 	/*
328312b8e62eSrie 	 * Alert the debuggers that the link-maps are consistent.  Note, in the
328412b8e62eSrie 	 * case of tearing down a whole link-map list, lml will be null.  In
328512b8e62eSrie 	 * this case use the main link-map list to test for a notification.
32867c478bd9Sstevel@tonic-gate 	 */
32873dbfc803SRod Evans 	if (elml == NULL)
328812b8e62eSrie 		elml = &lml_main;
328912b8e62eSrie 	if (elml->lm_flags & LML_FLG_DBNOTIF)
329012b8e62eSrie 		rd_event(elml, RD_DLACTIVITY, RT_CONSISTENT);
32917c478bd9Sstevel@tonic-gate 
32927247f888Srie 	/*
32937247f888Srie 	 * Alert any auditors that the link-maps are consistent.
32947247f888Srie 	 */
3295cce0e03bSab 	for (APLIST_TRAVERSE(elml->lm_actaudit, idx, clmp)) {
3296cce0e03bSab 		audit_activity(clmp, LA_ACT_CONSISTENT);
32977247f888Srie 
3298cce0e03bSab 		aplist_delete(elml->lm_actaudit, &idx);
32997247f888Srie 	}
33007247f888Srie 
33017c478bd9Sstevel@tonic-gate 	if (nu_fd != FD_UNAVAIL) {
33027c478bd9Sstevel@tonic-gate 		(void) close(nu_fd);
33037c478bd9Sstevel@tonic-gate 		nu_fd = FD_UNAVAIL;
33047c478bd9Sstevel@tonic-gate 	}
33057c478bd9Sstevel@tonic-gate 
33067c478bd9Sstevel@tonic-gate 	/*
33077c478bd9Sstevel@tonic-gate 	 * Reinitialize error message pointer, and any overflow indication.
33087c478bd9Sstevel@tonic-gate 	 */
33097c478bd9Sstevel@tonic-gate 	nextptr = errbuf;
331043d7826aSRod Evans 	prevptr = NULL;
33117c478bd9Sstevel@tonic-gate 
331256deab07SRod Evans 	/*
331356deab07SRod Evans 	 * Defragment any freed memory.
331456deab07SRod Evans 	 */
331556deab07SRod Evans 	if (aplist_nitems(free_alp))
331656deab07SRod Evans 		defrag();
331756deab07SRod Evans 
33187c478bd9Sstevel@tonic-gate 	/*
33197c478bd9Sstevel@tonic-gate 	 * Don't drop our lock if we are running on our link-map list as
33207c478bd9Sstevel@tonic-gate 	 * there's little point in doing so since we are single-threaded.
33217c478bd9Sstevel@tonic-gate 	 *
33227c478bd9Sstevel@tonic-gate 	 * LML_FLG_HOLDLOCK is set for:
332343d7826aSRod Evans 	 *  -	 The ld.so.1's link-map list.
332443d7826aSRod Evans 	 *  -	 The auditor's link-map if the environment is pre-UPM.
33257c478bd9Sstevel@tonic-gate 	 */
33267c478bd9Sstevel@tonic-gate 	if (lml && (lml->lm_flags & LML_FLG_HOLDLOCK))
33277c478bd9Sstevel@tonic-gate 		return;
33287c478bd9Sstevel@tonic-gate 
33297c478bd9Sstevel@tonic-gate 	if (rt_bind_clear(0) & THR_FLG_RTLD) {
33308cd45542Sraf 		if (!thr_flg_nolock)
33318cd45542Sraf 			(void) rt_mutex_unlock(&rtldlock);
33328cd45542Sraf 		(void) rt_bind_clear(THR_FLG_RTLD | thr_flg_nolock | flags);
33337c478bd9Sstevel@tonic-gate 	}
33347c478bd9Sstevel@tonic-gate }
33357c478bd9Sstevel@tonic-gate 
33367c478bd9Sstevel@tonic-gate int
333760758829Srie callable(Rt_map *clmp, Rt_map *dlmp, Grp_hdl *ghp, uint_t slflags)
33387c478bd9Sstevel@tonic-gate {
3339cce0e03bSab 	APlist		*calp, *dalp;
3340cce0e03bSab 	Aliste		idx1, idx2;
3341cce0e03bSab 	Grp_hdl		*ghp1, *ghp2;
33427c478bd9Sstevel@tonic-gate 
33437c478bd9Sstevel@tonic-gate 	/*
33447c478bd9Sstevel@tonic-gate 	 * An object can always find symbols within itself.
33457c478bd9Sstevel@tonic-gate 	 */
33467c478bd9Sstevel@tonic-gate 	if (clmp == dlmp)
33477c478bd9Sstevel@tonic-gate 		return (1);
33487c478bd9Sstevel@tonic-gate 
334960758829Srie 	/*
335060758829Srie 	 * The search for a singleton must look in every loaded object.
335160758829Srie 	 */
335260758829Srie 	if (slflags & LKUP_SINGLETON)
335360758829Srie 		return (1);
335460758829Srie 
33557c478bd9Sstevel@tonic-gate 	/*
33567c478bd9Sstevel@tonic-gate 	 * Don't allow an object to bind to an object that is being deleted
33577c478bd9Sstevel@tonic-gate 	 * unless the binder is also being deleted.
33587c478bd9Sstevel@tonic-gate 	 */
33597c478bd9Sstevel@tonic-gate 	if ((FLAGS(dlmp) & FLG_RT_DELETE) &&
33607c478bd9Sstevel@tonic-gate 	    ((FLAGS(clmp) & FLG_RT_DELETE) == 0))
33617c478bd9Sstevel@tonic-gate 		return (0);
33627c478bd9Sstevel@tonic-gate 
33637c478bd9Sstevel@tonic-gate 	/*
33647c478bd9Sstevel@tonic-gate 	 * An object with world access can always bind to an object with global
33657c478bd9Sstevel@tonic-gate 	 * visibility.
33667c478bd9Sstevel@tonic-gate 	 */
336737ffaf83SRod Evans 	if (((MODE(clmp) & RTLD_WORLD) || (slflags & LKUP_WORLD)) &&
336837ffaf83SRod Evans 	    (MODE(dlmp) & RTLD_GLOBAL))
33697c478bd9Sstevel@tonic-gate 		return (1);
33707c478bd9Sstevel@tonic-gate 
33717c478bd9Sstevel@tonic-gate 	/*
33727c478bd9Sstevel@tonic-gate 	 * An object with local access can only bind to an object that is a
33737c478bd9Sstevel@tonic-gate 	 * member of the same group.
33747c478bd9Sstevel@tonic-gate 	 */
33757c478bd9Sstevel@tonic-gate 	if (((MODE(clmp) & RTLD_GROUP) == 0) ||
3376cce0e03bSab 	    ((calp = GROUPS(clmp)) == NULL) || ((dalp = GROUPS(dlmp)) == NULL))
33777c478bd9Sstevel@tonic-gate 		return (0);
33787c478bd9Sstevel@tonic-gate 
33797c478bd9Sstevel@tonic-gate 	/*
33807c478bd9Sstevel@tonic-gate 	 * Traverse the list of groups the caller is a part of.
33817c478bd9Sstevel@tonic-gate 	 */
3382cce0e03bSab 	for (APLIST_TRAVERSE(calp, idx1, ghp1)) {
33837c478bd9Sstevel@tonic-gate 		/*
33847c478bd9Sstevel@tonic-gate 		 * If we're testing for the ability of two objects to bind to
33857c478bd9Sstevel@tonic-gate 		 * each other regardless of a specific group, ignore that group.
33867c478bd9Sstevel@tonic-gate 		 */
3387cce0e03bSab 		if (ghp && (ghp1 == ghp))
33887c478bd9Sstevel@tonic-gate 			continue;
33897c478bd9Sstevel@tonic-gate 
33907c478bd9Sstevel@tonic-gate 		/*
33917c478bd9Sstevel@tonic-gate 		 * Traverse the list of groups the destination is a part of.
33927c478bd9Sstevel@tonic-gate 		 */
3393cce0e03bSab 		for (APLIST_TRAVERSE(dalp, idx2, ghp2)) {
3394efb9e8b8Srie 			Grp_desc	*gdp;
3395cce0e03bSab 			Aliste		idx3;
3396efb9e8b8Srie 
3397cce0e03bSab 			if (ghp1 != ghp2)
3398efb9e8b8Srie 				continue;
3399efb9e8b8Srie 
3400efb9e8b8Srie 			/*
3401efb9e8b8Srie 			 * Make sure the relationship between the destination
3402efb9e8b8Srie 			 * and the caller provide symbols for relocation.
3403efb9e8b8Srie 			 * Parents are maintained as callers, but unless the
3404efb9e8b8Srie 			 * destination object was opened with RTLD_PARENT, the
3405efb9e8b8Srie 			 * parent doesn't provide symbols for the destination
3406efb9e8b8Srie 			 * to relocate against.
3407efb9e8b8Srie 			 */
3408cce0e03bSab 			for (ALIST_TRAVERSE(ghp2->gh_depends, idx3, gdp)) {
3409efb9e8b8Srie 				if (dlmp != gdp->gd_depend)
3410efb9e8b8Srie 					continue;
3411efb9e8b8Srie 
3412efb9e8b8Srie 				if (gdp->gd_flags & GPD_RELOC)
3413efb9e8b8Srie 					return (1);
3414efb9e8b8Srie 			}
34157c478bd9Sstevel@tonic-gate 		}
34167c478bd9Sstevel@tonic-gate 	}
34177c478bd9Sstevel@tonic-gate 	return (0);
34187c478bd9Sstevel@tonic-gate }
34197c478bd9Sstevel@tonic-gate 
34207c478bd9Sstevel@tonic-gate /*
34217c478bd9Sstevel@tonic-gate  * Initialize the environ symbol.  Traditionally this is carried out by the crt
34227c478bd9Sstevel@tonic-gate  * code prior to jumping to main.  However, init sections get fired before this
34237c478bd9Sstevel@tonic-gate  * variable is initialized, so ld.so.1 sets this directly from the AUX vector
34247c478bd9Sstevel@tonic-gate  * information.  In addition, a process may have multiple link-maps (ld.so.1's
34257c478bd9Sstevel@tonic-gate  * debugging and preloading objects), and link auditing, and each may need an
34267c478bd9Sstevel@tonic-gate  * environ variable set.
34277c478bd9Sstevel@tonic-gate  *
34287c478bd9Sstevel@tonic-gate  * This routine is called after a relocation() pass, and thus provides for:
34297c478bd9Sstevel@tonic-gate  *
343043d7826aSRod Evans  *  -	setting environ on the main link-map after the initial application and
34317c478bd9Sstevel@tonic-gate  *	its dependencies have been established.  Typically environ lives in the
34327c478bd9Sstevel@tonic-gate  *	application (provided by its crt), but in older applications it might
34337c478bd9Sstevel@tonic-gate  *	be in libc.  Who knows what's expected of applications not built on
34347c478bd9Sstevel@tonic-gate  *	Solaris.
34357c478bd9Sstevel@tonic-gate  *
343643d7826aSRod Evans  *  -	after loading a new shared object.  We can add shared objects to various
34377c478bd9Sstevel@tonic-gate  *	link-maps, and any link-map dependencies requiring getopt() require
34387c478bd9Sstevel@tonic-gate  *	their own environ.  In addition, lazy loading might bring in the
343941072f3cSrie  *	supplier of environ (libc used to be a lazy loading candidate) after
344041072f3cSrie  *	the link-map has been established and other objects are present.
34417c478bd9Sstevel@tonic-gate  *
34427c478bd9Sstevel@tonic-gate  * This routine handles all these scenarios, without adding unnecessary overhead
34437c478bd9Sstevel@tonic-gate  * to ld.so.1.
34447c478bd9Sstevel@tonic-gate  */
34457c478bd9Sstevel@tonic-gate void
34467c478bd9Sstevel@tonic-gate set_environ(Lm_list *lml)
34477c478bd9Sstevel@tonic-gate {
34487c478bd9Sstevel@tonic-gate 	Slookup		sl;
3449*08278a5eSRod Evans 	Sresult		sr;
34507c478bd9Sstevel@tonic-gate 	uint_t		binfo;
34517c478bd9Sstevel@tonic-gate 
345275e7992aSrie 	/*
3453*08278a5eSRod Evans 	 * Initialize the symbol lookup, and symbol result, data structures.
345475e7992aSrie 	 */
345575e7992aSrie 	SLOOKUP_INIT(sl, MSG_ORIG(MSG_SYM_ENVIRON), lml->lm_head, lml->lm_head,
345675e7992aSrie 	    ld_entry_cnt, 0, 0, 0, 0, LKUP_WEAK);
3457*08278a5eSRod Evans 	SRESULT_INIT(sr, MSG_ORIG(MSG_SYM_ENVIRON));
3458*08278a5eSRod Evans 
3459*08278a5eSRod Evans 	if (LM_LOOKUP_SYM(lml->lm_head)(&sl, &sr, &binfo, 0)) {
3460*08278a5eSRod Evans 		Rt_map	*dlmp = sr.sr_dmap;
34617c478bd9Sstevel@tonic-gate 
3462*08278a5eSRod Evans 		lml->lm_environ = (char ***)sr.sr_sym->st_value;
34637c478bd9Sstevel@tonic-gate 
34647c478bd9Sstevel@tonic-gate 		if (!(FLAGS(dlmp) & FLG_RT_FIXED))
346541072f3cSrie 			lml->lm_environ =
346641072f3cSrie 			    (char ***)((uintptr_t)lml->lm_environ +
346741072f3cSrie 			    (uintptr_t)ADDR(dlmp));
346841072f3cSrie 		*(lml->lm_environ) = (char **)environ;
34697c478bd9Sstevel@tonic-gate 		lml->lm_flags |= LML_FLG_ENVIRON;
34707c478bd9Sstevel@tonic-gate 	}
34717c478bd9Sstevel@tonic-gate }
34727c478bd9Sstevel@tonic-gate 
34737c478bd9Sstevel@tonic-gate /*
34747c478bd9Sstevel@tonic-gate  * Determine whether we have a secure executable.  Uid and gid information
34757c478bd9Sstevel@tonic-gate  * can be passed to us via the aux vector, however if these values are -1
34767c478bd9Sstevel@tonic-gate  * then use the appropriate system call to obtain them.
34777c478bd9Sstevel@tonic-gate  *
347843d7826aSRod Evans  *  -	If the user is the root they can do anything
34797c478bd9Sstevel@tonic-gate  *
348043d7826aSRod Evans  *  -	If the real and effective uid's don't match, or the real and
34817c478bd9Sstevel@tonic-gate  *	effective gid's don't match then this is determined to be a `secure'
34827c478bd9Sstevel@tonic-gate  *	application.
34837c478bd9Sstevel@tonic-gate  *
34847c478bd9Sstevel@tonic-gate  * This function is called prior to any dependency processing (see _setup.c).
34857c478bd9Sstevel@tonic-gate  * Any secure setting will remain in effect for the life of the process.
34867c478bd9Sstevel@tonic-gate  */
34877c478bd9Sstevel@tonic-gate void
34887c478bd9Sstevel@tonic-gate security(uid_t uid, uid_t euid, gid_t gid, gid_t egid, int auxflags)
34897c478bd9Sstevel@tonic-gate {
34907c478bd9Sstevel@tonic-gate 	if (auxflags != -1) {
34917c478bd9Sstevel@tonic-gate 		if ((auxflags & AF_SUN_SETUGID) != 0)
34927c478bd9Sstevel@tonic-gate 			rtld_flags |= RT_FL_SECURE;
34937c478bd9Sstevel@tonic-gate 		return;
34947c478bd9Sstevel@tonic-gate 	}
349556deab07SRod Evans 
3496a953e2b1Srie 	if (uid == (uid_t)-1)
34977c478bd9Sstevel@tonic-gate 		uid = getuid();
34987c478bd9Sstevel@tonic-gate 	if (uid) {
3499a953e2b1Srie 		if (euid == (uid_t)-1)
35007c478bd9Sstevel@tonic-gate 			euid = geteuid();
35017c478bd9Sstevel@tonic-gate 		if (uid != euid)
35027c478bd9Sstevel@tonic-gate 			rtld_flags |= RT_FL_SECURE;
35037c478bd9Sstevel@tonic-gate 		else {
3504a953e2b1Srie 			if (gid == (gid_t)-1)
35057c478bd9Sstevel@tonic-gate 				gid = getgid();
3506a953e2b1Srie 			if (egid == (gid_t)-1)
35077c478bd9Sstevel@tonic-gate 				egid = getegid();
35087c478bd9Sstevel@tonic-gate 			if (gid != egid)
35097c478bd9Sstevel@tonic-gate 				rtld_flags |= RT_FL_SECURE;
35107c478bd9Sstevel@tonic-gate 		}
35117c478bd9Sstevel@tonic-gate 	}
35127c478bd9Sstevel@tonic-gate }
35137c478bd9Sstevel@tonic-gate 
35143dbfc803SRod Evans /*
35153dbfc803SRod Evans  * Determine whether ld.so.1 itself is owned by root and has its mode setuid.
35163dbfc803SRod Evans  */
35173dbfc803SRod Evans int
35183dbfc803SRod Evans is_rtld_setuid()
35193dbfc803SRod Evans {
3520cb511613SAli Bahrami 	rtld_stat_t	status;
35213dbfc803SRod Evans 
35223dbfc803SRod Evans 	if ((rtld_flags2 & RT_FL2_SETUID) ||
3523cb511613SAli Bahrami 	    ((rtld_stat(NAME(lml_rtld.lm_head), &status) == 0) &&
35243dbfc803SRod Evans 	    (status.st_uid == 0) && (status.st_mode & S_ISUID))) {
35253dbfc803SRod Evans 		rtld_flags2 |= RT_FL2_SETUID;
35263dbfc803SRod Evans 		return (1);
35273dbfc803SRod Evans 	}
35283dbfc803SRod Evans 	return (0);
35293dbfc803SRod Evans }
35303dbfc803SRod Evans 
3531*08278a5eSRod Evans /*
3532*08278a5eSRod Evans  * Determine that systems platform name.  Normally, this name is provided from
3533*08278a5eSRod Evans  * the AT_SUN_PLATFORM aux vector from the kernel.  This routine provides a
3534*08278a5eSRod Evans  * fall back.
3535*08278a5eSRod Evans  */
3536*08278a5eSRod Evans void
3537*08278a5eSRod Evans platform_name(Syscapset *scapset)
3538*08278a5eSRod Evans {
3539*08278a5eSRod Evans 	char	info[SYS_NMLN];
3540*08278a5eSRod Evans 	size_t	size;
3541*08278a5eSRod Evans 
3542*08278a5eSRod Evans 	if ((scapset->sc_platsz = size =
3543*08278a5eSRod Evans 	    sysinfo(SI_PLATFORM, info, SYS_NMLN)) == (size_t)-1)
3544*08278a5eSRod Evans 		return;
3545*08278a5eSRod Evans 
3546*08278a5eSRod Evans 	if ((scapset->sc_plat = malloc(size)) == NULL) {
3547*08278a5eSRod Evans 		scapset->sc_platsz = (size_t)-1;
3548*08278a5eSRod Evans 		return;
3549*08278a5eSRod Evans 	}
3550*08278a5eSRod Evans 	(void) strcpy(scapset->sc_plat, info);
3551*08278a5eSRod Evans }
3552*08278a5eSRod Evans 
3553*08278a5eSRod Evans /*
3554*08278a5eSRod Evans  * Determine that systems machine name.  Normally, this name is provided from
3555*08278a5eSRod Evans  * the AT_SUN_MACHINE aux vector from the kernel.  This routine provides a
3556*08278a5eSRod Evans  * fall back.
3557*08278a5eSRod Evans  */
3558*08278a5eSRod Evans void
3559*08278a5eSRod Evans machine_name(Syscapset *scapset)
3560*08278a5eSRod Evans {
3561*08278a5eSRod Evans 	char	info[SYS_NMLN];
3562*08278a5eSRod Evans 	size_t	size;
3563*08278a5eSRod Evans 
3564*08278a5eSRod Evans 	if ((scapset->sc_machsz = size =
3565*08278a5eSRod Evans 	    sysinfo(SI_MACHINE, info, SYS_NMLN)) == (size_t)-1)
3566*08278a5eSRod Evans 		return;
3567*08278a5eSRod Evans 
3568*08278a5eSRod Evans 	if ((scapset->sc_mach = malloc(size)) == NULL) {
3569*08278a5eSRod Evans 		scapset->sc_machsz = (size_t)-1;
3570*08278a5eSRod Evans 		return;
3571*08278a5eSRod Evans 	}
3572*08278a5eSRod Evans 	(void) strcpy(scapset->sc_mach, info);
3573*08278a5eSRod Evans }
3574*08278a5eSRod Evans 
35757c478bd9Sstevel@tonic-gate /*
35767c478bd9Sstevel@tonic-gate  * _REENTRANT code gets errno redefined to a function so provide for return
35777c478bd9Sstevel@tonic-gate  * of the thread errno if applicable.  This has no meaning in ld.so.1 which
35787c478bd9Sstevel@tonic-gate  * is basically singled threaded.  Provide the interface for our dependencies.
35797c478bd9Sstevel@tonic-gate  */
35807c478bd9Sstevel@tonic-gate #undef errno
35817c478bd9Sstevel@tonic-gate int *
35827c478bd9Sstevel@tonic-gate ___errno()
35837c478bd9Sstevel@tonic-gate {
35847c478bd9Sstevel@tonic-gate 	extern	int	errno;
35857c478bd9Sstevel@tonic-gate 
35867c478bd9Sstevel@tonic-gate 	return (&errno);
35877c478bd9Sstevel@tonic-gate }
35887c478bd9Sstevel@tonic-gate 
35897c478bd9Sstevel@tonic-gate /*
35907c478bd9Sstevel@tonic-gate  * Determine whether a symbol name should be demangled.
35917c478bd9Sstevel@tonic-gate  */
35927c478bd9Sstevel@tonic-gate const char *
35937c478bd9Sstevel@tonic-gate demangle(const char *name)
35947c478bd9Sstevel@tonic-gate {
35957c478bd9Sstevel@tonic-gate 	if (rtld_flags & RT_FL_DEMANGLE)
35965aefb655Srie 		return (conv_demangle_name(name));
35977c478bd9Sstevel@tonic-gate 	else
35987c478bd9Sstevel@tonic-gate 		return (name);
35997c478bd9Sstevel@tonic-gate }
3600cb511613SAli Bahrami 
3601cb511613SAli Bahrami #ifndef _LP64
3602cb511613SAli Bahrami /*
3603cb511613SAli Bahrami  * Wrappers on stat() and fstat() for 32-bit rtld that uses stat64()
3604cb511613SAli Bahrami  * underneath while preserving the object size limits of a non-largefile
3605cb511613SAli Bahrami  * enabled 32-bit process. The purpose of this is to prevent large inode
3606cb511613SAli Bahrami  * values from causing stat() to fail.
3607cb511613SAli Bahrami  */
3608cb511613SAli Bahrami inline static int
3609cb511613SAli Bahrami rtld_stat_process(int r, struct stat64 *lbuf, rtld_stat_t *restrict buf)
3610cb511613SAli Bahrami {
3611cb511613SAli Bahrami 	extern int	errno;
3612cb511613SAli Bahrami 
3613cb511613SAli Bahrami 	/*
3614cb511613SAli Bahrami 	 * Although we used a 64-bit capable stat(), the 32-bit rtld
3615cb511613SAli Bahrami 	 * can only handle objects < 2GB in size. If this object is
3616cb511613SAli Bahrami 	 * too big, turn the success into an overflow error.
3617cb511613SAli Bahrami 	 */
3618cb511613SAli Bahrami 	if ((lbuf->st_size & 0xffffffff80000000) != 0) {
3619cb511613SAli Bahrami 		errno = EOVERFLOW;
3620cb511613SAli Bahrami 		return (-1);
3621cb511613SAli Bahrami 	}
3622cb511613SAli Bahrami 
3623cb511613SAli Bahrami 	/*
3624cb511613SAli Bahrami 	 * Transfer the information needed by rtld into a rtld_stat_t
3625cb511613SAli Bahrami 	 * structure that preserves the non-largile types for everything
3626cb511613SAli Bahrami 	 * except inode.
3627cb511613SAli Bahrami 	 */
3628cb511613SAli Bahrami 	buf->st_dev = lbuf->st_dev;
3629cb511613SAli Bahrami 	buf->st_ino = lbuf->st_ino;
3630cb511613SAli Bahrami 	buf->st_mode = lbuf->st_mode;
3631cb511613SAli Bahrami 	buf->st_uid = lbuf->st_uid;
3632cb511613SAli Bahrami 	buf->st_size = (off_t)lbuf->st_size;
3633cb511613SAli Bahrami 	buf->st_mtim = lbuf->st_mtim;
3634cb511613SAli Bahrami #ifdef sparc
3635cb511613SAli Bahrami 	buf->st_blksize = lbuf->st_blksize;
3636cb511613SAli Bahrami #endif
3637cb511613SAli Bahrami 
3638cb511613SAli Bahrami 	return (r);
3639cb511613SAli Bahrami }
3640cb511613SAli Bahrami 
3641cb511613SAli Bahrami int
3642cb511613SAli Bahrami rtld_stat(const char *restrict path, rtld_stat_t *restrict buf)
3643cb511613SAli Bahrami {
3644cb511613SAli Bahrami 	struct stat64	lbuf;
3645cb511613SAli Bahrami 	int		r;
3646cb511613SAli Bahrami 
3647cb511613SAli Bahrami 	r = stat64(path, &lbuf);
3648cb511613SAli Bahrami 	if (r != -1)
3649cb511613SAli Bahrami 		r = rtld_stat_process(r, &lbuf, buf);
3650cb511613SAli Bahrami 	return (r);
3651cb511613SAli Bahrami }
3652cb511613SAli Bahrami 
3653cb511613SAli Bahrami int
3654cb511613SAli Bahrami rtld_fstat(int fildes, rtld_stat_t *restrict buf)
3655cb511613SAli Bahrami {
3656cb511613SAli Bahrami 	struct stat64	lbuf;
3657cb511613SAli Bahrami 	int		r;
3658cb511613SAli Bahrami 
3659cb511613SAli Bahrami 	r = fstat64(fildes, &lbuf);
3660cb511613SAli Bahrami 	if (r != -1)
3661cb511613SAli Bahrami 		r = rtld_stat_process(r, &lbuf, buf);
3662cb511613SAli Bahrami 	return (r);
3663cb511613SAli Bahrami }
3664cb511613SAli Bahrami #endif
3665