ua_services_call.c 8.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209
  1. #include "ua_services.h"
  2. #include "ua_server_internal.h"
  3. #ifdef UA_ENABLE_METHODCALLS /* conditional compilation */
  4. static const UA_VariableNode *
  5. getArgumentsVariableNode(UA_Server *server, const UA_MethodNode *ofMethod,
  6. UA_String withBrowseName) {
  7. UA_NodeId hasProperty = UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY);
  8. for(size_t i = 0; i < ofMethod->referencesSize; i++) {
  9. if(ofMethod->references[i].isInverse == false &&
  10. UA_NodeId_equal(&hasProperty, &ofMethod->references[i].referenceTypeId)) {
  11. const UA_Node *refTarget =
  12. UA_NodeStore_get(server->nodestore, &ofMethod->references[i].targetId.nodeId);
  13. if(!refTarget)
  14. continue;
  15. if(refTarget->nodeClass == UA_NODECLASS_VARIABLE &&
  16. refTarget->browseName.namespaceIndex == 0 &&
  17. UA_String_equal(&withBrowseName, &refTarget->browseName.name)) {
  18. return (const UA_VariableNode*) refTarget;
  19. }
  20. }
  21. }
  22. return NULL;
  23. }
  24. static UA_StatusCode
  25. satisfySignature(UA_Server *server, const UA_Variant *var, const UA_Argument *arg) {
  26. if(!UA_NodeId_equal(&var->type->typeId, &arg->dataType)){
  27. if(!UA_NodeId_equal(&var->type->typeId, &UA_TYPES[UA_TYPES_INT32].typeId))
  28. return UA_STATUSCODE_BADINVALIDARGUMENT;
  29. /* enumerations are encoded as int32 -> if provided var is integer, check if arg is an enumeration type */
  30. UA_NodeId enumerationNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ENUMERATION);
  31. UA_NodeId hasSubTypeNodeId = UA_NODEID_NUMERIC(0,UA_NS0ID_HASSUBTYPE);
  32. UA_Boolean found = false;
  33. UA_StatusCode retval = isNodeInTree(server->nodestore, &arg->dataType, &enumerationNodeId, &hasSubTypeNodeId, 1, 1, &found);
  34. if(retval != UA_STATUSCODE_GOOD)
  35. return UA_STATUSCODE_BADINTERNALERROR;
  36. if(!found)
  37. return UA_STATUSCODE_BADINVALIDARGUMENT;
  38. }
  39. // Note: The namespace compiler will compile nodes with their actual array dimensions
  40. // Todo: Check if this is standard conform for scalars
  41. if(arg->arrayDimensionsSize > 0 && var->arrayDimensionsSize > 0)
  42. if(var->arrayDimensionsSize != arg->arrayDimensionsSize)
  43. return UA_STATUSCODE_BADINVALIDARGUMENT;
  44. UA_Int32 *varDims = var->arrayDimensions;
  45. size_t varDimsSize = var->arrayDimensionsSize;
  46. UA_Boolean scalar = UA_Variant_isScalar(var);
  47. /* The dimension 1 is implicit in the array length */
  48. UA_Int32 fakeDims;
  49. if(!scalar && !varDims) {
  50. fakeDims = (UA_Int32)var->arrayLength;
  51. varDims = &fakeDims;
  52. varDimsSize = 1;
  53. }
  54. /* ValueRank Semantics
  55. * n >= 1: the value is an array with the specified number of dimens*ions.
  56. * n = 0: the value is an array with one or more dimensions.
  57. * n = -1: the value is a scalar.
  58. * n = -2: the value can be a scalar or an array with any number of dimensions.
  59. * n = -3: the value can be a scalar or a one dimensional array. */
  60. switch(arg->valueRank) {
  61. case -3:
  62. if(varDimsSize > 1)
  63. return UA_STATUSCODE_BADINVALIDARGUMENT;
  64. break;
  65. case -2:
  66. break;
  67. case -1:
  68. if(!scalar)
  69. return UA_STATUSCODE_BADINVALIDARGUMENT;
  70. break;
  71. case 0:
  72. if(scalar || !varDims)
  73. return UA_STATUSCODE_BADINVALIDARGUMENT;
  74. break;
  75. default:
  76. break;
  77. }
  78. /* do the array dimensions match? */
  79. if(arg->arrayDimensionsSize != varDimsSize)
  80. return UA_STATUSCODE_BADINVALIDARGUMENT;
  81. for(size_t i = 0; i < varDimsSize; i++) {
  82. if((UA_Int32)arg->arrayDimensions[i] != varDims[i])
  83. return UA_STATUSCODE_BADINVALIDARGUMENT;
  84. }
  85. return UA_STATUSCODE_GOOD;
  86. }
  87. static UA_StatusCode
  88. argConformsToDefinition(UA_Server *server, const UA_VariableNode *argRequirements, size_t argsSize, const UA_Variant *args) {
  89. if(argRequirements->value.variant.value.type != &UA_TYPES[UA_TYPES_ARGUMENT])
  90. return UA_STATUSCODE_BADINTERNALERROR;
  91. UA_Argument *argReqs = (UA_Argument*)argRequirements->value.variant.value.data;
  92. size_t argReqsSize = argRequirements->value.variant.value.arrayLength;
  93. if(argRequirements->valueSource != UA_VALUESOURCE_VARIANT)
  94. return UA_STATUSCODE_BADINTERNALERROR;
  95. if(UA_Variant_isScalar(&argRequirements->value.variant.value))
  96. argReqsSize = 1;
  97. if(argReqsSize > argsSize)
  98. return UA_STATUSCODE_BADARGUMENTSMISSING;
  99. if(argReqsSize != argsSize)
  100. return UA_STATUSCODE_BADINVALIDARGUMENT;
  101. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  102. for(size_t i = 0; i < argReqsSize; i++)
  103. retval |= satisfySignature(server, &args[i], &argReqs[i]);
  104. return retval;
  105. }
  106. void
  107. Service_Call_single(UA_Server *server, UA_Session *session, const UA_CallMethodRequest *request,
  108. UA_CallMethodResult *result) {
  109. /* Verify method/object relations. Object must have a hasComponent reference to the method node. */
  110. UA_Boolean found = false;
  111. UA_NodeId hasComponentNodeId = UA_NODEID_NUMERIC(0,UA_NS0ID_HASCOMPONENT);
  112. result->statusCode = isNodeInTree(server->nodestore, &request->methodId, &request->objectId,
  113. &hasComponentNodeId, 1, 1, &found);
  114. if(!found)
  115. result->statusCode = UA_STATUSCODE_BADMETHODINVALID;
  116. if(result->statusCode != UA_STATUSCODE_GOOD)
  117. return;
  118. /* Get/verify the method node */
  119. const UA_MethodNode *methodCalled =
  120. (const UA_MethodNode*)UA_NodeStore_get(server->nodestore, &request->methodId);
  121. if(!methodCalled) {
  122. result->statusCode = UA_STATUSCODE_BADMETHODINVALID;
  123. return;
  124. }
  125. if(methodCalled->nodeClass != UA_NODECLASS_METHOD) {
  126. result->statusCode = UA_STATUSCODE_BADNODECLASSINVALID;
  127. return;
  128. }
  129. if(!methodCalled->executable || !methodCalled->userExecutable || !methodCalled->attachedMethod) {
  130. result->statusCode = UA_STATUSCODE_BADNOTWRITABLE; // There is no NOTEXECUTABLE?
  131. return;
  132. }
  133. /* Get/verify the object node */
  134. const UA_ObjectNode *withObject =
  135. (const UA_ObjectNode*)UA_NodeStore_get(server->nodestore, &request->objectId);
  136. if(!withObject) {
  137. result->statusCode = UA_STATUSCODE_BADNODEIDINVALID;
  138. return;
  139. }
  140. if(withObject->nodeClass != UA_NODECLASS_OBJECT && withObject->nodeClass != UA_NODECLASS_OBJECTTYPE) {
  141. result->statusCode = UA_STATUSCODE_BADNODECLASSINVALID;
  142. return;
  143. }
  144. /* Verify Input Argument count, types and sizes */
  145. const UA_VariableNode *inputArguments = getArgumentsVariableNode(server, methodCalled, UA_STRING("InputArguments"));
  146. if(!inputArguments) {
  147. result->statusCode = UA_STATUSCODE_BADINVALIDARGUMENT;
  148. return;
  149. }
  150. result->statusCode = argConformsToDefinition(server, inputArguments, request->inputArgumentsSize,
  151. request->inputArguments);
  152. if(result->statusCode != UA_STATUSCODE_GOOD)
  153. return;
  154. /* Allocate the output arguments */
  155. const UA_VariableNode *outputArguments = getArgumentsVariableNode(server, methodCalled, UA_STRING("OutputArguments"));
  156. if(!outputArguments) {
  157. result->statusCode = UA_STATUSCODE_BADINTERNALERROR;
  158. return;
  159. }
  160. result->outputArguments = UA_Array_new(outputArguments->value.variant.value.arrayLength, &UA_TYPES[UA_TYPES_VARIANT]);
  161. if(!result->outputArguments) {
  162. result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
  163. return;
  164. }
  165. result->outputArgumentsSize = outputArguments->value.variant.value.arrayLength;
  166. /* Call the method */
  167. result->statusCode = methodCalled->attachedMethod(methodCalled->methodHandle, withObject->nodeId,
  168. request->inputArgumentsSize, request->inputArguments,
  169. result->outputArgumentsSize, result->outputArguments);
  170. /* TODO: Verify Output Argument count, types and sizes */
  171. }
  172. void Service_Call(UA_Server *server, UA_Session *session, const UA_CallRequest *request,
  173. UA_CallResponse *response) {
  174. UA_LOG_DEBUG_SESSION(server->config.logger, session, "Processing CallRequest");
  175. if(request->methodsToCallSize <= 0) {
  176. response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
  177. return;
  178. }
  179. response->results = UA_Array_new(request->methodsToCallSize, &UA_TYPES[UA_TYPES_CALLMETHODRESULT]);
  180. if(!response->results) {
  181. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  182. return;
  183. }
  184. response->resultsSize = request->methodsToCallSize;
  185. for(size_t i = 0; i < request->methodsToCallSize;i++)
  186. Service_Call_single(server, session, &request->methodsToCall[i], &response->results[i]);
  187. }
  188. #endif /* UA_ENABLE_METHODCALLS */