static void
ct_version_tree_free_version(struct ct_vertree_ver *entry)
{
struct ct_vertree_dir *dir;
struct ct_vertree_spec *spec;
struct ct_vertree_link *flink;
struct ct_vertree_file *file;
if (C_ISDIR(entry->cvv_type)) {
dir = (struct ct_vertree_dir *)entry;
e_free(&dir);
} else if (C_ISBLK(entry->cvv_type) ||
C_ISCHR(entry->cvv_type)) {
spec = (struct ct_vertree_spec *)entry;
e_free(&spec);
} else if (C_ISLINK(entry->cvv_type)) {
flink = (struct ct_vertree_link *)entry;
if (flink->cvl_linkname != NULL)
e_free(&flink->cvl_linkname);
e_free(&flink);
} else if (C_ISREG(entry->cvv_type)) {
file = (struct ct_vertree_file *)entry;
e_free(&file);
}
return;
}
/*
* Main guts of ctd_build_version_tree. Factored out to avoid deep nesting.
* Insert or update an entry in the tree with the information received from
* the ctfile.
*/
static int
ct_vertree_add(struct ct_vertree_dnode_cache *dnode_cache,
struct ct_vertree_entry *head, struct ctfile_parse_state *parse_state,
struct ct_vertree_ctfile *ctfile, off_t fileoffset, int allfiles)
{
struct ctfile_header *hdr = &parse_state->xs_hdr;
struct ctfile_header *hdrlnk= &parse_state->xs_lnkhdr;
struct dnode *dnode;
struct ct_vertree_dnode *fb_dnode;
struct ct_vertree_entry *parent = NULL, sentry, *entry;
struct ct_vertree_ver *lastver, *ver;
struct ct_vertree_file *file;
struct ct_vertree_spec *spec;
struct ct_vertree_link *linkver;
size_t sz;
bool root_dnode = false;
entry = NULL;
/* First find parent directory if any */
if (hdr->cmh_parent_dir != -1 && hdr->cmh_parent_dir != -2) {
if ((dnode = ctfile_parse_finddir(parse_state,
hdr->cmh_parent_dir)) == NULL) {
CNDBG(CT_LOG_VERTREE, "can't find dir %" PRId64,
hdr->cmh_parent_dir);
return (CTE_CTFILE_CORRUPT);
}
fb_dnode = (struct ct_vertree_dnode *)dnode;
if (fb_dnode == dnode_cache->root_dnode) {
// If we have the root dnode, store in head.
parent = head;
} else {
parent = fb_dnode->cvd_dir;
}
} else {
parent = head;
}
if (parent == head && strcmp(hdr->cmh_filename, CT_PATHSEP_STR) == 0) {
root_dnode = true;
}
/*
* Have parent node, search children to see if we already exist.
* Else make a new one and insert.
*/
sentry.cve_name = hdr->cmh_filename;
if ((entry = RB_FIND(ct_vertree_entries, &parent->cve_children,
&sentry)) == NULL) {
/* new name, insert node */
entry = e_calloc(1, sizeof(*entry));
TAILQ_INIT(&entry->cve_versions);
RB_INIT(&entry->cve_children);
entry->cve_parent = parent;
entry->cve_name = e_strdup(sentry.cve_name);
/* don't insert root dnodes, just do dnode dance */
if (root_dnode) {
goto rootdir;
}
if (RB_INSERT(ct_vertree_entries, &parent->cve_children,
entry) != NULL) {
CNDBG(CT_LOG_VERTREE, "entry %s already exists",
sentry.cve_name);
e_free(&sentry.cve_name);
goto err;
}
}
/*
* then check version tags -> head/tail if mtime and type match, we're
* good else prepare version entry.
*/
if (allfiles) {
lastver = TAILQ_FIRST(&entry->cve_versions);
} else {
lastver = TAILQ_LAST(&entry->cve_versions, ct_vertree_vers);
}
/* Don't check atime, it doesn't matter */
if (lastver != NULL && lastver->cvv_type == hdr->cmh_type &&
lastver->cvv_mtime == hdr->cmh_mtime &&
lastver->cvv_uid == hdr->cmh_uid &&
lastver->cvv_gid == hdr->cmh_gid &&
lastver->cvv_mode == hdr->cmh_mode) {
ver = lastver;
} else { /* something changed. make a new one */
if (C_ISDIR(hdr->cmh_type)) {
sz = sizeof(struct ct_vertree_dir);
} else if (C_ISBLK(hdr->cmh_type) ||
C_ISCHR(hdr->cmh_type)) {
sz = sizeof(struct ct_vertree_spec);
} else if (C_ISLINK(hdr->cmh_type)) {
sz = sizeof(struct ct_vertree_link);
} else if (C_ISREG(hdr->cmh_type)) {
sz = sizeof(struct ct_vertree_file);
} else {
CNDBG(CT_LOG_VERTREE, "invalid type %d", hdr->cmh_type);
goto err;
}
ver = e_calloc(1, sz);
ver->cvv_type = hdr->cmh_type;
ver->cvv_mtime = hdr->cmh_mtime;
ver->cvv_atime = hdr->cmh_atime;
ver->cvv_uid = hdr->cmh_uid;
ver->cvv_gid = hdr->cmh_gid;
ver->cvv_mode = hdr->cmh_mode;
/* dir handled below */
if (C_ISBLK(hdr->cmh_type) || C_ISCHR(hdr->cmh_type)) {
spec = (struct ct_vertree_spec *)ver;
spec->cvs_rdev = hdr->cmh_rdev;
} else if (C_ISLINK(hdr->cmh_type)) {
/* hardlink/symlink */
linkver = (struct ct_vertree_link *)ver;
linkver->cvl_linkname = e_strdup(hdrlnk->cmh_filename);
linkver->cvl_hardlink = !C_ISLINK(hdrlnk->cmh_type);
} else if (C_ISREG(hdr->cmh_type)) {
file = (struct ct_vertree_file *)ver;
file->cvf_nr_shas = -1;
}
if (allfiles) {
TAILQ_INSERT_HEAD(&entry->cve_versions, ver, cvv_link);
} else {
TAILQ_INSERT_TAIL(&entry->cve_versions, ver, cvv_link);
}
}
/*
* Each ctfile only has each directory referenced once, so put it
* in the cache regardless of whether it was known of before, that
* will be a previous run and the cache will have been wiped since
* then.
*/
if (C_ISDIR(hdr->cmh_type)) {
rootdir:
fb_dnode = e_calloc(1, sizeof(*fb_dnode));
fb_dnode->cvd_dnode.d_name = e_strdup(entry->cve_name);
/*
* in the root_dnode case this will be a bad pointer but it
* will never be derefed.
*/
fb_dnode->cvd_dir = entry;
if ((dnode = ctfile_parse_insertdir(parse_state,
&fb_dnode->cvd_dnode)) != NULL)
CABORTX("duplicate dentry");
TAILQ_INSERT_TAIL(&dnode_cache->cache, fb_dnode, cvd_link);
if (root_dnode) {
dnode_cache->root_dnode = fb_dnode;
}
} else if (C_ISREG(hdr->cmh_type)) {
/*
* Allfiles ctfiles may have shas == -1, so in some cases we
* may wish to update an existing file when we find the actual
* shas. It is an error to have a file node with -1 for shas
* after all metadata have been parsed. it means one was
* missing.
*/
file = (struct ct_vertree_file *)ver;
/*
* bugs in previous editions with incremental selection and
* off_t on linux mean that there are ctfiles in the wild which
* provide a list of shas in a later level when the file is
* defined in an earlier level file, also. For example for the
* same filename and date we have level 0: 3 shas, level 1: -1
* shas (i.e. in a previous level), level 2: 3 shas (same as
* level * 0). In that case we just assume that if we already
* have sha data for a file * then it is correct and we skip
* previous versions.
*/
if (file->cvf_nr_shas != -1) {
goto out;
}
/*
* previous linux off_t bugs with files over 2gb mean that there
* are sign extended ctfiles in the wild, so we count those as
* zero length for purposes of the version tree.
*/
if (hdr->cmh_nr_shas < -1) {
hdr->cmh_nr_shas = 0;
}
if (hdr->cmh_nr_shas != -1) {
file->cvf_nr_shas = hdr->cmh_nr_shas;
file->cvf_sha_offs = fileoffset;
file->cvf_file = ctfile;
if (ctfile_parse_seek(parse_state)) {
CNDBG(CT_LOG_VERTREE,
"failed to skip shas in %s",
ctfile->cvc_path);
goto err;
}
}
if (ctfile_parse(parse_state) != XS_RET_FILE_END) {
CNDBG(CT_LOG_VERTREE, "no file trailer found");
goto err;
}
file->cvf_file_size = parse_state->xs_trl.cmt_orig_size;
}
out:
/*
* If we're an explicit "/" entry then we don't want to be added to
* the tree. all our children will be added to the root entry.
*/
if (root_dnode) {
e_free(&entry);
}
return (0);
err:
if (entry != NULL)
e_free(&entry);
return (CTE_CTFILE_CORRUPT);
}
/* Printing functions */
void
ct_pr_fmt_file(void *state, struct fnode *fnode)
{
int *verbose = state;
char *loginname;
struct group *group;
char *link_ty, *pchr;
char filemode[11], uid[11], gid[11], lctime[26];
time_t ltime;
if (*verbose == 0)
return;
if (*verbose > 1) {
switch(fnode->fn_type & C_TY_MASK) {
case C_TY_DIR:
filemode[0] = 'd'; break;
case C_TY_CHR:
filemode[0] = 'c'; break;
case C_TY_BLK:
filemode[0] = 'b'; break;
case C_TY_REG:
filemode[0] = '-'; break;
case C_TY_FIFO:
filemode[0] = 'f'; break;
case C_TY_LINK:
filemode[0] = 'l'; break;
case C_TY_SOCK:
filemode[0] = 's'; break;
default:
filemode[0] = '?';
}
filemode[1] = (fnode->fn_mode & 0400) ? 'r' : '-';
filemode[2] = (fnode->fn_mode & 0100) ? 'w' : '-';
filemode[3] = (fnode->fn_mode & 0200) ? 'x' : '-';
filemode[4] = (fnode->fn_mode & 0040) ? 'r' : '-';
filemode[5] = (fnode->fn_mode & 0020) ? 'w' : '-';
filemode[6] = (fnode->fn_mode & 0010) ? 'x' : '-';
filemode[7] = (fnode->fn_mode & 0004) ? 'r' : '-';
filemode[8] = (fnode->fn_mode & 0002) ? 'w' : '-';
filemode[9] = (fnode->fn_mode & 0001) ? 'x' : '-';
filemode[10] = '\0';
loginname = ct_getloginbyuid(fnode->fn_uid);
if (loginname && (strlen(loginname) < sizeof(uid)))
snprintf(uid, sizeof(uid), "%10s", loginname);
else
snprintf(uid, sizeof(uid), "%-10d", fnode->fn_uid);
group = getgrgid(fnode->fn_gid);
if (group && (strlen(group->gr_name) < sizeof(gid)))
snprintf(gid, sizeof(gid), "%10s", group->gr_name);
else
snprintf(gid, sizeof(gid), "%-10d", fnode->fn_gid);
ltime = fnode->fn_mtime;
ctime_r(<ime, lctime);
pchr = strchr(lctime, '\n');
if (pchr != NULL)
*pchr = '\0'; /* stupid newline on ctime */
printf("%s %s %s %s ", filemode, uid, gid, lctime);
}
if (fnode->fn_skip_file) {
if (*verbose > 1)
printf("%s does not need rearchive",
fnode->fn_fullname);
} else {
printf("%s", fnode->fn_fullname);
}
if (*verbose > 1) {
/* XXX - translate to guid name */
if (C_ISLINK(fnode->fn_type)) {
if (fnode->fn_hardlink) {
link_ty = "==";
} else {
link_ty = "->";
}
printf(" %s %s", link_ty, fnode->fn_hlname);
} else if (C_ISREG(fnode->fn_type)) {
}
}
fflush(stdout);
}
