changes to generate_builtin.py (capitalizing all enum members)

removed bug in printing function
... code still causing segfault as a openSecureChannel Packet is processed

Makefile.am

@@ -2,7 +2,7 @@
 if DEBUG
 AM_CFLAGS = -g -O0 -std=c99 -pedantic -pipe -fPIC -fno-exceptions -fstack-protector -Wl,-z,relro -Wl,-z,now -fvisibility=hidden -W -Wall -Wno-unused-parameter -Wno-unused-function -Wno-unused-label -Wpointer-arith -Wformat -Wreturn-type -Wsign-compare -Wmultichar -Wformat-nonliteral -Winit-self -Wuninitialized -Wno-deprecated -Wformat-security
 else
-AM_CFLAGS = -O2 -std=c99 -pedantic -pipe -fPIC -fno-exceptions -fstack-protector -Wl,-z,relro -Wl,-z,now -fvisibility=hidden -W -Wall -Wno-unused-parameter -Wno-unused-function -Wno-unused-label -Wpointer-arith -Wformat -Wreturn-type -Wsign-compare -Wmultichar -Wformat-nonliteral -Winit-self -Wuninitialized -Wno-deprecated -Wformat-security
+AM_CFLAGS = -g -O2 -std=c99 -pedantic -pipe -fPIC -fno-exceptions -fstack-protector -Wl,-z,relro -Wl,-z,now -fvisibility=hidden -W -Wall -Wno-unused-parameter -Wno-unused-function -Wno-unused-label -Wpointer-arith -Wformat -Wreturn-type -Wsign-compare -Wmultichar -Wformat-nonliteral -Winit-self -Wuninitialized -Wno-deprecated -Wformat-security
 endif
 
 export GLOBAL_AM_CFLAGS = $(AM_CFLAGS)

include/opcua_basictypes.h

@@ -242,9 +242,9 @@ UA_TYPE_METHOD_PROTOTYPES(UA_ExtensionObject)
 
 enum UA_ExtensionObject_EncodingMaskType_enum
 {
-	UA_ExtensionObject_NoBodyIsEncoded = 	0x00,
-	UA_ExtensionObject_BodyIsByteString = 	0x01,
-	UA_ExtensionObject_BodyIsXml = 	0x02
+	UA_EXTENSIONOBJECT_NOBODYISENCODED = 	0x00,
+	UA_EXTENSIONOBJECT_BODYISBYTESTRING = 	0x01,
+	UA_EXTENSIONOBJECT_BODYISXML = 	0x02
 };
 
 /* QualifiedNameBinaryEncoding - Part: 6, Chapter: 5.2.2.13, Page: 20 */
@@ -270,17 +270,17 @@ UA_TYPE_METHOD_PROTOTYPES(UA_DataValue)
 /** 62541-6, §5.2.2.17, Table 15 */
 enum UA_DataValue_EncodingMaskType_enum
 {
-	UA_DataValue_variant = 	0x01,
-	UA_DataValue_statusCode = 	0x02,
-	UA_DataValue_sourceTimestamp = 	0x04,
-	UA_DataValue_serverTimestamp = 	0x08,
-	UA_DataValue_sourcePicoseconds = 	0x10,
-	UA_DataValue_serverPicoseconds = 	0x20
+	UA_DATAVALUE_VARIANT = 	0x01,
+	UA_DATAVALUE_STATUSCODE = 	0x02,
+	UA_DATAVALUE_SOURCETIMESTAMP = 	0x04,
+	UA_DATAVALUE_SERVERTIMPSTAMP = 	0x08,
+	UA_DATAVALUE_SOURCEPICOSECONDS = 	0x10,
+	UA_DATAVALUE_SERVERPICOSECONDS = 	0x20
 };
 
 /* DiagnosticInfo - Part: 6, Chapter: 5.2.2.12, Page: 20 */
 typedef struct T_UA_DiagnosticInfo {
-	UA_Byte encodingMask; //Type of the Enum UA_DiagnosticInfoEncodingMaskType
+	UA_Byte encodingMask; //Type of the Enum UA_DIAGNOSTICINFO_ENCODINGMASKTYPE
 	UA_Int32 symbolicId;
 	UA_Int32 namespaceUri;
 	UA_Int32 localizedText;
@@ -291,15 +291,15 @@ typedef struct T_UA_DiagnosticInfo {
 } UA_DiagnosticInfo;
 UA_TYPE_METHOD_PROTOTYPES(UA_DiagnosticInfo)
 
-enum UA_DiagnosticInfoEncodingMaskType_enum
+enum UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_enum
 {
-	UA_DiagnosticInfoEncodingMaskType_SymbolicId = 			0x01,
-	UA_DiagnosticInfoEncodingMaskType_Namespace = 			0x02,
-	UA_DiagnosticInfoEncodingMaskType_LocalizedText = 		0x04,
-	UA_DiagnosticInfoEncodingMaskType_Locale = 				0x08,
-	UA_DiagnosticInfoEncodingMaskType_AdditionalInfo = 		0x10,
-	UA_DiagnosticInfoEncodingMaskType_InnerStatusCode = 	0x20,
-	UA_DiagnosticInfoEncodingMaskType_InnerDiagnosticInfo = 0x40
+	UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_SYMBOLICID = 			0x01,
+	UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_NAMESPACE = 			0x02,
+	UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_LOCALIZEDTEXT = 		0x04,
+	UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_LOCALE = 				0x08,
+	UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_ADDITIONALINFO = 		0x10,
+	UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_INNERSTATUSCODE = 	0x20,
+	UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_INNERDIAGNOSTICINFO = 0x40
 };
 
 #endif /* OPCUA_BASICTYPES_H_ */

src/Makefile.am

@@ -1,3 +1,7 @@
+#optimization levels depending on debug
+AM_CFLAGS = $(GLOBAL_AM_CFLAGS) -I$(top_builddir)/include
+
+
 TOOL_DIR = ../tool
 opcua.c: $(TOOL_DIR)/opcua.c
 	cp $< $@
@@ -37,7 +41,6 @@ libopen62541_la_SOURCES = include/opcua.h\
 						tcp_layer.h\
 						util/UA_list.c\
 						util/UA_indexedList.c
-libopen62541_la_CFLAGS = -I $(top_builddir)/include
 
 #bin_PROGRAMS= $(top_builddir)/bin/open62541.out
 #__top_builddir__bin_libOpen62541_out_SOURCES = opcuaServer.c
@@ -69,5 +72,3 @@ all-local: convenience-link
 
 clean-local: clean-convenience-link
 
-#optimization levels depending on debug
-AM_CFLAGS = $(GLOBAL_AM_CFLAGS)

src/opcua_basictypes.c

@@ -173,10 +173,10 @@ UA_Int32 UA_UInt32_encode(UA_UInt32 const * src, UA_Int32* pos, char *dst) {
 	return UA_SUCCESS;
 }
 UA_Int32 UA_UInt32_decode(char const * src, UA_Int32* pos, UA_UInt32 *dst) {
-	UA_UInt32 t1 = (UA_UInt32) src[(*pos)++];
-	UA_UInt32 t2 = (UA_UInt32) src[(*pos)++] << 8;
-	UA_UInt32 t3 = (UA_UInt32) src[(*pos)++] << 16;
-	UA_UInt32 t4 = (UA_UInt32) src[(*pos)++] << 24;
+	UA_UInt32 t1 = (UA_UInt32)((UA_Byte)(src[(*pos)++] & 0xFF));
+	UA_UInt32 t2 = (UA_UInt32)((UA_Byte)(src[(*pos)++]& 0xFF) << 8);
+	UA_UInt32 t3 = (UA_UInt32)((UA_Byte)(src[(*pos)++]& 0xFF) << 16);
+	UA_UInt32 t4 = (UA_UInt32)((UA_Byte)(src[(*pos)++]& 0xFF) << 24);
 	*dst = t1 + t2 + t3 + t4;
 	return UA_SUCCESS;
 }
@@ -327,8 +327,13 @@ UA_Int32 UA_String_compare(UA_String* string1, UA_String* string2) {
 	return retval;
 }
 void UA_String_printf(char* label, UA_String* string) {
-	printf("%s {Length=%d, Data=%.*s}\n", label, string->length, string->length,
+	if(string->data)
+	{
+		printf("%s {Length=%d, Data=%.*s}\n", label, string->length,
 			(char*) string->data);
+	} else {
+		printf("%s {Length=%d, Data=(NULL)}\n", label, string->length);
+	}
 }
 void UA_String_printx(char* label, UA_String* string) {
 	int i;
@@ -367,13 +372,13 @@ UA_Int32 UA_ByteString_compare(UA_ByteString *string1, UA_ByteString *string2) {
 	return UA_String_compare((UA_String*) string1, (UA_String*) string2);
 }
 void UA_ByteString_printf(char* label, UA_ByteString* string) {
-	return UA_String_printf(label, (UA_String*) string);
+	UA_String_printf(label, (UA_String*) string);
 }
 void UA_ByteString_printx(char* label, UA_String* string) {
-	return UA_String_printx(label, (UA_String*) string);
+	UA_String_printx(label, (UA_String*) string);
 }
 void UA_ByteString_printx_hex(char* label, UA_String* string) {
-	return UA_String_printx_hex(label, (UA_String*) string);
+	UA_String_printx_hex(label, (UA_String*) string);
 }
 
 
@@ -467,22 +472,22 @@ UA_Int32 UA_NodeId_calcSize(UA_NodeId const *p) {
 		length = sizeof(UA_NodeId);
 	} else {
 		switch (p->encodingByte) {
-		case UA_NodeIdType_TwoByte:
+		case UA_NODEIDTYPE_TWOBYTE:
 			length += 2 * sizeof(UA_Byte);
 			break;
-		case UA_NodeIdType_FourByte:
+		case UA_NODEIDTYPE_FOURBYTE:
 			length += 4 * sizeof(UA_Byte);
 			break;
-		case UA_NodeIdType_Numeric:
+		case UA_NODEIDTYPE_NUMERIC:
 			length += sizeof(UA_Byte) + sizeof(UA_UInt16) + sizeof(UA_UInt32);
 			break;
-		case UA_NodeIdType_String:
+		case UA_NODEIDTYPE_STRING:
 			length += sizeof(UA_Byte) + sizeof(UA_UInt16) + UA_String_calcSize(&(p->identifier.string));
 			break;
-		case UA_NodeIdType_Guid:
+		case UA_NODEIDTYPE_GUID:
 			length += sizeof(UA_Byte) + sizeof(UA_UInt16) + UA_Guid_calcSize(&(p->identifier.guid));
 			break;
-		case UA_NodeIdType_ByteString:
+		case UA_NODEIDTYPE_BYTESTRING:
 			length += sizeof(UA_Byte) + sizeof(UA_UInt16) + UA_ByteString_calcSize(&(p->identifier.byteString));
 			break;
 		default:
@@ -499,29 +504,29 @@ UA_Int32 UA_NodeId_encode(UA_NodeId const * src, UA_Int32* pos, char *dst) {
 	int retval = UA_SUCCESS;
 	retval |= UA_Byte_encode(&(src->encodingByte),pos,dst);
 	switch (src->encodingByte) {
-	case UA_NodeIdType_TwoByte:
+	case UA_NODEIDTYPE_TWOBYTE:
 		srcByte = src->identifier.numeric;
 		retval |= UA_Byte_encode(&srcByte,pos,dst);
 		break;
-	case UA_NodeIdType_FourByte:
+	case UA_NODEIDTYPE_FOURBYTE:
 		srcByte = src->namespace;
 		srcUInt16 = src->identifier.numeric;
 		retval |= UA_Byte_encode(&srcByte,pos,dst);
 		retval |= UA_UInt16_encode(&srcUInt16,pos,dst);
 		break;
-	case UA_NodeIdType_Numeric:
+	case UA_NODEIDTYPE_NUMERIC:
 		retval |= UA_UInt16_encode(&(src->namespace), pos, dst);
 		retval |= UA_UInt32_encode(&(src->identifier.numeric), pos, dst);
 		break;
-	case UA_NodeIdType_String:
+	case UA_NODEIDTYPE_STRING:
 		retval |= UA_UInt16_encode(&(src->namespace), pos, dst);
 		retval |= UA_String_encode(&(src->identifier.string), pos, dst);
 		break;
-	case UA_NodeIdType_Guid:
+	case UA_NODEIDTYPE_GUID:
 		retval |= UA_UInt16_encode(&(src->namespace), pos, dst);
 		retval |= UA_Guid_encode(&(src->identifier.guid), pos, dst);
 		break;
-	case UA_NodeIdType_ByteString:
+	case UA_NODEIDTYPE_BYTESTRING:
 		retval |= UA_UInt16_encode(&(src->namespace), pos, dst);
 		retval |= UA_ByteString_encode(&(src->identifier.byteString), pos, dst);
 		break;
@@ -536,30 +541,30 @@ UA_Int32 UA_NodeId_decode(char const * src, UA_Int32* pos, UA_NodeId *dst) {
 
 	retval |= UA_Byte_decode(src,pos,&(dst->encodingByte));
 	switch (dst->encodingByte) {
-	case UA_NodeIdType_TwoByte: // Table 7
+	case UA_NODEIDTYPE_TWOBYTE: // Table 7
 		retval |=UA_Byte_decode(src, pos, &dstByte);
 		dst->identifier.numeric = dstByte;
 		dst->namespace = 0; // default namespace
 		break;
-	case UA_NodeIdType_FourByte: // Table 8
+	case UA_NODEIDTYPE_FOURBYTE: // Table 8
 		retval |=UA_Byte_decode(src, pos, &dstByte);
 		dst->namespace= dstByte;
 		retval |=UA_UInt16_decode(src, pos, &dstUInt16);
 		dst->identifier.numeric = dstUInt16;
 		break;
-	case UA_NodeIdType_Numeric: // Table 6, first entry
+	case UA_NODEIDTYPE_NUMERIC: // Table 6, first entry
 		retval |=UA_UInt16_decode(src,pos,&(dst->namespace));
 		retval |=UA_UInt32_decode(src,pos,&(dst->identifier.numeric));
 		break;
-	case UA_NodeIdType_String: // Table 6, second entry
+	case UA_NODEIDTYPE_STRING: // Table 6, second entry
 		retval |=UA_UInt16_decode(src,pos,&(dst->namespace));
 		retval |=UA_String_decode(src,pos,&(dst->identifier.string));
 		break;
-	case UA_NodeIdType_Guid: // Table 6, third entry
+	case UA_NODEIDTYPE_GUID: // Table 6, third entry
 		retval |=UA_UInt16_decode(src,pos,&(dst->namespace));
 		retval |=UA_Guid_decode(src,pos,&(dst->identifier.guid));
 		break;
-	case UA_NodeIdType_ByteString: // Table 6, "OPAQUE"
+	case UA_NODEIDTYPE_BYTESTRING: // Table 6, "OPAQUE"
 		retval |=UA_UInt16_decode(src,pos,&(dst->namespace));
 		retval |=UA_ByteString_decode(src,pos,&(dst->identifier.byteString));
 		break;
@@ -570,43 +575,48 @@ UA_TYPE_METHOD_DELETE_STRUCT(UA_NodeId)
 UA_Int32 UA_NodeId_deleteMembers(UA_NodeId* p) {
 	int retval = UA_SUCCESS;
 	switch (p->encodingByte) {
-	case UA_NodeIdType_TwoByte:
-	case UA_NodeIdType_FourByte:
-	case UA_NodeIdType_Numeric:
+	case UA_NODEIDTYPE_TWOBYTE:
+	case UA_NODEIDTYPE_FOURBYTE:
+	case UA_NODEIDTYPE_NUMERIC:
 		// nothing to do
 		break;
-	case UA_NodeIdType_String: // Table 6, second entry
+	case UA_NODEIDTYPE_STRING: // Table 6, second entry
 		retval |= UA_String_deleteMembers(&(p->identifier.string));
 		break;
-	case UA_NodeIdType_Guid: // Table 6, third entry
+	case UA_NODEIDTYPE_GUID: // Table 6, third entry
 		retval |= UA_Guid_deleteMembers(&(p->identifier.guid));
 		break;
-	case UA_NodeIdType_ByteString: // Table 6, "OPAQUE"
+	case UA_NODEIDTYPE_BYTESTRING: // Table 6, "OPAQUE"
 		retval |= UA_ByteString_deleteMembers(&(p->identifier.byteString));
 		break;
 	}
 	return retval;
 }
+
 void UA_NodeId_printf(char* label, UA_NodeId* node) {
-	printf("%s {encodingByte=%d, namespace=%d, ", label,
-			(int) node->encodingByte, (int) node->namespace);
+
+
+	printf("%s {encodingByte=%d, namespace=%d,", label,
+			(int)( node->encodingByte), (int) (node->namespace));
+
 	switch (node->encodingByte) {
-	case UA_NodeIdType_TwoByte:
-	case UA_NodeIdType_FourByte:
-	case UA_NodeIdType_Numeric:
-		printf("identifier=%d", node->identifier.numeric);
+
+	case UA_NODEIDTYPE_TWOBYTE:
+	case UA_NODEIDTYPE_FOURBYTE:
+	case UA_NODEIDTYPE_NUMERIC:
+		printf("identifier=%d\n", node->identifier.numeric);
 		break;
-	case UA_NodeIdType_String:
+	case UA_NODEIDTYPE_STRING:
 		printf("identifier={length=%d, data=%.*s}",
 				node->identifier.string.length, node->identifier.string.length,
 				(char*) (node->identifier.string.data));
 		break;
-	case UA_NodeIdType_ByteString:
+	case UA_NODEIDTYPE_BYTESTRING:
 		printf("identifier={Length=%d, data=%.*s}",
 				node->identifier.byteString.length, node->identifier.byteString.length,
 				(char*) (node->identifier.byteString.data));
 		break;
-	case UA_NodeIdType_Guid:
+	case UA_NODEIDTYPE_GUID:
 		printf(
 				"guid={data1=%d, data2=%d, data3=%d, data4={length=%d, data=%.*s}}",
 				node->identifier.guid.data1, node->identifier.guid.data2,
@@ -683,10 +693,10 @@ UA_Int32 UA_ExtensionObject_calcSize(UA_ExtensionObject const * p) {
 		length += UA_NodeId_calcSize(&(p->typeId));
 		length += sizeof(UA_Byte); //p->encoding
 		switch (p->encoding) {
-		case UA_ExtensionObject_BodyIsByteString:
+		case UA_EXTENSIONOBJECT_BODYISBYTESTRING:
 			length += UA_ByteString_calcSize(&(p->body));
 			break;
-		case UA_ExtensionObject_BodyIsXml:
+		case UA_EXTENSIONOBJECT_BODYISXML:
 			length += UA_XmlElement_calcSize((UA_XmlElement*)&(p->body));
 			break;
 		}
@@ -698,10 +708,10 @@ UA_Int32 UA_ExtensionObject_encode(UA_ExtensionObject const *src, UA_Int32* pos,
 	retval |= UA_NodeId_encode(&(src->typeId),pos,dst);
 	retval |= UA_Byte_encode(&(src->encoding),pos,dst);
 	switch (src->encoding) {
-	case UA_ExtensionObject_NoBodyIsEncoded:
+	case UA_EXTENSIONOBJECT_NOBODYISENCODED:
 		break;
-	case UA_ExtensionObject_BodyIsByteString:
-	case UA_ExtensionObject_BodyIsXml:
+	case UA_EXTENSIONOBJECT_BODYISBYTESTRING:
+	case UA_EXTENSIONOBJECT_BODYISXML:
 		retval |= UA_ByteString_encode(&(src->body),pos,dst);
 		break;
 	}
@@ -710,14 +720,14 @@ UA_Int32 UA_ExtensionObject_encode(UA_ExtensionObject const *src, UA_Int32* pos,
 UA_Int32 UA_ExtensionObject_decode(char const * src, UA_Int32 *pos,
 		UA_ExtensionObject *dst) {
 	UA_Int32 retval = UA_SUCCESS;
-	retval |= UA_NodeId_decode(src,pos,&(dst->typeId));
+ 	retval |= UA_NodeId_decode(src,pos,&(dst->typeId));
 	retval |= UA_Byte_decode(src,pos,&(dst->encoding));
 	retval |= UA_String_copy(&UA_String_null, (UA_String*) &(dst->body));
 	switch (dst->encoding) {
-	case UA_ExtensionObject_NoBodyIsEncoded:
+	case UA_EXTENSIONOBJECT_NOBODYISENCODED:
 		break;
-	case UA_ExtensionObject_BodyIsByteString:
-	case UA_ExtensionObject_BodyIsXml:
+	case UA_EXTENSIONOBJECT_BODYISBYTESTRING:
+	case UA_EXTENSIONOBJECT_BODYISXML:
 		retval |= UA_ByteString_decode(src,pos,&(dst->body));
 		break;
 	}
@@ -742,25 +752,25 @@ UA_Int32 UA_DiagnosticInfo_decode(char const * src, UA_Int32 *pos, UA_Diagnostic
 	for (i = 0; i < 7; i++) {
 		switch ( (0x01 << i) & dst->encodingMask)  {
 
-		case UA_DiagnosticInfoEncodingMaskType_SymbolicId:
+		case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_SYMBOLICID:
 			 retval |= UA_Int32_decode(src, pos, &(dst->symbolicId));
 			break;
-		case UA_DiagnosticInfoEncodingMaskType_Namespace:
+		case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_NAMESPACE:
 			retval |= UA_Int32_decode(src, pos, &(dst->namespaceUri));
 			break;
-		case UA_DiagnosticInfoEncodingMaskType_LocalizedText:
+		case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_LOCALIZEDTEXT:
 			retval |= UA_Int32_decode(src, pos, &(dst->localizedText));
 			break;
-		case UA_DiagnosticInfoEncodingMaskType_Locale:
+		case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_LOCALE:
 			retval |= UA_Int32_decode(src, pos, &(dst->locale));
 			break;
-		case UA_DiagnosticInfoEncodingMaskType_AdditionalInfo:
+		case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_ADDITIONALINFO:
 			retval |= UA_String_decode(src, pos, &(dst->additionalInfo));
 			break;
-		case UA_DiagnosticInfoEncodingMaskType_InnerStatusCode:
+		case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_INNERSTATUSCODE:
 			retval |= UA_StatusCode_decode(src, pos, &(dst->innerStatusCode));
 			break;
-		case UA_DiagnosticInfoEncodingMaskType_InnerDiagnosticInfo:
+		case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_INNERDIAGNOSTICINFO:
 			// innerDiagnosticInfo is a pointer to struct, therefore allocate
 			retval |= UA_alloc((void **) &(dst->innerDiagnosticInfo),UA_DiagnosticInfo_calcSize(UA_NULL));
 			retval |= UA_DiagnosticInfo_decode(src, pos, dst->innerDiagnosticInfo);
@@ -777,25 +787,25 @@ UA_Int32 UA_DiagnosticInfo_encode(UA_DiagnosticInfo const *src, UA_Int32 *pos, c
 	UA_Byte_encode(&(src->encodingMask), pos, dst);
 	for (i = 0; i < 7; i++) {
 		switch ( (0x01 << i) & src->encodingMask)  {
-		case UA_DiagnosticInfoEncodingMaskType_SymbolicId:
+		case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_SYMBOLICID:
 			retval |= UA_Int32_encode(&(src->symbolicId), pos, dst);
 			break;
-		case UA_DiagnosticInfoEncodingMaskType_Namespace:
+		case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_NAMESPACE:
 			retval |=  UA_Int32_encode( &(src->namespaceUri), pos, dst);
 			break;
-		case UA_DiagnosticInfoEncodingMaskType_LocalizedText:
+		case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_LOCALIZEDTEXT:
 			retval |= UA_Int32_encode(&(src->localizedText), pos, dst);
 			break;
-		case UA_DiagnosticInfoEncodingMaskType_Locale:
+		case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_LOCALE:
 			retval |= UA_Int32_encode(&(src->locale), pos, dst);
 			break;
-		case UA_DiagnosticInfoEncodingMaskType_AdditionalInfo:
+		case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_ADDITIONALINFO:
 			retval |= UA_String_encode(&(src->additionalInfo), pos, dst);
 			break;
-		case UA_DiagnosticInfoEncodingMaskType_InnerStatusCode:
+		case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_INNERSTATUSCODE:
 			retval |= UA_StatusCode_encode(&(src->innerStatusCode), pos, dst);
 			break;
-		case UA_DiagnosticInfoEncodingMaskType_InnerDiagnosticInfo:
+		case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_INNERDIAGNOSTICINFO:
 			retval |= UA_DiagnosticInfo_encode(src->innerDiagnosticInfo, pos, dst);
 			break;
 		}
@@ -813,26 +823,26 @@ UA_Int32 UA_DiagnosticInfo_calcSize(UA_DiagnosticInfo const * ptr) {
 		for (mask = 0x01; mask <= 0x40; mask *= 2) {
 			switch (mask & (ptr->encodingMask)) {
 
-			case UA_DiagnosticInfoEncodingMaskType_SymbolicId:
+			case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_SYMBOLICID:
 				//	puts("diagnosticInfo symbolic id");
 				length += sizeof(UA_Int32);
 				break;
-			case UA_DiagnosticInfoEncodingMaskType_Namespace:
+			case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_NAMESPACE:
 				length += sizeof(UA_Int32);
 				break;
-			case UA_DiagnosticInfoEncodingMaskType_LocalizedText:
+			case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_LOCALIZEDTEXT:
 				length += sizeof(UA_Int32);
 				break;
-			case UA_DiagnosticInfoEncodingMaskType_Locale:
+			case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_LOCALE:
 				length += sizeof(UA_Int32);
 				break;
-			case UA_DiagnosticInfoEncodingMaskType_AdditionalInfo:
+			case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_ADDITIONALINFO:
 				length += UA_String_calcSize(&(ptr->additionalInfo));
 				break;
-			case UA_DiagnosticInfoEncodingMaskType_InnerStatusCode:
+			case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_INNERSTATUSCODE:
 				length += sizeof(UA_StatusCode);
 				break;
-			case UA_DiagnosticInfoEncodingMaskType_InnerDiagnosticInfo:
+			case UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_INNERDIAGNOSTICINFO:
 				length += UA_DiagnosticInfo_calcSize(ptr->innerDiagnosticInfo);
 				break;
 			}
@@ -843,7 +853,7 @@ UA_Int32 UA_DiagnosticInfo_calcSize(UA_DiagnosticInfo const * ptr) {
 UA_TYPE_METHOD_DELETE_STRUCT(UA_DiagnosticInfo)
 UA_Int32 UA_DiagnosticInfo_deleteMembers(UA_DiagnosticInfo *p) {
 	UA_Int32 retval = UA_SUCCESS;
-	if (p->encodingMask & UA_DiagnosticInfoEncodingMaskType_InnerDiagnosticInfo) {
+	if (p->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_INNERDIAGNOSTICINFO) {
 		retval |= UA_DiagnosticInfo_deleteMembers(p->innerDiagnosticInfo);
 		retval |= UA_free(p->innerDiagnosticInfo);
 	}
@@ -1018,25 +1028,25 @@ UA_Int32 UA_Variant_decode(char const * src, UA_Int32 *pos, UA_Variant *dst) {
 UA_Int32 UA_DataValue_decode(char const * src, UA_Int32* pos, UA_DataValue* dst) {
 	UA_Int32 retval = UA_SUCCESS;
 	retval |= UA_Byte_decode(src,pos,&(dst->encodingMask));
-	if (dst->encodingMask & UA_DataValue_variant) {
+	if (dst->encodingMask & UA_DATAVALUE_VARIANT) {
 		retval |= UA_Variant_decode(src,pos,&(dst->value));
 	}
-	if (dst->encodingMask & UA_DataValue_statusCode) {
+	if (dst->encodingMask & UA_DATAVALUE_STATUSCODE) {
 		retval |= UA_StatusCode_decode(src,pos,&(dst->status));
 	}
-	if (dst->encodingMask & UA_DataValue_sourceTimestamp) {
+	if (dst->encodingMask & UA_DATAVALUE_SOURCETIMESTAMP) {
 		retval |= UA_DateTime_decode(src,pos,&(dst->sourceTimestamp));
 	}
-	if (dst->encodingMask & UA_DataValue_sourcePicoseconds) {
+	if (dst->encodingMask & UA_DATAVALUE_SOURCEPICOSECONDS) {
 		retval |= UA_Int16_decode(src,pos,&(dst->sourcePicoseconds));
 		if (dst->sourcePicoseconds > MAX_PICO_SECONDS) {
 			dst->sourcePicoseconds = MAX_PICO_SECONDS;
 		}
 	}
-	if (dst->encodingMask & UA_DataValue_serverTimestamp) {
+	if (dst->encodingMask & UA_DATAVALUE_SERVERTIMPSTAMP) {
 		retval |= UA_DateTime_decode(src,pos,&(dst->serverTimestamp));
 	}
-	if (dst->encodingMask & UA_DataValue_serverPicoseconds) {
+	if (dst->encodingMask & UA_DATAVALUE_SERVERPICOSECONDS) {
 		retval |= UA_Int16_decode(src,pos,&(dst->serverPicoseconds));
 		if (dst->serverPicoseconds > MAX_PICO_SECONDS) {
 			dst->serverPicoseconds = MAX_PICO_SECONDS;
@@ -1047,22 +1057,22 @@ UA_Int32 UA_DataValue_decode(char const * src, UA_Int32* pos, UA_DataValue* dst)
 UA_Int32 UA_DataValue_encode(UA_DataValue const * src, UA_Int32* pos, char *dst) {
 	UA_Int32 retval = UA_SUCCESS;
 	retval |= UA_Byte_encode(&(src->encodingMask),pos,dst);
-	if (src->encodingMask & UA_DataValue_variant) {
+	if (src->encodingMask & UA_DATAVALUE_VARIANT) {
 		retval |= UA_Variant_encode(&(src->value),pos,dst);
 	}
-	if (src->encodingMask & UA_DataValue_statusCode) {
+	if (src->encodingMask & UA_DATAVALUE_STATUSCODE) {
 		retval |= UA_StatusCode_encode(&(src->status),pos,dst);
 	}
-	if (src->encodingMask & UA_DataValue_sourceTimestamp) {
+	if (src->encodingMask & UA_DATAVALUE_SOURCETIMESTAMP) {
 		retval |= UA_DateTime_encode(&(src->sourceTimestamp),pos,dst);
 	}
-	if (src->encodingMask & UA_DataValue_sourcePicoseconds) {
+	if (src->encodingMask & UA_DATAVALUE_SOURCEPICOSECONDS) {
 		retval |= UA_Int16_encode(&(src->sourcePicoseconds),pos,dst);
 	}
-	if (src->encodingMask & UA_DataValue_serverTimestamp) {
+	if (src->encodingMask & UA_DATAVALUE_SERVERTIMPSTAMP) {
 		retval |= UA_DateTime_encode(&(src->serverTimestamp),pos,dst);
 	}
-	if (src->encodingMask & UA_DataValue_serverPicoseconds) {
+	if (src->encodingMask & UA_DATAVALUE_SERVERPICOSECONDS) {
 		retval |= UA_Int16_encode(&(src->serverPicoseconds),pos,dst);
 	}
 	return retval;
@@ -1075,22 +1085,22 @@ UA_Int32 UA_DataValue_calcSize(UA_DataValue const * p) {
 		length = sizeof(UA_DataValue);
 	} else { // get decoding size
 		length = sizeof(UA_Byte);
-		if (p->encodingMask & UA_DataValue_variant) {
+		if (p->encodingMask & UA_DATAVALUE_VARIANT) {
 			length += UA_Variant_calcSize(&(p->value));
 		}
-		if (p->encodingMask & UA_DataValue_statusCode) {
+		if (p->encodingMask & UA_DATAVALUE_STATUSCODE) {
 			length += sizeof(UA_UInt32); //dataValue->status
 		}
-		if (p->encodingMask & UA_DataValue_sourceTimestamp) {
+		if (p->encodingMask & UA_DATAVALUE_SOURCETIMESTAMP) {
 			length += sizeof(UA_DateTime); //dataValue->sourceTimestamp
 		}
-		if (p->encodingMask & UA_DataValue_sourcePicoseconds) {
+		if (p->encodingMask & UA_DATAVALUE_SOURCEPICOSECONDS) {
 			length += sizeof(UA_Int64); //dataValue->sourcePicoseconds
 		}
-		if (p->encodingMask & UA_DataValue_serverTimestamp) {
+		if (p->encodingMask & UA_DATAVALUE_SERVERTIMPSTAMP) {
 			length += sizeof(UA_DateTime); //dataValue->serverTimestamp
 		}
-		if (p->encodingMask & UA_DataValue_serverPicoseconds) {
+		if (p->encodingMask & UA_DATAVALUE_SERVERPICOSECONDS) {
 			length += sizeof(UA_Int64); //dataValue->serverPicoseconds
 		}
 	}

src/opcua_linkedList.h

@@ -14,8 +14,8 @@
 
 typedef struct T_element
 {
-   AD_RawMessage *binaryData;
-   int(*serviceImplementation)(AD_RawMessage *data, AD_RawMessage *response);
+   UA_ByteString *binaryData;
+   int(*serviceImplementation)(UA_ByteString *data, UA_ByteString *response);
    struct T_linkedList * next;
 };
 

src/opcua_secureChannelLayer.c

@@ -43,7 +43,7 @@ UA_Int32 SL_initConnectionObject(UA_connection *connection)
 	connection->secureLayer.secureChannelId.data = NULL;
 	connection->secureLayer.secureChannelId.length = 0;
 
-	connection->secureLayer.securityMode = UA_SecurityMode_INVALID;
+	connection->secureLayer.securityMode = UA_SECURITYMODE_INVALID;
 	//TODO set a valid start secureChannelId number
 	connection->secureLayer.securityToken.secureChannelId = 25;
 
@@ -177,7 +177,7 @@ UA_Int32 SL_openSecureChannel(UA_connection *connection,
 	/*--------------type ----------------------*/
 
 	//Four Bytes Encoding
-	responseType.encodingByte = UA_NodeIdType_FourByte;
+	responseType.encodingByte = UA_NODEIDTYPE_FOURBYTE;
 	//openSecureChannelResponse = 449
 	responseType.identifier.numeric = 449;
 	responseType.namespace = 0;
@@ -267,7 +267,7 @@ UA_Int32 SL_openSecureChannel(UA_connection *connection,
 	//encode header
 	printf("SL_openSecureChannel - encoding response header \n");
 
-	UA_ResponseHeader_encode(&responseHeader, &pos, &response);
+	UA_ResponseHeader_encode(&responseHeader, &pos, &response.data);
 	printf("SL_openSecureChannel - response header encoded \n");
 
 	//encode message
@@ -332,7 +332,7 @@ UA_Int32 SL_processMessage(UA_connection *connection, UA_ByteString message) {
 	UA_NodeId_printf("SL_processMessage - serviceRequestType=",
 			&serviceRequestType);
 
-	if (serviceRequestType.encodingByte == UA_NodeIdType_FourByte
+	if (serviceRequestType.encodingByte == UA_NODEIDTYPE_FOURBYTE
 			&& serviceRequestType.identifier.numeric == 446) {
 		/* OpenSecureChannelService, defined in 62541-6 §6.4.4, Table 34.
 		 * Note that part 6 adds ClientProtocolVersion and ServerProtocolVersion
@@ -355,10 +355,10 @@ UA_Int32 SL_processMessage(UA_connection *connection, UA_ByteString message) {
 		// Req-1) RequestHeader requestHeader
 		UA_RequestHeader_decode(message.data, &pos, &requestHeader);
 		UA_String_printf("SL_processMessage - requestHeader.auditEntryId=",
-				&requestHeader.auditEntryId);
+				&(requestHeader.auditEntryId));
 		UA_NodeId_printf(
 				"SL_processMessage - requestHeader.authenticationToken=",
-				&requestHeader.authenticationToken);
+				&(requestHeader.authenticationToken));
 
 		// 	Req-2) UInt32 ClientProtocolVersion
 		UA_UInt32_decode(message.data, &pos,
@@ -378,7 +378,7 @@ UA_Int32 SL_processMessage(UA_connection *connection, UA_ByteString message) {
 		UA_Int32_decode(message.data, &pos, &requestType);
 		printf("SL_processMessage - requestType=%d\n", requestType);
 		switch (requestType) {
-		case securityToken_ISSUE:
+		case UA_SECURITYTOKEN_ISSUE:
 			if (connection->secureLayer.connectionState
 					== connectionState_ESTABLISHED) {
 				printf("SL_processMessage - multiply security token request");
@@ -389,7 +389,7 @@ UA_Int32 SL_processMessage(UA_connection *connection, UA_ByteString message) {
 					"SL_processMessage - TODO: create new token for a new SecureChannel\n");
 			//	SL_createNewToken(connection);
 			break;
-		case securityToken_RENEW:
+		case UA_SECURITYTOKEN_RENEW:
 			if (connection->secureLayer.connectionState
 					== connectionState_CLOSED) {
 				printf(
@@ -405,18 +405,18 @@ UA_Int32 SL_processMessage(UA_connection *connection, UA_ByteString message) {
 		UA_UInt32_decode(message.data, &pos, &securityMode);
 		printf("SL_processMessage - securityMode=%d\n", securityMode);
 		switch (securityMode) {
-		case UA_SecurityMode_INVALID:
+		case UA_SECURITYMODE_INVALID:
 			connection->secureLayer.remoteNonce.data = NULL;
 			connection->secureLayer.remoteNonce.length = 0;
 			printf("SL_processMessage - client demands no security \n");
 			break;
 
-		case UA_SecurityMode_SIGN:
+		case UA_SECURITYMODE_SIGN:
 			printf("SL_processMessage - client demands signed \n");
 			//TODO check if senderCertificate and ReceiverCertificateThumbprint are present
 			break;
 
-		case UA_SecurityMode_SIGNANDENCRYPT:
+		case UA_SECURITYMODE_SIGNANDENCRYPT:
 			printf("SL_processMessage - client demands signed & encrypted \n");
 			//TODO check if senderCertificate and ReceiverCertificateThumbprint are present
 			break;
@@ -468,21 +468,21 @@ void SL_receive(UA_connection *connection, UA_ByteString *serviceMessage) {
 
 		decodeSCMHeader(&secureChannelPacket, &pos, &SCM_Header);
 
-		switch (SCM_Header.MessageType) {
+		switch (SCM_Header.messageType) {
 
 		case packetType_OPN: /* openSecureChannel Message received */
 			decodeAASHeader(&secureChannelPacket, &pos, &AAS_Header);
 			UA_String_printf("SL_receive - AAS_Header.ReceiverThumbprint=",
-					&(AAS_Header.ReceiverThumbprint));
+					&(AAS_Header.receiverThumbprint));
 			UA_String_printf("SL_receive - AAS_Header.SecurityPolicyUri=",
-					&(AAS_Header.SecurityPolicyUri));
+					&(AAS_Header.securityPolicyUri));
 			UA_ByteString_printf("SL_receive - AAS_Header.SenderCertificate=",
-					&(AAS_Header.SenderCertificate));
-			if (SCM_Header.SecureChannelId != 0) {
+					&(AAS_Header.senderCertificate));
+			if (SCM_Header.secureChannelId != 0) {
 
 				iTmp = UA_ByteString_compare(
 						&(connection->secureLayer.remoteAsymAlgSettings.SenderCertificate),
-						&(AAS_Header.SenderCertificate));
+						&(AAS_Header.senderCertificate));
 				if (iTmp != UA_EQUAL) {
 					printf("SL_receive - UA_ERROR_BadSecureChannelUnknown \n");
 					//TODO return UA_ERROR_BadSecureChannelUnknown
@@ -496,14 +496,14 @@ void SL_receive(UA_connection *connection, UA_ByteString *serviceMessage) {
 
 			decodeSequenceHeader(&secureChannelPacket, &pos, &SequenceHeader);
 			printf("SL_receive - SequenceHeader.RequestId=%d\n",
-					SequenceHeader.RequestId);
+					SequenceHeader.requestId);
 			printf("SL_receive - SequenceHeader.SequenceNr=%d\n",
-					SequenceHeader.SequenceNumber);
+					SequenceHeader.sequenceNumber);
 			//save request id to return it to client
-			connection->secureLayer.requestId = SequenceHeader.RequestId;
+			connection->secureLayer.requestId = SequenceHeader.requestId;
 			//TODO check that the sequence number is smaller than MaxUInt32 - 1024
 			connection->secureLayer.sequenceNumber =
-					SequenceHeader.SequenceNumber;
+					SequenceHeader.sequenceNumber;
 
 			//SL_decrypt(&secureChannelPacket);
 			message.data = &secureChannelPacket.data[pos];
@@ -516,7 +516,7 @@ void SL_receive(UA_connection *connection, UA_ByteString *serviceMessage) {
 			if (connection->secureLayer.connectionState
 					== connectionState_ESTABLISHED) {
 
-				if (SCM_Header.SecureChannelId
+				if (SCM_Header.secureChannelId
 						== connection->secureLayer.securityToken.secureChannelId) {
 
 				} else {
@@ -604,11 +604,11 @@ UA_Int32 decodeSCMHeader(UA_ByteString *rawMessage, UA_Int32 *pos,
 	printf("decodeSCMHeader - entered \n");
 	// LU: wild guess - reset pos, we want to reread the message type again
 	*pos = 0;
-	SC_Header->MessageType = TL_getPacketType(rawMessage, pos);
-	SC_Header->IsFinal = rawMessage->data[*pos];
+	SC_Header->messageType = TL_getPacketType(rawMessage, pos);
+	SC_Header->isFinal = rawMessage->data[*pos];
 	*pos += 1;
-	UA_UInt32_decode(rawMessage->data, pos, &(SC_Header->MessageSize));
-	UA_UInt32_decode(rawMessage->data, pos, &(SC_Header->SecureChannelId));
+	UA_UInt32_decode(rawMessage->data, pos, &(SC_Header->messageSize));
+	UA_UInt32_decode(rawMessage->data, pos, &(SC_Header->secureChannelId));
 	return UA_SUCCESS;
 
 }
@@ -647,8 +647,8 @@ Int32 encodeSCMHeader(SL_SecureConversationMessageHeader *SC_Header, Int32 *pos,
 
 UA_Int32 decodeSequenceHeader(UA_ByteString *rawMessage, UA_Int32 *pos,
 		SL_SequenceHeader *SequenceHeader) {
-	UA_UInt32_decode(rawMessage->data, pos, &(SequenceHeader->SequenceNumber));
-	UA_UInt32_decode(rawMessage->data, pos, &(SequenceHeader->RequestId));
+	UA_UInt32_decode(rawMessage->data, pos, &(SequenceHeader->sequenceNumber));
+	UA_UInt32_decode(rawMessage->data, pos, &(SequenceHeader->requestId));
 	return UA_SUCCESS;
 }
 
@@ -659,21 +659,21 @@ UA_Int32 decodeAASHeader(UA_ByteString *rawMessage, UA_Int32 *pos,
 		SL_AsymmetricAlgorithmSecurityHeader* AAS_Header) {
 	UA_Int32 err = 0;
 	err |= UA_String_decode(rawMessage->data, pos,
-			&(AAS_Header->SecurityPolicyUri));
+			&(AAS_Header->securityPolicyUri));
 	err |= UA_ByteString_decode(rawMessage->data, pos,
-			&(AAS_Header->SenderCertificate));
+			&(AAS_Header->senderCertificate));
 	err |= UA_String_decode(rawMessage->data, pos,
-			&(AAS_Header->ReceiverThumbprint));
+			&(AAS_Header->receiverThumbprint));
 	return err;
 }
 
 UA_Int32 encodeAASHeader(SL_AsymmetricAlgorithmSecurityHeader *AAS_Header,
 		UA_Int32 *pos, UA_ByteString* dstRawMessage) {
-	UA_String_encode(&(AAS_Header->SecurityPolicyUri), pos,
+	UA_String_encode(&(AAS_Header->securityPolicyUri), pos,
 			dstRawMessage->data);
-	UA_ByteString_encode(&(AAS_Header->SenderCertificate), pos,
+	UA_ByteString_encode(&(AAS_Header->senderCertificate), pos,
 			dstRawMessage->data);
-	UA_String_encode(&(AAS_Header->ReceiverThumbprint), pos,
+	UA_String_encode(&(AAS_Header->receiverThumbprint), pos,
 			dstRawMessage->data);
 	return UA_SUCCESS;
 }

src/opcua_secureChannelLayer.h

@@ -9,51 +9,51 @@
 #define OPCUA_SECURECHANNELLAYER_H_
 
 #include "opcua.h"
-#include "opcua_connectionHelper.h"
+#include "UA_connection.h"
+#include "../include/UA_config.h"
 
 static const UA_Int32 SL_HEADER_LENGTH = 0;
-#define TOKEN_LIFETIME 30000
 typedef enum
 {
-	securityToken_ISSUE = 0,
-	securityToken_RENEW = 1
+	UA_SECURITYTOKEN_ISSUE = 0,
+	UA_SECURITYTOKEN_RENEW = 1
 }SecurityTokenRequestType;
 
 typedef enum
 {
-	UA_SecurityMode_INVALID = 0,
-	UA_SecurityMode_SIGN = 1,
-	UA_SecurityMode_SIGNANDENCRYPT = 2
+	UA_SECURITYMODE_INVALID = 0,
+	UA_SECURITYMODE_SIGN = 1,
+	UA_SECURITYMODE_SIGNANDENCRYPT = 2
 
 } securityMode;
 typedef struct T_SL_Response
 {
-	UA_UInt32 ServerProtocolVersion;
-	SL_ChannelSecurityToken SecurityToken;
-	UA_String ServerNonce;
+	UA_UInt32 serverProtocolVersion;
+	SL_ChannelSecurityToken securityToken;
+	UA_String serverNonce;
 }SL_Response;
 
 
 typedef struct T_SL_SecureConversationMessageHeader
 {
-	UA_UInt32 MessageType;
-	UA_Byte   IsFinal;
-	UA_UInt32 MessageSize;
-	UA_UInt32 SecureChannelId;
+	UA_UInt32 messageType;
+	UA_Byte   isFinal;
+	UA_UInt32 messageSize;
+	UA_UInt32 secureChannelId;
 }SL_SecureConversationMessageHeader;
 
 
 typedef struct T_SL_AsymmetricAlgorithmSecurityHeader
 {
-	UA_String SecurityPolicyUri;
-	UA_ByteString SenderCertificate;
-	UA_String ReceiverThumbprint;
+	UA_String securityPolicyUri;
+	UA_ByteString senderCertificate;
+	UA_String receiverThumbprint;
 }SL_AsymmetricAlgorithmSecurityHeader;
 
 typedef struct T_SL_SequenceHeader
 {
-	UA_UInt32 SequenceNumber;
-	UA_UInt32 RequestId;
+	UA_UInt32 sequenceNumber;
+	UA_UInt32 requestId;
 }SL_SequenceHeader;
 
 /*
@@ -61,11 +61,11 @@ typedef struct T_SL_SequenceHeader
  */
 typedef struct T_SL_AsymmetricAlgorithmSecurityFooter
 {
-	UA_Byte PaddingSize;
-	UA_Byte *Padding;
+	UA_Byte paddingSize;
+	UA_Byte *padding;
 
-	UA_UInt32 SignatureSize;
-	UA_Byte *Signature;
+	UA_UInt32 signatureSize;
+	UA_Byte *signature;
 }SL_AsymmetricAlgorithmSecurityFooter;
 
 /*

src/opcua_transportLayer.c

@@ -30,7 +30,7 @@ UA_Int32 TL_check(UA_connection *connection)
 
 	printf("TL_check - entered \n");
 
-
+	UA_ByteString_printf("received data:",&(connection->readData));
 	UA_UInt32_decode(connection->readData.data,&position,&messageLength);
 
 	printf("TL_check - messageLength = %d \n",messageLength);
@@ -270,7 +270,7 @@ UA_Int32 TL_process(UA_connection *connection,UA_Int32 packetType, UA_Int32 *pos
  */
 
 
-TL_send(UA_connection *connection, UA_ByteString *packet)
+UA_Int32 TL_send(UA_connection *connection, UA_ByteString *packet)
 {
 	printf("TL_send - entered \n");
 	connection->newDataToWrite = 1;

src/opcua_transportLayer.h

@@ -10,7 +10,7 @@
 #include <stdio.h>
 
 #include "opcua.h"
-#include "opcua_connectionHelper.h"
+#include "UA_connection.h"
 
 
 //TODO : Implement this interface
@@ -30,18 +30,18 @@ static const UA_UInt32 TL_MESSAGE_TYPE_LEN = 3;
 static const UA_UInt32 TL_RESERVED_LEN = 1;
 
 //variables which belong to layer
-static const TL_SERVER_PROTOCOL_VERSION = 0;
-static const TL_SERVER_MAX_CHUNK_COUNT = 1;
-static const TL_SERVER_MAX_MESSAGE_SIZE = 8192;
+#define TL_SERVER_PROTOCOL_VERSION  0
+#define TL_SERVER_MAX_CHUNK_COUNT 1
+#define  TL_SERVER_MAX_MESSAGE_SIZE  8192
 
 enum TL_messageType_td
 {
-	TL_HEL = 1,
-	TL_ACK = 2,
-	TL_ERR = 3,
-	TL_OPN = 4,
-	TL_CLO = 5,
-	TL_MSG = 6
+	TL_MESSAGETYPE_HEL = 1,
+	TL_MESSAGETYPE_ACK = 2,
+	TL_MESSAGETYPE_ERR = 3,
+	TL_MESSAGETYPE_OPN = 4,
+	TL_MESSAGETYPE_CLO = 5,
+	TL_MESSAGETYPE_MSG = 6
 }TL_messageType;
 
 struct TL_header

src/tcp_layer.h

@@ -7,7 +7,7 @@
 
 #ifndef TCP_LAYER_H_
 #define TCP_LAYER_H_
-#include "opcua_connectionHelper.h"
+#include "UA_connection.h"
 #ifdef LINUX
 
 #include <sys/types.h>

tests/check_stack.c

@@ -234,7 +234,7 @@ START_TEST(decodeUInt32_test)
 
 	UA_Int32 p = 0;
 	UA_UInt32 val;
-	UA_Int32_decode(rawMessage.data, &p, &val);
+	UA_UInt32_decode(rawMessage.data, &p, &val);
 	ck_assert_uint_eq(val,255);
 
 }
@@ -491,13 +491,13 @@ START_TEST(extensionObject_calcSize_test)
 	UA_ExtensionObject extensionObject;
 
 	// empty ExtensionObject, handcoded
-	extensionObject.typeId.encodingByte = UA_NodeIdType_TwoByte;
+	extensionObject.typeId.encodingByte = UA_NODEIDTYPE_TWOBYTE;
 	extensionObject.typeId.identifier.numeric = 0;
-	extensionObject.encoding = UA_ExtensionObject_NoBodyIsEncoded;
+	extensionObject.encoding = UA_EXTENSIONOBJECT_NOBODYISENCODED;
 	ck_assert_int_eq(UA_ExtensionObject_calcSize(&extensionObject), 1 + 1 + 1);
 
 	// ExtensionObject with ByteString-Body
-	extensionObject.encoding = UA_ExtensionObject_BodyIsByteString;
+	extensionObject.encoding = UA_EXTENSIONOBJECT_BODYISBYTESTRING;
 	extensionObject.body.data = data;
 	extensionObject.body.length = 3;
 	ck_assert_int_eq(UA_ExtensionObject_calcSize(&extensionObject), 3 + 4 + 3);
@@ -510,9 +510,9 @@ START_TEST(responseHeader_calcSize_test)
 	UA_DiagnosticInfo diagnosticInfo;
 	UA_ExtensionObject extensionObject;
 	UA_DiagnosticInfo  emptyDO = {0x00};
-	UA_ExtensionObject emptyEO = {{UA_NodeIdType_TwoByte,0},UA_ExtensionObject_NoBodyIsEncoded};
+	UA_ExtensionObject emptyEO = {{UA_NODEIDTYPE_TWOBYTE,0},UA_EXTENSIONOBJECT_NOBODYISENCODED};
 	//Should have the size of 26 Bytes
-	diagnosticInfo.encodingMask = UA_DiagnosticInfoEncodingMaskType_SymbolicId | UA_DiagnosticInfoEncodingMaskType_Namespace | UA_DiagnosticInfoEncodingMaskType_LocalizedText | UA_DiagnosticInfoEncodingMaskType_Locale | UA_DiagnosticInfoEncodingMaskType_AdditionalInfo;		// Byte:   1
+	diagnosticInfo.encodingMask = UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_SYMBOLICID | UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_NAMESPACE | UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_LOCALIZEDTEXT | UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_LOCALE | UA_DIAGNOSTICINFO_ENCODINGMASKTYPE_ADDITIONALINFO;		// Byte:   1
 	// Indices into to Stringtable of the responseHeader (62541-6 §5.5.12 )
 	diagnosticInfo.symbolicId = -1;										// Int32:  4
 	diagnosticInfo.namespaceUri = -1;									// Int32:  4
@@ -554,7 +554,7 @@ START_TEST(encodeDataValue_test)
 	dataValue.serverTimestamp = dateTime;
 
 	//--without Variant
-	dataValue.encodingMask = UA_DataValue_serverTimestamp; //Only the sourcePicoseconds
+	dataValue.encodingMask = UA_DATAVALUE_SERVERTIMPSTAMP; //Only the sourcePicoseconds
 	UA_DataValue_encode(&dataValue, &pos, buf);
 
 	ck_assert_int_eq(pos, 9);// represents the length
@@ -569,7 +569,7 @@ START_TEST(encodeDataValue_test)
 	ck_assert_uint_eq(buf[8], 0);
 
 	//TestCase for a DataValue with a Variant!
-	dataValue.encodingMask = UA_DataValue_variant | UA_DataValue_serverTimestamp; //Variant & SourvePicoseconds
+	dataValue.encodingMask = UA_DATAVALUE_VARIANT | UA_DATAVALUE_SERVERTIMPSTAMP; //Variant & SourvePicoseconds
 	dataValue.value.vt = &UA_[UA_INT32];
 	dataValue.value.arrayLength = 0;
 	dataValue.value.encodingMask = UA_INT32_NS0;
@@ -598,7 +598,7 @@ END_TEST
 START_TEST(DataValue_calcSize_test)
 {
 	UA_DataValue dataValue;
-	dataValue.encodingMask = UA_DataValue_statusCode |  UA_DataValue_sourceTimestamp |  UA_DataValue_sourcePicoseconds;
+	dataValue.encodingMask = UA_DATAVALUE_STATUSCODE |  UA_DATAVALUE_SOURCETIMESTAMP |  UA_DATAVALUE_SOURCEPICOSECONDS;
 	dataValue.status = 12;
 	UA_DateTime dateTime;
 	dateTime = 80;

tool/generate_builtin.py

@@ -82,7 +82,7 @@ def createEnumerated(element):
             valuemap[name + "_" + child.get("Name")] = child.get("Value")
     valuemap = OrderedDict(sorted(valuemap.iteritems(), key=lambda (k,v): int(v)))
     print("typedef UA_UInt32 " + name + ";", end='\n', file=fh);
-    print("enum " + name + "_enum { \n\t" + ",\n\t".join(map(lambda (key, value) : key + " = " + value, valuemap.iteritems())) + "\n};", end='\n', file=fh)
+    print("enum " + name + "_enum { \n\t" + ",\n\t".join(map(lambda (key, value) : key.upper() + " = " + value, valuemap.iteritems())) + "\n};", end='\n', file=fh)
     print("UA_TYPE_METHOD_PROTOTYPES (" + name + ")", end='\n', file=fh)
     print("UA_TYPE_METHOD_CALCSIZE_AS("+name+", UA_UInt32)", end='\n', file=fc)
     print("UA_TYPE_METHOD_ENCODE_AS("+name+", UA_UInt32)", end='\n', file=fc)