aboutsummaryrefslogtreecommitdiffstats
path: root/libical/src/libicalss
diff options
context:
space:
mode:
Diffstat (limited to 'libical/src/libicalss')
-rw-r--r--libical/src/libicalss/Makefile49
-rw-r--r--libical/src/libicalss/Makefile.in48
-rw-r--r--libical/src/libicalss/icalcalendar.c263
-rw-r--r--libical/src/libicalss/icalcalendar.h68
-rw-r--r--libical/src/libicalss/icalcluster.c399
-rw-r--r--libical/src/libicalss/icalcluster.h75
-rw-r--r--libical/src/libicalss/icalcomponent.h115
-rw-r--r--libical/src/libicalss/icalstore.c815
-rw-r--r--libical/src/libicalss/icalstore.h78
9 files changed, 1910 insertions, 0 deletions
diff --git a/libical/src/libicalss/Makefile b/libical/src/libicalss/Makefile
new file mode 100644
index 0000000000..91691b9051
--- /dev/null
+++ b/libical/src/libicalss/Makefile
@@ -0,0 +1,49 @@
+# Generated automatically from Makefile.in by configure.
+SOURCES = icalcluster.c icalstore.c icalcalendar.c
+OBJECTS = ${SOURCES:.c=.o}
+INCLUDES = -I . -I.. -I../libical
+CFLAGS = -Wall -g $(INCLUDES) -DSTDC_HEADERS=1 -DHAVE_MALLOC_H=1 -DHAVE_UNISTD_H=1 -DHAVE_TIME_H=1 -DHAVE_STDIO_H=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_ASSERT_H=1 -DHAVE_STRDUP=1 -DICAL_ERRORS_ARE_FATAL
+LIBS =
+CC = gcc
+AR = ar cr
+RANLIB = ranlib
+
+prefix = /usr/local
+PREFIX = ${prefix}
+EXEC_PREFIX = ${prefix}
+BIN_DIR = $(EXEC_PREFIX)/bin
+LIB_DIR = $(EXEC_PREFIX)/lib
+INCLUDE_DIR = $(PREFIX)/include
+
+INSTALL = /usr/bin/install -c
+INSTALL_DATA = ${INSTALL} -m 644
+INSTALL_PROGRAM= ${INSTALL} -m 755
+
+all: lib
+
+lib: $(OBJECTS)
+ $(AR) libicalss.a $(OBJECTS)
+ $(RANLIB) libicalss.a
+
+
+clean:
+ -/bin/rm -f *.o *.a
+ -/bin/rm -f \#*
+ -/bin/rm -f *~ Makefile.bak icalitip.tab.h icalitip.tab.c lex.yy.c
+ -/bin/rm -f icaltest parser core output *.output
+
+ci: clean
+ ci -u *.c *.h *.l *.y Makefile.in
+
+depend:
+ @makedepend -Y $(INCLUDES) $(SOURCES)
+
+
+install:
+ $(INSTALL_DATA) libicalss.a $(LIB_DIR)/libicalss.a;
+ for i in `ls *.h`; \
+ do \
+ $(INSTALL_DATA) $$i $(INCLUDE_DIR)/$$i; \
+ done;
+
+
diff --git a/libical/src/libicalss/Makefile.in b/libical/src/libicalss/Makefile.in
new file mode 100644
index 0000000000..fe4de906ad
--- /dev/null
+++ b/libical/src/libicalss/Makefile.in
@@ -0,0 +1,48 @@
+SOURCES = icalcluster.c icalstore.c icalcalendar.c
+OBJECTS = ${SOURCES:.c=.o}
+INCLUDES = -I . -I.. -I../libical
+CFLAGS = -Wall @CFLAGS@ $(INCLUDES) @DEFS@ -DICAL_ERRORS_ARE_FATAL
+LIBS =
+CC = @CC@
+AR = @AR@ cr
+RANLIB = @RANLIB@
+
+prefix = @prefix@
+PREFIX = ${prefix}
+EXEC_PREFIX = @exec_prefix@
+BIN_DIR = $(EXEC_PREFIX)/bin
+LIB_DIR = $(EXEC_PREFIX)/lib
+INCLUDE_DIR = $(PREFIX)/include
+
+INSTALL = @INSTALL@
+INSTALL_DATA = ${INSTALL} -m 644
+INSTALL_PROGRAM= ${INSTALL} -m 755
+
+all: lib
+
+lib: $(OBJECTS)
+ $(AR) libicalss.a $(OBJECTS)
+ $(RANLIB) libicalss.a
+
+
+clean:
+ -/bin/rm -f *.o *.a
+ -/bin/rm -f \#*
+ -/bin/rm -f *~ Makefile.bak icalitip.tab.h icalitip.tab.c lex.yy.c
+ -/bin/rm -f icaltest parser core output *.output
+
+ci: clean
+ ci -u *.c *.h *.l *.y Makefile.in
+
+depend:
+ @makedepend -Y $(INCLUDES) $(SOURCES)
+
+
+install:
+ $(INSTALL_DATA) libicalss.a $(LIB_DIR)/libicalss.a;
+ for i in `ls *.h`; \
+ do \
+ $(INSTALL_DATA) $$i $(INCLUDE_DIR)/$$i; \
+ done;
+
+
diff --git a/libical/src/libicalss/icalcalendar.c b/libical/src/libicalss/icalcalendar.c
new file mode 100644
index 0000000000..0933df1e31
--- /dev/null
+++ b/libical/src/libicalss/icalcalendar.c
@@ -0,0 +1,263 @@
+/* -*- Mode: C -*-
+ ======================================================================
+ FILE: icalcalendar.c
+ CREATOR: eric 23 December 1999
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 1999 Eric Busboom
+ http://www.softwarestudio.org
+
+ The contents of this file are subject to the Mozilla Public License
+ Version 1.0 (the "License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.mozilla.org/MPL/
+
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and
+ limitations under the License.
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+ ======================================================================*/
+
+
+#include "icalcalendar.h"
+#include "icalcluster.h"
+#include <limits.h>
+#include <sys/stat.h> /* For mkdir, stat */
+#include <sys/types.h> /* For mkdir */
+#include <fcntl.h> /* For mkdir */
+#include <unistd.h> /* For mkdir, stat */
+#include <stdlib.h> /* for malloc */
+#include <string.h> /* for strcat */
+#include <errno.h>
+
+#define BOOKED_DIR "booked"
+#define INCOMING_FILE "incoming.ics"
+#define PROP_FILE "properties.ics"
+#define FBLIST_FILE "freebusy.ics"
+
+struct icalcalendar_impl
+{
+ char* dir;
+ icalcomponent* freebusy;
+ icalcomponent* properties;
+ icalstore* booked;
+ icalstore* incoming;
+};
+
+struct icalcalendar_impl* icalcalendar_new_impl()
+{
+ struct icalcalendar_impl* impl;
+
+ if ( ( impl = (struct icalcalendar_impl*)
+ malloc(sizeof(struct icalcalendar_impl))) == 0) {
+ icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+ return 0;
+ }
+
+ return impl;
+}
+
+
+icalerrorenum icalcalendar_create(struct icalcalendar_impl* impl)
+{
+ char path[PATH_MAX];
+ struct stat sbuf;
+ int r;
+
+ icalerror_check_arg_re((impl != 0),"impl",ICAL_BADARG_ERROR);
+
+ path[0] = '\0';
+ strcpy(path,impl->dir);
+ strcat(path,"/");
+ strcat(path,BOOKED_DIR);
+
+ r = stat(path,&sbuf);
+
+ if( r != 0 && errno == ENOENT){
+
+ if(mkdir(path,0777)!=0){
+ icalerror_set_errno(ICAL_FILE_ERROR);
+ return ICAL_FILE_ERROR;
+ }
+ }
+
+ return ICAL_NO_ERROR;
+}
+
+icalcalendar* icalcalendar_new(char* dir)
+{
+ struct icalcalendar_impl* impl;
+
+ icalerror_check_arg_rz((dir != 0),"dir");
+
+ impl = icalcalendar_new_impl();
+
+ if (impl == 0){
+ return 0;
+ }
+
+ impl->dir = (char*)strdup(dir);
+ impl->freebusy = 0;
+ impl->properties = 0;
+ impl->booked = 0;
+ impl->incoming = 0;
+
+ if (icalcalendar_create(impl) != ICAL_NO_ERROR){
+ free(impl);
+ return 0;
+ }
+
+ return impl;
+}
+
+void icalcalendar_free(icalcalendar* calendar)
+{
+
+ struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar;
+
+ if (impl->dir !=0){
+ free(impl->dir);
+ }
+
+ if (impl->freebusy !=0){
+ icalcluster_free(impl->freebusy);
+ }
+
+ if (impl->properties !=0){
+ icalcluster_free(impl->properties);
+ }
+
+ if (impl->booked !=0){
+ icalstore_free(impl->booked);
+ }
+
+ if (impl->incoming !=0){
+ icalstore_free(impl->incoming);
+ }
+
+ impl->dir = 0;
+ impl->freebusy = 0;
+ impl->properties = 0;
+ impl->booked = 0;
+ impl->incoming = 0;
+
+
+ free(impl);
+}
+
+
+int icalcalendar_lock(icalcalendar* calendar)
+{
+ struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar;
+ icalerror_check_arg_rz((impl != 0),"impl");
+ return 0;
+}
+
+int icalcalendar_unlock(icalcalendar* calendar)
+{
+ struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar;
+ icalerror_check_arg_rz((impl != 0),"impl");
+ return 0;
+}
+
+int icalcalendar_islocked(icalcalendar* calendar)
+{
+ struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar;
+ icalerror_check_arg_rz((impl != 0),"impl");
+ return 0;
+}
+
+int icalcalendar_ownlock(icalcalendar* calendar)
+{
+ struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar;
+ icalerror_check_arg_rz((impl != 0),"impl");
+ return 0;
+}
+
+icalstore* icalcalendar_get_booked(icalcalendar* calendar)
+{
+ struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar;
+ char dir[PATH_MAX];
+
+ icalerror_check_arg_rz((impl != 0),"impl");
+
+ dir[0] = '\0';
+ strcpy(dir,impl->dir);
+ strcat(dir,"/");
+ strcat(dir,BOOKED_DIR);
+
+ if (impl->booked == 0){
+ icalerror_clear_errno();
+ impl->booked = icalstore_new(dir);
+ assert(icalerrno == ICAL_NO_ERROR);
+ }
+
+ return impl->booked;
+
+}
+
+icalcluster* icalcalendar_get_incoming(icalcalendar* calendar)
+{
+ char path[PATH_MAX];
+ struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar;
+ icalerror_check_arg_rz((impl != 0),"impl");
+
+ path[0] = '\0';
+ strcpy(path,impl->dir);
+ strcat(path,"/");
+ strcat(path,INCOMING_FILE);
+
+ if (impl->properties == 0){
+ impl->properties = icalcluster_new(path);
+ }
+
+ return impl->properties;
+}
+
+icalcluster* icalcalendar_get_properties(icalcalendar* calendar)
+{
+ char path[PATH_MAX];
+ struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar;
+ icalerror_check_arg_rz((impl != 0),"impl");
+
+ path[0] = '\0';
+ strcpy(path,impl->dir);
+ strcat(path,"/");
+ strcat(path,PROP_FILE);
+
+ if (impl->properties == 0){
+ impl->properties = icalcluster_new(path);
+ }
+
+ return impl->properties;
+}
+
+icalcluster* icalcalendar_get_freebusy(icalcalendar* calendar)
+{
+ char path[PATH_MAX];
+ struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar;
+ icalerror_check_arg_rz((impl != 0),"impl");
+
+ path[0] = '\0';
+ strcpy(path,impl->dir);
+ strcat(path,"/");
+ strcat(path,FBLIST_FILE);
+
+
+ if (impl->freebusy == 0){
+ impl->freebusy = icalcluster_new(path);
+ }
+
+ return impl->freebusy;
+}
+
+
+
+
diff --git a/libical/src/libicalss/icalcalendar.h b/libical/src/libicalss/icalcalendar.h
new file mode 100644
index 0000000000..90e7b33c22
--- /dev/null
+++ b/libical/src/libicalss/icalcalendar.h
@@ -0,0 +1,68 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalcalendar.h
+ CREATOR: eric 23 December 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 1999 Eric Busboom
+ http://www.softwarestudio.org
+
+ The contents of this file are subject to the Mozilla Public License
+ Version 1.0 (the "License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.mozilla.org/MPL/
+
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and
+ limitations under the License.
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALCALENDAR_H
+#define ICALCALENDAR_H
+
+#include "ical.h"
+#include "icalstore.h"
+#include "icalcluster.h"
+
+/* icalcalendar
+ * Routines for storing calendar data in a file system. The calendar
+ * has two icalstores, one for incoming components and one for booked
+ * components. It also has interfaces to access the free/busy list
+ * and a list of calendar properties */
+
+typedef void icalcalendar;
+
+icalcalendar* icalcalendar_new(char* dir);
+
+void icalcalendar_free(icalcalendar* calendar);
+
+int icalcalendar_lock(icalcalendar* calendar);
+
+int icalcalendar_unlock(icalcalendar* calendar);
+
+int icalcalendar_islocked(icalcalendar* calendar);
+
+int icalcalendar_ownlock(icalcalendar* calendar);
+
+icalstore* icalcalendar_get_booked(icalcalendar* calendar);
+
+icalcluster* icalcalendar_get_incoming(icalcalendar* calendar);
+
+icalcluster* icalcalendar_get_properties(icalcalendar* calendar);
+
+icalcluster* icalcalendar_get_freebusy(icalcalendar* calendar);
+
+
+#endif /* !ICALCALENDAR_H */
+
+
+
diff --git a/libical/src/libicalss/icalcluster.c b/libical/src/libicalss/icalcluster.c
new file mode 100644
index 0000000000..00e7ef0365
--- /dev/null
+++ b/libical/src/libicalss/icalcluster.c
@@ -0,0 +1,399 @@
+/* -*- Mode: C -*-
+ ======================================================================
+ FILE: icalcluster.c
+ CREATOR: eric 23 December 1999
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 1999 Eric Busboom
+ http://www.softwarestudio.org
+
+ The contents of this file are subject to the Mozilla Public License
+ Version 1.0 (the "License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.mozilla.org/MPL/
+
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and
+ limitations under the License.
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+ ======================================================================*/
+
+
+#include "icalcluster.h"
+#include <errno.h>
+#include <limits.h> /* For PATH_MAX */
+#include <sys/stat.h> /* for stat */
+#include <unistd.h> /* for stat, getpid */
+#include <stdlib.h>
+#include <string.h>
+
+struct icalcluster_impl {
+ char *path;
+ icalcomponent* cluster;
+ int changed;
+};
+
+icalcluster* icalcluster_new_impl()
+{
+ struct icalcluster_impl* comp;
+
+ if ( ( comp = (struct icalcluster_impl*)
+ malloc(sizeof(struct icalcluster_impl))) == 0) {
+ icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+ errno = ENOMEM;
+ return 0;
+ }
+
+ return comp;
+}
+
+icalerrorenum icalcluster_create_cluster(char *path)
+{
+
+ FILE* f;
+ int r;
+ icalcomponent *c;
+ struct icaltimetype tt;
+
+ icalerror_clear_errno();
+
+ f = fopen(path,"w");
+
+ if (f == 0){
+ fclose(f);
+ icalerror_set_errno(ICAL_FILE_ERROR);
+ return ICAL_FILE_ERROR;
+ }
+
+ /* Create the root component in the cluster. This component holds
+ all of the other components and stores a count of
+ components. */
+
+ memset(&tt,0,sizeof(struct icaltimetype));
+
+ c = icalcomponent_vanew(
+ ICAL_VCALENDAR_COMPONENT,
+ icalproperty_new_xlicclustercount(0),
+ icalproperty_new_dtstart(tt), /* dtstart of earliest comp */
+ icalproperty_new_dtend(tt), /* dtend of latest comp, excl. recuring */
+ 0
+ );
+
+ if (c == 0){
+ fclose(f);
+ icalerror_set_errno(ICAL_INTERNAL_ERROR);
+ return ICAL_INTERNAL_ERROR;
+ }
+
+
+ /* Write the base component to the file */
+ r = fputs(icalcomponent_as_ical_string(c),f);
+
+ fclose(f);
+
+ icalcomponent_free(c);
+
+ if (r == EOF){
+ icalerror_set_errno(ICAL_FILE_ERROR);
+ return ICAL_FILE_ERROR;
+ }
+
+ return ICAL_NO_ERROR;
+}
+
+FILE* parser_file; /*HACK. Not Thread Safe */
+char* read_from_file(char *s, size_t size)
+{
+ char *c = fgets(s,size, parser_file);
+ return c;
+}
+
+icalerrorenum icalcluster_load(icalcluster* cluster, char* path)
+{
+ struct icalcluster_impl *impl = (struct icalcluster_impl*)cluster;
+ icalerrorenum error;
+ errno = 0;
+
+ icalerror_check_arg_rz((cluster!=0),"cluster");
+ icalerror_check_arg_rz((path!=0),"path");
+
+ if(impl->path != 0 && strcmp(impl->path,path) == 0){
+ /* Already have the right cluster, so return */
+ return ICAL_NO_ERROR;
+ }
+
+ error = icalcluster_commit(cluster);
+
+ if (error != ICAL_NO_ERROR){
+ icalerror_set_errno(error);
+ return error;
+ }
+
+ free(impl->path);
+
+ impl->path= (char*)strdup(path);
+
+ parser_file = fopen(impl->path,"r");
+
+ /* HACK. Yeah, the following code is horrible....*/
+ if (parser_file ==0 || errno != 0){
+
+ /* Try to create the cluster */
+ error = icalcluster_create_cluster(path);
+
+ if (error == ICAL_NO_ERROR){
+ /* Try to open the parser again. */
+ errno = 0;
+ parser_file = fopen(impl->path,"r");
+
+ if (parser_file ==0 || errno != 0){
+ impl->cluster = 0;
+ icalerror_set_errno(ICAL_FILE_ERROR);
+ return ICAL_FILE_ERROR;
+ }
+ } else {
+ impl->cluster = 0;
+ icalerror_set_errno(error); /* Redundant, actually */
+ return error;
+ }
+ }
+
+ impl->cluster = icalparser_parse(read_from_file);
+
+ fclose(parser_file);
+
+ if (impl->cluster == 0){
+ icalerror_set_errno(ICAL_PARSE_ERROR);
+ return ICAL_PARSE_ERROR;
+ }
+
+ return ICAL_NO_ERROR;
+}
+
+
+icalcluster* icalcluster_new(char* path)
+{
+ struct icalcluster_impl *impl = icalcluster_new_impl();
+ struct stat sbuf;
+ int createclusterfile = 0;
+ icalerrorenum error;
+
+ icalerror_clear_errno();
+ icalerror_check_arg_rz( (path!=0), "path");
+
+ if (impl == 0){
+ return 0;
+ }
+
+ /*impl->path = strdup(path); icalcluster_load does this */
+ impl->changed = 0;
+ impl->cluster = 0;
+ impl->path = 0;
+
+ /* Check if the path already exists and if it is a regular file*/
+ if (stat(path,&sbuf) != 0){
+
+ /* A file by the given name does not exist, or there was
+ another error */
+
+ if (errno == ENOENT) {
+ /* It was because the file does not exist */
+ createclusterfile = 1;
+ } else {
+ /* It was because of another error */
+ icalerror_set_errno(ICAL_FILE_ERROR);
+ return 0;
+ }
+ } else {
+ /* A file by the given name exists, but is it a regular file */
+
+ if (!S_ISREG(sbuf.st_mode)){
+ /* Nope, not a directory */
+ icalerror_set_errno(ICAL_FILE_ERROR);
+ return 0;
+ } else {
+ /* Lets assume that it is a file of the right type */
+ createclusterfile = 0;
+ }
+ }
+
+ /* if cluster does not already exist, create it */
+
+ if (createclusterfile == 1) {
+ error = icalcluster_create_cluster(path);
+
+ if (error != ICAL_NO_ERROR){
+ icalerror_set_errno(error);
+ return 0;
+ }
+ }
+
+ error = icalcluster_load(impl,path);
+
+ if (error != ICAL_NO_ERROR){
+ return 0;
+ }
+
+ return impl;
+}
+
+void icalcluster_free(icalcluster* cluster)
+{
+ struct icalcluster_impl *impl = (struct icalcluster_impl*)cluster;
+
+ icalerror_check_arg_rv((cluster!=0),"cluster");
+
+ if (impl->cluster != 0){
+ icalcluster_commit(cluster);
+ icalcomponent_free(impl->cluster);
+ impl->cluster=0;
+ }
+
+ if(impl->path != 0){
+ free(impl->path);
+ impl->path = 0;
+ }
+
+ free(impl);
+}
+
+icalerrorenum icalcluster_commit(icalcluster* cluster)
+{
+ int ws; /* Size in char of file written to disk */
+ FILE *f;
+
+ struct icalcluster_impl *impl = (struct icalcluster_impl*)cluster;
+
+ icalerror_check_arg_re((impl!=0),"cluster",ICAL_BADARG_ERROR);
+
+ if (impl->changed != 0 ){
+ /* write the cluster to disk */
+
+ /* Construct a filename and write out the file */
+
+ if ( (f = fopen(impl->path,"w")) != 0){
+
+ char* str = icalcomponent_as_ical_string(impl->cluster);
+
+ ws = fwrite(str,sizeof(char),strlen(str),f);
+
+ if ( ws < strlen(str)){
+ fclose(f);
+ return ICAL_FILE_ERROR;
+ }
+
+ fclose(f);
+ impl->changed = 0;
+ return ICAL_NO_ERROR;
+ } else {
+ icalerror_set_errno(ICAL_FILE_ERROR);
+ return ICAL_FILE_ERROR;
+ }
+
+ }
+
+ return ICAL_NO_ERROR;
+}
+
+void icalcluster_mark(icalcluster* cluster){
+
+ struct icalcluster_impl *impl = (struct icalcluster_impl*)cluster;
+
+ icalerror_check_arg_rv((impl!=0),"cluster");
+
+ impl->changed = 1;
+
+}
+
+icalcomponent* icalcluster_get_component(icalcluster* cluster){
+ struct icalcluster_impl *impl = (struct icalcluster_impl*)cluster;
+
+ icalerror_check_arg_re((impl!=0),"cluster",ICAL_BADARG_ERROR);
+
+ return impl->cluster;
+}
+
+
+/* manipulate the components in the cluster */
+
+icalerrorenum icalcluster_add_component(icalcluster *cluster,
+ icalcomponent* child)
+{
+ struct icalcluster_impl* impl = (struct icalcluster_impl*)cluster;
+
+ icalerror_check_arg_rv((cluster!=0),"cluster");
+ icalerror_check_arg_rv((child!=0),"child");
+
+ icalcomponent_add_component(impl->cluster,child);
+
+ icalcluster_mark(cluster);
+
+ return ICAL_NO_ERROR;
+
+}
+
+icalerrorenum icalcluster_remove_component(icalcluster *cluster,
+ icalcomponent* child)
+{
+ struct icalcluster_impl* impl = (struct icalcluster_impl*)cluster;
+
+ icalerror_check_arg_rv((cluster!=0),"cluster");
+ icalerror_check_arg_rv((child!=0),"child");
+
+ icalcomponent_remove_component(impl->cluster,child);
+
+ icalcluster_mark(cluster);
+
+ return ICAL_NO_ERROR;
+}
+
+int icalcluster_count_components(icalcluster *cluster,
+ icalcomponent_kind kind)
+{
+ struct icalcluster_impl* impl = (struct icalcluster_impl*)cluster;
+
+ if(cluster == 0){
+ icalerror_set_errno(ICAL_BADARG_ERROR);
+ return -1;
+ }
+
+ return icalcomponent_count_components(impl->cluster,kind);
+}
+
+/* Iterate through components */
+icalcomponent* icalcluster_get_current_component (icalcluster* cluster)
+{
+ struct icalcluster_impl* impl = (struct icalcluster_impl*)cluster;
+
+ icalerror_check_arg_rz((cluster!=0),"cluster");
+
+ return icalcomponent_get_current_component(impl->cluster);
+}
+
+icalcomponent* icalcluster_get_first_component(icalcluster* cluster,
+ icalcomponent_kind kind)
+{
+ struct icalcluster_impl* impl = (struct icalcluster_impl*)cluster;
+
+ icalerror_check_arg_rz((cluster!=0),"cluster");
+
+ return icalcomponent_get_first_component(impl->cluster,kind);
+}
+
+icalcomponent* icalcluster_get_next_component(icalcluster* cluster,
+ icalcomponent_kind kind)
+{
+ struct icalcluster_impl* impl = (struct icalcluster_impl*)cluster;
+
+ icalerror_check_arg_rz((cluster!=0),"cluster");
+
+ return icalcomponent_get_next_component(impl->cluster,kind);
+}
+
diff --git a/libical/src/libicalss/icalcluster.h b/libical/src/libicalss/icalcluster.h
new file mode 100644
index 0000000000..05c3a4b144
--- /dev/null
+++ b/libical/src/libicalss/icalcluster.h
@@ -0,0 +1,75 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalcluster.h
+ CREATOR: eric 23 December 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 1999 Eric Busboom
+ http://www.softwarestudio.org
+
+ The contents of this file are subject to the Mozilla Public License
+ Version 1.0 (the "License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.mozilla.org/MPL/
+
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and
+ limitations under the License.
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALCLUSTER_H
+#define ICALCLUSTER_H
+
+#include "ical.h"
+
+typedef void icalcluster;
+
+
+icalcluster* icalcluster_new(char* path);
+void icalcluster_free(icalcluster* cluster);
+
+
+/* Load a new file into the cluster */
+icalerrorenum icalcluster_load(icalcluster* cluster, char* path);
+
+/* Return a reference to the internal component. */
+icalcomponent* icalcluster_get_component(icalcluster* cluster);
+
+/* Mark the cluster as changed, so it will be written to disk when it
+ is freed*/
+void icalcluster_mark(icalcluster* cluster);
+
+/* Write the cluster data back to disk */
+icalerrorenum icalcluster_commit(icalcluster* cluster);
+
+/* manipulate the components in the cluster */
+icalerrorenum icalcluster_add_component(icalcomponent* parent,
+ icalcomponent* child);
+
+icalerrorenum icalcluster_remove_component(icalcomponent* parent,
+ icalcomponent* child);
+
+int icalcluster_count_components(icalcomponent* component,
+ icalcomponent_kind kind);
+
+/* Iterate through components */
+icalcomponent* icalcluster_get_current_component (icalcomponent* component);
+
+icalcomponent* icalcluster_get_first_component(icalcomponent* component,
+ icalcomponent_kind kind);
+icalcomponent* icalcluster_get_next_component(icalcomponent* component,
+ icalcomponent_kind kind);
+
+#endif /* !ICALCLUSTER_H */
+
+
+
diff --git a/libical/src/libicalss/icalcomponent.h b/libical/src/libicalss/icalcomponent.h
new file mode 100644
index 0000000000..9e0e9f5a9f
--- /dev/null
+++ b/libical/src/libicalss/icalcomponent.h
@@ -0,0 +1,115 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalcomponent.h
+ CREATOR: eric 20 March 1999
+
+
+ (C) COPYRIGHT 1999 Eric Busboom
+ http://www.softwarestudio.org
+
+ The contents of this file are subject to the Mozilla Public License
+ Version 1.0 (the "License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.mozilla.org/MPL/
+
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and
+ limitations under the License.
+
+ The original author is Eric Busboom
+ The original code is icalcomponent.h
+
+======================================================================*/
+
+#ifndef ICALCOMPONENT_H
+#define ICALCOMPONENT_H
+
+#include "icalproperty.h"
+#include "icalvalue.h"
+#include "icalenums.h" /* defines icalcomponent_kind */
+
+typedef void icalcomponent;
+
+icalcomponent* icalcomponent_new(icalcomponent_kind kind);
+icalcomponent* icalcomponent_new_clone(icalcomponent* component);
+icalcomponent* icalcomponent_new_from_string(char* str);
+icalcomponent* icalcomponent_vanew(icalcomponent_kind kind, ...);
+void icalcomponent_free(icalcomponent* component);
+
+char* icalcomponent_as_ical_string(icalcomponent* component);
+
+int icalcomponent_is_valid(icalcomponent* component);
+
+icalcomponent_kind icalcomponent_isa(icalcomponent* component);
+
+int icalcomponent_isa_component (void* component);
+
+/*
+ * Working with properties
+ */
+
+void icalcomponent_add_property(icalcomponent* component,
+ icalproperty* property);
+
+void icalcomponent_remove_property(icalcomponent* component,
+ icalproperty* property);
+
+int icalcomponent_count_properties(icalcomponent* component,
+ icalproperty_kind kind);
+
+/* Iterate through the properties */
+icalproperty* icalcomponent_get_current_property(icalcomponent* component);
+
+icalproperty* icalcomponent_get_first_property(icalcomponent* component,
+ icalproperty_kind kind);
+icalproperty* icalcomponent_get_next_property(icalcomponent* component,
+ icalproperty_kind kind);
+
+/* Return a null-terminated array of icalproperties*/
+
+icalproperty** icalcomponent_get_properties(icalcomponent* component,
+ icalproperty_kind kind);
+
+
+/*
+ * Working with components
+ */
+
+
+void icalcomponent_add_component(icalcomponent* parent,
+ icalcomponent* child);
+
+void icalcomponent_remove_component(icalcomponent* parent,
+ icalcomponent* child);
+
+int icalcomponent_count_components(icalcomponent* component,
+ icalcomponent_kind kind);
+
+/* Iterate through components */
+icalcomponent* icalcomponent_get_current_component (icalcomponent* component);
+
+icalcomponent* icalcomponent_get_first_component(icalcomponent* component,
+ icalcomponent_kind kind);
+icalcomponent* icalcomponent_get_next_component(icalcomponent* component,
+ icalcomponent_kind kind);
+
+/* Return a null-terminated array of icalproperties*/
+icalproperty** icalcomponent_get_component(icalcomponent* component,
+ icalproperty_kind kind);
+
+/* Working with embedded error properties */
+
+int icalcomponent_count_errors(icalcomponent* component);
+void icalcomponent_strip_errors(icalcomponent* component);
+
+
+/* Internal operations. You don't see these... */
+icalcomponent* icalcomponent_get_parent(icalcomponent* component);
+void icalcomponent_set_parent(icalcomponent* component,
+ icalcomponent* parent);
+
+#endif /* !ICALCOMPONENT_H */
+
+
+
diff --git a/libical/src/libicalss/icalstore.c b/libical/src/libicalss/icalstore.c
new file mode 100644
index 0000000000..014c9ed19b
--- /dev/null
+++ b/libical/src/libicalss/icalstore.c
@@ -0,0 +1,815 @@
+/* -*- Mode: C -*-
+ ======================================================================
+ FILE: icalstore.c
+ CREATOR: eric 28 November 1999
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 1999 Eric Busboom
+ http://www.softwarestudio.org
+
+ The contents of this file are subject to the Mozilla Public License
+ Version 1.0 (the "License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.mozilla.org/MPL/
+
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and
+ limitations under the License.
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+ ======================================================================*/
+
+
+/*
+
+ icalstore manages a database of ical components and offers
+ interfaces for reading, writting and searching for components.
+
+ icalstore groups components in to clusters based on their DTSTART
+ time -- all components that start in the same month are grouped
+ together in a single file. All files in a sotre are kept in a single
+ directory. ( If a component does not have DTSTART, the store uses
+ DTSTAMP or CREATE )
+
+ The primary interfaces are icalstore_first and icalstore_next. These
+ routine iterate through all of the components in the store, subject
+ to the current gauge. A gauge is an icalcomponent that is tested
+ against other componets for a match. If a gauge has been set with
+ icalstore_select, icalstore_first and icalstore_next will only
+ return componentes that match the gauge.
+
+ The Store generated UIDs for all objects that are stored if they do
+ not already have a UID. The UID is the name of the cluster (month &
+ year as MMYYYY) plus a unique serial number. The serial number is
+ stored as a property of the cluster.
+
+*/
+
+#include "ical.h"
+#include "icalstore.h"
+#include "pvl.h"
+#include "icalerror.h"
+#include "icalparser.h"
+#include "icalcluster.h"
+
+#include "filelock.h"
+
+#include <limits.h>
+#include <dirent.h> /* for opendir() */
+#include <errno.h>
+#include <sys/types.h> /* for opendir() */
+#include <sys/stat.h> /* for stat */
+#include <unistd.h> /* for stat, getpid */
+#include <time.h> /* for clock() */
+#include <stdlib.h> /* for rand(), srand() */
+#include <sys/utsname.h> /* for uname */
+#include <string.h> /* for strdup */
+
+
+struct icalstore_impl
+{
+ char* dir;
+ icalcomponent* gauge;
+ icalcluster* cluster;
+ int first_component;
+ pvl_list directory;
+ pvl_elem directory_iterator;
+};
+
+struct icalstore_impl* icalstore_new_impl()
+{
+ struct icalstore_impl* comp;
+
+ if ( ( comp = (struct icalstore_impl*)
+ malloc(sizeof(struct icalstore_impl))) == 0) {
+ icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+ return 0;
+ }
+
+ return comp;
+}
+
+
+
+void icalstore_lock_dir(char* dir)
+{
+}
+
+
+void icalstore_unlock_dir(char* dir)
+{
+}
+
+/* Load the contents of the store directory into the store's internal directory list*/
+icalerrorenum icalstore_read_directory(struct icalstore_impl* impl)
+{
+ struct dirent *de;
+ DIR* dp;
+ char *str;
+
+ dp = opendir(impl->dir);
+
+ if ( dp == 0) {
+ icalerror_set_errno(ICAL_FILE_ERROR);
+ return ICAL_FILE_ERROR;
+ }
+
+ /* clear contents of directory list */
+ while((str = pvl_pop(impl->directory))){
+ free(str);
+ }
+
+ /* load all of the cluster names in the directory list */
+ for(de = readdir(dp);
+ de != 0;
+ de = readdir(dp)){
+
+ /* Remove known directory names '.' and '..'*/
+ if (strcmp(de->d_name,".") == 0 ||
+ strcmp(de->d_name,"..") == 0 ){
+ continue;
+ }
+
+ pvl_push(impl->directory, (void*)strdup(de->d_name));
+ }
+
+ closedir(dp);
+
+ return ICAL_NO_ERROR;
+}
+
+icalstore* icalstore_new(char* dir)
+{
+ struct icalstore_impl *impl = icalstore_new_impl();
+ struct stat sbuf;
+
+ if (impl == 0){
+ return 0;
+ }
+
+ icalerror_check_arg_rz( (dir!=0), "dir");
+
+ if (stat(dir,&sbuf) != 0){
+ icalerror_set_errno(ICAL_FILE_ERROR);
+ return 0;
+ }
+
+ /* dir is not the name of a direectory*/
+ if (!S_ISDIR(sbuf.st_mode)){
+ icalerror_set_errno(ICAL_USAGE_ERROR);
+ return 0;
+ }
+
+ icalstore_lock_dir(dir);
+
+ impl = icalstore_new_impl();
+
+ if (impl ==0){
+ icalerror_set_errno(ICAL_ALLOCATION_ERROR);
+ return 0;
+ }
+
+ impl->directory = pvl_newlist();
+ impl->directory_iterator = 0;
+ impl->dir = (char*)strdup(dir);
+ impl->gauge = 0;
+ impl->first_component = 0;
+ impl->cluster = 0;
+
+ icalstore_read_directory(impl);
+
+ return (icalstore*) impl;
+}
+
+void icalstore_free(icalstore* s)
+{
+ struct icalstore_impl *impl = (struct icalstore_impl*)s;
+ char* str;
+
+ icalstore_unlock_dir(impl->dir);
+
+ if(impl->dir !=0){
+ free(impl->dir);
+ }
+
+ if(impl->gauge !=0){
+ icalcomponent_free(impl->gauge);
+ }
+
+ if(impl->cluster !=0){
+ icalcluster_free(impl->cluster);
+ }
+
+ while( (str=pvl_pop(impl->directory)) != 0){
+ free(str);
+ }
+
+ pvl_free(impl->directory);
+
+ impl->directory = 0;
+ impl->directory_iterator = 0;
+ impl->dir = 0;
+ impl->gauge = 0;
+ impl->first_component = 0;
+
+ free(impl);
+
+}
+
+/* icalstore_next_uid_number updates a serial number in the Store
+ directory in a file called SEQUENCE */
+
+int icalstore_next_uid_number(icalstore* store)
+{
+ struct icalstore_impl *impl = (struct icalstore_impl*)store;
+ char sequence = 0;
+ char temp[128];
+ char filename[PATH_MAX];
+ char *r;
+ FILE *f;
+ struct stat sbuf;
+
+ icalerror_check_arg_rz( (store!=0), "store");
+
+ sprintf(filename,"%s/%s",impl->dir,"SEQUENCE");
+
+ /* Create the file if it does not exist.*/
+ if (stat(filename,&sbuf) == -1 || !S_ISREG(sbuf.st_mode)){
+
+ f = fopen(filename,"w");
+ if (f != 0){
+ fprintf(f,"0");
+ fclose(f);
+ } else {
+ icalerror_warn("Can't create SEQUENCE file in icalstore_next_uid_number");
+ return 0;
+ }
+
+ }
+
+ if ( (f = fopen(filename,"r+")) != 0){
+
+ rewind(f);
+ r = fgets(temp,128,f);
+
+ if (r == 0){
+ sequence = 1;
+ } else {
+ sequence = atoi(temp)+1;
+ }
+
+ rewind(f);
+
+ fprintf(f,"%d",sequence);
+
+ fclose(f);
+
+ return sequence;
+
+ } else {
+ icalerror_warn("Can't create SEQUENCE file in icalstore_next_uid_number");
+ return 0;
+ }
+
+}
+
+icalerrorenum icalstore_next_cluster(icalstore* store)
+{
+ struct icalstore_impl *impl = (struct icalstore_impl*)store;
+ char path[PATH_MAX];
+
+ if (impl->directory_iterator == 0){
+ icalerror_set_errno(ICAL_INTERNAL_ERROR);
+ return ICAL_INTERNAL_ERROR;
+ }
+ impl->directory_iterator = pvl_next(impl->directory_iterator);
+
+ if (impl->directory_iterator == 0){
+ /* There are no more clusters */
+ impl->cluster = 0;
+ return ICAL_NO_ERROR;
+ }
+
+
+ sprintf(path,"%s/%s",impl->dir,(char*)pvl_data(impl->directory_iterator));
+
+ return icalcluster_load(impl->cluster,path);
+}
+
+void icalstore_add_uid(icalstore* store, icalstore* comp)
+{
+ char uidstring[PATH_MAX];
+ icalproperty *uid;
+ struct utsname unamebuf;
+
+ icalerror_check_arg_rz( (store!=0), "store");
+ icalerror_check_arg_rz( (comp!=0), "comp");
+
+ uid = icalcomponent_get_first_property(comp,ICAL_UID_PROPERTY);
+
+ if (uid == 0) {
+
+ uname(&unamebuf);
+
+ sprintf(uidstring,"%d-%s",getpid(),unamebuf.nodename);
+
+ uid = icalproperty_new_uid(uidstring);
+ icalcomponent_add_property(comp,uid);
+ } else {
+
+ strcpy(uidstring,icalproperty_get_uid(uid));
+ }
+}
+
+icalerrorenum icalstore_add_component(icalstore* store, icalstore* comp)
+{
+ struct icalstore_impl *impl;
+ char clustername[PATH_MAX];
+ icalproperty *dt, *count, *lm;
+ icalvalue *v;
+ struct icaltimetype tm;
+ icalerrorenum error = ICAL_NO_ERROR;
+
+ impl = (struct icalstore_impl*)store;
+ icalerror_check_arg_rz( (store!=0), "store");
+ icalerror_check_arg_rz( (comp!=0), "comp");
+
+ errno = 0;
+
+ icalstore_add_uid(store,comp);
+
+ /* Determine which cluster this object belongs in */
+
+ dt = icalcomponent_get_first_property(comp,ICAL_DTSTART_PROPERTY);
+
+ if (dt == 0){
+ dt = icalcomponent_get_first_property(comp,ICAL_DTSTAMP_PROPERTY);
+ }
+
+ if (dt == 0){
+ dt = icalcomponent_get_first_property(comp,ICAL_CREATED_PROPERTY);
+ }
+
+ if (dt == 0){
+ icalerror_warn("The component does not have a DTSTART, DTSTAMP or a CREATED property, so it cannot be added to the store");
+ icalerror_set_errno(ICAL_BADARG_ERROR);
+ return ICAL_BADARG_ERROR;
+ }
+
+ v = icalproperty_get_value(dt);
+
+ tm = icalvalue_get_datetime(v);
+
+ sprintf(clustername,"%s/%04d%02d",impl->dir,tm.year,tm.month);
+
+ /* Load the cluster and insert the object */
+
+ if (impl->cluster == 0){
+ impl->cluster = icalcluster_new(clustername);
+
+ if (impl->cluster == 0){
+ error = icalerrno;
+ }
+ } else {
+ error = icalcluster_load(impl->cluster,
+ clustername);
+
+ }
+
+
+ if (error != ICAL_NO_ERROR){
+ icalerror_set_errno(error);
+ return error;
+ }
+
+ /* Update or add the LAST-MODIFIED property */
+
+ lm = icalcomponent_get_first_property(comp,
+ ICAL_LASTMODIFIED_PROPERTY);
+
+ if (lm == 0){
+ lm = icalproperty_new_lastmodified(icaltimetype_from_timet( time(0),1));
+ icalcomponent_add_property(comp,lm);
+ } else {
+ icalproperty_set_lastmodified(comp,icaltimetype_from_timet( time(0),1));
+ }
+
+
+ /* Add the component to the cluster */
+
+ icalcluster_add_component(impl->cluster,comp);
+
+
+ /* Increment the clusters count value */
+ count = icalcomponent_get_first_property(
+ icalcluster_get_component(impl->cluster),
+ ICAL_XLICCLUSTERCOUNT_PROPERTY);
+
+ if (count == 0){
+ icalerror_set_errno(ICAL_INTERNAL_ERROR);
+ return ICAL_INTERNAL_ERROR;
+ }
+
+ icalproperty_set_xlicclustercount(count,
+ icalproperty_get_xlicclustercount(count)+1);
+
+
+ icalcluster_mark(impl->cluster);
+
+ return ICAL_NO_ERROR;
+}
+
+/* Remove a component in the current cluster */
+icalerrorenum icalstore_remove_component(icalstore* store, icalstore* comp)
+{
+ struct icalstore_impl *impl = (struct icalstore_impl*)store;
+ icalproperty *count;
+
+ icalerror_check_arg_re((store!=0),"store",ICAL_BADARG_ERROR);
+ icalerror_check_arg_re((comp!=0),"comp",ICAL_BADARG_ERROR);
+ icalerror_check_arg_re((impl->cluster!=0),"Cluster pointer",ICAL_USAGE_ERROR);
+
+/* HACK The following code should be used to ensure that the component
+the caller is trying to remove is actually in the cluster, but it
+resets the internal iterators, which immediately ends any loops over
+the cluster the caller may have in progress
+
+ for(c = icalcluster_get_first_component(
+ impl->cluster,
+ ICAL_ANY_COMPONENT);
+ c != 0;
+ c = icalcluster_get_next_component(
+ impl->cluster,
+ ICAL_ANY_COMPONENT)){
+
+ if (c == comp){
+ found = 1;
+ }
+
+ }
+
+ if (found != 1){
+ icalerror_warn("icalstore_remove_component: component is not part of current cluster");
+ icalerror_set_errno(ICAL_USAGE_ERROR);
+ return ICAL_USAGE_ERROR;
+ }
+
+*/
+
+ icalcluster_remove_component(impl->cluster,
+ comp);
+
+ icalcluster_mark(impl->cluster);
+
+ /* Decrement the clusters count value */
+ count = icalcomponent_get_first_property(
+ icalcluster_get_component(impl->cluster),
+ ICAL_XLICCLUSTERCOUNT_PROPERTY);
+
+ if (count == 0){
+ icalerror_set_errno(ICAL_INTERNAL_ERROR);
+ return ICAL_INTERNAL_ERROR;
+ }
+
+ icalproperty_set_xlicclustercount(count,
+ icalproperty_get_xlicclustercount(count)-1);
+
+ return ICAL_NO_ERROR;
+}
+
+/* Convert a VQUERY component into a gauge */
+icalcomponent* icalstore_make_gauge(icalcomponent* query);
+
+/* icalstore_test compares a component against a gauge, and returns
+ true if the component passes the test
+
+ The gauge is a VCALENDAR component that specifies how to test the
+ target components. The guage holds a collection of VEVENT, VTODO or
+ VJOURNAL sub-components. Each of the sub-components has a
+ collection of properties that are compared to corresponding
+ properties in the target component, according to the
+ X-LIC-COMPARETYPE parameters to the gauge's properties.
+
+ When a gauge has several sub-components, the results of testing the
+ target against each of them is ORed together - the target
+ component will pass if it matches any of the sub-components in the
+ gauge. However, the results of matching the proeprties in a
+ sub-component are ANDed -- the target must match every property in
+ a gauge sub-component to match the sub-component.
+
+ Here is an example:
+
+ BEGIN:VCOMPONENT
+ BEGIN:VEVENT
+ DTSTART;X-LIC-COMPARETYPE=LESS:19981025T020000
+ ORGANIZER;X-LIC-COMPARETYPE=EQUAL:mrbig@host.com
+ END:VEVENT
+ BEGIN:VEVENT
+ LOCATION;X-LIC-COMPARETYPE=EQUAL:McNary's Pub
+ END:VEVENT
+ END:VCALENDAR
+
+ This gauge has two sub-components; one which will match a VEVENT
+ based on start time, and organizer, and another that matches based
+ on LOCATION. A target component will pass the test if it matched
+ either of the gauge.
+
+ */
+
+int icalstore_test(icalcomponent* comp, icalcomponent* gauge)
+{
+ int pass = 0,localpass = 0;
+ icalcomponent *c;
+ icalproperty *p;
+ icalcomponent *child;
+
+ icalerror_check_arg_rz( (comp!=0), "comp");
+ icalerror_check_arg_rz( (gauge!=0), "gauge");
+
+ for(c = icalcomponent_get_first_component(gauge,ICAL_ANY_COMPONENT);
+ c != 0;
+ c = icalcomponent_get_next_component(gauge,ICAL_ANY_COMPONENT)){
+
+
+ /* Test properties. For each property in the gauge, search through
+ the component for a similar property. If one is found, compare
+ the two properties value with the comparison specified in the
+ gauge with the X-LIC-COMPARETYPE parameter */
+
+ for(p = icalcomponent_get_first_property(c,ICAL_ANY_PROPERTY);
+ p != 0;
+ p = icalcomponent_get_next_property(c,ICAL_ANY_PROPERTY)){
+
+ icalproperty* targetprop;
+ icalparameter* compareparam;
+ icalparameter_xliccomparetype compare;
+ int rel; /* The realtionship between the gauge and target values.*/
+
+ /* Extract the comparison type from the gauge. If there is no
+ comparison type, assume that it is "EQUAL" */
+
+ compareparam = icalproperty_get_first_parameter(
+ p,
+ ICAL_XLICCOMPARETYPE_PARAMETER);
+
+ if (compareparam!=0){
+ compare = icalparameter_get_xliccomparetype(compareparam);
+ } else {
+ compare = ICAL_XLICCOMPARETYPE_EQUAL;
+ }
+
+ /* Find a property in the component that has the same type as
+ the gauge property */
+
+ targetprop = icalcomponent_get_first_property(comp,
+ icalproperty_isa(p));
+
+
+ if(targetprop == 0){
+ continue;
+ }
+
+ /* Compare the values of the gauge property and the target
+ property */
+
+ rel = icalvalue_compare(icalproperty_get_value(p),
+ icalproperty_get_value(targetprop));
+
+ /* Now see if the comparison is equavalent to the comparison
+ specified in the gauge */
+
+ if (rel == compare){
+ localpass++;
+ } else if (compare == ICAL_XLICCOMPARETYPE_LESSEQUAL &&
+ ( rel == ICAL_XLICCOMPARETYPE_LESS ||
+ rel == ICAL_XLICCOMPARETYPE_EQUAL)) {
+ localpass++;
+ } else if (compare == ICAL_XLICCOMPARETYPE_GREATEREQUAL &&
+ ( rel == ICAL_XLICCOMPARETYPE_GREATER ||
+ rel == ICAL_XLICCOMPARETYPE_EQUAL)) {
+ localpass++;
+ } else if (compare == ICAL_XLICCOMPARETYPE_NOTEQUAL &&
+ ( rel == ICAL_XLICCOMPARETYPE_GREATER ||
+ rel == ICAL_XLICCOMPARETYPE_LESS)) {
+ pass++;
+ } else {
+ localpass = 0;
+ }
+
+ pass += localpass;
+ }
+
+
+ /* test subcomponents. Look for a child component that has a
+ counterpart in the gauge. If one is found, recursively call
+ icalstore_test */
+
+ for(child = icalcomponent_get_first_component(comp,ICAL_ANY_COMPONENT);
+ child != 0;
+ child = icalcomponent_get_next_component(comp,ICAL_ANY_COMPONENT)){
+
+ pass += icalstore_test(child,gauge);
+
+ }
+ }
+
+ return pass>0;
+
+}
+
+icalcomponent* icalstore_query(icalstore* store, icalstore* query);
+
+
+icalcomponent* icalstore_fetch(icalstore* store, char* uid)
+{
+ icalcomponent *gauge;
+ icalcomponent *old_gauge;
+ icalcomponent *c;
+ struct icalstore_impl *impl = (struct icalstore_impl*)store;
+
+ icalerror_check_arg_rz( (store!=0), "store");
+ icalerror_check_arg_rz( (uid!=0), "uid");
+
+ gauge =
+ icalcomponent_vanew(
+ ICAL_VCALENDAR_COMPONENT,
+ icalcomponent_vanew(
+ ICAL_VEVENT_COMPONENT,
+ icalproperty_vanew_uid(
+ uid,
+ icalparameter_new_xliccomparetype(
+ ICAL_XLICCOMPARETYPE_EQUAL),
+ 0),
+ 0),
+ 0);
+
+ old_gauge = impl->gauge;
+ impl->gauge = gauge;
+
+ c= icalstore_get_first_component(store);
+
+ impl->gauge = old_gauge;
+
+ icalcomponent_free(gauge);
+
+ return c;
+}
+
+
+int icalstore_has_uid(icalstore* store, char* uid)
+{
+ icalcomponent *c;
+
+ icalerror_check_arg_rz( (store!=0), "store");
+ icalerror_check_arg_rz( (uid!=0), "uid");
+
+ /* HACK. This is a temporary implementation. _has_uid should use a
+ database, and _fetch should use _has_uid, not the other way
+ around */
+ c = icalstore_fetch(store,uid);
+
+ return c!=0;
+
+}
+
+
+icalerrorenum icalstore_select(icalstore* store, icalcomponent* gauge)
+{
+ struct icalstore_impl *impl = (struct icalstore_impl*)store;
+
+ icalerror_check_arg_re( (store!=0), "store",ICAL_BADARG_ERROR);
+ icalerror_check_arg_re( (gauge!=0), "gauge",ICAL_BADARG_ERROR);
+
+ if (!icalcomponent_is_valid(gauge)){
+ return ICAL_BADARG_ERROR;
+ }
+
+ impl->gauge = gauge;
+
+ return ICAL_NO_ERROR;
+}
+
+
+
+icalcomponent* icalstore_get_first_component(icalstore* store)
+{
+ struct icalstore_impl *impl = (struct icalstore_impl*)store;
+ icalerrorenum error;
+ char path[PATH_MAX];
+
+ error = icalstore_read_directory(impl);
+
+ if (error != ICAL_NO_ERROR){
+ icalerror_set_errno(error);
+ return 0;
+ }
+
+ impl->directory_iterator = pvl_head(impl->directory);
+
+ if (impl->directory_iterator == 0){
+ icalerror_set_errno(error);
+ return 0;
+ }
+
+ sprintf(path,"%s/%s",impl->dir,(char*)pvl_data(impl->directory_iterator));
+
+ if (impl->cluster == 0){
+ impl->cluster = icalcluster_new(path);
+
+ if (impl->cluster == 0){
+ error = icalerrno;
+ }
+ } else {
+ error = icalcluster_load(impl->cluster,path);
+
+ }
+
+ if (error != ICAL_NO_ERROR){
+ icalerror_set_errno(error);
+ return 0;
+ }
+
+ impl->first_component = 1;
+
+ return icalstore_get_next_component(store);
+}
+
+icalcomponent* icalstore_get_next_component(icalstore* store)
+{
+ struct icalstore_impl *impl;
+ icalcomponent *c;
+ icalerrorenum error;
+
+ icalerror_check_arg_rz( (store!=0), "store");
+
+ impl = (struct icalstore_impl*)store;
+
+ if(impl->cluster == 0){
+
+ icalerror_warn("icalstore_get_next_component called with a NULL cluster (Caller must call icalstore_get_first_component first");
+ icalerror_set_errno(ICAL_USAGE_ERROR);
+ return 0;
+
+ }
+
+ /* Set the component iterator for the following for loop */
+ if (impl->first_component == 1){
+ icalcluster_get_first_component(
+ impl->cluster,
+ ICAL_ANY_COMPONENT);
+ impl->first_component = 0;
+ } else {
+ icalcluster_get_next_component(
+ impl->cluster,
+ ICAL_ANY_COMPONENT);
+ }
+
+
+ while(1){
+ /* Iterate through all of the objects in the cluster*/
+ for( c = icalcluster_get_current_component(
+ impl->cluster);
+ c != 0;
+ c = icalcluster_get_next_component(
+ impl->cluster,
+ ICAL_ANY_COMPONENT)){
+
+ /* If there is a gauge defined and the component does not
+ pass the gauge, skip the rest of the loop */
+ if (impl->gauge != 0 && icalstore_test(c,impl->gauge) == 0){
+ continue;
+ }
+
+ /* Either there is no gauge, or the component passed the
+ gauge, so return it*/
+
+ return c;
+ }
+
+ /* Fell through the loop, so the component we want is not
+ in this cluster. Load a new cluster and try again.*/
+
+ error = icalstore_next_cluster(store);
+
+ if(impl->cluster == 0 || error != ICAL_NO_ERROR){
+ /* No more clusters */
+ return 0;
+ } else {
+ c = icalcluster_get_first_component(
+ impl->cluster,
+ ICAL_ANY_COMPONENT);
+ }
+ }
+}
+
+
+
+
+
+
diff --git a/libical/src/libicalss/icalstore.h b/libical/src/libicalss/icalstore.h
new file mode 100644
index 0000000000..13e0a182b5
--- /dev/null
+++ b/libical/src/libicalss/icalstore.h
@@ -0,0 +1,78 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalstore.h
+ CREATOR: eric 28 November 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 1999 Eric Busboom
+ http://www.softwarestudio.org
+
+ The contents of this file are subject to the Mozilla Public License
+ Version 1.0 (the "License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.mozilla.org/MPL/
+
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and
+ limitations under the License.
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALSTORE_H
+#define ICALSTORE_H
+
+#include "ical.h"
+#include "icalerror.h"
+typedef void icalstore;
+
+/* icalstore Routines for storing, fetching, and searching for ical
+ * objects in a database */
+
+icalstore* icalstore_new(char* dir);
+
+void icalstore_free(icalstore* store);
+
+/* Add a new component to the store */
+icalerrorenum icalstore_add_component(icalstore* store, icalstore* comp);
+
+/* Remove a component from the store */
+icalerrorenum icalstore_remove_component(icalstore* store, icalstore* comp);
+
+/* Restrict the component returned by icalstore_first, _next to those
+ that pass the gauge */
+icalerrorenum icalstore_select(icalstore* store, icalcomponent* gauge);
+
+/* Return true if a component passes the gauge */
+int icalstore_test(icalcomponent* comp, icalcomponent* gauge);
+
+/* Clear the restrictions set by icalstore_select */
+void icalstore_clear(icalstore* store);
+
+/* Get a single component by uid */
+icalcomponent* icalstore_fetch(icalstore* store, char* uid);
+
+/* Return true of the store has an object with the given UID */
+int icalstore_has_uid(icalstore* store, char* uid);
+
+/* Return the first component in the store, or first that passes the gauge.*/
+icalcomponent* icalstore_get_first_component(icalstore* store);
+
+/* Return the next component in the store, or next that passes the gauge.*/
+icalcomponent* icalstore_get_next_component(icalstore* store);
+
+
+int icalstore_next_uid_number(icalstore* store);
+
+
+#endif /* !ICALSTORE_H */
+
+
+