static UA_Int32 sendHello(UA_Int32 sock, UA_String *endpointURL) {
UA_TcpMessageHeader messageHeader;
messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_HELF;
UA_TcpHelloMessage hello;
UA_String_copy(endpointURL, &hello.endpointUrl);
hello.maxChunkCount = 1;
hello.maxMessageSize = 16777216;
hello.protocolVersion = 0;
hello.receiveBufferSize = 65536;
hello.sendBufferSize = 65536;
messageHeader.messageSize = UA_TcpHelloMessage_calcSizeBinary((UA_TcpHelloMessage const*) &hello) +
UA_TcpMessageHeader_calcSizeBinary((UA_TcpMessageHeader const*) &messageHeader);
UA_ByteString message;
UA_ByteString_newMembers(&message, messageHeader.messageSize);
size_t offset = 0;
UA_TcpMessageHeader_encodeBinary((UA_TcpMessageHeader const*) &messageHeader, &message, &offset);
UA_TcpHelloMessage_encodeBinary((UA_TcpHelloMessage const*) &hello, &message, &offset);
UA_Int32 sendret = send(sock, message.data, offset, 0);
UA_ByteString_deleteMembers(&message);
free(hello.endpointUrl.data);
if (sendret < 0)
return 1;
return 0;
}
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;
}
/* 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_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 UA_StatusCode
sendHELMessage(UA_Client *client) {
/* Get a buffer */
UA_ByteString message;
UA_Connection *conn = &client->connection;
UA_StatusCode retval = conn->getSendBuffer(conn, UA_MINMESSAGESIZE, &message);
if(retval != UA_STATUSCODE_GOOD)
return retval;
/* Prepare the HEL message and encode at offset 8 */
UA_TcpHelloMessage hello;
UA_String_copy(&client->endpointUrl, &hello.endpointUrl); /* must be less than 4096 bytes */
memcpy(&hello, &client->config.localConnectionConfig,
sizeof(UA_ConnectionConfig)); /* same struct layout */
UA_Byte *bufPos = &message.data[8]; /* skip the header */
const UA_Byte *bufEnd = &message.data[message.length];
client->connectStatus = UA_TcpHelloMessage_encodeBinary(&hello, &bufPos, bufEnd);
UA_TcpHelloMessage_deleteMembers (&hello);
/* Encode the message header at offset 0 */
UA_TcpMessageHeader messageHeader;
messageHeader.messageTypeAndChunkType = UA_CHUNKTYPE_FINAL + UA_MESSAGETYPE_HEL;
messageHeader.messageSize = (UA_UInt32) ((uintptr_t)bufPos - (uintptr_t)message.data);
bufPos = message.data;
retval = UA_TcpMessageHeader_encodeBinary(&messageHeader, &bufPos, bufEnd);
if(retval != UA_STATUSCODE_GOOD) {
conn->releaseSendBuffer(conn, &message);
return retval;
}
/* Send the HEL message */
message.length = messageHeader.messageSize;
retval = conn->send (conn, &message);
if(retval == UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_NETWORK, "Sent HEL message");
} else {
UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_NETWORK, "Sending HEL failed");
}
return retval;
}
static void processHEL(UA_Connection *connection, const UA_ByteString *msg, size_t *pos) {
UA_TcpHelloMessage helloMessage;
if(UA_TcpHelloMessage_decodeBinary(msg, pos, &helloMessage) != UA_STATUSCODE_GOOD) {
connection->close(connection);
return;
}
connection->remoteConf.maxChunkCount = helloMessage.maxChunkCount;
connection->remoteConf.maxMessageSize = helloMessage.maxMessageSize;
connection->remoteConf.protocolVersion = helloMessage.protocolVersion;
connection->remoteConf.recvBufferSize = helloMessage.receiveBufferSize;
if(connection->localConf.sendBufferSize > helloMessage.receiveBufferSize)
connection->localConf.sendBufferSize = helloMessage.receiveBufferSize;
if(connection->localConf.recvBufferSize > helloMessage.sendBufferSize)
connection->localConf.recvBufferSize = helloMessage.sendBufferSize;
connection->remoteConf.sendBufferSize = 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.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_ACKF;
ackHeader.messageSize = UA_TcpMessageHeader_calcSizeBinary(&ackHeader)
+ UA_TcpAcknowledgeMessage_calcSizeBinary(&ackMessage);
UA_ByteString ack_msg;
if(connection->getBuffer(connection, &ack_msg, ackHeader.messageSize) != UA_STATUSCODE_GOOD)
return;
size_t tmpPos = 0;
UA_TcpMessageHeader_encodeBinary(&ackHeader, &ack_msg, &tmpPos);
UA_TcpAcknowledgeMessage_encodeBinary(&ackMessage, &ack_msg, &tmpPos);
connection->write(connection, &ack_msg);
connection->releaseBuffer(connection, &ack_msg);
}
static UA_Int32 closeSecureChannel(ConnectionInfo *connectionInfo) {
size_t offset = 0;
UA_ByteString message;
UA_ByteString_newMembers(&message, 65536);
UA_CloseSecureChannelRequest rq;
UA_CloseSecureChannelRequest_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_TcpMessageHeader msghdr;
msghdr.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_CLOF;
msghdr.messageSize = 4 + UA_TcpMessageHeader_calcSizeBinary(&msghdr) +
UA_CloseSecureChannelRequest_calcSizeBinary(&rq);
UA_TcpMessageHeader_encodeBinary(&msghdr, &message, &offset);
UA_UInt32_encodeBinary(&connectionInfo->channelId, &message, &offset);
UA_CloseSecureChannelRequest_encodeBinary(&rq, &message, &offset);
UA_Int32 sendret = send(connectionInfo->socket, message.data, offset, 0);
UA_ByteString_deleteMembers(&message);
UA_CloseSecureChannelRequest_deleteMembers(&rq);
if(sendret < 0) {
printf("send CloseSecureChannelRequest failed");
return 1;
}
return 0;
}
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;
}
static int sendOpenSecureChannel(UA_Int32 sock) {
UA_TcpMessageHeader msghdr;
msghdr.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_OPNF;
UA_UInt32 secureChannelId = 0;
UA_String securityPolicy;
UA_String_copycstring("http://opcfoundation.org/UA/SecurityPolicy#None", &securityPolicy);
UA_String senderCert;
senderCert.data = UA_NULL;
senderCert.length = -1;
UA_String receiverCertThumb;
receiverCertThumb.data = UA_NULL;
receiverCertThumb.length = -1;
UA_UInt32 sequenceNumber = 51;
UA_UInt32 requestId = 1;
UA_NodeId type;
type.identifier.numeric = 446; // id of opensecurechannelrequest
type.identifierType = UA_NODEIDTYPE_NUMERIC;
type.namespaceIndex = 0;
UA_OpenSecureChannelRequest opnSecRq;
UA_OpenSecureChannelRequest_init(&opnSecRq);
opnSecRq.requestHeader.timestamp = UA_DateTime_now();
UA_ByteString_newMembers(&opnSecRq.clientNonce, 1);
opnSecRq.clientNonce.data[0] = 0;
opnSecRq.clientProtocolVersion = 0;
opnSecRq.requestedLifetime = 30000;
opnSecRq.securityMode = UA_MESSAGESECURITYMODE_NONE;
opnSecRq.requestType = UA_SECURITYTOKENREQUESTTYPE_ISSUE;
opnSecRq.requestHeader.authenticationToken.identifier.numeric = 10;
opnSecRq.requestHeader.authenticationToken.identifierType = UA_NODEIDTYPE_NUMERIC;
opnSecRq.requestHeader.authenticationToken.namespaceIndex = 10;
msghdr.messageSize = 135; // todo: compute the message size from the actual content
UA_ByteString message;
UA_ByteString_newMembers(&message, 1000);
size_t offset = 0;
UA_TcpMessageHeader_encodeBinary(&msghdr, &message, &offset);
UA_UInt32_encodeBinary(&secureChannelId, &message, &offset);
UA_String_encodeBinary(&securityPolicy, &message, &offset);
UA_String_encodeBinary(&senderCert, &message, &offset);
UA_String_encodeBinary(&receiverCertThumb, &message, &offset);
UA_UInt32_encodeBinary(&sequenceNumber, &message, &offset);
UA_UInt32_encodeBinary(&requestId, &message, &offset);
UA_NodeId_encodeBinary(&type, &message, &offset);
UA_OpenSecureChannelRequest_encodeBinary(&opnSecRq, &message, &offset);
UA_OpenSecureChannelRequest_deleteMembers(&opnSecRq);
UA_String_deleteMembers(&securityPolicy);
UA_Int32 sendret = send(sock, message.data, offset, 0);
UA_ByteString_deleteMembers(&message);
if (sendret < 0) {
printf("send opensecurechannel failed");
return 1;
}
return 0;
}
int main(int argc , char *argv[]) {
int sock;
struct sockaddr_in server;
UA_ByteString message;
message.data = (UA_Byte*)malloc(1000*sizeof(UA_Byte));
message.length = 1000;
//UA_UInt32 messageEncodedLength = 0;
UA_Byte server_reply[2000];
unsigned int messagepos = 0;
//Create socket
#ifdef UA_ENABLE_NONSTANDARD_UDP
sock = socket(AF_INET , SOCK_DGRAM , 0);
#else
sock = socket(AF_INET , SOCK_STREAM , 0);
#endif
if(sock == -1) {
printf("Could not create socket");
}
server.sin_addr.s_addr = inet_addr("127.0.0.1");
server.sin_family = AF_INET;
server.sin_port = htons( 16664 );
//Connect to remote server
if(connect(sock, (struct sockaddr *)&server, sizeof(server)) < 0) {
perror("connect failed. Error");
return 1;
}
UA_TcpMessageHeader reqTcpHeader;
UA_UInt32 reqSecureChannelId = 0;
UA_UInt32 reqTokenId = 0;
UA_SequenceHeader reqSequenceHeader;
UA_NodeId reqRequestType;
UA_ReadRequest req;
UA_RequestHeader reqHeader;
UA_NodeId reqHeaderAuthToken;
UA_ExtensionObject reqHeaderAdditionalHeader;
UA_NodeId_init(&reqRequestType);
reqRequestType.identifierType = UA_NODEIDTYPE_NUMERIC;
reqRequestType.identifier.numeric = 631; //read request
UA_SequenceHeader_init(&reqSequenceHeader);
reqSequenceHeader.sequenceNumber = 42;
UA_ReadRequest_init(&req);
req.requestHeader = reqHeader;
UA_RequestHeader_init(&(req.requestHeader));
req.requestHeader.authenticationToken = reqHeaderAuthToken;
UA_NodeId_init(&(req.requestHeader.authenticationToken));
req.requestHeader.additionalHeader = reqHeaderAdditionalHeader;
UA_ExtensionObject_init(&(req.requestHeader.additionalHeader));
req.nodesToRead= UA_Array_new(&UA_TYPES[UA_TYPES_READVALUEID], 1);
req.nodesToReadSize = 1;
UA_ReadValueId_init(&(req.nodesToRead[0]));
req.nodesToRead[0].attributeId = 13; //UA_ATTRIBUTEID_VALUE
UA_NodeId_init(&(req.nodesToRead[0].nodeId));
req.nodesToRead[0].nodeId.identifierType = UA_NODEIDTYPE_NUMERIC;
req.nodesToRead[0].nodeId.identifier.numeric = 2255;
UA_QualifiedName_init(&(req.nodesToRead[0].dataEncoding));
/**messageEncodedLength = UA_TcpMessageHeader_calcSizeBinary(&reqTcpHeader) +
UA_UInt32_calcSizeBinary(&reqSecureChannelId)+
UA_UInt32_calcSizeBinary(&reqTokenId)+
UA_SequenceHeader_calcSizeBinary(&reqSequenceHeader)+
UA_NodeId_calcSizeBinary(&reqRequestType) +
UA_ReadRequest_calcSizeBinary(&req);**/
UA_TcpMessageHeader_init(&reqTcpHeader);
reqTcpHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_MSGF;
UA_TcpMessageHeader_encodeBinary(&reqTcpHeader, &message, &messagepos);
UA_UInt32_encodeBinary(&reqSecureChannelId, &message, &messagepos);
UA_UInt32_encodeBinary(&reqTokenId, &message, &messagepos);
UA_SequenceHeader_encodeBinary(&reqSequenceHeader, &message, &messagepos);
UA_NodeId_encodeBinary(&reqRequestType, &message, &messagepos);
UA_ReadRequest_encodeBinary(&req, &message, &messagepos);
reqTcpHeader.messageSize = messagepos;
messagepos=0;
UA_TcpMessageHeader_encodeBinary(&reqTcpHeader, &message, &messagepos);
UA_UInt32_encodeBinary(&reqSecureChannelId, &message, &messagepos);
UA_UInt32_encodeBinary(&reqTokenId, &message, &messagepos);
UA_SequenceHeader_encodeBinary(&reqSequenceHeader, &message, &messagepos);
UA_NodeId_encodeBinary(&reqRequestType, &message, &messagepos);
UA_ReadRequest_encodeBinary(&req, &message, &messagepos);
//Send some data
if(send(sock , message.data, messagepos , 0) < 0) {
puts("Send failed");
return 1;
}
//Receive a reply from the server
int received = recv(sock , server_reply , 2000 , 0);
if(received < 0) {
puts("recv failed");
return 1;
}
for(int i=0;i<received;i++) {
//show only printable ascii
if(server_reply[i] >= 32 && server_reply[i]<= 126)
printf("%c",server_reply[i]);
}
printf("\n");
close(sock);
return 0;
}
