make/bin/files.cc

/*
 * 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 2003 Sun Microsystems, Inc. All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2019 RackTop Systems.
 */

/*
 *	files.c
 *
 *	Various file related routines:
 *		Figure out if file exists
 *		Wildcard resolution for directory reader
 *		Directory reader
 */


/*
 * Included files
 */
#include <dirent.h>		/* opendir() */
#include <errno.h>		/* errno */
#include <mk/defs.h>
#include <mksh/macro.h>		/* getvar() */
#include <mksh/misc.h>		/* get_prop(), append_prop() */
#include <sys/stat.h>		/* lstat() */
#include <libintl.h>

/*
 * Defined macros
 */

/*
 * typedefs & structs
 */

/*
 * Static variables
 */

/*
 * File table of contents
 */
extern	timestruc_t&	exists(Name target);
extern  void		set_target_stat(Name target, struct stat buf);
static	timestruc_t&	vpath_exists(Name target);
static	Name		enter_file_name(wchar_t *name_string, wchar_t *library);
static	Boolean		star_match(char *string, char *pattern);
static	Boolean		amatch(wchar_t *string, wchar_t *pattern);

/*
 *	exists(target)
 *
 *	Figure out the timestamp for one target.
 *
 *	Return value:
 *				The time the target was created
 *
 *	Parameters:
 *		target		The target to check
 *
 *	Global variables used:
 *		debug_level	Should we trace the stat call?
 *		recursion_level	Used for tracing
 *		vpath_defined	Was the variable VPATH defined in environment?
 */
timestruc_t&
exists(Name target)
{
	struct stat		buf;
	int		result;

	/* We cache stat information. */
	if (target->stat.time != file_no_time) {
		return target->stat.time;
	}

	/*
	 * If the target is a member, we have to extract the time
	 * from the archive.
	 */
	if (target->is_member &&
	    (get_prop(target->prop, member_prop) != NULL)) {
		return read_archive(target);
	}

	if (debug_level > 1) {
		(void) printf("%*sstat(%s)\n",
		              recursion_level,
		              "",
		              target->string_mb);
	}

	result = lstat_vroot(target->string_mb, &buf, NULL, VROOT_DEFAULT);
	if ((result != -1) && ((buf.st_mode & S_IFMT) == S_IFLNK)) {
                /*
		 * If the file is a symbolic link, we remember that
		 * and then we get the status for the refd file.
		 */
                target->stat.is_sym_link = true;
                result = stat_vroot(target->string_mb, &buf, NULL, VROOT_DEFAULT);
        } else {
                target->stat.is_sym_link = false;
	}

	if (result < 0) {
		target->stat.time = file_doesnt_exist;
		target->stat.stat_errno = errno;
		if ((errno == ENOENT) &&
		    vpath_defined &&
/* azv, fixing bug 1262942, VPATH works with a leaf name
 * but not a directory name.
 */
		    (target->string_mb[0] != (int) slash_char) ) {
/* BID_1214655 */
/* azv */
			vpath_exists(target);
			// return vpath_exists(target);
		}
	} else {
		/* Save all the information we need about the file */
		target->stat.stat_errno = 0;
		target->stat.is_file = true;
		target->stat.mode = buf.st_mode & 0777;
		target->stat.size = buf.st_size;
		target->stat.is_dir =
		  BOOLEAN((buf.st_mode & S_IFMT) == S_IFDIR);
		if (target->stat.is_dir) {
			target->stat.time = file_is_dir;
		} else {
			/* target->stat.time = buf.st_mtime; */
/* BID_1129806 */
/* vis@nbsp.nsk.su */
			target->stat.time = MAX(buf.st_mtim, file_min_time);
		}
	}
	if ((target->colon_splits > 0) &&
	    (get_prop(target->prop, time_prop) == NULL)) {
		append_prop(target, time_prop)->body.time.time =
		  target->stat.time;
	}
	return target->stat.time;
}

/*
 *	set_target_stat( target, buf)
 *
 *	Called by exists() to set some stat fields in the Name structure
 *	to those read by the stat_vroot() call (from disk).
 *
 *	Parameters:
 *		target		The target whose stat field is set
 *		buf		stat values (on disk) of the file
 *				represented by target.
 */
void
set_target_stat(Name target, struct stat buf)
{
	target->stat.stat_errno = 0;
	target->stat.is_file = true;
	target->stat.mode = buf.st_mode & 0777;
	target->stat.size = buf.st_size;
	target->stat.is_dir =
	  BOOLEAN((buf.st_mode & S_IFMT) == S_IFDIR);
	if (target->stat.is_dir) {
		target->stat.time = file_is_dir;
	} else {
		/* target->stat.time = buf.st_mtime; */
/* BID_1129806 */
/* vis@nbsp.nsk.su */
		target->stat.time = MAX(buf.st_mtim, file_min_time);
	}
}


/*
 *	vpath_exists(target)
 *
 *	Called if exists() discovers that there is a VPATH defined.
 *	This function stats the VPATH translation of the target.
 *
 *	Return value:
 *				The time the target was created
 *
 *	Parameters:
 *		target		The target to check
 *
 *	Global variables used:
 *		vpath_name	The Name "VPATH", used to get macro value
 */
static timestruc_t&
vpath_exists(Name target)
{
	wchar_t			*vpath;
	wchar_t			file_name[MAXPATHLEN];
	wchar_t			*name_p;
	Name			alias;

	/*
	 * To avoid recursive search through VPATH when exists(alias) is called
	 */
	vpath_defined = false;

	Wstring wcb(getvar(vpath_name));
	Wstring wcb1(target);

	vpath = wcb.get_string();

	while (*vpath != (int) nul_char) {
		name_p = file_name;
		while ((*vpath != (int) colon_char) &&
		       (*vpath != (int) nul_char)) {
			*name_p++ = *vpath++;
		}
		*name_p++ = (int) slash_char;
		(void) wcscpy(name_p, wcb1.get_string());
		alias = GETNAME(file_name, FIND_LENGTH);
		if (exists(alias) != file_doesnt_exist) {
			target->stat.is_file = true;
			target->stat.mode = alias->stat.mode;
			target->stat.size = alias->stat.size;
			target->stat.is_dir = alias->stat.is_dir;
			target->stat.time = alias->stat.time;
			maybe_append_prop(target, vpath_alias_prop)->
						body.vpath_alias.alias = alias;
			target->has_vpath_alias_prop = true;
			vpath_defined = true;
			return alias->stat.time;
		}
		while ((*vpath != (int) nul_char) &&
		       ((*vpath == (int) colon_char) || iswspace(*vpath))) {
			vpath++;
		}
	}
	/*
	 * Restore vpath_defined
	 */
	vpath_defined = true;
	return target->stat.time;
}

/*
 *	read_dir(dir, pattern, line, library)
 *
 *	Used to enter the contents of directories into makes namespace.
 *	Presence of a file is important when scanning for implicit rules.
 *	read_dir() is also used to expand wildcards in dependency lists.
 *
 *	Return value:
 *				Non-0 if we found files to match the pattern
 *
 *	Parameters:
 *		dir		Path to the directory to read
 *		pattern		Pattern for that files should match or NULL
 *		line		When we scan using a pattern we enter files
 *				we find as dependencies for this line
 *		library		If we scan for "lib.a(<wildcard-member>)"
 *
 *	Global variables used:
 *		debug_level	Should we trace the dir reading?
 *		dot		The Name ".", compared against
 *		sccs_dir_path	The path to the SCCS dir (from PROJECTDIR)
 *		vpath_defined	Was the variable VPATH defined in environment?
 *		vpath_name	The Name "VPATH", use to get macro value
 */
int
read_dir(Name dir, wchar_t *pattern, Property line, wchar_t *library)
{
	wchar_t			file_name[MAXPATHLEN];
	wchar_t			*file_name_p = file_name;
	Name			file;
	wchar_t			plain_file_name[MAXPATHLEN];
	wchar_t			*plain_file_name_p;
	Name			plain_file;
	wchar_t			tmp_wcs_buffer[MAXPATHLEN];
	DIR			*dir_fd;
	int			m_local_dependency=0;
#define d_fileno d_ino
        struct dirent  *dp;
	wchar_t			*vpath = NULL;
	wchar_t			*p;
	int			result = 0;

	if(dir->hash.length >= MAXPATHLEN) {
		return 0;
	}

	Wstring wcb(dir);
	Wstring vps;

	/* A directory is only read once unless we need to expand wildcards. */
	if (pattern == NULL) {
		if (dir->has_read_dir) {
			return 0;
		}
		dir->has_read_dir = true;
	}
	/* Check if VPATH is active and setup list if it is. */
	if (vpath_defined && (dir == dot)) {
		vps.init(getvar(vpath_name));
		vpath = vps.get_string();
	}

	/*
	 * Prepare the string where we build the full name of the
	 * files in the directory.
	 */
	if ((dir->hash.length > 1) || (wcb.get_string()[0] != (int) period_char)) {
		(void) wcscpy(file_name, wcb.get_string());
		MBSTOWCS(wcs_buffer, "/");
		(void) wcscat(file_name, wcs_buffer);
		file_name_p = file_name + wcslen(file_name);
	}

	/* Open the directory. */
vpath_loop:
	dir_fd = opendir(dir->string_mb);
	if (dir_fd == NULL) {
		return 0;
	}

	/* Read all the directory entries. */
	while ((dp = readdir(dir_fd)) != NULL) {
		/* We ignore "." and ".." */
		if ((dp->d_fileno == 0) ||
		    ((dp->d_name[0] == (int) period_char) &&
		     ((dp->d_name[1] == 0) ||
		      ((dp->d_name[1] == (int) period_char) &&
		       (dp->d_name[2] == 0))))) {
			continue;
		}
		/*
		 * Build the full name of the file using whatever
		 * path supplied to the function.
		 */
		MBSTOWCS(tmp_wcs_buffer, dp->d_name);
		(void) wcscpy(file_name_p, tmp_wcs_buffer);
		file = enter_file_name(file_name, library);
		if ((pattern != NULL) && amatch(tmp_wcs_buffer, pattern)) {
			/*
			 * If we are expanding a wildcard pattern, we
			 * enter the file as a dependency for the target.
			 */
			if (debug_level > 0){
				WCSTOMBS(mbs_buffer, pattern);
				(void) printf(gettext("'%s: %s' due to %s expansion\n"),
					      line->body.line.target->string_mb,
					      file->string_mb,
					      mbs_buffer);
			}
			enter_dependency(line, file, false);
			result++;
		} else {
			/*
			 * If the file has an SCCS/s. file,
			 * we will detect that later on.
			 */
			file->stat.has_sccs = NO_SCCS;
		/*
		 * If this is an s. file, we also enter it as if it
		 * existed in the plain directory.
		 */
		if ((dp->d_name[0] == 's') &&
		    (dp->d_name[1] == (int) period_char)) {

			MBSTOWCS(tmp_wcs_buffer, dp->d_name + 2);
			plain_file_name_p = plain_file_name;
			(void) wcscpy(plain_file_name_p, tmp_wcs_buffer);
			plain_file = GETNAME(plain_file_name, FIND_LENGTH);
			plain_file->stat.is_file = true;
			plain_file->stat.has_sccs = HAS_SCCS;
			/*
			 * Enter the s. file as a dependency for the
			 * plain file.
			 */
			maybe_append_prop(plain_file, sccs_prop)->
			  body.sccs.file = file;
			MBSTOWCS(tmp_wcs_buffer, dp->d_name + 2);
			if ((pattern != NULL) &&
			    amatch(tmp_wcs_buffer, pattern)) {
				if (debug_level > 0) {
					WCSTOMBS(mbs_buffer, pattern);
					(void) printf(gettext("'%s: %s' due to %s expansion\n"),
						      line->body.line.target->
						      string_mb,
						      plain_file->string_mb,
						      mbs_buffer);
				}
				enter_dependency(line, plain_file, false);
				result++;
			}
		}
	      }
	}
	(void) closedir(dir_fd);
	if ((vpath != NULL) && (*vpath != (int) nul_char)) {
		while ((*vpath != (int) nul_char) &&
		       (iswspace(*vpath) || (*vpath == (int) colon_char))) {
			vpath++;
		}
		p = vpath;
		while ((*vpath != (int) colon_char) &&
		       (*vpath != (int) nul_char)) {
			vpath++;
		}
		if (vpath > p) {
			dir = GETNAME(p, vpath - p);
			goto vpath_loop;
		}
	}
/*
 * look into SCCS directory only if it's not svr4. For svr4 dont do that.
 */

/*
 * Now read the SCCS directory.
 * Files in the SCSC directory are considered to be part of the set of
 * files in the plain directory. They are also entered in their own right.
 * Prepare the string where we build the true name of the SCCS files.
 */
	(void) wcsncpy(plain_file_name,
		      file_name,
		      file_name_p - file_name);
	plain_file_name[file_name_p - file_name] = 0;
	plain_file_name_p = plain_file_name + wcslen(plain_file_name);

        if(!svr4) {

	  if (sccs_dir_path != NULL) {
		wchar_t		tmp_wchar;
		wchar_t		path[MAXPATHLEN];
		char		mb_path[MAXPATHLEN];

		if (file_name_p - file_name > 0) {
			tmp_wchar = *file_name_p;
			*file_name_p = 0;
			WCSTOMBS(mbs_buffer, file_name);
			(void) sprintf(mb_path, "%s/%s/SCCS",
				        sccs_dir_path,
				        mbs_buffer);
			*file_name_p = tmp_wchar;
		} else {
			(void) sprintf(mb_path, "%s/SCCS", sccs_dir_path);
		}
		MBSTOWCS(path, mb_path);
		(void) wcscpy(file_name, path);
	  } else {
		MBSTOWCS(wcs_buffer, "SCCS");
		(void) wcscpy(file_name_p, wcs_buffer);
	  }
	} else {
		MBSTOWCS(wcs_buffer, ".");
		(void) wcscpy(file_name_p, wcs_buffer);
	}
	/* Internalize the constructed SCCS dir name. */
	(void) exists(dir = GETNAME(file_name, FIND_LENGTH));
	/* Just give up if the directory file doesnt exist. */
	if (!dir->stat.is_file) {
		return result;
	}
	/* Open the directory. */
	dir_fd = opendir(dir->string_mb);
	if (dir_fd == NULL) {
		return result;
	}
	MBSTOWCS(wcs_buffer, "/");
	(void) wcscat(file_name, wcs_buffer);
	file_name_p = file_name + wcslen(file_name);

	while ((dp = readdir(dir_fd)) != NULL) {
		if ((dp->d_fileno == 0) ||
		    ((dp->d_name[0] == (int) period_char) &&
		     ((dp->d_name[1] == 0) ||
		      ((dp->d_name[1] == (int) period_char) &&
		       (dp->d_name[2] == 0))))) {
			continue;
		}
		/* Construct and internalize the true name of the SCCS file. */
		MBSTOWCS(wcs_buffer, dp->d_name);
		(void) wcscpy(file_name_p, wcs_buffer);
		file = GETNAME(file_name, FIND_LENGTH);
		file->stat.is_file = true;
		file->stat.has_sccs = NO_SCCS;
		/*
		 * If this is an s. file, we also enter it as if it
		 * existed in the plain directory.
		 */
		if ((dp->d_name[0] == 's') &&
		    (dp->d_name[1] == (int) period_char)) {

			MBSTOWCS(wcs_buffer, dp->d_name + 2);
			(void) wcscpy(plain_file_name_p, wcs_buffer);
			plain_file = GETNAME(plain_file_name, FIND_LENGTH);
			plain_file->stat.is_file = true;
			plain_file->stat.has_sccs = HAS_SCCS;
				/* if sccs dependency is already set,skip */
			if(plain_file->prop) {
				Property sprop = get_prop(plain_file->prop,sccs_prop);
				if(sprop != NULL) {
					if (sprop->body.sccs.file) {
						goto try_pattern;
					}
				}
			}

			/*
			 * Enter the s. file as a dependency for the
			 * plain file.
			 */
			maybe_append_prop(plain_file, sccs_prop)->
			  body.sccs.file = file;
try_pattern:
			MBSTOWCS(tmp_wcs_buffer, dp->d_name + 2);
			if ((pattern != NULL) &&
			    amatch(tmp_wcs_buffer, pattern)) {
				if (debug_level > 0) {
					WCSTOMBS(mbs_buffer, pattern);
					(void) printf(gettext("'%s: %s' due to %s expansion\n"),
						      line->body.line.target->
						      string_mb,
						      plain_file->string_mb,
						      mbs_buffer);
				}
				enter_dependency(line, plain_file, false);
				result++;
			}
		}
	}
	(void) closedir(dir_fd);

	return result;
}

/*
 *	enter_file_name(name_string, library)
 *
 *	Helper function for read_dir().
 *
 *	Return value:
 *				The Name that was entered
 *
 *	Parameters:
 *		name_string	Name of the file we want to enter
 *		library		The library it is a member of, if any
 *
 *	Global variables used:
 */
static Name
enter_file_name(wchar_t *name_string, wchar_t *library)
{
	wchar_t		buffer[STRING_BUFFER_LENGTH];
	String_rec	lib_name;
	Name		name;
	Property	prop;

	if (library == NULL) {
		name = GETNAME(name_string, FIND_LENGTH);
		name->stat.is_file = true;
		return name;
	}

	INIT_STRING_FROM_STACK(lib_name, buffer);
	append_string(library, &lib_name, FIND_LENGTH);
	append_char((int) parenleft_char, &lib_name);
	append_string(name_string, &lib_name, FIND_LENGTH);
	append_char((int) parenright_char, &lib_name);

	name = GETNAME(lib_name.buffer.start, FIND_LENGTH);
	name->stat.is_file = true;
	name->is_member = true;
	prop = maybe_append_prop(name, member_prop);
	prop->body.member.library = GETNAME(library, FIND_LENGTH);
	prop->body.member.library->stat.is_file = true;
	prop->body.member.entry = NULL;
	prop->body.member.member = GETNAME(name_string, FIND_LENGTH);
	prop->body.member.member->stat.is_file = true;
	return name;
}

/*
 *	star_match(string, pattern)
 *
 *	This is a regular shell type wildcard pattern matcher
 *	It is used when xpanding wildcards in dependency lists
 *
 *	Return value:
 *				Indication if the string matched the pattern
 *
 *	Parameters:
 *		string		String to match
 *		pattern		Pattern to match it against
 *
 *	Global variables used:
 */
static Boolean
star_match(wchar_t *string, wchar_t *pattern)
{
	int		pattern_ch;

	switch (*pattern) {
	case 0:
		return succeeded;
	case bracketleft_char:
	case question_char:
	case asterisk_char:
		while (*string) {
			if (amatch(string++, pattern)) {
				return succeeded;
			}
		}
		break;
	default:
		pattern_ch = (int) *pattern++;
		while (*string) {
			if ((*string++ == pattern_ch) &&
			    amatch(string, pattern)) {
				return succeeded;
			}
		}
		break;
	}
	return failed;
}

/*
 *	amatch(string, pattern)
 *
 *	Helper function for shell pattern matching
 *
 *	Return value:
 *				Indication if the string matched the pattern
 *
 *	Parameters:
 *		string		String to match
 *		pattern		Pattern to match it against
 *
 *	Global variables used:
 */
static Boolean
amatch(wchar_t *string, wchar_t *pattern)
{
	long		lower_bound;
	long		string_ch;
	long		pattern_ch;
	int		k;

top:
	for (; 1; pattern++, string++) {
		lower_bound = 017777777777;
		string_ch = *string;
		switch (pattern_ch = *pattern) {
		case bracketleft_char:
			k = 0;
			while ((pattern_ch = *++pattern) != 0) {
				switch (pattern_ch) {
				case bracketright_char:
					if (!k) {
						return failed;
					}
					string++;
					pattern++;
					goto top;
				case hyphen_char:
					k |= (lower_bound <= string_ch) &&
					     (string_ch <=
					      (pattern_ch = pattern[1]));
					/* FALLTHROUGH */
				default:
					if (string_ch ==
					    (lower_bound = pattern_ch)) {
						k++;
					}
				}
			}
			return failed;
		case asterisk_char:
			return star_match(string, ++pattern);
		case 0:
			return BOOLEAN(!string_ch);
		case question_char:
			if (string_ch == 0) {
				return failed;
			}
			break;
		default:
			if (pattern_ch != string_ch) {
				return failed;
			}
			break;
		}
	}
	/* NOTREACHED */
}