added test functions for string encoding/decoding

OPCUAServer/.cproject

@@ -499,6 +499,7 @@
 			</target>
 			<target name="Server" path="src" targetID="org.eclipse.cdt.build.MakeTargetBuilder">
 				<buildCommand>make</buildCommand>
+				<buildArguments/>
 				<buildTarget>Server</buildTarget>
 				<stopOnError>true</stopOnError>
 				<useDefaultCommand>true</useDefaultCommand>

OPCUAServer/src/Makefile.am

@@ -23,6 +23,8 @@ libopen62541_la_SOURCES = opcua_builtInDatatypes.c\
 						opcua_transportLayer.c\
 						opcua_encodingLayer.c\
 						opcua_secureChannelLayer.c\
+						opcua_memory.c\
+						opcua_time.c\
 						opcua_builtInDatatypes.h\
 						opcua_binaryEncDec.h\
 						opcua_transportLayer.h\
@@ -31,7 +33,9 @@ libopen62541_la_SOURCES = opcua_builtInDatatypes.c\
 						opcua_connectionHelper.h\
 						opcua_encodingLayer.h\
 						opcua_secureChannelLayer.h\
-						tcp_layer.h
+						opcua_memory.h\
+						opcua_time.h\
+						tcp_layer.h						
 
 #bin_PROGRAMS= $(top_builddir)/bin/open62541.out
 #__top_builddir__bin_libOpen62541_out_SOURCES = opcuaServer.c

OPCUAServer/src/opcua_binaryEncDec.c

@@ -9,6 +9,11 @@
 #include "opcua_types.h"
 #include <stdio.h>
 #include <stdlib.h>
+
+#include "opcua_builtInDatatypes.h"
+#include "opcua_advancedDatatypes.h"
+
+
 Byte decodeByte(const char *buf, Int32 *pos)
 {
 	*pos = (*pos) + 1;
@@ -80,13 +85,14 @@ UInt32 decodeUInt32(const char* buf, Int32 *pos)
 	return t1 + t2 + t3 + t4;
 }
 
-void encodeUInt32(UInt32 value, char *dstBuf, Int32 *pos)
+void encodeUInt32(UInt32 value, Int32 *pos,char *dstBuf)
 {
 	memcpy(&(dstBuf[*pos]), &value, sizeof(value));
 	pos += 4;
 
 }
 
+
 Int64 decodeInt64(const char* buf, Int32 *pos)
 {
 
@@ -124,6 +130,23 @@ Int32 decodeUAString(const char* buf, Int32 *pos, UA_String *dstUAString)
 	*pos += dstUAString->Length;
 	return 0;
 }
+Int32 encodeUAString(UA_String *string, Int32 *pos, char *dstBuf)
+{
+	if(string->Length > 0)
+	{
+		memcpy(&(dstBuf[*pos]),&(string->Length),sizeof(Int32));
+		*pos += sizeof(Int32);
+		memcpy(&(dstBuf[*pos]),string->Data, string->Length);
+		*pos += string->Length;
+	}
+	else
+	{
+		int lengthNULL = 0xFFFFFFFF;
+		memcpy(&(dstBuf[*pos]),&lengthNULL,sizeof(Int32));
+		*pos += sizeof(Int32);
+	}
+	return 0;
+}
 
 Int32 decodeUAGuid(const char *buf, Int32 *pos, UA_Guid *dstGUID)
 {
@@ -270,6 +293,8 @@ Int32 decodeToDiagnosticInfo(char* buf, Int32 *pos,
 	*pos += 1;
 	return 0;
 }
+
+
 Int32 diagnosticInfo_calcSize(UA_DiagnosticInfo *diagnosticInfo)
 {
 	Int32 minimumLength = 1;
@@ -346,12 +371,25 @@ Int32 decodeRequestHeader(const AD_RawMessage *srcRaw, Int32 *pos,
  * Page: 133
  */
 /** \copydoc encodeResponseHeader */
-/*Int32 encodeResponseHeader(const T_ResponseHeader *responseHeader, Int32 *pos,
+Int32 encodeResponseHeader(const T_ResponseHeader *responseHeader, Int32 *pos,
 		AD_RawMessage *dstBuf)
 {
 
 	return 0;
-}*/
+}
+
+
+Int32 UA_String_calcSize(UA_String *string)
+{
+	if(string->Length>0)
+	{
+		return string->Length + sizeof(string->Length);
+	}
+	else
+	{
+		return sizeof(Int32);
+	}
+}
 Int32 nodeId_calcSize(UA_NodeId *nodeId)
 {
 	Int32 length = 0;

OPCUAServer/src/opcua_binaryEncDec.h

@@ -121,7 +121,7 @@ Int32 decodeUAString(const char* buf, Int32 *pos, UA_String *dstUAString);
  * @param dstBuf
  * @param pos
  */
-void encodeUInt32(UInt32 value, char *dstBuf, Int32 *pos);
+void encodeUInt32(UInt32 value, Int32 *pos, char *dstBuf);
 
 
 /**
@@ -178,4 +178,7 @@ Int32 diagnosticInfo_calcSize(UA_DiagnosticInfo *diagnosticInfo);
  * @return length of the binary encoded data
  */
 Int32 extensionObject_calcSize(UA_ExtensionObject *extensionObject);
+
+
+
 #endif /* OPCUA_BINARYENCDEC_NEU_H_ */

OPCUAServer/src/opcua_memory.c

@@ -5,7 +5,7 @@
  *      Author: opcua
  */
 
-
+#include "opcua_memory.h"
 void *opcua_malloc(size_t size)
 {
 	return malloc(size);

OPCUAServer/src/opcua_memory.h

@@ -7,7 +7,8 @@
 
 #ifndef OPCUA_MEMORY_H_
 #define OPCUA_MEMORY_H_
-
+#include <stdint.h>
+#include <stdlib.h>
 /**
  *
  * @param size

OPCUAServer/src/opcua_secureChannelLayer.c

@@ -11,15 +11,12 @@
 
 Int32 SL_openSecureChannelRequest_check(const UA_connection *connection, AD_RawMessage *secureChannelMessage)
 {
-	return 0;
+	return UA_NO_ERROR;
 }
-
-
-
 /*
  * respond the securechannel_open request
  */
-Int32 SL_secureChannel_ResponseHeader_form(UA_connection *connection, T_ResponseHeader *responseHeader)
+Int32 SL_secureChannel_ResponseHeader_get(const UA_connection *connection, T_ResponseHeader *responseHeader)
 {
 	responseHeader->timestamp = 0;//TODO getCurrentTime();
 	responseHeader->requestHandle = 0;
@@ -38,7 +35,7 @@ Int32 SL_secureChannel_ResponseHeader_form(UA_connection *connection, T_Response
 
 
 	responseHeader->requestHandle = 0;
-	return 0;
+	return UA_NO_ERROR;
 }
 
 /*
@@ -51,16 +48,38 @@ Int32 SL_secureChannel_open(const UA_connection *connection,
 		const SL_SequenceHeader *SequenceHeader)
 {
 
+	T_ResponseHeader responseHeader;
+	AD_RawMessage rawMessage;
+	Int32 position = 0;
+	SL_secureChannel_ResponseHeader_get(connection,&responseHeader);
+	Int32 size = responseHeader_calcSize(&responseHeader);
+	rawMessage.message = (char*)opcua_malloc(size);
 
+	encodeResponseHeader(&responseHeader, &position, &rawMessage);
 
+	rawMessage.length = position;
 
-	return 0;
-
+	return UA_NO_ERROR;
 }
 
-Int32 SL_openSecureChannel_responseMessage_getSize(SL_Response *response, Int32* sizeInOut)
+Int32 SL_openSecureChannel_responseMessage_get(UA_connection *connection,SL_Response *response, Int32* sizeInOut)
 {
 
+	response->ServerNonce.Length =0; // TODO set a valid value for the Server Nonce
+	response->ServerProtocolVersion = UA_PROTOCOL_VERSION; //
+	response->SecurityToken.createdAt = opcua_getTime(); //
+	response->SecurityToken.revisedLifetime = 300000; //TODO set Lifetime of Security Token
+	response->SecurityToken.secureChannelId = connection->secureLayer.UInt32_secureChannelId; //TODO set a valid value for secureChannel id
+	return UA_NO_ERROR;
+}
+
+Int32 SL_openSecureChannel_responseMessage_calcSize(SL_Response *response, Int32* sizeInOut)
+{
+	Int32 length = 0;
+	length += sizeof(response->SecurityToken);
+	length += UA_String_calcSize(response->ServerNonce);
+	length += sizeof(response->ServerProtocolVersion);
+	return length;
 }
 
 /*
@@ -89,16 +108,16 @@ void SL_receive(UA_connection *connection, AD_RawMessage *serviceMessage)
 	Int32 readPosition = 0;
 
 	//get the Secure Channel Message Header
-	SL_secureChannel_SCMHeader_get(connection,secureChannelMessage,
+	decodeSCMHeader(secureChannelMessage,
 			&readPosition, &SCM_Header);
 
 	//get the Secure Channel Asymmetric Algorithm Security Header
-	SL_secureChannel_AASHeader_get(connection, secureChannelMessage,
+	decodeAASHeader(secureChannelMessage,
 			&readPosition, &AAS_Header);
 
 	//get the Sequence Header
-	SL_secureChannel_SequenceHeader_get(connection,secureChannelMessage,
-			&readPosition,&SequenceHeader);
+	decodeSequenceHeader(secureChannelMessage,
+			&readPosition, &SequenceHeader);
 
 	//get Secure Channel Message
 	//SL_secureChannel_Message_get(connection, secureChannelMessage,
@@ -148,30 +167,66 @@ void SL_receive(UA_connection *connection, AD_RawMessage *serviceMessage)
 /*
  * get the secure channel message header
  */
-Int32 SL_secureChannel_SCMHeader_get(UA_connection *connection,
-	AD_RawMessage *rawMessage,Int32 *pos, SL_SecureConversationMessageHeader* SC_Header)
+Int32 decodeSCMHeader(AD_RawMessage *rawMessage,Int32 *pos,
+		SL_SecureConversationMessageHeader* SC_Header)
 {
 	SC_Header->MessageType = TL_getPacketType(rawMessage);
 	*pos += 3;//TL_MESSAGE_TYPE_LEN;
 	SC_Header->IsFinal = rawMessage->message[*pos];
 	SC_Header->MessageSize = decodeUInt32(rawMessage, *pos);
 	SC_Header->SecureChannelId = decodeUInt32(rawMessage, *pos);
-	return 0;
+	return UA_NO_ERROR;
+
+}
+Int32 encodeSCMHeader(SL_SecureConversationMessageHeader *SC_Header,
+		 Int32 *pos,AD_RawMessage *rawMessage)
+{
+	char *type = "ERR";
+	switch(SC_Header->MessageType)
+	{
+	case packetType_ACK:
+		type = "ACK";
+		break;
+	case packetType_CLO:
+		type = "CLO";
+		break;
+	case packetType_ERR:
+		type = "ERR";
+		break;
+	case packetType_HEL:
+		type = "HEL";
+		break;
+	case packetType_MSG:
+		type = "MSG";
+		break;
+	case packetType_OPN:
+		type = "OPN";
+		break;
+	default:
+		return UA_ERROR;
+	}
 
+	memcpy(&(rawMessage->message[*pos]), &type, 3);
+
+	return UA_NO_ERROR;
 }
-Int32 SL_secureChannel_SequenceHeader_get(UA_connection *connection,
-		AD_RawMessage *rawMessage, Int32 *pos,
+Int32 decodeSequenceHeader(AD_RawMessage *rawMessage, Int32 *pos,
 		SL_SequenceHeader *SequenceHeader)
 {
 	SequenceHeader->RequestId = decodeUInt32(rawMessage->message, pos);
 	SequenceHeader->SequenceNumber = decodeUInt32(rawMessage->message, pos);
-	return 0;
+	return UA_NO_ERROR;
+}
+Int32 encodeSequenceHeader(SL_SequenceHeader *sequenceHeader,Int32 *pos,
+		AD_RawMessage *dstRawMessage)
+{
+	encodeUInt32(sequenceHeader->SequenceNumber,pos,&dstRawMessage->message[*pos]);
+	return UA_NO_ERROR;
 }
 /*
  * get the asymmetric algorithm security header
  */
-Int32 SL_secureChannel_AASHeader_get(UA_connection *connection,
-	AD_RawMessage *rawMessage, Int32 *pos,
+Int32 decodeAASHeader(AD_RawMessage *rawMessage, Int32 *pos,
 	SL_AsymmetricAlgorithmSecurityHeader* AAS_Header)
 {
 	Int32 err = 0;
@@ -180,6 +235,15 @@ Int32 SL_secureChannel_AASHeader_get(UA_connection *connection,
 	err += decodeUAByteString(rawMessage->message,pos,AAS_Header->ReceiverThumbprint);
 	return err;
 }
+Int32 encodeAASHeader(SL_AsymmetricAlgorithmSecurityHeader *AAS_Header,
+		Int32 *pos, AD_RawMessage* dstRawMessage)
+{
+	encodeUAString(AAS_Header->SecurityPolicyUri,pos,&dstRawMessage->message[*pos]);
+	encodeUAString(AAS_Header->SenderCertificate,pos,&dstRawMessage->message[*pos]);
+	encodeUAString(AAS_Header->ReceiverThumbprint,pos,&dstRawMessage->message[*pos]);
+	return UA_NO_ERROR;
+}
+
 void SL_secureChannel_Footer_get()
 {
 

OPCUAServer/src/opcua_secureChannelLayer.h

@@ -16,7 +16,7 @@ static const Int32 SL_HEADER_LENGTH = 0;
 
 
 
-typedef struct _SL_OpenSecureChannelResponse
+typedef struct
 {
 	UInt32 ServerProtocolVersion;
 	SL_ChannelSecurityToken SecurityToken;
@@ -24,7 +24,7 @@ typedef struct _SL_OpenSecureChannelResponse
 }SL_Response;
 
 
-typedef struct _SL_SecureConversationMessageHeader
+typedef struct
 {
 	UInt32 MessageType;
 	Byte   IsFinal;
@@ -33,7 +33,7 @@ typedef struct _SL_SecureConversationMessageHeader
 }SL_SecureConversationMessageHeader;
 
 
-typedef struct _SL_AsymmetricAlgorithmSecurityHeader
+typedef struct
 {
 	UA_String SecurityPolicyUri;
 	UA_String SenderCertificate;
@@ -70,5 +70,67 @@ typedef struct _SL_ResponseHeader
     UA_ExtensionObject additionalHeader;
 }SL_ResponseHeader;
 */
+Int32 SL_openSecureChannel_responseMessage_get(UA_connection *connection,
+		SL_Response *response, Int32* sizeInOut);
+
+/**
+ *
+ * @param connection
+ * @param rawMessage
+ * @param pos
+ * @param SC_Header
+ * @return
+ */
+Int32 decodeSCMHeader(AD_RawMessage *rawMessage,Int32 *pos,
+		SL_SecureConversationMessageHeader* SC_Header);
+
+/**
+ *
+ * @param SC_Header
+ * @param pos
+ * @param rawMessage
+ * @return
+ */
+Int32 encodeSCMHeader(SL_SecureConversationMessageHeader *SC_Header,
+	 Int32 *pos,AD_RawMessage *rawMessage);
+
+/**
+ *
+ * @param rawMessage
+ * @param pos
+ * @param SequenceHeader
+ * @return
+ */
+Int32 decodeSequenceHeader(AD_RawMessage *rawMessage, Int32 *pos,
+		SL_SequenceHeader *sequenceHeader);
+/**
+ *
+ * @param sequenceHeader
+ * @param pos
+ * @param dstRawMessage
+ * @return
+ */
+Int32 encodeSequenceHeader(SL_SequenceHeader *sequenceHeader,Int32 *pos,
+		AD_RawMessage *dstRawMessage);
+/**
+ *
+ * @param rawMessage
+ * @param pos
+ * @param AAS_Header
+ * @return
+ */
+Int32 decodeAASHeader(AD_RawMessage *rawMessage, Int32 *pos,
+	SL_AsymmetricAlgorithmSecurityHeader* AAS_Header);
+
+/**
+ *
+ * @param AAS_Header
+ * @param pos
+ * @param dstRawMessage
+ * @return
+ */
+Int32 encodeAASHeader(SL_AsymmetricAlgorithmSecurityHeader *AAS_Header,
+		Int32 *pos, AD_RawMessage* dstRawMessage);
+
 
 #endif /* OPCUA_SECURECHANNELLAYER_H_ */

OPCUAServer/src/opcua_types.h

@@ -9,7 +9,10 @@
 #define OPCUA_TYPES_H_
 
 #include "opcua_builtInDatatypes.h"
+#define UA_PROTOCOL_VERSION 0
 
+#define UA_NO_ERROR 0
+#define UA_ERROR 1
 typedef enum _T_ApplicationType
 {
 	ApplicationType_SERVER_0,

OPCUAServer/tests/check_stack.c

@@ -121,6 +121,46 @@ START_TEST(encodeUInt16_test)
 END_TEST
 
 
+START_TEST(encodeUAString_test)
+{
+
+	Int32 pos = 0;
+	UA_String string;
+	Int32 l = 11;
+	char mem[11] = "ACPLT OPCUA";
+	char *dstBuf = (char*) malloc(sizeof(Int32)+l);
+	string.Data =  mem;
+	string.Length = 11;
+
+	encodeUAString(&string, &pos, dstBuf);
+
+	ck_assert_int_eq(dstBuf[0],11);
+	ck_assert_int_eq(dstBuf[0+sizeof(Int32)],'A');
+
+
+}
+END_TEST
+
+START_TEST(decodeUAString_test)
+{
+
+	Int32 pos = 0;
+	UA_String string;
+	Int32 l = 11;
+	char binString[15] = {11,0x00,0x00,0x00,'A','C','P','L','T',' ','U','A'};
+
+	char *dstBuf = (char*) malloc(l-sizeof(Int32));
+	string.Data = dstBuf;
+	string.Length = 0;
+	decodeUAString(binString, &pos, &string);
+
+
+	ck_assert_int_eq(string.Length,11);
+	ck_assert_int_eq(string.Data[3],'L');
+
+
+}
+END_TEST
 START_TEST(diagnosticInfo_calcSize_test)
 {
 
@@ -198,7 +238,7 @@ START_TEST(responseHeader_calcSize_test)
 
 }
 END_TEST
-Suite* TL_testSuite_getPacketType(void)
+Suite* testSuite_getPacketType(void)
 {
 	Suite *s = suite_create("getPacketType");
 	TCase *tc_core = tcase_create("Core");
@@ -206,7 +246,16 @@ Suite* TL_testSuite_getPacketType(void)
 	suite_add_tcase(s,tc_core);
 	return s;
 }
-Suite* TL_testSuite_decodeUInt16(void)
+
+Suite* testSuite_encodeByte(void)
+{
+	Suite *s = suite_create("encodeByte_test");
+	TCase *tc_core = tcase_create("Core");
+	tcase_add_test(tc_core, encodeByte_test);
+	suite_add_tcase(s,tc_core);
+	return s;
+}
+Suite* testSuite_decodeUInt16(void)
 {
 	Suite *s = suite_create("decodeUInt16_test");
 	TCase *tc_core = tcase_create("Core");
@@ -214,7 +263,7 @@ Suite* TL_testSuite_decodeUInt16(void)
 	suite_add_tcase(s,tc_core);
 	return s;
 }
-Suite* TL_testSuite_encodeUInt16(void)
+Suite* testSuite_encodeUInt16(void)
 {
 	Suite *s = suite_create("encodeUInt16_test");
 	TCase *tc_core = tcase_create("Core");
@@ -223,14 +272,25 @@ Suite* TL_testSuite_encodeUInt16(void)
 	return s;
 }
 
-Suite* TL_testSuite_encodeByte(void)
+
+
+Suite* testSuite_encodeUAString(void)
 {
-	Suite *s = suite_create("encodeByte_test");
+	Suite *s = suite_create("encodeUAString_test");
 	TCase *tc_core = tcase_create("Core");
-	tcase_add_test(tc_core, encodeByte_test);
+	tcase_add_test(tc_core, encodeUAString_test);
 	suite_add_tcase(s,tc_core);
 	return s;
 }
+Suite* testSuite_decodeUAString(void)
+{
+	Suite *s = suite_create("decodeUAString_test");
+	TCase *tc_core = tcase_create("Core");
+	tcase_add_test(tc_core, decodeUAString_test);
+	suite_add_tcase(s,tc_core);
+	return s;
+}
+
 
 /*
 Suite* TL_<TESTSUITENAME>(void)
@@ -242,7 +302,7 @@ Suite* TL_<TESTSUITENAME>(void)
 	return s;
 }
 */
-Suite* TL_testSuite_diagnosticInfo_calcSize()
+Suite* testSuite_diagnosticInfo_calcSize()
 {
 	Suite *s = suite_create("diagnosticInfo_calcSize");
 	TCase *tc_core = tcase_create("Core");
@@ -250,7 +310,7 @@ Suite* TL_testSuite_diagnosticInfo_calcSize()
 	suite_add_tcase(s,tc_core);
 	return s;
 }
-Suite* TL_testSuite_extensionObject_calcSize()
+Suite* testSuite_extensionObject_calcSize()
 {
 	Suite *s = suite_create("extensionObject_calcSize");
 	TCase *tc_core = tcase_create("Core");
@@ -258,7 +318,7 @@ Suite* TL_testSuite_extensionObject_calcSize()
 	suite_add_tcase(s,tc_core);
 	return s;
 }
-Suite* TL_testSuite_responseHeader_calcSize()
+Suite* testSuite_responseHeader_calcSize()
 {
 	Suite *s = suite_create("responseHeader_calcSize");
 	TCase *tc_core = tcase_create("Core");
@@ -270,48 +330,61 @@ int main (void)
 {
 	int number_failed = 0;
 
-	Suite *s = TL_testSuite_getPacketType();
+	Suite *s = testSuite_getPacketType();
 	SRunner *sr = srunner_create(s);
 	srunner_run_all(sr,CK_NORMAL);
 	number_failed = srunner_ntests_failed(sr);
 	srunner_free(sr);
 
-	s = TL_testSuite_decodeUInt16();
+	s = testSuite_decodeUInt16();
 	sr = srunner_create(s);
 	srunner_run_all(sr,CK_NORMAL);
 	number_failed += srunner_ntests_failed(sr);
 	srunner_free(sr);
 
-	s = TL_testSuite_encodeUInt16();
+	s = testSuite_encodeUInt16();
 	sr = srunner_create(s);
 	srunner_run_all(sr,CK_NORMAL);
 	number_failed += srunner_ntests_failed(sr);
 	srunner_free(sr);
 
-	s = TL_testSuite_encodeByte();
+	s = testSuite_encodeByte();
 	sr = srunner_create(s);
 	srunner_run_all(sr,CK_NORMAL);
 	number_failed += srunner_ntests_failed(sr);
 	srunner_free(sr);
 
-	s = TL_testSuite_diagnosticInfo_calcSize();
+	s = testSuite_encodeUAString();
 	sr = srunner_create(s);
 	srunner_run_all(sr,CK_NORMAL);
 	number_failed += srunner_ntests_failed(sr);
 	srunner_free(sr);
 
-	s = TL_testSuite_extensionObject_calcSize();
+	s = testSuite_decodeUAString();
 	sr = srunner_create(s);
 	srunner_run_all(sr,CK_NORMAL);
 	number_failed += srunner_ntests_failed(sr);
 	srunner_free(sr);
 
-	s = TL_testSuite_responseHeader_calcSize();
+	s = testSuite_diagnosticInfo_calcSize();
 	sr = srunner_create(s);
 	srunner_run_all(sr,CK_NORMAL);
 	number_failed += srunner_ntests_failed(sr);
 	srunner_free(sr);
 
+	s = testSuite_extensionObject_calcSize();
+	sr = srunner_create(s);
+	srunner_run_all(sr,CK_NORMAL);
+	number_failed += srunner_ntests_failed(sr);
+	srunner_free(sr);
+
+	s = testSuite_responseHeader_calcSize();
+	sr = srunner_create(s);
+	srunner_run_all(sr,CK_NORMAL);
+	number_failed += srunner_ntests_failed(sr);
+	srunner_free(sr);
+
+
 	/* <TESTSUITE_TEMPLATE>
 	s =  <TESTSUITENAME>;
 	sr = srunner_create(s);