/*
* 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
*/
/*
*/
#include <dirent.h>
#include <fnmatch.h>
#include <string.h>
#include "bart.h"
static int count_slashes(const char *);
static struct rule *gen_rulestruct(void);
static struct tree_modifier *gen_tree_modifier(void);
static struct dir_component *gen_dir_component(void);
static void add_modifier(struct rule *, char *);
static struct rule *add_subtree_rule(char *, char *, int, int *);
static struct rule *add_single_rule(char *);
static void dirs_cleanup(struct dir_component *);
static void add_dir(struct dir_component **, char *);
static int match_subtree(const char *, char *);
/*
* This function is responsible for validating whether or not a given file
* should be cataloged, based upon the modifiers for a subtree.
* catalog the C files (based upon pattern matching) in the subtree
*
* exclude_fname depends on having the modifiers be pre-sorted to put
* negative directory modifiers first, so that the logic does
* not need to save complex state information. This is valid because
* we are only cataloging things that meet all modifiers (AND logic.)
*
* Returns:
* NO_EXCLUDE
* EXCLUDE_SKIP
* EXCLUDE_PRUNE
*/
int
{
/*
* If this is create and there are no modifiers, bail.
* This will have to change once create handles multiple rules
* during walk.
*/
return (EXCLUDE_PRUNE);
else
return (NO_EXCLUDE);
/*
* Walk through all the modifiers until its they are exhausted OR
* until the file should definitely be excluded.
*/
/* leading !'s were processed in add_modifier */
/*
* Pattern is a file pattern.
*
* In the case when a user is trying to filter on
* a file pattern and the entry is a directory,
* this is not a match.
*
* If a match is required, skip this file. If
* a match is forbidden, keep looking at modifiers.
*/
if (fname_type == 'D') {
return (EXCLUDE_SKIP);
else
continue;
}
/*
* Match patterns against filenames.
* Need to be able to handle multi-level patterns,
* eg. "SCCS/<star-wildcard>.c", which means
* 'only match C files under SCCS directories.
*
* Determine the number of levels in the filename and
* in the pattern.
*/
/* Check for trivial exclude condition */
if (num_pattern_slash > num_fname_slash) {
return (EXCLUDE_SKIP);
}
/*
* Do an apples to apples comparison, based upon the
* number of levels:
*
* Assume fname is /A/B/C/D/E and the pattern is D/E.
* In that case, 'ptr' will point to "D/E" and
* 'slashes_to_adv' will be '4'.
*/
for (i = 0; i < slashes_to_adv; i++) {
ptr++;
}
}
/* OK, now do the fnmatch() compare to the file */
/* matches, is it an exclude? */
return (EXCLUDE_SKIP);
/* failed a required filename match */
return (EXCLUDE_SKIP);
}
} else {
/*
* The rule requires directory matching.
*
* Unlike filename matching, directory matching can
* prune.
*
* First, make copies, since both the pattern and
* filename need to be modified.
*
* When copying 'fname', ignore the relocatable root
* since pattern matching is done for the string AFTER
* the relocatable root. For example, if the
* pattern is "dir3/", we do NOT want to include every
* directory in the relocatable root. Instead, we
* only want to include subtrees that look like:
*
* NOTE: the 'fname_cp' does NOT have a trailing '/':
* necessary for fnmatch().
*/
sizeof (fname_cp));
sizeof (pattern_cp));
/*
* For non-directory files, remove the trailing
* name, e.g., for a file /A/B/C/D where 'D' is
* the actual filename, remove the 'D' since it
* should *not* be considered in the directory match.
*/
if (fname_type != 'D') {
*ptr = '\0';
/*
* Trivial case: a simple filename does
* not match a directory by definition,
* so skip if match is required,
* keep analyzing otherwise.
*/
return (EXCLUDE_SKIP);
}
/* Count the # of slashes in the pattern and fname */
/*
* fname_cp is too short if this is not a dir
*/
if ((num_pattern_slash > num_fname_slash) &&
(fname_type != 'D')) {
return (EXCLUDE_SKIP);
}
/*
* Take the leading '/' from fname_cp before
* decrementing the number of slashes.
*/
if (fname_cp[0] == '/') {
sizeof (fname_cp));
}
/*
* Begin the loop, walk through the file name until
* it can be determined that there is no match.
* For example: if pattern is C/D/, and fname_cp is
* A/B/C/D/E then compare A/B/ with C/D/, if it doesn't
* match, then walk further so that the next iteration
* checks B/C/ against C/D/, continue until we have
* exhausted options.
* In the above case, the 3rd iteration will match
* C/D/ with C/D/.
*/
while (num_pattern_slash <= num_fname_slash) {
/* get a pointer to our filename */
/*
* Walk the filename through the slashes
* so that we have a component of the same
* number of slashes as the pattern.
*/
for (i = 0; i < num_pattern_slash; i++) {
}
/*
* Save the character after our target slash
* before breaking the string for use with
* fnmatch
*/
saved_char = *(++ptr);
*ptr = '\0';
/*
* Call compare function for the current
* component with the pattern we are looking
* for.
*/
FNM_PATHNAME) == 0) {
break;
} else if (fname_type == 'D')
return (EXCLUDE_PRUNE);
else
return (EXCLUDE_SKIP);
if (fname_type == 'D')
return (EXCLUDE_PRUNE);
else
return (EXCLUDE_SKIP);
}
/*
* We didn't match, so restore the saved
* character to the original position.
*/
*ptr = saved_char;
/*
* Break down fname_cp, if it was A/B/C
* then after this operation it will be B/C
* in preparation for the next iteration.
*/
sizeof (fname_cp));
/*
* Decrement the number of slashes to
* compensate for the one removed above.
*/
} /* end while loop looking down the path */
/*
* If we didn't get a match above then we may be on the
* last component of our filename.
* This is to handle the following cases
* - filename is A/B/C/D/E and pattern may be D/E/
* - filename is D/E and pattern may be D/E/
*/
/* strip the trailing slash from the pattern */
*ptr = '\0';
/* fnmatch returns 0 for a match */
FNM_PATHNAME) == 0) {
if (fname_type == 'D')
return (EXCLUDE_PRUNE);
else
return (EXCLUDE_SKIP);
}
return (EXCLUDE_SKIP);
}
}
}
return (NO_EXCLUDE);
}
static int
{
int num_fname_slash = 0;
const char *p;
for (p = in_path; *p != '\0'; p++)
if (*p == '/')
return (num_fname_slash);
}
static struct rule *
gen_rulestruct(void)
{
return (new_rule);
}
static struct tree_modifier *
gen_tree_modifier(void)
{
(sizeof (struct tree_modifier));
return (new_modifier);
}
static struct dir_component *
gen_dir_component(void)
{
(sizeof (struct dir_component));
return (new_dir);
}
/*
* Set up a default rule when there is no rules file.
*/
static struct rule *
{
return (new_rule);
}
/*
* Utility function, used to initialize the flag in a new rule structure.
*/
static void
{
return;
}
/*
* Function to read the rulesfile. Used by both 'bart create' and
* 'bart compare'.
*/
int
{
char *s;
int global_block;
lex_linenum = 0;
check_flag = 0;
ignore_flag = 0;
syntax_err = 0;
global_block = 1;
return (ret_code);
} else if (!create) {
}
/* Read a line from the file */
/* skip blank lines and comments */
if (s == NULL || *s == 0 || *s == '#')
continue;
/*
* Beginning of a subtree and possibly a new block.
*
* If this is a new block, keep track of the beginning of
* the block. if there are directives later on, we need to
* apply that directive to all members of the block.
*
* If the first stmt in the file was an 'IGNORE all' or
* 'IGNORE contents', we need to keep track of it and
* automatically switch off contents checking for new
* subtrees.
*/
if (s[0] == '/') {
/* subtree definition hence not a global block */
global_block = 0;
&ret_code);
s = lex(0);
while ((s != NULL) && (*s != 0) && (*s != '#')) {
add_modifier(new_rule, s);
s = lex(0);
}
/* Found a new block, keep track of the beginning */
if (block_begin == NULL ||
(ignore_flag != 0) || (check_flag != 0)) {
check_flag = 0;
ignore_flag = 0;
}
/* Apply global settings to this block, if any */
} else if (IGNORE_KEYWORD(s) || CHECK_KEYWORD(s)) {
int check_kw;
if (IGNORE_KEYWORD(s)) {
ignore_flag++;
check_kw = 0;
} else {
check_flag++;
check_kw = 1;
}
/* Parse next token */
s = lex(0);
while ((s != NULL) && (*s != 0) && (*s != '#')) {
akp = attr_keylookup(s);
syntax_err++;
exit(2);
}
/*
* For all the flags, check if this is a global
*
* NOTE: The only time you can have a
* global ignore is when its the
* stmt before any blocks have been
* spec'd.
*/
if (global_block) {
if (check_kw)
else
} else {
if (check_kw)
else
}
}
/* Parse next token */
s = lex(0);
}
} else {
s = lex(0);
while (s != NULL && *s != 0) {
s = lex(0);
}
syntax_err++;
}
}
if (syntax_err) {
exit(2);
}
return (ret_code);
}
/*
* Add a modifier to the mod_ptr list in each rule, putting negative
* directory entries
* first to guarantee walks will be appropriately pruned.
*/
static void
{
int include, is_dir;
char *pattern;
include = B_TRUE;
/* see if the pattern is an include or an exclude */
if (pattern[0] == '!') {
include = B_FALSE;
pattern++;
}
new_mod_ptr->include = include;
if (is_dir && !include) {
else {
}
}
}
/*
* This funtion is invoked when reading rulesfiles. A subtree may have
* wildcards in it, e.g., '/home/n*', which is expected to match all home
* dirs which start with an 'n'.
*
* This function needs to break down the subtree into its components. For
* each component, see how many directories match. Take the subtree list just
* generated and run it through again, this time looking at the next component.
* At each iteration, keep a linked list of subtrees that currently match.
* Once the final list is created, invoke add_single_rule() to create the
* rule struct with the correct information.
*
* This function returns a ptr to the first element in the block of subtrees
* which matched the subtree def'n in the rulesfile.
*/
static struct rule *
{
int ret;
/*
* In the case of 'bart compare', don't validate
* the subtrees, since the machine running the
* comparison may not be the machine which generated
* the manifest.
*/
if (create == 0)
return (add_single_rule(full_path));
/* Insert 'current_level' into the linked list */
/* Special case: occurs when -R is "/" and the subtree is "/" */
while (beg_pattern != NULL) {
/*
* Extract the pathname component starting at 'beg_pattern'.
* Take those chars and put them into 'pattern'.
*/
while (*beg_pattern == '/')
beg_pattern++;
break;
if (end_pattern != NULL)
else
/*
* At this point, search for 'pattern' as a *subdirectory* of
* the dirs in the linked list.
*/
while (current_level != NULL) {
/* curr_dirname used to make the code more readable */
/* Initialization case */
if (strlen(curr_dirname) == 0)
/* Open up the dir for this element in the list */
*err_code = WARNING_EXIT;
} else
/*
* Now iterate through the subdirs of 'curr_dirname'
* In the case of a match against 'pattern',
* add the path to the next linked list, which
* will be matched on the next iteration.
*/
/* Skip the dirs "." and ".." */
continue;
}
FNM_PATHNAME) == 0) {
/*
* Build 'new_dirname' which will be
* examined on the next iteration.
*/
!= '/')
(void) snprintf(new_dirname,
sizeof (new_dirname),
"%s/%s", curr_dirname,
else
(void) snprintf(new_dirname,
sizeof (new_dirname),
"%s%s", curr_dirname,
/* Add to the next lined list */
}
}
/* Close directory */
/* Free this entry and move on.... */
}
/*
* OK, done with this level. Move to the next level and
* advance the ptrs which indicate the component name.
*/
next_level = NULL;
}
/* Error case: the subtree doesn't exist! */
if (current_level == NULL) {
*err_code = WARNING_EXIT;
}
/*
* Iterate through all the dirnames which match the pattern and
* add them to to global list of subtrees which must be examined.
*/
while (current_level != NULL) {
/*
* Sanity check for 'bart create', make sure the subtree
* points to a valid object.
*/
if (ret < 0) {
*err_code = WARNING_EXIT;
continue;
}
if (begin_rule == NULL) {
} else
}
/*
* Free up the memory and return a ptr to the first entry in the
* subtree block. This is necessary for the parser, which may need
* to add modifier strings to all the elements in this block.
*/
return (begin_rule);
}
/*
* Add a single entry to the linked list of rules to be read. Does not do
* the wildcard expansion of 'add_subtree_rule', so is much simpler.
*/
static struct rule *
{
/*
* If the rules list does NOT exist, then create it.
* If the rules list does exist, then traverse the next element.
*/
if (first_rule == NULL) {
first_rule = gen_rulestruct();
} else {
}
/* Setup the rule struct, handle relocatable roots, i.e. '-R' option */
sizeof (current_rule->subtree));
return (current_rule);
}
/*
* Code stolen from filesync utility, used by read_rules() to read in the
* rulesfile.
*/
static char *
{
char c, delim;
char *p;
char *s;
static char *savep;
if (file) { /* read a new line */
s = inbuf;
/* read the next input line, with all continuations */
lex_linenum++;
/* go find the last character of the input line */
while (*s && s[1])
s++;
if (*s == '\n')
s--;
/* see whether or not we need a continuation */
if (s < inbuf || *s != '\\')
break;
continue;
}
return (0);
s = inbuf;
} else { /* continue with old line */
return (0);
s = savep;
}
/* skip over leading white space */
while (isspace(*s))
s++;
if (*s == 0)
return (0);
/* see if this is a quoted string */
c = *s;
if (c == '\'' || c == '"') {
delim = c;
s++;
} else
delim = 0;
/* copy the token into the buffer */
for (p = namebuf; (c = *s) != 0; s++) {
/* literal escape */
if (c == '\\') {
s++;
*p++ = *s;
continue;
}
/* closing delimiter */
if (c == delim) {
s++;
break;
}
/* delimiting white space */
break;
/* ordinary characters */
*p++ = *s;
}
/* remember where we left off */
savep = *s ? s : 0;
/* null terminate and return the buffer */
*p = 0;
return (namebuf);
}
/*
* Iterate through the dir strcutures and free memory.
*/
static void
{
}
}
/*
* Create and initialize a new dir structure. Used by add_subtree_rule() when
* doing expansion of directory names caused by wildcards.
*/
static void
{
new = gen_dir_component();
else {
}
}
/*
* Traverse the linked list of rules in a REVERSE order.
*/
static struct rule *
{
if (reset) {
/* RESET: set cur_root to the end of the list */
break;
else
} else
return (curr_root);
}
/*
* Traverse the first entry, used by 'bart create' to iterate through
* subtrees or individual filenames.
*/
struct rule *
{
return (first_rule);
}
/*
* Traverse the next entry, used by 'bart create' to iterate through
* subtrees or individual filenames.
*/
struct rule *
{
}
char *
safe_strdup(char *s)
{
char *ret;
return (ret);
}
/*
* Function to match a filename against the subtrees in the link list
* of 'rule' strcutures. Upon finding a matching rule, see if it should
* be excluded. Keep going until a match is found OR all rules have been
* exhausted.
* NOTES: Rules are parsed in reverse;
* satisfies the spec that "Last rule wins". Also, the default rule should
* always match, so this function should NEVER return NULL.
*/
struct rule *
{
break;
}
}
return (root);
}
/*
* Function to determine if an entry in a rules file (see bart_rules(4)) applies
* to a filename. We truncate "fname" such that it has the same number of
* components as "rule" and let fnmatch(3C) do the rest. A "component" is one
* part of an fname as delimited by slashes ('/'). So "/A/B/C/D" has four
* components: "A", "B", "C" and "D".
*
* For example:
*
* should match.
*
*/
static int
{
/* If rule has more components than fname, it cannot match. */
return (0);
/* Create a copy of fname that we can truncate. */
/*
* Truncate fname_cp such that it has the same number of components
* as rule. If rule ends with '/', so should fname_cp. ie:
*
* rule fname fname_cp matches
* ---- ----- -------- -------
*/
while (*ptr != '\0') {
if (*ptr == '/')
break;
ptr++;
}
}
*ptr = '\0';
/* OK, now see if they match. */
/* No match, return failure */
if (match != 0)
return (0);
else
return (1);
}
void
{
char *cp;
if (ignore_list == NULL)
usage();
cp);
else
}
}