path: root/src/libical/icalrestriction.c.in

/*======================================================================
 File: icalrestriction.c

 (C) COPYRIGHT 2000, Eric Busboom  <eric@civicknowledge.com>

 This library is free software; you can redistribute it and/or modify
 it under the terms of either:

    The LGPL as published by the Free Software Foundation, version
    2.1, available at: https://www.gnu.org/licenses/lgpl-2.1.html

 Or:

    The Mozilla Public License Version 2.0. You may obtain a copy of
    the License at https://www.mozilla.org/MPL/
 ======================================================================*/
/*#line 7 "icalrestriction.c.in"*/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "icalrestriction.h"
#include "icalerror.h"

#include <assert.h>

/* Define the structs for the restrictions. these data are filled out
in machine generated code below */

struct icalrestriction_record;

typedef const char *(*restriction_func) (const struct icalrestriction_record * rec,
                                         icalcomponent *comp, icalproperty *prop);

typedef struct icalrestriction_record
{
    icalproperty_method method;
    icalcomponent_kind component;
    icalproperty_kind property;
    icalcomponent_kind subcomponent;
    icalrestriction_kind restriction;
    restriction_func function;
} icalrestriction_record;

static const icalrestriction_record *icalrestriction_get_restriction(
    const icalrestriction_record *start,
    icalproperty_method method, icalcomponent_kind component,
    icalproperty_kind property, icalcomponent_kind subcomp);

static const icalrestriction_record null_restriction_record =
    { ICAL_METHOD_NONE, ICAL_NO_COMPONENT,
      ICAL_NO_PROPERTY, ICAL_NO_COMPONENT, ICAL_RESTRICTION_UNKNOWN, NULL };

/** Each row gives the result of comparing a restriction against a count.
   The columns in each row represent 0,1,2+. '-1' indicates
   'invalid, 'don't care' or 'needs more analysis' So, for
   ICAL_RESTRICTION_ONE, if there is 1 of a property with that
   restriction, it passes, but if there are 0 or 2+, it fails. */

static const char compare_map[ICAL_RESTRICTION_UNKNOWN + 1][3] = {
    {1, 1, 1}, /*ICAL_RESTRICTION_NONE */
    {1, 0, 0}, /*ICAL_RESTRICTION_ZERO */
    {0, 1, 0}, /*ICAL_RESTRICTION_ONE */
    {1, 1, 1}, /*ICAL_RESTRICTION_ZEROPLUS */
    {0, 1, 1}, /*ICAL_RESTRICTION_ONEPLUS */
    {1, 1, 0}, /*ICAL_RESTRICTION_ZEROORONE */
    {1, 1, 0}, /*ICAL_RESTRICTION_ONEEXCLUSIVE */
    {1, 1, 0}, /*ICAL_RESTRICTION_ONEMUTUAL */
    {1, 1, 1}   /*ICAL_RESTRICTION_UNKNOWN */
};

static const char restr_string_map[ICAL_RESTRICTION_UNKNOWN + 1][60] = {
    "unknown number", /*ICAL_RESTRICTION_NONE */
    "0", /*ICAL_RESTRICTION_ZERO */
    "1", /*ICAL_RESTRICTION_ONE */
    "zero or more", /*ICAL_RESTRICTION_ZEROPLUS */
    "one or more", /*ICAL_RESTRICTION_ONEPLUS */
    "zero or one", /*ICAL_RESTRICTION_ZEROORONE */
    "zero or one, exclusive with another property", /*ICAL_RESTRICTION_ONEEXCLUSIVE */
    "zero or one, mutual with another property", /*ICAL_RESTRICTION_ONEMUTUAL */
    "unknown number"    /*ICAL_RESTRICTION_UNKNOWN */
};

int icalrestriction_compare(icalrestriction_kind restr, int count)
{
    /* restr is an unsigned int and ICAL_RESTRICTION_NONE == 0,
       so no need to check if restr < ICAL_RESTRICTION_NONE */
    if (restr > ICAL_RESTRICTION_UNKNOWN || count < 0) {
        return -1;
    }

    if (count > 2) {
        count = 2;
    }

    return compare_map[restr][count];
}

/* Special case routines */

static const char *icalrestriction_validate_status_value(
    const icalrestriction_record *rec, icalcomponent *comp, icalproperty *prop)
{
    icalproperty_status stat;

    _unused(comp);

    if (!prop) {
        return 0;
    }

    stat = icalproperty_get_status(prop);

    if (rec->method == ICAL_METHOD_CANCEL) {
        switch (rec->component) {
        case ICAL_VEVENT_COMPONENT:
        case ICAL_VTODO_COMPONENT:
            /* Hack. see rfc5546, 3.2.5 CANCEL for property STATUS. I don't
               understand the note */
            break;

        case ICAL_VJOURNAL_COMPONENT:
        case ICAL_VPOLL_COMPONENT:
            if (stat != ICAL_STATUS_CANCELLED) {
                return
                    "Failed iTIP restrictions for STATUS property. "
                    "Value must be CANCELLED";
            }
            break;

        default:
            break;
        }
    } else {
        switch (rec->component) {
        case ICAL_VEVENT_COMPONENT:
            switch (rec->method) {
            case ICAL_METHOD_PUBLISH:
            case ICAL_METHOD_COUNTER:
                if (!(stat == ICAL_STATUS_TENTATIVE ||
                      stat == ICAL_STATUS_CONFIRMED ||
                      stat == ICAL_STATUS_CANCELLED)) {
                    return
                        "Failed iTIP restrictions for STATUS property. "
                        "Value must be one of TENTATIVE, CONFIRMED or CANCELED";
                }
                break;

            case ICAL_METHOD_REQUEST:
            case ICAL_METHOD_ADD:
                if (!(stat == ICAL_STATUS_TENTATIVE ||
                      stat == ICAL_STATUS_CONFIRMED)) {
                    return
                        "Failed iTIP restrictions for STATUS property. "
                        "Value must be one of TENTATIVE or CONFIRMED";
                }
                break;

            default:
                break;
            }
            break;

        case ICAL_VTODO_COMPONENT:
            switch (rec->method) {
            case ICAL_METHOD_REQUEST:
            case ICAL_METHOD_ADD:
            case ICAL_METHOD_COUNTER:
                if (!(stat == ICAL_STATUS_COMPLETED ||
                      stat == ICAL_STATUS_NEEDSACTION ||
                      stat == ICAL_STATUS_INPROCESS)) {
                    return
                        "Failed iTIP restrictions for STATUS property. "
                        "Value must be one of COMPLETED, NEEDS-ACTION or IN-PROCESS";
                }
                break;

            default:
                break;
            }
            break;

        default:
            break;
        }
    }

    return 0;
}

static const char *icalrestriction_must_be_recurring(const icalrestriction_record * rec,
                                                     icalcomponent *comp, icalproperty *prop)
{
    _unused(rec);
    _unused(comp);
    _unused(prop);
    return 0;
}

const char *icalrestriction_must_if_tz_ref(const icalrestriction_record * rec,
                                           icalcomponent *comp, icalproperty *prop)
{
    _unused(rec);
    _unused(comp);
    _unused(prop);
    return 0;
}

static const char *icalrestriction_no_dtend(const icalrestriction_record * rec,
                                            icalcomponent *comp, icalproperty *prop)
{
    _unused(rec);

    if (prop != NULL &&
        icalcomponent_get_first_property(comp, ICAL_DTEND_PROPERTY)) {
        return
            "Failed iTIP restrictions for DTEND property. "
            "The component must not have both DURATION and DTEND";
    }

    return 0;
}

static const char *icalrestriction_no_duration(const icalrestriction_record * rec,
                                               icalcomponent *comp, icalproperty *prop)
{
    _unused(rec);

    if (prop != NULL &&
        icalcomponent_get_first_property(comp, ICAL_DURATION_PROPERTY)) {
        return
            "Failed iTIP restrictions for DURATION property. "
            "The component must not have both DTEND and DURATION";
    }

    return 0;
}

static int _check_restriction(icalcomponent *comp,
                              const icalrestriction_record *record,
                              int count, icalproperty *prop)
{
    icalrestriction_kind restr;
    const char *funcr = 0;
    int compare;

    restr = record->restriction;

    if (restr == ICAL_RESTRICTION_ONEEXCLUSIVE ||
        restr == ICAL_RESTRICTION_ONEMUTUAL) {

        /* First treat is as a 0/1 restriction */
        restr = ICAL_RESTRICTION_ZEROORONE;
    }

    compare = icalrestriction_compare(restr, count);

    assert(compare != -1);

    if (compare == 0) {
#define TMP_BUF_SIZE 1024
        char temp[TMP_BUF_SIZE];
        icalproperty *errProp;
        icalparameter *errParam;
        const char *type, *kind;

        if (record->subcomponent != ICAL_NO_COMPONENT) {
            type = "component";
            kind = icalenum_component_kind_to_string(record->subcomponent);
        } else {
            type = "property";
            kind = icalenum_property_kind_to_string(record->property);
        }

        snprintf(temp, TMP_BUF_SIZE,
                 "Failed iTIP restrictions for %s %s. "
                 "Expected %s instances of the %s and got %d",
                 kind, type, restr_string_map[restr], type, count);
        errParam = icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_INVALIDITIP);
        errProp = icalproperty_vanew_xlicerror(temp, errParam, 0);
        icalcomponent_add_property(comp, errProp);
        icalproperty_free(errProp);
    }

    if (record->function != NULL) {
        funcr = record->function(record, comp, prop);
    }

    if (funcr != 0) {
        icalproperty *errProp;
        icalparameter *errParam;

        errParam = icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_INVALIDITIP);
        errProp = icalproperty_vanew_xlicerror(funcr, errParam, 0);
        icalcomponent_add_property(comp, errProp);
        icalproperty_free(errProp);

        compare = 0;
    }

    return compare;
}

static int icalrestriction_check_component(icalproperty_method method,
                                           icalcomponent *comp)
{
    icalcomponent_kind comp_kind, inner_kind;
    icalproperty_kind prop_kind;
    const icalrestriction_record *start_record;
    icalproperty *method_prop = NULL;
    icalcomponent *inner_comp;
    const char *errStr = NULL;
    int count;
    int compare;
    int valid = 1;

    comp_kind = icalcomponent_isa(comp);

    switch (comp_kind) {
    case ICAL_VCALENDAR_COMPONENT:
        if (!icalcomponent_get_first_real_component(comp)) {

            errStr = "Failed iTIP restrictions for VCALENDAR component. "
                "Expected one or more \"real\" sub-components and got 0";
        }

        /* Get the Method property from the component */
        method_prop = icalcomponent_get_first_property(comp, ICAL_METHOD_PROPERTY);
        break;

    case ICAL_VTIMEZONE_COMPONENT:
        if (!icalcomponent_get_first_component(comp, ICAL_XSTANDARD_COMPONENT) &&
            !icalcomponent_get_first_component(comp, ICAL_XDAYLIGHT_COMPONENT)) {

            errStr = "Failed iTIP restrictions for VTIMEZONE component. "
                "Expected one or more STANDARD/DAYLIGHT sub-components and got 0";
        }

        method = ICAL_METHOD_NONE;
        break;

    default:
        break;
    }

    if (errStr != NULL) {
        icalproperty *errProp;
        icalparameter *errParam;

        errParam = icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_INVALIDITIP);
        errProp = icalproperty_vanew_xlicerror(errStr, errParam, 0);
        icalcomponent_add_property(comp, errProp);
        icalproperty_free(errProp);

        valid = 0;
    }

    /* Check all of the properties in this component */

    start_record = icalrestriction_get_restriction(NULL, method, comp_kind,
                                                   ICAL_ANY_PROPERTY,
                                                   ICAL_NO_COMPONENT);

    if (start_record != &null_restriction_record) {

        for (prop_kind = ICAL_ANY_PROPERTY + 1;
             prop_kind != ICAL_NO_PROPERTY; prop_kind++) {

            const icalrestriction_record *record =
                icalrestriction_get_restriction(start_record, method, comp_kind,
                                                prop_kind, ICAL_NO_COMPONENT);

            icalproperty *prop =
                icalcomponent_get_first_property(comp, prop_kind);

            count = icalcomponent_count_properties(comp, prop_kind);

            compare = _check_restriction(comp, record, count, prop);

            valid = valid && compare;
        }
    }

    /* Now check the inner components */

    start_record = icalrestriction_get_restriction(start_record, method, comp_kind,
                                                   ICAL_NO_PROPERTY,
                                                   ICAL_ANY_COMPONENT);

    if (start_record != &null_restriction_record) {

        for (inner_kind = ICAL_NO_COMPONENT + 3;
             inner_kind != ICAL_NUM_COMPONENT_TYPES; inner_kind++) {

            const icalrestriction_record *record =
                icalrestriction_get_restriction(start_record, method, comp_kind,
                                                ICAL_NO_PROPERTY, inner_kind);

            count = icalcomponent_count_components(comp, inner_kind);

            compare = _check_restriction(comp, record, count, NULL);

            valid = valid && compare;
        }
    }

    if (method_prop == 0) {
        method = ICAL_METHOD_NONE;
    } else {
        method = icalproperty_get_method(method_prop);
    }

    for (inner_comp = icalcomponent_get_first_component(comp, ICAL_ANY_COMPONENT);
         inner_comp != 0;
         inner_comp = icalcomponent_get_next_component(comp, ICAL_ANY_COMPONENT)) {

        compare = icalrestriction_check_component(method, inner_comp);

        valid = valid && compare;
    }

    return valid;
}

int icalrestriction_check(icalcomponent *outer_comp)
{
    icalcomponent_kind comp_kind;
    int valid;

    icalerror_check_arg_rz((outer_comp != 0), "outer comp");

    comp_kind = icalcomponent_isa(outer_comp);

    if (comp_kind != ICAL_VCALENDAR_COMPONENT) {
        icalerror_set_errno(ICAL_BADARG_ERROR);
        return 0;
    }

    /* Check the VCALENDAR wrapper */
    valid = icalrestriction_check_component(ICAL_METHOD_NONE, outer_comp);

    return valid;
}

static const char *icalrestriction_validate_valarm_prop(
    const icalrestriction_record *rec, icalcomponent *comp, icalproperty *prop)
{
    icalrestriction_record record =
        { ICAL_METHOD_NONE, ICAL_VALARM_COMPONENT,
          rec->property, ICAL_NO_COMPONENT, ICAL_RESTRICTION_UNKNOWN, NULL };
    const icalrestriction_record *myrec = NULL;
    enum icalproperty_action action = ICAL_ACTION_NONE;
    icalproperty *action_prop;
    int count = 0;

    switch (rec->subcomponent) {
    case ICAL_NO_COMPONENT:
        action_prop = icalcomponent_get_first_property(comp, ICAL_ACTION_PROPERTY);

        if (action_prop) {
            action = icalproperty_get_action(action_prop);
        }

        if (prop) {
            if (rec->restriction == ICAL_RESTRICTION_ZEROPLUS ||
                rec->restriction == ICAL_RESTRICTION_ONEPLUS) {
                count = icalcomponent_count_properties(comp, rec->property);
            } else {
                count = 1;
            }
        }

        switch (rec->property) {
        case ICAL_DURATION_PROPERTY:
            if (count &&
                !icalcomponent_get_first_property(comp, ICAL_DURATION_PROPERTY)) {
                return
                    "Failed iTIP restrictions for REPEAT property. "
                    "This component must have a REPEAT property "
                    "if it has a DURATION property";
            }
            break;

        case ICAL_REPEAT_PROPERTY:
            if (count &&
                !icalcomponent_get_first_property(comp, ICAL_DURATION_PROPERTY)) {
                return
                    "Failed iTIP restrictions for DURATION property. "
                    "This component must have a DURATION property "
                    "if it has a REPEAT property";
            }
            break;

        case ICAL_ATTACH_PROPERTY:
            if (count) {
                switch (action) {
                case ICAL_ACTION_AUDIO:
                case ICAL_ACTION_PROCEDURE:
                    record.restriction = ICAL_RESTRICTION_ZEROORONE;
                    myrec = &record;
                    break;

                case ICAL_ACTION_DISPLAY:
                    record.restriction = ICAL_RESTRICTION_ZERO;
                    myrec = &record;
                    break;

                default:
                    break;
                }
                break;
            }
            break;

        case ICAL_ATTENDEE_PROPERTY:
            switch (action) {
            case ICAL_ACTION_AUDIO:
            case ICAL_ACTION_DISPLAY:
            case ICAL_ACTION_PROCEDURE:
                if (count) {
                    record.restriction = ICAL_RESTRICTION_ZERO;
                    myrec = &record;
                }
                break;

            case ICAL_ACTION_EMAIL:
                if (!count) {
                    record.restriction = ICAL_RESTRICTION_ONEPLUS;
                    myrec = &record;
                }
                break;

            default:
                break;
            }
            break;

        case ICAL_DESCRIPTION_PROPERTY:
            switch (action) {
            case ICAL_ACTION_AUDIO:
                if (count) {
                    record.restriction = ICAL_RESTRICTION_ZERO;
                    myrec = &record;
                }
                break;

            case ICAL_ACTION_DISPLAY:
            case ICAL_ACTION_EMAIL:
                if (!count) {
                    record.restriction = ICAL_RESTRICTION_ONE;
                    myrec = &record;
                }
                break;

            default:
                break;
            }
            break;

        case ICAL_SUMMARY_PROPERTY:
            switch (action) {
            case ICAL_ACTION_AUDIO:
            case ICAL_ACTION_DISPLAY:
            case ICAL_ACTION_PROCEDURE:
                if (count) {
                    record.restriction = ICAL_RESTRICTION_ZERO;
                    myrec = &record;
                }
                break;

            case ICAL_ACTION_EMAIL:
                if (!count) {
                    record.restriction = ICAL_RESTRICTION_ONE;
                    myrec = &record;
                }
                break;

            default:
                break;
            }
            break;

        default:
            break;
        }
        break;

    case ICAL_VLOCATION_COMPONENT:
        if (!icalcomponent_get_first_property(comp, ICAL_PROXIMITY_PROPERTY)) {
            return
                "Failed iTIP restrictions for VLOCATION component. "
                "This component must only appear in a VALARM component "
                "if the VALARM has a PROXIMITY property.";
        }
        break;

    default:
        break;
    }

    if (myrec) {
        _check_restriction(comp, myrec, count, NULL);
    }

    return 0;
}

<insert_code_here>

static const icalrestriction_record *icalrestriction_get_restriction(
    const icalrestriction_record *start,
    icalproperty_method method, icalcomponent_kind component,
    icalproperty_kind property, icalcomponent_kind subcomp)
{
    const icalrestriction_record *rec;

    if (!start) {
        start = &icalrestriction_records[0];
    }

    for (rec = start; rec && rec->restriction != ICAL_RESTRICTION_NONE; rec++) {

        if (method == rec->method &&
            (component == ICAL_ANY_COMPONENT ||
             (component == rec->component &&
              (property == ICAL_ANY_PROPERTY || property == rec->property) &&
              (subcomp == ICAL_ANY_COMPONENT || subcomp == rec->subcomponent)))) {
            return rec;
        }
    }

    return &null_restriction_record;
}