API tools faq
paste
Advertisement
Guest User

opcuaclient

a guest
Nov 24th, 2014
255
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 19.70 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. C ECHO client example using sockets
  3.  
  4. This is an example client for internal benchmarks. It works, but is not ready
  5. for serious use. We do not really check any of the returns from the server.
  6. */
  7. #include <stdio.h> //printf
  8. #include <string.h> //strlen
  9. #include <sys/socket.h> //socket
  10. #include <arpa/inet.h> //inet_addr
  11. #include <unistd.h> // for close
  12. #include <stdlib.h> // pulls in declaration of malloc, free
  13. #include "ua_transport_generated.h"
  14. #include "ua_namespace_0.h"
  15. #include "ua_util.h"
  16.  
  17. UA_Int32 sendHello(UA_Int32 sock, UA_String *endpointURL) {
  18.  
  19. UA_TcpMessageHeader messageHeader;
  20. messageHeader.isFinal = 'F';
  21. messageHeader.messageType = UA_MESSAGETYPE_HEL;
  22.  
  23. UA_TcpHelloMessage hello;
  24. UA_String_copy(endpointURL, &hello.endpointUrl);
  25. hello.maxChunkCount = 1;
  26. hello.maxMessageSize = 16777216;
  27. hello.protocolVersion = 0;
  28. hello.receiveBufferSize = 65536;
  29. hello.sendBufferSize = 65536;
  30.  
  31. messageHeader.messageSize = UA_TcpHelloMessage_calcSizeBinary((UA_TcpHelloMessage const*) &hello) +
  32. UA_TcpMessageHeader_calcSizeBinary((UA_TcpMessageHeader const*) &messageHeader);
  33. UA_ByteString message;
  34. UA_ByteString_newMembers(&message, messageHeader.messageSize);
  35.  
  36. UA_UInt32 offset = 0;
  37. UA_TcpMessageHeader_encodeBinary((UA_TcpMessageHeader const*) &messageHeader, &message, &offset);
  38. UA_TcpHelloMessage_encodeBinary((UA_TcpHelloMessage const*) &hello, &message, &offset);
  39.  
  40. UA_Int32 sendret = send(sock, message.data, offset, 0);
  41.  
  42. UA_ByteString_deleteMembers(&message);
  43. free(hello.endpointUrl.data);
  44. if (sendret < 0)
  45. return 1;
  46. return 0;
  47. }
  48.  
  49. int sendOpenSecureChannel(UA_Int32 sock) {
  50. UA_TcpMessageHeader msghdr;
  51. msghdr.isFinal = 'F';
  52. msghdr.messageType = UA_MESSAGETYPE_OPN;
  53.  
  54. UA_UInt32 secureChannelId = 0;
  55. UA_String securityPolicy;
  56. UA_String_copycstring("http://opcfoundation.org/UA/SecurityPolicy#None", &securityPolicy);
  57.  
  58. UA_String senderCert;
  59. senderCert.data = UA_NULL;
  60. senderCert.length = -1;
  61.  
  62. UA_String receiverCertThumb;
  63. receiverCertThumb.data = UA_NULL;
  64. receiverCertThumb.length = -1;
  65.  
  66. UA_UInt32 sequenceNumber = 51;
  67.  
  68. UA_UInt32 requestId = 1;
  69.  
  70. UA_NodeId type;
  71. type.identifier.numeric = 446; // id of opensecurechannelrequest
  72. type.identifierType = UA_NODEIDTYPE_NUMERIC;
  73. type.namespaceIndex = 0;
  74.  
  75. UA_OpenSecureChannelRequest opnSecRq;
  76. UA_OpenSecureChannelRequest_init(&opnSecRq);
  77. opnSecRq.requestHeader.timestamp = UA_DateTime_now();
  78. UA_ByteString_newMembers(&opnSecRq.clientNonce, 1);
  79. opnSecRq.clientNonce.data[0] = 1;
  80. opnSecRq.clientProtocolVersion = 0;
  81. opnSecRq.requestedLifetime = 30000;
  82. opnSecRq.securityMode = UA_MESSAGESECURITYMODE_NONE;
  83. opnSecRq.requestType = UA_SECURITYTOKENREQUESTTYPE_ISSUE;
  84. opnSecRq.requestHeader.authenticationToken.identifier.numeric = 10;
  85. opnSecRq.requestHeader.authenticationToken.identifierType = UA_NODEIDTYPE_NUMERIC;
  86. opnSecRq.requestHeader.authenticationToken.namespaceIndex = 10;
  87.  
  88. msghdr.messageSize = 135; // todo: compute the message size from the actual content
  89.  
  90. UA_ByteString message;
  91. UA_ByteString_newMembers(&message, 1000);
  92. UA_UInt32 offset = 0;
  93. UA_TcpMessageHeader_encodeBinary(&msghdr, &message, &offset);
  94. UA_UInt32_encodeBinary(&secureChannelId, &message, &offset);
  95. UA_String_encodeBinary(&securityPolicy, &message, &offset);
  96. UA_String_encodeBinary(&senderCert, &message, &offset);
  97. UA_String_encodeBinary(&receiverCertThumb, &message, &offset);
  98. UA_UInt32_encodeBinary(&sequenceNumber, &message, &offset);
  99. UA_UInt32_encodeBinary(&requestId, &message, &offset);
  100. UA_NodeId_encodeBinary(&type, &message, &offset);
  101. UA_OpenSecureChannelRequest_encodeBinary(&opnSecRq, &message, &offset);
  102.  
  103. UA_OpenSecureChannelRequest_deleteMembers(&opnSecRq);
  104. UA_String_deleteMembers(&securityPolicy);
  105.  
  106. UA_Int32 sendret = send(sock, message.data, offset, 0);
  107. UA_ByteString_deleteMembers(&message);
  108. if (sendret < 0) {
  109. printf("send opensecurechannel failed");
  110. return 1;
  111. }
  112. return 0;
  113. }
  114.  
  115. UA_Int32 sendCreateSession(UA_Int32 sock, UA_UInt32 channelId, UA_UInt32 tokenId, UA_UInt32 sequenceNumber,
  116. UA_UInt32 requestId, UA_String *endpointUrl) {
  117. UA_ByteString message;
  118. UA_ByteString_newMembers(&message, 65536);
  119. UA_UInt32 tmpChannelId = channelId;
  120. UA_UInt32 offset = 0;
  121.  
  122. UA_TcpMessageHeader msghdr;
  123. msghdr.isFinal = 'F';
  124. msghdr.messageType = UA_MESSAGETYPE_MSG;
  125.  
  126. UA_NodeId type;
  127. type.identifier.numeric = 461;
  128. type.identifierType = UA_NODEIDTYPE_NUMERIC;
  129. type.namespaceIndex = 0;
  130.  
  131. UA_CreateSessionRequest rq;
  132. UA_CreateSessionRequest_init(&rq);
  133. rq.requestHeader.requestHandle = 1;
  134. rq.requestHeader.timestamp = UA_DateTime_now();
  135. rq.requestHeader.timeoutHint = 10000;
  136. rq.requestHeader.authenticationToken.identifier.numeric = 10;
  137. rq.requestHeader.authenticationToken.identifierType = UA_NODEIDTYPE_NUMERIC;
  138. rq.requestHeader.authenticationToken.namespaceIndex = 10;
  139. UA_String_copy(endpointUrl, &rq.endpointUrl);
  140. UA_String_copycstring("mysession", &rq.sessionName);
  141. UA_String_copycstring("abcd", &rq.clientCertificate);
  142. UA_ByteString_newMembers(&rq.clientNonce, 1);
  143. rq.clientNonce.data[0] = 1;
  144. rq.requestedSessionTimeout = 1200000;
  145. rq.maxResponseMessageSize = UA_INT32_MAX;
  146.  
  147. msghdr.messageSize = 16 + UA_TcpMessageHeader_calcSizeBinary(&msghdr) + UA_NodeId_calcSizeBinary(&type) +
  148. UA_CreateSessionRequest_calcSizeBinary(&rq);
  149.  
  150. UA_TcpMessageHeader_encodeBinary(&msghdr, &message, &offset);
  151. UA_UInt32_encodeBinary(&tmpChannelId, &message, &offset);
  152. UA_UInt32_encodeBinary(&tokenId, &message, &offset);
  153. UA_UInt32_encodeBinary(&sequenceNumber, &message, &offset);
  154. UA_UInt32_encodeBinary(&requestId, &message, &offset);
  155. UA_NodeId_encodeBinary(&type, &message, &offset);
  156. UA_CreateSessionRequest_encodeBinary(&rq, &message, &offset);
  157.  
  158. UA_Int32 sendret = send(sock, message.data, offset, 0);
  159. UA_ByteString_deleteMembers(&message);
  160. UA_CreateSessionRequest_deleteMembers(&rq);
  161. if (sendret < 0) {
  162. printf("send opensecurechannel failed");
  163. return 1;
  164. }
  165. return 0;
  166. }
  167. UA_Int32 sendActivateSession(UA_Int32 sock, UA_UInt32 channelId, UA_UInt32 tokenId, UA_UInt32 sequenceNumber,
  168. UA_UInt32 requestId, UA_NodeId authenticationToken) {
  169. UA_ByteString *message = UA_ByteString_new();
  170. UA_ByteString_newMembers(message, 65536);
  171. UA_UInt32 tmpChannelId = channelId;
  172. UA_UInt32 offset = 0;
  173.  
  174. UA_TcpMessageHeader msghdr;
  175. msghdr.isFinal = 'F';
  176. msghdr.messageType = UA_MESSAGETYPE_MSG;
  177. msghdr.messageSize = 86;
  178.  
  179. UA_NodeId type;
  180. type.identifier.numeric = 467;
  181. type.identifierType = UA_NODEIDTYPE_NUMERIC;
  182. type.namespaceIndex = 0;
  183.  
  184. UA_ActivateSessionRequest rq;
  185. UA_ActivateSessionRequest_init(&rq);
  186. rq.requestHeader.requestHandle = 2;
  187. rq.requestHeader.authenticationToken = authenticationToken;
  188. rq.requestHeader.timestamp = UA_DateTime_now();
  189. rq.requestHeader.timeoutHint = 10000;
  190.  
  191. msghdr.messageSize = 16 + UA_TcpMessageHeader_calcSizeBinary(&msghdr) + UA_NodeId_calcSizeBinary(&type) +
  192. UA_ActivateSessionRequest_calcSizeBinary(&rq);
  193.  
  194. UA_TcpMessageHeader_encodeBinary(&msghdr, message, &offset);
  195. UA_UInt32_encodeBinary(&tmpChannelId, message, &offset);
  196. UA_UInt32_encodeBinary(&tokenId, message, &offset);
  197. UA_UInt32_encodeBinary(&sequenceNumber, message, &offset);
  198. UA_UInt32_encodeBinary(&requestId, message, &offset);
  199. UA_NodeId_encodeBinary(&type, message, &offset);
  200. UA_ActivateSessionRequest_encodeBinary(&rq, message, &offset);
  201.  
  202. UA_Int32 sendret = send(sock, message->data, offset, 0);
  203. UA_ByteString_delete(message);
  204.  
  205. if (sendret < 0) {
  206. printf("send opensecurechannel failed");
  207. return 1;
  208. }
  209. return 0;
  210.  
  211. }
  212.  
  213. UA_Int64 sendReadRequest(UA_Int32 sock, UA_UInt32 channelId, UA_UInt32 tokenId, UA_UInt32 sequenceNumber, UA_UInt32 requestId,
  214. UA_NodeId authenticationToken, UA_Int32 nodeIds_size,UA_NodeId* nodeIds) {
  215. UA_ByteString *message = UA_ByteString_new();
  216. UA_ByteString_newMembers(message, 65536);
  217. UA_UInt32 tmpChannelId = channelId;
  218. UA_UInt32 offset = 0;
  219.  
  220. UA_TcpMessageHeader msghdr;
  221. msghdr.isFinal = 'F';
  222. msghdr.messageType = UA_MESSAGETYPE_MSG;
  223.  
  224. UA_NodeId type;
  225. type.identifier.numeric = 631;
  226. type.identifierType = UA_NODEIDTYPE_NUMERIC;
  227. type.namespaceIndex = 0;
  228.  
  229. UA_ReadRequest rq;
  230. UA_ReadRequest_init(&rq);
  231. rq.maxAge = 0;
  232. UA_Array_new((void **)&rq.nodesToRead, nodeIds_size, &UA_TYPES[UA_READVALUEID]);
  233. rq.nodesToReadSize = nodeIds_size;
  234. for(UA_Int32 i=0;i<nodeIds_size;i++) {
  235. UA_ReadValueId_init(&(rq.nodesToRead[i]));
  236. rq.nodesToRead[i].attributeId = 6; //WriteMask
  237. UA_NodeId_init(&(rq.nodesToRead[i].nodeId));
  238. rq.nodesToRead[i].nodeId = nodeIds[i];
  239. UA_QualifiedName_init(&(rq.nodesToRead[0].dataEncoding));
  240. }
  241. rq.requestHeader.timeoutHint = 10000;
  242. rq.requestHeader.timestamp = UA_DateTime_now();
  243. rq.requestHeader.authenticationToken = authenticationToken;
  244. rq.timestampsToReturn = 0x03;
  245. rq.requestHeader.requestHandle = 1 + requestId;
  246.  
  247. msghdr.messageSize = 16 + UA_TcpMessageHeader_calcSizeBinary(&msghdr) + UA_NodeId_calcSizeBinary(&type) +
  248. UA_ReadRequest_calcSizeBinary(&rq);
  249.  
  250. UA_TcpMessageHeader_encodeBinary(&msghdr,message,&offset);
  251. UA_UInt32_encodeBinary(&tmpChannelId, message, &offset);
  252. UA_UInt32_encodeBinary(&tokenId, message, &offset);
  253. UA_UInt32_encodeBinary(&sequenceNumber, message, &offset);
  254. UA_UInt32_encodeBinary(&requestId, message, &offset);
  255. UA_NodeId_encodeBinary(&type,message,&offset);
  256. UA_ReadRequest_encodeBinary(&rq, message, &offset);
  257.  
  258. UA_DateTime tic = UA_DateTime_now();
  259. UA_Int32 sendret = send(sock, message->data, offset, 0);
  260. UA_Array_delete(rq.nodesToRead,nodeIds_size,&UA_TYPES[UA_READVALUEID]);
  261. UA_ByteString_delete(message);
  262.  
  263. if (sendret < 0) {
  264. printf("send readrequest failed");
  265. return 1;
  266. }
  267. return tic;
  268. }
  269. UA_Int64 sendAddNodes(UA_Int32 sock, UA_UInt32 channelId, UA_UInt32 tokenId, UA_UInt32 sequenceNumber, UA_UInt32 requestId,
  270. UA_NodeId authenticationToken, UA_NodeId parentNodeId, UA_NodeId referenceTypeId,UA_NodeId* nodes,UA_UInt32 nodesSize) {
  271. UA_ByteString *message = UA_ByteString_new();
  272. UA_ByteString_newMembers(message, 65536);
  273. UA_UInt32 tmpChannelId = channelId;
  274. UA_UInt32 offset = 0;
  275.  
  276. UA_TcpMessageHeader msghdr;
  277. msghdr.isFinal = 'F';
  278. msghdr.messageType = UA_MESSAGETYPE_MSG;
  279.  
  280. UA_NodeId type;
  281. type.identifier.numeric = 488;
  282. type.identifierType = UA_NODEIDTYPE_NUMERIC;
  283. type.namespaceIndex = 0;
  284.  
  285. UA_AddNodesRequest rq;
  286. UA_AddNodesRequest_init(&rq);
  287.  
  288. UA_Array_new((void **)&rq.nodesToAdd, nodesSize, &UA_TYPES[UA_ADDNODESITEM]);
  289. rq.nodesToAddSize = nodesSize;
  290.  
  291.  
  292. for(UA_UInt32 i=0; i<nodesSize; i++) {
  293. UA_AddNodesItem_init(&(rq.nodesToAdd[i]));
  294. //rq.nodesToAdd[i].browseName.name.length = -1;
  295. //rq.nodesToAdd[i].browseName.name.data = UA_NULL;
  296.  
  297.  
  298. rq.nodesToAdd[i].parentNodeId.nodeId = parentNodeId;
  299.  
  300. UA_QualifiedName_init(&rq.nodesToAdd[i].browseName);
  301. //UA_QualifiedName_copycstring("test",&rq.nodesToAdd[i].browseName);
  302. rq.nodesToAdd[i].referenceTypeId = referenceTypeId;
  303. UA_ExpandedNodeId_init(&rq.nodesToAdd[i].requestedNewNodeId);
  304. rq.nodesToAdd[i].requestedNewNodeId.nodeId = nodes[i];
  305. rq.nodesToAdd[i].nodeClass = UA_NODECLASS_VARIABLE;
  306. UA_VariableAttributes varAttr;
  307. UA_VariableAttributes_init(&varAttr);
  308.  
  309. rq.nodesToAdd[i].typeDefinition.nodeId.identifier.numeric = 357;
  310. rq.nodesToAdd[i].typeDefinition.nodeId.identifierType = UA_NODEIDTYPE_NUMERIC;
  311. rq.nodesToAdd[i].typeDefinition.nodeId.namespaceIndex = 0;
  312. rq.nodesToAdd[i].nodeAttributes.typeId = rq.nodesToAdd[i].typeDefinition.nodeId;
  313.  
  314. //UA_LocalizedText_copycstring("someNode", &varAttr.displayName);
  315. //UA_LocalizedText_copycstring("someNode", &varAttr.description);
  316. //UA_Variant_copy(&dataValue->value,&varAttr.value);
  317. varAttr.userWriteMask = 0;
  318. varAttr.writeMask = 0;
  319. UA_Int32* val = UA_Int32_new();
  320. *val = 42;
  321. UA_Variant varVal;
  322. UA_Variant_init(&varVal);
  323.  
  324. varVal.vt = &UA_TYPES[UA_INT32];
  325. varVal.storage.data.dataPtr = val;
  326. varVal.storage.data.arrayDimensionsLength = -1;
  327. varVal.storage.data.arrayDimensions = UA_NULL;
  328. varVal.storageType = UA_VARIANT_DATA_NODELETE;
  329. varVal.storage.data.arrayLength = 1;
  330. varVal.storage.data.dataPtr = val;
  331.  
  332. varAttr.dataType = varVal.vt->typeId;
  333.  
  334. UA_Variant_copy(&varVal,&varAttr.value);
  335.  
  336. varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_VALUERANK;
  337.  
  338. varAttr.arrayDimensions = UA_NULL;
  339. varAttr.arrayDimensionsSize = -1;
  340.  
  341. varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_BROWSENAME;
  342. varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_DISPLAYNAME;
  343. varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_DESCRIPTION;
  344. varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_VALUE;
  345. varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_DATATYPE;
  346. varAttr.specifiedAttributes |= UA_NODEATTRIBUTESMASK_ARRAYDIMENSIONS;
  347. offset = 0;
  348. UA_ByteString_newMembers(&rq.nodesToAdd[i].nodeAttributes.body,
  349. UA_VariableAttributes_calcSizeBinary(&varAttr));
  350. UA_VariableAttributes_encodeBinary(&varAttr,
  351. &rq.nodesToAdd[i].nodeAttributes.body, &offset);
  352.  
  353. }
  354. rq.requestHeader.timeoutHint = 10000;
  355. rq.requestHeader.timestamp = UA_DateTime_now();
  356. rq.requestHeader.authenticationToken = authenticationToken;
  357.  
  358. rq.requestHeader.requestHandle = 1 + requestId;
  359.  
  360. msghdr.messageSize = 16 + UA_TcpMessageHeader_calcSizeBinary(&msghdr) + UA_NodeId_calcSizeBinary(&type) +
  361. UA_AddNodesRequest_calcSizeBinary(&rq);
  362. offset = 0;
  363. UA_TcpMessageHeader_encodeBinary(&msghdr,message,&offset);
  364. UA_UInt32_encodeBinary(&tmpChannelId, message, &offset);
  365. UA_UInt32_encodeBinary(&tokenId, message, &offset);
  366. UA_UInt32_encodeBinary(&sequenceNumber, message, &offset);
  367. UA_UInt32_encodeBinary(&requestId, message, &offset);
  368. UA_NodeId_encodeBinary(&type,message,&offset);
  369. UA_AddNodesRequest_encodeBinary(&rq, message, &offset);
  370.  
  371. UA_DateTime tic = UA_DateTime_now();
  372. UA_Int32 sendret = send(sock, message->data, offset, 0);
  373. UA_Array_delete(rq.nodesToAdd,nodesSize,&UA_TYPES[UA_ADDNODESITEM]);
  374. UA_ByteString_delete(message);
  375.  
  376. if (sendret < 0) {
  377. printf("send readrequest failed");
  378. return 1;
  379. }
  380. return tic;
  381. }
  382. int main(int argc, char *argv[]) {
  383. int sock;
  384. struct sockaddr_in server;
  385.  
  386. UA_ByteString reply;
  387. UA_ByteString_newMembers(&reply, 65536);
  388.  
  389. //start parameters
  390. if(argc < 7) {
  391. printf("1st parameter: number of nodes to read \n");
  392. printf("2nd parameter: number of read-tries \n");
  393. printf("3rd parameter: name of the file to save measurement data \n");
  394. printf("4th parameter: 1 = read same node, 0 = read different nodes \n");
  395. printf("5th parameter: ip adress \n");
  396. printf("6th parameter: port \n");
  397. return 0;
  398. }
  399.  
  400. UA_UInt32 nodesToReadSize;
  401. UA_UInt32 tries;
  402. UA_Boolean alwaysSameNode;
  403. if(argv[1] == UA_NULL)
  404. nodesToReadSize = 1;
  405. else
  406. nodesToReadSize = atoi(argv[1]);
  407.  
  408. if(argv[2] == UA_NULL)
  409. tries= 2;
  410. else
  411. tries = (UA_UInt32) atoi(argv[2]);
  412.  
  413. if(atoi(argv[4]) != 0)
  414. alwaysSameNode = UA_TRUE;
  415. else
  416. alwaysSameNode = UA_FALSE;
  417.  
  418. //Create socket
  419. sock = socket(AF_INET, SOCK_STREAM, 0);
  420. if(sock == -1) {
  421. printf("Could not create socket");
  422. return 1;
  423. }
  424. server.sin_addr.s_addr = inet_addr(argv[5]);
  425. server.sin_family = AF_INET;
  426. server.sin_port = htons(atoi(argv[6]));
  427.  
  428. //Connect to remote server
  429. if(connect(sock, (struct sockaddr *) &server, sizeof(server)) < 0) {
  430. perror("connect failed. Error");
  431. return 1;
  432. }
  433.  
  434. UA_String *endpointUrl = UA_String_new();
  435. UA_String_copycstring("opc.tcp://blabla.com:1234", endpointUrl);
  436. sendHello(sock, endpointUrl);
  437. int received = recv(sock, reply.data, reply.length, 0);
  438. sendOpenSecureChannel(sock);
  439. received = recv(sock, reply.data, reply.length, 0);
  440.  
  441. UA_UInt32 recvOffset = 0;
  442. UA_TcpMessageHeader msghdr;
  443. UA_TcpMessageHeader_decodeBinary(&reply, &recvOffset, &msghdr);
  444. UA_UInt32 secureChannelId;
  445. UA_AsymmetricAlgorithmSecurityHeader asymHeader;
  446. UA_SequenceHeader seqHeader;
  447. UA_NodeId rspType;
  448. UA_OpenSecureChannelResponse openSecChannelRsp;
  449. UA_UInt32_decodeBinary(&reply, &recvOffset, &secureChannelId);
  450. UA_AsymmetricAlgorithmSecurityHeader_decodeBinary(&reply,&recvOffset,&asymHeader);
  451. UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
  452. UA_SequenceHeader_decodeBinary(&reply,&recvOffset,&seqHeader);
  453. UA_NodeId_decodeBinary(&reply,&recvOffset,&rspType);
  454. UA_OpenSecureChannelResponse_decodeBinary(&reply,&recvOffset,&openSecChannelRsp);
  455. UA_UInt32 seqNumber = seqHeader.sequenceNumber + 1;
  456. UA_UInt32 reqNumber = seqHeader.requestId + 1;
  457. sendCreateSession(sock, secureChannelId, openSecChannelRsp.securityToken.tokenId, seqNumber, reqNumber, endpointUrl);
  458. seqNumber++;
  459. reqNumber++;
  460. received = recv(sock, reply.data, reply.length, 0);
  461.  
  462. UA_NodeId messageType;
  463. recvOffset = 24;
  464. UA_NodeId_decodeBinary(&reply,&recvOffset,&messageType);
  465. UA_CreateSessionResponse createSessionResponse;
  466. UA_CreateSessionResponse_decodeBinary(&reply,&recvOffset,&createSessionResponse);
  467.  
  468. sendActivateSession(sock, secureChannelId, openSecChannelRsp.securityToken.tokenId, seqNumber, reqNumber,
  469. createSessionResponse.authenticationToken);
  470. received = recv(sock, reply.data, reply.length, 0);
  471. seqNumber++;
  472. reqNumber++;
  473.  
  474. UA_NodeId *nodesToRead;
  475. UA_Array_new((void**)&nodesToRead,nodesToReadSize,&UA_TYPES[UA_NODEID]);
  476.  
  477. for(UA_UInt32 i = 0; i<nodesToReadSize; i++) {
  478. if(alwaysSameNode)
  479. nodesToRead[i].identifier.numeric = 2253; //ask always the same node
  480. else
  481. nodesToRead[i].identifier.numeric = 19000 +i;
  482. nodesToRead[i].identifierType = UA_NODEIDTYPE_NUMERIC;
  483. nodesToRead[i].namespaceIndex = 0;
  484. }
  485.  
  486. UA_DateTime tic, toc;
  487. UA_Double *timeDiffs;
  488.  
  489. UA_Array_new((void**)&timeDiffs,tries,&UA_TYPES[UA_DOUBLE]);
  490. UA_Double sum = 0;
  491.  
  492. for(UA_UInt32 i = 0; i < tries; i++) {
  493. seqNumber = 54+i;
  494. reqNumber = 4 + i;
  495. tic = sendReadRequest(sock, secureChannelId, openSecChannelRsp.securityToken.tokenId, seqNumber, reqNumber,
  496. createSessionResponse.authenticationToken,nodesToReadSize,nodesToRead);
  497. received = recv(sock, reply.data, 2000, 0);
  498. toc = UA_DateTime_now() - tic;
  499. timeDiffs[i] = (UA_Double)toc/(UA_Double)1e4;
  500. sum = sum + timeDiffs[i];
  501. }
  502.  
  503.  
  504.  
  505. UA_Double mean = sum / tries;
  506. printf("mean time for handling request: %16.10f ms \n",mean);
  507.  
  508. if(received>0)
  509. printf("%i",received); // dummy
  510.  
  511. //save to file
  512. char data[100];
  513. const char flag = 'a';
  514. FILE* fHandle = fopen(argv[3], &flag);
  515. //header
  516.  
  517. UA_Int32 bytesToWrite = sprintf(data, "measurement %s in ms, nodesToRead %d \n", argv[3], nodesToReadSize);
  518. fwrite(data,1,bytesToWrite,fHandle);
  519. for(UA_UInt32 i=0;i<tries;i++) {
  520. bytesToWrite = sprintf(data,"%16.10f \n",timeDiffs[i]);
  521. fwrite(data,1,bytesToWrite,fHandle);
  522. }
  523. fclose(fHandle);
  524. UA_Array_delete(nodesToRead,nodesToReadSize,&UA_TYPES[UA_NODEID]);
  525. UA_free(timeDiffs);
  526.  
  527.  
  528. UA_NodeId parentNodeId;
  529. parentNodeId.identifier.numeric = 84;
  530. parentNodeId.namespaceIndex = 0;
  531. parentNodeId.identifierType = UA_NODEIDTYPE_NUMERIC;
  532.  
  533. UA_NodeId nodes;
  534. nodes.identifier.numeric = 555;
  535. nodes.namespaceIndex = 0;
  536. nodes.identifierType = UA_NODEIDTYPE_NUMERIC;
  537.  
  538. UA_NodeId referenceTypeId;
  539. referenceTypeId.identifier.numeric = 35;
  540. referenceTypeId.namespaceIndex = 0;
  541. referenceTypeId.identifierType = UA_NODEIDTYPE_NUMERIC;
  542.  
  543. sendAddNodes(sock,secureChannelId, openSecChannelRsp.securityToken.tokenId, 54, 4,
  544. createSessionResponse.authenticationToken,parentNodeId, referenceTypeId,&nodes,1);
  545.  
  546.  
  547.  
  548.  
  549. UA_OpenSecureChannelResponse_deleteMembers(&openSecChannelRsp);
  550. UA_String_delete(endpointUrl);
  551. UA_String_deleteMembers(&reply);
  552.  
  553. UA_CreateSessionResponse_deleteMembers(&createSessionResponse);
  554.  
  555. close(sock);
  556.  
  557. return 0;
  558. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!