{
return g_quark_from_static_string("exchange-web-services");
}
-int process_relativeyearlyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error);
-int process_absoluteyearlyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error);
-int process_relativemonthlyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error);
-int process_absolutemonthlyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error);
-int process_weeklyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error);
-int process_dailyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error);
+
+gboolean process_relativeyearlyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error);
+gboolean process_absoluteyearlyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error);
+gboolean process_relativemonthlyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error);
+gboolean process_absolutemonthlyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error);
+gboolean process_weeklyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error);
+gboolean process_dailyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error);
gboolean process_organizer(icalcomponent *comp, xmlNode *xml_node, GError **error);
gboolean process_required_attendees(icalcomponent *comp, xmlNode *xml_node, GError **error);
gboolean process_sequence(icalcomponent *comp, xmlNode *xml_node, GError **error);
gboolean process_body(icalcomponent *comp, xmlNode *xml_node, GError **error);
gboolean process_subject(icalcomponent *comp, xmlNode *xml_node, GError **error);
-int process_recurrence(icalcomponent *comp, xmlNode *xml_node, icaltimezone *zone, GError **error);
+gboolean process_recurrence(icalcomponent *comp, xmlNode *xml_node, icaltimezone *zone, GError **error);
gboolean process_deleted_occurrences(icalcomponent *comp, xmlNode *xml_node,
icaltimetype **deletia, int *count, GError **error);
gboolean process_itemid(icalcomponent *comp, xmlNode *xmlnode, GError **error);
} else if (!strcmp((char *)xml_node->name, "Subject")) {
if (!process_subject(comp, xml_node, error))
goto err;
- } else if (!strcmp((char *)xml_node->name, "Recurrence"))
- process_recurrence(comp, xml_node, icaltz, error);
- else if (!strcmp((char *)xml_node->name, "DeletedOccurrences")) {
+ } else if (!strcmp((char *)xml_node->name, "Recurrence")) {
+ if (!process_recurrence(comp, xml_node, icaltz, error))
+ goto err;
+ } else if (!strcmp((char *)xml_node->name, "DeletedOccurrences")) {
if (!process_deleted_occurrences(comp, xml_node, &deletia, &deletia_count, error))
goto err;
} else if (!strcmp((char *)xml_node->name, "ItemId")) {
return monthnr + 1;
}
- fprintf(stderr, "Unrecognised month name '%s'\n", month);
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "Unrecognised month name '%s'", month);
return 0;
}
static int weekday_to_number(const char *day, int accept, GError **error)
return daynr + 1;
}
- fprintf(stderr, "Unrecognised day name '%s'\n", day);
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "Unrecognised day name '%s'", day);
return 0;
}
+
+#ifndef ARRAY_SIZE
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
+#endif
static int weekindex_to_ical(const char *week, GError **error)
{
if (!strcmp(week, table[i].exch))
return table[i].week;
}
- fprintf(stderr, "Unrecognised DayOfWeekIndex '%s'\n", week);
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "Unrecognised DayOfWeekIndex '%s'", week);
return 0;
}
return TRUE;
}
-int process_recurrence(icalcomponent *comp, xmlNode *xml_node, icaltimezone *zone, GError **error)
+gboolean process_recurrence(icalcomponent *comp, xmlNode *xml_node, icaltimezone *zone, GError **error)
{
struct icalrecurrencetype ical_recur;
char *end_date = NULL, *nr_occurrences = NULL;
ical_recur.freq = ICAL_NO_RECURRENCE;
if (!zone)
- fprintf(stderr, "Recurrence with no recognised TimeZone. Hope this is an all-day event\n");
+ g_warning("Recurrence with no recognised TimeZone. Hope this is an all-day event");
for (xml_node = xml_node->children; xml_node; xml_node = xml_node->next) {
if (xml_node->type != XML_ELEMENT_NODE)
continue;
if (!strcmp((char *)xml_node->name, "WeeklyRecurrence")) {
- if (process_weeklyrecurrence(xml_node, &ical_recur, error))
- return -1;
+ if (!process_weeklyrecurrence(xml_node, &ical_recur, error))
+ return FALSE;
} else if (!strcmp((char *)xml_node->name, "DailyRecurrence")) {
- if (process_dailyrecurrence(xml_node, &ical_recur, error))
- return -1;
+ if (!process_dailyrecurrence(xml_node, &ical_recur, error))
+ return FALSE;
} else if (!strcmp((char *)xml_node->name, "AbsoluteYearlyRecurrence")) {
- if (process_absoluteyearlyrecurrence(xml_node, &ical_recur, error))
- return -1;
+ if (!process_absoluteyearlyrecurrence(xml_node, &ical_recur, error))
+ return FALSE;
} else if (!strcmp((char *)xml_node->name, "RelativeYearlyRecurrence")) {
- if (process_relativeyearlyrecurrence(xml_node, &ical_recur, error))
- return -1;
+ if (!process_relativeyearlyrecurrence(xml_node, &ical_recur, error))
+ return FALSE;
} else if (!strcmp((char *)xml_node->name, "AbsoluteMonthlyRecurrence")) {
- if (process_absolutemonthlyrecurrence(xml_node, &ical_recur, error))
- return -1;
+ if (!process_absolutemonthlyrecurrence(xml_node, &ical_recur, error))
+ return FALSE;
} else if (!strcmp((char *)xml_node->name, "RelativeMonthlyRecurrence")) {
- if (process_relativemonthlyrecurrence(xml_node, &ical_recur, error))
- return -1;
+ if (!process_relativemonthlyrecurrence(xml_node, &ical_recur, error))
+ return FALSE;
} else if (!strcmp((char *)xml_node->name, "EndDateRecurrence")) {
for (xml_node2 = xml_node->children; xml_node2;
xml_node2 = xml_node2->next) {
}
}
if (ical_recur.freq == ICAL_NO_RECURRENCE) {
- fprintf(stderr, "No recognised Recurrence type\n");
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "No recognised Recurrence type");
+ return FALSE;
}
if (end_date) {
if (strlen(end_date) != 11 || end_date[4] != '-' ||
end_date[7] != '-' || end_date[10] != 'Z') {
- fprintf(stderr, "Failed to parse Recurrence EndDate '%s'\n",
- end_date);
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "Failed to parse Recurrence EndDate '%s'",
+ end_date);
+ return FALSE;
}
end_date = strdup(end_date);
end_date[10] = 0;
}
prop = icalproperty_new_rrule(ical_recur);
icalcomponent_add_property(comp, prop);
- return 0;
+ return TRUE;
}
gboolean process_itemid(icalcomponent *comp, xmlNode *xml_node, GError **error)
return NULL;
}
-int get_baseoffset(xmlNode *xml_node, int *retval, GError **error)
+gboolean get_baseoffset(xmlNode *xml_node, int *retval, GError **error)
{
const char *baseoffset;
struct icaldurationtype ofs;
break;
}
if (!xml_node) {
- fprintf(stderr, "<MeetingTimeZone> has no <BaseOffset>\n");
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "<MeetingTimeZone> has no <BaseOffset>\n");
+ return FALSE;
}
baseoffset = (const char *)xmlNodeGetContent(xml_node);
if (!baseoffset) {
- fprintf(stderr, "<BaseOffset> is empty\n");
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "<BaseOffset> is empty\n");
+ return FALSE;
}
ofs = icaldurationtype_from_string(baseoffset);
if (icaldurationtype_is_bad_duration(ofs)) {
- fprintf(stderr, "Failed to parse <BaseOffset> '%s'\n", baseoffset);
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "Failed to parse <BaseOffset> '%s'\n", baseoffset);
+ return FALSE;
}
if (ofs.is_neg)
*retval = ofs.minutes * 60;
else
*retval = -ofs.minutes * 60;
- return 0;
+ return TRUE;
}
-int process_relativeyearlyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error)
+gboolean process_relativeyearlyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error)
{
const char *week = NULL, *month = NULL, *weekday = NULL;
int weeknr, monthnr, daynr;
}
}
if (!week || !month || !weekday) {
- fprintf(stderr, "RelativeYearlyRecurrence missing essential fields (%s,%s,%s)\n",
- week, month, weekday);
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "RelativeYearlyRecurrence missing essential fields (%s,%s,%s)",
+ week, month, weekday);
+ return FALSE;
}
monthnr = month_to_number(month, error);
if (!month)
- return -1;
+ return FALSE;
weeknr = weekindex_to_ical(week, error);
if (!weeknr)
- return -1;
+ return FALSE;
daynr = weekday_to_number(weekday, 10, error);
if (!daynr)
- return -1;
+ return FALSE;
icalrecurrencetype_clear(ical_recur);
ical_recur->freq = ICAL_YEARLY_RECURRENCE;
ical_recur->by_set_pos[0] = weeknr;
}
- return 0;
+ return TRUE;
}
-int process_absoluteyearlyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error)
+
+gboolean process_absoluteyearlyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error)
{
const char *day_of_month = NULL;
const char *month = NULL;
month = (char *)xmlNodeGetContent(xml_node);
}
if (!day_of_month || !month) {
- fprintf(stderr, "AbsoluteYearlyRecurrence missing essential fields (%s,%s)\n",
- day_of_month, month);
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "AbsoluteYearlyRecurrence missing essential fields (%s,%s)",
+ day_of_month, month);
+ return FALSE;
}
daynr = strtol(day_of_month, NULL, 10);
if (!daynr) {
- fprintf(stderr, "Failed to parse DayOfMonth '%s'\n", day_of_month);
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "Failed to parse DayOfMonth '%s'", day_of_month);
+ return FALSE;
}
monthnr = month_to_number(month, error);
if (!month)
- return -1;
+ return FALSE;
icalrecurrencetype_clear(ical_recur);
ical_recur->freq = ICAL_YEARLY_RECURRENCE;
ical_recur->by_month[0] = monthnr;
ical_recur->by_month_day[0] = daynr;
- return 0;
+ return TRUE;
}
-int process_relativemonthlyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error)
+gboolean process_relativemonthlyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error)
{
const char *week = NULL, *interval = NULL, *weekday = NULL;
int weeknr, intervalnr, daynr;
}
}
if (!week || !interval || !weekday) {
- fprintf(stderr, "RelativeMonthlyRecurrence missing essential fields (%s,%s,%s)\n",
- week, interval, weekday);
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "RelativeMonthlyRecurrence missing essential fields (%s,%s,%s)",
+ week, interval, weekday);
+ return FALSE;
}
intervalnr = strtol(interval, NULL, 10);
if (!intervalnr) {
- fprintf(stderr, "Failed to parse Interval '%s'\n", interval);
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "Failed to parse Interval '%s'", interval);
+ return FALSE;
}
weeknr = weekindex_to_ical(week, error);
if (!weeknr)
- return -1;
+ return FALSE;
daynr = weekday_to_number(weekday, 10, error);
if (!daynr)
- return -1;
+ return FALSE;
icalrecurrencetype_clear(ical_recur);
ical_recur->freq = ICAL_MONTHLY_RECURRENCE;
ical_recur->by_day[0] = 1;
ical_recur->by_day[1] = 7;
ical_recur->by_set_pos[0] = weeknr;
- }
-
- return 0;
+ }
+ return TRUE;
}
-int process_absolutemonthlyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error)
+
+gboolean process_absolutemonthlyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur,
+ GError **error)
{
const char *interval = NULL, *monthday = NULL;
int intervalnr, monthdaynr;
}
}
if (!interval || !monthday) {
- fprintf(stderr, "AbsoluteMonthlyRecurrence missing essential fields (%s,%s)\n",
- interval, monthday);
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "AbsoluteMonthlyRecurrence missing essential fields (%s,%s)",
+ interval, monthday);
+ return FALSE;
}
intervalnr = strtol(interval, NULL, 10);
if (!intervalnr) {
- fprintf(stderr, "Failed to parse Interval '%s'\n", interval);
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "Failed to parse Interval '%s'", interval);
+ return FALSE;
}
monthdaynr = strtol(monthday, NULL, 10);
if (!monthday) {
- fprintf(stderr, "Failed to parse DayOfMonth '%s'\n", monthday);
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "Failed to parse DayOfMonth '%s'", monthday);
+ return FALSE;
}
icalrecurrencetype_clear(ical_recur);
ical_recur->freq = ICAL_MONTHLY_RECURRENCE;
ical_recur->interval = intervalnr;
ical_recur->by_month_day[0] = monthdaynr;
- return 0;
+ return TRUE;
}
-static int weekdays_to_recur_byday(const char *days, struct icalrecurrencetype *ical_recur, GError **error)
+gboolean weekdays_to_recur_byday(const char *days, struct icalrecurrencetype *ical_recur, GError **error)
{
const char *space;
const char *day;
daynr = weekday_to_number(day, 7, error);
if (!daynr)
- return -1;
+ return FALSE;
if (count == ICAL_BY_DAY_SIZE) {
- fprintf(stderr, "Too many days in DaysOfWeek list\n");
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "Too many days in DaysOfWeek list");
+ return FALSE;
}
ical_recur->by_day[count++] = daynr;
days = space + 1;
}
} while (space);
- return 0;
+ return TRUE;
}
-
-
-int process_weeklyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error)
+gboolean process_weeklyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error)
{
const char *interval = NULL, *weekday = NULL, *firstday = NULL;
int intervalnr, firstdaynr;
}
}
if (!interval || !weekday) {
- fprintf(stderr, "WeeklyRecurrence missing essential fields (%s,%s)\n",
- interval, weekday);
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "WeeklyRecurrence missing essential fields (%s,%s)",
+ interval, weekday);
+ return FALSE;
}
intervalnr = strtol(interval, NULL, 10);
if (!intervalnr) {
- fprintf(stderr, "Failed to parse Interval '%s'\n", interval);
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "Failed to parse Interval '%s'", interval);
+ return FALSE;
}
if (firstday)
firstdaynr = weekday_to_number(firstday, 7, error);
ical_recur->interval = intervalnr;
ical_recur->week_start = firstdaynr;
- if (weekdays_to_recur_byday(weekday, ical_recur, error))
- return -1;
+ if (!weekdays_to_recur_byday(weekday, ical_recur, error))
+ return FALSE;
ical_recur->freq = ICAL_WEEKLY_RECURRENCE;
- return 0;
+ return TRUE;
}
-int process_dailyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error)
+
+gboolean process_dailyrecurrence(xmlNode *xml_node, struct icalrecurrencetype *ical_recur, GError **error)
{
const char *interval = NULL;
int intervalnr;
}
}
if (!interval) {
- fprintf(stderr, "DailyRecurrence missing essential fields (%s)\n",
- interval);
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "DailyRecurrence missing essential fields (%s)",
+ interval);
+ return FALSE;
}
intervalnr = strtol(interval, NULL, 10);
if (!intervalnr) {
- fprintf(stderr, "Failed to parse Interval '%s'\n", interval);
- return -1;
+ g_set_error(error, EWS_ERROR, EWS_ERROR_PARSE,
+ "Failed to parse Interval '%s'", interval);
+ return FALSE;
}
icalrecurrencetype_clear(ical_recur);
ical_recur->freq = ICAL_DAILY_RECURRENCE;
ical_recur->interval = intervalnr;
-
- return 0;
+ return TRUE;
}
+
icalcomponent *process_timezone_rule(xmlNode *xml_node, icalcomponent_kind kind,
int *offset, GError **error)
{
prop = icalproperty_new_tzid(tzname);
icalcomponent_add_property(comp, prop);
- if (get_baseoffset(xml_node, &std_offset, error))
+ if (!get_baseoffset(xml_node, &std_offset, error))
return NULL;
dst_offset = std_offset;
projects / users / dwmw2 / ews-sync.git / commitdiff