mgrutil.c

SyncML ToolKits,学习syncml的参考工具包.非常好用.

/*************************************************************************/
/* module:          some helper functions                             	 */
/*                                                                       */   
/* file:            mgrutil.c		                                     */
/* target system:   all                                                  */
/* target OS:       all                                                  */   
/*                                                                       */   
/* Description:                                                          */   
/*************************************************************************/

/*
 * Copyright Notice
 * Copyright (c) Ericsson, IBM, Lotus, Matsushita Communication 
 * Industrial Co., Ltd., Motorola, Nokia, Openwave Systems, Inc., 
 * Palm, Inc., Psion, Starfish Software, Symbian, Ltd. (2001).
 * All Rights Reserved.
 * Implementation of all or part of any Specification may require 
 * licenses under third party intellectual property rights, 
 * including without limitation, patent rights (such a third party 
 * may or may not be a Supporter). The Sponsors of the Specification 
 * are not responsible and shall not be held responsible in any 
 * manner for identifying or failing to identify any or all such 
 * third party intellectual property rights.
 * 
 * THIS DOCUMENT AND THE INFORMATION CONTAINED HEREIN ARE PROVIDED 
 * ON AN "AS IS" BASIS WITHOUT WARRANTY OF ANY KIND AND ERICSSON, IBM, 
 * LOTUS, MATSUSHITA COMMUNICATION INDUSTRIAL CO. LTD, MOTOROLA, 
 * NOKIA, PALM INC., PSION, STARFISH SOFTWARE AND ALL OTHER SYNCML 
 * SPONSORS DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING 
 * BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION 
 * HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF 
 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT 
 * SHALL ERICSSON, IBM, LOTUS, MATSUSHITA COMMUNICATION INDUSTRIAL CO., 
 * LTD, MOTOROLA, NOKIA, PALM INC., PSION, STARFISH SOFTWARE OR ANY 
 * OTHER SYNCML SPONSOR BE LIABLE TO ANY PARTY FOR ANY LOSS OF 
 * PROFITS, LOSS OF BUSINESS, LOSS OF USE OF DATA, INTERRUPTION OF 
 * BUSINESS, OR FOR DIRECT, INDIRECT, SPECIAL OR EXEMPLARY, INCIDENTAL, 
 * PUNITIVE OR CONSEQUENTIAL DAMAGES OF ANY KIND IN CONNECTION WITH 
 * THIS DOCUMENT OR THE INFORMATION CONTAINED HEREIN, EVEN IF ADVISED 
 * OF THE POSSIBILITY OF SUCH LOSS OR DAMAGE.
 * 
 * The above notice and this paragraph must be included on all copies 
 * of this document that are made.
 * 
 */ 

/*************************************************************************
 *  Definitions
 *************************************************************************/

#include "syncml_tk_prefix_file.h" // %%% luz: needed for precompiled headers in eVC++

/* Include Headers */
#include <sml.h>
#include <smldtd.h>
#include <smldef.h>
#include <smlerr.h>
#include <smlmetinfdtd.h>
#include <smldevinfdtd.h>
#include "libmem.h"
#include "libstr.h"
#include "liblock.h"
#include "mgr.h"
#include "mgrutil.h"


/*************************************************************************
 *  Exported SyncML API functions
 *************************************************************************/

/**
 * FUNCTION: smlFreeProtoElement
 *
 * frees all allocated memory of a smlProtoElement
 *
 * IN:              VoidPtr_t
 *                  Element to free
 *
 * RETURN:          Ret_t
 *                  Return Code
 */
SML_API Ret_t smlFreeProtoElement(VoidPtr_t pProtoElement)
{
	if (! pProtoElement)
		return(SML_ERR_OK);

	switch (((SmlUnknownProtoElementPtr_t)pProtoElement)->elementType) {

		case SML_PE_HEADER:
			smlFreeSyncHdr((SmlSyncHdrPtr_t)pProtoElement);
			break;

		case SML_PE_SYNC_START:
			smlFreeSync((SmlSyncPtr_t)pProtoElement);
			break;

		case SML_PE_ADD:
		case SML_PE_COPY:
		case SML_PE_REPLACE:
		case SML_PE_DELETE:
		case SML_PE_GENERIC:
			smlFreeGeneric((SmlGenericCmdPtr_t)pProtoElement);
			break;

		case SML_PE_ALERT:
			smlFreeAlert((SmlAlertPtr_t)pProtoElement);
			break;

    case SML_PE_ATOMIC_START:
    case SML_PE_SEQUENCE_START:
		case SML_PE_CMD_GROUP:
			smlFreeAtomic((SmlAtomicPtr_t)pProtoElement);
			break;

#if (defined EXEC_SEND || defined EXEC_RECEIVE)
		case SML_PE_EXEC:
			smlFreeExec((SmlExecPtr_t)pProtoElement);
			break;
#endif

    case SML_PE_PUT:
    case SML_PE_GET:
		case SML_PE_PUT_GET:
			smlFreeGetPut((SmlPutPtr_t)pProtoElement);
			break;

		case SML_PE_MAP:
			smlFreeMap((SmlMapPtr_t)pProtoElement);
			break;

		case SML_PE_RESULTS:
			smlFreeResults((SmlResultsPtr_t)pProtoElement);
			break;

#if (defined SEARCH_SEND || defined SEARCH_RECEIVE)
		case SML_PE_SEARCH:
			smlFreeSearch((SmlSearchPtr_t)pProtoElement);
			break;
#endif
		case SML_PE_STATUS:
			smlFreeStatus((SmlStatusPtr_t)pProtoElement);
			break;

		default:
			return(SML_ERR_A_UTI_UNKNOWN_PROTO_ELEMENT);
	}

	return(SML_ERR_OK);
}


/**
 * FUNCTION: smlFreePcdata
 *
 * frees the Memory of an allocated Pcdata memory object
 *
 * IN:              SmlPcdataPtr_t
 *                  A Pointer to a PcData structure, which should be freed
 *
 * RETURN:          ---
 *
 */
SML_API void smlFreePcdata(SmlPcdataPtr_t pPcdata)
{
	if (! pPcdata)
		return;

	if (pPcdata->contentType == SML_PCDATA_EXTENSION) {
		switch ((int)pPcdata->extension) {
#ifdef __USE_METINF__
			case SML_EXT_METINF:
				smlFreeMetinfMetinf(pPcdata->content);
				smlLibFree(pPcdata);
				break;
#endif
#ifdef __USE_DEVINF__
			case SML_EXT_DEVINF:
				smlFreeDevInfDevInf(pPcdata->content);
				smlLibFree(pPcdata);
				break;
#endif
		}
		return;
	}

	if (pPcdata->content)
		smlLibFree(pPcdata->content);

	smlLibFree(pPcdata);
}


SML_API void smlFreePcdataList(SmlPcdataListPtr_t list) {
	if (!list) return;
	smlFreePcdataList(list->next);
	smlFreePcdata(list->data);
	smlLibFree(list);
	return;
}

#ifdef __USE_METINF__
/** Subfunctions to smlFreePcdata, to freeup MetaInf DTD structures **/
SML_API void smlFreeMetinfMetinf(SmlMetInfMetInfPtr_t data) {
    if (!data) return;
	smlFreePcdata(data->format);
	smlFreePcdata(data->type);
	smlFreePcdata(data->mark);
	smlFreePcdata(data->size);
	smlFreePcdata(data->version);
	smlFreePcdata(data->nextnonce);
	smlFreePcdata(data->maxmsgsize);
    /* SCTSTK - 18/03/2002, S.H. 2002-04-05 : SyncML 1.1 */
	smlFreePcdata(data->maxobjsize);
	smlFreeMetinfAnchor(data->anchor);
	smlFreeMetinfMem(data->mem);
	smlFreePcdataList(data->emi);
	smlLibFree(data);
	return;
}
SML_API void smlFreeMetinfAnchor(SmlMetInfAnchorPtr_t data) {
    if (!data) return;
	smlFreePcdata(data->last);
	smlFreePcdata(data->next);
	smlLibFree(data);
	return;
}
SML_API void smlFreeMetinfMem(SmlMetInfMemPtr_t data) {
    if (!data) return;
	smlFreePcdata(data->shared);
	smlFreePcdata(data->free);
	smlFreePcdata(data->freeid);
	smlLibFree(data);
	return;
}
#endif

#ifdef __USE_DEVINF__
/** Subfunctions to smlFreePcdata, to freeup DevInf DTD structures **/
SML_API void smlFreeDevInfDevInf(SmlDevInfDevInfPtr_t data) {
    if (!data) return;
    smlFreePcdata(data->verdtd);
    smlFreePcdata(data->man);
    smlFreePcdata(data->mod);
    smlFreePcdata(data->oem);
    smlFreePcdata(data->fwv);
    smlFreePcdata(data->hwv);
    smlFreePcdata(data->swv);
    smlFreePcdata(data->devid);
    smlFreePcdata(data->devtyp);
    smlFreeDevInfDatastoreList(data->datastore);
    smlFreeDevInfExtList(data->ext);
    smlFreeDevInfCtcapList(data->ctcap);
    smlLibFree(data);
}
SML_API void smlFreeDevInfDatastore(SmlDevInfDatastorePtr_t data) {
    if (!data) return;
    smlFreePcdata(data->sourceref);
    smlFreePcdata(data->displayname);
    smlFreePcdata(data->maxguidsize);
    smlFreeDevInfXmit(data->rxpref);
    smlFreeDevInfXmit(data->txpref);
    smlFreeDevInfXmitList(data->rx);
    smlFreeDevInfXmitList(data->tx);
    smlFreeDevInfDSMem(data->dsmem);
    smlFreeDevInfSynccap(data->synccap);
    smlLibFree(data);
    return;
}
SML_API void smlFreeDevInfDatastoreList(SmlDevInfDatastoreListPtr_t data) {
    if (!data) return;
    smlFreeDevInfDatastore(data->data);
    smlFreeDevInfDatastoreList(data->next);
    smlLibFree(data);
    return;
}
SML_API void smlFreeDevInfXmitList(SmlDevInfXmitListPtr_t data) {
    if (!data) return;
    smlFreeDevInfXmit(data->data);
    smlFreeDevInfXmitList(data->next);
    smlLibFree(data);
}
SML_API void smlFreeDevInfXmit(SmlDevInfXmitPtr_t data) {
    if (!data) return;
    smlFreePcdata(data->cttype);
    smlFreePcdata(data->verct);
    smlLibFree(data);
}
SML_API void smlFreeDevInfDSMem(SmlDevInfDSMemPtr_t data) {
    if (!data) return;
    // %%%luz:2003-04-28: this is now a flag! smlFreePcdata(data->shared);
    smlFreePcdata(data->maxmem);
    smlFreePcdata(data->maxid);
    smlLibFree(data);
}
SML_API void smlFreeDevInfSynccap(SmlDevInfSyncCapPtr_t data) {
    if (!data) return;
    smlFreePcdataList(data->synctype);
    smlLibFree(data);
}
SML_API void smlFreeDevInfExt(SmlDevInfExtPtr_t data) {
    if (!data) return;
    smlFreePcdata(data->xnam);
    smlFreePcdataList(data->xval);
    smlLibFree(data);
}
SML_API void smlFreeDevInfExtList(SmlDevInfExtListPtr_t data) {
    if (!data) return;
    smlFreeDevInfExt(data->data);
    smlFreeDevInfExtList(data->next);
    smlLibFree(data);
}
SML_API void smlFreeDevInfCTData(SmlDevInfCTDataPtr_t data) {
    if (!data) return;
    smlFreePcdata(data->name);
    smlFreePcdata(data->dname);
    smlFreePcdataList(data->valenum);
    smlFreePcdata(data->datatype);
    smlFreePcdata(data->size);
    smlLibFree(data);
}
SML_API void smlFreeDevInfCTDataProp(SmlDevInfCTDataPropPtr_t data) {
    if (!data) return;
    smlFreeDevInfCTData(data->prop);
    smlFreeDevInfCTDataList(data->param);
    smlLibFree(data);
}

SML_API void smlFreeDevInfCTDataList(SmlDevInfCTDataListPtr_t data) {
    if (!data) return;
    smlFreeDevInfCTData(data->data);
    smlFreeDevInfCTDataList(data->next);
    smlLibFree(data);
}

SML_API void smlFreeDevInfCTDataPropList(SmlDevInfCTDataPropListPtr_t data) {
    if (!data) return;
    smlFreeDevInfCTDataProp(data->data);
    smlFreeDevInfCTDataPropList(data->next);
    smlLibFree(data);
}

SML_API void smlFreeDevInfCTCap(SmlDevInfCTCapPtr_t data) {
    if (!data) return;
    smlFreePcdata(data->cttype);
    smlFreeDevInfCTDataPropList(data->prop);
    smlLibFree(data);
}

SML_API void smlFreeDevInfCtcapList(SmlDevInfCtcapListPtr_t data) {
    if (!data) return;

    smlFreeDevInfCTCap(data->data);
    smlFreeDevInfCtcapList(data->next);
    smlLibFree(data);
}
#endif


/*************************************************************************
 *  Exported SyncML API functions (FULL-SIZE TOOLKIT ONLY)
 *************************************************************************/

#ifndef __SML_LITE__  /* these API calls are NOT included in the Toolkit lite version */

/**
 * FUNCTION: smlGetFreeBuffer
 *
 * Return amount of unused Workspace memory
 *
 * RETURN:          MemSize_t
 *                  Amount of unused Workspace memory
 *
 */
SML_API MemSize_t smlGetFreeBuffer(InstanceID_t id)
{
	/* Definitions */ 
  MemSize_t  freeMem=0;
  
  #ifdef NOWSM
    InstanceInfoPtr_t pInstanceInfo = (InstanceInfoPtr_t)id; // ID is the instance info pointer
    if (pInstanceInfo==NULL) return 0; // no buffer if no instance there
    freeMem =
      (pInstanceInfo->instanceBuffer+pInstanceInfo->instanceBufSiz) - // end of buffer
      pInstanceInfo->writePointer; // current write pointer
  #else
    /* ask the Workspace Buffer */
    LOCKTOOLKIT("smlGetFreeBuffer");
    wsmGetFreeSize(id, &freeMem);
    RELEASETOOLKIT("smlGetFreeBuffer");
  #endif
   
	return (MemSize_t)freeMem;
}


/**
 * FUNCTION: smlString2Pcdata
 *
 * copy a string into a Pcdata structure
 *
 * IN:              String_t
 *                  Input String
 *
 * RETURN:          SmlPcdataPtr_t
 *                  A Pointer to a PcData structure
 *
 */
SML_API SmlPcdataPtr_t smlString2Pcdata(String_t str)
{
	/* Definitions */ 
	SmlPcdataPtr_t pcdata;

	/* Invalid Input */ 
    	if (! str) 
		return NULL;

	/* Allocate the PcData Structure */
	pcdata = (SmlPcdataPtr_t)smlLibMalloc((MemSize_t)sizeof(SmlPcdata_t));
	if (! pcdata) 
		return NULL;
    	smlLibMemset (pcdata, 0, (MemSize_t)sizeof(SmlPcdata_t));

	/* Set the PcData Structure */
	pcdata->contentType = SML_PCDATA_STRING;
	pcdata->length = smlLibStrlen( str );
	pcdata->content = (VoidPtr_t)smlLibStrdup(str);

	return pcdata;
}


/**
 * FUNCTION: smlPcdata2String
 *
 * copy a Pcdata structure into a string
 *
 * IN:              SmlPcdataPtr_t
 *                  A Pointer to a PcData structure
 * RETURN:          String_t
 *                  Input String
 *
 */
SML_API String_t smlPcdata2String(SmlPcdataPtr_t pcdata)
{
	/* Definitions */ 
	String_t 	str;

	/* Invalid Input */ 
    	if (! pcdata) 
		return NULL;

    	/* Allocate the String */
    str = (String_t)smlLibMalloc((MemSize_t)(pcdata->length+1));
    if (str == NULL)
		return NULL;

	/* Copy the string into the allocated data structure */
    	smlLibMemcpy((MemPtr_t)str, (MemPtr_t)pcdata->content, pcdata->length);
    	*(str + pcdata->length) = '\0';  

	return str;
}


/**
 * FUNCTION: smlPcdataDup
 *
 * Duplicates a Pcdata memory object
 *
 * IN:              SmlPcdataPtr_t
 *                  A Pointer to the original PcData structure
 *
 * RETURN:          SmlPcdataPtr_t
 *                  A Pointer to the copy of the PcData structure
 *
 */
SML_API SmlPcdataPtr_t smlPcdataDup(SmlPcdataPtr_t pcdata) 
{
	/* Definitions */ 
	SmlPcdataPtr_t newPcdata;

	/* Invalid Input */ 
	if (! pcdata) 
		return NULL;

	/* Allocate the new pcdata memory object */
	newPcdata = (SmlPcdataPtr_t)smlLibMalloc((MemSize_t)sizeof(SmlPcdata_t));
	if (! newPcdata) 
		return NULL;
	smlLibMemset (newPcdata, 0, (MemSize_t)sizeof(SmlPcdata_t));

	/* Set the PcData Structure */
	newPcdata->contentType = pcdata->contentType;
	newPcdata->length = pcdata->length;
	newPcdata->content =(VoidPtr_t)smlLibMalloc((MemSize_t)pcdata->length+1);
	if (newPcdata->content ==NULL)
	{
	    smlLibFree(newPcdata->content);
        smlLibFree(newPcdata);
        return NULL;
	} 
	smlLibMemset(newPcdata->content, 0, (MemSize_t)((pcdata->length)+1));	
	smlLibMemcpy(newPcdata->content, pcdata->content, (MemSize_t)pcdata->length);

	return newPcdata;
}

#endif

SML_API void smlFreeSyncHdr(SmlSyncHdrPtr_t pSyncHdr)
{
	if (! pSyncHdr)
		return;

	smlFreePcdata(pSyncHdr->version);
	smlFreePcdata(pSyncHdr->proto);
	smlFreePcdata(pSyncHdr->sessionID);