int
samepath(char *a, char *b)
{
char a1[MAXPATH],b1[MAXPATH];
fullname(a, a1);
fullname(b, b1);
return (patheq(a1, b1));
}
static void
set_builtins_path(void)
{
register unsigned char *path;
ucb_builtins = 0;
path = getpath("");
while (path && *path)
{
if (patheq(path, "/usr/ucb"))
{
ucb_builtins++;
break;
}
else if (patheq(path, "/usr/bin"))
break;
else if (patheq(path, "/bin"))
break;
else if (patheq(path, "/usr/5bin"))
break;
path = nextpath(path);
}
}
/*
* Is the given file in the given directory?
*/
int os_is_file_in_dir(const char *filename, const char *path,
int allow_subdirs, int match_self)
{
char filename_buf[OSFNMAX], path_buf[OSFNMAX];
size_t flen, plen;
int endsep = FALSE;
/* absolute-ize the filename, if necessary */
if (!os_is_file_absolute(filename))
{
os_get_abs_filename(filename_buf, sizeof(filename_buf), filename);
filename = filename_buf;
}
/* absolute-ize the path, if necessary */
if (!os_is_file_absolute(path))
{
os_get_abs_filename(path_buf, sizeof(path_buf), path);
path = path_buf;
}
/*
* canonicalize the paths, to remove .. and . elements - this will make
* it possible to directly compare the path strings
*/
safe_strcpy(filename_buf, sizeof(filename_buf), filename);
canonicalize_path(filename_buf);
filename = filename_buf;
safe_strcpy(path_buf, sizeof(path_buf), path);
canonicalize_path(path_buf);
path = path_buf;
/* get the length of the filename and the length of the path */
flen = strlen(filename);
plen = strlen(path);
/*
* If the path ends in a separator character, ignore that. Exception:
* if the path is a root path, leave the separator intact.
*/
if (plen > 0 && (path[plen-1] == '\\' || path[plen-1] == '/')
&& !is_root_path(path))
--plen;
/* if the path still ends in a path separator, so note */
endsep = (plen > 0 && (path[plen-1] == '\\' || path[plen-1] == '/'));
/*
* if the names match, return true if and only if the caller wants
* us to match the directory to itself
*/
if (flen == plen && memicmp(filename, path, flen) == 0)
return match_self;
/*
* Check that the filename has 'path' as its path prefix. First, check
* that the leading substring of the filename matches 'path', ignoring
* case. Note that we need the filename to be at least two characters
* longer than the path: it must have a path separator after the path
* name, and at least one character for a filename past that.
* Exception: if the path already ends in a path separator, we don't
* need to add another one, so the filename just needs to be one
* character longer.
*/
if (flen < plen + (endsep ? 1 : 2) || !patheq(filename, path, plen))
return FALSE;
/*
* Okay, 'path' is the leading substring of 'filename'; next make sure
* that this prefix actually ends at a path separator character in the
* filename. (This is necessary so that we don't confuse "c:\a\b.txt"
* as matching "c:\abc\d.txt" - if we only matched the "c:\a" prefix,
* we'd miss the fact that the file is actually in directory "c:\abc",
* not "c:\a".) If the path itself ends in a path separator, we've
* made this check already simply by the substring match.
*/
if (!endsep && (filename[plen] != '\\' && filename[plen] != '/'))
return FALSE;
/*
* We're good on the path prefix - we definitely have a file that's
* within the 'path' directory or one of its subdirectories. If we're
* allowed to match on subdirectories, we already have our answer
* (true). If we're not allowed to match subdirectories, we still have
* one more check, which is that the rest of the filename is free of
* path separator charactres. If it is, we have a file that's directly
* in the 'path' directory; otherwise it's in a subdirectory of 'path'
* and thus isn't a match.
*/
if (allow_subdirs)
{
/*
* filename is in the 'path' directory or one of its
* subdirectories, and we're allowed to match on subdirectories, so
* we have a match
*/
return TRUE;
}
else
{
const char *p;
/*
* We're not allowed to match subdirectories, so scan the rest of
* the filename for path separators. If we find any, the file is
* in a subdirectory of 'path' rather than directly in 'path'
* itself, so it's not a match. If we don't find any separators,
* we have a file directly in 'path', so it's a match.
*/
for (p = filename + plen + (endsep ? 1 : 0) ;
*p != '\0' && *p != '/' && *p != '\\' ; ++p) ;
/*
* if we reached the end of the string without finding a path
* separator character, it's a match
*/
return (*p == '\0');
}
}
