CDE/cde/lib/csa/attr.c

/*
 * 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
 */
/* $XConsortium: attr.c /main/1 1996/04/21 19:21:41 drk $ */
/*
 *  (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 <sys/types.h>
#include <unistd.h>
#include "attr.h"
#include "cmsdata.h"
#include "nametbl.h"
#include "free.h"
#include "misc.h"
#include "iso8601.h"
#include "lutil.h"

/*
 * calendar attributes defined by the library
 * Note: index zero is not used
 */
char *_CSA_calendar_attribute_names[] = {
	NULL,
	"-//XAPIA/CSA/CALATTR//NONSGML Access List//EN",
	"-//XAPIA/CSA/CALATTR//NONSGML Calendar Name//EN",
	"-//XAPIA/CSA/CALATTR//NONSGML Calendar Owner//EN",
	"-//XAPIA/CSA/CALATTR//NONSGML Calendar Size//EN",
	"-//XAPIA/CSA/CALATTR//NONSGML Character Set//EN",
	"-//XAPIA/CSA/CALATTR//NONSGML Country//EN",
	"-//XAPIA/CSA/CALATTR//NONSGML Date Created//EN",
	"-//XAPIA/CSA/CALATTR//NONSGML Language//EN",
	"-//XAPIA/CSA/CALATTR//NONSGML Number Entries//EN",
	"-//XAPIA/CSA/CALATTR//NONSGML Product Identifier//EN",
	"-//XAPIA/CSA/CALATTR//NONSGML Time Zone//EN",
	"-//XAPIA/CSA/CALATTR//NONSGML Version//EN",
	"-//XAPIA/CSA/CALATTR//NONSGML Work Schedule//EN",
	"-//CDE_XAPIA_PRIVATE/CSA/CALATTR//NONSGML Server Version//EN",
	"-//CDE_XAPIA_PRIVATE/CSA/CALATTR//NONSGML Data Version//EN",
	"-//CDE_XAPIA_PRIVATE/CSA/CALATTR//NONSGML Calendar Delimiter//EN"
};

/*
 * entry attributes defined by the library
 * Note: index zero is not used
 */
char *_CSA_entry_attribute_names[] = {
	NULL,
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Attendee List//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Audio Reminder//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Classification//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Date Completed//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Date Created//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Description//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Due Date//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML End Date//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Exception Dates//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Exception Rule//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Flashing Reminder//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Last Update//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Mail Reminder//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Number Recurrences//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Organizer//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Popup Reminder//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Priority//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Recurrence Rule//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Recurring Dates//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Reference Identifier//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Sequence Number//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Sponsor//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Start Date//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Status//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Subtype//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Summary//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Time Transparency//EN",
	"-//XAPIA/CSA/ENTRYATTR//NONSGML Type//EN",
	"-//CDE_XAPIA_PRIVATE/CSA/ENTRYATTR//NONSGML Show Time//EN",
	"-//CDE_XAPIA_PRIVATE/CSA/ENTRYATTR//NONSGML Repeat Type//EN",
	"-//CDE_XAPIA_PRIVATE/CSA/ENTRYATTR//NONSGML Repeat Times//EN",
	"-//CDE_XAPIA_PRIVATE/CSA/ENTRYATTR//NONSGML Repeat Interval//EN",
	"-//CDE_XAPIA_PRIVATE/CSA/ENTRYATTR//NONSGML Repeat Occurrence Number//EN",
	"-//CDE_XAPIA_PRIVATE/CSA/ENTRYATTR//NONSGML Sequence End Date//EN",
	"-//CDE_XAPIA_PRIVATE/CSA/ENTRYATTR//NONSGML Entry Delimiter//EN"
};

/*
 * Values for entry attribute CSA_ENTRY_ATTR_SUBTYPE
 */
char *_CSA_entry_subtype_values[] = {
	"-//XAPIA/CSA/SUBTYPE//NONSGML Subtype Appointment//EN",
	"-//XAPIA/CSA/SUBTYPE//NONSGML Subtype Class//EN",
	"-//XAPIA/CSA/SUBTYPE//NONSGML Subtype Holiday//EN",
	"-//XAPIA/CSA/SUBTYPE//NONSGML Subtype Meeting//EN",
	"-//XAPIA/CSA/SUBTYPE//NONSGML Subtype Miscellaneous//EN",
	"-//XAPIA/CSA/SUBTYPE//NONSGML Subtype Phone Call//EN",
	"-//XAPIA/CSA/SUBTYPE//NONSGML Subtype Sick Day//EN",
	"-//XAPIA/CSA/SUBTYPE//NONSGML Subtype Special Occasion//EN",
	"-//XAPIA/CSA/SUBTYPE//NONSGML Subtype Travel//EN",
	"-//XAPIA/CSA/SUBTYPE//NONSGML Subtype Vacation//EN",
};

/* list of calendar attributes and value type */
_DtCmAttrInfo _CSA_cal_attr_info[] =
{
	/* first element is not used */
	{ 0, -1, 0, _DtCm_old_attr_unknown, B_TRUE, B_TRUE },
	{ CSA_CAL_ATTR_ACCESS_LIST_I, CSA_VALUE_ACCESS_LIST,	1,
		_DtCm_old_attr_unknown, B_FALSE, B_FALSE },
	{ CSA_CAL_ATTR_CALENDAR_NAME_I, CSA_VALUE_STRING,	1,
		_DtCm_old_attr_unknown, B_TRUE, B_TRUE },
	{ CSA_CAL_ATTR_CALENDAR_OWNER_I, CSA_VALUE_CALENDAR_USER,	1,
		_DtCm_old_attr_unknown, B_TRUE, B_TRUE },
	{ CSA_CAL_ATTR_CALENDAR_SIZE_I,	CSA_VALUE_UINT32,	4,
		_DtCm_old_attr_unknown, B_TRUE, B_TRUE },
	{ CSA_CAL_ATTR_CHARACTER_SET_I,	CSA_VALUE_STRING,	4,
		_DtCm_old_attr_unknown, B_TRUE, B_TRUE },
	{ CSA_CAL_ATTR_COUNTRY_I,	CSA_VALUE_STRING,	0,
		_DtCm_old_attr_unknown, B_FALSE, B_FALSE },
	{ CSA_CAL_ATTR_DATE_CREATED_I,	CSA_VALUE_DATE_TIME,	4,
		_DtCm_old_attr_unknown, B_TRUE, B_TRUE },
	{ CSA_CAL_ATTR_LANGUAGE_I,	CSA_VALUE_STRING,	0,
		_DtCm_old_attr_unknown, B_FALSE, B_FALSE },
	{ CSA_CAL_ATTR_NUMBER_ENTRIES_I, CSA_VALUE_UINT32,	1,
		_DtCm_old_attr_unknown, B_TRUE, B_TRUE },
	{ CSA_CAL_ATTR_PRODUCT_IDENTIFIER_I, CSA_VALUE_STRING,	1,
		_DtCm_old_attr_unknown, B_TRUE, B_TRUE },
	{ CSA_CAL_ATTR_TIME_ZONE_I,	CSA_VALUE_STRING,	4,
		_DtCm_old_attr_unknown, B_TRUE, B_TRUE },
	{ CSA_CAL_ATTR_VERSION_I,	CSA_VALUE_STRING,	1,
		_DtCm_old_attr_unknown, B_TRUE, B_TRUE },
	{ CSA_CAL_ATTR_WORK_SCHEDULE_I,	CSA_VALUE_OPAQUE_DATA,	0,
		_DtCm_old_attr_unknown, B_FALSE, B_FALSE },
	{ CSA_X_DT_CAL_ATTR_SERVER_VERSION_I, CSA_VALUE_UINT32,	1,
		_DtCm_old_attr_unknown, B_TRUE, B_TRUE },
	{ CSA_X_DT_CAL_ATTR_DATA_VERSION_I, CSA_VALUE_UINT32,	1,
		_DtCm_old_attr_unknown, B_TRUE, B_TRUE },
	{ CSA_X_DT_CAL_ATTR_CAL_DELIMITER_I, CSA_VALUE_STRING,	-1,
		_DtCm_old_attr_unknown, B_TRUE, B_TRUE }
};

/* list of entry attributes and value type */
_DtCmAttrInfo _CSA_entry_attr_info[] =
{
	/* first element is not used */
	{ 0, -1, 0, _DtCm_old_attr_unknown, B_TRUE, B_TRUE },
	{ CSA_ENTRY_ATTR_ATTENDEE_LIST_I,	CSA_VALUE_ATTENDEE_LIST,
	  0,	_DtCm_old_attr_unknown,		B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_AUDIO_REMINDER_I,	CSA_VALUE_REMINDER,
	  1,	_DtCm_old_attr_beep_reminder,	B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_CLASSIFICATION_I,	CSA_VALUE_UINT32,
	  2,	_DtCm_old_attr_privacy,		B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_DATE_COMPLETED_I,	CSA_VALUE_DATE_TIME,
	  4,	_DtCm_old_attr_unknown,		B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_DATE_CREATED_I,	CSA_VALUE_DATE_TIME,
	  4,	_DtCm_old_attr_unknown,		B_TRUE, B_TRUE },
	{ CSA_ENTRY_ATTR_DESCRIPTION_I,		CSA_VALUE_STRING,
	  4,	_DtCm_old_attr_unknown,		B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_DUE_DATE_I,		CSA_VALUE_DATE_TIME,
	  4,	_DtCm_old_attr_unknown,		B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_END_DATE_I,		CSA_VALUE_DATE_TIME,
	  1,	_DtCm_old_attr_duration,	B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_EXCEPTION_DATES_I,	CSA_VALUE_DATE_TIME_LIST,
	  4,	_DtCm_old_attr_unknown,		B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_EXCEPTION_RULE_I,	CSA_VALUE_STRING,
	  0,	_DtCm_old_attr_unknown,		B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_FLASHING_REMINDER_I,	CSA_VALUE_REMINDER,
	  1,	_DtCm_old_attr_flash_reminder,	B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_LAST_UPDATE_I,		CSA_VALUE_DATE_TIME,
	  4,	_DtCm_old_attr_unknown,		B_TRUE, B_TRUE },
	{ CSA_ENTRY_ATTR_MAIL_REMINDER_I,	CSA_VALUE_REMINDER,
	  1,	_DtCm_old_attr_mail_reminder,	B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_NUMBER_RECURRENCES_I,	CSA_VALUE_UINT32,
	  4,	_DtCm_old_attr_unknown,		B_TRUE, B_TRUE },
	{ CSA_ENTRY_ATTR_ORGANIZER_I,		CSA_VALUE_CALENDAR_USER,
	  1,	_DtCm_old_attr_author,		B_TRUE, B_TRUE },
	{ CSA_ENTRY_ATTR_POPUP_REMINDER_I,	CSA_VALUE_REMINDER,
	  1,	_DtCm_old_attr_popup_reminder,	B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_PRIORITY_I,		CSA_VALUE_UINT32,
	  4,	_DtCm_old_attr_unknown,		B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_RECURRENCE_RULE_I,	CSA_VALUE_STRING,
	  4,	_DtCm_old_attr_unknown,		B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_RECURRING_DATES_I,	CSA_VALUE_DATE_TIME_LIST,
	  0,	_DtCm_old_attr_unknown,		B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_REFERENCE_IDENTIFIER_I, CSA_VALUE_OPAQUE_DATA,	
	  1,	_DtCm_old_attr_id,		B_TRUE, B_TRUE },
	{ CSA_ENTRY_ATTR_SEQUENCE_NUMBER_I,	CSA_VALUE_UINT32,
	  0,	_DtCm_old_attr_unknown,		B_TRUE, B_TRUE },
	{ CSA_ENTRY_ATTR_SPONSOR_I,		CSA_VALUE_CALENDAR_USER,
	  4,	_DtCm_old_attr_unknown,		B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_START_DATE_I,		CSA_VALUE_DATE_TIME,
	  1,	_DtCm_old_attr_time,		B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_STATUS_I,		CSA_VALUE_UINT32,
	  2,	_DtCm_old_attr_status,		B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_SUBTYPE_I,		CSA_VALUE_STRING,
	  1,	_DtCm_old_attr_type2,		B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_SUMMARY_I,		CSA_VALUE_STRING,
	  1,	_DtCm_old_attr_what,		B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_TIME_TRANSPARENCY_I,	CSA_VALUE_SINT32,
	  4,	_DtCm_old_attr_unknown,		B_FALSE, B_FALSE },
	{ CSA_ENTRY_ATTR_TYPE_I,		CSA_VALUE_UINT32,
	  1,	_DtCm_old_attr_type,		B_FALSE, B_FALSE },
	{ CSA_X_DT_ENTRY_ATTR_SHOWTIME_I,	CSA_VALUE_SINT32,
	  2,	_DtCm_old_attr_showtime,	B_FALSE, B_FALSE },
	{ CSA_X_DT_ENTRY_ATTR_REPEAT_TYPE_I,	CSA_VALUE_SINT32,
	  1,	_DtCm_old_attr_repeat_type,	B_FALSE, B_TRUE },
	{ CSA_X_DT_ENTRY_ATTR_REPEAT_TIMES_I,	CSA_VALUE_UINT32,
	  1,	_DtCm_old_attr_repeat_times,	B_FALSE, B_TRUE },
	{ CSA_X_DT_ENTRY_ATTR_REPEAT_INTERVAL_I, CSA_VALUE_UINT32,
	  3,	_DtCm_old_attr_repeat_nth_interval, B_FALSE, B_TRUE },
	{ CSA_X_DT_ENTRY_ATTR_REPEAT_OCCURRENCE_NUM_I, CSA_VALUE_SINT32,
	  3,	_DtCm_old_attr_repeat_nth_weeknum, B_FALSE, B_TRUE },
	{ CSA_X_DT_ENTRY_ATTR_SEQUENCE_END_DATE_I, CSA_VALUE_DATE_TIME,
	  3,	_DtCm_old_attr_end_date,	B_FALSE, B_TRUE },
	{ CSA_X_DT_ENTRY_ATTR_ENTRY_DELIMITER_I, CSA_VALUE_STRING,
	  -1,	_DtCm_old_attr_unknown,		B_TRUE, B_TRUE }
};

/*****************************************************************************
 * forward declaration of static functions used within the file
 *****************************************************************************/
static CSA_return_code check_predefined_attrs(
	int			fversion,
	uint			num_attrs,
	cms_attribute		*attrs,
	boolean_t		checkreadonly,
	_DtCmNameTable		*tbl,
	uint			num_defined,
	_DtCmAttrInfo		*our_attrs);

static CSA_return_code convert_cms_user_to_csa_user(char *from,
	CSA_calendar_user **to);

static CSA_return_code hash_entry_attrs(uint num_attrs, CSA_attribute *csaattrs,
	cms_attribute *cmsattrs, uint *hnum, cms_attribute **hattrs, uint *num);

static CSA_return_code hash_cal_attrs(uint num_attrs, CSA_attribute *csaattrs,
	cms_attribute *cmsattrs, uint *hnum, cms_attribute **hattrs, uint *num);

static CSA_return_code _DtCm_check_hashed_entry_attributes(
	int		fvers,
	uint		num_attrs,
	cms_attribute	*attrs,
	CSA_flags	utype);

static CSA_return_code _DtCm_check_hashed_cal_attributes(
	int		fvers,
	uint		num_attrs,
	cms_attribute	*attrs,
	char		*owner,
	char		*cname,
	boolean_t	checkreadonly,
	boolean_t	firsttime,
	boolean_t	csatype);

static CSA_return_code _CheckNameAtHost(char *owner, char *value);

static CSA_return_code _CheckCalendarOwner(char *owner, int type, char *name);

static CSA_return_code _CheckCalendarName(char *owner, char *cname,
					cms_attribute_value *val);

/*****************************************************************************
 * extern functions used in the library
 *****************************************************************************/

/*
 * For each calendar attribute, if it is a predefined attribute,
 * check that the data type is correct.
 * If checkreadonly is B_TRUE, also check that it's not readonly.
 */
extern CSA_return_code
_DtCm_check_cal_csa_attributes(
	int		fvers,
	uint		num_attrs,
	CSA_attribute	*attrs,
	char		*cname,
	boolean_t	checkreadonly,
	boolean_t	firsttime,
	boolean_t	checkattrnum)
{
	CSA_return_code stat;
	uint		hnum;
	cms_attribute	*hattrs;
	uint		realnum;

	if ((stat = hash_cal_attrs(num_attrs, attrs, NULL, &hnum, &hattrs,
	    &realnum)) != CSA_SUCCESS)
		return (stat);

	if (checkattrnum == B_TRUE && realnum == 0) {
		free(hattrs);
		return (CSA_E_INVALID_PARAMETER);
	}

	stat = _DtCm_check_hashed_cal_attributes(fvers, hnum, hattrs,
		NULL, cname, checkreadonly, firsttime, B_TRUE);

	free(hattrs);

	return (stat);
}

extern CSA_return_code
_DtCm_check_cal_cms_attributes(
	int		fvers,
	uint		num_attrs,
	cms_attribute	*attrs,
	char		*owner,
	char		*cname,
	boolean_t	checkreadonly,
	boolean_t	firsttime,
	boolean_t	checkattrnum)
{
	CSA_return_code stat;
	uint		hnum;
	cms_attribute	*hattrs;
	uint		realnum;

	if ((stat = hash_cal_attrs(num_attrs, NULL, attrs, &hnum, &hattrs,
	    &realnum)) != CSA_SUCCESS)
		return (stat);

	if (checkattrnum == B_TRUE && realnum == 0) {
		free(hattrs);
		return (CSA_E_INVALID_PARAMETER);
	}

	stat = _DtCm_check_hashed_cal_attributes(fvers, hnum, hattrs,
		owner, cname, checkreadonly, firsttime, B_FALSE);

	free(hattrs);

	return (stat);
}

extern CSA_return_code
_DtCm_check_entry_attributes(
	int		fvers,
	uint		num_attrs,
	CSA_attribute	*attrs,
	CSA_flags	utype,
	boolean_t	checkattrnum)
{
	CSA_return_code	stat;
	uint		hnum;
	cms_attribute	*hattrs;
	uint		realnum;

	if ((stat = hash_entry_attrs(num_attrs, attrs, NULL, &hnum, &hattrs,
	    &realnum)) != CSA_SUCCESS)
		return (stat);

	if (checkattrnum == B_TRUE && realnum == 0) {
		free(hattrs);
		return (CSA_E_INVALID_PARAMETER);
	}

	stat = _DtCm_check_hashed_entry_attributes(fvers, hnum, hattrs,
		utype);

	free(hattrs);

	return (stat);
}

extern CSA_return_code
_DtCm_check_entry_cms_attributes(
	int		fvers,
	uint		num_attrs,
	cms_attribute	*attrs,
	CSA_flags	utype,
	boolean_t	checkattrnum)
{
	CSA_return_code	stat;
	uint		hnum;
	cms_attribute	*hattrs;
	uint		realnum;

	if ((stat = hash_entry_attrs(num_attrs, NULL, attrs, &hnum, &hattrs,
	    &realnum)) != CSA_SUCCESS)
		return (stat);

	if (checkattrnum == B_TRUE && realnum == 0) {
		free(hattrs);
		return (CSA_E_INVALID_PARAMETER);
	}

	stat = _DtCm_check_hashed_entry_attributes(fvers, hnum, hattrs,
		utype);

	free(hattrs);

	return (stat);
}

/*
 * copy attributes
 * attributes with a name but NULL value is allowed
 * attributes with null names are ignored
 * validity of attributes should be checked before calling this routine
 *
 * Note: the first entry is not used
 */
extern CSA_return_code
_DtCm_copy_cms_attributes(
	uint srcsize,
	cms_attribute *srcattrs,
	uint *dstsize,
	cms_attribute **dstattrs)
{
	int	i, j;
	CSA_return_code stat = CSA_SUCCESS;
	cms_attribute	*attrs;

	if (dstsize == NULL || dstattrs == NULL)
		return (CSA_E_INVALID_PARAMETER);

	*dstsize = 0;
	*dstattrs = NULL;

	if (srcsize == 0)
		return (CSA_SUCCESS);

	if ((attrs = calloc(1, sizeof(cms_attribute) * (srcsize + 1))) == NULL)
		return (CSA_E_INSUFFICIENT_MEMORY);

	/* firstr element is not used */
	for (i = 1, j = 1; i <= srcsize; i++) {
		if (srcattrs[i].name.name != NULL) {
			if ((stat = _DtCm_copy_cms_attribute(&attrs[j],
			    &srcattrs[i], B_TRUE)) != CSA_SUCCESS)
				break;
			else
				j++;
		}
	}

	if (stat != CSA_SUCCESS && j > 1) {
		_DtCm_free_cms_attributes(j, attrs);
		free(attrs);
	} else {
		*dstsize = j - 1;
		*dstattrs = attrs;
	}

	return(stat);
}

/*
 * Frees the name and value field of the array, but not
 * array itself.
 * note: element 0 is not used
 */
extern void
_DtCm_free_cms_attributes(uint size, cms_attribute *attrs)
{
	int i;

	for (i = 0; i < size; i++) {
		if (attrs[i].name.name) {
			free(attrs[i].name.name);
			attrs[i].name.name = NULL;

			if (attrs[i].value) {
				_DtCm_free_cms_attribute_value(attrs[i].value);
				attrs[i].value = NULL;
			}
		}
	}
}

/*
 * Frees the name and value field of the array, but not
 * array itself.
 */
extern void
_DtCm_free_attributes(uint size, CSA_attribute * attrs)
{
	int i;

	for (i = 0; i < size; i++) {
		if (attrs[i].name) {
			free(attrs[i].name);
			attrs[i].name = NULL;

			if (attrs[i].value) {
				_DtCm_free_attribute_value(attrs[i].value);
				attrs[i].value = NULL;
			}
		}
	}
}

/*
 * Free the value part of the cms_attribute structure.
 * note: element 0 is not used
 */
extern void
_DtCm_free_cms_attribute_values(uint size, cms_attribute *attrs)
{
	int	i;

	for (i = 1; i <= size; i++) {
		if (attrs[i].value) {
			_DtCm_free_cms_attribute_value(attrs[i].value);
			attrs[i].value = NULL;
		}
	}
}

/*
 * Free the value part of the the attribute structure.
 */
extern void
_DtCm_free_attribute_values(uint size, CSA_attribute * attrs)
{
	int	i;

	for (i = 0; i < size; i++) {
		if (attrs[i].value) {
			_DtCm_free_attribute_value(attrs[i].value);
			attrs[i].value = NULL;
		}
	}
}

extern char *
_DtCm_old_reminder_name_to_name(char *oldname)
{
	if (strcmp(oldname, _DtCM_OLD_ATTR_BEEP_REMINDER) == 0)
		return (CSA_ENTRY_ATTR_AUDIO_REMINDER);
	else if (strcmp(oldname, _DtCM_OLD_ATTR_FLASH_REMINDER) == 0)
		return (CSA_ENTRY_ATTR_FLASHING_REMINDER);
	else if (strcmp(oldname, _DtCM_OLD_ATTR_MAIL_REMINDER) == 0)
		return (CSA_ENTRY_ATTR_MAIL_REMINDER);
	else if (strcmp(oldname, _DtCM_OLD_ATTR_POPUP_REMINDER) == 0)
		return (CSA_ENTRY_ATTR_POPUP_REMINDER);
	else
		return (oldname);
}

extern int
_DtCm_old_reminder_name_to_index(char *oldname)
{
	char	*name;

	name = _DtCm_old_reminder_name_to_name(oldname);

	return (_DtCm_get_index_from_table(_DtCm_entry_name_tbl, name));
}

/*
 * Given an attribute name, return the corresponding
 * attribute number that's supported by old backends (v4 and before).
 */
extern CSA_return_code
_DtCm_get_old_attr_by_name(char *name, _DtCm_old_attrs *attr)
{
	int	index;

	index = _DtCm_get_index_from_table(_DtCm_entry_name_tbl, name);
	if (index > 0 && index <= _DtCM_DEFINED_ENTRY_ATTR_SIZE) {

		if (_CSA_entry_attr_info[index].oldattr
		    != _DtCm_old_attr_unknown) {
			*attr = _CSA_entry_attr_info[index].oldattr;
			return (CSA_SUCCESS);
		} else
			return (CSA_E_UNSUPPORTED_ATTRIBUTE);
	} else
		return (CSA_E_INVALID_ATTRIBUTE);
}

/*
 * Given an attribute index, return the corresponding
 * attribute number that's supported by old backends (v4 and before).
 */
extern CSA_return_code
_DtCm_get_old_attr_by_index(int index, _DtCm_old_attrs *attr)
{
	if (index <= _DtCM_DEFINED_ENTRY_ATTR_SIZE) {
		if (_CSA_entry_attr_info[index].oldattr
		    != _DtCm_old_attr_unknown) {
			*attr = _CSA_entry_attr_info[index].oldattr;
			return (CSA_SUCCESS);
		} else
			return (CSA_E_UNSUPPORTED_ATTRIBUTE);
	} else
		return (CSA_E_INVALID_ATTRIBUTE);
}

/*
 * copy attribute
 * the attribute structure should contain valid value
 * a NULL attribute value is valid
 */
extern CSA_return_code
_DtCm_copy_cms_attribute(
	cms_attribute *to,
	cms_attribute *from,
	boolean_t copyname)
{
	CSA_return_code	stat = CSA_SUCCESS;
	char		*name;

	if (to == NULL)
		return (CSA_E_INVALID_PARAMETER);

	/* copy the attribute name */
	if (copyname) {
		if ((name = strdup(from->name.name)) == NULL)
			return(CSA_E_INSUFFICIENT_MEMORY);
	}

	if ((stat = _DtCm_copy_cms_attr_val(from->value, &to->value))
	    == CSA_SUCCESS) {
		if (copyname) {
			to->name.name = name;
			to->name.num = from->name.num;
		}
	} else if (copyname)
		free (name);

	return(stat);
}

extern CSA_return_code
_DtCm_copy_cms_attr_val(cms_attribute_value *from, cms_attribute_value **to)
{
	CSA_return_code	stat = CSA_SUCCESS;
	cms_attribute_value	*val;

	if (to == NULL)
		return (CSA_E_INVALID_PARAMETER);

	/* copy the attribute value */
	if (from == NULL)
		val = NULL;
	else {
		if ((val = (cms_attribute_value *)calloc(1,
		    sizeof(cms_attribute_value))) == NULL)
			return (CSA_E_INSUFFICIENT_MEMORY);

		switch (from->type) {
		case CSA_VALUE_BOOLEAN:
		case CSA_VALUE_ENUMERATED:
		case CSA_VALUE_FLAGS:
		case CSA_VALUE_UINT32:
		case CSA_VALUE_SINT32:
			val->item.uint32_value = from->item.uint32_value;
			break;

		case CSA_VALUE_STRING:
		case CSA_VALUE_DATE_TIME:
		case CSA_VALUE_DATE_TIME_RANGE:
		case CSA_VALUE_TIME_DURATION:
		case CSA_VALUE_CALENDAR_USER:
			if (from->item.string_value)
				val->item.string_value =
					strdup(from->item.string_value);
			else
				val->item.string_value = calloc(1, 1);
			if (val->item.string_value == NULL)
				stat = CSA_E_INSUFFICIENT_MEMORY;
			break;

		case CSA_VALUE_REMINDER:
			if (from->item.reminder_value == NULL)
				stat = CSA_E_INVALID_ATTRIBUTE_VALUE;
			else
				stat = _DtCm_copy_reminder(
					from->item.reminder_value,
					&val->item.reminder_value);
			break;
		case CSA_VALUE_ATTENDEE_LIST:
			stat = CSA_E_INVALID_ATTRIBUTE_VALUE;
			break;
		case CSA_VALUE_ACCESS_LIST:
			if (from->item.access_list_value &&
			    (val->item.access_list_value =
			    _DtCm_copy_cms_access_list(
			    from->item.access_list_value)) == NULL) {

				stat = CSA_E_INSUFFICIENT_MEMORY;
			}
			break;
		case CSA_VALUE_DATE_TIME_LIST:
			if (from->item.date_time_list_value &&
			    (val->item.date_time_list_value =
			    _DtCm_copy_date_time_list(
		    	    from->item.date_time_list_value)) == NULL) {

				stat = CSA_E_INSUFFICIENT_MEMORY;
			}
			break;
		case CSA_VALUE_OPAQUE_DATA:
			if (from->item.opaque_data_value) {
				stat = _DtCm_copy_opaque_data(
					from->item.opaque_data_value,
					&val->item.opaque_data_value);
			}
			break;
		default:
			stat = CSA_E_INVALID_ATTRIBUTE_VALUE;
			break;
		}

		if (stat != CSA_SUCCESS)
			free(val);
		else
			val->type = from->type;
	}

	if (stat == CSA_SUCCESS) {
		*to = val;
	}

	return(stat);
}

/*
 * copy the attribute name, and convert the attribute value
 */
extern CSA_return_code
_DtCm_cms2csa_attribute(cms_attribute from, CSA_attribute *to)
{
	CSA_return_code		stat;
	char			*name;
	CSA_attribute_value	*val;

	if ((name = strdup(from.name.name)) == NULL)
		return (CSA_E_INSUFFICIENT_MEMORY);

	if ((stat = _DtCm_cms2csa_attrval(from.value, &val)) == CSA_SUCCESS) {
		to->name = name;
		to->value = val;
	} else
		free(name);

	return (stat);
}

extern CSA_return_code
_DtCm_cms2csa_attrval(cms_attribute_value *from, CSA_attribute_value **to)
{
	CSA_return_code	stat = CSA_SUCCESS;
	CSA_attribute_value	*val;

	if (to == NULL)
		return (CSA_E_INVALID_PARAMETER);

	/* copy the attribute value */
	if (from == NULL)
		val = NULL;
	else {
		if ((val = (CSA_attribute_value *)calloc(1,
		    sizeof(CSA_attribute_value))) == NULL)
			return (CSA_E_INSUFFICIENT_MEMORY);

		switch (from->type) {
		case CSA_VALUE_BOOLEAN:
		case CSA_VALUE_ENUMERATED:
		case CSA_VALUE_FLAGS:
		case CSA_VALUE_UINT32:
		case CSA_VALUE_SINT32:
			val->item.uint32_value = from->item.uint32_value;
			break;

		case CSA_VALUE_STRING:
		case CSA_VALUE_DATE_TIME:
		case CSA_VALUE_DATE_TIME_RANGE:
		case CSA_VALUE_TIME_DURATION:
			if (from->item.string_value)
				val->item.string_value =
					strdup(from->item.string_value);
			else
				val->item.string_value = calloc(1, 1);
			if (val->item.string_value == NULL)
				stat = CSA_E_INSUFFICIENT_MEMORY;
			break;

		case CSA_VALUE_REMINDER:
			if (from->item.reminder_value == NULL)
				stat = CSA_E_INVALID_ATTRIBUTE_VALUE;
			else
				stat = _DtCm_copy_reminder(
					from->item.reminder_value,
					&val->item.reminder_value);
			break;
		case CSA_VALUE_CALENDAR_USER:
			if (from->item.calendar_user_value == NULL)
				stat = CSA_E_INVALID_ATTRIBUTE_VALUE;
			else
				stat = convert_cms_user_to_csa_user(
					from->item.calendar_user_value,
					&val->item.calendar_user_value);
			break;
		case CSA_VALUE_ACCESS_LIST:
			stat = _DtCm_cms2csa_access_list(
				from->item.access_list_value,
				&val->item.access_list_value);
			break;
		case CSA_VALUE_ATTENDEE_LIST:
			stat = CSA_E_INVALID_ATTRIBUTE_VALUE;
			break;
		case CSA_VALUE_DATE_TIME_LIST:
			if (from->item.date_time_list_value &&
			    (val->item.date_time_list_value =
			    _DtCm_copy_date_time_list(
			    from->item.date_time_list_value)) == NULL) {
				stat = CSA_E_INSUFFICIENT_MEMORY;
			}
			break;
		case CSA_VALUE_OPAQUE_DATA:
			if (from->item.opaque_data_value) {
				stat = _DtCm_copy_opaque_data(
					from->item.opaque_data_value,
					&val->item.opaque_data_value);
			} else
				val->item.opaque_data_value = NULL;
			break;
		default:
			stat = CSA_E_INVALID_ATTRIBUTE_VALUE;
			break;
		}

		if (stat != CSA_SUCCESS)
			free(val);
		else
			val->type = from->type;
	}

	if (stat == CSA_SUCCESS) {
		*to = val;
	}

	return(stat);
}

extern void
_DtCm_free_cms_attribute_value(cms_attribute_value *val)
{
	if (val == NULL)
		return;

	switch (val->type) {
	case CSA_VALUE_STRING:
	case CSA_VALUE_DATE_TIME:
	case CSA_VALUE_DATE_TIME_RANGE:
	case CSA_VALUE_TIME_DURATION:
	case CSA_VALUE_CALENDAR_USER:
		if (val->item.string_value)
			free(val->item.string_value);
		break;

	case CSA_VALUE_REMINDER:
		if (val->item.reminder_value)
			_DtCm_free_reminder(val->item.reminder_value);
		break;
	case CSA_VALUE_ACCESS_LIST:
		if (val->item.access_list_value)
			_DtCm_free_cms_access_entry(val->item.access_list_value);
		break;
	case CSA_VALUE_DATE_TIME_LIST:
		if (val->item.date_time_list_value)
			_DtCm_free_date_time_list(
				val->item.date_time_list_value);
		break;
	case CSA_VALUE_OPAQUE_DATA:
		if (val->item.opaque_data_value) {
			_DtCm_free_opaque_data(val->item.opaque_data_value);
		}
		break;
	}
	free(val);
}

extern void
_DtCm_free_attribute_value(CSA_attribute_value *val)
{
	if (val == NULL)
		return;

	switch (val->type) {
	case CSA_VALUE_STRING:
	case CSA_VALUE_DATE_TIME:
	case CSA_VALUE_DATE_TIME_RANGE:
	case CSA_VALUE_TIME_DURATION:
		if (val->item.string_value)
			free(val->item.string_value);
		break;

	case CSA_VALUE_REMINDER:
		if (val->item.reminder_value)
			_DtCm_free_reminder(val->item.reminder_value);
		break;
	case CSA_VALUE_ACCESS_LIST:
		if (val->item.access_list_value)
			_DtCm_free_csa_access_list(val->item.access_list_value);
		break;
	case CSA_VALUE_CALENDAR_USER:
		if (val->item.calendar_user_value) {
			if (val->item.calendar_user_value->user_name)
				free(val->item.calendar_user_value->user_name);
			if (val->item.calendar_user_value->calendar_address)
				free(val->item.calendar_user_value->user_name);
			free(val->item.calendar_user_value);
		}
		break;
	case CSA_VALUE_DATE_TIME_LIST:
		if (val->item.date_time_list_value)
			_DtCm_free_date_time_list(
				val->item.date_time_list_value);
		break;
	case CSA_VALUE_OPAQUE_DATA:
		if (val->item.opaque_data_value) {
			_DtCm_free_opaque_data(val->item.opaque_data_value);
		}
		break;
	}
	free(val);
}

extern CSA_return_code
_DtCm_set_uint32_attrval(uint numval, cms_attribute_value **attrval)
{
	cms_attribute_value	*val;

	if ((val = (cms_attribute_value *)malloc(sizeof(cms_attribute_value)))
	    == NULL) {
		return (CSA_E_INSUFFICIENT_MEMORY);
	}

	val->type = CSA_VALUE_UINT32;
	val->item.uint32_value = numval;

	*attrval = val;

	return (CSA_SUCCESS);
}

extern CSA_return_code
_DtCm_set_sint32_attrval(int numval, cms_attribute_value **attrval)
{
	cms_attribute_value	*val;

	if ((val = (cms_attribute_value *)malloc(sizeof(cms_attribute_value)))
	    == NULL) {
		return (CSA_E_INSUFFICIENT_MEMORY);
	}

	val->type = CSA_VALUE_SINT32;
	val->item.sint32_value = numval;

	*attrval = val;

	return (CSA_SUCCESS);
}

extern CSA_return_code
_DtCm_set_string_attrval(
	char *strval,
	cms_attribute_value **attrval,
	CSA_enum type)
{
	cms_attribute_value	*val;

	if (type != CSA_VALUE_STRING && type != CSA_VALUE_DATE_TIME &&
	    type != CSA_VALUE_DATE_TIME_RANGE &&
	    type != CSA_VALUE_TIME_DURATION && type != CSA_VALUE_CALENDAR_USER)
		return (CSA_E_INVALID_PARAMETER);

	if ((val = (cms_attribute_value *)malloc(sizeof(cms_attribute_value)))
	    == NULL) {
		return (CSA_E_INSUFFICIENT_MEMORY);
	}

	val->type = type;

	if (strval == NULL) {
		val->item.string_value = NULL;
	} else if ((val->item.string_value = strdup(strval)) == NULL) {
		free(val);
		return (CSA_E_INSUFFICIENT_MEMORY);
	}

	*attrval = val;

	return (CSA_SUCCESS);
}

extern CSA_return_code
_DtCm_set_user_attrval(
	char *user,
	cms_attribute_value **attrval)
{
	cms_attribute_value	*val;

	if (user == NULL) {
		*attrval = NULL;
		return (CSA_SUCCESS);
	}

	if ((val = (cms_attribute_value *)malloc(sizeof(cms_attribute_value)))
	    == NULL) {
		return (CSA_E_INSUFFICIENT_MEMORY);
	}

	val->type = CSA_VALUE_CALENDAR_USER;

	if ((val->item.calendar_user_value = strdup(user)) == NULL) {
		free(val);
		return (CSA_E_INSUFFICIENT_MEMORY);
	}

	*attrval = val;

	return (CSA_SUCCESS);
}

extern CSA_return_code
_DtCm_set_reminder_attrval(CSA_reminder *remval, cms_attribute_value **attrval)
{
	cms_attribute_value *val;
	CSA_return_code stat;

	if (remval == NULL)
		return (CSA_E_INVALID_ATTRIBUTE_VALUE);

	if ((val = (cms_attribute_value *)malloc(sizeof(cms_attribute_value)))
	    == NULL) {
		return (CSA_E_INSUFFICIENT_MEMORY);
	}

	val->type = CSA_VALUE_REMINDER;

	if ((stat = _DtCm_copy_reminder(remval, &val->item.reminder_value))
	    != CSA_SUCCESS) {
		free(val);
		return (stat);
	} else {

		*attrval = val;

		return (CSA_SUCCESS);
	}
}

extern CSA_return_code
_DtCm_set_csa_access_attrval(
	cms_access_entry *aval,
	CSA_attribute_value **attrval)
{
	CSA_attribute_value *val;
	CSA_return_code stat = CSA_SUCCESS;

	if ((val = (CSA_attribute_value *)malloc(sizeof(CSA_attribute_value)))
	    == NULL) {
		return (CSA_E_INSUFFICIENT_MEMORY);
	}

	val->type = CSA_VALUE_ACCESS_LIST;

	if (aval == NULL) {

		val->item.access_list_value = NULL;

	} else {
	
		stat = _DtCm_cms2csa_access_list(aval,
			&val->item.access_list_value);

	}

	if (stat == CSA_SUCCESS)
		*attrval = val;
	else
		free(val);

	return (stat);
}

extern CSA_return_code
_DtCm_set_opaque_attrval(CSA_opaque_data *data, cms_attribute_value **attrval)
{
	CSA_return_code stat;
	cms_attribute_value	*val;

	if (data == NULL)
		return (CSA_E_INVALID_ATTRIBUTE_VALUE);

	if ((val = (cms_attribute_value *)malloc(sizeof(cms_attribute_value)))
	    == NULL) {
		return (CSA_E_INSUFFICIENT_MEMORY);
	}

	val->type = CSA_VALUE_OPAQUE_DATA;

	if ((stat = _DtCm_copy_opaque_data(data, &val->item.opaque_data_value))
	    != CSA_SUCCESS) {
		free(val);
		return (stat);
	} else {

		*attrval = val;
		return (CSA_SUCCESS);
	}
}

extern CSA_return_code
_DtCm_set_csa_uint32_attrval(uint numval, CSA_attribute_value **attrval)
{
	CSA_attribute_value	*val;

	if ((val = (CSA_attribute_value *)malloc(sizeof(CSA_attribute_value)))
	    == NULL) {
		return (CSA_E_INSUFFICIENT_MEMORY);
	}

	val->type = CSA_VALUE_UINT32;
	val->item.uint32_value = numval;

	*attrval = val;

	return (CSA_SUCCESS);
}

extern CSA_return_code
_DtCm_set_csa_string_attrval(
	char *strval,
	CSA_attribute_value **attrval,
	CSA_enum type)
{
	CSA_attribute_value	*val;

	if (type != CSA_VALUE_STRING && type != CSA_VALUE_DATE_TIME &&
	    type != CSA_VALUE_DATE_TIME_RANGE &&
	    type != CSA_VALUE_TIME_DURATION && type != CSA_VALUE_CALENDAR_USER)
		return (CSA_E_INVALID_PARAMETER);

	if ((val = (CSA_attribute_value *)malloc(sizeof(CSA_attribute_value)))
	    == NULL) {
		return (CSA_E_INSUFFICIENT_MEMORY);
	}

	val->type = type;

	if (strval == NULL) {
		val->item.string_value = NULL;
	} else if ((val->item.string_value = strdup(strval)) == NULL) {
		free(val);
		return (CSA_E_INSUFFICIENT_MEMORY);
	}

	*attrval = val;

	return (CSA_SUCCESS);
}

extern void
_DtCm_free_csa_access_list(CSA_access_list alist)
{
	CSA_access_list nptr;

	while (alist != NULL) {
		nptr = alist->next;

		if (alist->user) {
			if (alist->user->user_name) {
				free(alist->user->user_name);
			}
			if (alist->user->calendar_address) {
				free(alist->user->calendar_address);
			}
			free(alist->user);
		}

		free(alist);

		alist = nptr;
	}
}

extern void
_DtCm_free_date_time_list(CSA_date_time_list list)
{
	CSA_date_time_entry *nptr;

	while (list != NULL) {
		nptr = list->next;

		if (list->date_time) {
			free(list->date_time);
		}

		free(list);

		list = nptr;
	}
}

extern void
_DtCm_free_cms_access_entry(cms_access_entry *list)
{
	cms_access_entry *nptr;

	while (list != NULL) {
		nptr = list->next;

		if (list->user) {
			free(list->user);
		}

		free(list);

		list = nptr;
	}
}

extern cms_access_entry *
_DtCm_copy_cms_access_list(cms_access_entry *alist)
{
	cms_access_entry	*l, *head, *prev;
	boolean_t	cleanup = B_FALSE;

	prev = head = NULL;
	while (alist != NULL) {
		if ((l = (cms_access_entry *)calloc(1, sizeof(cms_access_entry)))
		    == NULL) {
			cleanup = B_TRUE;
			break;
		}

		if ((l->user = strdup(alist->user)) == NULL) {
			free(l);
			cleanup = B_TRUE;
			break;
		}

		l->rights = alist->rights;
		l->next = NULL;

		if (head == NULL)
			head = l;
		else
			prev->next = l;
		prev = l;

		alist = alist->next;
	}

	if (cleanup == B_TRUE) {
		_DtCm_free_cms_access_entry(head);
		head = NULL;
	}
	return(head);
}

extern CSA_return_code
_DtCm_cms2csa_access_list(
	cms_access_entry *cmslist,
	CSA_access_rights **csalist)
{
	CSA_return_code stat = CSA_SUCCESS;
	CSA_access_rights *to, *head, *prev;

	head = prev = NULL;
	while (cmslist != NULL) {
		if ((to = (CSA_access_rights *)calloc(1,
		    sizeof(CSA_access_rights))) == NULL) {
			stat = CSA_E_INSUFFICIENT_MEMORY;
			break;
		}

		if ((to->user = (CSA_calendar_user *)calloc(1,
		    sizeof(CSA_calendar_user))) == NULL) {
			free(to);
			stat = CSA_E_INSUFFICIENT_MEMORY;
			break;
		}

		if ((to->user->user_name = strdup(cmslist->user)) == NULL) {
			free(to->user);
			free(to);
			stat = CSA_E_INSUFFICIENT_MEMORY;
			break;
		}

		to->rights = cmslist->rights;
		to->next = NULL;

		if (head == NULL)
			head = to;
		else
			prev->next = to;

		prev = to;

		cmslist = cmslist->next;
	}

	if (stat != CSA_SUCCESS) {
		_DtCm_free_csa_access_list(head);
		head = NULL;
	}

	*csalist = head;
	return (stat);
}

extern CSA_return_code
_DtCm_csa2cms_access_list(
	CSA_access_rights *csalist,
	cms_access_entry **cmslist)
{
	CSA_return_code stat = CSA_SUCCESS;
	cms_access_entry *to, *head, *prev;

	head = prev = NULL;
	while (csalist != NULL) {
		if ((to = (cms_access_entry *)calloc(1,
		    sizeof(cms_access_entry))) == NULL) {
			stat = CSA_E_INSUFFICIENT_MEMORY;
			break;
		}

		if (csalist->user->user_name) {
			if ((to->user = strdup(csalist->user->user_name))
			    == NULL) {
				stat = CSA_E_INSUFFICIENT_MEMORY;
				free(to);
				break;
			}
		} else {
			stat = CSA_E_INVALID_ATTRIBUTE_VALUE;
			free(to);
			break;
		}

		to->rights = csalist->rights;
		to->next = NULL;

		if (head == NULL)
			head = to;
		else
			prev->next = to;

		prev = to;

		csalist = csalist->next;
	}

	if (stat != CSA_SUCCESS) {
		_DtCm_free_cms_access_entry(head);
		head = NULL;
	}

	*cmslist = head;
	return (stat);
}

extern CSA_date_time_list
_DtCm_copy_date_time_list(CSA_date_time_list dlist)
{
	CSA_date_time_entry	*l, *head, *prev;
	boolean_t	cleanup = B_FALSE;

	prev = head = NULL;
	while (dlist != NULL) {
		if ((l = (CSA_date_time_entry *)calloc(1,
		    sizeof(CSA_date_time_entry))) == NULL) {
			cleanup = B_TRUE;
			break;
		}

		if ((l->date_time = strdup(dlist->date_time)) == NULL) {
			free(l);
			cleanup = B_TRUE;
			break;
		}

		l->next = NULL;

		if (head == NULL)
			head = l;
		else
			prev->next = l;
		prev = l;

		dlist = dlist->next;
	}

	if (cleanup == B_TRUE) {
		_DtCm_free_date_time_list(head);
		head = NULL;
	}
	return(head);
}

extern CSA_return_code
_DtCm_copy_reminder(CSA_reminder *from, CSA_reminder **to)
{
	CSA_reminder *newval;

	if ((newval = (CSA_reminder *)calloc(1, sizeof(CSA_reminder))) == NULL)
		return (CSA_E_INSUFFICIENT_MEMORY);

	if (from->lead_time) {
		if ((newval->lead_time = strdup(from->lead_time)) == NULL) {
			free(newval);
			return (CSA_E_INSUFFICIENT_MEMORY);
		}
	} else {
		free(newval);
		return (CSA_E_INVALID_ATTRIBUTE_VALUE);
	}

	if (from->snooze_time)
		newval->snooze_time = strdup(from->snooze_time);
	else
		newval->snooze_time = calloc(1, 1);

	if (newval->snooze_time == NULL) {
		_DtCm_free_reminder(newval);
		return (CSA_E_INSUFFICIENT_MEMORY);
	}

	newval->repeat_count = from->repeat_count;

	if (from->reminder_data.size > 0) {
		newval->reminder_data.size = from->reminder_data.size;
		if ((newval->reminder_data.data = malloc(
		    newval->reminder_data.size)) == NULL) {
			_DtCm_free_reminder(newval);
			return (CSA_E_INSUFFICIENT_MEMORY);
		}
		memcpy(newval->reminder_data.data, from->reminder_data.data,
			from->reminder_data.size);
	}

	*to = newval;
	return (CSA_SUCCESS);
}

extern void
_DtCm_free_reminder(CSA_reminder *val)
{
	if (val == NULL) return;

	if (val->lead_time)
		free(val->lead_time);

	if (val->snooze_time)
		free(val->snooze_time);

	if (val->reminder_data.size > 0)
		free(val->reminder_data.data);

	free(val);
}

extern CSA_return_code
_DtCm_copy_opaque_data(CSA_opaque_data *from, CSA_opaque_data **to)
{
	CSA_opaque_data	*val;

	if ((val = (CSA_opaque_data *)calloc(1, sizeof(CSA_opaque_data)))
	    == NULL) {
		return (CSA_E_INSUFFICIENT_MEMORY);
	}

	if (from->size > 0) {
		val->size = from->size;
		if ((val->data = malloc(from->size)) == NULL) {
			free(val);
			return (CSA_E_INSUFFICIENT_MEMORY);
		}
		memcpy(val->data, from->data, from->size);
	} else {
		val->size = 0;
		val->data = NULL;
	}

	*to = val;

	return (CSA_SUCCESS);
}

extern void
_DtCm_free_opaque_data(CSA_opaque_data *val)
{
	if (val == NULL) return;

	if (val->data)
		free(val->data);
	free(val);
}

extern void
_DtCm_get_attribute_types(uint size, int *types)
{
	int	i;

	for (i = 1; i <= size; i++) {
		types[i] = _CSA_entry_attr_info[i].type;
	}
}

/******************************************************************************
 * static functions used within the file
 ******************************************************************************/

/*
 * The passed in attributes are hashed.
 * For each attribute, check
 * 1. type is valid and supported
 * 2. if it's a date time value type, check validity of date time.
 * 3. if it's a reminder value type, check validity of lead time.
 * 4. if it is a defined attribute, check that the data type is correct.
 * 5. if it is a defined attribute and checkreadonly is set, check
 *	that it's not readonly.
 */
static CSA_return_code
check_predefined_attrs(
	int			fver,
	uint			num_attrs,
	cms_attribute		*attrs,
	boolean_t		checkreadonly,
	_DtCmNameTable		*tbl,
	uint			num_defined,
	_DtCmAttrInfo		*our_attrs)
{
	int		i, index, cl;
	CSA_reminder	*rptr;
	time_t		tick;

	for (i = 0; i < num_attrs; i++) {

		if (attrs[i].name.name == NULL)
			continue;

		if (tbl == NULL)
			index = i;
		else
			index = _DtCm_get_index_from_table(tbl,
					attrs[i].name.name); 

		if (index > 0 && index <= num_defined) {

			/* check whether the attribute is supported
			 * in this version
			 */
			if (our_attrs[index].fst_vers == 0 ||
			    (fver < _DtCM_FIRST_EXTENSIBLE_DATA_VERSION &&
			    fver < our_attrs[index].fst_vers))
				return (CSA_E_UNSUPPORTED_ATTRIBUTE);
			else if (our_attrs[index].fst_vers == -1)
				return (CSA_E_INVALID_ATTRIBUTE);

			/* check whether the attribute is readonly */
			if (checkreadonly &&
			    ((fver < _DtCM_FIRST_EXTENSIBLE_DATA_VERSION &&
			    our_attrs[index].nex_ro) ||
			    (fver >= _DtCM_FIRST_EXTENSIBLE_DATA_VERSION &&
			    our_attrs[index].ex_ro)))
				return (CSA_E_READONLY);

			/* check data type */
			if (attrs[i].value &&
			    attrs[i].value->type != our_attrs[index].type)
				return (CSA_E_INVALID_ATTRIBUTE_VALUE);

			if (index == CSA_ENTRY_ATTR_CLASSIFICATION_I) {
				cl = attrs[i].value->item.uint32_value;
				if (cl < CSA_CLASS_PUBLIC ||
				    cl > CSA_CLASS_CONFIDENTIAL)
					return (CSA_E_INVALID_ATTRIBUTE_VALUE);
			}

			if (index == CSA_ENTRY_ATTR_TYPE_I) {
				cl = attrs[i].value->item.uint32_value;
				if (cl < CSA_TYPE_EVENT ||
				    cl > CSA_X_DT_TYPE_OTHER)
					return (CSA_E_INVALID_ATTRIBUTE_VALUE);
			}

		} else if (fver < _DtCM_FIRST_EXTENSIBLE_DATA_VERSION) {
			return (CSA_E_INVALID_ATTRIBUTE);
		}

		/* check validity of value type */
		if (attrs[i].value) {
			if (attrs[i].value->type < CSA_VALUE_BOOLEAN ||
			    attrs[i].value->type > CSA_VALUE_OPAQUE_DATA)
				return (CSA_E_INVALID_ATTRIBUTE_VALUE);

			/* cast the sint32_value element to the desired
			 * type to be safe since the value part could
			 * actually be a pointer to a CSA_attribute_value
			 */
			switch (attrs[i].value->type) {
			case CSA_VALUE_DATE_TIME:
				if (attrs[i].value->item.sint32_value == 0
				    || _csa_iso8601_to_tick(
				    (char *)attrs[i].value->item.sint32_value,
				    &tick))
					return (CSA_E_INVALID_DATE_TIME);
				break;
			case CSA_VALUE_REMINDER:
				rptr = (CSA_reminder *)
					attrs[i].value->item.sint32_value;
				if (rptr == NULL || rptr->lead_time == NULL ||
				    _csa_iso8601_to_duration(rptr->lead_time,
							     &tick))
					return (CSA_E_INVALID_ATTRIBUTE_VALUE);
				break;
			case CSA_VALUE_ATTENDEE_LIST:
				return (CSA_E_INVALID_ATTRIBUTE_VALUE);
			}
		}
	}

	return (CSA_SUCCESS);
}

static CSA_return_code
convert_cms_user_to_csa_user(char *from, CSA_calendar_user **to)
{
	CSA_calendar_user *newval;

	if ((newval = (CSA_calendar_user *)calloc(1,
	    sizeof(CSA_calendar_user))) == NULL)
		return (CSA_E_INSUFFICIENT_MEMORY);

	if (from) {
		if ((newval->user_name = strdup(from)) == NULL) {
			free(newval);
			return (CSA_E_INSUFFICIENT_MEMORY);
		}
	}

	*to = newval;
	return (CSA_SUCCESS);
}

static CSA_return_code
hash_entry_attrs(
	uint		num_attrs,
	CSA_attribute	*csaattrs,
	cms_attribute	*cmsattrs,
	uint		*hnum,
	cms_attribute	**hattrs,
	uint		*num)
{
	int			i, j, index, count = 0;
	cms_attribute		*nattrs;
	char			*name;
	cms_attribute_value	*val;

	if ((nattrs = (cms_attribute *)calloc(1,
	    sizeof(cms_attribute)*(num_attrs+_DtCM_DEFINED_ENTRY_ATTR_SIZE+1)))
	    == NULL)
		return (CSA_E_INSUFFICIENT_MEMORY);

	for (i = 0, j = _DtCM_DEFINED_ENTRY_ATTR_SIZE + 1; i < num_attrs; i++) {
		name = (csaattrs ? csaattrs[i].name : cmsattrs[i].name.name);
		if (name == NULL)
			continue;
		else {
			count++;
			val = (csaattrs ?
				((cms_attribute_value *)csaattrs[i].value) :
				cmsattrs[i].value);
		}

		index = _DtCm_get_index_from_table(_DtCm_entry_name_tbl, name);

		if (index > 0) {
			if (cmsattrs) cmsattrs[i].name.num = index;

			nattrs[index].name.name = name;
			nattrs[index].value = val;
		} else {
			nattrs[j].name.name = name;
			nattrs[j++].value = val;
		}
	}

	if (num) *num = count;
	*hnum = j - 1;
	*hattrs = nattrs;
	return (CSA_SUCCESS);
}

static CSA_return_code
hash_cal_attrs(
	uint		num_attrs,
	CSA_attribute	*csaattrs,
	cms_attribute	*cmsattrs,
	uint		*hnum,
	cms_attribute	**hattrs,
	uint		*num)
{
	int			i, j, index, count = 0;
	cms_attribute		*nattrs;
	char			*name;
	cms_attribute_value	*val;

	if ((nattrs = (cms_attribute *)calloc(1,
	    sizeof(cms_attribute)*(num_attrs+_DtCM_DEFINED_CAL_ATTR_SIZE+1)))
	    == NULL)
		return (CSA_E_INSUFFICIENT_MEMORY);

	for (i = 0, j = _DtCM_DEFINED_CAL_ATTR_SIZE + 1; i < num_attrs; i++) {
		name = (csaattrs ? csaattrs[i].name : cmsattrs[i].name.name);
		if (name == NULL)
			continue;
		else {
			count++;
			val = (csaattrs ?
				((cms_attribute_value *)csaattrs[i].value) :
				cmsattrs[i].value);
		}

		index = _DtCm_get_index_from_table(_DtCm_cal_name_tbl, name);

		if (index > 0) {
			if (cmsattrs) cmsattrs[i].name.num = index;

			nattrs[index].name.name = name;
			nattrs[index].value = val;
		} else {
			nattrs[j].name.name = name;
			nattrs[j++].value = val;
		}
	}

	if (num) *num = count;
	*hnum = j - 1;
	*hattrs = nattrs;
	return (CSA_SUCCESS);
}

static CSA_return_code
_DtCm_check_hashed_cal_attributes(
	int		fvers,
	uint		num_attrs,
	cms_attribute	*attrs,
	char		*owner,
	char		*cname,
	boolean_t	checkreadonly,
	boolean_t	firsttime,
	boolean_t	csatype)
{
	CSA_return_code stat;
	CSA_attribute_value	*csaval;
	cms_attribute_value	*cmsval;
	char			*nattr = NULL; /* calendar name */
	char			*oattr = NULL; /* calendar owner */
	char			*cattr = NULL; /* character set */
	char			*tattr = NULL; /* time zone */

	if (firsttime) {
		if (attrs[CSA_CAL_ATTR_CALENDAR_OWNER_I].name.name) {
			if (attrs[CSA_CAL_ATTR_CALENDAR_OWNER_I].value == NULL
			    || attrs[CSA_CAL_ATTR_CALENDAR_OWNER_I].value->\
			    item.calendar_user_value == NULL)
				return (CSA_E_INVALID_ATTRIBUTE_VALUE);

			if (csatype) {
				csaval = (CSA_attribute_value *)attrs[\
					CSA_CAL_ATTR_CALENDAR_OWNER_I].value;
				stat = _CheckCalendarOwner(owner, csaval->type,
				    (csaval && csaval->item.calendar_user_value?
				    csaval->item.calendar_user_value->user_name:
				    NULL));
			} else {
				cmsval = attrs[CSA_CAL_ATTR_CALENDAR_OWNER_I].\
					value;
				stat = _CheckCalendarOwner(owner, cmsval->type,
					cmsval ?
					cmsval->item.calendar_user_value:NULL);
			}

			if (stat != CSA_SUCCESS)
				return (stat);

			oattr = attrs[CSA_CAL_ATTR_CALENDAR_OWNER_I].name.name;
			attrs[CSA_CAL_ATTR_CALENDAR_OWNER_I].name.name = NULL;
		}

		if (attrs[CSA_CAL_ATTR_CALENDAR_NAME_I].name.name) {
			if (attrs[CSA_CAL_ATTR_CALENDAR_NAME_I].value == NULL ||
			    attrs[CSA_CAL_ATTR_CALENDAR_NAME_I].value->\
			    item.string_value == NULL) {
				if (oattr)
					attrs[CSA_CAL_ATTR_CALENDAR_OWNER_I].\
						name.name = oattr;
				return (CSA_E_INVALID_ATTRIBUTE_VALUE);
			}

			if ((stat = _CheckCalendarName(owner, cname,
			    attrs[CSA_CAL_ATTR_CALENDAR_NAME_I].value))
			    != CSA_SUCCESS) {
				if (oattr)
					attrs[CSA_CAL_ATTR_CALENDAR_OWNER_I].\
						name.name = oattr;
				return (stat);
			}

			nattr = attrs[CSA_CAL_ATTR_CALENDAR_NAME_I].name.name;
			attrs[CSA_CAL_ATTR_CALENDAR_NAME_I].name.name = NULL;
		}

		if (attrs[CSA_CAL_ATTR_CHARACTER_SET_I].name.name) {
			cattr = attrs[CSA_CAL_ATTR_CHARACTER_SET_I].name.name;
			attrs[CSA_CAL_ATTR_CHARACTER_SET_I].name.name = NULL;
		}

		if (attrs[CSA_CAL_ATTR_TIME_ZONE_I].name.name) {
			tattr = attrs[CSA_CAL_ATTR_TIME_ZONE_I].name.name;
			attrs[CSA_CAL_ATTR_TIME_ZONE_I].name.name = NULL;
		}
	}

	stat = check_predefined_attrs(fvers, num_attrs+1, attrs,
		checkreadonly, NULL, _DtCM_DEFINED_CAL_ATTR_SIZE,
		_CSA_cal_attr_info);

	if (oattr)
		attrs[CSA_CAL_ATTR_CALENDAR_OWNER_I].name.name = oattr;

	if (nattr)
		attrs[CSA_CAL_ATTR_CALENDAR_NAME_I].name.name = nattr;

	if (cattr)
		attrs[CSA_CAL_ATTR_CHARACTER_SET_I].name.name = oattr;

	if (tattr)
		attrs[CSA_CAL_ATTR_TIME_ZONE_I].name.name = nattr;

	return (stat);
}

static CSA_return_code
_DtCm_check_hashed_entry_attributes(
	int		fvers,
	uint		num_attrs,
	cms_attribute	*attrs,
	CSA_flags	utype)
{
	CSA_return_code stat;

	if ((stat = check_predefined_attrs(fvers, num_attrs+1, attrs,
	    (utype == 0 ? B_FALSE : B_TRUE), NULL,
	    _DtCM_DEFINED_ENTRY_ATTR_SIZE, _CSA_entry_attr_info))
	    != CSA_SUCCESS) {

		return (stat);
	}

	if (utype == CSA_CB_ENTRY_ADDED) {

		/* make sure the minimum set of attribute is specified */
		if (attrs[CSA_ENTRY_ATTR_START_DATE_I].value == NULL ||
		    attrs[CSA_ENTRY_ATTR_TYPE_I].value == NULL)
			return (CSA_E_INVALID_PARAMETER);

	} else if (utype == CSA_CB_ENTRY_UPDATED) {

		/* type can only be set at insertion time */
		if (attrs[CSA_ENTRY_ATTR_TYPE_I].name.name)
			return (CSA_E_READONLY);
	}

	return (CSA_SUCCESS);
}

static CSA_return_code
_CheckNameAtHost(char *owner, char *value)
{
	char		*ptr, *optr;
	int		res;

	/* check name part first */
	if (owner == NULL) {
		/* get user name of user running the application */
		if ((owner = _DtCmGetUserName()) == NULL)
			return (CSA_E_FAILURE);
	}

	if (optr = strchr(owner, '@')) *optr = '\0';
	if (ptr = strchr(value, '@')) *ptr = '\0';
	res = strcmp(value, owner);
	if (optr) *optr = '@';
	if (ptr) *ptr = '@';

	if (res != 0)
		return (CSA_E_INVALID_ATTRIBUTE_VALUE);

	/* check host too if it's specified */
	if (ptr == NULL)
		return (CSA_SUCCESS);

	ptr++;
	if (strcmp(ptr, (optr ? ++optr : _DtCmGetLocalHost())) == 0)
		return (CSA_SUCCESS);
	else
		return (CSA_E_INVALID_ATTRIBUTE_VALUE);
}

/*
 * check the data type and validity of calendar owner attribute
 */
static CSA_return_code
_CheckCalendarOwner(char *owner, int type, char *user)
{
	if (type != CSA_VALUE_CALENDAR_USER || user == NULL)
		return (CSA_E_INVALID_ATTRIBUTE_VALUE);

	/* make sure user is the same as the one running the application */
	return (_CheckNameAtHost(owner, user));
}

/*
 * check the data type and validity of calendar name attribute
 */
static CSA_return_code
_CheckCalendarName(char *owner, char *cname, cms_attribute_value *val)
{
	CSA_return_code stat;
	char		*ptr, *optr;
	char		user[BUFSIZ];
	boolean_t	isuser;

	if (val->type != CSA_VALUE_STRING)
		return (CSA_E_INVALID_ATTRIBUTE_VALUE);

	/* check that the attribute value is the same as the given
	 * calendar name
	 */
	if ((stat = _CheckNameAtHost(cname, val->item.string_value))
	    != CSA_SUCCESS)
		return (stat);

	/* now make sure if cal name is a user name, it's
	 * the same as that of the calling user
	 */
	if (ptr = strchr(val->item.string_value, '@')) *ptr = '\0';
	isuser = _DtCmIsUserName(val->item.string_value);
	if (ptr) *ptr = '@';

	/* make sure it's the same as the user running the application */
	if (isuser == B_TRUE) {
		sprintf(user, "%s%s", val->item.string_value, (ptr ? ptr : ""));
		return (_CheckNameAtHost(owner, user));
	}

	/* check the host part */
	if (ptr == NULL)
		return (CSA_SUCCESS);
	else
		ptr++;

	if (owner && (optr = strchr(owner, '@')))
		optr++;
	else
		optr = _DtCmGetLocalHost();

	if (strcmp(ptr, optr) == 0)
		return (CSA_SUCCESS);
	else
		return (CSA_E_INVALID_ATTRIBUTE_VALUE);
}