dav/tags.c

/*
 * 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 <ctype.h>

#include <cx/string.h>
#include <cx/utils.h>
#include <cx/printf.h>
#include <cx/hash_map.h>

#include <libidav/crypto.h>

#include "libxattr.h"

#include "tags.h"

#ifdef __APPLE__
#include <CoreFoundation/CoreFoundation.h>
#endif

void free_dav_tag(DavTag* tag) {
    free(tag->name);
    if(tag->color) {
        free(tag->color);
    }
    free(tag);
}

void free_taglist(CxList *list) {
    if(!list) {
        return;
    }
    cxListDestroy(list);
}

int compare_tagname(DavTag* left, DavTag* right, void* ignorecase) {
    cxstring leftname = cx_str(left->name);
    cxstring rightname = cx_str(right->name);
    if (ignorecase && *((int*) ignorecase)) {
        return cx_strcasecmp(leftname, rightname);
    } else {
        return cx_strcmp(leftname, rightname);
    }
}

CxList* parse_text_taglist(const char *buf, size_t length) {
    CxList *tags = cxLinkedListCreateSimple(CX_STORE_POINTERS);
    cxDefineDestructor(tags, free_dav_tag);
    
    int line_start = 0;
    for(int i=0;i<length;i++) {
        if(buf[i] == '\n' || i == length-1) {
            cxstring line = cx_strtrim(cx_strn((char*)buf + line_start, i - line_start));
            if(line.length > 0) {
                DavTag *tag = calloc(1, sizeof(DavTag));
                cxstring color = cx_strchr(line, '#');
                if(color.length>0) {
                    cxstring name = line;
                    name.length = (int)(color.ptr-line.ptr);
                    if(name.length != 0) {
                        tag->name = cx_strdup(name).ptr;
                        color.ptr++;
                        color.length--;
                        if(color.length > 0) {
                            tag->color = cx_strdup(color).ptr;
                        }
                    } else {
                        free(tag);
                    }
                } else {
                    tag->name = cx_strdup(line).ptr;
                    tag->color = NULL;
                }
                
                cxListAdd(tags, tag);
            }
            line_start = i+1;
        }
    }
    
    return tags;
}

CxMap* taglist2map(CxList *tags) {
    if(!tags) {
        return cxHashMapCreate(cxDefaultAllocator, CX_STORE_POINTERS, 8);
    }
    
    CxMap *map = cxHashMapCreate(cxDefaultAllocator, CX_STORE_POINTERS, cxListSize(tags) + 8);
    CxIterator iter = cxListIterator(tags);
    cx_foreach(DavTag*, t, iter) {
        cxMapPut(map, cx_hash_key_str(t->name), t);
    }
    return map;
}

CxBuffer* create_text_taglist(CxList *tags) {
    if(!tags) {
        return NULL;
    }
    
    CxBuffer *buf = cxBufferCreate(NULL, 128, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
    CxIterator i = cxListIterator(tags);
    cx_foreach(DavTag *, tag, i) {
        if(tag->color) {
            cx_bprintf(buf, "%s#%s\n", tag->name, tag->color);
        } else {
            cx_bprintf(buf, "%s\n", tag->name);
        }
    }
    return buf;
}


CxList* parse_csv_taglist(const char *buf, size_t length) {
    CxList *taglist = cxLinkedListCreateSimple(CX_STORE_POINTERS);
    cxDefineDestructor(taglist, free_dav_tag);
    
    cxstring str = cx_strn(buf, length);
    CxStrtokCtx tags = cx_strtok(str, CX_STR(","), INT_MAX);
    cxstring tagstr;
    while(cx_strtok_next(&tags, &tagstr)) {
        cxstring trimmed_tag = cx_strtrim(tagstr);
        if (trimmed_tag.length > 0) {
            DavTag *tag = malloc(sizeof(DavTag));
            tag->name = cx_strdup(trimmed_tag).ptr;
            tag->color = NULL;
            cxListAdd(taglist, tag);
        }
    }
    return taglist;
}

CxBuffer* create_csv_taglist(CxList *tags) {
    CxBuffer *buf = cxBufferCreate(NULL, 128, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);
    int insertsep = 0;
    CxIterator i = cxListIterator(tags);
    cx_foreach(DavTag*, tag, i) {
        if(insertsep) {
            cxBufferPut(buf, ',');
        }
        cxBufferPutString(buf, tag->name);
        insertsep = 1;
    }
    return buf;
}


static DavTag* parse_xml_dav_tag(DavXmlNode *node) {
    char *name = NULL;
    char *color = NULL;
    
    DavXmlNode *c = node->children;
    while(c) {
        if(c->type == DAV_XML_ELEMENT) {
            char *value = dav_xml_getstring(c->children);
            if(value) {
                if(!strcmp(c->namespace, DAV_PROPS_NS)) {
                    if(!strcmp(c->name, "name")) {
                        name = value;
                    }
                    if(!strcmp(c->name, "color")) {
                        color = value;
                    }
                }
            }
        }
        c = c->next;
    }
    
    DavTag *tag = NULL;
    if(name) {
        tag = malloc(sizeof(DavTag));
        tag->name = strdup(name);
        tag->color = color ? strdup(color) : NULL;
    }
    return tag;
} 

CxList* parse_dav_xml_taglist(DavXmlNode *taglistnode) {
    CxList *tags = cxLinkedListCreateSimple(CX_STORE_POINTERS);
    cxDefineDestructor(tags, free_dav_tag);
    
    DavXmlNode *node = taglistnode;
    while(node) {
        if(node->type == DAV_XML_ELEMENT) {
            if(!strcmp(node->namespace, DAV_PROPS_NS) && !strcmp(node->name, "tag")) {
                DavTag *tag = parse_xml_dav_tag(node);
                if(tag) {
                    cxListAdd(tags, tag);
                }
            }
        } 
        node = node->next;
    }
    
    return tags;
}

DavXmlNode* create_xml_taglist(CxList *tags) {
    DavXmlNode *tag1 = NULL;
    DavXmlNode *lasttag = NULL;
    CxIterator i = cxListIterator(tags);
    cx_foreach(DavTag*, tag, i) {
        DavXmlNode *tagelm = dav_xml_createnode(DAV_PROPS_NS, "tag");
        DavXmlNode *tagname = dav_xml_createnode_with_text(DAV_PROPS_NS, "name", tag->name);
        tagelm->children = tagname;
        if(tag->color) {
            DavXmlNode *tagcolor = dav_xml_createnode_with_text(DAV_PROPS_NS, "color", tag->color);
            tagname->next = tagcolor;
        }
        
        if(lasttag) {
            lasttag->next = tagelm;
            tagelm->prev = lasttag;
        } else {
            tag1 = tagelm;
        }
        lasttag = tagelm;
    }
    return tag1;
}


#ifdef __APPLE__
static DavTag* tagstr2davtag(const char *str) {
    const char *name = str;
    const char *color = NULL;
    size_t len = strlen(str);
    size_t namelen = len;
    
    if(len == 0) {
        return NULL;
    }
    
    // start with 1 because the first char should not be a linebreak
    for(int i=1;i<len;i++) {
        if(str[i] == '\n') {
            if(!color) {
                color = str + i + 1;
                namelen = i;
            }
        }
    }
    int colorlen = len - namelen - 1;
    
    DavTag *tag = malloc(sizeof(DavTag));
    tag->name = malloc(namelen + 1);
    memcpy(tag->name, name, namelen);
    tag->name[namelen] = 0;
    if(colorlen > 0) {
        tag->color = malloc(colorlen + 1);
        memcpy(tag->color, color, colorlen);
        tag->color[colorlen] = 0;
    } else {
        tag->color = NULL;
    }
    
    return tag;
}

CxList* parse_macos_taglist(const char *buf, size_t length) {
    CxList *taglist = cxLinkedListCreateSimple(CX_STORE_POINTERS);
    taglist->simple_destructor = (cx_destructor_func)free_dav_tag;
    
    CFDataRef data = CFDataCreateWithBytesNoCopy(
            kCFAllocatorDefault,
            (const UInt8*)buf,
            length,
            kCFAllocatorNull);
    CFPropertyListRef propertylist = CFPropertyListCreateWithData(kCFAllocatorDefault, data, 0, NULL, NULL);
    CFArrayRef array = propertylist;
    int count = CFArrayGetCount(array);
    for(int i=0;i<count;i++) {
        CFStringRef str = CFArrayGetValueAtIndex(array, i);
        int slen = CFStringGetLength(str);
        size_t cstrbuflen = slen * 4 + 4;
        char *cstr = malloc(cstrbuflen);
        if(CFStringGetCString(str, cstr, cstrbuflen, kCFStringEncodingUTF8)) {
            DavTag *tag = tagstr2davtag(cstr);
            if(tag) {
                cxListAdd(taglist, tag);
            }
        }
        free(cstr);
    }
    
    CFRelease(propertylist);
    CFRelease(data);
    
    return taglist;
}

CxBuffer* create_macos_taglist(CxList *tags) {
    size_t count = tags->size;
    if(count == 0) {
        return NULL;
    }
    
    CFStringRef *strings = calloc(sizeof(CFStringRef), count);
    int i = 0;
    CxIterator iter = cxListIterator(tags);
    cx_foreach(DavTag*, tag, iter) {
        CFStringRef str = NULL;
        if(tag->color) {
            cxmutstr s = cx_strcat(3, cx_mutstr(tag->name), CX_STR("\n"), cx_str(tag->color));
            str = CFStringCreateWithCString(kCFAllocatorDefault, s.ptr, kCFStringEncodingUTF8);
            free(s.ptr);
        } else {
            str = CFStringCreateWithCString(kCFAllocatorDefault, tag->name, kCFStringEncodingUTF8);
        }
        strings[i] = str;
        i++; 
    }
    
    CFPropertyListRef array = CFArrayCreate(kCFAllocatorDefault, (const void**)strings, count, &kCFTypeArrayCallBacks);
    CFDataRef data = CFPropertyListCreateData(kCFAllocatorDefault, array, kCFPropertyListBinaryFormat_v1_0, 0, NULL);
    
    CxBuffer *buf = NULL;
    if(data) {
        int datalen = CFDataGetLength(data);
        CFRange range;
        range.location = 0;
        range.length = datalen;
        buf = cxBufferCreate(NULL, datalen, cxDefaultAllocator, 0);
        CFDataGetBytes(data, range, (UInt8*)buf->space);
        buf->size = datalen;
        CFRelease(data);
    }
    
    for(int i=0;i<count;i++) {
        CFRelease(strings[i]);
    }
    CFRelease(array);
    
    return buf;
}

#else
CxList* parse_macos_taglist(const char *buf, size_t length) {
    fprintf(stderr, "Error: macos tags not supported on this platform.\n");
    return NULL;
}
CxBuffer* create_macos_taglist(CxList *tags) {
    fprintf(stderr, "Error: macos tags not supported on this platform.\n");
    return NULL;
}
#endif


int compare_taglists(CxList *tags1, CxList *tags2) {
    if(!tags1) {
        return tags2 ? 0 : 1;
    }
    if(!tags2) {
        return tags1 ? 0 : 1;
    }
    
    CxMap *map1 = taglist2map(tags1);
    
    int equal = 1;
    int i = 0;
    CxIterator iter = cxListIterator(tags2);
    cx_foreach(DavTag*, t, iter) {
        if(!cxMapGet(map1, cx_hash_key_str(t->name))) {
            equal = 0;
            break;
        }
        i++;
    }
    
    if(i != cxMapSize(map1)) {
        equal = 0;
    }
    cxMapDestroy(map1);
    return equal;
}

char* create_tags_hash(CxList *tags) {
    if(!tags) {
        return NULL;
    }
    CxBuffer *buf = create_text_taglist(tags);
    char *hash = dav_create_hash(buf->space, buf->size);
    cxBufferDestroy(buf);
    return hash;
}

CxList* merge_tags(CxList *tags1, CxList *tags2) {
    // this map is used to check the existence of tags
    CxMap *tag_map = cxHashMapCreate(cxDefaultAllocator, CX_STORE_POINTERS, 32);
    // merged taglist
    CxList *new_tags = cxLinkedListCreateSimple(CX_STORE_POINTERS);
    cxDefineDestructor(new_tags, free_dav_tag);

    // add all local tags
    if(tags1) {
        CxIterator iter = cxListIterator(tags1);
        cx_foreach(DavTag*, t, iter) {
            cxMapPut(tag_map, cx_hash_key_str(t->name), t);
            DavTag *newt = calloc(1, sizeof(DavTag));
            newt->color = t->color ? strdup(t->color) : NULL;
            newt->name = strdup(t->name);
            cxListAdd(new_tags, newt);
        }
    }
   
    // check if a remote tag is already in the map
    // and if not add it to the new taglist
    if(tags2) {
        CxIterator iter = cxListIterator(tags2);
        cx_foreach(DavTag*, t, iter) {
            if(!cxMapGet(tag_map, cx_hash_key_str(t->name))) {
                DavTag *newt = calloc(1, sizeof(DavTag));
                newt->color = t->color ? strdup(t->color) : NULL;
                newt->name = strdup(t->name);
                cxListAdd(new_tags, newt);
            }
        }
    }

    cxMapDestroy(tag_map);

    return new_tags;
}

void add_tag_colors(CxList *taglist, CxList *colored) {
    CxMap *tagmap = taglist2map(taglist);
    
    CxIterator i = cxListIterator(colored);
    cx_foreach(DavTag*, colored_tag, i) {
        if(colored_tag->color) {
            DavTag *tag = cxMapGet(tagmap, cx_hash_key_str(colored_tag->name));
            if(tag && !tag->color) {
                tag->color = strdup(colored_tag->color);
            }
        }
    }
    
    cxMapDestroy(tagmap);
}

/* ----------- ----------- tag filter  ---------------------- */

static size_t rtrimskip(cxstring str, size_t skip) {
    while (skip < str.length && isspace(str.ptr[skip])) skip++;
    return skip;
}

static size_t parse_tagfilter_taglist(cxstring fs, SyncTagFilter* tagfilter) {
    size_t csvlen;
    for (csvlen = 0 ; csvlen < fs.length ; ++csvlen) {
        if (fs.ptr[csvlen] == ')') break;
    }
    fs.length = csvlen;
        
    tagfilter->tags = parse_csv_taglist(fs.ptr, fs.length);
        
    return csvlen;
}

static size_t parse_tagfilter_subfilters(cxstring fs, SyncTagFilter* tagfilter);

static size_t parse_tagfilter_filter(cxstring fs, SyncTagFilter* tagfilter) {
    
    size_t consumed = rtrimskip(fs, 0);
    fs = cx_strsubs(fs, consumed);
    
    if (fs.length == 0) {
        return consumed;
    } else {

        // optional operator
        int hasop = 0;
        if (fs.ptr[0] == '&') {
            tagfilter->mode = DAV_SYNC_TAGFILTER_AND;
            hasop = 1;
        } else if (fs.ptr[0] == '|') {
            tagfilter->mode = DAV_SYNC_TAGFILTER_OR;
            hasop = 1;
        } else if (fs.ptr[0] == '0') {
            tagfilter->mode = DAV_SYNC_TAGFILTER_NONE;
            hasop = 1;
        } else if (fs.ptr[0] == '1') {
            tagfilter->mode = DAV_SYNC_TAGFILTER_ONE;
            hasop = 1;
        } else {
            // default operator is AND
            tagfilter->mode = DAV_SYNC_TAGFILTER_AND;
        }
        
        if (hasop) {
            size_t skip = rtrimskip(fs, 1);
            consumed += skip;
            fs = cx_strsubs(fs, skip);
        }

        if (fs.length > 0 && fs.ptr[0] == '(') {
            size_t c = parse_tagfilter_subfilters(fs, tagfilter);
            if (c) {
                return consumed + c;
            } else {
                return 0;
            }
        } else {
            tagfilter->subfilter_count = 0;
            tagfilter->subfilters = NULL;
            return consumed + parse_tagfilter_taglist(fs, tagfilter);
        }
    }
}

/*
 * Parses:  ( "(" , filter , ")" )+
 */
static size_t parse_tagfilter_subfilters(cxstring fs, SyncTagFilter* f) {
    
    // strategy: allocate much and give back later (instead of reallocs in loop)
    size_t subfilter_cap = 8;
    f->subfilters = calloc(subfilter_cap, sizeof(SyncTagFilter*));
    f->subfilter_count = 0;
    
    size_t total_consumed = 0;
    size_t c;
    do {
        // skip leading parenthesis (and white spaces)
        c = rtrimskip(fs, 1);
        fs = cx_strsubs(fs, c);
        total_consumed += c;
    
        // increase array capacity, if necessary
        if (f->subfilter_count >= subfilter_cap) {
            subfilter_cap *= 2;
            SyncTagFilter** newarr = realloc(f->subfilters,
                    subfilter_cap * sizeof(SyncTagFilter*));
            if (newarr) {
                f->subfilters = newarr;
            } else {
                abort(); // no error handling reachable, so we are fucked
            }
        }
        
        // allocate space for a new filter
        SyncTagFilter* subf = calloc(1, sizeof(SyncTagFilter));
        
        // parse that filter
        c = parse_tagfilter_filter(fs, subf);
        
        // sanity check: we must end with a closing parenthesis
        if (c > 0 && fs.ptr[c] == ')') {
            f->subfilters[f->subfilter_count++] = subf;
            
            // consume ')' and find the next parenthesis or the end-of-string
            c = rtrimskip(fs, 1+c);
            fs = cx_strsubs(fs, c);
            total_consumed += c;

            if (fs.length == 0 || fs.ptr[0] == ')') {
                // our job is done
                break;
            } else if (fs.ptr[0] != '(') {
                // anything else than a parenthesis or end-of-string is an error
                return 0;
            }
        } else {
            free(subf);
            break;
        }
        
    } while(1);
    
    // try to shrink the array
    if (f->subfilter_count > 0) {
        SyncTagFilter** shrinked_array = realloc(f->subfilters,
                f->subfilter_count * sizeof(SyncTagFilter*));
        if (shrinked_array) {
            f->subfilters = shrinked_array;
        }
    } else {
        free(f->subfilters);
        f->subfilters = NULL;
    }
        
    return total_consumed;
}

SyncTagFilter* parse_tagfilter_string(const char* filterstring, int scope) {
    SyncTagFilter* tagfilter = calloc(1, sizeof(SyncTagFilter));
    tagfilter->scope = scope;
    if (!filterstring) {
        return tagfilter;
    }
    
    cxstring fs = cx_str(filterstring);
    size_t consumed = parse_tagfilter_filter(fs, tagfilter);
    if (!consumed) {
        free_tagfilter(tagfilter);
        return NULL;
    }
    
    // consume trailing white spaces
    consumed = rtrimskip(fs, consumed);
    
    // sanity check: have we consumed the whole string?
    if (consumed != fs.length) {
        free_tagfilter(tagfilter);
        return NULL;
    }
        
    return tagfilter;
}

void free_tagfilter(SyncTagFilter* filter) {
    for (size_t i = 0 ; i < filter->subfilter_count ; i++) {
        free_tagfilter(filter->subfilters[i]);
    }
    free(filter->subfilters);
    free(filter);
}


static int matches_tags_and(CxList *dav_tags, CxList *tags, int ignorecase) {
    // ignorecase not supported yet
    int ret = 1;
    CxMap *tagmap = taglist2map(dav_tags);
    CxIterator i = cxListIterator(tags);
    cx_foreach(DavTag *, tag, i) {
        if (cxMapGet(tagmap, cx_hash_key_str(tag->name)) == NULL) {
            ret = 0;
            break;
        }
    }
    cxMapDestroy(tagmap);
    return ret;
}

static int matches_tags_or(CxList *dav_tags, CxList *tags, int ignorecase) {
    // ignorecase not supported yet
    int ret = 0;
    CxMap *tagmap = taglist2map(dav_tags);
    CxIterator i = cxListIterator(tags);
    cx_foreach(DavTag *, tag, i) {
        if (cxMapGet(tagmap, cx_hash_key_str(tag->name))) {
            ret = 1;
            break;
        }
    }
    cxMapDestroy(tagmap);
    return ret;
}

static int matches_tags_one(CxList *dav_tags, CxList *tags, int ignorecase) {
    int matches_exactly_one = 0;
    CxMap *tagmap = taglist2map(dav_tags);
    CxIterator i = cxListIterator(tags);
    cx_foreach(DavTag *, tag, i) {
        if (cxMapGet(tagmap, cx_hash_key_str(tag->name))) {
            if (matches_exactly_one) {
                cxMapDestroy(tagmap);
                return 0;
            } else {
                matches_exactly_one = 1;
            }
        }
    }
    cxMapDestroy(tagmap);
    return matches_exactly_one;
}

static int matches_subfilters_and(CxList *dav_tags, SyncTagFilter *filter) {
    int ret = 1;
    for (size_t i = 0 ; i < filter->subfilter_count ; i++) {
        ret &= matches_tagfilter(dav_tags, filter->subfilters[i]);
    }
    return ret;
}

static int matches_subfilters_or(CxList *dav_tags, SyncTagFilter *filter) {
    int ret = 0;
    for (size_t i = 0 ; i < filter->subfilter_count ; i++) {
        ret |= matches_tagfilter(dav_tags, filter->subfilters[i]);
    }
    return ret;
}

static int matches_subfilters_one(CxList *dav_tags, SyncTagFilter *filter) {
    int one = 0;
    for (size_t i = 0 ; i < filter->subfilter_count ; i++) {
        if (matches_tagfilter(dav_tags, filter->subfilters[i])) {
            if (one) {
                return 0;
            } else {
                one = 1;
            }
        }
    }
    return one;
}

int matches_tagfilter(CxList *dav_tags, SyncTagFilter *tagfilter) {

    if (tagfilter->subfilter_count > 0) {
        switch (tagfilter->mode) {
        case DAV_SYNC_TAGFILTER_OR:
            return matches_subfilters_or(dav_tags, tagfilter);
        case DAV_SYNC_TAGFILTER_AND:
            return matches_subfilters_and(dav_tags, tagfilter);
        case DAV_SYNC_TAGFILTER_NONE:
            return !matches_subfilters_or(dav_tags, tagfilter);
        case DAV_SYNC_TAGFILTER_ONE:
            return matches_subfilters_one(dav_tags, tagfilter);
        default:
            abort();
        }
    } else {
        int ignorecase = 0; // TODO: maybe add support later
        switch (tagfilter->mode) {
        case DAV_SYNC_TAGFILTER_OR:
            return matches_tags_or(dav_tags, tagfilter->tags, ignorecase);
        case DAV_SYNC_TAGFILTER_AND:
            return matches_tags_and(dav_tags, tagfilter->tags, ignorecase);
        case DAV_SYNC_TAGFILTER_NONE:
            return !matches_tags_or(dav_tags, tagfilter->tags, ignorecase);
        case DAV_SYNC_TAGFILTER_ONE:
            return matches_tags_one(dav_tags, tagfilter->tags, ignorecase);
        default:
            abort();
        }
    }
}