AMVoid IAccount_SetNameType(AIMAccount *pAcnt, const AMChar *szName, AMUInt32 uiNameLen, AIM_ACCOUNT_TYPE eType)
{
AMAssert(0 != pAcnt);
AMAssert(0 != szName && eType>=0 && eType <= 8);
if(pAcnt->szName)
{
AMFree(pAcnt->szName);
pAcnt->szName = 0;
}
pAcnt->szName = AMMalloc(uiNameLen + 1);
AMAssert(0 != pAcnt->szName);
AMMemset(pAcnt->szName, 0, uiNameLen + 1);
AMMemcpy(pAcnt->szName, szName, uiNameLen);
pAcnt->eType = eType;
if(pAcnt->szID)
{
AMFree(pAcnt->szID);
pAcnt->szID = 0;
}
pAcnt->szID = AMMalloc(uiNameLen + ID_HEAD_LEN + 1);
AMAssert(0 != pAcnt->szID);
AMMemset(pAcnt->szID, 0, uiNameLen + ID_HEAD_LEN + 1);
AMStrcpy(pAcnt->szID, szID_Head[eType]);
AMMemcpy(pAcnt->szID + ID_HEAD_LEN, szName, uiNameLen);
}
AMVoid IAccount_Destroy(AIMAccount *pAcnt)
{
AMAssert(0 != pAcnt);
DPRINT("IAccount_Destroy..............%s\n", pAcnt->szID?pAcnt->szID:"0");
if(pAcnt->szID)
{
AMFree(pAcnt->szID);
pAcnt->szID = 0;
}
if(pAcnt->szBindID)
{
AMFree(pAcnt->szBindID);
pAcnt->szBindID = 0;
}
if(pAcnt->szName)
{
AMFree(pAcnt->szName);
pAcnt->szName = 0;
}
if(pAcnt->szPwd)
{
AMFree(pAcnt->szPwd);
pAcnt->szPwd = 0;
}
if(pAcnt->szToken)
{
AMFree(pAcnt->szToken);
pAcnt->szToken = 0;
}
if(pAcnt->szWebMD5)
{
AMFree(pAcnt->szWebMD5);
pAcnt->szWebMD5 = 0;
}
if(pAcnt->szPhoneNum)
{
AMFree(pAcnt->szPhoneNum);
pAcnt->szPhoneNum = 0;
}
if(pAcnt->szSignature)
{
AMFree(pAcnt->szSignature);
pAcnt->szSignature = AMNULL;
}
if(pAcnt->szSigXML)
{
AMFree(pAcnt->szSigXML);
pAcnt->szSigXML = AMNULL;
}
AMFree(pAcnt);
}
AMVoid IASession_Destroy(IASession *pSes)
{
AMAssert(0 != pSes);
if(pSes->szContactID)
{
AMFree(pSes->szContactID);
pSes->szContactID = 0;
}
pSes->pSesModel = 0;
AMFree(pSes);
}
AMVoid IAIMessage_Destroy(IAIMessage *pMsg)
{
AMAssert(0 != pMsg);
if(pMsg->szContactID)
{
AMFree(pMsg->szContactID);
pMsg->szContactID = 0;
}
if(pMsg->szContent)
{
AMFree(pMsg->szContent);
pMsg->szContent = 0;
}
AMFree(pMsg);
}
AMVoid _AIMAuth_destroy(AMVoid *pvArg)
{
AIMAuth *pAuth = (AIMAuth *)pvArg;
AMAssert(pAuth);
DPRINT("%s >>>>>> id: %d, session: %s, packetLen: %d\n", __FUNCTION__,
pAuth->iAuth, pAuth->szSession, pAuth->uiPacketLen);
if(pAuth->szSession)
AMFree(pAuth->szSession);
if(pAuth->szRawPacket)
IMnetPackRelease(pAuth->szRawPacket);
AMFree(pAuth);
}
IMnetRetCode AIMAuthModule_onNtfNeedAuth(IMnetHandle hIMnetHandle, EventContent* pEventContent)
{
IAIM *pIM = (IAIM *)IMnetGetReference(hIMnetHandle);
ImNtfNeedAuthCode *pNeedAuth = (ImNtfNeedAuthCode *)pEventContent;
AMInt32 iRetCode = eAIM_RESULT_OK, iImgLen = 0, iAuthId = 0;
AMChar *szSessin = AMNULL, *szImgData = AMNULL;
AIM_NTF_NEED_AUTH ntfNeedAuth;
DPRINT("%s >>>>>> Entering\n", __FUNCTION__);
iRetCode = _AIMAuth_getAuthImg(&szSessin, &szImgData, &iImgLen);
_AIMAuthModule_addAuth(pIM->hAuthModule, szSessin, pNeedAuth->szPacket, pNeedAuth->uiPacketLen, &iAuthId);
AMMemset(&ntfNeedAuth, 0, sizeof(ntfNeedAuth));
ntfNeedAuth.iAuthId = iAuthId;
ntfNeedAuth.iRetCode = iRetCode;
if(eAIM_RESULT_OK == iRetCode)
{
ntfNeedAuth.pvData = szImgData;
ntfNeedAuth.iDataLen = iImgLen;
pNeedAuth->szPacket = AMNULL;
}
_AIMAuth_notify(pIM, OnNtfNeedAuth, &ntfNeedAuth);
if(ntfNeedAuth.pvData)
AMFree(ntfNeedAuth.pvData);
DPRINT("%s >>>>>> id: %d, code: %d, session: %s, imgLen: %d\n", __FUNCTION__,
ntfNeedAuth.iAuthId, ntfNeedAuth.iRetCode, szSessin, iImgLen);
return eIMnetSkip;
}
AMInt32 _AIMAuth_setSession(AIMAuth *pAuth, const AMChar *szSession)
{
AMInt32 iLen = 0;
AMAssert(pAuth && szSession);
iLen = AMStrlen(szSession);
AMAssert(iLen);
if(pAuth->szSession)
{
AMFree(pAuth->szSession);
pAuth->szSession = AMNULL;
}
#if 1 //dynamic
pAuth->szSession = szSession;
#else
pAuth->szSession = (AMChar *)AMMalloc(iLen + 1);
if(!pAuth->szSession)
return eAIM_RESULT_MALLOC_ERROR;
AMStrcpy(pAuth->szSession, szSession);
#endif
pAuth->iStatus = eAUTH_SESSION;
return eAIM_RESULT_OK;
}
static AMInt32 _AIMAuth_getAuthImg(AMChar **pszSession, AMChar **pszImg, AMInt32 *piLen)
{
AMInt32 iRetCode = eAIM_RESULT_OK, iImgLen = 0;
AMChar *szSession = AMNULL, *szImgData = AMNULL;
AMAssert(pszSession && pszImg && piLen);
*pszSession = *pszImg = *piLen = 0;
szSession = _genSession();
if(szSession)
{
szImgData = _getCheckImg(szSession, &iImgLen);
if(!szImgData || !iImgLen)
{
AMFree(szSession);
iRetCode = eAIM_RESULT_NET;
}
}
else
iRetCode = eAIM_RESULT_MALLOC_ERROR;
if(eAIM_RESULT_OK == iRetCode)
{
*pszSession = szSession;
*pszImg = szImgData;
*piLen = iImgLen;
}
return iRetCode;
}
void FreeXMLString(AMChar** ppStr)
{
if(ppStr != NULL)
{
AMFree(*ppStr);
*ppStr = NULL;
}
}
AMVoid IAccountModel_ClearToken(IAccountModel *pAcntModle, const AIMAccount *pAcnt)
{
AIMAccount *pAcntFind = AMNULL;
AMChar *szSql = AMNULL, *szErrMsg = AMNULL;
sqlite3 *pDB = AMNULL;
AMInt32 rcSqlite = 0;
AMAssert(AMNULL != pAcntModle && AMNULL != pAcnt);
pAcntFind = find_List(&pAcntModle->listAcnt, (void*)pAcnt, sizeof(AIMAccount));
if(pAcntFind)
{
AMFree(pAcntFind->szToken);
pAcntFind->szToken = AMNULL;
IAccountModel_MarkDirt(pAcntModle);
rcSqlite = myADB_Open(IM_ACNT_DB, &pDB, AMFALSE);
if(rcSqlite)
{
DPRINT("IAccountModel_ClearToken: Can't open database: %s\n", sqlite3_errmsg(pDB));
sqlite3_close(pDB);
return;
}
rcSqlite = sqlite3_exec(pDB, SQL_CREATE_ACNT_TABLE, 0, 0, &szErrMsg);
if( rcSqlite != SQLITE_OK )
{
DPRINT("IAccountModel_ClearToken: Can't \"CREATE TABLE _account(...);\": %s!\n", szErrMsg);
sqlite3_close(pDB);
sqlite3_free(szErrMsg);
return;
}
szSql = sqlite3_mprintf(SQL_CLEAR_TOKEN, pAcnt->_iRid);
if(AMNULL != szSql)
{
rcSqlite = sqlite3_exec(pDB, szSql, 0, 0, &szErrMsg);
sqlite3_free(szSql);
if( rcSqlite != SQLITE_OK )
{
DPRINT("IAccountModel_ClearToken: Can't UPDATE!\n");
sqlite3_free(szErrMsg);
sqlite3_close(pDB);
return;
}
}
sqlite3_close(pDB);
IAccountModel_ClearDirt(pAcntModle);
}
}
PCRetCode ReaderRecvBody(PacketConnection* pPacketConnection, AMUInt8* pHead, AMUInt8** ppBodyBuffer, AMInt32* pBodyLength)
{
AMInt32 length = 0;
#ifdef AMOS_DEBUG
AMPrintf("noble:ReaderRecvBody <<<<.\n");
#endif
*pBodyLength = getIntValue(pHead, 12);
if(*pBodyLength <0 /*|| *pBodyLength > PC_MAX_PROTOCOL_LEN */)
{
#ifdef AMOS_DEBUG
AMPrintf("noble:reader: bodyLength exceed limited(0~20000) = %d\n", *pBodyLength);
#endif
//send a body exceed exception to up-layer.
ReaderExceedExceptionHandler(pPacketConnection->pProtocolEngine, *pBodyLength);
return eContinue;
}
// 分配Body空间并填充
*ppBodyBuffer = (AMUInt8*)AMMalloc(*pBodyLength);
if(*ppBodyBuffer == NULL)
{
#ifdef AMOS_DEBUG
AMPrintf("noble:malloc pBodyBuffer error = %d.\n", *pBodyLength);
AMAssert(0);
#endif
return eJumpWhile;
}
memset(*ppBodyBuffer, 0, *pBodyLength);
length = PCContextGetInstance()->recv(
pPacketConnection->pProtocolEngine->pPCCore->socketFd, *ppBodyBuffer, *pBodyLength);
if( length != *pBodyLength)
{
#ifdef AMOS_DEBUG
AMPrintf("noble:recv = %d != bodyLength = %d\n", length, *pBodyLength);
#endif
//first free memory
AMFree(*ppBodyBuffer);
*ppBodyBuffer = NULL;
//send exception to up.
if(ReaderRecvExceptionHandler(pPacketConnection,*pBodyLength,length) == eContinue)
return eContinue;
else
return eJumpWhile;
}
#ifdef AMOS_DEBUG
AMPrintf("noble:ReaderRecvBody >>>>>.\n");
#endif
return eOK;
}
AIM_RESULT IAIMGroup_ReleaseHandles( AMHandle hGroup, AMBool bCnt, AMHandle *phHandleArray, AMInt32 iArraySize)
{
const IAGroup * pGroup = (const IAGroup *)hGroup;
AMAssert(0 != pGroup );
if(iArraySize>0)
AMFree(phHandleArray);
return eAIM_RESULT_OK;
}
AMVoid IAGroup_Destroy(IAGroup *pGrp)
{
AMAssert(0 != pGrp);
destruct(List, &pGrp->lChildCnt);
destruct(List, &pGrp->lChildGrp);
if(pGrp->szName)
{
AMFree(pGrp->szName);
pGrp->szName = 0;
}
if(pGrp->szPinyin)
{
AMFree(pGrp->szPinyin);
pGrp->szPinyin = 0;
}
AMFree(pGrp);
}
AMVoid AIMAuthModule_destroy(AMHandle hAuthModule)
{
AIMAuthModule *pAuthModule = (AIMAuthModule *)hAuthModule;
AMAssert(pAuthModule);
AMThreadMutexDestroy(&pAuthModule->mtxAuth);
destruct(List, &pAuthModule->lstAuth);
AMFree(pAuthModule);
}
void LooperDestory(Looper** ppLooper)
{
if(ppLooper != NULL && *ppLooper != NULL)
{
(*ppLooper)->runner = NULL;
PCContextGetInstance()->threadExit(&((*ppLooper)->pHandle));
PCContextGetInstance()->semaphoreDestory(&(*ppLooper)->semaphore);
AMFree(*ppLooper);
*ppLooper = NULL;
}
}
AMVoid IAccount_SetBindID(AIMAccount *pAcnt, const AMChar *szBindID, AMUInt32 uiIdLen)
{
AMAssert(0 != pAcnt && 0 != szBindID);
if(pAcnt->szBindID)
{
AMFree(pAcnt->szBindID);
pAcnt->szBindID = 0;
}
pAcnt->szBindID = (AMChar *)AMMalloc(uiIdLen+1);
AMAssert(0 != pAcnt->szBindID);
AMMemcpy(pAcnt->szBindID, szBindID, uiIdLen);
pAcnt->szBindID[uiIdLen] = 0;
}
AMVoid IAGroup_SetName(IAGroup *pGrp, AMChar *szName, AMUInt32 uiLen)
{
AMAssert(0 != pGrp && 0 != szName && 0 < uiLen);
if(pGrp->szName)
{
AMFree(pGrp->szName);
pGrp->szName = 0;
}
pGrp->szName = (AMChar *)AMMalloc(uiLen + 1);
AMAssert(0 != pGrp->szName);
AMMemcpy(pGrp->szName, szName, uiLen);
pGrp->szName[uiLen] = 0;
}
AMVoid IAGroup_SetPinyin(IAGroup *pGrp, AMChar *szPinyin, AMUInt32 uiLen)
{
AMAssert(0 != pGrp && 0 != szPinyin && 0 < uiLen);
if(pGrp->szPinyin)
{
AMFree(pGrp->szPinyin);
pGrp->szPinyin = 0;
}
pGrp->szPinyin = (AMChar *)AMMalloc(uiLen + 1);
AMAssert(0 != pGrp->szPinyin);
AMMemcpy(pGrp->szPinyin, szPinyin, uiLen);
pGrp->szPinyin[uiLen] = 0;
}
AMVoid IAccount_SetPwd(AIMAccount *pAcnt, const AMChar *szPwd, AMUInt32 uiPwdLen)
{
AMAssert(0 != pAcnt && 0 != szPwd);
if(pAcnt->szPwd)
{
AMFree(pAcnt->szPwd);
pAcnt->szPwd = 0;
}
pAcnt->szPwd = (AMChar *)AMMalloc(uiPwdLen+1);
AMAssert(0 != pAcnt->szPwd);
AMMemcpy(pAcnt->szPwd, szPwd, uiPwdLen);
pAcnt->szPwd[uiPwdLen] = 0;
}
void GetXMLString(AMChar* pSrc, AMChar* token, AMInt32 tokenLen, AMChar** ppDst, AMInt32* pDstLen)
{
AMInt32 length = 0;
AMChar* pBegin = NULL;
AMChar* pEnd = NULL;
AMInt32 tokenBeginLen = tokenLen + 3;
AMInt32 tokenEndLen = tokenLen + 4;
AMChar* tokenBegin = (AMChar*)AMMalloc(tokenBeginLen);
AMChar* tokenEnd = (AMChar*)AMMalloc(tokenEndLen);
memset(tokenBegin, 0, tokenBeginLen);
memset(tokenEnd, 0, tokenEndLen);
//denx: sprintf这个东西可能导致异常
//sprintf(tokenBegin, "%c%s%c", '<', token, '>');
//sprintf(tokenEnd, "%s%s%c", "</", token, '>');
length = strlen(token);
memcpy(tokenBegin, "<", 1);
memcpy(tokenBegin+1, token, length);
memcpy(tokenBegin+1+length, ">", 1);
memcpy(tokenEnd, "</", 2);
memcpy(tokenEnd+2, token, length);
memcpy(tokenEnd+2+length, ">", 1);
pBegin = strstr(pSrc, tokenBegin);
pEnd = strstr(pSrc, tokenEnd);
if(pBegin != NULL && pEnd != NULL)
{
pBegin+= strlen(tokenBegin);
*pDstLen = pEnd - pBegin;
*ppDst = (AMChar*)AMMalloc(*pDstLen+1); //此处申请的内存将在外面自动释放
memset(*ppDst, 0, *pDstLen+1);
memcpy(*ppDst, pBegin, *pDstLen);
}
AMFree(tokenBegin);
AMFree(tokenEnd);
}
void PullQueue(Queue* pQueue, Event** ppEvt, AMInt32 sync)
{
QueueItem *pFirstItem = NULL;
if(pQueue && ppEvt)
{
*ppEvt = NULL;
if(sync)
PCContextGetInstance()->semaphoreWait(&pQueue->semaphore);
PCContextGetInstance()->mutexLock(&pQueue->mutexCritical);
pFirstItem = pQueue->pFirst;
if(pFirstItem != NULL)
{
*ppEvt = pFirstItem->pEvent;
pQueue->pFirst = pFirstItem->pNext;
if(pQueue->pFirst == NULL)
pQueue->pLast = NULL;
AMFree(pFirstItem);
}
else
{
pFirstItem = pQueue->pFirstLow;
if(pFirstItem != NULL)
{
*ppEvt = pFirstItem->pEvent;
pQueue->pFirstLow = pFirstItem->pNext;
if(pQueue->pFirstLow == NULL)
pQueue->pLastLow = NULL;
AMFree(pFirstItem);
}
}
PCContextGetInstance()->mutexUnlock(&pQueue->mutexCritical);
}
}
AMVoid IAccountModel_Destroy(IAccountModel *pAcntModel)
{
AMAssert(0 != pAcntModel && pAcntModel == pSingleAcntModel);
DPRINT("IAccountModel_Destroy................Remove Reference %d\n", pAcntModel->iRefCount);
IAccountModel_Store(pAcntModel);
pAcntModel->iRefCount--;
if(0 >= pAcntModel->iRefCount)
{
destruct(List, &pAcntModel->listAcnt);
AMFree(pSingleAcntModel);
pSingleAcntModel = 0;
DPRINT("IAccountModel_Destroy.................AcntModle Destroyed\n");
}
}
AMVoid IAIMessage_SetContent(IAIMessage *pMsg, const AMChar *szContent, AMUInt32 iLen)
{
AMAssert(0 != pMsg);
if(pMsg->szContent)
{
AMFree(pMsg->szContent);
pMsg->szContent = 0;
}
pMsg->szContent = (AMChar *)AMMalloc(iLen + 1);
AMAssert(0 != pMsg->szContent);
AMMemcpy(pMsg->szContent, szContent, iLen);
pMsg->szContent[iLen] = 0;
}
void PCCoreDestory(struct ST_ProtocolEngine* pProtocolEngine)
{
QueueDestory(&pProtocolEngine->pPCCore->pReaderQueue);
QueueDestory(&pProtocolEngine->pPCCore->pSenderQueue);
QueueDestory(&pProtocolEngine->pPCCore->pCallbackQueue);
//VarKeeperDestory(&pIMnetCore->pVarKeeper);
LooperDestory(&pProtocolEngine->pPCCore->pReaderLooper);
LooperDestory(&pProtocolEngine->pPCCore->pSenderLooper);
LooperDestory(&pProtocolEngine->pPCCore->pCallbackLooper);
AMFree(pProtocolEngine->pPCCore);
}
AMVoid IAIMessage_SetCntID(IAIMessage *pMsg, const AMChar * szCntID, AMUInt32 uiIDLen)
{
AMAssert(0 != pMsg && 0 != szCntID);
if(pMsg->szContactID)
{
AMFree(pMsg->szContactID);
pMsg->szContactID = 0;
}
pMsg->szContactID = (AMChar *)AMMalloc(uiIDLen + 1);
AMAssert(0 != pMsg->szContactID);
AMMemcpy(pMsg->szContactID, szCntID, uiIDLen);
pMsg->szContactID[uiIDLen] = 0;
}
int8_t insert_PrioQueue(PrioQueue *obj, int32_t priority, void *data, size_t datasize) {
PrioNode *ptr;
CHECK_VARN(obj,EINVAL);
CHECK_VARN(data,EINVAL);
CHECK_VARA(ptr = AMMalloc(sizeof *ptr),EALLOCF);
#ifdef AMOS_DEBUG
if(!(ptr->data = obj->data->API.alloc(datasize, __FILE__, __LINE__))) {
#else
if(!(ptr->data = obj->data->API.alloc(datasize))) {
#endif
AMFree(ptr);
return EALLOCF;
}
ptr->priority = priority;
obj->data->API.copy(ptr->data,data,datasize);
return insert(Heap,(obj->data),ptr,STATIC);
}
F_DUPLICATE(PrioQueue) {
PrioQueue *dst;
CHECK_VARN(obj,NULL);
CHECK_VARA(dst = AMMalloc(sizeof *dst),NULL);
if(!(dst->data = duplicate(Heap,obj->data))) {
AMFree(dst);
return NULL;
} else {
return dst;
}
}
void *top_data_PrioQueue(PrioQueue *obj) {
CHECK_VARN(obj,NULL);
if(!empty(Heap,(obj->data))) {
return NULL;
}
return ((PrioNode *)top(Heap,(obj->data)))->data;
}
AMInt32 AIMAuthModule_updateCode(AMHandle hAuthModule, AMInt32 iAuthId)
{
AIMAuthModule *pAuthModule = (AIMAuthModule *)hAuthModule;
AIMAuth tmpAuth, *pAuthFind = AMNULL;
AMInt32 iRetCode = eAIM_RESULT_OK, iImgLen = 0;
AMChar *szSessin = AMNULL, *szImgData = AMNULL;
AIM_NTF_NEED_AUTH ntfNeedAuth;
AMAssert(pAuthModule && iAuthId);
iRetCode = _AIMAuth_getAuthImg(&szSessin, &szImgData, &iImgLen);
DPRINT("%s >>>>>> session: %s, imgLen: %d\n", __FUNCTION__, szSessin, iImgLen);
if(eAIM_RESULT_OK == iRetCode)
{
tmpAuth.iAuth = iAuthId;
AMThreadMutexLock(&pAuthModule->mtxAuth);
set_compare(List, &pAuthModule->lstAuth, _AIMAuth_cmpId);
pAuthFind = _AIMAuthModule_findId(pAuthModule, iAuthId);
if(pAuthFind)
_AIMAuth_setSession(pAuthFind, szSessin);
else
iRetCode = eAIM_RESULT_NOT_READY;
AMThreadMutexUnlock(&pAuthModule->mtxAuth);
}
AMMemset(&ntfNeedAuth, 0, sizeof(ntfNeedAuth));
ntfNeedAuth.iAuthId = iAuthId;
ntfNeedAuth.iRetCode = iRetCode;
if(eAIM_RESULT_OK == iRetCode)
{
ntfNeedAuth.pvData = szImgData;
ntfNeedAuth.iDataLen = iImgLen;
}
if(eAIM_RESULT_NOT_READY != iRetCode)
_AIMAuth_notify(pAuthModule->pIM, OnNtfNeedAuth, &ntfNeedAuth);
if(ntfNeedAuth.pvData)
AMFree(ntfNeedAuth.pvData);
return eAIM_RESULT_OK;
}
AMVoid IAccount_SetPhoneNum(AIMAccount *pAcnt, const AMChar *szPhone)//, AMUInt32 uiPhoneLen)
{
AMUInt32 uiPhoneLen = 0;
AMAssert(0 != pAcnt && 0 != szPhone);
if(pAcnt->szPhoneNum)
{
AMFree(pAcnt->szPhoneNum);
pAcnt->szPhoneNum = 0;
}
uiPhoneLen = AMStrlen(szPhone);
pAcnt->szPhoneNum = (AMChar *)AMMalloc(uiPhoneLen+1);
AMAssert(0 != pAcnt->szPhoneNum);
AMMemcpy(pAcnt->szPhoneNum, szPhone, uiPhoneLen);
pAcnt->szPhoneNum[uiPhoneLen] = 0;
}
AMVoid IAccount_SetWebMD5(AIMAccount *pAcnt, const AMChar *szToken, AMUInt32 uiTokenLen)
{
AMAssert(0 != pAcnt && 0 != szToken);
if(pAcnt->szWebMD5)
{
AMFree(pAcnt->szWebMD5);
pAcnt->szWebMD5 = 0;
pAcnt->uiWebMD5Len = 0;
}
pAcnt->szWebMD5 = (AMChar *)AMMalloc(uiTokenLen+1);
AMAssert(0 != pAcnt->szWebMD5);
AMMemcpy(pAcnt->szWebMD5, szToken, uiTokenLen);
pAcnt->szWebMD5[uiTokenLen] = 0;
pAcnt->uiWebMD5Len = uiTokenLen;
}
void QueueDestory(Queue** ppObject)
{
QueueItem* pTemp = NULL;
if(ppObject == NULL)
return;
while((*ppObject)->pFirst)
{
pTemp = (*ppObject)->pFirst;
(*ppObject)->pFirst = (*ppObject)->pFirst->pNext;
//此处先释放item内部的内存
EventDestory(&pTemp->pEvent);
//再释放item本身的内存
AMFree(pTemp);
}
while((*ppObject)->pFirstLow)
{
pTemp = (*ppObject)->pFirstLow;
(*ppObject)->pFirstLow = (*ppObject)->pFirstLow->pNext;
//此处先释放item内部的内存
EventDestory(&pTemp->pEvent);
//再释放item本身的内存
AMFree(pTemp);
}
PCContextGetInstance()->mutexDestory(&(*ppObject)->mutexCritical);
PCContextGetInstance()->semaphoreDestory(&(*ppObject)->semaphore);
AMFree(*ppObject);
*ppObject = NULL;
}
