/**
* Clear all ressources needed for tracing.
*/
OpcUa_Void OPCUA_DLLCALL OpcUa_Trace_Clear(OpcUa_Void)
{
#if OPCUA_USE_SYNCHRONISATION
OPCUA_P_MUTEX_DELETE(&OpcUa_Trace_s_pLock);
#endif /* OPCUA_USE_SYNCHRONISATION */
OPCUA_P_TRACE_CLEAR();
}
/**
@brief Removes all elements from the list.
User data is not deallocated and must be delete manually
Takes no action if a_pList is null
Because this function deletes the mutex, OpcUa_List_Initialize
must be called before the list can be used again
@param a_pList [in] Location of the list to clear
*/
OpcUa_Void OpcUa_List_Clear(OpcUa_List* a_pList)
{
OpcUa_ListElement* deleteElement = OpcUa_Null;
OpcUa_ListElement* nextElement = OpcUa_Null;
if(a_pList == OpcUa_Null)
{
return;
}
deleteElement = a_pList->firstElement;
a_pList->currtElement = OpcUa_Null;
a_pList->firstElement = OpcUa_Null;
a_pList->lastElement = OpcUa_Null;
a_pList->uintNbElements = 0;
while(deleteElement)
{
nextElement = deleteElement->nextElement;
OpcUa_ListElement_Delete(&deleteElement);
deleteElement = nextElement;
}
if(a_pList->pMutex)
{
OPCUA_P_MUTEX_DELETE(&(a_pList->pMutex));
}
return;
}
/*============================================================================
* OpcUa_ProxyStub_Clear
*===========================================================================*/
OpcUa_Void OPCUA_DLLCALL OpcUa_ProxyStub_Clear(OpcUa_Void)
{
OpcUa_Boolean bSkip = OpcUa_False;
if(OpcUa_ProxyStub_g_PlatformLayerCalltable == OpcUa_Null)
{
/* error */
return;
}
else
{
#if OPCUA_USE_SYNCHRONISATION
OPCUA_P_MUTEX_LOCK(OpcUa_ProxyStub_g_hGlobalsMutex);
#endif /* OPCUA_USE_SYNCHRONISATION */
OpcUa_ProxyStub_g_uNoOfInits--;
if(OpcUa_ProxyStub_g_uNoOfInits > 0)
{
bSkip = OpcUa_True;
}
#if OPCUA_USE_SYNCHRONISATION
OPCUA_P_MUTEX_UNLOCK(OpcUa_ProxyStub_g_hGlobalsMutex);
#endif /* OPCUA_USE_SYNCHRONISATION */
if(bSkip == OpcUa_False)
{
if(OpcUa_ProxyStub_g_pConfigString != OpcUa_Null)
{
OpcUa_Free(OpcUa_ProxyStub_g_pConfigString);
OpcUa_ProxyStub_g_pConfigString = OpcUa_Null;
}
/* P-Layer resource */
OpcUa_Trace(OPCUA_TRACE_LEVEL_INFO, "OpcUa_ProxyStub_Clear: Network Module...\n");
OPCUA_P_CLEANUPNETWORK();
OPCUA_P_CLEANUPTIMERS(); /* Forces a stop of all timers not yet deleted. Leads to callbacks! */
#if OPCUA_USE_SYNCHRONISATION
OPCUA_P_MUTEX_DELETE(&OpcUa_ProxyStub_g_hGlobalsMutex);
#endif /* OPCUA_USE_SYNCHRONISATION */
OpcUa_Trace(OPCUA_TRACE_LEVEL_INFO, "OpcUa_ProxyStub_Clear: Network Module done!\n");
#if OPCUA_TRACE_ENABLE
/* internal resource */
OpcUa_Trace_Clear();
#endif /* OPCUA_TRACE_ENABLE */
OpcUa_EncodeableTypeTable_Delete(&OpcUa_ProxyStub_g_EncodeableTypes);
OpcUa_StringTable_Clear(&OpcUa_ProxyStub_g_NamespaceUris);
OpcUa_ProxyStub_g_PlatformLayerCalltable = OpcUa_Null;
}
}
}
/*============================================================================
* Delete
*===========================================================================*/
OpcUa_Void OpcUa_Thread_Delete(OpcUa_Thread* a_pThread)
{
OpcUa_ThreadInternal* pThread = OpcUa_Null;
if(a_pThread == OpcUa_Null || *a_pThread == OpcUa_Null)
{
return;
}
pThread = *((OpcUa_ThreadInternal**)a_pThread);
if(pThread->IsRunning != OpcUa_False)
{
return;
}
if(pThread->ShutdownEvent)
{
OPCUA_P_SEMAPHORE_DELETE(&(pThread->ShutdownEvent));
}
if(pThread->RawThread)
{
OpcUa_P_Thread_Delete(&(pThread->RawThread));
}
if(pThread->Mutex)
{
OPCUA_P_MUTEX_DELETE(&(pThread->Mutex));
}
pThread->ThreadData = OpcUa_Null;
pThread->ThreadMain = OpcUa_Null;
OpcUa_Free(*a_pThread);
*a_pThread = OpcUa_Null;
return;
}
/**
* @brief Clean up the given OpcUa_TcpListener_Connection. May be used for static memory.
*/
OpcUa_Void OpcUa_TcpListener_Connection_Clear(OpcUa_TcpListener_Connection* a_pConnection)
{
if(a_pConnection == OpcUa_Null)
{
return;
}
OpcUa_MemSet(&(a_pConnection->ConnectTime), 0, sizeof(OpcUa_DateTime));
OpcUa_MemSet(&(a_pConnection->DisconnectTime), 0, sizeof(OpcUa_DateTime));
a_pConnection->Socket = OpcUa_Null; /* Socket has to be freed externally. */
a_pConnection->pListenerHandle = OpcUa_Null;
a_pConnection->uNoOfRequestsTotal = 0;
OpcUa_String_Clear(&a_pConnection->sURL);
if(a_pConnection->pInputStream != OpcUa_Null)
{
OpcUa_TcpStream_Close((OpcUa_Stream*)a_pConnection->pInputStream);
OpcUa_TcpStream_Delete((OpcUa_Stream**)&a_pConnection->pInputStream);
}
while(a_pConnection->pSendQueue != OpcUa_Null)
{
OpcUa_BufferList* pCurrentBuffer = a_pConnection->pSendQueue;
a_pConnection->pSendQueue = pCurrentBuffer->pNext;
OpcUa_Buffer_Clear(&pCurrentBuffer->Buffer);
OpcUa_Free(pCurrentBuffer);
}
if(a_pConnection->Mutex)
{
OPCUA_P_MUTEX_DELETE(&(a_pConnection->Mutex));
}
OpcUa_Trace(OPCUA_TRACE_LEVEL_DEBUG, "OpcUa_TcpListener_Connection_Clear: Done!\n");
}
/*============================================================================
* OpcUa_TcpSecureChannel_Clear
*===========================================================================*/
OpcUa_StatusCode OpcUa_TcpSecureChannel_Clear(OpcUa_SecureChannel* a_pSecureChannel)
{
OpcUa_InitializeStatus(OpcUa_Module_SecureChannel, "Clear");
OpcUa_ReturnErrorIfArgumentNull(a_pSecureChannel);
OpcUa_ReturnErrorIfArgumentNull(a_pSecureChannel->Handle);
OpcUa_String_Clear(&a_pSecureChannel->SecurityPolicyUri);
OpcUa_String_Clear(&a_pSecureChannel->sPeerInfo);
OpcUa_Free(a_pSecureChannel->Handle);
a_pSecureChannel->Handle = OpcUa_Null;
OpcUa_ByteString_Clear(&a_pSecureChannel->ClientCertificate);
OpcUa_ByteString_Clear(&a_pSecureChannel->ServerCertificate);
if(a_pSecureChannel->pCurrentReceivingKeyset != OpcUa_Null)
{
OpcUa_SecurityKeyset_Clear(a_pSecureChannel->pCurrentReceivingKeyset);
OpcUa_Free(a_pSecureChannel->pCurrentReceivingKeyset);
a_pSecureChannel->pCurrentReceivingKeyset = OpcUa_Null;
}
if(a_pSecureChannel->pCurrentSendingKeyset != OpcUa_Null)
{
OpcUa_SecurityKeyset_Clear(a_pSecureChannel->pCurrentSendingKeyset);
OpcUa_Free(a_pSecureChannel->pCurrentSendingKeyset);
a_pSecureChannel->pCurrentSendingKeyset = OpcUa_Null;
}
if(a_pSecureChannel->pPreviousReceivingKeyset != OpcUa_Null)
{
OpcUa_SecurityKeyset_Clear(a_pSecureChannel->pPreviousReceivingKeyset);
OpcUa_Free(a_pSecureChannel->pPreviousReceivingKeyset);
a_pSecureChannel->pPreviousReceivingKeyset = OpcUa_Null;
}
if(a_pSecureChannel->pPreviousSendingKeyset != OpcUa_Null)
{
OpcUa_SecurityKeyset_Clear(a_pSecureChannel->pPreviousSendingKeyset);
OpcUa_Free(a_pSecureChannel->pPreviousSendingKeyset);
a_pSecureChannel->pPreviousSendingKeyset = OpcUa_Null;
}
/* delete both crypto providers */
if(a_pSecureChannel->pCurrentCryptoProvider != OpcUa_Null)
{
if(a_pSecureChannel->pPreviousCryptoProvider == a_pSecureChannel->pCurrentCryptoProvider)
{
/* prevent double deletion */
a_pSecureChannel->pPreviousCryptoProvider = OpcUa_Null;
}
OPCUA_P_CRYPTOFACTORY_DELETECRYPTOPROVIDER(a_pSecureChannel->pCurrentCryptoProvider);
OpcUa_Free(a_pSecureChannel->pCurrentCryptoProvider);
a_pSecureChannel->pCurrentCryptoProvider = OpcUa_Null;
}
if(a_pSecureChannel->pPreviousCryptoProvider != OpcUa_Null)
{
OPCUA_P_CRYPTOFACTORY_DELETECRYPTOPROVIDER(a_pSecureChannel->pPreviousCryptoProvider);
OpcUa_Free(a_pSecureChannel->pPreviousCryptoProvider);
a_pSecureChannel->pPreviousCryptoProvider = OpcUa_Null;
}
if(a_pSecureChannel->pPendingSecureIStream != OpcUa_Null)
{
OpcUa_Stream_Close((OpcUa_Stream*)(a_pSecureChannel->pPendingSecureIStream));
OpcUa_Stream_Delete((OpcUa_Stream**)&(a_pSecureChannel->pPendingSecureIStream));
}
while(a_pSecureChannel->pPendingSendBuffers != OpcUa_Null)
{
OpcUa_BufferList* pCurrentBuffer = a_pSecureChannel->pPendingSendBuffers;
a_pSecureChannel->pPendingSendBuffers = pCurrentBuffer->pNext;
OpcUa_Buffer_Clear(&pCurrentBuffer->Buffer);
OpcUa_Free(pCurrentBuffer);
}
if(a_pSecureChannel->hSyncAccess != OpcUa_Null)
{
OPCUA_P_MUTEX_DELETE(&(a_pSecureChannel->hSyncAccess));
a_pSecureChannel->hSyncAccess = OpcUa_Null;
}
if(a_pSecureChannel->hWriteMutex != OpcUa_Null)
{
OPCUA_P_MUTEX_DELETE(&(a_pSecureChannel->hWriteMutex));
a_pSecureChannel->hWriteMutex = OpcUa_Null;
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
/*============================================================================
* OpcUa_TcpSecureChannel_Create
*===========================================================================*/
OpcUa_StatusCode OpcUa_TcpSecureChannel_Create(OpcUa_SecureChannel** a_ppSecureChannel)
{
OpcUa_TcpSecureChannel* pTcpSecureChannel = OpcUa_Null;
OpcUa_InitializeStatus(OpcUa_Module_SecureChannel, "Create");
*a_ppSecureChannel = OpcUa_Null;
pTcpSecureChannel = (OpcUa_TcpSecureChannel*)OpcUa_Alloc(sizeof(OpcUa_TcpSecureChannel));
OpcUa_ReturnErrorIfAllocFailed(pTcpSecureChannel);
OpcUa_MemSet(pTcpSecureChannel, 0, sizeof(OpcUa_TcpSecureChannel));
*a_ppSecureChannel = (OpcUa_SecureChannel*)OpcUa_Alloc(sizeof(OpcUa_SecureChannel));
OpcUa_GotoErrorIfAllocFailed(*a_ppSecureChannel);
OpcUa_MemSet(*a_ppSecureChannel, 0, sizeof(OpcUa_SecureChannel));
(*a_ppSecureChannel)->SecureChannelId = OPCUA_SECURECHANNEL_ID_INVALID;
(*a_ppSecureChannel)->NextTokenId = 1;
(*a_ppSecureChannel)->uLastSequenceNumberRcvd = 0xFFFFFFFFU;
(*a_ppSecureChannel)->uLastSequenceNumberSent = OPCUA_SECURECHANNEL_STARTING_SEQUENCE_NUMBER;
(*a_ppSecureChannel)->Handle = pTcpSecureChannel;
(*a_ppSecureChannel)->Open = OpcUa_TcpSecureChannel_Open;
(*a_ppSecureChannel)->Renew = OpcUa_TcpSecureChannel_Renew;
(*a_ppSecureChannel)->Close = OpcUa_TcpSecureChannel_Close;
(*a_ppSecureChannel)->GenerateSecurityToken = OpcUa_TcpSecureChannel_GenerateSecurityToken;
(*a_ppSecureChannel)->RenewSecurityToken = OpcUa_TcpSecureChannel_RenewSecurityToken;
(*a_ppSecureChannel)->GetSecuritySet = OpcUa_TcpSecureChannel_GetSecuritySet;
(*a_ppSecureChannel)->GetCurrentSecuritySet = OpcUa_TcpSecureChannel_GetCurrentSecuritySet;
(*a_ppSecureChannel)->ReleaseSecuritySet = OpcUa_TcpSecureChannel_ReleaseSecuritySet;
(*a_ppSecureChannel)->GetSequenceNumber = OpcUa_TcpSecureChannel_GetSequenceNumber;
(*a_ppSecureChannel)->CheckSequenceNumber = OpcUa_TcpSecureChannel_CheckSequenceNumber;
(*a_ppSecureChannel)->LockWriteMutex = OpcUa_TcpSecureChannel_LockWriteMutex;
(*a_ppSecureChannel)->UnlockWriteMutex = OpcUa_TcpSecureChannel_UnlockWriteMutex;
(*a_ppSecureChannel)->IsOpen = OpcUa_SecureChannel_IsOpen;
(*a_ppSecureChannel)->DiscoveryOnly = OpcUa_False;
(*a_ppSecureChannel)->MessageSecurityMode = OpcUa_MessageSecurityMode_None;
uStatus = OPCUA_P_MUTEX_CREATE(&((*a_ppSecureChannel)->hSyncAccess));
OpcUa_GotoErrorIfBad(uStatus);
uStatus = OPCUA_P_MUTEX_CREATE(&((*a_ppSecureChannel)->hWriteMutex));
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_String_Initialize(&((*a_ppSecureChannel)->SecurityPolicyUri));
OpcUa_String_Initialize(&((*a_ppSecureChannel)->sPeerInfo));
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
if (*a_ppSecureChannel != OpcUa_Null)
{
if((*a_ppSecureChannel)->hSyncAccess != OpcUa_Null)
{
OPCUA_P_MUTEX_DELETE(&((*a_ppSecureChannel)->hSyncAccess));
}
if((*a_ppSecureChannel)->hWriteMutex != OpcUa_Null)
{
OPCUA_P_MUTEX_DELETE(&((*a_ppSecureChannel)->hWriteMutex));
}
OpcUa_Free(*a_ppSecureChannel);
*a_ppSecureChannel = OpcUa_Null;
}
OpcUa_Free(pTcpSecureChannel);
OpcUa_FinishErrorHandling;
}