/*============================================================================
* OpcUa_ExtensionObject_Initialize
*===========================================================================*/
OpcUa_Void OpcUa_ExtensionObject_Initialize(OpcUa_ExtensionObject* a_pValue)
{
if (a_pValue != OpcUa_Null)
{
OpcUa_MemSet(a_pValue, 0, sizeof(OpcUa_ExtensionObject));
}
}
/*============================================================================
* Bind to Socket
*===========================================================================*/
OpcUa_StatusCode OpcUa_P_RawSocket_Bind( OpcUa_RawSocket a_RawSocket,
OpcUa_Int16 a_nPort)
{
OpcUa_Int32 intSize = 0;
SOCKET winSocket = (SOCKET)OPCUA_P_SOCKET_INVALID;
struct sockaddr_in srv;
struct sockaddr *pName;
OpcUa_InitializeStatus(OpcUa_Module_Socket, "P_Bind");
OpcUa_GotoErrorIfArgumentNull(a_RawSocket);
winSocket = (SOCKET)a_RawSocket;
intSize = sizeof(struct sockaddr_in);
OpcUa_MemSet(&srv, 0, intSize);
srv.sin_addr.s_addr = INADDR_ANY;
srv.sin_port = htons(a_nPort);
srv.sin_family = AF_INET;
pName = (struct sockaddr*)&srv;
if(bind(winSocket, pName, intSize) == OPCUA_P_SOCKET_SOCKETERROR)
{
uStatus = OpcUa_BadCommunicationError;
goto Error;
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
/*============================================================================
* OpcUa_ExtensionObject_Clear
*===========================================================================*/
OpcUa_Void OpcUa_ExtensionObject_Clear(OpcUa_ExtensionObject* a_pValue)
{
if (a_pValue != OpcUa_Null)
{
OpcUa_ExpandedNodeId_Clear(&a_pValue->TypeId);
switch (a_pValue->Encoding)
{
case OpcUa_ExtensionObjectEncoding_Binary:
{
OpcUa_ByteString_Clear(&a_pValue->Body.Binary);
break;
}
case OpcUa_ExtensionObjectEncoding_Xml:
{
OpcUa_XmlElement_Clear(&a_pValue->Body.Xml);
break;
}
case OpcUa_ExtensionObjectEncoding_EncodeableObject:
{
OpcUa_EncodeableObject_Delete(a_pValue->Body.EncodeableObject.Type, &a_pValue->Body.EncodeableObject.Object);
break;
}
default:
{
break;
}
}
OpcUa_MemSet(a_pValue, 0, sizeof(OpcUa_ExtensionObject));
}
}
/*============================================================================
* OpcUa_MessageContext_Initialize
*===========================================================================*/
OpcUa_Void OpcUa_MessageContext_Clear(OpcUa_MessageContext* a_pContext)
{
if (a_pContext != OpcUa_Null)
{
OpcUa_MemSet(a_pContext, 0, sizeof(OpcUa_MessageContext));
}
}
/*============================================================================
* Connect Socket for Client.
*===========================================================================*/
OpcUa_StatusCode OpcUa_P_RawSocket_Connect( OpcUa_RawSocket a_RawSocket,
OpcUa_Int16 a_nPort,
OpcUa_StringA a_sHost)
{
int intSize = 0;
SOCKET winSocket = (SOCKET)OPCUA_P_SOCKET_INVALID;
struct sockaddr *pName;
struct sockaddr_in srv;
char* localhost = "127.0.0.1";
OpcUa_InitializeStatus(OpcUa_Module_Socket, "P_Connect");
OpcUa_GotoErrorIfArgumentNull(a_RawSocket);
winSocket = (SOCKET)a_RawSocket;
intSize = sizeof(struct sockaddr_in);
OpcUa_MemSet(&srv, 0, intSize);
if(!strcmp("localhost", a_sHost))
{
a_sHost = localhost;
}
srv.sin_addr.s_addr = inet_addr(a_sHost);
if(srv.sin_addr.s_addr == INADDR_NONE)
{
return OpcUa_BadInvalidArgument;
}
srv.sin_port = htons(a_nPort);
srv.sin_family = AF_INET;
pName = (struct sockaddr *) &srv;
if(connect(winSocket, pName, intSize) == OPCUA_P_SOCKET_SOCKETERROR)
{
int result = OpcUa_P_RawSocket_GetLastError((OpcUa_RawSocket)winSocket);
/* a connect takes some time and this "error" is common with nonblocking sockets */
if(result == WSAEWOULDBLOCK || result == WSAEINPROGRESS)
{
uStatus = OpcUa_BadWouldBlock;
}
else
{
uStatus = OpcUa_BadCommunicationError;
}
goto Error;
}
uStatus = OpcUa_Good;
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
/*============================================================================
* OpcUa_Variant_Initialize
*===========================================================================*/
OpcUa_Void OpcUa_Variant_Initialize(OpcUa_Variant* a_pValue)
{
if (a_pValue == OpcUa_Null)
{
return;
}
OpcUa_MemSet(a_pValue, 0, sizeof(OpcUa_Variant));
}
/*============================================================================
* OpcUa_DataValue_Initialize
*===========================================================================*/
OpcUa_Void OpcUa_DataValue_Initialize(OpcUa_DataValue* a_pValue)
{
if (a_pValue == OpcUa_Null)
{
return;
}
OpcUa_MemSet(a_pValue, 0, sizeof(OpcUa_DataValue));
}
/*============================================================================
* 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_DataValue_Clear
*===========================================================================*/
OpcUa_Void OpcUa_DataValue_Clear(OpcUa_DataValue* a_pValue)
{
if (a_pValue == OpcUa_Null)
{
return;
}
OpcUa_Variant_Clear(&a_pValue->Value);
OpcUa_MemSet(a_pValue, 0, sizeof(OpcUa_DataValue));
}
/*============================================================================
* OpcUa_ExpandedNodeId_Initialize
*===========================================================================*/
OpcUa_Void OpcUa_ExpandedNodeId_Initialize(OpcUa_ExpandedNodeId* a_pValue)
{
if (a_pValue == OpcUa_Null)
{
return;
}
OpcUa_MemSet(a_pValue, 0, sizeof(OpcUa_ExpandedNodeId));
OpcUa_NodeId_Initialize(&a_pValue->NodeId);
}
/*============================================================================
* OpcUa_ExpandedNodeId_Clear
*===========================================================================*/
OpcUa_Void OpcUa_ExpandedNodeId_Clear(OpcUa_ExpandedNodeId* a_pValue)
{
if (a_pValue == OpcUa_Null)
{
return;
}
OpcUa_NodeId_Clear(&a_pValue->NodeId);
OpcUa_String_Clear(&(a_pValue->NamespaceUri));
OpcUa_MemSet(a_pValue, 0, sizeof(OpcUa_ExpandedNodeId));
}
/*============================================================================
* OpcUa_MessageContext_Initialize
*===========================================================================*/
OpcUa_Void OpcUa_MessageContext_Initialize(OpcUa_MessageContext* a_pContext)
{
if (a_pContext != OpcUa_Null)
{
OpcUa_MemSet(a_pContext, 0, sizeof(OpcUa_MessageContext));
a_pContext->MaxArrayLength = OpcUa_ProxyStub_g_Configuration.iSerializer_MaxArrayLength;
a_pContext->MaxStringLength = OpcUa_ProxyStub_g_Configuration.iSerializer_MaxStringLength;
a_pContext->MaxByteStringLength = OpcUa_ProxyStub_g_Configuration.iSerializer_MaxByteStringLength;
a_pContext->MaxMessageLength = OpcUa_ProxyStub_g_Configuration.iSerializer_MaxMessageSize;
a_pContext->MaxRecursionDepth = OpcUa_ProxyStub_g_Configuration.iSerializer_MaxRecursionDepth;
}
}
/**
* @brief Initializes the given parameter and allocates embedded objects.
* If embedded objects cannot be allocated, the given pointer is set to OpcUa_Null.
*
* @return Bad status on fail; Good status on success;
*/
OpcUa_StatusCode OpcUa_TcpListener_Connection_Initialize(OpcUa_TcpListener_Connection* a_pConnection)
{
OpcUa_StatusCode uStatus = OpcUa_Good;
OpcUa_DeclareErrorTraceModule(OpcUa_Module_TcpListener);
OpcUa_ReturnErrorIfArgumentNull(a_pConnection);
OpcUa_MemSet(&(a_pConnection->ConnectTime), 0, sizeof(OpcUa_DateTime));
OpcUa_MemSet(&(a_pConnection->DisconnectTime), 0, sizeof(OpcUa_DateTime));
a_pConnection->Socket = OpcUa_Null;
#if OPCUA_P_SOCKETGETPEERINFO_V2
OpcUa_MemSet(a_pConnection->achPeerInfo, 0, OPCUA_P_PEERINFO_MIN_SIZE);
#else /* OPCUA_P_SOCKETGETPEERINFO_V2 */
a_pConnection->PeerPort = 0;
a_pConnection->PeerIp = 0;
#endif /* OPCUA_P_SOCKETGETPEERINFO_V2 */
a_pConnection->pListenerHandle = OpcUa_Null;
a_pConnection->pInputStream = OpcUa_Null;
a_pConnection->uNoOfRequestsTotal = 0;
a_pConnection->bConnected = OpcUa_False;
OpcUa_String_Initialize(&a_pConnection->sURL);
uStatus = OPCUA_P_MUTEX_CREATE(&(a_pConnection->Mutex));
OpcUa_ReturnErrorIfBad(uStatus);
a_pConnection->ReceiveBufferSize = 0;
a_pConnection->SendBufferSize = 0;
a_pConnection->pSendQueue = OpcUa_Null;
a_pConnection->bCloseWhenDone = OpcUa_False;
a_pConnection->bNoRcvUntilDone = OpcUa_False;
a_pConnection->bRcvDataPending = OpcUa_False;
return OpcUa_Good;
}
/*============================================================================
* OpcUa_DiagnosticInfo_Initialize
*===========================================================================*/
OpcUa_Void OpcUa_DiagnosticInfo_Initialize(OpcUa_DiagnosticInfo* a_pValue)
{
if (a_pValue == OpcUa_Null)
{
return;
}
OpcUa_MemSet(a_pValue, 0, sizeof(OpcUa_DiagnosticInfo));
a_pValue->SymbolicId = -1;
a_pValue->NamespaceUri = -1;
a_pValue->Locale = -1;
a_pValue->LocalizedText = -1;
}
/**
* @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");
}
/**
* @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;
}
/*============================================================================
* OpcUa_DiagnosticInfo_Clear
*===========================================================================*/
OpcUa_Void OpcUa_DiagnosticInfo_Clear(OpcUa_DiagnosticInfo* a_pValue)
{
if (a_pValue == OpcUa_Null)
{
return;
}
OpcUa_String_Clear(&(a_pValue->AdditionalInfo));
if(a_pValue->InnerDiagnosticInfo != OpcUa_Null)
{
OpcUa_DiagnosticInfo_Clear(a_pValue->InnerDiagnosticInfo);
OpcUa_Free(a_pValue->InnerDiagnosticInfo);
}
OpcUa_MemSet(a_pValue, 0, sizeof(OpcUa_DiagnosticInfo));
}
/**
* @brief Initialize an allocated connection manager.
*/
OpcUa_StatusCode OpcUa_TcpListener_ConnectionManager_Initialize(
OpcUa_TcpListener_ConnectionManager* a_pConnectionManager)
{
OpcUa_StatusCode uStatus = OpcUa_Good;
OpcUa_DeclareErrorTraceModule(OpcUa_Module_TcpListener);
if(a_pConnectionManager == OpcUa_Null)
{
return OpcUa_BadInvalidArgument;
}
OpcUa_MemSet(a_pConnectionManager, 0, sizeof(OpcUa_TcpListener_ConnectionManager));
uStatus = OpcUa_List_Create( &(a_pConnectionManager->Connections));
OpcUa_ReturnErrorIfBad(uStatus);
return uStatus;
}
/*============================================================================
* 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;
}
/*============================================================================
* OpcUa_Variant_Clear
*===========================================================================*/
OpcUa_Void OpcUa_Variant_Clear(OpcUa_Variant* a_pValue)
{
if (a_pValue == OpcUa_Null)
{
return;
}
if (a_pValue->ArrayType == OpcUa_VariantArrayType_Scalar)
{
OpcUa_VariantUnion_Clear(a_pValue->Datatype, &a_pValue->Value);
}
else if (a_pValue->ArrayType == OpcUa_VariantArrayType_Array)
{
OpcUa_VariantArrayValue_Clear(
a_pValue->Datatype,
a_pValue->Value.Array.Length,
&a_pValue->Value.Array.Value);
}
else if (a_pValue->ArrayType == OpcUa_VariantArrayType_Matrix)
{
OpcUa_VariantArrayValue_Clear(
a_pValue->Datatype,
OpcUa_VariantMatrix_GetElementCount(&a_pValue->Value.Matrix),
&a_pValue->Value.Matrix.Value);
if (a_pValue->Value.Matrix.Dimensions != OpcUa_Null)
{
OpcUa_Free(a_pValue->Value.Matrix.Dimensions);
}
}
else
{
OpcUa_MemSet(a_pValue, 0, sizeof(OpcUa_Variant));
return;
}
a_pValue->ArrayType = 0;
a_pValue->Datatype = 0;
}
/*============================================================================
* Accept Socket connection from Client.
*===========================================================================*/
OpcUa_RawSocket OpcUa_P_RawSocket_Accept( OpcUa_RawSocket a_RawSocket,
OpcUa_UInt16* a_pPort,
OpcUa_UInt32* a_pAddress,
OpcUa_Boolean a_bNagleOff,
OpcUa_Boolean a_bKeepAliveOn)
{
int cli_size = 0;
int iFlag = 1;
SOCKET winSocketServer = (SOCKET)OPCUA_P_SOCKET_INVALID;
SOCKET winSocketClient = (SOCKET)OPCUA_P_SOCKET_INVALID;
struct sockaddr_in cli;
#if OPCUA_P_SOCKET_SETTCPRCVBUFFERSIZE || OPCUA_P_SOCKET_SETTCPSNDBUFFERSIZE
OpcUa_Int iBufferSize = OPCUA_P_TCPRCVBUFFERSIZE;
#endif /* OPCUA_P_SOCKET_SETTCPRCVBUFFERSIZE || OPCUA_P_SOCKET_SETTCPSNDBUFFERSIZE */
if(a_RawSocket == (OpcUa_RawSocket)OPCUA_P_SOCKET_INVALID)
{
return OpcUa_Null;
}
winSocketServer = (SOCKET)a_RawSocket;
cli_size = sizeof(cli);
OpcUa_MemSet(&cli, 0, cli_size);
winSocketClient = accept(winSocketServer,(struct sockaddr*) &cli, &cli_size);
if(winSocketClient == OPCUA_P_SOCKET_INVALID)
{
/* accept failed */
goto Error;
}
if(a_pPort != OpcUa_Null)
{
*a_pPort = ntohs((OpcUa_UInt16)((struct sockaddr_in*)(&cli))->sin_port);
}
if(a_pAddress != OpcUa_Null)
{
*a_pAddress = ((struct sockaddr_in*)(&cli))->sin_addr.s_addr;
}
if(a_bNagleOff)
{
/* set socket options */
if(OPCUA_P_SOCKET_SOCKETERROR == setsockopt(winSocketClient, IPPROTO_TCP, TCP_NODELAY, (const char*)&iFlag, sizeof(int)))
{
goto Error;
}
}
if(a_bKeepAliveOn)
{
/* set socket options */
if(OPCUA_P_SOCKET_SOCKETERROR == setsockopt( winSocketClient, IPPROTO_TCP, SO_KEEPALIVE, (const char*)&iFlag, sizeof(int)))
{
goto Error;
}
}
#if OPCUA_P_SOCKET_SETTCPRCVBUFFERSIZE
iBufferSize = OPCUA_P_TCPRCVBUFFERSIZE;
if(OPCUA_P_SOCKET_SOCKETERROR == setsockopt(winSocketClient, SOL_SOCKET, SO_RCVBUF, (const char*)&iBufferSize, sizeof(int)))
{
/*int result = OpcUa_P_RawSocket_GetLastError((OpcUa_RawSocket)winSocketClient);*/
goto Error;
}
#endif /* OPCUA_P_SOCKET_SETTCPRCVBUFFERSIZE */
#if OPCUA_P_SOCKET_SETTCPSNDBUFFERSIZE
iBufferSize = OPCUA_P_TCPSNDBUFFERSIZE;
if(OPCUA_P_SOCKET_SOCKETERROR == setsockopt(winSocketClient, SOL_SOCKET, SO_SNDBUF, (const char*)&iBufferSize, sizeof(int)))
{
/*int result = OpcUa_P_RawSocket_GetLastError((OpcUa_RawSocket)winSocketClient);*/
goto Error;
}
#endif /* OPCUA_P_SOCKET_SETTCPSNDBUFFERSIZE */
return (OpcUa_RawSocket)winSocketClient;
Error:
if(winSocketClient == OPCUA_P_SOCKET_INVALID)
{
OpcUa_P_RawSocket_Close((OpcUa_RawSocket)winSocketClient);
}
return (OpcUa_RawSocket)OPCUA_P_SOCKET_INVALID;
}
/*============================================================================
* 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;
}
/*============================================================================
* 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;
}
/*============================================================================
* Create a new socket manager or initialize the global one (OpcUa_Null first).
*===========================================================================*/
OpcUa_StatusCode OPCUA_DLLCALL OpcUa_P_SocketManager_Create(OpcUa_SocketManager* a_pSocketManager,
OpcUa_UInt32 a_nSockets,
OpcUa_UInt32 a_nFlags)
{
OpcUa_InternalSocketManager* pInternalSocketManager = OpcUa_Null;
OpcUa_InitializeStatus(OpcUa_Module_Socket, "SocketManager_Create");
if(a_nFlags & 0xFFFFFFF8)
{
return OpcUa_BadInvalidArgument;
}
if(a_nSockets > OPCUA_P_SOCKETMANAGER_NUMBEROFSOCKETS)
{
return OpcUa_BadInvalidArgument;
}
/* set number of socket to maximum */
if(a_nSockets == 0)
{
a_nSockets = OPCUA_P_SOCKETMANAGER_NUMBEROFSOCKETS;
}
a_nSockets += 1; /* add signal socket to requested sockets */
#if !OPCUA_MULTITHREADED
if(a_pSocketManager == OpcUa_Null && OpcUa_Socket_g_SocketManager == OpcUa_Null)
{
a_pSocketManager = &OpcUa_Socket_g_SocketManager;
}
#endif
if(a_pSocketManager == OpcUa_Null)
{
return OpcUa_BadInvalidArgument;
}
*a_pSocketManager = OpcUa_SocketManager_Alloc();
OpcUa_GotoErrorIfAllocFailed(*a_pSocketManager);
pInternalSocketManager = (OpcUa_InternalSocketManager*)*a_pSocketManager;
OpcUa_SocketManager_Initialize(pInternalSocketManager);
#if OPCUA_USE_SYNCHRONISATION
uStatus = OpcUa_P_Mutex_Create(&pInternalSocketManager->pMutex);
OpcUa_GotoErrorIfBad(uStatus);
#endif /* OPCUA_USE_SYNCHRONISATION */
/* preallocate socket structures for all possible sockets (maxsockets) */
uStatus = OpcUa_SocketManager_CreateSockets((OpcUa_SocketManager)pInternalSocketManager, a_nSockets);
OpcUa_GotoErrorIfBad(uStatus);
pInternalSocketManager->uintLastExternalEvent = OPCUA_SOCKET_NO_EVENT;
/* set the behaviour flags */
if((a_nFlags & OPCUA_SOCKET_SPAWN_THREAD_ON_ACCEPT) != OPCUA_SOCKET_NO_FLAG)
{
pInternalSocketManager->Flags.bSpawnThreadOnAccept = OpcUa_True;
}
if((a_nFlags & OPCUA_SOCKET_REJECT_ON_NO_THREAD) != OPCUA_SOCKET_NO_FLAG)
{
pInternalSocketManager->Flags.bRejectOnThreadFail = OpcUa_True;
}
if((a_nFlags & OPCUA_SOCKET_DONT_CLOSE_ON_EXCEPT) != OPCUA_SOCKET_NO_FLAG)
{
pInternalSocketManager->Flags.bDontCloseOnExcept = OpcUa_True;
}
uStatus = OpcUa_P_SocketManager_NewSignalSocket(pInternalSocketManager);
OpcUa_GotoErrorIfBad(uStatus);
#if OPCUA_MULTITHREADED
if (pInternalSocketManager->Flags.bSpawnThreadOnAccept)
{
/* create a semaphore with no free resources for which a host can wait to be signalled. */
uStatus = OpcUa_P_Semaphore_Create(&pInternalSocketManager->pStartupSemaphore, 0, 1);
OpcUa_GotoErrorIfBad(uStatus);
pInternalSocketManager->pSocketManagers = OpcUa_P_Memory_Alloc(sizeof(OpcUa_InternalSocketManager*) * OPCUA_SOCKET_MAXMANAGERS);
OpcUa_GotoErrorIfAllocFailed(pInternalSocketManager->pSocketManagers);
OpcUa_MemSet(pInternalSocketManager->pSocketManagers, 0, sizeof(OpcUa_InternalSocketManager*) * OPCUA_SOCKET_MAXMANAGERS);
}
/* if multithreaded, create and start the server thread if the list is not the global list. */
uStatus = OpcUa_P_Thread_Create(&pInternalSocketManager->pThread); /* make raw thread */
OpcUa_GotoErrorIfBad(uStatus);
uStatus = OpcUa_P_Thread_Start( pInternalSocketManager->pThread,
OpcUa_P_SocketManager_ServerLoopThread,
(OpcUa_Void*)pInternalSocketManager);
OpcUa_GotoErrorIfBad(uStatus);
#endif /* OPCUA_MULTITHREADED */
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
if(pInternalSocketManager != OpcUa_Null)
{
#if OPCUA_MULTITHREADED
if(pInternalSocketManager->pThread != OpcUa_Null)
{
OpcUa_P_Thread_Delete(&pInternalSocketManager->pThread);
}
if(pInternalSocketManager->pSocketManagers != OpcUa_Null)
{
OpcUa_P_Memory_Free(pInternalSocketManager->pSocketManagers);
}
if(pInternalSocketManager->pStartupSemaphore != OpcUa_Null)
{
OpcUa_P_Semaphore_Delete(&pInternalSocketManager->pStartupSemaphore);
}
#endif /* OPCUA_MULTITHREADED */
if(pInternalSocketManager->pCookie != (OpcUa_RawSocket)OPCUA_P_SOCKET_INVALID)
{
OpcUa_P_RawSocket_Close(pInternalSocketManager->pCookie);
}
if(pInternalSocketManager->pSockets != OpcUa_Null)
{
if(pInternalSocketManager->pSockets[0].rawSocket != (OpcUa_RawSocket)OPCUA_P_SOCKET_INVALID)
{
OpcUa_P_RawSocket_Close(pInternalSocketManager->pSockets[0].rawSocket);
}
OpcUa_P_Memory_Free(pInternalSocketManager->pSockets);
}
#if OPCUA_USE_SYNCHRONISATION
if(pInternalSocketManager->pMutex != OpcUa_Null)
{
OpcUa_P_Mutex_Delete(&pInternalSocketManager->pMutex);
}
#endif /* OPCUA_USE_SYNCHRONISATION */
OpcUa_P_Memory_Free(pInternalSocketManager);
}
*a_pSocketManager = OpcUa_Null;
OpcUa_FinishErrorHandling;
}
