LocalizedText encodingmask only implicit

src/ua_application.c

@@ -16,10 +16,8 @@ UA_Node* create_node_ns0(UA_Int32 class, UA_Int32 nodeClass, UA_Int32 const id,
 	n->nodeId.namespace = 0;
 	n->nodeId.identifier.numeric = id;
 	UA_String_copycstring(qn,&(n->browseName.name));
-	n->displayName.encodingMask = UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT;
-	UA_String_copycstring(dn,&(n->displayName.text));
-	n->description.encodingMask = UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT;
-	UA_String_copycstring(desc,&(n->description.text));
+	UA_String_copycstring(dn,n->displayName.text);
+	UA_String_copycstring(desc,n->description.text);
 	n->nodeClass = nodeClass;
 	return n;
 }

src/ua_services_attribute.c

@@ -2,50 +2,51 @@
 #include "ua_statuscodes.h"
 
 enum UA_AttributeId {
-	UA_ATTRIBUTEID_NODEID = 1,
-	UA_ATTRIBUTEID_NODECLASS = 2,
-	UA_ATTRIBUTEID_BROWSENAME = 3,
-	UA_ATTRIBUTEID_DISPLAYNAME = 4,
-	UA_ATTRIBUTEID_DESCRIPTION = 5,
-	UA_ATTRIBUTEID_WRITEMASK = 6,
-	UA_ATTRIBUTEID_USERWRITEMASK = 7,
-	UA_ATTRIBUTEID_ISABSTRACT = 8,
-	UA_ATTRIBUTEID_SYMMETRIC = 9,
-	UA_ATTRIBUTEID_INVERSENAME = 10,
-	UA_ATTRIBUTEID_CONTAINSNOLOOPS = 11,
-	UA_ATTRIBUTEID_EVENTNOTIFIER = 12,
-	UA_ATTRIBUTEID_VALUE = 13,
-	UA_ATTRIBUTEID_DATATYPE = 14,
-	UA_ATTRIBUTEID_VALUERANK = 15,
-	UA_ATTRIBUTEID_ARRAYDIMENSIONS = 16,
-	UA_ATTRIBUTEID_ACCESSLEVEL = 17,
-	UA_ATTRIBUTEID_USERACCESSLEVEL = 18,
+	UA_ATTRIBUTEID_NODEID                  = 1,
+	UA_ATTRIBUTEID_NODECLASS               = 2,
+	UA_ATTRIBUTEID_BROWSENAME              = 3,
+	UA_ATTRIBUTEID_DISPLAYNAME             = 4,
+	UA_ATTRIBUTEID_DESCRIPTION             = 5,
+	UA_ATTRIBUTEID_WRITEMASK               = 6,
+	UA_ATTRIBUTEID_USERWRITEMASK           = 7,
+	UA_ATTRIBUTEID_ISABSTRACT              = 8,
+	UA_ATTRIBUTEID_SYMMETRIC               = 9,
+	UA_ATTRIBUTEID_INVERSENAME             = 10,
+	UA_ATTRIBUTEID_CONTAINSNOLOOPS         = 11,
+	UA_ATTRIBUTEID_EVENTNOTIFIER           = 12,
+	UA_ATTRIBUTEID_VALUE                   = 13,
+	UA_ATTRIBUTEID_DATATYPE                = 14,
+	UA_ATTRIBUTEID_VALUERANK               = 15,
+	UA_ATTRIBUTEID_ARRAYDIMENSIONS         = 16,
+	UA_ATTRIBUTEID_ACCESSLEVEL             = 17,
+	UA_ATTRIBUTEID_USERACCESSLEVEL         = 18,
 	UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL = 19,
-	UA_ATTRIBUTEID_HISTORIZING = 20,
-	UA_ATTRIBUTEID_EXECUTABLE = 21,
-	UA_ATTRIBUTEID_USEREXECUTABLE = 22
+	UA_ATTRIBUTEID_HISTORIZING             = 20,
+	UA_ATTRIBUTEID_EXECUTABLE              = 21,
+	UA_ATTRIBUTEID_USEREXECUTABLE          = 22
 };
 
-#define CHECK_NODECLASS(CLASS) do {									\
-		if((node->nodeClass & (CLASS)) != 0x00) {					\
-			v.encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE;	\
-			v.status = UA_STATUSCODE_BADNOTREADABLE;				\
-		}															\
-		break;														\
-	} while(0)
+#define CHECK_NODECLASS(CLASS) do {                                \
+		if((node->nodeClass & (CLASS)) != 0x00) {                  \
+			v.encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE; \
+			v.status       = UA_STATUSCODE_BADNOTREADABLE;         \
+		}                                                          \
+		break;                                                     \
+} while(0)
 
-static UA_DataValue service_read_node(Application * app, const UA_ReadValueId * id) {
+static UA_DataValue service_read_node(Application *app, const UA_ReadValueId *id) {
 	UA_DataValue v;
 	UA_DataValue_init(&v);
 
-	DBG(printf("service_read_node - entered with ns=%d,id=%d,attr=%i\n", id->nodeId.namespace, id->nodeId.identifier.numeric, id->attributeId));
+	DBG(printf("service_read_node - entered with ns=%d,id=%d,attr=%i\n", id->nodeId.namespace,
+	           id->nodeId.identifier.numeric, id->attributeId));
 	Namespace *ns = UA_indexedList_findValue(app->namespaces, id->nodeId.namespace);
 
 	if(ns == UA_NULL) {
-		DBG_VERBOSE(printf("service_read_node - unknown namespace %d\n", id->nodeId.namespace));
-		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE;
-		v.status = UA_STATUSCODE_BADNODEIDUNKNOWN;
-		return v;
+	DBG_VERBOSE(printf("service_read_node - unknown namespace %d\n", id->nodeId.namespace));
+	v.encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE;
+	v.status       = UA_STATUSCODE_BADNODEIDUNKNOWN;
+	return v;
 	}
 
 	UA_Node const *node = UA_NULL;
@@ -54,122 +55,162 @@ static UA_DataValue service_read_node(Application * app, const UA_ReadValueId *
 	DBG_VERBOSE(UA_NodeId_printf("service_read_node - search for ", &(id->nodeId)));
 	UA_Int32 result = Namespace_get(ns, &(id->nodeId), &node, &lock);
 	if(result != UA_SUCCESS || node == UA_NULL) {
-		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE;
-		v.status = UA_STATUSCODE_BADNODEIDUNKNOWN;
-		return v;
+	v.encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE;
+	v.status       = UA_STATUSCODE_BADNODEIDUNKNOWN;
+	return v;
 	}
 	DBG_VERBOSE(UA_NodeId_printf("service_read_node - found node=", &(node->nodeId)));
 
 	UA_Int32 retval = UA_SUCCESS;
 
-	switch (id->attributeId) {
+	switch(id->attributeId) {
 	case UA_ATTRIBUTEID_NODEID:
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_NODEID], &node->nodeId);
 		break;
+
 	case UA_ATTRIBUTEID_NODECLASS:
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_UINT32], &node->nodeClass);
 		break;
+
 	case UA_ATTRIBUTEID_BROWSENAME:
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_QUALIFIEDNAME], &node->browseName);
 		break;
+
 	case UA_ATTRIBUTEID_DISPLAYNAME:
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_LOCALIZEDTEXT], &node->displayName);
+		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_LOCALIZEDTEXT],
+		                                  &node->displayName);
 		break;
+
 	case UA_ATTRIBUTEID_DESCRIPTION:
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE;
-		v.status = UA_STATUSCODE_BADNOTREADABLE;
+		v.status       = UA_STATUSCODE_BADNOTREADABLE;
 		break;
+
 	case UA_ATTRIBUTEID_WRITEMASK:
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_UINT32], &node->writeMask);
 		break;
+
 	case UA_ATTRIBUTEID_USERWRITEMASK:
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_UINT32], &node->userWriteMask);
 		break;
+
 	case UA_ATTRIBUTEID_ISABSTRACT:
 		CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BOOLEAN], &((UA_ReferenceTypeNode *) node)->isAbstract);
+		retval |=
+		    UA_Variant_copySetValue(&v.value, &UA_.types[UA_BOOLEAN],
+		                            &((UA_ReferenceTypeNode *)node)->isAbstract);
 		break;
+
 	case UA_ATTRIBUTEID_SYMMETRIC:
 		CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BOOLEAN], &((UA_ReferenceTypeNode *) node)->symmetric);
+		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BOOLEAN],
+		                                  &((UA_ReferenceTypeNode *)node)->symmetric);
 		break;
+
 	case UA_ATTRIBUTEID_INVERSENAME:
 		CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_LOCALIZEDTEXT], &((UA_ReferenceTypeNode *) node)->inverseName);
+		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_LOCALIZEDTEXT],
+		                                  &((UA_ReferenceTypeNode *)node)->inverseName);
 		break;
+
 	case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
 		CHECK_NODECLASS(UA_NODECLASS_VIEW);
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BOOLEAN], &((UA_ViewNode *) node)->containsNoLoops);
+		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BOOLEAN],
+		                                  &((UA_ViewNode *)node)->containsNoLoops);
 		break;
+
 	case UA_ATTRIBUTEID_EVENTNOTIFIER:
 		CHECK_NODECLASS(UA_NODECLASS_VIEW);
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BYTE], &((UA_ViewNode *) node)->eventNotifier);
+		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BYTE],
+		                                  &((UA_ViewNode *)node)->eventNotifier);
 		break;
+
 	case UA_ATTRIBUTEID_VALUE:
 		CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
 		// TODO: Ensure that the borrowed value is not freed prematurely (multithreading)
-		retval |= UA_Variant_borrowSetValue(&v.value, &UA_.types[UA_VARIANT], &((UA_VariableNode *) node)->value);
+		retval |= UA_Variant_borrowSetValue(&v.value, &UA_.types[UA_VARIANT],
+		                                    &((UA_VariableNode *)node)->value);
 		break;
+
 	case UA_ATTRIBUTEID_DATATYPE:
 		CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_NODEID], &((UA_VariableTypeNode *) node)->dataType);
+		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_NODEID],
+		                                  &((UA_VariableTypeNode *)node)->dataType);
 		break;
+
 	case UA_ATTRIBUTEID_VALUERANK:
 		CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_INT32], &((UA_VariableTypeNode *) node)->valueRank);
+		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_INT32],
+		                                  &((UA_VariableTypeNode *)node)->valueRank);
 		break;
+
 	case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
 		CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-		UA_Variant_copySetArray(&v.value, &UA_.types[UA_UINT32], ((UA_VariableTypeNode *) node)->arrayDimensionsSize, &((UA_VariableTypeNode *) node)->arrayDimensions);
+		UA_Variant_copySetArray(&v.value, &UA_.types[UA_UINT32],
+		                        ((UA_VariableTypeNode *)node)->arrayDimensionsSize,
+		                        &((UA_VariableTypeNode *)node)->arrayDimensions);
 		break;
+
 	case UA_ATTRIBUTEID_ACCESSLEVEL:
 		CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BYTE], &((UA_VariableNode *) node)->accessLevel);
+		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BYTE],
+		                                  &((UA_VariableNode *)node)->accessLevel);
 		break;
+
 	case UA_ATTRIBUTEID_USERACCESSLEVEL:
 		CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BYTE], &((UA_VariableNode *) node)->userAccessLevel);
+		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BYTE],
+		                                  &((UA_VariableNode *)node)->userAccessLevel);
 		break;
+
 	case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
 		CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_DOUBLE], &((UA_VariableNode *) node)->minimumSamplingInterval);
+		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_DOUBLE],
+		                                  &((UA_VariableNode *)node)->minimumSamplingInterval);
 		break;
+
 	case UA_ATTRIBUTEID_HISTORIZING:
 		CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BOOLEAN], &((UA_VariableNode *) node)->historizing);
+		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BOOLEAN],
+		                                  &((UA_VariableNode *)node)->historizing);
 		break;
+
 	case UA_ATTRIBUTEID_EXECUTABLE:
 		CHECK_NODECLASS(UA_NODECLASS_METHOD);
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BOOLEAN], &((UA_MethodNode *) node)->executable);
+		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BOOLEAN],
+		                                  &((UA_MethodNode *)node)->executable);
 		break;
+
 	case UA_ATTRIBUTEID_USEREXECUTABLE:
 		CHECK_NODECLASS(UA_NODECLASS_METHOD);
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
-		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BOOLEAN], &((UA_MethodNode *) node)->userExecutable);
+		retval |= UA_Variant_copySetValue(&v.value, &UA_.types[UA_BOOLEAN],
+		                                  &((UA_MethodNode *)node)->userExecutable);
 		break;
+
 	default:
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE;
-		v.status = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
+		v.status       = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
 		break;
 	}
 
@@ -177,15 +218,16 @@ static UA_DataValue service_read_node(Application * app, const UA_ReadValueId *
 
 	if(retval != UA_SUCCESS) {
 		v.encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE;
-		v.status = UA_STATUSCODE_BADNOTREADABLE;
+		v.status       = UA_STATUSCODE_BADNOTREADABLE;
 	}
 
 	return v;
 }
 
-UA_Int32 Service_Read(SL_Channel * channel, const UA_ReadRequest * request, UA_ReadResponse * response) {
+UA_Int32 Service_Read(SL_Channel *channel, const UA_ReadRequest *request,
+                      UA_ReadResponse *response) {
 	if(channel->session == UA_NULL || channel->session->application == UA_NULL)
-		return UA_ERROR;	// TODO: Return error message
+		return UA_ERROR;    // TODO: Return error message
 
 	int readsize = request->nodesToReadSize;
 	/* NothingTodo */
@@ -197,10 +239,11 @@ UA_Int32 Service_Read(SL_Channel * channel, const UA_ReadRequest * request, UA_R
 
 	response->resultsSize = readsize;
 	UA_alloc((void **)&response->results, sizeof(UA_DataValue) * readsize);
-	for(int i = 0; i < readsize; i++) {
+	for(int i = 0;i < readsize;i++) {
 		DBG_VERBOSE(printf("service_read - attributeId=%d\n", request->nodesToRead[i].attributeId));
 		DBG_VERBOSE(UA_NodeId_printf("service_read - nodeId=", &(request->nodesToRead[i].nodeId)));
-		response->results[i] = service_read_node(channel->session->application, &request->nodesToRead[i]);
+		response->results[i] = service_read_node(channel->session->application,
+		                                         &request->nodesToRead[i]);
 	}
 	response->responseHeader.serviceResult = UA_STATUSCODE_GOOD;
 	response->diagnosticInfosSize = -1;

src/ua_services_securechannel.c

@@ -1,17 +1,18 @@
 #include "ua_services.h"
 #include "ua_transport_binary_secure.h"
 
-UA_Int32 Service_OpenSecureChannel(SL_Channel *channel, const UA_OpenSecureChannelRequest* request, UA_OpenSecureChannelResponse* response) {
-	
-	if (request->clientProtocolVersion != channel->tlConnection->remoteConf.protocolVersion) {
+UA_Int32 Service_OpenSecureChannel(SL_Channel *channel, const UA_OpenSecureChannelRequest *request,
+                                   UA_OpenSecureChannelResponse *response) {
+
+	if(request->clientProtocolVersion != channel->tlConnection->remoteConf.protocolVersion) {
 		printf("SL_processMessage - error protocol version \n");
 		//TODO ERROR_Bad_ProtocolVersionUnsupported
 	}
 
 	UA_UInt32 retval = UA_SUCCESS;
-	switch (request->requestType) {
+	switch(request->requestType) {
 	case UA_SECURITYTOKEN_ISSUE:
-		if (channel->connectionState == CONNECTIONSTATE_ESTABLISHED) {
+		if(channel->connectionState == CONNECTIONSTATE_ESTABLISHED) {
 			printf("SL_processMessage - multiple security token request");
 			//TODO return ERROR
 			retval = UA_ERROR;
@@ -20,9 +21,11 @@ UA_Int32 Service_OpenSecureChannel(SL_Channel *channel, const UA_OpenSecureChann
 		printf("SL_processMessage - TODO: create new token for a new SecureChannel\n");
 		//	SL_createNewToken(connection);
 		break;
+
 	case UA_SECURITYTOKEN_RENEW:
-		if (channel->connectionState == CONNECTIONSTATE_CLOSED) {
-			printf("SL_processMessage - renew token request received, but no secureChannel was established before");
+		if(channel->connectionState == CONNECTIONSTATE_CLOSED) {
+			printf(
+			    "SL_processMessage - renew token request received, but no secureChannel was established before");
 			//TODO return ERROR
 			retval = UA_ERROR;
 			break;
@@ -31,9 +34,9 @@ UA_Int32 Service_OpenSecureChannel(SL_Channel *channel, const UA_OpenSecureChann
 		break;
 	}
 
-	switch (request->securityMode) {
+	switch(request->securityMode) {
 	case UA_SECURITYMODE_INVALID:
-		channel->remoteNonce.data = UA_NULL;
+		channel->remoteNonce.data   = UA_NULL;
 		channel->remoteNonce.length = -1;
 		printf("SL_processMessage - client demands no security \n");
 		break;
@@ -51,24 +54,25 @@ UA_Int32 Service_OpenSecureChannel(SL_Channel *channel, const UA_OpenSecureChann
 
 	channel->connectionState = CONNECTIONSTATE_ESTABLISHED;
 
-	if (request->requestHeader.returnDiagnostics != 0) {
+	if(request->requestHeader.returnDiagnostics != 0) {
 		printf("SL_openSecureChannel - diagnostics demanded by the client\n");
 		printf("SL_openSecureChannel - retrieving diagnostics not implemented!\n");
 		//TODO fill with demanded information part 4, 7.8 - Table 123
 		response->responseHeader.serviceDiagnostics.encodingMask = 0;
-	} else {
+	} else
 		response->responseHeader.serviceDiagnostics.encodingMask = 0;
-	}
 
 	response->serverProtocolVersion = channel->tlConnection->localConf.protocolVersion;
-	response->securityToken.channelId = channel->securityToken.secureChannelId;
-	response->securityToken.tokenId = channel->securityToken.tokenId.tokenId;
+	response->securityToken.channelId       = channel->securityToken.secureChannelId;
+	response->securityToken.tokenId         = channel->securityToken.tokenId.tokenId;
 	response->securityToken.revisedLifetime = channel->securityToken.revisedLifetime;
 	UA_ByteString_copy(&channel->localNonce, &response->serverNonce);
 	return retval;
 }
 
-UA_Int32 Service_CloseSecureChannel(SL_Channel *channel, const UA_CloseSecureChannelRequest *request, UA_CloseSecureChannelResponse *response) {
+UA_Int32 Service_CloseSecureChannel(SL_Channel                         *channel,
+                                    const UA_CloseSecureChannelRequest *request,
+                                    UA_CloseSecureChannelResponse      *response) {
 	// 62451 Part 6 Chapter 7.1.4 - The server does not send a CloseSecureChannel response
 	channel->connectionState = CONNECTIONSTATE_CLOSE;
 	return UA_SUCCESS;

src/ua_transport_binary_secure.c

@@ -11,34 +11,36 @@
 
 SL_Channel slc;
 
-static UA_Int32 SL_Send(SL_Channel* channel, const UA_ByteString * responseMessage, UA_Int32 type) {
+static UA_Int32 SL_Send(SL_Channel *channel, const UA_ByteString *responseMessage, UA_Int32 type) {
 	UA_UInt32 offset = 0;
-	UA_Int32 isAsym = (type == UA_OPENSECURECHANNELRESPONSE_NS0); // FIXME: this is a to dumb method to determine asymmetric algorithm setting
+	// FIXME: this is a to dumb method to determine asymmetric algorithm setting
+	UA_Int32  isAsym = (type == UA_OPENSECURECHANNELRESPONSE_NS0);
 
 	UA_NodeId resp_nodeid;
-	resp_nodeid.encodingByte = UA_NODEIDTYPE_FOURBYTE;
-	resp_nodeid.namespace = 0;
+	resp_nodeid.encodingByte       = UA_NODEIDTYPE_FOURBYTE;
+	resp_nodeid.namespace          = 0;
 	resp_nodeid.identifier.numeric = type+2; // binary encoding
 
-	const UA_ByteString *response_gather[2]; // securechannel_header, seq_header, security_encryption_header, message_length (eventually + padding + size_signature);
+	const UA_ByteString *response_gather[2];
 	UA_alloc((void **)&response_gather[0], sizeof(UA_ByteString));
 	if(isAsym) {
-		UA_ByteString_newMembers((UA_ByteString *)response_gather[0], SIZE_SECURECHANNEL_HEADER + SIZE_SEQHEADER_HEADER +
-								 UA_AsymmetricAlgorithmSecurityHeader_calcSizeBinary(&channel->localAsymAlgSettings) +
-								 UA_NodeId_calcSizeBinary(&resp_nodeid));
+	UA_ByteString_newMembers(
+	    (UA_ByteString *)response_gather[0], SIZE_SECURECHANNEL_HEADER + SIZE_SEQHEADER_HEADER +
+	    UA_AsymmetricAlgorithmSecurityHeader_calcSizeBinary(&channel->localAsymAlgSettings) +
+	    UA_NodeId_calcSizeBinary(&resp_nodeid));
+	}else {
+		UA_ByteString_newMembers((UA_ByteString *)response_gather[0], 8 +
+		                         16 + // normal header + 4*32bit secure channel information
+		                         UA_NodeId_calcSizeBinary(&resp_nodeid));
 	}
-	else {
-		UA_ByteString_newMembers((UA_ByteString *)response_gather[0], 8 + 16 + // normal header + 4*32bit secure channel information
-								 UA_NodeId_calcSizeBinary(&resp_nodeid));
-	}
-		
-	
+
+
 	// sizePadding = 0;
 	// sizeSignature = 0;
-    UA_ByteString *header = (UA_ByteString *)response_gather[0];
+	UA_ByteString *header = (UA_ByteString *)response_gather[0];
 
 	/*---encode Secure Conversation Message Header ---*/
-	if (isAsym) {
+	if(isAsym) {
 		header->data[0] = 'O';
 		header->data[1] = 'P';
 		header->data[2] = 'N';
@@ -51,16 +53,15 @@ static UA_Int32 SL_Send(SL_Channel* channel, const UA_ByteString * responseMessa
 	header->data[offset] = 'F';
 	offset += 1;
 
-    UA_Int32 packetSize = response_gather[0]->length + responseMessage->length;
-	UA_Int32_encodeBinary(&packetSize,header, &offset);
+	UA_Int32 packetSize = response_gather[0]->length + responseMessage->length;
+	UA_Int32_encodeBinary(&packetSize, header, &offset);
 	UA_UInt32_encodeBinary(&channel->securityToken.secureChannelId, header, &offset);
 
 	/*---encode Algorithm Security Header ---*/
-	if (isAsym) {
+	if(isAsym)
 		UA_AsymmetricAlgorithmSecurityHeader_encodeBinary(&channel->localAsymAlgSettings, header, &offset);
-	} else {
+	else
 		UA_SymmetricAlgorithmSecurityHeader_encodeBinary(&channel->securityToken.tokenId, header, &offset);
-	}
 
 	/*---encode Sequence Header ---*/
 	UA_UInt32_encodeBinary(&channel->sequenceHeader.sequenceNumber, header, &offset);
@@ -68,46 +69,46 @@ static UA_Int32 SL_Send(SL_Channel* channel, const UA_ByteString * responseMessa
 
 	/*---add payload type---*/
 	UA_NodeId_encodeBinary(&resp_nodeid, header, &offset);
-	
+
 	/*---add encoded Message ---*/
-    response_gather[1] = responseMessage; // is deleted in the calling function
+	response_gather[1] = responseMessage; // is deleted in the calling function
 
 	/* sign Data*/
 
 	/* encrypt Data*/
 
 	/* send Data */
-    TL_Send(channel->tlConnection, response_gather, 2);
+	TL_Send(channel->tlConnection, response_gather, 2);
 
 	UA_ByteString_delete((UA_ByteString *)response_gather[0]);
 	return UA_SUCCESS;
 }
 
-static void init_response_header(UA_RequestHeader const * p, UA_ResponseHeader * r) {
-	memset((void*) r, 0, sizeof(UA_ResponseHeader));
-	r->requestHandle = p->requestHandle;
-	r->serviceResult = UA_STATUSCODE_GOOD;
+static void init_response_header(UA_RequestHeader const *p, UA_ResponseHeader *r) {
+	memset((void *)r, 0, sizeof(UA_ResponseHeader));
+	r->requestHandle   = p->requestHandle;
+	r->serviceResult   = UA_STATUSCODE_GOOD;
 	r->stringTableSize = 0;
-	r->timestamp = UA_DateTime_now();
+	r->timestamp       = UA_DateTime_now();
 }
 
-#define INVOKE_SERVICE(TYPE) \
-	UA_##TYPE##Request p; \
-	UA_##TYPE##Response r; \
-	UA_##TYPE##Request_decodeBinary(msg, offset, &p); \
-	UA_##TYPE##Response_init(&r); \
-	init_response_header(&p.requestHeader, &r.responseHeader); \
-	DBG_VERBOSE(printf("Invoke Service: %s\n", #TYPE)); \
-	Service_##TYPE(channel, &p, &r); \
-	DBG_VERBOSE(printf("Finished Service: %s\n", #TYPE)); \
-    *offset = 0; \
-	UA_ByteString_newMembers(&response_msg, UA_##TYPE##Response_calcSizeBinary(&r)); \
-	UA_##TYPE##Response_encodeBinary(&r, &response_msg, offset); \
-	UA_##TYPE##Request_deleteMembers(&p); \
-	UA_##TYPE##Response_deleteMembers(&r); \
+#define INVOKE_SERVICE(TYPE)                                                         \
+    UA_##TYPE##Request p;                                                            \
+    UA_##TYPE##Response r;                                                           \
+    UA_##TYPE##Request_decodeBinary(msg, offset, &p);                                \
+    UA_##TYPE##Response_init(&r);                                                    \
+    init_response_header(&p.requestHeader, &r.responseHeader);                       \
+    DBG_VERBOSE(printf("Invoke Service: %s\n", # TYPE));                             \
+    Service_##TYPE(channel, &p, &r);                                                 \
+    DBG_VERBOSE(printf("Finished Service: %s\n", # TYPE));                           \
+    *offset = 0;                                                                     \
+    UA_ByteString_newMembers(&response_msg, UA_##TYPE##Response_calcSizeBinary(&r)); \
+    UA_##TYPE##Response_encodeBinary(&r, &response_msg, offset);                     \
+    UA_##TYPE##Request_deleteMembers(&p);                                            \
+    UA_##TYPE##Response_deleteMembers(&r);                                           \
 
 /** this function manages all the generic stuff for the request-response game */
-UA_Int32 SL_handleRequest(SL_Channel *channel, const UA_ByteString* msg, UA_UInt32 *offset) {
+UA_Int32 SL_handleRequest(SL_Channel *channel, const UA_ByteString *msg, UA_UInt32 *offset) {
 	UA_Int32 retval = UA_SUCCESS;
 
 	// Every Message starts with a NodeID which names the serviceRequestType
@@ -117,45 +118,39 @@ UA_Int32 SL_handleRequest(SL_Channel *channel, const UA_ByteString* msg, UA_UInt
 
 	UA_ByteString response_msg;
 	int serviceid = serviceRequestType.identifier.numeric-2; // binary encoding has 2 added to the id
-    UA_Int32 responsetype;
+	UA_Int32      responsetype;
 	if(serviceid == UA_GETENDPOINTSREQUEST_NS0) {
 		INVOKE_SERVICE(GetEndpoints);
 		responsetype = UA_GETENDPOINTSRESPONSE_NS0;
-	}
-	else if(serviceid == UA_OPENSECURECHANNELREQUEST_NS0) {
+	}else if(serviceid == UA_OPENSECURECHANNELREQUEST_NS0) {
 		INVOKE_SERVICE(OpenSecureChannel);
 		responsetype = UA_OPENSECURECHANNELRESPONSE_NS0;
-	}
-	else if(serviceid == UA_CLOSESECURECHANNELREQUEST_NS0) {
+	}else if(serviceid == UA_CLOSESECURECHANNELREQUEST_NS0) {
 		INVOKE_SERVICE(CloseSecureChannel);
 		responsetype = UA_CLOSESECURECHANNELRESPONSE_NS0;
-	}
-	else if(serviceid == UA_CREATESESSIONREQUEST_NS0) {
+	}else if(serviceid == UA_CREATESESSIONREQUEST_NS0) {
 		INVOKE_SERVICE(CreateSession);
 		responsetype = UA_CREATESESSIONRESPONSE_NS0;
-	}
-	else if(serviceid == UA_ACTIVATESESSIONREQUEST_NS0) {
+	}else if(serviceid == UA_ACTIVATESESSIONREQUEST_NS0) {
 		INVOKE_SERVICE(ActivateSession);
 		responsetype = UA_ACTIVATESESSIONRESPONSE_NS0;
-	}
-	else if(serviceid == UA_CLOSESESSIONREQUEST_NS0) {
+	}else if(serviceid == UA_CLOSESESSIONREQUEST_NS0) {
 		INVOKE_SERVICE(CloseSession);
 		responsetype = UA_CLOSESESSIONRESPONSE_NS0;
-	}
-	else if(serviceid == UA_READREQUEST_NS0) {
+	}else if(serviceid == UA_READREQUEST_NS0) {
 		INVOKE_SERVICE(Read);
-	    responsetype = UA_READRESPONSE_NS0;
-	}
-	else if(serviceid == UA_TRANSLATEBROWSEPATHSTONODEIDSREQUEST_NS0) {
+		responsetype = UA_READRESPONSE_NS0;
+	}else if(serviceid == UA_TRANSLATEBROWSEPATHSTONODEIDSREQUEST_NS0) {
 		INVOKE_SERVICE(TranslateBrowsePathsToNodeIds);
-	    responsetype = UA_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE_NS0;
-	}
-	else {
-		printf("SL_processMessage - unknown request, namespace=%d, request=%d\n", serviceRequestType.namespace,serviceRequestType.identifier.numeric);
+		responsetype = UA_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE_NS0;
+	}else {
+		printf("SL_processMessage - unknown request, namespace=%d, request=%d\n",
+		       serviceRequestType.namespace,
+		       serviceRequestType.identifier.numeric);
 		retval = UA_ERROR;
-		UA_RequestHeader p;
+		UA_RequestHeader  p;
 		UA_ResponseHeader r;
-		UA_RequestHeader_decodeBinary(msg,offset,&p);
+		UA_RequestHeader_decodeBinary(msg, offset, &p);
 		UA_ResponseHeader_init(&r);
 		r.requestHandle = p.requestHandle;
 		r.serviceResult = UA_STATUSCODE_BADSERVICEUNSUPPORTED;
@@ -177,30 +172,32 @@ UA_Int32 SL_handleRequest(SL_Channel *channel, const UA_ByteString* msg, UA_UInt
  * @param offset
  * @return
  */
-UA_Int32 SL_Channel_new(TL_Connection *connection, const UA_ByteString* msg, UA_UInt32* offset) {
+UA_Int32 SL_Channel_new(TL_Connection *connection, const UA_ByteString *msg, UA_UInt32 *offset) {
 	DBG_VERBOSE(printf("SL_Channel_new - entered\n"));
 	UA_Int32 retval = UA_SUCCESS;
 
 	/* Create New Channel*/
 	SL_Channel *channel = &slc; // FIXME: generate new secure channel
 	UA_AsymmetricAlgorithmSecurityHeader_init(&(channel->localAsymAlgSettings));
-	UA_ByteString_copy(&UA_ByteString_securityPoliceNone, &(channel->localAsymAlgSettings.securityPolicyUri));
-	UA_alloc((void**)&(channel->localNonce.data), sizeof(UA_Byte));
+	UA_ByteString_copy(&UA_ByteString_securityPoliceNone,
+	                   &(channel->localAsymAlgSettings.securityPolicyUri));
+	UA_alloc((void **)&(channel->localNonce.data), sizeof(UA_Byte));
 	channel->localNonce.length = 1;
-	channel->connectionState = CONNECTIONSTATE_CLOSED; // the state of the channel will be opened in the service
-	channel->sequenceHeader.requestId = 0;
+	channel->connectionState   = CONNECTIONSTATE_CLOSED; // the state of the channel will be opened in the service
+	channel->sequenceHeader.requestId      = 0;
 	channel->sequenceHeader.sequenceNumber = 1;
 	UA_String_init(&(channel->secureChannelId));
 	channel->securityMode = UA_SECURITYMODE_INVALID;
 	channel->securityToken.secureChannelId = 25; //TODO set a valid start secureChannelId number
-	channel->securityToken.tokenId.tokenId = 1; //TODO set a valid start TokenId
+	channel->securityToken.tokenId.tokenId = 1;  //TODO set a valid start TokenId
 
 	connection->secureChannel = channel;
 	connection->secureChannel->tlConnection = connection;
 
 	/* Read the OPN message headers */
 	*offset += 4; // skip the securechannelid
-	UA_AsymmetricAlgorithmSecurityHeader_decodeBinary(msg, offset, &connection->secureChannel->remoteAsymAlgSettings);
+	UA_AsymmetricAlgorithmSecurityHeader_decodeBinary(
+	    msg, offset, &connection->secureChannel->remoteAsymAlgSettings);
 	UA_SequenceHeader_decodeBinary(msg, offset, &connection->secureChannel->sequenceHeader);
 	//TODO check that the sequence number is smaller than MaxUInt32 - 1024
 	//TODO check if a OpenSecureChannelRequest follows
@@ -216,21 +213,22 @@ UA_Int32 SL_Channel_new(TL_Connection *connection, const UA_ByteString* msg, UA_
  * (OPN,MSG,...), isFinal and MessageSize. SL_process cares for
  * secureChannelId, XASHeader and sequenceHeader
  * */
-UA_Int32 SL_Process(SL_Channel* connection, const UA_ByteString* msg, UA_UInt32* offset) {
+UA_Int32 SL_Process(SL_Channel *connection, const UA_ByteString *msg, UA_UInt32 *offset) {
 
 	DBG_VERBOSE(printf("SL_process - entered \n"));
 	UA_UInt32 secureChannelId;
 
-	if (connection->connectionState == CONNECTIONSTATE_ESTABLISHED) {
-		UA_UInt32_decodeBinary(msg,offset,&secureChannelId);
+	if(connection->connectionState == CONNECTIONSTATE_ESTABLISHED) {
+		UA_UInt32_decodeBinary(msg, offset, &secureChannelId);
 
 		//FIXME: we assume SAS, need to check if AAS or SAS
 		UA_SymmetricAlgorithmSecurityHeader symAlgSecHeader;
 		// if (connection->securityMode == UA_MESSAGESECURITYMODE_NONE) {
 		UA_SymmetricAlgorithmSecurityHeader_decodeBinary(msg, offset, &symAlgSecHeader);
 
-		printf("SL_process - securityToken received=%d, expected=%d\n",secureChannelId,connection->securityToken.secureChannelId);
-		if (secureChannelId == connection->securityToken.secureChannelId) {
+		printf("SL_process - securityToken received=%d, expected=%d\n", secureChannelId,
+		       connection->securityToken.secureChannelId);
+		if(secureChannelId == connection->securityToken.secureChannelId) {
 			UA_SequenceHeader_decodeBinary(msg, offset, &(connection->sequenceHeader));
 			SL_handleRequest(&slc, msg, offset);
 		} else {

src/ua_types.c

@@ -529,35 +529,52 @@ UA_TYPE_DELETE_DEFAULT(UA_LocalizedText)
 UA_Int32 UA_LocalizedText_deleteMembers(UA_LocalizedText *p) {
 	if(p == UA_NULL) return UA_SUCCESS;
 	UA_Int32 retval = UA_SUCCESS;
-	retval |= UA_String_deleteMembers(&p->locale);
-	retval |= UA_String_deleteMembers(&p->text);
+	retval |= UA_String_delete(p->locale);
+	p->locale = UA_NULL;
+	retval |= UA_String_delete(p->text);
+	p->text = UA_NULL;
 	return retval;
 }
 
 UA_Int32 UA_LocalizedText_init(UA_LocalizedText *p) {
 	if(p == UA_NULL) return UA_ERROR;
-	p->encodingMask = 0;
-	UA_String_init(&p->locale);
-	UA_String_init(&p->text);
+	p->locale = UA_NULL;
+	p->text = UA_NULL;
 	return UA_SUCCESS;
 }
 
 UA_TYPE_NEW_DEFAULT(UA_LocalizedText)
 UA_Int32 UA_LocalizedText_copycstring(char const *src, UA_LocalizedText *dst) {
-	UA_Int32 retval = UA_SUCCESS;
 	if(dst == UA_NULL) return UA_ERROR;
-	dst->encodingMask = UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE | UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT;
-	retval |= UA_String_copycstring("EN", &dst->locale);
-	retval |= UA_String_copycstring(src, &dst->text);
+	UA_Int32 retval = UA_SUCCESS;
+
+	retval |= UA_LocalizedText_init(dst);
+	retval |= UA_String_new(&dst->locale);
+	if(retval != UA_SUCCESS) return retval;
+	retval |= UA_String_copycstring("EN", dst->locale); // TODO: Are language codes upper case?
+	if(retval != UA_SUCCESS) return retval;
+	retval |= UA_String_new(&dst->text);
+	if(retval != UA_SUCCESS) return retval;
+	retval |= UA_String_copycstring(src, dst->text);
 	return retval;
 }
 
 UA_Int32 UA_LocalizedText_copy(UA_LocalizedText const *src, UA_LocalizedText *dst) {
 	if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
 	UA_Int32 retval = UA_SUCCESS;
-	retval |= UA_Byte_copy(&src->encodingMask, &dst->encodingMask);
-	retval |= UA_String_copy(&src->locale, &dst->locale);
-	retval |= UA_String_copy(&src->text, &dst->text);
+
+	retval |= UA_LocalizedText_init(dst);
+	if(src->locale != UA_NULL) {
+		retval |= UA_String_new(&dst->locale);
+		if(retval != UA_SUCCESS) return retval;
+		retval |= UA_String_copy(src->locale, dst->locale);
+		if(retval != UA_SUCCESS) return retval;
+	}
+	if(src->text != UA_NULL) {
+		retval |= UA_String_new(&dst->text);
+		if(retval != UA_SUCCESS) return retval;
+		retval |= UA_String_copy(src->text, dst->text);
+	}
 	return retval;
 }
 
@@ -708,7 +725,7 @@ UA_Int32 UA_Variant_borrowSetArray(UA_Variant *v, UA_VTable_Entry *vt, UA_Int32
 	UA_Variant_init(v);
 	v->vt = &UA_borrowed_.types[UA_ns0ToVTableIndex(&vt->typeId)];
 	v->arrayLength = arrayLength;
-	vt->data = array;
+	v->data = (void *)array;
 	return UA_SUCCESS;
 }
 

src/ua_types.h

@@ -143,9 +143,8 @@ typedef struct UA_QualifiedName {
 
 /** @brief Human readable text with an optional locale identifier. */
 typedef struct UA_LocalizedText {
-	UA_Byte   encodingMask;
-	UA_String locale;
-	UA_String text;
+	UA_String *locale;
+	UA_String *text;
 } UA_LocalizedText;
 
 enum UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_enum {
@@ -153,7 +152,8 @@ enum UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_enum {
 	UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT   = 0x02
 };
 
-/** @brief A structure that contains an application specific data type that may not be recognized by the receiver. */
+/** @brief A structure that contains an application specific data type that may
+	not be recognized by the receiver. */
 typedef struct UA_ExtensionObject {
 	UA_NodeId     typeId;
 	UA_Byte       encoding;     // Type of the enum UA_ExtensionObjectEncodingMaskType

src/ua_types_encoding_binary.c

@@ -498,39 +498,39 @@ UA_TYPE_ENCODEBINARY(UA_QualifiedName,
 
 /* LocalizedText */
 UA_Int32 UA_LocalizedText_calcSizeBinary(UA_LocalizedText const *p) {
-	UA_Int32 length = 0;
-	if(p == UA_NULL) {
-		// size for UA_memalloc
-		length = sizeof(UA_LocalizedText);
-	} else {
-		// size for binary encoding
-		length += 1; // p->encodingMask;
-		if(p->encodingMask & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE)
-			length += UA_String_calcSizeBinary(&p->locale);
-		if(p->encodingMask & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT)
-			length += UA_String_calcSizeBinary(&p->text);
-	}
+	UA_Int32 length = 1; // for encodingMask
+	if(p == UA_NULL)
+		return sizeof(UA_LocalizedText);
+	if(p->locale != UA_NULL)
+		length += UA_String_calcSizeBinary(p->locale);
+	if(p->text != UA_NULL)
+		length += UA_String_calcSizeBinary(p->text);
 	return length;
 }
 
 UA_TYPE_ENCODEBINARY(UA_LocalizedText,
-                     retval |= UA_Byte_encodeBinary(&src->encodingMask, dst, offset);
-                     if(src->encodingMask & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE)
-						 retval |= UA_String_encodeBinary(&src->locale, dst, offset);
-                     if(src->encodingMask & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT)
-						 retval |= UA_String_encodeBinary(&src->text, dst, offset); )
+					 UA_Byte encodingMask = 0;
+					 if(src->locale != UA_NULL)
+						 encodingMask |= UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE;
+					 if(src->text != UA_NULL)
+						 encodingMask |= UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT;
+                     retval |= UA_Byte_encodeBinary(&encodingMask, dst, offset);
+                     if(encodingMask & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE)
+						 retval |= UA_String_encodeBinary(src->locale, dst, offset);
+                     if(encodingMask & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT)
+						 retval |= UA_String_encodeBinary(src->text, dst, offset); )
 
 UA_Int32 UA_LocalizedText_decodeBinary(UA_ByteString const *src, UA_UInt32 *offset, UA_LocalizedText *dst) {
 	UA_Int32 retval = UA_SUCCESS;
-
-	retval |= UA_String_init(&dst->locale);
-	retval |= UA_String_init(&dst->text);
-
-	CHECKED_DECODE(UA_Byte_decodeBinary(src, offset, &dst->encodingMask),; );
-	if(dst->encodingMask & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE)
-		CHECKED_DECODE(UA_String_decodeBinary(src, offset, &dst->locale), UA_LocalizedText_deleteMembers(dst));
-	if(dst->encodingMask & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT)
-		CHECKED_DECODE(UA_String_decodeBinary(src, offset, &dst->text), UA_LocalizedText_deleteMembers(dst));
+	retval |= UA_LocalizedText_init(dst);
+	UA_Byte encodingMask;
+	CHECKED_DECODE(UA_Byte_decodeBinary(src, offset, &encodingMask),; );
+	if(encodingMask & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE)
+		CHECKED_DECODE(UA_String_new(&dst->locale); UA_String_decodeBinary(src, offset, dst->locale),
+					   UA_LocalizedText_deleteMembers(dst));
+	if(encodingMask & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT)
+		CHECKED_DECODE(UA_String_new(&dst->text); UA_String_decodeBinary(src, offset, dst->text),
+					   UA_LocalizedText_deleteMembers(dst));
 	return retval;
 }
 

src/ua_types_encoding_xml.c

@@ -320,22 +320,20 @@ UA_Int32 UA_LocalizedText_decodeXmlFromStack(XML_Stack *s, XML_Attr *attr, UA_Lo
 		// set attributes
 		for(i = 0;attr[i];i += 2) {
 			if(0 == strncmp("Text", attr[i], strlen("Text"))) {
-				UA_String_copycstring(attr[i + 1], &(dst->text));
-				dst->encodingMask |= UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT;
+				UA_String_copycstring(attr[i + 1], dst->text);
 			} else if(0 == strncmp("Locale", attr[i], strlen("Locale"))) {
-				UA_String_copycstring(attr[i + 1], &(dst->locale));
-				dst->encodingMask |= UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE;
+				UA_String_copycstring(attr[i + 1], dst->locale);
 			} else
 				perror("Unknown attribute");
 		}
 	} else {
 		switch(s->parent[s->depth - 1].activeChild) {
 		case 0:
-			dst->encodingMask |= UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT;
+			//dst->encodingMask |= UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT;
 			break;
 
 		case 1:
-			dst->encodingMask |= UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE;
+			//dst->encodingMask |= UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE;
 			break;
 
 		default:

src/ua_xml.c

@@ -672,9 +672,9 @@ void print_node(UA_Node const * node) {
 	if (node != UA_NULL) {
 		UA_NodeId_printf("node.nodeId=", &(node->nodeId));
 		printf("\t.browseName='%.*s'\n", node->browseName.name.length, node->browseName.name.data);
-		printf("\t.displayName='%.*s'\n", node->displayName.text.length, node->displayName.text.data);
-		printf("\t.description='%.*s%s'\n", node->description.text.length > 40 ? 40 : node->description.text.length,
-		       node->description.text.data, node->description.text.length > 40 ? "..." : "");
+		printf("\t.displayName='%.*s'\n", node->displayName.text->length, node->displayName.text->data);
+		printf("\t.description='%.*s%s'\n", node->description.text->length > 40 ? 40 : node->description.text->length,
+		       node->description.text->data, node->description.text->length > 40 ? "..." : "");
 		printf("\t.nodeClass=%d\n", node->nodeClass);
 		printf("\t.writeMask=%d\n", node->writeMask);
 		printf("\t.userWriteMask=%d\n", node->userWriteMask);
@@ -709,9 +709,8 @@ void print_node(UA_Node const * node) {
 				{
 					if(p->value.data != UA_NULL) {
 						UA_LocalizedText *ltp = (UA_LocalizedText *)currentData;
-						printf(",enc=%d,locale={%d,{%.*s}},text={%d,{%.*s}}", ltp->encodingMask, ltp->locale.length,
-						       ltp->locale.length, ltp->locale.data, ltp->text.length, ltp->text.length,
-						       ltp->text.data);
+						printf(",locale={%d,{%.*s}},text={%d,{%.*s}}", ltp->locale->length, ltp->locale->length,
+							   ltp->locale->data, ltp->text->length, ltp->text->length, ltp->text->data);
 					}
 				}
 				break;

tests/check_builtin.c

@@ -424,35 +424,43 @@ END_TEST
 START_TEST(UA_LocalizedText_calcSizeTextOnlyShallReturnEncodingSize) {
 	// given
 	UA_LocalizedText arg;
-	arg.encodingMask = UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT;
-	arg.text.length  = 42;
+	UA_LocalizedText_init(&arg);
+	UA_String_new(&arg.text);
+	arg.text->length  = 42;
 	// when
 	UA_UInt32 encodingSize = UA_LocalizedText_calcSizeBinary(&arg);
 	// then
 	ck_assert_int_eq(encodingSize, 1+4+42);
+	// finally
+	UA_LocalizedText_deleteMembers(&arg);
 }
 END_TEST
 START_TEST(UA_LocalizedText_calcSizeLocaleOnlyShallReturnEncodingSize) {
 	// given
 	UA_LocalizedText arg;
-	arg.encodingMask  = UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE;
-	arg.locale.length = 11;
+	UA_LocalizedText_init(&arg);
+	UA_String_new(&arg.locale);
+	arg.locale->length = 11;
 	// when
 	UA_UInt32 encodingSize = UA_LocalizedText_calcSizeBinary(&arg);
 	// then
 	ck_assert_int_eq(encodingSize, 1+4+11);
+	UA_LocalizedText_deleteMembers(&arg);
 }
 END_TEST
 START_TEST(UA_LocalizedText_calcSizeTextAndLocaleShallReturnEncodingSize) {
 	// given
 	UA_LocalizedText arg;
-	arg.encodingMask  = UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE | UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT;
-	arg.text.length   = 47;
-	arg.locale.length = 11;
+	UA_LocalizedText_init(&arg);
+	UA_String_new(&arg.text);
+	UA_String_new(&arg.locale);
+	arg.text->length   = 47;
+	arg.locale->length = 11;
 	// when
 	UA_UInt32 encodingSize = UA_LocalizedText_calcSizeBinary(&arg);
 	// then
 	ck_assert_int_eq(encodingSize, 1+4+11+4+47);
+	UA_LocalizedText_deleteMembers(&arg);
 }
 END_TEST
 START_TEST(UA_Variant_calcSizeFixedSizeArrayShallReturnEncodingSize) {

tests/check_memory.c

@@ -114,7 +114,7 @@ START_TEST(decodeScalarBasicTypeFromRandomBufferShallSucceed) {
 	UA_Int32 buflen = 256;
 	UA_ByteString_newMembers(&msg1, buflen); // fixed size
 	srandom(42);
-	for(int n = 0;n < 1000;n++) {
+	for(int n = 0;n < 100;n++) {
 		for(UA_Int32 i = 0;i < buflen;i++) msg1.data[i] = (UA_Byte)random();  // when
 		UA_UInt32 pos = 0;
 		retval |= UA_.types[_i].new(&obj1);
@@ -137,7 +137,7 @@ START_TEST(decodeComplexTypeFromRandomBufferShallSurvive) {
 	UA_ByteString_newMembers(&msg1, buflen); // fixed size
 	srandom(42);
 	// when
-	for(int n = 0;n < 1000;n++) {
+	for(int n = 0;n < 100;n++) {
 		for(UA_Int32 i = 0;i < buflen;i++) msg1.data[i] = (UA_Byte)random();
 		UA_UInt32 pos = 0;
 		retval |= UA_.types[_i].new(&obj1);

tests/check_stack.c

@@ -429,7 +429,7 @@ int main(void) {
 
 	s  = testSuite();
 	sr = srunner_create(s);
-	// srunner_set_fork_status (sr, CK_NOFORK);
+	//srunner_set_fork_status (sr, CK_NOFORK);
 	srunner_run_all(sr, CK_NORMAL);
 	number_failed += srunner_ntests_failed(sr);
 	srunner_free(sr);

tools/uncrustify.cfg

@@ -1,5 +1,5 @@
 # Basics
-code_width		= 120
+code_width		= 110
 indent_with_tabs	= 1		# 1=indent to level only, 2=indent with tabs
 input_tab_size		= 4		# original tab size
 output_tab_size		= 4		# new tab size
@@ -74,22 +74,22 @@ sp_after_ptr_star	= remove
 # Aligning
 align_with_tabs		= false		# use tabs to align
 align_on_tabstop	= false		# align on tabstops
-align_var_def_thresh	= 4
+align_var_def_thresh	= 6
 align_func_params	= true		# align variable definitions
 align_assign_span	= 2
-align_assign_thresh	= 4
+align_assign_thresh	= 6
 align_nl_cont		= true		# align macros with backlash+newline
 ## Algin Variable Assignment
 align_var_def_span	= 2		# max distance of lines considered together
-align_var_def_thresh	= 4		# max horizontal distance for grouping
+align_var_def_thresh	= 6		# max horizontal distance for grouping
 align_var_def_star_style = 2
 align_var_def_amp_style = 2
 align_var_def_inline	= true
 ## Enum Assignment
-align_enum_equ_thresh	= 4
+align_enum_equ_thresh	= 12
 align_enum_equ_span	= 2
 sp_enum_assign		= force
 align_struct_init_span	= 2		# align stuff in a structure init '= { }'
 align_var_struct_span	= 2
-align_var_struct_thresh = 4
+align_var_struct_thresh = 6
 align_right_cmt_span	= 2