remove calcSizeBinary

src/client/ua_client.c

@@ -61,7 +61,7 @@ static UA_StatusCode HelAckHandshake(UA_Client *c) {
     messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_HELF;
 
     UA_TcpHelloMessage hello;
-    UA_String_copy(&c->endpointUrl, &hello.endpointUrl);
+    UA_String_copy(&c->endpointUrl, &hello.endpointUrl); /* must be less than 4096 bytes */
 
     UA_Connection *conn = &c->connection;
     hello.maxChunkCount = conn->localConf.maxChunkCount;
@@ -70,31 +70,35 @@ static UA_StatusCode HelAckHandshake(UA_Client *c) {
     hello.receiveBufferSize = conn->localConf.recvBufferSize;
     hello.sendBufferSize = conn->localConf.sendBufferSize;
 
-    messageHeader.messageSize = UA_TcpHelloMessage_calcSizeBinary((UA_TcpHelloMessage const*)&hello) +
-                                UA_TcpMessageHeader_calcSizeBinary((UA_TcpMessageHeader const*)&messageHeader);
     UA_ByteString message;
     UA_StatusCode retval = c->connection.getBuffer(&c->connection, &message);
     if(retval != UA_STATUSCODE_GOOD)
         return retval;
 
-    size_t offset = 0;
-    UA_TcpMessageHeader_encodeBinary(&messageHeader, &message, &offset);
-    UA_TcpHelloMessage_encodeBinary(&hello, &message, &offset);
+    size_t offset = 8;
+    retval |= UA_TcpHelloMessage_encodeBinary(&hello, &message, &offset);
+    messageHeader.messageSize = offset;
+    offset = 0;
+    retval |= UA_TcpMessageHeader_encodeBinary(&messageHeader, &message, &offset);
     UA_TcpHelloMessage_deleteMembers(&hello);
+    if(retval != UA_STATUSCODE_GOOD) {
+        c->connection.releaseBuffer(&c->connection, &message);
+        return retval;
+    }
 
     retval = c->connection.write(&c->connection, &message, messageHeader.messageSize);
-    if(retval != UA_STATUSCODE_GOOD)
+    if(retval != UA_STATUSCODE_GOOD) {
         c->connection.releaseBuffer(&c->connection, &message);
-    if(retval)
         return retval;
+    }
 
     UA_ByteString reply;
     UA_ByteString_init(&reply);
     do {
         retval = c->connection.recv(&c->connection, &reply, c->config.timeout);
-        if(retval == UA_STATUSCODE_BADCONNECTIONCLOSED)
+        if(retval != UA_STATUSCODE_GOOD)
             return retval;
-    } while(retval != UA_STATUSCODE_GOOD);
+    } while(!reply.data);
 
     offset = 0;
     UA_TcpMessageHeader_decodeBinary(&reply, &offset, &messageHeader);
@@ -142,13 +146,6 @@ static UA_StatusCode SecureChannelHandshake(UA_Client *client, UA_Boolean renew)
         opnSecRq.securityMode = UA_MESSAGESECURITYMODE_NONE;
     }
 
-    messageHeader.messageHeader.messageSize =
-        UA_SecureConversationMessageHeader_calcSizeBinary(&messageHeader) +
-        UA_AsymmetricAlgorithmSecurityHeader_calcSizeBinary(&asymHeader) +
-        UA_SequenceHeader_calcSizeBinary(&seqHeader) +
-        UA_NodeId_calcSizeBinary(&requestType) +
-        UA_OpenSecureChannelRequest_calcSizeBinary(&opnSecRq);
-
     UA_ByteString message;
     UA_StatusCode retval = client->connection.getBuffer(&client->connection, &message);
     if(retval != UA_STATUSCODE_GOOD) {
@@ -157,30 +154,36 @@ static UA_StatusCode SecureChannelHandshake(UA_Client *client, UA_Boolean renew)
         return retval;
     }
 
-    size_t offset = 0;
-    UA_SecureConversationMessageHeader_encodeBinary(&messageHeader, &message, &offset);
-    UA_AsymmetricAlgorithmSecurityHeader_encodeBinary(&asymHeader, &message, &offset);
-    UA_SequenceHeader_encodeBinary(&seqHeader, &message, &offset);
-    UA_NodeId_encodeBinary(&requestType, &message, &offset);
-    UA_OpenSecureChannelRequest_encodeBinary(&opnSecRq, &message, &offset);
+    size_t offset = 12;
+    retval = UA_AsymmetricAlgorithmSecurityHeader_encodeBinary(&asymHeader, &message, &offset);
+    retval |= UA_SequenceHeader_encodeBinary(&seqHeader, &message, &offset);
+    retval |= UA_NodeId_encodeBinary(&requestType, &message, &offset);
+    retval |= UA_OpenSecureChannelRequest_encodeBinary(&opnSecRq, &message, &offset);
+    messageHeader.messageHeader.messageSize = offset;
+    offset = 0;
+    retval |= UA_SecureConversationMessageHeader_encodeBinary(&messageHeader, &message, &offset);
 
     UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
     UA_OpenSecureChannelRequest_deleteMembers(&opnSecRq);
+    if(retval != UA_STATUSCODE_GOOD) {
+        client->connection.releaseBuffer(&client->connection, &message);
+        return retval;
+    }
 
     retval = client->connection.write(&client->connection, &message, messageHeader.messageHeader.messageSize);
-    if(retval != UA_STATUSCODE_GOOD)
+    if(retval != UA_STATUSCODE_GOOD) {
         client->connection.releaseBuffer(&client->connection, &message);
-    if(retval)
         return retval;
+    }
 
     // parse the response
     UA_ByteString reply;
     UA_ByteString_init(&reply);
     do {
         retval = client->connection.recv(&client->connection, &reply, client->config.timeout);
-        if(retval == UA_STATUSCODE_BADCONNECTIONCLOSED)
+        if(retval == UA_STATUSCODE_GOOD)
             return retval;
-    } while(retval != UA_STATUSCODE_GOOD);
+    } while(!reply.data);
 
     offset = 0;
     UA_SecureConversationMessageHeader_decodeBinary(&reply, &offset, &messageHeader);
@@ -193,6 +196,8 @@ static UA_StatusCode SecureChannelHandshake(UA_Client *client, UA_Boolean renew)
         UA_ByteString_deleteMembers(&reply);
         UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
         UA_NodeId_deleteMembers(&requestType);
+        UA_LOG_ERROR(client->logger, UA_LOGCATEGORY_CLIENT,
+                     "Reply answers the wrong request. Expected OpenSecureChannelResponse.");
         return UA_STATUSCODE_BADINTERNALERROR;
     }
 
@@ -239,7 +244,7 @@ static void synchronousRequest(UA_Client *client, void *request, const UA_DataTy
                                                               request, requestType);
     UA_ResponseHeader *respHeader = (UA_ResponseHeader*)response;
     if(retval) {
-        if(retval == UA_STATUSCODE_BADENCODINGERROR)
+        if(retval == UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED)
             respHeader->serviceResult = UA_STATUSCODE_BADREQUESTTOOLARGE;
         else
             respHeader->serviceResult = retval;
@@ -270,15 +275,29 @@ static void synchronousRequest(UA_Client *client, void *request, const UA_DataTy
     retval |= UA_NodeId_decodeBinary(&reply, &offset, &responseId);
     UA_NodeId expectedNodeId = UA_NODEID_NUMERIC(0, responseType->typeId.identifier.numeric +
                                                  UA_ENCODINGOFFSET_BINARY);
-    if(!UA_NodeId_equal(&responseId, &expectedNodeId) || seqHeader.requestId != requestId) {
-        // Todo: we need to demux responses since a publish responses may come at any time
-        UA_ByteString_deleteMembers(&reply);
-        UA_SymmetricAlgorithmSecurityHeader_deleteMembers(&symHeader);
-        respHeader->serviceResult = UA_STATUSCODE_BADINTERNALERROR;
-        return;
-    }
 
+    if(retval != UA_STATUSCODE_GOOD)
+        goto finish;
+
+    /* Todo: we need to demux responses since a publish responses may come at any time */
+    if(!UA_NodeId_equal(&responseId, &expectedNodeId) || seqHeader.requestId != requestId) {
+        if(responseId.identifier.numeric != UA_NS0ID_SERVICEFAULT + UA_ENCODINGOFFSET_BINARY) {
+            UA_LOG_ERROR(client->logger, UA_LOGCATEGORY_CLIENT,
+                         "Reply answers the wrong request. Expected ns=%i,i=%i. But retrieved ns=%i,i=%i",
+                         expectedNodeId.namespaceIndex, expectedNodeId.identifier.numeric,
+                         responseId.namespaceIndex, responseId.identifier.numeric);
+            respHeader->serviceResult = UA_STATUSCODE_BADINTERNALERROR;
+        } else
+            retval = UA_decodeBinary(&reply, &offset, respHeader, &UA_TYPES[UA_TYPES_SERVICEFAULT]);
+        goto finish;
+    } 
+    
     retval = UA_decodeBinary(&reply, &offset, response, responseType);
+    if(retval == UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED)
+        retval = UA_STATUSCODE_BADRESPONSETOOLARGE;
+
+ finish:
+    UA_SymmetricAlgorithmSecurityHeader_deleteMembers(&symHeader);
     UA_ByteString_deleteMembers(&reply);
     if(retval != UA_STATUSCODE_GOOD)
         respHeader->serviceResult = retval;
@@ -430,29 +449,28 @@ static UA_StatusCode CloseSecureChannel(UA_Client *client) {
 
     UA_NodeId typeId = UA_NODEID_NUMERIC(0, UA_NS0ID_CLOSESECURECHANNELREQUEST + UA_ENCODINGOFFSET_BINARY);
 
-    msgHeader.messageHeader.messageSize =
-        UA_SecureConversationMessageHeader_calcSizeBinary(&msgHeader) +
-        UA_SymmetricAlgorithmSecurityHeader_calcSizeBinary(&symHeader) +
-        UA_SequenceHeader_calcSizeBinary(&seqHeader) +
-        UA_NodeId_calcSizeBinary(&typeId) +
-        UA_calcSizeBinary(&request, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]);
-
     UA_ByteString message;
     UA_StatusCode retval = client->connection.getBuffer(&client->connection, &message);
     if(retval != UA_STATUSCODE_GOOD)
         return retval;
 
-    size_t offset = 0;
-    retval |= UA_SecureConversationMessageHeader_encodeBinary(&msgHeader, &message, &offset);
+    size_t offset = 12;
     retval |= UA_SymmetricAlgorithmSecurityHeader_encodeBinary(&symHeader, &message, &offset);
     retval |= UA_SequenceHeader_encodeBinary(&seqHeader, &message, &offset);
     retval |= UA_NodeId_encodeBinary(&typeId, &message, &offset);
     retval |= UA_encodeBinary(&request, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST], &message, &offset);
-    if(retval == UA_STATUSCODE_GOOD) {
-        retval = client->connection.write(&client->connection, &message, msgHeader.messageHeader.messageSize);
-        if(retval != UA_STATUSCODE_GOOD)
-            client->connection.releaseBuffer(&client->connection, &message);
-    } else
+
+    msgHeader.messageHeader.messageSize = offset;
+    offset = 0;
+    retval |= UA_SecureConversationMessageHeader_encodeBinary(&msgHeader, &message, &offset);
+
+    if(retval != UA_STATUSCODE_GOOD) {
+        client->connection.releaseBuffer(&client->connection, &message);
+        return retval;
+    }
+        
+    retval = client->connection.write(&client->connection, &message, msgHeader.messageHeader.messageSize);
+    if(retval != UA_STATUSCODE_GOOD)
         client->connection.releaseBuffer(&client->connection, &message);
     return retval;
 }

src/server/ua_server_binary.c

@@ -38,9 +38,7 @@ static void processHEL(UA_Connection *connection, const UA_ByteString *msg, size
 
     UA_TcpMessageHeader ackHeader;
     ackHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_ACKF;
-    ackHeader.messageSize =  8 + 20;
-    /* == UA_TcpMessageHeader_calcSizeBinary(&ackHeader) +
-       UA_TcpAcknowledgeMessage_calcSizeBinary(&ackMessage) */
+    ackHeader.messageSize =  8 + 20; /* ackHeader + ackMessage */
 
     UA_ByteString ack_msg;
     if(connection->getBuffer(connection, &ack_msg) != UA_STATUSCODE_GOOD)
@@ -174,7 +172,7 @@ static void invoke_service(UA_Server *server, UA_SecureChannel *channel, UA_UInt
     }
     UA_StatusCode retval = UA_SecureChannel_sendBinaryMessage(channel, requestId, response, responseType);
     if(retval != UA_STATUSCODE_GOOD) {
-        if(retval == UA_STATUSCODE_BADENCODINGERROR)
+        if(retval == UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED)
             response->serviceResult = UA_STATUSCODE_BADRESPONSETOOLARGE;
         else
             response->serviceResult = retval;

src/server/ua_services_attribute.c

@@ -425,16 +425,21 @@ void Service_Read(UA_Server *server, UA_Session *session, const UA_ReadRequest *
 		expireArray = UA_Array_new(&UA_TYPES[UA_TYPES_DATETIME], request->nodesToReadSize);
 		variant.data = expireArray;
 
-		UA_ByteString str;
-		UA_ByteString_init(&str);
-
 		/*expires in 20 seconds*/
 		for(UA_Int32 i = 0;i < response->resultsSize;i++) {
 			expireArray[i] = UA_DateTime_now() + 20 * 100 * 1000 * 1000;
 		}
 		size_t offset = 0;
-		str.data = UA_malloc(UA_Variant_calcSizeBinary(&variant));
-		str.length = UA_Variant_calcSizeBinary(&variant);
+        UA_Connection *c = UA_NULL;
+        UA_SecureChannel *sc = session->channel;
+        if(sc)
+            c = session->sc;
+        if(!c) {
+            response->responseHeader.serviceResult = UA_STATUSCODE_BADINTERNALERROR;
+            return;
+        }
+		UA_ByteString str;
+        UA_ByteString_newMembers(&str, c->remoteConf.maxMessageSize);
 		UA_Variant_encodeBinary(&variant, &str, &offset);
 		additionalHeader.body = str;
 		response->responseHeader.additionalHeader = additionalHeader;

src/ua_types_encoding_binary.c

@@ -7,23 +7,6 @@
 /* Array Handling */
 /******************/
 
-static size_t UA_Array_calcSizeBinary(const void *p, UA_Int32 noElements,
-		const UA_DataType *dataType) {
-	if (noElements <= 0)
-		return 4;
-	size_t size = 4; // the array size encoding
-	if (dataType->fixedSize) {
-		size += noElements * UA_calcSizeBinary(p, dataType);
-		return size;
-	}
-	uintptr_t ptr = (uintptr_t) p;
-	for (int i = 0; i < noElements; i++) {
-		size += UA_calcSizeBinary((void*) ptr, dataType);
-		ptr += dataType->memSize;
-	}
-	return size;
-}
-
 static UA_StatusCode UA_Array_encodeBinary(const void *src, UA_Int32 noElements,
 		const UA_DataType *dataType, UA_ByteString *dst,
 		size_t *UA_RESTRICT offset) {
@@ -37,11 +20,9 @@ static UA_StatusCode UA_Array_encodeBinary(const void *src, UA_Int32 noElements,
 	if (dataType->zeroCopyable) {
 		if (noElements <= 0)
 			return UA_STATUSCODE_GOOD;
-		if ((size_t) dst->length
-				< *offset + (dataType->memSize * (size_t) noElements))
+		if ((size_t) dst->length < *offset + (dataType->memSize * (size_t) noElements))
 			return UA_STATUSCODE_BADENCODINGERROR;
-		memcpy(&dst->data[*offset], src,
-				dataType->memSize * (size_t) noElements);
+		memcpy(&dst->data[*offset], src, dataType->memSize * (size_t) noElements);
 		*offset += dataType->memSize * (size_t) noElements;
 		return retval;
 	}
@@ -68,8 +49,7 @@ static UA_StatusCode UA_Array_decodeBinary(const UA_ByteString *src,
 		return UA_STATUSCODE_BADOUTOFMEMORY;
 
 	/* filter out arrays that can obviously not be parsed */
-	if (*offset + ((dataType->memSize * noElements) / 32)
-			> (UA_UInt32) src->length)
+	if (*offset + ((dataType->memSize * noElements) / 32) > (UA_UInt32) src->length)
 		return UA_STATUSCODE_BADDECODINGERROR;
 
 	*dst = UA_calloc(1, dataType->memSize * noElements);
@@ -79,11 +59,9 @@ static UA_StatusCode UA_Array_decodeBinary(const UA_ByteString *src,
 	UA_StatusCode retval = UA_STATUSCODE_GOOD;
 #ifndef UA_NON_LITTLEENDIAN_ARCHITECTURE
 	if (dataType->zeroCopyable) {
-		if ((size_t) src->length
-				< *offset + (dataType->memSize * (size_t) noElements))
+		if ((size_t) src->length < *offset + (dataType->memSize * (size_t) noElements))
 			return UA_STATUSCODE_BADDECODINGERROR;
-		memcpy(*dst, &src->data[*offset],
-				dataType->memSize * (size_t) noElements);
+		memcpy(*dst, &src->data[*offset], dataType->memSize * (size_t) noElements);
 		*offset += dataType->memSize * (size_t) noElements;
 		return retval;
 	}
@@ -106,13 +84,7 @@ static UA_StatusCode UA_Array_decodeBinary(const UA_ByteString *src,
 /* Builtin Types */
 /*****************/
 
-#define UA_TYPE_CALCSIZEBINARY_MEMSIZE(TYPE) \
-    size_t TYPE##_calcSizeBinary(TYPE const *p) { return sizeof(TYPE); }
-
 #define UA_TYPE_BINARY_ENCODING_AS(TYPE, TYPE_AS)                       \
-    size_t TYPE##_calcSizeBinary(TYPE const *p) {                       \
-        return TYPE_AS##_calcSizeBinary((const TYPE_AS *)p);            \
-    }                                                                   \
     UA_StatusCode TYPE##_encodeBinary(TYPE const *src, UA_ByteString *dst, size_t *UA_RESTRICT offset) { \
         return TYPE_AS##_encodeBinary((const TYPE_AS *)src, dst, offset); \
     }                                                                   \
@@ -121,7 +93,6 @@ static UA_StatusCode UA_Array_decodeBinary(const UA_ByteString *src,
     }
 
 /* Boolean */
-UA_TYPE_CALCSIZEBINARY_MEMSIZE(UA_Boolean)
 UA_StatusCode UA_Boolean_encodeBinary(const UA_Boolean *src, UA_ByteString *dst,
 		size_t *UA_RESTRICT offset) {
 	if ((UA_Int32) (*offset + sizeof(UA_Boolean)) > dst->length)
@@ -144,7 +115,6 @@ UA_StatusCode UA_Boolean_decodeBinary(UA_ByteString const *src,
 UA_TYPE_BINARY_ENCODING_AS(UA_SByte, UA_Byte)
 
 /* Byte */
-UA_TYPE_CALCSIZEBINARY_MEMSIZE(UA_Byte)
 UA_StatusCode UA_Byte_encodeBinary(const UA_Byte *src, UA_ByteString *dst,
 		size_t *UA_RESTRICT offset) {
 	if ((UA_Int32) (*offset + sizeof(UA_Byte)) > dst->length)
@@ -167,7 +137,6 @@ UA_StatusCode UA_Byte_decodeBinary(UA_ByteString const *src,
 UA_TYPE_BINARY_ENCODING_AS(UA_Int16, UA_UInt16)
 
 /* UInt16 */
-UA_TYPE_CALCSIZEBINARY_MEMSIZE(UA_UInt16)
 UA_StatusCode UA_UInt16_encodeBinary(UA_UInt16 const *src, UA_ByteString *dst,
 		size_t *UA_RESTRICT offset) {
 	if ((UA_Int32) (*offset + sizeof(UA_UInt16)) > dst->length)
@@ -209,7 +178,6 @@ UA_StatusCode UA_UInt16_decodeBinary(UA_ByteString const *src,
 UA_TYPE_BINARY_ENCODING_AS(UA_Int32, UA_UInt32)
 
 /* UInt32 */
-UA_TYPE_CALCSIZEBINARY_MEMSIZE(UA_UInt32)
 UA_StatusCode UA_UInt32_encodeBinary(UA_UInt32 const *src, UA_ByteString * dst,
 		size_t *UA_RESTRICT offset) {
 	if ((UA_Int32) (*offset + sizeof(UA_UInt32)) > dst->length)
@@ -255,7 +223,6 @@ UA_StatusCode UA_UInt32_decodeBinary(UA_ByteString const *src,
 UA_TYPE_BINARY_ENCODING_AS(UA_Int64, UA_UInt64)
 
 /* UInt64 */
-UA_TYPE_CALCSIZEBINARY_MEMSIZE(UA_UInt64)
 UA_StatusCode UA_UInt64_encodeBinary(UA_UInt64 const *src, UA_ByteString *dst,
 		size_t *UA_RESTRICT offset) {
 	if ((UA_Int32) (*offset + sizeof(UA_UInt64)) > dst->length)
@@ -379,14 +346,8 @@ UA_StatusCode UA_Double_decodeBinary(UA_ByteString const *src, size_t *offset,
 UA_TYPE_BINARY_ENCODING_AS(UA_Float, UA_UInt32)
 UA_TYPE_BINARY_ENCODING_AS(UA_Double, UA_UInt64)
 #endif /* UA_MIXED_ENDIAN */
-/* String */
-size_t UA_String_calcSizeBinary(UA_String const *string) {
-	if (string->length > 0)
-		return sizeof(UA_Int32) + (string->length * sizeof(UA_Byte));
-	else
-		return sizeof(UA_Int32);
-}
 
+/* String */
 UA_StatusCode UA_String_encodeBinary(UA_String const *src, UA_ByteString *dst,
 		size_t *UA_RESTRICT offset) {
 	UA_Int32 end = *offset + 4;
@@ -433,10 +394,6 @@ UA_StatusCode UA_String_decodeBinary(UA_ByteString const *src,
 UA_TYPE_BINARY_ENCODING_AS(UA_DateTime, UA_Int64)
 
 /* Guid */
-size_t UA_Guid_calcSizeBinary(UA_Guid const *p) {
-	return 16;
-}
-
 UA_StatusCode UA_Guid_encodeBinary(UA_Guid const *src, UA_ByteString * dst,
 		size_t *UA_RESTRICT offset) {
 	UA_StatusCode retval = UA_UInt32_encodeBinary(&src->data1, dst, offset);
@@ -467,42 +424,9 @@ UA_TYPE_BINARY_ENCODING_AS(UA_ByteString, UA_String)
 UA_TYPE_BINARY_ENCODING_AS(UA_XmlElement, UA_String)
 
 /* NodeId */
-
-/* The shortened numeric nodeid types. */
 #define UA_NODEIDTYPE_TWOBYTE 0
 #define UA_NODEIDTYPE_FOURBYTE 1
 
-size_t UA_NodeId_calcSizeBinary(UA_NodeId const *p) {
-	size_t length = 0;
-	switch (p->identifierType) {
-	case UA_NODEIDTYPE_NUMERIC:
-		if (p->identifier.numeric > UA_UINT16_MAX
-				|| p->namespaceIndex > UA_BYTE_MAX)
-			length = sizeof(UA_Byte) + sizeof(UA_UInt16) + sizeof(UA_UInt32);
-		else if (p->identifier.numeric > UA_BYTE_MAX || p->namespaceIndex > 0)
-			length = 4; /* UA_NODEIDTYPE_FOURBYTE */
-		else
-			length = 2; /* UA_NODEIDTYPE_TWOBYTE*/
-		break;
-	case UA_NODEIDTYPE_STRING:
-		length = sizeof(UA_Byte) + sizeof(UA_UInt16)
-				+ UA_String_calcSizeBinary(&p->identifier.string);
-		break;
-	case UA_NODEIDTYPE_GUID:
-		length = sizeof(UA_Byte) + sizeof(UA_UInt16)
-				+ UA_Guid_calcSizeBinary(&p->identifier.guid);
-		break;
-	case UA_NODEIDTYPE_BYTESTRING:
-		length = sizeof(UA_Byte) + sizeof(UA_UInt16)
-				+ UA_ByteString_calcSizeBinary(&p->identifier.byteString);
-		break;
-	default:
-		UA_assert(UA_FALSE); // this must never happen
-		break;
-	}
-	return length;
-}
-
 static UA_StatusCode UA_NodeId_encodeBinary_nodeid_offset(UA_NodeId const *src,
 		UA_ByteString * dst, size_t *UA_RESTRICT offset, UA_Int32 nodeid_offset) {
 	UA_StatusCode retval = UA_STATUSCODE_GOOD;
@@ -623,15 +547,6 @@ UA_StatusCode UA_NodeId_decodeBinary(UA_ByteString const *src,
 }
 
 /* ExpandedNodeId */
-size_t UA_ExpandedNodeId_calcSizeBinary(UA_ExpandedNodeId const *p) {
-	size_t length = UA_NodeId_calcSizeBinary(&p->nodeId);
-	if (p->namespaceUri.length > 0)
-		length += UA_String_calcSizeBinary(&p->namespaceUri);
-	if (p->serverIndex > 0)
-		length += sizeof(UA_UInt32);
-	return length;
-}
-
 #define UA_EXPANDEDNODEID_NAMESPACEURI_FLAG 0x80
 #define UA_EXPANDEDNODEID_SERVERINDEX_FLAG 0x40
 
@@ -679,13 +594,6 @@ UA_StatusCode UA_ExpandedNodeId_decodeBinary(UA_ByteString const *src,
 UA_TYPE_BINARY_ENCODING_AS(UA_StatusCode, UA_UInt32)
 
 /* QualifiedName */
-size_t UA_QualifiedName_calcSizeBinary(UA_QualifiedName const *p) {
-	size_t length = sizeof(UA_UInt16); //qualifiedName->namespaceIndex
-	// length += sizeof(UA_UInt16); //qualifiedName->reserved
-	length += UA_String_calcSizeBinary(&p->name); //qualifiedName->name
-	return length;
-}
-
 UA_StatusCode UA_QualifiedName_decodeBinary(UA_ByteString const *src,
 		size_t *UA_RESTRICT offset, UA_QualifiedName *dst) {
 	UA_QualifiedName_init(dst);
@@ -709,15 +617,6 @@ UA_StatusCode UA_QualifiedName_encodeBinary(UA_QualifiedName const *src,
 #define UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE 0x01
 #define UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT 0x02
 
-size_t UA_LocalizedText_calcSizeBinary(UA_LocalizedText const *p) {
-	size_t length = 1; // for encodingMask
-	if (p->locale.data != UA_NULL)
-		length += UA_String_calcSizeBinary(&p->locale);
-	if (p->text.data != UA_NULL)
-		length += UA_String_calcSizeBinary(&p->text);
-	return length;
-}
-
 UA_StatusCode UA_LocalizedText_encodeBinary(UA_LocalizedText const *src,
 		UA_ByteString * dst, size_t *UA_RESTRICT offset) {
 	UA_Byte encodingMask = 0;
@@ -748,25 +647,6 @@ UA_StatusCode UA_LocalizedText_decodeBinary(UA_ByteString const *src,
 }
 
 /* ExtensionObject */
-size_t UA_ExtensionObject_calcSizeBinary(UA_ExtensionObject const *p) {
-	size_t length = UA_NodeId_calcSizeBinary(&p->typeId);
-	length += 1; // encoding
-	switch (p->encoding) {
-	case UA_EXTENSIONOBJECT_ENCODINGMASK_NOBODYISENCODED:
-		break;
-	case UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING:
-		length += UA_ByteString_calcSizeBinary(&p->body);
-		break;
-	case UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISXML:
-		length += UA_XmlElement_calcSizeBinary(
-				(const UA_XmlElement *) &p->body);
-		break;
-	default:
-		UA_assert(UA_FALSE);
-	}
-	return length;
-}
-
 UA_StatusCode UA_ExtensionObject_encodeBinary(UA_ExtensionObject const *src,
 		UA_ByteString * dst, size_t *UA_RESTRICT offset) {
 	UA_StatusCode retval = UA_NodeId_encodeBinary(&src->typeId, dst, offset);
@@ -816,23 +696,6 @@ UA_StatusCode UA_ExtensionObject_decodeBinary(UA_ByteString const *src,
 }
 
 /* DataValue */
-size_t UA_DataValue_calcSizeBinary(UA_DataValue const *p) {
-	size_t length = sizeof(UA_Byte);
-	if (p->hasValue)
-		length += UA_Variant_calcSizeBinary(&p->value);
-	if (p->hasStatus)
-		length += sizeof(UA_UInt32);
-	if (p->hasSourceTimestamp)
-		length += sizeof(UA_DateTime);
-	if (p->hasSourcePicoseconds)
-		length += sizeof(UA_Int16);
-	if (p->hasServerTimestamp)
-		length += sizeof(UA_DateTime);
-	if (p->hasServerPicoseconds)
-		length += sizeof(UA_Int16);
-	return length;
-}
-
 UA_StatusCode UA_DataValue_encodeBinary(UA_DataValue const *src,
 		UA_ByteString *dst, size_t *UA_RESTRICT offset) {
 	UA_StatusCode retval = UA_Byte_encodeBinary((const UA_Byte*) src, dst,
@@ -896,31 +759,6 @@ enum UA_VARIANT_ENCODINGMASKTYPE_enum {
 	UA_VARIANT_ENCODINGMASKTYPE_ARRAY = (0x01 << 7)      // bit 7
 };
 
-size_t UA_Variant_calcSizeBinary(UA_Variant const *p) {
-	UA_Boolean isArray = p->arrayLength != -1 || !p->data; // a single element is not an array
-	UA_Boolean hasDimensions = isArray && p->arrayDimensions != UA_NULL;
-	UA_Boolean isBuiltin = p->type->namespaceZero
-			&& UA_IS_BUILTIN(p->type->typeIndex);
-	size_t length = sizeof(UA_Byte); //p->encodingMask
-	UA_Int32 arrayLength = p->arrayLength;
-	if (!isArray) {
-		arrayLength = 1;
-		length += UA_calcSizeBinary(p->data, p->type);
-	} else
-		length += UA_Array_calcSizeBinary(p->data, arrayLength, p->type);
-
-	// if the type is not builtin, we encode it as an extensionobject
-	if (!isBuiltin) {
-		if (arrayLength > 0)
-			length += 9 * arrayLength; // overhead for extensionobjects: 4 byte nodeid + 1 byte
-									   // encoding + 4 byte bytestring length
-	}
-	if (hasDimensions)
-		length += UA_Array_calcSizeBinary(p->arrayDimensions,
-				p->arrayDimensionsSize, &UA_TYPES[UA_TYPES_INT32]);
-	return length;
-}
-
 UA_StatusCode UA_Variant_encodeBinary(UA_Variant const *src, UA_ByteString *dst,
 		size_t *UA_RESTRICT offset) {
 	UA_Byte encodingByte = 0;
@@ -1065,25 +903,6 @@ UA_StatusCode UA_Variant_decodeBinary(UA_ByteString const *src,
 }
 
 /* DiagnosticInfo */
-size_t UA_DiagnosticInfo_calcSizeBinary(UA_DiagnosticInfo const *ptr) {
-	size_t length = sizeof(UA_Byte);
-	if (ptr->hasSymbolicId)
-		length += sizeof(UA_Int32);
-	if (ptr->hasNamespaceUri)
-		length += sizeof(UA_Int32);
-	if (ptr->hasLocalizedText)
-		length += sizeof(UA_Int32);
-	if (ptr->hasLocale)
-		length += sizeof(UA_Int32);
-	if (ptr->hasAdditionalInfo)
-		length += UA_String_calcSizeBinary(&ptr->additionalInfo);
-	if (ptr->hasInnerStatusCode)
-		length += sizeof(UA_StatusCode);
-	if (ptr->hasInnerDiagnosticInfo)
-		length += UA_DiagnosticInfo_calcSizeBinary(ptr->innerDiagnosticInfo);
-	return length;
-}
-
 UA_StatusCode UA_DiagnosticInfo_encodeBinary(const UA_DiagnosticInfo *src,
 		UA_ByteString * dst, size_t *UA_RESTRICT offset) {
 	UA_StatusCode retval = UA_Byte_encodeBinary((const UA_Byte *) src, dst,
@@ -1148,95 +967,6 @@ UA_StatusCode UA_DiagnosticInfo_decodeBinary(UA_ByteString const *src,
 /* Structured Types */
 /********************/
 
-size_t UA_calcSizeBinary(const void *p, const UA_DataType *dataType) {
-	size_t size = 0;
-	uintptr_t ptr = (uintptr_t) p;
-	UA_Byte membersSize = dataType->membersSize;
-	for (size_t i = 0; i < membersSize; i++) {
-		const UA_DataTypeMember *member = &dataType->members[i];
-		const UA_DataType *memberType;
-		if (member->namespaceZero)
-			memberType = &UA_TYPES[member->memberTypeIndex];
-		else
-			memberType =
-					&dataType[member->memberTypeIndex - dataType->typeIndex];
-
-		if (member->isArray) {
-			ptr += (member->padding >> 3);
-			const UA_Int32 noElements = *((const UA_Int32*) ptr);
-			ptr += sizeof(UA_Int32) + (member->padding & 0x07);
-			size += UA_Array_calcSizeBinary(*(void * const *) ptr, noElements,
-					memberType);
-			ptr += sizeof(void*);
-			continue;
-		}
-
-		ptr += member->padding;
-		if (!member->namespaceZero) {
-			size += UA_calcSizeBinary((const void*) ptr, memberType);
-			ptr += memberType->memSize;
-			continue;
-		}
-
-		switch (member->memberTypeIndex) {
-		case UA_TYPES_BOOLEAN:
-		case UA_TYPES_SBYTE:
-		case UA_TYPES_BYTE:
-			size += 1;
-			break;
-		case UA_TYPES_INT16:
-		case UA_TYPES_UINT16:
-			size += 2;
-			break;
-		case UA_TYPES_INT32:
-		case UA_TYPES_UINT32:
-		case UA_TYPES_STATUSCODE:
-		case UA_TYPES_FLOAT:
-			size += 4;
-			break;
-		case UA_TYPES_INT64:
-		case UA_TYPES_UINT64:
-		case UA_TYPES_DOUBLE:
-		case UA_TYPES_DATETIME:
-			size += 8;
-			break;
-		case UA_TYPES_GUID:
-			size += 16;
-			break;
-		case UA_TYPES_NODEID:
-			size += UA_NodeId_calcSizeBinary((const UA_NodeId*) ptr);
-			break;
-		case UA_TYPES_EXPANDEDNODEID:
-			size += UA_ExpandedNodeId_calcSizeBinary(
-					(const UA_ExpandedNodeId*) ptr);
-			break;
-		case UA_TYPES_LOCALIZEDTEXT:
-			size += UA_LocalizedText_calcSizeBinary(
-					(const UA_LocalizedText*) ptr);
-			break;
-		case UA_TYPES_EXTENSIONOBJECT:
-			size += UA_ExtensionObject_calcSizeBinary(
-					(const UA_ExtensionObject*) ptr);
-			break;
-		case UA_TYPES_DATAVALUE:
-			size += UA_DataValue_calcSizeBinary((const UA_DataValue*) ptr);
-			break;
-		case UA_TYPES_VARIANT:
-			size += UA_Variant_calcSizeBinary((const UA_Variant*) ptr);
-			break;
-		case UA_TYPES_DIAGNOSTICINFO:
-			size += UA_DiagnosticInfo_calcSizeBinary(
-					(const UA_DiagnosticInfo*) ptr);
-			break;
-		default:
-			// UA_TYPES_QUALIFIEDNAME, UA_TYPES_STRING, UA_TYPES_BYTESTRING, UA_TYPES_XMLELEMENT:
-			size += UA_calcSizeBinary((const void*) ptr, memberType);
-		}
-		ptr += memberType->memSize;
-	}
-	return size;
-}
-
 UA_StatusCode UA_encodeBinary(const void *src, const UA_DataType *dataType,
 		UA_ByteString *dst, size_t *UA_RESTRICT offset) {
 	uintptr_t ptr = (uintptr_t) src;
@@ -1403,27 +1133,22 @@ UA_StatusCode UA_decodeBinary(const UA_ByteString *src,
 			retval = UA_NodeId_decodeBinary(src, offset, (UA_NodeId*) ptr);
 			break;
 		case UA_TYPES_EXPANDEDNODEID:
-			retval = UA_ExpandedNodeId_decodeBinary(src, offset,
-					(UA_ExpandedNodeId*) ptr);
+			retval = UA_ExpandedNodeId_decodeBinary(src, offset, (UA_ExpandedNodeId*) ptr);
 			break;
 		case UA_TYPES_LOCALIZEDTEXT:
-			retval = UA_LocalizedText_decodeBinary(src, offset,
-					(UA_LocalizedText*) ptr);
+			retval = UA_LocalizedText_decodeBinary(src, offset, (UA_LocalizedText*) ptr);
 			break;
 		case UA_TYPES_EXTENSIONOBJECT:
-			retval = UA_ExtensionObject_decodeBinary(src, offset,
-					(UA_ExtensionObject*) ptr);
+			retval = UA_ExtensionObject_decodeBinary(src, offset, (UA_ExtensionObject*) ptr);
 			break;
 		case UA_TYPES_DATAVALUE:
-			retval = UA_DataValue_decodeBinary(src, offset,
-					(UA_DataValue*) ptr);
+			retval = UA_DataValue_decodeBinary(src, offset, (UA_DataValue*) ptr);
 			break;
 		case UA_TYPES_VARIANT:
 			retval = UA_Variant_decodeBinary(src, offset, (UA_Variant*) ptr);
 			break;
 		case UA_TYPES_DIAGNOSTICINFO:
-			retval = UA_DiagnosticInfo_decodeBinary(src, offset,
-					(UA_DiagnosticInfo*) ptr);
+			retval = UA_DiagnosticInfo_decodeBinary(src, offset, (UA_DiagnosticInfo*) ptr);
 			break;
 		default:
 			// UA_TYPES_QUALIFIEDNAME, UA_TYPES_STRING, UA_TYPES_BYTESTRING, UA_TYPES_XMLELEMENT:

src/ua_types_encoding_binary.h

@@ -16,9 +16,6 @@
  * All datatypes have similar functions with a common postfix. DO NOT CALL THESE
  * FUNCTIONS WITH NULL-POINTERS IF IT IS NOT EXPLICITLY PERMITTED.
  *
- * - _calcSize: Returns the size of the (encoded) variable in bytes. This length
- *   is used to allocate the bytestring for later encoding.
- *
  * - _encode: Encodes a variable into a bytestring. If an error occurs
  *   (indicated by the return value), the bytestring may be left in an
  *   inconsistent state.
@@ -32,7 +29,6 @@
  */
 
 #define UA_TYPE_BINARY_ENCODING(TYPE)                                   \
-    size_t TYPE##_calcSizeBinary(TYPE const *p);                        \
     UA_StatusCode TYPE##_encodeBinary(TYPE const *src, UA_ByteString *dst, size_t *UA_RESTRICT offset); \
     UA_StatusCode TYPE##_decodeBinary(UA_ByteString const *src, size_t *UA_RESTRICT offset, TYPE *dst);
 
@@ -62,11 +58,10 @@ UA_TYPE_BINARY_ENCODING(UA_DataValue)
 UA_TYPE_BINARY_ENCODING(UA_Variant)
 UA_TYPE_BINARY_ENCODING(UA_DiagnosticInfo)
 
-size_t UA_calcSizeBinary(const void *p, const UA_DataType *dataType);
 UA_StatusCode UA_encodeBinary(const void *src, const UA_DataType *dataType, UA_ByteString *dst,
                               size_t *UA_RESTRICT offset);
 UA_StatusCode UA_decodeBinary(const UA_ByteString *src, size_t * UA_RESTRICT offset, void *dst,
                               const UA_DataType *dataType);
-/// @} /* end of group */
+/// @}
 
 #endif /* UA_TYPES_ENCODING_BINARY_H_ */

tests/check_builtin.c

@@ -14,303 +14,6 @@ enum UA_VARIANT_ENCODINGMASKTYPE_enum {
 	UA_VARIANT_ENCODINGMASKTYPE_ARRAY       = (0x01 << 7)      // bit 7
 };
 
-START_TEST(UA_ExtensionObject_calcSizeShallWorkOnExample) {
-	// given
-	UA_Byte data[3] = { 1, 2, 3 };
-	UA_ExtensionObject extensionObject;
-
-	// empty ExtensionObject, handcoded
-	// when
-	UA_ExtensionObject_init(&extensionObject);
-	extensionObject.typeId.identifierType = UA_NODEIDTYPE_NUMERIC;
-	extensionObject.typeId.identifier.numeric = 0;
-	extensionObject.encoding = UA_EXTENSIONOBJECT_ENCODINGMASK_NOBODYISENCODED;
-	// then
-	ck_assert_int_eq(UA_ExtensionObject_calcSizeBinary(&extensionObject), 1 + 1 + 1);
-
-	// ExtensionObject with ByteString-Body
-	// when
-	extensionObject.encoding    = UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING;
-	extensionObject.body.data   = data;
-	extensionObject.body.length = 3;
-	// then
-	ck_assert_int_eq(UA_ExtensionObject_calcSizeBinary(&extensionObject), 3 + 4 + 3);
-}
-END_TEST
-
-START_TEST(UA_DataValue_calcSizeShallWorkOnExample) {
-	// given
-	UA_DataValue dataValue;
-    UA_DataValue_init(&dataValue);
-	dataValue.status       = 12;
-    dataValue.hasStatus = UA_TRUE;
-	dataValue.sourceTimestamp = 80;
-    dataValue.hasSourceTimestamp = UA_TRUE;
-	dataValue.sourcePicoseconds = 214;
-    dataValue.hasSourcePicoseconds = UA_TRUE;
-	int size = 0;
-	// when
-	size = UA_DataValue_calcSizeBinary(&dataValue);
-	// then
-    // 1 (bitfield) + 4 (status) + 8 (timestamp) + 2 (picoseconds)
-	ck_assert_int_eq(size, 15);
-}
-END_TEST
-
-START_TEST(UA_DiagnosticInfo_calcSizeShallWorkOnExample) {
-	// given
-	UA_DiagnosticInfo diagnosticInfo;
-    UA_DiagnosticInfo_init(&diagnosticInfo);
-	diagnosticInfo.symbolicId    = 30;
-    diagnosticInfo.hasSymbolicId = UA_TRUE;
-	diagnosticInfo.namespaceUri  = 25;
-    diagnosticInfo.hasNamespaceUri = UA_TRUE;
-	diagnosticInfo.localizedText = 22;
-    diagnosticInfo.hasLocalizedText = UA_TRUE;
-	UA_Byte additionalInfoData = 'd';
-	diagnosticInfo.additionalInfo.data = &additionalInfoData; //"OPCUA";
-	diagnosticInfo.additionalInfo.length = 1;
-    diagnosticInfo.hasAdditionalInfo = UA_TRUE;
-	// when & then
-    // 1 (bitfield) + 4 (symbolic id) + 4 (namespaceuri) + 4 (localizedtext) + 5 (additionalinfo)
-	ck_assert_int_eq(UA_DiagnosticInfo_calcSizeBinary(&diagnosticInfo), 18);
-}
-END_TEST
-
-START_TEST(UA_String_calcSizeWithNegativLengthShallReturnEncodingSize) {
-	// given
-	UA_String arg = { -1, UA_NULL };
-	// when
-	UA_UInt32 encodingSize = UA_String_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 4);
-}
-END_TEST
-
-START_TEST(UA_String_calcSizeWithNegativLengthAndValidPointerShallReturnEncodingSize) {
-	// given
-	UA_String arg = { -1, (UA_Byte *)"OPC" };
-	// when
-	UA_UInt32 encodingSize = UA_String_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 4);
-}
-END_TEST
-
-START_TEST(UA_String_calcSizeWithZeroLengthShallReturnEncodingSize) {
-	// given
-	UA_String arg = { 0, UA_NULL };
-	// when
-	UA_UInt32 encodingSize = UA_String_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 4);
-}
-END_TEST
-
-START_TEST(UA_String_calcSizeWithZeroLengthAndValidPointerShallReturnEncodingSize) {
-	// given
-	UA_String arg = { 0, (UA_Byte *)"OPC" };
-	// when
-	UA_UInt32 encodingSize = UA_String_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 4);
-}
-END_TEST
-
-START_TEST(UA_String_calcSizeShallReturnEncodingSize) {
-	// given
-	UA_String arg = { 3, (UA_Byte *)"OPC" };
-	// when
-	UA_UInt32 encodingSize = UA_String_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 4+3);
-}
-END_TEST
-
-START_TEST(UA_NodeId_calcSizeEncodingTwoByteShallReturnEncodingSize) {
-	// given
-	UA_NodeId arg;
-	arg.identifierType = UA_NODEIDTYPE_NUMERIC;
-	arg.namespaceIndex = 0;
-	arg.identifier.numeric = 1;
-	// when
-	UA_UInt32 encodingSize = UA_NodeId_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 2);
-}
-END_TEST
-
-START_TEST(UA_NodeId_calcSizeEncodingFourByteShallReturnEncodingSize) {
-	// given
-	UA_NodeId arg;
-	arg.identifierType = UA_NODEIDTYPE_NUMERIC;
-	arg.namespaceIndex = 1;
-	arg.identifier.numeric = 1;
-	// when
-	UA_UInt32 encodingSize = UA_NodeId_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 4);
-}
-END_TEST
-
-START_TEST(UA_NodeId_calcSizeEncodingStringShallReturnEncodingSize) {
-	// given
-	UA_NodeId arg;
-	arg.identifierType = UA_NODEIDTYPE_STRING;
-	arg.identifier.string.length = 3;
-	arg.identifier.string.data   = (UA_Byte *)"PLT";
-	// when
-	UA_UInt32 encodingSize = UA_NodeId_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 1+2+4+3);
-}
-END_TEST
-
-START_TEST(UA_NodeId_calcSizeEncodingStringNegativLengthShallReturnEncodingSize) {
-	// given
-	UA_NodeId arg;
-	arg.identifierType = UA_NODEIDTYPE_STRING;
-	arg.identifier.string.length = -1;
-	// when
-	UA_UInt32 encodingSize = UA_NodeId_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 1+2+4+0);
-}
-END_TEST
-
-START_TEST(UA_NodeId_calcSizeEncodingStringZeroLengthShallReturnEncodingSize) {
-	// given
-	UA_NodeId arg;
-	arg.identifierType = UA_NODEIDTYPE_STRING;
-	arg.identifier.string.length = 0;
-	// when
-	UA_UInt32 encodingSize = UA_NodeId_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 1+2+4+0);
-}
-END_TEST
-
-START_TEST(UA_ExpandedNodeId_calcSizeEncodingStringAndServerIndexShallReturnEncodingSize) {
-	// given
-	UA_ExpandedNodeId arg;
-	UA_ExpandedNodeId_init(&arg);
-	arg.nodeId.identifierType = UA_NODEIDTYPE_STRING;
-	arg.serverIndex = 1;
-	arg.nodeId.identifier.string.length = 3;
-	// when
-	UA_UInt32 encodingSize = UA_ExpandedNodeId_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 1+2+4+3+4);
-}
-END_TEST
-
-START_TEST(UA_ExpandedNodeId_calcSizeEncodingStringAndNamespaceUriShallReturnEncodingSize) {
-	// given
-	UA_ExpandedNodeId arg;
-	UA_ExpandedNodeId_init(&arg);
-	arg.nodeId.identifierType = UA_NODEIDTYPE_STRING;
-	arg.nodeId.identifier.string.length = 3;
-	arg.namespaceUri.length = 7;
-	// when
-	UA_UInt32 encodingSize = UA_ExpandedNodeId_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 1+2+4+3+4+7);
-}
-END_TEST
-
-START_TEST(UA_Guid_calcSizeShallReturnEncodingSize) {
-	// given
-	UA_Guid   arg;
-	// when
-	UA_UInt32 encodingSize = UA_Guid_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 16);
-}
-END_TEST
-
-START_TEST(UA_LocalizedText_calcSizeTextOnlyShallReturnEncodingSize) {
-	// given
-	UA_LocalizedText arg;
-	UA_LocalizedText_init(&arg);
-	arg.text = (UA_String) {8, (UA_Byte *)"12345678"};
-	// when
-	UA_UInt32 encodingSize = UA_LocalizedText_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 1+4+8);
-	// finally
-	UA_LocalizedText_init(&arg); // do not delete text
-	UA_LocalizedText_deleteMembers(&arg);
-}
-END_TEST
-
-START_TEST(UA_LocalizedText_calcSizeLocaleOnlyShallReturnEncodingSize) {
-	// given
-	UA_LocalizedText arg;
-	UA_LocalizedText_init(&arg);
-	arg.locale = (UA_String) {8, (UA_Byte *)"12345678"};
-	// when
-	UA_UInt32 encodingSize = UA_LocalizedText_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 1+4+8);
-	UA_LocalizedText_init(&arg); // do not delete locale
-	UA_LocalizedText_deleteMembers(&arg);
-}
-END_TEST
-
-START_TEST(UA_LocalizedText_calcSizeTextAndLocaleShallReturnEncodingSize) {
-	// given
-	UA_LocalizedText arg;
-	UA_LocalizedText_init(&arg);
-	arg.locale = (UA_String) {8, (UA_Byte *)"12345678"};
-	arg.text = (UA_String) {8, (UA_Byte *)"12345678"};
-	// when
-	UA_UInt32 encodingSize = UA_LocalizedText_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 1+4+8+4+8);
-	UA_LocalizedText_init(&arg); // do not delete locale and text
-	UA_LocalizedText_deleteMembers(&arg);
-}
-END_TEST
-
-START_TEST(UA_Variant_calcSizeFixedSizeArrayShallReturnEncodingSize) {
-	// given
-	UA_Variant arg;
-	UA_Variant_init(&arg);
-    arg.type = &UA_TYPES[UA_TYPES_INT32];
-#define ARRAY_LEN 8
-	arg.arrayLength = ARRAY_LEN;
-	UA_Int32 *data[ARRAY_LEN];
-	arg.data = (void *)data;
-
-	// when
-	UA_UInt32 encodingSize = UA_Variant_calcSizeBinary(&arg);
-
-	// then
-	ck_assert_int_eq(encodingSize, 1+4+ARRAY_LEN*4);
-#undef ARRAY_LEN
-}
-END_TEST
-
-START_TEST(UA_Variant_calcSizeVariableSizeArrayShallReturnEncodingSize) {
-	// given
-	UA_Variant arg;
-	UA_Variant_init(&arg);
-	arg.type = &UA_TYPES[UA_TYPES_STRING];
-#define ARRAY_LEN 3
-	arg.arrayLength = ARRAY_LEN;
-	UA_String strings[3];
-	strings[0] = (UA_String) {-1, UA_NULL };
-	strings[1] = (UA_String) {3, (UA_Byte *)"PLT" };
-	strings[2] = (UA_String) {47, UA_NULL };
-	arg.data   = (void *)strings;
-	// when
-	UA_UInt32 encodingSize = UA_Variant_calcSizeBinary(&arg);
-	// then
-	ck_assert_int_eq(encodingSize, 1+4+(4+0)+(4+3)+(4+47));
-#undef ARRAY_LEN
-}
-END_TEST
-
 START_TEST(UA_Byte_decodeShallCopyAndAdvancePosition) {
 	// given
 	UA_Byte dst;
@@ -1619,16 +1322,17 @@ START_TEST(UA_ExtensionObject_encodeDecodeShallWorkOnExtensionObject) {
 	varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_DATATYPE;
 	varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_VALUE;
 	varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_USERWRITEMASK;
+
 	/* wrap it into a extension object attributes */
 	UA_ExtensionObject extensionObject;
 	UA_ExtensionObject_init(&extensionObject);
 	extensionObject.typeId = UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES].typeId;
 	UA_Byte extensionData[50];
-	extensionObject.body = (UA_ByteString){.data = extensionData, .length=UA_VariableAttributes_calcSizeBinary(&varAttr)};
+	extensionObject.body = (UA_ByteString){.data = extensionData, .length=50};
 	size_t posEncode = 0;
 	UA_VariableAttributes_encodeBinary(&varAttr, &extensionObject.body, &posEncode);
+    extensionObject.body.length = posEncode;
 	extensionObject.encoding = UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING;
-	ck_assert_int_eq(posEncode, UA_VariableAttributes_calcSizeBinary(&varAttr));
 
 	UA_Byte data[50];
 	UA_ByteString dst = {.data = data, .length=50};
@@ -1659,32 +1363,6 @@ END_TEST
 static Suite *testSuite_builtin(void) {
 	Suite *s = suite_create("Built-in Data Types 62541-6 Table 1");
 
-	TCase *tc_calcSize = tcase_create("calcSize");
-	tcase_add_test(tc_calcSize, UA_ExtensionObject_calcSizeShallWorkOnExample);
-	tcase_add_test(tc_calcSize, UA_DataValue_calcSizeShallWorkOnExample);
-	tcase_add_test(tc_calcSize, UA_DiagnosticInfo_calcSizeShallWorkOnExample);
-	tcase_add_test(tc_calcSize, UA_String_calcSizeShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_String_calcSizeWithNegativLengthShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_String_calcSizeWithNegativLengthAndValidPointerShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_String_calcSizeWithZeroLengthShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_String_calcSizeWithZeroLengthAndValidPointerShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_NodeId_calcSizeEncodingTwoByteShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_NodeId_calcSizeEncodingFourByteShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_NodeId_calcSizeEncodingStringShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_NodeId_calcSizeEncodingStringNegativLengthShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_NodeId_calcSizeEncodingStringZeroLengthShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_ExpandedNodeId_calcSizeEncodingStringAndServerIndexShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_ExpandedNodeId_calcSizeEncodingStringAndNamespaceUriShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_Guid_calcSizeShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_Guid_calcSizeShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_LocalizedText_calcSizeTextOnlyShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_LocalizedText_calcSizeLocaleOnlyShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_LocalizedText_calcSizeTextAndLocaleShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_Variant_calcSizeFixedSizeArrayShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_Variant_calcSizeVariableSizeArrayShallReturnEncodingSize);
-	tcase_add_test(tc_calcSize, UA_Variant_decodeWithOutDeleteMembersShallFailInCheckMem);
-	suite_add_tcase(s, tc_calcSize);
-
 	TCase *tc_decode = tcase_create("decode");
 	tcase_add_test(tc_decode, UA_Byte_decodeShallCopyAndAdvancePosition);
 	tcase_add_test(tc_decode, UA_Byte_decodeShallModifyOnlyCurrentPosition);

tests/check_memory.c

@@ -51,8 +51,9 @@ START_TEST(encodeShallYieldDecode) {
 	UA_ByteString msg1, msg2;
 	size_t pos = 0;
 	void *obj1 = UA_new(&UA_TYPES[_i]);
-	UA_ByteString_newMembers(&msg1, UA_calcSizeBinary(obj1, &UA_TYPES[_i]));
+	UA_ByteString_newMembers(&msg1, 65000); // fixed buf size
     UA_StatusCode retval = UA_encodeBinary(obj1, &UA_TYPES[_i], &msg1, &pos);
+    msg1.length = pos;
 	if(retval != UA_STATUSCODE_GOOD) {
 		UA_delete(obj1, &UA_TYPES[_i]);
 		UA_ByteString_deleteMembers(&msg1);
@@ -63,13 +64,15 @@ START_TEST(encodeShallYieldDecode) {
 	void *obj2 = UA_new(&UA_TYPES[_i]);
 	pos = 0; retval = UA_decodeBinary(&msg1, &pos, obj2, &UA_TYPES[_i]);
 	ck_assert_msg(retval == UA_STATUSCODE_GOOD, "messages differ idx=%d,nodeid=%i", _i, UA_TYPES[_i].typeId.identifier.numeric);
-	retval = UA_ByteString_newMembers(&msg2, UA_calcSizeBinary(obj2, &UA_TYPES[_i]));
+	retval = UA_ByteString_newMembers(&msg2, 65000);
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 	pos = 0; retval = UA_encodeBinary(obj2, &UA_TYPES[_i], &msg2, &pos);
+    msg2.length = pos;
 	ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
 
 	// then
-	ck_assert_msg(UA_ByteString_equal(&msg1, &msg2) == UA_TRUE, "messages differ idx=%d,nodeid=%i", _i, UA_TYPES[_i].typeId.identifier.numeric);
+	ck_assert_msg(UA_ByteString_equal(&msg1, &msg2) == UA_TRUE, "messages differ idx=%d,nodeid=%i", _i,
+                  UA_TYPES[_i].typeId.identifier.numeric);
 
 	// finally
 	UA_delete(obj1, &UA_TYPES[_i]);
@@ -84,7 +87,7 @@ START_TEST(decodeShallFailWithTruncatedBufferButSurvive) {
 	UA_ByteString msg1;
 	void *obj1 = UA_new(&UA_TYPES[_i]);
 	size_t pos = 0;
-	UA_ByteString_newMembers(&msg1, UA_calcSizeBinary(obj1, &UA_TYPES[_i]));
+	UA_ByteString_newMembers(&msg1, 65000); // fixed buf size
     UA_StatusCode retval = UA_encodeBinary(obj1, &UA_TYPES[_i], &msg1, &pos);
 	UA_delete(obj1, &UA_TYPES[_i]);
     if(retval != UA_STATUSCODE_GOOD) {
@@ -94,7 +97,7 @@ START_TEST(decodeShallFailWithTruncatedBufferButSurvive) {
 	// when
 	void *obj2 = UA_new(&UA_TYPES[_i]);
 	pos = 0;
-	msg1.length = msg1.length / 2;
+	msg1.length = pos / 2;
 	//fprintf(stderr,"testing %s with half buffer\n",UA_TYPES[_i].name);
 	UA_decodeBinary(&msg1, &pos, obj2, &UA_TYPES[_i]);
 	//then

tests/check_stack.c

@@ -558,26 +558,6 @@ START_TEST(UA_SecureConversationMessageFooter_copyShallWorkOnInputExample) {
 }
 END_TEST
 
-START_TEST(UA_SecureConversationMessageFooter_calcSizeBinaryShallWorkOnInputExample) {
-	// given
-	UA_SecureConversationMessageFooter src;
-	UA_SecureConversationMessageFooter_init(&src);
-	UA_Byte srcByte[3] = {24, 57, 87};
-	src.padding = srcByte;
-	src.paddingSize = 3;
-	src.signature = 5;
-
-	const UA_SecureConversationMessageFooter srcConst = src;
-
-	UA_Int32 ret;
-
-	// when
-	ret = UA_SecureConversationMessageFooter_calcSizeBinary(&srcConst);
-	// then
-	ck_assert_int_eq(ret, 8);
-}
-END_TEST
-
 START_TEST(UA_SecureConversationMessageFooter_encodeBinaryShallWorkOnInputExample) {
 //	// given
 //	UA_SecureConversationMessageFooter src = {3, (UA_Byte*)"447", 5};;
@@ -639,7 +619,6 @@ Suite *testSuite() {
 	tcase_add_test(tc_transport, UA_SecureConversationMessageHeader_copyShallWorkOnInputExample);
 	tcase_add_test(tc_transport, UA_SequenceHeader_copyShallWorkOnInputExample);
 	tcase_add_test(tc_transport, UA_SecureConversationMessageFooter_copyShallWorkOnInputExample);
-	tcase_add_test(tc_transport, UA_SecureConversationMessageFooter_calcSizeBinaryShallWorkOnInputExample);
 	tcase_add_test(tc_transport, UA_SecureConversationMessageFooter_encodeBinaryShallWorkOnInputExample);
 	tcase_add_test(tc_transport, UA_SecureConversationMessageAbortBody_copyShallWorkOnInputExample);
 	suite_add_tcase(s, tc_transport);

tools/generate_datatypes.py

@@ -183,9 +183,8 @@ class EnumerationType(object):
 #define %s_delete(p) UA_Int32_delete((UA_Int32*)p)
 #define %s_deleteMembers(p) UA_Int32_deleteMembers((UA_Int32*)p)
 #define %s_copy(src, dst) UA_Int32_copy((const UA_Int32*)src, (UA_Int32*)dst)
-#define %s_calcSizeBinary(p) UA_Int32_calcSizeBinary((UA_Int32*)p)
 #define %s_encodeBinary(src, dst, offset) UA_Int32_encodeBinary((UA_Int32*)src, dst, offset)
-#define %s_decodeBinary(src, offset, dst) UA_Int32_decodeBinary(src, offset, (UA_Int32*)dst)''' % tuple(itertools.repeat(self.name, 9))
+#define %s_decodeBinary(src, offset, dst) UA_Int32_decodeBinary(src, offset, (UA_Int32*)dst)''' % tuple(itertools.repeat(self.name, 8))
 
 class OpaqueType(object):
     def __init__(self, name, description = ""):
@@ -217,7 +216,6 @@ class OpaqueType(object):
 #define %s_delete UA_ByteString_delete
 #define %s_deleteMembers UA_ByteString_deleteMembers
 #define %s_copy UA_ByteString_copy
-#define %s_calcSizeBinary UA_ByteString_calcSizeBinary
 #define %s_encodeBinary UA_ByteString_encodeBinary
 #define %s_decodeBinary UA_ByteString_decodeBinary''' % tuple(itertools.repeat(self.name, 8))
 
@@ -324,10 +322,9 @@ class StructType(object):
 #define %s_delete(p) UA_delete(p, %s)
 #define %s_deleteMembers(p) UA_deleteMembers(p, %s)
 #define %s_copy(src, dst) UA_copy(src, dst, %s)
-#define %s_calcSizeBinary(p) UA_calcSizeBinary(p, %s)
 #define %s_encodeBinary(src, dst, offset) UA_encodeBinary(src, %s, dst, offset)
 #define %s_decodeBinary(src, offset, dst) UA_decodeBinary(src, offset, dst, %s)''' % \
-    tuple([self.name] + list(itertools.chain(*itertools.repeat([self.name, "&"+typeTableName+"[" + typeTableName + "_" + self.name[3:].upper()+"]"], 8))))
+    tuple([self.name] + list(itertools.chain(*itertools.repeat([self.name, "&"+typeTableName+"[" + typeTableName + "_" + self.name[3:].upper()+"]"], 7))))
 
 def parseTypeDefinitions(xmlDescription, existing_types = OrderedDict()):
     '''Returns an ordered dict that maps names to types. The order is such that