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 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_StatusCode ServerNetworkLayerGetBuffer(UA_Connection *connection, UA_ByteString *buf) {
#ifdef UA_MULTITHREADING
return UA_ByteString_newMembers(buf, connection->remoteConf.recvBufferSize);
#else
ServerNetworkLayerTCP *layer = connection->handle;
*buf = layer->buffer;
return UA_STATUSCODE_GOOD;
#endif
}
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_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
}
END_TEST
START_TEST(encodeShallYieldDecode) {
// given
UA_ByteString msg1, msg2;
UA_UInt32 pos = 0;
void *obj1 = UA_TYPES[_i].new();
UA_ByteString_newMembers(&msg1, UA_TYPES[_i].encodings[UA_ENCODING_BINARY].calcSize(obj1));
UA_StatusCode retval = UA_TYPES[_i].encodings[UA_ENCODING_BINARY].encode(obj1, &msg1, &pos);
if(retval != UA_STATUSCODE_GOOD) {
// this happens, e.g. when we encode a variant (with UA_TYPES[UA_INVALIDTYPE] in the vtable)
UA_TYPES[_i].delete(obj1);
UA_ByteString_deleteMembers(&msg1);
return;
}
UA_ServerNetworkLayer ServerNetworkLayerTCP_new(UA_ConnectionConfig conf, UA_UInt32 port) {
#ifdef _WIN32
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD(2, 2);
WSAStartup(wVersionRequested, &wsaData);
#endif
UA_ServerNetworkLayer nl;
memset(&nl, 0, sizeof(UA_ServerNetworkLayer));
ServerNetworkLayerTCP *layer = malloc(sizeof(ServerNetworkLayerTCP));
if(!layer){
return nl;
}
layer->conf = conf;
layer->mappingsSize = 0;
layer->mappings = NULL;
layer->port = port;
char hostname[256];
gethostname(hostname, 255);
UA_String_copyprintf("opc.tcp://%s:%d", &nl.discoveryUrl, hostname, port);
#ifndef UA_MULTITHREADING
layer->buffer = (UA_ByteString){.length = conf.maxMessageSize, .data = malloc(conf.maxMessageSize)};
#endif
nl.handle = layer;
nl.start = ServerNetworkLayerTCP_start;
nl.getJobs = ServerNetworkLayerTCP_getJobs;
nl.stop = ServerNetworkLayerTCP_stop;
nl.deleteMembers = ServerNetworkLayerTCP_deleteMembers;
return nl;
}
/***************************/
/* Client NetworkLayer TCP */
/***************************/
static UA_StatusCode ClientNetworkLayerGetBuffer(UA_Connection *connection, UA_ByteString *buf) {
#ifndef UA_MULTITHREADING
*buf = *(UA_ByteString*)connection->handle;
return UA_STATUSCODE_GOOD;
#else
return UA_ByteString_newMembers(buf, connection->remoteConf.recvBufferSize);
#endif
}
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_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;
}
/* we have no networklayer. instead, attach the reusable buffer to the handle */
UA_Connection ClientNetworkLayerTCP_connect(UA_ConnectionConfig localConf, char *endpointUrl,
UA_Logger *logger) {
UA_Connection connection;
UA_Connection_init(&connection);
connection.localConf = localConf;
#ifndef UA_MULTITHREADING
connection.handle = UA_ByteString_new();
UA_ByteString_newMembers(connection.handle, localConf.maxMessageSize);
#endif
size_t urlLength = strlen(endpointUrl);
if(urlLength < 11 || urlLength >= 512) {
UA_LOG_WARNING((*logger), UA_LOGCATEGORY_COMMUNICATION, "Server url size invalid");
return connection;
}
if(strncmp(endpointUrl, "opc.tcp://", 10) != 0) {
UA_LOG_WARNING((*logger), UA_LOGCATEGORY_COMMUNICATION, "Server url does not begin with opc.tcp://");
return connection;
}
UA_UInt16 portpos = 9;
UA_UInt16 port = 0;
for(;portpos < urlLength-1; portpos++) {
if(endpointUrl[portpos] == ':') {
port = atoi(&endpointUrl[portpos+1]);
break;
}
}
if(port == 0) {
UA_LOG_WARNING((*logger), UA_LOGCATEGORY_COMMUNICATION, "Port invalid");
return connection;
}
char hostname[512];
for(int i=10; i < portpos; i++)
hostname[i-10] = endpointUrl[i];
hostname[portpos-10] = 0;
#ifdef _WIN32
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD(2, 2);
WSAStartup(wVersionRequested, &wsaData);
if((connection.sockfd = socket(PF_INET, SOCK_STREAM,0)) == (UA_Int32)INVALID_SOCKET) {
#else
if((connection.sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
#endif
UA_LOG_WARNING((*logger), UA_LOGCATEGORY_COMMUNICATION, "Could not create socket");
return connection;
}
struct hostent *server = gethostbyname(hostname);
if(server == NULL) {
UA_LOG_WARNING((*logger), UA_LOGCATEGORY_COMMUNICATION, "DNS lookup of %s failed", hostname);
return connection;
}
struct sockaddr_in server_addr;
memset(&server_addr, 0, sizeof(server_addr));
memcpy((char *)&server_addr.sin_addr.s_addr, (char *)server->h_addr_list[0], server->h_length);
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port);
connection.state = UA_CONNECTION_OPENING;
if(connect(connection.sockfd, (struct sockaddr *) &server_addr, sizeof(server_addr)) < 0) {
ClientNetworkLayerClose(&connection);
UA_LOG_WARNING((*logger), UA_LOGCATEGORY_COMMUNICATION, "Connection failed");
return connection;
}
#ifdef SO_NOSIGPIPE
int val = 1;
if (setsockopt(connection.sockfd, SOL_SOCKET, SO_NOSIGPIPE, (void*)&val, sizeof(val)) < 0) {
UA_LOG_WARNING((*logger), UA_LOGCATEGORY_COMMUNICATION, "Couldn't set SO_NOSIGPIPE");
}
#endif
//socket_set_nonblocking(connection.sockfd);
connection.write = socket_write;
connection.recv = socket_recv;
connection.close = ClientNetworkLayerClose;
connection.getBuffer = ClientNetworkLayerGetBuffer;
connection.releaseBuffer = ClientNetworkLayerReleaseBuffer;
return connection;
}
void Service_Read(UA_Server *server, UA_Session *session, const UA_ReadRequest *request,
UA_ReadResponse *response) {
UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SESSION,
"Processing ReadRequest for Session (ns=%i,i=%i)",
session->sessionId.namespaceIndex, session->sessionId.identifier.numeric);
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(size, &UA_TYPES[UA_TYPES_DATAVALUE]);
if(!response->results) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
response->resultsSize = size;
if(request->maxAge < 0) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADMAXAGEINVALID;
return;
}
#ifdef UA_ENABLE_EXTERNAL_NAMESPACES
UA_Boolean isExternal[size];
UA_UInt32 indices[size];
memset(isExternal, UA_FALSE, sizeof(UA_Boolean) * size);
for(size_t 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);
}
#endif
for(size_t i = 0;i < size;i++) {
#ifdef UA_ENABLE_EXTERNAL_NAMESPACES
if(!isExternal[i])
#endif
Service_Read_single(server, session, request->timestampsToReturn,
&request->nodesToRead[i], &response->results[i]);
}
#ifdef UA_ENABLE_NONSTANDARD_STATELESS
/* Add an expiry header for caching */
if(session==&anonymousSession){
UA_ExtensionObject additionalHeader;
UA_ExtensionObject_init(&additionalHeader);
additionalHeader.typeId = UA_TYPES[UA_TYPES_VARIANT].typeId;
additionalHeader.encoding = UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING;
UA_Variant variant;
UA_Variant_init(&variant);
UA_DateTime* expireArray = NULL;
expireArray = UA_Array_new(&UA_TYPES[UA_TYPES_DATETIME], request->nodesToReadSize);
variant.data = expireArray;
/*expires in 20 seconds*/
for(UA_Int32 i = 0;i < response->resultsSize;i++) {
expireArray[i] = UA_DateTime_now() + 20 * 100 * 1000 * 1000;
}
UA_Variant_setArray(&variant, expireArray, request->nodesToReadSize, &UA_TYPES[UA_TYPES_DATETIME]);
size_t offset = 0;
UA_ByteString str;
UA_ByteString_newMembers(&str, 65536);
UA_Variant_encodeBinary(&variant, &str, &offset);
UA_Array_delete(expireArray, &UA_TYPES[UA_TYPES_DATETIME], request->nodesToReadSize);
additionalHeader.body = str;
additionalHeader.body.length = offset;
response->responseHeader.additionalHeader = additionalHeader;
}
#endif
}
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;
}
static int ua_client_connectUA(char* ipaddress,int port, UA_String *endpointUrl, ConnectionInfo *connectionInfo,
UA_Boolean stateless, UA_Boolean udp) {
UA_ByteString reply;
UA_ByteString_newMembers(&reply, 65536);
int sock;
struct sockaddr_in server;
//Create socket
if(udp==UA_TRUE){
sock = socket(AF_INET, SOCK_DGRAM, 0);
}else{
sock = socket(AF_INET, SOCK_STREAM, 0);
}
if(sock == -1) {
printf("Could not create socket");
return 1;
}
server.sin_addr.s_addr = inet_addr(ipaddress);
server.sin_family = AF_INET;
server.sin_port = htons(port);
if(connect(sock, (struct sockaddr *) &server, sizeof(server)) < 0) {
perror("connect failed. Error");
return 1;
}
connectionInfo->socket = sock;
if(stateless){
UA_NodeId_init(&connectionInfo->authenticationToken);
connectionInfo->channelId=0;
UA_SequenceHeader_init(&connectionInfo->sequenceHdr);
connectionInfo->tokenId=0;
return 0;
}else{
sendHello(sock, endpointUrl);
recv(sock, reply.data, reply.length, 0);
sendOpenSecureChannel(sock);
recv(sock, reply.data, reply.length, 0);
size_t recvOffset = 0;
UA_TcpMessageHeader msghdr;
UA_TcpMessageHeader_decodeBinary(&reply, &recvOffset, &msghdr);
UA_AsymmetricAlgorithmSecurityHeader asymHeader;
UA_NodeId rspType;
UA_OpenSecureChannelResponse openSecChannelRsp;
UA_UInt32_decodeBinary(&reply, &recvOffset, &connectionInfo->channelId);
UA_AsymmetricAlgorithmSecurityHeader_decodeBinary(&reply,&recvOffset,&asymHeader);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
UA_SequenceHeader_decodeBinary(&reply,&recvOffset,&connectionInfo->sequenceHdr);
UA_NodeId_decodeBinary(&reply,&recvOffset,&rspType);
UA_OpenSecureChannelResponse_decodeBinary(&reply,&recvOffset,&openSecChannelRsp);
connectionInfo->tokenId = openSecChannelRsp.securityToken.tokenId;
sendCreateSession(sock, connectionInfo->channelId, openSecChannelRsp.securityToken.tokenId, 52, 2, endpointUrl);
recv(sock, reply.data, reply.length, 0);
UA_NodeId messageType;
recvOffset = 24;
UA_NodeId_decodeBinary(&reply,&recvOffset,&messageType);
UA_CreateSessionResponse createSessionResponse;
UA_CreateSessionResponse_decodeBinary(&reply,&recvOffset,&createSessionResponse);
connectionInfo->authenticationToken = createSessionResponse.authenticationToken;
sendActivateSession(sock, connectionInfo->channelId, connectionInfo->tokenId, 53, 3,
connectionInfo->authenticationToken);
recv(sock, reply.data, reply.length, 0);
UA_OpenSecureChannelResponse_deleteMembers(&openSecChannelRsp);
UA_String_deleteMembers(&reply);
UA_CreateSessionResponse_deleteMembers(&createSessionResponse);
return 0;
}
}
UA_UInt32 pos = 0;
void *obj1 = UA_TYPES[_i].new();
UA_ByteString_newMembers(&msg1, UA_TYPES[_i].encodings[UA_ENCODING_BINARY].calcSize(obj1));
UA_StatusCode retval = UA_TYPES[_i].encodings[UA_ENCODING_BINARY].encode(obj1, &msg1, &pos);
if(retval != UA_STATUSCODE_GOOD) {
// this happens, e.g. when we encode a variant (with UA_TYPES[UA_INVALIDTYPE] in the vtable)
UA_TYPES[_i].delete(obj1);
UA_ByteString_deleteMembers(&msg1);
return;
}
// when
void *obj2 = UA_TYPES[_i].new();
pos = 0; retval = UA_TYPES[_i].encodings[UA_ENCODING_BINARY].decode(&msg1, &pos, obj2);
ck_assert_msg(retval == UA_STATUSCODE_GOOD, "messages differ idx=%d,name=%s", _i, UA_TYPES[_i].name);
retval = UA_ByteString_newMembers(&msg2, UA_TYPES[_i].encodings[UA_ENCODING_BINARY].calcSize(obj2));
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
pos = 0; retval = UA_TYPES[_i].encodings[UA_ENCODING_BINARY].encode(obj2, &msg2, &pos);
ck_assert_int_eq(retval, UA_STATUSCODE_GOOD);
// then
ck_assert_msg(UA_ByteString_equal(&msg1, &msg2) == UA_TRUE, "messages differ idx=%d,name=%s", _i, UA_TYPES[_i].name);
// finally
UA_TYPES[_i].delete(obj1);
UA_TYPES[_i].delete(obj2);
UA_ByteString_deleteMembers(&msg1);
UA_ByteString_deleteMembers(&msg2);
}
END_TEST
int main(int argc, char *argv[]) {
int defaultParams = argc < 8;
//start parameters
if(defaultParams) {
printf("1st parameter: number of nodes to read \n");
printf("2nd parameter: number of read-tries \n");
printf("3rd parameter: name of the file to save measurement data \n");
printf("4th parameter: 1 = read same node, 0 = read different nodes \n");
printf("5th parameter: ip adress \n");
printf("6th parameter: port \n");
printf("7th parameter: 0=stateful, 1=stateless\n");
printf("8th parameter: 0=tcp, 1=udp (only with stateless calls)\n");
printf("\nUsing default parameters. \n");
}
UA_UInt32 nodesToReadSize;
UA_UInt32 tries;
UA_Boolean alwaysSameNode;
UA_ByteString reply;
UA_ByteString_newMembers(&reply, 65536);
UA_Boolean stateless;
UA_Boolean udp;
if(defaultParams)
nodesToReadSize = 1;
else
nodesToReadSize = atoi(argv[1]);
if(defaultParams)
tries= 2;
else
tries = (UA_UInt32) atoi(argv[2]);
if(defaultParams){
alwaysSameNode = UA_TRUE;
}else{
if(atoi(argv[4]) != 0)
alwaysSameNode = UA_TRUE;
else
alwaysSameNode = UA_FALSE;
}
if(defaultParams){
stateless = UA_FALSE;
}else{
if(atoi(argv[7]) != 0)
stateless = UA_TRUE;
else
stateless = UA_FALSE;
}
if(defaultParams){
udp = UA_FALSE;
}else{
if(atoi(argv[8]) != 0)
udp = UA_TRUE;
else
udp = UA_FALSE;
}
//Connect to remote server
UA_String endpoint;
UA_String_copycstring("none",&endpoint);
ConnectionInfo connectionInfo;
/* REQUEST START*/
UA_NodeId *nodesToRead;
nodesToRead = UA_Array_new(&UA_TYPES[UA_TYPES_NODEID], 1);
for(UA_UInt32 i = 0; i<1; i++) {
if(alwaysSameNode)
nodesToRead[i].identifier.numeric = 2253; //ask always the same node
else
nodesToRead[i].identifier.numeric = 19000 +i;
nodesToRead[i].identifierType = UA_NODEIDTYPE_NUMERIC;
nodesToRead[i].namespaceIndex = 0;
}
UA_DateTime tic, toc;
UA_Double *timeDiffs;
UA_Int32 received;
timeDiffs = UA_Array_new(&UA_TYPES[UA_TYPES_DOUBLE], tries);
UA_Double sum = 0;
tic = UA_DateTime_now();
/**
UA_Double duration;
UA_UInt32 count = 0;
UA_Double start = 0, stop = 0;
UA_UInt32 timeToRun = 30;
UA_UInt32 timeToStart = 8;
UA_UInt32 timeToStop = 22;
do{
toc = UA_DateTime_now();
duration = ((UA_Double)toc-(UA_Double)tic)/(UA_Double)1e4;
if(duration>=timeToStart*1000 && duration <= timeToStop*1000){
if(start==0.0){
start=UA_DateTime_now();
}
}
//if(stateless || (!stateless && i==0)){
if(defaultParams){
if(ua_client_connectUA("127.0.0.1",atoi("16664"),&endpoint,&connectionInfo,stateless,udp) != 0){
return 0;
}
}else{
if(ua_client_connectUA(argv[5],atoi(argv[6]),&endpoint,&connectionInfo,stateless,udp) != 0){
return 0;
}
}
//}
sendReadRequest(&connectionInfo,1,nodesToRead);
received = recv(connectionInfo.socket, reply.data, 2000, 0);
if(duration>=timeToStart*1000 && duration <= timeToStop*1000){
count++;
}
if(!stateless){
closeSession(&connectionInfo);
recv(connectionInfo.socket, reply.data, 2000, 0);
closeSecureChannel(&connectionInfo);
}
//if(stateless || (!stateless && i==tries-1)){
close(connectionInfo.socket);
//}
if(duration >= timeToStop*1000 && stop==0){
stop=UA_DateTime_now();
printf("%i messages in %f secs, rate %f m/s\n", count, (stop-start)/(UA_Double)1e7, (UA_Double)count/((stop-start)/(UA_Double)1e7));
}
}while(duration<timeToRun*1000);
exit(0);
**/
for(UA_UInt32 i = 0; i < tries; i++) {
//if(stateless || (!stateless && i==0)){
tic = UA_DateTime_now();
if(defaultParams){
if(ua_client_connectUA("127.0.0.1",atoi("16664"),&endpoint,&connectionInfo,stateless,udp) != 0){
return 0;
}
}else{
if(ua_client_connectUA(argv[5],atoi(argv[6]),&endpoint,&connectionInfo,stateless,udp) != 0){
return 0;
}
}
//}
for(UA_UInt32 i = 0; i < nodesToReadSize; i++) {
sendReadRequest(&connectionInfo,1,nodesToRead);
received = recv(connectionInfo.socket, reply.data, 2000, 0);
}
if(!stateless){
closeSession(&connectionInfo);
recv(connectionInfo.socket, reply.data, 2000, 0);
closeSecureChannel(&connectionInfo);
}
//if(stateless || (!stateless && i==tries-1)){
close(connectionInfo.socket);
//}
toc = UA_DateTime_now() - tic;
timeDiffs[i] = (UA_Double)toc/(UA_Double)1e4;
sum = sum + timeDiffs[i];
}
/* REQUEST END*/
UA_Double mean = sum / tries;
printf("mean time for handling request: %16.10f ms \n",mean);
if(received>0)
printf("received: %i\n",received); // dummy
//save to file
char data[100];
const char flag = 'a';
FILE* fHandle = UA_NULL;
if (defaultParams) {
fHandle = fopen("client.log", &flag);
}else{
fHandle = fopen(argv[3], &flag);
}
//header
UA_Int32 bytesToWrite = sprintf(data, "measurement %s in ms, nodesToRead %d \n", argv[3], 1);
fwrite(data,1,bytesToWrite,fHandle);
for(UA_UInt32 i=0;i<tries;i++) {
bytesToWrite = sprintf(data,"%16.10f \n",timeDiffs[i]);
fwrite(data,1,bytesToWrite,fHandle);
}
fclose(fHandle);
UA_String_deleteMembers(&reply);
UA_Array_delete(nodesToRead,&UA_TYPES[UA_TYPES_NODEID], 1);
UA_free(timeDiffs);
return 0;
}
static UA_StatusCode GetMallocedBuffer(UA_Connection *connection, UA_Int32 length, UA_ByteString *buf) {
if((UA_UInt32)length > connection->remoteConf.recvBufferSize)
return UA_STATUSCODE_BADCOMMUNICATIONERROR;
return UA_ByteString_newMembers(buf, connection->remoteConf.recvBufferSize);
}
