/*============================================================================
* OpcUa_MemoryStream_CreateReadable
*===========================================================================*/
OpcUa_StatusCode OpcUa_MemoryStream_CreateReadable(
OpcUa_Byte* buffer,
OpcUa_UInt32 bufferSize,
OpcUa_InputStream** istrm)
{
OpcUa_StatusCode uStatus = OpcUa_Good;
OpcUa_MemoryStream* handle = OpcUa_Null;
OpcUa_DeclareErrorTraceModule(OpcUa_Module_MemoryStream);
OpcUa_ReturnErrorIfNull(istrm, OpcUa_BadInvalidArgument);
*istrm = OpcUa_Null;
handle = (OpcUa_MemoryStream*)OpcUa_Alloc(sizeof(OpcUa_MemoryStream));
OpcUa_GotoErrorIfAllocFailed(handle);
OpcUa_MemSet(handle, 0, sizeof(OpcUa_MemoryStream));
handle->SanityCheck = OpcUa_MemoryStream_SanityCheck;
handle->pBuffer = OpcUa_Null;
handle->Closed = OpcUa_False;
uStatus = OpcUa_Buffer_Create(buffer, bufferSize, bufferSize, bufferSize, OpcUa_False, (OpcUa_Buffer**)&handle->pBuffer);
OpcUa_GotoErrorIfBad(uStatus);
*istrm = (OpcUa_InputStream*)OpcUa_Alloc(sizeof(OpcUa_InputStream));
OpcUa_GotoErrorIfAllocFailed(*istrm);
(*istrm)->Type = OpcUa_StreamType_Input;
(*istrm)->Handle = handle;
(*istrm)->GetPosition = OpcUa_MemoryStream_GetPosition;
(*istrm)->SetPosition = OpcUa_MemoryStream_SetPosition;
(*istrm)->Close = OpcUa_MemoryStream_Close;
(*istrm)->Delete = OpcUa_MemoryStream_Delete;
(*istrm)->Read = OpcUa_MemoryStream_Read;
(*istrm)->AttachBuffer = OpcUa_MemoryStream_AttachBuffer;
(*istrm)->DetachBuffer = OpcUa_MemoryStream_DetachBuffer;
(*istrm)->GetChunkLength = OpcUa_MemoryStream_GetChunkLength;
(*istrm)->NonBlocking = OpcUa_False;
(*istrm)->CanSeek = OpcUa_True;
return OpcUa_Good;
Error:
if (handle != OpcUa_Null && handle->pBuffer != OpcUa_Null)
{
OpcUa_Buffer_Delete((OpcUa_Buffer**)&handle->pBuffer);
}
OpcUa_Free(handle);
OpcUa_Free(*istrm);
*istrm = OpcUa_Null;
return uStatus;
}
/*============================================================================
* OpcUa_ExtensionObject_Create
*===========================================================================*/
OpcUa_Void OpcUa_ExtensionObject_Create(OpcUa_ExtensionObject** a_ppValue)
{
if (a_ppValue != OpcUa_Null)
{
*a_ppValue = (OpcUa_ExtensionObject*)OpcUa_Alloc(sizeof(OpcUa_ExtensionObject));
if(*a_ppValue != OpcUa_Null)
{
OpcUa_ExtensionObject_Initialize(*a_ppValue);
}
}
}
/*============================================================================
* OpcUa_TcpSecureChannel_RenewSecurityToken
*===========================================================================*/
OpcUa_StatusCode OpcUa_TcpSecureChannel_RenewSecurityToken( OpcUa_SecureChannel* a_pSecureChannel,
OpcUa_ChannelSecurityToken* a_pSecurityToken,
OpcUa_UInt32 a_tokenLifeTime,
OpcUa_ChannelSecurityToken** a_ppSecurityToken)
{
OpcUa_ChannelSecurityToken* pSecurityToken = OpcUa_Null;
OpcUa_InitializeStatus(OpcUa_Module_SecureChannel, "RenewSecurityToken");
/* check parameters */
OpcUa_ReturnErrorIfArgumentNull(a_pSecureChannel);
OpcUa_ReturnErrorIfArgumentNull(a_pSecurityToken);
OpcUa_ReturnErrorIfArgumentNull(a_ppSecurityToken);
OPCUA_SECURECHANNEL_LOCK(a_pSecureChannel);
/* initialize outparameters */
*a_ppSecurityToken = OpcUa_Null;
/*** create token ***/
pSecurityToken = (OpcUa_ChannelSecurityToken*)OpcUa_Alloc(sizeof(OpcUa_ChannelSecurityToken));
OpcUa_GotoErrorIfAllocFailed(pSecurityToken);
OpcUa_ChannelSecurityToken_Initialize(pSecurityToken);
pSecurityToken->TokenId = a_pSecureChannel->NextTokenId;
pSecurityToken->ChannelId = a_pSecurityToken->ChannelId;
pSecurityToken->CreatedAt = OPCUA_P_DATETIME_UTCNOW();
OpcUa_Trace(OPCUA_TRACE_LEVEL_INFO, "OpcUa_TcpSecureChannel_RenewSecurityToken: TOKEN ID is %u-%u\n", pSecurityToken->ChannelId, pSecurityToken->TokenId);
OpcUa_TcpSecureChannel_ReviseLifetime(a_tokenLifeTime, &pSecurityToken->RevisedLifetime);
/* increment renew counter */
a_pSecureChannel->NextTokenId++;
OPCUA_SECURECHANNEL_UNLOCK(a_pSecureChannel);
/* assign outparameter */
*a_ppSecurityToken = pSecurityToken;
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OPCUA_SECURECHANNEL_UNLOCK(a_pSecureChannel);
if(pSecurityToken != OpcUa_Null)
{
OpcUa_Free(pSecurityToken);
}
OpcUa_FinishErrorHandling;
}
/**
@brief Creates and initializes a new list element
@return OpcUa_Good on success
@param a_ppNewElement [in/out] Location of a pointer to the new List Element
*/
OpcUa_StatusCode OpcUa_ListElement_Create(OpcUa_ListElement** a_ppNewElement)
{
OpcUa_DeclareErrorTraceModule(OpcUa_Module_List);
OpcUa_ReturnErrorIfArgumentNull(a_ppNewElement);
*a_ppNewElement = (OpcUa_ListElement*)OpcUa_Alloc(sizeof(OpcUa_ListElement));
OpcUa_ReturnErrorIfAllocFailed(*a_ppNewElement);
OpcUa_ListElement_Initialize(*a_ppNewElement);
return OpcUa_Good;
}
/**
* @brief Allocate and initialize a new OpcUa_TcpListener_Connection object.
*
* @return Bad status on fail; Good status on success;
*/
OpcUa_StatusCode OpcUa_TcpListener_Connection_Create(OpcUa_TcpListener_Connection** a_ppConnection)
{
OpcUa_TcpListener_Connection* pConnection = OpcUa_Null;
OpcUa_DeclareErrorTraceModule(OpcUa_Module_TcpListener);
pConnection = (OpcUa_TcpListener_Connection*) OpcUa_Alloc(sizeof(OpcUa_TcpListener_Connection));
OpcUa_ReturnErrorIfAllocFailed(pConnection);
OpcUa_MemSet(pConnection, 0, sizeof(OpcUa_TcpListener_Connection));
pConnection->uCurrentChunk = 0;
OpcUa_TcpListener_Connection_Initialize(pConnection);
*a_ppConnection = pConnection;
return OpcUa_Good;
}
/*============================================================================
* Create
*===========================================================================*/
OpcUa_StatusCode OpcUa_Thread_Create( OpcUa_Thread* a_pThread,
OpcUa_PfnThreadMain* a_pThreadMain,
OpcUa_Void* a_pThreadArgument)
{
OpcUa_StatusCode uStatus = OpcUa_Good;
OpcUa_ThreadInternal* pThread = OpcUa_Null;
OpcUa_DeclareErrorTraceModule(OpcUa_Module_Thread);
OpcUa_ReturnErrorIfArgumentNull(a_pThread);
OpcUa_ReturnErrorIfArgumentNull(a_pThreadMain);
pThread = (OpcUa_ThreadInternal*)OpcUa_Alloc(sizeof(OpcUa_ThreadInternal));
OpcUa_ReturnErrorIfAllocFailed(pThread);
OpcUa_MemSet(pThread, 0, sizeof(OpcUa_ThreadInternal));
pThread->IsRunning = OpcUa_False;
pThread->ThreadMain = a_pThreadMain;
pThread->ThreadData = a_pThreadArgument;
pThread->Mutex = OpcUa_Null;
pThread->ShutdownEvent = OpcUa_Null;
uStatus = OpcUa_P_Thread_Create(&(pThread->RawThread));
OpcUa_GotoErrorIfBad(uStatus);
uStatus = OPCUA_P_SEMAPHORE_CREATE( &(pThread->ShutdownEvent),
1, /* the initial value is 1 (signalled, 1 free resource) */
1); /* the maximum value is 1 */
OpcUa_GotoErrorIfBad(uStatus);
uStatus = OPCUA_P_MUTEX_CREATE(&(pThread->Mutex));
OpcUa_GotoErrorIfBad(uStatus);
*a_pThread = pThread;
return OpcUa_Good;
Error:
return uStatus;
}
/**
* Create a new connection manager
* @param a_ppConnectionManager Description
* @return StatusCode
*/
OpcUa_StatusCode OpcUa_TcpListener_ConnectionManager_Create(
OpcUa_TcpListener_ConnectionManager** a_ppConnectionManager)
{
OpcUa_TcpListener_ConnectionManager *pConnMngr = OpcUa_Null;
OpcUa_DeclareErrorTraceModule(OpcUa_Module_TcpListener);
OpcUa_ReturnErrorIfArgumentNull(a_ppConnectionManager);
*a_ppConnectionManager = OpcUa_Null;
pConnMngr = (OpcUa_TcpListener_ConnectionManager*)OpcUa_Alloc(sizeof(OpcUa_TcpListener_ConnectionManager));
OpcUa_ReturnErrorIfAllocFailed(pConnMngr);
OpcUa_TcpListener_ConnectionManager_Initialize(pConnMngr);
if(pConnMngr->Connections == OpcUa_Null)
{
OpcUa_TcpListener_ConnectionManager_Delete(&pConnMngr);
}
*a_ppConnectionManager = pConnMngr;
return OpcUa_Good;
}
/**
@brief Creates a new empty list.
Crashes if a_ppNewList is null
@return OpcUa_Good on success
@param a_ppNewList [in/out] Location of a pointer to the new list
*/
OpcUa_StatusCode OpcUa_List_Create(OpcUa_List** a_ppNewList)
{
OpcUa_List* pNewList = OpcUa_Null;
OpcUa_StatusCode uStatus = OpcUa_Good;
OpcUa_DeclareErrorTraceModule(OpcUa_Module_List);
OpcUa_ReturnErrorIfArgumentNull(a_ppNewList);
*a_ppNewList = OpcUa_Null;
pNewList = (OpcUa_List*)OpcUa_Alloc(sizeof(OpcUa_List));
OpcUa_ReturnErrorIfAllocFailed(pNewList);
uStatus = OpcUa_List_Initialize(pNewList);
if(OpcUa_IsBad(uStatus))
{
/* error during initialize -> Cleanup */
OpcUa_List_Delete(&pNewList);
}
*a_ppNewList = pNewList;
return uStatus;
}
/*============================================================================
* OpcUa_ProxyStub_UpdateConfigString
*===========================================================================*/
static OpcUa_StatusCode OpcUa_ProxyStub_UpdateConfigString()
{
OpcUa_Int iRes = 0;
OpcUa_Int iPos = 0;
OpcUa_InitializeStatus(OpcUa_Module_ProxyStub, "UpdateConfigString");
#if OPCUA_USE_SYNCHRONISATION
OPCUA_P_MUTEX_LOCK(OpcUa_ProxyStub_g_hGlobalsMutex);
#endif /* OPCUA_USE_SYNCHRONISATION */
if(OpcUa_ProxyStub_g_pConfigString == OpcUa_Null)
{
OpcUa_ProxyStub_g_pConfigString = (OpcUa_StringA) OpcUa_Alloc(OPCUA_CONFIG_STRING_SIZE + 1);
OpcUa_GotoErrorIfAllocFailed(OpcUa_ProxyStub_g_pConfigString);
OpcUa_MemSet(OpcUa_ProxyStub_g_pConfigString, 0, OPCUA_CONFIG_STRING_SIZE + 1);
}
#if OPCUA_USE_SAFE_FUNCTIONS
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%u\\", "TraceEnabled", (OpcUa_ProxyStub_g_Configuration.bProxyStub_Trace_Enabled != 0)?1:0);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadInternalError);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%u\\", "TraceLevel", OpcUa_ProxyStub_g_Configuration.uProxyStub_Trace_Level);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iSerializer_MaxAlloc", OpcUa_ProxyStub_g_Configuration.iSerializer_MaxAlloc);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iSerializer_MaxStringLength", OpcUa_ProxyStub_g_Configuration.iSerializer_MaxStringLength);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iSerializer_MaxByteStringLength", OpcUa_ProxyStub_g_Configuration.iSerializer_MaxByteStringLength);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iSerializer_MaxArrayLength", OpcUa_ProxyStub_g_Configuration.iSerializer_MaxArrayLength);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iSerializer_MaxMessageSize", OpcUa_ProxyStub_g_Configuration.iSerializer_MaxMessageSize);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%u\\", "bSecureListener_ThreadPool_Enabled", (OpcUa_ProxyStub_g_Configuration.bSecureListener_ThreadPool_Enabled != 0)?1:0);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iSecureListener_ThreadPool_MinThreads", OpcUa_ProxyStub_g_Configuration.iSecureListener_ThreadPool_MinThreads);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iSecureListener_ThreadPool_MaxThreads", OpcUa_ProxyStub_g_Configuration.iSecureListener_ThreadPool_MaxThreads);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iSecureListener_ThreadPool_MaxJobs", OpcUa_ProxyStub_g_Configuration.iSecureListener_ThreadPool_MaxJobs);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%u\\", "bSecureListener_ThreadPool_BlockOnAdd", (OpcUa_ProxyStub_g_Configuration.bSecureListener_ThreadPool_BlockOnAdd != 0)?1:0);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%u\\", "uSecureListener_ThreadPool_Timeout", OpcUa_ProxyStub_g_Configuration.uSecureListener_ThreadPool_Timeout);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%u\\", "bTcpListener_ClientThreadsEnabled", (OpcUa_ProxyStub_g_Configuration.bTcpListener_ClientThreadsEnabled != 0)?1:0);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iTcpListener_DefaultChunkSize", OpcUa_ProxyStub_g_Configuration.iTcpListener_DefaultChunkSize);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iTcpConnection_DefaultChunkSize", OpcUa_ProxyStub_g_Configuration.iTcpConnection_DefaultChunkSize);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iTcpTransport_MaxMessageLength", OpcUa_ProxyStub_g_Configuration.iTcpTransport_MaxMessageLength);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iTcpTransport_MaxChunkCount", OpcUa_ProxyStub_g_Configuration.iTcpTransport_MaxChunkCount);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%u\\", "bTcpStream_ExpectWriteToBlock", (OpcUa_ProxyStub_g_Configuration.bTcpStream_ExpectWriteToBlock != 0)?1:0);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
#else /* OPCUA_USE_SAFE_FUNCTIONS */
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%u\\", "TraceEnabled", (OpcUa_ProxyStub_g_Configuration.bProxyStub_Trace_Enabled != 0)?1:0);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadInternalError);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%u\\", "TraceLevel", OpcUa_ProxyStub_g_Configuration.uProxyStub_Trace_Level);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iSerializer_MaxAlloc", OpcUa_ProxyStub_g_Configuration.iSerializer_MaxAlloc);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iSerializer_MaxStringLength", OpcUa_ProxyStub_g_Configuration.iSerializer_MaxStringLength);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iSerializer_MaxByteStringLength", OpcUa_ProxyStub_g_Configuration.iSerializer_MaxByteStringLength);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iSerializer_MaxArrayLength", OpcUa_ProxyStub_g_Configuration.iSerializer_MaxArrayLength);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iSerializer_MaxMessageSize", OpcUa_ProxyStub_g_Configuration.iSerializer_MaxMessageSize);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%u\\", "bSecureListener_ThreadPool_Enabled", (OpcUa_ProxyStub_g_Configuration.bSecureListener_ThreadPool_Enabled != 0)?1:0);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iSecureListener_ThreadPool_MinThreads", OpcUa_ProxyStub_g_Configuration.iSecureListener_ThreadPool_MinThreads);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iSecureListener_ThreadPool_MaxThreads", OpcUa_ProxyStub_g_Configuration.iSecureListener_ThreadPool_MaxThreads);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iSecureListener_ThreadPool_MaxJobs", OpcUa_ProxyStub_g_Configuration.iSecureListener_ThreadPool_MaxJobs);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%u\\", "bSecureListener_ThreadPool_BlockOnAdd", (OpcUa_ProxyStub_g_Configuration.bSecureListener_ThreadPool_BlockOnAdd != 0)?1:0);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%u\\", "uSecureListener_ThreadPool_Timeout", OpcUa_ProxyStub_g_Configuration.uSecureListener_ThreadPool_Timeout);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%u\\", "bTcpListener_ClientThreadsEnabled", (OpcUa_ProxyStub_g_Configuration.bTcpListener_ClientThreadsEnabled != 0)?1:0);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iTcpListener_DefaultChunkSize", OpcUa_ProxyStub_g_Configuration.iTcpListener_DefaultChunkSize);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iTcpConnection_DefaultChunkSize", OpcUa_ProxyStub_g_Configuration.iTcpConnection_DefaultChunkSize);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iTcpTransport_MaxMessageLength", OpcUa_ProxyStub_g_Configuration.iTcpTransport_MaxMessageLength);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%i\\", "iTcpTransport_MaxChunkCount", OpcUa_ProxyStub_g_Configuration.iTcpTransport_MaxChunkCount);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
iRes = OpcUa_SnPrintfA(&OpcUa_ProxyStub_g_pConfigString[iPos], OPCUA_CONFIG_STRING_SIZE - iPos, "%s:%u\\", "bTcpStream_ExpectWriteToBlock", (OpcUa_ProxyStub_g_Configuration.bTcpStream_ExpectWriteToBlock != 0)?1:0);
if(iRes > 0){iPos += iRes;}else{OpcUa_GotoErrorWithStatus(OpcUa_BadOutOfMemory);}
#endif /* OPCUA_USE_SAFE_FUNCTIONS */
#if OPCUA_USE_SYNCHRONISATION
OPCUA_P_MUTEX_UNLOCK(OpcUa_ProxyStub_g_hGlobalsMutex);
#endif /* OPCUA_USE_SYNCHRONISATION */
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
/*============================================================================
* OpcUa_MemoryStream_CreateWriteable
*===========================================================================*/
OpcUa_StatusCode OpcUa_MemoryStream_CreateWriteable(
OpcUa_UInt32 a_uBlockSize,
OpcUa_UInt32 a_uMaxSize,
OpcUa_OutputStream** a_ppOstrm)
{
OpcUa_MemoryStream* pMemoryStream = OpcUa_Null;
#if OPCUA_PREALLOC_MEMORYBLOCK
OpcUa_Byte* pbyData = OpcUa_Null;
#endif /* OPCUA_PREALLOC_MEMORYBLOCK */
OpcUa_InitializeStatus(OpcUa_Module_MemoryStream, "CreateWriteable");
OpcUa_ReturnErrorIfNull(a_ppOstrm, OpcUa_BadInvalidArgument);
*a_ppOstrm = OpcUa_Null;
pMemoryStream = (OpcUa_MemoryStream*)OpcUa_Alloc(sizeof(OpcUa_MemoryStream));
OpcUa_GotoErrorIfAllocFailed(pMemoryStream);
pMemoryStream->SanityCheck = OpcUa_MemoryStream_SanityCheck;
pMemoryStream->pBuffer = OpcUa_Null;
pMemoryStream->Closed = OpcUa_False;
#if OPCUA_PREALLOC_MEMORYBLOCK
pbyData = (OpcUa_Byte*)OpcUa_Alloc(a_uBlockSize);
OpcUa_GotoErrorIfAllocFailed(pbyData);
uStatus = OpcUa_Buffer_Create( pbyData, /* buffer space */
a_uBlockSize, /* buffer space size */
a_uBlockSize, /* allocation increment */
a_uMaxSize, /* max memory block size */
OpcUa_True, /* release buffer space */
(OpcUa_Buffer**)&pMemoryStream->pBuffer);
OpcUa_GotoErrorIfBad(uStatus);
#else /* OPCUA_PREALLOC_MEMORYBLOCK */
uStatus = OpcUa_Buffer_Create( OpcUa_Null, /* buffer space */
0,/* used data in buffer space */
a_uBlockSize, /* allocation increment */
a_uMaxSize, /* max memory block size */
OpcUa_True, /* release buffer space */
(OpcUa_Buffer**)&pMemoryStream->pBuffer);
OpcUa_GotoErrorIfBad(uStatus);
#endif /* OPCUA_PREALLOC_MEMORYBLOCK */
*a_ppOstrm = (OpcUa_OutputStream*)OpcUa_Alloc(sizeof(OpcUa_OutputStream));
OpcUa_GotoErrorIfAllocFailed(*a_ppOstrm);
OpcUa_MemSet(*a_ppOstrm, 0, sizeof(OpcUa_OutputStream));
(*a_ppOstrm)->Type = OpcUa_StreamType_Output;
(*a_ppOstrm)->Handle = pMemoryStream;
(*a_ppOstrm)->GetPosition = OpcUa_MemoryStream_GetPosition;
(*a_ppOstrm)->SetPosition = OpcUa_MemoryStream_SetPosition;
(*a_ppOstrm)->Close = OpcUa_MemoryStream_Close;
(*a_ppOstrm)->Delete = OpcUa_MemoryStream_Delete;
(*a_ppOstrm)->Flush = OpcUa_MemoryStream_Flush;
(*a_ppOstrm)->Write = OpcUa_MemoryStream_Write;
(*a_ppOstrm)->AttachBuffer = OpcUa_MemoryStream_AttachBuffer;
(*a_ppOstrm)->DetachBuffer = OpcUa_MemoryStream_DetachBuffer;
(*a_ppOstrm)->GetChunkLength = OpcUa_MemoryStream_GetChunkLength;
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
if(pMemoryStream != OpcUa_Null && pMemoryStream->pBuffer != OpcUa_Null)
{
OpcUa_Buffer_Delete((OpcUa_Buffer**)&pMemoryStream->pBuffer);
}
OpcUa_Free(pMemoryStream);
OpcUa_Free(*a_ppOstrm);
*a_ppOstrm = OpcUa_Null;
OpcUa_FinishErrorHandling;
}
/*============================================================================
* method which implements the Read service.
*===========================================================================*/
OpcUa_StatusCode my_Read(
OpcUa_Endpoint a_hEndpoint,
OpcUa_Handle a_hContext,
const OpcUa_RequestHeader* a_pRequestHeader,
OpcUa_Double a_nMaxAge,
OpcUa_TimestampsToReturn a_eTimestampsToReturn,
OpcUa_Int32 a_nNoOfNodesToRead,
const OpcUa_ReadValueId* a_pNodesToRead,
OpcUa_ResponseHeader* a_pResponseHeader,
OpcUa_Int32* a_pNoOfResults,
OpcUa_DataValue** a_pResults,
OpcUa_Int32* a_pNoOfDiagnosticInfos,
OpcUa_DiagnosticInfo** a_pDiagnosticInfos)
{
OpcUa_Int i,n;
OpcUa_Void* p_Node;
extern OpcUa_UInt32 securechannelId;
extern OpcUa_UInt32 session_flag;
extern OpcUa_Double msec_counter;
extern OpcUa_String* p_user_name;
OpcUa_InitializeStatus(OpcUa_Module_Server, "OpcUa_ServerApi_Read");
/* validate arguments. */
OpcUa_ReturnErrorIfArgumentNull(a_hEndpoint);
OpcUa_ReturnErrorIfArgumentNull(a_hContext);
OpcUa_ReturnErrorIfArgumentNull(a_pRequestHeader);
OpcUa_ReferenceParameter(a_nMaxAge);
OpcUa_ReferenceParameter(a_eTimestampsToReturn);
OpcUa_ReturnErrorIfArrayArgumentNull(a_nNoOfNodesToRead, a_pNodesToRead);
OpcUa_ReturnErrorIfArgumentNull(a_pResponseHeader);
OpcUa_ReturnErrorIfArrayArgumentNull(a_pNoOfResults, a_pResults);
OpcUa_ReturnErrorIfArrayArgumentNull(a_pNoOfDiagnosticInfos, a_pDiagnosticInfos);
*a_pNoOfDiagnosticInfos=0;
*a_pDiagnosticInfos=OpcUa_Null;
RESET_SESSION_COUNTER
#ifndef NO_DEBUGING_
MY_TRACE("\n\n\nRREADSERVICE==============================================\n");
if(p_user_name!=OpcUa_Null)
MY_TRACE("\nUser:%s\n",OpcUa_String_GetRawString(p_user_name));
#endif /*_DEBUGING_*/
if(OpcUa_IsBad(session_flag))
{
//teile client mit , dass Session geschlossen ist
#ifndef NO_DEBUGING_
MY_TRACE("\nSession nicht aktiv\n");
#endif /*_DEBUGING_*/
uStatus=OpcUa_BadSessionNotActivated;
OpcUa_GotoError;
}
uStatus=check_authentication_token(a_pRequestHeader);
if(OpcUa_IsBad(uStatus))
{
#ifndef NO_DEBUGING_
MY_TRACE("\nAuthentication Token ungültig.\n");
#endif /*_DEBUGING_*/
OpcUa_GotoError;
}
*a_pResults=OpcUa_Alloc(a_nNoOfNodesToRead*sizeof(OpcUa_DataValue));
OpcUa_GotoErrorIfAllocFailed((*a_pResults))
for(n=0;n<a_nNoOfNodesToRead;n++)
{
OpcUa_DataValue_Initialize((*a_pResults)+n);
((*a_pResults)+n)->StatusCode=OpcUa_BadAttributeIdInvalid;
p_Node=search_for_node((a_pNodesToRead+n)->NodeId);
if(p_Node!= OpcUa_Null) //pruefe ob Knoten existiert
{
if(((a_pNodesToRead+n)->AttributeId)<=7 && ((a_pNodesToRead+n)->AttributeId)>=1)
{
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_NodeId)
{
((*a_pResults)+n)->Value.Value.NodeId=OpcUa_Memory_Alloc(sizeof(OpcUa_NodeId));
if(((*a_pResults)+n)->Value.Value.NodeId !=OpcUa_Null)
{
OpcUa_NodeId_Initialize(((*a_pResults)+n)->Value.Value.NodeId);
*(((*a_pResults)+n)->Value.Value.NodeId)=((_ObjectKnoten_*)p_Node)->BaseAttribute.NodeId;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_NodeId, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
else
{
((*a_pResults)+n)->StatusCode=OpcUa_BadOutOfMemory;
}
}
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_NodeClass)
{
((*a_pResults)+n)->Value.Value.Int32=((_ObjectKnoten_*)p_Node)->BaseAttribute.NodeClass;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_Int32, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_BrowseName)
{
((*a_pResults)+n)->Value.Value.QualifiedName=OpcUa_Memory_Alloc(sizeof(OpcUa_QualifiedName));
if(((*a_pResults)+n)->Value.Value.QualifiedName!=OpcUa_Null)
{
OpcUa_QualifiedName_Initialize(((*a_pResults)+n)->Value.Value.QualifiedName);
OpcUa_String_AttachCopy(&((*a_pResults)+n)->Value.Value.QualifiedName->Name,((_ObjectKnoten_*)p_Node)->BaseAttribute.BrowseName);
((*a_pResults)+n)->Value.Value.QualifiedName->NamespaceIndex=((_ObjectKnoten_*)p_Node)->BaseAttribute.NodeId.NamespaceIndex;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_QualifiedName, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
else
{
((*a_pResults)+n)->StatusCode=OpcUa_BadOutOfMemory;
}
}
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_DisplayName)
{
((*a_pResults)+n)->Value.Value.LocalizedText=OpcUa_Memory_Alloc(sizeof(OpcUa_LocalizedText));
if(((*a_pResults)+n)->Value.Value.LocalizedText!=OpcUa_Null)
{
OpcUa_LocalizedText_Initialize(((*a_pResults)+n)->Value.Value.LocalizedText);
OpcUa_String_AttachCopy(&((*a_pResults)+n)->Value.Value.LocalizedText->Text,((_ObjectKnoten_*)p_Node)->BaseAttribute.DisplayName);
OpcUa_String_AttachCopy(&((*a_pResults)+n)->Value.Value.LocalizedText->Locale,"en");
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_LocalizedText, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
else
{
((*a_pResults)+n)->StatusCode=OpcUa_BadOutOfMemory;
}
}
if(((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_Description || (a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_WriteMask) || (a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_UserWriteMask)
{
((*a_pResults)+n)->StatusCode=OpcUa_BadNotReadable;
}
}
else
{
switch((((_ObjectKnoten_*)p_Node)->BaseAttribute.NodeClass))
{
case OpcUa_NodeClass_Variable:
{
if((a_pNodesToRead+n)->AttributeId<=20 && (a_pNodesToRead+n)->AttributeId>=13)
{
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_Value)
{
((*a_pResults)+n)->StatusCode=fill_Variant_for_value_attribute((_VariableKnoten_*)p_Node, OpcUa_Null,((*a_pResults)+n));
if(a_eTimestampsToReturn!=OpcUa_TimestampsToReturn_Neither)
{
uStatus=assigne_Timestamp(((*a_pResults)+n),a_eTimestampsToReturn);
if(OpcUa_IsBad(uStatus))
{
((*a_pResults)+n)->StatusCode=OpcUa_BadInternalError;
uStatus=OpcUa_Good;
}
}
}
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_DataType)
{
((*a_pResults)+n)->Value.Value.NodeId=OpcUa_Memory_Alloc(sizeof(OpcUa_NodeId));
if(((*a_pResults)+n)->Value.Value.NodeId!=OpcUa_Null)
{
OpcUa_NodeId_Initialize(((*a_pResults)+n)->Value.Value.NodeId);
*(((*a_pResults+n)->Value.Value.NodeId))=((_VariableKnoten_*)p_Node)->DataType;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_NodeId, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
else
{
((*a_pResults)+n)->StatusCode=OpcUa_BadOutOfMemory;
}
}
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_ValueRank)
{
((*a_pResults)+n)->Value.Value.Int32=((_VariableKnoten_*)p_Node)->ValueRank;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_Int32, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_ArrayDimensions)
{
((*a_pResults)+n)->Value.Value.UInt32=(((_VariableKnoten_*)p_Node)->ArrayDimensions);
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_UInt32, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_AccessLevel)
{
((*a_pResults)+n)->Value.Value.Byte=((_VariableKnoten_*)p_Node)->AccessLevel;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_Byte, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_UserAccessLevel)
{
((*a_pResults)+n)->Value.Value.Byte=((_VariableKnoten_*)p_Node)->UserAccessLevel;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_Byte, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_MinimumSamplingInterval)
{
((*a_pResults)+n)->Value.Value.Double=OpcUa_MinimumSamplingIntervals_Indeterminate;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_Double, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_Historizing)
{
((*a_pResults)+n)->Value.Value.Boolean=((_VariableKnoten_*)p_Node)->Historizing;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_Boolean, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
}
break;
}
case OpcUa_NodeClass_VariableType:
{
if(((a_pNodesToRead+n)->AttributeId<=16 && (a_pNodesToRead+n)->AttributeId>=13) ||((a_pNodesToRead+n)->AttributeId==8))
{
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_Value)
{
((*a_pResults)+n)->StatusCode=fill_Variant_for_value_attribute((_VariableKnoten_*)p_Node, OpcUa_Null,((*a_pResults)+n));
if(a_eTimestampsToReturn!=OpcUa_TimestampsToReturn_Neither)
{
uStatus=assigne_Timestamp(((*a_pResults)+n),a_eTimestampsToReturn);
if(OpcUa_IsBad(uStatus))
{
((*a_pResults)+n)->StatusCode=OpcUa_BadInternalError;
uStatus=OpcUa_Good;
}
}
}
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_DataType)
{
((*a_pResults)+n)->Value.Value.NodeId=OpcUa_Memory_Alloc(sizeof(OpcUa_NodeId));
if(((*a_pResults)+n)->Value.Value.NodeId!=OpcUa_Null)
{
OpcUa_NodeId_Initialize(((*a_pResults)+n)->Value.Value.NodeId);
*((*a_pResults)+n)->Value.Value.NodeId=((_VariableTypeKnoten_*)p_Node)->DataType;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_NodeId, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
else
{
((*a_pResults)+n)->StatusCode=OpcUa_BadOutOfMemory;
}
}
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_ArrayDimensions)
{
((*a_pResults)+n)->Value.Value.UInt32=((_VariableTypeKnoten_*)p_Node)->ArrayDimensions;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_UInt32, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_IsAbstract)
{
((*a_pResults)+n)->Value.Value.Boolean=((_VariableTypeKnoten_*)p_Node)->IsAbstract;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_Boolean, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
}
break;
}
case OpcUa_NodeClass_Object:
{
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_EventNotifier)
{
((*a_pResults)+n)->Value.Value.Byte=((_ObjectKnoten_*)p_Node)->EventNotifier;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_Byte, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
break;
}
case OpcUa_NodeClass_ObjectType:
{
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_IsAbstract)
{
((*a_pResults)+n)->Value.Value.Boolean=((_ObjectTypeKnoten_*)p_Node)->IsAbstract;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_Boolean, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
break;
}
case OpcUa_NodeClass_DataType:
{
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_IsAbstract)
{
((*a_pResults)+n)->Value.Value.Boolean=((_DataTypeKnoten_*)p_Node)->IsAbstract;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_Boolean, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
break;
}
case OpcUa_NodeClass_ReferenceType:
{
if((a_pNodesToRead+n)->AttributeId<=10 && (a_pNodesToRead+n)->AttributeId>=8)
{
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_IsAbstract)
{
((*a_pResults)+n)->Value.Value.Boolean=((_ReferenceTypeKnoten_*)p_Node)->IsAbstract;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_Boolean, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_Symmetric)
{
((*a_pResults)+n)->Value.Value.Boolean=((_ReferenceTypeKnoten_*)p_Node)->Symmetric;
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_Boolean, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
if((a_pNodesToRead+n)->AttributeId==OpcUa_Attributes_InverseName)
{
((*a_pResults)+n)->Value.Value.LocalizedText=OpcUa_Memory_Alloc(sizeof(OpcUa_LocalizedText));
if(((*a_pResults)+n)->Value.Value.NodeId!=OpcUa_Null)
{
OpcUa_LocalizedText_Initialize(((*a_pResults)+n)->Value.Value.LocalizedText);
OpcUa_String_AttachCopy(&((*a_pResults)+n)->Value.Value.LocalizedText->Text, ((_ReferenceTypeKnoten_*)p_Node)->InverseName_text);
OpcUa_String_AttachCopy(&((*a_pResults)+n)->Value.Value.LocalizedText->Locale, ((_ReferenceTypeKnoten_*)p_Node)->InverseName_locale);
fill_datatype_arraytype_in_my_Variant(((*a_pResults)+n),OpcUaId_LocalizedText, OpcUa_VariantArrayType_Scalar,0);
((*a_pResults)+n)->StatusCode=OpcUa_Good;
}
else
{
((*a_pResults)+n)->StatusCode=OpcUa_BadOutOfMemory;
}
}
}
break;
}
default:
break;
}
}
}
else
{
((*a_pResults)+n)->StatusCode=OpcUa_BadNodeIdUnknown;
}
}
*a_pNoOfResults=a_nNoOfNodesToRead;
#ifndef NO_DEBUGING_
MY_TRACE("\nanzahl der nodes :%d\n",a_nNoOfNodesToRead);
for(i=0;i<a_nNoOfNodesToRead;i++)
{
MY_TRACE("\n|%d|, |%d| attributeId:%u\n",(a_pNodesToRead+i)->NodeId.NamespaceIndex,(a_pNodesToRead+i)->NodeId.Identifier.Numeric,(a_pNodesToRead+i)->AttributeId);
}
#endif /*_DEBUGING_*/
uStatus = response_header_ausfuellen(a_pResponseHeader,a_pRequestHeader,uStatus);
if(OpcUa_IsBad(uStatus))
{
a_pResponseHeader->ServiceResult=OpcUa_BadInternalError;
}
#ifndef NO_DEBUGING_
MY_TRACE("\nSERVICE===ENDE============================================\n\n\n");
#endif /*_DEBUGING_*/
RESET_SESSION_COUNTER
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
uStatus = response_header_ausfuellen(a_pResponseHeader,a_pRequestHeader,uStatus);
if(OpcUa_IsBad(uStatus))
{
a_pResponseHeader->ServiceResult=OpcUa_BadInternalError;
}
#ifndef NO_DEBUGING_
MY_TRACE("\nSERVICEENDE (IM SERVICE SIND FEHLER AUFGETRETTEN)===========\n\n\n");
#endif /*_DEBUGING_*/
RESET_SESSION_COUNTER
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;
}
/*============================================================================
* OpcUa_SecureChannel_Renew
*===========================================================================*/
OpcUa_StatusCode OpcUa_TcpSecureChannel_Renew( OpcUa_SecureChannel* a_pSecureChannel,
OpcUa_Handle a_hTransportConnection,
OpcUa_ChannelSecurityToken a_ChannelSecurityToken,
OpcUa_MessageSecurityMode a_eMessageSecurityMode,
OpcUa_ByteString* a_pbsClientCertificate,
OpcUa_ByteString* a_pbsServerCertificate,
OpcUa_SecurityKeyset* a_pNewReceivingKeyset,
OpcUa_SecurityKeyset* a_pNewSendingKeyset,
OpcUa_CryptoProvider* a_pNewCryptoProvider)
{
OpcUa_InitializeStatus(OpcUa_Module_SecureChannel, "Renew");
OpcUa_ReturnErrorIfArgumentNull(a_pSecureChannel);
OpcUa_ReturnErrorIfArgumentNull(a_hTransportConnection);
OpcUa_ReturnErrorIfArgumentNull(a_pNewCryptoProvider);
OPCUA_SECURECHANNEL_LOCK(a_pSecureChannel);
OpcUa_Trace(OPCUA_TRACE_LEVEL_INFO, "OpcUa_TcpSecureChannel_Renew: New token id for channel %u is %u\n", a_pSecureChannel->SecureChannelId, a_ChannelSecurityToken.TokenId);
if(a_pSecureChannel->TransportConnection != a_hTransportConnection)
{
OpcUa_GotoErrorWithStatus(OpcUa_BadSecureChannelIdInvalid);
}
if(a_pSecureChannel->SecureChannelId != a_ChannelSecurityToken.ChannelId)
{
OpcUa_GotoErrorWithStatus(OpcUa_BadSecureChannelIdInvalid);
}
/*** TCP SECURECHANNEL ***/
/* Previous objects will be overwritten by current objects */
a_pSecureChannel->bCurrentTokenActive = OpcUa_False;
/* set channelSecurityToken members */
a_pSecureChannel->PreviousChannelSecurityToken.ChannelId = a_pSecureChannel->CurrentChannelSecurityToken.ChannelId;
a_pSecureChannel->PreviousChannelSecurityToken.TokenId = a_pSecureChannel->CurrentChannelSecurityToken.TokenId;
a_pSecureChannel->PreviousChannelSecurityToken.CreatedAt = a_pSecureChannel->CurrentChannelSecurityToken.CreatedAt;
a_pSecureChannel->PreviousChannelSecurityToken.RevisedLifetime = a_pSecureChannel->CurrentChannelSecurityToken.RevisedLifetime;
/* set current channelSecurityToken */
a_pSecureChannel->CurrentChannelSecurityToken.ChannelId = a_ChannelSecurityToken.ChannelId;
a_pSecureChannel->CurrentChannelSecurityToken.TokenId = a_ChannelSecurityToken.TokenId;
a_pSecureChannel->CurrentChannelSecurityToken.CreatedAt = a_ChannelSecurityToken.CreatedAt;
a_pSecureChannel->CurrentChannelSecurityToken.RevisedLifetime = a_ChannelSecurityToken.RevisedLifetime;
/*** SECURECHANNEL ***/
a_pSecureChannel->State = OpcUa_SecureChannelState_Opened;
a_pSecureChannel->MessageSecurityMode = a_eMessageSecurityMode;
a_pSecureChannel->uExpirationCounter = (OpcUa_UInt32)(a_pSecureChannel->CurrentChannelSecurityToken.RevisedLifetime/OPCUA_SECURELISTENER_WATCHDOG_INTERVAL);
a_pSecureChannel->uOverlapCounter = (OpcUa_UInt32)((a_pSecureChannel->CurrentChannelSecurityToken.RevisedLifetime>>2)/OPCUA_SECURELISTENER_WATCHDOG_INTERVAL);
/* free old certificate and add new one */
OpcUa_ByteString_Clear(&a_pSecureChannel->ClientCertificate);
/* copy client certificate!!! */
if(a_pbsClientCertificate != OpcUa_Null && a_pbsClientCertificate->Length > 0)
{
a_pSecureChannel->ClientCertificate.Data = (OpcUa_Byte*)OpcUa_Alloc(a_pbsClientCertificate->Length);
OpcUa_GotoErrorIfAllocFailed(a_pSecureChannel->ClientCertificate.Data);
a_pSecureChannel->ClientCertificate.Length = a_pbsClientCertificate->Length;
OpcUa_MemCpy( a_pSecureChannel->ClientCertificate.Data,
a_pSecureChannel->ClientCertificate.Length,
a_pbsClientCertificate->Data,
a_pbsClientCertificate->Length);
}
/* free old certificate and add new one */
OpcUa_ByteString_Clear(&a_pSecureChannel->ServerCertificate);
if(a_pbsServerCertificate != OpcUa_Null && a_pbsServerCertificate->Length > 0)
{
a_pSecureChannel->ServerCertificate.Data = (OpcUa_Byte*)OpcUa_Alloc(a_pbsServerCertificate->Length);
OpcUa_GotoErrorIfAllocFailed(a_pSecureChannel->ServerCertificate.Data);
a_pSecureChannel->ServerCertificate.Length = a_pbsServerCertificate->Length;
OpcUa_MemCpy( a_pSecureChannel->ServerCertificate.Data,
a_pSecureChannel->ServerCertificate.Length,
a_pbsServerCertificate->Data,
a_pbsServerCertificate->Length);
}
/* delete previous keysets */
OpcUa_SecurityKeyset_Clear(a_pSecureChannel->pPreviousReceivingKeyset);
OpcUa_SecurityKeyset_Clear(a_pSecureChannel->pPreviousSendingKeyset);
OpcUa_Free(a_pSecureChannel->pPreviousReceivingKeyset);
OpcUa_Free(a_pSecureChannel->pPreviousSendingKeyset);
a_pSecureChannel->pPreviousReceivingKeyset = OpcUa_Null;
a_pSecureChannel->pPreviousSendingKeyset = OpcUa_Null;
/* assign current to previous */
a_pSecureChannel->pPreviousReceivingKeyset = a_pSecureChannel->pCurrentReceivingKeyset;
a_pSecureChannel->pPreviousSendingKeyset = a_pSecureChannel->pCurrentSendingKeyset;
/* delete previous cryptoprovider */
if( a_pSecureChannel->pPreviousCryptoProvider != OpcUa_Null
&& a_pSecureChannel->pPreviousCryptoProvider != a_pSecureChannel->pCurrentCryptoProvider)
{
OPCUA_P_CRYPTOFACTORY_DELETECRYPTOPROVIDER(a_pSecureChannel->pPreviousCryptoProvider);
OpcUa_Free(a_pSecureChannel->pPreviousCryptoProvider);
a_pSecureChannel->pPreviousCryptoProvider = OpcUa_Null;
}
else
{
a_pSecureChannel->pPreviousCryptoProvider = OpcUa_Null;
}
/* make current cryptoprovider previous */
a_pSecureChannel->pPreviousCryptoProvider = a_pSecureChannel->pCurrentCryptoProvider;
a_pSecureChannel->pCurrentCryptoProvider = a_pNewCryptoProvider;
a_pSecureChannel->pCurrentReceivingKeyset = a_pNewReceivingKeyset;
a_pSecureChannel->pCurrentSendingKeyset = a_pNewSendingKeyset;
OPCUA_SECURECHANNEL_UNLOCK(a_pSecureChannel);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_SecurityKeyset_Clear(a_pNewReceivingKeyset);
OpcUa_SecurityKeyset_Clear(a_pNewSendingKeyset);
OpcUa_Free(a_pNewReceivingKeyset);
OpcUa_Free(a_pNewSendingKeyset);
OPCUA_SECURECHANNEL_UNLOCK(a_pSecureChannel);
OpcUa_FinishErrorHandling;
}
/*============================================================================
* OpcUa_SecureChannel_Open
*===========================================================================*/
OpcUa_StatusCode OpcUa_TcpSecureChannel_Open( OpcUa_SecureChannel* a_pSecureChannel,
OpcUa_Handle a_hTransportConnection,
OpcUa_ChannelSecurityToken a_channelSecurityToken,
OpcUa_MessageSecurityMode a_messageSecurityMode,
OpcUa_ByteString* a_pbsClientCertificate,
OpcUa_ByteString* a_pbsServerCertificate,
OpcUa_SecurityKeyset* a_pReceivingKeyset,
OpcUa_SecurityKeyset* a_pSendingKeyset,
OpcUa_CryptoProvider* a_pCryptoProvider)
{
OpcUa_InitializeStatus(OpcUa_Module_SecureChannel, "Open");
OpcUa_ReturnErrorIfArgumentNull(a_pSecureChannel);
OpcUa_ReturnErrorIfArgumentNull(a_hTransportConnection);
OpcUa_ReturnErrorIfArgumentNull(a_pCryptoProvider);
OPCUA_SECURECHANNEL_LOCK(a_pSecureChannel);
if(a_pSecureChannel->SecureChannelId != a_channelSecurityToken.ChannelId)
{
OpcUa_GotoErrorWithStatus(OpcUa_BadSecureChannelIdInvalid);
}
a_pSecureChannel->bCurrentTokenActive = OpcUa_True;
/*** TCP SECURECHANNEL ***/
a_pSecureChannel->CurrentChannelSecurityToken.ChannelId = a_channelSecurityToken.ChannelId;
a_pSecureChannel->CurrentChannelSecurityToken.TokenId = a_channelSecurityToken.TokenId;
a_pSecureChannel->CurrentChannelSecurityToken.CreatedAt = a_channelSecurityToken.CreatedAt;
a_pSecureChannel->CurrentChannelSecurityToken.RevisedLifetime = a_channelSecurityToken.RevisedLifetime;
/*** SECURECHANNEL ***/
a_pSecureChannel->State = OpcUa_SecureChannelState_Opened;
a_pSecureChannel->TransportConnection = a_hTransportConnection;
a_pSecureChannel->MessageSecurityMode = a_messageSecurityMode;
a_pSecureChannel->uExpirationCounter = (OpcUa_UInt32)(a_pSecureChannel->CurrentChannelSecurityToken.RevisedLifetime/OPCUA_SECURELISTENER_WATCHDOG_INTERVAL);
a_pSecureChannel->uOverlapCounter = (OpcUa_UInt32)((a_pSecureChannel->CurrentChannelSecurityToken.RevisedLifetime>>2)/OPCUA_SECURELISTENER_WATCHDOG_INTERVAL);
/* copy client certificate */
if(a_pbsClientCertificate != OpcUa_Null && a_pbsClientCertificate->Length > 0)
{
a_pSecureChannel->ClientCertificate.Data = (OpcUa_Byte *)OpcUa_Alloc(a_pbsClientCertificate->Length);
OpcUa_GotoErrorIfAllocFailed(a_pSecureChannel->ClientCertificate.Data);
a_pSecureChannel->ClientCertificate.Length = a_pbsClientCertificate->Length;
OpcUa_MemCpy( a_pSecureChannel->ClientCertificate.Data,
a_pSecureChannel->ClientCertificate.Length,
a_pbsClientCertificate->Data,
a_pbsClientCertificate->Length);
}
else
{
OpcUa_ByteString_Initialize(&a_pSecureChannel->ClientCertificate);
}
if(a_pbsServerCertificate != OpcUa_Null && a_pbsServerCertificate->Length > 0)
{
a_pSecureChannel->ServerCertificate.Data = (OpcUa_Byte*)OpcUa_Alloc(a_pbsServerCertificate->Length);
OpcUa_GotoErrorIfAllocFailed(a_pSecureChannel->ServerCertificate.Data);
a_pSecureChannel->ServerCertificate.Length = a_pbsServerCertificate->Length;
OpcUa_MemCpy( a_pSecureChannel->ServerCertificate.Data,
a_pSecureChannel->ServerCertificate.Length,
a_pbsServerCertificate->Data,
a_pbsServerCertificate->Length);
}
else
{
OpcUa_ByteString_Initialize(&a_pSecureChannel->ServerCertificate);
}
a_pSecureChannel->pCurrentReceivingKeyset = a_pReceivingKeyset;
a_pSecureChannel->pCurrentSendingKeyset = a_pSendingKeyset;
a_pSecureChannel->pCurrentCryptoProvider = a_pCryptoProvider;
OPCUA_SECURECHANNEL_UNLOCK(a_pSecureChannel);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_SecurityKeyset_Clear(a_pReceivingKeyset);
OpcUa_SecurityKeyset_Clear(a_pSendingKeyset);
OpcUa_Free(a_pReceivingKeyset);
OpcUa_Free(a_pSendingKeyset);
OPCUA_SECURECHANNEL_UNLOCK(a_pSecureChannel);
OpcUa_FinishErrorHandling;
}