diff options
Diffstat (limited to 'libical/src')
38 files changed, 2539 insertions, 1519 deletions
diff --git a/libical/src/Makefile.am b/libical/src/Makefile.am index 37dc5e39cb..4edf2a1d14 100644 --- a/libical/src/Makefile.am +++ b/libical/src/Makefile.am @@ -1 +1 @@ -SUBDIRS = libical libicalss test +SUBDIRS = libical libicalss libicalvcal test diff --git a/libical/src/libical/Makefile.am b/libical/src/libical/Makefile.am index d9af51bccd..35a08effc7 100644 --- a/libical/src/libical/Makefile.am +++ b/libical/src/libical/Makefile.am @@ -30,9 +30,16 @@ libical_a_SOURCES = \ icaltypes.h \ icalvalue.c \ icalvalue.h \ - icalvcal.h \ + icalrecur.c \ + icalrecur.h \ + icaltime.h \ + icaltime.c \ pvl.c \ - pvl.h + pvl.h \ + sspm.c \ + sspm.h \ + icalmime.c \ + icalmime.h include_HEADERS=\ ical.h \ @@ -46,9 +53,12 @@ include_HEADERS=\ icalrestriction.h \ icaltypes.h \ icalvalue.h \ - icalvcal.h \ + icalrecur.h \ icalversion.h \ - pvl.h + icaltime.h \ + pvl.h \ + sspm.h \ + icalmime.h # diff --git a/libical/src/libical/ical.h b/libical/src/libical/ical.h index d0f33cd1a1..05e7ca82bc 100644 --- a/libical/src/libical/ical.h +++ b/libical/src/libical/ical.h @@ -4,20 +4,19 @@ 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 + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org + + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + The original code is ical.h ======================================================================*/ @@ -36,6 +35,14 @@ #include "icalmemory.h" #include "icalerror.h" #include "icalrestriction.h" +#include "icaltime.h" +#include "icalrecur.h" + +#ifdef DMALLOC +#include "dmalloc.h" +#endif + + #endif /* !ICAL_H */ diff --git a/libical/src/libical/icalcomponent.c b/libical/src/libical/icalcomponent.c index bd2b13189c..52c2088140 100644 --- a/libical/src/libical/icalcomponent.c +++ b/libical/src/libical/icalcomponent.c @@ -1,25 +1,22 @@ -/* -*- Mode: C -*- */ /*====================================================================== FILE: icalcomponent.c CREATOR: eric 28 April 1999 $Id$ + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org - (C) COPYRIGHT 1999 Eric Busboom - http://www.softwarestudio.org + This program is free software; you can redistribute it and/or modify + it under the terms of either: - 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 LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ - The original author is Eric Busboom The original code is icalcomponent.c ======================================================================*/ @@ -154,6 +151,7 @@ icalcomponent* icalcomponent_new_clone(icalcomponent* component) struct icalcomponent_impl *new; icalproperty *p; icalcomponent *c; + pvl_elem itr; icalerror_check_arg_rv( (component!=0), "component"); @@ -164,20 +162,22 @@ icalcomponent* icalcomponent_new_clone(icalcomponent* component) } - for(p = icalcomponent_get_first_property(old,ICAL_ANY_PROPERTY); - p != 0; - p = icalcomponent_get_next_property(old,ICAL_ANY_PROPERTY)){ - - icalcomponent_add_property(new,icalproperty_new_clone(p)); - } + for( itr = pvl_head(old->properties); + itr != 0; + itr = pvl_next(itr)) + { + p = (icalproperty*)pvl_data(itr); + icalcomponent_add_property(new,icalproperty_new_clone(p)); + } - for(c = icalcomponent_get_first_component(old,ICAL_ANY_COMPONENT); - c != 0; - c = icalcomponent_get_next_component(old,ICAL_ANY_COMPONENT)){ - - icalcomponent_add_component(new,icalcomponent_new_clone(c)); - } + for( itr = pvl_head(old->components); + itr != 0; + itr = pvl_next(itr)) + { + c = (icalcomponent*)pvl_data(itr); + icalcomponent_add_component(new,icalcomponent_new_clone(c)); + } return new; @@ -242,6 +242,8 @@ icalcomponent_as_ical_string (icalcomponent* component) char* tmp_buf; size_t buf_size = 1024; char* buf_ptr = 0; + pvl_elem itr; + struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component; #ifdef ICAL_UNIX_NEWLINE char newline[] = "\n"; @@ -270,22 +272,28 @@ icalcomponent_as_ical_string (icalcomponent* component) icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline); - for(p = icalcomponent_get_first_property(component,ICAL_ANY_PROPERTY); - p != 0; - p = icalcomponent_get_next_property(component,ICAL_ANY_PROPERTY)){ - tmp_buf = icalproperty_as_ical_string(p); - - icalmemory_append_string(&buf, &buf_ptr, &buf_size, tmp_buf); - } + for( itr = pvl_head(impl->properties); + itr != 0; + itr = pvl_next(itr)) + { + p = (icalproperty*)pvl_data(itr); + + icalerror_assert((p!=0),"Got a null property"); + tmp_buf = icalproperty_as_ical_string(p); + + icalmemory_append_string(&buf, &buf_ptr, &buf_size, tmp_buf); + } - for(c = icalcomponent_get_first_component(component,ICAL_ANY_COMPONENT); - c != 0; - c = icalcomponent_get_next_component(component,ICAL_ANY_COMPONENT)){ + for( itr = pvl_head(impl->components); + itr != 0; + itr = pvl_next(itr)) + { + c = (icalcomponent*)pvl_data(itr); tmp_buf = icalcomponent_as_ical_string(c); - + icalmemory_append_string(&buf, &buf_ptr, &buf_size, tmp_buf); } @@ -423,17 +431,23 @@ icalcomponent_remove_property (icalcomponent* component, icalproperty* property) } int -icalcomponent_count_properties (icalcomponent* component, icalproperty_kind kind) +icalcomponent_count_properties (icalcomponent* component, + icalproperty_kind kind) { int count=0; - icalproperty *p; + pvl_elem itr; + struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component; + icalerror_check_arg_rz( (component!=0), "component"); - for(p = icalcomponent_get_first_property(component,kind); - p != 0; - p = icalcomponent_get_next_property(component,kind)){ - - count++; + for( itr = pvl_head(impl->properties); + itr != 0; + itr = pvl_next(itr)) + { + if(kind == icalproperty_isa((icalproperty*)pvl_data(itr)) || + kind == ICAL_ANY_PROPERTY){ + count++; + } } @@ -545,30 +559,42 @@ icalcomponent_remove_component (icalcomponent* parent, icalcomponent* child) if( pvl_data(itr) == (void*)child ){ if (impl->component_iterator == itr){ - /* impl->component_iterator = pvl_next(itr);*/ + /* Don't let the current iterator become invalid */ + + /* HACK. The semantics for this are troubling. */ + impl->component_iterator = + pvl_next(impl->component_iterator); + } pvl_remove( impl->components, itr); cimpl->parent = 0; + break; } } } int -icalcomponent_count_components (icalcomponent* component, icalcomponent_kind kind) +icalcomponent_count_components (icalcomponent* component, + icalcomponent_kind kind) { int count=0; - icalcomponent *c; + pvl_elem itr; + struct icalcomponent_impl *impl = + (struct iccalcomponent_impl*)component; + icalerror_check_arg_rz( (component!=0), "component"); - for(c = icalcomponent_get_first_component(component,kind); - c != 0; - c = icalcomponent_get_next_component(component,kind)){ - - count++; + for( itr = pvl_head(impl->components); + itr != 0; + itr = pvl_next(itr)) + { + if(kind == icalcomponent_isa((icalcomponent*)pvl_data(itr)) || + kind == ICAL_ANY_COMPONENT){ + count++; + } } - return count; } @@ -646,10 +672,14 @@ int icalcomponent_count_errors(icalcomponent* component) int errors = 0; icalproperty *p; icalcomponent *c; + pvl_elem itr; + struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component; - for(p = icalcomponent_get_first_property(component,ICAL_ANY_PROPERTY); - p != 0; - p = icalcomponent_get_next_property(component,ICAL_ANY_PROPERTY)){ + for( itr = pvl_head(impl->properties); + itr != 0; + itr = pvl_next(itr)) + { + p = (icalproperty*)pvl_data(itr); if(icalproperty_isa(p) == ICAL_XLICERROR_PROPERTY) { @@ -657,9 +687,12 @@ int icalcomponent_count_errors(icalcomponent* component) } } - for(c = icalcomponent_get_first_component(component,ICAL_ANY_COMPONENT); - c != 0; - c = icalcomponent_get_next_component(component,ICAL_ANY_COMPONENT)){ + + for( itr = pvl_head(impl->components); + itr != 0; + itr = pvl_next(itr)) + { + c = (icalcomponent*)pvl_data(itr); errors += icalcomponent_count_errors(c); @@ -671,30 +704,34 @@ int icalcomponent_count_errors(icalcomponent* component) void icalcomponent_strip_errors(icalcomponent* component) { - icalproperty *p, *next_p; + icalproperty *p; icalcomponent *c; + pvl_elem itr, next_itr; + struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component; - for(p = icalcomponent_get_first_property(component,ICAL_ANY_PROPERTY); - p != 0; - p = next_p){ - - next_p = icalcomponent_get_next_property(component,ICAL_ANY_PROPERTY); + for( itr = pvl_head(impl->properties); + itr != 0; + itr = next_itr) + { + p = (icalproperty*)pvl_data(itr); + next_itr = pvl_next(itr); if(icalproperty_isa(p) == ICAL_XLICERROR_PROPERTY) { icalcomponent_remove_property(component,p); } } - - for(c = icalcomponent_get_first_component(component,ICAL_ANY_COMPONENT); - c != 0; - c = icalcomponent_get_next_component(component,ICAL_ANY_COMPONENT)){ - + + for( itr = pvl_head(impl->components); + itr != 0; + itr = pvl_next(itr)) + { + c = (icalcomponent*)pvl_data(itr); icalcomponent_strip_errors(c); } } - +/* Hack. This will change the state of the iterators */ void icalcomponent_convert_errors(icalcomponent* component) { icalproperty *p, *next_p; @@ -709,7 +746,6 @@ void icalcomponent_convert_errors(icalcomponent* component) if(icalproperty_isa(p) == ICAL_XLICERROR_PROPERTY) { struct icalreqstattype rst; - char tmp[MAX_TMP]; icalparameter *param = icalproperty_get_first_parameter (p,ICAL_XLICERRORTYPE_PARAMETER); @@ -779,4 +815,111 @@ void icalcomponent_set_parent(icalcomponent* component, icalcomponent* parent) c->parent = parent; } +icalcompiter icalcompiter_null = {ICAL_NO_COMPONENT,0}; + +icalcompiter +icalcomponent_begin_component(icalcomponent* component,icalcomponent_kind kind) +{ + struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component; + icalcompiter itr; + pvl_elem i; + + itr.kind = kind; + + icalerror_check_arg_rz( (component!=0),"component"); + + for( i = pvl_head(impl->components); i != 0; i = pvl_next(itr.iter)) { + + icalcomponent *c = (icalcomponent*) pvl_data(i); + + if (icalcomponent_isa(c) == kind || kind == ICAL_ANY_COMPONENT) { + + itr.iter = i; + + return itr; + } + } + + return icalcompiter_null;; +} + +icalcompiter +icalcomponent_end_component(icalcomponent* component,icalcomponent_kind kind) +{ + struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component; + icalcompiter itr; + pvl_elem i; + + itr.kind = kind; + + icalerror_check_arg_rz( (component!=0),"component"); + + for( i = pvl_tail(impl->components); i != 0; i = pvl_prior(i)) { + + icalcomponent *c = (icalcomponent*) pvl_data(i); + + if (icalcomponent_isa(c) == kind || kind == ICAL_ANY_COMPONENT) { + + itr.iter = pvl_next(i); + + return itr; + } + } + + return icalcompiter_null;; +} + + +icalcomponent* icalcompiter_next(icalcompiter* i) +{ + if (i->iter == 0){ + return 0; + } + + for( i->iter = pvl_next(i->iter); + i->iter != 0; + i->iter = pvl_next(i->iter)) { + + icalcomponent *c = (icalcomponent*) pvl_data(i->iter); + + if (icalcomponent_isa(c) == i->kind + || i->kind == ICAL_ANY_COMPONENT) { + + return icalcompiter_deref(i);; + } + } + + return 0; + +} + +icalcomponent* icalcompiter_prior(icalcompiter* i) +{ + if (i->iter == 0){ + return 0; + } + + for( i->iter = pvl_prior(i->iter); + i->iter != 0; + i->iter = pvl_prior(i->iter)) { + + icalcomponent *c = (icalcomponent*) pvl_data(i->iter); + + if (icalcomponent_isa(c) == i->kind + || i->kind == ICAL_ANY_COMPONENT) { + + return icalcompiter_deref(i);; + } + } + return 0; + +} +icalcomponent* icalcompiter_deref(icalcompiter* i) +{ + if(i->iter ==0){ + return 0; + } + + return pvl_data(i->iter); +} diff --git a/libical/src/libical/icalcomponent.h b/libical/src/libical/icalcomponent.h index 8d9f22ca76..b0d1e33630 100644 --- a/libical/src/libical/icalcomponent.h +++ b/libical/src/libical/icalcomponent.h @@ -4,20 +4,19 @@ 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 + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org + + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + The original code is icalcomponent.h ======================================================================*/ @@ -28,9 +27,19 @@ #include "icalproperty.h" #include "icalvalue.h" #include "icalenums.h" /* defines icalcomponent_kind */ +#include "pvl.h" typedef void icalcomponent; +/* This is exposed so that callers will not have to allocate and + deallocate iterators. Pretend that you can't see it. */ +typedef struct icalcompiter +{ + icalcomponent_kind kind; + pvl_elem iter; + +} icalcompiter; + icalcomponent* icalcomponent_new(icalcomponent_kind kind); icalcomponent* icalcomponent_new_clone(icalcomponent* component); icalcomponent* icalcomponent_new_from_string(char* str); @@ -86,6 +95,20 @@ void icalcomponent_remove_component(icalcomponent* parent, int icalcomponent_count_components(icalcomponent* component, icalcomponent_kind kind); +/* Iteration Routines. There are two forms of iterators, internal and +external. The internal ones came first, and are almost completely +sufficient, but they fail badly when you want to construct a loop that +removes components from the container. + +The internal iterators are deprecated. */ + +/* Using external iterators */ +icalcompiter icalcomponent_begin_component(icalcomponent* component, + icalcomponent_kind kind); + +icalcompiter icalcomponent_end_component(icalcomponent* component, + icalcomponent_kind kind); + /* Iterate through components */ icalcomponent* icalcomponent_get_current_component (icalcomponent* component); @@ -94,6 +117,8 @@ icalcomponent* icalcomponent_get_first_component(icalcomponent* component, 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); @@ -113,6 +138,14 @@ icalcomponent* icalcomponent_get_parent(icalcomponent* component); void icalcomponent_set_parent(icalcomponent* component, icalcomponent* parent); + + +/* External component iterator */ +icalcomponent* icalcompiter_next(icalcompiter* i); +icalcomponent* icalcompiter_prior(icalcompiter* i); +icalcomponent* icalcompiter_deref(icalcompiter* i); + + #endif /* !ICALCOMPONENT_H */ diff --git a/libical/src/libical/icalenums.c b/libical/src/libical/icalenums.c index 7f0aae6a0e..50d23c8d41 100644 --- a/libical/src/libical/icalenums.c +++ b/libical/src/libical/icalenums.c @@ -5,21 +5,19 @@ $Id$ + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org - (C) COPYRIGHT 1999 Eric Busboom - http://www.softwarestudio.org + This program is free software; you can redistribute it and/or modify + it under the terms of either: - 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 LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ - The original author is Eric Busboom The original code is icalenum.c ======================================================================*/ @@ -33,7 +31,7 @@ struct icalproperty_kind_map { icalproperty_kind kind; - char name[20]; + char *name; }; static struct icalproperty_kind_map property_map[] = @@ -98,6 +96,10 @@ static struct icalproperty_kind_map property_map[] = /* libical private properties */ { ICAL_XLICERROR_PROPERTY,"X-LIC-ERROR"}, + { ICAL_XLICMIMECONTENTTYPE_PROPERTY,"X-LIC-MIME-CONTENT-TYPE"}, + { ICAL_XLICMIMEENCODING_PROPERTY,"X-LIC-MIME-ENCODING"}, + { ICAL_XLICMIMEOPTINFO_PROPERTY,"X-LIC-MIME-OPT-INFO"}, + { ICAL_XLICMIMECHARSET_PROPERTY,"X-LIC-MIME-CHARSET"}, { ICAL_XLICCLUSTERCOUNT_PROPERTY,"X-LIC-CLUSTERCOUNT"}, /* End of the list */ @@ -287,6 +289,7 @@ static struct icalcomponent_kind_map component_map[] = /* libical private components */ { ICAL_XLICINVALID_COMPONENT, "X-LIC-UNKNOWN" }, + { ICAL_XLICMIMEPART_COMPONENT, "X-LIC-MIME-PART" }, { ICAL_ANY_COMPONENT, "ANY" }, { ICAL_XROOT_COMPONENT, "XROOT" }, diff --git a/libical/src/libical/icalenums.h b/libical/src/libical/icalenums.h index ff7cee486e..ba3137803e 100644 --- a/libical/src/libical/icalenums.h +++ b/libical/src/libical/icalenums.h @@ -1,23 +1,23 @@ + /* -*- Mode: C -*-*/ /*====================================================================== FILE: icalenums.h - (C) COPYRIGHT 1999 Eric Busboom - http://www.softwarestudio.org + (C) COPYRIGHT 2000, 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. + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ - The original author is Eric Busboom The original code is icalenums.h Contributions from: @@ -57,7 +57,10 @@ typedef enum icalcomponent_kind { ICAL_VQUERY_COMPONENT, ICAL_VCAR_COMPONENT, ICAL_VCOMMAND_COMPONENT, - ICAL_XLICINVALID_COMPONENT + ICAL_XLICINVALID_COMPONENT, + ICAL_XLICMIMEPART_COMPONENT /* a non-stardard component that mirrors + structure of MIME data */ + } icalcomponent_kind; /*********************************************************************** @@ -126,6 +129,12 @@ typedef enum icalproperty_kind { /* libical private properties */ ICAL_XLICERROR_PROPERTY, ICAL_XLICCLUSTERCOUNT_PROPERTY, + ICAL_XLICMIMECONTENTTYPE_PROPERTY, + ICAL_XLICMIMEENCODING_PROPERTY, + ICAL_XLICMIMECID_PROPERTY, + ICAL_XLICMIMEFILENAME_PROPERTY, + ICAL_XLICMIMECHARSET_PROPERTY, + ICAL_XLICMIMEOPTINFO_PROPERTY, ICAL_NO_PROPERTY /* This must be the last enum, for iteration */ @@ -323,7 +332,9 @@ typedef enum icalparameter_xlicerrortype { ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR, ICAL_XLICERRORTYPE_PROPERTYPARSEERROR, ICAL_XLICERRORTYPE_VALUEPARSEERROR, - ICAL_XLICERRORTYPE_INVALIDITIP + ICAL_XLICERRORTYPE_UNKVCALPROP, + ICAL_XLICERRORTYPE_INVALIDITIP, + ICAL_XLICERRORTYPE_MIMEPARSEERROR, } icalparameter_xlicerrortype; typedef enum icalparameter_xliccomparetype { @@ -359,17 +370,20 @@ typedef enum icalparameter_value { * Recurrances **********************************************************************/ - typedef enum icalrecurrencetype_frequency { - ICAL_NO_RECURRENCE, - ICAL_SECONDLY_RECURRENCE, - ICAL_MINUTELY_RECURRENCE, - ICAL_HOURLY_RECURRENCE, - ICAL_DAILY_RECURRENCE, - ICAL_WEEKLY_RECURRENCE, - ICAL_MONTHLY_RECURRENCE, - ICAL_YEARLY_RECURRENCE + /* These enums are used to index an array, so don't change the + order or the integers */ + + ICAL_SECONDLY_RECURRENCE=0, + ICAL_MINUTELY_RECURRENCE=1, + ICAL_HOURLY_RECURRENCE=2, + ICAL_DAILY_RECURRENCE=3, + ICAL_WEEKLY_RECURRENCE=4, + ICAL_MONTHLY_RECURRENCE=5, + ICAL_YEARLY_RECURRENCE=6, + ICAL_NO_RECURRENCE=7 + } icalrecurrencetype_frequency; typedef enum icalrecurrencetype_weekday diff --git a/libical/src/libical/icalerror.c b/libical/src/libical/icalerror.c index fb9e152b16..c7641da504 100644 --- a/libical/src/libical/icalerror.c +++ b/libical/src/libical/icalerror.c @@ -4,23 +4,23 @@ CREATOR: eric 16 May 1999 $Id$ + $Locker$ - (C) COPYRIGHT 1999 Eric Busboom - http://www.softwarestudio.org + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org + + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: - 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 Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ - The original author is Eric Busboom The original code is icalerror.c ======================================================================*/ diff --git a/libical/src/libical/icalerror.h b/libical/src/libical/icalerror.h index 124699c21b..fbf6076dd6 100644 --- a/libical/src/libical/icalerror.h +++ b/libical/src/libical/icalerror.h @@ -6,20 +6,19 @@ $Id$ - (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 + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org + + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + The original code is icalerror.h ======================================================================*/ @@ -122,6 +121,7 @@ typedef enum icalerrorenum { ICAL_USAGE_ERROR, ICAL_NO_ERROR, ICAL_MULTIPLEINCLUSION_ERROR, + ICAL_TIMEDOUT_ERROR, ICAL_UNKNOWN_ERROR /* Used for problems in input to icalerror_strerror()*/ } icalerrorenum; diff --git a/libical/src/libical/icalmemory.c b/libical/src/libical/icalmemory.c index 35544b14ee..e13c2c42ca 100644 --- a/libical/src/libical/icalmemory.c +++ b/libical/src/libical/icalmemory.c @@ -4,6 +4,7 @@ CREATOR: eric 30 June 1999 $Id$ + $Locker$ The contents of this file are subject to the Mozilla Public License @@ -16,12 +17,34 @@ the License for the specific language governing rights and limitations under the License. + + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + The Original Code is icalmemory.h - The Initial Developer of the Original Code is Eric Busboom - (C) COPYRIGHT 1999 The Software Studio. - http://www.softwarestudio.org + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + + The Initial Developer of the Original Code is Eric Busboom + + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org ======================================================================*/ /* libical often passes strings back to the caller. To make these @@ -41,6 +64,9 @@ #include "config.h" #endif +#ifdef DMALLOC +#include "dmalloc.h" +#endif #include "icalmemory.h" #include "icalerror.h" @@ -52,18 +78,16 @@ #define BUFFER_RING_SIZE 25 #define MIN_BUFFER_SIZE 200 -void* buffer_ring[BUFFER_RING_SIZE+1]; -int buffer_pos = 0; +/* HACK. Not threadsafe */ +void* buffer_ring[BUFFER_RING_SIZE]; +int buffer_pos = -1; int initialized = 0; -/* Create a new temporary buffer on the ring. Libical owns these and wil deallocate them. */ -void* -icalmemory_tmp_buffer (size_t size) +/* Add an existing buffer to the buffer ring */ +void icalmemory_add_tmp_buffer(void* buf) { - void *rtrn; /* I don't think I need this -- I think static arrays are initialized to 0 as a standard part of C, but I am not sure. */ - if (initialized == 0){ int i; for(i=0; i<BUFFER_RING_SIZE; i++){ @@ -71,30 +95,45 @@ icalmemory_tmp_buffer (size_t size) } initialized = 1; } - - /* Ideally, this routine would re-use an existing buffer if it is - larger than the requested buffer. Maybe later.... */ - if (size < MIN_BUFFER_SIZE){ - size = MIN_BUFFER_SIZE; + /* Wrap around the ring */ + if(++buffer_pos == BUFFER_RING_SIZE){ + buffer_pos = 0; } - + + /* Free buffers as their slots are overwritten */ if ( buffer_ring[buffer_pos] != 0){ - /*sprintf(buffer_ring[buffer_pos], "***DEALLOCATED MEMORY***: %d",buffer_pos);*/ free( buffer_ring[buffer_pos]); buffer_ring[buffer_pos] = 0; } + /* Assign the buffer to a slot */ + buffer_ring[buffer_pos] = buf; +} - rtrn = buffer_ring[buffer_pos] = (void*)malloc(size); +/* Create a new temporary buffer on the ring. Libical owns these and + wil deallocate them. */ +void* +icalmemory_tmp_buffer (size_t size) +{ + char *buf; - memset(rtrn,0,size); + if (size < MIN_BUFFER_SIZE){ + size = MIN_BUFFER_SIZE; + } + + buf = (void*)malloc(size); - if(++buffer_pos > BUFFER_RING_SIZE){ - buffer_pos = 0; + if( buf == 0){ + icalerror_set_errno(ICAL_NEWFAILED_ERROR); + return 0; } - return rtrn; + memset(buf,0,size); + + icalmemory_add_tmp_buffer(buf); + + return buf; } void icalmemory_free_ring() @@ -112,6 +151,8 @@ void icalmemory_free_ring() } + + /* Like strdup, but the buffer is on the ring. */ char* icalmemory_tmp_copy(char* str) @@ -124,6 +165,10 @@ icalmemory_tmp_copy(char* str) } +char* icalmemory_strdup(const char *s) +{ + return strdup(s); +} void icalmemory_free_tmp_buffer (void* buf) @@ -137,13 +182,18 @@ icalmemory_free_tmp_buffer (void* buf) } -/* These buffer routines create memory the old fashioned way -- so the caller will have to delocate the new memory */ +/* These buffer routines create memory the old fashioned way -- so the + caller will have to delocate the new memory */ void* icalmemory_new_buffer(size_t size) { - /* HACK. need to handle out of memory case */ void *b = malloc(size); + if( b == 0){ + icalerror_set_errno(ICAL_NEWFAILED_ERROR); + return 0; + } + memset(b,0,size); return b; @@ -151,9 +201,14 @@ void* icalmemory_new_buffer(size_t size) void* icalmemory_resize_buffer(void* buf, size_t size) { - /* HACK. need to handle out of memory case */ + void *b = realloc(buf, size); - return realloc(buf, size); + if( b == 0){ + icalerror_set_errno(ICAL_NEWFAILED_ERROR); + return 0; + } + + return b; } void icalmemory_free_buffer(void* buf) @@ -240,5 +295,5 @@ icalmemory_append_char(char** buf, char** pos, size_t* buf_size, **pos = ch; *pos += 1; - + **pos = 0; } diff --git a/libical/src/libical/icalmemory.h b/libical/src/libical/icalmemory.h index 26d22b7316..6c974cdc95 100644 --- a/libical/src/libical/icalmemory.h +++ b/libical/src/libical/icalmemory.h @@ -17,12 +17,34 @@ the License for the specific language governing rights and limitations under the License. + + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + The Original Code is icalmemory.h - The Initial Developer of the Original Code is Eric Busboom - (C) COPYRIGHT 1999 The Software Studio. - http://www.softwarestudio.org + This program is free software; you can redistribute it and/or modify + it under the terms of either: + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + + The Initial Developer of the Original Code is Eric Busboom + + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org ======================================================================*/ #ifndef ICALMEMORY_H @@ -30,7 +52,8 @@ #include <sys/types.h> /* for size_t */ -/* Tmp buffers are managed by ical. References can be returned to the caller, although the caller will not own the memory. */ +/* Tmp buffers are managed by ical. References can be returned to the + caller, although the caller will not own the memory. */ void* icalmemory_tmp_buffer(size_t size); char* icalmemory_tmp_copy(char* str); @@ -70,6 +93,9 @@ void icalmemory_append_string(char** buf, char** pos, size_t* buf_size, void icalmemory_append_char(char** buf, char** pos, size_t* buf_size, char ch); +/* A wrapper around strdup */ +char* icalmemory_strdup(const char *s); + #endif /* !ICALMEMORY_H */ diff --git a/libical/src/libical/icalparameter.c b/libical/src/libical/icalparameter.c index cf37eb07b2..c77c223f1c 100644 --- a/libical/src/libical/icalparameter.c +++ b/libical/src/libical/icalparameter.c @@ -4,23 +4,23 @@ CREATOR: eric 09 May 1999 $Id$ + $Locker$ - (C) COPYRIGHT 1999 Eric Busboom - http://www.softwarestudio.org + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org + + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: - 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 Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ - The original author is Eric Busboom The original code is icalderivedparameters.{c,h} Contributions from: @@ -114,7 +114,7 @@ icalparameter_new_clone(icalparameter* param) memcpy(new,old,sizeof(struct icalparameter_impl)); if (old->string != 0){ - new->string = strdup(old->string); + new->string = icalmemory_strdup(old->string); if (new->string == 0){ icalparameter_free(new); return 0; @@ -122,7 +122,7 @@ icalparameter_new_clone(icalparameter* param) } if (old->x_name != 0){ - new->x_name = strdup(old->x_name); + new->x_name = icalmemory_strdup(old->x_name); if (new->x_name == 0){ icalparameter_free(new); return 0; @@ -132,6 +132,116 @@ icalparameter_new_clone(icalparameter* param) return new; } +#if 0 + +struct param_string_map { + icalparameter_kind kind; + int val; /* Actually, union of several types of enums */ + char* str; +} param_string_map[] = +{ + {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_INDIVIDUAL,"INDIVIDUAL"}, + {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_GROUP,"GROUP"}, + {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_RESOURCE,"RESOURCE"}, + {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_ROOM,"ROOM"}, + {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_UNKNOWN,"UNKNOWN"}, + {ICAL_FBTYPE_PARAMETER,ICAL_FBTYPE_FREE,"FREE"}, + {ICAL_FBTYPE_PARAMETER,ICAL_FBTYPE_BUSY,"BUSY"}, + {ICAL_FBTYPE_PARAMETER,ICAL_FBTYPE_BUSYUNAVAILABLE,"BUSYUNAVAILABLE"}, + {ICAL_FBTYPE_PARAMETER,ICAL_FBTYPE_BUSYTENTATIVE,"BUSYTENTATIVE"}, + {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_NEEDSACTION,"NEEDSACTION"}, + {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_ACCEPTED,"ACCEPTED"}, + {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_DECLINED,"DECLINED"}, + {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_TENTATIVE,"TENTATIVE"}, + {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_DELEGATED,"DELEGATED"}, + {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_COMPLETED,"COMPLETED"}, + {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_INPROCESS,"INPROCESS"}, + {ICAL_RANGE_PARAMETER,ICAL_RANGE_THISANDPRIOR,"THISANDPRIOR"}, + {ICAL_RANGE_PARAMETER,ICAL_RANGE_THISANDFUTURE,"THISANDFUTURE"}, + {ICAL_RELATED_PARAMETER,ICAL_RELATED_START,"START"}, + {ICAL_RELATED_PARAMETER,ICAL_RELATED_END,"END"}, + {ICAL_RELTYPE_PARAMETER,ICAL_RELTYPE_PARENT,"PARENT"}, + {ICAL_RELTYPE_PARAMETER,ICAL_RELTYPE_CHILD,"CHILD"}, + {ICAL_RELTYPE_PARAMETER,ICAL_RELTYPE_SIBLING,"SIBLING"}, + {ICAL_ROLE_PARAMETER,ICAL_ROLE_CHAIR,"CHAIR"}, + {ICAL_RSVP_PARAMETER,ICAL_RSVP_PARAMETER,"TRUE"}, + {ICAL_RSVP_PARAMETER,ICAL_RSVP_PARAMETER,"FALSE"}, + {ICAL_VALUE_PARAMETER,ICAL_VALUE_BINARY,"BINARY"}, + {ICAL_VALUE_PARAMETER,ICAL_VALUE_BOOLEAN,"BOOLEAN"}, + {ICAL_VALUE_PARAMETER,ICAL_VALUE_DATE,"DATE"}, + {ICAL_VALUE_PARAMETER,ICAL_VALUE_DURATION,"DURATION"}, + {ICAL_VALUE_PARAMETER,ICAL_VALUE_FLOAT,"FLOAT"}, + {ICAL_VALUE_PARAMETER,ICAL_VALUE_INTEGER,"INTEGER"}, + {ICAL_VALUE_PARAMETER,ICAL_VALUE_PERIOD,"PERIOD"}, + {ICAL_VALUE_PARAMETER,ICAL_VALUE_RECUR,"RECUR"}, + {ICAL_VALUE_PARAMETER,ICAL_VALUE_TEXT,"TEXT"}, + {ICAL_VALUE_PARAMETER,ICAL_VALUE_TIME,"TIME"}, + {ICAL_VALUE_PARAMETER,ICAL_VALUE_URI,"URI"}, + {ICAL_VALUE_PARAMETER,ICAL_VALUE_XNAME,"ERROR"}, + {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_COMPONENTPARSEERROR,"COMPONENT_PARSE_ERROR"}, + {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_PROPERTYPARSEERROR,"PROPERTY_PARSE_ERROR"}, + {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR,"PARAMETER_NAME_PARSE_ERROR"}, + {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR,"PARAMETER_VALUE_PARSE_ERROR"}, + {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_VALUEPARSEERROR,"VALUE_PARSE_ERROR"}, + {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_INVALIDITIP,"INVALID_ITIP"}, + {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_UNKVCALPROP,"UNKNOWN_VCAL_PROP_ERROR"}, + {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_MIMEPARSEERROR,"MIME_PARSE_ERROR"}, + {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_EQUAL,"EQUAL"}, + {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_NOTEQUAL,"NOTEQUAL"}, + {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_LESS,"LESS"}, + {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_GREATER,"GREATER"}, + {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_LESSEQUAL,"LESSEQUAL"}, + {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_GREATEREQUAL,"GREATEREQUAL"}, + {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_REGEX,"REGEX"}, + {ICAL_NO_PARAMETER,0,""}, + +}; + + +icalparameter* icalparameter_new_from_string(icalparameter_kind kind, char* val) +{ + int i =0; + icalparameter* param=0; + + icalerror_check_arg_rz((val!=0),"val"); + + switch(kind){ + case ICAL_SENTBY_PARAMETER: + case ICAL_TZID_PARAMETER: + case ICAL_X_PARAMETER: + case ICAL_FMTTYPE_PARAMETER: + case ICAL_LANGUAGE_PARAMETER: + case ICAL_MEMBER_PARAMETER: + case ICAL_DELEGATEDFROM_PARAMETER: + case ICAL_DELEGATEDTO_PARAMETER: + case ICAL_DIR_PARAMETER: + case ICAL_ALTREP_PARAMETER: + case ICAL_CN_PARAMETER: + { + if (impl->string == 0){ return no_parameter;} + strcpy(tend,impl->string);break; + break; + } + + case ICAL_NO_PARAMETER: + case ICAL_ANY_PARAMETER: + { + } + + default: { + /* All other types are enumerated */ + for(i = 0; param_string_map[i].kind != ICAL_NO_PARAMETER){ + if(kind == param_string_map[i].kind && + strcmp(val,param_string_map[i].str) == 0){ + + + } + } + } +} + +#endif + icalparameter* icalparameter_new_from_string(icalparameter_kind kind, char* val) { @@ -427,6 +537,12 @@ icalparameter* icalparameter_new_from_string(icalparameter_kind kind, char* val) else if(strcmp(val,"INVALID_ITIP") == 0){ param = icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_INVALIDITIP); } + else if(strcmp(val,"MIME_PARSE_ERROR") == 0){ + param = icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_MIMEPARSEERROR); + } + else if(strcmp(val,"UNKNOWN_VCAL_PROP_ERROR") == 0){ + param = icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_UNKVCALPROP); + } break; } @@ -839,6 +955,14 @@ icalparameter_as_ical_string (icalparameter* parameter) { strcpy(tend,"INVALID_ITIP");break; } + case ICAL_XLICERRORTYPE_UNKVCALPROP: + { + strcpy(tend,"UNKNOWN_VCAL_PROP_ERROR");break; + } + case ICAL_XLICERRORTYPE_MIMEPARSEERROR: + { + strcpy(tend,"MIME_PARSE_ERROR");break; + } } break; } @@ -969,7 +1093,7 @@ icalparameter_set_xname (icalparameter* param, char* v) free(impl->x_name); } - impl->x_name = strdup(v); + impl->x_name = icalmemory_strdup(v); if (impl->x_name == 0){ errno = ENOMEM; @@ -998,7 +1122,7 @@ icalparameter_set_xvalue (icalparameter* param, char* v) free(impl->string); } - impl->string = strdup(v); + impl->string = icalmemory_strdup(v); if (impl->string == 0){ errno = ENOMEM; @@ -1071,7 +1195,7 @@ void icalparameter_set_altrep(icalparameter* param, char* v) icalerror_check_arg_rv( (param!=0), "param"); icalerror_clear_errno(); - ((struct icalparameter_impl*)param)->string = strdup(v); + ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); } /* CN */ @@ -1107,7 +1231,7 @@ void icalparameter_set_cn(icalparameter* param, char* v) icalerror_check_arg_rv( (param!=0), "param"); icalerror_clear_errno(); - ((struct icalparameter_impl*)param)->string = strdup(v); + ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); } /* CUTYPE */ @@ -1184,7 +1308,7 @@ void icalparameter_set_delegatedfrom(icalparameter* param, char* v) icalerror_check_arg_rv( (param!=0), "param"); icalerror_clear_errno(); - ((struct icalparameter_impl*)param)->string = strdup(v); + ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); } /* DELEGATED-TO */ @@ -1220,7 +1344,7 @@ void icalparameter_set_delegatedto(icalparameter* param, char* v) icalerror_check_arg_rv( (param!=0), "param"); icalerror_clear_errno(); - ((struct icalparameter_impl*)param)->string = strdup(v); + ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); } /* DIR */ @@ -1256,7 +1380,7 @@ void icalparameter_set_dir(icalparameter* param, char* v) icalerror_check_arg_rv( (param!=0), "param"); icalerror_clear_errno(); - ((struct icalparameter_impl*)param)->string = strdup(v); + ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); } /* ENCODING */ @@ -1374,7 +1498,7 @@ void icalparameter_set_fmttype(icalparameter* param, char* v) icalerror_check_arg_rv( (param!=0), "param"); icalerror_clear_errno(); - ((struct icalparameter_impl*)param)->string = strdup(v); + ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); } /* LANGUAGE */ @@ -1410,7 +1534,7 @@ void icalparameter_set_language(icalparameter* param, char* v) icalerror_check_arg_rv( (param!=0), "param"); icalerror_clear_errno(); - ((struct icalparameter_impl*)param)->string = strdup(v); + ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); } /* MEMBER */ @@ -1446,7 +1570,7 @@ void icalparameter_set_member(icalparameter* param, char* v) icalerror_check_arg_rv( (param!=0), "param"); icalerror_clear_errno(); - ((struct icalparameter_impl*)param)->string = strdup(v); + ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); } /* PARTSTAT */ @@ -1719,7 +1843,7 @@ void icalparameter_set_sentby(icalparameter* param, char* v) icalerror_check_arg_rv( (param!=0), "param"); icalerror_clear_errno(); - ((struct icalparameter_impl*)param)->string = strdup(v); + ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); } /* TZID */ @@ -1755,7 +1879,7 @@ void icalparameter_set_tzid(icalparameter* param, char* v) icalerror_check_arg_rv( (param!=0), "param"); icalerror_clear_errno(); - ((struct icalparameter_impl*)param)->string = strdup(v); + ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); } /* VALUE */ @@ -1832,7 +1956,7 @@ void icalparameter_set_x(icalparameter* param, char* v) icalerror_check_arg_rv( (param!=0), "param"); icalerror_clear_errno(); - ((struct icalparameter_impl*)param)->string = strdup(v); + ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); } /* X-LIC-ERRORTYPE */ diff --git a/libical/src/libical/icalparameter.h b/libical/src/libical/icalparameter.h index 174cae6f3f..ad97f34e58 100644 --- a/libical/src/libical/icalparameter.h +++ b/libical/src/libical/icalparameter.h @@ -9,20 +9,19 @@ - (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 + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org + + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + The original code is icalparam.h ======================================================================*/ diff --git a/libical/src/libical/icalparser.c b/libical/src/libical/icalparser.c index 3be754036a..b4563e23c9 100644 --- a/libical/src/libical/icalparser.c +++ b/libical/src/libical/icalparser.c @@ -4,6 +4,7 @@ CREATOR: eric 04 August 1999 $Id$ + $Locker$ The contents of this file are subject to the Mozilla Public License @@ -16,11 +17,21 @@ the License for the specific language governing rights and limitations under the License. - The Initial Developer of the Original Code is Eric Busboom - (C) COPYRIGHT 1999 The Software Studio. - http://www.softwarestudio.org + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + + The Initial Developer of the Original Code is Eric Busboom + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org ======================================================================*/ #ifdef HAVE_CONFIG_H @@ -91,6 +102,7 @@ icalparser* icalparser_new() return (icalparser*)impl; } + void icalparser_free(icalparser* parser) { struct icalparser_impl* impl = (struct icalparser_impl*)parser; @@ -105,6 +117,8 @@ void icalparser_free(icalparser* parser) } pvl_free(impl->components); + + free(impl); } void icalparser_set_gen_data(icalparser* parser, void* data) @@ -115,7 +129,7 @@ void icalparser_set_gen_data(icalparser* parser, void* data) } -icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind, +icalvalue* icalvalue_new_From_string_with_error(icalvalue_kind kind, char* str, icalproperty **error); @@ -313,7 +327,6 @@ char* icalparser_get_next_value(char* line, char **end, icalvalue_kind kind) ) { /* The COMMA was followed by 'FREQ', is it a real seperator*/ /* Fall through */ - printf("%s\n",next); } else if (next != 0){ /* Not real, get the next COMMA */ p = next+1; @@ -404,7 +417,8 @@ char* icalparser_get_line(icalparser *parser, /* If the last position in the temp buffer is occupied, mark the buffer as full. The means we will do another read later, because the line is not finished */ - if (impl->temp[impl->tmp_buf_size-1] == 0){ + if (impl->temp[impl->tmp_buf_size-1] == 0 && + impl->temp[impl->tmp_buf_size-2] != '\n'){ impl->buffer_full = 1; } else { impl->buffer_full = 0; @@ -515,7 +529,6 @@ icalcomponent* icalparser_parse(icalparser *parser, do{ line = icalparser_get_line(parser, line_gen_func); - if ((c = icalparser_add_line(parser,line)) != 0){ if (root_component == 0){ /* Just one component */ @@ -538,6 +551,9 @@ icalcomponent* icalparser_parse(icalparser *parser, icalparser_claim(parser); } } + if(line != 0){ + free(line); + } } while ( line != 0); return root_component; @@ -568,7 +584,7 @@ icalcomponent* icalparser_add_line(icalparser* parser, /* Begin by getting the property name at the start of the line. The property name may end up being "BEGIN" or "END" in which case it - is not really a property, but the market for the start or end of + is not really a property, but the marker for the start or end of a component */ end = 0; @@ -591,8 +607,6 @@ icalcomponent* icalparser_add_line(icalparser* parser, /********************************************************************** * Handle begin and end of components **********************************************************************/ - - /* If the property name is BEGIN or END, we are actually starting or ending a new component */ diff --git a/libical/src/libical/icalparser.h b/libical/src/libical/icalparser.h index 25c07eca9f..161127379f 100644 --- a/libical/src/libical/icalparser.h +++ b/libical/src/libical/icalparser.h @@ -6,20 +6,19 @@ $Id$ - (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 + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org + + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + The original code is icalparser.h ======================================================================*/ @@ -32,6 +31,16 @@ #include <stdio.h> /* For FILE* */ typedef void* icalparser; + + +/*********************************************************************** + * Line-oriented parsing. + * + * Create a new parser via icalparse_new_parser, then add ines one at + * a time with icalparse_add_line(). icalparser_add_line() will return + * non-zero when it has finished with a component. + ***********************************************************************/ + typedef enum icalparser_state { ICALPARSER_ERROR, ICALPARSER_SUCCESS, @@ -40,6 +49,13 @@ typedef enum icalparser_state { ICALPARSER_IN_PROGRESS } icalparser_state; +icalparser* icalparser_new(); +icalcomponent* icalparser_add_line(icalparser* parser, char* str ); +icalcomponent* icalparser_claim(icalparser* parser); +icalcomponent* icalparser_clean(icalparser* parser); +icalparser_state icalparser_get_state(icalparser* parser); +void icalparser_free(icalparser* parser); + /*********************************************************************** * Message oriented parsing. icalparser_parse takes a string that @@ -51,25 +67,13 @@ typedef enum icalparser_state { icalcomponent* icalparser_parse(icalparser *parser, char* (*line_gen_func)(char *s, size_t size, void *d)); -/* A simple, and incorrect interface - can only return one component*/ -icalcomponent* icalparser_parse_string(char* str); +/* Set the data that icalparser_parse will give to the line_gen_func + as the parameter 'd'*/ +void icalparser_set_gen_data(icalparser* parser, void* data); -/*********************************************************************** - * Line-oriented parsing. - * - * Create a new parser via icalparse_new_parser, then add ines one at - * a time with icalparse_add_line(). icalparser_add_line() will return - * non-zero when it has finished with a component. - ***********************************************************************/ +icalcomponent* icalparser_parse_string(char* str); -icalparser* icalparser_new(); -void icalparser_set_gen_data(icalparser* parser, void* data); -icalcomponent* icalparser_add_line(icalparser* parser, char* str ); -icalcomponent* icalparser_claim(icalparser* parser); -icalcomponent* icalparser_clean(icalparser* parser); -icalparser_state icalparser_get_state(icalparser* parser); -void icalparser_free(icalparser* parser); /*********************************************************************** * Parser support functions @@ -81,14 +85,6 @@ icalvalue* icalparser_parse_value(icalvalue_kind kind, char* str, icalcomponent /* Given a line generator function, return a single iCal content line.*/ char* icalparser_get_line(icalparser* parser, char* (*line_gen_func)(char *s, size_t size, void *d)); - -/* a line_gen_function that returns lines from a string. To use it, - set string_line_generator_str to point to the input string, and set - string_line_generator_pos to 0. These globals make the routine not - thead-safe. */ - -extern char* string_line_generator_str; -extern char* string_line_generator_pos; char* string_line_generator(char *out, size_t buf_size, void *d); #endif /* !ICALPARSE_H */ diff --git a/libical/src/libical/icalproperty.c b/libical/src/libical/icalproperty.c index c3fe7c9073..1040215108 100644 --- a/libical/src/libical/icalproperty.c +++ b/libical/src/libical/icalproperty.c @@ -7,20 +7,19 @@ $Id$ - (C) COPYRIGHT 1999 Eric Busboom - http://www.softwarestudio.org + (C) COPYRIGHT 2000, 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. + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ - The original author is Eric Busboom The original code is icalproperty.c ======================================================================*/ @@ -29,7 +28,7 @@ #include "config.h" #endif -#include <string.h> /* For strdup, rindex */ +#include <string.h> /* For icalmemory_strdup, rindex */ #include <assert.h> #include <stdlib.h> #include <errno.h> @@ -80,7 +79,7 @@ void icalproperty_add_parameters(struct icalproperty_impl *impl,va_list args) icalproperty_add_parameter((icalproperty*)impl, (icalparameter*)vp); } else { - abort(); + assert(0); } } @@ -138,7 +137,7 @@ icalproperty_new_clone(icalproperty* prop) if (old->x_name != 0) { - new->x_name = strdup(old->x_name); + new->x_name = icalmemory_strdup(old->x_name); if (new->x_name == 0) { icalproperty_free(new); @@ -269,6 +268,7 @@ icalproperty_as_ical_string (icalproperty* prop) icalerror_check_arg_rz( (prop!=0),"prop"); + /* Append property name */ if (impl->kind == ICAL_X_PROPERTY && impl->x_name != 0){ @@ -315,8 +315,9 @@ icalproperty_as_ical_string (icalproperty* prop) value = icalproperty_get_value(prop); if (value != 0){ - icalmemory_append_string(&buf, &buf_ptr, &buf_size, - icalvalue_as_ical_string(icalproperty_get_value(prop))); + char *str = icalvalue_as_ical_string(value); + icalerror_assert((str !=0),"Could not get string representation of a value"); + icalmemory_append_string(&buf, &buf_ptr, &buf_size, str); } else { icalmemory_append_string(&buf, &buf_ptr, &buf_size,"ERROR: No Value"); @@ -479,7 +480,7 @@ void icalproperty_set_x_name(icalproperty* prop, char* name) free(impl->x_name); } - impl->x_name = strdup(name); + impl->x_name = icalmemory_strdup(name); if(impl->x_name == 0){ icalerror_set_errno(ICAL_ALLOCATION_ERROR); @@ -569,6 +570,59 @@ icalproperty_method icalproperty_get_method(icalproperty* prop) return icalvalue_get_method(value); } +/* X-LIC-MIMECID */ + +icalproperty* icalproperty_new_xlicmimecid(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECID_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicmimecid((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_xlicmimecid(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECID_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicmimecid((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_xlicmimecid(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_string(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_xlicmimecid(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_string(value); +} + /* LAST-MODIFIED */ icalproperty* icalproperty_new_lastmodified(struct icaltimetype v) @@ -1193,6 +1247,112 @@ char* icalproperty_get_contact(icalproperty* prop) return icalvalue_get_text(value); } +/* X-LIC-MIMECONTENTTYPE */ + +icalproperty* icalproperty_new_xlicmimecontenttype(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECONTENTTYPE_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicmimecontenttype((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_xlicmimecontenttype(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECONTENTTYPE_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicmimecontenttype((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_xlicmimecontenttype(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_string(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_xlicmimecontenttype(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_string(value); +} + +/* X-LIC-MIMEOPTINFO */ + +icalproperty* icalproperty_new_xlicmimeoptinfo(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEOPTINFO_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicmimeoptinfo((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_xlicmimeoptinfo(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEOPTINFO_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicmimeoptinfo((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_xlicmimeoptinfo(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_string(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_xlicmimeoptinfo(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_string(value); +} + /* RELATED-TO */ icalproperty* icalproperty_new_relatedto(char* v) @@ -1352,6 +1512,59 @@ char* icalproperty_get_comment(icalproperty* prop) return icalvalue_get_text(value); } +/* X-LIC-ERROR */ + +icalproperty* icalproperty_new_xlicerror(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICERROR_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicerror((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_xlicerror(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICERROR_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicerror((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_xlicerror(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_xlicerror(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + /* TRIGGER */ icalproperty* icalproperty_new_trigger(union icaltriggertype v) @@ -1402,27 +1615,27 @@ union icaltriggertype icalproperty_get_trigger(icalproperty* prop) return icalvalue_get_trigger(value); } -/* X-LIC-ERROR */ +/* CLASS */ -icalproperty* icalproperty_new_xlicerror(char* v) +icalproperty* icalproperty_new_class(char* v) { - struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICERROR_PROPERTY); + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CLASS_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); - icalproperty_set_xlicerror((icalproperty*)impl,v); + icalproperty_set_class((icalproperty*)impl,v); return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_xlicerror(char* v, ...) +icalproperty* icalproperty_vanew_class(char* v, ...) { va_list args; - struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICERROR_PROPERTY); + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CLASS_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); - icalproperty_set_xlicerror((icalproperty*)impl,v); + icalproperty_set_class((icalproperty*)impl,v); va_start(args,v); icalproperty_add_parameters(impl, args); @@ -1431,7 +1644,7 @@ icalproperty* icalproperty_vanew_xlicerror(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_xlicerror(icalproperty* prop, char* v) +void icalproperty_set_class(icalproperty* prop, char* v) { icalvalue *value; @@ -1445,7 +1658,7 @@ void icalproperty_set_xlicerror(icalproperty* prop, char* v) } -char* icalproperty_get_xlicerror(icalproperty* prop) +char* icalproperty_get_class(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1455,27 +1668,27 @@ char* icalproperty_get_xlicerror(icalproperty* prop) return icalvalue_get_text(value); } -/* CLASS */ +/* X */ -icalproperty* icalproperty_new_class(char* v) +icalproperty* icalproperty_new_x(char* v) { - struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CLASS_PROPERTY); + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_X_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); - icalproperty_set_class((icalproperty*)impl,v); + icalproperty_set_x((icalproperty*)impl,v); return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_class(char* v, ...) +icalproperty* icalproperty_vanew_x(char* v, ...) { va_list args; - struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CLASS_PROPERTY); + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_X_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); - icalproperty_set_class((icalproperty*)impl,v); + icalproperty_set_x((icalproperty*)impl,v); va_start(args,v); icalproperty_add_parameters(impl, args); @@ -1484,7 +1697,7 @@ icalproperty* icalproperty_vanew_class(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_class(icalproperty* prop, char* v) +void icalproperty_set_x(icalproperty* prop, char* v) { icalvalue *value; @@ -1498,7 +1711,7 @@ void icalproperty_set_class(icalproperty* prop, char* v) } -char* icalproperty_get_class(icalproperty* prop) +char* icalproperty_get_x(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1611,6 +1824,59 @@ char* icalproperty_get_transp(icalproperty* prop) return icalvalue_get_text(value); } +/* X-LIC-MIMEENCODING */ + +icalproperty* icalproperty_new_xlicmimeencoding(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEENCODING_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicmimeencoding((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_xlicmimeencoding(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEENCODING_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicmimeencoding((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_xlicmimeencoding(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_string(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_xlicmimeencoding(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_string(value); +} + /* SEQUENCE */ icalproperty* icalproperty_new_sequence(int v) @@ -2432,6 +2698,59 @@ struct icalperiodtype icalproperty_get_rdate(icalproperty* prop) return icalvalue_get_datetimeperiod(value); } +/* X-LIC-MIMEFILENAME */ + +icalproperty* icalproperty_new_xlicmimefilename(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEFILENAME_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicmimefilename((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_xlicmimefilename(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEFILENAME_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicmimefilename((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_xlicmimefilename(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_string(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_xlicmimefilename(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_string(value); +} + /* URL */ icalproperty* icalproperty_new_url(char* v) @@ -2485,25 +2804,25 @@ char* icalproperty_get_url(icalproperty* prop) return icalvalue_get_uri(value); } -/* ATTACH */ +/* X-LIC-CLUSTERCOUNT */ -icalproperty* icalproperty_new_attach(struct icalattachtype v) +icalproperty* icalproperty_new_xlicclustercount(int v) { - struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTACH_PROPERTY); + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICCLUSTERCOUNT_PROPERTY); - icalproperty_set_attach((icalproperty*)impl,v); + icalproperty_set_xlicclustercount((icalproperty*)impl,v); return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_attach(struct icalattachtype v, ...) +icalproperty* icalproperty_vanew_xlicclustercount(int v, ...) { va_list args; - struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTACH_PROPERTY); + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICCLUSTERCOUNT_PROPERTY); - icalproperty_set_attach((icalproperty*)impl,v); + icalproperty_set_xlicclustercount((icalproperty*)impl,v); va_start(args,v); icalproperty_add_parameters(impl, args); @@ -2512,48 +2831,48 @@ icalproperty* icalproperty_vanew_attach(struct icalattachtype v, ...) return (icalproperty*)impl; } -void icalproperty_set_attach(icalproperty* prop, struct icalattachtype v) +void icalproperty_set_xlicclustercount(icalproperty* prop, int v) { icalvalue *value; icalerror_check_arg_rv( (prop!=0),"prop"); - value = icalvalue_new_attach(v); + value = icalvalue_new_integer(v); icalproperty_set_value(prop,value); } -struct icalattachtype icalproperty_get_attach(icalproperty* prop) +int icalproperty_get_xlicclustercount(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); value = icalproperty_get_value(prop); - return icalvalue_get_attach(value); + return icalvalue_get_integer(value); } -/* X-LIC-CLUSTERCOUNT */ +/* ATTACH */ -icalproperty* icalproperty_new_xlicclustercount(int v) +icalproperty* icalproperty_new_attach(struct icalattachtype v) { - struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICCLUSTERCOUNT_PROPERTY); + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTACH_PROPERTY); - icalproperty_set_xlicclustercount((icalproperty*)impl,v); + icalproperty_set_attach((icalproperty*)impl,v); return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_xlicclustercount(int v, ...) +icalproperty* icalproperty_vanew_attach(struct icalattachtype v, ...) { va_list args; - struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICCLUSTERCOUNT_PROPERTY); + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTACH_PROPERTY); - icalproperty_set_xlicclustercount((icalproperty*)impl,v); + icalproperty_set_attach((icalproperty*)impl,v); va_start(args,v); icalproperty_add_parameters(impl, args); @@ -2562,27 +2881,27 @@ icalproperty* icalproperty_vanew_xlicclustercount(int v, ...) return (icalproperty*)impl; } -void icalproperty_set_xlicclustercount(icalproperty* prop, int v) +void icalproperty_set_attach(icalproperty* prop, struct icalattachtype v) { icalvalue *value; icalerror_check_arg_rv( (prop!=0),"prop"); - value = icalvalue_new_integer(v); + value = icalvalue_new_attach(v); icalproperty_set_value(prop,value); } -int icalproperty_get_xlicclustercount(icalproperty* prop) +struct icalattachtype icalproperty_get_attach(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); value = icalproperty_get_value(prop); - return icalvalue_get_integer(value); + return icalvalue_get_attach(value); } /* EXRULE */ @@ -2891,6 +3210,59 @@ struct icalgeotype icalproperty_get_geo(icalproperty* prop) return icalvalue_get_geo(value); } +/* X-LIC-MIMECHARSET */ + +icalproperty* icalproperty_new_xlicmimecharset(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECHARSET_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicmimecharset((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_xlicmimecharset(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECHARSET_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicmimecharset((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_xlicmimecharset(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_string(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_xlicmimecharset(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_string(value); +} + /* COMPLETED */ icalproperty* icalproperty_new_completed(struct icaltimetype v) diff --git a/libical/src/libical/icalproperty.h b/libical/src/libical/icalproperty.h index 2cd28fe179..278c4d533f 100644 --- a/libical/src/libical/icalproperty.h +++ b/libical/src/libical/icalproperty.h @@ -5,20 +5,7 @@ $Id$ - (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. - - + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org ======================================================================*/ @@ -63,7 +50,6 @@ icalvalue* icalproperty_get_value(icalproperty* prop); void icalproperty_set_x_name(icalproperty* prop, char* name); char* icalproperty_get_x_name(icalproperty* prop); - /* Everything below this line is machine generated. Do not edit. */ /* METHOD */ @@ -72,6 +58,12 @@ icalproperty* icalproperty_vanew_method(icalproperty_method v, ...); void icalproperty_set_method(icalproperty* prop, icalproperty_method v); icalproperty_method icalproperty_get_method(icalproperty* prop); +/* X-LIC-MIMECID */ +icalproperty* icalproperty_new_xlicmimecid(char* v); +icalproperty* icalproperty_vanew_xlicmimecid(char* v, ...); +void icalproperty_set_xlicmimecid(icalproperty* prop, char* v); +char* icalproperty_get_xlicmimecid(icalproperty* prop); + /* LAST-MODIFIED */ icalproperty* icalproperty_new_lastmodified(struct icaltimetype v); icalproperty* icalproperty_vanew_lastmodified(struct icaltimetype v, ...); @@ -144,6 +136,18 @@ icalproperty* icalproperty_vanew_contact(char* v, ...); void icalproperty_set_contact(icalproperty* prop, char* v); char* icalproperty_get_contact(icalproperty* prop); +/* X-LIC-MIMECONTENTTYPE */ +icalproperty* icalproperty_new_xlicmimecontenttype(char* v); +icalproperty* icalproperty_vanew_xlicmimecontenttype(char* v, ...); +void icalproperty_set_xlicmimecontenttype(icalproperty* prop, char* v); +char* icalproperty_get_xlicmimecontenttype(icalproperty* prop); + +/* X-LIC-MIMEOPTINFO */ +icalproperty* icalproperty_new_xlicmimeoptinfo(char* v); +icalproperty* icalproperty_vanew_xlicmimeoptinfo(char* v, ...); +void icalproperty_set_xlicmimeoptinfo(icalproperty* prop, char* v); +char* icalproperty_get_xlicmimeoptinfo(icalproperty* prop); + /* RELATED-TO */ icalproperty* icalproperty_new_relatedto(char* v); icalproperty* icalproperty_vanew_relatedto(char* v, ...); @@ -162,24 +166,30 @@ icalproperty* icalproperty_vanew_comment(char* v, ...); void icalproperty_set_comment(icalproperty* prop, char* v); char* icalproperty_get_comment(icalproperty* prop); -/* TRIGGER */ -icalproperty* icalproperty_new_trigger(union icaltriggertype v); -icalproperty* icalproperty_vanew_trigger(union icaltriggertype v, ...); -void icalproperty_set_trigger(icalproperty* prop, union icaltriggertype v); -union icaltriggertype icalproperty_get_trigger(icalproperty* prop); - /* X-LIC-ERROR */ icalproperty* icalproperty_new_xlicerror(char* v); icalproperty* icalproperty_vanew_xlicerror(char* v, ...); void icalproperty_set_xlicerror(icalproperty* prop, char* v); char* icalproperty_get_xlicerror(icalproperty* prop); +/* TRIGGER */ +icalproperty* icalproperty_new_trigger(union icaltriggertype v); +icalproperty* icalproperty_vanew_trigger(union icaltriggertype v, ...); +void icalproperty_set_trigger(icalproperty* prop, union icaltriggertype v); +union icaltriggertype icalproperty_get_trigger(icalproperty* prop); + /* CLASS */ icalproperty* icalproperty_new_class(char* v); icalproperty* icalproperty_vanew_class(char* v, ...); void icalproperty_set_class(icalproperty* prop, char* v); char* icalproperty_get_class(icalproperty* prop); +/* X */ +icalproperty* icalproperty_new_x(char* v); +icalproperty* icalproperty_vanew_x(char* v, ...); +void icalproperty_set_x(icalproperty* prop, char* v); +char* icalproperty_get_x(icalproperty* prop); + /* TZOFFSETTO */ icalproperty* icalproperty_new_tzoffsetto(int v); icalproperty* icalproperty_vanew_tzoffsetto(int v, ...); @@ -192,6 +202,12 @@ icalproperty* icalproperty_vanew_transp(char* v, ...); void icalproperty_set_transp(icalproperty* prop, char* v); char* icalproperty_get_transp(icalproperty* prop); +/* X-LIC-MIMEENCODING */ +icalproperty* icalproperty_new_xlicmimeencoding(char* v); +icalproperty* icalproperty_vanew_xlicmimeencoding(char* v, ...); +void icalproperty_set_xlicmimeencoding(icalproperty* prop, char* v); +char* icalproperty_get_xlicmimeencoding(icalproperty* prop); + /* SEQUENCE */ icalproperty* icalproperty_new_sequence(int v); icalproperty* icalproperty_vanew_sequence(int v, ...); @@ -288,24 +304,30 @@ icalproperty* icalproperty_vanew_rdate(struct icalperiodtype v, ...); void icalproperty_set_rdate(icalproperty* prop, struct icalperiodtype v); struct icalperiodtype icalproperty_get_rdate(icalproperty* prop); +/* X-LIC-MIMEFILENAME */ +icalproperty* icalproperty_new_xlicmimefilename(char* v); +icalproperty* icalproperty_vanew_xlicmimefilename(char* v, ...); +void icalproperty_set_xlicmimefilename(icalproperty* prop, char* v); +char* icalproperty_get_xlicmimefilename(icalproperty* prop); + /* URL */ icalproperty* icalproperty_new_url(char* v); icalproperty* icalproperty_vanew_url(char* v, ...); void icalproperty_set_url(icalproperty* prop, char* v); char* icalproperty_get_url(icalproperty* prop); -/* ATTACH */ -icalproperty* icalproperty_new_attach(struct icalattachtype v); -icalproperty* icalproperty_vanew_attach(struct icalattachtype v, ...); -void icalproperty_set_attach(icalproperty* prop, struct icalattachtype v); -struct icalattachtype icalproperty_get_attach(icalproperty* prop); - /* X-LIC-CLUSTERCOUNT */ icalproperty* icalproperty_new_xlicclustercount(int v); icalproperty* icalproperty_vanew_xlicclustercount(int v, ...); void icalproperty_set_xlicclustercount(icalproperty* prop, int v); int icalproperty_get_xlicclustercount(icalproperty* prop); +/* ATTACH */ +icalproperty* icalproperty_new_attach(struct icalattachtype v); +icalproperty* icalproperty_vanew_attach(struct icalattachtype v, ...); +void icalproperty_set_attach(icalproperty* prop, struct icalattachtype v); +struct icalattachtype icalproperty_get_attach(icalproperty* prop); + /* EXRULE */ icalproperty* icalproperty_new_exrule(struct icalrecurrencetype v); icalproperty* icalproperty_vanew_exrule(struct icalrecurrencetype v, ...); @@ -342,6 +364,12 @@ icalproperty* icalproperty_vanew_geo(struct icalgeotype v, ...); void icalproperty_set_geo(icalproperty* prop, struct icalgeotype v); struct icalgeotype icalproperty_get_geo(icalproperty* prop); +/* X-LIC-MIMECHARSET */ +icalproperty* icalproperty_new_xlicmimecharset(char* v); +icalproperty* icalproperty_vanew_xlicmimecharset(char* v, ...); +void icalproperty_set_xlicmimecharset(icalproperty* prop, char* v); +char* icalproperty_get_xlicmimecharset(icalproperty* prop); + /* COMPLETED */ icalproperty* icalproperty_new_completed(struct icaltimetype v); icalproperty* icalproperty_vanew_completed(struct icaltimetype v, ...); diff --git a/libical/src/libical/icalrestriction.c b/libical/src/libical/icalrestriction.c index 8371e87545..be0e292d28 100644 --- a/libical/src/libical/icalrestriction.c +++ b/libical/src/libical/icalrestriction.c @@ -2,20 +2,7 @@ /* ====================================================================== File: icalrestriction.c - (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. - - + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org ======================================================================*/ #ifdef HAVE_CONFIG_H @@ -1466,7 +1453,7 @@ icalrestriction_property_record icalrestriction_property_records[] = { {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0}, {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0}, {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0}, - {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_PROPERTY,ICAL_RESTRICTION_NONE} + {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_PROPERTY,ICAL_RESTRICTION_NONE,0} }; icalrestriction_component_record icalrestriction_component_records[] = { {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0}, @@ -1596,5 +1583,5 @@ icalrestriction_component_record icalrestriction_component_records[] = { {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO,0}, {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0}, {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO,0}, - {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_COMPONENT,ICAL_RESTRICTION_NONE} + {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_COMPONENT,ICAL_RESTRICTION_NONE,0} }; diff --git a/libical/src/libical/icalrestriction.h b/libical/src/libical/icalrestriction.h index ca4beeea7b..12421d0f32 100644 --- a/libical/src/libical/icalrestriction.h +++ b/libical/src/libical/icalrestriction.h @@ -6,20 +6,19 @@ $Id$ - (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 + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org + + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + The original code is icalrestriction.h Contributions from: diff --git a/libical/src/libical/icaltypes.c b/libical/src/libical/icaltypes.c index b60333887e..c7017eb2af 100644 --- a/libical/src/libical/icaltypes.c +++ b/libical/src/libical/icaltypes.c @@ -7,20 +7,19 @@ $Locker$ - (C) COPYRIGHT 1999 Eric Busboom - http://www.softwarestudio.org + (C) COPYRIGHT 2000, 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. + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ - The original author is Eric Busboom The original code is icaltypes.c ======================================================================*/ @@ -31,9 +30,9 @@ #include "icaltypes.h" #include "icalerror.h" #include "icalmemory.h" -#include <stdlib.h> /* for malloc */ +#include <stdlib.h> /* for malloc and abs() */ #include <errno.h> /* for errno */ -#include <string.h> /* for strdup */ +#include <string.h> /* for icalmemory_strdup */ #include <assert.h> #include <limits.h> /* for SHRT_MAX */ @@ -106,9 +105,9 @@ void icalattachtype_set_url(struct icalattachtype* v, char* url) free (v->url); } - v->url = strdup(url); + v->url = icalmemory_strdup(url); - /* HACK This routine should do something if strdup returns NULL */ + /* HACK This routine should do something if icalmemory_strdup returns NULL */ } @@ -159,28 +158,6 @@ icalperiodtype_duration (struct icalperiodtype period); time_t icalperiodtype_end (struct icalperiodtype period); -struct icaltimetype -icaltimetype_from_timet(time_t v, int date) -{ - struct icaltimetype tt; - struct tm t; - time_t tm = time(&v); - -/* HACK Does not properly consider timezone */ - t = *(gmtime(&tm)); - - tt.second = t.tm_sec; - tt.minute = t.tm_min; - tt.hour = t.tm_hour; - tt.day = t.tm_mday; - tt.month = t.tm_mon + 1; - tt.year = t.tm_year+ 1900; - - tt.is_utc = 1; - tt.is_date = date; - - return tt; -} /* From Russel Steinthal */ time_t icaldurationtype_as_timet(struct icaldurationtype dur) @@ -210,7 +187,7 @@ struct icaldurationtype icaldurationtype_from_timet(time_t t) return dur; } - + void icalrecurrencetype_clear(struct icalrecurrencetype *recur) { memset(recur,ICAL_RECURRENCE_ARRAY_MAX_BYTE, @@ -218,16 +195,34 @@ void icalrecurrencetype_clear(struct icalrecurrencetype *recur) recur->week_start = ICAL_NO_WEEKDAY; recur->freq = ICAL_NO_RECURRENCE; - recur->interval = 0; - recur->until.year = 0; + recur->interval = 1; + memset(&(recur->until),0,sizeof(struct icaltimetype)); recur->count = 0; } +/* The 'day' element of icalrecurrencetype_weekday is encoded to allow +reporesentation of both the day of the week ( Monday, Tueday), but +also the Nth day of the week ( First tuesday of the month, last +thursday of the year) These routines decode the day values. + +The day's position in the period ( Nth-ness) and the numerical value +of the day are encoded together as: pos*7 + dow + */ + +enum icalrecurrencetype_weekday icalrecurrencetype_day_day_of_week(short day) +{ + return abs(day)%8; +} + +short icalrecurrencetype_day_position(short day) +{ + return (day-icalrecurrencetype_day_day_of_week(day))/8; +} + struct icalreqstattype icalreqstattype_from_string(char* str) { char *p1,*p2; - size_t len; struct icalreqstattype stat; int major, minor; @@ -235,7 +230,6 @@ struct icalreqstattype icalreqstattype_from_string(char* str) stat.code = ICAL_UNKNOWN_STATUS; stat.debug = 0; - stat.desc = 0; /* Get the status numbers */ @@ -278,7 +272,6 @@ struct icalreqstattype icalreqstattype_from_string(char* str) char* icalreqstattype_as_string(struct icalreqstattype stat) { - char format[20]; char *temp; temp = (char*)icalmemory_tmp_buffer(TEMP_MAX); diff --git a/libical/src/libical/icaltypes.h b/libical/src/libical/icaltypes.h index 77a67fae80..1130ab2457 100644 --- a/libical/src/libical/icaltypes.h +++ b/libical/src/libical/icaltypes.h @@ -4,20 +4,19 @@ 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 + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org + + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + The original code is icaltypes.h ======================================================================*/ @@ -27,6 +26,7 @@ #include <time.h> #include "icalenums.h" /* for recurrence enums */ +#include "icaltime.h" /* This type type should probably be an opaque type... */ struct icalattachtype @@ -67,21 +67,6 @@ struct icalgeotype float lon; }; -struct icaltimetype -{ - int year; - int month; - int day; - int hour; - int minute; - int second; - - int is_utc; /* 1-> time is in UTC timezone */ - - int is_date; /* 1 -> interpret this as date. */ -}; - -struct icaltimetype icaltimetype_from_timet(time_t v, int is_date); /* See RFC 2445 Section 4.3.10, RECUR Value, for an explaination of @@ -112,7 +97,7 @@ struct icalrecurrencetype short by_second[61]; short by_minute[61]; short by_hour[25]; - short by_day[8]; + short by_day[8]; /* Encoded value, see below */ short by_month_day[32]; short by_year_day[367]; short by_week_no[54]; @@ -123,6 +108,17 @@ struct icalrecurrencetype void icalrecurrencetype_clear(struct icalrecurrencetype *r); +/* The 'day' element of icalrecurrencetype_weekday is encoded to allow +reporesentation of both the day of the week ( Monday, Tueday), but +also the Nth day of the week ( First tuesday of the month, last +thursday of the year) These routines decode the day values */ + +/* 1 == Monday, etc. */ +enum icalrecurrencetype_weekday icalrecurrencetype_day_day_of_week(short day); + +/* 0 == any of day of week. 1 == first, 2 = second, -2 == second to last, etc */ +short icalrecurrencetype_day_position(short day); + struct icaldurationtype { unsigned int days; @@ -171,7 +167,7 @@ operating on a the value of a request_status property. */ struct icalreqstattype { - icalrequeststatus code; + icalrequeststatus code; char* desc; char* debug; }; diff --git a/libical/src/libical/icalvalue.c b/libical/src/libical/icalvalue.c index 79eb8d827a..db0e58efe8 100644 --- a/libical/src/libical/icalvalue.c +++ b/libical/src/libical/icalvalue.c @@ -5,21 +5,19 @@ $Id$ + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org - (C) COPYRIGHT 1999 Eric Busboom - http://www.softwarestudio.org + This program is free software; you can redistribute it and/or modify + it under the terms of either: - 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 LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ - The original author is Eric Busboom The original code is icalvalue.c Contributions from: @@ -49,7 +47,7 @@ #include <limits.h> /* for SHRT_MAX */ #if _MAC_OS_ -#include "strdup.h" +#include "icalmemory_strdup.h" #endif #define TMP_BUF_SIZE 1024 @@ -88,8 +86,10 @@ struct icalvalue_impl { /*struct icaltimetype v_datetime;*/ /*struct icaltimetype v_datetimedate;*/ - /* struct icalrecurrencetype was once a value in this - union, but it contributes 2000 bytes to every*/ + /* struct icalrecurrencetype was once included + directly ( not referenced ) in this union, but it + contributes 2000 bytes to every value, so now it is + a reference*/ struct icalrecurrencetype *v_recur; union icaltriggertype v_trigger; @@ -159,7 +159,7 @@ icalvalue* icalvalue_new_clone(icalvalue* value){ case ICAL_URI_VALUE: { if (old->data.v_string != 0) { - new->data.v_string=strdup(old->data.v_string); + new->data.v_string=icalmemory_strdup(old->data.v_string); if ( new->data.v_string == 0 ) { return 0; @@ -195,7 +195,7 @@ icalvalue* icalvalue_new_clone(icalvalue* value){ return new; } -char* strdup_and_dequote(char* str) +char* icalmemory_strdup_and_dequote(char* str) { char* p; char* out = (char*)malloc(sizeof(char) * strlen(str) +1); @@ -343,7 +343,7 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,char* str,ic case ICAL_TEXT_VALUE: { - char* dequoted_str = strdup_and_dequote(str); + char* dequoted_str = icalmemory_strdup_and_dequote(str); value = icalvalue_new_text(dequoted_str); free(dequoted_str); break; @@ -663,8 +663,11 @@ char* icalvalue_recur_as_ical_string(icalvalue* value) for(i=0; i< limit && array[i] != ICAL_RECURRENCE_ARRAY_MAX; i++){ if (j == 3) { /* BYDAY */ - icalmemory_append_string(&str,&str_p,&buf_sz, - icalenum_weekday_to_string(array[i])); + short dow = icalrecurrencetype_day_day_of_week(array[i]); + char *daystr = icalenum_weekday_to_string(dow); + + /* HACK, does not correctly handle the integer value */ + icalmemory_append_string(&str,&str_p,&buf_sz,daystr); } else { sprintf(temp,"%d",array[i]); icalmemory_append_string(&str,&str_p,&buf_sz, temp); @@ -1369,6 +1372,7 @@ icalvalue_set_attach(icalvalue* value, struct icalattachtype v) icalerror_check_value_type(value, ICAL_ATTACH_VALUE); impl = (struct icalvalue_impl*)value; + impl->data.v_attach = v; } @@ -1405,6 +1409,8 @@ icalvalue_set_binary(icalvalue* value, char* v) icalerror_check_value_type(value, ICAL_BINARY_VALUE); impl = (struct icalvalue_impl*)value; + if(impl->data.v_string!=0) {free(impl->data.v_string);} + impl->data.v_string = strdup(v); if (impl->data.v_string == 0){ @@ -1444,6 +1450,7 @@ icalvalue_set_boolean(icalvalue* value, int v) icalerror_check_value_type(value, ICAL_BOOLEAN_VALUE); impl = (struct icalvalue_impl*)value; + impl->data.v_int = v; } @@ -1480,6 +1487,8 @@ icalvalue_set_caladdress(icalvalue* value, char* v) icalerror_check_value_type(value, ICAL_CALADDRESS_VALUE); impl = (struct icalvalue_impl*)value; + if(impl->data.v_string!=0) {free(impl->data.v_string);} + impl->data.v_string = strdup(v); if (impl->data.v_string == 0){ @@ -1519,6 +1528,7 @@ icalvalue_set_date(icalvalue* value, struct icaltimetype v) icalerror_check_value_type(value, ICAL_DATE_VALUE); impl = (struct icalvalue_impl*)value; + impl->data.v_time = v; } @@ -1553,6 +1563,7 @@ icalvalue_set_datetime(icalvalue* value, struct icaltimetype v) icalerror_check_value_type(value, ICAL_DATETIME_VALUE); impl = (struct icalvalue_impl*)value; + impl->data.v_time = v; } @@ -1587,6 +1598,7 @@ icalvalue_set_datetimedate(icalvalue* value, struct icaltimetype v) icalerror_check_value_type(value, ICAL_DATETIMEDATE_VALUE); impl = (struct icalvalue_impl*)value; + impl->data.v_time = v; } @@ -1621,6 +1633,7 @@ icalvalue_set_datetimeperiod(icalvalue* value, struct icalperiodtype v) icalerror_check_value_type(value, ICAL_DATETIMEPERIOD_VALUE); impl = (struct icalvalue_impl*)value; + impl->data.v_period = v; } @@ -1655,6 +1668,7 @@ icalvalue_set_duration(icalvalue* value, struct icaldurationtype v) icalerror_check_value_type(value, ICAL_DURATION_VALUE); impl = (struct icalvalue_impl*)value; + impl->data.v_duration = v; } @@ -1689,6 +1703,7 @@ icalvalue_set_float(icalvalue* value, float v) icalerror_check_value_type(value, ICAL_FLOAT_VALUE); impl = (struct icalvalue_impl*)value; + impl->data.v_float = v; } @@ -1723,6 +1738,7 @@ icalvalue_set_geo(icalvalue* value, struct icalgeotype v) icalerror_check_value_type(value, ICAL_GEO_VALUE); impl = (struct icalvalue_impl*)value; + impl->data.v_geo = v; } @@ -1757,6 +1773,7 @@ icalvalue_set_integer(icalvalue* value, int v) icalerror_check_value_type(value, ICAL_INTEGER_VALUE); impl = (struct icalvalue_impl*)value; + impl->data.v_int = v; } @@ -1791,6 +1808,7 @@ icalvalue_set_method(icalvalue* value, icalproperty_method v) icalerror_check_value_type(value, ICAL_METHOD_VALUE); impl = (struct icalvalue_impl*)value; + impl->data.v_method = v; } @@ -1825,6 +1843,7 @@ icalvalue_set_period(icalvalue* value, struct icalperiodtype v) icalerror_check_value_type(value, ICAL_PERIOD_VALUE); impl = (struct icalvalue_impl*)value; + impl->data.v_period = v; } @@ -1837,7 +1856,6 @@ icalvalue_get_period(icalvalue* value) return ((struct icalvalue_impl*)value)->data.v_period; } - icalvalue* icalvalue_new_string (char* v) { @@ -1861,6 +1879,8 @@ icalvalue_set_string(icalvalue* value, char* v) icalerror_check_value_type(value, ICAL_STRING_VALUE); impl = (struct icalvalue_impl*)value; + if(impl->data.v_string!=0) {free(impl->data.v_string);} + impl->data.v_string = strdup(v); if (impl->data.v_string == 0){ @@ -1878,6 +1898,7 @@ icalvalue_get_string(icalvalue* value) return ((struct icalvalue_impl*)value)->data.v_string; } + icalvalue* icalvalue_new_text (char* v) { @@ -1901,6 +1922,8 @@ icalvalue_set_text(icalvalue* value, char* v) icalerror_check_value_type(value, ICAL_TEXT_VALUE); impl = (struct icalvalue_impl*)value; + if(impl->data.v_string!=0) {free(impl->data.v_string);} + impl->data.v_string = strdup(v); if (impl->data.v_string == 0){ @@ -1940,6 +1963,7 @@ icalvalue_set_time(icalvalue* value, struct icaltimetype v) icalerror_check_value_type(value, ICAL_TIME_VALUE); impl = (struct icalvalue_impl*)value; + impl->data.v_time = v; } @@ -1974,6 +1998,7 @@ icalvalue_set_trigger(icalvalue* value, union icaltriggertype v) icalerror_check_value_type(value, ICAL_TRIGGER_VALUE); impl = (struct icalvalue_impl*)value; + impl->data.v_trigger = v; } @@ -2010,6 +2035,8 @@ icalvalue_set_uri(icalvalue* value, char* v) icalerror_check_value_type(value, ICAL_URI_VALUE); impl = (struct icalvalue_impl*)value; + if(impl->data.v_string!=0) {free(impl->data.v_string);} + impl->data.v_string = strdup(v); if (impl->data.v_string == 0){ @@ -2049,6 +2076,7 @@ icalvalue_set_utcoffset(icalvalue* value, int v) icalerror_check_value_type(value, ICAL_UTCOFFSET_VALUE); impl = (struct icalvalue_impl*)value; + impl->data.v_int = v; } @@ -2085,6 +2113,8 @@ icalvalue_set_query(icalvalue* value, char* v) icalerror_check_value_type(value, ICAL_QUERY_VALUE); impl = (struct icalvalue_impl*)value; + if(impl->data.v_string!=0) {free(impl->data.v_string);} + impl->data.v_string = strdup(v); if (impl->data.v_string == 0){ diff --git a/libical/src/libical/icalvalue.h b/libical/src/libical/icalvalue.h index ec7457d6aa..18c15abaf4 100644 --- a/libical/src/libical/icalvalue.h +++ b/libical/src/libical/icalvalue.h @@ -9,20 +9,19 @@ - (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 + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org + + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + The original code is icalvalue.h ======================================================================*/ diff --git a/libical/src/libical/icalyacc.c b/libical/src/libical/icalyacc.c index 46de31370d..04999747db 100644 --- a/libical/src/libical/icalyacc.c +++ b/libical/src/libical/icalyacc.c @@ -145,20 +145,19 @@ $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 author is Eric Busboom + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org + + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + The original code is icalitip.y @@ -189,6 +188,7 @@ struct icaldurationtype duration; struct icalrecurrencetype recur; short skiplist[367]; short skippos; +int dow_pos; void copy_list(short* array, size_t size); void clear_recur(); @@ -207,7 +207,7 @@ void ical_yy_error(char *s); /* Don't know why I need this.... */ VALUEs, that is, ) correctly. */ -#line 75 "icalyacc.y" +#line 76 "icalyacc.y" typedef union { float v_float; int v_int; @@ -274,7 +274,7 @@ typedef union { -#define YYFINAL 135 +#define YYFINAL 137 #define YYFLAG -32768 #define YYNTBASE 141 @@ -329,10 +329,10 @@ static const short yyprhs[] = { 0, 42, 45, 48, 51, 54, 57, 61, 64, 68, 71, 74, 75, 77, 79, 83, 87, 91, 101, 108, 112, 116, 120, 124, 128, 132, 136, 138, 140, 142, 144, - 146, 148, 150, 152, 155, 159, 161, 165, 169, 173, - 177, 181, 185, 189, 193, 197, 201, 205, 209, 213, - 217, 221, 225, 229, 233, 237, 241, 245, 246, 250, - 253, 255, 257, 261 + 146, 148, 150, 152, 155, 159, 164, 166, 170, 174, + 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, + 218, 222, 226, 230, 234, 238, 242, 246, 250, 251, + 255, 258, 260, 262, 266 }; static const short yyrhs[] = { 142, @@ -351,33 +351,33 @@ static const short yyrhs[] = { 142, 8, 26, 0, 16, 8, 30, 0, 16, 8, 28, 0, 16, 8, 32, 0, 39, 0, 37, 0, 40, 0, 41, 0, 42, 0, 43, 0, 38, 0, 159, - 0, 3, 159, 0, 160, 11, 159, 0, 3, 0, - 161, 11, 3, 0, 33, 8, 3, 0, 36, 8, - 39, 0, 36, 8, 37, 0, 36, 8, 40, 0, - 36, 8, 41, 0, 36, 8, 42, 0, 36, 8, - 43, 0, 36, 8, 38, 0, 22, 8, 161, 0, - 19, 8, 161, 0, 18, 8, 161, 0, 17, 8, - 160, 0, 20, 8, 161, 0, 21, 8, 161, 0, - 25, 8, 161, 0, 24, 8, 161, 0, 23, 8, - 161, 0, 35, 8, 147, 0, 35, 8, 144, 0, - 34, 8, 3, 0, 0, 163, 12, 162, 0, 158, - 163, 0, 137, 0, 138, 0, 165, 4, 4, 0, - 165, 4, 4, 4, 0 + 0, 3, 159, 0, 160, 11, 159, 0, 160, 11, + 3, 159, 0, 3, 0, 161, 11, 3, 0, 33, + 8, 3, 0, 36, 8, 39, 0, 36, 8, 37, + 0, 36, 8, 40, 0, 36, 8, 41, 0, 36, + 8, 42, 0, 36, 8, 43, 0, 36, 8, 38, + 0, 22, 8, 161, 0, 19, 8, 161, 0, 18, + 8, 161, 0, 17, 8, 160, 0, 20, 8, 161, + 0, 21, 8, 161, 0, 25, 8, 161, 0, 24, + 8, 161, 0, 23, 8, 161, 0, 35, 8, 147, + 0, 35, 8, 144, 0, 34, 8, 3, 0, 0, + 163, 12, 162, 0, 158, 163, 0, 137, 0, 138, + 0, 165, 4, 4, 0, 165, 4, 4, 4, 0 }; #endif #if YYDEBUG != 0 static const short yyrline[] = { 0, - 158, 160, 161, 162, 163, 164, 165, 166, 167, 173, - 175, 178, 181, 196, 198, 201, 203, 205, 221, 222, - 224, 229, 232, 235, 239, 243, 248, 252, 257, 262, - 267, 270, 273, 277, 282, 287, 296, 317, 349, 351, - 352, 353, 354, 355, 356, 360, 362, 363, 364, 365, - 366, 367, 371, 373, 374, 377, 379, 382, 384, 385, - 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, - 396, 397, 398, 399, 400, 403, 406, 410, 412, 414, - 422, 423, 425, 431 + 159, 161, 162, 163, 164, 165, 166, 167, 168, 174, + 176, 179, 182, 197, 199, 202, 204, 206, 222, 223, + 225, 230, 233, 236, 240, 244, 249, 253, 258, 263, + 268, 271, 274, 278, 283, 288, 297, 318, 350, 352, + 353, 354, 355, 356, 357, 361, 364, 366, 368, 370, + 372, 374, 379, 381, 382, 383, 386, 388, 391, 393, + 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 412, 415, 419, 421, + 423, 431, 432, 434, 440 }; #endif @@ -415,10 +415,10 @@ static const short yyr1[] = { 0, 149, 150, 150, 150, 151, 151, 152, 152, 153, 154, 155, 155, 155, 156, 156, 156, 157, 157, 158, 158, 158, 158, 158, 158, 158, 159, 159, 159, 159, 159, - 159, 159, 160, 160, 160, 161, 161, 162, 162, 162, + 159, 159, 160, 160, 160, 160, 161, 161, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, - 162, 162, 162, 162, 162, 162, 162, 163, 163, 164, - 165, 165, 166, 166 + 162, 162, 162, 162, 162, 162, 162, 162, 163, 163, + 164, 165, 165, 166, 166 }; static const short yyr2[] = { 0, @@ -427,55 +427,55 @@ static const short yyr2[] = { 0, 2, 2, 2, 2, 2, 3, 2, 3, 2, 2, 0, 1, 1, 3, 3, 3, 9, 6, 3, 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, 1, - 1, 1, 1, 2, 3, 1, 3, 3, 3, 3, + 1, 1, 1, 2, 3, 4, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 0, 3, 2, - 1, 1, 3, 4 + 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, + 2, 1, 1, 3, 4 }; static const short yydefact[] = { 0, 9, 13, 11, 12, 0, 10, 32, 33, 1, 2, - 3, 4, 0, 5, 6, 78, 7, 0, 8, 0, - 0, 0, 80, 0, 14, 42, 40, 44, 39, 43, - 41, 45, 0, 0, 34, 36, 35, 19, 0, 83, + 3, 4, 0, 5, 6, 79, 7, 0, 8, 0, + 0, 0, 81, 0, 14, 42, 40, 44, 39, 43, + 41, 45, 0, 0, 34, 36, 35, 19, 0, 84, 15, 18, 21, 30, 0, 22, 23, 24, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 79, 84, 31, 25, 27, 29, 0, 0, + 0, 0, 80, 85, 31, 25, 27, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 33, 38, 0, 26, 0, 28, 0, - 47, 52, 46, 48, 49, 50, 51, 53, 69, 56, - 68, 67, 70, 71, 66, 74, 73, 72, 58, 77, - 13, 76, 75, 60, 65, 59, 61, 62, 63, 64, - 0, 54, 0, 0, 0, 16, 55, 57, 14, 17, - 37, 18, 0, 0, 0 + 47, 52, 46, 48, 49, 50, 51, 53, 70, 57, + 69, 68, 71, 72, 67, 75, 74, 73, 59, 78, + 13, 77, 76, 61, 66, 60, 62, 63, 64, 65, + 0, 54, 0, 0, 0, 16, 0, 55, 58, 14, + 17, 37, 56, 18, 0, 0, 0 }; -static const short yydefgoto[] = { 133, - 9, 10, 11, 42, 131, 12, 35, 36, 37, 46, +static const short yydefgoto[] = { 135, + 9, 10, 11, 42, 132, 12, 35, 36, 37, 46, 47, 48, 38, 13, 14, 15, 16, 98, 99, 101, 63, 23, 17, 18, 19 }; static const short yypact[] = { -1, --32768, -123,-32768,-32768, 1,-32768, 3, 6,-32768,-32768, --32768,-32768, -127,-32768,-32768,-32768,-32768, 64,-32768, 66, - -10, -2, 58, 67, -58,-32768,-32768,-32768,-32768,-32768, --32768,-32768, -128, 70,-32768,-32768,-32768, -55, 28, 71, --32768, -64,-32768,-32768, -68,-32768,-32768,-32768,-32768, 69, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83,-32768,-32768, 2, 89, 90,-32768, 0, 91, - 91, 91, 91, 91, 91, 91, 91, 92, 93, 94, - -14, -51,-32768,-32768,-32768, -36,-32768, -56,-32768, -7, --32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 88,-32768, - 95, 95, 95, 95, 95, 95, 95, 95,-32768,-32768, - -29,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, - 98,-32768, -7, 99, 100, -26,-32768,-32768, -58,-32768, --32768,-32768, 105, 107,-32768 +-32768, -123,-32768,-32768, 1,-32768, 3, 8,-32768,-32768, +-32768,-32768, -122,-32768,-32768,-32768,-32768, 12,-32768, 33, + -7, -2, 40, 49, -119,-32768,-32768,-32768,-32768,-32768, +-32768,-32768, -128, 51,-32768,-32768,-32768, -46, 39, 80, +-32768, -55,-32768,-32768, -100,-32768,-32768,-32768,-32768, 78, + 79, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91,-32768,-32768, 2, 97, 98,-32768, 0, 99, + 99, 99, 99, 99, 99, 99, 99, 100, 101, 102, + -11, -41,-32768,-32768,-32768, -28,-32768, -27,-32768, 28, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 96,-32768, + 103, 103, 103, 103, 103, 103, 103, 103,-32768,-32768, + -20,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 107,-32768, 7, 108, 109, -17, 28,-32768,-32768, -119, +-32768,-32768,-32768,-32768, 115, 116,-32768 }; static const short yypgoto[] = {-32768, --32768,-32768, 29, -21,-32768, 30,-32768,-32768, 84,-32768, - 45, 46,-32768,-32768, 47,-32768,-32768, -79,-32768, -17, +-32768,-32768, 37, -12,-32768, 41,-32768,-32768, 93,-32768, + 53, 55,-32768,-32768, 58,-32768,-32768, -72,-32768, 5, -32768,-32768,-32768,-32768,-32768 }; @@ -484,37 +484,37 @@ static const short yypgoto[] = {-32768, static const short yytable[] = { 1, - 33, 2, 90, 43, 82, 20, -81, 44, 21, -82, - 122, 22, 3, 4, 5, 26, 27, 28, 29, 30, - 31, 32, 114, 115, 116, 117, 118, 119, 120, 91, - 92, 93, 94, 95, 96, 97, 91, 92, 93, 94, - 95, 96, 97, 127, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 102, 103, 104, 105, 106, 107, 108, - 59, 60, 61, 62, 66, 67, 68, 24, 25, 39, - 40, 41, 45, 34, 64, 65, 69, 121, 68, 70, - 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - 81, 86, 88, 100, 109, 110, 111, 67, 123, 125, - 126, 128, 129, 130, 134, 124, 135, 132, 112, 113, - 87, 85, 89, 0, 0, 0, 0, 0, 0, 0, - 0, 49, 0, 0, 0, 0, 34, 0, 0, 6, - 0, 0, 0, 0, 0, 7, 8, -31, 83, 84 + 33, 2, 90, 43, 82, 20, -82, 44, 21, 127, + 41, -83, 3, 4, 5, 24, 22, 122, 26, 27, + 28, 29, 30, 31, 32, 114, 115, 116, 117, 118, + 119, 120, 66, 67, 68, 25, 91, 92, 93, 94, + 95, 96, 97, 91, 92, 93, 94, 95, 96, 97, + 128, 39, 40, 45, 133, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 91, 92, 93, 94, 95, 96, + 97, 59, 60, 61, 62, 102, 103, 104, 105, 106, + 107, 108, 34, 64, 65, 69, 70, 121, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 86, + 88, 100, 109, 110, 111, 67, 123, 68, 125, 126, + 129, 130, 131, 124, 136, 137, 112, 134, 87, 0, + 113, 89, 85, 0, 0, 0, 34, 0, 0, 6, + 49, 0, 0, 0, 0, 7, 8, -31, 83, 84 }; static const short yycheck[] = { 1, - 3, 3, 3, 132, 3, 129, 4, 136, 8, 4, - 90, 139, 14, 15, 16, 26, 27, 28, 29, 30, - 31, 32, 37, 38, 39, 40, 41, 42, 43, 37, - 38, 39, 40, 41, 42, 43, 37, 38, 39, 40, - 41, 42, 43, 123, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 71, 72, 73, 74, 75, 76, 77, - 33, 34, 35, 36, 133, 134, 135, 4, 3, 12, - 4, 130, 3, 129, 4, 140, 8, 129, 135, 8, - 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, - 8, 3, 3, 3, 3, 3, 3, 134, 11, 129, - 3, 3, 3, 130, 0, 11, 0, 129, 80, 80, - 66, 65, 67, -1, -1, -1, -1, -1, -1, -1, - -1, 38, -1, -1, -1, -1, 129, -1, -1, 131, - -1, -1, -1, -1, -1, 137, 138, 139, 137, 138 + 3, 3, 3, 132, 3, 129, 4, 136, 8, 3, + 130, 4, 14, 15, 16, 4, 139, 90, 26, 27, + 28, 29, 30, 31, 32, 37, 38, 39, 40, 41, + 42, 43, 133, 134, 135, 3, 37, 38, 39, 40, + 41, 42, 43, 37, 38, 39, 40, 41, 42, 43, + 123, 12, 4, 3, 127, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 37, 38, 39, 40, 41, 42, + 43, 33, 34, 35, 36, 71, 72, 73, 74, 75, + 76, 77, 129, 4, 140, 8, 8, 129, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 3, + 3, 3, 3, 3, 3, 134, 11, 135, 129, 3, + 3, 3, 130, 11, 0, 0, 80, 130, 66, -1, + 80, 67, 65, -1, -1, -1, 129, -1, -1, 131, + 38, -1, -1, -1, -1, 137, 138, 139, 137, 138 }; /* -*-C-*- Note some compilers choke on comments on `#line' lines. */ #line 3 "/usr/lib/bison.simple" @@ -1060,7 +1060,7 @@ yyreduce: switch (yyn) { case 9: -#line 167 "icalyacc.y" +#line 168 "icalyacc.y" { icalparser_yy_value = 0; icalparser_clear_flex_input(); @@ -1068,15 +1068,15 @@ case 9: ; break;} case 11: -#line 177 "icalyacc.y" +#line 178 "icalyacc.y" { icalparser_yy_value = icalvalue_new_boolean(1); ; break;} case 12: -#line 179 "icalyacc.y" +#line 180 "icalyacc.y" { icalparser_yy_value = icalvalue_new_boolean(0); ; break;} case 13: -#line 182 "icalyacc.y" +#line 183 "icalyacc.y" { struct icaltimetype stm; @@ -1092,23 +1092,23 @@ case 13: ; break;} case 14: -#line 197 "icalyacc.y" +#line 198 "icalyacc.y" {utc = 0;; break;} case 15: -#line 198 "icalyacc.y" +#line 199 "icalyacc.y" {utc = 1;; break;} case 16: -#line 202 "icalyacc.y" +#line 203 "icalyacc.y" {utc_b = 0;; break;} case 17: -#line 203 "icalyacc.y" +#line 204 "icalyacc.y" {utc_b = 1;; break;} case 18: -#line 207 "icalyacc.y" +#line 208 "icalyacc.y" { struct icaltimetype stm; stm = fill_datetime(yyvsp[-3].v_string, yyvsp[-1].v_string); @@ -1120,100 +1120,100 @@ case 18: ; break;} case 21: -#line 225 "icalyacc.y" +#line 226 "icalyacc.y" { duration.weeks = atoi(yyvsp[-1].v_string); ; break;} case 22: -#line 230 "icalyacc.y" +#line 231 "icalyacc.y" { ; break;} case 23: -#line 233 "icalyacc.y" +#line 234 "icalyacc.y" { ; break;} case 24: -#line 236 "icalyacc.y" +#line 237 "icalyacc.y" { ; break;} case 25: -#line 240 "icalyacc.y" +#line 241 "icalyacc.y" { duration.hours = atoi(yyvsp[-1].v_string); ; break;} case 26: -#line 244 "icalyacc.y" +#line 245 "icalyacc.y" { duration.hours = atoi(yyvsp[-2].v_string); ; break;} case 27: -#line 249 "icalyacc.y" +#line 250 "icalyacc.y" { duration.minutes = atoi(yyvsp[-1].v_string); ; break;} case 28: -#line 253 "icalyacc.y" +#line 254 "icalyacc.y" { duration.minutes = atoi(yyvsp[-2].v_string); ; break;} case 29: -#line 258 "icalyacc.y" +#line 259 "icalyacc.y" { duration.seconds = atoi(yyvsp[-1].v_string); ; break;} case 30: -#line 263 "icalyacc.y" +#line 264 "icalyacc.y" { duration.days = atoi(yyvsp[-1].v_string); ; break;} case 31: -#line 268 "icalyacc.y" +#line 269 "icalyacc.y" { ; break;} case 32: -#line 271 "icalyacc.y" +#line 272 "icalyacc.y" { ; break;} case 33: -#line 274 "icalyacc.y" +#line 275 "icalyacc.y" { ; break;} case 34: -#line 278 "icalyacc.y" +#line 279 "icalyacc.y" { icalparser_yy_value = icalvalue_new_duration(duration); memset(&duration,0, sizeof(duration)); ; break;} case 35: -#line 283 "icalyacc.y" +#line 284 "icalyacc.y" { icalparser_yy_value = icalvalue_new_duration(duration); memset(&duration,0, sizeof(duration)); ; break;} case 36: -#line 288 "icalyacc.y" +#line 289 "icalyacc.y" { icalparser_yy_value = icalvalue_new_duration(duration); memset(&duration,0, sizeof(duration)); ; break;} case 37: -#line 297 "icalyacc.y" +#line 298 "icalyacc.y" { struct icalperiodtype p; @@ -1236,7 +1236,7 @@ case 37: ; break;} case 38: -#line 318 "icalyacc.y" +#line 319 "icalyacc.y" { struct icalperiodtype p; @@ -1265,175 +1265,194 @@ case 38: ; break;} case 39: -#line 350 "icalyacc.y" +#line 351 "icalyacc.y" {clear_recur();recur.freq = ICAL_SECONDLY_RECURRENCE;; break;} case 40: -#line 351 "icalyacc.y" +#line 352 "icalyacc.y" {clear_recur();recur.freq = ICAL_MINUTELY_RECURRENCE;; break;} case 41: -#line 352 "icalyacc.y" +#line 353 "icalyacc.y" {clear_recur();recur.freq = ICAL_HOURLY_RECURRENCE;; break;} case 42: -#line 353 "icalyacc.y" +#line 354 "icalyacc.y" {clear_recur();recur.freq = ICAL_DAILY_RECURRENCE;; break;} case 43: -#line 354 "icalyacc.y" +#line 355 "icalyacc.y" {clear_recur();recur.freq = ICAL_WEEKLY_RECURRENCE;; break;} case 44: -#line 355 "icalyacc.y" +#line 356 "icalyacc.y" {clear_recur();recur.freq = ICAL_MONTHLY_RECURRENCE;; break;} case 45: -#line 356 "icalyacc.y" +#line 357 "icalyacc.y" {clear_recur();recur.freq = ICAL_YEARLY_RECURRENCE;; break;} case 46: -#line 361 "icalyacc.y" -{ skiplist[skippos]=ICAL_SUNDAY_WEEKDAY; if( skippos<8) skippos++;; +#line 362 "icalyacc.y" +{ skiplist[skippos]=ICAL_SUNDAY_WEEKDAY+8*dow_pos; + if( skippos<8) skippos++;; break;} case 47: -#line 362 "icalyacc.y" -{ skiplist[skippos]=ICAL_MONDAY_WEEKDAY;if( skippos<8) skippos++;; +#line 364 "icalyacc.y" +{ skiplist[skippos]=ICAL_MONDAY_WEEKDAY+8*dow_pos; + if( skippos<8) skippos++;; break;} case 48: -#line 363 "icalyacc.y" -{ skiplist[skippos]=ICAL_TUESDAY_WEEKDAY;if( skippos<8) skippos++;; +#line 366 "icalyacc.y" +{ skiplist[skippos]=ICAL_TUESDAY_WEEKDAY+8*dow_pos; + if( skippos<8) skippos++;; break;} case 49: -#line 364 "icalyacc.y" -{ skiplist[skippos]=ICAL_WEDNESDAY_WEEKDAY;if( skippos<8) skippos++;; +#line 368 "icalyacc.y" +{ skiplist[skippos]=ICAL_WEDNESDAY_WEEKDAY+8*dow_pos; + if( skippos<8) skippos++;; break;} case 50: -#line 365 "icalyacc.y" -{ skiplist[skippos]=ICAL_THURSDAY_WEEKDAY;if( skippos<8) skippos++;; +#line 370 "icalyacc.y" +{ skiplist[skippos]=ICAL_THURSDAY_WEEKDAY+8*dow_pos; + if( skippos<8) skippos++;; break;} case 51: -#line 366 "icalyacc.y" -{ skiplist[skippos]=ICAL_FRIDAY_WEEKDAY;if( skippos<8) skippos++;; +#line 372 "icalyacc.y" +{ skiplist[skippos]=ICAL_FRIDAY_WEEKDAY+8*dow_pos; + if( skippos<8) skippos++;; break;} case 52: -#line 367 "icalyacc.y" -{ skiplist[skippos]=ICAL_SATURDAY_WEEKDAY;if( skippos<8) skippos++;; +#line 374 "icalyacc.y" +{ skiplist[skippos]=ICAL_SATURDAY_WEEKDAY+8*dow_pos; + if( skippos<8) skippos++;; + break;} +case 53: +#line 380 "icalyacc.y" +{dow_pos = 0; break;} case 54: -#line 373 "icalyacc.y" -{ ; +#line 381 "icalyacc.y" +{ dow_pos = atoi(yyvsp[-1].v_string); + break;} +case 55: +#line 382 "icalyacc.y" +{dow_pos = 0; break;} case 56: -#line 378 "icalyacc.y" -{ skiplist[skippos] = atoi(yyvsp[0].v_string); skippos++;; +#line 383 "icalyacc.y" +{ dow_pos = atoi(yyvsp[-1].v_string); break;} case 57: -#line 379 "icalyacc.y" -{ skiplist[skippos] = atoi(yyvsp[0].v_string); if (skippos<367) skippos++;; +#line 387 "icalyacc.y" +{ skiplist[skippos] = atoi(yyvsp[0].v_string); skippos++;; break;} case 58: -#line 383 "icalyacc.y" -{recur.interval = atoi(yyvsp[0].v_string);; +#line 388 "icalyacc.y" +{ skiplist[skippos] = atoi(yyvsp[0].v_string); if (skippos<367) skippos++;; break;} case 59: -#line 384 "icalyacc.y" -{recur.week_start = ICAL_SUNDAY_WEEKDAY;; +#line 392 "icalyacc.y" +{recur.interval = atoi(yyvsp[0].v_string);; break;} case 60: -#line 385 "icalyacc.y" -{recur.week_start = ICAL_MONDAY_WEEKDAY;; +#line 393 "icalyacc.y" +{recur.week_start = ICAL_SUNDAY_WEEKDAY;; break;} case 61: -#line 386 "icalyacc.y" -{recur.week_start = ICAL_TUESDAY_WEEKDAY;; +#line 394 "icalyacc.y" +{recur.week_start = ICAL_MONDAY_WEEKDAY;; break;} case 62: -#line 387 "icalyacc.y" -{recur.week_start = ICAL_WEDNESDAY_WEEKDAY;; +#line 395 "icalyacc.y" +{recur.week_start = ICAL_TUESDAY_WEEKDAY;; break;} case 63: -#line 388 "icalyacc.y" -{recur.week_start = ICAL_THURSDAY_WEEKDAY;; +#line 396 "icalyacc.y" +{recur.week_start = ICAL_WEDNESDAY_WEEKDAY;; break;} case 64: -#line 389 "icalyacc.y" -{recur.week_start = ICAL_FRIDAY_WEEKDAY;; +#line 397 "icalyacc.y" +{recur.week_start = ICAL_THURSDAY_WEEKDAY;; break;} case 65: -#line 390 "icalyacc.y" -{recur.week_start = ICAL_SATURDAY_WEEKDAY;; +#line 398 "icalyacc.y" +{recur.week_start = ICAL_FRIDAY_WEEKDAY;; break;} case 66: -#line 391 "icalyacc.y" -{copy_list(recur.by_second,60);; +#line 399 "icalyacc.y" +{recur.week_start = ICAL_SATURDAY_WEEKDAY;; break;} case 67: -#line 392 "icalyacc.y" -{copy_list(recur.by_minute,60);; +#line 400 "icalyacc.y" +{copy_list(recur.by_second,60);; break;} case 68: -#line 393 "icalyacc.y" -{copy_list(recur.by_hour,24);; +#line 401 "icalyacc.y" +{copy_list(recur.by_minute,60);; break;} case 69: -#line 394 "icalyacc.y" -{copy_list(recur.by_day,7);; +#line 402 "icalyacc.y" +{copy_list(recur.by_hour,24);; break;} case 70: -#line 395 "icalyacc.y" -{copy_list(recur.by_month,12);; +#line 403 "icalyacc.y" +{copy_list(recur.by_day,7);; break;} case 71: -#line 396 "icalyacc.y" -{copy_list(recur.by_month_day,31);; +#line 404 "icalyacc.y" +{copy_list(recur.by_month,12);; break;} case 72: -#line 397 "icalyacc.y" -{copy_list(recur.by_year_day,366);; +#line 405 "icalyacc.y" +{copy_list(recur.by_month_day,31);; break;} case 73: -#line 398 "icalyacc.y" -{copy_list(recur.by_week_no,53);; +#line 406 "icalyacc.y" +{copy_list(recur.by_year_day,366);; break;} case 74: -#line 399 "icalyacc.y" -{copy_list(recur.by_set_pos,366);; +#line 407 "icalyacc.y" +{copy_list(recur.by_week_no,53);; break;} case 75: -#line 401 "icalyacc.y" +#line 408 "icalyacc.y" +{copy_list(recur.by_set_pos,366);; + break;} +case 76: +#line 410 "icalyacc.y" { recur.until = icalvalue_get_datetime(icalparser_yy_value); icalvalue_free(icalparser_yy_value); icalparser_yy_value=0;; break;} -case 76: -#line 404 "icalyacc.y" +case 77: +#line 413 "icalyacc.y" { recur.until = icalvalue_get_date(icalparser_yy_value); icalvalue_free(icalparser_yy_value); icalparser_yy_value=0;; break;} -case 77: -#line 407 "icalyacc.y" +case 78: +#line 416 "icalyacc.y" { recur.count = atoi(yyvsp[0].v_string); ; break;} -case 80: -#line 416 "icalyacc.y" +case 81: +#line 425 "icalyacc.y" { icalparser_yy_value = icalvalue_new_recur(recur); ; break;} -case 81: -#line 422 "icalyacc.y" +case 82: +#line 431 "icalyacc.y" { utcsign = 1; ; break;} -case 82: -#line 423 "icalyacc.y" +case 83: +#line 432 "icalyacc.y" { utcsign = -1; ; break;} -case 83: -#line 427 "icalyacc.y" +case 84: +#line 436 "icalyacc.y" { icalparser_yy_value = icalvalue_new_utcoffset( utcsign * (yyvsp[-1].v_int*3600) + (yyvsp[0].v_int*60) ); ; break;} -case 84: -#line 432 "icalyacc.y" +case 85: +#line 441 "icalyacc.y" { icalparser_yy_value = icalvalue_new_utcoffset(utcsign * (yyvsp[-2].v_int*3600) + (yyvsp[-1].v_int*60) +(yyvsp[0].v_int)); ; @@ -1660,7 +1679,7 @@ yyerrhandle: } return 1; } -#line 438 "icalyacc.y" +#line 447 "icalyacc.y" diff --git a/libical/src/libical/icalyacc.y b/libical/src/libical/icalyacc.y index 1fe2a737e9..0917daf371 100644 --- a/libical/src/libical/icalyacc.y +++ b/libical/src/libical/icalyacc.y @@ -6,7 +6,7 @@ DESCRIPTION: - $Id: icalyacc.y,v 1.4 2000/06/06 22:48:09 alves Exp $ + $Id: icalyacc.y,v 1.5 2000/08/24 20:12:04 jpr Exp $ $Locker: $ (C) COPYRIGHT 1999 Eric Busboom @@ -53,6 +53,7 @@ struct icaldurationtype duration; struct icalrecurrencetype recur; short skiplist[367]; short skippos; +int dow_pos; void copy_list(short* array, size_t size); void clear_recur(); @@ -358,20 +359,28 @@ recur_start: weekday: - SU { skiplist[skippos]=ICAL_SUNDAY_WEEKDAY; if( skippos<8) skippos++;} - | MO { skiplist[skippos]=ICAL_MONDAY_WEEKDAY;if( skippos<8) skippos++;} - | TU { skiplist[skippos]=ICAL_TUESDAY_WEEKDAY;if( skippos<8) skippos++;} - | WE { skiplist[skippos]=ICAL_WEDNESDAY_WEEKDAY;if( skippos<8) skippos++;} - | TH { skiplist[skippos]=ICAL_THURSDAY_WEEKDAY;if( skippos<8) skippos++;} - | FR { skiplist[skippos]=ICAL_FRIDAY_WEEKDAY;if( skippos<8) skippos++;} - | SA { skiplist[skippos]=ICAL_SATURDAY_WEEKDAY;if( skippos<8) skippos++;} + SU { skiplist[skippos]=ICAL_SUNDAY_WEEKDAY+8*dow_pos; + if( skippos<8) skippos++;} + | MO { skiplist[skippos]=ICAL_MONDAY_WEEKDAY+8*dow_pos; + if( skippos<8) skippos++;} + | TU { skiplist[skippos]=ICAL_TUESDAY_WEEKDAY+8*dow_pos; + if( skippos<8) skippos++;} + | WE { skiplist[skippos]=ICAL_WEDNESDAY_WEEKDAY+8*dow_pos; + if( skippos<8) skippos++;} + | TH { skiplist[skippos]=ICAL_THURSDAY_WEEKDAY+8*dow_pos; + if( skippos<8) skippos++;} + | FR { skiplist[skippos]=ICAL_FRIDAY_WEEKDAY+8*dow_pos; + if( skippos<8) skippos++;} + | SA { skiplist[skippos]=ICAL_SATURDAY_WEEKDAY+8*dow_pos; + if( skippos<8) skippos++;} ; weekday_list: - weekday - | DIGITS weekday { } /* HACK Incorectly handles int in BYDAY */ - | weekday_list COMMA weekday + weekday {dow_pos = 0}; + | DIGITS weekday { dow_pos = atoi($1)} + | weekday_list COMMA weekday {dow_pos = 0}; + | weekday_list COMMA DIGITS weekday { dow_pos = atoi($3)} recur_list: diff --git a/libical/src/libical/pvl.c b/libical/src/libical/pvl.c index d5225a541e..94eaeac874 100644 --- a/libical/src/libical/pvl.c +++ b/libical/src/libical/pvl.c @@ -3,18 +3,7 @@ CREATOR: eric November, 1995 - (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. + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org ======================================================================*/ #ifdef HAVE_CONFIG_H @@ -505,6 +494,10 @@ pvl_remove(pvl_list l,pvl_elem e) data = E->d; + E->prior = 0; + E->next = 0; + E->d = 0; + free(E); return data; diff --git a/libical/src/libical/pvl.h b/libical/src/libical/pvl.h index 8113f7495a..40ca516e9f 100644 --- a/libical/src/libical/pvl.h +++ b/libical/src/libical/pvl.h @@ -3,27 +3,9 @@ CREATOR: eric November, 1995 - (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. - + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org ======================================================================*/ -/* - struct pvl_elem_t - - This type is private. Always use pvl_elem instead - - */ #ifndef __PVL_H__ #define __PVL_H__ @@ -31,6 +13,14 @@ typedef void* pvl_list; typedef void* pvl_elem; +/* + struct pvl_elem_t + + This type is private. Always use pvl_elem instead. The struct would + not even appear in this header except to make code in the USE_MACROS + blocks work + + */ typedef struct pvl_elem_t { int MAGIC; /* Magic Identifier */ diff --git a/libical/src/libicalss/Makefile.am b/libical/src/libicalss/Makefile.am index 01a7fa4d9c..e4431cb492 100644 --- a/libical/src/libicalss/Makefile.am +++ b/libical/src/libicalss/Makefile.am @@ -6,16 +6,27 @@ lib_LIBRARIES = libicalss.a libicalss_a_SOURCES =\ icalcalendar.c \ icalcalendar.h \ - icalcluster.c \ - icalcluster.h \ - icalstore.c \ - icalstore.h + icalset.h \ + icalset.c \ + icalfileset.c \ + icalfileset.h \ + icalfilesetimpl.h \ + icaldirset.c \ + icaldirset.h \ + icalcsdb.h \ + icalcstp.h \ + icalgauge.h \ + icalgauge.c include_HEADERS =\ icalcalendar.h \ - icalcluster.h \ - icalstore.h - + icalset.h + icalfileset.h \ + icalfilesetimpl.h \ + icaldirset.h \ + icalcsdb.h \ + icalcstp.h \ + icalgauge.h INCLUDES = \ -I ../libical/ \ diff --git a/libical/src/libicalss/icalcalendar.c b/libical/src/libicalss/icalcalendar.c index 0f2231b1d7..e63b5330ad 100644 --- a/libical/src/libicalss/icalcalendar.c +++ b/libical/src/libicalss/icalcalendar.c @@ -1,27 +1,22 @@ -/* -*- 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 + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ ======================================================================*/ @@ -32,7 +27,9 @@ #include "icalcalendar.h" -#include "icalcluster.h" +#include "icalset.h" +#include "icalfileset.h" +#include "icaldirset.h" #include <limits.h> #include <sys/stat.h> /* For mkdir, stat */ #include <sys/types.h> /* For mkdir */ @@ -52,8 +49,8 @@ struct icalcalendar_impl char* dir; icalcomponent* freebusy; icalcomponent* properties; - icalstore* booked; - icalstore* incoming; + icalset* booked; + icalset* incoming; }; struct icalcalendar_impl* icalcalendar_new_impl() @@ -132,19 +129,19 @@ void icalcalendar_free(icalcalendar* calendar) } if (impl->freebusy !=0){ - icalcluster_free(impl->freebusy); + icalfileset_free(impl->freebusy); } if (impl->properties !=0){ - icalcluster_free(impl->properties); + icalfileset_free(impl->properties); } if (impl->booked !=0){ - icalstore_free(impl->booked); + icaldirset_free(impl->booked); } if (impl->incoming !=0){ - icalstore_free(impl->incoming); + icaldirset_free(impl->incoming); } impl->dir = 0; @@ -186,7 +183,7 @@ int icalcalendar_ownlock(icalcalendar* calendar) return 0; } -icalstore* icalcalendar_get_booked(icalcalendar* calendar) +icalset* icalcalendar_get_booked(icalcalendar* calendar) { struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar; char dir[PATH_MAX]; @@ -200,7 +197,7 @@ icalstore* icalcalendar_get_booked(icalcalendar* calendar) if (impl->booked == 0){ icalerror_clear_errno(); - impl->booked = icalstore_new(dir); + impl->booked = icaldirset_new(dir); assert(icalerrno == ICAL_NO_ERROR); } @@ -208,7 +205,7 @@ icalstore* icalcalendar_get_booked(icalcalendar* calendar) } -icalcluster* icalcalendar_get_incoming(icalcalendar* calendar) +icalset* icalcalendar_get_incoming(icalcalendar* calendar) { char path[PATH_MAX]; struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar; @@ -220,13 +217,13 @@ icalcluster* icalcalendar_get_incoming(icalcalendar* calendar) strcat(path,INCOMING_FILE); if (impl->properties == 0){ - impl->properties = icalcluster_new(path); + impl->properties = icalfileset_new(path); } return impl->properties; } -icalcluster* icalcalendar_get_properties(icalcalendar* calendar) +icalset* icalcalendar_get_properties(icalcalendar* calendar) { char path[PATH_MAX]; struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar; @@ -238,13 +235,13 @@ icalcluster* icalcalendar_get_properties(icalcalendar* calendar) strcat(path,PROP_FILE); if (impl->properties == 0){ - impl->properties = icalcluster_new(path); + impl->properties = icalfileset_new(path); } return impl->properties; } -icalcluster* icalcalendar_get_freebusy(icalcalendar* calendar) +icalset* icalcalendar_get_freebusy(icalcalendar* calendar) { char path[PATH_MAX]; struct icalcalendar_impl *impl = (struct icalcalendar_impl*)calendar; @@ -257,7 +254,7 @@ icalcluster* icalcalendar_get_freebusy(icalcalendar* calendar) if (impl->freebusy == 0){ - impl->freebusy = icalcluster_new(path); + impl->freebusy = icalfileset_new(path); } return impl->freebusy; diff --git a/libical/src/libicalss/icalcalendar.h b/libical/src/libicalss/icalcalendar.h index 90e7b33c22..f07457c60d 100644 --- a/libical/src/libicalss/icalcalendar.h +++ b/libical/src/libicalss/icalcalendar.h @@ -7,19 +7,19 @@ $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. - + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org + + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + The LGPL as published by the Free Software Foundation, version + 2.1, available at: http://www.fsf.org/copyleft/lesser.html + + Or: + + The Mozilla Public License Version 1.0. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + The Original Code is eric. The Initial Developer of the Original Code is Eric Busboom @@ -30,12 +30,11 @@ #define ICALCALENDAR_H #include "ical.h" -#include "icalstore.h" -#include "icalcluster.h" +#include "icalset.h" /* icalcalendar * Routines for storing calendar data in a file system. The calendar - * has two icalstores, one for incoming components and one for booked + * has two icaldirsets, 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 */ @@ -53,13 +52,13 @@ int icalcalendar_islocked(icalcalendar* calendar); int icalcalendar_ownlock(icalcalendar* calendar); -icalstore* icalcalendar_get_booked(icalcalendar* calendar); +icalset* icalcalendar_get_booked(icalcalendar* calendar); -icalcluster* icalcalendar_get_incoming(icalcalendar* calendar); +icalset* icalcalendar_get_incoming(icalcalendar* calendar); -icalcluster* icalcalendar_get_properties(icalcalendar* calendar); +icalset* icalcalendar_get_properties(icalcalendar* calendar); -icalcluster* icalcalendar_get_freebusy(icalcalendar* calendar); +icalset* icalcalendar_get_freebusy(icalcalendar* calendar); #endif /* !ICALCALENDAR_H */ diff --git a/libical/src/test/Makefile.am b/libical/src/test/Makefile.am index 81ffff8c39..bd76fca669 100644 --- a/libical/src/test/Makefile.am +++ b/libical/src/test/Makefile.am @@ -1,7 +1,7 @@ -noinst_PROGRAMS = usecases copycluster regression parser findobj storage stow +noinst_PROGRAMS = copycluster regression parser findobj storage stow testvcal recur testmime -LDADD = ../libical/libical.a ../libicalss/libicalss.a +LDADD = ../libical/libical.a ../libicalss/libicalss.a ../libicalvcal/libicalvcal.a INCLUDES = \ -I . \ -I $(srcdir) \ @@ -9,11 +9,15 @@ INCLUDES = \ -I $(srcdir)/../libical \ -I../libicalss \ -I $(srcdir)/../libicalss + -I../libicalvcal \ + -I $(srcdir)/../libicalvcal findobj_SOURCES = findobj.c -usecases_SOURCES = usecases.c copycluster_SOURCES = copycluster.c regression_SOURCES = regression.c parser_SOURCES = icaltestparser.c storage_SOURCES = storage.c -stow_SOURCES = stow.c
\ No newline at end of file +stow_SOURCES = stow.c +testvcal_SOURCES =testvcal.c +recur_SOURCES = recur.c +test_mime = testmime.c
\ No newline at end of file diff --git a/libical/src/test/Makefile.in b/libical/src/test/Makefile.in deleted file mode 100644 index 8a7cf257c3..0000000000 --- a/libical/src/test/Makefile.in +++ /dev/null @@ -1,385 +0,0 @@ -# Makefile.in generated automatically by automake 1.4 from Makefile.am - -# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc. -# This Makefile.in is free software; the Free Software Foundation -# gives unlimited permission to copy and/or distribute it, -# with or without modifications, as long as this notice is preserved. - -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY, to the extent permitted by law; without -# even the implied warranty of MERCHANTABILITY or FITNESS FOR A -# PARTICULAR PURPOSE. - - -SHELL = @SHELL@ - -srcdir = @srcdir@ -top_srcdir = @top_srcdir@ -VPATH = @srcdir@ -prefix = @prefix@ -exec_prefix = @exec_prefix@ - -bindir = @bindir@ -sbindir = @sbindir@ -libexecdir = @libexecdir@ -datadir = @datadir@ -sysconfdir = @sysconfdir@ -sharedstatedir = @sharedstatedir@ -localstatedir = @localstatedir@ -libdir = @libdir@ -infodir = @infodir@ -mandir = @mandir@ -includedir = @includedir@ -oldincludedir = /usr/include - -DESTDIR = - -pkgdatadir = $(datadir)/@PACKAGE@ -pkglibdir = $(libdir)/@PACKAGE@ -pkgincludedir = $(includedir)/@PACKAGE@ - -top_builddir = ../.. - -ACLOCAL = @ACLOCAL@ -AUTOCONF = @AUTOCONF@ -AUTOMAKE = @AUTOMAKE@ -AUTOHEADER = @AUTOHEADER@ - -INSTALL = @INSTALL@ -INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(AM_INSTALL_PROGRAM_FLAGS) -INSTALL_DATA = @INSTALL_DATA@ -INSTALL_SCRIPT = @INSTALL_SCRIPT@ -transform = @program_transform_name@ - -NORMAL_INSTALL = : -PRE_INSTALL = : -POST_INSTALL = : -NORMAL_UNINSTALL = : -PRE_UNINSTALL = : -POST_UNINSTALL = : -host_alias = @host_alias@ -host_triplet = @host@ -AR = @AR@ -AS = @AS@ -CC = @CC@ -DLLTOOL = @DLLTOOL@ -LEX = @LEX@ -LIBTOOL = @LIBTOOL@ -LN_S = @LN_S@ -MAKEINFO = @MAKEINFO@ -OBJDUMP = @OBJDUMP@ -PACKAGE = @PACKAGE@ -RANLIB = @RANLIB@ -VERSION = @VERSION@ -YACC = @YACC@ - -noinst_PROGRAMS = usecases copycluster regression parser findobj storage stow - -LDADD = ../libical/libical.a ../libicalss/libicalss.a -INCLUDES = -I . -I $(srcdir) -I../libical -I $(srcdir)/../libical -I../libicalss -I $(srcdir)/../libicalss - - -findobj_SOURCES = findobj.c -usecases_SOURCES = usecases.c -copycluster_SOURCES = copycluster.c -regression_SOURCES = regression.c -parser_SOURCES = icaltestparser.c -storage_SOURCES = storage.c -stow_SOURCES = stow.c -mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs -CONFIG_HEADER = ../../config.h -CONFIG_CLEAN_FILES = -PROGRAMS = $(noinst_PROGRAMS) - - -DEFS = @DEFS@ -I. -I$(srcdir) -I../.. -CPPFLAGS = @CPPFLAGS@ -LDFLAGS = @LDFLAGS@ -LIBS = @LIBS@ -usecases_OBJECTS = usecases.o -usecases_LDADD = $(LDADD) -usecases_DEPENDENCIES = ../libical/libical.a ../libicalss/libicalss.a -usecases_LDFLAGS = -copycluster_OBJECTS = copycluster.o -copycluster_LDADD = $(LDADD) -copycluster_DEPENDENCIES = ../libical/libical.a \ -../libicalss/libicalss.a -copycluster_LDFLAGS = -regression_OBJECTS = regression.o -regression_LDADD = $(LDADD) -regression_DEPENDENCIES = ../libical/libical.a ../libicalss/libicalss.a -regression_LDFLAGS = -parser_OBJECTS = icaltestparser.o -parser_LDADD = $(LDADD) -parser_DEPENDENCIES = ../libical/libical.a ../libicalss/libicalss.a -parser_LDFLAGS = -findobj_OBJECTS = findobj.o -findobj_LDADD = $(LDADD) -findobj_DEPENDENCIES = ../libical/libical.a ../libicalss/libicalss.a -findobj_LDFLAGS = -storage_OBJECTS = storage.o -storage_LDADD = $(LDADD) -storage_DEPENDENCIES = ../libical/libical.a ../libicalss/libicalss.a -storage_LDFLAGS = -stow_OBJECTS = stow.o -stow_LDADD = $(LDADD) -stow_DEPENDENCIES = ../libical/libical.a ../libicalss/libicalss.a -stow_LDFLAGS = -CFLAGS = @CFLAGS@ -COMPILE = $(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -CCLD = $(CC) -LINK = $(LIBTOOL) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ -DIST_COMMON = Makefile.am Makefile.in - - -DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST) - -TAR = gtar -GZIP_ENV = --best -DEP_FILES = .deps/copycluster.P .deps/findobj.P .deps/icaltestparser.P \ -.deps/regression.P .deps/storage.P .deps/stow.P .deps/usecases.P -SOURCES = $(usecases_SOURCES) $(copycluster_SOURCES) $(regression_SOURCES) $(parser_SOURCES) $(findobj_SOURCES) $(storage_SOURCES) $(stow_SOURCES) -OBJECTS = $(usecases_OBJECTS) $(copycluster_OBJECTS) $(regression_OBJECTS) $(parser_OBJECTS) $(findobj_OBJECTS) $(storage_OBJECTS) $(stow_OBJECTS) - -all: all-redirect -.SUFFIXES: -.SUFFIXES: .S .c .lo .o .s -$(srcdir)/Makefile.in: Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4) - cd $(top_srcdir) && $(AUTOMAKE) --gnu src/test/Makefile - -Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status $(BUILT_SOURCES) - cd $(top_builddir) \ - && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status - - -mostlyclean-noinstPROGRAMS: - -clean-noinstPROGRAMS: - -test -z "$(noinst_PROGRAMS)" || rm -f $(noinst_PROGRAMS) - -distclean-noinstPROGRAMS: - -maintainer-clean-noinstPROGRAMS: - -.s.o: - $(COMPILE) -c $< - -.S.o: - $(COMPILE) -c $< - -mostlyclean-compile: - -rm -f *.o core *.core - -clean-compile: - -distclean-compile: - -rm -f *.tab.c - -maintainer-clean-compile: - -.s.lo: - $(LIBTOOL) --mode=compile $(COMPILE) -c $< - -.S.lo: - $(LIBTOOL) --mode=compile $(COMPILE) -c $< - -mostlyclean-libtool: - -rm -f *.lo - -clean-libtool: - -rm -rf .libs _libs - -distclean-libtool: - -maintainer-clean-libtool: - -usecases: $(usecases_OBJECTS) $(usecases_DEPENDENCIES) - @rm -f usecases - $(LINK) $(usecases_LDFLAGS) $(usecases_OBJECTS) $(usecases_LDADD) $(LIBS) - -copycluster: $(copycluster_OBJECTS) $(copycluster_DEPENDENCIES) - @rm -f copycluster - $(LINK) $(copycluster_LDFLAGS) $(copycluster_OBJECTS) $(copycluster_LDADD) $(LIBS) - -regression: $(regression_OBJECTS) $(regression_DEPENDENCIES) - @rm -f regression - $(LINK) $(regression_LDFLAGS) $(regression_OBJECTS) $(regression_LDADD) $(LIBS) - -parser: $(parser_OBJECTS) $(parser_DEPENDENCIES) - @rm -f parser - $(LINK) $(parser_LDFLAGS) $(parser_OBJECTS) $(parser_LDADD) $(LIBS) - -findobj: $(findobj_OBJECTS) $(findobj_DEPENDENCIES) - @rm -f findobj - $(LINK) $(findobj_LDFLAGS) $(findobj_OBJECTS) $(findobj_LDADD) $(LIBS) - -storage: $(storage_OBJECTS) $(storage_DEPENDENCIES) - @rm -f storage - $(LINK) $(storage_LDFLAGS) $(storage_OBJECTS) $(storage_LDADD) $(LIBS) - -stow: $(stow_OBJECTS) $(stow_DEPENDENCIES) - @rm -f stow - $(LINK) $(stow_LDFLAGS) $(stow_OBJECTS) $(stow_LDADD) $(LIBS) - -tags: TAGS - -ID: $(HEADERS) $(SOURCES) $(LISP) - list='$(SOURCES) $(HEADERS)'; \ - unique=`for i in $$list; do echo $$i; done | \ - awk ' { files[$$0] = 1; } \ - END { for (i in files) print i; }'`; \ - here=`pwd` && cd $(srcdir) \ - && mkid -f$$here/ID $$unique $(LISP) - -TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) $(LISP) - tags=; \ - here=`pwd`; \ - list='$(SOURCES) $(HEADERS)'; \ - unique=`for i in $$list; do echo $$i; done | \ - awk ' { files[$$0] = 1; } \ - END { for (i in files) print i; }'`; \ - test -z "$(ETAGS_ARGS)$$unique$(LISP)$$tags" \ - || (cd $(srcdir) && etags $(ETAGS_ARGS) $$tags $$unique $(LISP) -o $$here/TAGS) - -mostlyclean-tags: - -clean-tags: - -distclean-tags: - -rm -f TAGS ID - -maintainer-clean-tags: - -distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir) - -subdir = src/test - -distdir: $(DISTFILES) - here=`cd $(top_builddir) && pwd`; \ - top_distdir=`cd $(top_distdir) && pwd`; \ - distdir=`cd $(distdir) && pwd`; \ - cd $(top_srcdir) \ - && $(AUTOMAKE) --include-deps --build-dir=$$here --srcdir-name=$(top_srcdir) --output-dir=$$top_distdir --gnu src/test/Makefile - @for file in $(DISTFILES); do \ - d=$(srcdir); \ - if test -d $$d/$$file; then \ - cp -pr $$d/$$file $(distdir)/$$file; \ - else \ - test -f $(distdir)/$$file \ - || ln $$d/$$file $(distdir)/$$file 2> /dev/null \ - || cp -p $$d/$$file $(distdir)/$$file || :; \ - fi; \ - done - -DEPS_MAGIC := $(shell mkdir .deps > /dev/null 2>&1 || :) - --include $(DEP_FILES) - -mostlyclean-depend: - -clean-depend: - -distclean-depend: - -rm -rf .deps - -maintainer-clean-depend: - -%.o: %.c - @echo '$(COMPILE) -c $<'; \ - $(COMPILE) -Wp,-MD,.deps/$(*F).pp -c $< - @-cp .deps/$(*F).pp .deps/$(*F).P; \ - tr ' ' '\012' < .deps/$(*F).pp \ - | sed -e 's/^\\$$//' -e '/^$$/ d' -e '/:$$/ d' -e 's/$$/ :/' \ - >> .deps/$(*F).P; \ - rm .deps/$(*F).pp - -%.lo: %.c - @echo '$(LTCOMPILE) -c $<'; \ - $(LTCOMPILE) -Wp,-MD,.deps/$(*F).pp -c $< - @-sed -e 's/^\([^:]*\)\.o[ ]*:/\1.lo \1.o :/' \ - < .deps/$(*F).pp > .deps/$(*F).P; \ - tr ' ' '\012' < .deps/$(*F).pp \ - | sed -e 's/^\\$$//' -e '/^$$/ d' -e '/:$$/ d' -e 's/$$/ :/' \ - >> .deps/$(*F).P; \ - rm -f .deps/$(*F).pp -info-am: -info: info-am -dvi-am: -dvi: dvi-am -check-am: all-am -check: check-am -installcheck-am: -installcheck: installcheck-am -install-exec-am: -install-exec: install-exec-am - -install-data-am: -install-data: install-data-am - -install-am: all-am - @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am -install: install-am -uninstall-am: -uninstall: uninstall-am -all-am: Makefile $(PROGRAMS) -all-redirect: all-am -install-strip: - $(MAKE) $(AM_MAKEFLAGS) AM_INSTALL_PROGRAM_FLAGS=-s install -installdirs: - - -mostlyclean-generic: - -clean-generic: - -distclean-generic: - -rm -f Makefile $(CONFIG_CLEAN_FILES) - -rm -f config.cache config.log stamp-h stamp-h[0-9]* - -maintainer-clean-generic: -mostlyclean-am: mostlyclean-noinstPROGRAMS mostlyclean-compile \ - mostlyclean-libtool mostlyclean-tags mostlyclean-depend \ - mostlyclean-generic - -mostlyclean: mostlyclean-am - -clean-am: clean-noinstPROGRAMS clean-compile clean-libtool clean-tags \ - clean-depend clean-generic mostlyclean-am - -clean: clean-am - -distclean-am: distclean-noinstPROGRAMS distclean-compile \ - distclean-libtool distclean-tags distclean-depend \ - distclean-generic clean-am - -rm -f libtool - -distclean: distclean-am - -maintainer-clean-am: maintainer-clean-noinstPROGRAMS \ - maintainer-clean-compile maintainer-clean-libtool \ - maintainer-clean-tags maintainer-clean-depend \ - maintainer-clean-generic distclean-am - @echo "This command is intended for maintainers to use;" - @echo "it deletes files that may require special tools to rebuild." - -maintainer-clean: maintainer-clean-am - -.PHONY: mostlyclean-noinstPROGRAMS distclean-noinstPROGRAMS \ -clean-noinstPROGRAMS maintainer-clean-noinstPROGRAMS \ -mostlyclean-compile distclean-compile clean-compile \ -maintainer-clean-compile mostlyclean-libtool distclean-libtool \ -clean-libtool maintainer-clean-libtool tags mostlyclean-tags \ -distclean-tags clean-tags maintainer-clean-tags distdir \ -mostlyclean-depend distclean-depend clean-depend \ -maintainer-clean-depend info-am info dvi-am dvi check check-am \ -installcheck-am installcheck install-exec-am install-exec \ -install-data-am install-data install-am install uninstall-am uninstall \ -all-redirect all-am all installdirs mostlyclean-generic \ -distclean-generic clean-generic maintainer-clean-generic clean \ -mostlyclean distclean maintainer-clean - - -# Tell versions [3.59,3.63) of GNU make to not export all variables. -# Otherwise a system limit (for SysV at least) may be exceeded. -.NOEXPORT: diff --git a/libical/src/test/copycluster.c b/libical/src/test/copycluster.c index b059130c13..11bd94c62d 100644 --- a/libical/src/test/copycluster.c +++ b/libical/src/test/copycluster.c @@ -27,7 +27,7 @@ #include <stdio.h> /* for printf */ #include "ical.h" -#include "icalcluster.h" +#include "icalfileset.h" #include <errno.h> #include <string.h> /* For strerror */ #include "icalrestriction.h" @@ -41,7 +41,7 @@ void usage(char* arg0) { int main(int c, char *argv[]){ - icalcluster *clusterin, *clusterout; + icalfileset *clusterin, *clusterout; icalcomponent *itr; int count=0; int tostdout = 0; @@ -55,7 +55,7 @@ int main(int c, char *argv[]){ tostdout = 1; } - clusterin = icalcluster_new(argv[1]); + clusterin = icalfileset_new(argv[1]); if (clusterin == 0){ printf("Could not open input cluster \"%s\"",argv[1]); @@ -64,7 +64,7 @@ int main(int c, char *argv[]){ } if (!tostdout){ - clusterout = icalcluster_new(argv[2]); + clusterout = icalfileset_new(argv[2]); if (clusterout == 0){ printf("Could not open output cluster \"%s\"\n",argv[2]); exit(1); @@ -72,10 +72,10 @@ int main(int c, char *argv[]){ } - for (itr = icalcluster_get_first_component(clusterin, + for (itr = icalfileset_get_first_component(clusterin, ICAL_ANY_COMPONENT); itr != 0; - itr = icalcluster_get_next_component(clusterin, + itr = icalfileset_get_next_component(clusterin, ICAL_ANY_COMPONENT)){ icalrestriction_check(itr); @@ -87,7 +87,7 @@ int main(int c, char *argv[]){ printf("--------------\n%s\n",icalcomponent_as_ical_string(itr)); } else { - icalcluster_add_component(clusterout, + icalfileset_add_component(clusterout, icalcomponent_new_clone(itr)); } @@ -101,11 +101,11 @@ int main(int c, char *argv[]){ printf("Transfered %d components\n",count); - icalcluster_free(clusterin); + icalfileset_free(clusterin); if (!tostdout){ - icalcluster_mark(clusterout); - icalcluster_free(clusterout); + icalfileset_mark(clusterout); + icalfileset_free(clusterout); } return 0; diff --git a/libical/src/test/findobj.c b/libical/src/test/findobj.c index e7ec59169a..c31101c33d 100644 --- a/libical/src/test/findobj.c +++ b/libical/src/test/findobj.c @@ -28,6 +28,7 @@ #include <stdio.h> /* for printf */ #include "ical.h" #include "icalcalendar.h" +#include "icaldirset.h" #include <errno.h> #include <string.h> /* For strerror */ #include "icalrestriction.h" @@ -41,7 +42,7 @@ void usage(char* arg0) { int main(int c, char *argv[]){ icalcalendar *cal; - icalstore *booked; + icaldirset *booked; icalcomponent *itr; if(c < 2 || c > 3){ @@ -59,7 +60,7 @@ int main(int c, char *argv[]){ booked = icalcalendar_get_booked(cal); - itr = icalstore_fetch(booked,argv[2]); + itr = icaldirset_fetch(booked,argv[2]); if(itr != 0){ diff --git a/libical/src/test/icaltestparser.c b/libical/src/test/icaltestparser.c index 98dbcff94f..71f91b641f 100644 --- a/libical/src/test/icaltestparser.c +++ b/libical/src/test/icaltestparser.c @@ -91,7 +91,6 @@ char* read_stream(char *s, size_t size, void *d) int main(int argc, char* argv[]) { - int lineno = 0; char* line; FILE* stream; icalcomponent *c; @@ -120,5 +119,5 @@ int main(int argc, char* argv[]) } while ( line != 0); - -} + return 0; + } diff --git a/libical/src/test/regression.c b/libical/src/test/regression.c index 7b1606d432..dc6a5301f1 100644 --- a/libical/src/test/regression.c +++ b/libical/src/test/regression.c @@ -34,11 +34,12 @@ #include <stdio.h> /* for printf */ #include <time.h> /* for time() */ #include "icalmemory.h" -#include "icalstore.h" -#include "icalcluster.h" #include "icalerror.h" #include "icalrestriction.h" #include "icalcalendar.h" +#include "icalgauge.h" +#include "icaldirset.h" +#include "icalfileset.h" /* This example creates and minipulates the ical object that appears * in rfc 2445, page 137 */ @@ -92,8 +93,8 @@ icalcomponent* create_simple_component() icalcomponent* calendar; struct icalperiodtype rtime; - rtime.start = icaltimetype_from_timet( time(0),0); - rtime.end = icaltimetype_from_timet( time(0),0); + rtime.start = icaltime_from_timet( time(0),0,0); + rtime.end = icaltime_from_timet( time(0),0,0); rtime.end.hour++; @@ -122,12 +123,12 @@ icalcomponent* create_new_component() icalcomponent* timezone; icalcomponent* tzc; icalcomponent* event; - struct icaltimetype atime = icaltimetype_from_timet( time(0),0); + struct icaltimetype atime = icaltime_from_timet( time(0),0,0); struct icalperiodtype rtime; icalproperty* property; - rtime.start = icaltimetype_from_timet( time(0),0); - rtime.end = icaltimetype_from_timet( time(0),0); + rtime.start = icaltime_from_timet( time(0),0,0); + rtime.end = icaltime_from_timet( time(0),0,0); rtime.end.hour++; @@ -331,11 +332,11 @@ icalcomponent* create_new_component_with_va_args() { icalcomponent* calendar; - struct icaltimetype atime = icaltimetype_from_timet( time(0),0); + struct icaltimetype atime = icaltime_from_timet( time(0),0,0); struct icalperiodtype rtime; - rtime.start = icaltimetype_from_timet( time(0),0); - rtime.end = icaltimetype_from_timet( time(0),0); + rtime.start = icaltime_from_timet( time(0),0,0); + rtime.end = icaltime_from_timet( time(0),0,0); rtime.end.hour++; @@ -524,9 +525,9 @@ void test_values() icalvalue_free(copy); - v = icalvalue_new_date(icaltimetype_from_timet( time(0),0)); + v = icalvalue_new_date(icaltime_from_timet( time(0),0,0)); printf("date 1: %s\n",icalvalue_as_ical_string(v)); - icalvalue_set_date(v,icaltimetype_from_timet( time(0)+3600,0)); + icalvalue_set_date(v,icaltime_from_timet( time(0)+3600,0,0)); printf("date 2: %s\n",icalvalue_as_ical_string(v)); copy = icalvalue_new_clone(v); @@ -662,6 +663,7 @@ void test_components() void test_memory() { size_t bufsize = 256; + int i; char *p; char S1[] = "1) When in the Course of human events, "; @@ -682,8 +684,7 @@ void test_memory() char *f, *b1, *b2, *b3, *b4, *b5, *b6, *b7, *b8; - #define BUFSIZE 1024 - +#define BUFSIZE 1024 f = icalmemory_new_buffer(bufsize); p = f; @@ -737,32 +738,61 @@ void test_memory() free(f); bufsize = 4; + f = icalmemory_new_buffer(bufsize); + + memset(f,0,bufsize); p = f; icalmemory_append_char(&f, &p, &bufsize, 'a'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'b'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'c'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'd'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'e'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'f'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'g'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'h'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'i'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'j'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'a'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'b'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'c'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'd'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'e'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'f'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'g'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'h'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'i'); + printf("Char-by-Char buffer: %s\n", f); icalmemory_append_char(&f, &p, &bufsize, 'j'); - printf("Char-by-Char buffer: %s\n", f); + + for(i=0; i<100; i++){ + f = icalmemory_tmp_buffer(bufsize); + + assert(f!=0); + memset(f,0,bufsize); + sprintf(f,"%d",i); + } } @@ -772,14 +802,14 @@ int test_store() icalcomponent *c, *gauge; icalerrorenum error; icalcomponent *next, *itr; - icalcluster* cluster; + icalfileset* cluster; struct icalperiodtype rtime; - icalstore *s = icalstore_new("store"); + icaldirset *s = icaldirset_new("store"); int i; - rtime.start = icaltimetype_from_timet( time(0),0); + rtime.start = icaltime_from_timet( time(0),0,0); - cluster = icalcluster_new("clusterin.vcd"); + cluster = icalfileset_new("clusterin.vcd"); if (cluster == 0){ printf("Failed to create cluster: %s\n",icalerror_strerror(icalerrno)); @@ -799,10 +829,10 @@ int test_store() rtime.end = rtime.start; rtime.end.hour++; - for (itr = icalcluster_get_first_component(cluster, + for (itr = icalfileset_get_first_component(cluster, ICAL_ANY_COMPONENT); itr != 0; - itr = icalcluster_get_next_component(cluster, + itr = icalfileset_get_next_component(cluster, ICAL_ANY_COMPONENT)){ icalcomponent *clone; icalproperty *p; @@ -847,7 +877,7 @@ int test_store() printf("\n----------\n%s\n---------\n",icalcomponent_as_ical_string(clone)); - error = icalstore_add_component(s,clone); + error = icaldirset_add_component(s,clone); assert(icalerrno == ICAL_NO_ERROR); @@ -877,15 +907,15 @@ int test_store() #if 0 - icalstore_select(s,gauge); + icaldirset_select(s,gauge); - for(c = icalstore_first(s); c != 0; c = icalstore_next(s)){ + for(c = icaldirset_first(s); c != 0; c = icaldirset_next(s)){ printf("Got one! (%d)\n", count++); if (c != 0){ printf("%s", icalcomponent_as_ical_string(c));; - if (icalstore_store(s2,c) == 0){ + if (icaldirset_store(s2,c) == 0){ printf("Failed to write!\n"); } icalcomponent_free(c); @@ -895,18 +925,18 @@ int test_store() } - icalstore_free(s2); + icaldirset_free(s2); #endif - for(c = icalstore_get_first_component(s); + for(c = icaldirset_get_first_component(s,ICAL_ANY_COMPONENT); c != 0; c = next){ - next = icalstore_get_next_component(s); + next = icaldirset_get_next_component(s,ICAL_ANY_COMPONENT); if (c != 0){ - /*icalstore_remove_component(s,c);*/ + /*icaldirset_remove_component(s,c);*/ printf("%s", icalcomponent_as_ical_string(c));; } else { printf("Failed to get component\n"); @@ -915,7 +945,7 @@ int test_store() } - icalstore_free(s); + icaldirset_free(s); return 0; } @@ -976,7 +1006,7 @@ int test_compare() printf("%s",icalcomponent_as_ical_string(gauge)); - printf("%d\n",icalstore_test(c,gauge)); + printf("%d\n",icalgauge_test(c,gauge)); return 0; } @@ -984,13 +1014,13 @@ int test_compare() void test_restriction() { icalcomponent *comp; - struct icaltimetype atime = icaltimetype_from_timet( time(0),0); + struct icaltimetype atime = icaltime_from_timet( time(0),0,0); int valid; struct icalperiodtype rtime; - rtime.start = icaltimetype_from_timet( time(0),0); - rtime.end = icaltimetype_from_timet( time(0),0); + rtime.start = icaltime_from_timet( time(0),0,0); + rtime.end = icaltime_from_timet( time(0),0,0); rtime.end.hour++; @@ -1097,11 +1127,11 @@ void test_restriction() void test_calendar() { icalcomponent *comp; - icalcluster *c; - icalstore *s; + icalfileset *c; + icaldirset *s; icalcalendar* calendar = icalcalendar_new("calendar"); icalerrorenum error; - struct icaltimetype atime = icaltimetype_from_timet( time(0),0); + struct icaltimetype atime = icaltime_from_timet( time(0),0,0); comp = icalcomponent_vanew( ICAL_VEVENT_COMPONENT, @@ -1125,13 +1155,13 @@ void test_calendar() s = icalcalendar_get_booked(calendar); - error = icalstore_add_component(s,comp); + error = icaldirset_add_component(s,comp); assert(error == ICAL_NO_ERROR); c = icalcalendar_get_properties(calendar); - error = icalcluster_add_component(c,icalcomponent_new_clone(comp)); + error = icalfileset_add_component(c,icalcomponent_new_clone(comp)); assert(error == ICAL_NO_ERROR); @@ -1170,6 +1200,19 @@ void test_recur() } +void test_recur_expansion() +{ + + icalvalue *v; + + v = icalvalue_new_from_string(ICAL_RECUR_VALUE, + "FREQ=YEARLY;UNTIL=123456T123456;INTERVAL=2;BYMONTH=1;BYDAY=SU;BYHOUR=8,9;BYMINUTE=30"); + + printf("%s\n",icalvalue_as_ical_string(v)); + + icalrecurrencetype_test(); +} + void test_duration() { @@ -1278,19 +1321,213 @@ void test_requeststat() } +void test_time() +{ + struct icaltimetype ictt; + time_t tt,tt2; + icalvalue *v; + short day_of_week,start_day_of_week, day_of_year; + + + tt = time(0); + + printf("System time is: %s\n",ctime(&tt)); + + ictt = icaltime_from_timet(tt,0,0); + + v = icalvalue_new_datetime(ictt); + + printf("System time from libical: %s\n",icalvalue_as_ical_string(v)); + + tt2 = icaltime_as_timet(ictt); + printf("Converted back to libc: %s\n",ctime(&tt2)); + + + ictt.year++; + tt2 = icaltime_as_timet(ictt); + printf("Add a year: %s\n",ctime(&tt2)); + + ictt.month+=13; + tt2 = icaltime_as_timet(ictt); + printf("Add 13 months: %s\n",ctime(&tt2)); + + ictt.second+=90; + tt2 = icaltime_as_timet(ictt); + printf("Add 90 seconds: %s\n",ctime(&tt2)); + + ictt = icaltime_from_timet(tt,0,0); + + + day_of_week = icaltime_day_of_week(ictt); + start_day_of_week = icaltime_start_doy_of_week(ictt); + day_of_year = icaltime_day_of_year(ictt); + + printf("Today is day of week %d, day of year %d\n",day_of_week,day_of_year); + printf("Week started n doy of %d\n",start_day_of_week); + + +} + +void test_iterators() +{ + icalcomponent *c,*inner,*next; + icalcompiter i; + + c= icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalcomponent_vanew(ICAL_VEVENT_COMPONENT, + icalproperty_vanew_version("1"),0), + icalcomponent_vanew(ICAL_VEVENT_COMPONENT, + icalproperty_vanew_version("2"),0), + icalcomponent_vanew(ICAL_VEVENT_COMPONENT, + icalproperty_vanew_version("3"),0), + icalcomponent_vanew(ICAL_VEVENT_COMPONENT, + icalproperty_vanew_version("4"),0), + icalcomponent_vanew(ICAL_VTODO_COMPONENT, + icalproperty_vanew_version("5"),0), + icalcomponent_vanew(ICAL_VJOURNAL_COMPONENT, + icalproperty_vanew_version("6"),0), + icalcomponent_vanew(ICAL_VEVENT_COMPONENT, + icalproperty_vanew_version("7"),0), + icalcomponent_vanew(ICAL_VJOURNAL_COMPONENT, + icalproperty_vanew_version("8"),0), + icalcomponent_vanew(ICAL_VJOURNAL_COMPONENT, + icalproperty_vanew_version("9"),0), + icalcomponent_vanew(ICAL_VJOURNAL_COMPONENT, + icalproperty_vanew_version("10"),0), + 0); + + printf("1: "); + + /* List all of the VEVENTS */ + for(i = icalcomponent_begin_component(c,ICAL_VEVENT_COMPONENT); + icalcompiter_deref(&i)!= 0; icalcompiter_next(&i)){ + + icalcomponent *this = icalcompiter_deref(&i); + + icalproperty *p = + icalcomponent_get_first_property(this, + ICAL_VERSION_PROPERTY); + char* s = icalproperty_get_version(p); + + printf("%s ",s); + + } + + printf("\n2: "); + +#if 0 + for(inner = icalcomponent_get_first_component(c,ICAL_VEVENT_COMPONENT); + inner != 0; + inner = next){ + + next = icalcomponent_get_next_component(c,ICAL_VEVENT_COMPONENT); + + icalcomponent_remove_component(c,inner); + + icalcomponent_free(inner); + } +#endif + + /* Delete all of the VEVENTS */ + /* reset iterator */ + icalcomponent_get_first_component(c,ICAL_VEVENT_COMPONENT); + + while((inner=icalcomponent_get_current_component(c)) != 0 ){ + if(icalcomponent_isa(inner) == ICAL_VEVENT_COMPONENT){ + icalcomponent_remove_component(c,inner); + } else { + icalcomponent_get_next_component(c,ICAL_VEVENT_COMPONENT); + } + } + + + + /* List all remaining components */ + for(inner = icalcomponent_get_first_component(c,ICAL_ANY_COMPONENT); + inner != 0; + inner = icalcomponent_get_next_component(c,ICAL_ANY_COMPONENT)){ + + + icalproperty *p = + icalcomponent_get_first_property(inner,ICAL_VERSION_PROPERTY); + + char* s = icalproperty_get_version(p); + + printf("%s ",s); + } + + printf("\n3: "); + + + /* Remove all remaining components */ + for(inner = icalcomponent_get_first_component(c,ICAL_ANY_COMPONENT); + inner != 0; + inner = next){ + + icalcomponent *this; + icalproperty *p; + char* s; + next = icalcomponent_get_next_component(c,ICAL_ANY_COMPONENT); + + p=icalcomponent_get_first_property(inner,ICAL_VERSION_PROPERTY); + s = icalproperty_get_version(p); + printf("rem:%s ",s); + + icalcomponent_remove_component(c,inner); + + this = icalcomponent_get_current_component(c); + + if(this != 0){ + p=icalcomponent_get_first_property(this,ICAL_VERSION_PROPERTY); + s = icalproperty_get_version(p); + printf("next:%s; ",s); + } + + icalcomponent_free(inner); + } + + printf("\n4: "); + + + /* List all remaining components */ + for(inner = icalcomponent_get_first_component(c,ICAL_ANY_COMPONENT); + inner != 0; + inner = icalcomponent_get_next_component(c,ICAL_ANY_COMPONENT)){ + + icalproperty *p = + icalcomponent_get_first_property(inner,ICAL_VERSION_PROPERTY); + + char* s = icalproperty_get_version(p); + + printf("%s ",s); + } + + printf("\n"); +} + int main(int argc, char *argv[]) { + printf("\n------------Test Memory---------------\n"); + test_memory(); + +exit(0); + + + printf("\n------------Test Iterators-----------\n"); + test_iterators(); + + + printf("\n------------Test time----------------\n"); + test_time(); printf("\n------------Test Restriction---------------\n"); test_restriction(); - exit(0); - printf("\n------------Test request status-------\n"); test_requeststat(); - printf("\n------------Test strings---------------\n"); test_strings(); @@ -1303,9 +1540,6 @@ int main(int argc, char *argv[]) printf("\n------------Test Compare---------------\n"); test_compare(); - printf("\n------------Test Memory---------------\n"); - test_memory(); - printf("\n------------Test Values---------------\n"); test_values(); diff --git a/libical/src/test/storage.c b/libical/src/test/storage.c index f6d0dd69e5..d53001b574 100644 --- a/libical/src/test/storage.c +++ b/libical/src/test/storage.c @@ -34,14 +34,13 @@ #include <stdio.h> /* for printf */ #include <time.h> /* for time() */ #include "icalmemory.h" -#include "icalstore.h" -#include "icalcluster.h" +#include "icaldirset.h" +#include "icalfileset.h" #include "icalerror.h" #include "icalrestriction.h" #include "icalcalendar.h" -/* This example creates and minipulates the ical object that appears - * in rfc 2445, page 137 */ +#define OUTPUT_FILE "filesetout.ics" char str[] = "BEGIN:VCALENDAR\n\ PRODID:\"-//RDU Software//NONSGML HandCal//EN\"\n\ @@ -106,29 +105,31 @@ END:VCALENDAR\n\ "; -void test_cluster() +void test_fileset() { - icalcluster *cin, *cout; + icalfileset *cout; int month = 0; int count=0; struct icaltimetype start, end; icalcomponent *c,*clone, *itr; - start = icaltimetype_from_timet( time(0),0); + start = icaltime_from_timet( time(0),0,0); end = start; end.hour++; - cout = icalcluster_new("clusterout.ics"); + cout = icalfileset_new(OUTPUT_FILE); assert(cout != 0); c = icalparser_parse_string(str2); assert(c != 0); - for(month = 1; month < 2; month++){ + /* Add data to the file */ + + for(month = 1; month < 10; month++){ icalcomponent *event; icalproperty *dtstart, *dtend; - cout = icalcluster_new("clusterout.ics"); + cout = icalfileset_new(OUTPUT_FILE); assert(cout != 0); start.month = month; @@ -147,10 +148,10 @@ void test_cluster() assert(dtend!=0); icalproperty_set_dtend(dtend,end); - icalcluster_add_component(cout,clone); - icalcluster_commit(cout); + icalfileset_add_component(cout,clone); + icalfileset_commit(cout); - icalcluster_free(cout); + icalfileset_free(cout); } @@ -158,13 +159,13 @@ void test_cluster() /* Print them out */ - cout = icalcluster_new("clusterout.ics"); + cout = icalfileset_new(OUTPUT_FILE); assert(cout != 0); - for (itr = icalcluster_get_first_component(cout, + for (itr = icalfileset_get_first_component(cout, ICAL_ANY_COMPONENT); itr != 0; - itr = icalcluster_get_next_component(cout, + itr = icalfileset_get_next_component(cout, ICAL_ANY_COMPONENT)){ icalcomponent *event; @@ -184,34 +185,34 @@ void test_cluster() /* Remove all of them */ - icalcluster_free(cout); + icalfileset_free(cout); - cout = icalcluster_new("clusterout.ics"); + cout = icalfileset_new(OUTPUT_FILE); assert(cout != 0); - for (itr = icalcluster_get_first_component(cout, + for (itr = icalfileset_get_first_component(cout, ICAL_ANY_COMPONENT); itr != 0; - itr = icalcluster_get_next_component(cout, + itr = icalfileset_get_next_component(cout, ICAL_ANY_COMPONENT)){ - icalcluster_remove_component(cout, itr); + icalfileset_remove_component(cout, itr); } - icalcluster_free(cout); + icalfileset_free(cout); /* Print them out again */ - cout = icalcluster_new("clusterout.ics"); + cout = icalfileset_new(OUTPUT_FILE); assert(cout != 0); count =0; - for (itr = icalcluster_get_first_component(cout, + for (itr = icalfileset_get_first_component(cout, ICAL_ANY_COMPONENT); itr != 0; - itr = icalcluster_get_next_component(cout, + itr = icalfileset_get_next_component(cout, ICAL_ANY_COMPONENT)){ icalcomponent *event; @@ -229,29 +230,29 @@ void test_cluster() } - icalcluster_free(cout); + icalfileset_free(cout); } -int test_store() +int test_dirset() { icalcomponent *c, *gauge; icalerrorenum error; - icalcomponent *next, *itr; - icalcluster* cluster; + icalcomponent *itr; + icalfileset* cluster; struct icalperiodtype rtime; - icalstore *s = icalstore_new("store"); + icaldirset *s = icaldirset_new("store"); int i; assert(s != 0); - rtime.start = icaltimetype_from_timet( time(0),0); + rtime.start = icaltime_from_timet( time(0),0,0); - cluster = icalcluster_new("clusterout.ics"); + cluster = icalfileset_new(OUTPUT_FILE); assert(cluster != 0); @@ -268,10 +269,10 @@ int test_store() rtime.end = rtime.start; rtime.end.hour++; - for (itr = icalcluster_get_first_component(cluster, + for (itr = icalfileset_get_first_component(cluster, ICAL_ANY_COMPONENT); itr != 0; - itr = icalcluster_get_next_component(cluster, + itr = icalfileset_get_next_component(cluster, ICAL_ANY_COMPONENT)){ icalcomponent *clone, *inner; icalproperty *p; @@ -316,7 +317,8 @@ int test_store() printf("\n----------\n%s\n---------\n",icalcomponent_as_ical_string(inner)); - error = icalstore_add_component(s,inner); + error = icaldirset_add_component(s, + icalcomponent_new_clone(itr)); assert(icalerrno == ICAL_NO_ERROR); @@ -346,15 +348,15 @@ int test_store() #if 0 - icalstore_select(s,gauge); + icaldirset_select(s,gauge); - for(c = icalstore_first(s); c != 0; c = icalstore_next(s)){ + for(c = icaldirset_first(s); c != 0; c = icaldirset_next(s)){ printf("Got one! (%d)\n", count++); if (c != 0){ printf("%s", icalcomponent_as_ical_string(c));; - if (icalstore_store(s2,c) == 0){ + if (icaldirset_store(s2,c) == 0){ printf("Failed to write!\n"); } icalcomponent_free(c); @@ -364,38 +366,43 @@ int test_store() } - icalstore_free(s2); + icaldirset_free(s2); #endif - for(c = icalstore_get_first_component(s); + for(c = icaldirset_get_first_component(s,ICAL_ANY_COMPONENT); c != 0; - c = next){ - - next = icalstore_get_next_component(s); + c = icaldirset_get_next_component(s,ICAL_ANY_COMPONENT)){ if (c != 0){ - /*icalstore_remove_component(s,c);*/ printf("%s", icalcomponent_as_ical_string(c));; } else { printf("Failed to get component\n"); } + } + + /* Remove all of the components */ + i=0; + while((c=icaldirset_get_current_component(s)) != 0 ){ + i++; + icaldirset_remove_component(s,c); } + - icalstore_free(s); + icaldirset_free(s); return 0; } void test_calendar() { icalcomponent *comp; - icalcluster *c; - icalstore *s; + icalfileset *c; + icaldirset *s; icalcalendar* calendar = icalcalendar_new("calendar"); icalerrorenum error; - struct icaltimetype atime = icaltimetype_from_timet( time(0),0); + struct icaltimetype atime = icaltime_from_timet( time(0),0,0); comp = icalcomponent_vanew( ICAL_VEVENT_COMPONENT, @@ -419,13 +426,13 @@ void test_calendar() s = icalcalendar_get_booked(calendar); - error = icalstore_add_component(s,comp); + error = icaldirset_add_component(s,comp); assert(error == ICAL_NO_ERROR); c = icalcalendar_get_properties(calendar); - error = icalcluster_add_component(c,icalcomponent_new_clone(comp)); + error = icalfileset_add_component(c,icalcomponent_new_clone(comp)); assert(error == ICAL_NO_ERROR); @@ -437,16 +444,14 @@ void test_calendar() int main(int argc, char *argv[]) { +/* printf("\n------------Test File Set---------------\n"); + test_fileset(); */ - printf("\n------------Test Cluster---------------\n"); - test_cluster(); + printf("\n------------Test Dir Set---------------\n"); + test_dirset(); #if 0 - printf("\n------------Test Store---------------\n"); - test_store(); - - printf("\n------------Test Calendar---------------\n"); test_calendar(); diff --git a/libical/src/test/stow.c b/libical/src/test/stow.c index d7629855c5..f742b417a5 100644 --- a/libical/src/test/stow.c +++ b/libical/src/test/stow.c @@ -33,35 +33,85 @@ #include <stdlib.h> #include <sys/utsname.h> /* for uname */ #include <sys/stat.h> /* for stat */ -#include <unistd.h> /* for stat, getpid */ +#include <unistd.h> /* for stat, getpid, getopt */ +#include <pwd.h> /* For getpwent */ +#include <sys/types.h> /* For getpwent */ +#include <ctype.h> /* for tolower */ #include "ical.h" #include "icalcalendar.h" - +#include "icalfileset.h" +#include "icalmime.h" char* program_name; #define TMPSIZE 2048 +#define SENDMAIL "/usr/lib/sendmail -t" enum options { - STORE_IN_DIR, + STORE_IN_FILE, STORE_IN_DB, - INPUT_IS_EMAIL, + INPUT_IS_MIME, INPUT_IS_ICAL, INPUT_FROM_STDIN, - INPUT_FROM_FILE + INPUT_FROM_FILE, + ERRORS_TO_STDOUT, + ERRORS_TO_ORGANIZER }; struct options_struct { enum options storage; enum options input_type; + enum options input_source; + enum options errors; char* input_file; - char* input_text; char* calid; - char* caldir; + char* output_file; +}; + + +enum file_type +{ + ERROR, + NO_FILE, + DIRECTORY, + REGULAR, + OTHER }; +enum file_type test_file(char *path) +{ + struct stat sbuf; + enum file_type type; + + errno = 0; + + /* Check if the path already exists and if it is a directory*/ + if (stat(path,&sbuf) != 0){ + + /* A file by the given name does not exist, or there was + another error */ + if(errno == ENOENT) + { + type = NO_FILE; + } else { + type = ERROR; + } + + } else { + /* A file by the given name exists, but is it a directory? */ + + if (S_ISDIR(sbuf.st_mode)){ + type = DIRECTORY; + } else if(S_ISREG(sbuf.st_mode)){ + type = REGULAR; + } else { + type = OTHER; + } + } + return type; +} char* lowercase(char* str) { @@ -79,23 +129,33 @@ char* lowercase(char* str) return new; } +#if 0 char* get_local_attendee(struct options_struct *opt) { char attendee[PATH_MAX]; - char* user = getenv("USER"); - struct utsname uts; + if(opt->calid){ - uname(&uts); + strncpy(attendee,opt->calid,PATH_MAX); - /* HACK nodename may not be a fully qualified domain name */ - snprintf(attendee,PATH_MAX,"%s@%s",user,uts.nodename); + } else { + + char* user = getenv("USER"); + struct utsname uts; + uname(&utget_option); + /* HACK nodename may not be a fully qualified domain name */ + snprintf(attendee,PATH_MAX,"%s@%s",user,uts.nodename); + } + return lowercase(attendee); } +#endif void usage(char *message) { + fprintf(stderr,"Usage: %s [-emdcn] [-i inputfile] [-o outputfile] [-u calid]\n",program_name); + } icalcomponent* get_first_real_component(icalcomponent *comp) @@ -140,20 +200,20 @@ char* make_mime(char* to, char* from, char* subject, uname(&uts); srand(time(0)<<getpid()); - sprintf(content_id,"%d-%d@%s",time(0),rand(),uts.nodename); - sprintf(boundary,"%d-%d-%s",time(0),rand(),uts.nodename); + sprintf(content_id,"%d-%d@%s",(int)time(0),rand(),uts.nodename); + sprintf(boundary,"%d-%d-%s",(int)time(0),rand(),uts.nodename); sprintf(mime_part_1,"Content-ID: %s\n\ Content-type: text/plain\n\ Content-Description: Text description of error message\n\n\ -%s\n\n%s", +%s\n\n--%s", content_id,text_message,boundary); if(ical_message != 0 && method != 0){ - sprintf(mime_part_2,"\nContent-ID: %s\n\ + sprintf(mime_part_2,"Content-ID: %s\n\ Content-type: text/calendar; method=%s\n\ -Content-Description: ICal component reply\n\n\ -%s\n\n%s--\n", +Content-Description: iCal component reply\n\n\ +%s\n\n--%s--", content_id,method,ical_message,boundary); } @@ -166,6 +226,7 @@ Content-Type: multipart/mixed; boundary=\"%s\"\n\ \n\ This is a multimedia message in MIME format\n\ \n\ +--%s %s ", to,from,subject,content_id,boundary,boundary, @@ -181,14 +242,39 @@ Content-Type: multipart/mixed; boundary=\"%s\"\n\ } /* The incoming component had fatal errors */ -void return_failure(icalcomponent* comp, char* message, struct options_struct *opt) +void return_failure(icalcomponent* comp, char* message, + struct options_struct *opt) { - + char* local_attendee = opt->calid; + FILE* p; - fputs(make_mime("Dest", "Source", "iMIP error", - message, "reply", - icalcomponent_as_ical_string(comp)),stdout); + icalcomponent *inner = get_first_real_component(comp); + + icalproperty *organizer_prop = icalcomponent_get_first_property(inner,ICAL_ORGANIZER_PROPERTY); + char *organizer = icalproperty_get_organizer(organizer_prop); + + organizer += 7; + if (opt->errors == ERRORS_TO_ORGANIZER){ + p = popen(SENDMAIL,"w"); + } else { + p = stdout; + } + + if(p == 0){ + fprintf(stderr, + "%s: fatal. Could not open pipe to sendmail (\"%s\") \n", + program_name,SENDMAIL); + exit(1); + } + + fputs(make_mime(organizer, local_attendee, "iMIP error", + message, "reply", + icalcomponent_as_ical_string(comp)),p); + + if (opt->errors == ERRORS_TO_ORGANIZER){ + pclose(p); + } } /* The program had a fatal error and could not process the incoming component*/ @@ -201,43 +287,124 @@ void return_error(icalcomponent* comp, char* message, struct options_struct *op } -char* check_component(icalcomponent* comp, struct options_struct *opt) +icalcomponent* make_reply(icalcomponent *comp, icalproperty *return_status, + struct options_struct *opt) + +{ + icalcomponent *reply, *rinner; + icalcomponent *inner = get_first_real_component(comp); + icalproperty *p=0; + char* local_attendee = opt->calid; + char attendee[TMPSIZE]; + + char prodid[TMPSIZE]; + + snprintf(attendee,TMPSIZE,"mailto:%s",local_attendee); + + snprintf(prodid,TMPSIZE,"-//Softwarestudio.org//%s version %s//EN",ICAL_PACKAGE,ICAL_VERSION); + + /* Create the base component */ + reply = icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalproperty_new_version(strdup("2.0")), + icalproperty_new_prodid(strdup(prodid)), + icalproperty_new_method(ICAL_METHOD_REPLY), + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_new_clone( + icalcomponent_get_first_property(inner,ICAL_DTSTAMP_PROPERTY)), + icalproperty_new_clone( + icalcomponent_get_first_property(inner,ICAL_ORGANIZER_PROPERTY)), + icalproperty_new_clone( + icalcomponent_get_first_property(inner,ICAL_UID_PROPERTY)), + icalproperty_new_attendee(attendee), + 0), + 0); + + + /* Convert errors into request-status properties and transfers + them to the reply component */ + + icalcomponent_convert_errors(comp); + + rinner = get_first_real_component(reply); + + for(p = icalcomponent_get_first_property(inner, + ICAL_REQUESTSTATUS_PROPERTY); + p != 0; + p = icalcomponent_get_next_property(inner, + ICAL_REQUESTSTATUS_PROPERTY)){ + + icalcomponent_add_property(rinner,icalproperty_new_clone(p)); + } + + if(return_status != 0){ + icalcomponent_add_property(rinner, return_status); + } + + return reply; + +} + +int check_attendee(icalproperty *p, struct options_struct *opt){ + char* s = icalproperty_get_attendee(p); + char* lower_attendee = lowercase(s); + char* local_attendee = opt->calid; + + /* Check that attendee begins with "mailto:" */ + if (strncmp(lower_attendee,"mailto:",7) == 0){ + /* skip over the mailto: part */ + lower_attendee += 7; + + if(strcmp(lower_attendee,local_attendee) == 0){ + return 1; + } + + lower_attendee -= 7; + + free(lower_attendee); + } + + return 0; +} + +char static_component_error_str[PATH_MAX]; +char* check_component(icalcomponent* comp, icalproperty **return_status, + struct options_struct *opt) { - static char static_component_error_str[PATH_MAX]; char* component_error_str=0; icalcomponent* inner; int errors = 0; icalproperty *p; int found_attendee = 0; + *return_status = 0; + /* This do/while loop only executes once because it is being used to fake exceptions */ do { - /* Check that the root component is a VCALENDAR */ - if(icalcomponent_isa(comp) != ICAL_VCALENDAR_COMPONENT){ + /* Check that we actually got a component */ + if(comp == 0){ strcpy(static_component_error_str, - "Root component is not a VCALENDAR"); + "Did not find a component"); component_error_str = static_component_error_str; break; } - /* Check that the component passes iTIP restrictions */ - - errors = icalcomponent_count_errors(comp); - icalrestriction_check(comp); - - if(errors != icalcomponent_count_errors(comp)){ + /* Check that the root component is a VCALENDAR */ + if(icalcomponent_isa(comp) != ICAL_VCALENDAR_COMPONENT){ strcpy(static_component_error_str, - "The component does not conform to iTIP restrictions"); + "Root component is not a VCALENDAR"); component_error_str = static_component_error_str; break; } + /* Check that the component has a METHOD */ - if (!icalcomponent_get_first_property(comp,ICAL_METHOD_PROPERTY) == 0) + if (icalcomponent_get_first_property(comp,ICAL_METHOD_PROPERTY) == 0) { strcpy(static_component_error_str, "Component does not have a METHOD property"); @@ -245,208 +412,288 @@ char* check_component(icalcomponent* comp, struct options_struct *opt) break; } - /* Check for this user as an attendee */ + inner = get_first_real_component(comp); - inner = get_first_real_component(comp); + /* Check that the compopnent has an organizer */ + if(icalcomponent_get_first_property(inner,ICAL_ORGANIZER_PROPERTY) == 0){ + fprintf(stderr,"%s: fatal. Component does not have an ORGANIZER property\n",program_name); + + exit(1); + } + + + /* Check for this user as an attendee or organizer */ for(p = icalcomponent_get_first_property(inner,ICAL_ATTENDEE_PROPERTY); p != 0; p = icalcomponent_get_next_property(inner,ICAL_ATTENDEE_PROPERTY)){ - - char* s = icalproperty_get_attendee(p); - char* lower_attendee = lowercase(s); - char* local_attendee = get_local_attendee(opt); - - /* Check that attendee begins with "mailto:" */ - if (strncmp(lower_attendee,"mailto:",7) == 0){ - /* skip over the mailto: part */ - lower_attendee += 7; - - if(strcmp(lower_attendee,local_attendee) == 0){ - found_attendee = 1; - } - - lower_attendee -= 7; + + found_attendee += check_attendee(p,opt); + } - free(local_attendee); - free(lower_attendee); - - } + for(p = icalcomponent_get_first_property(inner,ICAL_ORGANIZER_PROPERTY); + p != 0; + p = icalcomponent_get_next_property(inner,ICAL_ORGANIZER_PROPERTY)){ + + found_attendee += check_attendee(p,opt); } - + if (found_attendee == 0){ - char* local_attendee = get_local_attendee(opt); + struct icalreqstattype rs; + char* rs_string; + memset(static_component_error_str,0,PATH_MAX); + snprintf(static_component_error_str,PATH_MAX, - "This target user (%s) is not listed as an attendee", - local_attendee ); + "This target user (%s) is not listed as an attendee or organizer", + opt->calid ); component_error_str = static_component_error_str; - free(local_attendee); + + rs.code = ICAL_3_7_INVCU_STATUS; + rs.desc = 0; + rs.debug = component_error_str; + rs_string = icalreqstattype_as_string(rs); + + *return_status = icalproperty_new_requeststatus(rs_string); break; } + + + /* Check that the component passes iTIP restrictions */ + + errors = icalcomponent_count_errors(comp); + icalrestriction_check(comp); + + if(errors != icalcomponent_count_errors(comp)){ + snprintf(static_component_error_str,PATH_MAX, + "The component does not conform to iTIP restrictions.\n Here is the original component; look at the X-LIC-ERROR properties\nfor details\n\n%s",icalcomponent_as_ical_string(comp)); + component_error_str = static_component_error_str; + break; + } + + + } while(0); return component_error_str; } + void get_options(int argc, char* argv[], struct options_struct *opt) { - opt->storage = STORE_IN_DIR; - opt->input_type = INPUT_FROM_STDIN; + int c; + extern char *optarg; + extern int optind, optopt; + int errflg=0; + + opt->storage = STORE_IN_FILE; + opt->input_source = INPUT_FROM_STDIN; + opt->input_type = INPUT_IS_ICAL; opt->input_file = 0; - opt->input_text = 0; + opt->errors = ERRORS_TO_ORGANIZER; opt->calid = 0; - opt->caldir = 0; -} - -char* check_options(struct options_struct *opt) -{ - return 0; -} - -void store_component(icalcomponent *comp, icalcalendar* cal, - struct options_struct *opt) -{ - - icalcluster *incoming = 0; - icalerrorenum error; - - incoming = icalcalendar_get_incoming(cal); + opt->output_file = 0; + + + while ((c = getopt(argc, argv, "nemu:o:d:b:c:i:")) != -1) { + switch (c) { + case 'e': { /* Input data is MIME encapsulated */ + opt->input_type = INPUT_IS_MIME; + break; + } + case 'm': { /* Input is iCal. Default*/ + opt->input_type = INPUT_IS_ICAL; + break; + } + case 'i': { /* Input comes from named file */ + opt->input_source = INPUT_FROM_FILE; + opt->input_file = strdup(optarg); + break; + } + case 'o': { /* Output goes to named file. Default*/ + opt->output_file = strdup(optarg); + opt->storage = STORE_IN_FILE; + break; + } + case 'd': { /* Output goes to database */ + fprintf(stderr,"%s: option -d is unimplmented\n",program_name); + opt->storage = STORE_IN_DB; + errflg++; + break; + } + case 'c': { + + break; + } + case 'u': { /* Set the calid for the output database or + file. Default is user name of user running + program */ + opt->calid = strdup(optarg); + break; + } + + case 'n': { /* Dump error to stdout. Default is to + send error to the organizer specified + in the iCal data */ + opt->errors = ERRORS_TO_STDOUT; + break; + } + + case ':': {/* Option given without an operand */ + fprintf(stderr, + "%s: Option -%c requires an operand\n", + program_name,optopt); + errflg++; + break; + } + case '?': { + errflg++; + } + + } + + if (errflg >0){ + usage(""); + exit(1); + } + } - if (incoming == 0){ - fprintf(stderr,"%s: Failed to get incoming component directory: %s\n", - program_name, icalerror_strerror(icalerrno)); - exit(1); - } + if(opt->calid == 0){ + /* If no calid specified, use username */ + char attendee[PATH_MAX]; + char* user = getenv("USER"); + struct utsname uts; + uname(&uts); + /* HACK nodename may not be a fully qualified domain name */ + snprintf(attendee,PATH_MAX,"%s@%s",user,uts.nodename); - error = icalcluster_add_component(incoming,comp); - - if (error != ICAL_NO_ERROR){ - fprintf(stderr,"%s: Failed to write incoming component: %s\n", - program_name, icalerror_strerror(icalerrno)); - exit(1); - } - - error = icalcluster_commit(incoming); - - if (error != ICAL_NO_ERROR){ - fprintf(stderr,"%s: Failed to commit incoming cluster: %s\n", - program_name, icalerror_strerror(icalerrno)); - exit(1); + opt->calid = lowercase(attendee); } - - return; -} - -enum file_type -{ - ERROR, - NO_FILE, - DIRECTORY, - REGULAR, - OTHER -}; -enum file_type test_file(char *path) -{ - struct stat sbuf; - enum file_type type; - - errno = 0; + if(opt->storage == STORE_IN_FILE && + opt->output_file ==0){ + char file[PATH_MAX]; + char* user = getenv("USER"); + struct passwd *pw; - /* Check if the path already exists and if it is a directory*/ - if (stat(path,&sbuf) != 0){ + if(!user){ + fprintf(stderr,"%s: Can't get username. Try explicitly specifing the output file with -o", program_name); + exit(1); + } - /* A file by the given name does not exist, or there was - another error */ - if(errno == ENOENT) - { - type = NO_FILE; - } else { - type = ERROR; + /* Find password entry for user */ + while( (pw = getpwent())!=0){ + if(strcmp(user,pw->pw_name)==0){ + break; + } + } + + if(pw==0){ + fprintf(stderr,"%s: Can't get get password entry for user \"%s\" Try explicitly specifing the output file with -o", + program_name,user); + exit(1); } - } else { - /* A file by the given name exists, but is it a directory? */ - - if (S_ISDIR(sbuf.st_mode)){ - type = DIRECTORY; - } else if(S_ISREG(sbuf.st_mode)){ - type = REGULAR; - } else { - type = OTHER; + if(pw->pw_dir==0){ + fprintf(stderr,"%s: User \"%s\" has no home directory. Try explicitly specifing the output file with -o", + program_name, user); + exit(1); } + + snprintf(file,PATH_MAX,"%s/.facs/%s",pw->pw_dir,opt->calid); + + opt->output_file = strdup(file); } - return type; -} -icalcalendar* get_calendar(icalcomponent* comp, struct options_struct *opt) -{ - - struct stat sbuf; - char calpath[PATH_MAX]; - char facspath[PATH_MAX]; - char* home = getenv("HOME"); - char* user = getenv("USER"); - enum file_type type; - icalcalendar* cal; + /* Now try to create the calendar directory if it does + not exist */ - snprintf(facspath,PATH_MAX,"%s/.facs",home); + if(opt->storage == STORE_IN_FILE ) { + char * p; + char* facspath = strdup(opt->output_file); + enum file_type type; - type = test_file(facspath); + /* Cut off the last slash to make it just a directoy */ - errno = 0; - if (type == NO_FILE){ + p = strrchr(facspath,'/'); - if(mkdir(facspath,0775) != 0){ - fprintf(stderr,"%s: Failed to create calendar store directory %s: %s\n", - program_name,facspath, strerror(errno)); - exit(1); - } else { - printf("%s: Creating calendar store directory %s\n",program_name,facspath); - } + if (p == 0){ + fprintf(stderr,"%s: Invalid calendar filename \"%s\"", + program_name,facspath); + exit(1); + } + + *p='\0'; + + type = test_file(facspath); - } else if(type==REGULAR || type == ERROR){ - fprintf(stderr,"%s: Cannot create calendar store directory %s\n", + errno = 0; + if (type == NO_FILE){ + + if(mkdir(facspath,0775) != 0){ + fprintf(stderr, + "%s: Failed to create calendar directory %s: %s\n", + program_name,facspath, strerror(errno)); + exit(1); + } else { + fprintf(stderr,"%s: Creating calendar directory %s\n", + program_name,facspath); + } + + } else if(type==REGULAR || type == ERROR){ + fprintf(stderr,"%s: Cannot create calendar directory %s\n", program_name,facspath); exit(1); - } + } + } +} +char* check_options(struct options_struct *opt) +{ + return 0; +} +void store_component(icalcomponent *comp, struct options_struct *opt) +{ + icalerrorenum error; - snprintf(calpath,PATH_MAX,"%s/%s",facspath,user); - type = test_file(calpath); + if(opt->storage == STORE_IN_FILE){ + icalfileset *fs = icalfileset_new(opt->output_file); - errno = 0; + if (fs == 0){ + fprintf(stderr, + "%s: Failed to get incoming component directory: %s\n", + program_name, icalerror_strerror(icalerrno)); + exit(1); + } - if (type == NO_FILE){ - if(mkdir(calpath,0775) != 0){ - fprintf(stderr,"%s: Failed to create calendar directory %s: %s\n", - program_name,calpath, strerror(errno)); - } else { - printf("%s: Creating calendar store directory %s\n",program_name,facspath); + error = icalfileset_add_component(fs,comp); + + if (error != ICAL_NO_ERROR){ + fprintf(stderr,"%s: Failed to write incoming component: %s\n", + program_name, icalerror_strerror(icalerrno)); + exit(1); } - } else if(type==REGULAR || type == ERROR){ - fprintf(stderr,"%s: Cannot create calendar directory %s\n", - program_name,calpath); + + error = icalfileset_commit(fs); + + if (error != ICAL_NO_ERROR){ + fprintf(stderr,"%s: Failed to commit incoming cluster: %s\n", + program_name, icalerror_strerror(icalerrno)); exit(1); - } - - cal = icalcalendar_new(calpath); + } + + icalfileset_free(fs); - if(cal == 0){ - fprintf(stderr,"%s: Failed to open calendar at %s: %s", - program_name,calpath,icalerror_strerror(icalerrno)); - exit(1); + return; + } else { + assert(0); } - - return cal; - } char* read_stream(char *s, size_t size, void *d) @@ -456,14 +703,14 @@ char* read_stream(char *s, size_t size, void *d) return c; } -icalcomponent* read_component(struct options_struct *opt) +icalcomponent* read_nonmime_component(struct options_struct *opt) { FILE *stream; icalcomponent *comp; icalparser* parser = icalparser_new(); char* line; - if(opt->input_type == INPUT_FROM_FILE){ + if(opt->input_source == INPUT_FROM_FILE){ stream = fopen(opt->input_file,"r"); if (stream == 0){ @@ -490,22 +737,89 @@ icalcomponent* read_component(struct options_struct *opt) } while ( line != 0); - if(opt->input_type == INPUT_FROM_FILE){ + if(opt->input_source == INPUT_FROM_FILE){ fclose(stream); } + return comp; } +icalcomponent* find_vcalendar(icalcomponent* comp) +{ + icalcomponent *c,*rtrn; + + for(c = icalcomponent_get_first_component(comp,ICAL_ANY_COMPONENT); + c != 0; + c = icalcomponent_get_next_component(comp,ICAL_ANY_COMPONENT)){ + + if(icalcomponent_isa(c) == ICAL_VCALENDAR_COMPONENT){ + icalcomponent_remove_component(comp,c); + return c; + } + + if((rtrn=find_vcalendar(c)) != 0){ + return rtrn; + } + } + + return 0; +} + +icalcomponent* read_mime_component(struct options_struct *opt) +{ + icalcomponent *comp,*mimecomp; + FILE* stream; + + if(opt->input_source == INPUT_FROM_FILE){ + stream = fopen(opt->input_file,"r"); + + if (stream == 0){ + perror("Can't open input file"); + exit(1); + } + + } else { + stream = stdin; + } + + assert(stream != 0); + + mimecomp = icalmime_parse(read_stream,(void*)stream); + + /* now find the iCal component embedded within the mime component */ + comp = find_vcalendar(mimecomp); + + + if(comp == 0){ + return 0; + } + + return comp; +} + +icalcomponent* read_component(struct options_struct *opt) +{ + if(opt->input_type == INPUT_IS_MIME){ + return read_mime_component(opt); + } else if (opt->input_type == INPUT_IS_ICAL){ + return read_nonmime_component(opt); + } else { + fprintf(stderr,"%s: Internal Error; unknown option for input_type\n", + program_name); + exit(1); + } +} + int main(int argc, char* argv[] ) { char* options_error_str; char* component_error_str; - icalcalendar* cal; icalcomponent* comp, *reply; struct options_struct opt; + icalproperty *return_status; - program_name = argv[0]; + program_name = strrchr(argv[0],'/'); get_options(argc, argv, &opt); @@ -516,17 +830,19 @@ int main(int argc, char* argv[] ) comp = read_component(&opt); - if ( (component_error_str = check_component(comp,&opt)) != 0){ - return_failure(comp, component_error_str, &opt); - exit(1); + if ( (component_error_str = + check_component(comp,&return_status,&opt)) != 0){ + reply = make_reply(comp,return_status,&opt); + return_failure(reply, component_error_str, &opt); + icalcomponent_free(reply); + exit(0); } - cal = get_calendar(comp,&opt); + store_component(comp,&opt); - store_component(comp,cal, &opt); - icalcomponent_free(comp); - icalcalendar_free(cal); + /* Don't free the component comp, since it is now part of the + store, and will be freed there */ exit(0); } |