void rm_digest_free(RmDigest *digest) {
switch(digest->type) {
case RM_DIGEST_MD5:
case RM_DIGEST_SHA512:
case RM_DIGEST_SHA256:
case RM_DIGEST_SHA1:
g_checksum_free(digest->glib_checksum);
digest->glib_checksum = NULL;
break;
case RM_DIGEST_PARANOID:
if(digest->shadow_hash) {
rm_digest_free(digest->shadow_hash);
}
case RM_DIGEST_CUMULATIVE:
case RM_DIGEST_MURMUR512:
case RM_DIGEST_CITY512:
case RM_DIGEST_MURMUR256:
case RM_DIGEST_CITY256:
case RM_DIGEST_BASTARD:
case RM_DIGEST_SPOOKY:
case RM_DIGEST_SPOOKY32:
case RM_DIGEST_SPOOKY64:
case RM_DIGEST_MURMUR:
case RM_DIGEST_CITY:
if(digest->checksum) {
g_slice_free1(digest->bytes, digest->checksum);
digest->checksum = NULL;
}
break;
default:
g_assert_not_reached();
}
g_slice_free(RmDigest, digest);
}
static int rm_hasher_callback(_U RmHasher *hasher,
RmDigest *digest,
RmHasherSession *session,
gpointer index_ptr) {
gint index = GPOINTER_TO_INT(index_ptr);
g_mutex_lock(&session->lock);
{
if(session->print_in_order && digest) {
/* add digest in buffer array */
session->completed_digests_buffer[index] = digest;
/* check if the next due digest has been completed; if yes then print
* it (and possibly any following digests) */
while(session->completed_digests_buffer[session->path_index]) {
if(session->paths[session->path_index]) {
rm_hasher_print(
session->completed_digests_buffer[session->path_index],
session->paths[session->path_index],
session->print_multihash);
rm_digest_free(
session->completed_digests_buffer[session->path_index]);
}
session->completed_digests_buffer[session->path_index] = NULL;
session->path_index++;
}
} else if(digest) {
rm_hasher_print(digest, session->paths[index], session->print_multihash);
}
}
g_mutex_unlock(&session->lock);
return 0;
}
static void rm_directory_free(RmDirectory *self) {
rm_digest_free(self->digest);
g_hash_table_unref(self->hash_set);
g_queue_clear(&self->known_files);
g_queue_clear(&self->children);
g_free(self->dirname);
g_free(self);
}
guint8 *rm_digest_steal(RmDigest *digest) {
guint8 *result = g_slice_alloc0(digest->bytes);
gsize buflen = digest->bytes;
if(rm_digest_needs_steal(digest->type)) {
/* reading the digest is destructive, so we need to take a copy */
RmDigest *copy = rm_digest_copy(digest);
g_checksum_get_digest(copy->glib_checksum, result, &buflen);
rm_assert_gentle(buflen == digest->bytes);
rm_digest_free(copy);
} else {
memcpy(result, digest->checksum, digest->bytes);
}
return result;
}
RmDigest *rm_digest_copy(RmDigest *digest) {
g_assert(digest);
RmDigest *self = NULL;
switch(digest->type) {
case RM_DIGEST_MD5:
case RM_DIGEST_SHA512:
case RM_DIGEST_SHA256:
case RM_DIGEST_SHA1:
self = g_slice_new0(RmDigest);
self->bytes = digest->bytes;
self->type = digest->type;
self->glib_checksum = g_checksum_copy(digest->glib_checksum);
break;
case RM_DIGEST_PARANOID:
case RM_DIGEST_SPOOKY:
case RM_DIGEST_SPOOKY32:
case RM_DIGEST_SPOOKY64:
case RM_DIGEST_MURMUR:
case RM_DIGEST_CITY:
case RM_DIGEST_CITY256:
case RM_DIGEST_MURMUR256:
case RM_DIGEST_CITY512:
case RM_DIGEST_MURMUR512:
case RM_DIGEST_BASTARD:
case RM_DIGEST_CUMULATIVE:
self = rm_digest_new(
digest->type, digest->initial_seed1, digest->initial_seed2, digest->bytes
);
if(self->type == RM_DIGEST_PARANOID) {
self->paranoid_offset = digest->paranoid_offset;
rm_digest_free(self->shadow_hash);
self->shadow_hash = rm_digest_copy(digest->shadow_hash);
}
if(self->checksum && digest->checksum) {
memcpy((char *)self->checksum, (char *)digest->checksum, self->bytes);
}
break;
default:
g_assert_not_reached();
}
return self;
}
void rm_digest_free(RmDigest *digest) {
switch(digest->type) {
case RM_DIGEST_MD5:
case RM_DIGEST_SHA512:
case RM_DIGEST_SHA256:
case RM_DIGEST_SHA1:
g_checksum_free(digest->glib_checksum);
digest->glib_checksum = NULL;
break;
case RM_DIGEST_PARANOID:
if(digest->paranoid->shadow_hash) {
rm_digest_free(digest->paranoid->shadow_hash);
}
rm_digest_release_buffers(digest);
if(digest->paranoid->incoming_twin_candidates) {
g_async_queue_unref(digest->paranoid->incoming_twin_candidates);
}
g_slist_free(digest->paranoid->rejects);
g_slice_free(RmParanoid, digest->paranoid);
break;
case RM_DIGEST_EXT:
case RM_DIGEST_CUMULATIVE:
case RM_DIGEST_MURMUR512:
case RM_DIGEST_XXHASH:
case RM_DIGEST_CITY512:
case RM_DIGEST_MURMUR256:
case RM_DIGEST_CITY256:
case RM_DIGEST_BASTARD:
case RM_DIGEST_SPOOKY:
case RM_DIGEST_SPOOKY32:
case RM_DIGEST_SPOOKY64:
case RM_DIGEST_FARMHASH:
case RM_DIGEST_MURMUR:
case RM_DIGEST_CITY:
if(digest->checksum) {
g_slice_free1(digest->bytes, digest->checksum);
digest->checksum = NULL;
}
break;
default:
rm_assert_gentle_not_reached();
}
g_slice_free(RmDigest, digest);
}
guint8 *rm_digest_steal_buffer(RmDigest *digest) {
guint8 *result = g_slice_alloc0(digest->bytes);
RmDigest *copy = NULL;
gsize buflen = digest->bytes;
switch(digest->type) {
case RM_DIGEST_MD5:
case RM_DIGEST_SHA512:
case RM_DIGEST_SHA256:
case RM_DIGEST_SHA1:
/* for all of the above, reading the digest is destructive, so we
* need to take a copy */
copy = rm_digest_copy(digest);
g_checksum_get_digest(copy->glib_checksum, result, &buflen);
g_assert(buflen == digest->bytes);
rm_digest_free(copy);
break;
case RM_DIGEST_SPOOKY32:
case RM_DIGEST_SPOOKY64:
case RM_DIGEST_SPOOKY:
case RM_DIGEST_MURMUR:
case RM_DIGEST_CITY:
case RM_DIGEST_CITY256:
case RM_DIGEST_MURMUR256:
case RM_DIGEST_CITY512:
case RM_DIGEST_MURMUR512:
case RM_DIGEST_BASTARD:
case RM_DIGEST_CUMULATIVE:
case RM_DIGEST_PARANOID:
memcpy(result, digest->checksum, digest->bytes);
break;
default:
g_assert_not_reached();
}
return result;
}
