END_TEST
START_TEST(encodeShallYieldDecode) {
/* floating point types may change the representaton due to several possible NaN values. */
if(_i != UA_TYPES_FLOAT || _i != UA_TYPES_DOUBLE ||
_i != UA_TYPES_CREATESESSIONREQUEST || _i != UA_TYPES_CREATESESSIONRESPONSE ||
_i != UA_TYPES_VARIABLEATTRIBUTES || _i != UA_TYPES_READREQUEST ||
_i != UA_TYPES_MONITORINGPARAMETERS || _i != UA_TYPES_MONITOREDITEMCREATERESULT ||
_i != UA_TYPES_CREATESUBSCRIPTIONREQUEST || _i != UA_TYPES_CREATESUBSCRIPTIONRESPONSE)
return;
// given
UA_ByteString msg1, msg2;
void *obj1 = UA_new(&UA_TYPES[_i]);
UA_StatusCode retval = UA_ByteString_allocBuffer(&msg1, 65000); // fixed buf size
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
UA_Byte *pos = msg1.data;
const UA_Byte *end = &msg1.data[msg1.length];
retval = UA_encodeBinary(obj1, &UA_TYPES[_i],
&pos, &end, NULL, NULL);
if(retval != UA_STATUSCODE_GOOD) {
UA_delete(obj1, &UA_TYPES[_i]);
UA_ByteString_deleteMembers(&msg1);
return;
}
// when
void *obj2 = UA_new(&UA_TYPES[_i]);
size_t offset = 0;
retval = UA_decodeBinary(&msg1, &offset, obj2, &UA_TYPES[_i], 0, NULL);
ck_assert_msg(retval == UA_STATUSCODE_GOOD, "could not decode idx=%d,nodeid=%i",
_i, UA_TYPES[_i].typeId.identifier.numeric);
ck_assert(!memcmp(obj1, obj2, UA_TYPES[_i].memSize)); // bit identical decoding
retval = UA_ByteString_allocBuffer(&msg2, 65000);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
pos = msg2.data;
end = &msg2.data[msg2.length];
retval = UA_encodeBinary(obj2, &UA_TYPES[_i], &pos, &end, NULL, NULL);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
// then
msg1.length = offset;
msg2.length = offset;
ck_assert_msg(UA_ByteString_equal(&msg1, &msg2) == true, "messages differ idx=%d,nodeid=%i", _i,
UA_TYPES[_i].typeId.identifier.numeric);
// finally
UA_delete(obj1, &UA_TYPES[_i]);
UA_delete(obj2, &UA_TYPES[_i]);
UA_ByteString_deleteMembers(&msg1);
UA_ByteString_deleteMembers(&msg2);
}
END_TEST
START_TEST(calcSizeBinaryShallBeCorrect) {
/* Empty variants (with no type defined) cannot be encoded. This is intentional. Discovery configuration is just a base class and void * */
if(_i == UA_TYPES_VARIANT ||
_i == UA_TYPES_VARIABLEATTRIBUTES ||
_i == UA_TYPES_VARIABLETYPEATTRIBUTES ||
_i == UA_TYPES_FILTEROPERAND ||
_i == UA_TYPES_MONITORINGFILTER ||
_i == UA_TYPES_DISCOVERYCONFIGURATION ||
_i == UA_TYPES_UNION ||
_i == UA_TYPES_HISTORYREADDETAILS ||
_i == UA_TYPES_NOTIFICATIONDATA ||
_i == UA_TYPES_MONITORINGFILTERRESULT)
return;
void *obj = UA_new(&UA_TYPES[_i]);
size_t predicted_size = UA_calcSizeBinary(obj, &UA_TYPES[_i]);
ck_assert_int_ne(predicted_size, 0);
UA_ByteString msg;
UA_StatusCode retval = UA_ByteString_allocBuffer(&msg, predicted_size);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
UA_Byte *pos = msg.data;
const UA_Byte *end = &msg.data[msg.length];
retval = UA_encodeBinary(obj, &UA_TYPES[_i], &pos, &end, NULL, NULL);
if(retval)
printf("%i\n",_i);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
ck_assert_int_eq((uintptr_t)(pos - msg.data), predicted_size);
UA_delete(obj, &UA_TYPES[_i]);
UA_ByteString_deleteMembers(&msg);
}
static UA_StatusCode CloseSecureChannel(UA_Client *client) {
UA_SecureChannel *channel = &client->channel;
UA_CloseSecureChannelRequest request;
UA_CloseSecureChannelRequest_init(&request);
request.requestHeader.requestHandle = 1; //TODO: magic number?
request.requestHeader.timestamp = UA_DateTime_now();
request.requestHeader.timeoutHint = 10000;
request.requestHeader.authenticationToken = client->authenticationToken;
UA_SecureConversationMessageHeader msgHeader;
msgHeader.messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_CLOF;
msgHeader.secureChannelId = client->channel.securityToken.channelId;
UA_SymmetricAlgorithmSecurityHeader symHeader;
symHeader.tokenId = channel->securityToken.tokenId;
UA_SequenceHeader seqHeader;
seqHeader.sequenceNumber = ++channel->sequenceNumber;
seqHeader.requestId = ++client->requestId;
UA_NodeId typeId = UA_NODEID_NUMERIC(0, UA_NS0ID_CLOSESECURECHANNELREQUEST + UA_ENCODINGOFFSET_BINARY);
UA_ByteString message;
UA_Connection *c = &client->connection;
UA_StatusCode retval = c->getSendBuffer(c, c->remoteConf.recvBufferSize, &message);
if(retval != UA_STATUSCODE_GOOD)
return retval;
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);
msgHeader.messageHeader.messageSize = offset;
offset = 0;
retval |= UA_SecureConversationMessageHeader_encodeBinary(&msgHeader, &message, &offset);
if(retval != UA_STATUSCODE_GOOD) {
client->connection.releaseSendBuffer(&client->connection, &message);
return retval;
}
message.length = msgHeader.messageHeader.messageSize;
retval = client->connection.send(&client->connection, &message);
return retval;
}
END_TEST
START_TEST(decodeShallFailWithTruncatedBufferButSurvive) {
//Skip test for void*
if (_i == UA_TYPES_DISCOVERYCONFIGURATION ||
_i == UA_TYPES_FILTEROPERAND ||
_i == UA_TYPES_MONITORINGFILTER ||
_i == UA_TYPES_UNION ||
_i == UA_TYPES_HISTORYREADDETAILS ||
_i == UA_TYPES_NOTIFICATIONDATA ||
_i == UA_TYPES_MONITORINGFILTERRESULT)
return;
// given
UA_ByteString msg1;
void *obj1 = UA_new(&UA_TYPES[_i]);
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_encodeBinary(obj1, &UA_TYPES[_i], &pos, &end, NULL, NULL);
UA_delete(obj1, &UA_TYPES[_i]);
if(retval != UA_STATUSCODE_GOOD) {
UA_ByteString_deleteMembers(&msg1);
return; // e.g. variants cannot be encoded after an init without failing (no datatype set)
}
size_t half = (uintptr_t)(pos - msg1.data) / 2;
msg1.length = half;
// when
void *obj2 = UA_new(&UA_TYPES[_i]);
size_t offset = 0;
retval = UA_decodeBinary(&msg1, &offset, obj2, &UA_TYPES[_i], 0, NULL);
ck_assert_int_ne(retval, UA_STATUSCODE_GOOD);
UA_delete(obj2, &UA_TYPES[_i]);
UA_ByteString_deleteMembers(&msg1);
}
int main(int argc, char** argv) {
signal(SIGINT, stopHandler); /* catches ctrl-c */
UA_ServerConfig config = UA_ServerConfig_standard;
UA_ServerNetworkLayer nl = UA_ServerNetworkLayerTCP(UA_ConnectionConfig_standard, 16664, logger);
config.logger = Logger_Stdout;
config.networkLayers = &nl;
config.networkLayersSize = 1;
UA_Server *server = UA_Server_new(config);
/* add a variable node to the address space */
UA_VariableAttributes attr;
UA_VariableAttributes_init(&attr);
UA_Int32 myInteger = 42;
UA_Variant_setScalar(&attr.value, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
attr.description = UA_LOCALIZEDTEXT("en_US","the answer");
attr.displayName = UA_LOCALIZEDTEXT("en_US","the answer");
UA_NodeId myIntegerNodeId = UA_NODEID_STRING(1, "the.answer");
UA_QualifiedName myIntegerName = UA_QUALIFIEDNAME(1, "the answer");
UA_NodeId parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
UA_Server_addVariableNode(server, myIntegerNodeId, parentNodeId,
parentReferenceNodeId, myIntegerName,
UA_NODEID_NULL, attr, NULL, NULL);
UA_ReadRequest request;
UA_ReadRequest_init(&request);
UA_ReadValueId rvi;
rvi.nodeId = myIntegerNodeId;
rvi.attributeId = UA_ATTRIBUTEID_VALUE;
rvi.indexRange = UA_STRING_NULL;
rvi.dataEncoding = UA_QUALIFIEDNAME(0, "DefaultBinary");
request.timestampsToReturn = UA_TIMESTAMPSTORETURN_NEITHER;
request.nodesToReadSize = 1;
request.nodesToRead = &rvi;
UA_StatusCode retval = UA_STATUSCODE_GOOD;
UA_ByteString request_msg;
retval |= UA_ByteString_allocBuffer(&request_msg, 1000);
UA_ByteString response_msg;
retval |= UA_ByteString_allocBuffer(&response_msg, 1000);
size_t offset = 0;
retval |= UA_encodeBinary(&request, &UA_TYPES[UA_TYPES_READREQUEST], &request_msg, &offset);
clock_t begin, end;
begin = clock();
UA_ReadRequest rq;
UA_ReadResponse rr;
for(int i = 0; i < 900000; i++) {
offset = 0;
retval |= UA_decodeBinary(&request_msg, &offset, &rq, &UA_TYPES[UA_TYPES_READREQUEST]);
UA_ReadResponse_init(&rr);
Service_Read(server, &adminSession, &rq, &rr);
offset = 0;
retval |= UA_encodeBinary(&rr, &UA_TYPES[UA_TYPES_READRESPONSE], &response_msg, &offset);
UA_ReadRequest_deleteMembers(&rq);
UA_ReadResponse_deleteMembers(&rr);
}
end = clock();
double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("duration was %f s\n", time_spent);
printf("retval is %i\n", retval);
UA_ByteString_deleteMembers(&request_msg);
UA_ByteString_deleteMembers(&response_msg);
retval |= UA_Server_run(server, &running);
UA_Server_delete(server);
nl.deleteMembers(&nl);
return (int)retval;
}
/* When a change is detected, encoding contains the heap-allocated binary
* encoded value. The default for changed is false. */
static UA_StatusCode
detectValueChangeWithFilter(UA_Server *server, UA_MonitoredItem *mon, UA_DataValue *value,
UA_ByteString *encoding, UA_Boolean *changed) {
if(UA_DataType_isNumeric(value->value.type) &&
(mon->filter.dataChangeFilter.trigger == UA_DATACHANGETRIGGER_STATUSVALUE ||
mon->filter.dataChangeFilter.trigger == UA_DATACHANGETRIGGER_STATUSVALUETIMESTAMP)) {
if(mon->filter.dataChangeFilter.deadbandType == UA_DEADBANDTYPE_ABSOLUTE) {
if(!updateNeededForFilteredValue(&value->value, &mon->lastValue,
mon->filter.dataChangeFilter.deadbandValue))
return UA_STATUSCODE_GOOD;
}
#ifdef UA_ENABLE_DA
else if(mon->filter.dataChangeFilter.deadbandType == UA_DEADBANDTYPE_PERCENT) {
UA_QualifiedName qn = UA_QUALIFIEDNAME(0, "EURange");
UA_BrowsePathResult bpr = UA_Server_browseSimplifiedBrowsePath(server, mon->monitoredNodeId, 1, &qn);
if(bpr.statusCode != UA_STATUSCODE_GOOD || bpr.targetsSize < 1) { //if branch is not entried, property has been found
UA_BrowsePathResult_deleteMembers(&bpr);
return UA_STATUSCODE_GOOD;
}
const UA_VariableNode* node =
(const UA_VariableNode*) UA_Nodestore_getNode(server->nsCtx, &bpr.targets->targetId.nodeId);
UA_Range* euRange = (UA_Range*) node->value.data.value.value.data;
if(!updateNeededForFilteredPercentValue(&value->value, &mon->lastValue,
mon->filter.dataChangeFilter.deadbandValue, euRange)) {
if(!updateNeededForStatusCode(value, mon)) //when same value, but different status code is written
return UA_STATUSCODE_GOOD;
}
}
#endif
}
/* Stack-allocate some memory for the value encoding. We might heap-allocate
* more memory if needed. This is just enough for scalars and small
* structures. */
UA_STACKARRAY(UA_Byte, stackValueEncoding, UA_VALUENCODING_MAXSTACK);
UA_ByteString valueEncoding;
valueEncoding.data = stackValueEncoding;
valueEncoding.length = UA_VALUENCODING_MAXSTACK;
/* Encode the value */
UA_Byte *bufPos = valueEncoding.data;
const UA_Byte *bufEnd = &valueEncoding.data[valueEncoding.length];
UA_StatusCode retval = UA_encodeBinary(value, &UA_TYPES[UA_TYPES_DATAVALUE],
&bufPos, &bufEnd, NULL, NULL);
if(retval == UA_STATUSCODE_BADENCODINGERROR) {
size_t binsize = UA_calcSizeBinary(value, &UA_TYPES[UA_TYPES_DATAVALUE]);
if(binsize == 0)
return UA_STATUSCODE_BADENCODINGERROR;
if(binsize > UA_VALUENCODING_MAXSTACK) {
retval = UA_ByteString_allocBuffer(&valueEncoding, binsize);
if(retval == UA_STATUSCODE_GOOD) {
bufPos = valueEncoding.data;
bufEnd = &valueEncoding.data[valueEncoding.length];
retval = UA_encodeBinary(value, &UA_TYPES[UA_TYPES_DATAVALUE],
&bufPos, &bufEnd, NULL, NULL);
}
}
}
if(retval != UA_STATUSCODE_GOOD) {
if(valueEncoding.data != stackValueEncoding)
UA_ByteString_deleteMembers(&valueEncoding);
return retval;
}
/* Has the value changed? */
valueEncoding.length = (uintptr_t)bufPos - (uintptr_t)valueEncoding.data;
*changed = (!mon->lastSampledValue.data ||
!UA_String_equal(&valueEncoding, &mon->lastSampledValue));
/* No change */
if(!(*changed)) {
if(valueEncoding.data != stackValueEncoding)
UA_ByteString_deleteMembers(&valueEncoding);
return UA_STATUSCODE_GOOD;
}
/* Change detected. Copy encoding on the heap if necessary. */
if(valueEncoding.data == stackValueEncoding)
return UA_ByteString_copy(&valueEncoding, encoding);
*encoding = valueEncoding;
return UA_STATUSCODE_GOOD;
}