github/open62541
7
0
Fork 0
mirror of https://github.com/open62541/open62541.git synced 2025-06-03 04:00:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat(core): Extend the binary encoding to take encoding options

Browse Source
This commit is contained in:
Julius Pfrommer 2024-08-12 21:27:34 +02:00 committed by Julius Pfrommer
parent b4a1f7c918
commit 28554978c1
24 changed files with 137 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
include/open62541/types.h
View File

@ -1312,10 +1312,17 @@ UA_NamespaceMapping_delete(UA_NamespaceMapping *nm);
* Encoding and decoding routines for the binary format. For the binary decoding
* additional data types can be forwarded. */
typedef struct {
/* Mapping of namespace indices in NodeIds and of NamespaceUris in
* ExpandedNodeIds. */
UA_NamespaceMapping *namespaceMapping;
} UA_EncodeBinaryOptions;
/* Returns the number of bytes the value p takes in binary encoding. Returns
* zero if an error occurs. */
UA_EXPORT size_t
UA_calcSizeBinary(const void *p, const UA_DataType *type);
UA_calcSizeBinary(const void *p, const UA_DataType *type,
UA_EncodeBinaryOptions *options);
/* Encodes a data-structure in the binary format. If outBuf has a length of
* zero, a buffer of the required size is allocated. Otherwise, encoding into
@ -1323,7 +1330,7 @@ UA_calcSizeBinary(const void *p, const UA_DataType *type);
* small). */
UA_EXPORT UA_StatusCode
UA_encodeBinary(const void *p, const UA_DataType *type,
UA_ByteString *outBuf);
UA_ByteString *outBuf, UA_EncodeBinaryOptions *options);
/* The structure with the decoding options may be extended in the future.
* Zero-out the entire structure initially to ensure code-compatibility when
@ -1332,6 +1339,10 @@ typedef struct {
/* Begin of a linked list with custom datatype definitions */
const UA_DataTypeArray *customTypes;
/* Mapping of namespace indices in NodeIds and of NamespaceUris in
* ExpandedNodeIds. */
UA_NamespaceMapping *namespaceMapping;
/* Override calloc for arena-based memory allocation. Note that allocated
* memory is not freed if decoding fails afterwards. */
void *callocContext;

4
src/client/ua_client_connect.c
View File

@ -431,7 +431,7 @@ sendHELMessage(UA_Client *client) {
const UA_Byte *bufEnd = &message.data[message.length];
client->connectStatus =
UA_encodeBinaryInternal(&hello, &UA_TRANSPORT[UA_TRANSPORT_TCPHELLOMESSAGE],
&bufPos, &bufEnd, NULL, NULL);
&bufPos, &bufEnd, NULL, NULL, NULL);
/* Encode the message header at offset 0 */
UA_TcpMessageHeader messageHeader;
@ -440,7 +440,7 @@ sendHELMessage(UA_Client *client) {
bufPos = message.data;
retval = UA_encodeBinaryInternal(&messageHeader,
&UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER],
&bufPos, &bufEnd, NULL, NULL);
&bufPos, &bufEnd, NULL, NULL, NULL);
if(retval != UA_STATUSCODE_GOOD) {
cm->freeNetworkBuffer(cm, client->channel.connectionId, &message);
return retval;

20
src/pubsub/ua_pubsub_networkmessage_binary.c
View File

@ -85,12 +85,12 @@ UA_NetworkMessage_updateBufferedMessage(UA_NetworkMessageOffsetBuffer *buffer) {
case UA_PUBSUB_OFFSETTYPE_PAYLOAD_RAW:
rv = UA_encodeBinaryInternal(nmo->content.value.value.data,
nmo->content.value.value.type,
&bufPos, &bufEnd, NULL, NULL);
&bufPos, &bufEnd, NULL, NULL, NULL);
break;
case UA_PUBSUB_OFFSETTYPE_PAYLOAD_RAW_EXTERNAL:
rv = UA_encodeBinaryInternal((*nmo->content.externalValue)->value.data,
(*nmo->content.externalValue)->value.type,
&bufPos, &bufEnd, NULL, NULL);
&bufPos, &bufEnd, NULL, NULL, NULL);
break;
default:
break; /* The other fields are assumed to not change between messages.
@ -1404,13 +1404,15 @@ UA_DataSetMessage_keyFrame_encodeBinary(const UA_DataSetMessage* src, UA_Byte **
if(fmd->maxStringLength != 0 &&
(v->value.type->typeKind == UA_DATATYPEKIND_STRING ||
v->value.type->typeKind == UA_DATATYPEKIND_BYTESTRING)) {
rv = UA_encodeBinaryInternal(valuePtr, v->value.type, bufPos, &bufEnd, NULL, NULL);
rv = UA_encodeBinaryInternal(valuePtr, v->value.type, bufPos, &bufEnd,
NULL, NULL, NULL);
size_t lengthDifference = fmd->maxStringLength - ((UA_String *)valuePtr)->length;
memset(*bufPos, 0, lengthDifference);
*bufPos += lengthDifference;
} else {
/* Padding not yet supported for strings as part of structures */
rv = UA_encodeBinaryInternal(valuePtr, v->value.type, bufPos, &bufEnd, NULL, NULL);
rv = UA_encodeBinaryInternal(valuePtr, v->value.type, bufPos, &bufEnd,
NULL, NULL, NULL);
}
valuePtr += v->value.type->memSize;
}
@ -1684,7 +1686,7 @@ UA_DataSetMessage_calcSizeBinary(UA_DataSetMessage* p,
if(p->header.fieldEncoding == UA_FIELDENCODING_VARIANT) {
if(offsetBuffer)
nmo->contentType = UA_PUBSUB_OFFSETTYPE_PAYLOAD_VARIANT;
size += UA_calcSizeBinary(&v->value, &UA_TYPES[UA_TYPES_VARIANT]);
size += UA_calcSizeBinary(&v->value, &UA_TYPES[UA_TYPES_VARIANT], NULL);
} else if(p->header.fieldEncoding == UA_FIELDENCODING_RAWDATA) {
if(p->data.keyFrameData.dataSetFields != NULL) {
if(offsetBuffer) {
@ -1708,7 +1710,7 @@ UA_DataSetMessage_calcSizeBinary(UA_DataSetMessage* p,
for(size_t cnt = 0; cnt < fmd->arrayDimensionsSize; cnt++) {
elemCnt *= fmd->arrayDimensions[cnt];
}
size += (elemCnt * UA_calcSizeBinary(v->value.data, v->value.type));
size += (elemCnt * UA_calcSizeBinary(v->value.data, v->value.type, NULL));
/* Handle zero-padding for strings with max-string-length.
* Currently not supported for strings that are a part of larger
@ -1735,7 +1737,7 @@ UA_DataSetMessage_calcSizeBinary(UA_DataSetMessage* p,
} else if(p->header.fieldEncoding == UA_FIELDENCODING_DATAVALUE) {
if(offsetBuffer)
nmo->contentType = UA_PUBSUB_OFFSETTYPE_PAYLOAD_DATAVALUE;
size += UA_calcSizeBinary(v, &UA_TYPES[UA_TYPES_DATAVALUE]);
size += UA_calcSizeBinary(v, &UA_TYPES[UA_TYPES_DATAVALUE], NULL);
}
}
} else if(p->header.dataSetMessageType == UA_DATASETMESSAGE_DATADELTAFRAME) {
@ -1751,9 +1753,9 @@ UA_DataSetMessage_calcSizeBinary(UA_DataSetMessage* p,
for(UA_UInt16 i = 0; i < p->data.deltaFrameData.fieldCount; i++) {
const UA_DataValue *v = &p->data.deltaFrameData.deltaFrameFields[i].fieldValue;
if(p->header.fieldEncoding == UA_FIELDENCODING_VARIANT)
size += UA_calcSizeBinary(&v->value, &UA_TYPES[UA_TYPES_VARIANT]);
size += UA_calcSizeBinary(&v->value, &UA_TYPES[UA_TYPES_VARIANT], NULL);
else if(p->header.fieldEncoding == UA_FIELDENCODING_DATAVALUE)
size += UA_calcSizeBinary(v, &UA_TYPES[UA_TYPES_DATAVALUE]);
size += UA_calcSizeBinary(v, &UA_TYPES[UA_TYPES_DATAVALUE], NULL);
}
} else {
return 0;

8
src/pubsub/ua_pubsub_writer.c
View File

@ -407,8 +407,8 @@ valueChangedVariant(UA_Variant *oldValue, UA_Variant *newValue) {
if(!oldValue || !newValue)
return false;
size_t oldValueEncodingSize = UA_calcSizeBinary(oldValue, &UA_TYPES[UA_TYPES_VARIANT]);
size_t newValueEncodingSize = UA_calcSizeBinary(newValue, &UA_TYPES[UA_TYPES_VARIANT]);
size_t oldValueEncodingSize = UA_calcSizeBinary(oldValue, &UA_TYPES[UA_TYPES_VARIANT], NULL);
size_t newValueEncodingSize = UA_calcSizeBinary(newValue, &UA_TYPES[UA_TYPES_VARIANT], NULL);
if(oldValueEncodingSize == 0 || newValueEncodingSize == 0)
return false;
@ -435,12 +435,12 @@ valueChangedVariant(UA_Variant *oldValue, UA_Variant *newValue) {
UA_Boolean compareResult = false; /* default */
res = UA_encodeBinaryInternal(oldValue, &UA_TYPES[UA_TYPES_VARIANT],
&bufPosOldValue, &bufEndOldValue, NULL, NULL);
&bufPosOldValue, &bufEndOldValue, NULL, NULL, NULL);
if(res != UA_STATUSCODE_GOOD)
goto cleanup;
res = UA_encodeBinaryInternal(newValue, &UA_TYPES[UA_TYPES_VARIANT],
&bufPosNewValue, &bufEndNewValue, NULL, NULL);
&bufPosNewValue, &bufEndNewValue, NULL, NULL, NULL);
if(res != UA_STATUSCODE_GOOD)
goto cleanup;

8
src/server/ua_server_binary.c
View File

@ -258,10 +258,10 @@ processHEL(UA_Server *server, UA_SecureChannel *channel, const UA_ByteString *ms
const UA_Byte *bufEnd = &ack_msg.data[ack_msg.length];
retval |= UA_encodeBinaryInternal(&ackHeader,
&UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER],
&bufPos, &bufEnd, NULL, NULL);
&bufPos, &bufEnd, NULL, NULL, NULL);
retval |= UA_encodeBinaryInternal(&ackMessage,
&UA_TRANSPORT[UA_TRANSPORT_TCPACKNOWLEDGEMESSAGE],
&bufPos, &bufEnd, NULL, NULL);
&bufPos, &bufEnd, NULL, NULL, NULL);
if(retval != UA_STATUSCODE_GOOD) {
cm->freeNetworkBuffer(cm, channel->connectionId, &ack_msg);
return retval;
@ -959,7 +959,7 @@ sendRHEMessage(UA_Server *server, uintptr_t connectionId,
UA_StatusCode result =
UA_encodeBinaryInternal(&reverseHello,
&UA_TRANSPORT[UA_TRANSPORT_TCPREVERSEHELLOMESSAGE],
&bufPos, &bufEnd, NULL, NULL);
&bufPos, &bufEnd, NULL, NULL, NULL);
if(result != UA_STATUSCODE_GOOD) {
cm->freeNetworkBuffer(cm, connectionId, &message);
@ -973,7 +973,7 @@ sendRHEMessage(UA_Server *server, uintptr_t connectionId,
bufPos = message.data;
retval = UA_encodeBinaryInternal(&messageHeader,
&UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER],
&bufPos, &bufEnd, NULL, NULL);
&bufPos, &bufEnd, NULL, NULL, NULL);
if(retval != UA_STATUSCODE_GOOD) {
cm->freeNetworkBuffer(cm, connectionId, &message);
return retval;

4
src/server/ua_server_ns0_gds.c
View File

@ -670,7 +670,7 @@ openTrustList(UA_Server *server,
certGroup->getTrustList(certGroup, &trustList);
UA_ByteString encTrustList = UA_BYTESTRING_NULL;
retval = UA_encodeBinary(&trustList, &UA_TYPES[UA_TYPES_TRUSTLISTDATATYPE], &encTrustList);
retval = UA_encodeBinary(&trustList, &UA_TYPES[UA_TYPES_TRUSTLISTDATATYPE], &encTrustList, NULL);
UA_TrustListDataType_clear(&trustList);
if(retval != UA_STATUSCODE_GOOD) {
UA_ByteString_clear(&encTrustList);
@ -737,7 +737,7 @@ openTrustListWithMask(UA_Server *server,
certGroup->getTrustList(certGroup, &trustList);
UA_ByteString encTrustList = UA_BYTESTRING_NULL;
retval = UA_encodeBinary(&trustList, &UA_TYPES[UA_TYPES_TRUSTLISTDATATYPE], &encTrustList);
retval = UA_encodeBinary(&trustList, &UA_TYPES[UA_TYPES_TRUSTLISTDATATYPE], &encTrustList, NULL);
UA_TrustListDataType_clear(&trustList);
if(retval != UA_STATUSCODE_GOOD) {
UA_ByteString_clear(&encTrustList);

19
src/ua_securechannel.c
View File

@ -113,10 +113,10 @@ UA_SecureChannel_sendError(UA_SecureChannel *channel, UA_TcpErrorMessage *error)
const UA_Byte *bufEnd = &msg.data[msg.length];
retval |= UA_encodeBinaryInternal(&header,
&UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER],
&bufPos, &bufEnd, NULL, NULL);
&bufPos, &bufEnd, NULL, NULL, NULL);
retval |= UA_encodeBinaryInternal(error,
&UA_TRANSPORT[UA_TRANSPORT_TCPERRORMESSAGE],
&bufPos, &bufEnd, NULL, NULL);
&bufPos, &bufEnd, NULL, NULL, NULL);
(void)retval; /* Encoding of these cannot fail */
msg.length = header.messageSize;
cm->sendWithConnection(cm, channel->connectionId, &UA_KEYVALUEMAP_NULL, &msg);
@ -273,8 +273,12 @@ UA_SecureChannel_sendAsymmetricOPNMessage(UA_SecureChannel *channel,
size_t securityHeaderLength, pre_sig_length, total_length, encryptedLength;
/* Encode the message type and content */
UA_EncodeBinaryOptions encOpts;
memset(&encOpts, 0, sizeof(UA_EncodeBinaryOptions));
encOpts.namespaceMapping = channel->namespaceMapping;
res |= UA_NodeId_encodeBinary(&contentType->binaryEncodingId, &buf_pos, buf_end);
res |= UA_encodeBinaryInternal(content, contentType, &buf_pos, &buf_end, NULL, NULL);
res |= UA_encodeBinaryInternal(content, contentType, &buf_pos, &buf_end,
&encOpts, NULL, NULL);
UA_CHECK_STATUS(res, goto error);
/* Compute the header length */
@ -355,13 +359,13 @@ encodeHeadersSym(UA_MessageContext *mc, size_t totalLength) {
UA_StatusCode res = UA_STATUSCODE_GOOD;
res |= UA_encodeBinaryInternal(&header, &UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER],
&header_pos, &mc->buf_end, NULL, NULL);
&header_pos, &mc->buf_end, NULL, NULL, NULL);
res |= UA_UInt32_encodeBinary(&channel->securityToken.channelId,
&header_pos, mc->buf_end);
res |= UA_UInt32_encodeBinary(&channel->securityToken.tokenId,
&header_pos, mc->buf_end);
res |= UA_encodeBinaryInternal(&seqHeader, &UA_TRANSPORT[UA_TRANSPORT_SEQUENCEHEADER],
&header_pos, &mc->buf_end, NULL, NULL);
&header_pos, &mc->buf_end, NULL, NULL, NULL);
return res;
}
@ -504,9 +508,12 @@ UA_MessageContext_begin(UA_MessageContext *mc, UA_SecureChannel *channel,
UA_StatusCode
UA_MessageContext_encode(UA_MessageContext *mc, const void *content,
const UA_DataType *contentType) {
UA_EncodeBinaryOptions encOpts;
memset(&encOpts, 0, sizeof(UA_EncodeBinaryOptions));
encOpts.namespaceMapping = mc->channel->namespaceMapping;
UA_StatusCode res =
UA_encodeBinaryInternal(content, contentType, &mc->buf_pos, &mc->buf_end,
sendSymmetricEncodingCallback, mc);
&encOpts, sendSymmetricEncodingCallback, mc);
if(res != UA_STATUSCODE_GOOD && mc->messageBuffer.length > 0)
UA_MessageContext_abort(mc);
return res;

4
src/ua_securechannel.h
View File

@ -104,6 +104,10 @@ struct UA_SecureChannel {
UA_ConnectionManager *connectionManager;
uintptr_t connectionId;
/* The namespace mapping translates namespace indices of NodeIds during
* de/encoding (client only) */
UA_NamespaceMapping *namespaceMapping;
/* Linked lists (only used in the server) */
TAILQ_ENTRY(UA_SecureChannel) serverEntry;
TAILQ_ENTRY(UA_SecureChannel) componentEntry;

10
src/ua_securechannel_crypto.c
View File

@ -174,7 +174,7 @@ prependHeadersAsym(UA_SecureChannel *const channel, UA_Byte *header_pos,
UA_StatusCode retval = UA_STATUSCODE_GOOD;
retval |= UA_encodeBinaryInternal(&messageHeader,
&UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER],
&header_pos, &buf_end, NULL, NULL);
&header_pos, &buf_end, NULL, NULL, NULL);
retval |= UA_UInt32_encodeBinary(&secureChannelId, &header_pos, buf_end);
UA_CHECK_STATUS(retval, return retval);
@ -187,9 +187,9 @@ prependHeadersAsym(UA_SecureChannel *const channel, UA_Byte *header_pos,
asymHeader.receiverCertificateThumbprint.length = 20;
asymHeader.receiverCertificateThumbprint.data = channel->remoteCertificateThumbprint;
}
retval = UA_encodeBinaryInternal(&asymHeader,
&UA_TRANSPORT[UA_TRANSPORT_ASYMMETRICALGORITHMSECURITYHEADER],
&header_pos, &buf_end, NULL, NULL);
retval = UA_encodeBinaryInternal(
&asymHeader, &UA_TRANSPORT[UA_TRANSPORT_ASYMMETRICALGORITHMSECURITYHEADER],
&header_pos, &buf_end, NULL, NULL, NULL);
UA_CHECK_STATUS(retval, return retval);
/* Increase the sequence number in the channel */
@ -199,7 +199,7 @@ prependHeadersAsym(UA_SecureChannel *const channel, UA_Byte *header_pos,
seqHeader.requestId = requestId;
seqHeader.sequenceNumber = channel->sendSequenceNumber;
retval = UA_encodeBinaryInternal(&seqHeader, &UA_TRANSPORT[UA_TRANSPORT_SEQUENCEHEADER],
&header_pos, &buf_end, NULL, NULL);
&header_pos, &buf_end, NULL, NULL, NULL);
return retval;
}

20
src/ua_types_encoding_binary.c
View File

@ -892,7 +892,10 @@ FUNC_ENCODE_BINARY(ExtensionObject) {
* calcSizeBinary mode. This is avoids recursive cycles.*/
i32 signed_len = 0;
if(ctx->end != NULL) {
size_t len = UA_calcSizeBinary(src->content.decoded.data, contentType);
UA_EncodeBinaryOptions opts;
memset(&opts, 0, sizeof(UA_EncodeBinaryOptions));
opts.namespaceMapping = ctx->opts.namespaceMapping;
size_t len = UA_calcSizeBinary(src->content.decoded.data, contentType, &opts);
UA_CHECK(len <= UA_INT32_MAX, return UA_STATUSCODE_BADENCODINGERROR);
signed_len = (i32)len;
}
@ -1643,6 +1646,7 @@ const encodeBinarySignature encodeBinaryJumpTable[UA_DATATYPEKINDS] = {
status
UA_encodeBinaryInternal(const void *src, const UA_DataType *type,
u8 **bufPos, const u8 **bufEnd,
UA_EncodeBinaryOptions *options,
UA_exchangeEncodeBuffer exchangeCallback,
void *exchangeHandle) {
if(!type || !src)
@ -1655,6 +1659,9 @@ UA_encodeBinaryInternal(const void *src, const UA_DataType *type,
ctx.depth = 0;
ctx.exchangeBufferCallback = exchangeCallback;
ctx.exchangeBufferCallbackHandle = exchangeHandle;
memset(&ctx.opts, 0, sizeof(UA_DecodeBinaryOptions));
if(options)
ctx.opts.namespaceMapping = options->namespaceMapping;
/* Encode */
status ret = encodeWithExchangeBuffer(&ctx, src, type);
@ -1669,12 +1676,12 @@ UA_encodeBinaryInternal(const void *src, const UA_DataType *type,
UA_StatusCode
UA_encodeBinary(const void *p, const UA_DataType *type,
UA_ByteString *outBuf) {
UA_ByteString *outBuf, UA_EncodeBinaryOptions *options) {
/* Allocate buffer */
UA_Boolean allocated = false;
status res = UA_STATUSCODE_GOOD;
if(outBuf->length == 0) {
size_t len = UA_calcSizeBinary(p, type);
size_t len = UA_calcSizeBinary(p, type, options);
res = UA_ByteString_allocBuffer(outBuf, len);
if(res != UA_STATUSCODE_GOOD)
return res;
@ -1684,7 +1691,7 @@ UA_encodeBinary(const void *p, const UA_DataType *type,
/* Encode */
u8 *pos = outBuf->data;
const u8 *posEnd = &outBuf->data[outBuf->length];
res = UA_encodeBinaryInternal(p, type, &pos, &posEnd, NULL, NULL);
res = UA_encodeBinaryInternal(p, type, &pos, &posEnd, options, NULL, NULL);
/* Clean up */
if(res == UA_STATUSCODE_GOOD) {
@ -1904,10 +1911,11 @@ UA_decodeBinary(const UA_ByteString *inBuf,
* throw an error when the buffer limits are exceeded. */
size_t
UA_calcSizeBinary(const void *p, const UA_DataType *type) {
UA_calcSizeBinary(const void *p, const UA_DataType *type,
UA_EncodeBinaryOptions *options) {
u8 *pos = NULL;
const u8 *posEnd = NULL;
UA_StatusCode res = UA_encodeBinaryInternal(p, type, &pos, &posEnd, NULL, NULL);
UA_StatusCode res = UA_encodeBinaryInternal(p, type, &pos, &posEnd, options, NULL, NULL);
if(res != UA_STATUSCODE_GOOD)
return 0;
return (size_t)(uintptr_t)pos;

1
src/ua_types_encoding_binary.h
View File

@ -77,6 +77,7 @@ extern const decodeBinarySignature decodeBinaryJumpTable[UA_DATATYPEKINDS];
UA_StatusCode
UA_encodeBinaryInternal(const void *src, const UA_DataType *type,
UA_Byte **bufPos, const UA_Byte **bufEnd,
UA_EncodeBinaryOptions *options,
UA_exchangeEncodeBuffer exchangeCallback,
void *exchangeHandle)
UA_FUNC_ATTR_WARN_UNUSED_RESULT;

4
src/util/ua_util_internal.h
View File

@ -330,12 +330,12 @@ void UA_Guid_to_hex(const UA_Guid *guid, u8* out, UA_Boolean lower);
#define UA_ENCODING_HELPERS(TYPE, UPCASE_TYPE) \
static UA_INLINE size_t \
UA_##TYPE##_calcSizeBinary(const UA_##TYPE *src) { \
return UA_calcSizeBinary(src, &UA_TYPES[UA_TYPES_##UPCASE_TYPE]); \
return UA_calcSizeBinary(src, &UA_TYPES[UA_TYPES_##UPCASE_TYPE], NULL); \
} \
static UA_INLINE UA_StatusCode \
UA_##TYPE##_encodeBinary(const UA_##TYPE *src, UA_Byte **bufPos, const UA_Byte *bufEnd) { \
return UA_encodeBinaryInternal(src, &UA_TYPES[UA_TYPES_##UPCASE_TYPE], \
bufPos, &bufEnd, NULL, NULL); \
bufPos, &bufEnd, NULL, NULL, NULL); \
} \
static UA_INLINE UA_StatusCode \
UA_##TYPE##_decodeBinary(const UA_ByteString *src, size_t *offset, UA_##TYPE *dst) { \

16
tests/check_chunking.c
View File

@ -49,13 +49,13 @@ START_TEST(encodeArrayIntoFiveChunksShallWork) {
UA_Byte *pos = workingBuffer.data;
const UA_Byte *end = &workingBuffer.data[workingBuffer.length];
UA_StatusCode retval = UA_encodeBinaryInternal(&v,&UA_TYPES[UA_TYPES_VARIANT],
&pos, &end, sendChunkMockUp, NULL);
&pos, &end, NULL, sendChunkMockUp, NULL);
ck_assert_uint_eq(retval,UA_STATUSCODE_GOOD);
ck_assert_uint_eq(counter,4); //5 chunks allocated - callback called 4 times
dataCount += (uintptr_t)(pos - buffers[bufIndex].data);
ck_assert_uint_eq(UA_calcSizeBinary(&v,&UA_TYPES[UA_TYPES_VARIANT]), dataCount);
ck_assert_uint_eq(UA_calcSizeBinary(&v,&UA_TYPES[UA_TYPES_VARIANT], NULL), dataCount);
UA_Variant_clear(&v);
UA_Array_delete(buffers, chunkCount, &UA_TYPES[UA_TYPES_BYTESTRING]);
@ -93,13 +93,13 @@ START_TEST(encodeStringIntoFiveChunksShallWork) {
UA_Byte *pos = workingBuffer.data;
const UA_Byte *end = &workingBuffer.data[workingBuffer.length];
UA_StatusCode retval = UA_encodeBinaryInternal(&v, &UA_TYPES[UA_TYPES_VARIANT],
&pos, &end, sendChunkMockUp, NULL);
&pos, &end, NULL, sendChunkMockUp, NULL);
ck_assert_uint_eq(retval,UA_STATUSCODE_GOOD);
ck_assert_uint_eq(counter,4); //5 chunks allocated - callback called 4 times
dataCount += (uintptr_t)(pos - buffers[bufIndex].data);
ck_assert_uint_eq(UA_calcSizeBinary(&v,&UA_TYPES[UA_TYPES_VARIANT]), dataCount);
ck_assert_uint_eq(UA_calcSizeBinary(&v,&UA_TYPES[UA_TYPES_VARIANT], NULL), dataCount);
UA_Variant_clear(&v);
UA_Array_delete(buffers, chunkCount, &UA_TYPES[UA_TYPES_BYTESTRING]);
@ -134,18 +134,18 @@ START_TEST(encodeTwoStringsIntoTenChunksShallWork) {
UA_Byte *pos = workingBuffer.data;
const UA_Byte *end = &workingBuffer.data[workingBuffer.length];
UA_StatusCode retval = UA_encodeBinaryInternal(&string, &UA_TYPES[UA_TYPES_STRING],
&pos, &end, sendChunkMockUp, NULL);
&pos, &end, NULL, sendChunkMockUp, NULL);
ck_assert_uint_eq(retval,UA_STATUSCODE_GOOD);
ck_assert_uint_eq(counter,4); //5 chunks allocated - callback called 4 times
size_t offset = (uintptr_t)(pos - buffers[bufIndex].data);
ck_assert_uint_eq(UA_calcSizeBinary(&string,&UA_TYPES[UA_TYPES_STRING]), dataCount + offset);
ck_assert_uint_eq(UA_calcSizeBinary(&string,&UA_TYPES[UA_TYPES_STRING], NULL), dataCount + offset);
retval = UA_encodeBinaryInternal(&string,&UA_TYPES[UA_TYPES_STRING],
&pos, &end, sendChunkMockUp, NULL);
&pos, &end, NULL, sendChunkMockUp, NULL);
dataCount += (uintptr_t)(pos - buffers[bufIndex].data);
ck_assert_uint_eq(retval,UA_STATUSCODE_GOOD);
ck_assert_uint_eq(counter,9); //10 chunks allocated - callback called 4 times
ck_assert_uint_eq(2 * UA_calcSizeBinary(&string,&UA_TYPES[UA_TYPES_STRING]), dataCount);
ck_assert_uint_eq(2 * UA_calcSizeBinary(&string,&UA_TYPES[UA_TYPES_STRING], NULL), dataCount);
UA_Array_delete(buffers, chunkCount, &UA_TYPES[UA_TYPES_BYTESTRING]);
UA_String_clear(&string);

24
tests/check_types_builtin.c
View File

@ -23,7 +23,7 @@ enum UA_VARIANT_ENCODINGMASKTYPE_enum {
static UA_Variant* EncodeDecodeVariant(UA_Variant* sourceVariant) {
UA_ByteString encodedVariant;
UA_ByteString_init(&encodedVariant);
UA_StatusCode encodeResult = UA_encodeBinary(sourceVariant, &UA_TYPES[UA_TYPES_VARIANT], &encodedVariant);
UA_StatusCode encodeResult = UA_encodeBinary(sourceVariant, &UA_TYPES[UA_TYPES_VARIANT], &encodedVariant, NULL);
UA_Variant* decodedVariant = UA_Variant_new();
UA_StatusCode decodeResult = UA_decodeBinary(&encodedVariant, decodedVariant, &UA_TYPES[UA_TYPES_VARIANT], NULL );
@ -97,7 +97,7 @@ START_TEST(UA_Byte_decodeShallCopyAndAdvancePosition) {
// then
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
ck_assert_uint_eq(pos, 1);
ck_assert_uint_eq(pos, UA_calcSizeBinary(&dst, &UA_TYPES[UA_TYPES_BYTE]));
ck_assert_uint_eq(pos, UA_calcSizeBinary(&dst, &UA_TYPES[UA_TYPES_BYTE], NULL));
ck_assert_uint_eq(dst, 0x08);
}
END_TEST
@ -367,7 +367,7 @@ START_TEST(UA_String_decodeShallAllocateMemoryAndCopyString) {
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
ck_assert_uint_eq(dst.length, 8);
ck_assert_int_eq(dst.data[3], 'L');
ck_assert_uint_eq(pos, UA_calcSizeBinary(&dst, &UA_TYPES[UA_TYPES_STRING]));
ck_assert_uint_eq(pos, UA_calcSizeBinary(&dst, &UA_TYPES[UA_TYPES_STRING], NULL));
// finally
UA_String_clear(&dst);
}
@ -416,7 +416,7 @@ START_TEST(UA_NodeId_decodeTwoByteShallReadTwoBytesAndSetNamespaceToZero) {
// then
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
ck_assert_uint_eq(pos, 2);
ck_assert_uint_eq(pos, UA_calcSizeBinary(&dst, &UA_TYPES[UA_TYPES_NODEID]));
ck_assert_uint_eq(pos, UA_calcSizeBinary(&dst, &UA_TYPES[UA_TYPES_NODEID], NULL));
ck_assert_int_eq(dst.identifierType, UA_NODEIDTYPE_NUMERIC);
ck_assert_int_eq(dst.identifier.numeric, 16);
ck_assert_int_eq(dst.namespaceIndex, 0);
@ -434,7 +434,7 @@ START_TEST(UA_NodeId_decodeFourByteShallReadFourBytesAndRespectNamespace) {
// then
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
ck_assert_uint_eq(pos, 4);
ck_assert_uint_eq(pos, UA_calcSizeBinary(&dst, &UA_TYPES[UA_TYPES_NODEID]));
ck_assert_uint_eq(pos, UA_calcSizeBinary(&dst, &UA_TYPES[UA_TYPES_NODEID], NULL));
ck_assert_int_eq(dst.identifierType, UA_NODEIDTYPE_NUMERIC);
ck_assert_int_eq(dst.identifier.numeric, 256);
ck_assert_int_eq(dst.namespaceIndex, 1);
@ -452,7 +452,7 @@ START_TEST(UA_NodeId_decodeStringShallAllocateMemory) {
// then
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
ck_assert_uint_eq(pos, 10);
ck_assert_uint_eq(pos, UA_calcSizeBinary(&dst, &UA_TYPES[UA_TYPES_NODEID]));
ck_assert_uint_eq(pos, UA_calcSizeBinary(&dst, &UA_TYPES[UA_TYPES_NODEID], NULL));
ck_assert_int_eq(dst.identifierType, UA_NODEIDTYPE_STRING);
ck_assert_int_eq(dst.namespaceIndex, 1);
ck_assert_uint_eq(dst.identifier.string.length, 3);
@ -473,7 +473,7 @@ START_TEST(UA_Variant_decodeWithOutArrayFlagSetShallSetVTAndAllocateMemoryForArr
// then
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
ck_assert_uint_eq(pos, 5);
ck_assert_uint_eq(pos, UA_calcSizeBinary(&dst, &UA_TYPES[UA_TYPES_VARIANT]));
ck_assert_uint_eq(pos, UA_calcSizeBinary(&dst, &UA_TYPES[UA_TYPES_VARIANT], NULL));
//ck_assert_ptr_eq((const void *)dst.type, (const void *)&UA_TYPES[UA_TYPES_INT32]); //does not compile in gcc 4.6
ck_assert_uint_eq((uintptr_t)dst.type, (uintptr_t)&UA_TYPES[UA_TYPES_INT32]);
ck_assert_uint_eq(dst.arrayLength, 0);
@ -499,7 +499,7 @@ START_TEST(UA_Variant_decodeWithArrayFlagSetShallSetVTAndAllocateMemoryForArray)
// then
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
ck_assert_uint_eq(pos, 1+4+2*4);
ck_assert_uint_eq(pos, UA_calcSizeBinary(&dst, &UA_TYPES[UA_TYPES_VARIANT]));
ck_assert_uint_eq(pos, UA_calcSizeBinary(&dst, &UA_TYPES[UA_TYPES_VARIANT], NULL));
//ck_assert_ptr_eq((const (void*))dst.type, (const void*)&UA_TYPES[UA_TYPES_INT32]); //does not compile in gcc 4.6
ck_assert_uint_eq((uintptr_t)dst.type,(uintptr_t)&UA_TYPES[UA_TYPES_INT32]);
ck_assert_uint_eq(dst.arrayLength, 2);
@ -929,7 +929,7 @@ START_TEST(UA_String_encodeShallWorkOnExample) {
UA_StatusCode retval = UA_String_encodeBinary(&src, &pos, end);
// then
ck_assert_uint_eq((uintptr_t)(pos - dst.data), sizeof(UA_Int32)+11);
ck_assert_uint_eq(sizeof(UA_Int32)+11, UA_calcSizeBinary(&src, &UA_TYPES[UA_TYPES_STRING]));
ck_assert_uint_eq(sizeof(UA_Int32)+11, UA_calcSizeBinary(&src, &UA_TYPES[UA_TYPES_STRING], NULL));
ck_assert_int_eq(dst.data[0], 11);
ck_assert_int_eq(dst.data[sizeof(UA_Int32)+0], 'A');
ck_assert_int_eq(dst.data[sizeof(UA_Int32)+1], 'C');
@ -1006,7 +1006,7 @@ START_TEST(UA_ExpandedNodeId_encodeShallWorkOnExample) {
// then
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
ck_assert_uint_eq((uintptr_t)(pos - dst.data), 13);
ck_assert_uint_eq(13, UA_calcSizeBinary(&src, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]));
ck_assert_uint_eq(13, UA_calcSizeBinary(&src, &UA_TYPES[UA_TYPES_EXPANDEDNODEID], NULL));
ck_assert_int_eq(dst.data[0], 0x80); // namespaceuri flag
}
END_TEST
@ -1029,7 +1029,7 @@ START_TEST(UA_DataValue_encodeShallWorkOnExampleWithoutVariant) {
UA_StatusCode retval = UA_DataValue_encodeBinary(&src, &pos, end);
// then
ck_assert_uint_eq((uintptr_t)(pos - dst.data), 9);
ck_assert_uint_eq(9, UA_calcSizeBinary(&src, &UA_TYPES[UA_TYPES_DATAVALUE]));
ck_assert_uint_eq(9, UA_calcSizeBinary(&src, &UA_TYPES[UA_TYPES_DATAVALUE], NULL));
ck_assert_int_eq(dst.data[0], 0x08); // encodingMask
ck_assert_int_eq(dst.data[1], 80); // 8 Byte serverTimestamp
ck_assert_int_eq(dst.data[2], 0);
@ -1066,7 +1066,7 @@ START_TEST(UA_DataValue_encodeShallWorkOnExampleWithVariant) {
UA_StatusCode retval = UA_DataValue_encodeBinary(&src, &pos, end);
// then
ck_assert_uint_eq((uintptr_t)(pos - dst.data), 1+(1+4)+8); // represents the length
ck_assert_uint_eq(1+(1+4)+8, UA_calcSizeBinary(&src, &UA_TYPES[UA_TYPES_DATAVALUE]));
ck_assert_uint_eq(1+(1+4)+8, UA_calcSizeBinary(&src, &UA_TYPES[UA_TYPES_DATAVALUE], NULL));
ck_assert_int_eq(dst.data[0], 0x08 | 0x01); // encodingMask
ck_assert_int_eq(dst.data[1], 0x06); // Variant's Encoding Mask - INT32
ck_assert_int_eq(dst.data[2], 45); // the single value

46
tests/check_types_custom.c
View File

@ -298,12 +298,12 @@ START_TEST(parseCustomScalar) {
UA_Variant_init(&var);
UA_Variant_setScalar(&var, &p, &PointType);
size_t buflen = UA_calcSizeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT]);
size_t buflen = UA_calcSizeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], NULL);
UA_ByteString buf;
UA_StatusCode retval = UA_ByteString_allocBuffer(&buf, buflen);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
retval = UA_encodeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], &buf);
retval = UA_encodeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], &buf, NULL);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
UA_Variant var2;
@ -334,12 +334,12 @@ START_TEST(parseCustomScalarExtensionObject) {
eo.content.decoded.data = &p;
eo.content.decoded.type = &PointType;
size_t buflen = UA_calcSizeBinary(&eo, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]);
size_t buflen = UA_calcSizeBinary(&eo, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT], NULL);
UA_ByteString buf;
UA_StatusCode retval = UA_ByteString_allocBuffer(&buf, buflen);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
retval = UA_encodeBinary(&eo, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT], &buf);
retval = UA_encodeBinary(&eo, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT], &buf, NULL);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
UA_ExtensionObject eo2;
@ -371,12 +371,12 @@ START_TEST(parseCustomArray) {
UA_Variant_init(&var);
UA_Variant_setArray(&var, (void*)ps, 10, &PointType);
size_t buflen = UA_calcSizeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT]);
size_t buflen = UA_calcSizeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], NULL);
UA_ByteString buf;
UA_StatusCode retval = UA_ByteString_allocBuffer(&buf, buflen);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
retval = UA_encodeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], &buf);
retval = UA_encodeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], &buf, NULL);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
UA_Variant var2;
@ -416,12 +416,12 @@ START_TEST(parseCustomStructureWithOptionalFields) {
UA_Variant_init(&var);
UA_Variant_setScalarCopy(&var, &o, &OptType);
size_t buflen = UA_calcSizeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT]);
size_t buflen = UA_calcSizeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], NULL);
UA_ByteString buf;
UA_StatusCode retval = UA_ByteString_allocBuffer(&buf, buflen);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
retval = UA_encodeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], &buf);
retval = UA_encodeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], &buf, NULL);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
UA_Variant var2;
@ -458,13 +458,13 @@ START_TEST(parseCustomStructureWithOptionalFieldsWithArrayNotContained) {
UA_Variant_init(&var);
retval = UA_Variant_setScalarCopy(&var, &oa, &ArrayOptType);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
size_t buflen = UA_calcSizeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT]);
size_t buflen = UA_calcSizeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], NULL);
UA_ByteString buf;
retval = UA_ByteString_allocBuffer(&buf, buflen);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
size_t binSize = UA_calcSizeBinary(&oa, &ArrayOptType);
size_t binSize = UA_calcSizeBinary(&oa, &ArrayOptType, NULL);
ck_assert_uint_eq(binSize, 44);
retval = UA_encodeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], &buf);
retval = UA_encodeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], &buf, NULL);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
UA_Variant var2;
@ -516,13 +516,13 @@ START_TEST(parseCustomStructureWithOptionalFieldsWithArrayContained) {
UA_Variant_init(&var);
retval = UA_Variant_setScalarCopy(&var, &oa, &ArrayOptType);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
size_t buflen = UA_calcSizeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT]);
size_t buflen = UA_calcSizeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], NULL);
UA_ByteString buf;
retval = UA_ByteString_allocBuffer(&buf, buflen);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
size_t binSize = UA_calcSizeBinary(&oa, &ArrayOptType);
size_t binSize = UA_calcSizeBinary(&oa, &ArrayOptType, NULL);
ck_assert_uint_eq(binSize, 60);
retval = UA_encodeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], &buf);
retval = UA_encodeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], &buf, NULL);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
UA_Variant var2;
UA_DecodeBinaryOptions opt;
@ -564,16 +564,16 @@ START_TEST(parseCustomUnion) {
retval = UA_Variant_setScalarCopy(&var, &u, &UniType);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
size_t lengthOfUnion = UA_calcSizeBinary(&u, &UniType);
size_t lengthOfUnion = UA_calcSizeBinary(&u, &UniType, NULL);
//check if 19 is the right size
ck_assert_uint_eq(lengthOfUnion, 19);
size_t buflen = UA_calcSizeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT]);
size_t buflen = UA_calcSizeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], NULL);
UA_ByteString buf;
retval = UA_ByteString_allocBuffer(&buf, buflen);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
retval = UA_encodeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], &buf);
retval = UA_encodeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], &buf, NULL);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
UA_Variant var2;
@ -606,16 +606,16 @@ START_TEST(parseSelfContainingUnionNormalMember) {
retval = UA_Variant_setScalarCopy(&var, &s, &selfContainingUnionType);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
size_t lengthOfUnion = UA_calcSizeBinary(&s, &selfContainingUnionType);
size_t lengthOfUnion = UA_calcSizeBinary(&s, &selfContainingUnionType, NULL);
//check if 12 is the right size
ck_assert_uint_eq(lengthOfUnion, 12);
size_t buflen = UA_calcSizeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT]);
size_t buflen = UA_calcSizeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], NULL);
UA_ByteString buf;
retval = UA_ByteString_allocBuffer(&buf, buflen);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
retval = UA_encodeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], &buf);
retval = UA_encodeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], &buf, NULL);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
UA_Variant var2;
@ -651,18 +651,18 @@ START_TEST(parseSelfContainingUnionSelfMember) {
retval = UA_Variant_setScalarCopy(&var, &s, &selfContainingUnionType);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
size_t lengthOfUnion = UA_calcSizeBinary(&s, &selfContainingUnionType);
size_t lengthOfUnion = UA_calcSizeBinary(&s, &selfContainingUnionType, NULL);
//check if 32 is the right size
ck_assert_uint_eq(lengthOfUnion, 32);
UA_free(s.fields.array.array);
size_t buflen = UA_calcSizeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT]);
size_t buflen = UA_calcSizeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], NULL);
UA_ByteString buf;
retval = UA_ByteString_allocBuffer(&buf, buflen);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
retval = UA_encodeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], &buf);
retval = UA_encodeBinary(&var, &UA_TYPES[UA_TYPES_VARIANT], &buf, NULL);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
UA_Variant var2;

10
tests/check_types_memory.c
View File

@ -61,7 +61,7 @@ START_TEST(encodeShallYieldDecode) {
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
UA_Byte *pos = msg1.data;
const UA_Byte *end = &msg1.data[msg1.length];
retval = UA_encodeBinaryInternal(obj1, &UA_TYPES[_i], &pos, &end, NULL, NULL);
retval = UA_encodeBinaryInternal(obj1, &UA_TYPES[_i], &pos, &end, NULL, NULL, NULL);
if(retval != UA_STATUSCODE_GOOD) {
UA_delete(obj1, &UA_TYPES[_i]);
UA_ByteString_clear(&msg1);
@ -79,7 +79,7 @@ START_TEST(encodeShallYieldDecode) {
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
pos = msg2.data;
end = &msg2.data[msg2.length];
retval = UA_encodeBinaryInternal(obj2, &UA_TYPES[_i], &pos, &end, NULL, NULL);
retval = UA_encodeBinaryInternal(obj2, &UA_TYPES[_i], &pos, &end, NULL, NULL, NULL);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
// then
@ -115,7 +115,7 @@ START_TEST(decodeShallFailWithTruncatedBufferButSurvive) {
UA_StatusCode retval = UA_ByteString_allocBuffer(&msg1, 65000); // fixed buf size
UA_Byte *pos = msg1.data;
const UA_Byte *end = &msg1.data[msg1.length];
retval |= UA_encodeBinaryInternal(obj1, &UA_TYPES[_i], &pos, &end, NULL, NULL);
retval |= UA_encodeBinaryInternal(obj1, &UA_TYPES[_i], &pos, &end, NULL, NULL, NULL);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
UA_delete(obj1, &UA_TYPES[_i]);
@ -208,14 +208,14 @@ END_TEST
START_TEST(calcSizeBinaryShallBeCorrect) {
void *obj = UA_new(&UA_TYPES[_i]);
size_t predicted_size = UA_calcSizeBinary(obj, &UA_TYPES[_i]);
size_t predicted_size = UA_calcSizeBinary(obj, &UA_TYPES[_i], NULL);
ck_assert_uint_ne(predicted_size, 0);
UA_ByteString msg;
UA_StatusCode retval = UA_ByteString_allocBuffer(&msg, predicted_size);
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
UA_Byte *pos = msg.data;
const UA_Byte *end = &msg.data[msg.length];
retval = UA_encodeBinaryInternal(obj, &UA_TYPES[_i], &pos, &end, NULL, NULL);
retval = UA_encodeBinaryInternal(obj, &UA_TYPES[_i], &pos, &end, NULL, NULL, NULL);
if(retval)
printf("%i\n",_i);
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);

2
tests/encryption/check_gds_informationmodel.c
View File

@ -351,7 +351,7 @@ START_TEST(rw_trustlist) {
fd = *(UA_Int32*)fileHandler.data;
UA_ByteString encTrustList = UA_BYTESTRING_NULL;
retval = UA_encodeBinary(&trustList, &UA_TYPES[UA_TYPES_TRUSTLISTDATATYPE], &encTrustList);
retval = UA_encodeBinary(&trustList, &UA_TYPES[UA_TYPES_TRUSTLISTDATATYPE], &encTrustList, NULL);
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
UA_ByteString chunk1 = {.length = 1000, .data = encTrustList.data};

4
tests/fuzz/fuzz_binary_decode.cc
View File

@ -67,7 +67,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
UA_delete(dstCopy, &UA_TYPES[typeIndex]);
// now also test encoding
size_t encSize = UA_calcSizeBinary(dst, &UA_TYPES[typeIndex]);
size_t encSize = UA_calcSizeBinary(dst, &UA_TYPES[typeIndex], NULL);
UA_ByteString encoded;
ret = UA_ByteString_allocBuffer(&encoded, encSize);
if(ret != UA_STATUSCODE_GOOD) {
@ -75,7 +75,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
return 0;
}
ret = UA_encodeBinary(dst, &UA_TYPES[typeIndex], &encoded);
ret = UA_encodeBinary(dst, &UA_TYPES[typeIndex], &encoded, NULL);
UA_assert(ret == UA_STATUSCODE_GOOD);
UA_ByteString_clear(&encoded);

4
tests/pubsub/attic/check_pubsub_connection_xdp.c
View File

@ -274,8 +274,8 @@ START_TEST(GetMaximalConnectionConfigurationAndCompareValues){
ck_assert(UA_String_equal(&connectionConfig.name, &connectionConf.name) == UA_TRUE);
ck_assert(UA_String_equal(&connectionConfig.transportProfileUri, &connectionConf.transportProfileUri) == UA_TRUE);
UA_NetworkAddressUrlDataType networkAddressUrlDataCopy = *((UA_NetworkAddressUrlDataType *)connectionConfig.address.data);
ck_assert(UA_calcSizeBinary(&networkAddressUrlDataCopy, &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]) ==
UA_calcSizeBinary(&networkAddressUrlData, &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]));
ck_assert(UA_calcSizeBinary(&networkAddressUrlDataCopy, &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE], NULL) ==
UA_calcSizeBinary(&networkAddressUrlData, &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE], NULL));
for(size_t i = 0; i < connectionConfig.connectionProperties.mapSize; i++){
ck_assert(UA_String_equal(&connectionConfig.connectionProperties.map[i].key.name, &connectionConf.connectionProperties.map[i].key.name) == UA_TRUE);
ck_assert(UA_Variant_calcSizeBinary(&connectionConfig.connectionProperties.map[i].value) == UA_Variant_calcSizeBinary(&connectionConf.connectionProperties.map[i].value));

4
tests/pubsub/check_pubsub_connection_ethernet.c
View File

@ -210,8 +210,8 @@ START_TEST(GetMaximalConnectionConfigurationAndCompareValues){
ck_assert(UA_String_equal(&connectionConfig.name, &connectionConf.name) == UA_TRUE);
ck_assert(UA_String_equal(&connectionConfig.transportProfileUri, &connectionConf.transportProfileUri) == UA_TRUE);
UA_NetworkAddressUrlDataType networkAddressUrlDataCopy = *((UA_NetworkAddressUrlDataType *)connectionConfig.address.data);
ck_assert(UA_calcSizeBinary(&networkAddressUrlDataCopy, &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]) ==
UA_calcSizeBinary(&networkAddressUrlData, &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]));
ck_assert(UA_calcSizeBinary(&networkAddressUrlDataCopy, &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE], NULL) ==
UA_calcSizeBinary(&networkAddressUrlData, &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE], NULL));
for(size_t i = 0; i < connectionConfig.connectionProperties.mapSize; i++){
ck_assert(UA_String_equal(&connectionConfig.connectionProperties.map[i].key.name, &connectionConf.connectionProperties.map[i].key.name) == UA_TRUE);
ck_assert(UA_Variant_calcSizeBinary(&connectionConfig.connectionProperties.map[i].value) == UA_Variant_calcSizeBinary(&connectionConf.connectionProperties.map[i].value));

4
tests/pubsub/check_pubsub_connection_mqtt.c
View File

@ -204,9 +204,9 @@ START_TEST(GetMaximalConnectionConfigurationAndCompareValues){
UA_NetworkAddressUrlDataType networkAddressUrlDataCopy =
*((UA_NetworkAddressUrlDataType *)connectionConfig.address.data);
ck_assert(UA_calcSizeBinary(&networkAddressUrlDataCopy,
&UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]) ==
&UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE], NULL) ==
UA_calcSizeBinary(&networkAddressUrlData,
&UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]));
&UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE], NULL));
for(size_t i = 0; i < connectionConfig.connectionProperties.mapSize; i++){
ck_assert(UA_String_equal(&connectionConfig.connectionProperties.map[i].key.name,
&connectionConf.connectionProperties.map[i].key.name) == UA_TRUE);

4
tests/pubsub/check_pubsub_connection_udp.c
View File

@ -244,8 +244,8 @@ START_TEST(GetMaximalConnectionConfigurationAndCompareValues){
ck_assert(UA_String_equal(&connectionConfig.name, &connectionConf.name) == UA_TRUE);
ck_assert(UA_String_equal(&connectionConfig.transportProfileUri, &connectionConf.transportProfileUri) == UA_TRUE);
UA_NetworkAddressUrlDataType networkAddressUrlDataCopy = *((UA_NetworkAddressUrlDataType *)connectionConfig.address.data);
ck_assert(UA_calcSizeBinary(&networkAddressUrlDataCopy, &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]) ==
UA_calcSizeBinary(&networkAddressUrlData, &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]));
ck_assert(UA_calcSizeBinary(&networkAddressUrlDataCopy, &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE], NULL) ==
UA_calcSizeBinary(&networkAddressUrlData, &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE], NULL));
for(size_t i = 0; i < connectionConfig.connectionProperties.mapSize; i++){
ck_assert(UA_String_equal(&connectionConfig.connectionProperties.map[i].key.name, &connectionConf.connectionProperties.map[i].key.name) == UA_TRUE);
ck_assert(UA_Variant_calcSizeBinary(&connectionConfig.connectionProperties.map[i].value) == UA_Variant_calcSizeBinary(&connectionConf.connectionProperties.map[i].value));

4
tests/server/check_server_readspeed.c
View File

@ -156,7 +156,7 @@ START_TEST(readSpeedWithEncoding) {
UA_ByteString request_msg = request_buffer;
/* Encode the request */
retval = UA_encodeBinary(&request, &UA_TYPES[UA_TYPES_READREQUEST], &request_msg);
retval = UA_encodeBinary(&request, &UA_TYPES[UA_TYPES_READREQUEST], &request_msg, NULL);
ck_assert(retval == UA_STATUSCODE_GOOD);
/* Decode the request */
@ -167,7 +167,7 @@ START_TEST(readSpeedWithEncoding) {
Service_Read(server, &server->adminSession, &req, &res);
UA_UNLOCK(&server->serviceMutex);
retval = UA_encodeBinary(&res, &UA_TYPES[UA_TYPES_READRESPONSE], &response_msg);
retval = UA_encodeBinary(&res, &UA_TYPES[UA_TYPES_READRESPONSE], &response_msg, NULL);
ck_assert(retval == UA_STATUSCODE_GOOD);
UA_ReadRequest_clear(&req);

2
tools/ua2json/ua2json.c
View File

@ -55,7 +55,7 @@ decode(const UA_ByteString *buf, UA_ByteString *out, const UA_DataType *type) {
}
/* Encode Binary. Internally allocates the buffer upon success */
retval = UA_encodeBinary(data, type, out);
retval = UA_encodeBinary(data, type, out, NULL);
/* Clean up */
UA_delete(data, type);