UA_Int32 UA_AsymmetricAlgorithmSecurityHeader_init(UA_AsymmetricAlgorithmSecurityHeader* p) {
UA_Int32 retval = UA_SUCCESS;
if(p==UA_NULL) return UA_ERROR;
retval |= UA_ByteString_init(&(p->securityPolicyUri));
retval |= UA_ByteString_init(&(p->senderCertificate));
retval |= UA_ByteString_init(&(p->receiverCertificateThumbprint));
return retval;
}
void UA_SecureChannel_init(UA_SecureChannel *channel) {
UA_AsymmetricAlgorithmSecurityHeader_init(&channel->clientAsymAlgSettings);
UA_AsymmetricAlgorithmSecurityHeader_init(&channel->serverAsymAlgSettings);
UA_ByteString_init(&channel->clientNonce);
UA_ByteString_init(&channel->serverNonce);
channel->connection = UA_NULL;
channel->session = UA_NULL;
}
static UA_StatusCode socket_recv(UA_Connection *connection, UA_ByteString *response, UA_UInt32 timeout) {
response->data = malloc(connection->localConf.recvBufferSize);
if(!response->data) {
UA_ByteString_init(response);
return UA_STATUSCODE_GOOD; /* not enough memory retry */
}
struct timeval tmptv = {0, timeout * 1000};
if(0 != setsockopt(connection->sockfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tmptv, sizeof(struct timeval))){
free(response->data);
UA_ByteString_init(response);
socket_close(connection);
return UA_STATUSCODE_BADINTERNALERROR;
}
int ret = recv(connection->sockfd, (char*)response->data, connection->localConf.recvBufferSize, 0);
if(ret == 0) {
free(response->data);
UA_ByteString_init(response);
socket_close(connection);
return UA_STATUSCODE_BADCONNECTIONCLOSED; /* ret == 0 -> server has closed the connection */
} else if(ret < 0) {
free(response->data);
UA_ByteString_init(response);
#ifdef _WIN32
if(WSAGetLastError() == WSAEINTR || WSAGetLastError() == WSAEWOULDBLOCK) {
#else
if(errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) {
#endif
return UA_STATUSCODE_GOOD; /* retry */
} else {
socket_close(connection);
return UA_STATUSCODE_BADCONNECTIONCLOSED;
}
}
response->length = ret;
*response = UA_Connection_completeMessages(connection, *response);
return UA_STATUSCODE_GOOD;
}
static UA_StatusCode socket_set_nonblocking(UA_Int32 sockfd) {
#ifdef _WIN32
u_long iMode = 1;
if(ioctlsocket(sockfd, FIONBIO, &iMode) != NO_ERROR)
return UA_STATUSCODE_BADINTERNALERROR;
#else
int opts = fcntl(sockfd, F_GETFL);
if(opts < 0 || fcntl(sockfd, F_SETFL, opts|O_NONBLOCK) < 0)
return UA_STATUSCODE_BADINTERNALERROR;
#endif
return UA_STATUSCODE_GOOD;
}
UA_Client * UA_Client_new(void) {
UA_Client *client = UA_malloc(sizeof(UA_Client));
if(!client)
return UA_NULL;
UA_String_init(&client->endpointUrl);
client->connection.state = UA_CONNECTION_OPENING;
client->sequenceNumber = 0;
client->requestId = 0;
/* Secure Channel */
UA_ChannelSecurityToken_deleteMembers(&client->securityToken);
UA_ByteString_init(&client->clientNonce);
UA_ByteString_init(&client->serverNonce);
UA_NodeId_init(&client->authenticationToken);
return client;
}
void UA_Connection_init(UA_Connection *connection) {
connection->state = UA_CONNECTION_CLOSED;
connection->localConf = UA_ConnectionConfig_standard;
connection->remoteConf = UA_ConnectionConfig_standard;
connection->channel = NULL;
connection->sockfd = 0;
connection->handle = NULL;
UA_ByteString_init(&connection->incompleteMessage);
connection->send = NULL;
connection->close = NULL;
connection->recv = NULL;
connection->getSendBuffer = NULL;
connection->releaseSendBuffer = NULL;
connection->releaseRecvBuffer = NULL;
}
/* HEL -> Open up the connection */
static void processHEL(UA_Connection *connection, const UA_ByteString *msg, size_t *offset) {
UA_TcpHelloMessage helloMessage;
if(UA_TcpHelloMessage_decodeBinary(msg, offset, &helloMessage) != UA_STATUSCODE_GOOD) {
connection->close(connection);
return;
}
/* Parameterize the connection */
connection->remoteConf.maxChunkCount = helloMessage.maxChunkCount; /* zero -> unlimited */
connection->remoteConf.maxMessageSize = helloMessage.maxMessageSize; /* zero -> unlimited */
connection->remoteConf.protocolVersion = helloMessage.protocolVersion;
connection->remoteConf.recvBufferSize = helloMessage.receiveBufferSize;
if(connection->localConf.sendBufferSize > helloMessage.receiveBufferSize)
connection->localConf.sendBufferSize = helloMessage.receiveBufferSize;
connection->remoteConf.sendBufferSize = helloMessage.sendBufferSize;
if(connection->localConf.recvBufferSize > helloMessage.sendBufferSize)
connection->localConf.recvBufferSize = helloMessage.sendBufferSize;
connection->state = UA_CONNECTION_ESTABLISHED;
UA_TcpHelloMessage_deleteMembers(&helloMessage);
/* Build acknowledge response */
UA_TcpAcknowledgeMessage ackMessage;
ackMessage.protocolVersion = connection->localConf.protocolVersion;
ackMessage.receiveBufferSize = connection->localConf.recvBufferSize;
ackMessage.sendBufferSize = connection->localConf.sendBufferSize;
ackMessage.maxMessageSize = connection->localConf.maxMessageSize;
ackMessage.maxChunkCount = connection->localConf.maxChunkCount;
UA_TcpMessageHeader ackHeader;
ackHeader.messageTypeAndChunkType = UA_MESSAGETYPE_ACK + UA_CHUNKTYPE_FINAL;
ackHeader.messageSize = 8 + 20; /* ackHeader + ackMessage */
/* Get the send buffer from the network layer */
UA_ByteString ack_msg;
UA_ByteString_init(&ack_msg);
UA_StatusCode retval =
connection->getSendBuffer(connection, connection->localConf.sendBufferSize, &ack_msg);
if(retval != UA_STATUSCODE_GOOD)
return;
/* Encode and send the response */
size_t tmpPos = 0;
UA_TcpMessageHeader_encodeBinary(&ackHeader, &ack_msg, &tmpPos);
UA_TcpAcknowledgeMessage_encodeBinary(&ackMessage, &ack_msg, &tmpPos);
ack_msg.length = ackHeader.messageSize;
connection->send(connection, &ack_msg);
}
static UA_StatusCode HelAckHandshake(UA_Client *c) {
UA_TcpMessageHeader messageHeader;
messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_HELF;
UA_TcpHelloMessage hello;
UA_String_copy(&c->endpointUrl, &hello.endpointUrl); /* must be less than 4096 bytes */
UA_Connection *conn = &c->connection;
hello.maxChunkCount = conn->localConf.maxChunkCount;
hello.maxMessageSize = conn->localConf.maxMessageSize;
hello.protocolVersion = conn->localConf.protocolVersion;
hello.receiveBufferSize = conn->localConf.recvBufferSize;
hello.sendBufferSize = conn->localConf.sendBufferSize;
UA_ByteString message;
UA_StatusCode retval;
retval = c->connection.getSendBuffer(&c->connection, c->connection.remoteConf.recvBufferSize, &message);
if(retval != UA_STATUSCODE_GOOD)
return retval;
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.releaseSendBuffer(&c->connection, &message);
return retval;
}
message.length = messageHeader.messageSize;
retval = c->connection.send(&c->connection, &message);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG(c->logger, UA_LOGCATEGORY_NETWORK, "Sending HEL failed");
return retval;
}
UA_LOG_DEBUG(c->logger, UA_LOGCATEGORY_NETWORK, "Sent HEL message");
UA_ByteString reply;
UA_ByteString_init(&reply);
do {
retval = c->connection.recv(&c->connection, &reply, c->config.timeout);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG(c->logger, UA_LOGCATEGORY_NETWORK, "Receiving ACK message failed");
return retval;
}
} while(!reply.data);
offset = 0;
UA_TcpMessageHeader_decodeBinary(&reply, &offset, &messageHeader);
UA_TcpAcknowledgeMessage ackMessage;
retval = UA_TcpAcknowledgeMessage_decodeBinary(&reply, &offset, &ackMessage);
UA_ByteString_deleteMembers(&reply);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG(c->logger, UA_LOGCATEGORY_NETWORK, "Decoding ACK message failed");
return retval;
}
UA_LOG_DEBUG(c->logger, UA_LOGCATEGORY_NETWORK, "Received ACK message");
conn->remoteConf.maxChunkCount = ackMessage.maxChunkCount;
conn->remoteConf.maxMessageSize = ackMessage.maxMessageSize;
conn->remoteConf.protocolVersion = ackMessage.protocolVersion;
conn->remoteConf.recvBufferSize = ackMessage.receiveBufferSize;
conn->remoteConf.sendBufferSize = ackMessage.sendBufferSize;
conn->state = UA_CONNECTION_ESTABLISHED;
return UA_STATUSCODE_GOOD;
}
void __UA_Client_Service(UA_Client *client, const void *r, const UA_DataType *requestType,
void *response, const UA_DataType *responseType) {
/* Requests always begin witih a RequestHeader, therefore we can cast. */
UA_RequestHeader *request = (void*)(uintptr_t)r;
UA_StatusCode retval = UA_STATUSCODE_GOOD;
UA_init(response, responseType);
UA_ResponseHeader *respHeader = (UA_ResponseHeader*)response;
/* make sure we have a valid session */
retval = UA_Client_manuallyRenewSecureChannel(client);
if(retval != UA_STATUSCODE_GOOD) {
respHeader->serviceResult = retval;
client->state = UA_CLIENTSTATE_ERRORED;
return;
}
/* handling request parameters */
UA_NodeId_copy(&client->authenticationToken, &request->authenticationToken);
request->timestamp = UA_DateTime_now();
request->requestHandle = ++client->requestHandle;
/* Send the request */
UA_UInt32 requestId = ++client->requestId;
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_CLIENT,
"Sending a request of type %i", requestType->typeId.identifier.numeric);
retval = UA_SecureChannel_sendBinaryMessage(&client->channel, requestId, request, requestType);
if(retval) {
if(retval == UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED)
respHeader->serviceResult = UA_STATUSCODE_BADREQUESTTOOLARGE;
else
respHeader->serviceResult = retval;
client->state = UA_CLIENTSTATE_ERRORED;
return;
}
/* Retrieve the response */
// Todo: push this into the generic securechannel implementation for client and server
UA_ByteString reply;
UA_ByteString_init(&reply);
do {
retval = client->connection.recv(&client->connection, &reply, client->config.timeout);
if(retval != UA_STATUSCODE_GOOD) {
respHeader->serviceResult = retval;
client->state = UA_CLIENTSTATE_ERRORED;
return;
}
} while(!reply.data);
size_t offset = 0;
UA_SecureConversationMessageHeader msgHeader;
retval |= UA_SecureConversationMessageHeader_decodeBinary(&reply, &offset, &msgHeader);
UA_SymmetricAlgorithmSecurityHeader symHeader;
retval |= UA_SymmetricAlgorithmSecurityHeader_decodeBinary(&reply, &offset, &symHeader);
UA_SequenceHeader seqHeader;
retval |= UA_SequenceHeader_decodeBinary(&reply, &offset, &seqHeader);
UA_NodeId responseId;
retval |= UA_NodeId_decodeBinary(&reply, &offset, &responseId);
UA_NodeId expectedNodeId = UA_NODEID_NUMERIC(0, responseType->typeId.identifier.numeric +
UA_ENCODINGOFFSET_BINARY);
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){
UA_LOG_INFO(client->logger, UA_LOGCATEGORY_CLIENT, "Error receiving the response");
client->state = UA_CLIENTSTATE_ERRORED;
respHeader->serviceResult = retval;
}
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_CLIENT,
"Received a response of type %i", responseId.identifier.numeric);
}
static UA_StatusCode SecureChannelHandshake(UA_Client *client, UA_Boolean renew) {
/* Check if sc is still valid */
if(renew && client->scExpiresAt - UA_DateTime_now() > client->config.timeToRenewSecureChannel * 10000)
return UA_STATUSCODE_GOOD;
UA_SecureConversationMessageHeader messageHeader;
messageHeader.messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_OPNF;
messageHeader.secureChannelId = 0;
UA_SequenceHeader seqHeader;
seqHeader.sequenceNumber = ++client->channel.sequenceNumber;
seqHeader.requestId = ++client->requestId;
UA_AsymmetricAlgorithmSecurityHeader asymHeader;
UA_AsymmetricAlgorithmSecurityHeader_init(&asymHeader);
asymHeader.securityPolicyUri = UA_STRING_ALLOC("http://opcfoundation.org/UA/SecurityPolicy#None");
/* id of opensecurechannelrequest */
UA_NodeId requestType = UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELREQUEST + UA_ENCODINGOFFSET_BINARY);
UA_OpenSecureChannelRequest opnSecRq;
UA_OpenSecureChannelRequest_init(&opnSecRq);
opnSecRq.requestHeader.timestamp = UA_DateTime_now();
opnSecRq.requestHeader.authenticationToken = client->authenticationToken;
opnSecRq.requestedLifetime = client->config.secureChannelLifeTime;
if(renew) {
opnSecRq.requestType = UA_SECURITYTOKENREQUESTTYPE_RENEW;
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_SECURECHANNEL, "Requesting to renew the SecureChannel");
} else {
opnSecRq.requestType = UA_SECURITYTOKENREQUESTTYPE_ISSUE;
UA_ByteString_init(&client->channel.clientNonce);
UA_ByteString_copy(&client->channel.clientNonce, &opnSecRq.clientNonce);
opnSecRq.securityMode = UA_MESSAGESECURITYMODE_NONE;
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_SECURECHANNEL, "Requesting to open a SecureChannel");
}
UA_ByteString message;
UA_Connection *c = &client->connection;
UA_StatusCode retval = c->getSendBuffer(c, c->remoteConf.recvBufferSize, &message);
if(retval != UA_STATUSCODE_GOOD) {
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
UA_OpenSecureChannelRequest_deleteMembers(&opnSecRq);
return retval;
}
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.releaseSendBuffer(&client->connection, &message);
return retval;
}
message.length = messageHeader.messageHeader.messageSize;
retval = client->connection.send(&client->connection, &message);
if(retval != UA_STATUSCODE_GOOD)
return retval;
UA_ByteString reply;
UA_ByteString_init(&reply);
do {
retval = client->connection.recv(&client->connection, &reply, client->config.timeout);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_SECURECHANNEL,
"Receiving OpenSecureChannelResponse failed");
return retval;
}
} while(!reply.data);
offset = 0;
UA_SecureConversationMessageHeader_decodeBinary(&reply, &offset, &messageHeader);
UA_AsymmetricAlgorithmSecurityHeader_decodeBinary(&reply, &offset, &asymHeader);
UA_SequenceHeader_decodeBinary(&reply, &offset, &seqHeader);
UA_NodeId_decodeBinary(&reply, &offset, &requestType);
UA_NodeId expectedRequest = UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELRESPONSE +
UA_ENCODINGOFFSET_BINARY);
if(!UA_NodeId_equal(&requestType, &expectedRequest)) {
UA_ByteString_deleteMembers(&reply);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
UA_NodeId_deleteMembers(&requestType);
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_CLIENT,
"Reply answers the wrong request. Expected OpenSecureChannelResponse.");
return UA_STATUSCODE_BADINTERNALERROR;
}
UA_OpenSecureChannelResponse response;
UA_OpenSecureChannelResponse_init(&response);
retval = UA_OpenSecureChannelResponse_decodeBinary(&reply, &offset, &response);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_SECURECHANNEL,
"Decoding OpenSecureChannelResponse failed");
UA_ByteString_deleteMembers(&reply);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
UA_OpenSecureChannelResponse_init(&response);
response.responseHeader.serviceResult = retval;
return retval;
}
client->scExpiresAt = UA_DateTime_now() + response.securityToken.revisedLifetime * 10000;
UA_ByteString_deleteMembers(&reply);
retval = response.responseHeader.serviceResult;
if(retval != UA_STATUSCODE_GOOD)
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_SECURECHANNEL,
"SecureChannel could not be opened / renewed");
else if(!renew) {
UA_ChannelSecurityToken_copy(&response.securityToken, &client->channel.securityToken);
/* if the handshake is repeated, replace the old nonce */
UA_ByteString_deleteMembers(&client->channel.serverNonce);
UA_ByteString_copy(&response.serverNonce, &client->channel.serverNonce);
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_SECURECHANNEL, "SecureChannel opened");
} else
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_SECURECHANNEL, "SecureChannel renewed");
UA_OpenSecureChannelResponse_deleteMembers(&response);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
return retval;
}
static UA_UInt32
testHistoricalDataBackend(size_t maxResponseSize)
{
const UA_HistorizingNodeIdSettings* setting = gathering->getHistorizingSetting(server, gathering->context, &outNodeId);
UA_HistorizingNodeIdSettings newSetting = *setting;
newSetting.maxHistoryDataResponseSize = maxResponseSize;
gathering->updateNodeIdSetting(server, gathering->context, &outNodeId, newSetting);
UA_UInt32 retval = 0;
size_t i = 0;
testTuple *current = &testRequests[i];
fprintf(stderr, "Testing with maxResponseSize of %lu\n", maxResponseSize);
fprintf(stderr, "Start | End | numValuesPerNode | returnBounds |ContPoint| {Expected}{Result} Result\n");
fprintf(stderr, "------+------+------------------+--------------+---------+----------------\n");
size_t j;
while (current->start || current->end) {
j = 0;
if (current->start == TIMESTAMP_UNSPECIFIED) {
fprintf(stderr, "UNSPEC|");
} else {
fprintf(stderr, " %3lld |", current->start / UA_DATETIME_SEC);
}
if (current->end == TIMESTAMP_UNSPECIFIED) {
fprintf(stderr, "UNSPEC|");
} else {
fprintf(stderr, " %3lld |", current->end / UA_DATETIME_SEC);
}
fprintf(stderr, " %2u | %s | %s | {", current->numValuesPerNode, (current->returnBounds ? "Yes" : " No"), (current->returnContinuationPoint ? "Yes" : " No"));
while (current->result[j]) {
printTimestamp(current->result[j]);
++j;
}
fprintf(stderr, "}");
UA_DataValue *result = NULL;
size_t resultSize = 0;
UA_ByteString continuous;
UA_ByteString_init(&continuous);
UA_Boolean readOk = true;
size_t reseivedValues = 0;
fprintf(stderr, "{");
size_t counter = 0;
do {
UA_HistoryReadResponse response;
UA_HistoryReadResponse_init(&response);
UA_UInt32 numValuesPerNode = current->numValuesPerNode;
if (numValuesPerNode > 0 && numValuesPerNode + (UA_UInt32)reseivedValues > current->numValuesPerNode)
numValuesPerNode = current->numValuesPerNode - (UA_UInt32)reseivedValues;
requestHistory(current->start,
current->end,
&response,
numValuesPerNode,
current->returnBounds,
&continuous);
++counter;
if(response.resultsSize != 1) {
fprintf(stderr, "ResultError:Size %lu %s", response.resultsSize, UA_StatusCode_name(response.responseHeader.serviceResult));
readOk = false;
UA_HistoryReadResponse_deleteMembers(&response);
break;
}
UA_StatusCode stat = response.results[0].statusCode;
if (stat == UA_STATUSCODE_BADBOUNDNOTSUPPORTED && current->returnBounds) {
fprintf(stderr, "%s", UA_StatusCode_name(stat));
UA_HistoryReadResponse_deleteMembers(&response);
break;
}
if(response.results[0].historyData.encoding != UA_EXTENSIONOBJECT_DECODED
|| response.results[0].historyData.content.decoded.type != &UA_TYPES[UA_TYPES_HISTORYDATA]) {
fprintf(stderr, "ResultError:HistoryData");
readOk = false;
UA_HistoryReadResponse_deleteMembers(&response);
break;
}
UA_HistoryData * data = (UA_HistoryData *)response.results[0].historyData.content.decoded.data;
resultSize = data->dataValuesSize;
result = data->dataValues;
if (resultSize == 0 && continuous.length > 0) {
fprintf(stderr, "continuousResultEmpty");
readOk = false;
UA_HistoryReadResponse_deleteMembers(&response);
break;
}
if (resultSize > maxResponseSize) {
fprintf(stderr, "resultToBig");
readOk = false;
UA_HistoryReadResponse_deleteMembers(&response);
break;
}
if (stat != UA_STATUSCODE_GOOD) {
fprintf(stderr, "%s", UA_StatusCode_name(stat));
} else {
for (size_t k = 0; k < resultSize; ++k)
printResult(&result[k]);
}
if (stat == UA_STATUSCODE_GOOD && j >= resultSize + reseivedValues) {
for (size_t l = 0; l < resultSize; ++l) {
/* See OPC UA Part 11, Version 1.03, Page 5-6, Table 1, Mark a for details.*/
if (current->result[l + reseivedValues] == TIMESTAMP_LAST && current->end == TIMESTAMP_UNSPECIFIED) {
// This test will work on not continous read, only
if (reseivedValues == 0 && !(l > 0 && result[l].sourceTimestamp == result[l-1].sourceTimestamp + UA_DATETIME_SEC))
readOk = false;
}
/* See OPC UA Part 11, Version 1.03, Page 5-6, Table 1, Mark b for details.*/
if (current->result[l + reseivedValues] == TIMESTAMP_FIRST && current->start == TIMESTAMP_UNSPECIFIED) {
// This test will work on not continous read, only
if (reseivedValues == 0 && !(l > 0 && result[l].sourceTimestamp == result[l-1].sourceTimestamp - UA_DATETIME_SEC))
readOk = false;
}
if (!resultIsEqual(&result[l], current, l + reseivedValues))
readOk = false;
}
if (response.results[0].continuationPoint.length > 0)
fprintf(stderr, "C,");
reseivedValues += resultSize;
if (reseivedValues == j) {
if (current->returnContinuationPoint && response.results[0].continuationPoint.length == 0) {
readOk = false;
fprintf(stderr, "missingContinuationPoint");
}
if (!current->returnContinuationPoint && response.results[0].continuationPoint.length > 0) {
readOk = false;
fprintf(stderr, "unexpectedContinuationPoint");
}
UA_HistoryReadResponse_deleteMembers(&response);
break;
}
UA_ByteString_deleteMembers(&continuous);
UA_ByteString_copy(&response.results[0].continuationPoint, &continuous);
} else {
readOk = false;
UA_HistoryReadResponse_deleteMembers(&response);
break;
}
UA_HistoryReadResponse_deleteMembers(&response);
} while (continuous.length > 0);
if (j != reseivedValues) {
readOk = false;
}
UA_ByteString_deleteMembers(&continuous);
if (!readOk) {
fprintf(stderr, "} Fail (%lu requests)\n", counter);
++retval;
} else {
fprintf(stderr, "} OK (%lu requests)\n", counter);
}
current = &testRequests[++i];
}
return retval;
}
void Service_Read(UA_Server *server, UA_Session *session, const UA_ReadRequest *request,
UA_ReadResponse *response) {
if(request->nodesToReadSize <= 0) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
return;
}
if(request->timestampsToReturn > 3){
response->responseHeader.serviceResult = UA_STATUSCODE_BADTIMESTAMPSTORETURNINVALID;
return;
}
size_t size = request->nodesToReadSize;
response->results = UA_Array_new(&UA_TYPES[UA_TYPES_DATAVALUE], size);
if(!response->results) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
response->resultsSize = size;
if(request->maxAge < 0) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADMAXAGEINVALID;
return;
}
/* ### Begin External Namespaces */
UA_Boolean *isExternal = UA_alloca(sizeof(UA_Boolean) * size);
UA_memset(isExternal, UA_FALSE, sizeof(UA_Boolean) * size);
UA_UInt32 *indices = UA_alloca(sizeof(UA_UInt32) * size);
for(UA_Int32 j = 0;j<server->externalNamespacesSize;j++) {
size_t indexSize = 0;
for(size_t i = 0;i < size;i++) {
if(request->nodesToRead[i].nodeId.namespaceIndex != server->externalNamespaces[j].index)
continue;
isExternal[i] = UA_TRUE;
indices[indexSize] = i;
indexSize++;
}
if(indexSize == 0)
continue;
UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
ens->readNodes(ens->ensHandle, &request->requestHeader, request->nodesToRead,
indices, indexSize, response->results, UA_FALSE, response->diagnosticInfos);
}
/* ### End External Namespaces */
for(size_t i = 0;i < size;i++) {
if(!isExternal[i])
readValue(server, request->timestampsToReturn, &request->nodesToRead[i], &response->results[i]);
}
#ifdef EXTENSION_STATELESS
if(session==&anonymousSession){
/* expiry header */
UA_ExtensionObject additionalHeader;
UA_ExtensionObject_init(&additionalHeader);
additionalHeader.encoding = UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING;
UA_Variant variant;
UA_Variant_init(&variant);
variant.type = &UA_TYPES[UA_TYPES_DATETIME];
variant.arrayLength = request->nodesToReadSize;
UA_DateTime* expireArray = UA_NULL;
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_Variant_encodeBinary(&variant, &str, &offset);
additionalHeader.body = str;
response->responseHeader.additionalHeader = additionalHeader;
}
#endif
}
/* OPN -> Open up/renew the securechannel */
static void
processOPN(UA_Server *server, UA_Connection *connection,
UA_UInt32 channelId, const UA_ByteString *msg) {
UA_StatusCode retval = UA_STATUSCODE_GOOD;
/* Called before HEL */
if(connection->state != UA_CONNECTION_ESTABLISHED)
retval = UA_STATUSCODE_BADCOMMUNICATIONERROR;
/* Opening up a channel with a channelid already set */
if(!connection->channel && channelId != 0)
retval = UA_STATUSCODE_BADCOMMUNICATIONERROR;
/* Renew a channel with the wrong channelid */
if(connection->channel && channelId != connection->channel->securityToken.channelId)
retval = UA_STATUSCODE_BADCOMMUNICATIONERROR;
/* Decode the request */
UA_AsymmetricAlgorithmSecurityHeader asymHeader;
UA_SequenceHeader seqHeader;
UA_NodeId requestType;
UA_OpenSecureChannelRequest r;
size_t offset = 0;
retval |= UA_AsymmetricAlgorithmSecurityHeader_decodeBinary(msg, &offset, &asymHeader);
retval |= UA_SequenceHeader_decodeBinary(msg, &offset, &seqHeader);
retval |= UA_NodeId_decodeBinary(msg, &offset, &requestType);
retval |= UA_OpenSecureChannelRequest_decodeBinary(msg, &offset, &r);
/* Error occured */
if(retval != UA_STATUSCODE_GOOD || requestType.identifier.numeric != 446) {
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
UA_NodeId_deleteMembers(&requestType);
UA_OpenSecureChannelRequest_deleteMembers(&r);
connection->close(connection);
return;
}
/* Call the service */
UA_OpenSecureChannelResponse p;
UA_OpenSecureChannelResponse_init(&p);
Service_OpenSecureChannel(server, connection, &r, &p);
UA_OpenSecureChannelRequest_deleteMembers(&r);
/* Opening the channel failed */
UA_SecureChannel *channel = connection->channel;
if(!channel) {
UA_OpenSecureChannelResponse_deleteMembers(&p);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
connection->close(connection);
return;
}
/* Set the starting sequence number */
channel->receiveSequenceNumber = seqHeader.sequenceNumber;
/* Allocate the return message */
UA_ByteString resp_msg;
UA_ByteString_init(&resp_msg);
retval = connection->getSendBuffer(connection, connection->localConf.sendBufferSize, &resp_msg);
if(retval != UA_STATUSCODE_GOOD) {
UA_OpenSecureChannelResponse_deleteMembers(&p);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
connection->close(connection);
return;
}
/* Encode the message after the secureconversationmessageheader */
size_t tmpPos = 12; /* skip the header */
seqHeader.sequenceNumber = UA_atomic_add(&channel->sendSequenceNumber, 1);
retval |= UA_AsymmetricAlgorithmSecurityHeader_encodeBinary(&asymHeader, &resp_msg, &tmpPos); // just mirror back
retval |= UA_SequenceHeader_encodeBinary(&seqHeader, &resp_msg, &tmpPos);
UA_NodeId responseType = UA_NODEID_NUMERIC(0, UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE].binaryEncodingId);
retval |= UA_NodeId_encodeBinary(&responseType, &resp_msg, &tmpPos);
retval |= UA_OpenSecureChannelResponse_encodeBinary(&p, &resp_msg, &tmpPos);
if(retval != UA_STATUSCODE_GOOD) {
connection->releaseSendBuffer(connection, &resp_msg);
UA_OpenSecureChannelResponse_deleteMembers(&p);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
connection->close(connection);
return;
}
/* Encode the secureconversationmessageheader (cannot fail) and send */
UA_SecureConversationMessageHeader respHeader;
respHeader.messageHeader.messageTypeAndChunkType = UA_MESSAGETYPE_OPN + UA_CHUNKTYPE_FINAL;
respHeader.messageHeader.messageSize = (UA_UInt32)tmpPos;
respHeader.secureChannelId = p.securityToken.channelId;
tmpPos = 0;
UA_SecureConversationMessageHeader_encodeBinary(&respHeader, &resp_msg, &tmpPos);
resp_msg.length = respHeader.messageHeader.messageSize;
connection->send(connection, &resp_msg);
/* Clean up */
UA_OpenSecureChannelResponse_deleteMembers(&p);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
}
