rtld/common/config_elf.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include	<sys/mman.h>
#include	<sys/types.h>
#include	<sys/stat.h>
#include	<fcntl.h>
#include	<limits.h>
#include	<stdio.h>
#include	<string.h>
#include	<rtc.h>
#include	<debug.h>
#include	<conv.h>
#include	"_rtld.h"
#include	"msg.h"

static Config	_config = { 0 };
Config		*config = &_config;

/*
 * Validate a configuration file.
 */
static void
elf_config_validate(Addr addr, Rtc_head *head, Rt_map *lmp)
{
	Lm_list		*lml = LIST(lmp);
	const char	*str, *strtbl = config->c_strtbl;
	Rtc_obj		*obj;
	Rtc_dir		*dirtbl;
	Rtc_file	*filetbl;
	rtld_stat_t	status;
	int		err;

	/*
	 * If this configuration file is for a specific application make sure
	 * we've been invoked by the application.  Note that we only check the
	 * basename component of the application as the original application
	 * and its cached equivalent are never going to have the same pathnames.
	 * Also, we use PATHNAME() and not NAME() - this catches things like vi
	 * that exec shells using execv(/usr/bin/ksh, sh ...).
	 */
	if (head->ch_app) {
		char		*_str, *_cname, *cname;
		const char	*aname = PATHNAME(lmp);

		obj = (Rtc_obj *)(head->ch_app + addr);
		cname = _cname = (char *)(strtbl + obj->co_name);

		if ((_str = strrchr(aname, '/')) != NULL)
			aname = ++_str;
		if ((_str = strrchr(cname, '/')) != NULL)
			cname = ++_str;

		if (strcmp(aname, cname)) {
			/*
			 * It's possible a user is trying to ldd(1) an alternate
			 * shared object and point to a configuration file that
			 * the shared object is part of.  In this case ignore
			 * any mismatch name warnings.
			 */
			if ((lml->lm_flags & LML_FLG_TRC_ENABLE) &&
			    ((FLAGS1(lmp) & FL1_RT_LDDSTUB) == 0)) {
				eprintf(lml, ERR_WARNING,
				    MSG_INTL(MSG_CONF_APP), config->c_name,
				    _cname);
				return;
			}
		}

		/*
		 * If we have a valid alternative application reset its original
		 * name for possible $ORIGIN processing.
		 */
		if ((FLAGS1(lmp) & FL1_RT_LDDSTUB) == 0) {
			ORIGNAME(lmp) = _cname;
			DIRSZ(lmp) = cname - _cname - 1;
		}
	}

	/*
	 * If alternative objects are specified traverse the directories
	 * specified in the configuration file, if any directory is newer than
	 * the time it was recorded in the cache then continue to inspect its
	 * files.  Any file determined newer than its configuration recording
	 * questions the the use of any alternative objects.  The intent here
	 * is to make sure no-one abuses a configuration as a means of static
	 * linking.
	 */
	for (dirtbl = (Rtc_dir *)(head->ch_dir + addr);
	    dirtbl->cd_obj; dirtbl++) {
		/*
		 * Skip directories that provide no files - this also catches
		 * RTC_OBJ_NOEXIST directories.
		 */
		filetbl = (Rtc_file *)(dirtbl->cd_file + addr);
		if (filetbl->cf_obj == 0)
			continue;

		/*
		 * Skip directories that haven't provided real, dumped files.
		 */
		obj = (Rtc_obj *)(dirtbl->cd_obj + addr);
		if ((obj->co_flags & (RTC_OBJ_DUMP | RTC_OBJ_REALPTH)) !=
		    (RTC_OBJ_DUMP | RTC_OBJ_REALPTH))
			continue;

		str = strtbl + obj->co_name;

		if (rtld_stat(str, &status) != 0) {
			err = errno;
			eprintf(lml, ERR_WARNING, MSG_INTL(MSG_CONF_DSTAT),
			    config->c_name, str, strerror(err));
			continue;
		}

		if (status.st_mtime == obj->co_info)
			continue;

		/*
		 * The system directory is newer than the configuration files
		 * entry, start checking any dumped files.
		 */
		for (; filetbl->cf_obj; filetbl++) {
			obj = (Rtc_obj *)(filetbl->cf_obj + addr);
			str = strtbl + obj->co_name;

			/*
			 * Skip any files that aren't real, dumped files.
			 */
			if ((obj->co_flags &
			    (RTC_OBJ_DUMP | RTC_OBJ_REALPTH)) !=
			    (RTC_OBJ_DUMP | RTC_OBJ_REALPTH))
				continue;

			if (rtld_stat(str, &status) != 0) {
				err = errno;
				eprintf(lml, ERR_WARNING,
				    MSG_INTL(MSG_CONF_FSTAT), config->c_name,
				    str, strerror(err));
				continue;
			}

			/*
			 * If the files size is different somethings been
			 * changed.
			 */
			if (status.st_size != obj->co_info) {
				eprintf(lml, ERR_WARNING,
				    MSG_INTL(MSG_CONF_FCMP), config->c_name,
				    str);
			}
		}
	}
}

/*
 * Process a configuration file.
 *
 * A configuration file can be specified using the LD_CONFIG environment
 * variable, from a DT_CONFIG string recorded in the executable (see ld(1) -c),
 * or in the case of a crle(1) dumped image, the file is "fabricated" to a
 * configuration file that may have been associated with the dumped image.  In
 * the absence of any of these techniques, a default configuration file is used.
 *
 * The LD_CONFIG variable takes precedence, unless the application is secure
 * (see ld.so.1(1), issetugid(2)), in which case the environment variable is
 * ignored (see ld_generic_env()).
 *
 * A DT_CONFIG string is honored, even if the application is secure.  However,
 * the path name follows the same rules as RUNPATH's, which must be a full path
 * name with no use of $ORIGIN.
 */
int
elf_config(Rt_map *lmp)
{
	Rtc_id		*id;
	Rtc_head	*head;
	int		fd, features = 0;
	rtld_stat_t	status;
	Addr		addr;
	const char	*str;
	char		path[PATH_MAX];

	/*
	 * If we're dealing with an alternative application, fabricate the need
	 * for a $ORIGIN/ld.config.app-name configuration file.
	 */
	if (rtld_flags & RT_FL_CONFAPP) {
		if ((str = strrchr(PATHNAME(lmp), '/')) != NULL)
			str++;
		else
			str = PATHNAME(lmp);

		(void) snprintf(path, PATH_MAX, MSG_ORIG(MSG_ORG_CONFIG), str);
		str = path;
	} else
		str = config->c_name;

	/*
	 * If a configuration file name is known, expand and verify the name.
	 */
	if (str) {
		size_t	size = strlen(str);
		char	*estr = (char *)str;
		uint_t	tkns;

		/*
		 * Expand any configuration string.
		 */
		if ((tkns = expand(&estr, &size, 0, 0,
		    (PD_TKN_ISALIST | PD_TKN_CAP), lmp)) == 0)
			return (0);

		/*
		 * If this is a secure application, validate the configuration
		 * file path name.  Ignore any untrustworthy path name, and
		 * fall through to pick up the defaults.
		 */
		if ((rtld_flags & RT_FL_SECURE) &&
		    (is_path_secure(estr, lmp, PD_FLG_FULLPATH, tkns) == 0))
			str = NULL;
		else
			str = (const char *)estr;
	}

	/*
	 * If a configuration file has not been specified try opening up the
	 * default.
	 */
	if (str == NULL) {
#if	defined(_ELF64)
		str = MSG_ORIG(MSG_PTH_CONFIG_64);
#else
		str = MSG_ORIG(MSG_PTH_CONFIG);
#endif
	}
	config->c_name = str;

	/*
	 * If we can't open the configuration file return silently.
	 */
	if ((fd = open(str, O_RDONLY, 0)) == -1)
		return (DBG_CONF_PRCFAIL);

	/*
	 * Determine the configuration file size and map the file.
	 */
	(void) rtld_fstat(fd, &status);
	if (status.st_size < sizeof (Rtc_head)) {
		(void) close(fd);
		return (DBG_CONF_CORRUPT);
	}
	if ((addr = (Addr)mmap(0, status.st_size, PROT_READ, MAP_SHARED,
	    fd, 0)) == (Addr)MAP_FAILED) {
		(void) close(fd);
		return (DBG_CONF_PRCFAIL);
	}
	(void) close(fd);

	/*
	 * If we have an Rtc_id block at the beginning, then validate it
	 * and advance the address to the Rtc_head. If not, then trust
	 * that the file is compatible with us and move ahead (there is
	 * some error checking for Rtc_head below as well).
	 */
	id = (Rtc_id *) addr;
	if (RTC_ID_TEST(id)) {
		addr += sizeof (*id);
		status.st_size -= sizeof (*id);
		if (status.st_size < sizeof (Rtc_head))
			return (DBG_CONF_CORRUPT);
		if ((id->id_class != M_CLASS) || (id->id_data != M_DATA) ||
		    (id->id_machine != M_MACH))
			return (DBG_CONF_ABIMISMATCH);
	}

	config->c_bgn = addr;
	config->c_end = addr + status.st_size;

	head = (Rtc_head *)addr;

	/*
	 * Make sure we can handle this version of the configuration file.
	 */
	if (head->ch_version > RTC_VER_CURRENT)
		return (DBG_CONF_VERSION);

	/*
	 * When crle(1) creates a temporary configuration file the
	 * RTC_HDR_IGNORE flag is set.  Thus the mapping of the configuration
	 * file is taken into account but not its content.
	 */
	if (head->ch_cnflags & RTC_HDR_IGNORE)
		return (DBG_CONF_IGNORE);

	/*
	 * Apply any new default library pathname.
	 */
	if (head->ch_edlibpath) {
		str = (const char *)(head->ch_edlibpath + addr);
		if ((head->ch_cnflags & RTC_HDR_UPM) == 0) {
#if	defined(_ELF64)
			str = conv_config_upm(str, MSG_ORIG(MSG_PTH_USRLIB_64),
			    MSG_ORIG(MSG_PTH_LIB_64), MSG_PTH_LIB_64_SIZE);
#else
			str = conv_config_upm(str, MSG_ORIG(MSG_PTH_USRLIB),
			    MSG_ORIG(MSG_PTH_LIB), MSG_PTH_LIB_SIZE);
#endif
		}
		if (expand_paths(lmp, str, &elf_def_dirs, AL_CNT_SEARCH,
		    (LA_SER_DEFAULT | LA_SER_CONFIG), PD_TKN_CAP) != 0)
			features |= CONF_EDLIBPATH;
	}
	if (head->ch_eslibpath) {
		str = (const char *)(head->ch_eslibpath + addr);
		if ((head->ch_cnflags & RTC_HDR_UPM) == 0) {
#if	defined(_ELF64)
			str = conv_config_upm(str,
			    MSG_ORIG(MSG_PTH_USRLIBSE_64),
			    MSG_ORIG(MSG_PTH_LIBSE_64), MSG_PTH_LIBSE_64_SIZE);
#else
			str = conv_config_upm(str, MSG_ORIG(MSG_PTH_USRLIBSE),
			    MSG_ORIG(MSG_PTH_LIBSE), MSG_PTH_LIBSE_SIZE);
#endif
		}
		if (expand_paths(lmp, str, &elf_sec_dirs, AL_CNT_SEARCH,
		    (LA_SER_SECURE | LA_SER_CONFIG), PD_TKN_CAP) != 0)
			features |= CONF_ESLIBPATH;
	}

	/*
	 * Apply any environment variables.  This attribute was added with
	 * RTC_VER_THREE.
	 */
	if ((head->ch_version >= RTC_VER_THREE) && head->ch_env &&
	    (!(rtld_flags & RT_FL_NOENVCFG))) {
		if (readenv_config((Rtc_env *)(head->ch_env + addr),
		    addr) != 0)
			return (-1);
		features |= CONF_ENVS;
	}

	/*
	 * Determine whether filter/filtee associations are available.
	 */
	if ((head->ch_version >= RTC_VER_FOUR) && head->ch_fltr &&
	    (!(rtld_flags2 & RT_FL2_NOFLTCFG))) {
		rtld_flags2 |= RT_FL2_FLTCFG;
		config->c_fltr = (Rtc_fltr *)(head->ch_fltr + addr);
		config->c_flte = (Rtc_flte *)(head->ch_flte + addr);
		features |= CONF_FLTR;
	}

	/*
	 * Determine whether directory configuration is available.
	 */
	if ((!(rtld_flags & RT_FL_NODIRCFG)) && head->ch_hash) {
		config->c_hashtbl = (Word *)(head->ch_hash + addr);
		config->c_hashchain = &config->c_hashtbl[2 +
		    config->c_hashtbl[0]];
		config->c_objtbl = (Rtc_obj *)(head->ch_obj + addr);
		config->c_strtbl = (const char *)(head->ch_str + addr);

		rtld_flags |= RT_FL_DIRCFG;
		features |= CONF_DIRCFG;
	}

	/*
	 * Determine whether alternative objects are specified or an object
	 * reservation area is required.  If the reservation can't be completed
	 * (either because the configuration information is out-of-date, or the
	 * the reservation can't be allocated), then alternative objects are
	 * ignored.
	 */
	if ((!(rtld_flags & (RT_FL_NODIRCFG | RT_FL_NOOBJALT))) &&
	    (head->ch_cnflags & RTC_HDR_ALTER)) {
		rtld_flags |= RT_FL_OBJALT;
		features |= CONF_OBJALT;

		elf_config_validate(addr, head, lmp);

		if (head->ch_resbgn) {

			if (((config->c_bgn <= head->ch_resbgn) &&
			    (config->c_bgn >= head->ch_resend)) ||
			    (nu_map(LIST(lmp),
			    (caddr_t)(uintptr_t)head->ch_resbgn,
			    (head->ch_resend - head->ch_resbgn), PROT_NONE,
			    MAP_FIXED | MAP_PRIVATE) == MAP_FAILED))
				return (-1);

			rtld_flags |= RT_FL_MEMRESV;
			features |= CONF_MEMRESV;
		}
	}

	return (features);
}

/*
 * Determine whether the given file exists in the configuration file.
 */
Rtc_obj *
elf_config_ent(const char *name, Word hash, int id, const char **alternate)
{
	Word		bkt, ndx;
	const char	*str;
	Rtc_obj		*obj;

	bkt = hash % config->c_hashtbl[0];
	ndx = config->c_hashtbl[2 + bkt];

	while (ndx) {
		obj = config->c_objtbl + ndx;
		str = config->c_strtbl + obj->co_name;

		if ((obj->co_hash != hash) || (strcmp(name, str) != 0) ||
		    (id && (id != obj->co_id))) {
			ndx = config->c_hashchain[ndx];
			continue;
		}

		if ((obj->co_flags & RTC_OBJ_ALTER) && alternate)
			*alternate = config->c_strtbl + obj->co_alter;

		return (obj);
	}
	return (0);
}

/*
 * Determine whether a filter and filtee string pair exists in the configuration
 * file.  If so, return the cached filtees that are associated with this pair as
 * an Alist.
 */
void
elf_config_flt(Lm_list *lml, const char *filter, const char *string,
    Alist **alpp, Aliste alni)
{
	Rtc_fltr	*fltrtbl;

	for (fltrtbl = (Rtc_fltr *)config->c_fltr; fltrtbl->fr_filter;
	    fltrtbl++) {
		Rtc_flte	*fltetbl;
		const char	*fltr, *str;

		fltr = config->c_strtbl + fltrtbl->fr_filter;
		str = config->c_strtbl + fltrtbl->fr_string;
		if (strcmp(filter, fltr) || strcmp(string, str))
			continue;

		/*
		 * Create a path descriptor for each filtee associated with this
		 * filter/filtee string pair.  Note, no expansion of filtee
		 * entries is called for, as any original expansion would have
		 * been carried out before they were recorded in the
		 * configuration file.
		 */
		/* LINTED */
		for (fltetbl = (Rtc_flte *)((char *)config->c_flte +
		    fltrtbl->fr_filtee); fltetbl->fe_filtee; fltetbl++) {
			const char	*flte;
			Pdesc		*pdp;

			flte = config->c_strtbl + fltetbl->fe_filtee;

			if ((pdp = alist_append(alpp, NULL, sizeof (Pdesc),
			    alni)) == NULL)
				return;

			pdp->pd_pname = (char *)flte;
			pdp->pd_plen = strlen(flte) + 1;
			pdp->pd_flags = LA_SER_CONFIG;

			DBG_CALL(Dbg_file_filter(lml, fltr, flte, 1));
		}
	}
}