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;
}
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 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 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 processOPN(UA_Connection *connection, UA_Server *server, const UA_ByteString *msg,
size_t *pos) {
if(connection->state != UA_CONNECTION_ESTABLISHED) {
connection->close(connection);
return;
}
UA_UInt32 secureChannelId;
UA_StatusCode retval = UA_UInt32_decodeBinary(msg, pos, &secureChannelId);
UA_AsymmetricAlgorithmSecurityHeader asymHeader;
retval |= UA_AsymmetricAlgorithmSecurityHeader_decodeBinary(msg, pos, &asymHeader);
UA_SequenceHeader seqHeader;
retval |= UA_SequenceHeader_decodeBinary(msg, pos, &seqHeader);
UA_NodeId requestType;
retval |= UA_NodeId_decodeBinary(msg, pos, &requestType);
UA_OpenSecureChannelRequest r;
retval |= UA_OpenSecureChannelRequest_decodeBinary(msg, pos, &r);
if(retval != UA_STATUSCODE_GOOD || requestType.identifier.numeric != 446) {
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
UA_SequenceHeader_deleteMembers(&seqHeader);
UA_NodeId_deleteMembers(&requestType);
UA_OpenSecureChannelRequest_deleteMembers(&r);
connection->close(connection);
return;
}
UA_OpenSecureChannelResponse p;
UA_OpenSecureChannelResponse_init(&p);
Service_OpenSecureChannel(server, connection, &r, &p);
UA_OpenSecureChannelRequest_deleteMembers(&r);
UA_SecureChannel *channel = connection->channel;
if(!channel) {
connection->close(connection);
UA_OpenSecureChannelResponse_deleteMembers(&p);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
return;
}
/* send the response with an asymmetric security header */
seqHeader.sequenceNumber = channel->sequenceNumber;
UA_SecureConversationMessageHeader respHeader;
respHeader.messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_OPNF;
respHeader.messageHeader.messageSize = 0;
respHeader.secureChannelId = p.securityToken.channelId;
UA_NodeId responseType = UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELRESPONSE +
UA_ENCODINGOFFSET_BINARY);
respHeader.messageHeader.messageSize =
UA_SecureConversationMessageHeader_calcSizeBinary(&respHeader)
+ UA_AsymmetricAlgorithmSecurityHeader_calcSizeBinary(&asymHeader)
+ UA_SequenceHeader_calcSizeBinary(&seqHeader)
+ UA_NodeId_calcSizeBinary(&responseType)
+ UA_OpenSecureChannelResponse_calcSizeBinary(&p);
UA_ByteString resp_msg;
retval = connection->getBuffer(connection, &resp_msg, respHeader.messageHeader.messageSize);
if(retval != UA_STATUSCODE_GOOD) {
UA_OpenSecureChannelResponse_deleteMembers(&p);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
return;
}
size_t tmpPos = 0;
UA_SecureConversationMessageHeader_encodeBinary(&respHeader, &resp_msg, &tmpPos);
UA_AsymmetricAlgorithmSecurityHeader_encodeBinary(&asymHeader, &resp_msg, &tmpPos); // just mirror back
UA_SequenceHeader_encodeBinary(&seqHeader, &resp_msg, &tmpPos); // just mirror back
UA_NodeId_encodeBinary(&responseType, &resp_msg, &tmpPos);
UA_OpenSecureChannelResponse_encodeBinary(&p, &resp_msg, &tmpPos);
UA_OpenSecureChannelResponse_deleteMembers(&p);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
connection->write(connection, &resp_msg);
connection->releaseBuffer(connection, &resp_msg);
}
