static void
s_load_certs_from_disk (zcertstore_t *self)
{
s_empty_store (self);
zdir_t *dir = zdir_new (self->location, NULL);
if (dir) {
// Load all certificates including those in subdirectories
zfile_t **filelist = zdir_flatten (dir);
uint index;
for (index = 0;; index++) {
zfile_t *file = filelist [index];
if (!file)
break; // End of list
if (zfile_is_regular (file)) {
zcert_t *cert = zcert_load (zfile_filename (file, NULL));
if (cert)
zcertstore_insert (self, &cert);
}
}
zdir_flatten_free (&filelist);
self->modified = zdir_modified (dir);
self->count = zdir_count (dir);
self->cursize = zdir_cursize (dir);
zdir_destroy (&dir);
}
}
void
zdir_fprint (zdir_t *self, FILE *stream, int indent)
{
assert (self);
zfile_t **files = zdir_flatten (self);
uint index;
for (index = 0;; index++) {
zfile_t *file = files [index];
if (!file)
break;
fprintf (stream, "%s\n", zfile_filename (file, NULL));
}
zdir_flatten_free (&files);
}
zlist_t *
zdir_list (zdir_t *self)
{
zfile_t **files = zdir_flatten (self);
zlist_t *list = zlist_new ();
size_t index;
if (files)
{
for (index = 0 ; files[index] ; index++)
{
zlist_append (list, files[index]);
}
}
zdir_flatten_free (&files);
return list;
}
zhash_t *
zdir_cache (zdir_t *self)
{
assert (self);
// Load any previous cache from disk
zhash_t *cache = zhash_new ();
if (!cache)
return NULL;
zhash_autofree (cache);
char *cache_file = (char *) zmalloc (strlen (self->path) + strlen ("/.cache") + 1);
if (!cache_file) {
zhash_destroy (&cache);
return NULL;
}
sprintf (cache_file, "%s/.cache", self->path);
zhash_load (cache, cache_file);
// Recalculate digest for any new files
zfile_t **files = zdir_flatten (self);
uint index;
for (index = 0;; index++) {
zfile_t *file = files [index];
if (!file)
break;
const char *filename = zfile_filename (file, self->path);
if (zhash_lookup (cache, zfile_filename (file, self->path)) == NULL) {
int rc = zhash_insert (cache, filename, (void *) zfile_digest (file));
if (rc != 0) {
zhash_destroy (&cache);
break;
}
}
}
freen (files);
// Save cache to disk for future reference
if (cache)
zhash_save (cache, cache_file);
freen (cache_file);
return cache;
}
static void
s_disk_loader (zcertstore_t *certstore)
{
disk_loader_state *state = (disk_loader_state *)certstore->state;
zdir_t *dir = zdir_new (state->location, NULL);
if (dir
&& (state->modified != zdir_modified (dir)
|| state->count != zdir_count (dir)
|| state->cursize != (size_t) zdir_cursize (dir)))
{
zhashx_purge (certstore->certs);
// Load all certificates including those in subdirectories
zfile_t **filelist = zdir_flatten (dir);
assert (filelist);
zrex_t *rex = zrex_new ("_secret$");
assert (rex);
uint index;
for (index = 0;; index++) {
zfile_t *file = filelist [index];
if (!file)
break; // End of list
if (zfile_is_regular (file)
&& !zrex_matches (rex, zfile_filename (file, NULL))) {
zcert_t *cert = zcert_load (zfile_filename (file, NULL));
if (cert)
zcertstore_insert (certstore, &cert);
}
}
zdir_flatten_free (&filelist);
state->modified = zdir_modified (dir);
state->count = zdir_count (dir);
state->cursize = zdir_cursize (dir);
zrex_destroy (&rex);
}
zdir_destroy (&dir);
}
zlist_t *
zdir_resync (zdir_t *self, const char *alias)
{
zlist_t *patches = zlist_new ();
if (!patches)
return NULL;
zfile_t **files = zdir_flatten (self);
uint index;
for (index = 0;; index++) {
zfile_t *file = files [index];
if (!file)
break;
if (zlist_append (patches, zdir_patch_new (
self->path, file, patch_create, alias))) {
zlist_destroy (&patches);
break;
}
}
freen (files);
return patches;
}
zlist_t *
zdir_diff (zdir_t *older, zdir_t *newer, const char *alias)
{
zlist_t *patches = zlist_new ();
if (!patches)
return NULL;
zfile_t **old_files = zdir_flatten (older);
zfile_t **new_files = zdir_flatten (newer);
int old_index = 0;
int new_index = 0;
// Note that both lists are sorted, so detecting differences
// is rather trivial
while (old_files [old_index] || new_files [new_index]) {
zfile_t *old_file = old_files [old_index];
zfile_t *new_file = new_files [new_index];
int cmp;
if (!old_file)
cmp = 1; // Old file was deleted at end of list
else
if (!new_file)
cmp = -1; // New file was added at end of list
else
cmp = strcmp (zfile_filename (old_file, NULL), zfile_filename (new_file, NULL));
if (cmp > 0) {
// New file was created
if (zfile_is_stable (new_file)) {
int rc = zlist_append (patches, zdir_patch_new (newer->path, new_file, patch_create, alias));
if (rc != 0) {
zlist_destroy (&patches);
break;
}
}
old_index--;
}
else
if (cmp < 0) {
// Old file was deleted
if (zfile_is_stable (old_file)) {
int rc = zlist_append (patches, zdir_patch_new (older->path, old_file, patch_delete, alias));
if (rc != 0) {
zlist_destroy (&patches);
break;
}
}
new_index--;
}
else
if (cmp == 0 && zfile_is_stable (new_file)) {
if (zfile_is_stable (old_file)) {
// Old file was modified or replaced
// Since we don't check file contents, treat as created
// Could better do SHA check on file here
if (zfile_modified (new_file) != zfile_modified (old_file)
|| zfile_cursize (new_file) != zfile_cursize (old_file)) {
int rc = zlist_append (patches, zdir_patch_new (newer->path, new_file, patch_create, alias));
if (rc != 0) {
zlist_destroy (&patches);
break;
}
}
}
else {
// File was created over some period of time
int rc = zlist_append (patches, zdir_patch_new (newer->path, new_file, patch_create, alias));
if (rc != 0) {
zlist_destroy (&patches);
break;
}
}
}
old_index++;
new_index++;
}
freen (old_files);
freen (new_files);
return patches;
}
