Mercurial > hg > dav / file revision

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2018 Olaf Wintermann. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#include "db.h"

#include <cx/utils.h>

#include <libidav/utils.h>

#include <libxml/encoding.h>
#include <libxml/xmlwriter.h>


#define xstreq(a,b) xmlStrEqual(BAD_CAST a, BAD_CAST b)

#ifdef _WIN32
#define ENV_HOME getenv("USERPROFILE")
#else
#define ENV_HOME getenv("HOME")
#endif /* _WIN32 */

SyncDatabase* load_db(char *name) {
    char *dav_dir = util_concat_path(ENV_HOME, ".dav");
    char *db_file = util_concat_path(dav_dir, name);
    free(dav_dir);
    
    SyncDatabase *db = malloc(sizeof(SyncDatabase));
    db->resources = cxHashMapCreate(cxDefaultAllocator, CX_STORE_POINTERS, 2048);
    db->conflict = cxHashMapCreate(cxDefaultAllocator, CX_STORE_POINTERS, 16);
    
    db->resources->destructor_data = (cx_destructor_func)local_resource_free;
    db->conflict->destructor_data = (cx_destructor_func)local_resource_free;
    
    xmlTextReaderPtr reader = xmlReaderForFile(db_file, NULL, 0);
    if(!reader) {
        xmlDoc *doc =  doc = xmlNewDoc(BAD_CAST "1.0");
        xmlNode *root = xmlNewNode(NULL, BAD_CAST "directory");
        xmlDocSetRootElement(doc, root);
        if(xmlSaveFormatFileEnc(db_file, doc, "UTF-8", 1) == -1) {
            destroy_db(db);
            db = NULL;
        }
        xmlFreeDoc(doc);
        free(db_file);
        return db;
    }
    free(db_file);
    
    int error = 0;
    while(xmlTextReaderRead(reader)) {
        int type = xmlTextReaderNodeType(reader);
        const xmlChar *name = xmlTextReaderConstName(reader);
        
        if(type == XML_READER_TYPE_ELEMENT) {
            if(xstreq(name, "resource")) {
                LocalResource *res = process_resource(reader);
                if(res) {
                    cxMapPut(db->resources, cx_hash_key_str(res->path), res);
                } else {
                    error = 1;
                    break;
                }
            } else if(xstreq(name, "conflict")) {
                LocalResource *res = process_conflict(reader);
                if(res) {
                    cxMapPut(db->conflict, cx_hash_key_str(res->path), res);
                } else {
                    error = 1;
                    break;
                }
            }
        }
    }
    
    xmlFreeTextReader(reader);
    if(error) {
        destroy_db(db);
        return NULL;
    } else {
        return db;
    }
}

void process_parts(xmlTextReaderPtr reader, LocalResource *res) {
    // TODO: rewrite using low level array
    
    CxList *parts = cxLinkedListCreateSimple(CX_STORE_POINTERS);
    parts->destructor_data = (cx_destructor_func)filepart_free;
    
    FilePart *current_part = NULL;
    
    size_t count = 0;
    int field = -1;
    int err = 0;
    while(xmlTextReaderRead(reader)) {
        int type = xmlTextReaderNodeType(reader);
        const xmlChar *name = xmlTextReaderConstName(reader);
        int depth = xmlTextReaderDepth(reader);
        
        if(type == XML_READER_TYPE_ELEMENT) {
            if(depth == 3 && xstreq(name, "part")) {
                current_part = calloc(1, sizeof(FilePart));
                current_part->block = count;
                cxListAdd(parts, current_part);
                count++;
            } else if(depth == 4) {
                if(xstreq(name, "hash")) {
                    field = 0;
                } else if(xstreq(name, "etag")) {
                    field = 1;
                }
            }
        } else if(type == XML_READER_TYPE_END_ELEMENT) {
            if(depth == 2) {
                // </parts>
                break;
            } else if(depth == 3) {
                if(current_part) {
                    if(!current_part->hash || !current_part->etag) {
                        err = 1;
                    }
                }
                // </part>
                current_part = NULL;
            }
            field = -1;
        } else if(type == XML_READER_TYPE_TEXT && depth == 5 && current_part) {
            const char *text = (const char*)xmlTextReaderConstValue(reader);
            if(field == 0) {
                current_part->hash = strdup(text);
            } else if(field == 1) {
                current_part->etag = strdup(text);
            }
        }
    }
    
    if(!err) {
        FilePart *file_parts = calloc(count, sizeof(FilePart));
        size_t i = 0;
        CxIterator iter = cxListIterator(parts);
        cx_foreach(FilePart*, p, iter) {
            file_parts[i] = *p;
            free(p);
            i++;
        }
        
        res->parts = file_parts;
        res->numparts = count;
    } 
    
    cxListDestroy(parts);
}

LocalResource* process_resource(xmlTextReaderPtr reader) {
    LocalResource *res = calloc(1, sizeof(LocalResource));
    
    int field = -1;
    while(xmlTextReaderRead(reader)) {
        int type = xmlTextReaderNodeType(reader);
        const xmlChar *name = xmlTextReaderConstName(reader);
        
        if(type == XML_READER_TYPE_ELEMENT) {
            if(xstreq(name, "path")) {
                field = 0;
            } else if(xstreq(name, "etag")) {
                field = 1;
            } else if(xstreq(name, "lastmodified")) {
                field = 2;
            } else if(xstreq(name, "size")) {
                field = 3;
            } else if(xstreq(name, "tags-hash")) {
                field = 4;
            } else if(xstreq(name, "mode")) {
                field = 5;
            } else if(xstreq(name, "uid")) {
                field = 6;
            } else if(xstreq(name, "gid")) {
                field = 7;
            } else if(xstreq(name, "xattr-hash")) {
                field = 8;
            } else if(xstreq(name, "remote-tags-hash")) {
                field = 9;
            } else if(xstreq(name, "blocksize")) {
                field = 10;
            } else if(xstreq(name, "hash")) {
                field = 11;
            } else if(xstreq(name, "link")) {
                field = 12;
            } else if(xstreq(name, "localpath")) {
                field = 13;
            } else if(xstreq(name, "versioncontrol")) {
                field = 14;
            } else if(xstreq(name, "skipped")) {
                res->skipped = TRUE;
            } else if(xstreq(name, "tags-updated")) {
                res->tags_updated = TRUE;
            } else if(xstreq(name, "parts")) {
                process_parts(reader, res);
            } else if(xstreq(name, "isdirectory")) {
                res->isdirectory = 1;
            }
        } else if(type == XML_READER_TYPE_TEXT) {
            const xmlChar *value = xmlTextReaderConstValue(reader);
            //int b = 0;
            switch(field) {
                case 0: {
                    res->path = strdup((char*)value);
                    break;
                }
                case 1: {
                    res->etag = strdup((char*)value);
                    break;
                }
                case 2: {
                    //res->last_modified = util_parse_lastmodified((char*)value);
                    //res->last_modified = atoi((char*)value);
                    char *endptr = (char*)value;
                    time_t t = strtoll((char*)value, &endptr, 10);
                    if(endptr == (char*)value) {
                        fprintf(
                            stderr,
                            "lastmodified does not contain a number: %s\n", value);
                    } else {
                        res->last_modified = t;
                    }
                    break;
                }
                case 3: {
                    res->size = 0;
                    int64_t filelen = 0;
                    if(util_strtoint((char*)value, &filelen)) {
                        if(filelen > 0) {
                            res->size = (size_t)filelen;
                        }
                    }
                    break;
                }
                case 4: {
                    res->tags_hash = strdup((char*)value);
                    break;
                }
                case 5: {
                    char *end;
                    errno = 0;
                    long int mode = strtol((char*)value, &end, 8);
                    if(errno == 0) {
                        res->mode = (mode_t)mode;
                    }
                    break;
                }
                case 6: {
                    uint64_t uid = 0;
                    if(util_strtouint((char*)value, &uid)) {
                        res->uid = (uid_t)uid;
                    }
                    break;
                }
                case 7: {
                    uint64_t gid = 0;
                    if(util_strtouint((char*)value, &gid)) {
                        res->gid = (gid_t)gid;
                    }
                    break;
                }
                case 8: {
                    res->xattr_hash = strdup((char*)value);
                    break;
                }
                case 9: {
                    res->remote_tags_hash = strdup((char*)value);
                    break;
                }
                case 10: {
                    int64_t blsz = 0;
                    if(util_strtoint((char*)value, &blsz)) {
                        if(blsz < -1) {
                            blsz = -1;
                        }
                        if(blsz > 0 && blsz < 16) {
                            blsz = 0;
                        }
                        res->blocksize = blsz;
                    }
                    break;
                }
                case 11: {
                    res->hash = strdup((char*)value);
                    break;
                }
                case 12: {
                    res->link_target = strdup((char*)value);
                    break;
                }
                case 13: {
                    res->local_path = strdup((char*)value);
                }
                case 14: {
                    res->versioncontrol = util_getboolean((char*)value);
                }
            }
        } else if(XML_READER_TYPE_END_ELEMENT) {
            if(xstreq(name, "resource")) {
                break;
            } else {
                field = -1;
            }
        }
    }
    
    if(!res->path) {
        // TODO: free res
        return NULL;
    } else {
        return res;
    }
}

LocalResource* process_conflict(xmlTextReaderPtr reader) {
    LocalResource *res = calloc(1, sizeof(LocalResource));
    
    int field = 0;
    while(xmlTextReaderRead(reader)) {
        int type = xmlTextReaderNodeType(reader);
        const xmlChar *name = xmlTextReaderConstName(reader);
        
        if(type == XML_READER_TYPE_ELEMENT) {
            if(xstreq(name, "path")) {
                field = 1;
            } else if(xstreq(name, "source")) {
                field = 2;
            }
        } else if(type == XML_READER_TYPE_TEXT) {
            const xmlChar *value = xmlTextReaderConstValue(reader);
            switch(field) {
                case 1: {
                    res->path = strdup((const char*)value);
                    break;
                }
                case 2: {
                    res->conflict_source = strdup((const char*)value);
                    break;
                }
            }
        } else if(XML_READER_TYPE_END_ELEMENT) {
            if(xstreq(name, "conflict")) {
                break;
            } else {
                field = 0;
            }
        }
    }
    
    if(!res->path) {
        // TODO: free res
        return NULL;
    } else {
        return res;
    }
}

int store_db(SyncDatabase *db, char *name, uint32_t settings) {
    // open writer
    char *dav_dir = util_concat_path(ENV_HOME, ".dav");
    char *db_file = util_concat_path(dav_dir, name);
    free(dav_dir);
    xmlTextWriterPtr writer = xmlNewTextWriterFilename(db_file, 0);
    if(!writer) {
        fprintf(stderr, "Cannot write db file: %s\n", db_file);
        free(db_file);
        return -1;
    }
    free(db_file);
    
    // start document
    int r = 0;
    r = xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL);
    if(r < 0) {
        xmlFreeTextWriter(writer);
        return -1;
    }
    xmlTextWriterStartElement(writer, BAD_CAST "directory");
    
    // write all resource entries
    CxIterator i = cxMapIteratorValues(db->resources);
    LocalResource *res;
    cx_foreach(LocalResource*, res, i) {
        // <resource>
        xmlTextWriterStartElement(writer, BAD_CAST "resource");
        
        r = xmlTextWriterWriteElement(
                writer,
                BAD_CAST "path",
                BAD_CAST res->path);
        if(r < 0) {
            fprintf(stderr, "Cannot write path: %s\n", res->path);
            xmlFreeTextWriter(writer);
            return -1;
        }
        
        if(res->isdirectory) {
            r = xmlTextWriterStartElement(writer, BAD_CAST "isdirectory");
            r += xmlTextWriterEndElement(writer);
            if(r < 0) {
                fprintf(stderr, "Cannot write isdirectory\n");
                xmlFreeTextWriter(writer);
                return -1;
            }
        }
        
        if(res->etag) {
            r = xmlTextWriterWriteElement(
                    writer,
                    BAD_CAST "etag",
                    BAD_CAST res->etag);
            if(r < 0) {
                fprintf(stderr, "Cannot write etag: %s\n", res->etag);
                xmlFreeTextWriter(writer);
                return -1;
            }
        }
        
        if(res->hash) {
            r = xmlTextWriterWriteElement(
                    writer,
                    BAD_CAST "hash",
                    BAD_CAST res->hash);
            if(r < 0) {
                fprintf(stderr, "Cannot write hash: %s\n", res->hash);
                xmlFreeTextWriter(writer);
                return -1;
            }
        }

        r = xmlTextWriterWriteFormatElement(
                writer,
                BAD_CAST "lastmodified",
                "%" PRId64,
                (int64_t)res->last_modified);
        if(r < 0) {
            fprintf(stderr, "Cannot write lastmodified\n");
            xmlFreeTextWriter(writer);
            return -1;
        }
        
        if(res->blocksize != 0) {
            r = xmlTextWriterWriteFormatElement(
                writer,
                BAD_CAST "mode",
                "%" PRId64,
                res->blocksize);
            if(r < 0) {
                fprintf(stderr, "Cannot write blocksize\n");
                xmlFreeTextWriter(writer);
                return -1;
            }
        }
        
        if((settings & DB_STORE_MODE) == DB_STORE_MODE) {
            r = xmlTextWriterWriteFormatElement(
                writer,
                BAD_CAST "mode",
                "%o",
                (int)res->mode);
            if(r < 0) {
                fprintf(stderr, "Cannot write mode\n");
                xmlFreeTextWriter(writer);
                return -1;
            }
        }
        
        if((settings & DB_STORE_OWNER) == DB_STORE_OWNER) {
            r = xmlTextWriterWriteFormatElement(
                    writer,
                    BAD_CAST "uid",
                    "%u",
                    (unsigned int)res->uid);
            if(r < 0) {
                fprintf(stderr, "Cannot write uid\n");
                xmlFreeTextWriter(writer);
                return -1;
            }
            r = xmlTextWriterWriteFormatElement(
                    writer,
                    BAD_CAST "gid",
                    "%u",
                    (unsigned int)res->gid);
            if(r < 0) {
                fprintf(stderr, "Cannot write gid\n");
                xmlFreeTextWriter(writer);
                return -1;
            }
        }
        
        r = xmlTextWriterWriteFormatElement(
                writer,
                BAD_CAST "size",
                "%" PRId64,
                (int64_t)res->size);
        if(r < 0) {
            fprintf(stderr, "Cannot write size\n");
            xmlFreeTextWriter(writer);
            return -1;
        }
        
        if(res->tags_hash) {
            r = xmlTextWriterWriteElement(
                    writer,
                    BAD_CAST "tags-hash",
                    BAD_CAST res->tags_hash);
            if(r < 0) {
                fprintf(stderr, "Cannot write tags-hash: %s\n", res->tags_hash);
                xmlFreeTextWriter(writer);
                return -1;
            }
        }
        
        if(res->remote_tags_hash) {
            r = xmlTextWriterWriteElement(
                    writer,
                    BAD_CAST "remote-tags-hash",
                    BAD_CAST res->remote_tags_hash);
            if(r < 0) {
                fprintf(stderr, "Cannot write remote-tags-hash: %s\n", res->remote_tags_hash);
                xmlFreeTextWriter(writer);
                return -1;
            }
        }
        
        if(res->link_target) {
            r = xmlTextWriterWriteElement(
                    writer,
                    BAD_CAST "link",
                    BAD_CAST res->link_target);
            if(r < 0) {
                fprintf(stderr, "Cannot write link: %s\n", res->link_target);
                xmlFreeTextWriter(writer);
                return -1;
            }
        }
        
        if(res->local_path) {
            r = xmlTextWriterWriteElement(
                    writer,
                    BAD_CAST "localpath",
                    BAD_CAST res->local_path);
            if(r < 0) {
                fprintf(stderr, "Cannot write localpath: %s\n", res->local_path);
                xmlFreeTextWriter(writer);
                return -1;
            }
        }
        
        
        if(res->xattr_hash) {
            r = xmlTextWriterWriteElement(
                    writer,
                    BAD_CAST "xattr-hash",
                    BAD_CAST res->xattr_hash);
            if(r < 0) {
                fprintf(stderr, "Cannot write xattr-hash: %s\n", res->xattr_hash);
                xmlFreeTextWriter(writer);
                return -1;
            }
        }
        
        if(res->skipped) {
            r = xmlTextWriterStartElement(writer, BAD_CAST "skipped");
            r += xmlTextWriterEndElement(writer);
            if(r < 0) {
                fprintf(stderr, "Cannot write skipped\n");
                xmlFreeTextWriter(writer);
                return -1;
            }
        }
        
        if(res->tags_updated) {
            r = xmlTextWriterStartElement(writer, BAD_CAST "tags-updated");
            r += xmlTextWriterEndElement(writer);
            if(r < 0) {
                fprintf(stderr, "Cannot write tags-updated\n");
                xmlFreeTextWriter(writer);
                return -1;
            }
        }
        
        if(res->numparts > 0) {
            r = xmlTextWriterStartElement(writer, BAD_CAST "parts");
            if(r < 0) {
                xmlFreeTextWriter(writer);
                return -1;
            }
            for(size_t i=0;i<res->numparts;i++) {
                FilePart p = res->parts[i];
                r = xmlTextWriterStartElement(writer, BAD_CAST "part");
                if(r < 0) {
                    xmlFreeTextWriter(writer);
                    return -1;
                }
                
                if(p.hash) {
                    r = xmlTextWriterWriteElement(writer, BAD_CAST "hash", BAD_CAST p.hash);
                    if(r < 0) {
                        xmlFreeTextWriter(writer);
                        return -1;
                    }
                }
                if(p.etag) {
                    r = xmlTextWriterWriteElement(writer, BAD_CAST "etag", BAD_CAST p.etag);
                    if(r < 0) {
                        xmlFreeTextWriter(writer);
                        return -1;
                    }
                }
                r = xmlTextWriterEndElement(writer);
                if(r < 0) {
                    xmlFreeTextWriter(writer);
                    return -1;
                }
            }
            r = xmlTextWriterEndElement(writer);
            if(r < 0) {
                xmlFreeTextWriter(writer);
                return -1;
            }
        }
        
        if(res->versioncontrol) {
            r = xmlTextWriterWriteElement(
                    writer,
                    BAD_CAST "versioncontrol",
                    BAD_CAST "true");
            if(r < 0) {
                fprintf(stderr, "Cannot write versioncontrol\n");
                xmlFreeTextWriter(writer);
                return -1;
            }
        }
        
        // </resource>
        xmlTextWriterEndElement(writer);
    }
    
    // write all remove entries
/*
    i = ucx_map_iterator(db->remove);
    UCX_MAP_FOREACH(key, res, i) {
        // <remove>
        xmlTextWriterStartElement(writer, BAD_CAST "remove");
        
        xmlTextWriterWriteElement(
                    writer,
                    BAD_CAST "path",
                    BAD_CAST res->path);
        
        // </remove>
        xmlTextWriterEndElement(writer);
    }
*/
    
    // write all conflict entries
    i = cxMapIteratorValues(db->conflict);
    cx_foreach(LocalResource*, res, i) {
        // <conflict>
        xmlTextWriterStartElement(writer, BAD_CAST "conflict");
        
        xmlTextWriterWriteElement(
                    writer,
                    BAD_CAST "path",
                    BAD_CAST res->path);
        
        if(res->conflict_source) {
            xmlTextWriterWriteElement(
                    writer,
                    BAD_CAST "source",
                    BAD_CAST res->conflict_source);
        }
        
        // </conflict>
        xmlTextWriterEndElement(writer);
    }
    
    // end
    xmlTextWriterEndElement(writer);
    r = xmlTextWriterEndDocument(writer);
    if(r < 0) {
        xmlFreeTextWriter(writer);
        return -1;
    }
    xmlFreeTextWriter(writer);
    return 0;
}

void destroy_db(SyncDatabase *db) {
    cxMapDestroy(db->resources);
    cxMapDestroy(db->conflict);
    free(db);
}

void local_resource_free(LocalResource *res) {
    if(!res) {
        return;
    }
    if(res->name) {
        free(res->name);
    }
    if(res->path) {
        free(res->path);
    }
    if(res->etag) {
        free(res->etag);
    }
    if(res->cached_tags) {
        cxBufferFree(res->cached_tags);
    }
    if(res->tags_hash) {
        free(res->tags_hash);
    }
    if(res->prev_hash) {
        free(res->prev_hash);
    }
    free(res);
}

static char* nullstrdup(const char *s) {
    return s ? strdup(s) : NULL;
}

void local_resource_copy_parts(LocalResource *from, LocalResource *to) {
    if(from->parts) {
        to->numparts = from->numparts;
        to->parts = calloc(from->numparts, sizeof(FilePart));
        for(int i=0;i<to->numparts;i++) {
            FilePart s = from->parts[i];
            FilePart p;
            p.block = s.block;
            p.hash = nullstrdup(s.hash);
            p.etag = nullstrdup(s.etag);
            to->parts[i] = p;
        }
    }
}

LocalResource* local_resource_copy(LocalResource *src, const char *new_path) {
    LocalResource *newres = calloc(1, sizeof(LocalResource));
    newres->path = strdup(new_path);
    newres->etag = nullstrdup(src->etag);
    newres->hash = nullstrdup(src->hash);
    newres->last_modified = src->last_modified;
    newres->mode = src->mode;
    newres->uid = src->uid;
    newres->gid = src->gid;
    newres->size = src->size;
    newres->isdirectory = src->isdirectory;
    newres->skipped = src->skipped;
    newres->versioncontrol = src->versioncontrol;
    
    if(src->xattr) {
        XAttributes *xattr = calloc(1, sizeof(XAttributes));
        xattr->hash = nullstrdup(src->xattr->hash);
        xattr->nattr = src->xattr->nattr;
        xattr->names = calloc(xattr->nattr, sizeof(char*));
        xattr->values = calloc(xattr->nattr, sizeof(cxmutstr));
        for(int i=0;i<xattr->nattr;i++) {
            xattr->names[i] = strdup(src->xattr->names[i]);
            xattr->values[i] = cx_strdup(cx_strcast(src->xattr->values[i]));
        }
        newres->xattr = xattr;
    }
    
    newres->tags_hash = nullstrdup(src->tags_hash);
    newres->xattr_hash = nullstrdup(src->xattr_hash);
    newres->remote_tags_hash = nullstrdup(src->remote_tags_hash);
    
    local_resource_copy_parts(src, newres);
    
    newres->blocksize = src->blocksize;
    
    newres->tags_updated = src->tags_updated;
    newres->finfo_updated = src->finfo_updated;
    newres->xattr_updated = src->xattr_updated;
    newres->metadata_updated = src->metadata_updated;
    
    return newres;
    
}

void filepart_free(FilePart *part) {
    if(part->etag) {
        free(part->etag);
    }
    if(part->hash) {
        free(part->hash);
    }
    free(part);
}

CxMap* create_hash_index(SyncDatabase *db) {
    CxMap *hmap = cxHashMapCreate(cxDefaultAllocator, CX_STORE_POINTERS, db->resources->size + 64);
    
    CxIterator i = cxMapIteratorValues(db->resources);
    LocalResource *res;
    cx_foreach(LocalResource*, res, i) {
        if(res->hash) {
            cxMapPut(hmap, cx_hash_key_str(res->hash), res);
        }
    }
    
    return hmap;
}