ua_services_call.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258
  1. /* This Source Code Form is subject to the terms of the Mozilla Public
  2. * License, v. 2.0. If a copy of the MPL was not distributed with this
  3. * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
  4. #include "ua_services.h"
  5. #include "ua_server_internal.h"
  6. #ifdef UA_ENABLE_METHODCALLS /* conditional compilation */
  7. static const UA_VariableNode *
  8. getArgumentsVariableNode(UA_Server *server, const UA_MethodNode *ofMethod,
  9. UA_String withBrowseName) {
  10. UA_NodeId hasProperty = UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY);
  11. for(size_t i = 0; i < ofMethod->referencesSize; ++i) {
  12. UA_NodeReferenceKind *rk = &ofMethod->references[i];
  13. if(rk->isInverse != false)
  14. continue;
  15. if(!UA_NodeId_equal(&hasProperty, &rk->referenceTypeId))
  16. continue;
  17. for(size_t j = 0; j < rk->targetIdsSize; ++j) {
  18. const UA_Node *refTarget =
  19. server->config.nodestore.getNode(server->config.nodestore.context,
  20. &rk->targetIds[j].nodeId);
  21. if(!refTarget)
  22. continue;
  23. if(refTarget->nodeClass == UA_NODECLASS_VARIABLE &&
  24. refTarget->browseName.namespaceIndex == 0 &&
  25. UA_String_equal(&withBrowseName, &refTarget->browseName.name)) {
  26. return (const UA_VariableNode*)refTarget;
  27. }
  28. server->config.nodestore.releaseNode(server->config.nodestore.context,
  29. refTarget);
  30. }
  31. }
  32. return NULL;
  33. }
  34. static UA_StatusCode
  35. typeCheckArguments(UA_Server *server, const UA_VariableNode *argRequirements,
  36. size_t argsSize, UA_Variant *args) {
  37. /* Verify that we have a Variant containing UA_Argument (scalar or array) in
  38. * the "InputArguments" node */
  39. if(argRequirements->valueSource != UA_VALUESOURCE_DATA)
  40. return UA_STATUSCODE_BADINTERNALERROR;
  41. if(!argRequirements->value.data.value.hasValue)
  42. return UA_STATUSCODE_BADINTERNALERROR;
  43. if(argRequirements->value.data.value.value.type != &UA_TYPES[UA_TYPES_ARGUMENT])
  44. return UA_STATUSCODE_BADINTERNALERROR;
  45. /* Verify the number of arguments. A scalar argument value is interpreted as
  46. * an array of length 1. */
  47. size_t argReqsSize = argRequirements->value.data.value.value.arrayLength;
  48. if(UA_Variant_isScalar(&argRequirements->value.data.value.value))
  49. argReqsSize = 1;
  50. if(argReqsSize > argsSize)
  51. return UA_STATUSCODE_BADARGUMENTSMISSING;
  52. if(argReqsSize < argsSize)
  53. return UA_STATUSCODE_BADTOOMANYARGUMENTS;
  54. /* Type-check every argument against the definition */
  55. UA_Argument *argReqs = (UA_Argument*)argRequirements->value.data.value.value.data;
  56. for(size_t i = 0; i < argReqsSize; ++i) {
  57. if(!compatibleValue(server, &argReqs[i].dataType, argReqs[i].valueRank,
  58. argReqs[i].arrayDimensionsSize, argReqs[i].arrayDimensions,
  59. &args[i], NULL))
  60. return UA_STATUSCODE_BADTYPEMISMATCH;
  61. }
  62. return UA_STATUSCODE_GOOD;
  63. }
  64. static UA_StatusCode
  65. validMethodArguments(UA_Server *server, const UA_MethodNode *method,
  66. const UA_CallMethodRequest *request) {
  67. /* Get the input arguments node */
  68. const UA_VariableNode *inputArguments =
  69. getArgumentsVariableNode(server, method, UA_STRING("InputArguments"));
  70. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  71. if(!inputArguments) {
  72. if(request->inputArgumentsSize > 0)
  73. retval = UA_STATUSCODE_BADINVALIDARGUMENT;
  74. return retval;
  75. }
  76. /* Verify the request */
  77. retval = typeCheckArguments(server, inputArguments,
  78. request->inputArgumentsSize,
  79. request->inputArguments);
  80. /* Release the input arguments node */
  81. server->config.nodestore.releaseNode(server->config.nodestore.context,
  82. (const UA_Node*)inputArguments);
  83. return retval;
  84. }
  85. static const UA_NodeId hasComponentNodeId = {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_HASCOMPONENT}};
  86. static const UA_NodeId hasSubTypeNodeId = {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_HASSUBTYPE}};
  87. static void
  88. callWithMethodAndObject(UA_Server *server, UA_Session *session,
  89. const UA_CallMethodRequest *request, UA_CallMethodResult *result,
  90. const UA_MethodNode *method, const UA_ObjectNode *object) {
  91. /* Verify the object's NodeClass */
  92. if(object->nodeClass != UA_NODECLASS_OBJECT &&
  93. object->nodeClass != UA_NODECLASS_OBJECTTYPE) {
  94. result->statusCode = UA_STATUSCODE_BADNODECLASSINVALID;
  95. return;
  96. }
  97. /* Verify the method's NodeClass */
  98. if(method->nodeClass != UA_NODECLASS_METHOD) {
  99. result->statusCode = UA_STATUSCODE_BADNODECLASSINVALID;
  100. return;
  101. }
  102. /* Is there a method to execute? */
  103. if(!method->method) {
  104. result->statusCode = UA_STATUSCODE_BADINTERNALERROR;
  105. return;
  106. }
  107. /* Verify method/object relations. Object must have a hasComponent or a
  108. * subtype of hasComponent reference to the method node. Therefore, check
  109. * every reference between the parent object and the method node if there is
  110. * a hasComponent (or subtype) reference */
  111. UA_Boolean found = false;
  112. for(size_t i = 0; i < object->referencesSize && !found; ++i) {
  113. UA_NodeReferenceKind *rk = &object->references[i];
  114. if(rk->isInverse)
  115. continue;
  116. if(!isNodeInTree(&server->config.nodestore, &rk->referenceTypeId,
  117. &hasComponentNodeId, &hasSubTypeNodeId, 1))
  118. continue;
  119. for(size_t j = 0; j < rk->targetIdsSize; ++j) {
  120. if(UA_NodeId_equal(&rk->targetIds[j].nodeId, &request->methodId)) {
  121. found = true;
  122. break;
  123. }
  124. }
  125. }
  126. if(!found) {
  127. result->statusCode = UA_STATUSCODE_BADMETHODINVALID;
  128. return;
  129. }
  130. /* Verify access rights */
  131. UA_Boolean executable = method->executable;
  132. if(session != &adminSession)
  133. executable = executable &&
  134. server->config.accessControl.getUserExecutableOnObject(&session->sessionId,
  135. session->sessionHandle, &request->methodId, method->context,
  136. &request->objectId, object->context);
  137. if(!executable) {
  138. result->statusCode = UA_STATUSCODE_BADNOTWRITABLE; // There is no NOTEXECUTABLE?
  139. return;
  140. }
  141. /* Verify Input Arguments */
  142. result->statusCode = validMethodArguments(server, method, request);
  143. if(result->statusCode != UA_STATUSCODE_GOOD)
  144. return;
  145. /* Get the output arguments node */
  146. const UA_VariableNode *outputArguments =
  147. getArgumentsVariableNode(server, method, UA_STRING("OutputArguments"));
  148. /* Allocate the output arguments array */
  149. if(outputArguments) {
  150. if(outputArguments->value.data.value.value.arrayLength > 0) {
  151. result->outputArguments = (UA_Variant*)
  152. UA_Array_new(outputArguments->value.data.value.value.arrayLength,
  153. &UA_TYPES[UA_TYPES_VARIANT]);
  154. if(!result->outputArguments) {
  155. result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
  156. return;
  157. }
  158. result->outputArgumentsSize = outputArguments->value.data.value.value.arrayLength;
  159. }
  160. /* Release the output arguments node */
  161. server->config.nodestore.releaseNode(server->config.nodestore.context,
  162. (const UA_Node*)outputArguments);
  163. }
  164. /* Call the method */
  165. result->statusCode = method->method(server, &session->sessionId, session->sessionHandle,
  166. &method->nodeId, (void*)(uintptr_t)method->context,
  167. &object->nodeId, (void*)(uintptr_t)&object->context,
  168. request->inputArgumentsSize, request->inputArguments,
  169. result->outputArgumentsSize, result->outputArguments);
  170. /* TODO: Verify Output matches the argument definition */
  171. }
  172. static void
  173. Operation_CallMethod(UA_Server *server, UA_Session *session,
  174. const UA_CallMethodRequest *request,
  175. UA_CallMethodResult *result) {
  176. /* Get the method node */
  177. const UA_MethodNode *method = (const UA_MethodNode*)
  178. server->config.nodestore.getNode(server->config.nodestore.context,
  179. &request->methodId);
  180. if(!method) {
  181. result->statusCode = UA_STATUSCODE_BADMETHODINVALID;
  182. return;
  183. }
  184. /* Get the object node */
  185. const UA_ObjectNode *object = (const UA_ObjectNode*)
  186. server->config.nodestore.getNode(server->config.nodestore.context,
  187. &request->objectId);
  188. if(!object) {
  189. result->statusCode = UA_STATUSCODE_BADNODEIDINVALID;
  190. server->config.nodestore.releaseNode(server->config.nodestore.context,
  191. (const UA_Node*)method);
  192. return;
  193. }
  194. /* Continue with method and object as context */
  195. callWithMethodAndObject(server, session, request, result, method, object);
  196. /* Release the method and object node */
  197. server->config.nodestore.releaseNode(server->config.nodestore.context,
  198. (const UA_Node*)method);
  199. server->config.nodestore.releaseNode(server->config.nodestore.context,
  200. (const UA_Node*)object);
  201. }
  202. void Service_Call(UA_Server *server, UA_Session *session,
  203. const UA_CallRequest *request,
  204. UA_CallResponse *response) {
  205. UA_LOG_DEBUG_SESSION(server->config.logger, session,
  206. "Processing CallRequest");
  207. if(server->config.maxNodesPerMethodCall != 0 &&
  208. request->methodsToCallSize > server->config.maxNodesPerMethodCall) {
  209. response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS;
  210. return;
  211. }
  212. response->responseHeader.serviceResult =
  213. UA_Server_processServiceOperations(server, session,
  214. (UA_ServiceOperation)Operation_CallMethod,
  215. &request->methodsToCallSize, &UA_TYPES[UA_TYPES_CALLMETHODREQUEST],
  216. &response->resultsSize, &UA_TYPES[UA_TYPES_CALLMETHODRESULT]);
  217. }
  218. UA_CallMethodResult UA_EXPORT
  219. UA_Server_call(UA_Server *server, const UA_CallMethodRequest *request) {
  220. UA_CallMethodResult result;
  221. UA_CallMethodResult_init(&result);
  222. Operation_CallMethod(server, &adminSession, request, &result);
  223. return result;
  224. }
  225. #endif /* UA_ENABLE_METHODCALLS */