- Fix for possible unset uid/gid in toproto - Fix for default mtree style - Update libelf - Importing libexecinfo - Resynchronize GCC, mpc, gmp, mpfr - build.sh: Replace params with show-params. This has been done as the make target has been renamed in the same way, while a new target named params has been added. This new target generates a file containing all the parameters, instead of printing it on the console. - Update test48 with new etc/services (Fix by Ben Gras <ben@minix3.org) get getservbyport() out of the inner loop Change-Id: Ie6ad5226fa2621ff9f0dee8782ea48f9443d2091
888 lines
21 KiB
C
888 lines
21 KiB
C
/*
|
|
* Automated Testing Framework (atf)
|
|
*
|
|
* Copyright (c) 2007 The NetBSD Foundation, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
|
|
* CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
|
|
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
|
|
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
|
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#if defined(HAVE_CONFIG_H)
|
|
#include "bconfig.h"
|
|
#endif
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/param.h>
|
|
#include <sys/mount.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/wait.h>
|
|
|
|
#include <dirent.h>
|
|
#include <errno.h>
|
|
#include <libgen.h>
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include "atf-c/defs.h"
|
|
#include "atf-c/error.h"
|
|
|
|
#include "fs.h"
|
|
#include "sanity.h"
|
|
#include "text.h"
|
|
#include "user.h"
|
|
|
|
/* ---------------------------------------------------------------------
|
|
* Prototypes for auxiliary functions.
|
|
* --------------------------------------------------------------------- */
|
|
|
|
static bool check_umask(const mode_t, const mode_t);
|
|
static atf_error_t copy_contents(const atf_fs_path_t *, char **);
|
|
static mode_t current_umask(void);
|
|
static atf_error_t do_mkdtemp(char *);
|
|
static atf_error_t normalize(atf_dynstr_t *, char *);
|
|
static atf_error_t normalize_ap(atf_dynstr_t *, const char *, va_list);
|
|
static void replace_contents(atf_fs_path_t *, const char *);
|
|
static const char *stat_type_to_string(const int);
|
|
|
|
/* ---------------------------------------------------------------------
|
|
* The "invalid_umask" error type.
|
|
* --------------------------------------------------------------------- */
|
|
|
|
struct invalid_umask_error_data {
|
|
/* One of atf_fs_stat_*_type. */
|
|
int m_type;
|
|
|
|
/* The original path causing the error. */
|
|
/* XXX: Ideally this would be an atf_fs_path_t, but if we create it
|
|
* from the error constructor, we cannot delete the path later on.
|
|
* Can't remember why atf_error_new does not take a hook for
|
|
* deletion. */
|
|
char m_path[1024];
|
|
|
|
/* The umask that caused the error. */
|
|
mode_t m_umask;
|
|
};
|
|
typedef struct invalid_umask_error_data invalid_umask_error_data_t;
|
|
|
|
static
|
|
void
|
|
invalid_umask_format(const atf_error_t err, char *buf, size_t buflen)
|
|
{
|
|
const invalid_umask_error_data_t *data;
|
|
|
|
PRE(atf_error_is(err, "invalid_umask"));
|
|
|
|
data = atf_error_data(err);
|
|
snprintf(buf, buflen, "Could not create the temporary %s %s because "
|
|
"it will not have enough access rights due to the current "
|
|
"umask %05o", stat_type_to_string(data->m_type),
|
|
data->m_path, (unsigned int)data->m_umask);
|
|
}
|
|
|
|
static
|
|
atf_error_t
|
|
invalid_umask_error(const atf_fs_path_t *path, const int type,
|
|
const mode_t failing_mask)
|
|
{
|
|
atf_error_t err;
|
|
invalid_umask_error_data_t data;
|
|
|
|
data.m_type = type;
|
|
|
|
strncpy(data.m_path, atf_fs_path_cstring(path), sizeof(data.m_path));
|
|
data.m_path[sizeof(data.m_path) - 1] = '\0';
|
|
|
|
data.m_umask = failing_mask;
|
|
|
|
err = atf_error_new("invalid_umask", &data, sizeof(data),
|
|
invalid_umask_format);
|
|
|
|
return err;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------
|
|
* The "unknown_file_type" error type.
|
|
* --------------------------------------------------------------------- */
|
|
|
|
struct unknown_type_error_data {
|
|
const char *m_path;
|
|
int m_type;
|
|
};
|
|
typedef struct unknown_type_error_data unknown_type_error_data_t;
|
|
|
|
static
|
|
void
|
|
unknown_type_format(const atf_error_t err, char *buf, size_t buflen)
|
|
{
|
|
const unknown_type_error_data_t *data;
|
|
|
|
PRE(atf_error_is(err, "unknown_type"));
|
|
|
|
data = atf_error_data(err);
|
|
snprintf(buf, buflen, "Unknown file type %d of %s", data->m_type,
|
|
data->m_path);
|
|
}
|
|
|
|
static
|
|
atf_error_t
|
|
unknown_type_error(const char *path, int type)
|
|
{
|
|
atf_error_t err;
|
|
unknown_type_error_data_t data;
|
|
|
|
data.m_path = path;
|
|
data.m_type = type;
|
|
|
|
err = atf_error_new("unknown_type", &data, sizeof(data),
|
|
unknown_type_format);
|
|
|
|
return err;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------
|
|
* Auxiliary functions.
|
|
* --------------------------------------------------------------------- */
|
|
|
|
static
|
|
bool
|
|
check_umask(const mode_t exp_mode, const mode_t min_mode)
|
|
{
|
|
const mode_t actual_mode = (~current_umask() & exp_mode);
|
|
return (actual_mode & min_mode) == min_mode;
|
|
}
|
|
|
|
static
|
|
atf_error_t
|
|
copy_contents(const atf_fs_path_t *p, char **buf)
|
|
{
|
|
atf_error_t err;
|
|
char *str;
|
|
|
|
str = (char *)malloc(atf_dynstr_length(&p->m_data) + 1);
|
|
if (str == NULL)
|
|
err = atf_no_memory_error();
|
|
else {
|
|
strcpy(str, atf_dynstr_cstring(&p->m_data));
|
|
*buf = str;
|
|
err = atf_no_error();
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static
|
|
mode_t
|
|
current_umask(void)
|
|
{
|
|
const mode_t current = umask(0);
|
|
(void)umask(current);
|
|
return current;
|
|
}
|
|
|
|
static
|
|
atf_error_t
|
|
do_mkdtemp(char *tmpl)
|
|
{
|
|
atf_error_t err;
|
|
|
|
PRE(strstr(tmpl, "XXXXXX") != NULL);
|
|
|
|
if (mkdtemp(tmpl) == NULL)
|
|
err = atf_libc_error(errno, "Cannot create temporary directory "
|
|
"with template '%s'", tmpl);
|
|
else
|
|
err = atf_no_error();
|
|
|
|
return err;
|
|
}
|
|
|
|
static
|
|
atf_error_t
|
|
do_mkstemp(char *tmpl, int *fdout)
|
|
{
|
|
atf_error_t err;
|
|
|
|
PRE(strstr(tmpl, "XXXXXX") != NULL);
|
|
|
|
*fdout = mkstemp(tmpl);
|
|
if (*fdout == -1)
|
|
err = atf_libc_error(errno, "Cannot create temporary file "
|
|
"with template '%s'", tmpl);
|
|
|
|
else
|
|
err = atf_no_error();
|
|
|
|
return err;
|
|
}
|
|
|
|
static
|
|
atf_error_t
|
|
normalize(atf_dynstr_t *d, char *p)
|
|
{
|
|
const char *ptr;
|
|
char *last;
|
|
atf_error_t err;
|
|
bool first;
|
|
|
|
PRE(strlen(p) > 0);
|
|
PRE(atf_dynstr_length(d) == 0);
|
|
|
|
if (p[0] == '/')
|
|
err = atf_dynstr_append_fmt(d, "/");
|
|
else
|
|
err = atf_no_error();
|
|
|
|
first = true;
|
|
last = NULL; /* Silence GCC warning. */
|
|
ptr = strtok_r(p, "/", &last);
|
|
while (!atf_is_error(err) && ptr != NULL) {
|
|
if (strlen(ptr) > 0) {
|
|
err = atf_dynstr_append_fmt(d, "%s%s", first ? "" : "/", ptr);
|
|
first = false;
|
|
}
|
|
|
|
ptr = strtok_r(NULL, "/", &last);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static
|
|
atf_error_t
|
|
normalize_ap(atf_dynstr_t *d, const char *p, va_list ap)
|
|
{
|
|
char *str;
|
|
atf_error_t err;
|
|
va_list ap2;
|
|
|
|
err = atf_dynstr_init(d);
|
|
if (atf_is_error(err))
|
|
goto out;
|
|
|
|
va_copy(ap2, ap);
|
|
err = atf_text_format_ap(&str, p, ap2);
|
|
va_end(ap2);
|
|
if (atf_is_error(err))
|
|
atf_dynstr_fini(d);
|
|
else {
|
|
err = normalize(d, str);
|
|
free(str);
|
|
}
|
|
|
|
out:
|
|
return err;
|
|
}
|
|
|
|
static
|
|
void
|
|
replace_contents(atf_fs_path_t *p, const char *buf)
|
|
{
|
|
atf_error_t err;
|
|
|
|
PRE(atf_dynstr_length(&p->m_data) == strlen(buf));
|
|
|
|
atf_dynstr_clear(&p->m_data);
|
|
err = atf_dynstr_append_fmt(&p->m_data, "%s", buf);
|
|
|
|
INV(!atf_is_error(err));
|
|
}
|
|
|
|
static
|
|
const char *
|
|
stat_type_to_string(const int type)
|
|
{
|
|
const char *str;
|
|
|
|
if (type == atf_fs_stat_blk_type)
|
|
str = "block device";
|
|
else if (type == atf_fs_stat_chr_type)
|
|
str = "character device";
|
|
else if (type == atf_fs_stat_dir_type)
|
|
str = "directory";
|
|
else if (type == atf_fs_stat_fifo_type)
|
|
str = "named pipe";
|
|
else if (type == atf_fs_stat_lnk_type)
|
|
str = "symbolic link";
|
|
else if (type == atf_fs_stat_reg_type)
|
|
str = "regular file";
|
|
else if (type == atf_fs_stat_sock_type)
|
|
str = "socket";
|
|
else if (type == atf_fs_stat_wht_type)
|
|
str = "whiteout";
|
|
else {
|
|
UNREACHABLE;
|
|
str = NULL;
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------
|
|
* The "atf_fs_path" type.
|
|
* --------------------------------------------------------------------- */
|
|
|
|
/*
|
|
* Constructors/destructors.
|
|
*/
|
|
|
|
atf_error_t
|
|
atf_fs_path_init_ap(atf_fs_path_t *p, const char *fmt, va_list ap)
|
|
{
|
|
atf_error_t err;
|
|
va_list ap2;
|
|
|
|
va_copy(ap2, ap);
|
|
err = normalize_ap(&p->m_data, fmt, ap2);
|
|
va_end(ap2);
|
|
|
|
return err;
|
|
}
|
|
|
|
atf_error_t
|
|
atf_fs_path_init_fmt(atf_fs_path_t *p, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
atf_error_t err;
|
|
|
|
va_start(ap, fmt);
|
|
err = atf_fs_path_init_ap(p, fmt, ap);
|
|
va_end(ap);
|
|
|
|
return err;
|
|
}
|
|
|
|
atf_error_t
|
|
atf_fs_path_copy(atf_fs_path_t *dest, const atf_fs_path_t *src)
|
|
{
|
|
return atf_dynstr_copy(&dest->m_data, &src->m_data);
|
|
}
|
|
|
|
void
|
|
atf_fs_path_fini(atf_fs_path_t *p)
|
|
{
|
|
atf_dynstr_fini(&p->m_data);
|
|
}
|
|
|
|
/*
|
|
* Getters.
|
|
*/
|
|
|
|
atf_error_t
|
|
atf_fs_path_branch_path(const atf_fs_path_t *p, atf_fs_path_t *bp)
|
|
{
|
|
const size_t endpos = atf_dynstr_rfind_ch(&p->m_data, '/');
|
|
atf_error_t err;
|
|
|
|
if (endpos == atf_dynstr_npos)
|
|
err = atf_fs_path_init_fmt(bp, ".");
|
|
else if (endpos == 0)
|
|
err = atf_fs_path_init_fmt(bp, "/");
|
|
else
|
|
err = atf_dynstr_init_substr(&bp->m_data, &p->m_data, 0, endpos);
|
|
|
|
#if defined(HAVE_CONST_DIRNAME)
|
|
INV(atf_equal_dynstr_cstring(&bp->m_data,
|
|
dirname(atf_dynstr_cstring(&p->m_data))));
|
|
#endif /* defined(HAVE_CONST_DIRNAME) */
|
|
|
|
return err;
|
|
}
|
|
|
|
const char *
|
|
atf_fs_path_cstring(const atf_fs_path_t *p)
|
|
{
|
|
return atf_dynstr_cstring(&p->m_data);
|
|
}
|
|
|
|
atf_error_t
|
|
atf_fs_path_leaf_name(const atf_fs_path_t *p, atf_dynstr_t *ln)
|
|
{
|
|
size_t begpos = atf_dynstr_rfind_ch(&p->m_data, '/');
|
|
atf_error_t err;
|
|
|
|
if (begpos == atf_dynstr_npos)
|
|
begpos = 0;
|
|
else
|
|
begpos++;
|
|
|
|
err = atf_dynstr_init_substr(ln, &p->m_data, begpos, atf_dynstr_npos);
|
|
|
|
#if defined(HAVE_CONST_BASENAME)
|
|
INV(atf_equal_dynstr_cstring(ln,
|
|
basename(atf_dynstr_cstring(&p->m_data))));
|
|
#endif /* defined(HAVE_CONST_BASENAME) */
|
|
|
|
return err;
|
|
}
|
|
|
|
bool
|
|
atf_fs_path_is_absolute(const atf_fs_path_t *p)
|
|
{
|
|
return atf_dynstr_cstring(&p->m_data)[0] == '/';
|
|
}
|
|
|
|
bool
|
|
atf_fs_path_is_root(const atf_fs_path_t *p)
|
|
{
|
|
return atf_equal_dynstr_cstring(&p->m_data, "/");
|
|
}
|
|
|
|
/*
|
|
* Modifiers.
|
|
*/
|
|
|
|
atf_error_t
|
|
atf_fs_path_append_ap(atf_fs_path_t *p, const char *fmt, va_list ap)
|
|
{
|
|
atf_dynstr_t aux;
|
|
atf_error_t err;
|
|
va_list ap2;
|
|
|
|
va_copy(ap2, ap);
|
|
err = normalize_ap(&aux, fmt, ap2);
|
|
va_end(ap2);
|
|
if (!atf_is_error(err)) {
|
|
const char *auxstr = atf_dynstr_cstring(&aux);
|
|
const bool needslash = auxstr[0] != '/';
|
|
|
|
err = atf_dynstr_append_fmt(&p->m_data, "%s%s",
|
|
needslash ? "/" : "", auxstr);
|
|
|
|
atf_dynstr_fini(&aux);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
atf_error_t
|
|
atf_fs_path_append_fmt(atf_fs_path_t *p, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
atf_error_t err;
|
|
|
|
va_start(ap, fmt);
|
|
err = atf_fs_path_append_ap(p, fmt, ap);
|
|
va_end(ap);
|
|
|
|
return err;
|
|
}
|
|
|
|
atf_error_t
|
|
atf_fs_path_append_path(atf_fs_path_t *p, const atf_fs_path_t *p2)
|
|
{
|
|
return atf_fs_path_append_fmt(p, "%s", atf_dynstr_cstring(&p2->m_data));
|
|
}
|
|
|
|
atf_error_t
|
|
atf_fs_path_to_absolute(const atf_fs_path_t *p, atf_fs_path_t *pa)
|
|
{
|
|
atf_error_t err;
|
|
|
|
PRE(!atf_fs_path_is_absolute(p));
|
|
|
|
err = atf_fs_getcwd(pa);
|
|
if (atf_is_error(err))
|
|
goto out;
|
|
|
|
err = atf_fs_path_append_path(pa, p);
|
|
if (atf_is_error(err))
|
|
atf_fs_path_fini(pa);
|
|
|
|
out:
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* Operators.
|
|
*/
|
|
|
|
bool atf_equal_fs_path_fs_path(const atf_fs_path_t *p1,
|
|
const atf_fs_path_t *p2)
|
|
{
|
|
return atf_equal_dynstr_dynstr(&p1->m_data, &p2->m_data);
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------
|
|
* The "atf_fs_path" type.
|
|
* --------------------------------------------------------------------- */
|
|
|
|
/*
|
|
* Constants.
|
|
*/
|
|
|
|
const int atf_fs_stat_blk_type = 1;
|
|
const int atf_fs_stat_chr_type = 2;
|
|
const int atf_fs_stat_dir_type = 3;
|
|
const int atf_fs_stat_fifo_type = 4;
|
|
const int atf_fs_stat_lnk_type = 5;
|
|
const int atf_fs_stat_reg_type = 6;
|
|
const int atf_fs_stat_sock_type = 7;
|
|
const int atf_fs_stat_wht_type = 8;
|
|
|
|
/*
|
|
* Constructors/destructors.
|
|
*/
|
|
|
|
atf_error_t
|
|
atf_fs_stat_init(atf_fs_stat_t *st, const atf_fs_path_t *p)
|
|
{
|
|
atf_error_t err;
|
|
const char *pstr = atf_fs_path_cstring(p);
|
|
|
|
if (lstat(pstr, &st->m_sb) == -1) {
|
|
err = atf_libc_error(errno, "Cannot get information of %s; "
|
|
"lstat(2) failed", pstr);
|
|
} else {
|
|
int type = st->m_sb.st_mode & S_IFMT;
|
|
err = atf_no_error();
|
|
switch (type) {
|
|
case S_IFBLK: st->m_type = atf_fs_stat_blk_type; break;
|
|
case S_IFCHR: st->m_type = atf_fs_stat_chr_type; break;
|
|
case S_IFDIR: st->m_type = atf_fs_stat_dir_type; break;
|
|
case S_IFIFO: st->m_type = atf_fs_stat_fifo_type; break;
|
|
case S_IFLNK: st->m_type = atf_fs_stat_lnk_type; break;
|
|
case S_IFREG: st->m_type = atf_fs_stat_reg_type; break;
|
|
case S_IFSOCK: st->m_type = atf_fs_stat_sock_type; break;
|
|
#if defined(S_IFWHT)
|
|
case S_IFWHT: st->m_type = atf_fs_stat_wht_type; break;
|
|
#endif
|
|
default:
|
|
err = unknown_type_error(pstr, type);
|
|
}
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
void
|
|
atf_fs_stat_copy(atf_fs_stat_t *dest, const atf_fs_stat_t *src)
|
|
{
|
|
dest->m_type = src->m_type;
|
|
dest->m_sb = src->m_sb;
|
|
}
|
|
|
|
void
|
|
atf_fs_stat_fini(atf_fs_stat_t *st ATF_DEFS_ATTRIBUTE_UNUSED)
|
|
{
|
|
}
|
|
|
|
/*
|
|
* Getters.
|
|
*/
|
|
|
|
dev_t
|
|
atf_fs_stat_get_device(const atf_fs_stat_t *st)
|
|
{
|
|
return st->m_sb.st_dev;
|
|
}
|
|
|
|
ino_t
|
|
atf_fs_stat_get_inode(const atf_fs_stat_t *st)
|
|
{
|
|
return st->m_sb.st_ino;
|
|
}
|
|
|
|
mode_t
|
|
atf_fs_stat_get_mode(const atf_fs_stat_t *st)
|
|
{
|
|
return st->m_sb.st_mode & ~S_IFMT;
|
|
}
|
|
|
|
off_t
|
|
atf_fs_stat_get_size(const atf_fs_stat_t *st)
|
|
{
|
|
return st->m_sb.st_size;
|
|
}
|
|
|
|
int
|
|
atf_fs_stat_get_type(const atf_fs_stat_t *st)
|
|
{
|
|
return st->m_type;
|
|
}
|
|
|
|
bool
|
|
atf_fs_stat_is_owner_readable(const atf_fs_stat_t *st)
|
|
{
|
|
return st->m_sb.st_mode & S_IRUSR;
|
|
}
|
|
|
|
bool
|
|
atf_fs_stat_is_owner_writable(const atf_fs_stat_t *st)
|
|
{
|
|
return st->m_sb.st_mode & S_IWUSR;
|
|
}
|
|
|
|
bool
|
|
atf_fs_stat_is_owner_executable(const atf_fs_stat_t *st)
|
|
{
|
|
return st->m_sb.st_mode & S_IXUSR;
|
|
}
|
|
|
|
bool
|
|
atf_fs_stat_is_group_readable(const atf_fs_stat_t *st)
|
|
{
|
|
return st->m_sb.st_mode & S_IRGRP;
|
|
}
|
|
|
|
bool
|
|
atf_fs_stat_is_group_writable(const atf_fs_stat_t *st)
|
|
{
|
|
return st->m_sb.st_mode & S_IWGRP;
|
|
}
|
|
|
|
bool
|
|
atf_fs_stat_is_group_executable(const atf_fs_stat_t *st)
|
|
{
|
|
return st->m_sb.st_mode & S_IXGRP;
|
|
}
|
|
|
|
bool
|
|
atf_fs_stat_is_other_readable(const atf_fs_stat_t *st)
|
|
{
|
|
return st->m_sb.st_mode & S_IROTH;
|
|
}
|
|
|
|
bool
|
|
atf_fs_stat_is_other_writable(const atf_fs_stat_t *st)
|
|
{
|
|
return st->m_sb.st_mode & S_IWOTH;
|
|
}
|
|
|
|
bool
|
|
atf_fs_stat_is_other_executable(const atf_fs_stat_t *st)
|
|
{
|
|
return st->m_sb.st_mode & S_IXOTH;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------
|
|
* Free functions.
|
|
* --------------------------------------------------------------------- */
|
|
|
|
const int atf_fs_access_f = 1 << 0;
|
|
const int atf_fs_access_r = 1 << 1;
|
|
const int atf_fs_access_w = 1 << 2;
|
|
const int atf_fs_access_x = 1 << 3;
|
|
|
|
/*
|
|
* An implementation of access(2) but using the effective user value
|
|
* instead of the real one. Also avoids false positives for root when
|
|
* asking for execute permissions, which appear in SunOS.
|
|
*/
|
|
atf_error_t
|
|
atf_fs_eaccess(const atf_fs_path_t *p, int mode)
|
|
{
|
|
atf_error_t err;
|
|
struct stat st;
|
|
bool ok;
|
|
|
|
PRE(mode & atf_fs_access_f || mode & atf_fs_access_r ||
|
|
mode & atf_fs_access_w || mode & atf_fs_access_x);
|
|
|
|
if (lstat(atf_fs_path_cstring(p), &st) == -1) {
|
|
err = atf_libc_error(errno, "Cannot get information from file %s",
|
|
atf_fs_path_cstring(p));
|
|
goto out;
|
|
}
|
|
|
|
err = atf_no_error();
|
|
|
|
/* Early return if we are only checking for existence and the file
|
|
* exists (stat call returned). */
|
|
if (mode & atf_fs_access_f)
|
|
goto out;
|
|
|
|
ok = false;
|
|
if (atf_user_is_root()) {
|
|
if (!ok && !(mode & atf_fs_access_x)) {
|
|
/* Allow root to read/write any file. */
|
|
ok = true;
|
|
}
|
|
|
|
if (!ok && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) {
|
|
/* Allow root to execute the file if any of its execution bits
|
|
* are set. */
|
|
ok = true;
|
|
}
|
|
} else {
|
|
if (!ok && (atf_user_euid() == st.st_uid)) {
|
|
ok = ((mode & atf_fs_access_r) && (st.st_mode & S_IRUSR)) ||
|
|
((mode & atf_fs_access_w) && (st.st_mode & S_IWUSR)) ||
|
|
((mode & atf_fs_access_x) && (st.st_mode & S_IXUSR));
|
|
}
|
|
if (!ok && atf_user_is_member_of_group(st.st_gid)) {
|
|
ok = ((mode & atf_fs_access_r) && (st.st_mode & S_IRGRP)) ||
|
|
((mode & atf_fs_access_w) && (st.st_mode & S_IWGRP)) ||
|
|
((mode & atf_fs_access_x) && (st.st_mode & S_IXGRP));
|
|
}
|
|
if (!ok && ((atf_user_euid() != st.st_uid) &&
|
|
!atf_user_is_member_of_group(st.st_gid))) {
|
|
ok = ((mode & atf_fs_access_r) && (st.st_mode & S_IROTH)) ||
|
|
((mode & atf_fs_access_w) && (st.st_mode & S_IWOTH)) ||
|
|
((mode & atf_fs_access_x) && (st.st_mode & S_IXOTH));
|
|
}
|
|
}
|
|
|
|
if (!ok)
|
|
err = atf_libc_error(EACCES, "Access check failed");
|
|
|
|
out:
|
|
return err;
|
|
}
|
|
|
|
atf_error_t
|
|
atf_fs_exists(const atf_fs_path_t *p, bool *b)
|
|
{
|
|
atf_error_t err;
|
|
|
|
err = atf_fs_eaccess(p, atf_fs_access_f);
|
|
if (atf_is_error(err)) {
|
|
if (atf_error_is(err, "libc") && atf_libc_error_code(err) == ENOENT) {
|
|
atf_error_free(err);
|
|
err = atf_no_error();
|
|
*b = false;
|
|
}
|
|
} else
|
|
*b = true;
|
|
|
|
return err;
|
|
}
|
|
|
|
atf_error_t
|
|
atf_fs_getcwd(atf_fs_path_t *p)
|
|
{
|
|
atf_error_t err;
|
|
char *cwd;
|
|
|
|
#if defined(HAVE_GETCWD_DYN)
|
|
cwd = getcwd(NULL, 0);
|
|
#else
|
|
cwd = getcwd(NULL, MAXPATHLEN);
|
|
#endif
|
|
if (cwd == NULL) {
|
|
err = atf_libc_error(errno, "Cannot determine current directory");
|
|
goto out;
|
|
}
|
|
|
|
err = atf_fs_path_init_fmt(p, "%s", cwd);
|
|
free(cwd);
|
|
|
|
out:
|
|
return err;
|
|
}
|
|
|
|
atf_error_t
|
|
atf_fs_mkdtemp(atf_fs_path_t *p)
|
|
{
|
|
atf_error_t err;
|
|
char *buf = NULL; /* MINIX: Complain in -O3 */
|
|
|
|
if (!check_umask(S_IRWXU, S_IRWXU)) {
|
|
err = invalid_umask_error(p, atf_fs_stat_dir_type, current_umask());
|
|
goto out;
|
|
}
|
|
|
|
err = copy_contents(p, &buf);
|
|
if (atf_is_error(err))
|
|
goto out;
|
|
|
|
err = do_mkdtemp(buf);
|
|
if (atf_is_error(err))
|
|
goto out_buf;
|
|
|
|
replace_contents(p, buf);
|
|
|
|
INV(!atf_is_error(err));
|
|
out_buf:
|
|
free(buf);
|
|
out:
|
|
return err;
|
|
}
|
|
|
|
atf_error_t
|
|
atf_fs_mkstemp(atf_fs_path_t *p, int *fdout)
|
|
{
|
|
atf_error_t err;
|
|
char *buf = NULL; /* MINIX: Complain in -O3 */
|
|
int fd;
|
|
|
|
if (!check_umask(S_IRWXU, S_IRWXU)) {
|
|
err = invalid_umask_error(p, atf_fs_stat_reg_type, current_umask());
|
|
goto out;
|
|
}
|
|
|
|
err = copy_contents(p, &buf);
|
|
if (atf_is_error(err))
|
|
goto out;
|
|
|
|
err = do_mkstemp(buf, &fd);
|
|
if (atf_is_error(err))
|
|
goto out_buf;
|
|
|
|
replace_contents(p, buf);
|
|
*fdout = fd;
|
|
|
|
INV(!atf_is_error(err));
|
|
out_buf:
|
|
free(buf);
|
|
out:
|
|
return err;
|
|
}
|
|
|
|
atf_error_t
|
|
atf_fs_rmdir(const atf_fs_path_t *p)
|
|
{
|
|
atf_error_t err;
|
|
|
|
if (rmdir(atf_fs_path_cstring(p))) {
|
|
if (errno == EEXIST) {
|
|
/* Some operating systems (e.g. OpenSolaris 200906) return
|
|
* EEXIST instead of ENOTEMPTY for non-empty directories.
|
|
* Homogenize the return value so that callers don't need
|
|
* to bother about differences in operating systems. */
|
|
errno = ENOTEMPTY;
|
|
}
|
|
err = atf_libc_error(errno, "Cannot remove directory");
|
|
} else
|
|
err = atf_no_error();
|
|
|
|
return err;
|
|
}
|
|
|
|
atf_error_t
|
|
atf_fs_unlink(const atf_fs_path_t *p)
|
|
{
|
|
atf_error_t err;
|
|
const char *path;
|
|
|
|
path = atf_fs_path_cstring(p);
|
|
|
|
if (unlink(path) != 0)
|
|
err = atf_libc_error(errno, "Cannot unlink file: '%s'", path);
|
|
else
|
|
err = atf_no_error();
|
|
|
|
return err;
|
|
}
|