static time_t
get_time_from_property (icalcomponent *ical,
icalproperty_kind prop_kind,
struct icaltimetype (* get_prop_func) (const icalproperty *prop),
icaltimezone *default_zone)
{
icalproperty *prop;
struct icaltimetype ical_time;
icalparameter *param;
icaltimezone *timezone = NULL;
prop = icalcomponent_get_first_property (ical, prop_kind);
if (!prop)
return 0;
ical_time = get_prop_func (prop);
param = icalproperty_get_first_parameter (prop, ICAL_TZID_PARAMETER);
if (param)
timezone = icaltimezone_get_builtin_timezone_from_tzid (icalparameter_get_tzid (param));
else if (icaltime_is_utc (ical_time))
timezone = icaltimezone_get_utc_timezone ();
else
timezone = default_zone;
return icaltime_as_timet_with_zone (ical_time, timezone);
}
icalparameter* icallangbind_get_first_parameter(icalproperty *prop)
{
icalparameter_kind kind = ICAL_ANY_PARAMETER;
return icalproperty_get_first_parameter(prop,kind);
}
NS_IMETHODIMP
calIcalProperty::GetFirstParameterName(nsACString &name)
{
icalparameter *icalparam =
icalproperty_get_first_parameter(mProperty,
ICAL_ANY_PARAMETER);
return FillParameterName(icalparam, name);
}
/**
* get parameters from the icalendar property and store them in the internal
* struct if the parameter describes a hidden or inline attachment.
*/
static void
add_e_attachment_parameters(icalproperty *prop, I_common *i_common, gboolean inln)
{
gboolean binary = FALSE;
gchar* mime_type = NULL;
gchar* label = NULL;
/* iterate over all parameters of the attachment property */
int i, pc = icalproperty_count_parameters(prop);
icalparameter *para;
for (i = 0; i < pc; i++) {
icalparameter_kind kind;
icalparameter_value xvalue;
para = i == 0 ? icalproperty_get_first_parameter(prop, ICAL_ANY_PARAMETER) :
icalproperty_get_next_parameter(prop, ICAL_ANY_PARAMETER);
kind = icalparameter_isa(para);
xvalue = icalparameter_get_value(para);
if (kind == ICAL_VALUE_PARAMETER && xvalue == ICAL_VALUE_BINARY)
binary = TRUE; /* not a link attachment */
else if (kind == ICAL_FMTTYPE_PARAMETER) /* found mime type */
mime_type = (gchar*) icalparameter_get_xvalue(para);
else if (xvalue == ICAL_VALUE_X) { /* found attachment name */
const char* name = icalparameter_get_xname(para);
const char* value = icalparameter_get_xvalue(para);
if (name && strcmp(name, ICONTACT_KOLAB_STORE_ATTACHMENT_NAME) == 0)
label = (gchar*) value;
}
}
if (binary) { /* if not a linked attachment add data to struct */
Kolab_conv_mail_part *mpart = g_new0(Kolab_conv_mail_part, 1);
gchar* pname = NULL;
if (label != NULL) {
if (inln)
i_common->inline_attachment_names = g_list_append(
i_common->inline_attachment_names,
strdup(label));
mpart->name = strdup(label);
}
if (mime_type != NULL)
mpart->mime_type = strdup(mime_type);
/* add data and length */
pname = (gchar*) icalproperty_get_value_as_string(prop);
if (pname) {
gsize outlen;
mpart->data = (gchar*) g_base64_decode (pname, &outlen);
mpart->length = outlen;
/* add created mail part to the attachment list */
i_common->kolab_attachment_store = g_list_append(i_common->kolab_attachment_store, mpart);
}
}
}
icalspanlist *icalspanlist_from_vfreebusy(icalcomponent *comp)
{
icalcomponent *inner;
icalproperty *prop;
icalspanlist *sl;
icalerror_check_arg_rz((comp != NULL), "comp");
inner = icalcomponent_get_inner(comp);
if (!inner)
return NULL;
if ((sl = (icalspanlist *) malloc(sizeof(icalspanlist))) == 0) {
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return 0;
}
sl->spans = pvl_newlist();
/* cycle through each FREEBUSY property, adding to the spanlist */
for (prop = icalcomponent_get_first_property(inner, ICAL_FREEBUSY_PROPERTY);
prop != NULL;
prop = icalcomponent_get_next_property(inner, ICAL_FREEBUSY_PROPERTY)) {
icaltime_span *s = (icaltime_span *) malloc(sizeof(icaltime_span));
icalparameter *param;
struct icalperiodtype period;
icalparameter_fbtype fbtype;
if (s == 0) {
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
icalspanlist_free(sl);
return 0;
}
param = icalproperty_get_first_parameter(prop, ICAL_FBTYPE_PARAMETER);
fbtype = (param) ? icalparameter_get_fbtype(param) : ICAL_FBTYPE_BUSY;
switch (fbtype) {
case ICAL_FBTYPE_FREE:
case ICAL_FBTYPE_NONE:
case ICAL_FBTYPE_X:
s->is_busy = 1;
break;
default:
s->is_busy = 0;
}
period = icalproperty_get_freebusy(prop);
s->start = icaltime_as_timet_with_zone(period.start, icaltimezone_get_utc_timezone());
s->end = icaltime_as_timet_with_zone(period.end, icaltimezone_get_utc_timezone());
;
pvl_insert_ordered(sl->spans, compare_span, (void *)s);
}
/** @todo calculate start/end limits.. fill in holes? **/
return sl;
}
icalparameter* icalproperty_get_iana_parameter_by_name(icalproperty *prop,
const char *name)
{
icalparameter *param;
for (param = icalproperty_get_first_parameter(prop, ICAL_IANA_PARAMETER);
param && strcmp(icalparameter_get_iana_name(param), name);
param = icalproperty_get_next_parameter(prop, ICAL_IANA_PARAMETER));
return param;
}
static icalparameter*
FindParameter(icalproperty *prop, const nsACString ¶m, icalparameter_kind kind)
{
for (icalparameter *icalparam =
icalproperty_get_first_parameter(prop, kind);
icalparam;
icalparam = icalproperty_get_next_parameter(prop, kind)) {
if (param.Equals(icalparameter_get_xname(icalparam)))
return icalparam;
}
return nullptr;
}
void test_properties()
{
icalproperty *prop;
icalparameter *param;
icalvalue *value;
char *str;
icalproperty *clone;
/* Create a new property */
prop = icalproperty_vanew_comment(
"Another Comment",
icalparameter_new_cn("A Common Name 1"),
icalparameter_new_cn("A Common Name 2"),
icalparameter_new_cn("A Common Name 3"),
icalparameter_new_cn("A Common Name 4"),
0);
/* Iterate through all of the parameters in the property */
for(param = icalproperty_get_first_parameter(prop,ICAL_ANY_PARAMETER);
param != 0;
param = icalproperty_get_next_parameter(prop,ICAL_ANY_PARAMETER)) {
printf("Prop parameter: %s\n",icalparameter_get_cn(param));
}
/* Get a string representation of the property's value */
printf("Prop value: %s\n",icalproperty_get_comment(prop));
/* Spit out the property in its RFC 5545 representation */
str = icalproperty_as_ical_string_r(prop);
printf("As iCAL string:\n %s\n", str);
free(str);
/* Make a copy of the property. Caller owns the memory */
clone = icalproperty_new_clone(prop);
/* Get a reference to the value within the clone property */
value = icalproperty_get_value(clone);
str = icalvalue_as_ical_string_r(value);
printf("Value: %s", str);
free(str);
/* Free the original and the clone */
icalproperty_free(clone);
icalproperty_free(prop);
}
/*
* Construct an XML element for an iCalendar property.
*/
static xmlNodePtr icalproperty_as_xml_element(icalproperty *prop)
{
icalproperty_kind prop_kind;
const char *x_name, *property_name = NULL;
icalparameter *param;
xmlNodePtr xprop, xparams = NULL;
if (!prop) return NULL;
prop_kind = icalproperty_isa(prop);
x_name = icalproperty_get_x_name(prop);
if (prop_kind == ICAL_X_PROPERTY && x_name)
property_name = x_name;
else
property_name = icalproperty_kind_to_string(prop_kind);
if (!property_name) {
icalerror_warn("Got a property of an unknown kind.");
return NULL;
}
/* Create property */
xprop = xmlNewNode(NULL,
BAD_CAST lcase(icalmemory_tmp_copy(property_name)));
/* Add parameters */
for (param = icalproperty_get_first_parameter(prop, ICAL_ANY_PARAMETER);
param != 0;
param = icalproperty_get_next_parameter(prop, ICAL_ANY_PARAMETER)) {
if (icalparameter_isa(param) == ICAL_VALUE_PARAMETER) continue;
if (!xparams)
xparams = xmlNewChild(xprop, NULL, BAD_CAST "parameters", NULL);
xmlAddChild(xparams, icalparameter_as_xml_element(param));
}
/* Add value */
icalproperty_add_value_as_xml_element(xprop, prop);
return xprop;
}
/*
* Determine the type (kind) of an iCalendar property value.
*/
const char *icalproperty_value_kind_as_string(icalproperty *prop)
{
icalvalue_kind kind = ICAL_NO_VALUE;
icalparameter *val_param;
val_param = icalproperty_get_first_parameter(prop, ICAL_VALUE_PARAMETER);
if (val_param) {
/* Use the kind specified in the VALUE param */
kind = icalparameter_value_to_value_kind(
icalparameter_get_value(val_param));
}
if (kind == ICAL_NO_VALUE) {
icalvalue *value = icalproperty_get_value(prop);
if (value) {
/* Use the kind determined from the property value */
kind = icalvalue_isa(value);
}
}
if (kind == ICAL_NO_VALUE) {
/* Use the default kind for the property */
kind = icalproperty_kind_to_value_kind(icalproperty_isa(prop));
}
switch (kind) {
case ICAL_X_VALUE:
return "unknown";
case ICAL_ACTION_VALUE:
case ICAL_CARLEVEL_VALUE:
case ICAL_CLASS_VALUE:
case ICAL_CMD_VALUE:
case ICAL_METHOD_VALUE:
case ICAL_QUERYLEVEL_VALUE:
case ICAL_STATUS_VALUE:
case ICAL_TRANSP_VALUE:
return "text";
default:
return icalvalue_kind_to_string(kind);
}
}
void update_attendees(icalcomponent* event)
{
icalproperty* p;
icalparameter* parameter;
assert(event != 0);
assert(icalcomponent_isa(event) == ICAL_VEVENT_COMPONENT);
for(
p = icalcomponent_get_first_property(event,ICAL_ATTENDEE_PROPERTY);
p != 0;
p = icalcomponent_get_next_property(event,ICAL_ATTENDEE_PROPERTY)
) {
parameter = icalproperty_get_first_parameter(p,ICAL_PARTSTAT_PARAMETER);
if (parameter == 0) {
/* There was no PARTSTAT parameter, so add one. */
icalproperty_add_parameter(
p,
icalparameter_new_partstat(ICAL_PARTSTAT_TENTATIVE)
);
} else if (icalparameter_get_partstat(parameter) == ICAL_PARTSTAT_NEEDSACTION) {
/* Remove the NEEDSACTION parameter and replace it with
TENTATIVE */
icalproperty_remove_parameter_by_kind(p,ICAL_PARTSTAT_PARAMETER);
/* Don't forget to free it */
icalparameter_free(parameter);
/* Add a new one */
icalproperty_add_parameter(
p,
icalparameter_new_partstat(ICAL_PARTSTAT_TENTATIVE)
);
}
}
}
void get_required_attendees(icalcomponent* event)
{
icalproperty* p;
icalparameter* parameter;
assert(event != 0);
assert(icalcomponent_isa(event) == ICAL_VEVENT_COMPONENT);
/* This loop iterates over all of the ATTENDEE properties in the
event */
/* The iteration routines save their state in the event
struct, so the are not thread safe unless you lock the whole
component. */
for(
p = icalcomponent_get_first_property(event,ICAL_ATTENDEE_PROPERTY);
p != 0;
p = icalcomponent_get_next_property(event,ICAL_ATTENDEE_PROPERTY)
) {
/* Get the first ROLE parameter in the property. There should
only be one, so we won't bother to iterate over them. But,
you can iterate over parameters just like with properties */
parameter = icalproperty_get_first_parameter(p,ICAL_ROLE_PARAMETER);
/* If the parameter indicates the participant is required, get
the attendees name and stick a copy of it into the output
array */
if ( icalparameter_get_role(parameter) == ICAL_ROLE_REQPARTICIPANT)
{
/* Remember, the caller does not own this string, so you
should strdup it if you want to change it. */
const char *attendee = icalproperty_get_attendee(p);
printf("%s",attendee);
}
}
}
HashList *iterate_get_ical_attendees(StrBuf *Target, WCTemplputParams *TP)
{
icalcomponent *cal = (icalcomponent *) CTX(CTX_ICAL);
icalparameter *partstat_param;
icalproperty *p;
CalAttendee *Att;
HashList *Attendees = NULL;
const char *ch;
int n = 0;
/* If the component has attendees, iterate through them. */
for (p = icalcomponent_get_first_property(cal, ICAL_ATTENDEE_PROPERTY);
(p != NULL);
p = icalcomponent_get_next_property(cal, ICAL_ATTENDEE_PROPERTY)) {
ch = icalproperty_get_attendee(p);
if ((ch != NULL) && !strncasecmp(ch, "MAILTO:", 7)) {
Att = (CalAttendee*) malloc(sizeof(CalAttendee));
/** screen name or email address */
Att->AttendeeStr = NewStrBufPlain(ch + 7, -1);
StrBufTrim(Att->AttendeeStr);
/** participant status */
partstat_param = icalproperty_get_first_parameter(
p,
ICAL_PARTSTAT_PARAMETER
);
if (partstat_param == NULL) {
Att->partstat = ICAL_PARTSTAT_X;
}
else {
Att->partstat = icalparameter_get_partstat(partstat_param);
}
if (Attendees == NULL)
Attendees = NewHash(1, Flathash);
Put(Attendees, IKEY(n), Att, DeleteAtt);
n++;
}
}
return Attendees;
}
/**
* is_attendee_declined:
* @icalcomp: Component where to check the attendee list.
* @email: Attendee's email to look for.
*
* Returns: Whether the required attendee declined or not.
* It's not necessary to have this attendee in the list.
**/
static gboolean
is_attendee_declined (icalcomponent *icalcomp,
const gchar *email)
{
icalproperty *prop;
icalparameter *param;
g_return_val_if_fail (icalcomp != NULL, FALSE);
g_return_val_if_fail (email != NULL, FALSE);
for (prop = icalcomponent_get_first_property (icalcomp, ICAL_ATTENDEE_PROPERTY);
prop != NULL;
prop = icalcomponent_get_next_property (icalcomp, ICAL_ATTENDEE_PROPERTY)) {
gchar *attendee;
gchar *text = NULL;
attendee = icalproperty_get_value_as_string_r (prop);
if (!attendee)
continue;
if (!g_ascii_strncasecmp (attendee, "mailto:", 7))
text = g_strdup (attendee + 7);
text = g_strstrip (text);
if (!g_ascii_strcasecmp (email, text)) {
g_free (text);
g_free (attendee);
break;
}
g_free (text);
g_free (attendee);
}
if (!prop)
return FALSE;
param = icalproperty_get_first_parameter (prop, ICAL_PARTSTAT_PARAMETER);
return param && icalparameter_get_partstat (param) == ICAL_PARTSTAT_DECLINED;
}
static void
patch_tzids (icalcomponent *subcomp,
GHashTable *mapping)
{
gchar *tzid = NULL;
if (icalcomponent_isa (subcomp) != ICAL_VTIMEZONE_COMPONENT) {
icalproperty *prop = icalcomponent_get_first_property (
subcomp, ICAL_ANY_PROPERTY);
while (prop) {
icalparameter *param = icalproperty_get_first_parameter (
prop, ICAL_TZID_PARAMETER);
while (param) {
const gchar *oldtzid;
const gchar *newtzid;
g_free (tzid);
tzid = g_strdup (icalparameter_get_tzid (param));
if (!g_hash_table_lookup_extended (
mapping, tzid,
(gpointer *) &oldtzid,
(gpointer *) &newtzid)) {
/* Corresponding VTIMEZONE not seen before! */
newtzid = e_cal_match_tzid (tzid);
}
if (newtzid) {
icalparameter_set_tzid (param, newtzid);
}
param = icalproperty_get_next_parameter (
prop, ICAL_TZID_PARAMETER);
}
prop = icalcomponent_get_next_property (
subcomp, ICAL_ANY_PROPERTY);
}
}
g_free (tzid);
}
static gboolean
needs_to_accept (icalcomponent *icalcomp,
const gchar *user_email)
{
icalproperty *prop;
icalparameter *param;
icalparameter_partstat status = ICAL_PARTSTAT_NONE;
prop = get_attendee_prop (icalcomp, user_email);
/* It might be a mailing list */
if (!prop)
return TRUE;
param = icalproperty_get_first_parameter (prop, ICAL_PARTSTAT_PARAMETER);
if (param)
status = icalparameter_get_partstat (param);
if (status == ICAL_PARTSTAT_ACCEPTED || status == ICAL_PARTSTAT_TENTATIVE)
return FALSE;
return TRUE;
}
int main(int argc, char *argv[])
{
icalcomponent *c, *next_c = NULL;
int i = 0;
int dont_remove;
icalfileset_options options = { O_RDONLY, 0644, 0, NULL };
icalset *f = icalset_new(ICAL_FILE_SET, TEST_DATADIR "/process-incoming.ics", &options);
icalset *trash = icalset_new_file("trash.ics");
icalset *cal = icalset_new(ICAL_FILE_SET, TEST_DATADIR "/process-calendar.ics", &options);
icalset *out = icalset_new_file("outgoing.ics");
const char *this_user = "******";
_unused(argc);
_unused(argv);
assert(f != 0);
assert(cal != 0);
assert(trash != 0);
assert(out != 0);
/* Foreach incoming message */
for (c = icalset_get_first_component(f); c != 0; c = next_c) {
icalproperty_xlicclass class;
icalcomponent *match;
icalcomponent *inner;
icalcomponent *reply = 0;
assert(c != 0);
inner = icalcomponent_get_first_real_component(c);
i++;
reply = 0;
dont_remove = 0;
if (inner == 0) {
printf("Bad component, no inner\n %s\n", icalcomponent_as_ical_string(c));
continue;
}
/* Find a booked component that is matched to the incoming
message, based on the incoming component's UID, SEQUENCE
and RECURRENCE-ID */
match = icalset_fetch_match(cal, c);
class = icalclassify(c, match, this_user);
/* Print out the notes associated with the incoming component
and the matched component in the */
{
const char *inc_note = 0;
const char *match_note = 0;
icalproperty *p;
for (p = icalcomponent_get_first_property(c, ICAL_X_PROPERTY);
p != 0; p = icalcomponent_get_next_property(c, ICAL_X_PROPERTY)) {
if (strcmp(icalproperty_get_x_name(p), "X-LIC-NOTE") == 0) {
inc_note = icalproperty_get_x(p);
}
}
if (match != 0) {
for (p = icalcomponent_get_first_property(match, ICAL_X_PROPERTY);
p != 0;
p = icalcomponent_get_next_property(match, ICAL_X_PROPERTY)) {
if (strcmp(icalproperty_get_x_name(p), "X-LIC-NOTE") == 0) {
match_note = icalproperty_get_x(p);
}
}
}
if (inc_note != 0) {
printf("Incoming: %s\n", inc_note);
}
if (match_note != 0) {
printf("Match : %s\n", match_note);
}
}
/* Main processing structure */
switch (class) {
case ICAL_XLICCLASS_NONE:{
char temp[1024];
/* Huh? Return an error to sender */
icalrestriction_check(c);
icalcomponent_convert_errors(c);
snprintf(temp, 1024,
"I can't understand the component you sent.\n"
"Here is the component you sent, possibly with error messages:\n"
"%s",
icalcomponent_as_ical_string(c));
reply = icalmessage_new_error_reply(c, this_user, temp, "", ICAL_UNKNOWN_STATUS);
break;
}
case ICAL_XLICCLASS_PUBLISHNEW:{
/* Don't accept published events from anyone but
self. If self, fall through to ICAL_XLICCLASS_REQUESTNEW */
}
case ICAL_XLICCLASS_REQUESTNEW:{
/* Book the new component if it does not overlap
anything. If the time is busy and the start time is
an even modulo 4, delegate to
[email protected]. If the time is busy and
is 1 modulo 4, counterpropose for the first
available free time. Otherwise, deline the meeting */
icalcomponent *overlaps = icalclassify_find_overlaps(cal, c);
if (overlaps == 0) {
/* No overlaps, book the meeting */
/* icalset_add_component(cal,icalcomponent_new_clone(c));*/
/* Return a reply */
reply =
icalmessage_new_accept_reply(
c, this_user, "I can make it to this meeting");
(void)icalset_add_component(out, reply);
} else {
/* There was a conflict, so delegate, counterpropose
or decline it */
struct icaltimetype dtstart = icalcomponent_get_dtstart(c);
if (dtstart.hour % 4 == 0) {
/* Delegate the meeting */
reply =
icalmessage_new_delegate_reply(
c,
this_user,
"*****@*****.**",
"Unfortunately, I have another commitment that conflicts "
"with this meeting. I am delegating my attendance to Bob.");
(void)icalset_add_component(out, reply);
} else if (dtstart.hour % 4 == 1) {
/* Counter propose to next available time */
icalcomponent *newc;
struct icalperiodtype next_time;
icalspanlist *spanl = icalspanlist_new(cal, dtstart,
icaltime_null_time());
next_time =
icalspanlist_next_free_time(spanl, icalcomponent_get_dtstart(c));
newc = icalcomponent_new_clone(c);
icalcomponent_set_dtstart(newc, next_time.start);
/* Hack, the duration of the counterproposed
meeting may be longer than the free time
available */
icalcomponent_set_duration(newc, icalcomponent_get_duration(c));
reply =
icalmessage_new_counterpropose_reply(
c,
newc,
this_user,
"Unfortunately, I have another commitment that conflicts with "
"this meeting. I am proposing a time that works better for me.");
(void)icalset_add_component(out, reply);
icalspanlist_free(spanl);
icalcomponent_free(newc);
} else {
/* Decline the meeting */
reply =
icalmessage_new_decline_reply(
c,
this_user,
"I can't make it to this meeting");
(void)icalset_add_component(out, reply);
}
}
icalcomponent_free(overlaps);
break;
}
case ICAL_XLICCLASS_PUBLISHFREEBUSY:{
/* Store the busy time information in a file named after
the sender */
break;
}
case ICAL_XLICCLASS_PUBLISHUPDATE:{
/* Only accept publish updates from self. If self, fall
through to ICAL_XLICCLASS_REQUESTUPDATE */
}
case ICAL_XLICCLASS_REQUESTUPDATE:{
/* always accept the changes */
break;
}
case ICAL_XLICCLASS_REQUESTRESCHEDULE:{
/* Use same rules as REQUEST_NEW */
(void)icalclassify_find_overlaps(cal, c);
break;
}
case ICAL_XLICCLASS_REQUESTDELEGATE:{
break;
}
case ICAL_XLICCLASS_REQUESTNEWORGANIZER:{
break;
}
case ICAL_XLICCLASS_REQUESTFORWARD:{
break;
}
case ICAL_XLICCLASS_REQUESTSTATUS:{
break;
}
case ICAL_XLICCLASS_REQUESTFREEBUSY:{
break;
}
case ICAL_XLICCLASS_REPLYACCEPT:{
/* Change the PARTSTAT of the sender */
break;
}
case ICAL_XLICCLASS_REPLYDECLINE:{
/* Change the PARTSTAT of the sender */
break;
}
case ICAL_XLICCLASS_REPLYCRASHERACCEPT:{
/* Add the crasher to the ATTENDEE list with the
appropriate PARTSTAT */
break;
}
case ICAL_XLICCLASS_REPLYCRASHERDECLINE:{
/* Add the crasher to the ATTENDEE list with the
appropriate PARTSTAT */
break;
}
case ICAL_XLICCLASS_ADDINSTANCE:{
break;
}
case ICAL_XLICCLASS_CANCELEVENT:{
/* Remove the component */
break;
}
case ICAL_XLICCLASS_CANCELINSTANCE:{
break;
}
case ICAL_XLICCLASS_CANCELALL:{
/* Remove the component */
break;
}
case ICAL_XLICCLASS_REFRESH:{
/* Resend the latest copy of the request */
break;
}
case ICAL_XLICCLASS_COUNTER:{
break;
}
case ICAL_XLICCLASS_DECLINECOUNTER:{
break;
}
case ICAL_XLICCLASS_MALFORMED:{
/* Send back an error */
break;
}
case ICAL_XLICCLASS_OBSOLETE:{
printf(" ** Got an obsolete component:\n%s", icalcomponent_as_ical_string(c));
/* Send back an error */
break;
}
case ICAL_XLICCLASS_MISSEQUENCED:{
printf(" ** Got a missequenced component:\n%s", icalcomponent_as_ical_string(c));
/* Send back an error */
break;
}
case ICAL_XLICCLASS_UNKNOWN:{
printf(" ** Don't know what to do with this component:\n%s",
icalcomponent_as_ical_string(c));
/* Send back an error */
break;
}
case ICAL_XLICCLASS_X:
case ICAL_XLICCLASS_REPLYDELEGATE:
default:{
}
}
#if 0
if (reply != 0) {
/* Don't send the reply if the RSVP parameter indicates not to */
icalcomponent *reply_inner;
icalproperty *attendee;
icalparameter *rsvp;
reply_inner = icalcomponent_get_first_real_component(reply);
attendee = icalcomponent_get_first_property(reply_inner, ICAL_ATTENDEE_PROPERTY);
rsvp = icalproperty_get_first_parameter(attendee, ICAL_RSVP_PARAMETER);
if (rsvp == 0 || icalparameter_get_rsvp(rsvp) == 1) {
icalrestriction_check(reply);
send_message(reply, this_user);
}
icalcomponent_free(reply);
}
#endif
if (reply != 0) {
printf("%s\n", icalcomponent_as_ical_string(reply));
}
next_c = icalset_get_next_component(f);
if (dont_remove == 0) {
/*icalset_remove_component(f,c);
icalset_add_component(trash,c); */
}
}
#if 0
for (c = icalset_get_first_component(out); c != 0; c = icalset_get_next_component(out)) {
printf("%s", icalcomponent_as_ical_string(c));
}
#endif
icalset_free(f);
icalset_free(trash);
icalset_free(cal);
icalset_free(out);
return 0;
}
RRCAPCmdArgs *
msg_parse(RRCAP *cap, icalcomponent *comp) {
icalproperty *prop;
icalparameter *param;
icalvalue *value;
RRCAPCmdArgs *ret = g_new0(RRCAPCmdArgs, 1);
char *str;
ret->comp = comp;
/* Find the command */
if ((prop = icalcomponent_get_first_property(comp, ICAL_CMD_PROPERTY)) == NULL) {
rr_cap_send_error(cap, NULL, ICAL_9_0_UNRECOGNIZED_COMMAND,
"No CMD sent", NULL);
goto FAILED;
}
if ((value = icalproperty_get_value(prop)) == NULL) {
str = icalproperty_as_ical_string_r(prop);
rr_cap_send_error(cap, NULL, ICAL_9_0_UNRECOGNIZED_COMMAND,
"CMD has no value", str);
free(str);
goto FAILED;
}
ret->cmd = icalvalue_get_cmd(value);
/* Look for params */
/* ID */
if ((param = icalproperty_get_first_parameter(prop,
ICAL_ID_PARAMETER)) != NULL) {
if ((ret->id = icalparameter_get_id(param)) == NULL) {
str = icalproperty_as_ical_string_r(prop);
rr_cap_send_error(cap, NULL,
ICAL_9_0_UNRECOGNIZED_COMMAND,
"ID param is garbled",
str);
free(str);
goto FAILED;
}
}
/* LATENCY */
if ((param = icalproperty_get_first_parameter(prop,
ICAL_LATENCY_PARAMETER)) != NULL) {
const char *tmp;
if ((tmp = icalparameter_get_latency(param)) == NULL) {
str = icalproperty_as_ical_string_r(prop);
rr_cap_send_error(cap, NULL,
ICAL_9_0_UNRECOGNIZED_COMMAND,
"LATENCY is garbled",
str);
free(str);
goto FAILED;
}
ret->latency = atoi(tmp);
}
/* ACTION */
if ((param = icalproperty_get_first_parameter(prop,
ICAL_ACTIONPARAM_PARAMETER)) != NULL) {
if ((ret->action = icalparameter_get_actionparam(param))
== NULL) {
str = icalproperty_as_ical_string_r(prop);
rr_cap_send_error(cap, NULL,
ICAL_9_0_UNRECOGNIZED_COMMAND,
"ACTION is garbled",
str);
free(str);
goto FAILED;
}
}
if ((ret->latency >= 0) ^ (ret->action != ICAL_ACTIONPARAM_NONE)) {
str = icalproperty_as_ical_string_r(prop);
rr_cap_send_error(cap, NULL, ICAL_9_0_UNRECOGNIZED_COMMAND,
"LATENCY and ACTION must be both present",
str);
free(str);
goto FAILED;
}
return ret;
FAILED:
g_free(ret);
return NULL;
}
nsresult calIcalProperty::getDatetime_(calIcalComponent * parent,
icalproperty * prop,
calIDateTime ** dtp)
{
icalvalue * const val = icalproperty_get_value(prop);
icalvalue_kind const valkind = icalvalue_isa(val);
if (valkind != ICAL_DATETIME_VALUE && valkind != ICAL_DATE_VALUE) {
return NS_ERROR_UNEXPECTED;
}
icaltimetype itt = icalvalue_get_datetime(val);
char const* tzid_ = nullptr;
if (!itt.is_utc) {
if (itt.zone) {
tzid_ = icaltimezone_get_tzid(const_cast<icaltimezone *>(itt.zone));
} else {
// Need to get the tzid param. Unfortunatly, libical tends to return raw
// ics strings, with quotes and everything. That's not what we want. Need
// to work around.
icalparameter * const tzparam = icalproperty_get_first_parameter(prop, ICAL_TZID_PARAMETER);
if (tzparam) {
tzid_ = icalparameter_get_xvalue(tzparam);
}
}
}
nsCOMPtr<calITimezone> tz;
if (tzid_) {
nsDependentCString const tzid(tzid_);
calIcalComponent * comp = nullptr;
if (parent) {
comp = parent->getParentVCalendarOrThis();
}
// look up parent if timezone is already referenced:
if (comp) {
comp->mReferencedTimezones.Get(tzid, getter_AddRefs(tz));
}
if (!tz) {
if (parent) {
// passed tz provider has precedence over timezone service:
calITimezoneProvider * const tzProvider = parent->getTzProvider();
if (tzProvider) {
tzProvider->GetTimezone(tzid, getter_AddRefs(tz));
NS_ASSERTION(tz, tzid_);
}
}
if (!tz) {
// look up tz in tz service.
// this hides errors from incorrect ics files, which could state
// a TZID that is not present in the ics file.
// The other way round, it makes this product more error tolerant.
nsresult rv = cal::getTimezoneService()->GetTimezone(tzid, getter_AddRefs(tz));
if (NS_FAILED(rv) || !tz) {
icaltimezone const* zone = itt.zone;
if (!zone && comp) {
// look up parent VCALENDAR for VTIMEZONE:
zone = icalcomponent_get_timezone(comp->mComponent, tzid_);
NS_ASSERTION(zone, tzid_);
}
if (zone) {
// We need to decouple this (inner) VTIMEZONE from the parent VCALENDAR to avoid
// running into circular references (referenced timezones):
icaltimezone * const clonedZone = icaltimezone_new();
CAL_ENSURE_MEMORY(clonedZone);
icalcomponent * const clonedZoneComp =
icalcomponent_new_clone(icaltimezone_get_component(const_cast<icaltimezone *>(zone)));
if (!clonedZoneComp) {
icaltimezone_free(clonedZone, 1 /* free struct */);
CAL_ENSURE_MEMORY(clonedZoneComp);
}
if (!icaltimezone_set_component(clonedZone, clonedZoneComp)) {
icaltimezone_free(clonedZone, 1 /* free struct */);
return NS_ERROR_INVALID_ARG;
}
nsCOMPtr<calIIcalComponent> const tzComp(new calIcalComponent(clonedZone, clonedZoneComp));
CAL_ENSURE_MEMORY(tzComp);
tz = new calTimezone(tzid, tzComp);
CAL_ENSURE_MEMORY(tz);
} else { // install phantom timezone, so the data could be repaired:
tz = new calTimezone(tzid, nullptr);
CAL_ENSURE_MEMORY(tz);
}
}
}
if (comp && tz) {
// assure timezone is known:
comp->AddTimezoneReference(tz);
}
}
if (tz) {
// correct itt which would else appear floating:
itt.zone = cal::getIcalTimezone(tz);
itt.is_utc = 0;
} else {
cal::logMissingTimezone(tzid_);
}
}
*dtp = new calDateTime(&itt, tz);
CAL_ENSURE_MEMORY(*dtp);
NS_ADDREF(*dtp);
return NS_OK;
}
/*
* Construct a JSON array for an iCalendar property.
*/
static json_t *icalproperty_as_json_array(icalproperty *prop)
{
icalproperty_kind prop_kind;
const char *x_name, *property_name = NULL;
icalparameter *param;
const char *type = NULL;
const icalvalue *value;
json_t *jprop, *jparams;
if (!prop) return NULL;
prop_kind = icalproperty_isa(prop);
x_name = icalproperty_get_x_name(prop);
if (prop_kind == ICAL_X_PROPERTY && x_name)
property_name = x_name;
else
property_name = icalproperty_kind_to_string(prop_kind);
if (!property_name) {
icalerror_warn("Got a property of an unknown kind.");
return NULL;
}
/* Create property array */
jprop = json_array();
/* Add property name */
json_array_append_new(jprop,
json_string(lcase(icalmemory_tmp_copy(property_name))));
/* Add parameters */
jparams = json_object();
for (param = icalproperty_get_first_parameter(prop, ICAL_ANY_PARAMETER);
param != 0;
param = icalproperty_get_next_parameter(prop, ICAL_ANY_PARAMETER)) {
if (icalparameter_isa(param) == ICAL_VALUE_PARAMETER) continue;
icalparameter_as_json_object_member(param, jparams);
}
json_array_append_new(jprop, jparams);
/* Add type */
type = icalproperty_value_kind_as_string(prop);
json_array_append_new(jprop, json_string(lcase(icalmemory_tmp_copy(type))));
/* Add value */
value = icalproperty_get_value(prop);
if (value) {
switch (icalproperty_isa(prop)) {
case ICAL_CATEGORIES_PROPERTY:
case ICAL_RESOURCES_PROPERTY:
case ICAL_POLLPROPERTIES_PROPERTY:
if (icalvalue_isa(value) == ICAL_TEXT_VALUE) {
/* Handle multi-valued properties */
const char *str = icalvalue_as_ical_string(value);
tok_t tok;
tok_init(&tok, str, ",", TOK_TRIMLEFT|TOK_TRIMRIGHT|TOK_EMPTY);
while ((str = tok_next(&tok))) {
if (*str) json_array_append_new(jprop, json_string(str));
}
tok_fini(&tok);
break;
}
default:
json_array_append_new(jprop, icalvalue_as_json_object(value));
break;
}
}
return jprop;
}
char *icallangbind_property_eval_string_r(icalproperty *prop, char *sep)
{
char tmp[25];
size_t buf_size = 1024;
char *buf;
char *buf_ptr;
icalparameter *param;
icalvalue *value;
if (prop == 0) {
return 0;
}
buf = icalmemory_new_buffer(buf_size);
buf_ptr = buf;
APPENDS("{ ");
value = icalproperty_get_value(prop);
APPENDS(" 'name' ");
APPENDS(sep);
APPENDC('\'');
APPENDS(icalproperty_kind_to_string(icalproperty_isa(prop)));
APPENDC('\'');
if (value) {
APPENDS(", 'value_type' ");
APPENDS(sep);
APPENDC('\'');
APPENDS(icalvalue_kind_to_string(icalvalue_isa(value)));
APPENDC('\'');
}
APPENDS(", 'pid' ");
APPENDS(sep);
APPENDC('\'');
snprintf(tmp, 25, "%p", prop);
APPENDS(tmp);
APPENDC('\'');
if (value) {
switch (icalvalue_isa(value)) {
case ICAL_ATTACH_VALUE:
case ICAL_BINARY_VALUE:
case ICAL_NO_VALUE:{
icalerror_set_errno(ICAL_INTERNAL_ERROR);
break;
}
default:
{
char *str = icalvalue_as_ical_string_r(value);
char *copy = (char *)malloc(strlen(str) + 1);
const char *i;
char *j;
if (copy == 0) {
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
break;
}
/* Remove any newlines */
for (j = copy, i = str; *i != 0; j++, i++) {
if (*i == '\n') {
i++;
}
*j = *i;
}
*j = 0;
APPENDS(", 'value'");
APPENDS(sep);
APPENDC('\'');
APPENDS(copy);
APPENDC('\'');
free(copy);
free(str);
break;
}
}
}
/* Add Parameters */
for (param = icalproperty_get_first_parameter(prop, ICAL_ANY_PARAMETER);
param != 0; param = icalproperty_get_next_parameter(prop, ICAL_ANY_PARAMETER)) {
char *copy = icalparameter_as_ical_string_r(param);
char *v;
if (copy == 0) {
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
continue;
}
v = strchr(copy, '=');
if (v == 0) {
free(copy);
continue;
}
*v = 0;
v++;
APPENDS(", ");
APPENDC('\'');
APPENDS(copy);
APPENDC('\'');
APPENDS(sep);
APPENDC('\'');
APPENDS(v);
APPENDC('\'');
free(copy);
}
APPENDC('}');
return buf;
}
int icalgauge_compare_recurse(icalcomponent* comp, icalcomponent* gauge)
{
int pass = 1,localpass = 0;
icalproperty *p;
icalcomponent *child,*subgauge;
icalcomponent_kind gaugekind, compkind;
icalerror_check_arg_rz( (comp!=0), "comp");
icalerror_check_arg_rz( (gauge!=0), "gauge");
gaugekind = icalcomponent_isa(gauge);
compkind = icalcomponent_isa(comp);
if( ! (gaugekind == compkind || gaugekind == ICAL_ANY_COMPONENT) ){
return 0;
}
/* Test properties. For each property in the gauge, search through
the component for a similar property. If one is found, compare
the two properties value with the comparison specified in the
gauge with the X-LIC-COMPARETYPE parameter */
for(p = icalcomponent_get_first_property(gauge,ICAL_ANY_PROPERTY);
p != 0;
p = icalcomponent_get_next_property(gauge,ICAL_ANY_PROPERTY)){
icalproperty* targetprop;
icalparameter* compareparam;
icalparameter_xliccomparetype compare;
int rel; /* The relationship between the gauge and target values.*/
/* Extract the comparison type from the gauge. If there is no
comparison type, assume that it is "EQUAL" */
compareparam = icalproperty_get_first_parameter(
p,
ICAL_XLICCOMPARETYPE_PARAMETER);
if (compareparam!=0){
compare = icalparameter_get_xliccomparetype(compareparam);
} else {
compare = ICAL_XLICCOMPARETYPE_EQUAL;
}
/* Find a property in the component that has the same type
as the gauge property. HACK -- multiples of a single
property type in the gauge will match only the first
instance in the component */
targetprop = icalcomponent_get_first_property(comp,
icalproperty_isa(p));
if(targetprop != 0){
/* Compare the values of the gauge property and the target
property */
rel = icalvalue_compare(icalproperty_get_value(p),
icalproperty_get_value(targetprop));
/* Now see if the comparison is equavalent to the comparison
specified in the gauge */
if (rel == compare){
localpass++;
} else if (compare == ICAL_XLICCOMPARETYPE_LESSEQUAL &&
( rel == ICAL_XLICCOMPARETYPE_LESS ||
rel == ICAL_XLICCOMPARETYPE_EQUAL)) {
localpass++;
} else if (compare == ICAL_XLICCOMPARETYPE_GREATEREQUAL &&
( rel == ICAL_XLICCOMPARETYPE_GREATER ||
rel == ICAL_XLICCOMPARETYPE_EQUAL)) {
localpass++;
} else if (compare == ICAL_XLICCOMPARETYPE_NOTEQUAL &&
( rel == ICAL_XLICCOMPARETYPE_GREATER ||
rel == ICAL_XLICCOMPARETYPE_LESS)) {
localpass++;
} else {
localpass = 0;
}
pass = pass && (localpass>0);
}
}
/* Test subcomponents. Look for a child component that has a
counterpart in the gauge. If one is found, recursively call
icaldirset_test */
for(subgauge = icalcomponent_get_first_component(gauge,ICAL_ANY_COMPONENT);
subgauge != 0;
subgauge = icalcomponent_get_next_component(gauge,ICAL_ANY_COMPONENT)){
gaugekind = icalcomponent_isa(subgauge);
if (gaugekind == ICAL_ANY_COMPONENT){
child = icalcomponent_get_first_component(comp,ICAL_ANY_COMPONENT);
} else {
child = icalcomponent_get_first_component(comp,gaugekind);
}
if(child !=0){
localpass = icalgauge_compare_recurse(child,subgauge);
pass = pass && localpass;
} else {
pass = 0;
}
}
return pass;
}
void ical2exchange_property_ATTACH(struct ical2exchange *ical2exchange)
{
int data;
char *extension = NULL;
char *filename = NULL;
const char *fmttype = NULL;
icalattach *icalattach = NULL;
icalparameter *fmttypePar = NULL;
icalparameter *xfilePar = NULL;
const char *xname = NULL;
icalproperty *attachProp = NULL;
/*sanity check*/
if(!ical2exchange->attachEvent) return;
attachProp=icalcomponent_get_first_property(ical2exchange->attachEvent, ICAL_ATTACH_PROPERTY);
while(attachProp){
icalattach = icalproperty_get_attach(attachProp);
data = ldb_base64_decode((char *) icalattach_get_data (icalattach));
/*FMTTYPE*/
fmttypePar = icalproperty_get_first_parameter(attachProp, ICAL_FMTTYPE_PARAMETER);
if(fmttypePar){
fmttype = icalparameter_get_fmttype(fmttypePar);
}
/*X-FIlename*/
xfilePar = icalproperty_get_first_parameter(attachProp, ICAL_X_PARAMETER);
if(xfilePar){
xname = icalparameter_get_xname(xfilePar);
if(!strcmp(xname,"X-FILENAME")){
filename = (char *) icalparameter_get_x(xfilePar);
}
}
/*Extension*/
if(filename){
char buff[256];
char *temp;
strncpy(buff,filename, 255);
buff[255] = '\0';
extension = strtok(buff, ".");
while((temp = strtok(NULL, "."))) extension = temp;
}
printf("Create a new attachment object with\n");
printf(" set PidTagAttachDataBinary to %d\n", data);
printf(" set PidTagAttachExtension to %s\n", extension);
printf(" set PidTagAttachFilename to %s\n", filename);
printf(" set PidTagAttachLongFilename to %s\n", filename);
printf(" set PidTagAttachMimeTag to %s\n", fmttype);
printf(" set PidTagAttachFlags to 0x00000000\n");
printf(" set PidTagAttachMethod to 0x00000001\n");
printf(" set PidTagAttachmentContactPhoto to FALSE\n");
printf(" set PidTagAttachmentFlags to 0x00000000\n");
printf(" set PidTagAttachEncoding to empty SBinary");
printf(" set PidTagAttachmentHidden to FALSE\n");
printf(" set PidTagAttachmentLinkId to 0x00000000\n");
printf(" set PidTagDisplayName to %s\n", filename);
printf(" set PidTagExceptionEndTime to 0x0CB34557A3DD4000\n");
printf(" set PidTagExceptionStartTime to 0x0CB34557A3DD4000\n");
printf(" set PidTagRenderingPosition to 0xFFFFFFFF\n");
attachProp=icalcomponent_get_next_property(ical2exchange->attachEvent, ICAL_ATTACH_PROPERTY);
}
}