falso
/
cdesktopenv
mirror of https://git.code.sf.net/p/cdesktopenv/code
1
0
Fork 0
Code Issues Releases Wiki Activity
cdesktopenv/cde/lib/csa/match.c

1178 lines
28 KiB
C
Raw Permalink Blame History

/*
* CDE - Common Desktop Environment
*
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
*
* These libraries and programs are free software; you can
* redistribute them and/or modify them under the terms of the GNU
* Lesser General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* These libraries and programs are distributed in the hope that
* they will be useful, but WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with these libraries and programs; if not, write
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
* Floor, Boston, MA 02110-1301 USA
*/
/* $TOG: match.c /main/2 1999/10/14 17:15:21 mgreess $ */
/*
* (c) Copyright 1993, 1994 Hewlett-Packard Company
* (c) Copyright 1993, 1994 International Business Machines Corp.
* (c) Copyright 1993, 1994 Novell, Inc.
* (c) Copyright 1993, 1994 Sun Microsystems, Inc.
*/
#include <EUSCompat.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "nametbl.h"
#include "match.h"
#include "cm.h"
#include "appt4.h"
#include "attr.h"
#include "convert4-5.h"
#include "iso8601.h"
#include "misc.h"
/*****************************************************************************
* forward declaration of static functions
*****************************************************************************/
static boolean_t match_this_attribute(
Appt_4 *appt,
cms_attribute attr,
CSA_enum op);
static Attribute_4 *get_appt_reminder(Attribute_4 *attr, char *oldattr);
static boolean_t match_names(char *target, uint num_names, char **names);
static boolean_t match_old_reminder_attribute(
Attribute_4 *rem4,
cms_attribute_value *val,
CSA_enum op);
static boolean_t is_same_string(char *str1, char *str2);
static boolean_t contain_substr(char *str1, char *str2);
static boolean_t is_same_opaque_data(CSA_opaque_data *d1, CSA_opaque_data *d2);
/*****************************************************************************
* extern functions used in the library
*****************************************************************************/
/*
* new array of cms_attribute type is allocated.
* and CSA_attribute_value is converted to cms_attribtue_value type
* If conflicts in the search criteria that lead to a no
* match situation is detected, no_match will be set to B_TRUE and the
* function return CSA_SUCCESS right away. The calling
* function should always check the return status and the no_match
* parameter first before using any of the other output parameters.
* If CSA_E_INVALID_ATTRIBUTE is returned, the caller should treat
* it as a no_match case.
*/
extern CSA_return_code
_DtCmHashCriteria(
_DtCmNameTable *tbl,
CSA_uint32 num_attrs,
CSA_attribute *csaattrs,
cms_attribute *cmsattrs,
CSA_enum *ops,
boolean_t *no_match,
boolean_t *no_start_time_range,
boolean_t *no_end_time_range,
time_t *start1,
time_t *start2,
time_t *end1,
time_t *end2,
long *id,
CSA_uint32 *hnum,
cms_attribute **hattrs,
CSA_enum **hops)
{
int i, j, index, starti = -1, endi = -1;
time_t tstart1, tstart2, tend1, tend2;
time_t tick;
char *name;
cms_attribute_value *val, *hval = NULL;
boolean_t keep;
*hnum = 0;
*hattrs = NULL;
*hops = NULL;
*no_match = B_FALSE;
/*
* Find time range.
*/
tstart1 = _DtCM_BOT;
tstart2 = _DtCM_EOT;
tend1 = _DtCM_BOT;
tend2 = _DtCM_EOT;
*id = 0;
for (i = 0, j = 0; i < num_attrs; i++) {
keep = B_TRUE;
name = (csaattrs ? csaattrs[i].name : cmsattrs[i].name.name);
if ((index = _DtCm_get_index_from_table(tbl, name)) == -1)
return (CSA_E_INVALID_ATTRIBUTE);
val = (csaattrs ? ((cms_attribute_value *)csaattrs[i].value) :
cmsattrs[i].value);
if (index == CSA_ENTRY_ATTR_START_DATE_I && val == NULL) {
if (ops == NULL || ops[i] == CSA_MATCH_EQUAL_TO) {
*no_match = B_TRUE;
return (CSA_SUCCESS);
} else if (ops && (ops[i] == CSA_MATCH_ANY ||
ops[i] == CSA_MATCH_NOT_EQUAL_TO)) {
/* match any start date, no need to set
* the range since the range is default to
* the largest range already
*/
starti = i;
keep = B_FALSE;
}
} else if (index == CSA_ENTRY_ATTR_START_DATE_I && val) {
starti = i;
keep = B_FALSE;
if (_csa_iso8601_to_tick(val->item.date_time_value,
&tick))
return (CSA_E_INVALID_DATE_TIME);
if (ops == NULL || ops[i] == CSA_MATCH_EQUAL_TO) {
tstart1 = tick - 1;
tstart2 = tick + 1;
} else switch (ops[i]) {
/*
*case CSA_MATCH_ANY:
*case CSA_MATCH_NOT_EQUAL_TO:
* this will be really expensive
* tstart1 = _DtCM_BOT;
* tstart2 = _DtCM_EOT;
* break;
*/
case CSA_MATCH_NOT_EQUAL_TO:
keep = B_TRUE;
break;
case CSA_MATCH_LESS_THAN:
tstart2 = tick;
break;
case CSA_MATCH_LESS_THAN_OR_EQUAL_TO:
tstart2 = tick + 1;
break;
case CSA_MATCH_GREATER_THAN:
tstart1 = tick;
break;
case CSA_MATCH_GREATER_THAN_OR_EQUAL_TO:
tstart1 = tick - 1;
break;
}
} else if (index == CSA_ENTRY_ATTR_END_DATE_I && val) {
endi = i;
keep = B_FALSE;
if (_csa_iso8601_to_tick(val->item.date_time_value,
&tick))
return (CSA_E_INVALID_DATE_TIME);
if (ops == NULL || ops[i] == CSA_MATCH_EQUAL_TO) {
tend1 = tick - 1;
tend2 = tick + 1;
} else switch (ops[i]) {
/*
*case CSA_MATCH_ANY:
*case CSA_MATCH_NOT_EQUAL_TO:
* this will be really expensive
* old_range.key1 = _DtCM_BOT;
* old_range.key2 = _DtCM_EOT;
* break;
*/
case CSA_MATCH_NOT_EQUAL_TO:
keep = B_TRUE;
break;
case CSA_MATCH_LESS_THAN:
tend2 = tick;
break;
case CSA_MATCH_LESS_THAN_OR_EQUAL_TO:
tend2 = tick + 1;
break;
case CSA_MATCH_GREATER_THAN:
tend1 = tick;
break;
case CSA_MATCH_GREATER_THAN_OR_EQUAL_TO:
tend1 = tick - 1;
break;
}
} else if (index == CSA_ENTRY_ATTR_REFERENCE_IDENTIFIER_I) {
keep = B_FALSE;
if (val && val->item.opaque_data_value &&
val->item.opaque_data_value->data) {
*id = atoi((char *)val->\
item.opaque_data_value->data);
}
}
if (keep == B_TRUE) {
void *savedHattrs = NULL;
if (*hattrs == NULL) {
if ((*hattrs = (cms_attribute *)calloc(1,
sizeof(cms_attribute)*(num_attrs-i)+
sizeof(char *))) == NULL)
return (CSA_E_INSUFFICIENT_MEMORY);
if ((hval = (cms_attribute_value *)calloc(1,
sizeof(cms_attribute_value)*(num_attrs-i)))
== NULL) {
free(*hattrs);
return (CSA_E_INSUFFICIENT_MEMORY);
} else {
savedHattrs = (void *)*hattrs;
*((char**)(*hattrs)) = (char *)&hval[0];
*hattrs = (cms_attribute *)\
((char *)(*hattrs)+sizeof(char*));
}
if (ops && (*hops = (CSA_enum *)calloc(1,
sizeof(CSA_enum)*(num_attrs-i))) == NULL) {
free(hval);
free(savedHattrs);
return (CSA_E_INSUFFICIENT_MEMORY);
}
}
(*hattrs)[j].name.name = name;
(*hattrs)[j].name.num = index;
if (val && hval) {
(*hattrs)[j].value = &hval[j];
(*hattrs)[j].value->type = val->type;
if (csaattrs &&
val->type == CSA_VALUE_CALENDAR_USER) {
if (csaattrs[i].value->item.calendar_user_value)
(*hattrs)[j].value->item.\
calendar_user_value =
csaattrs[i].value->item.\
calendar_user_value->\
user_name;
} else
(*hattrs)[j].value->item.sint32_value =
val->item.sint32_value;
}
if (ops != NULL)
(*hops)[j] = ops[i];
j++;
}
}
if (j == 0) {
if (*hattrs) _DtCmFreeHashedArrays(*hnum, *hattrs, *hops);
*hnum = 0;
*hattrs = NULL;
*hops = NULL;
} else {
*hnum = j;
}
if (starti == -1)
*no_start_time_range = B_TRUE;
else
*no_start_time_range = B_FALSE;
if (endi == -1)
*no_end_time_range = B_TRUE;
else
*no_end_time_range = B_FALSE;
/* do some optimization here: if an end time range is
* specified, since start time cannot be > end time,
* set end of start time range to end of end time range
* if the original end of start time range is > the
* end of end time range
*/
if (endi != -1 && start2 > end2)
tstart2 = tend2;
*start1 = tstart1;
*start2 = tstart2;
*end1 = tend1;
*end2 = tend2;
return (CSA_SUCCESS);
}
extern void _DtCmFreeHashedArrays(
CSA_uint32 hnum,
cms_attribute *hattrs,
CSA_enum *hops)
{
char *ptr, *ptr1;
if (hattrs) {
ptr = ((char *)hattrs - sizeof(char *));
ptr1 = *((char **)ptr);
free(ptr1);
free(ptr);
}
if (hops) free(hops);
}
/*
* The algorithm used now simply goes through each criterion.
* Probably need to optimize this.
*/
extern Appt_4 *
_DtCm_match_appts(
Appt_4 *appts,
long id,
boolean_t no_end_time_range,
time_t end1,
time_t end2,
CSA_uint32 num_attrs,
cms_attribute *attrs,
CSA_enum *ops)
{
Appt_4 *head = NULL;
Appt_4 *freelist = NULL;
Appt_4 *last, *nptr;
time_t endtick;
if (id == 0 && num_attrs == 0 && no_end_time_range)
return (appts);
while (appts != NULL) {
nptr = appts->next;
endtick = appts->appt_id.tick + appts->duration;
if ((id > 0 && id != appts->appt_id.key) ||
(!no_end_time_range && (appts->duration == 0 ||
endtick < end1 || endtick >= end2)) ||
(num_attrs > 0 && !_DtCm_match_one_appt(appts, num_attrs,
attrs, ops)))
{
/* not match */
appts->next = freelist;
freelist = appts;
} else {
/* match */
appts->next = NULL;
if (head == NULL) {
head = appts;
last = appts;
} else {
last->next = appts;
last = appts;
}
}
appts = nptr;
}
_DtCm_free_appt4(freelist);
return (head);
}
extern boolean_t
_DtCm_match_one_appt(
Appt_4 *appt,
uint num_attrs,
cms_attribute *attrs,
CSA_enum *ops)
{
int i;
for (i = 0; i < num_attrs; i++) {
if (match_this_attribute(appt, attrs[i],
(ops ? ops[i] : CSA_MATCH_EQUAL_TO)) == B_FALSE)
return (B_FALSE);
}
/* match all given attributes */
return (B_TRUE);
}
extern Reminder_4 *
_DtCm_match_reminders(Reminder_4 *rems, uint num_names, char **names)
{
Reminder_4 *head = NULL;
Reminder_4 *freelist = NULL;
Reminder_4 *nptr;
if (rems == NULL)
return (NULL);
if (names == NULL || num_names == 0) {
return (rems);
}
while (rems != NULL) {
nptr = rems->next;
if (match_names(rems->attr.attr, num_names, names) == B_TRUE) {
rems->next = head;
head = rems;
} else {
rems->next = freelist;
freelist = rems;
}
rems = nptr;
}
_DtCm_free_reminder4(freelist);
return (head);
}
extern CSA_return_code
_DtCm_check_operator(
uint size,
CSA_attribute *csaattrs,
cms_attribute *cmsattrs,
CSA_enum *ops)
{
int i;
char *name;
cms_attribute_value *val;
for (i = 0; i < size; i++) {
if ((name = csaattrs ? csaattrs[i].name : cmsattrs[i].name.name)
== NULL)
continue;
val = (csaattrs ? ((cms_attribute_value *)csaattrs[i].value) :
cmsattrs[i].value);
/* don't support matching on CSA_VALUE_OPAQUE_DATA,
* CSA_VALUE_ACCESS_LIST, CSA_VALUE_ATTENDEE_LIST,
* and CSA_VALUE_DATE_TIME_LIST data type
*/
if (val && (val->type == CSA_VALUE_ACCESS_LIST ||
val->type == CSA_VALUE_ATTENDEE_LIST ||
val->type == CSA_VALUE_DATE_TIME_LIST ||
(val->type == CSA_VALUE_OPAQUE_DATA &&
(strcmp(name, CSA_ENTRY_ATTR_REFERENCE_IDENTIFIER) ||
(ops && ops[i] != CSA_MATCH_EQUAL_TO)))))
return (CSA_E_UNSUPPORTED_ENUM);
/* all other test depends on ops being not NULL */
if (ops == NULL)
continue;
/* unknown operator */
if (ops[i] < CSA_MATCH_ANY || ops[i] > CSA_MATCH_CONTAIN)
return (CSA_E_INVALID_ENUM);
/*
* if an operator other than CSA_MATCH_ANY, or
* CSA_MATCH_EQUAL_TO, CSA_MATCH_NOT_EQUAL_TO
* is specified, must specify a value
*/
if (val == NULL && (ops[i] != CSA_MATCH_ANY &&
ops[i] != CSA_MATCH_EQUAL_TO &&
ops[i] != CSA_MATCH_NOT_EQUAL_TO))
return (CSA_E_INVALID_ENUM);
/*
* only support CSA_MATCH_ANY and CSA_MATCH_EQUAL_TO
* for CSA_VALUE_REMINDER, CSA_VALUE_CALENDAR_USER,
* and CSA_VALUE_DATE_TIME_RANGE data type
*/
if (val && (val->type == CSA_VALUE_REMINDER ||
val->type == CSA_VALUE_CALENDAR_USER ||
val->type == CSA_VALUE_DATE_TIME_RANGE) &&
(ops[i] != CSA_MATCH_ANY &&
ops[i] != CSA_MATCH_EQUAL_TO))
return (CSA_E_UNSUPPORTED_ENUM);
/*
* only support CSA_MATCH_ANY, CSA_MATCH_EQUAL_TO,
* CSA_MATCH_NOT_EQUAL_TO and CSA_MATCH_CONTAIN
* for strings, other op does not make sense
*/
if (val && val->type == CSA_VALUE_STRING &&
(ops[i] > CSA_MATCH_NOT_EQUAL_TO &&
ops[i] < CSA_MATCH_CONTAIN))
return (CSA_E_UNSUPPORTED_ENUM);
/* CSA_MATCH_CONTAIN applies to CSA_VALUE_STRING type only */
if (ops[i] == CSA_MATCH_CONTAIN && val &&
val->type != CSA_VALUE_STRING)
return (CSA_E_UNSUPPORTED_ENUM);
}
return (CSA_SUCCESS);
}
extern boolean_t
_DtCm_match_time_attribute(
cms_attribute_value *val1,
cms_attribute_value *val2,
CSA_enum op)
{
cms_attribute_value tval1, tval2;
if ((val1 && val1->type != CSA_VALUE_DATE_TIME) ||
(val2 && val2->type != CSA_VALUE_DATE_TIME))
return (B_FALSE);
if (val1) {
tval1.type = CSA_VALUE_SINT32;
if (_csa_iso8601_to_tick(val1->item.date_time_value,
(time_t *)&tval1.item.sint32_value))
return (B_FALSE);
}
if (val2) {
tval2.type = CSA_VALUE_SINT32;
if (_csa_iso8601_to_tick(val2->item.date_time_value,
(time_t *)&tval2.item.sint32_value))
return (B_FALSE);
}
return (_DtCm_match_sint32_attribute((val1 ? &tval1 : NULL),
(val2 ? &tval2 : NULL), op));
}
extern boolean_t
_DtCm_match_time_duration_attribute(
cms_attribute_value *val1,
cms_attribute_value *val2,
CSA_enum op)
{
cms_attribute_value tval1, tval2;
if ((val1 && val1->type != CSA_VALUE_TIME_DURATION) ||
(val2 && val2->type != CSA_VALUE_TIME_DURATION))
return (B_FALSE);
if (val1) {
tval1.type = CSA_VALUE_SINT32;
if (_csa_iso8601_to_duration(val1->item.time_duration_value,
(time_t *)&tval1.item.sint32_value))
return (B_FALSE);
}
if (val2) {
tval2.type = CSA_VALUE_SINT32;
if (_csa_iso8601_to_duration(val2->item.time_duration_value,
(time_t *)&tval2.item.sint32_value))
return (B_FALSE);
}
return (_DtCm_match_sint32_attribute((val1 ? &tval1 : NULL),
(val2 ? &tval2 : NULL), op));
}
extern boolean_t
_DtCm_match_sint32_attribute(
cms_attribute_value *val1,
cms_attribute_value *val2,
CSA_enum op)
{
if (val1 && val2 && val1->type != val2->type)
return (B_FALSE);
switch (op) {
case CSA_MATCH_ANY:
if (val1 != NULL)
return (B_TRUE);
else
return (B_FALSE);
case CSA_MATCH_EQUAL_TO:
if (val2 == NULL) {
if (val1 == NULL)
return (B_TRUE);
else
return (B_FALSE);
} else {
if (val1 && val1->item.sint32_value
== val2->item.sint32_value)
return (B_TRUE);
else
return (B_FALSE);
}
case CSA_MATCH_NOT_EQUAL_TO:
if (val2 == NULL) {
if (val1 != NULL)
return (B_TRUE);
else
return (B_FALSE);
} else {
if (val1 && val1->item.sint32_value
!= val2->item.sint32_value)
return (B_TRUE);
else
return (B_FALSE);
}
case CSA_MATCH_LESS_THAN:
if (val1 == NULL)
return (B_FALSE);
else if (val2 && val1->item.sint32_value < val2->item.sint32_value)
return (B_TRUE);
else
return (B_FALSE);
case CSA_MATCH_LESS_THAN_OR_EQUAL_TO:
if (val1 == NULL)
return (B_FALSE);
else if (val2 && val1->item.sint32_value <= val2->item.sint32_value)
return (B_TRUE);
else
return (B_FALSE);
case CSA_MATCH_GREATER_THAN:
if (val1 == NULL)
return (B_FALSE);
else if (val2 && val1->item.sint32_value > val2->item.sint32_value)
return (B_TRUE);
else
return (B_FALSE);
case CSA_MATCH_GREATER_THAN_OR_EQUAL_TO:
if (val1 == NULL)
return (B_FALSE);
else if (val2 && val1->item.sint32_value >= val2->item.sint32_value)
return (B_TRUE);
else
return (B_FALSE);
case CSA_MATCH_CONTAIN: /* only apply to string type */
default:
return (B_FALSE);
}
}
extern boolean_t
_DtCm_match_uint32_attribute(
cms_attribute_value *val1,
cms_attribute_value *val2,
CSA_enum op)
{
if (val1 && val2 && val1->type != val2->type)
return (B_FALSE);
switch (op) {
case CSA_MATCH_ANY:
if (val1 != NULL)
return (B_TRUE);
else
return (B_FALSE);
case CSA_MATCH_EQUAL_TO:
if (val2 == NULL) {
if (val1 == NULL)
return (B_TRUE);
else
return (B_FALSE);
} else {
if (val1 && val1->item.uint32_value
== val2->item.uint32_value)
return (B_TRUE);
else
return (B_FALSE);
}
case CSA_MATCH_NOT_EQUAL_TO:
if (val2 == NULL) {
if (val1 != NULL)
return (B_TRUE);
else
return (B_FALSE);
} else {
if (val1 && val1->item.uint32_value
!= val2->item.uint32_value)
return (B_TRUE);
else
return (B_FALSE);
}
case CSA_MATCH_LESS_THAN:
if (val1 == NULL)
return (B_FALSE);
else if (val2 && val1->item.uint32_value < val2->item.uint32_value)
return (B_TRUE);
else
return (B_FALSE);
case CSA_MATCH_LESS_THAN_OR_EQUAL_TO:
if (val1 == NULL)
return (B_FALSE);
else if (val2 && val1->item.uint32_value <= val2->item.uint32_value)
return (B_TRUE);
else
return (B_FALSE);
case CSA_MATCH_GREATER_THAN:
if (val1 == NULL)
return (B_FALSE);
else if (val2 && val1->item.uint32_value > val2->item.uint32_value)
return (B_TRUE);
else
return (B_FALSE);
case CSA_MATCH_GREATER_THAN_OR_EQUAL_TO:
if (val1 == NULL)
return (B_FALSE);
else if (val2 && val1->item.uint32_value >= val2->item.uint32_value)
return (B_TRUE);
else
return (B_FALSE);
case CSA_MATCH_CONTAIN: /* only apply to string type */
default:
return (B_FALSE);
}
}
/*
* The matching value should have been checked by _DtCm_check_operator()
* already so contains valid value for the corresponding operator.
* Treat NULL string and string with zero length to be equal.
* val1 is the string to be matched
* val2 is the matching string
*/
extern boolean_t
_DtCm_match_string_attribute(
cms_attribute_value *val1,
cms_attribute_value *val2,
CSA_enum op)
{
if (val1 && val2 && val1->type != val2->type)
return (B_FALSE);
if (val1 == NULL) {
if ((op == CSA_MATCH_EQUAL_TO && val2 == NULL) ||
(op == CSA_MATCH_NOT_EQUAL_TO && val2))
return (B_TRUE);
else
return (B_FALSE);
}
switch (op) {
case CSA_MATCH_ANY:
return (B_TRUE); /* since val1 != NULL */
case CSA_MATCH_EQUAL_TO:
if (val2 == NULL) {
return (B_FALSE); /* since val1 != NULL */
} else {
return (is_same_string(val1->item.string_value,
val2->item.string_value));
}
case CSA_MATCH_NOT_EQUAL_TO:
if (val2 == NULL) {
return (B_TRUE); /* since val1 != NULL */
} else {
return (!is_same_string(val1->item.string_value,
val2->item.string_value));
}
case CSA_MATCH_CONTAIN:
/* if val2 is null, will be rejected already */
return (contain_substr(val1->item.string_value,
val2->item.string_value));
case CSA_MATCH_LESS_THAN:
case CSA_MATCH_LESS_THAN_OR_EQUAL_TO:
case CSA_MATCH_GREATER_THAN:
case CSA_MATCH_GREATER_THAN_OR_EQUAL_TO:
default:
return (B_FALSE);
}
}
extern boolean_t
_DtCm_match_reminder_attribute(
cms_attribute_value *val1,
cms_attribute_value *val2,
CSA_enum op)
{
CSA_reminder *r1, *r2;
cms_attribute_value tv1, tv2;
if ((val1 && val1->type != CSA_VALUE_REMINDER) ||
(val2 && val2->type != CSA_VALUE_REMINDER))
return (B_FALSE);
switch (op) {
case CSA_MATCH_ANY:
if (val1 != NULL)
return (B_TRUE);
else
return (B_FALSE);
case CSA_MATCH_EQUAL_TO:
if (val2 == NULL || val2->item.reminder_value == NULL) {
if (val1 == NULL || val1->item.reminder_value == NULL)
return (B_TRUE);
else
return (B_FALSE);
} else if (val1 == NULL || val1->item.reminder_value == NULL) {
return (B_FALSE);
} else {
r1 = val1->item.reminder_value;
r2 = val2->item.reminder_value;
if ((r1->repeat_count != r2->repeat_count) ||
!is_same_opaque_data(&r1->reminder_data,
&r2->reminder_data))
return (B_FALSE);
tv1.type = CSA_VALUE_SINT32;
tv2.type = CSA_VALUE_SINT32;
tv1.item.sint32_value = 0;
tv2.item.sint32_value = 0;
if (r1->lead_time && *r1->lead_time &&
_csa_iso8601_to_duration(r1->lead_time,
(time_t *)&tv1.item.sint32_value))
return (B_FALSE);
if (r2->lead_time && *r2->lead_time &&
_csa_iso8601_to_duration(r2->lead_time,
(time_t *)&tv2.item.sint32_value))
return (B_FALSE);
if (_DtCm_match_sint32_attribute(&tv1, &tv2, op)
== B_FALSE)
return (B_FALSE);
tv1.item.sint32_value = 0;
tv2.item.sint32_value = 0;
if (r1->snooze_time && *r1->snooze_time &&
_csa_iso8601_to_duration(r1->snooze_time,
(time_t *)&tv1.item.sint32_value))
return (B_FALSE);
if (r2->snooze_time && *r2->snooze_time &&
_csa_iso8601_to_duration(r2->snooze_time,
(time_t *)&tv2.item.sint32_value))
return (B_FALSE);
return (_DtCm_match_sint32_attribute(&tv1, &tv2, op));
}
/* these are not supported for CSA_VALUE_REMINDER type */
case CSA_MATCH_NOT_EQUAL_TO:
case CSA_MATCH_LESS_THAN:
case CSA_MATCH_LESS_THAN_OR_EQUAL_TO:
case CSA_MATCH_GREATER_THAN:
case CSA_MATCH_GREATER_THAN_OR_EQUAL_TO:
case CSA_MATCH_CONTAIN:
default:
return (B_FALSE);
}
}
/*****************************************************************************
* static functions used within the file
*****************************************************************************/
static boolean_t
match_this_attribute(Appt_4 *appt, cms_attribute attr, CSA_enum op)
{
time_t tick;
_DtCm_old_attrs oldtag;
cms_attribute_value oldattr;
cms_attribute_value matchattr;
if (attr.name.name == NULL || attr.value == NULL)
return (B_FALSE);
if ((attr.name.num > 0 &&
_DtCm_get_old_attr_by_index(attr.name.num, &oldtag)) ||
(attr.name.num == 0 &&
_DtCm_get_old_attr_by_name(attr.name.name, &oldtag)))
return (B_FALSE);
switch (oldtag) {
/* id is matched somewhere else
case _DtCm_old_attr_id:
*/
case _DtCm_old_attr_time:
/* the only case is to match a non-NULL start date with
* CSA_MATCH_NOT_EQUAL_TO
*/
_csa_iso8601_to_tick(attr.value->item.date_time_value, &tick);
if (appt->appt_id.tick == tick)
return (B_FALSE);
else
return (B_TRUE);
case _DtCm_old_attr_type:
oldattr.type = CSA_VALUE_UINT32;
oldattr.item.uint32_value =
_DtCm_eventtype4_to_type(appt->tag->tag);
return (_DtCm_match_uint32_attribute(&oldattr, attr.value, op));
case _DtCm_old_attr_type2:
oldattr.type = CSA_VALUE_STRING;
oldattr.item.string_value =
_DtCm_eventtype4_to_subtype(appt->tag->tag);
return (_DtCm_match_string_attribute(&oldattr, attr.value, op));
case _DtCm_old_attr_duration:
/* the only possibility is to match a NULL end date value
* or match a non-NULL end date with MATCH_NOT_EQUAL_TO
*/
if (op == CSA_MATCH_EQUAL_TO) {
if (appt->duration == 0)
return (B_TRUE);
else
return (B_FALSE);
} else if (op == CSA_MATCH_ANY) {
return (B_TRUE);
} else if (op == CSA_MATCH_NOT_EQUAL_TO && attr.value == NULL) {
if (appt->duration == 0)
return (B_FALSE);
else
return (B_TRUE);
} else if (op == CSA_MATCH_NOT_EQUAL_TO && attr.value) {
_csa_iso8601_to_tick(attr.value->item.date_time_value,
&tick);
if ((appt->appt_id.tick+appt->duration) == tick)
return (B_FALSE);
else
return (B_TRUE);
} else
return (B_FALSE);
case _DtCm_old_attr_repeat_type:
oldattr.type = CSA_VALUE_SINT32;
oldattr.item.sint32_value =
_DtCm_interval4_to_rtype(appt->period.period);
return (_DtCm_match_sint32_attribute(&oldattr, attr.value, op));
case _DtCm_old_attr_what:
oldattr.type = CSA_VALUE_STRING;
oldattr.item.string_value = appt->what;
return (_DtCm_match_string_attribute(&oldattr, attr.value, op));
case _DtCm_old_attr_status:
oldattr.type = CSA_VALUE_UINT32;
oldattr.item.uint32_value =
_DtCm_apptstatus4_to_status(appt->appt_status);
return (_DtCm_match_uint32_attribute(&oldattr, attr.value, op));
case _DtCm_old_attr_author:
oldattr.type = CSA_VALUE_STRING;
oldattr.item.string_value = appt->author;
return (_DtCm_match_string_attribute(&oldattr, attr.value, op));
case _DtCm_old_attr_beep_reminder:
return (match_old_reminder_attribute(
get_appt_reminder(appt->attr,
_DtCM_OLD_ATTR_BEEP_REMINDER), attr.value, op));
case _DtCm_old_attr_flash_reminder:
return (match_old_reminder_attribute(
get_appt_reminder(appt->attr,
_DtCM_OLD_ATTR_FLASH_REMINDER), attr.value, op));
case _DtCm_old_attr_mail_reminder:
return (match_old_reminder_attribute(
get_appt_reminder(appt->attr,
_DtCM_OLD_ATTR_MAIL_REMINDER), attr.value, op));
case _DtCm_old_attr_popup_reminder:
return (match_old_reminder_attribute(
get_appt_reminder(appt->attr,
_DtCM_OLD_ATTR_POPUP_REMINDER), attr.value, op));
case _DtCm_old_attr_repeat_times:
oldattr.type = CSA_VALUE_UINT32;
oldattr.item.uint32_value = appt->ntimes;
return (_DtCm_match_uint32_attribute(&oldattr, attr.value, op));
case _DtCm_old_attr_showtime:
oldattr.type = CSA_VALUE_SINT32;
oldattr.item.sint32_value = appt->tag->showtime;
return (_DtCm_match_sint32_attribute(&oldattr, attr.value, op));
case _DtCm_old_attr_privacy:
oldattr.type = CSA_VALUE_UINT32;
oldattr.item.uint32_value =
_DtCm_privacy4_to_classification(appt->privacy);
return (_DtCm_match_uint32_attribute(&oldattr, attr.value, op));
case _DtCm_old_attr_repeat_nth_interval:
oldattr.type = CSA_VALUE_UINT32;
oldattr.item.uint32_value = appt->period.nth;
return (_DtCm_match_uint32_attribute(&oldattr, attr.value, op));
case _DtCm_old_attr_repeat_nth_weeknum:
oldattr.type = CSA_VALUE_SINT32;
oldattr.item.sint32_value = appt->period.nth;
return (_DtCm_match_sint32_attribute(&oldattr, attr.value, op));
case _DtCm_old_attr_end_date:
oldattr.type = CSA_VALUE_SINT32;
oldattr.item.sint32_value = appt->period.enddate;
if (attr.value) {
matchattr.type = CSA_VALUE_SINT32;
_csa_iso8601_to_tick(attr.value->item.date_time_value,
(time_t *)&matchattr.item.sint32_value);
}
return (_DtCm_match_sint32_attribute(&oldattr,
(attr.value ? &matchattr : NULL), op));
default:
return (B_FALSE);
}
}
static Attribute_4 *
get_appt_reminder(Attribute_4 *attr4, char *oldattr)
{
while (attr4 != NULL) {
if (attr4->attr && !strcmp(attr4->attr, oldattr))
return (attr4);
else
attr4 = attr4->next;
}
return (NULL);
}
static boolean_t
match_names(char *oldattr, uint num_names, char **names)
{
int i;
char *attrname;
if (oldattr == NULL)
return (B_FALSE);
attrname = _DtCm_old_reminder_name_to_name(oldattr);
for (i = 0; i < num_names; i++) {
if (names[i] && (strcmp(names[i], attrname) == 0)) {
return (B_TRUE);
}
}
return (B_FALSE);
}
static boolean_t
match_old_reminder_attribute(
Attribute_4 *rem4,
cms_attribute_value *val,
CSA_enum op)
{
cms_attribute_value oldattr;
CSA_reminder rem;
char ltstring[BUFSIZ];
if (rem4 != NULL) {
rem.snooze_time = NULL;
rem.repeat_count = 0;
rem.reminder_data.size = (rem4->clientdata ?
strlen(rem4->clientdata) : 0);
rem.reminder_data.data = (unsigned char *)rem4->clientdata;
_csa_duration_to_iso8601((rem4->value ? atoi(rem4->value) : 0),
ltstring);
rem.lead_time = ltstring;
oldattr.type = CSA_VALUE_REMINDER;
oldattr.item.reminder_value = &rem;
}
return (_DtCm_match_reminder_attribute((rem4 ? &oldattr : NULL),
val, op));
}
static boolean_t
is_same_string(char *str1, char *str2)
{
/* val2 is a NULL string */
if (str2 == NULL || *str2 == 0) {
if (str1 == NULL || *str1 == 0)
return (B_TRUE);
else
return (B_FALSE);
} else {
if (str1 && strcmp(str1, str2) == 0)
return (B_TRUE);
else
return (B_FALSE);
}
}
static boolean_t
contain_substr(char *str1, char *str2)
{
int i, len;
if (str2 == NULL || *str2 == '\0')
return (B_TRUE);
if (str1 == NULL || *str1 == '\0') {
return (B_FALSE);
} else {
len = strlen(str2);
for (i = 0; str1[i] != '\0'; i++) {
if (strncasecmp(&str1[i], str2, len) == 0)
return (B_TRUE);
}
return (B_FALSE);
}
}
static boolean_t
is_same_opaque_data(CSA_opaque_data *d1, CSA_opaque_data *d2)
{
/* val2 is a NULL string */
if (d2 == NULL || d2->size == 0) {
if (d1 == NULL || d1->size == 0)
return (B_TRUE);
else
return (B_FALSE);
} else {
if (d1 && d1->size > 0) {
if (d1->size == d2->size) {
if (memcmp(d1->data, d2->data, d1->size) == 0)
return (B_TRUE);
else
return (B_FALSE);
} else
return (B_FALSE);
} else
return (B_FALSE);
}
}
Reference in New Issue View Git Blame Copy Permalink