xref: /titanic_50/usr/src/cmd/sgs/rtld/common/util.c (revision c0889d7a91fa87e1cb7ef4457629b0cb51d47b50)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  *	Copyright (c) 1988 AT&T
24  *	  All Rights Reserved
25  *
26  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
27  * Use is subject to license terms.
28  */
29 #pragma ident	"%Z%%M%	%I%	%E% SMI"
30 
31 /*
32  * Utility routines for run-time linker.  some are duplicated here from libc
33  * (with different names) to avoid name space collisions.
34  */
35 #include	"_synonyms.h"
36 #include	<stdio.h>
37 #include	<sys/types.h>
38 #include	<sys/mman.h>
39 #include	<sys/lwp.h>
40 #include	<sys/debug.h>
41 #include	<stdarg.h>
42 #include	<fcntl.h>
43 #include	<string.h>
44 #include	<ctype.h>
45 #include	<dlfcn.h>
46 #include	<unistd.h>
47 #include	<stdlib.h>
48 #include	<sys/auxv.h>
49 #include	<debug.h>
50 #include	<conv.h>
51 #include	"_rtld.h"
52 #include	"_audit.h"
53 #include	"_elf.h"
54 #include	"msg.h"
55 
56 static int ld_flags_env(const char *, Word *, Word *, uint_t, int);
57 
58 /*
59  * All error messages go through eprintf().  During process initialization these
60  * messages should be directed to the standard error, however once control has
61  * been passed to the applications code these messages should be stored in an
62  * internal buffer for use with dlerror().  Note, fatal error conditions that
63  * may occur while running the application will still cause a standard error
64  * message, see rtldexit() in this file for details.
65  * The `application' flag serves to indicate the transition between process
66  * initialization and when the applications code is running.
67  */
68 
69 /*
70  * Null function used as place where a debugger can set a breakpoint.
71  */
72 void
73 rtld_db_dlactivity(Lm_list *lml)
74 {
75 	DBG_CALL(Dbg_util_dbnotify(lml, r_debug.rtd_rdebug.r_rdevent,
76 	    r_debug.rtd_rdebug.r_state));
77 }
78 
79 /*
80  * Null function used as place where debugger can set a pre .init
81  * processing breakpoint.
82  */
83 void
84 rtld_db_preinit(Lm_list *lml)
85 {
86 	DBG_CALL(Dbg_util_dbnotify(lml, r_debug.rtd_rdebug.r_rdevent,
87 	    r_debug.rtd_rdebug.r_state));
88 }
89 
90 /*
91  * Null function used as place where debugger can set a post .init
92  * processing breakpoint.
93  */
94 void
95 rtld_db_postinit(Lm_list *lml)
96 {
97 	DBG_CALL(Dbg_util_dbnotify(lml, r_debug.rtd_rdebug.r_rdevent,
98 	    r_debug.rtd_rdebug.r_state));
99 }
100 
101 /*
102  * Debugger Event Notification
103  *
104  * This function centralizes all debugger event notification (ala rtld_db).
105  *
106  * There's a simple intent, focused on insuring the primary link-map control
107  * list (or each link-map list) is consistent, and the indication that objects
108  * have been added or deleted from this list.  Although an RD_ADD and RD_DELETE
109  * event are posted for each of these, most debuggers don't care, as their
110  * view is that these events simply convey an "inconsistent" state.
111  *
112  * We also don't want to trigger multiple RD_ADD/RD_DELETE events any time we
113  * enter ld.so.1.
114  *
115  * With auditors, we may be in the process of relocating a collection of
116  * objects, and will leave() ld.so.1 to call the auditor.  At this point we
117  * must indicate an RD_CONSISTENT event, but librtld_db will not report an
118  * object to the debuggers until relocation processing has been completed on it.
119  * To allow for the collection of these objects that are pending relocation, an
120  * RD_ADD event is set after completing a series of relocations on the primary
121  * link-map control list.
122  *
123  * Set an RD_ADD/RD_DELETE event and indicate that an RD_CONSISTENT event is
124  * required later (LML_FLG_DBNOTIF):
125  *
126  *  i	the first time we add or delete an object to the primary link-map
127  *	control list.
128  *  ii	the first time we move a secondary link-map control list to the primary
129  *	link-map control list (effectively, this is like adding a group of
130  *	objects to the primary link-map control list).
131  *
132  * Set an RD_CONSISTENT event when it is required (LML_FLG_DBNOTIF is set) and
133  *
134  *  i	each time we leave the runtime linker.
135  */
136 void
137 rd_event(Lm_list *lml, rd_event_e event, r_state_e state)
138 {
139 	void	(*fptr)(Lm_list *);
140 
141 	switch (event) {
142 	case RD_PREINIT:
143 		fptr = rtld_db_preinit;
144 		break;
145 	case RD_POSTINIT:
146 		fptr = rtld_db_postinit;
147 		break;
148 	case RD_DLACTIVITY:
149 		switch (state) {
150 		case RT_CONSISTENT:
151 			lml->lm_flags &= ~LML_FLG_DBNOTIF;
152 
153 			/*
154 			 * Do we need to send a notification?
155 			 */
156 			if ((rtld_flags & RT_FL_DBNOTIF) == 0)
157 				return;
158 			rtld_flags &= ~RT_FL_DBNOTIF;
159 			break;
160 		case RT_ADD:
161 		case RT_DELETE:
162 			lml->lm_flags |= LML_FLG_DBNOTIF;
163 
164 			/*
165 			 * If we are already in an inconsistent state, no
166 			 * notification is required.
167 			 */
168 			if (rtld_flags & RT_FL_DBNOTIF)
169 				return;
170 			rtld_flags |= RT_FL_DBNOTIF;
171 			break;
172 		};
173 		fptr = rtld_db_dlactivity;
174 		break;
175 	default:
176 		/*
177 		 * RD_NONE - do nothing
178 		 */
179 		break;
180 	};
181 
182 	/*
183 	 * Set event state and call 'notification' function.
184 	 *
185 	 * The debugging clients have previously been told about these
186 	 * notification functions and have set breakpoints on them if they
187 	 * are interested in the notification.
188 	 */
189 	r_debug.rtd_rdebug.r_state = state;
190 	r_debug.rtd_rdebug.r_rdevent = event;
191 	fptr(lml);
192 	r_debug.rtd_rdebug.r_rdevent = RD_NONE;
193 }
194 
195 #if	defined(__sparc) || defined(__x86)
196 /*
197  * Stack Cleanup.
198  *
199  * This function is invoked to 'remove' arguments that were passed in on the
200  * stack.  This is most likely if ld.so.1 was invoked directly.  In that case
201  * we want to remove ld.so.1 as well as it's arguments from the argv[] array.
202  * Which means we then need to slide everything above it on the stack down
203  * accordingly.
204  *
205  * While the stack layout is platform specific - it just so happens that __x86,
206  * and __sparc platforms share the following initial stack layout.
207  *
208  *	!_______________________!  high addresses
209  *	!			!
210  *	!	Information	!
211  *	!	Block		!
212  *	!	(size varies)	!
213  *	!_______________________!
214  *	!	0 word		!
215  *	!_______________________!
216  *	!	Auxiliary	!
217  *	!	vector		!
218  *	!	2 word entries	!
219  *	!			!
220  *	!_______________________!
221  *	!	0 word		!
222  *	!_______________________!
223  *	!	Environment	!
224  *	!	pointers	!
225  *	!	...		!
226  *	!	(one word each)	!
227  *	!_______________________!
228  *	!	0 word		!
229  *	!_______________________!
230  *	!	Argument	! low addresses
231  *	!	pointers	!
232  *	!	Argc words	!
233  *	!_______________________!
234  *	!			!
235  *	!	Argc		!
236  *	!_______________________!
237  *	!	...		!
238  *
239  */
240 static void
241 stack_cleanup(char **argv, char ***envp, auxv_t **auxv, int rmcnt)
242 {
243 	int		ndx;
244 	long		*argc;
245 	char		**oargv, **nargv;
246 	char		**oenvp, **nenvp;
247 	auxv_t		*oauxv, *nauxv;
248 
249 	/*
250 	 * Slide ARGV[] and update argc.  The argv pointer remains the same,
251 	 * however slide the applications arguments over the arguments to
252 	 * ld.so.1.
253 	 */
254 	nargv = &argv[0];
255 	oargv = &argv[rmcnt];
256 
257 	for (ndx = 0; oargv[ndx]; ndx++)
258 		nargv[ndx] = oargv[ndx];
259 	nargv[ndx] = oargv[ndx];
260 
261 	argc = (long *)((uintptr_t)argv - sizeof (long *));
262 	*argc -= rmcnt;
263 
264 	/*
265 	 * Slide ENVP[], and update the environment array pointer.
266 	 */
267 	ndx++;
268 	nenvp = &nargv[ndx];
269 	oenvp = &oargv[ndx];
270 	*envp = nenvp;
271 
272 	for (ndx = 0; oenvp[ndx]; ndx++)
273 		nenvp[ndx] = oenvp[ndx];
274 	nenvp[ndx] = oenvp[ndx];
275 
276 	/*
277 	 * Slide AUXV[], and update the aux vector pointer.
278 	 */
279 	ndx++;
280 	nauxv = (auxv_t *)&nenvp[ndx];
281 	oauxv = (auxv_t *)&oenvp[ndx];
282 	*auxv = nauxv;
283 
284 	for (ndx = 0; (oauxv[ndx].a_type != AT_NULL); ndx++)
285 		nauxv[ndx] = oauxv[ndx];
286 	nauxv[ndx] = oauxv[ndx];
287 }
288 #else
289 /*
290  * Verify that the above routine is appropriate for any new platforms.
291  */
292 #error	unsupported architecture!
293 #endif
294 
295 /*
296  * The only command line argument recognized is -e, followed by a runtime
297  * linker environment variable.
298  */
299 int
300 rtld_getopt(char **argv, char ***envp, auxv_t **auxv, Word *lmflags,
301     Word *lmtflags, int aout)
302 {
303 	int	ndx;
304 
305 	for (ndx = 1; argv[ndx]; ndx++) {
306 		char	*str;
307 
308 		if (argv[ndx][0] != '-')
309 			break;
310 
311 		if (argv[ndx][1] == '\0') {
312 			ndx++;
313 			break;
314 		}
315 
316 		if (argv[ndx][1] != 'e')
317 			return (1);
318 
319 		if (argv[ndx][2] == '\0') {
320 			ndx++;
321 			if (argv[ndx] == NULL)
322 				return (1);
323 			str = argv[ndx];
324 		} else
325 			str = &argv[ndx][2];
326 
327 		/*
328 		 * If the environment variable starts with LD_, strip the LD_.
329 		 * Otherwise, take things as is.
330 		 */
331 		if ((str[0] == 'L') && (str[1] == 'D') && (str[2] == '_') &&
332 		    (str[3] != '\0'))
333 			str += 3;
334 		if (ld_flags_env(str, lmflags, lmtflags, 0, aout) == 1)
335 			return (1);
336 	}
337 
338 	/*
339 	 * Make sure an object file has been specified.
340 	 */
341 	if (argv[ndx] == 0)
342 		return (1);
343 
344 	/*
345 	 * Having gotten the arguments, clean ourselves off of the stack.
346 	 */
347 	stack_cleanup(argv, envp, auxv, ndx);
348 	return (0);
349 }
350 
351 /*
352  * Compare function for FullpathNode AVL tree.
353  */
354 static int
355 fpavl_compare(const void * n1, const void * n2)
356 {
357 	uint_t		hash1, hash2;
358 	const char	*st1, *st2;
359 	int		rc;
360 
361 	hash1 = ((FullpathNode *)n1)->fpn_hash;
362 	hash2 = ((FullpathNode *)n2)->fpn_hash;
363 
364 	if (hash1 > hash2)
365 		return (1);
366 	if (hash1 < hash2)
367 		return (-1);
368 
369 	st1 = ((FullpathNode *)n1)->fpn_name;
370 	st2 = ((FullpathNode *)n2)->fpn_name;
371 
372 	rc = strcmp(st1, st2);
373 	if (rc > 0)
374 		return (1);
375 	if (rc < 0)
376 		return (-1);
377 	return (0);
378 }
379 
380 
381 /*
382  * Determine if a given pathname has already been loaded in the AVL tree.
383  * If the pathname does not exist in the AVL tree, the next insertion point
384  * is deposited in "where".  This value can be used by fpavl_insert() to
385  * expedite the insertion.
386  */
387 Rt_map *
388 fpavl_loaded(Lm_list *lml, const char *name, avl_index_t *where)
389 {
390 	FullpathNode	fpn, *fpnp;
391 	avl_tree_t	*avlt;
392 
393 	/*
394 	 * Create the avl tree if required.
395 	 */
396 	if ((avlt = lml->lm_fpavl) == NULL) {
397 		if ((avlt = calloc(sizeof (avl_tree_t), 1)) == 0)
398 			return (0);
399 		avl_create(avlt, fpavl_compare, sizeof (FullpathNode),
400 		    SGSOFFSETOF(FullpathNode, fpn_avl));
401 		lml->lm_fpavl = avlt;
402 	}
403 
404 	fpn.fpn_name = name;
405 	fpn.fpn_hash = sgs_str_hash(name);
406 
407 	if ((fpnp = avl_find(lml->lm_fpavl, &fpn, where)) == NULL)
408 		return (NULL);
409 
410 	return (fpnp->fpn_lmp);
411 }
412 
413 
414 /*
415  * Insert a name into the FullpathNode AVL tree for the link-map list.  The
416  * objects NAME() is the path that would have originally been searched for, and
417  * is therefore the name to associate with any "where" value.  If the object has
418  * a different PATHNAME(), perhaps because it has resolved to a different file
419  * (see fullpath), then this name is recorded also.  See load_file().
420  */
421 int
422 fpavl_insert(Lm_list *lml, Rt_map *lmp, const char *name, avl_index_t where)
423 {
424 	FullpathNode	*fpnp;
425 
426 	if (where == 0) {
427 		/* LINTED */
428 		Rt_map	*_lmp = fpavl_loaded(lml, name, &where);
429 
430 		/*
431 		 * We better not get a hit now, we do not want duplicates in
432 		 * the tree.
433 		 */
434 		ASSERT(_lmp == 0);
435 	}
436 
437 	/*
438 	 * Insert new node in tree
439 	 */
440 	if ((fpnp = calloc(sizeof (FullpathNode), 1)) == 0)
441 		return (0);
442 
443 	fpnp->fpn_name = name;
444 	fpnp->fpn_hash = sgs_str_hash(name);
445 	fpnp->fpn_lmp = lmp;
446 
447 	if (aplist_append(&FPNODE(lmp), fpnp, AL_CNT_FPNODE) == NULL) {
448 		free(fpnp);
449 		return (0);
450 	}
451 
452 	ASSERT(lml->lm_fpavl != NULL);
453 	avl_insert(lml->lm_fpavl, fpnp, where);
454 	return (1);
455 }
456 
457 /*
458  * Remove an object from the Fullpath AVL tree.  Note, this is called *before*
459  * the objects link-map is torn down (remove_so), which is where any NAME() and
460  * PATHNAME() strings will be deallocated.
461  */
462 void
463 fpavl_remove(Rt_map *lmp)
464 {
465 	FullpathNode	*fpnp;
466 	Aliste		idx;
467 
468 	for (APLIST_TRAVERSE(FPNODE(lmp), idx, fpnp)) {
469 		avl_remove(LIST(lmp)->lm_fpavl, fpnp);
470 		free(fpnp);
471 	}
472 	free(FPNODE(lmp));
473 	FPNODE(lmp) = NULL;
474 }
475 
476 
477 /*
478  * Prior to calling an object, either via a .plt or through dlsym(), make sure
479  * its .init has fired.  Through topological sorting, ld.so.1 attempts to fire
480  * init's in the correct order, however, this order is typically based on needed
481  * dependencies and non-lazy relocation bindings.  Lazy relocations (.plts) can
482  * still occur and result in bindings that were not captured during topological
483  * sorting.  This routine compensates for this lack of binding information, and
484  * provides for dynamic .init firing.
485  */
486 void
487 is_dep_init(Rt_map * dlmp, Rt_map * clmp)
488 {
489 	Rt_map **	tobj;
490 
491 	/*
492 	 * If the caller is an auditor, and the destination isn't, then don't
493 	 * run any .inits (see comments in load_completion()).
494 	 */
495 	if ((LIST(clmp)->lm_flags & LML_FLG_NOAUDIT) &&
496 	    (LIST(clmp) != LIST(dlmp)))
497 		return;
498 
499 	if ((dlmp == clmp) || (rtld_flags & (RT_FL_BREADTH | RT_FL_INITFIRST)))
500 		return;
501 
502 	if ((FLAGS(dlmp) & (FLG_RT_RELOCED | FLG_RT_INITDONE)) ==
503 	    (FLG_RT_RELOCED | FLG_RT_INITDONE))
504 		return;
505 
506 	if ((FLAGS(dlmp) & (FLG_RT_RELOCED | FLG_RT_INITCALL)) ==
507 	    (FLG_RT_RELOCED | FLG_RT_INITCALL)) {
508 		DBG_CALL(Dbg_util_no_init(dlmp));
509 		return;
510 	}
511 
512 	if ((tobj = calloc(2, sizeof (Rt_map *))) != NULL) {
513 		tobj[0] = dlmp;
514 		call_init(tobj, DBG_INIT_DYN);
515 	}
516 }
517 
518 /*
519  * In a threaded environment insure the thread responsible for loading an object
520  * has completed .init processing for that object before any new thread is
521  * allowed to access the object.  This check is only valid with libthread
522  * TI_VERSION 2, where ld.so.1 implements locking through low level mutexes.
523  *
524  * When a new link-map is created, the thread that causes it to be loaded is
525  * identified by THREADID(dlmp).  Compare this with the current thread to
526  * determine if it must be blocked.
527  *
528  * NOTE, there are a number of instances (typically only for .plt processing)
529  * where we must skip this test:
530  *
531  *   .	any thread id of 0 - threads that call thr_exit() may be in this state
532  *	thus we can't deduce what tid they used to be.  Also some of the
533  *	lib/libthread worker threads have this id and must bind (to themselves
534  *	or libc) for libthread to function.
535  *
536  *   .	libthread itself binds to libc, and as libthread is INITFIRST
537  *	libc's .init can't have fired yet.  Luckly libc's .init is not required
538  *	by libthreads binding.
539  *
540  *   .	if the caller is an auditor, and the destination isn't, then don't
541  *	block (see comments in load_completion()).
542  */
543 void
544 is_dep_ready(Rt_map * dlmp, Rt_map * clmp, int what)
545 {
546 	thread_t	tid;
547 
548 	if ((LIST(clmp)->lm_flags & LML_FLG_NOAUDIT) &&
549 	    (LIST(clmp) != LIST(dlmp)))
550 		return;
551 
552 	if ((rtld_flags & RT_FL_CONCUR) &&
553 	    ((FLAGS(dlmp) & FLG_RT_INITDONE) == 0) &&
554 	    ((FLAGS(clmp) & FLG_RT_INITFRST) == 0) &&
555 	    ((tid = rt_thr_self()) != 0) && (THREADID(dlmp) != tid)) {
556 		while ((FLAGS(dlmp) & FLG_RT_INITDONE) == 0) {
557 			FLAGS1(dlmp) |= FL1_RT_INITWAIT;
558 			DBG_CALL(Dbg_util_wait(clmp, dlmp, what));
559 			(void) rt_cond_wait(CONDVAR(dlmp), &rtldlock);
560 		}
561 	}
562 }
563 
564 /*
565  * Execute .{preinit|init|fini}array sections
566  */
567 void
568 call_array(Addr *array, uint_t arraysz, Rt_map *lmp, Word shtype)
569 {
570 	int	start, stop, incr, ndx;
571 	uint_t	arraycnt = (uint_t)(arraysz / sizeof (Addr));
572 
573 	if (array == NULL)
574 		return;
575 
576 	/*
577 	 * initarray & preinitarray are walked from beginning to end - while
578 	 * finiarray is walked from end to beginning.
579 	 */
580 	if (shtype == SHT_FINI_ARRAY) {
581 		start = arraycnt - 1;
582 		stop = incr = -1;
583 	} else {
584 		start = 0;
585 		stop = arraycnt;
586 		incr = 1;
587 	}
588 
589 	/*
590 	 * Call the .*array[] entries
591 	 */
592 	for (ndx = start; ndx != stop; ndx += incr) {
593 		void (*fptr)(void) = (void(*)())array[ndx];
594 
595 		DBG_CALL(Dbg_util_call_array(lmp, (void *)fptr, ndx, shtype));
596 
597 		leave(LIST(lmp));
598 		(*fptr)();
599 		(void) enter();
600 	}
601 }
602 
603 
604 /*
605  * Execute any .init sections.  These are passed to us in an lmp array which
606  * (by default) will have been sorted.
607  */
608 void
609 call_init(Rt_map ** tobj, int flag)
610 {
611 	Rt_map **	_tobj, ** _nobj;
612 	static List	pending = { NULL, NULL };
613 
614 	/*
615 	 * If we're in the middle of an INITFIRST, this must complete before
616 	 * any new init's are fired.  In this case add the object list to the
617 	 * pending queue and return.  We'll pick up the queue after any
618 	 * INITFIRST objects have their init's fired.
619 	 */
620 	if (rtld_flags & RT_FL_INITFIRST) {
621 		(void) list_append(&pending, tobj);
622 		return;
623 	}
624 
625 	/*
626 	 * Traverse the tobj array firing each objects init.
627 	 */
628 	for (_tobj = _nobj = tobj, _nobj++; *_tobj != NULL; _tobj++, _nobj++) {
629 		Rt_map *	lmp = *_tobj;
630 		void (*		iptr)() = INIT(lmp);
631 
632 		if (FLAGS(lmp) & FLG_RT_INITCALL)
633 			continue;
634 
635 		FLAGS(lmp) |= FLG_RT_INITCALL;
636 
637 		/*
638 		 * Establish an initfirst state if necessary - no other inits
639 		 * will be fired (because of additional relocation bindings)
640 		 * when in this state.
641 		 */
642 		if (FLAGS(lmp) & FLG_RT_INITFRST)
643 			rtld_flags |= RT_FL_INITFIRST;
644 
645 		if (INITARRAY(lmp) || iptr) {
646 			Aliste		idx;
647 			Bnd_desc 	*bdp;
648 
649 			/*
650 			 * Make sure that all dependencies that have been
651 			 * relocated to are initialized before this objects
652 			 * .init is executed.  This insures that a dependency
653 			 * on an external item that must first be initialized
654 			 * by its associated object is satisfied.
655 			 */
656 			for (APLIST_TRAVERSE(DEPENDS(lmp), idx, bdp)) {
657 				if ((bdp->b_flags & BND_REFER) == 0)
658 					continue;
659 				is_dep_ready(bdp->b_depend, lmp, DBG_WAIT_INIT);
660 			}
661 			DBG_CALL(Dbg_util_call_init(lmp, flag));
662 		}
663 
664 		if (iptr) {
665 			leave(LIST(lmp));
666 			(*iptr)();
667 			(void) enter();
668 		}
669 
670 		call_array(INITARRAY(lmp), INITARRAYSZ(lmp), lmp,
671 		    SHT_INIT_ARRAY);
672 
673 		if (INITARRAY(lmp) || iptr)
674 			DBG_CALL(Dbg_util_call_init(lmp, DBG_INIT_DONE));
675 
676 		/*
677 		 * Set the initdone flag regardless of whether this object
678 		 * actually contains an .init section.  This flag prevents us
679 		 * from processing this section again for an .init and also
680 		 * signifies that a .fini must be called should it exist.
681 		 * Clear the sort field for use in later .fini processing.
682 		 */
683 		FLAGS(lmp) |= FLG_RT_INITDONE;
684 		SORTVAL(lmp) = -1;
685 
686 		/*
687 		 * Wake anyone up who might be waiting on this .init.
688 		 */
689 		if (FLAGS1(lmp) & FL1_RT_INITWAIT) {
690 			DBG_CALL(Dbg_util_broadcast(lmp));
691 			(void) rt_cond_broadcast(CONDVAR(lmp));
692 			FLAGS1(lmp) &= ~FL1_RT_INITWAIT;
693 		}
694 
695 		/*
696 		 * If we're firing an INITFIRST object, and other objects must
697 		 * be fired which are not INITFIRST, make sure we grab any
698 		 * pending objects that might have been delayed as this
699 		 * INITFIRST was processed.
700 		 */
701 		if ((rtld_flags & RT_FL_INITFIRST) &&
702 		    ((*_nobj == NULL) || !(FLAGS(*_nobj) & FLG_RT_INITFRST))) {
703 			Listnode *	lnp;
704 			Rt_map **	pobj;
705 
706 			rtld_flags &= ~RT_FL_INITFIRST;
707 
708 			while ((lnp = pending.head) != NULL) {
709 				if ((pending.head = lnp->next) == NULL)
710 					pending.tail = NULL;
711 				pobj = lnp->data;
712 				free(lnp);
713 
714 				call_init(pobj, DBG_INIT_PEND);
715 			}
716 		}
717 	}
718 	free(tobj);
719 }
720 
721 /*
722  * Function called by atexit(3C).  Calls all .fini sections related with the
723  * mains dependent shared libraries in the order in which the shared libraries
724  * have been loaded.  Skip any .fini defined in the main executable, as this
725  * will be called by crt0 (main was never marked as initdone).
726  */
727 void
728 call_fini(Lm_list * lml, Rt_map ** tobj)
729 {
730 	Rt_map **_tobj;
731 
732 	for (_tobj = tobj; *_tobj != NULL; _tobj++) {
733 		Rt_map		*clmp, * lmp = *_tobj;
734 		Aliste		idx;
735 		Bnd_desc	*bdp;
736 
737 		/*
738 		 * If concurrency checking isn't enabled only fire .fini if
739 		 * .init has completed.  We collect all .fini sections of
740 		 * objects that had their .init collected, but that doesn't
741 		 * mean at the time that the .init had completed.
742 		 */
743 		if ((rtld_flags & RT_FL_CONCUR) ||
744 		    (FLAGS(lmp) & FLG_RT_INITDONE)) {
745 			void	(*fptr)(void) = FINI(lmp);
746 
747 			if (FINIARRAY(lmp) || fptr) {
748 				/*
749 				 * If concurrency checking is enabled make sure
750 				 * this object's .init is completed before
751 				 * calling any .fini.
752 				 */
753 				is_dep_ready(lmp, lmp, DBG_WAIT_FINI);
754 				DBG_CALL(Dbg_util_call_fini(lmp));
755 			}
756 
757 			call_array(FINIARRAY(lmp), FINIARRAYSZ(lmp), lmp,
758 			    SHT_FINI_ARRAY);
759 
760 			if (fptr) {
761 				leave(LIST(lmp));
762 				(*fptr)();
763 				(void) enter();
764 			}
765 		}
766 
767 		/*
768 		 * Skip main, this is explicitly called last in atexit_fini().
769 		 */
770 		if (FLAGS(lmp) & FLG_RT_ISMAIN)
771 			continue;
772 
773 		/*
774 		 * Audit `close' operations at this point.  The library has
775 		 * exercised its last instructions (regardless of whether it
776 		 * will be unmapped or not).
777 		 *
778 		 * First call any global auditing.
779 		 */
780 		if (lml->lm_tflags & LML_TFLG_AUD_OBJCLOSE)
781 			_audit_objclose(&(auditors->ad_list), lmp);
782 
783 		/*
784 		 * Finally determine whether this object has local auditing
785 		 * requirements by inspecting itself and then its dependencies.
786 		 */
787 		if ((lml->lm_flags & LML_FLG_LOCAUDIT) == 0)
788 			continue;
789 
790 		if (FLAGS1(lmp) & LML_TFLG_AUD_OBJCLOSE)
791 			_audit_objclose(&(AUDITORS(lmp)->ad_list), lmp);
792 
793 		for (APLIST_TRAVERSE(CALLERS(lmp), idx, bdp)) {
794 			clmp = bdp->b_caller;
795 
796 			if (FLAGS1(clmp) & LML_TFLG_AUD_OBJCLOSE) {
797 				_audit_objclose(&(AUDITORS(clmp)->ad_list),
798 				    lmp);
799 				break;
800 			}
801 		}
802 	}
803 	DBG_CALL(Dbg_bind_plt_summary(lml, M_MACH, pltcnt21d, pltcnt24d,
804 	    pltcntu32, pltcntu44, pltcntfull, pltcntfar));
805 
806 	free(tobj);
807 }
808 
809 void
810 atexit_fini()
811 {
812 	Rt_map **	tobj, * lmp;
813 	Lm_list *	lml;
814 	Listnode *	lnp;
815 
816 	(void) enter();
817 
818 	rtld_flags |= RT_FL_ATEXIT;
819 
820 	lml = &lml_main;
821 	lml->lm_flags |= LML_FLG_ATEXIT;
822 	lml->lm_flags &= ~LML_FLG_INTRPOSETSORT;
823 	lmp = (Rt_map *)lml->lm_head;
824 
825 	/*
826 	 * Display any objects that haven't been referenced so far.
827 	 */
828 	unused(lml);
829 
830 	/*
831 	 * Reverse topologically sort the main link-map for .fini execution.
832 	 */
833 	if (((tobj = tsort(lmp, lml->lm_obj, RT_SORT_FWD)) != 0) &&
834 	    (tobj != (Rt_map **)S_ERROR))
835 		call_fini(lml, tobj);
836 
837 	/*
838 	 * Add an explicit close to main and ld.so.1.  Although main's .fini is
839 	 * collected in call_fini() to provide for FINITARRAY processing, its
840 	 * audit_objclose is explicitly skipped.  This provides for it to be
841 	 * called last, here.  This is the reverse of the explicit calls to
842 	 * audit_objopen() made in setup().
843 	 */
844 	if ((lml->lm_tflags | FLAGS1(lmp)) & LML_TFLG_AUD_MASK) {
845 		audit_objclose(lmp, (Rt_map *)lml_rtld.lm_head);
846 		audit_objclose(lmp, lmp);
847 	}
848 
849 	/*
850 	 * Now that all .fini code has been run, see what unreferenced objects
851 	 * remain.  Any difference between this and the above unused() would
852 	 * indicate an object is only being used for .fini processing, which
853 	 * might be fine, but might also indicate an overhead whose removal
854 	 * would be worth considering.
855 	 */
856 	unused(lml);
857 
858 	/*
859 	 * Traverse any alternative link-map lists.
860 	 */
861 	for (LIST_TRAVERSE(&dynlm_list, lnp, lml)) {
862 		/*
863 		 * Ignore the base-link-map list, which has already been
864 		 * processed, and the runtime linkers link-map list, which is
865 		 * typically processed last.
866 		 */
867 		if (lml->lm_flags & (LML_FLG_BASELM | LML_FLG_RTLDLM))
868 			continue;
869 
870 		if ((lmp = (Rt_map *)lml->lm_head) == 0)
871 			continue;
872 
873 		lml->lm_flags |= LML_FLG_ATEXIT;
874 		lml->lm_flags &= ~LML_FLG_INTRPOSETSORT;
875 
876 		/*
877 		 * Reverse topologically sort the link-map for .fini execution.
878 		 */
879 		if (((tobj = tsort(lmp, lml->lm_obj, RT_SORT_FWD)) != 0) &&
880 		    (tobj != (Rt_map **)S_ERROR))
881 			call_fini(lml, tobj);
882 
883 		unused(lml);
884 	}
885 
886 	/*
887 	 * Finally reverse topologically sort the runtime linkers link-map for
888 	 * .fini execution.
889 	 */
890 	lml = &lml_rtld;
891 	lml->lm_flags |= LML_FLG_ATEXIT;
892 	lml->lm_flags &= ~LML_FLG_INTRPOSETSORT;
893 	lmp = (Rt_map *)lml->lm_head;
894 
895 	if (((tobj = tsort(lmp, lml->lm_obj, RT_SORT_FWD)) != 0) &&
896 	    (tobj != (Rt_map **)S_ERROR))
897 		call_fini(lml, tobj);
898 
899 	leave(&lml_main);
900 }
901 
902 
903 /*
904  * This routine is called to complete any runtime linker activity which may have
905  * resulted in objects being loaded.  This is called from all user entry points
906  * and from any internal dl*() requests.
907  */
908 void
909 load_completion(Rt_map *nlmp)
910 {
911 	Rt_map	**tobj = 0;
912 	Lm_list	*nlml;
913 
914 	/*
915 	 * Establish any .init processing.  Note, in a world of lazy loading,
916 	 * objects may have been loaded regardless of whether the users request
917 	 * was fulfilled (i.e., a dlsym() request may have failed to find a
918 	 * symbol but objects might have been loaded during its search).  Thus,
919 	 * any tsorting starts from the nlmp (new link-maps) pointer and not
920 	 * necessarily from the link-map that may have satisfied the request.
921 	 *
922 	 * Note, the primary link-map has an initialization phase where dynamic
923 	 * .init firing is suppressed.  This provides for a simple and clean
924 	 * handshake with the primary link-maps libc, which is important for
925 	 * establishing uberdata.  In addition, auditors often obtain handles
926 	 * to primary link-map objects as the objects are loaded, so as to
927 	 * inspect the link-map for symbols.  This inspection is allowed without
928 	 * running any code on the primary link-map, as running this code may
929 	 * reenter the auditor, who may not yet have finished its own
930 	 * initialization.
931 	 */
932 	if (nlmp)
933 		nlml = LIST(nlmp);
934 
935 	if (nlmp && nlml->lm_init &&
936 	    ((nlml != &lml_main) || (rtld_flags2 & RT_FL2_PLMSETUP))) {
937 		if ((tobj = tsort(nlmp, LIST(nlmp)->lm_init,
938 		    RT_SORT_REV)) == (Rt_map **)S_ERROR)
939 			tobj = 0;
940 	}
941 
942 	/*
943 	 * Make sure any alternative link-map retrieves any external interfaces
944 	 * and initializes threads.
945 	 */
946 	if (nlmp && (nlml != &lml_main)) {
947 		(void) rt_get_extern(nlml, nlmp);
948 		rt_thr_init(nlml);
949 	}
950 
951 	/*
952 	 * Traverse the list of new link-maps and register any dynamic TLS.
953 	 * This storage is established for any objects not on the primary
954 	 * link-map, and for any objects added to the primary link-map after
955 	 * static TLS has been registered.
956 	 */
957 	if (nlmp && nlml->lm_tls &&
958 	    ((nlml != &lml_main) || (rtld_flags2 & RT_FL2_PLMSETUP))) {
959 		Rt_map	*lmp;
960 
961 		for (lmp = nlmp; lmp; lmp = (Rt_map *)NEXT(lmp)) {
962 			if (PTTLS(lmp) && PTTLS(lmp)->p_memsz)
963 				tls_modaddrem(lmp, TM_FLG_MODADD);
964 		}
965 		nlml->lm_tls = 0;
966 	}
967 
968 	/*
969 	 * Fire any .init's.
970 	 */
971 	if (tobj)
972 		call_init(tobj, DBG_INIT_SORT);
973 }
974 
975 /*
976  * Append an item to the specified list, and return a pointer to the list
977  * node created.
978  */
979 Listnode *
980 list_append(List *lst, const void *item)
981 {
982 	Listnode *	_lnp;
983 
984 	if ((_lnp = malloc(sizeof (Listnode))) == 0)
985 		return (0);
986 
987 	_lnp->data = (void *)item;
988 	_lnp->next = NULL;
989 
990 	if (lst->head == NULL)
991 		lst->tail = lst->head = _lnp;
992 	else {
993 		lst->tail->next = _lnp;
994 		lst->tail = lst->tail->next;
995 	}
996 	return (_lnp);
997 }
998 
999 
1000 /*
1001  * Add an item after specified listnode, and return a pointer to the list
1002  * node created.
1003  */
1004 Listnode *
1005 list_insert(List *lst, const void *item, Listnode *lnp)
1006 {
1007 	Listnode *	_lnp;
1008 
1009 	if ((_lnp = malloc(sizeof (Listnode))) == (Listnode *)0)
1010 		return (0);
1011 
1012 	_lnp->data = (void *)item;
1013 	_lnp->next = lnp->next;
1014 	if (_lnp->next == NULL)
1015 		lst->tail = _lnp;
1016 	lnp->next = _lnp;
1017 	return (_lnp);
1018 }
1019 
1020 /*
1021  * Prepend an item to the specified list, and return a pointer to the
1022  * list node created.
1023  */
1024 Listnode *
1025 list_prepend(List * lst, const void * item)
1026 {
1027 	Listnode *	_lnp;
1028 
1029 	if ((_lnp = malloc(sizeof (Listnode))) == (Listnode *)0)
1030 		return (0);
1031 
1032 	_lnp->data = (void *)item;
1033 
1034 	if (lst->head == NULL) {
1035 		_lnp->next = NULL;
1036 		lst->tail = lst->head = _lnp;
1037 	} else {
1038 		_lnp->next = lst->head;
1039 		lst->head = _lnp;
1040 	}
1041 	return (_lnp);
1042 }
1043 
1044 
1045 /*
1046  * Delete a 'listnode' from a list.
1047  */
1048 void
1049 list_delete(List *lst, void *item)
1050 {
1051 	Listnode	*clnp, *plnp;
1052 
1053 	for (plnp = NULL, clnp = lst->head; clnp; clnp = clnp->next) {
1054 		if (item == clnp->data)
1055 			break;
1056 		plnp = clnp;
1057 	}
1058 
1059 	if (clnp == 0)
1060 		return;
1061 
1062 	if (lst->head == clnp)
1063 		lst->head = clnp->next;
1064 	if (lst->tail == clnp)
1065 		lst->tail = plnp;
1066 
1067 	if (plnp)
1068 		plnp->next = clnp->next;
1069 
1070 	free(clnp);
1071 }
1072 
1073 /*
1074  * Append an item to the specified link map control list.
1075  */
1076 void
1077 lm_append(Lm_list *lml, Aliste lmco, Rt_map *lmp)
1078 {
1079 	Lm_cntl	*lmc;
1080 	int	add = 1;
1081 
1082 	/*
1083 	 * Indicate that this link-map list has a new object.
1084 	 */
1085 	(lml->lm_obj)++;
1086 
1087 	/*
1088 	 * If we're about to add a new object to the main link-map control list,
1089 	 * alert the debuggers that we are about to mess with this list.
1090 	 * Additions of individual objects to the main link-map control list
1091 	 * occur during initial setup as the applications immediate dependencies
1092 	 * are loaded.  Individual objects are also loaded on the main link-map
1093 	 * control list of new alternative link-map control lists.
1094 	 */
1095 	if ((lmco == ALIST_OFF_DATA) &&
1096 	    ((lml->lm_flags & LML_FLG_DBNOTIF) == 0))
1097 		rd_event(lml, RD_DLACTIVITY, RT_ADD);
1098 
1099 	/* LINTED */
1100 	lmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, lmco);
1101 
1102 	/*
1103 	 * A link-map list header points to one of more link-map control lists
1104 	 * (see include/rtld.h).  The initial list, pointed to by lm_cntl, is
1105 	 * the list of relocated objects.  Other lists maintain objects that
1106 	 * are still being analyzed or relocated.  This list provides the core
1107 	 * link-map list information used by all ld.so.1 routines.
1108 	 */
1109 	if (lmc->lc_head == NULL) {
1110 		/*
1111 		 * If this is the first link-map for the given control list,
1112 		 * initialize the list.
1113 		 */
1114 		lmc->lc_head = lmc->lc_tail = lmp;
1115 		add = 0;
1116 
1117 	} else if (FLAGS(lmp) & FLG_RT_OBJINTPO) {
1118 		Rt_map	*tlmp;
1119 
1120 		/*
1121 		 * If this is an interposer then append the link-map following
1122 		 * any other interposers (these are objects that have been
1123 		 * previously preloaded, or were identified with -z interpose).
1124 		 * Interposers can only be inserted on the first link-map
1125 		 * control list, as once relocation has started, interposition
1126 		 * from new interposers can't be guaranteed.
1127 		 *
1128 		 * NOTE: We do not interpose on the head of a list.  This model
1129 		 * evolved because dynamic executables have already been fully
1130 		 * relocated within themselves and thus can't be interposed on.
1131 		 * Nowadays it's possible to have shared objects at the head of
1132 		 * a list, which conceptually means they could be interposed on.
1133 		 * But, shared objects can be created via dldump() and may only
1134 		 * be partially relocated (just relatives), in which case they
1135 		 * are interposable, but are marked as fixed (ET_EXEC).
1136 		 *
1137 		 * Thus we really don't have a clear method of deciding when the
1138 		 * head of a link-map is interposable.  So, to be consistent,
1139 		 * for now only add interposers after the link-map lists head
1140 		 * object.
1141 		 */
1142 		for (tlmp = (Rt_map *)NEXT(lmc->lc_head); tlmp;
1143 		    tlmp = (Rt_map *)NEXT(tlmp)) {
1144 
1145 			if (FLAGS(tlmp) & FLG_RT_OBJINTPO)
1146 				continue;
1147 
1148 			/*
1149 			 * Insert the new link-map before this non-interposer,
1150 			 * and indicate an interposer is found.
1151 			 */
1152 			NEXT((Rt_map *)PREV(tlmp)) = (Link_map *)lmp;
1153 			PREV(lmp) = PREV(tlmp);
1154 
1155 			NEXT(lmp) = (Link_map *)tlmp;
1156 			PREV(tlmp) = (Link_map *)lmp;
1157 
1158 			lmc->lc_flags |= LMC_FLG_REANALYZE;
1159 			add = 0;
1160 			break;
1161 		}
1162 	}
1163 
1164 	/*
1165 	 * Fall through to appending the new link map to the tail of the list.
1166 	 * If we're processing the initial objects of this link-map list, add
1167 	 * them to the backward compatibility list.
1168 	 */
1169 	if (add) {
1170 		NEXT(lmc->lc_tail) = (Link_map *)lmp;
1171 		PREV(lmp) = (Link_map *)lmc->lc_tail;
1172 		lmc->lc_tail = lmp;
1173 	}
1174 
1175 	/*
1176 	 * Having added this link-map to a control list, indicate which control
1177 	 * list the link-map belongs to.  Note, control list information is
1178 	 * always maintained as an offset, as the Alist can be reallocated.
1179 	 */
1180 	CNTL(lmp) = lmco;
1181 
1182 	/*
1183 	 * Indicate if an interposer is found.  Note that the first object on a
1184 	 * link-map can be explicitly defined as an interposer so that it can
1185 	 * provide interposition over direct binding requests.
1186 	 */
1187 	if (FLAGS(lmp) & MSK_RT_INTPOSE)
1188 		lml->lm_flags |= LML_FLG_INTRPOSE;
1189 
1190 	/*
1191 	 * For backward compatibility with debuggers, the link-map list contains
1192 	 * pointers to the main control list.
1193 	 */
1194 	if (lmco == ALIST_OFF_DATA) {
1195 		lml->lm_head = lmc->lc_head;
1196 		lml->lm_tail = lmc->lc_tail;
1197 	}
1198 }
1199 
1200 /*
1201  * Delete an item from the specified link map control list.
1202  */
1203 void
1204 lm_delete(Lm_list *lml, Rt_map *lmp)
1205 {
1206 	Lm_cntl	*lmc;
1207 
1208 	/*
1209 	 * If the control list pointer hasn't been initialized, this object
1210 	 * never got added to a link-map list.
1211 	 */
1212 	if (CNTL(lmp) == 0)
1213 		return;
1214 
1215 	/*
1216 	 * If we're about to delete an object from the main link-map control
1217 	 * list, alert the debuggers that we are about to mess with this list.
1218 	 */
1219 	if ((CNTL(lmp) == ALIST_OFF_DATA) &&
1220 	    ((lml->lm_flags & LML_FLG_DBNOTIF) == 0))
1221 		rd_event(lml, RD_DLACTIVITY, RT_DELETE);
1222 
1223 	/* LINTED */
1224 	lmc = (Lm_cntl *)alist_item_by_offset(lml->lm_lists, CNTL(lmp));
1225 
1226 	if (lmc->lc_head == lmp)
1227 		lmc->lc_head = (Rt_map *)NEXT(lmp);
1228 	else
1229 		NEXT((Rt_map *)PREV(lmp)) = (void *)NEXT(lmp);
1230 
1231 	if (lmc->lc_tail == lmp)
1232 		lmc->lc_tail = (Rt_map *)PREV(lmp);
1233 	else
1234 		PREV((Rt_map *)NEXT(lmp)) = PREV(lmp);
1235 
1236 	/*
1237 	 * For backward compatibility with debuggers, the link-map list contains
1238 	 * pointers to the main control list.
1239 	 */
1240 	if (lmc == (Lm_cntl *)&lml->lm_lists->al_data) {
1241 		lml->lm_head = lmc->lc_head;
1242 		lml->lm_tail = lmc->lc_tail;
1243 	}
1244 
1245 	/*
1246 	 * Indicate we have one less object on this control list.
1247 	 */
1248 	(lml->lm_obj)--;
1249 }
1250 
1251 /*
1252  * Move a link-map control list to another.  Objects that are being relocated
1253  * are maintained on secondary control lists.  Once their relocation is
1254  * complete, the entire list is appended to the previous control list, as this
1255  * list must have been the trigger for generating the new control list.
1256  */
1257 void
1258 lm_move(Lm_list *lml, Aliste nlmco, Aliste plmco, Lm_cntl *nlmc, Lm_cntl *plmc)
1259 {
1260 	Rt_map	*lmp;
1261 
1262 	/*
1263 	 * If we're about to add a new family of objects to the main link-map
1264 	 * control list, alert the debuggers that we are about to mess with this
1265 	 * list.  Additions of object families to the main link-map control
1266 	 * list occur during lazy loading, filtering and dlopen().
1267 	 */
1268 	if ((plmco == ALIST_OFF_DATA) &&
1269 	    ((lml->lm_flags & LML_FLG_DBNOTIF) == 0))
1270 		rd_event(lml, RD_DLACTIVITY, RT_ADD);
1271 
1272 	DBG_CALL(Dbg_file_cntl(lml, nlmco, plmco));
1273 
1274 	/*
1275 	 * Indicate each new link-map has been moved to the previous link-map
1276 	 * control list.
1277 	 */
1278 	for (lmp = nlmc->lc_head; lmp; lmp = (Rt_map *)NEXT(lmp))
1279 		CNTL(lmp) = plmco;
1280 
1281 	/*
1282 	 * Move the new link-map control list, to the callers link-map control
1283 	 * list.
1284 	 */
1285 	if (plmc->lc_head == 0) {
1286 		plmc->lc_head = nlmc->lc_head;
1287 		PREV(nlmc->lc_head) = 0;
1288 	} else {
1289 		NEXT(plmc->lc_tail) = (Link_map *)nlmc->lc_head;
1290 		PREV(nlmc->lc_head) = (Link_map *)plmc->lc_tail;
1291 	}
1292 
1293 	plmc->lc_tail = nlmc->lc_tail;
1294 	nlmc->lc_head = nlmc->lc_tail = 0;
1295 
1296 	/*
1297 	 * For backward compatibility with debuggers, the link-map list contains
1298 	 * pointers to the main control list.
1299 	 */
1300 	if (plmco == ALIST_OFF_DATA) {
1301 		lml->lm_head = plmc->lc_head;
1302 		lml->lm_tail = plmc->lc_tail;
1303 	}
1304 }
1305 
1306 /*
1307  * Environment variables can have a variety of defined permutations, and thus
1308  * the following infrastructure exists to allow this variety and to select the
1309  * required definition.
1310  *
1311  * Environment variables can be defined as 32- or 64-bit specific, and if so
1312  * they will take precedence over any instruction set neutral form.  Typically
1313  * this is only useful when the environment value is an informational string.
1314  *
1315  * Environment variables may be obtained from the standard user environment or
1316  * from a configuration file.  The latter provides a fallback if no user
1317  * environment setting is found, and can take two forms:
1318  *
1319  *  .	a replaceable definition - this will be used if no user environment
1320  *	setting has been seen, or
1321  *
1322  *  .	an permanent definition - this will be used no matter what user
1323  *	environment setting is seen.  In the case of list variables it will be
1324  *	appended to any process environment setting seen.
1325  *
1326  * Environment variables can be defined without a value (ie. LD_XXXX=) so as to
1327  * override any replaceable environment variables from a configuration file.
1328  */
1329 static	u_longlong_t		rplgen;		/* replaceable generic */
1330 						/*	variables */
1331 static	u_longlong_t		rplisa;		/* replaceable ISA specific */
1332 						/*	variables */
1333 static	u_longlong_t		prmgen;		/* permanent generic */
1334 						/*	variables */
1335 static	u_longlong_t		prmisa;		/* permanent ISA specific */
1336 						/*	variables */
1337 
1338 /*
1339  * Classify an environment variables type.
1340  */
1341 #define	ENV_TYP_IGNORE		0x1		/* ignore - variable is for */
1342 						/*	the wrong ISA */
1343 #define	ENV_TYP_ISA		0x2		/* variable is ISA specific */
1344 #define	ENV_TYP_CONFIG		0x4		/* variable obtained from a */
1345 						/*	config file */
1346 #define	ENV_TYP_PERMANT		0x8		/* variable is permanent */
1347 
1348 /*
1349  * Identify all environment variables.
1350  */
1351 #define	ENV_FLG_AUDIT		0x0000000001ULL
1352 #define	ENV_FLG_AUDIT_ARGS	0x0000000002ULL
1353 #define	ENV_FLG_BIND_NOW	0x0000000004ULL
1354 #define	ENV_FLG_BIND_NOT	0x0000000008ULL
1355 #define	ENV_FLG_BINDINGS	0x0000000010ULL
1356 #define	ENV_FLG_CONCURRENCY	0x0000000020ULL
1357 #define	ENV_FLG_CONFGEN		0x0000000040ULL
1358 #define	ENV_FLG_CONFIG		0x0000000080ULL
1359 #define	ENV_FLG_DEBUG		0x0000000100ULL
1360 #define	ENV_FLG_DEBUG_OUTPUT	0x0000000200ULL
1361 #define	ENV_FLG_DEMANGLE	0x0000000400ULL
1362 #define	ENV_FLG_FLAGS		0x0000000800ULL
1363 #define	ENV_FLG_INIT		0x0000001000ULL
1364 #define	ENV_FLG_LIBPATH		0x0000002000ULL
1365 #define	ENV_FLG_LOADAVAIL	0x0000004000ULL
1366 #define	ENV_FLG_LOADFLTR	0x0000008000ULL
1367 #define	ENV_FLG_NOAUDIT		0x0000010000ULL
1368 #define	ENV_FLG_NOAUXFLTR	0x0000020000ULL
1369 #define	ENV_FLG_NOBAPLT		0x0000040000ULL
1370 #define	ENV_FLG_NOCONFIG	0x0000080000ULL
1371 #define	ENV_FLG_NODIRCONFIG	0x0000100000ULL
1372 #define	ENV_FLG_NODIRECT	0x0000200000ULL
1373 #define	ENV_FLG_NOENVCONFIG	0x0000400000ULL
1374 #define	ENV_FLG_NOLAZY		0x0000800000ULL
1375 #define	ENV_FLG_NOOBJALTER	0x0001000000ULL
1376 #define	ENV_FLG_NOVERSION	0x0002000000ULL
1377 #define	ENV_FLG_PRELOAD		0x0004000000ULL
1378 #define	ENV_FLG_PROFILE		0x0008000000ULL
1379 #define	ENV_FLG_PROFILE_OUTPUT	0x0010000000ULL
1380 #define	ENV_FLG_SIGNAL		0x0020000000ULL
1381 #define	ENV_FLG_TRACE_OBJS	0x0040000000ULL
1382 #define	ENV_FLG_TRACE_PTHS	0x0080000000ULL
1383 #define	ENV_FLG_UNREF		0x0100000000ULL
1384 #define	ENV_FLG_UNUSED		0x0200000000ULL
1385 #define	ENV_FLG_VERBOSE		0x0400000000ULL
1386 #define	ENV_FLG_WARN		0x0800000000ULL
1387 #define	ENV_FLG_NOFLTCONFIG	0x1000000000ULL
1388 #define	ENV_FLG_BIND_LAZY	0x2000000000ULL
1389 #define	ENV_FLG_NOUNRESWEAK	0x4000000000ULL
1390 
1391 #ifdef	SIEBEL_DISABLE
1392 #define	ENV_FLG_FIX_1		0x8000000000ULL
1393 #endif
1394 
1395 #define	SEL_REPLACE		0x0001
1396 #define	SEL_PERMANT		0x0002
1397 #define	SEL_ACT_RT		0x0100	/* setting rtld_flags */
1398 #define	SEL_ACT_RT2		0x0200	/* setting rtld_flags2 */
1399 #define	SEL_ACT_STR		0x0400	/* setting string value */
1400 #define	SEL_ACT_LML		0x0800	/* setting lml_flags */
1401 #define	SEL_ACT_LMLT		0x1000	/* setting lml_tflags */
1402 #define	SEL_ACT_SPEC_1		0x2000	/* For FLG_{FLAGS, LIBPATH} */
1403 #define	SEL_ACT_SPEC_2		0x4000	/* need special handling */
1404 
1405 /*
1406  * Pattern match an LD_XXXX environment variable.  s1 points to the XXXX part
1407  * and len specifies its length (comparing a strings length before the string
1408  * itself speed things up).  s2 points to the token itself which has already
1409  * had any leading white-space removed.
1410  */
1411 static void
1412 ld_generic_env(const char *s1, size_t len, const char *s2, Word *lmflags,
1413     Word *lmtflags, uint_t env_flags, int aout)
1414 {
1415 	u_longlong_t	variable = 0;
1416 	ushort_t	select = 0;
1417 	const char	**str;
1418 	Word		val = 0;
1419 
1420 	/*
1421 	 * Determine whether we're dealing with a replaceable or permanent
1422 	 * string.
1423 	 */
1424 	if (env_flags & ENV_TYP_PERMANT) {
1425 		/*
1426 		 * If the string is from a configuration file and defined as
1427 		 * permanent, assign it as permanent.
1428 		 */
1429 		select |= SEL_PERMANT;
1430 	} else
1431 		select |= SEL_REPLACE;
1432 
1433 	/*
1434 	 * Parse the variable given.
1435 	 *
1436 	 * The LD_AUDIT family.
1437 	 */
1438 	if (*s1 == 'A') {
1439 		if ((len == MSG_LD_AUDIT_SIZE) && (strncmp(s1,
1440 		    MSG_ORIG(MSG_LD_AUDIT), MSG_LD_AUDIT_SIZE) == 0)) {
1441 			/*
1442 			 * Replaceable and permanent audit objects can exist.
1443 			 */
1444 			select |= SEL_ACT_STR;
1445 			if (select & SEL_REPLACE)
1446 				str = &rpl_audit;
1447 			else {
1448 				str = &prm_audit;
1449 				rpl_audit = 0;
1450 			}
1451 			variable = ENV_FLG_AUDIT;
1452 		} else if ((len == MSG_LD_AUDIT_ARGS_SIZE) &&
1453 		    (strncmp(s1, MSG_ORIG(MSG_LD_AUDIT_ARGS),
1454 		    MSG_LD_AUDIT_ARGS_SIZE) == 0)) {
1455 			/*
1456 			 * A specialized variable for plt_exit() use, not
1457 			 * documented for general use.
1458 			 */
1459 			select |= SEL_ACT_SPEC_2;
1460 			variable = ENV_FLG_AUDIT_ARGS;
1461 		}
1462 	}
1463 	/*
1464 	 * The LD_BIND family and LD_BREADTH (historic).
1465 	 */
1466 	else if (*s1 == 'B') {
1467 		if ((len == MSG_LD_BIND_LAZY_SIZE) && (strncmp(s1,
1468 		    MSG_ORIG(MSG_LD_BIND_LAZY),
1469 		    MSG_LD_BIND_LAZY_SIZE) == 0)) {
1470 			select |= SEL_ACT_RT2;
1471 			val = RT_FL2_BINDLAZY;
1472 			variable = ENV_FLG_BIND_LAZY;
1473 		} else if ((len == MSG_LD_BIND_NOW_SIZE) && (strncmp(s1,
1474 		    MSG_ORIG(MSG_LD_BIND_NOW), MSG_LD_BIND_NOW_SIZE) == 0)) {
1475 			select |= SEL_ACT_RT2;
1476 			val = RT_FL2_BINDNOW;
1477 			variable = ENV_FLG_BIND_NOW;
1478 		} else if ((len == MSG_LD_BIND_NOT_SIZE) && (strncmp(s1,
1479 		    MSG_ORIG(MSG_LD_BIND_NOT), MSG_LD_BIND_NOT_SIZE) == 0)) {
1480 			/*
1481 			 * Another trick, enabled to help debug AOUT
1482 			 * applications under BCP, but not documented for
1483 			 * general use.
1484 			 */
1485 			select |= SEL_ACT_RT;
1486 			val = RT_FL_NOBIND;
1487 			variable = ENV_FLG_BIND_NOT;
1488 		} else if ((len == MSG_LD_BINDINGS_SIZE) && (strncmp(s1,
1489 		    MSG_ORIG(MSG_LD_BINDINGS), MSG_LD_BINDINGS_SIZE) == 0)) {
1490 			/*
1491 			 * This variable is simply for backward compatibility.
1492 			 * If this and LD_DEBUG are both specified, only one of
1493 			 * the strings is going to get processed.
1494 			 */
1495 			select |= SEL_ACT_SPEC_2;
1496 			variable = ENV_FLG_BINDINGS;
1497 #ifndef LD_BREADTH_DISABLED
1498 		} else if ((len == MSG_LD_BREADTH_SIZE) && (strncmp(s1,
1499 		    MSG_ORIG(MSG_LD_BREADTH), MSG_LD_BREADTH_SIZE) == 0)) {
1500 			/*
1501 			 * Besides some old patches this is no longer available.
1502 			 */
1503 			rtld_flags |= RT_FL_BREADTH;
1504 			return;
1505 #endif
1506 		}
1507 	}
1508 	/*
1509 	 * LD_CONCURRENCY and LD_CONFIG family.
1510 	 */
1511 	else if (*s1 == 'C') {
1512 		if ((len == MSG_LD_CONCURRENCY_SIZE) && (strncmp(s1,
1513 		    MSG_ORIG(MSG_LD_CONCURRENCY),
1514 		    MSG_LD_CONCURRENCY_SIZE) == 0)) {
1515 			/*
1516 			 * Waiting in the wings, as concurrency checking isn't
1517 			 * yet enabled.
1518 			 */
1519 			select |= SEL_ACT_SPEC_2;
1520 			variable = ENV_FLG_CONCURRENCY;
1521 		} else if ((len == MSG_LD_CONFGEN_SIZE) && (strncmp(s1,
1522 		    MSG_ORIG(MSG_LD_CONFGEN), MSG_LD_CONFGEN_SIZE) == 0)) {
1523 			/*
1524 			 * Set by crle(1) to indicate it's building a
1525 			 * configuration file, not documented for general use.
1526 			 */
1527 			select |= SEL_ACT_SPEC_2;
1528 			variable = ENV_FLG_CONFGEN;
1529 		} else if ((len == MSG_LD_CONFIG_SIZE) && (strncmp(s1,
1530 		    MSG_ORIG(MSG_LD_CONFIG), MSG_LD_CONFIG_SIZE) == 0)) {
1531 			/*
1532 			 * Secure applications must use a default configuration
1533 			 * file.  A setting from a configuration file doesn't
1534 			 * make sense (given we must be reading a configuration
1535 			 * file to have gotten this).
1536 			 */
1537 			if ((rtld_flags & RT_FL_SECURE) ||
1538 			    (env_flags & ENV_TYP_CONFIG))
1539 				return;
1540 			select |= SEL_ACT_STR;
1541 			str = &config->c_name;
1542 			variable = ENV_FLG_CONFIG;
1543 		}
1544 	}
1545 	/*
1546 	 * The LD_DEBUG family and LD_DEMANGLE.
1547 	 */
1548 	else if (*s1 == 'D') {
1549 		if ((len == MSG_LD_DEBUG_SIZE) && (strncmp(s1,
1550 		    MSG_ORIG(MSG_LD_DEBUG), MSG_LD_DEBUG_SIZE) == 0)) {
1551 			select |= SEL_ACT_STR;
1552 			if (select & SEL_REPLACE)
1553 				str = &rpl_debug;
1554 			else {
1555 				str = &prm_debug;
1556 				rpl_debug = 0;
1557 			}
1558 			variable = ENV_FLG_DEBUG;
1559 		} else if ((len == MSG_LD_DEBUG_OUTPUT_SIZE) && (strncmp(s1,
1560 		    MSG_ORIG(MSG_LD_DEBUG_OUTPUT),
1561 		    MSG_LD_DEBUG_OUTPUT_SIZE) == 0)) {
1562 			select |= SEL_ACT_STR;
1563 			str = &dbg_file;
1564 			variable = ENV_FLG_DEBUG_OUTPUT;
1565 		} else if ((len == MSG_LD_DEMANGLE_SIZE) && (strncmp(s1,
1566 		    MSG_ORIG(MSG_LD_DEMANGLE), MSG_LD_DEMANGLE_SIZE) == 0)) {
1567 			select |= SEL_ACT_RT;
1568 			val = RT_FL_DEMANGLE;
1569 			variable = ENV_FLG_DEMANGLE;
1570 		}
1571 	}
1572 	/*
1573 	 * LD_FLAGS - collect the best variable definition.  On completion of
1574 	 * environment variable processing pass the result to ld_flags_env()
1575 	 * where they'll be decomposed and passed back to this routine.
1576 	 */
1577 	else if (*s1 == 'F') {
1578 		if ((len == MSG_LD_FLAGS_SIZE) && (strncmp(s1,
1579 		    MSG_ORIG(MSG_LD_FLAGS), MSG_LD_FLAGS_SIZE) == 0)) {
1580 			select |= SEL_ACT_SPEC_1;
1581 			if (select & SEL_REPLACE)
1582 				str = &rpl_ldflags;
1583 			else {
1584 				str = &prm_ldflags;
1585 				rpl_ldflags = 0;
1586 			}
1587 			variable = ENV_FLG_FLAGS;
1588 		}
1589 	}
1590 	/*
1591 	 * LD_INIT (internal, used by ldd(1)).
1592 	 */
1593 	else if (*s1 == 'I') {
1594 		if ((len == MSG_LD_INIT_SIZE) && (strncmp(s1,
1595 		    MSG_ORIG(MSG_LD_INIT), MSG_LD_INIT_SIZE) == 0)) {
1596 			select |= SEL_ACT_LML;
1597 			val = LML_FLG_TRC_INIT;
1598 			variable = ENV_FLG_INIT;
1599 		}
1600 	}
1601 	/*
1602 	 * The LD_LIBRARY_PATH and LD_LOAD families.
1603 	 */
1604 	else if (*s1 == 'L') {
1605 		if ((len == MSG_LD_LIBPATH_SIZE) && (strncmp(s1,
1606 		    MSG_ORIG(MSG_LD_LIBPATH), MSG_LD_LIBPATH_SIZE) == 0)) {
1607 			select |= SEL_ACT_SPEC_1;
1608 			if (select & SEL_REPLACE)
1609 				str = &rpl_libpath;
1610 			else {
1611 				str = &prm_libpath;
1612 				rpl_libpath = 0;
1613 			}
1614 			variable = ENV_FLG_LIBPATH;
1615 		} else if ((len == MSG_LD_LOADAVAIL_SIZE) && (strncmp(s1,
1616 		    MSG_ORIG(MSG_LD_LOADAVAIL), MSG_LD_LOADAVAIL_SIZE) == 0)) {
1617 			/*
1618 			 * Internal use by crle(1), not documented for general
1619 			 * use.
1620 			 */
1621 			select |= SEL_ACT_LML;
1622 			val = LML_FLG_LOADAVAIL;
1623 			variable = ENV_FLG_LOADAVAIL;
1624 		} else if ((len == MSG_LD_LOADFLTR_SIZE) && (strncmp(s1,
1625 		    MSG_ORIG(MSG_LD_LOADFLTR), MSG_LD_LOADFLTR_SIZE) == 0)) {
1626 			select |= SEL_ACT_SPEC_2;
1627 			variable = ENV_FLG_LOADFLTR;
1628 		}
1629 	}
1630 	/*
1631 	 * The LD_NO family.
1632 	 */
1633 	else if (*s1 == 'N') {
1634 		if ((len == MSG_LD_NOAUDIT_SIZE) && (strncmp(s1,
1635 		    MSG_ORIG(MSG_LD_NOAUDIT), MSG_LD_NOAUDIT_SIZE) == 0)) {
1636 			select |= SEL_ACT_RT;
1637 			val = RT_FL_NOAUDIT;
1638 			variable = ENV_FLG_NOAUDIT;
1639 		} else if ((len == MSG_LD_NOAUXFLTR_SIZE) && (strncmp(s1,
1640 		    MSG_ORIG(MSG_LD_NOAUXFLTR), MSG_LD_NOAUXFLTR_SIZE) == 0)) {
1641 			select |= SEL_ACT_RT;
1642 			val = RT_FL_NOAUXFLTR;
1643 			variable = ENV_FLG_NOAUXFLTR;
1644 		} else if ((len == MSG_LD_NOBAPLT_SIZE) && (strncmp(s1,
1645 		    MSG_ORIG(MSG_LD_NOBAPLT), MSG_LD_NOBAPLT_SIZE) == 0)) {
1646 			select |= SEL_ACT_RT;
1647 			val = RT_FL_NOBAPLT;
1648 			variable = ENV_FLG_NOBAPLT;
1649 		} else if ((len == MSG_LD_NOCONFIG_SIZE) && (strncmp(s1,
1650 		    MSG_ORIG(MSG_LD_NOCONFIG), MSG_LD_NOCONFIG_SIZE) == 0)) {
1651 			select |= SEL_ACT_RT;
1652 			val = RT_FL_NOCFG;
1653 			variable = ENV_FLG_NOCONFIG;
1654 		} else if ((len == MSG_LD_NODIRCONFIG_SIZE) && (strncmp(s1,
1655 		    MSG_ORIG(MSG_LD_NODIRCONFIG),
1656 		    MSG_LD_NODIRCONFIG_SIZE) == 0)) {
1657 			select |= SEL_ACT_RT;
1658 			val = RT_FL_NODIRCFG;
1659 			variable = ENV_FLG_NODIRCONFIG;
1660 		} else if ((len == MSG_LD_NODIRECT_SIZE) && (strncmp(s1,
1661 		    MSG_ORIG(MSG_LD_NODIRECT), MSG_LD_NODIRECT_SIZE) == 0)) {
1662 			select |= SEL_ACT_LMLT;
1663 			val = LML_TFLG_NODIRECT;
1664 			variable = ENV_FLG_NODIRECT;
1665 		} else if ((len == MSG_LD_NOENVCONFIG_SIZE) && (strncmp(s1,
1666 		    MSG_ORIG(MSG_LD_NOENVCONFIG),
1667 		    MSG_LD_NOENVCONFIG_SIZE) == 0)) {
1668 			select |= SEL_ACT_RT;
1669 			val = RT_FL_NOENVCFG;
1670 			variable = ENV_FLG_NOENVCONFIG;
1671 		} else if ((len == MSG_LD_NOFLTCONFIG_SIZE) && (strncmp(s1,
1672 		    MSG_ORIG(MSG_LD_NOFLTCONFIG),
1673 		    MSG_LD_NOFLTCONFIG_SIZE) == 0)) {
1674 			select |= SEL_ACT_RT2;
1675 			val = RT_FL2_NOFLTCFG;
1676 			variable = ENV_FLG_NOFLTCONFIG;
1677 		} else if ((len == MSG_LD_NOLAZY_SIZE) && (strncmp(s1,
1678 		    MSG_ORIG(MSG_LD_NOLAZY), MSG_LD_NOLAZY_SIZE) == 0)) {
1679 			select |= SEL_ACT_LMLT;
1680 			val = LML_TFLG_NOLAZYLD;
1681 			variable = ENV_FLG_NOLAZY;
1682 		} else if ((len == MSG_LD_NOOBJALTER_SIZE) && (strncmp(s1,
1683 		    MSG_ORIG(MSG_LD_NOOBJALTER),
1684 		    MSG_LD_NOOBJALTER_SIZE) == 0)) {
1685 			select |= SEL_ACT_RT;
1686 			val = RT_FL_NOOBJALT;
1687 			variable = ENV_FLG_NOOBJALTER;
1688 		} else if ((len == MSG_LD_NOVERSION_SIZE) && (strncmp(s1,
1689 		    MSG_ORIG(MSG_LD_NOVERSION), MSG_LD_NOVERSION_SIZE) == 0)) {
1690 			select |= SEL_ACT_RT;
1691 			val = RT_FL_NOVERSION;
1692 			variable = ENV_FLG_NOVERSION;
1693 		} else if ((len == MSG_LD_NOUNRESWEAK_SIZE) && (strncmp(s1,
1694 		    MSG_ORIG(MSG_LD_NOUNRESWEAK),
1695 		    MSG_LD_NOUNRESWEAK_SIZE) == 0)) {
1696 			/*
1697 			 * LD_NOUNRESWEAK (internal, used by ldd(1)).
1698 			 */
1699 			select |= SEL_ACT_LML;
1700 			val = LML_FLG_TRC_NOUNRESWEAK;
1701 			variable = ENV_FLG_NOUNRESWEAK;
1702 		}
1703 	}
1704 	/*
1705 	 * LD_ORIGIN.
1706 	 */
1707 	else if (*s1 == 'O') {
1708 #ifndef	EXPAND_RELATIVE
1709 		if ((len == MSG_LD_ORIGIN_SIZE) && (strncmp(s1,
1710 		    MSG_ORIG(MSG_LD_ORIGIN), MSG_LD_ORIGIN_SIZE) == 0)) {
1711 			/*
1712 			 * Besides some old patches this is no longer required.
1713 			 */
1714 			rtld_flags |= RT_FL_RELATIVE;
1715 		}
1716 #endif
1717 		return;
1718 	}
1719 	/*
1720 	 * LD_PRELOAD and LD_PROFILE family.
1721 	 */
1722 	else if (*s1 == 'P') {
1723 		if ((len == MSG_LD_PRELOAD_SIZE) && (strncmp(s1,
1724 		    MSG_ORIG(MSG_LD_PRELOAD), MSG_LD_PRELOAD_SIZE) == 0)) {
1725 			select |= SEL_ACT_STR;
1726 			if (select & SEL_REPLACE)
1727 				str = &rpl_preload;
1728 			else  {
1729 				str = &prm_preload;
1730 				rpl_preload = 0;
1731 			}
1732 			variable = ENV_FLG_PRELOAD;
1733 		} else if ((len == MSG_LD_PROFILE_SIZE) && (strncmp(s1,
1734 		    MSG_ORIG(MSG_LD_PROFILE), MSG_LD_PROFILE_SIZE) == 0)) {
1735 			/*
1736 			 * Only one user library can be profiled at a time.
1737 			 */
1738 			select |= SEL_ACT_SPEC_2;
1739 			variable = ENV_FLG_PROFILE;
1740 		} else if ((len == MSG_LD_PROFILE_OUTPUT_SIZE) && (strncmp(s1,
1741 		    MSG_ORIG(MSG_LD_PROFILE_OUTPUT),
1742 		    MSG_LD_PROFILE_OUTPUT_SIZE) == 0)) {
1743 			/*
1744 			 * Only one user library can be profiled at a time.
1745 			 */
1746 			select |= SEL_ACT_STR;
1747 			str = &profile_out;
1748 			variable = ENV_FLG_PROFILE_OUTPUT;
1749 		}
1750 	}
1751 	/*
1752 	 * LD_SIGNAL.
1753 	 */
1754 	else if (*s1 == 'S') {
1755 		if (rtld_flags & RT_FL_SECURE)
1756 			return;
1757 		if ((len == MSG_LD_SIGNAL_SIZE) &&
1758 		    (strncmp(s1, MSG_ORIG(MSG_LD_SIGNAL),
1759 		    MSG_LD_SIGNAL_SIZE) == 0)) {
1760 			select |= SEL_ACT_SPEC_2;
1761 			variable = ENV_FLG_SIGNAL;
1762 		}
1763 	}
1764 	/*
1765 	 * The LD_TRACE family (internal, used by ldd(1)).  This definition is
1766 	 * the key to enabling all other ldd(1) specific environment variables.
1767 	 * In case an auditor is called, which in turn might exec(2) a
1768 	 * subprocess, this variable is disabled, so that any subprocess
1769 	 * escapes ldd(1) processing.
1770 	 */
1771 	else if (*s1 == 'T') {
1772 		if (((len == MSG_LD_TRACE_OBJS_SIZE) &&
1773 		    (strncmp(s1, MSG_ORIG(MSG_LD_TRACE_OBJS),
1774 		    MSG_LD_TRACE_OBJS_SIZE) == 0)) ||
1775 		    ((len == MSG_LD_TRACE_OBJS_E_SIZE) &&
1776 		    (((strncmp(s1, MSG_ORIG(MSG_LD_TRACE_OBJS_E),
1777 		    MSG_LD_TRACE_OBJS_E_SIZE) == 0) && !aout) ||
1778 		    ((strncmp(s1, MSG_ORIG(MSG_LD_TRACE_OBJS_A),
1779 		    MSG_LD_TRACE_OBJS_A_SIZE) == 0) && aout)))) {
1780 			char	*s0 = (char *)s1;
1781 
1782 			select |= SEL_ACT_SPEC_2;
1783 			variable = ENV_FLG_TRACE_OBJS;
1784 
1785 #if	defined(__sparc) || defined(__x86)
1786 			/*
1787 			 * The simplest way to "disable" this variable is to
1788 			 * truncate this string to "LD_'\0'". This string is
1789 			 * ignored by any ld.so.1 environment processing.
1790 			 * Use of such interfaces as unsetenv(3c) are overkill,
1791 			 * and would drag too much libc implementation detail
1792 			 * into ld.so.1.
1793 			 */
1794 			*s0 = '\0';
1795 #else
1796 /*
1797  * Verify that the above write is appropriate for any new platforms.
1798  */
1799 #error	unsupported architecture!
1800 #endif
1801 		} else if ((len == MSG_LD_TRACE_PTHS_SIZE) && (strncmp(s1,
1802 		    MSG_ORIG(MSG_LD_TRACE_PTHS),
1803 		    MSG_LD_TRACE_PTHS_SIZE) == 0)) {
1804 			select |= SEL_ACT_LML;
1805 			val = LML_FLG_TRC_SEARCH;
1806 			variable = ENV_FLG_TRACE_PTHS;
1807 		}
1808 	}
1809 	/*
1810 	 * LD_UNREF and LD_UNUSED (internal, used by ldd(1)).
1811 	 */
1812 	else if (*s1 == 'U') {
1813 		if ((len == MSG_LD_UNREF_SIZE) && (strncmp(s1,
1814 		    MSG_ORIG(MSG_LD_UNREF), MSG_LD_UNREF_SIZE) == 0)) {
1815 			select |= SEL_ACT_LML;
1816 			val = LML_FLG_TRC_UNREF;
1817 			variable = ENV_FLG_UNREF;
1818 		} else if ((len == MSG_LD_UNUSED_SIZE) && (strncmp(s1,
1819 		    MSG_ORIG(MSG_LD_UNUSED), MSG_LD_UNUSED_SIZE) == 0)) {
1820 			select |= SEL_ACT_LML;
1821 			val = LML_FLG_TRC_UNUSED;
1822 			variable = ENV_FLG_UNUSED;
1823 		}
1824 	}
1825 	/*
1826 	 * LD_VERBOSE (internal, used by ldd(1)).
1827 	 */
1828 	else if (*s1 == 'V') {
1829 		if ((len == MSG_LD_VERBOSE_SIZE) && (strncmp(s1,
1830 		    MSG_ORIG(MSG_LD_VERBOSE), MSG_LD_VERBOSE_SIZE) == 0)) {
1831 			select |= SEL_ACT_LML;
1832 			val = LML_FLG_TRC_VERBOSE;
1833 			variable = ENV_FLG_VERBOSE;
1834 		}
1835 	}
1836 	/*
1837 	 * LD_WARN (internal, used by ldd(1)).
1838 	 */
1839 	else if (*s1 == 'W') {
1840 		if ((len == MSG_LD_WARN_SIZE) && (strncmp(s1,
1841 		    MSG_ORIG(MSG_LD_WARN), MSG_LD_WARN_SIZE) == 0)) {
1842 			select |= SEL_ACT_LML;
1843 			val = LML_FLG_TRC_WARN;
1844 			variable = ENV_FLG_WARN;
1845 		}
1846 #ifdef	SIEBEL_DISABLE
1847 	}
1848 	/*
1849 	 * LD__FIX__ (undocumented, enable future technology that can't be
1850 	 * delivered in a patch release).
1851 	 */
1852 	else if (*s1 == '_') {
1853 		if ((len == MSG_LD_FIX_1_SIZE) && (strncmp(s1,
1854 		    MSG_ORIG(MSG_LD_FIX_1), MSG_LD_FIX_1_SIZE) == 0)) {
1855 			select |= SEL_ACT_RT;
1856 			val = RT_FL_DISFIX_1;
1857 			variable = ENV_FLG_FIX_1;
1858 		}
1859 #endif
1860 	}
1861 	if (variable == 0)
1862 		return;
1863 
1864 	/*
1865 	 * If the variable is already processed with ISA specific variable,
1866 	 * no further processing needed.
1867 	 */
1868 	if (((select & SEL_REPLACE) && (rplisa & variable)) ||
1869 	    ((select & SEL_PERMANT) && (prmisa & variable)))
1870 		return;
1871 
1872 	/*
1873 	 * Now mark the appropriate variables.
1874 	 * If the replaceable variable is already set, then the
1875 	 * process environment variable must be set. Any replaceable
1876 	 * variable specified in a configuration file can be ignored.
1877 	 */
1878 	if (env_flags & ENV_TYP_ISA) {
1879 		/*
1880 		 * This is ISA setting. We do the setting
1881 		 * even if s2 is NULL.
1882 		 * If s2 is NULL, we might need to undo
1883 		 * the setting.
1884 		 */
1885 		if (select & SEL_REPLACE) {
1886 			if (rplisa & variable)
1887 				return;
1888 			rplisa |= variable;
1889 		} else {
1890 			prmisa |= variable;
1891 		}
1892 	} else if (s2) {
1893 		/*
1894 		 * This is non0-ISA setting
1895 		 */
1896 		if (select & SEL_REPLACE) {
1897 			if (rplgen & variable)
1898 				return;
1899 			rplgen |= variable;
1900 		} else
1901 			prmgen |= variable;
1902 	} else
1903 		/*
1904 		 * This is non-ISA setting which
1905 		 * can be ignored.
1906 		 */
1907 		return;
1908 
1909 	/*
1910 	 * Now perform the setting.
1911 	 */
1912 	if (select & SEL_ACT_RT) {
1913 		if (s2)
1914 			rtld_flags |= val;
1915 		else
1916 			rtld_flags &= ~val;
1917 	} else if (select & SEL_ACT_RT2) {
1918 		if (s2)
1919 			rtld_flags2 |= val;
1920 		else
1921 			rtld_flags2 &= ~val;
1922 	} else if (select & SEL_ACT_STR)
1923 		*str = s2;
1924 	else if (select & SEL_ACT_LML) {
1925 		if (s2)
1926 			*lmflags |= val;
1927 		else
1928 			*lmflags &= ~val;
1929 	} else if (select & SEL_ACT_LMLT) {
1930 		if (s2)
1931 			*lmtflags |= val;
1932 		else
1933 			*lmtflags &= ~val;
1934 	} else if (select & SEL_ACT_SPEC_1) {
1935 		/*
1936 		 * variable is either ENV_FLG_FLAGS or ENV_FLG_LIBPATH
1937 		 */
1938 		*str = s2;
1939 		if ((select & SEL_REPLACE) && (env_flags & ENV_TYP_CONFIG)) {
1940 			if (s2) {
1941 				if (variable == ENV_FLG_FLAGS)
1942 					env_info |= ENV_INF_FLAGCFG;
1943 				else
1944 					env_info |= ENV_INF_PATHCFG;
1945 			} else {
1946 				if (variable == ENV_FLG_FLAGS)
1947 					env_info &= ~ENV_INF_FLAGCFG;
1948 				else
1949 					env_info &= ~ENV_INF_PATHCFG;
1950 			}
1951 		}
1952 	} else if (select & SEL_ACT_SPEC_2) {
1953 		/*
1954 		 * variables can be: ENV_FLG_
1955 		 * 	AUDIT_ARGS, BINDING, CONCURRENCY, CONFGEN,
1956 		 *	LOADFLTR, PROFILE, SIGNAL, TRACE_OBJS
1957 		 */
1958 		if (variable == ENV_FLG_AUDIT_ARGS) {
1959 			if (s2) {
1960 				audit_argcnt = atoi(s2);
1961 				audit_argcnt += audit_argcnt % 2;
1962 			} else
1963 				audit_argcnt = 0;
1964 		} else if (variable == ENV_FLG_BINDINGS) {
1965 			if (s2)
1966 				rpl_debug = MSG_ORIG(MSG_TKN_BINDINGS);
1967 			else
1968 				rpl_debug = 0;
1969 		} else if (variable == ENV_FLG_CONCURRENCY) {
1970 			if (s2)
1971 				rtld_flags &= ~RT_FL_NOCONCUR;
1972 			else
1973 				rtld_flags |= RT_FL_NOCONCUR;
1974 		} else if (variable == ENV_FLG_CONFGEN) {
1975 			if (s2) {
1976 				rtld_flags |= RT_FL_CONFGEN;
1977 				*lmflags |= LML_FLG_IGNRELERR;
1978 			} else {
1979 				rtld_flags &= ~RT_FL_CONFGEN;
1980 				*lmflags &= ~LML_FLG_IGNRELERR;
1981 			}
1982 		} else if (variable == ENV_FLG_LOADFLTR) {
1983 			if (s2) {
1984 				*lmtflags |= LML_TFLG_LOADFLTR;
1985 				if (*s2 == '2')
1986 					rtld_flags |= RT_FL_WARNFLTR;
1987 			} else {
1988 				*lmtflags &= ~LML_TFLG_LOADFLTR;
1989 				rtld_flags &= ~RT_FL_WARNFLTR;
1990 			}
1991 		} else if (variable == ENV_FLG_PROFILE) {
1992 			profile_name = s2;
1993 			if (s2) {
1994 				if (strcmp(s2, MSG_ORIG(MSG_FIL_RTLD)) == 0) {
1995 					return;
1996 				}
1997 				/* BEGIN CSTYLED */
1998 				if (rtld_flags & RT_FL_SECURE) {
1999 					profile_lib =
2000 #if	defined(_ELF64)
2001 					    MSG_ORIG(MSG_PTH_LDPROFSE_64);
2002 #else
2003 					    MSG_ORIG(MSG_PTH_LDPROFSE);
2004 #endif
2005 				} else {
2006 					profile_lib =
2007 #if	defined(_ELF64)
2008 					    MSG_ORIG(MSG_PTH_LDPROF_64);
2009 #else
2010 					    MSG_ORIG(MSG_PTH_LDPROF);
2011 #endif
2012 				}
2013 				/* END CSTYLED */
2014 			} else
2015 				profile_lib = 0;
2016 		} else if (variable == ENV_FLG_SIGNAL) {
2017 			killsig = s2 ? atoi(s2) : SIGKILL;
2018 		} else if (variable == ENV_FLG_TRACE_OBJS) {
2019 			if (s2) {
2020 				*lmflags |= LML_FLG_TRC_ENABLE;
2021 				if (*s2 == '2')
2022 					*lmflags |= LML_FLG_TRC_LDDSTUB;
2023 			} else
2024 				*lmflags &=
2025 				    ~(LML_FLG_TRC_ENABLE|LML_FLG_TRC_LDDSTUB);
2026 		}
2027 	}
2028 }
2029 
2030 /*
2031  * Determine whether we have an architecture specific environment variable.
2032  * If we do, and we're the wrong architecture, it'll just get ignored.
2033  * Otherwise the variable is processed in it's architecture neutral form.
2034  */
2035 static int
2036 ld_arch_env(const char *s1, size_t *len)
2037 {
2038 	size_t	_len = *len - 3;
2039 
2040 	if (s1[_len++] == '_') {
2041 		if ((s1[_len] == '3') && (s1[_len + 1] == '2')) {
2042 #if	defined(_ELF64)
2043 			return (ENV_TYP_IGNORE);
2044 #else
2045 			*len = *len - 3;
2046 			return (ENV_TYP_ISA);
2047 #endif
2048 		}
2049 		if ((s1[_len] == '6') && (s1[_len + 1] == '4')) {
2050 #if	defined(_ELF64)
2051 			*len = *len - 3;
2052 			return (ENV_TYP_ISA);
2053 #else
2054 			return (ENV_TYP_IGNORE);
2055 #endif
2056 		}
2057 	}
2058 	return (0);
2059 }
2060 
2061 
2062 /*
2063  * Process an LD_FLAGS environment variable.  The value can be a comma
2064  * separated set of tokens, which are sent (in upper case) into the generic
2065  * LD_XXXX environment variable engine.  For example:
2066  *
2067  *	LD_FLAGS=bind_now		->	LD_BIND_NOW=1
2068  *	LD_FLAGS=library_path=/foo:.	->	LD_LIBRARY_PATH=/foo:.
2069  *	LD_FLAGS=debug=files:detail	->	LD_DEBUG=files:detail
2070  * or
2071  *	LD_FLAGS=bind_now,library_path=/foo:.,debug=files:detail
2072  */
2073 static int
2074 ld_flags_env(const char *str, Word *lmflags, Word *lmtflags,
2075     uint_t env_flags, int aout)
2076 {
2077 	char	*nstr, *sstr, *estr = 0;
2078 	size_t	nlen, len;
2079 
2080 	if (str == 0)
2081 		return (0);
2082 
2083 	/*
2084 	 * Create a new string as we're going to transform the token(s) into
2085 	 * uppercase and separate tokens with nulls.
2086 	 */
2087 	len = strlen(str);
2088 	if ((nstr = malloc(len + 1)) == 0)
2089 		return (1);
2090 	(void) strcpy(nstr, str);
2091 
2092 	for (sstr = nstr; sstr; sstr++, len--) {
2093 		int	flags;
2094 
2095 		if ((*sstr != '\0') && (*sstr != ',')) {
2096 			if (estr == 0) {
2097 				if (*sstr == '=')
2098 					estr = sstr;
2099 				else {
2100 					/*
2101 					 * Translate token to uppercase.  Don't
2102 					 * use toupper(3C) as including this
2103 					 * code doubles the size of ld.so.1.
2104 					 */
2105 					if ((*sstr >= 'a') && (*sstr <= 'z'))
2106 						*sstr = *sstr - ('a' - 'A');
2107 				}
2108 			}
2109 			continue;
2110 		}
2111 
2112 		*sstr = '\0';
2113 		if (estr) {
2114 			nlen = estr - nstr;
2115 			if ((*++estr == '\0') || (*estr == ','))
2116 				estr = 0;
2117 		} else
2118 			nlen = sstr - nstr;
2119 
2120 		/*
2121 		 * Fabricate a boolean definition for any unqualified variable.
2122 		 * Thus LD_FLAGS=bind_now is represented as BIND_NOW=(null).
2123 		 * The value is sufficient to assert any boolean variables, plus
2124 		 * the term "(null)" is specifically chosen in case someone
2125 		 * mistakenly supplies something like LD_FLAGS=library_path.
2126 		 */
2127 		if (estr == 0)
2128 			estr = (char *)MSG_INTL(MSG_STR_NULL);
2129 
2130 		/*
2131 		 * Determine whether the environment variable is 32- or 64-bit
2132 		 * specific.  The length, len, will reflect the architecture
2133 		 * neutral portion of the string.
2134 		 */
2135 		if ((flags = ld_arch_env(nstr, &nlen)) != ENV_TYP_IGNORE) {
2136 			ld_generic_env(nstr, nlen, estr, lmflags,
2137 			    lmtflags, (env_flags | flags), aout);
2138 		}
2139 		if (len == 0)
2140 			return (0);
2141 
2142 		nstr = sstr + 1;
2143 		estr = 0;
2144 	}
2145 	return (0);
2146 }
2147 
2148 
2149 /*
2150  * Process a single environment string.  Only strings starting with `LD_' are
2151  * reserved for our use.  By convention, all strings should be of the form
2152  * `LD_XXXX=', if the string is followed by a non-null value the appropriate
2153  * functionality is enabled.  Also pick off applicable locale variables.
2154  */
2155 #define	LOC_LANG	1
2156 #define	LOC_MESG	2
2157 #define	LOC_ALL		3
2158 
2159 static void
2160 ld_str_env(const char *s1, Word *lmflags, Word *lmtflags, uint_t env_flags,
2161     int aout)
2162 {
2163 	const char	*s2;
2164 	static		size_t	loc = 0;
2165 
2166 	if (*s1++ != 'L')
2167 		return;
2168 
2169 	/*
2170 	 * See if we have any locale environment settings.  These environment
2171 	 * variables have a precedence, LC_ALL is higher than LC_MESSAGES which
2172 	 * is higher than LANG.
2173 	 */
2174 	s2 = s1;
2175 	if ((*s2++ == 'C') && (*s2++ == '_') && (*s2 != '\0')) {
2176 		if (strncmp(s2, MSG_ORIG(MSG_LC_ALL), MSG_LC_ALL_SIZE) == 0) {
2177 			s2 += MSG_LC_ALL_SIZE;
2178 			if ((*s2 != '\0') && (loc < LOC_ALL)) {
2179 				glcs[CI_LCMESSAGES].lc_un.lc_ptr = (char *)s2;
2180 				loc = LOC_ALL;
2181 			}
2182 		} else if (strncmp(s2, MSG_ORIG(MSG_LC_MESSAGES),
2183 		    MSG_LC_MESSAGES_SIZE) == 0) {
2184 			s2 += MSG_LC_MESSAGES_SIZE;
2185 			if ((*s2 != '\0') && (loc < LOC_MESG)) {
2186 				glcs[CI_LCMESSAGES].lc_un.lc_ptr = (char *)s2;
2187 				loc = LOC_MESG;
2188 			}
2189 		}
2190 		return;
2191 	}
2192 
2193 	s2 = s1;
2194 	if ((*s2++ == 'A') && (*s2++ == 'N') && (*s2++ == 'G') &&
2195 	    (*s2++ == '=') && (*s2 != '\0') && (loc < LOC_LANG)) {
2196 		glcs[CI_LCMESSAGES].lc_un.lc_ptr = (char *)s2;
2197 		loc = LOC_LANG;
2198 		return;
2199 	}
2200 
2201 	/*
2202 	 * Pick off any LD_XXXX environment variables.
2203 	 */
2204 	if ((*s1++ == 'D') && (*s1++ == '_') && (*s1 != '\0')) {
2205 		size_t	len;
2206 		int	flags;
2207 
2208 		/*
2209 		 * In a branded process we must ignore all LD_XXXX env vars
2210 		 * because they are intended for the brand's linker.
2211 		 * To affect the Solaris linker, use LD_BRAND_XXXX instead.
2212 		 */
2213 		if (rtld_flags2 & RT_FL2_BRANDED) {
2214 			if (strncmp(s1, MSG_ORIG(MSG_LD_BRAND_PREFIX),
2215 			    MSG_LD_BRAND_PREFIX_SIZE) != 0)
2216 				return;
2217 			s1 += MSG_LD_BRAND_PREFIX_SIZE;
2218 		}
2219 
2220 		/*
2221 		 * Environment variables with no value (ie. LD_XXXX=) typically
2222 		 * have no impact, however if environment variables are defined
2223 		 * within a configuration file, these null user settings can be
2224 		 * used to disable any configuration replaceable definitions.
2225 		 */
2226 		if ((s2 = strchr(s1, '=')) == 0) {
2227 			len = strlen(s1);
2228 			s2 = 0;
2229 		} else if (*++s2 == '\0') {
2230 			len = strlen(s1) - 1;
2231 			s2 = 0;
2232 		} else {
2233 			len = s2 - s1 - 1;
2234 			while (isspace(*s2))
2235 				s2++;
2236 		}
2237 
2238 		/*
2239 		 * Determine whether the environment variable is 32- or 64-bit
2240 		 * specific.  The length, len, will reflect the architecture
2241 		 * neutral portion of the string.
2242 		 */
2243 		if ((flags = ld_arch_env(s1, &len)) == ENV_TYP_IGNORE)
2244 			return;
2245 		env_flags |= flags;
2246 
2247 		ld_generic_env(s1, len, s2, lmflags, lmtflags, env_flags, aout);
2248 	}
2249 }
2250 
2251 /*
2252  * Internal getenv routine.  Called immediately after ld.so.1 initializes
2253  * itself.
2254  */
2255 int
2256 readenv_user(const char ** envp, Word *lmflags, Word *lmtflags, int aout)
2257 {
2258 	char	*locale;
2259 
2260 	if (envp == (const char **)0)
2261 		return (0);
2262 
2263 	while (*envp != (const char *)0)
2264 		ld_str_env(*envp++, lmflags, lmtflags, 0, aout);
2265 
2266 	/*
2267 	 * Having collected the best representation of any LD_FLAGS, process
2268 	 * these strings.
2269 	 */
2270 	if (ld_flags_env(rpl_ldflags, lmflags, lmtflags, 0, aout) == 1)
2271 		return (1);
2272 
2273 	/*
2274 	 * Don't allow environment controlled auditing when tracing or if
2275 	 * explicitly disabled.  Trigger all tracing modes from
2276 	 * LML_FLG_TRC_ENABLE.
2277 	 */
2278 	if ((*lmflags & LML_FLG_TRC_ENABLE) || (rtld_flags & RT_FL_NOAUDIT))
2279 		rpl_audit = profile_lib = profile_name = 0;
2280 	if ((*lmflags & LML_FLG_TRC_ENABLE) == 0)
2281 		*lmflags &= ~LML_MSK_TRC;
2282 
2283 	/*
2284 	 * If both LD_BIND_NOW and LD_BIND_LAZY are specified, the former wins.
2285 	 */
2286 	if ((rtld_flags2 & (RT_FL2_BINDNOW | RT_FL2_BINDLAZY)) ==
2287 	    (RT_FL2_BINDNOW | RT_FL2_BINDLAZY))
2288 		rtld_flags2 &= ~RT_FL2_BINDLAZY;
2289 
2290 	/*
2291 	 * If we have a locale setting make sure its worth processing further.
2292 	 * C and POSIX locales don't need any processing.  In addition, to
2293 	 * ensure no one escapes the /usr/lib/locale hierarchy, don't allow
2294 	 * the locale to contain a segment that leads upward in the file system
2295 	 * hierarchy (i.e. no '..' segments).   Given that we'll be confined to
2296 	 * the /usr/lib/locale hierarchy, there is no need to extensively
2297 	 * validate the mode or ownership of any message file (as libc's
2298 	 * generic handling of message files does).  Duplicate the string so
2299 	 * that new locale setting can generically cleanup any previous locales.
2300 	 */
2301 	if ((locale = glcs[CI_LCMESSAGES].lc_un.lc_ptr) != 0) {
2302 		if (((*locale == 'C') && (*(locale + 1) == '\0')) ||
2303 		    (strcmp(locale, MSG_ORIG(MSG_TKN_POSIX)) == 0) ||
2304 		    (strstr(locale, MSG_ORIG(MSG_TKN_DOTDOT)) != NULL))
2305 			glcs[CI_LCMESSAGES].lc_un.lc_ptr = 0;
2306 		else
2307 			glcs[CI_LCMESSAGES].lc_un.lc_ptr = strdup(locale);
2308 	}
2309 	return (0);
2310 }
2311 
2312 /*
2313  * Configuration environment processing.  Called after the a.out has been
2314  * processed (as the a.out can specify its own configuration file).
2315  */
2316 int
2317 readenv_config(Rtc_env * envtbl, Addr addr, int aout)
2318 {
2319 	Word *	lmflags = &(lml_main.lm_flags);
2320 	Word *	lmtflags = &(lml_main.lm_tflags);
2321 
2322 	if (envtbl == (Rtc_env *)0)
2323 		return (0);
2324 
2325 	while (envtbl->env_str) {
2326 		uint_t	env_flags = ENV_TYP_CONFIG;
2327 
2328 		if (envtbl->env_flags & RTC_ENV_PERMANT)
2329 			env_flags |= ENV_TYP_PERMANT;
2330 
2331 		ld_str_env((const char *)(envtbl->env_str + addr),
2332 		    lmflags, lmtflags, env_flags, 0);
2333 		envtbl++;
2334 	}
2335 
2336 	/*
2337 	 * Having collected the best representation of any LD_FLAGS, process
2338 	 * these strings.
2339 	 */
2340 	if (ld_flags_env(rpl_ldflags, lmflags, lmtflags, 0, aout) == 1)
2341 		return (1);
2342 	if (ld_flags_env(prm_ldflags, lmflags, lmtflags, ENV_TYP_CONFIG,
2343 	    aout) == 1)
2344 		return (1);
2345 
2346 	/*
2347 	 * Don't allow environment controlled auditing when tracing or if
2348 	 * explicitly disabled.  Trigger all tracing modes from
2349 	 * LML_FLG_TRC_ENABLE.
2350 	 */
2351 	if ((*lmflags & LML_FLG_TRC_ENABLE) || (rtld_flags & RT_FL_NOAUDIT))
2352 		prm_audit = profile_lib = profile_name = 0;
2353 	if ((*lmflags & LML_FLG_TRC_ENABLE) == 0)
2354 		*lmflags &= ~LML_MSK_TRC;
2355 
2356 	return (0);
2357 }
2358 
2359 int
2360 dowrite(Prfbuf * prf)
2361 {
2362 	/*
2363 	 * We do not have a valid file descriptor, so we are unable
2364 	 * to flush the buffer.
2365 	 */
2366 	if (prf->pr_fd == -1)
2367 		return (0);
2368 	(void) write(prf->pr_fd, prf->pr_buf, prf->pr_cur - prf->pr_buf);
2369 	prf->pr_cur = prf->pr_buf;
2370 	return (1);
2371 }
2372 
2373 /*
2374  * Simplified printing.  The following conversion specifications are supported:
2375  *
2376  *	% [#] [-] [min field width] [. precision] s|d|x|c
2377  *
2378  *
2379  * dorprf takes the output buffer in the form of Prfbuf which permits
2380  * the verification of the output buffer size and the concatenation
2381  * of data to an already existing output buffer.  The Prfbuf
2382  * structure contains the following:
2383  *
2384  *  pr_buf	pointer to the beginning of the output buffer.
2385  *  pr_cur	pointer to the next available byte in the output buffer.  By
2386  *		setting pr_cur ahead of pr_buf you can append to an already
2387  *		existing buffer.
2388  *  pr_len	the size of the output buffer.  By setting pr_len to '0' you
2389  *		disable protection from overflows in the output buffer.
2390  *  pr_fd	a pointer to the file-descriptor the buffer will eventually be
2391  *		output to.  If pr_fd is set to '-1' then it's assumed there is
2392  *		no output buffer, and doprf() will return with an error to
2393  *		indicate an output buffer overflow.  If pr_fd is > -1 then when
2394  *		the output buffer is filled it will be flushed to pr_fd and will
2395  *		then be	available for additional data.
2396  */
2397 #define	FLG_UT_MINUS	0x0001	/* - */
2398 #define	FLG_UT_SHARP	0x0002	/* # */
2399 #define	FLG_UT_DOTSEEN	0x0008	/* dot appeared in format spec */
2400 
2401 /*
2402  * This macro is for use from within doprf only.  It is to be used for checking
2403  * the output buffer size and placing characters into the buffer.
2404  */
2405 #define	PUTC(c) \
2406 	{ \
2407 		char tmpc; \
2408 		\
2409 		tmpc = (c); \
2410 		if (bufsiz && (bp >= bufend)) { \
2411 			prf->pr_cur = bp; \
2412 			if (dowrite(prf) == 0) \
2413 				return (0); \
2414 			bp = prf->pr_cur; \
2415 		} \
2416 		*bp++ = tmpc; \
2417 	}
2418 
2419 /*
2420  * Define a local buffer size for building a numeric value - large enough to
2421  * hold a 64-bit value.
2422  */
2423 #define	NUM_SIZE	22
2424 
2425 size_t
2426 doprf(const char *format, va_list args, Prfbuf *prf)
2427 {
2428 	char	c;
2429 	char	*bp = prf->pr_cur;
2430 	char	*bufend = prf->pr_buf + prf->pr_len;
2431 	size_t	bufsiz = prf->pr_len;
2432 
2433 	while ((c = *format++) != '\0') {
2434 		if (c != '%') {
2435 			PUTC(c);
2436 		} else {
2437 			int	base = 0, flag = 0, width = 0, prec = 0;
2438 			size_t	_i;
2439 			int	_c, _n;
2440 			char	*_s;
2441 			int	ls = 0;
2442 again:
2443 			c = *format++;
2444 			switch (c) {
2445 			case '-':
2446 				flag |= FLG_UT_MINUS;
2447 				goto again;
2448 			case '#':
2449 				flag |= FLG_UT_SHARP;
2450 				goto again;
2451 			case '.':
2452 				flag |= FLG_UT_DOTSEEN;
2453 				goto again;
2454 			case '0':
2455 			case '1':
2456 			case '2':
2457 			case '3':
2458 			case '4':
2459 			case '5':
2460 			case '6':
2461 			case '7':
2462 			case '8':
2463 			case '9':
2464 				if (flag & FLG_UT_DOTSEEN)
2465 					prec = (prec * 10) + c - '0';
2466 				else
2467 					width = (width * 10) + c - '0';
2468 				goto again;
2469 			case 'x':
2470 			case 'X':
2471 				base = 16;
2472 				break;
2473 			case 'd':
2474 			case 'D':
2475 			case 'u':
2476 				base = 10;
2477 				flag &= ~FLG_UT_SHARP;
2478 				break;
2479 			case 'l':
2480 				base = 10;
2481 				ls++; /* number of l's (long or long long) */
2482 				if ((*format == 'l') ||
2483 				    (*format == 'd') || (*format == 'D') ||
2484 				    (*format == 'x') || (*format == 'X') ||
2485 				    (*format == 'o') || (*format == 'O'))
2486 					goto again;
2487 				break;
2488 			case 'o':
2489 			case 'O':
2490 				base = 8;
2491 				break;
2492 			case 'c':
2493 				_c = va_arg(args, int);
2494 
2495 				for (_i = 24; _i > 0; _i -= 8) {
2496 					if ((c = ((_c >> _i) & 0x7f)) != 0) {
2497 						PUTC(c);
2498 					}
2499 				}
2500 				if ((c = ((_c >> _i) & 0x7f)) != 0) {
2501 					PUTC(c);
2502 				}
2503 				break;
2504 			case 's':
2505 				_s = va_arg(args, char *);
2506 				_i = strlen(_s);
2507 				/* LINTED */
2508 				_n = (int)(width - _i);
2509 				if (!prec)
2510 					/* LINTED */
2511 					prec = (int)_i;
2512 
2513 				if (width && !(flag & FLG_UT_MINUS)) {
2514 					while (_n-- > 0)
2515 						PUTC(' ');
2516 				}
2517 				while (((c = *_s++) != 0) && prec--) {
2518 					PUTC(c);
2519 				}
2520 				if (width && (flag & FLG_UT_MINUS)) {
2521 					while (_n-- > 0)
2522 						PUTC(' ');
2523 				}
2524 				break;
2525 			case '%':
2526 				PUTC('%');
2527 				break;
2528 			default:
2529 				break;
2530 			}
2531 
2532 			/*
2533 			 * Numeric processing
2534 			 */
2535 			if (base) {
2536 				char		local[NUM_SIZE];
2537 				size_t		ssize = 0, psize = 0;
2538 				const char	*string =
2539 				    MSG_ORIG(MSG_STR_HEXNUM);
2540 				const char	*prefix =
2541 				    MSG_ORIG(MSG_STR_EMPTY);
2542 				u_longlong_t	num;
2543 
2544 				switch (ls) {
2545 				case 0:	/* int */
2546 					num = (u_longlong_t)
2547 					    va_arg(args, uint_t);
2548 					break;
2549 				case 1:	/* long */
2550 					num = (u_longlong_t)
2551 					    va_arg(args, ulong_t);
2552 					break;
2553 				case 2:	/* long long */
2554 					num = va_arg(args, u_longlong_t);
2555 					break;
2556 				}
2557 
2558 				if (flag & FLG_UT_SHARP) {
2559 					if (base == 16) {
2560 						prefix = MSG_ORIG(MSG_STR_HEX);
2561 						psize = 2;
2562 					} else {
2563 						prefix = MSG_ORIG(MSG_STR_ZERO);
2564 						psize = 1;
2565 					}
2566 				}
2567 				if ((base == 10) && (long)num < 0) {
2568 					prefix = MSG_ORIG(MSG_STR_NEGATE);
2569 					psize = MSG_STR_NEGATE_SIZE;
2570 					num = (u_longlong_t)(-(longlong_t)num);
2571 				}
2572 
2573 				/*
2574 				 * Convert the numeric value into a local
2575 				 * string (stored in reverse order).
2576 				 */
2577 				_s = local;
2578 				do {
2579 					*_s++ = string[num % base];
2580 					num /= base;
2581 					ssize++;
2582 				} while (num);
2583 
2584 				ASSERT(ssize < sizeof (local));
2585 
2586 				/*
2587 				 * Provide any precision or width padding.
2588 				 */
2589 				if (prec) {
2590 					/* LINTED */
2591 					_n = (int)(prec - ssize);
2592 					while ((_n-- > 0) &&
2593 					    (ssize < sizeof (local))) {
2594 						*_s++ = '0';
2595 						ssize++;
2596 					}
2597 				}
2598 				if (width && !(flag & FLG_UT_MINUS)) {
2599 					/* LINTED */
2600 					_n = (int)(width - ssize - psize);
2601 					while (_n-- > 0) {
2602 						PUTC(' ');
2603 					}
2604 				}
2605 
2606 				/*
2607 				 * Print any prefix and the numeric string
2608 				 */
2609 				while (*prefix)
2610 					PUTC(*prefix++);
2611 				do {
2612 					PUTC(*--_s);
2613 				} while (_s > local);
2614 
2615 				/*
2616 				 * Provide any width padding.
2617 				 */
2618 				if (width && (flag & FLG_UT_MINUS)) {
2619 					/* LINTED */
2620 					_n = (int)(width - ssize - psize);
2621 					while (_n-- > 0)
2622 						PUTC(' ');
2623 				}
2624 			}
2625 		}
2626 	}
2627 
2628 	PUTC('\0');
2629 	prf->pr_cur = bp;
2630 	return (1);
2631 }
2632 
2633 static int
2634 doprintf(const char *format, va_list args, Prfbuf *prf)
2635 {
2636 	char	*ocur = prf->pr_cur;
2637 
2638 	if (doprf(format, args, prf) == 0)
2639 		return (0);
2640 	/* LINTED */
2641 	return ((int)(prf->pr_cur - ocur));
2642 }
2643 
2644 /* VARARGS2 */
2645 int
2646 sprintf(char *buf, const char *format, ...)
2647 {
2648 	va_list	args;
2649 	int	len;
2650 	Prfbuf	prf;
2651 
2652 	va_start(args, format);
2653 	prf.pr_buf = prf.pr_cur = buf;
2654 	prf.pr_len = 0;
2655 	prf.pr_fd = -1;
2656 	len = doprintf(format, args, &prf);
2657 	va_end(args);
2658 
2659 	/*
2660 	 * sprintf() return value excludes the terminating null byte.
2661 	 */
2662 	return (len - 1);
2663 }
2664 
2665 /* VARARGS3 */
2666 int
2667 snprintf(char *buf, size_t n, const char *format, ...)
2668 {
2669 	va_list	args;
2670 	int	len;
2671 	Prfbuf	prf;
2672 
2673 	va_start(args, format);
2674 	prf.pr_buf = prf.pr_cur = buf;
2675 	prf.pr_len = n;
2676 	prf.pr_fd = -1;
2677 	len = doprintf(format, args, &prf);
2678 	va_end(args);
2679 
2680 	return (len);
2681 }
2682 
2683 /* VARARGS2 */
2684 int
2685 bufprint(Prfbuf *prf, const char *format, ...)
2686 {
2687 	va_list	args;
2688 	int	len;
2689 
2690 	va_start(args, format);
2691 	len = doprintf(format, args, prf);
2692 	va_end(args);
2693 
2694 	return (len);
2695 }
2696 
2697 /*PRINTFLIKE1*/
2698 int
2699 printf(const char *format, ...)
2700 {
2701 	va_list	args;
2702 	char 	buffer[ERRSIZE];
2703 	Prfbuf	prf;
2704 
2705 	va_start(args, format);
2706 	prf.pr_buf = prf.pr_cur = buffer;
2707 	prf.pr_len = ERRSIZE;
2708 	prf.pr_fd = 1;
2709 	(void) doprf(format, args, &prf);
2710 	va_end(args);
2711 	/*
2712 	 * Trim trailing '\0' form buffer
2713 	 */
2714 	prf.pr_cur--;
2715 	return (dowrite(&prf));
2716 }
2717 
2718 static char	errbuf[ERRSIZE], *nextptr = errbuf, *prevptr = 0;
2719 
2720 /*PRINTFLIKE3*/
2721 void
2722 eprintf(Lm_list *lml, Error error, const char *format, ...)
2723 {
2724 	va_list		args;
2725 	int		overflow = 0;
2726 	static int	lock = 0;
2727 	Prfbuf		prf;
2728 
2729 	if (lock || (nextptr == (errbuf + ERRSIZE)))
2730 		return;
2731 
2732 	/*
2733 	 * Note: this lock is here to prevent the same thread from recursively
2734 	 * entering itself during a eprintf.  ie: during eprintf malloc() fails
2735 	 * and we try and call eprintf ... and then malloc() fails ....
2736 	 */
2737 	lock = 1;
2738 
2739 	/*
2740 	 * If we have completed startup initialization, all error messages
2741 	 * must be saved.  These are reported through dlerror().  If we're
2742 	 * still in the initialization stage, output the error directly and
2743 	 * add a newline.
2744 	 */
2745 	va_start(args, format);
2746 
2747 	prf.pr_buf = prf.pr_cur = nextptr;
2748 	prf.pr_len = ERRSIZE - (nextptr - errbuf);
2749 
2750 	if (!(rtld_flags & RT_FL_APPLIC))
2751 		prf.pr_fd = 2;
2752 	else
2753 		prf.pr_fd = -1;
2754 
2755 	if (error > ERR_NONE) {
2756 		if ((error == ERR_FATAL) && (rtld_flags2 & RT_FL2_FTL2WARN))
2757 			error = ERR_WARNING;
2758 		if (error == ERR_WARNING) {
2759 			if (err_strs[ERR_WARNING] == 0)
2760 				err_strs[ERR_WARNING] =
2761 				    MSG_INTL(MSG_ERR_WARNING);
2762 		} else if (error == ERR_FATAL) {
2763 			if (err_strs[ERR_FATAL] == 0)
2764 				err_strs[ERR_FATAL] = MSG_INTL(MSG_ERR_FATAL);
2765 		} else if (error == ERR_ELF) {
2766 			if (err_strs[ERR_ELF] == 0)
2767 				err_strs[ERR_ELF] = MSG_INTL(MSG_ERR_ELF);
2768 		}
2769 		if (procname) {
2770 			if (bufprint(&prf, MSG_ORIG(MSG_STR_EMSGFOR1),
2771 			    rtldname, procname, err_strs[error]) == 0)
2772 				overflow = 1;
2773 		} else {
2774 			if (bufprint(&prf, MSG_ORIG(MSG_STR_EMSGFOR2),
2775 			    rtldname, err_strs[error]) == 0)
2776 				overflow = 1;
2777 		}
2778 		if (overflow == 0) {
2779 			/*
2780 			 * Remove the terminating '\0'.
2781 			 */
2782 			prf.pr_cur--;
2783 		}
2784 	}
2785 
2786 	if ((overflow == 0) && doprf(format, args, &prf) == 0)
2787 		overflow = 1;
2788 
2789 	/*
2790 	 * If this is an ELF error, it will have been generated by a support
2791 	 * object that has a dependency on libelf.  ld.so.1 doesn't generate any
2792 	 * ELF error messages as it doesn't interact with libelf.  Determine the
2793 	 * ELF error string.
2794 	 */
2795 	if ((overflow == 0) && (error == ERR_ELF)) {
2796 		static int		(*elfeno)() = 0;
2797 		static const char	*(*elfemg)();
2798 		const char		*emsg;
2799 		Rt_map			*dlmp, *lmp = lml_rtld.lm_head;
2800 
2801 		if (NEXT(lmp) && (elfeno == 0)) {
2802 			if (((elfemg = (const char *(*)())dlsym_intn(RTLD_NEXT,
2803 			    MSG_ORIG(MSG_SYM_ELFERRMSG), lmp, &dlmp)) == 0) ||
2804 			    ((elfeno = (int (*)())dlsym_intn(RTLD_NEXT,
2805 			    MSG_ORIG(MSG_SYM_ELFERRNO), lmp, &dlmp)) == 0))
2806 				elfeno = 0;
2807 		}
2808 
2809 		/*
2810 		 * Lookup the message; equivalent to elf_errmsg(elf_errno()).
2811 		 */
2812 		if (elfeno && ((emsg = (* elfemg)((* elfeno)())) != 0)) {
2813 			prf.pr_cur--;
2814 			if (bufprint(&prf, MSG_ORIG(MSG_STR_EMSGFOR2),
2815 			    emsg) == 0)
2816 				overflow = 1;
2817 		}
2818 	}
2819 
2820 	/*
2821 	 * Push out any message that's been built.  Note, in the case of an
2822 	 * overflow condition, this message may be incomplete, in which case
2823 	 * make sure any partial string is null terminated.
2824 	 */
2825 	if (overflow)
2826 		*(prf.pr_cur) = '\0';
2827 	if ((rtld_flags & (RT_FL_APPLIC | RT_FL_SILENCERR)) == 0) {
2828 		*(prf.pr_cur - 1) = '\n';
2829 		(void) dowrite(&prf);
2830 	}
2831 
2832 	DBG_CALL(Dbg_util_str(lml, nextptr));
2833 	va_end(args);
2834 
2835 	/*
2836 	 * Determine if there was insufficient space left in the buffer to
2837 	 * complete the message.  If so, we'll have printed out as much as had
2838 	 * been processed if we're not yet executing the application.
2839 	 * Otherwise, there will be some debugging diagnostic indicating
2840 	 * as much of the error message as possible.  Write out a final buffer
2841 	 * overflow diagnostic - unlocalized, so we don't chance more errors.
2842 	 */
2843 	if (overflow) {
2844 		char	*str = (char *)MSG_INTL(MSG_EMG_BUFOVRFLW);
2845 
2846 		if ((rtld_flags & RT_FL_SILENCERR) == 0) {
2847 			lasterr = str;
2848 
2849 			if ((rtld_flags & RT_FL_APPLIC) == 0) {
2850 				(void) write(2, str, strlen(str));
2851 				(void) write(2, MSG_ORIG(MSG_STR_NL),
2852 				    MSG_STR_NL_SIZE);
2853 			}
2854 		}
2855 		DBG_CALL(Dbg_util_str(lml, str));
2856 
2857 		lock = 0;
2858 		nextptr = errbuf + ERRSIZE;
2859 		return;
2860 	}
2861 
2862 	/*
2863 	 * If the application has started, then error messages are being saved
2864 	 * for retrieval by dlerror(), or possible flushing from rtldexit() in
2865 	 * the case of a fatal error.  In this case, establish the next error
2866 	 * pointer.  If we haven't started the application, the whole message
2867 	 * buffer can be reused.
2868 	 */
2869 	if ((rtld_flags & RT_FL_SILENCERR) == 0) {
2870 		lasterr = nextptr;
2871 
2872 		/*
2873 		 * Note, should we encounter an error such as ENOMEM, there may
2874 		 * be a number of the same error messages (ie. an operation
2875 		 * fails with ENOMEM, and then the attempts to construct the
2876 		 * error message itself, which incurs additional ENOMEM errors).
2877 		 * Compare any previous error message with the one we've just
2878 		 * created to prevent any duplication clutter.
2879 		 */
2880 		if ((rtld_flags & RT_FL_APPLIC) &&
2881 		    ((prevptr == 0) || (strcmp(prevptr, nextptr) != 0))) {
2882 			prevptr = nextptr;
2883 			nextptr = prf.pr_cur;
2884 			*nextptr = '\0';
2885 		}
2886 	}
2887 	lock = 0;
2888 }
2889 
2890 
2891 #if	DEBUG
2892 /*
2893  * Provide assfail() for ASSERT() statements,
2894  * see <sys/debug.h> for further details.
2895  */
2896 int
2897 assfail(const char *a, const char *f, int l)
2898 {
2899 	(void) printf("assertion failed: %s, file: %s, line: %d\n", a, f, l);
2900 	(void) _lwp_kill(_lwp_self(), SIGABRT);
2901 	return (0);
2902 }
2903 #endif
2904 
2905 /*
2906  * Exit.  If we arrive here with a non zero status it's because of a fatal
2907  * error condition (most commonly a relocation error).  If the application has
2908  * already had control, then the actual fatal error message will have been
2909  * recorded in the dlerror() message buffer.  Print the message before really
2910  * exiting.
2911  */
2912 void
2913 rtldexit(Lm_list * lml, int status)
2914 {
2915 	if (status) {
2916 		if (rtld_flags & RT_FL_APPLIC) {
2917 			/*
2918 			 * If the error buffer has been used, write out all
2919 			 * pending messages - lasterr is simply a pointer to
2920 			 * the last message in this buffer.  However, if the
2921 			 * buffer couldn't be created at all, lasterr points
2922 			 * to a constant error message string.
2923 			 */
2924 			if (*errbuf) {
2925 				char	*errptr = errbuf;
2926 				char	*errend = errbuf + ERRSIZE;
2927 
2928 				while ((errptr < errend) && *errptr) {
2929 					size_t	size = strlen(errptr);
2930 					(void) write(2, errptr, size);
2931 					(void) write(2, MSG_ORIG(MSG_STR_NL),
2932 					    MSG_STR_NL_SIZE);
2933 					errptr += (size + 1);
2934 				}
2935 			}
2936 			if (lasterr && ((lasterr < errbuf) ||
2937 			    (lasterr > (errbuf + ERRSIZE)))) {
2938 				(void) write(2, lasterr, strlen(lasterr));
2939 				(void) write(2, MSG_ORIG(MSG_STR_NL),
2940 				    MSG_STR_NL_SIZE);
2941 			}
2942 		}
2943 		leave(lml);
2944 		(void) _lwp_kill(_lwp_self(), killsig);
2945 	}
2946 	_exit(status);
2947 }
2948 
2949 /*
2950  * Routines to co-ordinate the opening of /dev/zero and /proc.
2951  * dz_fd is exported for possible use by libld.so, and to insure it gets
2952  * closed on leaving ld.so.1.
2953  */
2954 int	dz_fd = FD_UNAVAIL;
2955 
2956 void
2957 dz_init(int fd)
2958 {
2959 	dz_fd = fd;
2960 }
2961 
2962 
2963 /*
2964  * mmap() a page from MAP_ANON
2965  *
2966  * Note: MAP_ANON is only on Solaris8++, we use this routine to
2967  *       not only mmap(MAP_ANON) but to also probe if it is available
2968  *	 on the current OS.
2969  */
2970 Am_ret
2971 anon_map(Lm_list *lml, caddr_t *addr, size_t len, int prot, int flags)
2972 {
2973 #if defined(MAP_ANON)
2974 	static int	noanon = 0;
2975 	caddr_t		va;
2976 
2977 	if (noanon == 0) {
2978 		if ((va = (caddr_t)mmap(*addr, len, prot,
2979 		    (flags | MAP_ANON), -1, 0)) != MAP_FAILED) {
2980 			*addr = va;
2981 			return (AM_OK);
2982 		}
2983 
2984 		if ((errno != EBADF) && (errno != EINVAL)) {
2985 			int	err = errno;
2986 			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_MMAPANON),
2987 			    MSG_ORIG(MSG_PTH_DEVZERO), strerror(err));
2988 			return (AM_ERROR);
2989 		} else
2990 			noanon = 1;
2991 	}
2992 #endif
2993 	return (AM_NOSUP);
2994 }
2995 
2996 /*
2997  * Map anonymous memory from /dev/zero, or via MAP_ANON.
2998  *
2999  * (MAP_ANON only appears on Solaris 8, so we need fall-back
3000  * behavior for older systems.)
3001  */
3002 caddr_t
3003 dz_map(Lm_list *lml, caddr_t addr, size_t len, int prot, int flags)
3004 {
3005 	caddr_t	va;
3006 	int	err;
3007 	Am_ret	amret;
3008 
3009 	amret = anon_map(lml, &addr, len, prot, flags);
3010 
3011 	if (amret == AM_OK)
3012 		return (addr);
3013 	if (amret == AM_ERROR)
3014 		return (MAP_FAILED);
3015 
3016 	/* amret == AM_NOSUP -> fallback to a devzero mmaping */
3017 
3018 	if (dz_fd == FD_UNAVAIL) {
3019 		if ((dz_fd = open(MSG_ORIG(MSG_PTH_DEVZERO),
3020 		    O_RDONLY)) == FD_UNAVAIL) {
3021 			err = errno;
3022 			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN),
3023 			    MSG_ORIG(MSG_PTH_DEVZERO), strerror(err));
3024 			return (MAP_FAILED);
3025 		}
3026 	}
3027 
3028 	if ((va = mmap(addr, len, prot, flags, dz_fd, 0)) == MAP_FAILED) {
3029 		err = errno;
3030 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_MMAP),
3031 		    MSG_ORIG(MSG_PTH_DEVZERO), strerror(err));
3032 	}
3033 	return (va);
3034 }
3035 
3036 static int	pr_fd = FD_UNAVAIL;
3037 
3038 int
3039 pr_open(Lm_list *lml)
3040 {
3041 	char	proc[16];
3042 
3043 	if (pr_fd == FD_UNAVAIL) {
3044 		(void) snprintf(proc, 16, MSG_ORIG(MSG_FMT_PROC),
3045 		    (int)getpid());
3046 		if ((pr_fd = open(proc, O_RDONLY)) == FD_UNAVAIL) {
3047 			int	err = errno;
3048 
3049 			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN), proc,
3050 			    strerror(err));
3051 		}
3052 	}
3053 	return (pr_fd);
3054 }
3055 
3056 static int	nu_fd = FD_UNAVAIL;
3057 
3058 caddr_t
3059 nu_map(Lm_list *lml, caddr_t addr, size_t len, int prot, int flags)
3060 {
3061 	caddr_t	va;
3062 	int	err;
3063 
3064 	if (nu_fd == FD_UNAVAIL) {
3065 		if ((nu_fd = open(MSG_ORIG(MSG_PTH_DEVNULL),
3066 		    O_RDONLY)) == FD_UNAVAIL) {
3067 			err = errno;
3068 			eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN),
3069 			    MSG_ORIG(MSG_PTH_DEVNULL), strerror(err));
3070 			return (MAP_FAILED);
3071 		}
3072 	}
3073 
3074 	if ((va = (caddr_t)mmap(addr, len, prot, flags, nu_fd, 0)) ==
3075 	    MAP_FAILED) {
3076 		err = errno;
3077 		eprintf(lml, ERR_FATAL, MSG_INTL(MSG_SYS_MMAP),
3078 		    MSG_ORIG(MSG_PTH_DEVNULL), strerror(err));
3079 	}
3080 	return (va);
3081 }
3082 
3083 /*
3084  * Generic entry point from user code - simply grabs a lock, and bumps the
3085  * entrance count.
3086  */
3087 int
3088 enter(void)
3089 {
3090 	if (rt_bind_guard(THR_FLG_RTLD)) {
3091 		(void) rt_mutex_lock(&rtldlock);
3092 		ld_entry_cnt++;
3093 		return (1);
3094 	}
3095 	return (0);
3096 }
3097 
3098 /*
3099  * Generate diagnostics as to whether an object has been used.  A symbolic
3100  * reference that gets bound to an object marks it as used.  Dependencies that
3101  * are unused when RTLD_NOW is in effect should be removed from future builds
3102  * of an object.  Dependencies that are unused without RTLD_NOW in effect are
3103  * candidates for lazy-loading.
3104  * Unreferenced objects identify objects that are defined as dependencies but
3105  * are unreferenced by the caller (they may however be referenced by other
3106  * objects within the process, and therefore don't qualify as completely unused.
3107  */
3108 void
3109 unused(Lm_list *lml)
3110 {
3111 	Rt_map		*lmp;
3112 	int		nl = 0;
3113 	Word		tracing;
3114 
3115 	/*
3116 	 * If we're not tracing unused references or dependencies, or debugging
3117 	 * there's nothing to do.
3118 	 */
3119 	tracing = lml->lm_flags & (LML_FLG_TRC_UNREF | LML_FLG_TRC_UNUSED);
3120 
3121 	if ((tracing == 0) && (DBG_ENABLED == 0))
3122 		return;
3123 
3124 	/*
3125 	 * Traverse the link-maps looking for unreferenced or unused
3126 	 * dependencies.  Ignore the first object on a link-map list, as this
3127 	 * is effectively always used.
3128 	 */
3129 	for (lmp = (Rt_map *)NEXT(lml->lm_head); lmp;
3130 	    lmp = (Rt_map *)NEXT(lmp)) {
3131 		/*
3132 		 * If tracing unreferenced objects, or under debugging,
3133 		 * determine whether any of this objects callers haven't
3134 		 * referenced it.
3135 		 */
3136 		if ((tracing & LML_FLG_TRC_UNREF) || DBG_ENABLED) {
3137 			Bnd_desc	*bdp;
3138 			Aliste		idx;
3139 
3140 			for (APLIST_TRAVERSE(CALLERS(lmp), idx, bdp)) {
3141 				Rt_map *	clmp;
3142 
3143 				if (bdp->b_flags & BND_REFER)
3144 					continue;
3145 
3146 				clmp = bdp->b_caller;
3147 				if (FLAGS1(clmp) & FL1_RT_LDDSTUB)
3148 					continue;
3149 
3150 				/* BEGIN CSTYLED */
3151 				if (nl++ == 0) {
3152 					if (tracing & LML_FLG_TRC_UNREF)
3153 					    (void) printf(MSG_ORIG(MSG_STR_NL));
3154 					else
3155 					    DBG_CALL(Dbg_util_nl(lml,
3156 						DBG_NL_STD));
3157 				}
3158 
3159 				if (tracing & LML_FLG_TRC_UNREF)
3160 				    (void) printf(MSG_INTL(MSG_LDD_UNREF_FMT),
3161 					NAME(lmp), NAME(clmp));
3162 				else
3163 				    DBG_CALL(Dbg_unused_unref(lmp, NAME(clmp)));
3164 				/* END CSTYLED */
3165 			}
3166 		}
3167 
3168 		/*
3169 		 * If tracing unused objects simply display those objects that
3170 		 * haven't been referenced by anyone.
3171 		 */
3172 		if (FLAGS1(lmp) & FL1_RT_USED)
3173 			continue;
3174 
3175 		if (nl++ == 0) {
3176 			if (tracing)
3177 				(void) printf(MSG_ORIG(MSG_STR_NL));
3178 			else
3179 				DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD));
3180 		}
3181 		if (CYCGROUP(lmp)) {
3182 			if (tracing)
3183 				(void) printf(MSG_INTL(MSG_LDD_UNCYC_FMT),
3184 				    NAME(lmp), CYCGROUP(lmp));
3185 			else
3186 				DBG_CALL(Dbg_unused_file(lml, NAME(lmp), 0,
3187 				    CYCGROUP(lmp)));
3188 		} else {
3189 			if (tracing)
3190 				(void) printf(MSG_INTL(MSG_LDD_UNUSED_FMT),
3191 				    NAME(lmp));
3192 			else
3193 				DBG_CALL(Dbg_unused_file(lml, NAME(lmp), 0, 0));
3194 		}
3195 	}
3196 
3197 	DBG_CALL(Dbg_util_nl(lml, DBG_NL_STD));
3198 }
3199 
3200 /*
3201  * Initialization routine for the Fmap structure.  If the fmap structure is
3202  * already in use, any mapping is released.  The structure is then initialized
3203  * in preparation for further use.
3204  */
3205 void
3206 fmap_setup()
3207 {
3208 #if defined(MAP_ALIGN)
3209 	/*
3210 	 * If MAP_ALIGN is set, the fm_addr has been seeded with an alignment
3211 	 * value.  Otherwise, if fm_addr is non-null it indicates a mapping that
3212 	 * should now be freed.
3213 	 */
3214 	if (fmap->fm_maddr && ((fmap->fm_mflags & MAP_ALIGN) == 0))
3215 		(void) munmap((caddr_t)fmap->fm_maddr, fmap->fm_msize);
3216 
3217 	/*
3218 	 * Providing we haven't determined that this system doesn't support
3219 	 * MAP_ALIGN, initialize the mapping address with the default segment
3220 	 * alignment.
3221 	 */
3222 	if ((rtld_flags2 & RT_FL2_NOMALIGN) == 0) {
3223 		fmap->fm_maddr = (char *)M_SEGM_ALIGN;
3224 		fmap->fm_mflags = MAP_PRIVATE | MAP_ALIGN;
3225 	} else {
3226 		fmap->fm_maddr = 0;
3227 		fmap->fm_mflags = MAP_PRIVATE;
3228 	}
3229 #else
3230 	if (fmap->fm_maddr)
3231 		(void) munmap((caddr_t)fmap->fm_maddr, fmap->fm_msize);
3232 
3233 	fmap->fm_maddr = 0;
3234 	fmap->fm_mflags = MAP_PRIVATE;
3235 #endif
3236 
3237 	fmap->fm_msize = FMAP_SIZE;
3238 	fmap->fm_hwptr = 0;
3239 }
3240 
3241 /*
3242  * Generic cleanup routine called prior to returning control to the user.
3243  * Insures that any ld.so.1 specific file descriptors or temporary mapping are
3244  * released, and any locks dropped.
3245  */
3246 void
3247 leave(Lm_list *lml)
3248 {
3249 	Lm_list	*elml = lml;
3250 	Rt_map	*clmp;
3251 	Aliste	idx;
3252 
3253 	/*
3254 	 * Alert the debuggers that the link-maps are consistent.  Note, in the
3255 	 * case of tearing down a whole link-map list, lml will be null.  In
3256 	 * this case use the main link-map list to test for a notification.
3257 	 */
3258 	if (elml == 0)
3259 		elml = &lml_main;
3260 	if (elml->lm_flags & LML_FLG_DBNOTIF)
3261 		rd_event(elml, RD_DLACTIVITY, RT_CONSISTENT);
3262 
3263 	/*
3264 	 * Alert any auditors that the link-maps are consistent.
3265 	 */
3266 	for (APLIST_TRAVERSE(elml->lm_actaudit, idx, clmp)) {
3267 		audit_activity(clmp, LA_ACT_CONSISTENT);
3268 
3269 		aplist_delete(elml->lm_actaudit, &idx);
3270 	}
3271 
3272 	if (dz_fd != FD_UNAVAIL) {
3273 		(void) close(dz_fd);
3274 		dz_fd = FD_UNAVAIL;
3275 	}
3276 
3277 	if (pr_fd != FD_UNAVAIL) {
3278 		(void) close(pr_fd);
3279 		pr_fd = FD_UNAVAIL;
3280 	}
3281 
3282 	if (nu_fd != FD_UNAVAIL) {
3283 		(void) close(nu_fd);
3284 		nu_fd = FD_UNAVAIL;
3285 	}
3286 
3287 	fmap_setup();
3288 
3289 	/*
3290 	 * Reinitialize error message pointer, and any overflow indication.
3291 	 */
3292 	nextptr = errbuf;
3293 	prevptr = 0;
3294 
3295 	/*
3296 	 * Don't drop our lock if we are running on our link-map list as
3297 	 * there's little point in doing so since we are single-threaded.
3298 	 *
3299 	 * LML_FLG_HOLDLOCK is set for:
3300 	 *	*) The ld.so.1's link-map list.
3301 	 *	*) The auditor's link-map if the environment is
3302 	 *	   libc/libthread un-unified.
3303 	 */
3304 	if (lml && (lml->lm_flags & LML_FLG_HOLDLOCK))
3305 		return;
3306 
3307 	if (rt_bind_clear(0) & THR_FLG_RTLD) {
3308 		(void) rt_mutex_unlock(&rtldlock);
3309 		(void) rt_bind_clear(THR_FLG_RTLD);
3310 	}
3311 }
3312 
3313 int
3314 callable(Rt_map *clmp, Rt_map *dlmp, Grp_hdl *ghp, uint_t slflags)
3315 {
3316 	APlist		*calp, *dalp;
3317 	Aliste		idx1, idx2;
3318 	Grp_hdl		*ghp1, *ghp2;
3319 
3320 	/*
3321 	 * An object can always find symbols within itself.
3322 	 */
3323 	if (clmp == dlmp)
3324 		return (1);
3325 
3326 	/*
3327 	 * The search for a singleton must look in every loaded object.
3328 	 */
3329 	if (slflags & LKUP_SINGLETON)
3330 		return (1);
3331 
3332 	/*
3333 	 * Don't allow an object to bind to an object that is being deleted
3334 	 * unless the binder is also being deleted.
3335 	 */
3336 	if ((FLAGS(dlmp) & FLG_RT_DELETE) &&
3337 	    ((FLAGS(clmp) & FLG_RT_DELETE) == 0))
3338 		return (0);
3339 
3340 	/*
3341 	 * An object with world access can always bind to an object with global
3342 	 * visibility.
3343 	 */
3344 	if ((MODE(clmp) & RTLD_WORLD) && (MODE(dlmp) & RTLD_GLOBAL))
3345 		return (1);
3346 
3347 	/*
3348 	 * An object with local access can only bind to an object that is a
3349 	 * member of the same group.
3350 	 */
3351 	if (((MODE(clmp) & RTLD_GROUP) == 0) ||
3352 	    ((calp = GROUPS(clmp)) == NULL) || ((dalp = GROUPS(dlmp)) == NULL))
3353 		return (0);
3354 
3355 	/*
3356 	 * Traverse the list of groups the caller is a part of.
3357 	 */
3358 	for (APLIST_TRAVERSE(calp, idx1, ghp1)) {
3359 		/*
3360 		 * If we're testing for the ability of two objects to bind to
3361 		 * each other regardless of a specific group, ignore that group.
3362 		 */
3363 		if (ghp && (ghp1 == ghp))
3364 			continue;
3365 
3366 		/*
3367 		 * Traverse the list of groups the destination is a part of.
3368 		 */
3369 		for (APLIST_TRAVERSE(dalp, idx2, ghp2)) {
3370 			Grp_desc	*gdp;
3371 			Aliste		idx3;
3372 
3373 			if (ghp1 != ghp2)
3374 				continue;
3375 
3376 			/*
3377 			 * Make sure the relationship between the destination
3378 			 * and the caller provide symbols for relocation.
3379 			 * Parents are maintained as callers, but unless the
3380 			 * destination object was opened with RTLD_PARENT, the
3381 			 * parent doesn't provide symbols for the destination
3382 			 * to relocate against.
3383 			 */
3384 			for (ALIST_TRAVERSE(ghp2->gh_depends, idx3, gdp)) {
3385 				if (dlmp != gdp->gd_depend)
3386 					continue;
3387 
3388 				if (gdp->gd_flags & GPD_RELOC)
3389 					return (1);
3390 			}
3391 		}
3392 	}
3393 	return (0);
3394 }
3395 
3396 /*
3397  * Initialize the environ symbol.  Traditionally this is carried out by the crt
3398  * code prior to jumping to main.  However, init sections get fired before this
3399  * variable is initialized, so ld.so.1 sets this directly from the AUX vector
3400  * information.  In addition, a process may have multiple link-maps (ld.so.1's
3401  * debugging and preloading objects), and link auditing, and each may need an
3402  * environ variable set.
3403  *
3404  * This routine is called after a relocation() pass, and thus provides for:
3405  *
3406  *  o	setting environ on the main link-map after the initial application and
3407  *	its dependencies have been established.  Typically environ lives in the
3408  *	application (provided by its crt), but in older applications it might
3409  *	be in libc.  Who knows what's expected of applications not built on
3410  *	Solaris.
3411  *
3412  *  o	after loading a new shared object.  We can add shared objects to various
3413  *	link-maps, and any link-map dependencies requiring getopt() require
3414  *	their own environ.  In addition, lazy loading might bring in the
3415  *	supplier of environ (libc used to be a lazy loading candidate) after
3416  *	the link-map has been established and other objects are present.
3417  *
3418  * This routine handles all these scenarios, without adding unnecessary overhead
3419  * to ld.so.1.
3420  */
3421 void
3422 set_environ(Lm_list *lml)
3423 {
3424 	Rt_map		*dlmp;
3425 	Sym		*sym;
3426 	Slookup		sl;
3427 	uint_t		binfo;
3428 
3429 	/*
3430 	 * Initialize the symbol lookup data structure.
3431 	 */
3432 	SLOOKUP_INIT(sl, MSG_ORIG(MSG_SYM_ENVIRON), lml->lm_head, lml->lm_head,
3433 	    ld_entry_cnt, 0, 0, 0, 0, LKUP_WEAK);
3434 
3435 	if (sym = LM_LOOKUP_SYM(lml->lm_head)(&sl, &dlmp, &binfo)) {
3436 		lml->lm_environ = (char ***)sym->st_value;
3437 
3438 		if (!(FLAGS(dlmp) & FLG_RT_FIXED))
3439 			lml->lm_environ =
3440 			    (char ***)((uintptr_t)lml->lm_environ +
3441 			    (uintptr_t)ADDR(dlmp));
3442 		*(lml->lm_environ) = (char **)environ;
3443 		lml->lm_flags |= LML_FLG_ENVIRON;
3444 	}
3445 }
3446 
3447 /*
3448  * Determine whether we have a secure executable.  Uid and gid information
3449  * can be passed to us via the aux vector, however if these values are -1
3450  * then use the appropriate system call to obtain them.
3451  *
3452  *  o	If the user is the root they can do anything
3453  *
3454  *  o	If the real and effective uid's don't match, or the real and
3455  *	effective gid's don't match then this is determined to be a `secure'
3456  *	application.
3457  *
3458  * This function is called prior to any dependency processing (see _setup.c).
3459  * Any secure setting will remain in effect for the life of the process.
3460  */
3461 void
3462 security(uid_t uid, uid_t euid, gid_t gid, gid_t egid, int auxflags)
3463 {
3464 #ifdef AT_SUN_AUXFLAGS
3465 	if (auxflags != -1) {
3466 		if ((auxflags & AF_SUN_SETUGID) != 0)
3467 			rtld_flags |= RT_FL_SECURE;
3468 		return;
3469 	}
3470 #endif
3471 	if (uid == (uid_t)-1)
3472 		uid = getuid();
3473 	if (uid) {
3474 		if (euid == (uid_t)-1)
3475 			euid = geteuid();
3476 		if (uid != euid)
3477 			rtld_flags |= RT_FL_SECURE;
3478 		else {
3479 			if (gid == (gid_t)-1)
3480 				gid = getgid();
3481 			if (egid == (gid_t)-1)
3482 				egid = getegid();
3483 			if (gid != egid)
3484 				rtld_flags |= RT_FL_SECURE;
3485 		}
3486 	}
3487 }
3488 
3489 /*
3490  * _REENTRANT code gets errno redefined to a function so provide for return
3491  * of the thread errno if applicable.  This has no meaning in ld.so.1 which
3492  * is basically singled threaded.  Provide the interface for our dependencies.
3493  */
3494 #undef errno
3495 #pragma weak _private___errno = ___errno
3496 int *
3497 ___errno()
3498 {
3499 	extern	int	errno;
3500 
3501 	return (&errno);
3502 }
3503 
3504 /*
3505  * The interface with the c library which is supplied through libdl.so.1.
3506  * A non-null argument allows a function pointer array to be passed to us which
3507  * is used to re-initialize the linker libc table.
3508  */
3509 void
3510 _ld_libc(void * ptr)
3511 {
3512 	get_lcinterface(_caller(caller(), CL_EXECDEF), (Lc_interface *)ptr);
3513 }
3514 
3515 /*
3516  * Determine whether a symbol name should be demangled.
3517  */
3518 const char *
3519 demangle(const char *name)
3520 {
3521 	if (rtld_flags & RT_FL_DEMANGLE)
3522 		return (conv_demangle_name(name));
3523 	else
3524 		return (name);
3525 }
3526