icalset.c

Go to the documentation of this file.

/*======================================================================
 FILE: icalset.c
 CREATOR: eric 17 Jul 2000
 
 SPDX-FileCopyrightText: 2000, Eric Busboom <eric@civicknowledge.com>
 SPDX-License-Identifier: LGPL-2.1-only OR MPL-2.0
 
 Icalset is the "base class" for representations of a collection of
 iCal components. Derived classes (actually delegates) include:
 
    icalfileset   Store components in a single file
    icaldirset    Store components in multiple files in a directory
    icalheapset   Store components on the heap
    icalmysqlset  Store components in a mysql database.
 
 The Original Code is eric. The Initial Developer of the Original
 Code is Eric Busboom
======================================================================*/

 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include "icalset.h"
#include "icaldirset.h"
#include "icaldirsetimpl.h"
#include "icalerror_p.h"
#include "icalfileset.h"
#include "icalfilesetimpl.h"
 
#if defined(HAVE_BDB)
#include "icalbdbset.h"
#include "icalbdbsetimpl.h"
#endif
 
#include <errno.h>
#include <stdlib.h>
 
/* #define _DLOPEN_TEST */
#if defined(_DLOPEN_TEST)
#include <sys/types.h>
#include <dlfcn.h>
#include <dirent.h>
#endif
 
static icalset icalset_dirset_init = {
    ICAL_DIR_SET,
    sizeof(icaldirset),
    NULL,
    icaldirset_init,
    icaldirset_free,
    icaldirset_path,
    icaldirset_mark,
    icaldirset_commit,
    icaldirset_add_component,
    icaldirset_remove_component,
    icaldirset_count_components,
    icaldirset_select,
    icaldirset_clear,
    icaldirset_fetch,
    icaldirset_fetch_match,
    icaldirset_has_uid,
    icaldirset_modify,
    icaldirset_get_current_component,
    icaldirset_get_first_component,
    icaldirset_get_next_component,
    icaldirset_begin_component,
    icaldirsetiter_to_next,
    icaldirsetiter_to_prior};
 
static icalset icalset_fileset_init = {
    ICAL_FILE_SET,
    sizeof(icalfileset),
    NULL,
    icalfileset_init,
    icalfileset_free,
    icalfileset_path,
    icalfileset_mark,
    icalfileset_commit,
    icalfileset_add_component,
    icalfileset_remove_component,
    icalfileset_count_components,
    icalfileset_select,
    icalfileset_clear,
    icalfileset_fetch,
    icalfileset_fetch_match,
    icalfileset_has_uid,
    icalfileset_modify,
    icalfileset_get_current_component,
    icalfileset_get_first_component,
    icalfileset_get_next_component,
    icalfileset_begin_component,
    icalfilesetiter_to_next,
    NULL};
 
#if defined(HAVE_BDB)
static icalset icalset_bdbset_init = {
    ICAL_BDB_SET,
    sizeof(icalbdbset),
    NULL,
    icalbdbset_init,
    icalbdbset_free,
    icalbdbset_path,
    icalbdbset_mark,
    icalbdbset_commit,
    icalbdbset_add_component,
    icalbdbset_remove_component,
    icalbdbset_count_components,
    icalbdbset_select,
    icalbdbset_clear,
    icalbdbset_fetch,
    icalbdbset_fetch_match,
    icalbdbset_has_uid,
    icalbdbset_modify,
    icalbdbset_get_current_component,
    icalbdbset_get_first_component,
    icalbdbset_get_next_component,
    icalbdbset_begin_component,
    icalbdbsetiter_to_next,
    NULL};
#endif
 
#if defined(_DLOPEN_TEST)
static int icalset_init_done = 0;
static icalpvl_list icalset_kinds = 0;
 
typedef icalset *(*fptr)(void);

static bool load(const char *file)
{
    void *modh;
    fptr inith;
    const char *dlerr;
    icalset *icalset_init_ptr;
 
    if ((modh = dlopen(file, RTLD_NOW)) == 0) {
        perror("dlopen");
        return false;
    }
 
    (void)dlerror(); /* clear */
    inith = (fptr)dlsym(modh, "InitModule");
    dlerr = dlerror();
    if (dlerr != NULL) {
        fprintf(stderr, "dlsym error: %s\n", dlerr);
        dlclose(modh);
        return false;
    }
 
    while ((icalset_init_ptr = ((inith)())) != 0) {
        icalpvl_push(icalset_kinds, &icalset_init_ptr);
    }
 
    (void)dlerror(); /* clear */
    dlclose(modh);
    return true;
}
 
static void icalset_init(void)
{
    assert(icalset_kinds == 0);
    icalset_kinds = icalpvl_newlist();
 
    icalpvl_push(icalset_kinds, &icalset_fileset_init);
    icalpvl_push(icalset_kinds, &icalset_dirset_init);
#if defined(HAVE_BDB)
    icalpvl_push(icalset_kinds, &icalset_bdb4set_init);
#endif
 
    icalset_init_done++;
}
 
bool icalset_register_class(icalset *set)
{
    if (!icalset_init_done) {
        icalset_init();
    }
 
    icalpvl_push(icalset_kinds, set);
    return true;
}
 
#endif
 
icalset *icalset_new(icalset_kind kind, const char *dsn, void *options)
{
    icalset *data = NULL;
    icalset *ret = NULL;
 
#if defined(_DLOPEN_TEST)
    icalpvl_elem e;
    const icalset *impl;
 
    if (!icalset_init_done) {
        icalset_init();
    }
 
    for (e = icalpvl_head(icalset_kinds); e != 0; e = icalpvl_next(e)) {
        impl = (icalset *)icalpvl_data(e);
        if (impl->kind == kind) {
            break;
        }
    }
    if (e == 0) {
        icalerror_set_errno(ICAL_UNIMPLEMENTED_ERROR);
        return (NULL);
    }
 
    data = (icalset *)malloc(impl->size);
    if (data == (icalset *)NULL) {
        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
        errno = ENOMEM;
        return 0;
    }
 
    /* The first member of the derived class must be an icalset. */
    memset(data, 0, impl->size);
    /* *data = *impl; */
    memcpy(data, impl, sizeof(icalset));
 
    data->dsn = strdup(dsn);
#else
    switch (kind) {
    case ICAL_FILE_SET: {
        icalfileset *fdata;
        fdata = (icalfileset *)malloc(sizeof(icalfileset));
        data = (icalset *)fdata;
        if (data == 0) {
            icalerror_set_errno(ICAL_NEWFAILED_ERROR);
            errno = ENOMEM;
            return 0;
        }
        memset(data, 0, sizeof(icalfileset));
        *data = icalset_fileset_init;
        break;
    }
    case ICAL_DIR_SET: {
        icaldirset *ddata;
        ddata = (icaldirset *)malloc(sizeof(icaldirset));
        data = (icalset *)ddata;
        if (data == 0) {
            icalerror_set_errno(ICAL_NEWFAILED_ERROR);
            errno = ENOMEM;
            return 0;
        }
        memset(data, 0, sizeof(icaldirset));
        *data = icalset_dirset_init;
        break;
    }
#if defined(HAVE_BDB)
    case ICAL_BDB_SET: {
        icalbdbset *bdata;
        bdata = (icalbdbset *)malloc(sizeof(icalbdbset));
        data = (icalset *)bdata;
        if (data == 0) {
            icalerror_set_errno(ICAL_NEWFAILED_ERROR);
            errno = ENOMEM;
            return 0;
        }
        memset(data, 0, sizeof(icalbdbset));
        *data = icalset_bdbset_init;
        break;
    }
#endif
 
    default:
        icalerror_set_errno(ICAL_UNIMPLEMENTED_ERROR);
        return (NULL);
    }
 
    data->kind = kind;
    data->dsn = strdup(dsn);
#endif

    if ((ret = data->init(data, dsn, options)) == NULL) {
        /* coverity[alloc_free_mismatch] */
        icalset_free(data);
    }
 
    return ret;
}
 
icalset *icalset_new_file(const char *path)
{
    return icalset_new(ICAL_FILE_SET, path, NULL);
}
 
icalset *icalset_new_file_writer(const char *path)
{
    return icalfileset_new_writer(path);
}
 
icalset *icalset_new_file_reader(const char *path)
{
    return icalfileset_new_reader(path);
}
 
icalset *icalset_new_dir(const char *path)
{
    return icalset_new(ICAL_DIR_SET, path, NULL);
}
 
icalset *icalset_new_dir_writer(const char *path)
{
    return icaldirset_new_writer(path);
}
 
icalset *icalset_new_dir_reader(const char *path)
{
    return icaldirset_new_reader(path);
}
 
/* Functions for built-in methods */
 
void icalset_free(icalset *set)
{
    if (set->free) {
        set->free(set);
    }
 
    if (set->dsn) {
        free(set->dsn);
    }
 
    free(set);
}
 
const char *icalset_path(icalset *set)
{
    return set->path(set);
}
 
void icalset_mark(icalset *set)
{
    set->mark(set);
}
 
icalerrorenum icalset_commit(icalset *set)
{
    return set->commit(set);
}
 
icalerrorenum icalset_add_component(icalset *set, icalcomponent *comp)
{
    return set->add_component(set, comp);
}
 
icalerrorenum icalset_remove_component(icalset *set, icalcomponent *comp)
{
    return set->remove_component(set, comp);
}
 
int icalset_count_components(icalset *set, icalcomponent_kind kind)
{
    return set->count_components(set, kind);
}
 
icalerrorenum icalset_select(icalset *set, icalgauge *gauge)
{
    return set->select(set, gauge);
}
 
void icalset_clear(icalset *set)
{
    set->clear(set);
}
 
icalcomponent *icalset_fetch(icalset *set, const char *uid)
{
    return set->fetch(set, 0, uid);
}
 
icalcomponent *icalset_fetch_match(icalset *set, const icalcomponent *comp)
{
    return set->fetch_match(set, comp);
}
 
int icalset_has_uid(icalset *set, const char *uid)
{
    return set->has_uid(set, uid);
}
 
icalerrorenum icalset_modify(icalset *set, icalcomponent *old, icalcomponent *new)
{
    return set->modify(set, old, new);
}
 
icalcomponent *icalset_get_current_component(icalset *set)
{
    return set->get_current_component(set);
}
 
icalcomponent *icalset_get_first_component(icalset *set)
{
    return set->get_first_component(set);
}
 
icalcomponent *icalset_get_next_component(icalset *set)
{
    return set->get_next_component(set);
}
 
icalsetiter icalsetiter_null = {{ICAL_NO_COMPONENT, 0}, 0, 0, 0, 0};
 
icalsetiter icalset_begin_component(icalset *set,
                                    icalcomponent_kind kind, icalgauge *gauge, const char *tzid)
{
    return set->icalset_begin_component(set, kind, gauge, tzid);
}
 
icalcomponent *icalsetiter_next(icalsetiter *itr)
{
    icalcomponent *c = 0;
 
    icalerror_check_arg_rz((itr != NULL), "i");
 
    do {
        c = icalcompiter_next(&(itr->iter));
        if (c != 0 && (itr->gauge == 0 || icalgauge_compare(itr->gauge, c) == 1)) {
            return c;
        }
    } while (c != 0);
 
    return 0;
}
 
icalcomponent *icalsetiter_prior(icalsetiter *i)
{
    icalcomponent *c = 0;
 
    icalerror_check_arg_rz((i != NULL), "i");
 
    do {
        c = icalcompiter_prior(&(i->iter));
        if (c != 0 && (i->gauge == 0 || icalgauge_compare(i->gauge, c) == 1)) {
            return c;
        }
    } while (c != 0);
 
    return 0;
}
 
icalcomponent *icalsetiter_deref(icalsetiter *i)
{
    icalerror_check_arg_rz((i != NULL), "i");
    return (icalcompiter_deref(&(i->iter)));
}
 
/* For subclasses that use multiple clusters that require specialized cluster traversal */
icalcomponent *icalsetiter_to_next(icalset *set, icalsetiter *i)
{
    return set->icalsetiter_to_next(set, i);
}
 
icalcomponent *icalsetiter_to_prior(icalset *set, icalsetiter *i)
{
    return set->icalsetiter_to_prior(set, i);
}