ua_server_utils.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447
  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_server_internal.h"
  5. /**********************/
  6. /* Parse NumericRange */
  7. /**********************/
  8. static size_t
  9. readDimension(UA_Byte *buf, size_t buflen, UA_NumericRangeDimension *dim) {
  10. size_t progress = UA_readNumber(buf, buflen, &dim->min);
  11. if(progress == 0)
  12. return 0;
  13. if(buflen <= progress + 1 || buf[progress] != ':') {
  14. dim->max = dim->min;
  15. return progress;
  16. }
  17. ++progress;
  18. size_t progress2 = UA_readNumber(&buf[progress], buflen - progress, &dim->max);
  19. if(progress2 == 0)
  20. return 0;
  21. /* invalid range */
  22. if(dim->min >= dim->max)
  23. return 0;
  24. return progress + progress2;
  25. }
  26. UA_StatusCode
  27. UA_NumericRange_parseFromString(UA_NumericRange *range, const UA_String *str) {
  28. size_t idx = 0;
  29. size_t dimensionsMax = 0;
  30. UA_NumericRangeDimension *dimensions = NULL;
  31. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  32. size_t offset = 0;
  33. while(true) {
  34. /* alloc dimensions */
  35. if(idx >= dimensionsMax) {
  36. UA_NumericRangeDimension *newds;
  37. size_t newdssize = sizeof(UA_NumericRangeDimension) * (dimensionsMax + 2);
  38. newds = (UA_NumericRangeDimension*)UA_realloc(dimensions, newdssize);
  39. if(!newds) {
  40. retval = UA_STATUSCODE_BADOUTOFMEMORY;
  41. break;
  42. }
  43. dimensions = newds;
  44. dimensionsMax = dimensionsMax + 2;
  45. }
  46. /* read the dimension */
  47. size_t progress = readDimension(&str->data[offset], str->length - offset,
  48. &dimensions[idx]);
  49. if(progress == 0) {
  50. retval = UA_STATUSCODE_BADINDEXRANGEINVALID;
  51. break;
  52. }
  53. offset += progress;
  54. ++idx;
  55. /* loop into the next dimension */
  56. if(offset >= str->length)
  57. break;
  58. if(str->data[offset] != ',') {
  59. retval = UA_STATUSCODE_BADINDEXRANGEINVALID;
  60. break;
  61. }
  62. ++offset;
  63. }
  64. if(retval == UA_STATUSCODE_GOOD && idx > 0) {
  65. range->dimensions = dimensions;
  66. range->dimensionsSize = idx;
  67. } else
  68. UA_free(dimensions);
  69. return retval;
  70. }
  71. /********************************/
  72. /* Information Model Operations */
  73. /********************************/
  74. UA_Boolean
  75. isNodeInTree(UA_Nodestore *ns, const UA_NodeId *leafNode, const UA_NodeId *nodeToFind,
  76. const UA_NodeId *referenceTypeIds, size_t referenceTypeIdsSize) {
  77. if(UA_NodeId_equal(nodeToFind, leafNode))
  78. return true;
  79. const UA_Node *node = ns->getNode(ns->context, leafNode);
  80. if(!node)
  81. return false;
  82. for(size_t i = 0; i < node->referencesSize; ++i) {
  83. UA_NodeReferenceKind *refs = &node->references[i];
  84. /* Search upwards in the tree */
  85. if(!refs->isInverse)
  86. continue;
  87. /* Consider only the indicated reference types */
  88. UA_Boolean match = false;
  89. for(size_t j = 0; j < referenceTypeIdsSize; ++j) {
  90. if(UA_NodeId_equal(&refs->referenceTypeId, &referenceTypeIds[j])) {
  91. match = true;
  92. break;
  93. }
  94. }
  95. if(!match)
  96. continue;
  97. /* Match the targets or recurse */
  98. for(size_t j = 0; j < refs->targetIdsSize; ++j) {
  99. if(isNodeInTree(ns, &refs->targetIds[j].nodeId, nodeToFind,
  100. referenceTypeIds, referenceTypeIdsSize)) {
  101. ns->releaseNode(ns->context, node);
  102. return true;
  103. }
  104. }
  105. }
  106. ns->releaseNode(ns->context, node);
  107. return false;
  108. }
  109. const UA_Node *
  110. getNodeType(UA_Server *server, const UA_Node *node) {
  111. /* The reference to the parent is different for variable and variabletype */
  112. UA_NodeId parentRef;
  113. UA_Boolean inverse;
  114. UA_NodeClass typeNodeClass;
  115. switch(node->nodeClass) {
  116. case UA_NODECLASS_OBJECT:
  117. parentRef = UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION);
  118. inverse = false;
  119. typeNodeClass = UA_NODECLASS_OBJECTTYPE;
  120. break;
  121. case UA_NODECLASS_VARIABLE:
  122. parentRef = UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION);
  123. inverse = false;
  124. typeNodeClass = UA_NODECLASS_VARIABLETYPE;
  125. break;
  126. case UA_NODECLASS_OBJECTTYPE:
  127. case UA_NODECLASS_VARIABLETYPE:
  128. case UA_NODECLASS_REFERENCETYPE:
  129. case UA_NODECLASS_DATATYPE:
  130. parentRef = UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE);
  131. inverse = true;
  132. typeNodeClass = node->nodeClass;
  133. break;
  134. default:
  135. return NULL;
  136. }
  137. /* Return the first matching candidate */
  138. for(size_t i = 0; i < node->referencesSize; ++i) {
  139. if(node->references[i].isInverse != inverse)
  140. continue;
  141. if(!UA_NodeId_equal(&node->references[i].referenceTypeId, &parentRef))
  142. continue;
  143. UA_assert(node->references[i].targetIdsSize > 0);
  144. const UA_NodeId *targetId = &node->references[i].targetIds[0].nodeId;
  145. const UA_Node *type = UA_Nodestore_get(server, targetId);
  146. if(!type)
  147. continue;
  148. if(type->nodeClass == typeNodeClass)
  149. return type;
  150. UA_Nodestore_release(server, type);
  151. }
  152. return NULL;
  153. }
  154. UA_Boolean
  155. UA_Node_hasSubTypeOrInstances(const UA_Node *node) {
  156. const UA_NodeId hasSubType = UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE);
  157. const UA_NodeId hasTypeDefinition = UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION);
  158. for(size_t i = 0; i < node->referencesSize; ++i) {
  159. if(node->references[i].isInverse == false &&
  160. UA_NodeId_equal(&node->references[i].referenceTypeId, &hasSubType))
  161. return true;
  162. if(node->references[i].isInverse == true &&
  163. UA_NodeId_equal(&node->references[i].referenceTypeId, &hasTypeDefinition))
  164. return true;
  165. }
  166. return false;
  167. }
  168. static const UA_NodeId hasSubtypeNodeId =
  169. {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_HASSUBTYPE}};
  170. static UA_StatusCode
  171. getTypeHierarchyFromNode(UA_NodeId **results_ptr, size_t *results_count,
  172. size_t *results_size, const UA_Node *node) {
  173. UA_NodeId *results = *results_ptr;
  174. for(size_t i = 0; i < node->referencesSize; ++i) {
  175. /* Is the reference kind relevant? */
  176. UA_NodeReferenceKind *refs = &node->references[i];
  177. if(!refs->isInverse)
  178. continue;
  179. if(!UA_NodeId_equal(&hasSubtypeNodeId, &refs->referenceTypeId))
  180. continue;
  181. /* Append all targets of the reference kind .. if not a duplicate */
  182. for(size_t j = 0; j < refs->targetIdsSize; ++j) {
  183. /* Is the target a duplicate? (multi-inheritance) */
  184. UA_NodeId *targetId = &refs->targetIds[j].nodeId;
  185. UA_Boolean duplicate = false;
  186. for(size_t k = 0; k < *results_count; ++k) {
  187. if(UA_NodeId_equal(targetId, &results[k])) {
  188. duplicate = true;
  189. break;
  190. }
  191. }
  192. if(duplicate)
  193. continue;
  194. /* Increase array length if necessary */
  195. if(*results_count >= *results_size) {
  196. size_t new_size = sizeof(UA_NodeId) * (*results_size) * 2;
  197. UA_NodeId *new_results = (UA_NodeId*)UA_realloc(results, new_size);
  198. if(!new_results) {
  199. UA_Array_delete(results, *results_count, &UA_TYPES[UA_TYPES_NODEID]);
  200. return UA_STATUSCODE_BADOUTOFMEMORY;
  201. }
  202. results = new_results;
  203. *results_ptr = results;
  204. *results_size *= 2;
  205. }
  206. /* Copy new nodeid to the end of the list */
  207. UA_StatusCode retval = UA_NodeId_copy(targetId, &results[*results_count]);
  208. if(retval != UA_STATUSCODE_GOOD) {
  209. UA_Array_delete(results, *results_count, &UA_TYPES[UA_TYPES_NODEID]);
  210. return retval;
  211. }
  212. *results_count += 1;
  213. }
  214. }
  215. return UA_STATUSCODE_GOOD;
  216. }
  217. UA_StatusCode
  218. getTypeHierarchy(UA_Nodestore *ns, const UA_NodeId *leafType,
  219. UA_NodeId **typeHierarchy, size_t *typeHierarchySize) {
  220. /* Allocate the results array. Probably too big, but saves mallocs. */
  221. size_t results_size = 20;
  222. UA_NodeId *results = (UA_NodeId*)UA_malloc(sizeof(UA_NodeId) * results_size);
  223. if(!results)
  224. return UA_STATUSCODE_BADOUTOFMEMORY;
  225. /* The leaf is the first element */
  226. size_t results_count = 1;
  227. UA_StatusCode retval = UA_NodeId_copy(leafType, &results[0]);
  228. if(retval != UA_STATUSCODE_GOOD) {
  229. UA_free(results);
  230. return retval;
  231. }
  232. /* Loop over the array members .. and add new elements to the end */
  233. for(size_t idx = 0; idx < results_count; ++idx) {
  234. /* Get the node */
  235. const UA_Node *node = ns->getNode(ns->context, &results[idx]);
  236. /* Invalid node, remove from the array */
  237. if(!node) {
  238. for(size_t i = idx; i < results_count-1; ++i)
  239. results[i] = results[i+1];
  240. results_count--;
  241. continue;
  242. }
  243. /* Add references from the current node to the end of the array */
  244. retval = getTypeHierarchyFromNode(&results, &results_count,
  245. &results_size, node);
  246. /* Release the node */
  247. ns->releaseNode(ns->context, node);
  248. if(retval != UA_STATUSCODE_GOOD) {
  249. UA_Array_delete(results, results_count, &UA_TYPES[UA_TYPES_NODEID]);
  250. return retval;
  251. }
  252. }
  253. /* Zero results. The leaf node was not found */
  254. if(results_count == 0) {
  255. UA_free(results);
  256. results = NULL;
  257. }
  258. *typeHierarchy = results;
  259. *typeHierarchySize = results_count;
  260. return UA_STATUSCODE_GOOD;
  261. }
  262. /* For mulithreading: make a copy of the node, edit and replace.
  263. * For singlethreading: edit the original */
  264. UA_StatusCode
  265. UA_Server_editNode(UA_Server *server, UA_Session *session,
  266. const UA_NodeId *nodeId, UA_EditNodeCallback callback,
  267. const void *data) {
  268. #ifndef UA_ENABLE_MULTITHREADING
  269. const UA_Node *node = UA_Nodestore_get(server, nodeId);
  270. if(!node)
  271. return UA_STATUSCODE_BADNODEIDUNKNOWN;
  272. UA_StatusCode retval = callback(server, session,
  273. (UA_Node*)(uintptr_t)node, data);
  274. UA_Nodestore_release(server, node);
  275. return retval;
  276. #else
  277. UA_StatusCode retval;
  278. do {
  279. UA_Node *node;
  280. retval = server->config.nodestore.getNodeCopy(server->config.nodestore.context,
  281. nodeId, &node);
  282. if(retval != UA_STATUSCODE_GOOD)
  283. return retval;
  284. retval = callback(server, session, node, data);
  285. if(retval != UA_STATUSCODE_GOOD) {
  286. server->config.nodestore.deleteNode(server->config.nodestore.context, node);
  287. return retval;
  288. }
  289. retval = server->config.nodestore.replaceNode(server->config.nodestore.context, node);
  290. } while(retval != UA_STATUSCODE_GOOD);
  291. return retval;
  292. #endif
  293. }
  294. UA_StatusCode
  295. UA_Server_processServiceOperations(UA_Server *server, UA_Session *session,
  296. UA_ServiceOperation operationCallback,
  297. const size_t *requestOperations,
  298. const UA_DataType *requestOperationsType,
  299. size_t *responseOperations,
  300. const UA_DataType *responseOperationsType) {
  301. size_t ops = *requestOperations;
  302. if(ops == 0)
  303. return UA_STATUSCODE_BADNOTHINGTODO;
  304. /* No padding after size_t */
  305. void **respPos = (void**)((uintptr_t)responseOperations + sizeof(size_t));
  306. *respPos = UA_Array_new(ops, responseOperationsType);
  307. if(!(*respPos))
  308. return UA_STATUSCODE_BADOUTOFMEMORY;
  309. *responseOperations = ops;
  310. uintptr_t respOp = (uintptr_t)*respPos;
  311. /* No padding after size_t */
  312. uintptr_t reqOp = *(uintptr_t*)((uintptr_t)requestOperations + sizeof(size_t));
  313. for(size_t i = 0; i < ops; i++) {
  314. operationCallback(server, session, (void*)reqOp, (void*)respOp);
  315. reqOp += requestOperationsType->memSize;
  316. respOp += responseOperationsType->memSize;
  317. }
  318. return UA_STATUSCODE_GOOD;
  319. }
  320. /*********************************/
  321. /* Default attribute definitions */
  322. /*********************************/
  323. const UA_ObjectAttributes UA_ObjectAttributes_default = {
  324. 0, /* specifiedAttributes */
  325. {{0, NULL}, {0, NULL}}, /* displayName */
  326. {{0, NULL}, {0, NULL}}, /* description */
  327. 0, 0, /* writeMask (userWriteMask) */
  328. 0 /* eventNotifier */
  329. };
  330. const UA_VariableAttributes UA_VariableAttributes_default = {
  331. 0, /* specifiedAttributes */
  332. {{0, NULL}, {0, NULL}}, /* displayName */
  333. {{0, NULL}, {0, NULL}}, /* description */
  334. 0, 0, /* writeMask (userWriteMask) */
  335. {NULL, UA_VARIANT_DATA,
  336. 0, NULL, 0, NULL}, /* value */
  337. {0, UA_NODEIDTYPE_NUMERIC,
  338. {UA_NS0ID_BASEDATATYPE}}, /* dataType */
  339. -2, /* valueRank */
  340. 0, NULL, /* arrayDimensions */
  341. UA_ACCESSLEVELMASK_READ, 0, /* accessLevel (userAccessLevel) */
  342. 0.0, /* minimumSamplingInterval */
  343. false /* historizing */
  344. };
  345. const UA_MethodAttributes UA_MethodAttributes_default = {
  346. 0, /* specifiedAttributes */
  347. {{0, NULL}, {0, NULL}}, /* displayName */
  348. {{0, NULL}, {0, NULL}}, /* description */
  349. 0, 0, /* writeMask (userWriteMask) */
  350. true, true /* executable (userExecutable) */
  351. };
  352. const UA_ObjectTypeAttributes UA_ObjectTypeAttributes_default = {
  353. 0, /* specifiedAttributes */
  354. {{0, NULL}, {0, NULL}}, /* displayName */
  355. {{0, NULL}, {0, NULL}}, /* description */
  356. 0, 0, /* writeMask (userWriteMask) */
  357. false /* isAbstract */
  358. };
  359. const UA_VariableTypeAttributes UA_VariableTypeAttributes_default = {
  360. 0, /* specifiedAttributes */
  361. {{0, NULL}, {0, NULL}}, /* displayName */
  362. {{0, NULL}, {0, NULL}}, /* description */
  363. 0, 0, /* writeMask (userWriteMask) */
  364. {NULL, UA_VARIANT_DATA,
  365. 0, NULL, 0, NULL}, /* value */
  366. {0, UA_NODEIDTYPE_NUMERIC,
  367. {UA_NS0ID_BASEDATATYPE}}, /* dataType */
  368. -2, /* valueRank */
  369. 0, NULL, /* arrayDimensions */
  370. false /* isAbstract */
  371. };
  372. const UA_ReferenceTypeAttributes UA_ReferenceTypeAttributes_default = {
  373. 0, /* specifiedAttributes */
  374. {{0, NULL}, {0, NULL}}, /* displayName */
  375. {{0, NULL}, {0, NULL}}, /* description */
  376. 0, 0, /* writeMask (userWriteMask) */
  377. false, /* isAbstract */
  378. false, /* symmetric */
  379. {{0, NULL}, {0, NULL}} /* inverseName */
  380. };
  381. const UA_DataTypeAttributes UA_DataTypeAttributes_default = {
  382. 0, /* specifiedAttributes */
  383. {{0, NULL}, {0, NULL}}, /* displayName */
  384. {{0, NULL}, {0, NULL}}, /* description */
  385. 0, 0, /* writeMask (userWriteMask) */
  386. false /* isAbstract */
  387. };
  388. const UA_ViewAttributes UA_ViewAttributes_default = {
  389. 0, /* specifiedAttributes */
  390. {{0, NULL}, {0, NULL}}, /* displayName */
  391. {{0, NULL}, {0, NULL}}, /* description */
  392. 0, 0, /* writeMask (userWriteMask) */
  393. false, /* containsNoLoops */
  394. 0 /* eventNotifier */
  395. };