static int rm_xattr_get(RmFile *file,
const char *key,
char *out_value,
size_t value_size) {
RM_DEFINE_PATH(file);
return rm_xattr_is_fail("getxattr", getxattr(file_path, key, out_value, value_size));
}
static int rm_xattr_set(RmFile *file,
const char *key,
const char *value,
size_t value_size) {
RM_DEFINE_PATH(file);
return rm_xattr_is_fail("setxattr", setxattr(file_path, key, value, value_size, 0));
}
static void rm_fmt_elem(_U RmSession *session, RmFmtHandler *parent, FILE *out,
RmFile *file) {
RmFmtHandlerProgress *self = (RmFmtHandlerProgress *)parent;
if(file->lint_type == RM_LINT_TYPE_UNIQUE_FILE) {
/* pretty output should not contain this */
return;
}
self->elems_written++;
if(file->lint_type != self->last_lint_type) {
fprintf(out, "\n%s#%s %s:\n", MAYBE_YELLOW(out, session),
MAYBE_RESET(out, session),
_(RM_LINT_TYPE_TO_DESCRIPTION[file->lint_type]));
self->last_lint_type = file->lint_type;
}
fprintf(out, " %s", rm_fmt_command_color(session, file, out));
const char *format = RM_LINT_TYPE_TO_COMMAND[file->lint_type];
switch(file->lint_type) {
case RM_LINT_TYPE_BADUID:
fprintf(out, format, self->user);
break;
case RM_LINT_TYPE_BADGID:
fprintf(out, format, self->group);
break;
case RM_LINT_TYPE_BADUGID:
fprintf(out, format, self->user, self->group);
break;
case RM_LINT_TYPE_DUPE_CANDIDATE:
if(file->is_original) {
fprintf(out, "ls");
} else {
fprintf(out, "%s", format);
}
break;
case RM_LINT_TYPE_DUPE_DIR_CANDIDATE:
if(file->is_original) {
fprintf(out, "ls -la");
} else {
fprintf(out, "%s", format);
}
break;
default:
fprintf(out, "%s", format);
}
RM_DEFINE_PATH(file);
char *esc_path = rm_util_strsub(file_path, "'", "'\"'\"'");
fprintf(out, "%s '%s'\n", MAYBE_RESET(out, session), esc_path);
g_free(esc_path);
}
static void rm_fmt_elem(_U RmSession *session, _U RmFmtHandler *parent, _U FILE *out,
RmFile *file) {
if(file->lint_type != RM_LINT_TYPE_UNIQUE_FILE) {
/* we only not want to list unfinished files. */
return;
}
if(session->cfg->keep_all_tagged && !file->is_prefd) {
/* don't list 'untagged' files as unique */
return;
}
if(session->cfg->keep_all_untagged && file->is_prefd) {
/* don't list 'tagged' files as unique */
return;
}
RM_DEFINE_PATH(file);
fputs(file_path, out);
fputc('\n', out);
}
void rm_tm_feed(RmTreeMerger *self, RmFile *file) {
RM_DEFINE_PATH(file);
char *dirname = g_path_get_dirname(file_path);
/* See if we know that directory already */
RmDirectory *directory = rm_trie_search(&self->dir_tree, dirname);
if(directory == NULL) {
/* Get the actual file count */
int file_count = GPOINTER_TO_INT(rm_trie_search(&self->count_tree, dirname));
if(file_count == 0) {
rm_log_error(
RED "Empty directory or weird RmFile encountered; rejecting.\n" RESET);
file_count = -1;
}
directory = rm_directory_new(dirname);
directory->file_count = file_count;
/* Make the new directory known */
rm_trie_insert(&self->dir_tree, dirname, directory);
g_queue_push_head(&self->valid_dirs, directory);
} else {
g_free(dirname);
}
g_queue_push_tail(self->free_list, file);
rm_directory_add(directory, file);
/* Add the file to this directory */
g_queue_push_head(&directory->known_files, file);
/* Remember the digest (if only to free it later...) */
g_hash_table_replace(self->known_hashs, file->digest, NULL);
/* Check if the directory reached the number of actual files in it */
if(directory->dupe_count == directory->file_count && directory->file_count > 0) {
rm_tm_insert_dir(self, directory);
}
}
static void rm_fmt_elem(_UNUSED RmSession *session, _UNUSED RmFmtHandler *parent, FILE *out,
RmFile *file) {
if (file->lint_type == RM_LINT_TYPE_UNIQUE_FILE && (!file->digest || !session->cfg->write_unfinished)) {
/* unique file with no partial checksum */
return;
/* TODO: add option to output all unique files */
}
char checksum_str[rm_digest_get_bytes(file->digest) * 2 + 1];
memset(checksum_str, '0', sizeof(checksum_str));
checksum_str[sizeof(checksum_str) - 1] = 0;
if(file->digest) {
rm_digest_hexstring(file->digest, checksum_str);
}
/* Escape quotes in the path (refer http://tools.ietf.org/html/rfc4180, item 6)*/
RM_DEFINE_PATH(file);
char *clean_path = rm_util_strsub(file_path, CSV_QUOTE, CSV_QUOTE "" CSV_QUOTE);
fprintf(out, CSV_FORMAT, rm_file_lint_type_to_string(file->lint_type), clean_path,
file->file_size, checksum_str);
g_free(clean_path);
}
static int rm_pp_cmp_reverse_alphabetical(const RmFile *a, const RmFile *b) {
RM_DEFINE_PATH(a);
RM_DEFINE_PATH(b);
return g_strcmp0(b_path, a_path);
}
static void rm_fmt_elem(RmSession *session, _UNUSED RmFmtHandler *parent, FILE *out,
RmFile *file) {
if(rm_fmt_get_config_value(session->formats, "json", "no_body")) {
return;
}
if(file->lint_type == RM_LINT_TYPE_UNIQUE_FILE &&
(!file->digest || !session->cfg->write_unfinished)) {
/* unique file with no partial checksum */
return;
}
char checksum_str[rm_digest_get_bytes(file->digest) * 2 + 1];
rm_fmt_json_cksum(file, checksum_str, sizeof(checksum_str));
RmFmtHandlerJSON *self = (RmFmtHandlerJSON *)parent;
/* Make it look like a json element */
rm_fmt_json_open(self, out);
{
RM_DEFINE_PATH(file);
rm_fmt_json_key_int(out, "id",
rm_fmt_json_generate_id(self, file, file_path, checksum_str));
rm_fmt_json_sep(self, out);
rm_fmt_json_key(out, "type", rm_file_lint_type_to_string(file->lint_type));
rm_fmt_json_sep(self, out);
gdouble progress = 0;
if(session->shred_bytes_after_preprocess) {
progress = CLAMP(100 -
100 * ((gdouble)session->shred_bytes_remaining /
(gdouble)session->shred_bytes_after_preprocess),
0, 100);
}
rm_fmt_json_key_int(out, "progress", progress);
rm_fmt_json_sep(self, out);
if(file->digest) {
rm_fmt_json_key(out, "checksum", checksum_str);
rm_fmt_json_sep(self, out);
}
rm_fmt_json_key_unsafe(out, "path", file_path);
rm_fmt_json_sep(self, out);
if(file->lint_type != RM_LINT_TYPE_UNIQUE_FILE) {
rm_fmt_json_key_int(out, "size", file->actual_file_size);
rm_fmt_json_sep(self, out);
if(file->twin_count >= 0) {
rm_fmt_json_key_int(out, "twins", file->twin_count);
rm_fmt_json_sep(self, out);
}
rm_fmt_json_key_int(out, "depth", file->depth);
rm_fmt_json_sep(self, out);
rm_fmt_json_key_int(out, "inode", file->inode);
rm_fmt_json_sep(self, out);
rm_fmt_json_key_int(out, "disk_id", file->dev);
rm_fmt_json_sep(self, out);
rm_fmt_json_key_bool(out, "is_original", file->is_original);
rm_fmt_json_sep(self, out);
if(session->cfg->find_hardlinked_dupes) {
RmFile *hardlink_head = RM_FILE_HARDLINK_HEAD(file);
if(hardlink_head && hardlink_head != file) {
char orig_checksum_str[rm_digest_get_bytes(file->digest) * 2 + 1];
rm_fmt_json_cksum(hardlink_head, orig_checksum_str,
sizeof(orig_checksum_str));
RM_DEFINE_PATH(hardlink_head);
guint32 orig_id = rm_fmt_json_generate_id(
self, hardlink_head, hardlink_head_path, orig_checksum_str);
rm_fmt_json_key_int(out, "hardlink_of", orig_id);
rm_fmt_json_sep(self, out);
}
}
}
rm_fmt_json_key_float(out, "mtime", file->mtime);
}
rm_fmt_json_close(self, out);
}
static int rm_xattr_del(RmFile *file, const char *key) {
RM_DEFINE_PATH(file);
return rm_xattr_is_fail("removexattr", removexattr(file_path, key));
}
