7 files changed, 85 insertions, 381 deletions

diff --git a/libical/src/libicalss/icalclassify.c b/libical/src/libicalss/icalclassify.c
index 89761d8120..ad2d6d6fd8 100644
--- a/libical/src/libicalss/icalclassify.c
+++ b/libical/src/libicalss/icalclassify.c
@@ -117,7 +117,7 @@ icalcomponent* icalclassify_find_overlaps(icalset* set, icalcomponent* comp)
 
 
 
-icalparameter_partstat icalclassify_find_attendee(icalcomponent *c, 
+icalproperty* icalclassify_find_attendee(icalcomponent *c, 
 						  const char* attendee)
 {
     icalproperty *p;
@@ -133,22 +133,17 @@ icalparameter_partstat icalclassify_find_attendee(icalcomponent *c,
 	    = icalclassify_lowercase(icalproperty_get_attendee(p));
 	char* this_upn = strchr(this_attendee,':');
 
-	if(strcmp(this_upn,upn)==0){
-
-	    icalparameter *param = icalproperty_get_first_parameter(p,
-					    ICAL_PARTSTAT_PARAMETER);
-	    if (param != 0){
-		free(lattendee);
-		free((void*)this_attendee);
-		return icalparameter_get_partstat(param);
-	    }
+        if(this_upn == 0){
+            continue;
+        } 
 
+	if(strcmp(this_upn,upn)==0){
+            return p;
 	}
 
     }
 
-    free(lattendee);
-    return ICAL_PARTSTAT_NONE;
+    return 0;
 
 }
 
@@ -453,12 +448,12 @@ int icalclassify_reply_accept(
     struct icalclassify_parts *match, 
     const char* user)
 {
-    icalparameter_partstat partstat;
+    icalproperty* attendee;
     icalclassify_pre;
 
-    partstat = icalclassify_find_attendee(match->c,comp->reply_attendee);
+    attendee = icalclassify_find_attendee(match->c,comp->reply_attendee);
 
-    if(partstat != ICAL_PARTSTAT_NONE &&
+    if(attendee != 0&&
        comp->reply_partstat == ICAL_PARTSTAT_ACCEPTED){
 	rtrn = 1;
     }
@@ -470,13 +465,13 @@ int icalclassify_reply_decline(
     struct icalclassify_parts *match, 
     const char* user)
 {
-    icalparameter_partstat partstat;
+    icalproperty* attendee;
     icalclassify_pre;
 
+    attendee = icalclassify_find_attendee(match->c,comp->reply_attendee);
 
-    partstat = icalclassify_find_attendee(match->c,comp->reply_attendee);
 
-    if(partstat != ICAL_PARTSTAT_NONE &&
+    if( attendee != 0 &&
        comp->reply_partstat == ICAL_PARTSTAT_DECLINED){
 	rtrn = 1;
     }
@@ -487,13 +482,12 @@ int icalclassify_reply_crasher_accept(
     struct icalclassify_parts *match, 
     const char* user)
 {
-    icalparameter_partstat partstat;
+    icalproperty* attendee;
     icalclassify_pre;
 
+    attendee= icalclassify_find_attendee(match->c,comp->reply_attendee);
 
-    partstat = icalclassify_find_attendee(match->c,comp->reply_attendee);
-
-    if(partstat == ICAL_PARTSTAT_NONE &&
+    if(attendee == 0 &&
        comp->reply_partstat == ICAL_PARTSTAT_ACCEPTED){
 	rtrn = 1;
     }
@@ -505,12 +499,13 @@ int icalclassify_reply_crasher_decline(
     const char* user)
 {
     icalparameter_partstat partstat;
+    icalproperty* attendee;
     icalclassify_pre;
 
 
-    partstat = icalclassify_find_attendee(match->c,comp->reply_attendee);
+    attendee = icalclassify_find_attendee(match->c,comp->reply_attendee);
 
-    if(partstat == ICAL_PARTSTAT_NONE &&
+    if(attendee == 0 &&
        comp->reply_partstat == ICAL_PARTSTAT_DECLINED){
 	rtrn = 1;
     }
diff --git a/libical/src/libicalss/icalcstp.c b/libical/src/libicalss/icalcstp.c
index 53ee7bdeef..3b212b424a 100644
--- a/libical/src/libicalss/icalcstp.c
+++ b/libical/src/libicalss/icalcstp.c
@@ -37,380 +37,80 @@
 #include <stdlib.h> /* for malloc */
 #include <string.h>
 
-enum cstps_state {
-    NO_STATE,
-    CONNECTED,
-    AUTHENTICATED,
-    IDENTIFIED,
-    DISCONNECTED,
-    RECEIVE,
-};
-
-struct icalcstps_impl {
-	int timeout;
-	icalparser *parser;
-	enum cstps_state major_state;
-	struct icalcstps_stubs stubs;
-};
-
-
-enum cstp_command {
-    ABORT,
-    AUTHENTICATE,
-    CAPABILITY,
-    CONTINUE,
-    EXPANDCALID,
-    IDENTIFY,
-    DISCONNECT,
-    SENDDATA,
-    STARTTLS,
-    EXPANDUPN,
-    COMMAND_COMPLETE,
-    UNKNOWN
-};
 
 struct command_map {
-	enum cstp_command command;
+	enum icalcstp_command command;
 	char *str;
 } command_map[] = 
 {
-    {ABORT,"ABORT"},
-    {AUTHENTICATE,"AUTHENTICATE"},
-    {CAPABILITY,"CAPABILITY"},
-    {CONTINUE,"CONTINUE"},
-    {EXPANDCALID,"EXPANDCALID"},
-    {IDENTIFY,"IDENTIFY"},
-    {DISCONNECT,"DISCONNECT"},
-    {SENDDATA,"SENDDATA"},
-    {STARTTLS,"STARTTLS"},
-    {EXPANDUPN,"EXPANDUPN"},
-    {UNKNOWN,"UNKNOWN"}
+    {ICAL_ABORT_COMMAND,"ABORT"},
+    {ICAL_AUTHENTICATE_COMMAND,"AUTHENTICATE"},
+    {ICAL_CAPABILITY_COMMAND,"CAPABILITY"},
+    {ICAL_CONTINUE_COMMAND,"CONTINUE"},
+    {ICAL_CALIDEXPAND_COMMAND,"CALIDEXPAND"},
+    {ICAL_IDENTIFY_COMMAND,"IDENTIFY"},
+    {ICAL_DISCONNECT_COMMAND,"DISCONNECT"},
+    {ICAL_SENDDATA_COMMAND,"SENDDATA"},
+    {ICAL_STARTTLS_COMMAND,"STARTTLS"},
+    {ICAL_UPNEXPAND_COMMAND,"UPNEXPAND"},
+    {ICAL_UNKNOWN_COMMAND,"UNKNOWN"}
 };
 
 
-
-/* This state machine is a Mealy-type: actions occur on the
-   transitions, not in the states.
-   
-   Here is the state machine diagram from the CAP draft:
-
-
-        STARTTLS /
-        CAPABILITY
-       +-------+
-       |       |                       +---------------+
-       |   +-----------+ AUTHENTICATE  |               |
-       +-->| Connected |-------------->| Authenticated |
-           +-----------+               |               |
-             |                         +---------------+
-             |                              |
-             |                              |
-             |                              |
-             |                              |       +-----+ STARTTLS /
-             |                              V       |     | CAPABILITY /
-             |                         +---------------+  | IDENTIFY
-             |                         |               |<-+
-             |                         |   Identified  |<----+
-             |                +--------|               |     |
-             |                |        +---------------+     | command
-             |                |             |                | completes
-             V                |DISCONNECT   |                |
-           +--------------+   |             |SENDDATA        |
-           | Disconnected |<--+             |                |
-           +--------------+                 |                | ABORT
-                     A                      |                |
-                     |                      V                |
-                     |     DISCONNECT     +---------------+  |
-                     +--------------------|    Receive    |--+
-                                          |               |<--+
-                                          +---------------+   |
-                                                         |    | CONTINUTE
-                                                         +----+
-
-   In this implmenetation, the transition from CONNECTED to IDENTIFIED
-   is non-standard. The spec specifies that on the ATHENTICATE
-   command, the machine transitions from CONNECTED to AUTHENTICATED,
-   and then immediately goes to IDENTIFIED. This makes AUTHENTICATED a
-   useless state, so I removed it */
-
-struct state_table {
-	enum cstps_state major_state;
-	enum cstp_command command;
-	void (*action)();
-	enum cstps_state next_state;
-
-} server_state_table[] = 
+icalcstp_command icalcstp_line_command(char* line)
 {
-    { CONNECTED, CAPABILITY , 0, CONNECTED},
-    { CONNECTED, AUTHENTICATE , 0,  IDENTIFIED}, /* Non-standard */
-    { IDENTIFIED, STARTTLS, 0, IDENTIFIED},
-    { IDENTIFIED, IDENTIFY, 0, IDENTIFIED},
-    { IDENTIFIED, CAPABILITY, 0, IDENTIFIED},
-    { IDENTIFIED, SENDDATA, 0, RECEIVE},
-    { IDENTIFIED, DISCONNECT, 0, DISCONNECTED},
-    { DISCONNECTED, 0, 0, 0},
-    { RECEIVE,  DISCONNECT, 0, DISCONNECTED},
-    { RECEIVE,  CONTINUE, 0, RECEIVE},
-    { RECEIVE,  ABORT , 0, IDENTIFIED},
-    { RECEIVE,  COMMAND_COMPLETE , 0, IDENTIFIED}
-};
+    int i;
 
+    for(i = 0; command_map[i].command != ICAL_UNKNOWN_COMMAND; i++){
+        size_t l = strlen(command_map[i].str);
 
-/**********************************************************************/
-
-
-
-icalcstps* icalcstps_new(struct icalcstps_stubs stubs)
-{
-    struct icalcstps_impl* impl;
-
-    if ( ( impl = (struct icalcstps_impl*)
-	   malloc(sizeof(struct icalcstps_impl))) == 0) {
-	icalerror_set_errno(ICAL_NEWFAILED_ERROR);
-	return 0;
+        if(strncmp(line, command_map[i].str, l) == 0){
+            return command_map[i].command;
+        }
+    
     }
 
-    impl->stubs = stubs;
-    impl->timeout = 10;
-
-    return (icalcstps*)impl;
-
+    return ICAL_UNKNOWN_COMMAND;
 }
 
-void icalcstps_free(icalcstps* cstp);
-
-int icalcstps_set_timeout(icalcstps* cstp, int sec) 
+icalrequeststatus icalcstp_line_response_code(char* line)
 {
-    struct icalcstps_impl *impl = (struct icalcstps_impl *) cstp;
+    struct icalreqstattype rs; 
 
-    icalerror_check_arg_rz( (cstp!=0), "cstp");
+    rs = icalreqstattype_from_string(line);
 
-    impl->timeout = sec;
-
-    return sec;
+    return rs.code;
 }
 
-typedef struct icalcstps_response {	
-	icalrequeststatus code;
-	char caluid[1024];
-	void* result;
-} icalcstps_response;
-
-int line_is_command(char* line);
-int line_is_response(char* line);
-int line_is_endofdata(char* line);
-int line_is_mime(char* line);
-
-icalerrorenum prep_abort(struct icalcstps_impl* impl, char* data)
+int icalcstp_line_is_endofdata(char* line)
 {
-    return ICAL_NO_ERROR;
-}
-icalerrorenum prep_authenticate(struct icalcstps_impl* impl, char* data)
-{    return ICAL_NO_ERROR;
-}
-icalerrorenum prep_capability(struct icalcstps_impl* impl, char* data)
-{    return ICAL_NO_ERROR;
-}
-icalerrorenum prep_calidexpand(struct icalcstps_impl* impl, char* data)
-{
-    return ICAL_NO_ERROR;
-}
-icalerrorenum prep_continue(struct icalcstps_impl* impl, char* data)
-{
-    return ICAL_NO_ERROR;
-}
-icalerrorenum prep_disconnect(struct icalcstps_impl* impl, char* data)
-{
-    return ICAL_NO_ERROR;
-}
-icalerrorenum prep_identify(struct icalcstps_impl* impl, char* data)
-{
-    return ICAL_NO_ERROR;
-}
-icalerrorenum prep_starttls(struct icalcstps_impl* impl, char* data)
-{
-    return ICAL_NO_ERROR;
-}
-icalerrorenum prep_upnexpand(struct icalcstps_impl* impl, char* data)
-{
-    return ICAL_NO_ERROR;
-}
-icalerrorenum prep_sendata(struct icalcstps_impl* impl, char* data)
-{    return ICAL_NO_ERROR;
-}
-
-char* icalcstps_process_incoming(icalcstps* cstp, char* input)
-{
-    struct icalcstps_impl *impl = (struct icalcstps_impl *) cstp;
-    char *i;
-    char *cmd_or_resp;
-    char *data;
-    char *input_cpy;
-    icalerrorenum error;
-
-    icalerror_check_arg_rz(cstp !=0,"cstp");
-    icalerror_check_arg_rz(input !=0,"input");
-
-    if ((input_cpy = (char*)strdup(input)) == 0){
-	icalerror_set_errno(ICAL_NEWFAILED_ERROR);
-	return 0;
-    }
-
-    i = (char*)strstr(" ",input_cpy);
-
-    cmd_or_resp = input_cpy;
-
-    if (i != 0){
-	*i = '\0';
-	data = ++i;
-    } else {
-	data = 0;
+    if(line[0] == '.' && line[1] == '\n'){
+        return 1;
     }
 
-    printf("cmd: %s\n",cmd_or_resp);
-    printf("data: %s\n",data);
-	
-    /* extract the command, look up in the state table, and dispatch
-       to the proper handler */    
-
-    if(strcmp(cmd_or_resp,"ABORT") == 0){
-	error = prep_abort(impl,data);	
-    } else if(strcmp(cmd_or_resp,"AUTHENTICATE") == 0){
-	error = prep_authenticate(impl,data);
-    } else if(strcmp(cmd_or_resp,"CAPABILITY") == 0){
-	error = prep_capability(impl,data);
-    } else if(strcmp(cmd_or_resp,"CALIDEXPAND") == 0){
-	error = prep_calidexpand(impl,data);
-    } else if(strcmp(cmd_or_resp,"CONTINUE") == 0){
-	error = prep_continue(impl,data);
-    } else if(strcmp(cmd_or_resp,"DISCONNECT") == 0){
-	error = prep_disconnect(impl,data);
-    } else if(strcmp(cmd_or_resp,"IDENTIFY") == 0){
-	error = prep_identify(impl,data);
-    } else if(strcmp(cmd_or_resp,"STARTTLS") == 0){
-	error = prep_starttls(impl,data);
-    } else if(strcmp(cmd_or_resp,"UPNEXPAND") == 0){
-	error = prep_upnexpand(impl,data);
-    } else if(strcmp(cmd_or_resp,"SENDDATA") == 0){
-	error = prep_sendata(impl,data);
-    }
-    
     return 0;
-}
-
-    /* Read data until we get a end of data marker */
-
-
-
-struct icalcstps_server_stubs {
-  icalerrorenum (*abort)(icalcstps* cstp);
-  icalerrorenum (*authenticate)(icalcstps* cstp, char* mechanism, 
-                                    char* data);
-  icalerrorenum (*calidexpand)(icalcstps* cstp, char* calid);
-  icalerrorenum (*capability)(icalcstps* cstp);
-  icalerrorenum (*cont)(icalcstps* cstp, unsigned int time);
-  icalerrorenum (*identify)(icalcstps* cstp, char* id);
-  icalerrorenum (*disconnect)(icalcstps* cstp);
-  icalerrorenum (*sendata)(icalcstps* cstp, unsigned int time, 
-                               icalcomponent *comp);
-  icalerrorenum (*starttls)(icalcstps* cstp, char* command, 
-                                char* data);
-  icalerrorenum (*upnexpand)(icalcstps* cstp, char* upn);
-  icalerrorenum (*unknown)(icalcstps* cstp, char* command, char* data);
-};
-
-
-/********************** Client (Sender) Interfaces **************************/
-
-struct icalcstpc_impl {
-	int timeout;
-	icalparser *parser;
-	enum cstp_command command;
-	char* next_output;
-	char* next_input;	
-};
 
-icalcstps* icalcstpc_new();
-
-void* icalcstpc_free(icalcstpc* cstpc);
-
-/* Get the next string to send to the server */
-char* icalcstpc_next_output(icalcstpc* cstp)
-{
-    return 0;
 }
 
-/* process the next string to send to the server */ 
-int icalcstpc_next_input(icalcstpc* cstp)
+int icalcstp_line_is_mime(char* line)
 {
-    return 0;
 }
 
-/* After icalcstpc_next_input returns a 0, there are responses
-   ready. use these to get them */
-icalcstpc_response icalcstpc_first_response(icalcstpc* cstp);
-icalcstpc_response icalcstpc_next_response(icalcstpc* cstp);
-
-int icalcstpc_set_timeout(icalcstpc* cstp, int sec);
 
-icalerrorenum icalcstpc_abort(icalcstpc* cstp)
-{
-    struct icalcstpc_impl* impl = (struct icalcstpc_impl*)cstp;
-
-    icalerror_check_arg_re(cstp!=0,"cstp",ICAL_BADARG_ERROR);
-
-    impl->next_output = "ABORT";
+const char* icalcstp_command_to_string(icalcstp_command command){
 
-    return ICAL_NO_ERROR;
-}
+    int i;
 
-icalerrorenum icalcstpc_authenticate(icalcstpc* cstp, char* mechanism, 
-                                        char* data, char* f(char*))
-{
-    return ICAL_NO_ERROR;
-}
+    for(i = 0; command_map[i].command != ICAL_UNKNOWN_COMMAND; i++){
+        size_t l = strlen(command_map[i].str);
 
-icalerrorenum icalcstpc_capability(icalcstpc* cstp)
-{
-    return ICAL_NO_ERROR;}
-
-icalerrorenum icalcstpc_calidexpand(icalcstpc* cstp,char* calid)
-{
-    return ICAL_NO_ERROR;
-}
-
-icalerrorenum icalcstpc_continue(icalcstpc* cstp, unsigned int time)
-{
-    return ICAL_NO_ERROR;
-}
-
-icalerrorenum icalcstpc_disconnect(icalcstpc* cstp)
-{
-    return ICAL_NO_ERROR;
-}
-
-icalerrorenum icalcstpc_identify(icalcstpc* cstp, char* id)
-{
-    return ICAL_NO_ERROR;
-}
-
-icalerrorenum icalcstpc_starttls(icalcstpc* cstp, char* command, 
-                                    char* data, char * f(char*))
-{
-    return ICAL_NO_ERROR;
-}
+        if(command_map[i].command == command){
+            return command_map[i].str;
+        }
+    
+    }
 
-icalerrorenum icalcstpc_upnexpand(icalcstpc* cstp,char* calid)
-{
-    return ICAL_NO_ERROR;
-}
+    return command_map[i].str;
 
-icalerrorenum icalcstpc_sendata(icalcstpc* cstp, unsigned int time,
-                                   icalcomponent *comp)
-{
-    return ICAL_NO_ERROR;
 }
 
-
-
-
diff --git a/libical/src/libicalss/icaldirset.c b/libical/src/libicalss/icaldirset.c
index 78b2373219..3a7b9cfdd9 100644
--- a/libical/src/libicalss/icaldirset.c
+++ b/libical/src/libicalss/icaldirset.c
@@ -65,7 +65,7 @@
 #include "icalfilesetimpl.h"
 #include "icalgauge.h"
 
-#include <limits.h>
+#include <limits.h> /* For PATH_MAX */
 #include <dirent.h> /* for opendir() */
 #include <errno.h>
 #include <sys/types.h> /* for opendir() */
@@ -191,7 +191,7 @@ icaldirset* icaldirset_new(const char* dir)
     impl = icaldirset_new_impl();
 
     if (impl ==0){
-	icalerror_set_errno(ICAL_ALLOCATION_ERROR);
+	icalerror_set_errno(ICAL_NEWFAILED_ERROR);
 	return 0;
     }
     
@@ -252,7 +252,7 @@ int icaldirset_next_uid_number(icaldirset* store)
     struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
     char sequence = 0;
     char temp[128];
-    char filename[PATH_MAX];
+    char filename[ICAL_PATH_MAX];
     char *r;
     FILE *f;
     struct stat sbuf;
@@ -304,7 +304,7 @@ int icaldirset_next_uid_number(icaldirset* store)
 icalerrorenum icaldirset_next_cluster(icaldirset* store)
 {
     struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
-    char path[PATH_MAX];
+    char path[ICAL_PATH_MAX];
 
     if (impl->directory_iterator == 0){
 	icalerror_set_errno(ICAL_INTERNAL_ERROR);
@@ -332,7 +332,7 @@ icalerrorenum icaldirset_next_cluster(icaldirset* store)
 
 void icaldirset_add_uid(icaldirset* store, icaldirset* comp)
 {
-    char uidstring[PATH_MAX];
+    char uidstring[ICAL_PATH_MAX];
     icalproperty *uid;
     struct utsname unamebuf;
 
@@ -363,7 +363,7 @@ void icaldirset_add_uid(icaldirset* store, icaldirset* comp)
 icalerrorenum icaldirset_add_component(icaldirset* store, icaldirset* comp)
 {
     struct icaldirset_impl *impl;
-    char clustername[PATH_MAX];
+    char clustername[ICAL_PATH_MAX];
     icalproperty *dt;
     icalvalue *v;
     struct icaltimetype tm;
@@ -418,7 +418,7 @@ icalerrorenum icaldirset_add_component(icaldirset* store, icaldirset* comp)
 
     tm = icalvalue_get_datetime(v);
 
-    snprintf(clustername,PATH_MAX,"%s/%04d%02d",impl->dir,tm.year,tm.month);
+    snprintf(clustername,ICAL_PATH_MAX,"%s/%04d%02d",impl->dir,tm.year,tm.month);
 
     /* Load the cluster and insert the object */
 
@@ -633,7 +633,7 @@ icalcomponent* icaldirset_get_first_component(icaldirset* store)
 {
     struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
     icalerrorenum error;
-    char path[PATH_MAX];
+    char path[ICAL_PATH_MAX];
 
     error = icaldirset_read_directory(impl);
 
@@ -649,7 +649,7 @@ icalcomponent* icaldirset_get_first_component(icaldirset* store)
 	return 0;
     }
     
-    snprintf(path,PATH_MAX,"%s/%s",impl->dir,(char*)pvl_data(impl->directory_iterator));
+    snprintf(path,ICAL_PATH_MAX,"%s/%s",impl->dir,(char*)pvl_data(impl->directory_iterator));
 
     /* If the next cluster we need is different than the current cluster, 
        delete the current one and get a new one */
diff --git a/libical/src/libicalss/icalfileset.c b/libical/src/libicalss/icalfileset.c
index 2ef38ff876..b6e3430f7d 100644
--- a/libical/src/libicalss/icalfileset.c
+++ b/libical/src/libicalss/icalfileset.c
@@ -33,7 +33,6 @@
 #include "icalfileset.h"
 #include "icalgauge.h"
 #include <errno.h>
-#include <limits.h> /* For PATH_MAX */
 #include <sys/stat.h> /* for stat */
 #include <unistd.h> /* for stat, getpid */
 #include <stdlib.h>
@@ -155,7 +154,6 @@ icalerrorenum icalfileset_read_file(icalfileset* cluster,mode_t mode)
 {
 
     icalparser *parser;
-    int fd;
   
     struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
     
@@ -292,7 +290,7 @@ int icalfileset_safe_saves=0;
 
 icalerrorenum icalfileset_commit(icalfileset* cluster)
 {
-    char tmp[PATH_MAX]; 
+    char tmp[ICAL_PATH_MAX]; 
     char *str;
     icalcomponent *c;
     off_t write_size=0;
@@ -309,7 +307,7 @@ icalerrorenum icalfileset_commit(icalfileset* cluster)
     }
     
     if(icalfileset_safe_saves == 1){
-	snprintf(tmp,PATH_MAX,"cp %s %s.bak",impl->path,impl->path);
+	snprintf(tmp,ICAL_PATH_MAX,"cp %s %s.bak",impl->path,impl->path);
 	
 	if(system(tmp) < 0){
 	    icalerror_set_errno(ICAL_FILE_ERROR);
@@ -376,8 +374,8 @@ icalerrorenum icalfileset_add_component(icalfileset *cluster,
 {
     struct icalfileset_impl* impl = (struct icalfileset_impl*)cluster;
 
-    icalerror_check_arg_rv((cluster!=0),"cluster");
-    icalerror_check_arg_rv((child!=0),"child");
+    icalerror_check_arg_re((cluster!=0),"cluster", ICAL_BADARG_ERROR);
+    icalerror_check_arg_re((child!=0),"child",ICAL_BADARG_ERROR);
 
     icalcomponent_add_component(impl->cluster,child);
 
@@ -392,8 +390,8 @@ icalerrorenum icalfileset_remove_component(icalfileset *cluster,
 {
     struct icalfileset_impl* impl = (struct icalfileset_impl*)cluster;
 
-    icalerror_check_arg_rv((cluster!=0),"cluster");
-    icalerror_check_arg_rv((child!=0),"child");
+    icalerror_check_arg_re((cluster!=0),"cluster",ICAL_BADARG_ERROR);
+    icalerror_check_arg_re((child!=0),"child",ICAL_BADARG_ERROR);
 
     icalcomponent_remove_component(impl->cluster,child);
 
diff --git a/libical/src/libicalss/icalfileset.h b/libical/src/libicalss/icalfileset.h
index 3b4b87c34d..c785921463 100644
--- a/libical/src/libicalss/icalfileset.h
+++ b/libical/src/libicalss/icalfileset.h
@@ -30,6 +30,7 @@
 #define ICALFILESET_H
 
 #include "ical.h"
+#include "icalset.h"
 #include "icalgauge.h"
 #include <sys/types.h> /* For open() flags and mode */
 #include <sys/stat.h> /* For open() flags and mode */
diff --git a/libical/src/libicalss/icalset.c b/libical/src/libicalss/icalset.c
index 3edbe503c4..2120609928 100644
--- a/libical/src/libicalss/icalset.c
+++ b/libical/src/libicalss/icalset.c
@@ -123,7 +123,7 @@ struct icalset_impl icalset_get_impl(icalset* set)
     struct icalset_impl  impl;
 
     memset(&impl,0,sizeof(impl));
-    icalerror_check_arg_rv( (set!=0),"set");
+    icalerror_check_arg_re( (set!=0),"set",impl);
 
     if(strcmp((char*)set,ICALSET_ID)==0) {
 	/* It is actually a set, so just sent the reference back out. */
diff --git a/libical/src/libicalss/icalset.h b/libical/src/libicalss/icalset.h
index d4678e3bed..7b083dae24 100644
--- a/libical/src/libicalss/icalset.h
+++ b/libical/src/libicalss/icalset.h
@@ -37,9 +37,19 @@
 #ifndef ICALSET_H
 #define ICALSET_H
 
+#include <limits.h> /* For PATH_MAX */
 #include "ical.h"
 #include "icalerror.h"
 
+#ifdef PATH_MAX
+#define ICAL_PATH_MAX PATH_MAX
+#else
+#define ICAL_PATH_MAX 1024
+#endif
+
+
+
+
 typedef void icalset;
 
 typedef enum icalset_kind {