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); }