static UA_Int64 sendReadRequest(ConnectionInfo *connectionInfo, UA_Int32 nodeIds_size,UA_NodeId* nodeIds){
/*UA_Int32 sock, UA_UInt32 channelId, UA_UInt32 tokenId, UA_UInt32 sequenceNumber, UA_UInt32 requestId,
UA_NodeId authenticationToken, UA_Int32 nodeIds_size,UA_NodeId* nodeIds) {
*/
UA_ByteString *message = UA_ByteString_new();
UA_ByteString_newMembers(message, 65536);
UA_UInt32 tmpChannelId = connectionInfo->channelId;
size_t offset = 0;
UA_TcpMessageHeader msghdr;
msghdr.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_MSGF;
UA_NodeId type;
type.identifier.numeric = 631;
type.identifierType = UA_NODEIDTYPE_NUMERIC;
type.namespaceIndex = 0;
UA_ReadRequest rq;
UA_ReadRequest_init(&rq);
rq.maxAge = 0;
rq.nodesToRead = UA_Array_new(&UA_TYPES[UA_TYPES_READVALUEID], nodeIds_size);
rq.nodesToReadSize = 1;
for(UA_Int32 i=0;i<nodeIds_size;i++) {
UA_ReadValueId_init(&(rq.nodesToRead[i]));
rq.nodesToRead[i].attributeId = 6; //WriteMask
UA_NodeId_init(&(rq.nodesToRead[i].nodeId));
rq.nodesToRead[i].nodeId = nodeIds[i];
UA_QualifiedName_init(&(rq.nodesToRead[0].dataEncoding));
}
rq.requestHeader.timeoutHint = 10000;
rq.requestHeader.timestamp = UA_DateTime_now();
rq.requestHeader.authenticationToken = connectionInfo->authenticationToken;
rq.timestampsToReturn = 0x03;
rq.requestHeader.requestHandle = 1 + connectionInfo->sequenceHdr.requestId;
msghdr.messageSize = 16 + UA_TcpMessageHeader_calcSizeBinary(&msghdr) + UA_NodeId_calcSizeBinary(&type) +
UA_ReadRequest_calcSizeBinary(&rq);
UA_TcpMessageHeader_encodeBinary(&msghdr,message,&offset);
UA_UInt32_encodeBinary(&tmpChannelId, message, &offset);
UA_UInt32_encodeBinary(&connectionInfo->tokenId, message, &offset);
UA_UInt32_encodeBinary(&connectionInfo->sequenceHdr.sequenceNumber, message, &offset);
UA_UInt32_encodeBinary(&connectionInfo->sequenceHdr.requestId, message, &offset);
UA_NodeId_encodeBinary(&type,message,&offset);
UA_ReadRequest_encodeBinary(&rq, message, &offset);
UA_DateTime tic = UA_DateTime_now();
UA_Int32 sendret = send(connectionInfo->socket, message->data, offset, 0);
UA_Array_delete(rq.nodesToRead, &UA_TYPES[UA_TYPES_READVALUEID], nodeIds_size);
UA_ByteString_delete(message);
if (sendret < 0) {
printf("send readrequest failed");
return 1;
}
return tic;
}
END_TEST
START_TEST(Server_HistorizingStrategyValueSet)
{
// init to a defined value
UA_StatusCode retval = setUInt32(client, outNodeId, 43);
ck_assert_str_eq(UA_StatusCode_name(retval), UA_StatusCode_name(UA_STATUSCODE_GOOD));
// set a data backend
UA_HistorizingNodeIdSettings setting;
setting.historizingBackend = UA_HistoryDataBackend_Memory(3, 100);
setting.maxHistoryDataResponseSize = 100;
setting.historizingUpdateStrategy = UA_HISTORIZINGUPDATESTRATEGY_VALUESET;
serverMutexLock();
retval = gathering->registerNodeId(server, gathering->context, &outNodeId, setting);
serverMutexUnlock();
ck_assert_str_eq(UA_StatusCode_name(retval), UA_StatusCode_name(UA_STATUSCODE_GOOD));
// fill the data
UA_fakeSleep(100);
UA_DateTime start = UA_DateTime_now();
UA_fakeSleep(100);
for (UA_UInt32 i = 0; i < 10; ++i) {
retval = setUInt32(client, outNodeId, i);
ck_assert_str_eq(UA_StatusCode_name(retval), UA_StatusCode_name(UA_STATUSCODE_GOOD));
UA_fakeSleep(100);
}
UA_DateTime end = UA_DateTime_now();
// request
UA_HistoryReadResponse response;
UA_HistoryReadResponse_init(&response);
requestHistory(start, end, &response, 0, false, NULL);
// test the response
ck_assert_str_eq(UA_StatusCode_name(response.responseHeader.serviceResult), UA_StatusCode_name(UA_STATUSCODE_GOOD));
ck_assert_uint_eq(response.resultsSize, 1);
for (size_t i = 0; i < response.resultsSize; ++i) {
ck_assert_str_eq(UA_StatusCode_name(response.results[i].statusCode), UA_StatusCode_name(UA_STATUSCODE_GOOD));
ck_assert_uint_eq(response.results[i].historyData.encoding, UA_EXTENSIONOBJECT_DECODED);
ck_assert(response.results[i].historyData.content.decoded.type == &UA_TYPES[UA_TYPES_HISTORYDATA]);
UA_HistoryData * data = (UA_HistoryData *)response.results[i].historyData.content.decoded.data;
ck_assert(data->dataValuesSize > 0);
for (size_t j = 0; j < data->dataValuesSize; ++j) {
ck_assert(data->dataValues[j].sourceTimestamp >= start && data->dataValues[j].sourceTimestamp < end);
ck_assert_uint_eq(data->dataValues[j].hasSourceTimestamp, true);
ck_assert_str_eq(UA_StatusCode_name(data->dataValues[j].status), UA_StatusCode_name(UA_STATUSCODE_GOOD));
ck_assert_uint_eq(data->dataValues[j].hasValue, true);
ck_assert(data->dataValues[j].value.type == &UA_TYPES[UA_TYPES_UINT32]);
UA_UInt32 * value = (UA_UInt32 *)data->dataValues[j].value.data;
ck_assert_uint_eq(*value, j);
}
}
UA_HistoryReadResponse_deleteMembers(&response);
UA_HistoryDataBackend_Memory_deleteMembers(&setting.historizingBackend);
}
void print_time() {
UA_DateTime now = UA_DateTime_now();
UA_ByteString str;
UA_DateTime_toString(now, &str);
printf("\"%.*s\"}", str.length, str.data);
UA_ByteString_deleteMembers(&str);
}
static UA_StatusCode readLedStatus(void *handle, UA_Boolean sourceTimeStamp,
const UA_NumericRange *range, UA_DataValue *value) {
if(range) {
value->hasStatus = UA_TRUE;
value->status = UA_STATUSCODE_BADINDEXRANGEINVALID;
return UA_STATUSCODE_GOOD;
}
/* In order to reduce blocking time, we could alloc memory for every read
and return a copy of the data. */
#ifdef UA_MULTITHREADING
pthread_rwlock_rdlock(&writeLock);
#endif
value->value.type = &UA_TYPES[UA_TYPES_BOOLEAN];
value->value.arrayLength = -1;
value->value.data = &ledStatus;
value->value.arrayDimensionsSize = -1;
value->value.arrayDimensions = NULL;
value->hasValue = UA_TRUE;
if(sourceTimeStamp) {
value->sourceTimestamp = UA_DateTime_now();
value->hasSourceTimestamp = UA_TRUE;
}
return UA_STATUSCODE_GOOD;
}
/**
* Setting up an event
* ^^^^^^^^^^^^^^^^^^^
* In order to set up the event, we can first use ``UA_Server_createEvent`` to give us a node representation of the event.
* All we need for this is our `EventType`. Once we have our event node, which is saved internally as an `ObjectNode`,
* we can define the attributes the event has the same way we would define the attributes of an object node. It is not
* necessary to define the attributes `EventId`, `ReceiveTime`, `SourceNode` or `EventType` since these are set
* automatically by the server. In this example, we will be setting the fields 'Message' and 'Severity' in addition
* to `Time` which is needed to make the example UaExpert compliant.
*/
static UA_StatusCode
setUpEvent(UA_Server *server, UA_NodeId *outId) {
UA_StatusCode retval = UA_Server_createEvent(server, eventType, outId);
if (retval != UA_STATUSCODE_GOOD) {
UA_LOG_WARNING(UA_Log_Stdout, UA_LOGCATEGORY_SERVER,
"createEvent failed. StatusCode %s", UA_StatusCode_name(retval));
return retval;
}
/* Set the Event Attributes */
/* Setting the Time is required or else the event will not show up in UAExpert! */
UA_DateTime eventTime = UA_DateTime_now();
UA_Server_writeObjectProperty_scalar(server, *outId, UA_QUALIFIEDNAME(0, "Time"),
&eventTime, &UA_TYPES[UA_TYPES_DATETIME]);
UA_UInt16 eventSeverity = 100;
UA_Server_writeObjectProperty_scalar(server, *outId, UA_QUALIFIEDNAME(0, "Severity"),
&eventSeverity, &UA_TYPES[UA_TYPES_UINT16]);
UA_LocalizedText eventMessage = UA_LOCALIZEDTEXT("en-US", "An event has been generated.");
UA_Server_writeObjectProperty_scalar(server, *outId, UA_QUALIFIEDNAME(0, "Message"),
&eventMessage, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
UA_String eventSourceName = UA_STRING("Server");
UA_Server_writeObjectProperty_scalar(server, *outId, UA_QUALIFIEDNAME(0, "SourceName"),
&eventSourceName, &UA_TYPES[UA_TYPES_STRING]);
return UA_STATUSCODE_GOOD;
}
static void print_time(void) {
UA_DateTime now = UA_DateTime_now();
UA_ByteString str;
UA_DateTime_toString(now, &str);
printf("%.27s", str.data); //a bit hacky way not to display nanoseconds
UA_ByteString_deleteMembers(&str);
}
static UA_StatusCode
readTemperature(void *handle, const UA_NodeId nodeId, UA_Boolean sourceTimeStamp,
const UA_NumericRange *range, UA_DataValue *value) {
if(range) {
value->hasStatus = true;
value->status = UA_STATUSCODE_BADINDEXRANGEINVALID;
return UA_STATUSCODE_GOOD;
}
rewind(temperatureFile);
fflush(temperatureFile);
UA_Double currentTemperature;
if(fscanf(temperatureFile, "%lf", ¤tTemperature) != 1){
UA_LOG_WARNING(logger, UA_LOGCATEGORY_USERLAND, "Can not parse temperature");
exit(1);
}
currentTemperature /= 1000.0;
value->sourceTimestamp = UA_DateTime_now();
value->hasSourceTimestamp = true;
UA_Variant_setScalarCopy(&value->value, ¤tTemperature, &UA_TYPES[UA_TYPES_DOUBLE]);
value->hasValue = true;
return UA_STATUSCODE_GOOD;
}
static void handleServerTimestamps(UA_TimestampsToReturn timestamps, UA_DataValue* v) {
if (v && (timestamps == UA_TIMESTAMPSTORETURN_SERVER
|| timestamps == UA_TIMESTAMPSTORETURN_BOTH)) {
v->hasServerTimestamp = UA_TRUE;
v->serverTimestamp = UA_DateTime_now();
}
}
void UA_Log_Stdout(UA_LogLevel level, UA_LogCategory category, const char *msg, ...) {
UA_String t = UA_DateTime_toString(UA_DateTime_now());
printf("[%.23s] %s/%s\t", t.data, LogLevelNames[level], LogCategoryNames[category]);
UA_ByteString_deleteMembers(&t);
va_list ap;
va_start(ap, msg);
vprintf(msg, ap);
va_end(ap);
printf("\n");
}
static UA_StatusCode
requestActivateSession (UA_Client *client, UA_UInt32 *requestId) {
UA_ActivateSessionRequest request;
UA_ActivateSessionRequest_init(&request);
request.requestHeader.requestHandle = ++client->requestHandle;
request.requestHeader.timestamp = UA_DateTime_now ();
request.requestHeader.timeoutHint = 600000;
UA_StatusCode retval =
UA_ExtensionObject_copy(&client->config.userIdentityToken, &request.userIdentityToken);
if(retval != UA_STATUSCODE_GOOD)
return retval;
/* If not token is set, use anonymous */
if(request.userIdentityToken.encoding == UA_EXTENSIONOBJECT_ENCODED_NOBODY) {
UA_AnonymousIdentityToken *t = UA_AnonymousIdentityToken_new();
if(!t) {
UA_ActivateSessionRequest_deleteMembers(&request);
return UA_STATUSCODE_BADOUTOFMEMORY;
}
request.userIdentityToken.content.decoded.data = t;
request.userIdentityToken.content.decoded.type = &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN];
request.userIdentityToken.encoding = UA_EXTENSIONOBJECT_DECODED;
}
/* Set the policy-Id from the endpoint. Every IdentityToken starts with a
* string. */
retval = UA_String_copy(&client->config.userTokenPolicy.policyId,
(UA_String*)request.userIdentityToken.content.decoded.data);
#ifdef UA_ENABLE_ENCRYPTION
/* Encrypt the UserIdentityToken */
const UA_String *userTokenPolicy = &client->channel.securityPolicy->policyUri;
if(client->config.userTokenPolicy.securityPolicyUri.length > 0)
userTokenPolicy = &client->config.userTokenPolicy.securityPolicyUri;
retval |= encryptUserIdentityToken(client, userTokenPolicy, &request.userIdentityToken);
/* This function call is to prepare a client signature */
retval |= signActivateSessionRequest(&client->channel, &request);
#endif
if(retval != UA_STATUSCODE_GOOD) {
UA_ActivateSessionRequest_deleteMembers(&request);
client->connectStatus = retval;
return retval;
}
retval = UA_Client_sendAsyncRequest (
client, &request, &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST],
(UA_ClientAsyncServiceCallback) responseActivateSession,
&UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE], NULL, requestId);
UA_ActivateSessionRequest_deleteMembers(&request);
client->connectStatus = retval;
return retval;
}
static UA_Int32 sendCreateSession(UA_Int32 sock, UA_UInt32 channelId, UA_UInt32 tokenId, UA_UInt32 sequenceNumber,
UA_UInt32 requestId, UA_String *endpointUrl) {
UA_ByteString message;
UA_ByteString_newMembers(&message, 65536);
UA_UInt32 tmpChannelId = channelId;
size_t offset = 0;
UA_TcpMessageHeader msghdr;
msghdr.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_MSGF;
UA_NodeId type;
type.identifier.numeric = 461;
type.identifierType = UA_NODEIDTYPE_NUMERIC;
type.namespaceIndex = 0;
UA_CreateSessionRequest rq;
UA_CreateSessionRequest_init(&rq);
rq.requestHeader.requestHandle = 1;
rq.requestHeader.timestamp = UA_DateTime_now();
rq.requestHeader.timeoutHint = 10000;
rq.requestHeader.authenticationToken.identifier.numeric = 10;
rq.requestHeader.authenticationToken.identifierType = UA_NODEIDTYPE_NUMERIC;
rq.requestHeader.authenticationToken.namespaceIndex = 10;
UA_String_copy(endpointUrl, &rq.endpointUrl);
UA_String_copycstring("mysession", &rq.sessionName);
UA_String_copycstring("abcd", &rq.clientCertificate);
UA_ByteString_newMembers(&rq.clientNonce, 1);
rq.clientNonce.data[0] = 0;
rq.requestedSessionTimeout = 1200000;
rq.maxResponseMessageSize = UA_INT32_MAX;
msghdr.messageSize = 16 + UA_TcpMessageHeader_calcSizeBinary(&msghdr) + UA_NodeId_calcSizeBinary(&type) +
UA_CreateSessionRequest_calcSizeBinary(&rq);
UA_TcpMessageHeader_encodeBinary(&msghdr, &message, &offset);
UA_UInt32_encodeBinary(&tmpChannelId, &message, &offset);
UA_UInt32_encodeBinary(&tokenId, &message, &offset);
UA_UInt32_encodeBinary(&sequenceNumber, &message, &offset);
UA_UInt32_encodeBinary(&requestId, &message, &offset);
UA_NodeId_encodeBinary(&type, &message, &offset);
UA_CreateSessionRequest_encodeBinary(&rq, &message, &offset);
UA_Int32 sendret = send(sock, message.data, offset, 0);
UA_ByteString_deleteMembers(&message);
UA_CreateSessionRequest_deleteMembers(&rq);
if (sendret < 0) {
printf("send opensecurechannel failed");
return 1;
}
return 0;
}
static void
sendCloseSessionAsync(UA_Client *client, UA_UInt32 *requestId) {
UA_CloseSessionRequest request;
UA_CloseSessionRequest_init(&request);
request.requestHeader.timestamp = UA_DateTime_now();
request.requestHeader.timeoutHint = 10000;
request.deleteSubscriptions = true;
UA_Client_sendAsyncRequest(
client, &request, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST],
(UA_ClientAsyncServiceCallback) sendCloseSecureChannelAsync,
&UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE], NULL, requestId);
}
static UA_StatusCode EndpointsHandshake(UA_Client *client) {
UA_GetEndpointsRequest request;
UA_GetEndpointsRequest_init(&request);
request.requestHeader.authenticationToken = client->authenticationToken;
request.requestHeader.timestamp = UA_DateTime_now();
request.requestHeader.timeoutHint = 10000;
request.endpointUrl = client->endpointUrl;
UA_String profileUri = UA_STRING("http://opcfoundation.org/UA-Profile/Transport/uatcp-uasc-uabinary");
request.profileUris = &profileUri;
request.profileUrisSize = 1;
UA_GetEndpointsResponse response;
UA_GetEndpointsResponse_init(&response);
__UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST],
&response, &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]);
UA_Boolean endpointFound = UA_FALSE;
UA_Boolean tokenFound = UA_FALSE;
UA_String securityNone = UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#None");
for(UA_Int32 i = 0; i < response.endpointsSize; i++) {
UA_EndpointDescription* endpoint = &response.endpoints[i];
/* look out for an endpoint without security */
if(!UA_String_equal(&endpoint->securityPolicyUri, &securityNone))
continue;
endpointFound = UA_TRUE;
/* endpoint with no security found */
/* look for a user token policy with an anonymous token */
for(UA_Int32 j=0; j<endpoint->userIdentityTokensSize; ++j) {
UA_UserTokenPolicy* userToken = &endpoint->userIdentityTokens[j];
if(userToken->tokenType != UA_USERTOKENTYPE_ANONYMOUS)
continue;
tokenFound = UA_TRUE;
UA_UserTokenPolicy_copy(userToken, &client->token);
break;
}
}
UA_GetEndpointsResponse_deleteMembers(&response);
if(!endpointFound) {
UA_LOG_ERROR(client->logger, UA_LOGCATEGORY_CLIENT, "No suitable endpoint found");
return UA_STATUSCODE_BADINTERNALERROR;
}
if(!tokenFound) {
UA_LOG_ERROR(client->logger, UA_LOGCATEGORY_CLIENT, "No anonymous token found");
return UA_STATUSCODE_BADINTERNALERROR;
}
return response.responseHeader.serviceResult;
}
UA_StatusCode temperature_sensor_read(void * handle, const UA_NodeId node_id, UA_Boolean source_timestamp,
const UA_NumericRange *range, UA_DataValue * data_value)
{
UA_DateTime sourceTimestamp = UA_DateTime_now();
int result = 0;
if(i2c_fd < 0)
return UA_STATUSCODE_BADNOTREADABLE;
if(!temperature_get(i2c_fd, CONVERSION_CURRENT, &result))
return UA_STATUSCODE_BADNOTREADABLE;
data_value->hasValue = true;
data_value->hasSourceTimestamp = true;
data_value->hasServerTimestamp = true;
data_value->sourceTimestamp = sourceTimestamp;
UA_Variant_setScalarCopy(&data_value->value, &result, &UA_TYPES[UA_TYPES_INT32]);
return UA_STATUSCODE_GOOD;
}
static UA_StatusCode CloseSession(UA_Client *client) {
UA_CloseSessionRequest request;
UA_CloseSessionRequest_init(&request);
request.requestHeader.timestamp = UA_DateTime_now();
request.requestHeader.timeoutHint = 10000;
request.deleteSubscriptions = UA_TRUE;
UA_NodeId_copy(&client->authenticationToken, &request.requestHeader.authenticationToken);
UA_CloseSessionResponse response;
__UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST],
&response, &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]);
UA_CloseSessionRequest_deleteMembers(&request);
UA_CloseSessionResponse_deleteMembers(&response);
return response.responseHeader.serviceResult; // not deleted
}
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;
}
static UA_StatusCode
requestGetEndpoints(UA_Client *client, UA_UInt32 *requestId) {
UA_GetEndpointsRequest request;
UA_GetEndpointsRequest_init(&request);
request.requestHeader.timestamp = UA_DateTime_now();
request.requestHeader.timeoutHint = 10000;
/* assume the endpointurl outlives the service call */
UA_String_copy(&client->endpointUrl, &request.endpointUrl);
client->connectStatus = UA_Client_sendAsyncRequest(
client, &request, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST],
(UA_ClientAsyncServiceCallback) responseGetEndpoints,
&UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE], NULL, requestId);
UA_GetEndpointsRequest_deleteMembers(&request);
return client->connectStatus;
}
static UA_StatusCode
readTimeData(void *handle, const UA_NodeId nodeId, UA_Boolean sourceTimeStamp,
const UA_NumericRange *range, UA_DataValue *value) {
if(range) {
value->hasStatus = true;
value->status = UA_STATUSCODE_BADINDEXRANGEINVALID;
return UA_STATUSCODE_GOOD;
}
UA_DateTime currentTime = UA_DateTime_now();
UA_Variant_setScalarCopy(&value->value, ¤tTime, &UA_TYPES[UA_TYPES_DATETIME]);
value->hasValue = true;
if(sourceTimeStamp) {
value->hasSourceTimestamp = true;
value->sourceTimestamp = currentTime;
}
return UA_STATUSCODE_GOOD;
}
static UA_Int32 closeSession(ConnectionInfo *connectionInfo) {
size_t offset = 0;
UA_ByteString message;
UA_ByteString_newMembers(&message, 65536);
UA_CloseSessionRequest rq;
UA_CloseSessionRequest_init(&rq);
rq.requestHeader.requestHandle = 1;
rq.requestHeader.timestamp = UA_DateTime_now();
rq.requestHeader.timeoutHint = 10000;
rq.requestHeader.authenticationToken.identifier.numeric = 10;
rq.requestHeader.authenticationToken.identifierType = UA_NODEIDTYPE_NUMERIC;
rq.requestHeader.authenticationToken.namespaceIndex = 10;
rq.deleteSubscriptions = UA_TRUE;
UA_TcpMessageHeader msghdr;
msghdr.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_MSGF;
UA_NodeId type;
type.identifier.numeric = 473;
type.identifierType = UA_NODEIDTYPE_NUMERIC;
type.namespaceIndex = 0;
msghdr.messageSize = 16 + UA_TcpMessageHeader_calcSizeBinary(&msghdr) + UA_NodeId_calcSizeBinary(&type) +
UA_CloseSessionRequest_calcSizeBinary(&rq);
UA_TcpMessageHeader_encodeBinary(&msghdr, &message, &offset);
UA_UInt32_encodeBinary(&connectionInfo->channelId, &message, &offset);
UA_UInt32_encodeBinary(&connectionInfo->tokenId, &message, &offset);
UA_UInt32_encodeBinary(&connectionInfo->sequenceHdr.sequenceNumber, &message, &offset);
UA_UInt32_encodeBinary(&connectionInfo->sequenceHdr.requestId, &message, &offset);
UA_NodeId_encodeBinary(&type, &message, &offset);
UA_CloseSessionRequest_encodeBinary(&rq, &message, &offset);
UA_Int32 sendret = send(connectionInfo->socket, message.data, offset, 0);
UA_ByteString_deleteMembers(&message);
UA_CloseSessionRequest_deleteMembers(&rq);
if(sendret < 0) {
printf("send closesessionrequest failed");
return 1;
}
return 0;
}
static void
sendError(UA_SecureChannel *channel, const UA_ByteString *msg,
size_t offset, const UA_DataType *responseType,
UA_UInt32 requestId, UA_StatusCode error) {
UA_RequestHeader requestHeader;
UA_StatusCode retval = UA_RequestHeader_decodeBinary(msg, &offset, &requestHeader);
if(retval != UA_STATUSCODE_GOOD)
return;
void *response = UA_alloca(responseType->memSize);
UA_init(response, responseType);
UA_ResponseHeader *responseHeader = (UA_ResponseHeader*)response;
responseHeader->requestHandle = requestHeader.requestHandle;
responseHeader->timestamp = UA_DateTime_now();
responseHeader->serviceResult = error;
UA_SecureChannel_sendBinaryMessage(channel, requestId, response, responseType);
UA_RequestHeader_deleteMembers(&requestHeader);
UA_ResponseHeader_deleteMembers(responseHeader);
}
static UA_Int32 sendActivateSession(UA_Int32 sock, UA_UInt32 channelId, UA_UInt32 tokenId, UA_UInt32 sequenceNumber,
UA_UInt32 requestId, UA_NodeId authenticationToken) {
UA_ByteString *message = UA_ByteString_new();
UA_ByteString_newMembers(message, 65536);
UA_UInt32 tmpChannelId = channelId;
size_t offset = 0;
UA_TcpMessageHeader msghdr;
msghdr.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_MSGF;
msghdr.messageSize = 86;
UA_NodeId type;
type.identifier.numeric = 467;
type.identifierType = UA_NODEIDTYPE_NUMERIC;
type.namespaceIndex = 0;
UA_ActivateSessionRequest rq;
UA_ActivateSessionRequest_init(&rq);
rq.requestHeader.requestHandle = 2;
rq.requestHeader.authenticationToken = authenticationToken;
rq.requestHeader.timestamp = UA_DateTime_now();
rq.requestHeader.timeoutHint = 10000;
msghdr.messageSize = 16 + UA_TcpMessageHeader_calcSizeBinary(&msghdr) + UA_NodeId_calcSizeBinary(&type) +
UA_ActivateSessionRequest_calcSizeBinary(&rq);
UA_TcpMessageHeader_encodeBinary(&msghdr, message, &offset);
UA_UInt32_encodeBinary(&tmpChannelId, message, &offset);
UA_UInt32_encodeBinary(&tokenId, message, &offset);
UA_UInt32_encodeBinary(&sequenceNumber, message, &offset);
UA_UInt32_encodeBinary(&requestId, message, &offset);
UA_NodeId_encodeBinary(&type, message, &offset);
UA_ActivateSessionRequest_encodeBinary(&rq, message, &offset);
UA_Int32 sendret = send(sock, message->data, offset, 0);
UA_ByteString_delete(message);
if (sendret < 0) {
printf("send opensecurechannel failed");
return 1;
}
return 0;
}
static void
variables_basic(void) {
/* Int32 */
UA_Int32 i = 5;
UA_Int32 j;
UA_Int32_copy(&i, &j);
UA_Int32 *ip = UA_Int32_new();
UA_Int32_copy(&i, ip);
UA_Int32_delete(ip);
/* String */
UA_String s;
UA_String_init(&s); /* _init zeroes out the entire memory of the datatype */
char *test = "test";
s.length = strlen(test);
s.data = (UA_Byte*)test;
UA_String s2;
UA_String_copy(&s, &s2);
UA_String_deleteMembers(&s2); /* Copying heap-allocated the dynamic content */
UA_String s3 = UA_STRING("test2");
UA_String s4 = UA_STRING_ALLOC("test2"); /* Copies the content to the heap */
UA_Boolean eq = UA_String_equal(&s3, &s4);
UA_String_deleteMembers(&s4);
if(!eq)
return;
/* Structured Type */
UA_ReadRequest rr;
UA_init(&rr, &UA_TYPES[UA_TYPES_READREQUEST]); /* Generic method */
UA_ReadRequest_init(&rr); /* Shorthand for the previous line */
rr.requestHeader.timestamp = UA_DateTime_now(); /* Members of a structure */
rr.nodesToRead = (UA_ReadValueId *)UA_Array_new(5, &UA_TYPES[UA_TYPES_READVALUEID]);
rr.nodesToReadSize = 5; /* Array size needs to be made known */
UA_ReadRequest *rr2 = UA_ReadRequest_new();
UA_copy(&rr, rr2, &UA_TYPES[UA_TYPES_READREQUEST]);
UA_ReadRequest_deleteMembers(&rr);
UA_ReadRequest_delete(rr2);
}
static UA_StatusCode
readLedStatus(void *handle, UA_NodeId nodeid, UA_Boolean sourceTimeStamp,
const UA_NumericRange *range, UA_DataValue *value) {
if(range)
return UA_STATUSCODE_BADINDEXRANGEINVALID;
value->hasValue = true;
UA_StatusCode retval = UA_Variant_setScalarCopy(&value->value, &ledStatus,
&UA_TYPES[UA_TYPES_BOOLEAN]);
if(retval != UA_STATUSCODE_GOOD)
return retval;
if(sourceTimeStamp) {
value->sourceTimestamp = UA_DateTime_now();
value->hasSourceTimestamp = true;
}
return UA_STATUSCODE_GOOD;
}
/* Async disconnection */
static void
sendCloseSecureChannelAsync(UA_Client *client, void *userdata,
UA_UInt32 requestId, void *response) {
UA_NodeId_deleteMembers (&client->authenticationToken);
client->requestHandle = 0;
UA_SecureChannel *channel = &client->channel;
UA_CloseSecureChannelRequest request;
UA_CloseSecureChannelRequest_init(&request);
request.requestHeader.requestHandle = ++client->requestHandle;
request.requestHeader.timestamp = UA_DateTime_now();
request.requestHeader.timeoutHint = 10000;
request.requestHeader.authenticationToken = client->authenticationToken;
UA_SecureChannel_sendSymmetricMessage(
channel, ++client->requestId, UA_MESSAGETYPE_CLO, &request,
&UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]);
UA_SecureChannel_close(&client->channel);
UA_SecureChannel_deleteMembers(&client->channel);
}
static UA_StatusCode
requestSession(UA_Client *client, UA_UInt32 *requestId) {
UA_CreateSessionRequest request;
UA_CreateSessionRequest_init(&request);
UA_StatusCode retval = UA_STATUSCODE_GOOD;
if(client->channel.securityMode == UA_MESSAGESECURITYMODE_SIGN ||
client->channel.securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) {
if(client->channel.localNonce.length != UA_SESSION_LOCALNONCELENGTH) {
UA_ByteString_deleteMembers(&client->channel.localNonce);
retval = UA_ByteString_allocBuffer(&client->channel.localNonce,
UA_SESSION_LOCALNONCELENGTH);
if(retval != UA_STATUSCODE_GOOD)
return retval;
}
retval = client->channel.securityPolicy->symmetricModule.
generateNonce(client->channel.securityPolicy, &client->channel.localNonce);
if(retval != UA_STATUSCODE_GOOD)
return retval;
}
request.requestHeader.requestHandle = ++client->requestHandle;
request.requestHeader.timestamp = UA_DateTime_now();
request.requestHeader.timeoutHint = 10000;
UA_ByteString_copy(&client->channel.localNonce, &request.clientNonce);
request.requestedSessionTimeout = client->config.requestedSessionTimeout;
request.maxResponseMessageSize = UA_INT32_MAX;
UA_String_copy(&client->config.endpoint.endpointUrl, &request.endpointUrl);
UA_ApplicationDescription_copy(&client->config.clientDescription,
&request.clientDescription);
retval = UA_Client_sendAsyncRequest (
client, &request, &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST],
(UA_ClientAsyncServiceCallback) responseSessionCallback,
&UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE], NULL, requestId);
UA_CreateSessionRequest_deleteMembers(&request);
client->connectStatus = retval;
return client->connectStatus;
}
void
UA_Log_Stdout_log(void *_, UA_LogLevel level, UA_LogCategory category,
const char *msg, va_list args) {
UA_Int64 tOffset = UA_DateTime_localTimeUtcOffset();
UA_DateTimeStruct dts = UA_DateTime_toStruct(UA_DateTime_now() + tOffset);
#ifdef UA_ENABLE_MULTITHREADING
pthread_mutex_lock(&printf_mutex);
#endif
printf("[%04u-%02u-%02u %02u:%02u:%02u.%03u (UTC%+05d)] %s/%s" ANSI_COLOR_RESET "\t",
dts.year, dts.month, dts.day, dts.hour, dts.min, dts.sec, dts.milliSec,
(int)(tOffset / UA_DATETIME_SEC / 36), logLevelNames[level], logCategoryNames[category]);
vprintf(msg, args);
printf("\n");
fflush(stdout);
#ifdef UA_ENABLE_MULTITHREADING
pthread_mutex_unlock(&printf_mutex);
#endif
}
static UA_StatusCode
GetEndpoints(UA_Client *client, const UA_String* endpointUrl,
size_t* endpointDescriptionsSize,
UA_EndpointDescription** endpointDescriptions,
const char* filterTransportProfileUri) {
UA_GetEndpointsRequest request;
UA_GetEndpointsRequest_init(&request);
//request.requestHeader.authenticationToken = client->authenticationToken;
request.requestHeader.timestamp = UA_DateTime_now();
request.requestHeader.timeoutHint = 10000;
request.endpointUrl = *endpointUrl; // assume the endpointurl outlives the service call
if (filterTransportProfileUri) {
request.profileUrisSize = 1;
request.profileUris = (UA_String*)UA_malloc(sizeof(UA_String));
request.profileUris[0] = UA_String_fromChars(filterTransportProfileUri);
}
UA_GetEndpointsResponse response;
UA_GetEndpointsResponse_init(&response);
__UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST],
&response, &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]);
if (filterTransportProfileUri) {
UA_Array_delete(request.profileUris, request.profileUrisSize, &UA_TYPES[UA_TYPES_STRING]);
}
ck_assert_uint_eq(response.responseHeader.serviceResult, UA_STATUSCODE_GOOD);
*endpointDescriptionsSize = response.endpointsSize;
*endpointDescriptions =
(UA_EndpointDescription*)UA_Array_new(response.endpointsSize,
&UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
for(size_t i=0;i<response.endpointsSize;i++) {
UA_EndpointDescription_init(&(*endpointDescriptions)[i]);
UA_EndpointDescription_copy(&response.endpoints[i], &(*endpointDescriptions)[i]);
}
UA_GetEndpointsResponse_deleteMembers(&response);
return UA_STATUSCODE_GOOD;
}
static UA_StatusCode SessionHandshake(UA_Client *client) {
UA_CreateSessionRequest request;
UA_CreateSessionRequest_init(&request);
// todo: is this needed for all requests?
UA_NodeId_copy(&client->authenticationToken, &request.requestHeader.authenticationToken);
request.requestHeader.timestamp = UA_DateTime_now();
request.requestHeader.timeoutHint = 10000;
UA_ByteString_copy(&client->channel.clientNonce, &request.clientNonce);
request.requestedSessionTimeout = 1200000;
request.maxResponseMessageSize = UA_INT32_MAX;
UA_CreateSessionResponse response;
UA_CreateSessionResponse_init(&response);
__UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST],
&response, &UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]);
UA_NodeId_copy(&response.authenticationToken, &client->authenticationToken);
UA_CreateSessionRequest_deleteMembers(&request);
UA_CreateSessionResponse_deleteMembers(&response);
return response.responseHeader.serviceResult; // not deleted
}
static UA_StatusCode readTimeData(void *handle, UA_Boolean sourceTimeStamp,
const UA_NumericRange *range, UA_DataValue *value) {
if(range) {
value->hasStatus = UA_TRUE;
value->status = UA_STATUSCODE_BADINDEXRANGEINVALID;
return UA_STATUSCODE_GOOD;
}
UA_DateTime *currentTime = UA_DateTime_new();
if(!currentTime)
return UA_STATUSCODE_BADOUTOFMEMORY;
*currentTime = UA_DateTime_now();
value->value.type = &UA_TYPES[UA_TYPES_DATETIME];
value->value.arrayLength = -1;
value->value.data = currentTime;
value->value.arrayDimensionsSize = -1;
value->value.arrayDimensions = NULL;
value->hasValue = UA_TRUE;
if(sourceTimeStamp) {
value->hasSourceTimestamp = UA_TRUE;
value->sourceTimestamp = *currentTime;
}
return UA_STATUSCODE_GOOD;
}
static UA_StatusCode ActivateSession(UA_Client *client) {
UA_ActivateSessionRequest request;
UA_ActivateSessionRequest_init(&request);
request.requestHeader.requestHandle = 2; //TODO: is it a magic number?
request.requestHeader.authenticationToken = client->authenticationToken;
request.requestHeader.timestamp = UA_DateTime_now();
request.requestHeader.timeoutHint = 10000;
UA_AnonymousIdentityToken identityToken;
UA_AnonymousIdentityToken_init(&identityToken);
UA_String_copy(&client->token.policyId, &identityToken.policyId);
//manual ExtensionObject encoding of the identityToken
request.userIdentityToken.encoding = UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING;
request.userIdentityToken.typeId = UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN].typeId;
request.userIdentityToken.typeId.identifier.numeric+=UA_ENCODINGOFFSET_BINARY;
if (identityToken.policyId.length >= 0)
UA_ByteString_newMembers(&request.userIdentityToken.body, identityToken.policyId.length+4);
else {
identityToken.policyId.length = -1;
UA_ByteString_newMembers(&request.userIdentityToken.body, 4);
}
size_t offset = 0;
UA_ByteString_encodeBinary(&identityToken.policyId,&request.userIdentityToken.body,&offset);
UA_ActivateSessionResponse response;
__UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST],
&response, &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]);
UA_AnonymousIdentityToken_deleteMembers(&identityToken);
UA_ActivateSessionRequest_deleteMembers(&request);
UA_ActivateSessionResponse_deleteMembers(&response);
return response.responseHeader.serviceResult; // not deleted
}
