ua_server_binary.c 27 KB

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