static void
write_normal_file(const char *name, struct archive *archive,
struct archive_entry_linkresolver *resolver,
const char *owner, const char *group)
{
char buf[16384];
ssize_t buf_len;
struct archive_entry *entry, *sparse_entry;
struct stat st;
if (lstat(name, &st) == -1)
err(2, "lstat failed for file %s", name);
entry = archive_entry_new();
archive_entry_set_pathname(entry, name);
archive_entry_copy_stat(entry, &st);
if (owner != NULL) {
uid_t uid;
archive_entry_set_uname(entry, owner);
if (uid_from_user(owner, &uid) == -1)
errx(2, "user %s unknown", owner);
archive_entry_set_uid(entry, uid);
} else {
archive_entry_set_uname(entry, user_from_uid(st.st_uid, 1));
}
if (group != NULL) {
gid_t gid;
archive_entry_set_gname(entry, group);
if (gid_from_group(group, &gid) == -1)
errx(2, "group %s unknown", group);
archive_entry_set_gid(entry, gid);
} else {
archive_entry_set_gname(entry, group_from_gid(st.st_gid, 1));
}
if ((st.st_mode & S_IFMT) == S_IFLNK) {
buf_len = readlink(name, buf, sizeof buf);
if (buf_len < 0)
err(2, "cannot read symlink %s", name);
buf[buf_len] = '\0';
archive_entry_set_symlink(entry, buf);
}
archive_entry_linkify(resolver, &entry, &sparse_entry);
if (entry != NULL)
write_entry(archive, entry);
if (sparse_entry != NULL)
write_entry(archive, sparse_entry);
}
/*
* Given a GID or group name in a string, return the GID. If an empty string
* was given, returns -1. Exits on invalid user names/UIDs.
*/
gid_t
a_gid(const char *s)
{
const char *errstr;
gid_t gid;
if (*s == '\0') /* Argument was "uid[:.]". */
return ((gid_t)-1);
/* Group name was given. */
if (gid_from_group(s, &gid) != -1)
return (gid);
/* GID was given. */
gid = (gid_t)strtonum(s, 0, GID_MAX, &errstr);
if (errstr)
errx(1, "group is %s: %s", errstr, s);
return (gid);
}
static void
update_ids(struct memory_file *file)
{
if (file->owner != NULL) {
uid_t uid;
if (uid_from_user(file->owner, &uid) == -1)
errx(2, "user %s unknown", file->owner);
file->st.st_uid = uid;
} else {
file->owner = xstrdup(user_from_uid(file->st.st_uid, 1));
}
if (file->group != NULL) {
gid_t gid;
if (gid_from_group(file->group, &gid) == -1)
errx(2, "group %s unknown", file->group);
file->st.st_gid = gid;
} else {
file->group = xstrdup(group_from_gid(file->st.st_gid, 1));
}
}
static int
read_mtree_keywords(FILE *fp, fsnode *node)
{
char keyword[PATH_MAX];
char *name, *p, *value;
gid_t gid;
uid_t uid;
struct stat *st, sb;
intmax_t num;
u_long flset, flclr;
int error, istemp, type;
st = &node->inode->st;
do {
error = skip_over(fp, " \t");
if (error)
break;
error = read_word(fp, keyword, sizeof(keyword));
if (error)
break;
if (keyword[0] == '\0')
break;
value = strchr(keyword, '=');
if (value != NULL)
*value++ = '\0';
/*
* We use EINVAL, ENOATTR, ENOSYS and ENXIO to signal
* certain conditions:
* EINVAL - Value provided for a keyword that does
* not take a value. The value is ignored.
* ENOATTR - Value missing for a keyword that needs
* a value. The keyword is ignored.
* ENOSYS - Unsupported keyword encountered. The
* keyword is ignored.
* ENXIO - Value provided for a keyword that does
* not take a value. The value is ignored.
*/
switch (keyword[0]) {
case 'c':
if (strcmp(keyword, "contents") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
node->contents = strdup(value);
} else
error = ENOSYS;
break;
case 'f':
if (strcmp(keyword, "flags") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
flset = flclr = 0;
if (!strtofflags(&value, &flset, &flclr)) {
st->st_flags &= ~flclr;
st->st_flags |= flset;
} else
error = errno;
} else
error = ENOSYS;
break;
case 'g':
if (strcmp(keyword, "gid") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
error = read_number(value, 10, &num,
0, UINT_MAX);
if (!error)
st->st_gid = num;
} else if (strcmp(keyword, "gname") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
if (gid_from_group(value, &gid) == 0)
st->st_gid = gid;
else
error = EINVAL;
} else
error = ENOSYS;
break;
case 'l':
if (strcmp(keyword, "link") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
node->symlink = strdup(value);
} else
error = ENOSYS;
break;
case 'm':
if (strcmp(keyword, "mode") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
if (value[0] >= '0' && value[0] <= '9') {
error = read_number(value, 8, &num,
0, 07777);
if (!error) {
st->st_mode &= S_IFMT;
st->st_mode |= num;
}
} else {
/* Symbolic mode not supported. */
error = EINVAL;
break;
}
} else
error = ENOSYS;
break;
case 'o':
if (strcmp(keyword, "optional") == 0) {
if (value != NULL)
error = ENXIO;
node->flags |= FSNODE_F_OPTIONAL;
} else
error = ENOSYS;
break;
case 's':
if (strcmp(keyword, "size") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
error = read_number(value, 10, &num,
0, INTMAX_MAX);
if (!error)
st->st_size = num;
} else
error = ENOSYS;
break;
case 't':
if (strcmp(keyword, "time") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
p = strchr(value, '.');
if (p != NULL)
*p++ = '\0';
error = read_number(value, 10, &num, 0,
INTMAX_MAX);
if (error)
break;
st->st_atime = num;
st->st_ctime = num;
st->st_mtime = num;
if (p == NULL)
break;
error = read_number(p, 10, &num, 0,
INTMAX_MAX);
if (error)
break;
if (num != 0)
error = EINVAL;
} else if (strcmp(keyword, "type") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
if (strcmp(value, "dir") == 0)
node->type = S_IFDIR;
else if (strcmp(value, "file") == 0)
node->type = S_IFREG;
else if (strcmp(value, "link") == 0)
node->type = S_IFLNK;
else
error = EINVAL;
} else
error = ENOSYS;
break;
case 'u':
if (strcmp(keyword, "uid") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
error = read_number(value, 10, &num,
0, UINT_MAX);
if (!error)
st->st_uid = num;
} else if (strcmp(keyword, "uname") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
if (uid_from_user(value, &uid) == 0)
st->st_uid = uid;
else
error = EINVAL;
} else
error = ENOSYS;
break;
default:
error = ENOSYS;
break;
}
switch (error) {
case EINVAL:
mtree_error("%s: invalid value '%s'", keyword, value);
break;
case ENOATTR:
mtree_error("%s: keyword needs a value", keyword);
break;
case ENOSYS:
mtree_warning("%s: unsupported keyword", keyword);
break;
case ENXIO:
mtree_error("%s: keyword does not take a value",
keyword);
break;
}
} while (1);
if (error)
return (error);
st->st_mode = (st->st_mode & ~S_IFMT) | node->type;
/* Nothing more to do for the global defaults. */
if (node->name == NULL)
return (0);
/*
* Be intelligent about the file type.
*/
if (node->contents != NULL) {
if (node->symlink != NULL) {
mtree_error("%s: both link and contents keywords "
"defined", node->name);
return (0);
}
type = S_IFREG;
} else if (node->type != 0) {
type = node->type;
if (type == S_IFREG) {
/* the named path is the default contents */
node->contents = mtree_file_path(node);
}
} else
type = (node->symlink != NULL) ? S_IFLNK : S_IFDIR;
if (node->type == 0)
node->type = type;
if (node->type != type) {
mtree_error("%s: file type and defined keywords to not match",
node->name);
return (0);
}
st->st_mode = (st->st_mode & ~S_IFMT) | node->type;
if (node->contents == NULL)
return (0);
name = mtree_resolve(node->contents, &istemp);
if (name == NULL)
return (errno);
if (stat(name, &sb) != 0) {
mtree_error("%s: contents file '%s' not found", node->name,
name);
free(name);
return (0);
}
/*
* Check for hardlinks. If the contents key is used, then the check
* will only trigger if the contents file is a link even if it is used
* by more than one file
*/
if (sb.st_nlink > 1) {
fsinode *curino;
st->st_ino = sb.st_ino;
st->st_dev = sb.st_dev;
curino = link_check(node->inode);
if (curino != NULL) {
free(node->inode);
node->inode = curino;
node->inode->nlink++;
}
}
free(node->contents);
node->contents = name;
st->st_size = sb.st_size;
return (0);
}
int
main(int argc, char *argv[])
{
struct stat from_sb, to_sb;
mode_t *set;
u_long fset;
int ch, no_target;
u_int iflags;
char *p;
const char *to_name;
iflags = 0;
group = owner = NULL;
while ((ch = getopt(argc, argv, "B:bCcD:df:g:h:l:M:m:N:o:pSsT:Uv")) !=
-1)
switch((char)ch) {
case 'B':
suffix = optarg;
/* FALLTHROUGH */
case 'b':
dobackup = 1;
break;
case 'C':
docompare = 1;
break;
case 'c':
/* For backwards compatibility. */
break;
case 'D':
destdir = optarg;
break;
case 'd':
dodir = 1;
break;
case 'f':
haveopt_f = 1;
fflags = optarg;
break;
case 'g':
haveopt_g = 1;
group = optarg;
break;
case 'h':
digest = optarg;
break;
case 'l':
for (p = optarg; *p != '\0'; p++)
switch (*p) {
case 's':
dolink &= ~(LN_HARD|LN_MIXED);
dolink |= LN_SYMBOLIC;
break;
case 'h':
dolink &= ~(LN_SYMBOLIC|LN_MIXED);
dolink |= LN_HARD;
break;
case 'm':
dolink &= ~(LN_SYMBOLIC|LN_HARD);
dolink |= LN_MIXED;
break;
case 'a':
dolink &= ~LN_RELATIVE;
dolink |= LN_ABSOLUTE;
break;
case 'r':
dolink &= ~LN_ABSOLUTE;
dolink |= LN_RELATIVE;
break;
default:
errx(1, "%c: invalid link type", *p);
/* NOTREACHED */
}
break;
case 'M':
metafile = optarg;
break;
case 'm':
haveopt_m = 1;
if (!(set = setmode(optarg)))
errx(EX_USAGE, "invalid file mode: %s",
optarg);
mode = getmode(set, 0);
free(set);
break;
case 'N':
if (!setup_getid(optarg))
err(EX_OSERR, "Unable to use user and group "
"databases in `%s'", optarg);
break;
case 'o':
haveopt_o = 1;
owner = optarg;
break;
case 'p':
docompare = dopreserve = 1;
break;
case 'S':
safecopy = 1;
break;
case 's':
dostrip = 1;
break;
case 'T':
tags = optarg;
break;
case 'U':
dounpriv = 1;
break;
case 'v':
verbose = 1;
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
/* some options make no sense when creating directories */
if (dostrip && dodir) {
warnx("-d and -s may not be specified together");
usage();
}
if (getenv("DONTSTRIP") != NULL) {
warnx("DONTSTRIP set - will not strip installed binaries");
dostrip = 0;
}
/* must have at least two arguments, except when creating directories */
if (argc == 0 || (argc == 1 && !dodir))
usage();
if (digest != NULL) {
if (strcmp(digest, "none") == 0) {
digesttype = DIGEST_NONE;
} else if (strcmp(digest, "md5") == 0) {
digesttype = DIGEST_MD5;
} else if (strcmp(digest, "rmd160") == 0) {
digesttype = DIGEST_RIPEMD160;
} else if (strcmp(digest, "sha1") == 0) {
digesttype = DIGEST_SHA1;
} else if (strcmp(digest, "sha256") == 0) {
digesttype = DIGEST_SHA256;
} else if (strcmp(digest, "sha512") == 0) {
digesttype = DIGEST_SHA512;
} else {
warnx("unknown digest `%s'", digest);
usage();
}
}
/* need to make a temp copy so we can compare stripped version */
if (docompare && dostrip)
safecopy = 1;
/* get group and owner id's */
if (group != NULL && !dounpriv) {
if (gid_from_group(group, &gid) == -1) {
id_t id;
if (!parseid(group, &id))
errx(1, "unknown group %s", group);
gid = id;
}
} else
gid = (gid_t)-1;
if (owner != NULL && !dounpriv) {
if (uid_from_user(owner, &uid) == -1) {
id_t id;
if (!parseid(owner, &id))
errx(1, "unknown user %s", owner);
uid = id;
}
} else
uid = (uid_t)-1;
if (fflags != NULL && !dounpriv) {
if (strtofflags(&fflags, &fset, NULL))
errx(EX_USAGE, "%s: invalid flag", fflags);
iflags |= SETFLAGS;
}
if (metafile != NULL) {
if ((metafp = fopen(metafile, "a")) == NULL)
warn("open %s", metafile);
} else
digesttype = DIGEST_NONE;
if (dodir) {
for (; *argv != NULL; ++argv)
install_dir(*argv);
exit(EX_OK);
/* NOTREACHED */
}
to_name = argv[argc - 1];
no_target = stat(to_name, &to_sb);
if (!no_target && S_ISDIR(to_sb.st_mode)) {
if (dolink & LN_SYMBOLIC) {
if (lstat(to_name, &to_sb) != 0)
err(EX_OSERR, "%s vanished", to_name);
if (S_ISLNK(to_sb.st_mode)) {
if (argc != 2) {
errno = ENOTDIR;
err(EX_USAGE, "%s", to_name);
}
install(*argv, to_name, fset, iflags);
exit(EX_OK);
}
}
for (; *argv != to_name; ++argv)
install(*argv, to_name, fset, iflags | DIRECTORY);
exit(EX_OK);
/* NOTREACHED */
}
/* can't do file1 file2 directory/file */
if (argc != 2) {
if (no_target)
warnx("target directory `%s' does not exist",
argv[argc - 1]);
else
warnx("target `%s' is not a directory",
argv[argc - 1]);
usage();
}
if (!no_target && !dolink) {
if (stat(*argv, &from_sb))
err(EX_OSERR, "%s", *argv);
if (!S_ISREG(to_sb.st_mode)) {
errno = EFTYPE;
err(EX_OSERR, "%s", to_name);
}
if (to_sb.st_dev == from_sb.st_dev &&
to_sb.st_ino == from_sb.st_ino)
errx(EX_USAGE,
"%s and %s are the same file", *argv, to_name);
}
install(*argv, to_name, fset, iflags);
exit(EX_OK);
/* NOTREACHED */
}
