paths.c revision 5aefb6555731130ca4fd295960123d71f2d21fe8
/*
* 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
* 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 (c) 1988 AT&T
* All Rights Reserved
*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* PATH setup and search directory functions.
*/
#include "_synonyms.h"
#include <stdio.h>
#include <limits.h>
#include <fcntl.h>
#include <string.h>
#include <sys/systeminfo.h>
#include <debug.h>
#include <conv.h>
#include "_rtld.h"
#include "msg.h"
/*
* Given a search rule type, return a list of directories to search according
* to the specified rule.
*/
static Pnode *
{
int search;
/*
* Determine whether ldd -s is in effect - ignore when we're searching
* for audit libraries as these will be added to their own link-map.
*/
((flags & FLG_RT_AUDIT) == 0))
search = 1;
else
search = 0;
switch (rules) {
case RPLENV:
/*
* Initialize the replaceable environment variable
* (LD_LIBRARY_PATH) search path list. Note, we always call
* Dbg_libs_path() so that every library lookup diagnostic can
* be preceded with the appropriate search path information.
*/
if (rpl_libpath) {
/*
* Note, this path may have originated from the users
* environment or from a configuration file.
*/
if (env_info & ENV_INF_PATHCFG)
mode |= LA_SER_CONFIG;
/*
* For ldd(1) -s, indicate the search paths that'll
* be used. If this is a secure program then some
* search paths may be ignored, therefore reset the
* rpl_libdirs pointer each time so that the
* diagnostics related to these unsecure directories
* will be output for each image loaded.
*/
if (search) {
const char *fmt;
if (env_info & ENV_INF_PATHCFG)
else
}
(search || DBG_ENABLED)) {
rpl_libdirs = 0;
}
if (!rpl_libdirs) {
/*
* If this is a secure application we need to
* be selective over what directories we use.
*/
mode, PN_TKN_HWCAP);
}
}
break;
case PRMENV:
/*
* Initialize the permanent (LD_LIBRARY_PATH) search path list.
* This can only originate from a configuration file. To be
* consistent with the debugging display of DEFENV (above),
* always call Dbg_libs_path().
*/
if (prm_libpath) {
/*
* For ldd(1) -s, indicate the search paths that'll
* be used. If this is a secure program then some
* search paths may be ignored, therefore reset the
* prm_libdirs pointer each time so that the
* diagnostics related to these unsecure directories
* will be output for each image loaded.
*/
if (search)
(search || DBG_ENABLED)) {
prm_libdirs = 0;
}
if (!prm_libdirs) {
/*
* If this is a secure application we need to
* be selective over what directories we use.
*/
}
}
break;
case RUNPATH:
/*
* Initialize the runpath search path list. To be consistent
* with the debugging display of DEFENV (above), always call
* Dbg_libs_path().
*/
/*
* For ldd(1) -s, indicate the search paths that'll
* be used. If this is a secure program then some
* search paths may be ignored, therefore reset the
* runlist pointer each time so that the diagnostics
* related to these unsecure directories will be
* output for each image loaded.
*/
if (search)
(search || DBG_ENABLED)) {
}
/*
* If this is a secure application we need to
* be selective over what directories we use.
*/
}
break;
case DEFAULT:
if ((rtld_flags & RT_FL_SECURE) &&
else
}
/*
* For ldd(1) -s, indicate the default paths that'll be used.
*/
int num = 0;
if (search)
if (search) {
const char *fmt;
if (num)
else
} else
}
if (search) {
else
}
}
break;
default:
break;
}
return (dirlist);
}
/*
* Get the next dir in the search rules path.
*/
Pnode *
{
/*
* Search rules consist of one or more directories names. If this is a
* new search, then start at the beginning of the search rules.
* Otherwise traverse the list of directories that make up the rule.
*/
if (!*dirlist) {
} else {
return (*dirlist);
else
rules++;
}
while (*rules) {
return (*dirlist);
else
rules++;
}
/*
* If we got here, no more directories to search, return NULL.
*/
}
/*
* Process a directory (runpath) or filename (needed or filter) string looking
* for tokens to expand. Allocate a new buffer for the string.
*/
{
int isaflag = 0;
/*
* When expanding paths while a configuration file
* exists that contains directory information, determine
* whether the path contains "./". If so, we'll resolve
* the path later to remove these relative entries.
*/
if ((rtld_flags & RT_FL_DIRCFG) &&
flags |= TKN_DOTSLASH;
continue;
}
/*
* Copy any string we've presently passed over to the new
* buffer.
*/
} else {
oname);
return (0);
}
}
/*
* Skip the token delimiter and determine if a reserved token
* match is found.
*/
_flags = 0;
token = 0;
MSG_TKN_ORIGIN_SIZE) == 0) {
/*
* $ORIGIN expansion is required. Determine this
* objects basename. Expansion of $ORIGIN is allowed
* for secure applications but must be checked by the
* caller to insure the expanded path matches a
* registered secure name.
*/
if (((omit & PN_TKN_ORIGIN) == 0) &&
_flags |= PN_TKN_ORIGIN;
} else {
return (0);
}
}
MSG_TKN_PLATFORM_SIZE) == 0) {
/*
* $PLATFORM expansion required. This would have been
* established from the AT_SUN_PLATFORM aux vector, but
* if not attempt to get it from sysconf().
*/
if (((omit & PN_TKN_PLATFORM) == 0) &&
((platform == 0) && (platform_sz == 0))) {
long _size;
if ((_size != -1) &&
}
}
if (((omit & PN_TKN_PLATFORM) == 0) &&
(platform != 0)) {
} else {
return (0);
}
}
MSG_TKN_OSNAME_SIZE) == 0) {
/*
* $OSNAME expansion required. This is established
* from the sysname[] returned by uname(2).
*/
if (((omit & PN_TKN_OSNAME) == 0) &&
uts->uts_osnamesz);
_flags |= PN_TKN_OSNAME;
} else {
return (0);
}
}
MSG_TKN_OSREL_SIZE) == 0) {
/*
* $OSREL expansion required. This is established
* from the release[] returned by uname(2).
*/
if (((omit & PN_TKN_OSREL) == 0) &&
uts->uts_osrelsz);
_flags |= PN_TKN_OSREL;
} else {
return (0);
}
}
MSG_TKN_ISALIST_SIZE) == 0)) {
int ok;
/*
* $ISALIST expansion required. When accompanied with
* a list pointer, this routine updates that pointer
* with the new list of potential candidates. Without
* this list pointer, only the first expansion is
* provided. NOTE, that two $ISLIST expansions within
* the same path aren't supported.
*/
ok = 0;
else
ok = 1;
isa = conv_isalist();
char *lptr;
opt->isa_namesz);
_flags |= PN_TKN_ISALIST;
} else {
return (0);
}
if (list) {
return (0);
hlen);
opt->isa_namesz);
tlen);
*lptr++ = ':';
}
if (**list)
else
*--lptr = '\0';
}
}
MSG_TKN_HWCAP_SIZE) == 0) {
/*
* $HWCAP expansion required. For compatibility with
* older environments, only expand this token when hard-
* ware capability information is available. This
* expansion is only allowed for non-simple pathnames
* (must contain a '/'), with the token itself being the
* last element of the path. Therefore, all we need do
* is test the existence of the string "/$HWCAP\0".
*/
if (((omit & PN_TKN_HWCAP) == 0) &&
(rtld_flags2 & RT_FL2_HWCAP) &&
/*
* Decrement the present pointer so that the
* directories trailing "/" gets nuked later.
*/
_flags |= PN_TKN_HWCAP;
}
} else {
/*
* If reserved token was not found, copy the
* character.
*/
*nptr++ = '$';
nlen++;
}
/*
* If reserved token was found, and could not be expanded,
* this is an error.
*/
if (token) {
if (_flags)
else {
return (0);
}
}
}
/*
* First make sure the current length is shorter than PATH_MAX. We may
* arrive here if the given path contains '$' characters which are not
* the lead of a reserved token.
*/
oname);
return (0);
}
/*
* If any ISALIST processing has occurred not only do we return the
* expanded node we're presently working on, but we can also update the
* remaining list so that it is effectively prepended with this node
* expanded to all remaining ISALIST options. Note that we can only
* handle one ISALIST per node. For more than one ISALIST to be
* processed we'd need a better algorithm than above to replace the
* newly generated list. Whether we want to encourage the number of
* pathname permutations this would provide is another question. So, for
* now if more than one ISALIST is encountered we return the original
* node untouched.
*/
if (isaflag) {
if (isaflag == 1) {
if (list)
} else {
flags &= ~PN_TKN_ISALIST;
return (0);
return (TKN_NONE);
}
}
/*
* Copy any remaining string. Terminate the new string with a null as
* this string can be displayed via debugging diagnostics.
*/
} else {
return (0);
}
}
*nptr = '\0';
/*
* A path that has been expanded, is typically used to create full
* pathnames for objects that will be opened. The final pathname is
* resolved to simplify it, and set the stage for possible $ORIGIN
* processing. Therefore, it's usually unncessary to resolve the path
* at this point. However, if a configuration file, containing
* directory information is in use, then we might need to lookup this
* path in the configuration file. To keep the number of pathname
* resolutions to a minimum, only resolve paths that contain "./". The
* use of "$ORIGIN/../lib" will probably only match a configuration file
* entry after resolution.
*/
int len;
}
}
/*
* Allocate permanent storage for the new string and return to the user.
*/
return (0);
/*
* Return an indication of any token expansion that may have occurred.
* Under security, any pathname expanded with the $ORIGIN token must be
* validated against any registered secure directories.
*/
}
/*
* Determine whether a pathname is secure.
*/
static int
{
/*
* If a pathname originates from a configuration file, use it. The use
* of a configuration file is already validated for secure applications,
* so if we're using a configuration file, we must be able to use all
* that it defines.
*/
if (info & LA_SER_CONFIG)
return (1);
if ((info & LA_SER_MASK) == 0) {
char *str;
/*
* If the pathname specifies a file (rather than a directory),
* peel off the file before making the comparison.
*/
/*
* A simple filename (one containing no "/") is fine, as this
* will be combined with search paths to determine the complete
* path. Other paths are checked:
*
* . a full path (one starting with "/") is fine, provided
* . any $ORIGIN expansion
* . any relative path
*/
((info & PN_SER_EXTLOAD) == 0))) &&
((flags & PN_TKN_ORIGIN) == 0))
return (1);
else {
return (0);
}
} else {
/*
* A search path, i.e., RPATH, configuration file path, etc. is
* used as is. Exceptions to this are:
*
* . LD_LIBRARY_PATH
* . any $ORIGIN expansion
* . any relative path
*/
((flags & PN_TKN_ORIGIN) == 0))
return (1);
}
while (sdir) {
return (1);
}
/*
* The path is insecure, so depending on the caller, provide a
* diagnostic. Preloaded, or audit libraries generate a warning, as
* the process will run without them.
*/
if (info & PN_SER_EXTLOAD) {
opath);
} else
opath);
return (0);
}
/*
* Explicit file references are fatal.
*/
if ((info & LA_SER_MASK) == 0) {
if (((rtld_flags & RT_FL_SILENCERR) == 0) ||
opath);
}
} else
} else {
/*
* Search paths.
*/
}
return (0);
}
/*
* Expand one or more pathnames. This routine is called for all path strings,
* i.e., NEEDED, rpaths, default search paths, configuration file search paths,
* filtees, etc. The path may be a single pathname, or a colon separated list
* of pathnames. Each individual pathname is processed for possible reserved
* token expansion. All string nodes are maintained in allocated memory
* (regardless of whether they are constant (":"), or token expanded) to
* simplify pnode removal.
*
* The info argument passes in auxiliary information regarding the callers
* intended use of the pathnames. This information may be maintained in the
* pnode element produced to describe the pathname (i.e., LA_SER_LIBPATH etc.),
* or may be used to determine additional security or diagnostic processing.
*/
Pnode *
{
char *ostr;
if (*nlist == ';')
/* If not a final null segment, check following one */
if (*nlist)
nlist++;
/*
* When the shell sees a null PATH segment, it
* treats it as if it were the cwd (.). We mimic
* this behavior for LD_LIBRARY_PATH and runpaths
* (mainly for backwards compatibility with previous
* behavior). For other paths, this makes no sense,
* so we simply ignore the segment.
*/
continue; /* Process next segment */
return ((Pnode *)0);
} else {
char *elist;
len = 0;
}
/* Check for a following final null segment */
if (*nlist)
nlist++;
/*
* Expand the captured string. Besides expanding the
* deal with (ISALIST expands to multiple new entries).
*/
clmp)) == 0)
return ((Pnode *)0);
if (olist)
}
}
/*
* If this a secure application, validation of the expanded
* pathname may be necessary.
*/
if (rtld_flags & RT_FL_SECURE) {
tkns) == 0)
continue;
}
/*
* Allocate a new Pnode for this string.
*/
return ((Pnode *)0);
if (opnp == 0)
else
char *oname;
/*
* If this is a pathname, and any token expansion
* occurred, maintain the original string for possible
* diagnostic use.
*/
return ((Pnode *)0);
}
(tkns & PN_TKN_MASK);
}
if (olist)
return (pnp);
}