Diffstat (limited to 'libical/src/libicalss/icalclassify.c') (more/less context) (show whitespace changes)
-rw-r--r-- | libical/src/libicalss/icalclassify.c | 132 |
1 files changed, 47 insertions, 85 deletions
diff --git a/libical/src/libicalss/icalclassify.c b/libical/src/libicalss/icalclassify.c index c029309..61ddbd3 100644 --- a/libical/src/libicalss/icalclassify.c +++ b/libical/src/libicalss/icalclassify.c | |||
@@ -5,52 +5,52 @@ | |||
5 | 5 | ||
6 | $Id$ | 6 | $Id$ |
7 | $Locker$ | 7 | $Locker$ |
8 | 8 | ||
9 | (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org | 9 | (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org |
10 | 10 | ||
11 | This program is free software; you can redistribute it and/or modify | 11 | This program is free software; you can redistribute it and/or modify |
12 | it under the terms of either: | 12 | it under the terms of either: |
13 | 13 | ||
14 | The LGPL as published by the Free Software Foundation, version | 14 | The LGPL as published by the Free Software Foundation, version |
15 | 2.1, available at: http://www.fsf.org/copyleft/lesser.html | 15 | 2.1, available at: http://www.fsf.org/copyleft/lesser.html |
16 | 16 | ||
17 | Or: | 17 | Or: |
18 | 18 | ||
19 | The Mozilla Public License Version 1.0. You may obtain a copy of | 19 | The Mozilla Public License Version 1.0. You may obtain a copy of |
20 | the License at http://www.mozilla.org/MPL/ | 20 | the License at http://www.mozilla.org/MPL/ |
21 | 21 | ||
22 | 22 | ||
23 | ======================================================================*/ | 23 | ======================================================================*/ |
24 | 24 | ||
25 | #ifdef HAVE_CONFIG_H | 25 | #ifdef HAVE_CONFIG_H |
26 | #include "config.h" | 26 | #include "config.h" |
27 | #endif | 27 | #endif |
28 | 28 | ||
29 | #include "icalerror.h" | ||
30 | #include "ical.h" | 29 | #include "ical.h" |
31 | #include "icalclassify.h" | 30 | #include "icalclassify.h" |
32 | #include "icalmemory.h" | 31 | #include "icalmemory.h" |
32 | |||
33 | #include <ctype.h> /* For tolower() */ | 33 | #include <ctype.h> /* For tolower() */ |
34 | #include <string.h> /* for index() */ | 34 | #include <string.h> /* for index() */ |
35 | #include <stdlib.h> /* for malloc and free */ | 35 | #include <stdlib.h> /* for malloc and free */ |
36 | 36 | ||
37 | 37 | ||
38 | 38 | ||
39 | struct icalclassify_parts { | 39 | struct icalclassify_parts { |
40 | icalcomponent *c; | 40 | icalcomponent *c; |
41 | icalcomponent_kind inner_kind; | 41 | icalcomponent_kind inner_kind; |
42 | icalproperty_method method; | 42 | icalproperty_method method; |
43 | char* organizer; | 43 | char* organizer; |
44 | icalparameter_partstat reply_partstat; | 44 | icalparameter_partstat reply_partstat; |
45 | char* reply_attendee; | 45 | char* reply_attendee; |
46 | char* uid; | 46 | char* uid; |
47 | int sequence; | 47 | int sequence; |
48 | struct icaltimetype dtstamp; | 48 | struct icaltimetype dtstamp; |
49 | struct icaltimetype recurrence_id; | 49 | struct icaltimetype recurrence_id; |
50 | }; | 50 | }; |
51 | 51 | ||
52 | 52 | ||
53 | char* icalclassify_lowercase(const char* str) | 53 | char* icalclassify_lowercase(const char* str) |
54 | { | 54 | { |
55 | char* p = 0; | 55 | char* p = 0; |
56 | char* new = icalmemory_strdup(str); | 56 | char* new = icalmemory_strdup(str); |
@@ -125,63 +125,67 @@ icalproperty* icalclassify_find_attendee(icalcomponent *c, | |||
125 | icalproperty *p; | 125 | icalproperty *p; |
126 | icalcomponent* inner; | 126 | icalcomponent* inner; |
127 | char* lattendee; | 127 | char* lattendee; |
128 | char* upn; | 128 | char* upn; |
129 | 129 | ||
130 | if(attendee == 0){ | 130 | if(attendee == 0){ |
131 | return 0; | 131 | return 0; |
132 | } | 132 | } |
133 | 133 | ||
134 | lattendee = icalclassify_lowercase(attendee); | 134 | lattendee = icalclassify_lowercase(attendee); |
135 | upn = strchr(lattendee,':'); | 135 | upn = strchr(lattendee,':'); |
136 | 136 | ||
137 | if (upn== 0){ | 137 | if (upn== 0){ |
138 | upn = lattendee; | 138 | upn = lattendee; |
139 | } else { | 139 | } else { |
140 | upn++; /* skip the ";"*/ | 140 | upn++; /* skip the ";"*/ |
141 | } | 141 | } |
142 | 142 | ||
143 | inner = icalcomponent_get_first_real_component(c); | 143 | inner = icalcomponent_get_first_real_component(c); |
144 | 144 | ||
145 | for(p = icalcomponent_get_first_property(inner,ICAL_ATTENDEE_PROPERTY); | 145 | for(p = icalcomponent_get_first_property(inner,ICAL_ATTENDEE_PROPERTY); |
146 | p != 0; | 146 | p != 0; |
147 | p = icalcomponent_get_next_property(inner,ICAL_ATTENDEE_PROPERTY)) | 147 | p = icalcomponent_get_next_property(inner,ICAL_ATTENDEE_PROPERTY)) |
148 | { | 148 | { |
149 | const char* this_attendee | 149 | char* this_attendee |
150 | = icalclassify_lowercase(icalproperty_get_attendee(p)); | 150 | = icalclassify_lowercase(icalproperty_get_attendee(p)); |
151 | char* this_upn = strchr(this_attendee,':'); | 151 | char* this_upn = strchr(this_attendee,':'); |
152 | 152 | ||
153 | if(this_upn == 0){ | 153 | if(this_upn == 0){ |
154 | continue; | 154 | continue; |
155 | } else { | 155 | } else { |
156 | this_upn++; | 156 | this_upn++; |
157 | } | 157 | } |
158 | 158 | ||
159 | if(strcmp(this_upn,upn)==0){ | 159 | if(strcmp(this_upn,upn)==0){ |
160 | free(lattendee); | ||
161 | free(this_attendee); | ||
160 | return p; | 162 | return p; |
161 | } | 163 | } |
162 | 164 | ||
165 | free(this_attendee); | ||
163 | } | 166 | } |
167 | free(lattendee); | ||
164 | 168 | ||
165 | return 0; | 169 | return 0; |
166 | 170 | ||
167 | } | 171 | } |
168 | 172 | ||
169 | void icalssutil_free_parts(struct icalclassify_parts *parts) | 173 | void icalssutil_free_parts(struct icalclassify_parts *parts) |
170 | { | 174 | { |
171 | if(parts == 0){ | 175 | if(parts == 0){ |
172 | return; | 176 | return; |
173 | } | 177 | } |
174 | 178 | ||
175 | if(parts->organizer != 0){ | 179 | if(parts->organizer != 0){ |
176 | free(parts->organizer); | 180 | free(parts->organizer); |
177 | } | 181 | } |
178 | 182 | ||
179 | if(parts->uid != 0){ | 183 | if(parts->uid != 0){ |
180 | free(parts->uid); | 184 | free(parts->uid); |
181 | } | 185 | } |
182 | 186 | ||
183 | if(parts->reply_attendee){ | 187 | if(parts->reply_attendee){ |
184 | free(parts->reply_attendee); | 188 | free(parts->reply_attendee); |
185 | } | 189 | } |
186 | } | 190 | } |
187 | 191 | ||
@@ -263,49 +267,49 @@ int icalssutil_is_rescheduled(icalcomponent* a,icalcomponent* b) | |||
263 | { | 267 | { |
264 | icalproperty *p1,*p2; | 268 | icalproperty *p1,*p2; |
265 | icalcomponent *i1,*i2; | 269 | icalcomponent *i1,*i2; |
266 | int i; | 270 | int i; |
267 | 271 | ||
268 | icalproperty_kind kind_array[] = { | 272 | icalproperty_kind kind_array[] = { |
269 | ICAL_DTSTART_PROPERTY, | 273 | ICAL_DTSTART_PROPERTY, |
270 | ICAL_DTEND_PROPERTY, | 274 | ICAL_DTEND_PROPERTY, |
271 | ICAL_DURATION_PROPERTY, | 275 | ICAL_DURATION_PROPERTY, |
272 | ICAL_DUE_PROPERTY, | 276 | ICAL_DUE_PROPERTY, |
273 | ICAL_RRULE_PROPERTY, | 277 | ICAL_RRULE_PROPERTY, |
274 | ICAL_RDATE_PROPERTY, | 278 | ICAL_RDATE_PROPERTY, |
275 | ICAL_EXRULE_PROPERTY, | 279 | ICAL_EXRULE_PROPERTY, |
276 | ICAL_EXDATE_PROPERTY, | 280 | ICAL_EXDATE_PROPERTY, |
277 | ICAL_NO_PROPERTY | 281 | ICAL_NO_PROPERTY |
278 | }; | 282 | }; |
279 | 283 | ||
280 | i1 = icalcomponent_get_first_real_component(a); | 284 | i1 = icalcomponent_get_first_real_component(a); |
281 | i2 = icalcomponent_get_first_real_component(b); | 285 | i2 = icalcomponent_get_first_real_component(b); |
282 | 286 | ||
283 | for(i =0; kind_array[i] != ICAL_NO_PROPERTY; i++){ | 287 | for(i =0; kind_array[i] != ICAL_NO_PROPERTY; i++){ |
284 | p1 = icalcomponent_get_first_property(i1,kind_array[i]); | 288 | p1 = icalcomponent_get_first_property(i1,kind_array[i]); |
285 | p2 = icalcomponent_get_first_property(i2,kind_array[i]); | 289 | p2 = icalcomponent_get_first_property(i2,kind_array[i]); |
286 | 290 | ||
287 | if( (p1!=0)^(p1!=0) ){ | 291 | if( (p1!=0)^(p2!=0) ){ |
288 | /* Return true if the property exists in one component and not | 292 | /* Return true if the property exists in one component and not |
289 | the other */ | 293 | the other */ |
290 | return 1; | 294 | return 1; |
291 | } | 295 | } |
292 | 296 | ||
293 | if(p1 && strcmp(icalproperty_as_ical_string(p1), | 297 | if(p1 && strcmp(icalproperty_as_ical_string(p1), |
294 | icalproperty_as_ical_string(p2)) != 0){ | 298 | icalproperty_as_ical_string(p2)) != 0){ |
295 | return 1; | 299 | return 1; |
296 | } | 300 | } |
297 | } | 301 | } |
298 | 302 | ||
299 | return 0; | 303 | return 0; |
300 | 304 | ||
301 | } | 305 | } |
302 | 306 | ||
303 | #define icalclassify_pre \ | 307 | #define icalclassify_pre \ |
304 | int rtrn =0; | 308 | int rtrn =0; |
305 | 309 | ||
306 | #define icalclassify_post \ | 310 | #define icalclassify_post \ |
307 | return rtrn; | 311 | return rtrn; |
308 | 312 | ||
309 | 313 | ||
310 | int icalclassify_publish_new(struct icalclassify_parts *comp, | 314 | int icalclassify_publish_new(struct icalclassify_parts *comp, |
311 | struct icalclassify_parts *match, | 315 | struct icalclassify_parts *match, |
@@ -525,49 +529,48 @@ int icalclassify_reply_delegate( | |||
525 | } | 529 | } |
526 | icalclassify_post | 530 | icalclassify_post |
527 | } | 531 | } |
528 | int icalclassify_reply_crasher_accept( | 532 | int icalclassify_reply_crasher_accept( |
529 | struct icalclassify_parts *comp, | 533 | struct icalclassify_parts *comp, |
530 | struct icalclassify_parts *match, | 534 | struct icalclassify_parts *match, |
531 | const char* user) | 535 | const char* user) |
532 | { | 536 | { |
533 | icalproperty* attendee; | 537 | icalproperty* attendee; |
534 | icalclassify_pre; | 538 | icalclassify_pre; |
535 | 539 | ||
536 | attendee= icalclassify_find_attendee(match->c,comp->reply_attendee); | 540 | attendee= icalclassify_find_attendee(match->c,comp->reply_attendee); |
537 | 541 | ||
538 | if(attendee == 0 && | 542 | if(attendee == 0 && |
539 | comp->reply_partstat == ICAL_PARTSTAT_ACCEPTED){ | 543 | comp->reply_partstat == ICAL_PARTSTAT_ACCEPTED){ |
540 | rtrn = 1; | 544 | rtrn = 1; |
541 | } | 545 | } |
542 | icalclassify_post | 546 | icalclassify_post |
543 | } | 547 | } |
544 | int icalclassify_reply_crasher_decline( | 548 | int icalclassify_reply_crasher_decline( |
545 | struct icalclassify_parts *comp, | 549 | struct icalclassify_parts *comp, |
546 | struct icalclassify_parts *match, | 550 | struct icalclassify_parts *match, |
547 | const char* user) | 551 | const char* user) |
548 | { | 552 | { |
549 | icalparameter_partstat partstat; | ||
550 | icalproperty* attendee; | 553 | icalproperty* attendee; |
551 | icalclassify_pre; | 554 | icalclassify_pre; |
552 | 555 | ||
553 | 556 | ||
554 | attendee = icalclassify_find_attendee(match->c,comp->reply_attendee); | 557 | attendee = icalclassify_find_attendee(match->c,comp->reply_attendee); |
555 | 558 | ||
556 | if(attendee == 0 && | 559 | if(attendee == 0 && |
557 | comp->reply_partstat == ICAL_PARTSTAT_DECLINED){ | 560 | comp->reply_partstat == ICAL_PARTSTAT_DECLINED){ |
558 | rtrn = 1; | 561 | rtrn = 1; |
559 | } | 562 | } |
560 | icalclassify_post | 563 | icalclassify_post |
561 | } | 564 | } |
562 | int icalclassify_add_instance( | 565 | int icalclassify_add_instance( |
563 | struct icalclassify_parts *comp, | 566 | struct icalclassify_parts *comp, |
564 | struct icalclassify_parts *match, | 567 | struct icalclassify_parts *match, |
565 | const char* user) | 568 | const char* user) |
566 | { | 569 | { |
567 | icalclassify_pre | 570 | icalclassify_pre |
568 | if(comp->method == ICAL_METHOD_ADD){ | 571 | if(comp->method == ICAL_METHOD_ADD){ |
569 | rtrn = 1; | 572 | rtrn = 1; |
570 | } | 573 | } |
571 | icalclassify_post | 574 | icalclassify_post |
572 | } | 575 | } |
573 | int icalclassify_cancel_event( | 576 | int icalclassify_cancel_event( |
@@ -621,172 +624,131 @@ int icalclassify_counter( | |||
621 | { | 624 | { |
622 | icalclassify_pre | 625 | icalclassify_pre |
623 | if(comp->method == ICAL_METHOD_COUNTER){ | 626 | if(comp->method == ICAL_METHOD_COUNTER){ |
624 | rtrn = 1; | 627 | rtrn = 1; |
625 | } | 628 | } |
626 | icalclassify_post | 629 | icalclassify_post |
627 | } | 630 | } |
628 | int icalclassify_delinecounter( | 631 | int icalclassify_delinecounter( |
629 | struct icalclassify_parts *comp, | 632 | struct icalclassify_parts *comp, |
630 | struct icalclassify_parts *match, | 633 | struct icalclassify_parts *match, |
631 | const char* user) | 634 | const char* user) |
632 | { | 635 | { |
633 | icalclassify_pre | 636 | icalclassify_pre |
634 | 637 | ||
635 | if(comp->method == ICAL_METHOD_DECLINECOUNTER){ | 638 | if(comp->method == ICAL_METHOD_DECLINECOUNTER){ |
636 | rtrn = 1; | 639 | rtrn = 1; |
637 | } | 640 | } |
638 | 641 | ||
639 | icalclassify_post | 642 | icalclassify_post |
640 | } | 643 | } |
641 | 644 | ||
642 | struct icalclassify_map { | 645 | struct icalclassify_map { |
643 | icalproperty_method method; | 646 | icalproperty_method method; |
644 | int (*fn)(struct icalclassify_parts *comp,struct icalclassify_parts *match, const char* user); | 647 | int (*fn)(struct icalclassify_parts *comp,struct icalclassify_parts *match, const char* user); |
645 | ical_class class; | 648 | icalproperty_xlicclass class; |
646 | } icalclassify_map[] = | 649 | } icalclassify_map[] = |
647 | { {ICAL_METHOD_PUBLISH,icalclassify_publish_new,ICAL_PUBLISH_NEW_CLASS}, | 650 | { {ICAL_METHOD_PUBLISH,icalclassify_publish_new,ICAL_XLICCLASS_PUBLISHNEW}, |
648 | {ICAL_METHOD_PUBLISH,icalclassify_publish_update,ICAL_PUBLISH_UPDATE_CLASS}, | 651 | {ICAL_METHOD_PUBLISH,icalclassify_publish_update,ICAL_XLICCLASS_PUBLISHUPDATE}, |
649 | {ICAL_METHOD_PUBLISH,icalclassify_publish_freebusy,ICAL_PUBLISH_FREEBUSY_CLASS}, | 652 | {ICAL_METHOD_PUBLISH,icalclassify_publish_freebusy,ICAL_XLICCLASS_PUBLISHFREEBUSY}, |
650 | {ICAL_METHOD_REQUEST,icalclassify_request_delegate,ICAL_REQUEST_DELEGATE_CLASS}, | 653 | {ICAL_METHOD_REQUEST,icalclassify_request_delegate,ICAL_XLICCLASS_REQUESTDELEGATE}, |
651 | {ICAL_METHOD_REQUEST,icalclassify_request_new,ICAL_REQUEST_NEW_CLASS}, | 654 | {ICAL_METHOD_REQUEST,icalclassify_request_new,ICAL_XLICCLASS_REQUESTNEW}, |
652 | {ICAL_METHOD_REQUEST,icalclassify_request_update,ICAL_REQUEST_UPDATE_CLASS}, | 655 | {ICAL_METHOD_REQUEST,icalclassify_request_update,ICAL_XLICCLASS_REQUESTUPDATE}, |
653 | {ICAL_METHOD_REQUEST,icalclassify_request_reschedule,ICAL_REQUEST_RESCHEDULE_CLASS}, | 656 | {ICAL_METHOD_REQUEST,icalclassify_request_reschedule,ICAL_XLICCLASS_REQUESTRESCHEDULE}, |
654 | 657 | ||
655 | {ICAL_METHOD_REQUEST,icalclassify_request_new_organizer,ICAL_REQUEST_NEW_ORGANIZER_CLASS}, | 658 | {ICAL_METHOD_REQUEST,icalclassify_request_new_organizer,ICAL_XLICCLASS_REQUESTNEWORGANIZER}, |
656 | {ICAL_METHOD_REQUEST,icalclassify_request_forward,ICAL_REQUEST_FORWARD_CLASS}, | 659 | {ICAL_METHOD_REQUEST,icalclassify_request_forward,ICAL_XLICCLASS_REQUESTFORWARD}, |
657 | {ICAL_METHOD_REQUEST,icalclassify_request_status,ICAL_REQUEST_STATUS_CLASS}, | 660 | {ICAL_METHOD_REQUEST,icalclassify_request_status,ICAL_XLICCLASS_REQUESTSTATUS}, |
658 | {ICAL_METHOD_REQUEST,icalclassify_request_freebusy,ICAL_REQUEST_FREEBUSY_CLASS}, | 661 | {ICAL_METHOD_REQUEST,icalclassify_request_freebusy,ICAL_XLICCLASS_REQUESTFREEBUSY}, |
659 | 662 | ||
660 | {ICAL_METHOD_REPLY,icalclassify_reply_accept,ICAL_REPLY_ACCEPT_CLASS}, | 663 | {ICAL_METHOD_REPLY,icalclassify_reply_accept,ICAL_XLICCLASS_REPLYACCEPT}, |
661 | {ICAL_METHOD_REPLY,icalclassify_reply_decline,ICAL_REPLY_DECLINE_CLASS}, | 664 | {ICAL_METHOD_REPLY,icalclassify_reply_decline,ICAL_XLICCLASS_REPLYDECLINE}, |
662 | {ICAL_METHOD_REPLY,icalclassify_reply_delegate,ICAL_REPLY_DELEGATE_CLASS}, | 665 | {ICAL_METHOD_REPLY,icalclassify_reply_delegate,ICAL_XLICCLASS_REPLYDELEGATE}, |
663 | {ICAL_METHOD_REPLY,icalclassify_reply_crasher_accept,ICAL_REPLY_CRASHER_ACCEPT_CLASS}, | 666 | {ICAL_METHOD_REPLY,icalclassify_reply_crasher_accept,ICAL_XLICCLASS_REPLYCRASHERACCEPT}, |
664 | {ICAL_METHOD_REPLY,icalclassify_reply_crasher_decline,ICAL_REPLY_CRASHER_DECLINE_CLASS}, | 667 | {ICAL_METHOD_REPLY,icalclassify_reply_crasher_decline,ICAL_XLICCLASS_REPLYCRASHERDECLINE}, |
665 | 668 | ||
666 | {ICAL_METHOD_ADD,icalclassify_add_instance,ICAL_ADD_INSTANCE_CLASS}, | 669 | {ICAL_METHOD_ADD,icalclassify_add_instance,ICAL_XLICCLASS_ADDINSTANCE}, |
667 | 670 | ||
668 | {ICAL_METHOD_CANCEL,icalclassify_cancel_event,ICAL_CANCEL_EVENT_CLASS}, | 671 | {ICAL_METHOD_CANCEL,icalclassify_cancel_event,ICAL_XLICCLASS_CANCELEVENT}, |
669 | {ICAL_METHOD_CANCEL,icalclassify_cancel_instance,ICAL_CANCEL_INSTANCE_CLASS}, | 672 | {ICAL_METHOD_CANCEL,icalclassify_cancel_instance,ICAL_XLICCLASS_CANCELINSTANCE}, |
670 | {ICAL_METHOD_CANCEL,icalclassify_cancel_all,ICAL_CANCEL_ALL_CLASS}, | 673 | {ICAL_METHOD_CANCEL,icalclassify_cancel_all,ICAL_XLICCLASS_CANCELALL}, |
671 | 674 | ||
672 | {ICAL_METHOD_REFRESH,icalclassify_refesh,ICAL_REFRESH_CLASS}, | 675 | {ICAL_METHOD_REFRESH,icalclassify_refesh,ICAL_XLICCLASS_REFRESH}, |
673 | {ICAL_METHOD_COUNTER,icalclassify_counter,ICAL_COUNTER_CLASS}, | 676 | {ICAL_METHOD_COUNTER,icalclassify_counter,ICAL_XLICCLASS_COUNTER}, |
674 | {ICAL_METHOD_DECLINECOUNTER,icalclassify_delinecounter,ICAL_DECLINECOUNTER_CLASS}, | 677 | {ICAL_METHOD_DECLINECOUNTER,icalclassify_delinecounter,ICAL_XLICCLASS_DECLINECOUNTER}, |
675 | {ICAL_METHOD_NONE,0,ICAL_NO_CLASS} | 678 | {ICAL_METHOD_NONE,0,ICAL_XLICCLASS_NONE} |
676 | }; | 679 | }; |
677 | 680 | ||
678 | 681 | ||
679 | ical_class icalclassify(icalcomponent* c,icalcomponent* match, | 682 | icalproperty_xlicclass icalclassify(icalcomponent* c,icalcomponent* match, |
680 | const char* user) | 683 | const char* user) |
681 | { | 684 | { |
682 | icalcomponent *inner; | 685 | icalcomponent *inner; |
683 | icalproperty *p; | 686 | icalproperty *p; |
684 | icalproperty_method method; | 687 | icalproperty_method method; |
685 | ical_class class = ICAL_UNKNOWN_CLASS; | 688 | icalproperty_xlicclass class = ICAL_XLICCLASS_UNKNOWN; |
686 | 689 | ||
687 | int i; | 690 | int i; |
688 | 691 | ||
689 | struct icalclassify_parts comp_parts; | 692 | struct icalclassify_parts comp_parts; |
690 | struct icalclassify_parts match_parts; | 693 | struct icalclassify_parts match_parts; |
691 | 694 | ||
692 | inner = icalcomponent_get_first_real_component(c); | 695 | inner = icalcomponent_get_first_real_component(c); |
693 | 696 | ||
694 | if (inner == 0) { | 697 | if (inner == 0) { |
695 | return ICAL_NO_CLASS; | 698 | return ICAL_XLICCLASS_NONE; |
696 | } | 699 | } |
697 | 700 | ||
698 | icalssutil_get_parts(c,&comp_parts); | 701 | icalssutil_get_parts(c,&comp_parts); |
699 | icalssutil_get_parts(match,&match_parts); | 702 | icalssutil_get_parts(match,&match_parts); |
700 | 703 | ||
701 | /* Determine if the incoming component is obsoleted by the match */ | 704 | /* Determine if the incoming component is obsoleted by the match */ |
702 | if(match != 0 && ( | 705 | if(match != 0 && ( |
703 | comp_parts.method == ICAL_METHOD_REQUEST | 706 | comp_parts.method == ICAL_METHOD_REQUEST |
704 | )){ | 707 | )){ |
705 | assert ( ! ((comp_parts.dtstamp.is_utc==1)^ | 708 | assert ( ! ((comp_parts.dtstamp.is_utc==1)^ |
706 | (match_parts.dtstamp.is_utc==1))); | 709 | (match_parts.dtstamp.is_utc==1))); |
707 | 710 | ||
708 | if( comp_parts.sequence<match_parts.sequence && | 711 | if( comp_parts.sequence<match_parts.sequence && |
709 | icaltime_compare(comp_parts.dtstamp,match_parts.dtstamp)>0) | 712 | icaltime_compare(comp_parts.dtstamp,match_parts.dtstamp)>0) |
710 | { | 713 | { |
711 | /* comp has a smaller sequence and a later DTSTAMP */ | 714 | /* comp has a smaller sequence and a later DTSTAMP */ |
712 | return ICAL_MISSEQUENCED_CLASS; | 715 | class = ICAL_XLICCLASS_MISSEQUENCED; |
716 | goto CLEANUP; | ||
713 | } | 717 | } |
714 | 718 | ||
715 | if( (comp_parts.sequence<match_parts.sequence ) | 719 | if( (comp_parts.sequence<match_parts.sequence ) |
716 | /*&&icaltime_compare(comp_parts.dtstamp,match_parts.dtstamp)<=0*/ | 720 | /*&&icaltime_compare(comp_parts.dtstamp,match_parts.dtstamp)<=0*/ |
717 | || | 721 | || |
718 | ( comp_parts.sequence == match_parts.sequence && | 722 | ( comp_parts.sequence == match_parts.sequence && |
719 | icaltime_compare(comp_parts.dtstamp,match_parts.dtstamp)<=0)){ | 723 | icaltime_compare(comp_parts.dtstamp,match_parts.dtstamp)<=0)){ |
720 | 724 | ||
721 | return ICAL_OBSOLETE_CLASS; | 725 | class = ICAL_XLICCLASS_OBSOLETE; |
726 | goto CLEANUP; | ||
722 | } | 727 | } |
723 | 728 | ||
724 | } | 729 | } |
725 | 730 | ||
726 | p = icalcomponent_get_first_property(c,ICAL_METHOD_PROPERTY); | 731 | p = icalcomponent_get_first_property(c,ICAL_METHOD_PROPERTY); |
727 | if (p == 0) { | 732 | if (p == 0) { |
728 | return ICAL_UNKNOWN_CLASS; | 733 | class = ICAL_XLICCLASS_UNKNOWN; |
734 | goto CLEANUP; | ||
729 | } | 735 | } |
730 | method = icalproperty_get_method(p); | 736 | method = icalproperty_get_method(p); |
731 | 737 | ||
732 | for (i =0; icalclassify_map[i].method != ICAL_METHOD_NONE; i++){ | 738 | for (i =0; icalclassify_map[i].method != ICAL_METHOD_NONE; i++){ |
733 | if(icalclassify_map[i].method == method){ | 739 | if(icalclassify_map[i].method == method){ |
734 | if( (*(icalclassify_map[i].fn))(&comp_parts,&match_parts,user)==1){ | 740 | if( (*(icalclassify_map[i].fn))(&comp_parts,&match_parts,user)==1){ |
735 | class = icalclassify_map[i].class; | 741 | class = icalclassify_map[i].class; |
736 | break; | 742 | break; |
737 | } | 743 | } |
738 | } | 744 | } |
739 | } | 745 | } |
740 | 746 | ||
747 | CLEANUP: | ||
741 | icalssutil_free_parts(&comp_parts); | 748 | icalssutil_free_parts(&comp_parts); |
742 | icalssutil_free_parts(&match_parts); | 749 | icalssutil_free_parts(&match_parts); |
743 | 750 | ||
744 | return class; | 751 | return class; |
745 | 752 | ||
746 | } | 753 | } |
747 | 754 | ||
748 | struct class_map { | ||
749 | ical_class class; | ||
750 | char *str; | ||
751 | } class_map[] = { | ||
752 | {ICAL_NO_CLASS,"No class"}, | ||
753 | {ICAL_PUBLISH_NEW_CLASS,"New Publish"}, | ||
754 | {ICAL_PUBLISH_UPDATE_CLASS,"Publish Update"}, | ||
755 | {ICAL_PUBLISH_FREEBUSY_CLASS,"Publish freebusy"}, | ||
756 | {ICAL_REQUEST_NEW_CLASS,"New request"}, | ||
757 | {ICAL_REQUEST_UPDATE_CLASS,"Update"}, | ||
758 | {ICAL_REQUEST_RESCHEDULE_CLASS,"Reschedule"}, | ||
759 | {ICAL_REQUEST_DELEGATE_CLASS,"Delegate request"}, | ||
760 | {ICAL_REQUEST_NEW_ORGANIZER_CLASS,"New Organizer"}, | ||
761 | {ICAL_REQUEST_FORWARD_CLASS,"Forward"}, | ||
762 | {ICAL_REQUEST_STATUS_CLASS,"Status request"}, | ||
763 | {ICAL_REPLY_ACCEPT_CLASS,"Accept reply"}, | ||
764 | {ICAL_REPLY_DECLINE_CLASS,"Decline reply"}, | ||
765 | {ICAL_REPLY_DELEGATE_CLASS,"Delegation reply"}, | ||
766 | {ICAL_REPLY_CRASHER_ACCEPT_CLASS,"Crasher's accept reply"}, | ||
767 | {ICAL_REPLY_CRASHER_DECLINE_CLASS,"Crasher's decline reply"}, | ||
768 | {ICAL_ADD_INSTANCE_CLASS,"Add instance"}, | ||
769 | {ICAL_CANCEL_EVENT_CLASS,"Cancel event"}, | ||
770 | {ICAL_CANCEL_INSTANCE_CLASS,"Cancel instance"}, | ||
771 | {ICAL_CANCEL_ALL_CLASS,"Cancel all instances"}, | ||
772 | {ICAL_REFRESH_CLASS,"Refresh"}, | ||
773 | {ICAL_COUNTER_CLASS,"Counter"}, | ||
774 | {ICAL_DECLINECOUNTER_CLASS,"Decline counter"}, | ||
775 | {ICAL_MALFORMED_CLASS,"Malformed"}, | ||
776 | {ICAL_OBSOLETE_CLASS,"Obsolete"}, | ||
777 | {ICAL_MISSEQUENCED_CLASS,"Missequenced"}, | ||
778 | {ICAL_UNKNOWN_CLASS,"Unknown"} | ||
779 | }; | ||
780 | |||
781 | char* icalclassify_class_to_string(ical_class class) | ||
782 | { | ||
783 | int i; | ||
784 | |||
785 | for (i = 0;class_map[i].class != ICAL_UNKNOWN_CLASS;i++){ | ||
786 | if (class_map[i].class == class){ | ||
787 | return class_map[i].str; | ||
788 | } | ||
789 | } | ||
790 | |||
791 | return "Unknown"; | ||
792 | } | ||