Fix wrong variable in for loop
[claws.git] / src / plugins / vcalendar / libical / libical / icalcomponent.c
1 /*======================================================================
2   FILE: icalcomponent.c
3   CREATOR: eric 28 April 1999
4   
5   $Id$
6
7
8  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
9
10  This program is free software; you can redistribute it and/or modify
11  it under the terms of either: 
12
13     The LGPL as published by the Free Software Foundation, version
14     2.1, available at: http://www.fsf.org/copyleft/lesser.html
15
16   Or:
17
18     The Mozilla Public License Version 1.0. You may obtain a copy of
19     the License at http://www.mozilla.org/MPL/
20
21   The original code is icalcomponent.c
22
23 ======================================================================*/
24
25
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29
30 #include "icalcomponent.h"
31 #include "pvl.h" /* "Pointer-to-void list" */
32 #include "icalerror.h"
33 #include "icalmemory.h"
34 #include "icalenums.h"
35 #include "icaltime.h"
36 #include "icalduration.h"
37 #include "icalperiod.h"
38 #include "icalparser.h"
39
40 #include <string.h>  /* for strcpy & memset */
41 #include <stdlib.h>  /* for malloc */
42 #include <stdarg.h> /* for va_list, etc */
43 #include <errno.h>
44 #include <assert.h>
45 #include <stdio.h> /* for fprintf */
46
47 #define MAX_TMP 1024
48
49 struct icalcomponent_impl 
50 {
51         char id[5];
52         icalcomponent_kind kind;
53         char* x_name;
54         pvl_list properties;
55         pvl_elem property_iterator;
56         pvl_list components;
57         pvl_elem component_iterator;
58         icalcomponent* parent;
59 };
60
61 /* icalproperty functions that only components get to use */
62 void icalproperty_set_parent(icalproperty* property,
63                              icalcomponent* component);
64 icalcomponent* icalproperty_get_parent(icalproperty* property);
65 void icalcomponent_add_children(struct icalcomponent_impl *impl,va_list args);
66 icalcomponent* icalcomponent_new_impl (icalcomponent_kind kind);
67 int icalcomponent_property_sorter(void *a, void *b);
68
69
70 void icalcomponent_add_children(struct icalcomponent_impl *impl,va_list args)
71 {
72     void* vp;
73     
74     while((vp = va_arg(args, void*)) != 0) {
75
76         assert (icalcomponent_isa_component(vp) != 0 ||
77                 icalproperty_isa_property(vp) != 0 ) ;
78
79         if (icalcomponent_isa_component(vp) != 0 ){
80
81             icalcomponent_add_component((icalcomponent*)impl,
82                                        (icalcomponent*)vp);
83
84         } else if (icalproperty_isa_property(vp) != 0 ){
85
86             icalcomponent_add_property((icalcomponent*)impl,
87                                        (icalproperty*)vp);
88         }
89     }    
90 }
91
92 icalcomponent*
93 icalcomponent_new_impl (icalcomponent_kind kind)
94 {
95     struct icalcomponent_impl* comp;
96
97     if ( ( comp = (struct icalcomponent_impl*)
98            malloc(sizeof(struct icalcomponent_impl))) == 0) {
99         icalerror_set_errno(ICAL_NEWFAILED_ERROR);
100         return 0;
101     }
102     
103     strcpy(comp->id,"comp");
104
105     comp->kind = kind;
106     comp->properties = pvl_newlist();
107     comp->property_iterator = 0;
108     comp->components = pvl_newlist();
109     comp->component_iterator = 0;
110     comp->x_name = 0;
111     comp->parent = 0;
112
113     return comp;
114 }
115
116 icalcomponent*
117 icalcomponent_new (icalcomponent_kind kind)
118 {
119    return (icalcomponent*)icalcomponent_new_impl(kind);
120 }
121
122 icalcomponent*
123 icalcomponent_vanew (icalcomponent_kind kind, ...)
124 {
125    va_list args;
126
127    struct icalcomponent_impl *impl = icalcomponent_new_impl(kind);
128
129     if (impl == 0){
130         return 0;
131     }
132
133    va_start(args,kind);
134    icalcomponent_add_children(impl, args);
135    va_end(args);
136
137    return (icalcomponent*) impl;
138 }
139
140 icalcomponent* icalcomponent_new_from_string(char* str)
141 {
142     return icalparser_parse_string(str);
143 }
144
145 icalcomponent* icalcomponent_new_clone(icalcomponent* component)
146 {
147     struct icalcomponent_impl *old = (struct icalcomponent_impl*)component;
148     struct icalcomponent_impl *new;
149     icalproperty *p;
150     icalcomponent *c;
151     pvl_elem itr;
152
153     icalerror_check_arg_rz( (component!=0), "component");
154
155     new = icalcomponent_new_impl(old->kind);
156
157     if (new == 0){
158         return 0;
159     }
160
161     
162     for( itr = pvl_head(old->properties);
163          itr != 0;
164          itr = pvl_next(itr))
165     {   
166         p = (icalproperty*)pvl_data(itr);
167         icalcomponent_add_property(new,icalproperty_new_clone(p));
168     }
169    
170    
171     for( itr = pvl_head(old->components);
172          itr != 0;
173          itr = pvl_next(itr))
174     {   
175         c = (icalcomponent*)pvl_data(itr);
176         icalcomponent_add_component(new,icalcomponent_new_clone(c));
177     }
178
179    return new;
180
181 }
182
183
184 void
185 icalcomponent_free (icalcomponent* component)
186 {
187     icalproperty* prop;
188     icalcomponent* comp;
189     struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
190
191     icalerror_check_arg_rv( (component!=0), "component");
192
193 #ifdef ICAL_FREE_ON_LIST_IS_ERROR
194     icalerror_assert( (c->parent ==0),"Tried to free a component that is still attached to a parent component");
195 #else
196     if(c->parent != 0){
197         return;
198     }
199 #endif
200
201     if(component != 0 ){
202        
203        while( (prop=pvl_pop(c->properties)) != 0){
204            assert(prop != 0);
205            icalproperty_set_parent(prop,0);
206            icalproperty_free(prop);
207        }
208        
209        pvl_free(c->properties);
210
211        while( (comp=pvl_data(pvl_head(c->components))) != 0){
212            assert(comp!=0);
213            icalcomponent_remove_component(component,comp);
214            icalcomponent_free(comp);
215        }
216        
217        pvl_free(c->components);
218
219         if (c->x_name != 0) {
220             free(c->x_name);
221         }
222
223         c->kind = ICAL_NO_COMPONENT;
224         c->properties = 0;
225         c->property_iterator = 0;
226         c->components = 0;
227         c->component_iterator = 0;
228         c->x_name = 0;  
229         c->id[0] = 'X';
230
231         free(c);
232     }
233 }
234
235 char*
236 icalcomponent_as_ical_string (icalcomponent* component)
237 {
238    char* buf, *out_buf;
239    char* tmp_buf;
240    size_t buf_size = 1024;
241    char* buf_ptr = 0;
242     pvl_elem itr;
243     struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component;
244
245 #ifdef ICAL_UNIX_NEWLINE    
246     char newline[] = "\n";
247 #else
248     char newline[] = "\r\n";
249 #endif
250    
251    icalcomponent *c;
252    icalproperty *p;
253    icalcomponent_kind kind = icalcomponent_isa(component);
254
255    const char* kind_string;
256
257    buf = icalmemory_new_buffer(buf_size);
258    buf_ptr = buf; 
259
260    icalerror_check_arg_rz( (component!=0), "component");
261    icalerror_check_arg_rz( (kind!=ICAL_NO_COMPONENT), "component kind is ICAL_NO_COMPONENT");
262    
263    kind_string  = icalenum_component_kind_to_string(kind);
264
265    icalerror_check_arg_rz( (kind_string!=0),"Unknown kind of component");
266
267    icalmemory_append_string(&buf, &buf_ptr, &buf_size, "BEGIN:");
268    icalmemory_append_string(&buf, &buf_ptr, &buf_size, kind_string);
269    icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline);
270    
271
272
273    for( itr = pvl_head(impl->properties);
274          itr != 0;
275          itr = pvl_next(itr))
276     {   
277         p = (icalproperty*)pvl_data(itr);
278         
279         icalerror_assert((p!=0),"Got a null property");
280         tmp_buf = icalproperty_as_ical_string(p);
281         
282         icalmemory_append_string(&buf, &buf_ptr, &buf_size, tmp_buf);
283     }
284    
285    
286    for( itr = pvl_head(impl->components);
287         itr != 0;
288         itr = pvl_next(itr))
289    {    
290        c = (icalcomponent*)pvl_data(itr);
291        
292        tmp_buf = icalcomponent_as_ical_string(c);
293        
294        icalmemory_append_string(&buf, &buf_ptr, &buf_size, tmp_buf);
295        
296    }
297    
298    icalmemory_append_string(&buf, &buf_ptr, &buf_size, "END:");
299    icalmemory_append_string(&buf, &buf_ptr, &buf_size, 
300                             icalenum_component_kind_to_string(kind));
301    icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline);
302
303    out_buf = icalmemory_tmp_copy(buf);
304    free(buf);
305
306    return out_buf;
307 }
308
309
310 int
311 icalcomponent_is_valid (icalcomponent* component)
312 {
313     struct icalcomponent_impl *impl = (struct icalcomponent_impl *)component;
314
315         
316     if ( (strcmp(impl->id,"comp") == 0) &&
317          impl->kind != ICAL_NO_COMPONENT){
318         return 1;
319     } else {
320         return 0;
321     }
322
323 }
324
325
326 icalcomponent_kind
327 icalcomponent_isa (icalcomponent* component)
328 {
329     struct icalcomponent_impl *impl = (struct icalcomponent_impl *)component;
330     icalerror_check_arg_rz( (component!=0), "component");
331
332    if(component != 0)
333    {
334        return impl->kind;
335    }
336
337    return ICAL_NO_COMPONENT;
338 }
339
340
341 int
342 icalcomponent_isa_component (void* component)
343 {
344     struct icalcomponent_impl *impl = (struct icalcomponent_impl *)component;
345
346     icalerror_check_arg_rz( (component!=0), "component");
347
348     if (strcmp(impl->id,"comp") == 0) {
349         return 1;
350     } else {
351         return 0;
352     }
353
354 }
355
356 int icalcomponent_property_sorter(void *a, void *b)
357 {
358     icalproperty_kind kinda, kindb;
359     const char *ksa, *ksb;
360
361     kinda = icalproperty_isa((icalproperty*)a);
362     kindb = icalproperty_isa((icalproperty*)b);
363
364     ksa = icalenum_property_kind_to_string(kinda);
365     ksb = icalenum_property_kind_to_string(kindb);
366
367     return strcmp(ksa,ksb);
368 }
369
370
371 void
372 icalcomponent_add_property (icalcomponent* component, icalproperty* property)
373 {
374     struct icalcomponent_impl *impl;
375
376     icalerror_check_arg_rv( (component!=0), "component");
377     icalerror_check_arg_rv( (property!=0), "property");
378
379      impl = (struct icalcomponent_impl*)component;
380
381     icalerror_assert( (!icalproperty_get_parent(property)),"The property has already been added to a component. Remove the property with icalcomponent_remove_property before calling icalcomponent_add_property");
382
383     icalproperty_set_parent(property,component);
384
385 #ifdef ICAL_INSERT_ORDERED
386     pvl_insert_ordered(impl->properties,
387                        icalcomponent_property_sorter,property);
388 #else
389     pvl_push(impl->properties,property);
390 #endif
391
392 }
393
394
395 void
396 icalcomponent_remove_property (icalcomponent* component, icalproperty* property)
397 {
398     struct icalcomponent_impl *impl;
399     pvl_elem itr, next_itr;
400
401     icalerror_check_arg_rv( (component!=0), "component");
402     icalerror_check_arg_rv( (property!=0), "property");
403     
404     impl = (struct icalcomponent_impl*)component;
405
406     icalerror_assert( (icalproperty_get_parent(property)),"The property is not a member of a component");
407
408     
409     for( itr = pvl_head(impl->properties);
410          itr != 0;
411          itr = next_itr)
412     {
413         next_itr = pvl_next(itr);
414         
415         if( pvl_data(itr) == (void*)property ){
416
417            if (impl->property_iterator == itr){
418                impl->property_iterator = pvl_next(itr);
419            }
420
421            pvl_remove( impl->properties, itr); 
422           icalproperty_set_parent(property,0);
423         }
424     }   
425 }
426
427 int
428 icalcomponent_count_properties (icalcomponent* component, 
429                                 icalproperty_kind kind)
430 {
431     int count=0;
432     pvl_elem itr;
433     struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component;
434
435     icalerror_check_arg_rz( (component!=0), "component");
436
437     for( itr = pvl_head(impl->properties);
438          itr != 0;
439          itr = pvl_next(itr))
440     {   
441         if(kind == icalproperty_isa((icalproperty*)pvl_data(itr)) ||
442             kind == ICAL_ANY_PROPERTY){
443             count++;
444         }
445     }
446
447
448     return count;
449
450 }
451
452 icalproperty* icalcomponent_get_current_property (icalcomponent* component)
453 {
454
455    struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
456    icalerror_check_arg_rz( (component!=0),"component");
457
458    if ((c->property_iterator==0)){
459        return 0;
460    }
461
462    return (icalproperty*) pvl_data(c->property_iterator);
463
464 }
465
466 icalproperty*
467 icalcomponent_get_first_property (icalcomponent* component, icalproperty_kind kind)
468 {
469    struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
470    icalerror_check_arg_rz( (component!=0),"component");
471   
472    for( c->property_iterator = pvl_head(c->properties);
473         c->property_iterator != 0;
474         c->property_iterator = pvl_next(c->property_iterator)) {
475             
476        icalproperty *p =  (icalproperty*) pvl_data(c->property_iterator);
477         
478            if (icalproperty_isa(p) == kind || kind == ICAL_ANY_PROPERTY) {
479                
480                return p;
481            }
482    }
483    return 0;
484 }
485
486 icalproperty*
487 icalcomponent_get_next_property (icalcomponent* component, icalproperty_kind kind)
488 {
489    struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
490    icalerror_check_arg_rz( (component!=0),"component");
491
492    if (c->property_iterator == 0){
493        return 0;
494    }
495
496    for( c->property_iterator = pvl_next(c->property_iterator);
497         c->property_iterator != 0;
498         c->property_iterator = pvl_next(c->property_iterator)) {
499             
500        icalproperty *p =  (icalproperty*) pvl_data(c->property_iterator);
501            
502        if (icalproperty_isa(p) == kind || kind == ICAL_ANY_PROPERTY) {
503            
504            return p;
505        }
506    }
507
508    return 0;
509 }
510
511
512 icalproperty**
513 icalcomponent_get_properties (icalcomponent* component, icalproperty_kind kind);
514
515
516 void
517 icalcomponent_add_component (icalcomponent* parent, icalcomponent* child)
518 {
519     struct icalcomponent_impl *impl, *cimpl;
520
521     icalerror_check_arg_rv( (parent!=0), "parent");
522     icalerror_check_arg_rv( (child!=0), "child");
523     
524     impl = (struct icalcomponent_impl*)parent;
525     cimpl = (struct icalcomponent_impl*)child;
526
527     icalerror_assert( (cimpl->parent ==0),"The child component has already been added to a parent component. Remove the component with icalcomponent_remove_component before calling icalcomponent_add_component");
528
529     cimpl->parent = parent;
530
531     pvl_push(impl->components,child);
532 }
533
534
535 void
536 icalcomponent_remove_component (icalcomponent* parent, icalcomponent* child)
537 {
538    struct icalcomponent_impl *impl,*cimpl;
539    pvl_elem itr, next_itr;
540
541    icalerror_check_arg_rv( (parent!=0), "parent");
542    icalerror_check_arg_rv( (child!=0), "child");
543    
544    impl = (struct icalcomponent_impl*)parent;
545    cimpl = (struct icalcomponent_impl*)child;
546    
547    for( itr = pvl_head(impl->components);
548         itr != 0;
549         itr = next_itr)
550    {
551        next_itr = pvl_next(itr);
552        
553        if( pvl_data(itr) == (void*)child ){
554
555            if (impl->component_iterator == itr){
556                /* Don't let the current iterator become invalid */
557
558                /* HACK. The semantics for this are troubling. */
559                impl->component_iterator = 
560                    pvl_next(impl->component_iterator);
561                   
562            }
563            pvl_remove( impl->components, itr); 
564            cimpl->parent = 0;
565            break;
566        }
567    }    
568 }
569
570
571 int
572 icalcomponent_count_components (icalcomponent* component, 
573                                 icalcomponent_kind kind)
574 {
575     int count=0;
576     pvl_elem itr;
577     struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component;
578
579     icalerror_check_arg_rz( (component!=0), "component");
580
581     for( itr = pvl_head(impl->components);
582          itr != 0;
583          itr = pvl_next(itr))
584     {
585         if(kind == icalcomponent_isa((icalcomponent*)pvl_data(itr)) ||
586             kind == ICAL_ANY_COMPONENT){
587             count++;
588         }
589     }
590
591     return count;
592 }
593
594 icalcomponent*
595 icalcomponent_get_current_component(icalcomponent* component)
596 {
597    struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
598
599    icalerror_check_arg_rz( (component!=0),"component");
600
601    if (c->component_iterator == 0){
602        return 0;
603    }
604
605    return (icalcomponent*) pvl_data(c->component_iterator);
606 }
607
608 icalcomponent*
609 icalcomponent_get_first_component (icalcomponent* component, 
610                                    icalcomponent_kind kind)
611 {
612    struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
613
614    icalerror_check_arg_rz( (component!=0),"component");
615   
616    for( c->component_iterator = pvl_head(c->components);
617         c->component_iterator != 0;
618         c->component_iterator = pvl_next(c->component_iterator)) {
619             
620        icalcomponent *p =  (icalcomponent*) pvl_data(c->component_iterator);
621         
622            if (icalcomponent_isa(p) == kind || kind == ICAL_ANY_COMPONENT) {
623                
624                return p;
625            }
626    }
627
628    return 0;
629 }
630
631
632 icalcomponent*
633 icalcomponent_get_next_component (icalcomponent* component, icalcomponent_kind kind)
634 {
635    struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
636
637    icalerror_check_arg_rz( (component!=0),"component");
638   
639    if (c->component_iterator == 0){
640        return 0;
641    }
642
643    for( c->component_iterator = pvl_next(c->component_iterator);
644         c->component_iterator != 0;
645         c->component_iterator = pvl_next(c->component_iterator)) {
646             
647        icalcomponent *p =  (icalcomponent*) pvl_data(c->component_iterator);
648         
649            if (icalcomponent_isa(p) == kind || kind == ICAL_ANY_COMPONENT) {
650                
651                return p;
652            }
653    }
654
655    return 0;
656 }
657
658 icalcomponent* icalcomponent_get_first_real_component(icalcomponent *c)
659 {
660     icalcomponent *comp;
661
662     for(comp = icalcomponent_get_first_component(c,ICAL_ANY_COMPONENT);
663         comp != 0;
664         comp = icalcomponent_get_next_component(c,ICAL_ANY_COMPONENT)){
665
666         icalcomponent_kind kind = icalcomponent_isa(comp);
667
668         if(kind == ICAL_VEVENT_COMPONENT ||
669            kind == ICAL_VTODO_COMPONENT ||
670            kind == ICAL_VJOURNAL_COMPONENT ){
671             return comp;
672         }
673     }
674     return 0;
675 }
676
677 time_t icalcomponent_convert_time(icalproperty *p)
678 {
679     struct icaltimetype sict;
680     time_t convt;
681     icalproperty *tzp;
682         
683
684     /* Though it says _dtstart, it will work for dtend too */
685     sict = icalproperty_get_dtstart(p);
686
687     tzp = icalproperty_get_first_parameter(p,ICAL_TZID_PARAMETER);
688
689     if (sict.is_utc == 1 && tzp != 0){
690         icalerror_warn("icalcomponent_get_span: component has a UTC DTSTART with a timezone specified ");
691         icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
692         return 0; 
693     }
694
695     if(sict.is_utc == 1){
696 #ifdef TEST_CONVERT_TIME
697         gchar buft[512];
698 #endif
699         /* _as_timet will use gmtime() to do the conversion */
700         convt = icaltime_as_timet(sict);
701
702 #ifdef TEST_CONVERT_TIME
703         printf("convert time: use as_timet:\n %s\n %s",
704                icalproperty_as_ical_string(p), ctime_r(&convt,buft));
705 #endif
706
707     } else if (sict.is_utc == 0 && tzp == 0 ) {
708         time_t offset;
709 #ifdef TEST_CONVERT_TIME
710         gchar buft[512];
711 #endif
712
713         /* _as_timet will use localtime() to do the conversion */
714         convt = icaltime_as_timet(sict);
715         offset = icaltime_utc_offset(sict,0);
716         convt += offset;
717
718 #ifdef TEST_CONVERT_TIME
719         printf("convert time: use as_timet and adjust:\n %s\n %s",
720                icalproperty_as_ical_string(p), ctime_r(&convt,buft));
721 #endif
722     } else {
723 #ifdef TEST_CONVERT_TIME
724         gchar buft[512];
725 #endif
726         /* Convert the time to UTC for the named timezone*/
727         const char* timezone = icalparameter_get_tzid(tzp);
728         convt = icaltime_as_timet(icaltime_as_utc(sict,timezone));
729
730 #ifdef TEST_CONVERT_TIME
731         printf("convert time: use _as_utc:\n %s\n %s",
732                icalproperty_as_ical_string(p), ctime_r(&convt,buft));
733 #endif
734     }       
735
736     return convt;
737 }
738 struct icaltime_span icalcomponent_get_span(icalcomponent* comp)
739 {
740     icalcomponent *inner;
741     icalproperty *p, *duration;
742     icalcomponent_kind kind;
743     struct icaltime_span span;
744     struct icaltimetype start;
745 #ifdef TEST_CONVERT_TIME
746     gchar buft[512];
747 #endif
748
749     span.start = 0;
750     span.end = 0;
751     span.is_busy= 1;
752
753     /* initial Error checking */
754
755 /*    icalerror_check_arg_rz( (comp!=0),"comp");*/
756
757     kind  = icalcomponent_isa(comp);
758
759     if(kind == ICAL_VCALENDAR_COMPONENT){
760         inner = icalcomponent_get_first_real_component(comp);
761
762         /* Maybe there is a VTIMEZONE in there */
763         if (inner == 0){
764             inner = icalcomponent_get_first_component(comp,
765                                ICAL_VTIMEZONE_COMPONENT);
766         }
767
768     } else {
769         inner = comp;
770     }
771
772     if (inner == 0){
773         icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
774         /*icalerror_warn("icalcomponent_get_span: no component specified, or empty VCALENDAR component");*/
775         return span; 
776     }
777     
778     kind  = icalcomponent_isa(inner);
779
780     if( !( kind == ICAL_VEVENT_COMPONENT ||
781            kind == ICAL_VJOURNAL_COMPONENT ||
782            kind == ICAL_VTODO_COMPONENT ||         
783            kind == ICAL_VFREEBUSY_COMPONENT )) {
784         icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
785         /*icalerror_warn("icalcomponent_get_span: no component specified, or empty VCALENDAR component");*/
786         return span; 
787         
788     }
789
790
791
792     /* Get to work. starting with DTSTART */
793
794     p = icalcomponent_get_first_property(inner, ICAL_DTSTART_PROPERTY);
795
796     if (p ==0 ) {
797         icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
798         /*icalerror_warn("icalcomponent_get_span: component has no DTSTART time");*/
799         return span; 
800     }
801
802
803     start = icalproperty_get_dtstart(p);
804
805     icalerror_clear_errno();
806
807     span.start = icalcomponent_convert_time(p);
808
809 #ifdef TEST_CONVERT_TIME
810     printf("convert time:\n %s %s",
811            icalproperty_as_ical_string(p), ctime_r(&span.start, buft));
812 #endif
813
814     if(icalerrno != ICAL_NO_ERROR){
815         span.start = 0;
816         return span;
817     }
818
819     /* The end time could be specified as either a DTEND or a DURATION */
820     p = icalcomponent_get_first_property(inner, ICAL_DTEND_PROPERTY);
821     duration = icalcomponent_get_first_property(inner, ICAL_DURATION_PROPERTY);
822
823     if (p==0 && duration == 0 && start.is_date != 1) {
824         icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
825         /*icalerror_warn("icalcomponent_get_span: component has neither DTEND nor DURATION time");*/
826         span.start = 0;
827         return span; 
828     } 
829
830     if (p!=0){
831         span.end = icalcomponent_convert_time(p);
832     } else if (start.is_date == 1) {
833         /* Duration is all day */
834         span.end = span.start + 60*60*24;
835     } else {
836         /* Use the duration */
837         struct icaldurationtype dur;
838         time_t durt;
839         
840         
841         dur = icalproperty_get_duration(duration);
842
843         durt = icaldurationtype_as_int(dur);
844         span.end = span.start+durt;
845     }
846
847     return span;
848
849 }
850
851
852 int icalcomponent_count_errors(icalcomponent* component)
853 {
854     int errors = 0;
855     icalproperty *p;
856     icalcomponent *c;
857     pvl_elem itr;
858     struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component;
859
860     for( itr = pvl_head(impl->properties);
861          itr != 0;
862          itr = pvl_next(itr))
863     {   
864         p = (icalproperty*)pvl_data(itr);
865         
866         if(icalproperty_isa(p) == ICAL_XLICERROR_PROPERTY)
867         {
868             errors++;
869         }
870     }
871
872
873     for( itr = pvl_head(impl->components);
874          itr != 0;
875          itr = pvl_next(itr))
876     {   
877         c = (icalcomponent*)pvl_data(itr);
878         
879         errors += icalcomponent_count_errors(c);
880         
881     }
882
883     return errors;
884 }
885
886
887 void icalcomponent_strip_errors(icalcomponent* component)
888 {
889     icalproperty *p;
890     icalcomponent *c;
891     pvl_elem itr, next_itr;
892     struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component;
893
894    for( itr = pvl_head(impl->properties);
895          itr != 0;
896          itr = next_itr)
897     {   
898         p = (icalproperty*)pvl_data(itr);
899         next_itr = pvl_next(itr);
900
901         if(icalproperty_isa(p) == ICAL_XLICERROR_PROPERTY)
902         {
903             icalcomponent_remove_property(component,p);
904         }
905     }
906     
907     for( itr = pvl_head(impl->components);
908          itr != 0;
909          itr = pvl_next(itr))
910     {   
911         c = (icalcomponent*)pvl_data(itr);
912         icalcomponent_strip_errors(c);
913     }
914 }
915
916 /* Hack. This will change the state of the iterators */
917 void icalcomponent_convert_errors(icalcomponent* component)
918 {
919     icalproperty *p, *next_p;
920     icalcomponent *c;
921
922     for(p = icalcomponent_get_first_property(component,ICAL_ANY_PROPERTY);
923         p != 0;
924         p = next_p){
925         
926         next_p = icalcomponent_get_next_property(component,ICAL_ANY_PROPERTY);
927
928         if(icalproperty_isa(p) == ICAL_XLICERROR_PROPERTY)
929         {
930             struct icalreqstattype rst;
931             icalparameter *param  = icalproperty_get_first_parameter
932                 (p,ICAL_XLICERRORTYPE_PARAMETER);
933
934             rst.code = ICAL_UNKNOWN_STATUS;
935             rst.desc = 0;
936
937             switch(icalparameter_get_xlicerrortype(param)){
938
939                 case  ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR: {
940                     rst.code = ICAL_3_2_INVPARAM_STATUS;
941                     break;
942                 }
943                 case  ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR: {
944                     rst.code = ICAL_3_3_INVPARAMVAL_STATUS;
945                     break;
946                 }
947                 case  ICAL_XLICERRORTYPE_PROPERTYPARSEERROR: {              
948                     rst.code = ICAL_3_0_INVPROPNAME_STATUS;
949                     break;
950                 }
951                 case  ICAL_XLICERRORTYPE_VALUEPARSEERROR: {
952                     rst.code = ICAL_3_1_INVPROPVAL_STATUS;
953                     break;
954                 }
955                 case  ICAL_XLICERRORTYPE_COMPONENTPARSEERROR: {
956                     rst.code = ICAL_3_4_INVCOMP_STATUS;
957                     break;
958                 }
959
960                 default: {
961                 }
962             }
963             if (rst.code != ICAL_UNKNOWN_STATUS){
964                 
965                 rst.debug = icalproperty_get_xlicerror(p);
966                 icalcomponent_add_property(component,
967                                            icalproperty_new_requeststatus(
968                                                icalreqstattype_as_string(rst)
969                                                )
970                     );
971                 
972                 icalcomponent_remove_property(component,p);
973             }
974         }
975     }
976
977     for(c = icalcomponent_get_first_component(component,ICAL_ANY_COMPONENT);
978         c != 0;
979         c = icalcomponent_get_next_component(component,ICAL_ANY_COMPONENT)){
980         
981         icalcomponent_convert_errors(c);
982     }
983 }
984
985
986 icalcomponent* icalcomponent_get_parent(icalcomponent* component)
987 {
988    struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
989
990    return c->parent;
991 }
992
993 void icalcomponent_set_parent(icalcomponent* component, icalcomponent* parent)
994 {
995    struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
996
997    c->parent = parent;
998 }
999
1000 icalcompiter icalcompiter_null = {ICAL_NO_COMPONENT,0};
1001
1002
1003 struct icalcomponent_kind_map {
1004         icalcomponent_kind kind;
1005         char name[20];
1006 };
1007
1008   
1009
1010 static struct icalcomponent_kind_map component_map[] = 
1011 {
1012     { ICAL_VEVENT_COMPONENT, "VEVENT" },
1013     { ICAL_VTODO_COMPONENT, "VTODO" },
1014     { ICAL_VJOURNAL_COMPONENT, "VJOURNAL" },
1015     { ICAL_VCALENDAR_COMPONENT, "VCALENDAR" },
1016     { ICAL_VFREEBUSY_COMPONENT, "VFREEBUSY" },
1017     { ICAL_VTIMEZONE_COMPONENT, "VTIMEZONE" },
1018     { ICAL_VALARM_COMPONENT, "VALARM" },
1019     { ICAL_XSTANDARD_COMPONENT, "STANDARD" }, /*These are part of RFC2445 */
1020     { ICAL_XDAYLIGHT_COMPONENT, "DAYLIGHT" }, /*but are not really components*/
1021     { ICAL_X_COMPONENT, "X" },
1022     { ICAL_VSCHEDULE_COMPONENT, "SCHEDULE" },
1023
1024     /* CAP components */
1025     { ICAL_VQUERY_COMPONENT, "VQUERY" },  
1026     { ICAL_VCAR_COMPONENT, "VCAR" },  
1027     { ICAL_VCOMMAND_COMPONENT, "VCOMMAND" },  
1028
1029     /* libical private components */
1030     { ICAL_XLICINVALID_COMPONENT, "X-LIC-UNKNOWN" },  
1031     { ICAL_XLICMIMEPART_COMPONENT, "X-LIC-MIME-PART" },  
1032     { ICAL_ANY_COMPONENT, "ANY" },  
1033     { ICAL_XROOT_COMPONENT, "XROOT" },  
1034
1035     /* End of list */
1036     { ICAL_NO_COMPONENT, "" },
1037 };
1038
1039
1040
1041 const char* icalcomponent_kind_to_string(icalcomponent_kind kind)
1042 {
1043     int i;
1044
1045     for (i=0; component_map[i].kind != ICAL_NO_COMPONENT; i++) {
1046         if (component_map[i].kind == kind) {
1047             return component_map[i].name;
1048         }
1049     }
1050
1051     return 0;
1052
1053 }
1054
1055 icalcomponent_kind icalcomponent_string_to_kind(const char* string)
1056 {
1057     int i;
1058
1059     if (string ==0 ) { 
1060         return ICAL_NO_COMPONENT;
1061     }
1062
1063     for (i=0; component_map[i].kind  != ICAL_NO_COMPONENT; i++) {
1064         if (strcmp(component_map[i].name, string) == 0) {
1065             return component_map[i].kind;
1066         }
1067     }
1068
1069     return ICAL_NO_COMPONENT;
1070 }
1071
1072
1073
1074 icalcompiter 
1075 icalcomponent_begin_component(icalcomponent* component,icalcomponent_kind kind)
1076 {
1077     struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component;
1078     icalcompiter itr;
1079     pvl_elem i;
1080
1081     itr.kind = kind;
1082
1083     icalerror_check_arg_re( (component!=0),"component",icalcompiter_null);
1084
1085     for( i = pvl_head(impl->components); i != 0; i = pvl_next(i)) {
1086         
1087         icalcomponent *c =  (icalcomponent*) pvl_data(i);
1088         
1089         if (icalcomponent_isa(c) == kind || kind == ICAL_ANY_COMPONENT) {
1090             
1091             itr.iter = i;
1092
1093             return itr;
1094         }
1095     }
1096
1097     return icalcompiter_null;
1098 }
1099
1100 icalcompiter
1101 icalcomponent_end_component(icalcomponent* component,icalcomponent_kind kind)
1102 {
1103     struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component;
1104     icalcompiter itr; 
1105     pvl_elem i;
1106
1107     itr.kind = kind;
1108
1109     icalerror_check_arg_re( (component!=0),"component",icalcompiter_null);
1110
1111     for( i = pvl_tail(impl->components); i != 0; i = pvl_prior(i)) {
1112         
1113         icalcomponent *c =  (icalcomponent*) pvl_data(i);
1114         
1115         if (icalcomponent_isa(c) == kind || kind == ICAL_ANY_COMPONENT) {
1116             
1117             itr.iter = pvl_next(i);
1118
1119             return itr;
1120         }
1121     }
1122
1123     return icalcompiter_null;;
1124 }
1125
1126
1127 icalcomponent* icalcompiter_next(icalcompiter* i)
1128 {
1129    if (i->iter == 0){
1130        return 0;
1131    }
1132
1133    icalerror_check_arg_rz( (i!=0),"i");
1134
1135    for( i->iter = pvl_next(i->iter);
1136         i->iter != 0;
1137         i->iter = pvl_next(i->iter)) {
1138             
1139        icalcomponent *c =  (icalcomponent*) pvl_data(i->iter);
1140         
1141            if (icalcomponent_isa(c) == i->kind 
1142                || i->kind == ICAL_ANY_COMPONENT) {
1143                
1144                return icalcompiter_deref(i);;
1145            }
1146    }
1147
1148    return 0;
1149
1150 }
1151
1152 icalcomponent* icalcompiter_prior(icalcompiter* i)
1153 {
1154    if (i->iter == 0){
1155        return 0;
1156    }
1157
1158    for( i->iter = pvl_prior(i->iter);
1159         i->iter != 0;
1160         i->iter = pvl_prior(i->iter)) {
1161             
1162        icalcomponent *c =  (icalcomponent*) pvl_data(i->iter);
1163         
1164            if (icalcomponent_isa(c) == i->kind 
1165                || i->kind == ICAL_ANY_COMPONENT) {
1166                
1167                return icalcompiter_deref(i);;
1168            }
1169    }
1170
1171    return 0;
1172
1173 }
1174 icalcomponent* icalcompiter_deref(icalcompiter* i)
1175 {
1176     if(i->iter ==0){
1177         return 0;
1178     }
1179
1180     return pvl_data(i->iter);
1181 }
1182
1183 icalcomponent* icalcomponent_get_inner(icalcomponent* comp)
1184 {
1185     if (icalcomponent_isa(comp) == ICAL_VCALENDAR_COMPONENT){
1186         return icalcomponent_get_first_real_component(comp);
1187     } else {
1188         return comp;
1189     }
1190 }
1191
1192
1193 void icalcomponent_set_dtstart(icalcomponent* comp, struct icaltimetype v)
1194 {
1195
1196     icalcomponent *inner = icalcomponent_get_inner(comp); 
1197     icalproperty *prop 
1198         = icalcomponent_get_first_property(inner, ICAL_DTSTART_PROPERTY);
1199
1200
1201     if (prop == 0){
1202         prop = icalproperty_new_dtstart(v);
1203         icalcomponent_add_property(inner, prop);
1204     }
1205     
1206     icalproperty_set_dtstart(prop,v);
1207
1208 }
1209
1210
1211 struct icaltimetype icalcomponent_get_dtstart(icalcomponent* comp)
1212 {
1213     icalcomponent *inner = icalcomponent_get_inner(comp); 
1214     icalproperty *prop 
1215         = icalcomponent_get_first_property(inner,ICAL_DTSTART_PROPERTY);
1216
1217     if (prop == 0){
1218         return icaltime_null_time();
1219     }
1220     
1221     return icalproperty_get_dtstart(prop);
1222 }
1223
1224
1225 struct icaltimetype icalcomponent_get_dtend(icalcomponent* comp)
1226 {
1227     icalcomponent *inner = icalcomponent_get_inner(comp); 
1228
1229     icalproperty *end_prop 
1230         = icalcomponent_get_first_property(inner,ICAL_DTEND_PROPERTY);
1231
1232     icalproperty *dur_prop 
1233         = icalcomponent_get_first_property(inner, ICAL_DURATION_PROPERTY);
1234
1235
1236     if( end_prop == 0 && dur_prop == 0){
1237         return icaltime_null_time();
1238     } else if ( end_prop != 0) {
1239         return icalproperty_get_dtend(end_prop);
1240     } else if ( dur_prop != 0) { 
1241         
1242         struct icaltimetype start = 
1243             icalcomponent_get_dtstart(inner);
1244         struct icaldurationtype duration = 
1245             icalproperty_get_duration(dur_prop);
1246         
1247         struct icaltimetype end = icaltime_add(start,duration);
1248
1249         return end;
1250
1251     } else {
1252         /* Error, both duration and dtend have been specified */
1253         icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
1254         return icaltime_null_time();
1255
1256     }
1257     
1258 }
1259
1260
1261 void icalcomponent_set_dtend(icalcomponent* comp, struct icaltimetype v)
1262 {
1263     icalcomponent *inner = icalcomponent_get_inner(comp); 
1264
1265     icalproperty *end_prop 
1266         = icalcomponent_get_first_property(inner,ICAL_DTEND_PROPERTY);
1267
1268     icalproperty *dur_prop 
1269         = icalcomponent_get_first_property(inner,ICAL_DURATION_PROPERTY);
1270
1271
1272     if( end_prop == 0 && dur_prop == 0){
1273         end_prop = icalproperty_new_dtend(v);
1274         icalcomponent_add_property(inner,end_prop);
1275     } else if ( end_prop != 0) {
1276         icalproperty_set_dtend(end_prop,v);
1277     } else if ( dur_prop != 0) { 
1278         struct icaltimetype start = 
1279             icalcomponent_get_dtstart(inner);
1280
1281         struct icaltimetype end = 
1282             icalcomponent_get_dtend(inner);
1283
1284         struct icaldurationtype dur 
1285             = icaltime_subtract(end,start);
1286
1287         icalproperty_set_duration(dur_prop,dur);
1288
1289     } else {
1290         /* Error, both duration and dtend have been specified */
1291         icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
1292     }
1293 }
1294
1295 void icalcomponent_set_duration(icalcomponent* comp, 
1296                                 struct icaldurationtype v)
1297 {
1298     icalcomponent *inner = icalcomponent_get_inner(comp); 
1299
1300     icalproperty *end_prop 
1301         = icalcomponent_get_first_property(inner,ICAL_DTEND_PROPERTY);
1302
1303     icalproperty *dur_prop 
1304         = icalcomponent_get_first_property(inner,ICAL_DURATION_PROPERTY);
1305
1306
1307     if( end_prop == 0 && dur_prop == 0){
1308         dur_prop = icalproperty_new_duration(v);
1309         icalcomponent_add_property(inner, dur_prop);
1310     } else if ( end_prop != 0) {
1311         struct icaltimetype start = 
1312             icalcomponent_get_dtstart(inner);
1313         
1314         struct icaltimetype new_end = icaltime_add(start,v);
1315
1316         icalproperty_set_dtend(end_prop,new_end);
1317
1318     } else if ( dur_prop != 0) { 
1319         icalproperty_set_duration(dur_prop,v);
1320     } else {
1321         /* Error, both duration and dtend have been specified */
1322         icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
1323     }
1324 }
1325
1326 struct icaldurationtype icalcomponent_get_duration(icalcomponent* comp)
1327 {
1328     icalcomponent *inner = icalcomponent_get_inner(comp); 
1329
1330     icalproperty *end_prop 
1331         = icalcomponent_get_first_property(inner,ICAL_DTEND_PROPERTY);
1332
1333     icalproperty *dur_prop 
1334         = icalcomponent_get_first_property(inner,ICAL_DURATION_PROPERTY);
1335
1336     struct icaldurationtype null_duration;
1337     memset(&null_duration,0,sizeof(struct icaldurationtype));
1338
1339
1340     if( end_prop == 0 && dur_prop == 0){
1341         return null_duration;
1342     } else if ( end_prop != 0) {
1343         struct icaltimetype start = 
1344             icalcomponent_get_dtstart(inner);
1345         time_t startt = icaltime_as_timet(start);
1346
1347         struct icaltimetype end = 
1348             icalcomponent_get_dtend(inner);
1349         time_t endt = icaltime_as_timet(end);
1350         
1351         return icaldurationtype_from_int(endt-startt);
1352     } else if ( dur_prop != 0) { 
1353         return icalproperty_get_duration(dur_prop);
1354     } else {
1355         /* Error, both duration and dtend have been specified */
1356         icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
1357         return null_duration;
1358     }
1359 }
1360
1361 void icalcomponent_set_method(icalcomponent* comp, icalproperty_method method)
1362 {
1363     icalproperty *prop 
1364         = icalcomponent_get_first_property(comp, ICAL_METHOD_PROPERTY);
1365
1366
1367     if (prop == 0){
1368         prop = icalproperty_new_method(method);
1369         icalcomponent_add_property(comp, prop);
1370     }
1371     
1372     icalproperty_set_method(prop,method);
1373
1374 }
1375
1376 icalproperty_method icalcomponent_get_method(icalcomponent* comp)
1377 {
1378     icalproperty *prop 
1379         = icalcomponent_get_first_property(comp,ICAL_METHOD_PROPERTY);
1380
1381     if (prop == 0){
1382         return ICAL_METHOD_NONE;
1383     }
1384     
1385     return icalproperty_get_method(prop);
1386 }
1387
1388 void icalcomponent_set_dtstamp(icalcomponent* comp, struct icaltimetype v)
1389 {
1390
1391     icalcomponent *inner = icalcomponent_get_inner(comp); 
1392     icalproperty *prop 
1393         = icalcomponent_get_first_property(inner, ICAL_DTSTAMP_PROPERTY);
1394
1395
1396     if (prop == 0){
1397         prop = icalproperty_new_dtstamp(v);
1398         icalcomponent_add_property(inner, prop);
1399     }
1400     
1401     icalproperty_set_dtstamp(prop,v);
1402
1403 }
1404
1405
1406 struct icaltimetype icalcomponent_get_dtstamp(icalcomponent* comp)
1407 {
1408     icalcomponent *inner = icalcomponent_get_inner(comp); 
1409     icalproperty *prop 
1410         = icalcomponent_get_first_property(inner,ICAL_DTSTAMP_PROPERTY);
1411
1412     if (prop == 0){
1413         return icaltime_null_time();
1414     }
1415     
1416     return icalproperty_get_dtstamp(prop);
1417 }
1418
1419
1420 void icalcomponent_set_summary(icalcomponent* comp, const char* v)
1421 {
1422     icalcomponent *inner = icalcomponent_get_inner(comp); 
1423     icalproperty *prop 
1424         = icalcomponent_get_first_property(inner, ICAL_SUMMARY_PROPERTY);
1425
1426     if (prop == 0){
1427         prop = icalproperty_new_summary(v);
1428         icalcomponent_add_property(inner, prop);
1429     }
1430     
1431     icalproperty_set_summary(prop,v);
1432 }
1433
1434
1435 const char* icalcomponent_get_summary(icalcomponent* comp)
1436 {
1437     icalcomponent *inner = icalcomponent_get_inner(comp); 
1438     icalproperty *prop 
1439         = icalcomponent_get_first_property(inner,ICAL_SUMMARY_PROPERTY);
1440
1441     if (prop == 0){
1442         return 0;
1443     }
1444     
1445     return icalproperty_get_summary(prop);
1446
1447 }
1448
1449 void icalcomponent_set_comment(icalcomponent* comp, const char* v);
1450 const char* icalcomponent_get_comment(icalcomponent* comp);
1451
1452 void icalcomponent_set_uid(icalcomponent* comp, const char* v);
1453 const char* icalcomponent_get_uid(icalcomponent* comp);
1454
1455 void icalcomponent_set_recurrenceid(icalcomponent* comp, 
1456                                     struct icaltimetype v);
1457 struct icaltimetype icalcomponent_get_recurrenceid(icalcomponent* comp);
1458
1459
1460
1461
1462 icalcomponent* icalcomponent_new_vcalendar()
1463 {
1464     return icalcomponent_new(ICAL_VCALENDAR_COMPONENT);
1465 }
1466 icalcomponent* icalcomponent_new_vevent()
1467 {
1468     return icalcomponent_new(ICAL_VEVENT_COMPONENT);
1469 }
1470 icalcomponent* icalcomponent_new_vtodo()
1471 {
1472     return icalcomponent_new(ICAL_VTODO_COMPONENT);
1473 }
1474 icalcomponent* icalcomponent_new_vjournal()
1475 {
1476     return icalcomponent_new(ICAL_VJOURNAL_COMPONENT);
1477 }
1478 icalcomponent* icalcomponent_new_valarm()
1479 {
1480     return icalcomponent_new(ICAL_VALARM_COMPONENT);
1481 }
1482 icalcomponent* icalcomponent_new_vfreebusy()
1483 {
1484     return icalcomponent_new(ICAL_VFREEBUSY_COMPONENT);
1485 }
1486 icalcomponent* icalcomponent_new_vtimezone()
1487 {
1488     return icalcomponent_new(ICAL_VTIMEZONE_COMPONENT);
1489 }
1490 icalcomponent* icalcomponent_new_xstandard()
1491 {
1492     return icalcomponent_new(ICAL_XSTANDARD_COMPONENT);
1493 }
1494 icalcomponent* icalcomponent_new_xdaylight()
1495 {
1496     return icalcomponent_new(ICAL_XDAYLIGHT_COMPONENT);
1497 }