ua_server_binary.c 30 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704
  1. #include "ua_util.h"
  2. #include "ua_server_internal.h"
  3. #include "ua_services.h"
  4. #include "ua_securechannel_manager.h"
  5. #include "ua_session_manager.h"
  6. #include "ua_types_generated_encoding_binary.h"
  7. #include "ua_transport_generated.h"
  8. #include "ua_transport_generated_handling.h"
  9. #include "ua_transport_generated_encoding_binary.h"
  10. /********************/
  11. /* Helper Functions */
  12. /********************/
  13. static void init_response_header(const UA_RequestHeader *p, UA_ResponseHeader *r) {
  14. r->requestHandle = p->requestHandle;
  15. r->timestamp = UA_DateTime_now();
  16. }
  17. static void
  18. sendError(UA_SecureChannel *channel, const UA_ByteString *msg, size_t offset, const UA_DataType *responseType,
  19. UA_UInt32 requestId, UA_StatusCode error) {
  20. UA_RequestHeader requestHeader;
  21. UA_StatusCode retval = UA_RequestHeader_decodeBinary(msg, &offset, &requestHeader);
  22. if(retval != UA_STATUSCODE_GOOD)
  23. return;
  24. void *response = UA_alloca(responseType->memSize);
  25. UA_init(response, responseType);
  26. UA_ResponseHeader *responseHeader = (UA_ResponseHeader*)response;
  27. init_response_header(&requestHeader, responseHeader);
  28. responseHeader->serviceResult = error;
  29. UA_SecureChannel_sendBinaryMessage(channel, requestId, response, responseType);
  30. UA_RequestHeader_deleteMembers(&requestHeader);
  31. UA_ResponseHeader_deleteMembers(responseHeader);
  32. }
  33. /* Returns a complete decoded request (without securechannel headers + padding)
  34. or UA_BYTESTRING_NULL */
  35. static UA_ByteString processChunk(UA_SecureChannel *channel, UA_Server *server,
  36. const UA_TcpMessageHeader *messageHeader, UA_UInt32 requestId,
  37. const UA_ByteString *msg, size_t offset, size_t chunksize,
  38. UA_Boolean *deleteRequest) {
  39. UA_ByteString bytes = UA_BYTESTRING_NULL;
  40. switch(messageHeader->messageTypeAndChunkType & 0xff000000) {
  41. case UA_CHUNKTYPE_INTERMEDIATE:
  42. UA_LOG_TRACE_CHANNEL(server->config.logger, channel, "Chunk message");
  43. UA_SecureChannel_appendChunk(channel, requestId, msg, offset, chunksize);
  44. break;
  45. case UA_CHUNKTYPE_FINAL:
  46. UA_LOG_TRACE_CHANNEL(server->config.logger, channel, "Final chunk message");
  47. bytes = UA_SecureChannel_finalizeChunk(channel, requestId, msg, offset, chunksize, deleteRequest);
  48. break;
  49. case UA_CHUNKTYPE_ABORT:
  50. UA_LOG_INFO_CHANNEL(server->config.logger, channel, "Chunk aborted");
  51. UA_SecureChannel_removeChunk(channel, requestId);
  52. break;
  53. default:
  54. UA_LOG_INFO_CHANNEL(server->config.logger, channel, "Unknown chunk type");
  55. }
  56. return bytes;
  57. }
  58. static void
  59. getServicePointers(UA_UInt32 requestTypeId, const UA_DataType **requestType,
  60. const UA_DataType **responseType, UA_Service *service,
  61. UA_Boolean *requiresSession) {
  62. switch(requestTypeId - UA_ENCODINGOFFSET_BINARY) {
  63. case UA_NS0ID_GETENDPOINTSREQUEST:
  64. *service = (UA_Service)Service_GetEndpoints;
  65. *requestType = &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST];
  66. *responseType = &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE];
  67. *requiresSession = false;
  68. break;
  69. case UA_NS0ID_FINDSERVERSREQUEST:
  70. *service = (UA_Service)Service_FindServers;
  71. *requestType = &UA_TYPES[UA_TYPES_FINDSERVERSREQUEST];
  72. *responseType = &UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE];
  73. *requiresSession = false;
  74. break;
  75. case UA_NS0ID_CREATESESSIONREQUEST:
  76. *service = (UA_Service)Service_CreateSession;
  77. *requestType = &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST];
  78. *responseType = &UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE];
  79. *requiresSession = false;
  80. break;
  81. case UA_NS0ID_ACTIVATESESSIONREQUEST:
  82. *service = (UA_Service)Service_ActivateSession;
  83. *requestType = &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST];
  84. *responseType = &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE];
  85. break;
  86. case UA_NS0ID_CLOSESESSIONREQUEST:
  87. *service = (UA_Service)Service_CloseSession;
  88. *requestType = &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST];
  89. *responseType = &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE];
  90. break;
  91. case UA_NS0ID_READREQUEST:
  92. *service = (UA_Service)Service_Read;
  93. *requestType = &UA_TYPES[UA_TYPES_READREQUEST];
  94. *responseType = &UA_TYPES[UA_TYPES_READRESPONSE];
  95. break;
  96. case UA_NS0ID_WRITEREQUEST:
  97. *service = (UA_Service)Service_Write;
  98. *requestType = &UA_TYPES[UA_TYPES_WRITEREQUEST];
  99. *responseType = &UA_TYPES[UA_TYPES_WRITERESPONSE];
  100. break;
  101. case UA_NS0ID_BROWSEREQUEST:
  102. *service = (UA_Service)Service_Browse;
  103. *requestType = &UA_TYPES[UA_TYPES_BROWSEREQUEST];
  104. *responseType = &UA_TYPES[UA_TYPES_BROWSERESPONSE];
  105. break;
  106. case UA_NS0ID_BROWSENEXTREQUEST:
  107. *service = (UA_Service)Service_BrowseNext;
  108. *requestType = &UA_TYPES[UA_TYPES_BROWSENEXTREQUEST];
  109. *responseType = &UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE];
  110. break;
  111. case UA_NS0ID_REGISTERNODESREQUEST:
  112. *service = (UA_Service)Service_RegisterNodes;
  113. *requestType = &UA_TYPES[UA_TYPES_REGISTERNODESREQUEST];
  114. *responseType = &UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE];
  115. break;
  116. case UA_NS0ID_UNREGISTERNODESREQUEST:
  117. *service = (UA_Service)Service_UnregisterNodes;
  118. *requestType = &UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST];
  119. *responseType = &UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE];
  120. break;
  121. case UA_NS0ID_TRANSLATEBROWSEPATHSTONODEIDSREQUEST:
  122. *service = (UA_Service)Service_TranslateBrowsePathsToNodeIds;
  123. *requestType = &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST];
  124. *responseType = &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE];
  125. break;
  126. #ifdef UA_ENABLE_SUBSCRIPTIONS
  127. case UA_NS0ID_CREATESUBSCRIPTIONREQUEST:
  128. *service = (UA_Service)Service_CreateSubscription;
  129. *requestType = &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST];
  130. *responseType = &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE];
  131. break;
  132. case UA_NS0ID_PUBLISHREQUEST:
  133. *requestType = &UA_TYPES[UA_TYPES_PUBLISHREQUEST];
  134. *responseType = &UA_TYPES[UA_TYPES_PUBLISHRESPONSE];
  135. break;
  136. case UA_NS0ID_REPUBLISHREQUEST:
  137. *service = (UA_Service)Service_Republish;
  138. *requestType = &UA_TYPES[UA_TYPES_REPUBLISHREQUEST];
  139. *responseType = &UA_TYPES[UA_TYPES_REPUBLISHRESPONSE];
  140. break;
  141. case UA_NS0ID_MODIFYSUBSCRIPTIONREQUEST:
  142. *service = (UA_Service)Service_ModifySubscription;
  143. *requestType = &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST];
  144. *responseType = &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE];
  145. break;
  146. case UA_NS0ID_SETPUBLISHINGMODEREQUEST:
  147. *service = (UA_Service)Service_SetPublishingMode;
  148. *requestType = &UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST];
  149. *responseType = &UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE];
  150. break;
  151. case UA_NS0ID_DELETESUBSCRIPTIONSREQUEST:
  152. *service = (UA_Service)Service_DeleteSubscriptions;
  153. *requestType = &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST];
  154. *responseType = &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE];
  155. break;
  156. case UA_NS0ID_CREATEMONITOREDITEMSREQUEST:
  157. *service = (UA_Service)Service_CreateMonitoredItems;
  158. *requestType = &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST];
  159. *responseType = &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE];
  160. break;
  161. case UA_NS0ID_DELETEMONITOREDITEMSREQUEST:
  162. *service = (UA_Service)Service_DeleteMonitoredItems;
  163. *requestType = &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST];
  164. *responseType = &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE];
  165. break;
  166. case UA_NS0ID_MODIFYMONITOREDITEMSREQUEST:
  167. *service = (UA_Service)Service_ModifyMonitoredItems;
  168. *requestType = &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST];
  169. *responseType = &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE];
  170. break;
  171. case UA_NS0ID_SETMONITORINGMODEREQUEST:
  172. *service = (UA_Service)Service_SetMonitoringMode;
  173. *requestType = &UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST];
  174. *responseType = &UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE];
  175. break;
  176. #endif
  177. #ifdef UA_ENABLE_METHODCALLS
  178. case UA_NS0ID_CALLREQUEST:
  179. *service = (UA_Service)Service_Call;
  180. *requestType = &UA_TYPES[UA_TYPES_CALLREQUEST];
  181. *responseType = &UA_TYPES[UA_TYPES_CALLRESPONSE];
  182. break;
  183. #endif
  184. #ifdef UA_ENABLE_NODEMANAGEMENT
  185. case UA_NS0ID_ADDNODESREQUEST:
  186. *service = (UA_Service)Service_AddNodes;
  187. *requestType = &UA_TYPES[UA_TYPES_ADDNODESREQUEST];
  188. *responseType = &UA_TYPES[UA_TYPES_ADDNODESRESPONSE];
  189. break;
  190. case UA_NS0ID_ADDREFERENCESREQUEST:
  191. *service = (UA_Service)Service_AddReferences;
  192. *requestType = &UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST];
  193. *responseType = &UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE];
  194. break;
  195. case UA_NS0ID_DELETENODESREQUEST:
  196. *service = (UA_Service)Service_DeleteNodes;
  197. *requestType = &UA_TYPES[UA_TYPES_DELETENODESREQUEST];
  198. *responseType = &UA_TYPES[UA_TYPES_DELETENODESRESPONSE];
  199. break;
  200. case UA_NS0ID_DELETEREFERENCESREQUEST:
  201. *service = (UA_Service)Service_DeleteReferences;
  202. *requestType = &UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST];
  203. *responseType = &UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE];
  204. break;
  205. #endif
  206. default:
  207. break;
  208. }
  209. }
  210. /*************************/
  211. /* Process Message Types */
  212. /*************************/
  213. /* HEL -> Open up the connection */
  214. static void processHEL(UA_Connection *connection, const UA_ByteString *msg, size_t *offset) {
  215. UA_TcpHelloMessage helloMessage;
  216. if(UA_TcpHelloMessage_decodeBinary(msg, offset, &helloMessage) != UA_STATUSCODE_GOOD) {
  217. connection->close(connection);
  218. return;
  219. }
  220. connection->remoteConf.maxChunkCount = helloMessage.maxChunkCount; /* may be zero -> unlimited */
  221. connection->remoteConf.maxMessageSize = helloMessage.maxMessageSize; /* may be zero -> unlimited */
  222. connection->remoteConf.protocolVersion = helloMessage.protocolVersion;
  223. connection->remoteConf.recvBufferSize = helloMessage.receiveBufferSize;
  224. if(connection->localConf.sendBufferSize > helloMessage.receiveBufferSize)
  225. connection->localConf.sendBufferSize = helloMessage.receiveBufferSize;
  226. connection->remoteConf.sendBufferSize = helloMessage.sendBufferSize;
  227. if(connection->localConf.recvBufferSize > helloMessage.sendBufferSize)
  228. connection->localConf.recvBufferSize = helloMessage.sendBufferSize;
  229. connection->state = UA_CONNECTION_ESTABLISHED;
  230. UA_TcpHelloMessage_deleteMembers(&helloMessage);
  231. /* Build acknowledge response */
  232. UA_TcpAcknowledgeMessage ackMessage;
  233. ackMessage.protocolVersion = connection->localConf.protocolVersion;
  234. ackMessage.receiveBufferSize = connection->localConf.recvBufferSize;
  235. ackMessage.sendBufferSize = connection->localConf.sendBufferSize;
  236. ackMessage.maxMessageSize = connection->localConf.maxMessageSize;
  237. ackMessage.maxChunkCount = connection->localConf.maxChunkCount;
  238. UA_TcpMessageHeader ackHeader;
  239. ackHeader.messageTypeAndChunkType = UA_MESSAGETYPE_ACK + UA_CHUNKTYPE_FINAL;
  240. ackHeader.messageSize = 8 + 20; /* ackHeader + ackMessage */
  241. UA_ByteString ack_msg;
  242. UA_ByteString_init(&ack_msg);
  243. if(connection->getSendBuffer(connection, connection->localConf.sendBufferSize, &ack_msg) != UA_STATUSCODE_GOOD)
  244. return;
  245. size_t tmpPos = 0;
  246. UA_TcpMessageHeader_encodeBinary(&ackHeader, &ack_msg, &tmpPos);
  247. UA_TcpAcknowledgeMessage_encodeBinary(&ackMessage, &ack_msg, &tmpPos);
  248. ack_msg.length = ackHeader.messageSize;
  249. connection->send(connection, &ack_msg);
  250. }
  251. /* OPN -> Open up/renew the securechannel */
  252. static void processOPN(UA_Connection *connection, UA_Server *server, const UA_ByteString *msg, size_t *offset) {
  253. if(connection->state != UA_CONNECTION_ESTABLISHED) {
  254. connection->close(connection);
  255. return;
  256. }
  257. UA_UInt32 channelId;
  258. UA_StatusCode retval = UA_UInt32_decodeBinary(msg, offset, &channelId);
  259. /* Opening up a channel with a channelid already set */
  260. if(!connection->channel && channelId != 0)
  261. retval |= UA_STATUSCODE_BADREQUESTTYPEINVALID;
  262. /* Renew a channel with the wrong channelid */
  263. if(connection->channel && channelId != connection->channel->securityToken.channelId)
  264. retval |= UA_STATUSCODE_BADREQUESTTYPEINVALID;
  265. UA_AsymmetricAlgorithmSecurityHeader asymHeader;
  266. retval |= UA_AsymmetricAlgorithmSecurityHeader_decodeBinary(msg, offset, &asymHeader);
  267. UA_SequenceHeader seqHeader;
  268. retval |= UA_SequenceHeader_decodeBinary(msg, offset, &seqHeader);
  269. UA_NodeId requestType;
  270. retval |= UA_NodeId_decodeBinary(msg, offset, &requestType);
  271. UA_OpenSecureChannelRequest r;
  272. retval |= UA_OpenSecureChannelRequest_decodeBinary(msg, offset, &r);
  273. if(retval != UA_STATUSCODE_GOOD || requestType.identifier.numeric != 446) {
  274. UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
  275. UA_NodeId_deleteMembers(&requestType);
  276. UA_OpenSecureChannelRequest_deleteMembers(&r);
  277. connection->close(connection);
  278. return;
  279. }
  280. UA_OpenSecureChannelResponse p;
  281. UA_OpenSecureChannelResponse_init(&p);
  282. Service_OpenSecureChannel(server, connection, &r, &p);
  283. UA_OpenSecureChannelRequest_deleteMembers(&r);
  284. UA_SecureChannel *channel = connection->channel;
  285. /* Opening the channel failed */
  286. if(!channel) {
  287. UA_OpenSecureChannelResponse_deleteMembers(&p);
  288. UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
  289. connection->close(connection);
  290. return;
  291. }
  292. /* Set the starting sequence number */
  293. channel->receiveSequenceNumber = seqHeader.sequenceNumber;
  294. /* Allocate the return message */
  295. UA_ByteString resp_msg;
  296. UA_ByteString_init(&resp_msg);
  297. retval = connection->getSendBuffer(connection, connection->localConf.sendBufferSize, &resp_msg);
  298. if(retval != UA_STATUSCODE_GOOD) {
  299. UA_OpenSecureChannelResponse_deleteMembers(&p);
  300. UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
  301. connection->close(connection);
  302. return;
  303. }
  304. /* Encode the message after the secureconversationmessageheader */
  305. size_t tmpPos = 12; /* skip the header */
  306. #ifndef UA_ENABLE_MULTITHREADING
  307. seqHeader.sequenceNumber = ++channel->sendSequenceNumber;
  308. #else
  309. seqHeader.sequenceNumber = uatomic_add_return(&channel->sendSequenceNumber, 1);
  310. #endif
  311. retval |= UA_AsymmetricAlgorithmSecurityHeader_encodeBinary(&asymHeader, &resp_msg, &tmpPos); // just mirror back
  312. retval |= UA_SequenceHeader_encodeBinary(&seqHeader, &resp_msg, &tmpPos);
  313. UA_NodeId responseType = UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELRESPONSE + UA_ENCODINGOFFSET_BINARY);
  314. retval |= UA_NodeId_encodeBinary(&responseType, &resp_msg, &tmpPos);
  315. retval |= UA_OpenSecureChannelResponse_encodeBinary(&p, &resp_msg, &tmpPos);
  316. if(retval != UA_STATUSCODE_GOOD) {
  317. connection->releaseSendBuffer(connection, &resp_msg);
  318. UA_OpenSecureChannelResponse_deleteMembers(&p);
  319. UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
  320. connection->close(connection);
  321. return;
  322. }
  323. /* Encode the secureconversationmessageheader */
  324. UA_SecureConversationMessageHeader respHeader;
  325. respHeader.messageHeader.messageTypeAndChunkType = UA_MESSAGETYPE_OPN + UA_CHUNKTYPE_FINAL;
  326. respHeader.messageHeader.messageSize = (UA_UInt32)tmpPos;
  327. respHeader.secureChannelId = p.securityToken.channelId;
  328. tmpPos = 0;
  329. UA_SecureConversationMessageHeader_encodeBinary(&respHeader, &resp_msg, &tmpPos);
  330. resp_msg.length = respHeader.messageHeader.messageSize;
  331. connection->send(connection, &resp_msg);
  332. /* Clean up */
  333. UA_OpenSecureChannelResponse_deleteMembers(&p);
  334. UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
  335. }
  336. static void
  337. processRequest(UA_SecureChannel *channel, UA_Server *server,
  338. UA_UInt32 requestId, const UA_ByteString *msg) {
  339. /* At 0, the nodeid starts... */
  340. size_t ppos = 0;
  341. size_t *offset = &ppos;
  342. /* Decode the nodeid */
  343. UA_NodeId requestTypeId;
  344. UA_StatusCode retval = UA_NodeId_decodeBinary(msg, offset, &requestTypeId);
  345. if(retval != UA_STATUSCODE_GOOD)
  346. return;
  347. /* Store the start-position of the request */
  348. size_t requestPos = *offset;
  349. /* Test if the service type nodeid has the right format */
  350. if(requestTypeId.identifierType != UA_NODEIDTYPE_NUMERIC ||
  351. requestTypeId.namespaceIndex != 0) {
  352. UA_NodeId_deleteMembers(&requestTypeId);
  353. UA_LOG_DEBUG_CHANNEL(server->config.logger, channel,
  354. "Received a non-numeric message type NodeId");
  355. sendError(channel, msg, requestPos, &UA_TYPES[UA_TYPES_SERVICEFAULT],
  356. requestId, UA_STATUSCODE_BADSERVICEUNSUPPORTED);
  357. }
  358. /* Get the service pointers */
  359. UA_Service service = NULL;
  360. const UA_DataType *requestType = NULL;
  361. const UA_DataType *responseType = NULL;
  362. UA_Boolean sessionRequired = true;
  363. getServicePointers(requestTypeId.identifier.numeric, &requestType,
  364. &responseType, &service, &sessionRequired);
  365. if(!requestType) {
  366. if(requestTypeId.identifier.numeric == 787) {
  367. UA_LOG_INFO_CHANNEL(server->config.logger, channel,
  368. "Client requested a subscription, " \
  369. "but those are not enabled in the build");
  370. } else {
  371. UA_LOG_INFO_CHANNEL(server->config.logger, channel, "Unknown request %i",
  372. requestTypeId.identifier.numeric - UA_ENCODINGOFFSET_BINARY);
  373. }
  374. sendError(channel, msg, requestPos, &UA_TYPES[UA_TYPES_SERVICEFAULT],
  375. requestId, UA_STATUSCODE_BADSERVICEUNSUPPORTED);
  376. return;
  377. }
  378. UA_assert(responseType);
  379. #ifdef UA_ENABLE_NONSTANDARD_STATELESS
  380. /* Stateless extension: Sessions are optional */
  381. sessionRequired = false;
  382. #endif
  383. /* Decode the request */
  384. void *request = UA_alloca(requestType->memSize);
  385. UA_RequestHeader *requestHeader = (UA_RequestHeader*)request;
  386. retval = UA_decodeBinary(msg, offset, request, requestType);
  387. if(retval != UA_STATUSCODE_GOOD) {
  388. UA_LOG_DEBUG_CHANNEL(server->config.logger, channel, "Could not decode the request");
  389. sendError(channel, msg, requestPos, responseType, requestId, retval);
  390. return;
  391. }
  392. /* Prepare the respone */
  393. void *response = UA_alloca(responseType->memSize);
  394. UA_init(response, responseType);
  395. UA_Session *session = NULL; /* must be initialized before goto send_response */
  396. /* CreateSession doesn't need a session */
  397. if(requestType == &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]) {
  398. Service_CreateSession(server, channel, request, response);
  399. goto send_response;
  400. }
  401. /* Find the matching session */
  402. session = UA_SecureChannel_getSession(channel, &requestHeader->authenticationToken);
  403. if(!session)
  404. session = UA_SessionManager_getSession(&server->sessionManager,
  405. &requestHeader->authenticationToken);
  406. if(requestType == &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]) {
  407. if(!session) {
  408. UA_LOG_DEBUG_CHANNEL(server->config.logger, channel,
  409. "Trying to activate a session that is " \
  410. "not known in the server");
  411. sendError(channel, msg, requestPos, responseType,
  412. requestId, UA_STATUSCODE_BADSESSIONIDINVALID);
  413. UA_deleteMembers(request, requestType);
  414. return;
  415. }
  416. Service_ActivateSession(server, channel, session, request, response);
  417. goto send_response;
  418. }
  419. /* Set an anonymous, inactive session for services that need no session */
  420. UA_Session anonymousSession;
  421. if(!session) {
  422. if(sessionRequired) {
  423. UA_LOG_INFO_CHANNEL(server->config.logger, channel,
  424. "Service request %i without a valid session",
  425. requestTypeId.identifier.numeric - UA_ENCODINGOFFSET_BINARY);
  426. sendError(channel, msg, requestPos, responseType,
  427. requestId, UA_STATUSCODE_BADSESSIONIDINVALID);
  428. UA_deleteMembers(request, requestType);
  429. return;
  430. }
  431. UA_Session_init(&anonymousSession);
  432. anonymousSession.sessionId = UA_NODEID_GUID(0, UA_GUID_NULL);
  433. anonymousSession.channel = channel;
  434. session = &anonymousSession;
  435. }
  436. /* Trying to use a non-activated session? */
  437. if(sessionRequired && !session->activated) {
  438. UA_LOG_INFO_SESSION(server->config.logger, session,
  439. "Calling service %i on a non-activated session",
  440. requestTypeId.identifier.numeric - UA_ENCODINGOFFSET_BINARY);
  441. sendError(channel, msg, requestPos, responseType,
  442. requestId, UA_STATUSCODE_BADSESSIONNOTACTIVATED);
  443. UA_SessionManager_removeSession(&server->sessionManager,
  444. &session->authenticationToken);
  445. UA_deleteMembers(request, requestType);
  446. return;
  447. }
  448. /* The session is bound to another channel */
  449. if(session->channel != channel) {
  450. UA_LOG_DEBUG_CHANNEL(server->config.logger, channel,
  451. "Client tries to use an obsolete securechannel");
  452. sendError(channel, msg, requestPos, responseType,
  453. requestId, UA_STATUSCODE_BADSECURECHANNELIDINVALID);
  454. UA_deleteMembers(request, requestType);
  455. return;
  456. }
  457. /* Update the session lifetime */
  458. UA_Session_updateLifetime(session);
  459. #ifdef UA_ENABLE_SUBSCRIPTIONS
  460. /* The publish request is not answered immediately */
  461. if(requestType == &UA_TYPES[UA_TYPES_PUBLISHREQUEST]) {
  462. Service_Publish(server, session, request, requestId);
  463. UA_deleteMembers(request, requestType);
  464. return;
  465. }
  466. #endif
  467. /* Call the service */
  468. service(server, session, request, response);
  469. send_response:
  470. /* Send the response */
  471. init_response_header(request, response);
  472. retval = UA_SecureChannel_sendBinaryMessage(channel, requestId, response, responseType);
  473. if(retval != UA_STATUSCODE_GOOD)
  474. UA_LOG_INFO_CHANNEL(server->config.logger, channel, "Could not send the message over "
  475. "the SecureChannel with error code 0x%08x", retval);
  476. /* See if we need to return publish requests without a subscription */
  477. if(session && requestType == &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST])
  478. UA_Session_answerPublishRequestsWithoutSubscription(session);
  479. /* Clean up */
  480. UA_deleteMembers(request, requestType);
  481. UA_deleteMembers(response, responseType);
  482. }
  483. /* MSG -> Normal request */
  484. static void
  485. processMSG(UA_Connection *connection, UA_Server *server, const UA_TcpMessageHeader *messageHeader,
  486. const UA_ByteString *msg, size_t *offset) {
  487. /* Decode the header */
  488. UA_UInt32 channelId = 0;
  489. UA_UInt32 tokenId = 0;
  490. UA_SequenceHeader sequenceHeader;
  491. UA_StatusCode retval = UA_UInt32_decodeBinary(msg, offset, &channelId);
  492. retval |= UA_UInt32_decodeBinary(msg, offset, &tokenId);
  493. retval |= UA_SequenceHeader_decodeBinary(msg, offset, &sequenceHeader);
  494. if(retval != UA_STATUSCODE_GOOD)
  495. return;
  496. /* Get the SecureChannel */
  497. UA_SecureChannel *channel = connection->channel;
  498. UA_SecureChannel anonymousChannel; /* use if no channel specified */
  499. if(!channel) {
  500. UA_SecureChannel_init(&anonymousChannel);
  501. anonymousChannel.connection = connection;
  502. channel = &anonymousChannel;
  503. }
  504. /* Is the channel attached to connection? */
  505. if(channelId != channel->securityToken.channelId) {
  506. UA_LOG_INFO(server->config.logger, UA_LOGCATEGORY_NETWORK,
  507. "Connection %i | Received MSG with the channel id %i not bound to the connection",
  508. connection->sockfd, channelId);
  509. Service_CloseSecureChannel(server, channel);
  510. connection->close(connection);
  511. return;
  512. }
  513. /* Does the sequence number match? */
  514. retval = UA_SecureChannel_processSequenceNumber(sequenceHeader.sequenceNumber, channel);
  515. if (retval != UA_STATUSCODE_GOOD){
  516. UA_LOG_INFO_CHANNEL(server->config.logger, channel,
  517. "The sequence number was not increased by one. Got %i, expected %i",
  518. sequenceHeader.sequenceNumber, channel->receiveSequenceNumber + 1);
  519. sendError(channel, msg, *offset, &UA_TYPES[UA_TYPES_SERVICEFAULT],
  520. sequenceHeader.requestId, UA_STATUSCODE_BADSECURITYCHECKSFAILED);
  521. Service_CloseSecureChannel(server, channel);
  522. connection->close(connection);
  523. return;
  524. }
  525. /* Does the token match? */
  526. if(tokenId != channel->securityToken.tokenId) {
  527. if(tokenId != channel->nextSecurityToken.tokenId) {
  528. UA_LOG_INFO_CHANNEL(server->config.logger, channel,
  529. "Request with a wrong security token. Closing the SecureChannel.");
  530. Service_CloseSecureChannel(server, channel);
  531. connection->close(connection);
  532. return;
  533. }
  534. UA_SecureChannel_revolveTokens(channel);
  535. }
  536. /* Process chunk to get complete request */
  537. UA_Boolean deleteRequest = false;
  538. UA_ByteString request = processChunk(channel, server, messageHeader, sequenceHeader.requestId,
  539. msg, *offset, messageHeader->messageSize - 24, &deleteRequest);
  540. *offset += (messageHeader->messageSize - 24);
  541. if(request.length > 0) {
  542. /* Process the request */
  543. processRequest(channel, server, sequenceHeader.requestId, &request);
  544. if(deleteRequest)
  545. UA_ByteString_deleteMembers(&request);
  546. }
  547. /* Clean up a possible anonymous channel */
  548. if(channel == &anonymousChannel)
  549. UA_SecureChannel_deleteMembersCleanup(channel);
  550. }
  551. /* CLO -> Close the secure channel */
  552. static void
  553. processCLO(UA_Connection *connection, UA_Server *server, const UA_ByteString *msg, size_t *offset) {
  554. UA_UInt32 channelId;
  555. UA_UInt32 tokenId = 0;
  556. UA_SequenceHeader sequenceHeader;
  557. UA_StatusCode retval = UA_UInt32_decodeBinary(msg, offset, &channelId);
  558. retval |= UA_UInt32_decodeBinary(msg, offset, &tokenId);
  559. retval |= UA_SequenceHeader_decodeBinary(msg, offset, &sequenceHeader);
  560. if(retval != UA_STATUSCODE_GOOD)
  561. return;
  562. UA_SecureChannel *channel = connection->channel;
  563. if(!channel || channel->securityToken.channelId != channelId ||
  564. channel->securityToken.tokenId != tokenId)
  565. return;
  566. if(sequenceHeader.sequenceNumber != channel->receiveSequenceNumber + 1)
  567. return;
  568. Service_CloseSecureChannel(server, connection->channel);
  569. }
  570. /* Process binary message received from Connection dose not modify UA_ByteString
  571. * you have to free it youself. use of connection->getSendBuffer() and
  572. * connection->send() to answer Message */
  573. void UA_Server_processBinaryMessage(UA_Server *server, UA_Connection *connection, const UA_ByteString *msg) {
  574. size_t offset= 0;
  575. UA_TcpMessageHeader tcpMessageHeader;
  576. do {
  577. /* Decode the message header */
  578. UA_StatusCode retval = UA_TcpMessageHeader_decodeBinary(msg, &offset, &tcpMessageHeader);
  579. if(retval != UA_STATUSCODE_GOOD) {
  580. UA_LOG_INFO(server->config.logger, UA_LOGCATEGORY_NETWORK,
  581. "Decoding of message header failed on Connection %i", connection->sockfd);
  582. connection->close(connection);
  583. break;
  584. }
  585. if(tcpMessageHeader.messageSize < 16) {
  586. UA_LOG_INFO(server->config.logger, UA_LOGCATEGORY_NETWORK,
  587. "The message is suspiciously small on Connection %i", connection->sockfd);
  588. connection->close(connection);
  589. break;
  590. }
  591. /* Set the expected position after processing the chunk */
  592. size_t targetpos = offset - 8 + tcpMessageHeader.messageSize;
  593. /* Process the message */
  594. switch(tcpMessageHeader.messageTypeAndChunkType & 0x00ffffff) {
  595. case UA_MESSAGETYPE_HEL:
  596. UA_LOG_TRACE(server->config.logger, UA_LOGCATEGORY_NETWORK, "Connection %i | Process a HEL", connection->sockfd);
  597. processHEL(connection, msg, &offset);
  598. break;
  599. case UA_MESSAGETYPE_OPN:
  600. UA_LOG_TRACE(server->config.logger, UA_LOGCATEGORY_NETWORK, "Connection %i | Process a OPN", connection->sockfd);
  601. processOPN(connection, server, msg, &offset);
  602. break;
  603. case UA_MESSAGETYPE_MSG:
  604. #ifndef UA_ENABLE_NONSTANDARD_STATELESS
  605. if(connection->state != UA_CONNECTION_ESTABLISHED) {
  606. UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_NETWORK,
  607. "Connection %i | Received a MSG, but the connection is not established", connection->sockfd);
  608. connection->close(connection);
  609. return;
  610. }
  611. #endif
  612. UA_LOG_TRACE(server->config.logger, UA_LOGCATEGORY_NETWORK, "Connection %i | Process a MSG", connection->sockfd);
  613. processMSG(connection, server, &tcpMessageHeader, msg, &offset);
  614. break;
  615. case UA_MESSAGETYPE_CLO:
  616. UA_LOG_TRACE(server->config.logger, UA_LOGCATEGORY_NETWORK, "Connection %i | Process a CLO", connection->sockfd);
  617. processCLO(connection, server, msg, &offset);
  618. return;
  619. default:
  620. UA_LOG_TRACE(server->config.logger, UA_LOGCATEGORY_NETWORK, "Connection %i | Unknown chunk type", connection->sockfd);
  621. }
  622. /* Loop to process the next message in the stream */
  623. if(offset != targetpos) {
  624. UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_NETWORK, "Connection %i | Message was not entirely processed. "
  625. "Skip from position %i to position %i; message length is %i", connection->sockfd, offset, targetpos,
  626. msg->length);
  627. offset = targetpos;
  628. }
  629. } while(msg->length > offset);
  630. }