instvol.c revision 5c51f1241dbbdf2656d0e10011981411ed0c9673
/*
* 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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
#include <stdio.h>
#include <string.h>
#include <locale.h>
#include <libintl.h>
#include <dirent.h>
#include <pkgstrct.h>
#include <pkgdev.h>
#include <pkglocs.h>
#include <archives.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>
#include <wait.h>
/*
* libinstzones includes
*/
#include <instzones_api.h>
/*
* consolidation pkg command library includes
*/
#include <pkglib.h>
#include <pkgweb.h>
/*
* local pkg command library includes
*/
#include <install.h>
#include <libinst.h>
#include <libadm.h>
#include <dryrun.h>
#include <messages.h>
/*
* pkginstall local includes
*/
#include "pkginstall.h"
extern int pkgverbose;
extern char tmpdir[];
extern char pkgbin[];
extern char instdir[];
extern char saveSpoolInstallDir[];
extern char *pkginst;
extern int dbchg;
extern int nosetuid;
extern int nocnflct;
extern int warnflag;
#define DMRG_DONE -1
#define ck_efile(s, p) \
static int eocflag;
/*
* The variable below indicates that fix_attributes() will be inadequate
* because a replacement was permitted.
*/
static int repl_permitted = 0;
char **r_anyPathLocal);
static int fix_attributes(struct cfextra **, int);
static int dir_is_populated(char *dirpath);
/* Used to keep track of the entries in extlist that are regular files. */
struct reg_files {
int val;
};
/*
* This is the function that actually installs one volume (usually that's
* all there is). Upon entry, the extlist is entirely correct:
*
* 1. It contains only those files which are to be installed
* from all volumes.
* 2. The mode bits in the ainfo structure for each file are set
* correctly in accordance with administrative defaults.
* 3. mstat.setuid/setgid reflect what the status *was* before
* pkgdbmerg() processed compliance.
*/
void
char *a_zoneName)
{
char *anyPathLocal = (char *)NULL;
char *dstp;
char *listfile;
char *srcp;
char *pspool_loc;
int count;
int entryidx; /* array of current package objects */
int n;
int nc = 0;
int pass; /* pass count through the for loop. */
int tcount;
/*
* r_updated and r_skipped are optional parameters that can be passed in
* by the caller if the caller wants to know if any objects are either
* updated or skipped. Do not initialize either r_updated or r_skipped;
* the call to instvol could be cumulative and any previous update or
* skipped indication must not be disturbed - these flags are only set,
* they must never be reset. These flags are "char *" pointers so that
* the object that was skipped or updated can be displayed in debugging
* output.
*/
if (part == 1) {
}
tcount = 0;
/*
* For each class in this volume, install those files.
*
* NOTE : This loop index may be decremented by code below forcing a
* second trip through for the same class. This happens only when a
* class is split between an archive and the tree. Examples would be
* old WOS packages and the occasional class containing dynamic
* libraries which require special treatment.
*/
if (is_depend_pkginfo_DB() == B_FALSE) {
int classidx; /* the current class */
int pass_relative = 0;
int rel_init = 0;
/* Now what do we pass to the class action script */
pass_relative = 1;
}
for (;;) {
if (!tcount++) {
/* first file to install */
if (a_zoneName == (char *)NULL) {
} else {
}
}
/*
* If there's an install class action script and no
* list file has been created yet, create that file
* and provide the pointer in listfp.
*/
/* create list file */
quit(99);
}
}
/*
* The following function goes through the package
* object list returning the array index of the next
* regular file. If it encounters a directory,
* symlink, named pipe or device, it just creates it.
*/
&anyPathLocal);
/* Evaluate the return code */
/*
* Set ept to the first entry in extlist
* which is guaranteed to exist so
* later checks against ept->ftype are
* not compared to NULL.
*/
break; /* no more entries to process */
}
/*
* If not installing from a partially spooled package
* be changed (type is 'e' or 'v'), and the class is not
* "none": copy the file from the package (in pristine
* state with no actions performed) into the appropriate
* area.
*/
if ((!is_partial_inst()) &&
pspool_loc = ROOT;
} else {
pspool_loc = RELOC;
}
if (n >= PATH_MAX) {
quit(99);
}
/* copy, preserve source file mode */
warnflag++;
}
}
/*
* If this isn't writeable anyway, it's not going
* into the list file. Only count it if it's going
* into the list file.
*/
&(ext->fsys_value)))
count++;
/*
* If source verification is OK for this class, make
* sure the source we're passing to the class action
* script is useable.
*/
if (cl_iscript(classidx) ||
srcp);
logerr(getErrbufAddr());
warnflag++;
continue;
}
}
}
/*
* If there's a class action script for this class,
* just collect names in a temporary file
* that will be used as the stdin when the
* class action script is invoked.
*/
if ((cl_iscript(classidx)) &&
&(ext->fsys_value))))) {
if (pass_relative) {
if (!rel_init) {
rel_init++;
}
} else {
}
/*
* Note which entries in extlist are regular
* files to be installed via the class action
* script.
*/
if (regfiles_head == NULL) {
if (regfiles_head == NULL) {
quit(99);
}
rfp = regfiles_head;
} else {
quit(99);
}
}
/*
* A warning message about unwritable targets
* in a class may be appropriate here.
*/
continue;
}
/*
* If not installing from a partially spooled package
* be changed (type is 'e' or 'v') and the class
* identifier is not "none": copy the file from the
* package (in pristine state with no actions performed)
* into the appropriate location in the packages
*/
if ((!is_partial_inst()) &&
pspool_loc = ROOT;
} else {
pspool_loc = RELOC;
}
if (n >= PATH_MAX) {
quit(99);
}
/* copy, preserve source file mode */
warnflag++;
}
}
/*
* There are several tests here to determine
* how we're going to deal with objects
* intended for remote read-only filesystems.
* We don't use is_served() because this may be
* a server. We're actually interested in if
* it's *really* remote and *really* not
* writeable.
*/
if ((n != 0) &&
&(ext->fsys_value))) {
/*
* Don't change the file, we can't write
* to it anyway.
*/
/*
* If it's currently mounted, we can
* at least test it for existence.
*/
} else {
}
} else {
char *server_host;
ext->fsys_value);
/* If not, we're just stuck. */
dstp, server_host);
}
continue;
}
/* echo output destination name */
/*
*/
continue;
}
/*
* If doing a partial installation (creating a
* non-global zone), extra steps need to be taken:
*
* 1) if the file is not type 'e' and not type 'v' and
* the class is "none": then the file must already
* exist (as a result of the initial non-global zone
* installation which caused all non-e/v files to be
* copied from the global zone to the non-global
* zone). If this is the case, verify that the file
* exists and has the correct attributes.
*
* 2) if the file is not type 'e' and not type 'v'
* and the class is NOT "none", *OR* if the file is
* type 'e' or type 'v': then check to see if the
* file is located in an area inherited from the
* global zone. If so, then there is no ability to
* change the file since inherited file systems are
* "read only" - just verify that the file exists and
* verify attributes only if not 'e' or 'v'.
*/
if (is_partial_inst() != 0) {
/*
* determine if the destination package is in an
* area inherited from the global zone
*/
((get_inst_root()) &&
get_inst_root() : "",
/*
* if not type 'e|v' and class 'none', then the
* file must already exist.
*/
"none") == 0)) {
/*
* if the file is in a space inherited
* from the global zone, and if the
* contents or attributes are incorrect,
* then generate a warning that the
* attributes have been modified and
* that the modifications are extended
* to the non-global zone (inherited
* from the global zone).
*/
if (n == 0) {
/* is file changed? */
/* no - ok - continue */
if (n == 0) {
continue;
}
/* output warning message */
continue;
B_FALSE)) {
/*
* non-e/v file of class "none"
* not inherited from the global
* zone: verify file already
* exists:everything checks here
*/
}
continue;
}
/*
* non-e/v file with class action script, or
* e/v file: if the file is in an area inherited
* from the global zone, then no need (or the
* ability) to update just accept the file as is
*/
if (n == B_TRUE) {
/*
* the object is in an area inherited
* from the global zone and the objects
* attributes are verified
*/
/* NOTE: package object skipped */
skipped);
}
continue;
}
}
/*
* Copy from source media to target path and fix file
* mode and permission now in case installation halted.
*/
get_inst_root()) == B_FALSE) {
/*
* If the filesystem is read-only don't attempt
* to copy a file. Just check that the content
* and attributes of the file are correct.
*
* Normally this doesn't happen, because files,
* which don't change, are not returned by
* domerg(). However when installing a patch in
* a sparse zone, which was already installed
* in global zone with -G option, NGZ's
* contents db still contains the old record
* for this file and therefore domerg()
* considers these files to be different even
* though they are the same.
*/
n = 0;
&(ext->fsys_value)))
if (n != 0) {
warnflag++;
/*
* everything checks here
*/
}
}
/* NOTE: a package object was updated */
}
}
/*
* We have now completed processing of all pathnames
* associated with this volume and class.
*/
if (cl_iscript(classidx)) {
/*
* Execute appropriate class action script
* with list of source/destination pathnames
* as the input to the script.
*/
quit(99);
}
if (listfp) {
}
/*
* if the object associated with the class action script
* is in an area inherited from the global zone, then
* there is no need to run the class action script -
* assume that anything the script would do has already
* been done in the area shared from the global zone.
*/
/* nothing updated, nothing skipped */
if ((is_partial_inst() != 0) &&
(anyPathLocal == (char *)NULL)) {
/*
* installing in non-global zone, and no object
* inherited area), and no path delivered by the
* package is in an area not inherited from the
* global zone (all paths delivered are in
* areas inherited from the global zone): do not
* run the class action script because the only
* affected areas are inherited (read only).
*/
eocflag ? "ENDOFCLASS" :
skipped = "postinstall";
skipped);
}
} else {
/* run the class action script */
eocflag ? "ENDOFCLASS" :
/* Use ULIMIT if supplied. */
if (eocflag) {
/*
* end of class detected.
* Since there are no more volumes which
* contain pathnames associated with
* this class, execute class action
* script with the ENDOFCLASS argument;
* we do this even if none of the path
* names associated with this class and
* volume needed installation to
* guarantee the class action script is
* executed at least once during package
* installation.
*/
if (pkgverbose) {
SHELL, "-x",
"ENDOFCLASS", NULL);
} else {
n = pkgexecl(
(listfp ?
"ENDOFCLASS", NULL);
}
ckreturn(n, ERR_CASFAIL);
} else if (count) {
/* execute class action script */
if (pkgverbose) {
NULL);
} else {
NULL);
}
ckreturn(n, ERR_CASFAIL);
}
/*
* Ensure the mod times on disk match those
* in the pkgmap. In this case, call cverify
* with checksumming disabled, since the only
* action that needs to be done is to verify
* that the attributes are correct.
*/
}
}
clr_ulimit();
updated = "postinstall";
updated);
}
}
if (listfile) {
}
}
/*
* The quick verify just fixes everything.
* If it returns 0, all is well. If it
* returns 1, then the class installation
* was incomplete and we retry on the
* stuff that failed in the conventional
* way (without a CAS). this is primarily
* to accomodate old archives such as are
* found in pre-2.5 WOS; but, it is also
* used when a critical dynamic library
* is not archived with its class.
*/
/*
* Reset the CAS pointer. If the
* function returns 0 then there
* was no script there in the first
* place and we'll just have to
* call this a miss.
*/
if (cl_deliscript(classidx))
/*
* Decrement classidx for
* next pass.
*/
classidx--;
}
} else {
/*
* Finalize merge. This checks to make sure
* file attributes are correct and any links
* specified are created.
*/
}
}
}
}
/*
* Instead of creating links back to the GZ files the logic is
* to let zdo recreate the files from the GZ then invoke pkgadd to
* install the editable files and skip over any 'f'type files.
* The commented out block is to create the links which should be
* removed once the current code is tested to be correct.
*/
/*
* Go through extlist creating links for 'f'type files
* if we're in a global zone. Note that this code lies
* here instead of in the main loop to support CAF packages.
* In a CAF package the files are installed by the i.none script
* and don't exist until all files are done being processed, thus
* the additional loop through extlist.
*/
/*
* output appropriate completion message
*/
if (is_depend_pkginfo_DB() == B_TRUE) {
/* updating database only (hollow package) */
if (a_zoneName == (char *)NULL) {
} else {
}
} else if (tcount == 0) {
/* updating package (non-hollow package) */
if (a_zoneName == (char *)NULL) {
} else {
}
}
/*
* if any package objects were updated (not inherited from the
* global zone or otherwise already in existence), set the updated
* flag as appropriate
*/
}
}
/*
* if any package objects were skipped (verified inherited from the
* global zone), set the skipped flag as appropriate
*/
}
}
}
/*
* Name: domerg
* Description: For the specified class, review each entry and return the array
* index number of the next regular file to process. Hard links are
* skipped (they are created in endofclass() and directories,
* symlinks, pipes and devices are created here, as well as any
* file that already exists and has the correct attributes.
* Arguments: struct cfextra **extlist - [RO, *RW]
* - Pointer to list of cfextra structures representing
* the pkgmap of the package to be installed
* int part - [RO, *RO]
* - the part of the package currently being processed;
* packages begin with part "1" and proceed for the
* number (nparts) that comprise the package (volume).
* int nparts - [RO, *RO]
* - the number of parts the package is divided into
* int myclass - [RO, *RO]
* - index into class array of the current class
* char **srcp - [RW, *RW]
* - pointer to pointer to string representing the source
* path for the next package to process - if this
* function returns != DMRG_DONE then this pointer is
* set to a pointer to a string representing the source
* path for the next object from the package to process
* char **dstp - [RW, *RW]
* - pointer to pointer to string representing the target
* path for the next package to process - if this
* function returns != DMRG_DONE then this pointer is
* set to a pointer to a string representing the target
* path for the next object from the package to process
* char **r_updated - [RO, *RW]
* - pointer to pointer to string - set if the last path
* returned exists or does not need updating and the
* object is NOT located in an area inherited from the
* global zone. This is used to determine if the last
* path object returned DOES exist in an area that is
* inherited from the global zone. If no paths are
* inherited from the global zone, this is always set
* when a path to be installed exists and has the
* correct contents.
* char **r_skipped - [RO, *RW]
* - pointer to pointer to string - set if the last path
* returned exists or does not need updating and the
* object IS located in an area inherited from the
* global zone. This is used to determine if the last
* path object returned does NOT exist in an area that
* is inherited from the global zone. If no paths are
* inherited from the global zone, this is never set.
* char **r_anyPathLocal - [RO, *RW]
* - pointer to pointer to string - set if any object
* belonging to the package is NOT located in an area
* inherited from the global zone. This is used to
* determine if the package references ANY objects that
* are NOT located in an area inherited from the global
* zone - regardless of whether or not they need to be
* from the global zone, this is always set when a path
* to be installed already exists and has the correct
* contents.
* Returns: int
* != DMRG_DONE - index into extlist of the next path to
* == DMRG_DONE - all entries processed
*/
static int
char **r_anyPathLocal)
{
int i;
int msg_ugid;
static int maxvol = 0;
static int svindx = 0;
static int svpart = 0;
/* reset returned path pointers */
/* set to start or continue based on which part being processed */
if (part != 0) {
maxvol = 0;
svindx = 0;
} else {
i = svindx;
}
/*
* This goes through the pkgmap entries one by one testing them
* for inclusion in the package database as well as for validity
* against existing files.
*/
/*
* as paths are processed, if the "anyPathLocal" flag has not
* been set, if the object is not of type 'i' (package script),
* check to see if the object is in an area inherited from the
* global zone - if not, set "anyPathLocal" to the path found,
* indicating that at least one path is in an area that is not
* inherited from the global zone.
*/
if ((r_anyPathLocal != (char **)NULL) &&
(*r_anyPathLocal == (char *)NULL) &&
get_inst_root()) == B_FALSE)) {
}
/* if this isn't the class of current interest, skip it */
continue;
}
/* if the class is invalid, announce it & exit */
quit(99);
}
/*
* Next check to see if we are going to try to delete a
* populated directory in some distressing way.
*/
if (mstat->dir2nondir)
warnflag++;
continue;
} else { /* Replace is OK. */
/*
* Remove this directory, so it won't
* interfere with creation of the new object.
*/
/*
* If it didn't work, there's nothing
* we can do. To continue would
* likely corrupt the filesystem
* which is unacceptable.
*/
quit(99);
}
}
/* adjust the max volume number appropriately */
}
/* if this part goes into another volume, skip it */
continue;
}
/*
* If it's a conflicting file and it's not supposed to be
* installed, note it and skip.
*/
}
continue;
}
/*
* If we want to set uid or gid but user says no, note it.
* Remember that the actual mode bits in the structure have
* already been adjusted and the mstat flag is telling us
* about the original mode.
*/
&(extlist[i]->fsys_value))) {
} else {
}
}
} else {
msg_ugid = 0;
}
case 'l': /* hard link */
continue; /* defer to final proc */
case 's': /* for symlink, verify without fix first */
/* Do this only for default verify */
}
/*FALLTHRU*/
case 'd': /* directory */
case 'x': /* exclusive directory */
case 'c': /* character special device */
case 'b': /* block special device */
case 'p': /* named pipe */
/*
* If we can't get to it for legitimate reasons,
* don't try to verify it.
*/
get_inst_root())) ||
&(extlist[i]->fsys_value)) &&
&(extlist[i]->fsys_value))) {
break;
}
} else {
logerr(getErrbufAddr());
warnflag++;
}
break;
case 'i': /* information file */
break;
default:
break;
}
/*
* Both contchg and shared flags have to be taken into
* account. contchg is set if the file is already present
* in the package database, if it does not exist or if it
* exists and is modified.
* The shared flag is set when 'e' or 'v' file is not
* present in the package database, exists and is not
* modified. It also has to be checked here.
* Shared flag is also set when file is present in package
* database and owned by more than one package, but for
* this case contchg has already been set.
*/
if (is_partial_inst() != 0) {
if (*srcp[0] == '~') {
/* translate source pathname */
} else {
}
} else {
if (*srcp[0] == '~') {
/* translate source pathname */
}
}
} else {
/*
* At this point, we're returning a non-file
* that couldn't be created in the standard
* way. If it refers to a filesystem that is
* not writeable by us, don't waste the
* calling process's time.
*/
&(extlist[i]->fsys_value))) {
continue;
}
}
svindx = i+1;
return (i);
}
if (!msg_ugid)
/* fix the attributes now for robustness sake */
}
}
/*
* package object exists, or does not need updating: if the path
* is in an area inherited from the global zone, then treat
* the object as if it were "skipped" - if the path is not in an
* area inherited from the global zone, then treat the object as
* if it were "updated"
*/
/* LINTED warning: statement has no consequent: if */
/*
* the object in question is a directory or special
* file - the fact that this type of object already
* exists or does not need updating must not trigger
* that would cause class action scripts to be run
* when installing a new non-global zone - that action
* must only be done when a file object that is in
* an area inherited from the global zone is present.
*/
get_inst_root()) == B_TRUE) {
}
}
} else {
}
}
}
}
eocflag++; /* endofclass */
}
return (DMRG_DONE); /* no remaining entries on this volume */
}
/*
* Determine if the provided directory is populated. Return 0 if so and 1 if
* not. This also returns 0 if the dirpath is not a directory or if it does
* not exist.
*/
static int
dir_is_populated(char *dirpath) {
int retcode = 0;
continue;
}
continue;
}
/*
* If we get here, there's a real file in the
* directory
*/
retcode = 1;
break;
}
}
return (retcode);
}
/*
* This is the function that cleans up the installation of this class.
* This is where hard links get put in since the stuff they're linking
* probably exists by now.
*/
static void
{
char *temppath;
char *pspool_loc;
int flag;
int idx;
int n;
/* open the package database (contents) file */
quit(99);
}
/* find next package object in this class */
break;
}
idx++;
}
/* finish copying contents file and exit loop */
*a_cfVfp, *a_cfTmpVfp);
break;
}
temppath =
NULL;
/*
* At this point the only difference between the entry
* in the contents file and the entry in extlist[] is
* that the status indicator contains CONFIRM_CONT.
* So for the new DB we use this knowledge and just
* verify everything in accordance with extlist without
* trying to retrieve the entry from the DB.
*/
if (n == 0) {
break;
} else if (n < 0) {
quit(99);
} else if (n != 1) {
/*
* Check if path should be in the package
* database.
*/
continue;
}
quit(99);
}
/*
* If merge was not appropriate for this object, now is the
* time to choose one or the other.
*/
/*
* If installation was denied AFTER the package
* database was updated, skip this. We've already
* announced the discrepancy and the verifications
* that follow will make faulty decisions based on
* the ftype, which may not be correct.
*/
warnflag++;
} else {
/*
* This replaces the old entry with the new
* one. This should never happen in the new
* DB since the entries are already identical.
*/
/*
* Validate this entry and change the status flag in
* the package database.
*/
} else {
/* check the hard link now. */
}
}
/*
* Don't install or verify objects for
* remote, read-only filesystems. We need
* only flag them as shared from some server.
* Otherwise, ok to do final check.
*/
flag = -1;
} else {
(-1)), inheritedFlag);
}
/* Find this package in the list. */
while (pinfo) {
break;
}
}
/*
* If this package owns this file, then store
* it in the database with the appropriate
* status. Need to check pinfo in case it
* points to NULL which could happen if
* pinfo->next = NULL above.
*/
if (pinfo) {
/*
* This is provided to
* clients by a server.
*/
} else {
/*
* It's either there or it's
* not.
*/
}
}
}
}
/*
* If not installing from a partially spooled package, the
* changed (type is 'e' or 'v'), and the class IS "none":
* copy the installed volatile file into the appropriate
*/
if ((!is_partial_inst()) &&
pspool_loc = ROOT;
} else {
pspool_loc = RELOC;
}
if (n >= PATH_MAX) {
quit(99);
}
/* copy, preserve source file mode */
warnflag++;
}
}
/*
* Now insert this potentially changed package database
* entry.
*/
quit(99);
}
}
}
if (n == RESULT_WRN) {
warnflag++;
} else if (n == RESULT_ERR) {
quit(99);
}
}
/*
* This function goes through and fixes all the attributes. This is called
* out by using DST_QKVERIFY=this_class in the pkginfo file. The primary
* use for this is to fix up files installed by a class action script
* which is time-critical and reliable enough to assume likely success.
* The first such format was for WOS compressed-cpio'd file sets.
* The second format is the Class Archive Format.
*/
static int
{
int i, retval = 1;
int n;
char *pspool_loc;
for (i = 0; extlist[i]; i++) {
/*
* We don't care about 'i'nfo files because, they
* aren't laid down, 'e'ditable files can change
* anyway, so who cares and 's'ymlinks were already
* fixed in domerg(); however, certain old WOS
* package symlinks depend on a bug in the old
* pkgadd which has recently been expunged. For
* those packages in 2.2, we repeat the verification
* of symlinks.
*
* By 2.6 or so, ftype == 's' should be added to this.
*/
continue;
warnflag++;
continue;
}
continue;
}
/* If this is the right class, do the fast verify. */
} else /* We'll try full verify later */
retval = 0;
}
/*
* Need to copy the installed volitale file back to the
* partial spooled area if we are installing to a local zone
* or similar installation method.
*/
if ((!is_partial_inst()) &&
pspool_loc = ROOT;
} else {
pspool_loc = RELOC;
}
if (n >= PATH_MAX) {
quit(99);
}
/* copy, preserve source file mode */
warnflag++;
}
}
}
return (retval);
}
/*
* Check to see if first charcter in path is a '/'.
*
* Return:
* B_TRUE - if path is prepended with '/'
* B_FALSE - if not
*/
static boolean_t
absolutepath(char *path)
{
}
/*
* Check to see if path contains a '$' which makes it
* a parametric path and therefore relocatable.
*
* Parameters:
* path - The path to determine if it is absolute
* relocpath - The value of the unconditioned path
* Return:
* B_TRUE - if path is a parametric path
* B_FALSE - if not
*/
static boolean_t
{
/*
* If this is a valid parametric path then a '$' MUST occur at the
* first or second character.
*/
/*
* If a parametric path exists then when copying the
* path to the pspool directoy from the installing
* pkgs reloc directory we want to use the uncononditional
* varaiable path.
*/
return (B_TRUE);
}
return (B_FALSE);
}
void
{
if (regfiles_head != NULL) {
regfiles_head = rfp;
}
}
}