ua_server_binary.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464
  1. #include "ua_util.h"
  2. #include "ua_server_internal.h"
  3. #include "ua_types_encoding_binary.h"
  4. #include "ua_transport_generated.h"
  5. #include "ua_services.h"
  6. #include "ua_statuscodes.h"
  7. #include "ua_securechannel_manager.h"
  8. #include "ua_session_manager.h"
  9. #include "ua_nodeids.h"
  10. /** Max size of messages that are allocated on the stack */
  11. #define MAX_STACK_MESSAGE 65536
  12. static UA_StatusCode UA_ByteStringArray_deleteMembers(UA_ByteStringArray *stringarray) {
  13. if(!stringarray)
  14. return UA_STATUSCODE_BADINTERNALERROR;
  15. for(UA_UInt32 i = 0; i < stringarray->stringsSize; i++)
  16. UA_String_deleteMembers(&stringarray->strings[i]);
  17. return UA_STATUSCODE_GOOD;
  18. }
  19. static void processHEL(UA_Connection *connection, const UA_ByteString *msg, size_t *pos) {
  20. UA_TcpHelloMessage helloMessage;
  21. if(UA_TcpHelloMessage_decodeBinary(msg, pos, &helloMessage) != UA_STATUSCODE_GOOD) {
  22. connection->close(connection);
  23. return;
  24. }
  25. connection->remoteConf.maxChunkCount = helloMessage.maxChunkCount;
  26. connection->remoteConf.maxMessageSize = helloMessage.maxMessageSize;
  27. connection->remoteConf.protocolVersion = helloMessage.protocolVersion;
  28. connection->remoteConf.recvBufferSize = helloMessage.receiveBufferSize;
  29. connection->remoteConf.sendBufferSize = helloMessage.sendBufferSize;
  30. connection->state = UA_CONNECTION_ESTABLISHED;
  31. // build acknowledge response
  32. UA_TcpAcknowledgeMessage ackMessage;
  33. ackMessage.protocolVersion = connection->localConf.protocolVersion;
  34. ackMessage.receiveBufferSize = connection->localConf.recvBufferSize;
  35. ackMessage.sendBufferSize = connection->localConf.sendBufferSize;
  36. ackMessage.maxMessageSize = connection->localConf.maxMessageSize;
  37. ackMessage.maxChunkCount = connection->localConf.maxChunkCount;
  38. UA_TcpMessageHeader ackHeader;
  39. ackHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_ACKF;
  40. ackHeader.messageSize = UA_TcpAcknowledgeMessage_calcSizeBinary(&ackMessage) +
  41. UA_TcpMessageHeader_calcSizeBinary(&ackHeader);
  42. // The message is on the stack. That's ok since ack is very small.
  43. UA_ByteString ack_msg = (UA_ByteString){ .length = ackHeader.messageSize,
  44. .data = UA_alloca(ackHeader.messageSize) };
  45. size_t tmpPos = 0;
  46. UA_TcpMessageHeader_encodeBinary(&ackHeader, &ack_msg, &tmpPos);
  47. UA_TcpAcknowledgeMessage_encodeBinary(&ackMessage, &ack_msg, &tmpPos);
  48. UA_ByteStringArray answer_buf = { .stringsSize = 1, .strings = &ack_msg };
  49. connection->write(connection, answer_buf);
  50. UA_TcpHelloMessage_deleteMembers(&helloMessage);
  51. }
  52. static void processOPN(UA_Connection *connection, UA_Server *server, const UA_ByteString *msg,
  53. size_t *pos) {
  54. if(connection->state != UA_CONNECTION_ESTABLISHED) {
  55. connection->close(connection);
  56. return;
  57. }
  58. UA_UInt32 secureChannelId;
  59. UA_StatusCode retval = UA_UInt32_decodeBinary(msg, pos, &secureChannelId);
  60. UA_AsymmetricAlgorithmSecurityHeader asymHeader;
  61. retval |= UA_AsymmetricAlgorithmSecurityHeader_decodeBinary(msg, pos, &asymHeader);
  62. UA_SequenceHeader seqHeader;
  63. retval |= UA_SequenceHeader_decodeBinary(msg, pos, &seqHeader);
  64. UA_NodeId requestType;
  65. retval |= UA_NodeId_decodeBinary(msg, pos, &requestType);
  66. UA_OpenSecureChannelRequest r;
  67. retval |= UA_OpenSecureChannelRequest_decodeBinary(msg, pos, &r);
  68. if(retval != UA_STATUSCODE_GOOD || requestType.identifier.numeric != 446) {
  69. UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
  70. UA_SequenceHeader_deleteMembers(&seqHeader);
  71. UA_NodeId_deleteMembers(&requestType);
  72. UA_OpenSecureChannelRequest_deleteMembers(&r);
  73. connection->close(connection);
  74. return;
  75. }
  76. UA_OpenSecureChannelResponse p;
  77. UA_OpenSecureChannelResponse_init(&p);
  78. Service_OpenSecureChannel(server, connection, &r, &p);
  79. UA_SecureConversationMessageHeader respHeader;
  80. respHeader.messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_OPNF;
  81. respHeader.messageHeader.messageSize = 0;
  82. respHeader.secureChannelId = p.securityToken.channelId;
  83. UA_NodeId responseType = UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELRESPONSE +
  84. UA_ENCODINGOFFSET_BINARY);
  85. respHeader.messageHeader.messageSize =
  86. UA_SecureConversationMessageHeader_calcSizeBinary(&respHeader)
  87. + UA_AsymmetricAlgorithmSecurityHeader_calcSizeBinary(&asymHeader)
  88. + UA_SequenceHeader_calcSizeBinary(&seqHeader)
  89. + UA_NodeId_calcSizeBinary(&responseType)
  90. + UA_OpenSecureChannelResponse_calcSizeBinary(&p);
  91. UA_ByteString resp_msg = (UA_ByteString){
  92. .length = respHeader.messageHeader.messageSize,
  93. .data = UA_alloca(respHeader.messageHeader.messageSize)
  94. };
  95. size_t tmpPos = 0;
  96. UA_SecureConversationMessageHeader_encodeBinary(&respHeader, &resp_msg, &tmpPos);
  97. UA_AsymmetricAlgorithmSecurityHeader_encodeBinary(&asymHeader, &resp_msg, &tmpPos); // just mirror back
  98. UA_SequenceHeader_encodeBinary(&seqHeader, &resp_msg, &tmpPos); // just mirror back
  99. UA_NodeId_encodeBinary(&responseType, &resp_msg, &tmpPos);
  100. UA_OpenSecureChannelResponse_encodeBinary(&p, &resp_msg, &tmpPos);
  101. UA_OpenSecureChannelRequest_deleteMembers(&r);
  102. UA_OpenSecureChannelResponse_deleteMembers(&p);
  103. UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
  104. connection->write(connection, (UA_ByteStringArray){ .stringsSize = 1, .strings = &resp_msg });
  105. }
  106. static void init_response_header(const UA_RequestHeader *p, UA_ResponseHeader *r) {
  107. r->requestHandle = p->requestHandle;
  108. r->serviceResult = UA_STATUSCODE_GOOD;
  109. r->stringTableSize = 0;
  110. r->timestamp = UA_DateTime_now();
  111. }
  112. // if the message is small enough, we allocate it on the stack and save a malloc
  113. #define ALLOC_MESSAGE(MESSAGE, SIZE) do { \
  114. UA_UInt32 messageSize = SIZE; \
  115. if(messageSize <= MAX_STACK_MESSAGE) { \
  116. messageOnStack = UA_TRUE; \
  117. *MESSAGE = (UA_ByteString){.length = messageSize, \
  118. .data = UA_alloca(messageSize)}; \
  119. } else \
  120. UA_ByteString_newMembers(MESSAGE, messageSize); \
  121. } while(0)
  122. #define INVOKE_SERVICE(TYPE) do { \
  123. UA_##TYPE##Request p; \
  124. UA_##TYPE##Response r; \
  125. if(UA_##TYPE##Request_decodeBinary(msg, pos, &p)) \
  126. return; \
  127. UA_##TYPE##Response_init(&r); \
  128. init_response_header(&p.requestHeader, &r.responseHeader); \
  129. Service_##TYPE(server, clientSession, &p, &r); \
  130. ALLOC_MESSAGE(message, UA_##TYPE##Response_calcSizeBinary(&r)); \
  131. UA_##TYPE##Response_encodeBinary(&r, message, &sendOffset); \
  132. UA_##TYPE##Request_deleteMembers(&p); \
  133. UA_##TYPE##Response_deleteMembers(&r); \
  134. responseType = requestType.identifier.numeric + 3; \
  135. } while(0)
  136. static void processMSG(UA_Connection *connection, UA_Server *server, const UA_ByteString *msg, size_t *pos) {
  137. // 1) Read in the securechannel
  138. UA_UInt32 secureChannelId;
  139. UA_StatusCode retval = UA_UInt32_decodeBinary(msg, pos, &secureChannelId);
  140. if(retval != UA_STATUSCODE_GOOD)
  141. return;
  142. UA_SecureChannel *clientChannel = connection->channel;
  143. UA_SecureChannel anonymousChannel;
  144. if(!clientChannel) {
  145. UA_SecureChannel_init(&anonymousChannel);
  146. clientChannel = &anonymousChannel;
  147. }
  148. UA_Session *clientSession = clientChannel->session;
  149. #ifdef EXTENSION_STATELESS
  150. if(secureChannelId == 0)
  151. clientSession = &anonymousSession;
  152. #endif
  153. // 2) Read the security header
  154. UA_UInt32 tokenId;
  155. UA_SequenceHeader sequenceHeader;
  156. retval = UA_UInt32_decodeBinary(msg, pos, &tokenId);
  157. retval |= UA_SequenceHeader_decodeBinary(msg, pos, &sequenceHeader);
  158. if(retval != UA_STATUSCODE_GOOD)
  159. return;
  160. //UA_SecureChannel_checkSequenceNumber(channel,sequenceHeader.sequenceNumber);
  161. //UA_SecureChannel_checkRequestId(channel,sequenceHeader.requestId);
  162. clientChannel->sequenceNumber = sequenceHeader.sequenceNumber;
  163. clientChannel->requestId = sequenceHeader.requestId;
  164. // 3) Read the nodeid of the request
  165. UA_NodeId requestType;
  166. if(UA_NodeId_decodeBinary(msg, pos, &requestType))
  167. return;
  168. if(requestType.identifierType != UA_NODEIDTYPE_NUMERIC) {
  169. // That must not happen. The requestType does not have to be deleted at the end.
  170. UA_NodeId_deleteMembers(&requestType);
  171. return;
  172. }
  173. // 4) process the request
  174. UA_ByteString responseBufs[2]; // 0->header, 1->response payload
  175. UA_UInt32 responseType;
  176. UA_ByteString *header = &responseBufs[0];
  177. UA_ByteString *message = &responseBufs[1];
  178. UA_Boolean messageOnStack = UA_FALSE;
  179. size_t sendOffset = 0;
  180. #ifdef EXTENSION_STATELESS
  181. switch(requestType.identifier.numeric - UA_ENCODINGOFFSET_BINARY) {
  182. case UA_NS0ID_READREQUEST:
  183. case UA_NS0ID_WRITEREQUEST:
  184. case UA_NS0ID_BROWSEREQUEST:
  185. break;
  186. default:
  187. if(clientSession != &anonymousSession)
  188. retval = UA_STATUSCODE_BADNOTCONNECTED;
  189. }
  190. #endif
  191. //subtract UA_ENCODINGOFFSET_BINARY for binary encoding, if retval is set, this forces the default path
  192. switch(requestType.identifier.numeric - UA_ENCODINGOFFSET_BINARY + retval) {
  193. case UA_NS0ID_GETENDPOINTSREQUEST: {
  194. UA_GetEndpointsRequest p;
  195. UA_GetEndpointsResponse r;
  196. if(UA_GetEndpointsRequest_decodeBinary(msg, pos, &p))
  197. return;
  198. UA_GetEndpointsResponse_init(&r);
  199. init_response_header(&p.requestHeader, &r.responseHeader);
  200. Service_GetEndpoints(server, &p, &r);
  201. ALLOC_MESSAGE(message, UA_GetEndpointsResponse_calcSizeBinary(&r));
  202. UA_GetEndpointsResponse_encodeBinary(&r, message, &sendOffset);
  203. UA_GetEndpointsRequest_deleteMembers(&p);
  204. UA_GetEndpointsResponse_deleteMembers(&r);
  205. responseType = requestType.identifier.numeric + 3;
  206. break;
  207. }
  208. case UA_NS0ID_FINDSERVERSREQUEST: {
  209. UA_FindServersRequest p;
  210. UA_FindServersResponse r;
  211. if(UA_FindServersRequest_decodeBinary(msg, pos, &p))
  212. return;
  213. UA_FindServersResponse_init(&r);
  214. init_response_header(&p.requestHeader, &r.responseHeader);
  215. Service_FindServers(server, &p, &r);
  216. ALLOC_MESSAGE(message, UA_FindServersResponse_calcSizeBinary(&r));
  217. UA_FindServersResponse_encodeBinary(&r, message, &sendOffset);
  218. UA_FindServersRequest_deleteMembers(&p);
  219. UA_FindServersResponse_deleteMembers(&r);
  220. responseType = requestType.identifier.numeric + 3;
  221. break;
  222. }
  223. case UA_NS0ID_CREATESESSIONREQUEST: {
  224. UA_CreateSessionRequest p;
  225. UA_CreateSessionResponse r;
  226. if(UA_CreateSessionRequest_decodeBinary(msg, pos, &p))
  227. return;
  228. UA_CreateSessionResponse_init(&r);
  229. init_response_header(&p.requestHeader, &r.responseHeader);
  230. Service_CreateSession(server, clientChannel, &p, &r);
  231. ALLOC_MESSAGE(message, UA_CreateSessionResponse_calcSizeBinary(&r));
  232. UA_CreateSessionResponse_encodeBinary(&r, message, &sendOffset);
  233. UA_CreateSessionRequest_deleteMembers(&p);
  234. UA_CreateSessionResponse_deleteMembers(&r);
  235. responseType = requestType.identifier.numeric + 3;
  236. break;
  237. }
  238. case UA_NS0ID_ACTIVATESESSIONREQUEST: {
  239. UA_ActivateSessionRequest p;
  240. UA_ActivateSessionResponse r;
  241. if(UA_ActivateSessionRequest_decodeBinary(msg, pos, &p))
  242. return;
  243. UA_ActivateSessionResponse_init(&r);
  244. init_response_header(&p.requestHeader, &r.responseHeader);
  245. Service_ActivateSession(server, clientChannel, &p, &r);
  246. ALLOC_MESSAGE(message, UA_ActivateSessionResponse_calcSizeBinary(&r));
  247. UA_ActivateSessionResponse_encodeBinary(&r, message, &sendOffset);
  248. UA_ActivateSessionRequest_deleteMembers(&p);
  249. UA_ActivateSessionResponse_deleteMembers(&r);
  250. responseType = requestType.identifier.numeric + 3;
  251. break;
  252. }
  253. case UA_NS0ID_CLOSESESSIONREQUEST: {
  254. UA_CloseSessionRequest p;
  255. UA_CloseSessionResponse r;
  256. if(UA_CloseSessionRequest_decodeBinary(msg, pos, &p))
  257. return;
  258. UA_CloseSessionResponse_init(&r);
  259. init_response_header(&p.requestHeader, &r.responseHeader);
  260. Service_CloseSession(server, &p, &r);
  261. ALLOC_MESSAGE(message, UA_CloseSessionResponse_calcSizeBinary(&r));
  262. UA_CloseSessionResponse_encodeBinary(&r, message, &sendOffset);
  263. UA_CloseSessionRequest_deleteMembers(&p);
  264. UA_CloseSessionResponse_deleteMembers(&r);
  265. responseType = requestType.identifier.numeric + 3;
  266. break;
  267. }
  268. case UA_NS0ID_READREQUEST:
  269. INVOKE_SERVICE(Read);
  270. break;
  271. case UA_NS0ID_WRITEREQUEST:
  272. INVOKE_SERVICE(Write);
  273. break;
  274. case UA_NS0ID_BROWSEREQUEST:
  275. INVOKE_SERVICE(Browse);
  276. break;
  277. case UA_NS0ID_ADDREFERENCESREQUEST:
  278. INVOKE_SERVICE(AddReferences);
  279. break;
  280. case UA_NS0ID_REGISTERNODESREQUEST:
  281. INVOKE_SERVICE(RegisterNodes);
  282. break;
  283. case UA_NS0ID_UNREGISTERNODESREQUEST:
  284. INVOKE_SERVICE(UnregisterNodes);
  285. break;
  286. case UA_NS0ID_TRANSLATEBROWSEPATHSTONODEIDSREQUEST:
  287. INVOKE_SERVICE(TranslateBrowsePathsToNodeIds);
  288. break;
  289. default: {
  290. UA_LOG_INFO(server->logger, UA_LOGGERCATEGORY_COMMUNICATION, "Unknown request: NodeId(ns=%d, i=%d)",
  291. requestType.namespaceIndex, requestType.identifier.numeric);
  292. UA_RequestHeader p;
  293. UA_ResponseHeader r;
  294. if(UA_RequestHeader_decodeBinary(msg, pos, &p))
  295. return;
  296. UA_ResponseHeader_init(&r);
  297. init_response_header(&p, &r);
  298. r.serviceResult = UA_STATUSCODE_BADSERVICEUNSUPPORTED;
  299. #ifdef EXTENSION_STATELESS
  300. if(retval != UA_STATUSCODE_GOOD)
  301. r.serviceResult = retval;
  302. #endif
  303. ALLOC_MESSAGE(message, UA_ResponseHeader_calcSizeBinary(&r));
  304. UA_ResponseHeader_encodeBinary(&r, message, &sendOffset);
  305. UA_RequestHeader_deleteMembers(&p);
  306. UA_ResponseHeader_deleteMembers(&r);
  307. responseType = UA_NS0ID_RESPONSEHEADER + UA_ENCODINGOFFSET_BINARY;
  308. break;
  309. }
  310. }
  311. // 5) Build the header
  312. UA_SecureConversationMessageHeader respHeader;
  313. respHeader.messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_MSGF;
  314. respHeader.messageHeader.messageSize = 0;
  315. respHeader.secureChannelId = clientChannel->securityToken.channelId;
  316. UA_SymmetricAlgorithmSecurityHeader symSecHeader;
  317. symSecHeader.tokenId = clientChannel->securityToken.tokenId;
  318. UA_SequenceHeader seqHeader;
  319. seqHeader.sequenceNumber = clientChannel->sequenceNumber;
  320. seqHeader.requestId = clientChannel->requestId;
  321. UA_NodeId response_nodeid = { .namespaceIndex = 0, .identifierType = UA_NODEIDTYPE_NUMERIC,
  322. .identifier.numeric = responseType };
  323. UA_UInt32 headerSize =
  324. UA_SecureConversationMessageHeader_calcSizeBinary(&respHeader)
  325. + UA_SymmetricAlgorithmSecurityHeader_calcSizeBinary(&symSecHeader)
  326. + UA_SequenceHeader_calcSizeBinary(&seqHeader)
  327. + UA_NodeId_calcSizeBinary(&response_nodeid);
  328. *header = (UA_ByteString){ .length = headerSize, .data = UA_alloca(headerSize) };
  329. respHeader.messageHeader.messageSize = header->length + message->length;
  330. size_t rpos = 0;
  331. UA_SecureConversationMessageHeader_encodeBinary(&respHeader, header, &rpos);
  332. UA_SymmetricAlgorithmSecurityHeader_encodeBinary(&symSecHeader, header, &rpos);
  333. UA_SequenceHeader_encodeBinary(&seqHeader, header, &rpos);
  334. UA_NodeId_encodeBinary(&response_nodeid, header, &rpos);
  335. // todo: sign & encrypt
  336. // 6) Send it over the wire.
  337. UA_ByteStringArray responseBufArray;
  338. responseBufArray.strings = responseBufs;
  339. responseBufArray.stringsSize = 2;
  340. connection->write(connection, responseBufArray);
  341. if(!messageOnStack)
  342. UA_free(message->data);
  343. }
  344. static void processCLO(UA_Connection *connection, UA_Server *server, const UA_ByteString *msg,
  345. size_t *pos) {
  346. UA_UInt32 secureChannelId;
  347. UA_StatusCode retval = UA_UInt32_decodeBinary(msg, pos, &secureChannelId);
  348. if(retval != UA_STATUSCODE_GOOD || !connection->channel ||
  349. connection->channel->securityToken.channelId != secureChannelId)
  350. return;
  351. Service_CloseSecureChannel(server, secureChannelId);
  352. }
  353. void UA_Server_processBinaryMessage(UA_Server *server, UA_Connection *connection, UA_ByteString *msg) {
  354. *msg = UA_Connection_completeMessages(connection, *msg);
  355. if(msg->length <= 0)
  356. return;
  357. size_t pos = 0;
  358. UA_TcpMessageHeader tcpMessageHeader;
  359. do {
  360. if(UA_TcpMessageHeader_decodeBinary(msg, &pos, &tcpMessageHeader) != UA_STATUSCODE_GOOD) {
  361. UA_LOG_INFO(server->logger, UA_LOGGERCATEGORY_COMMUNICATION, "Decoding of message header failed");
  362. connection->close(connection);
  363. break;
  364. }
  365. if(tcpMessageHeader.messageSize < 32)
  366. break; // there is no usefull message of that size
  367. size_t targetpos = pos - 8 + tcpMessageHeader.messageSize;
  368. switch(tcpMessageHeader.messageTypeAndFinal & 0xffffff) {
  369. case UA_MESSAGETYPEANDFINAL_HELF & 0xffffff:
  370. processHEL(connection, msg, &pos);
  371. break;
  372. case UA_MESSAGETYPEANDFINAL_OPNF & 0xffffff:
  373. processOPN(connection, server, msg, &pos);
  374. break;
  375. case UA_MESSAGETYPEANDFINAL_MSGF & 0xffffff:
  376. #ifdef EXTENSION_STATELESS
  377. processMSG(connection, server, msg, &pos);
  378. break;
  379. #endif
  380. if(connection->state != UA_CONNECTION_ESTABLISHED) {
  381. connection->close(connection);
  382. break;
  383. }
  384. processMSG(connection, server, msg, &pos);
  385. break;
  386. case UA_MESSAGETYPEANDFINAL_CLOF & 0xffffff:
  387. processCLO(connection, server, msg, &pos);
  388. connection->close(connection);
  389. return;
  390. }
  391. UA_TcpMessageHeader_deleteMembers(&tcpMessageHeader);
  392. if(pos != targetpos) {
  393. UA_LOG_INFO(server->logger, UA_LOGGERCATEGORY_COMMUNICATION,
  394. "The message was not entirely processed, skipping to the end");
  395. pos = targetpos;
  396. }
  397. } while(msg->length > (UA_Int32)pos);
  398. }