ua_services_call.c 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225
  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. UA_NodeStore_get(server->nodestore, &rk->targetIds[j].nodeId);
  20. if(!refTarget)
  21. continue;
  22. if(refTarget->nodeClass == UA_NODECLASS_VARIABLE &&
  23. refTarget->browseName.namespaceIndex == 0 &&
  24. UA_String_equal(&withBrowseName, &refTarget->browseName.name)) {
  25. return (const UA_VariableNode*) refTarget;
  26. }
  27. }
  28. }
  29. return NULL;
  30. }
  31. static UA_StatusCode
  32. argumentsConformsToDefinition(UA_Server *server, const UA_VariableNode *argRequirements,
  33. size_t argsSize, UA_Variant *args) {
  34. if(argRequirements->value.data.value.value.type != &UA_TYPES[UA_TYPES_ARGUMENT])
  35. return UA_STATUSCODE_BADINTERNALERROR;
  36. UA_Argument *argReqs = (UA_Argument*)argRequirements->value.data.value.value.data;
  37. size_t argReqsSize = argRequirements->value.data.value.value.arrayLength;
  38. if(argRequirements->valueSource != UA_VALUESOURCE_DATA)
  39. return UA_STATUSCODE_BADINTERNALERROR;
  40. if(UA_Variant_isScalar(&argRequirements->value.data.value.value))
  41. argReqsSize = 1;
  42. if(argReqsSize > argsSize)
  43. return UA_STATUSCODE_BADARGUMENTSMISSING;
  44. if(argReqsSize != argsSize)
  45. return UA_STATUSCODE_BADINVALIDARGUMENT;
  46. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  47. for(size_t i = 0; i < argReqsSize; ++i)
  48. retval |= typeCheckValue(server, &argReqs[i].dataType, argReqs[i].valueRank,
  49. argReqs[i].arrayDimensionsSize, argReqs[i].arrayDimensions,
  50. &args[i], NULL, &args[i]);
  51. return retval;
  52. }
  53. void
  54. Service_Call_single(UA_Server *server, UA_Session *session,
  55. const UA_CallMethodRequest *request,
  56. UA_CallMethodResult *result) {
  57. /* Get/verify the method node */
  58. const UA_MethodNode *methodCalled =
  59. (const UA_MethodNode*)UA_NodeStore_get(server->nodestore, &request->methodId);
  60. if(!methodCalled) {
  61. result->statusCode = UA_STATUSCODE_BADMETHODINVALID;
  62. return;
  63. }
  64. if(methodCalled->nodeClass != UA_NODECLASS_METHOD) {
  65. result->statusCode = UA_STATUSCODE_BADNODECLASSINVALID;
  66. return;
  67. }
  68. if(!methodCalled->attachedMethod) {
  69. result->statusCode = UA_STATUSCODE_BADINTERNALERROR;
  70. return;
  71. }
  72. /* Get/verify the object node */
  73. const UA_ObjectNode *object =
  74. (const UA_ObjectNode*)UA_NodeStore_get(server->nodestore, &request->objectId);
  75. if(!object) {
  76. result->statusCode = UA_STATUSCODE_BADNODEIDINVALID;
  77. return;
  78. }
  79. if(object->nodeClass != UA_NODECLASS_OBJECT && object->nodeClass != UA_NODECLASS_OBJECTTYPE) {
  80. result->statusCode = UA_STATUSCODE_BADNODECLASSINVALID;
  81. return;
  82. }
  83. /* Verify access rights */
  84. UA_Boolean executable = methodCalled->executable;
  85. if(session != &adminSession)
  86. executable = executable &&
  87. server->config.accessControl.getUserExecutableOnObject(&session->sessionId, session->sessionHandle,
  88. &request->objectId, &request->methodId);
  89. if(!executable) {
  90. result->statusCode = UA_STATUSCODE_BADNOTWRITABLE; // There is no NOTEXECUTABLE?
  91. return;
  92. }
  93. /* Verify method/object relations. Object must have a hasComponent or a
  94. * subtype of hasComponent reference to the method node. Therefore, check
  95. * every reference between the parent object and the method node if there is
  96. * a hasComponent (or subtype) reference */
  97. UA_Boolean found = false;
  98. UA_NodeId hasComponentNodeId = UA_NODEID_NUMERIC(0,UA_NS0ID_HASCOMPONENT);
  99. UA_NodeId hasSubTypeNodeId = UA_NODEID_NUMERIC(0,UA_NS0ID_HASSUBTYPE);
  100. for(size_t i = 0; i < object->referencesSize; ++i) {
  101. UA_NodeReferenceKind *rk = &object->references[i];
  102. if(rk->isInverse)
  103. continue;
  104. if(!isNodeInTree(server->nodestore, &rk->referenceTypeId,
  105. &hasComponentNodeId, &hasSubTypeNodeId, 1))
  106. continue;
  107. for(size_t j = 0; j < rk->targetIdsSize; ++j) {
  108. if(UA_NodeId_equal(&rk->targetIds[j].nodeId, &request->methodId)) {
  109. found = true;
  110. break;
  111. }
  112. }
  113. }
  114. if(!found) {
  115. result->statusCode = UA_STATUSCODE_BADMETHODINVALID;
  116. return;
  117. }
  118. /* Verify Input Argument count, types and sizes */
  119. const UA_VariableNode *inputArguments =
  120. getArgumentsVariableNode(server, methodCalled, UA_STRING("InputArguments"));
  121. if(!inputArguments) {
  122. if(request->inputArgumentsSize > 0) {
  123. result->statusCode = UA_STATUSCODE_BADINVALIDARGUMENT;
  124. return;
  125. }
  126. } else {
  127. result->statusCode = argumentsConformsToDefinition(server, inputArguments,
  128. request->inputArgumentsSize,
  129. request->inputArguments);
  130. if(result->statusCode != UA_STATUSCODE_GOOD)
  131. return;
  132. }
  133. /* Allocate the output arguments */
  134. result->outputArgumentsSize = 0; /* the default */
  135. const UA_VariableNode *outputArguments =
  136. getArgumentsVariableNode(server, methodCalled, UA_STRING("OutputArguments"));
  137. if(outputArguments) {
  138. result->outputArguments =
  139. (UA_Variant*)UA_Array_new(outputArguments->value.data.value.value.arrayLength,
  140. &UA_TYPES[UA_TYPES_VARIANT]);
  141. if(!result->outputArguments) {
  142. result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
  143. return;
  144. }
  145. result->outputArgumentsSize = outputArguments->value.data.value.value.arrayLength;
  146. }
  147. /* Call the method */
  148. #if defined(UA_ENABLE_METHODCALLS) && defined(UA_ENABLE_SUBSCRIPTIONS)
  149. methodCallSession = session;
  150. #endif
  151. result->statusCode = methodCalled->attachedMethod(methodCalled->methodHandle, &object->nodeId,
  152. &session->sessionId, session->sessionHandle,
  153. request->inputArgumentsSize, request->inputArguments,
  154. result->outputArgumentsSize, result->outputArguments);
  155. #if defined(UA_ENABLE_METHODCALLS) && defined(UA_ENABLE_SUBSCRIPTIONS)
  156. methodCallSession = NULL;
  157. #endif
  158. /* TODO: Verify Output matches the argument definition */
  159. }
  160. void Service_Call(UA_Server *server, UA_Session *session,
  161. const UA_CallRequest *request,
  162. UA_CallResponse *response) {
  163. UA_LOG_DEBUG_SESSION(server->config.logger, session, "Processing CallRequest");
  164. if(request->methodsToCallSize <= 0) {
  165. response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
  166. return;
  167. }
  168. response->results = (UA_CallMethodResult*)UA_Array_new(request->methodsToCallSize,
  169. &UA_TYPES[UA_TYPES_CALLMETHODRESULT]);
  170. if(!response->results) {
  171. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  172. return;
  173. }
  174. response->resultsSize = request->methodsToCallSize;
  175. #ifdef UA_ENABLE_EXTERNAL_NAMESPACES
  176. UA_Boolean isExternal[request->methodsToCallSize];
  177. UA_UInt32 indices[request->methodsToCallSize];
  178. memset(isExternal, false, sizeof(UA_Boolean) * request->methodsToCallSize);
  179. for(size_t j = 0;j<server->externalNamespacesSize;++j) {
  180. size_t indexSize = 0;
  181. for(size_t i = 0;i < request->methodsToCallSize;++i) {
  182. if(request->methodsToCall[i].methodId.namespaceIndex != server->externalNamespaces[j].index)
  183. continue;
  184. isExternal[i] = true;
  185. indices[indexSize] = (UA_UInt32)i;
  186. ++indexSize;
  187. }
  188. if(indexSize == 0)
  189. continue;
  190. UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
  191. ens->call(ens->ensHandle, &request->requestHeader, request->methodsToCall,
  192. indices, (UA_UInt32)indexSize, response->results);
  193. }
  194. #endif
  195. for(size_t i = 0; i < request->methodsToCallSize;++i){
  196. #ifdef UA_ENABLE_EXTERNAL_NAMESPACES
  197. if(!isExternal[i])
  198. #endif
  199. Service_Call_single(server, session, &request->methodsToCall[i], &response->results[i]);
  200. }
  201. }
  202. #endif /* UA_ENABLE_METHODCALLS */