mgrutil.c

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

	smlFreePcdata(pSyncHdr->msgID);
	smlFreePcdata(pSyncHdr->respURI);
	smlFreePcdata(pSyncHdr->meta);

	smlFreeSourceTargetPtr(pSyncHdr->source);
	smlFreeSourceTargetPtr(pSyncHdr->target);

	smlFreeCredPtr(pSyncHdr->cred);

	smlLibFree(pSyncHdr);
}


SML_API void smlFreeSync(SmlSyncPtr_t pSync)
{
	if (! pSync)
		return;

	smlFreePcdata(pSync->cmdID);
	smlFreePcdata(pSync->meta);

	smlFreeSourceTargetPtr(pSync->source);
	smlFreeSourceTargetPtr(pSync->target);

	smlFreeCredPtr(pSync->cred);

	smlLibFree(pSync);
}


SML_API void smlFreeGeneric(SmlGenericCmdPtr_t pGenericCmd)
{
	if (! pGenericCmd)
		return;

	smlFreePcdata(pGenericCmd->cmdID);
	smlFreePcdata(pGenericCmd->meta);

	smlFreeCredPtr(pGenericCmd->cred);

	smlFreeItemList(pGenericCmd->itemList);

	smlLibFree(pGenericCmd);
}


SML_API void smlFreeAlert(SmlAlertPtr_t pAlert)
{
	if (! pAlert)
		return;

	smlFreePcdata(pAlert->cmdID);
	smlFreePcdata(pAlert->data);

	smlFreeCredPtr(pAlert->cred);

	smlFreeItemList(pAlert->itemList);

	smlLibFree(pAlert);
}


SML_API void smlFreeAtomic(SmlAtomicPtr_t pAtomic)
{
	if (! pAtomic)
		return;

	smlFreePcdata(pAtomic->cmdID);
	smlFreePcdata(pAtomic->meta);

	smlLibFree(pAtomic);
}

#if (defined EXEC_SEND || defined EXEC_RECEIVE)

SML_API void smlFreeExec(SmlExecPtr_t pExec)
{
	if (! pExec)
		return;

	smlFreePcdata(pExec->cmdID);

	smlFreeCredPtr(pExec->cred);

	smlFreeItemPtr(pExec->item);

	smlLibFree(pExec);
}

#endif

SML_API void smlFreeGetPut(SmlPutPtr_t pGetPut)
{
	if (! pGetPut)
		return;

	smlFreePcdata(pGetPut->cmdID);
	smlFreePcdata(pGetPut->meta);
	smlFreePcdata(pGetPut->lang);

	smlFreeCredPtr(pGetPut->cred);

	smlFreeItemList(pGetPut->itemList);

	smlLibFree(pGetPut);
}


SML_API void smlFreeMap(SmlMapPtr_t pMap)
{
	if (! pMap)
		return;

	smlFreePcdata(pMap->cmdID);
	smlFreePcdata(pMap->meta);

	smlFreeCredPtr(pMap->cred);

	smlFreeSourceTargetPtr(pMap->source);
	smlFreeSourceTargetPtr(pMap->target);

	smlFreeMapItemList(pMap->mapItemList);

	smlLibFree(pMap);
}


SML_API void smlFreeResults(SmlResultsPtr_t pResults)
{
	if (! pResults)
		return;

	smlFreePcdata(pResults->cmdID);
	smlFreePcdata(pResults->msgRef);
	smlFreePcdata(pResults->cmdRef);
	smlFreePcdata(pResults->meta);
	smlFreePcdata(pResults->targetRef);
	smlFreePcdata(pResults->sourceRef);

	smlFreeItemList(pResults->itemList);

	smlLibFree(pResults);
}

#if (defined SEARCH_SEND || defined SEARCH_RECEIVE)

SML_API void smlFreeSearch(SmlSearchPtr_t pSearch)
{
	if (! pSearch)
		return;

	smlFreePcdata(pSearch->cmdID);
	smlFreePcdata(pSearch->lang);
	smlFreePcdata(pSearch->meta);
	smlFreePcdata(pSearch->data);

	smlFreeCredPtr(pSearch->cred);

	smlFreeSourceTargetPtr(pSearch->target);

	smlFreeSourceList(pSearch->sourceList);

	smlLibFree(pSearch);
}

#endif

SML_API void smlFreeStatus(SmlStatusPtr_t pStatus)
{
	if (! pStatus)
		return;

	smlFreePcdata(pStatus->cmdID);
	smlFreePcdata(pStatus->msgRef);
	smlFreePcdata(pStatus->cmdRef);
	smlFreePcdata(pStatus->cmd);
	smlFreePcdata(pStatus->data);

	smlFreeCredPtr(pStatus->cred);
	smlFreeChalPtr(pStatus->chal);

	smlFreeTargetRefList(pStatus->targetRefList);
	smlFreeSourceRefList(pStatus->sourceRefList);

	smlFreeItemList(pStatus->itemList);

	smlLibFree(pStatus);
}


SML_API void smlFreeCredPtr(SmlCredPtr_t pCred)
{
	if (! pCred)
		return;

	smlFreePcdata(pCred->meta);
	smlFreePcdata(pCred->data);

	smlLibFree(pCred);
}


SML_API void smlFreeChalPtr(SmlChalPtr_t pChal)
{
	if (! pChal)
		return;

	smlFreePcdata(pChal->meta);

	smlLibFree(pChal);
}


SML_API void smlFreeSourceTargetPtr(SmlSourcePtr_t pSourceTarget)
{
	if (! pSourceTarget)
		return;

	smlFreePcdata(pSourceTarget->locURI);
	smlFreePcdata(pSourceTarget->locName);

	smlLibFree(pSourceTarget);
}


SML_API void smlFreeSourceList(SmlSourceListPtr_t pSourceList)
{
	SmlSourceListPtr_t	pTmp;

	while (pSourceList) {
		pTmp = pSourceList->next;
		smlFreeSourceTargetPtr(pSourceList->source);
		smlLibFree(pSourceList);
		pSourceList = pTmp;
	}
}


SML_API void smlFreeSourceRefList(SmlSourceRefListPtr_t pSourceRefList)
{
	SmlSourceRefListPtr_t	pTmp;

	while (pSourceRefList) {
		pTmp = pSourceRefList->next;
		smlFreePcdata(pSourceRefList->sourceRef);
		smlLibFree(pSourceRefList);
		pSourceRefList = pTmp;
	}
}


SML_API void smlFreeTargetRefList(SmlTargetRefListPtr_t pTargetRefList)
{
	SmlTargetRefListPtr_t	pTmp;

	while (pTargetRefList) {
		pTmp = pTargetRefList->next;
		smlFreePcdata(pTargetRefList->targetRef);
		smlLibFree(pTargetRefList);
		pTargetRefList = pTmp;
	}
}


SML_API void smlFreeItemPtr(SmlItemPtr_t pItem)
{
	if (! pItem)
		return;

	smlFreePcdata(pItem->meta);
	smlFreePcdata(pItem->data);

	smlFreeSourceTargetPtr(pItem->source);
	smlFreeSourceTargetPtr(pItem->target);

	smlLibFree(pItem);
}


SML_API void smlFreeItemList(SmlItemListPtr_t pItemList)
{
	SmlItemListPtr_t	pTmp;

	while (pItemList) {
		pTmp = pItemList->next;
		smlFreeItemPtr(pItemList->item);
		smlLibFree(pItemList);
		pItemList = pTmp;
	}
}


SML_API void smlFreeMapItemPtr(SmlMapItemPtr_t pMapItem)
{
	if (! pMapItem)
		return;

	smlFreeSourceTargetPtr(pMapItem->source);
	smlFreeSourceTargetPtr(pMapItem->target);

	smlLibFree(pMapItem);
}


SML_API void smlFreeMapItemList(SmlMapItemListPtr_t pMapItemList)
{
	SmlMapItemListPtr_t	pTmp;

	while (pMapItemList) {
		pTmp = pMapItemList->next;
		smlFreeMapItemPtr(pMapItemList->mapItem);
		smlLibFree(pMapItemList);
		pMapItemList = pTmp;
	}
}

#ifdef __USE_ALLOCFUNCS__
/* Helperfunctions, that allocate and preset SyncML C structs */
SML_API SmlPcdataPtr_t smlAllocPcdata() {
    SmlPcdataPtr_t p = (SmlPcdataPtr_t)smlLibMalloc(sizeof(SmlPcdata_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlPcdata_t));
    return p;
}

SML_API SmlPcdataListPtr_t smlAllocPcdataList() {
    SmlPcdataListPtr_t p = (SmlPcdataListPtr_t)smlLibMalloc(sizeof(SmlPcdataList_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlPcdataList_t));
    p->data = smlAllocPcdata();
    if (p->data == NULL) {
        smlFreePcdataList(p);
        return NULL;
    }
    return p;
}

SML_API SmlChalPtr_t smlAllocChal() {
    SmlChalPtr_t p = (SmlChalPtr_t)smlLibMalloc(sizeof(SmlChal_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlChal_t));
    p->meta = smlAllocPcdata();
    if (p->meta == NULL) {
        smlFreeChalPtr(p);
        return NULL;
    }
    return p;
}

SML_API SmlCredPtr_t smlAllocCred() {
    SmlCredPtr_t p = (SmlCredPtr_t)smlLibMalloc(sizeof(SmlCred_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlCred_t));
    p->data = smlAllocPcdata();
    if (p->data == NULL) {
        smlFreeCredPtr(p);
        return NULL;
    }
    return p;
}

SML_API SmlSourcePtr_t smlAllocSource() {
    SmlSourcePtr_t p = (SmlSourcePtr_t)smlLibMalloc(sizeof(SmlSource_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlSource_t));
    p->locURI = smlAllocPcdata();
    if (p->locURI == NULL) {
        smlFreeSourceTargetPtr(p);
        return NULL;
    }
    return p;
}

SML_API SmlTargetPtr_t smlAllocTarget() {
    return smlAllocSource();
}

SML_API SmlSourceListPtr_t smlAllocSourceList() {
    SmlSourceListPtr_t p = (SmlSourceListPtr_t)smlLibMalloc(sizeof(SmlSourceList_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlSourceList_t));
    p->source = smlAllocSource();
    if (p->source == NULL) {
        smlFreeSourceList(p);
        return NULL;
    }
    return p;
}


SML_API SmlSyncHdrPtr_t smlAllocSyncHdr() {
    SmlSyncHdrPtr_t p = (SmlSyncHdrPtr_t)smlLibMalloc(sizeof(SmlSyncHdr_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlSyncHdr_t));
    p->elementType = SML_PE_HEADER;
    p->version = smlAllocPcdata();
    if (p->version == NULL) {
        smlFreeSyncHdr(p);
        return NULL;
    }
    p->proto   = smlAllocPcdata();
    if (p->proto == NULL) {
        smlFreeSyncHdr(p);
        return NULL;
    }
    p->sessionID = smlAllocPcdata();
    if (p->sessionID == NULL) {
        smlFreeSyncHdr(p);
        return NULL;
    }
    p->msgID     = smlAllocPcdata();
    if (p->msgID == NULL) {
        smlFreeSyncHdr(p);
        return NULL;
    }
    p->target    = smlAllocTarget();
    if (p->target == NULL) {
        smlFreeSyncHdr(p);
        return NULL;
    }
    p->source    = smlAllocSource();
    if (p->source == NULL) {
        smlFreeSyncHdr(p);
        return NULL;
    }
    return p;
}

SML_API SmlItemPtr_t smlAllocItem() {
    SmlItemPtr_t p = (SmlItemPtr_t)smlLibMalloc(sizeof(SmlItem_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlItem_t));
    return p;
}

SML_API SmlItemListPtr_t smlAllocItemList() {
    SmlItemListPtr_t p = (SmlItemListPtr_t)smlLibMalloc(sizeof(SmlItemList_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlItemList_t));
    p->item = smlAllocItem();
    if (p->item == NULL) {
        smlFreeItemList(p);
        return NULL;
    }
    return p;
}

SML_API SmlGenericCmdPtr_t smlAllocGeneric() {
    SmlGenericCmdPtr_t p = (SmlGenericCmdPtr_t)smlLibMalloc(sizeof(SmlGenericCmd_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlGenericCmd_t));
    p->elementType = SML_PE_GENERIC;
    p->cmdID = smlAllocPcdata();
    if (p->cmdID == NULL) {
        smlFreeGeneric(p);
        return NULL;
    }
    p->itemList = smlAllocItemList();
    if (p->itemList == NULL) {
        smlFreeGeneric(p);
        return NULL;
    }
    return p;
}

SML_API SmlAddPtr_t smlAllocAdd() {
    SmlAddPtr_t p = smlAllocGeneric();
    if (p == NULL) return p;
    p->elementType = SML_PE_ADD;
    return p;
}

SML_API SmlCopyPtr_t smlAllocCopy() {
    SmlCopyPtr_t p = smlAllocGeneric();
    if (p == NULL) return p;
    p->elementType = SML_PE_COPY;
    return p;
}

SML_API SmlReplacePtr_t smlAllocReplace() {
    SmlReplacePtr_t p = smlAllocGeneric();
    if (p == NULL) return p;
    p->elementType = SML_PE_REPLACE;
    return p;
}

SML_API SmlDeletePtr_t smlAllocDelete() {
    SmlDeletePtr_t p = smlAllocGeneric();
    if (p == NULL) return p;
    p->elementType = SML_PE_DELETE;
    return p;
}

SML_API SmlAlertPtr_t smlAllocAlert() {
    SmlAlertPtr_t p = (SmlAlertPtr_t)smlLibMalloc(sizeof(SmlAlert_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlAlert_t));
    p->elementType = SML_PE_ALERT;
    p->cmdID = smlAllocPcdata();
    if (p->cmdID == NULL) {
        smlFreeAlert(p);
        return NULL;
    }
    p->itemList = smlAllocItemList();
    if (p->itemList == NULL) {
        smlFreeAlert(p);
        return NULL;
    }
    return p;
}

SML_API SmlAtomicPtr_t smlAllocAtomic() {
    SmlAtomicPtr_t p = (SmlAtomicPtr_t)smlLibMalloc(sizeof(SmlAtomic_t));
    if (p == NULL) return NULL;
    smlLibMemset(p, 0, sizeof(SmlAtomic_t));
    p->elementType = SML_PE_ATOMIC_START;
    p->cmdID = smlAllocPcdata();