ua_services_view.c 46 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254
  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. *
  5. * Copyright 2014-2019 (c) Fraunhofer IOSB (Author: Julius Pfrommer)
  6. * Copyright 2014-2017 (c) Florian Palm
  7. * Copyright 2015-2016 (c) Sten Grüner
  8. * Copyright 2015 (c) LEvertz
  9. * Copyright 2015 (c) Chris Iatrou
  10. * Copyright 2015 (c) Ecosmos
  11. * Copyright 2015-2016 (c) Oleksiy Vasylyev
  12. * Copyright 2017 (c) Stefan Profanter, fortiss GmbH
  13. * Copyright 2016 (c) Lorenz Haas
  14. * Copyright 2017 (c) pschoppe
  15. * Copyright 2017 (c) Julian Grothoff
  16. * Copyright 2017 (c) Henrik Norrman
  17. */
  18. #include "ua_server_internal.h"
  19. #include "ua_services.h"
  20. #include "ziptree.h"
  21. /********************/
  22. /* Browse Recursive */
  23. /********************/
  24. /* A RefTree holds a single array for both the NodeIds encountered during
  25. * recursive browsing and the entries for a tree-structure to check for
  26. * duplicates. Once the (recursive) browse has finished, the tree-structure part
  27. * can be simply cut away. A single realloc operation (with some pointer
  28. * repairing) can be used to increase the capacity of the RefTree.
  29. *
  30. * If an ExpandedNodeId is encountered, it has to be processed right away.
  31. * Remote ExpandedNodeId are not put into the tree, since it is not possible to
  32. * recurse into them anyway.
  33. *
  34. * The layout of the results array is as follows:
  35. *
  36. * | Targets [ExpandedNodeId] | Tree [RefEntry] | */
  37. #define UA_BROWSE_INITIAL_SIZE 16
  38. typedef struct RefEntry {
  39. ZIP_ENTRY(RefEntry) zipfields;
  40. const UA_ExpandedNodeId *target;
  41. UA_UInt32 targetHash; /* Hash of the target nodeid */
  42. } RefEntry;
  43. static enum ZIP_CMP
  44. cmpTarget(const void *a, const void *b) {
  45. const RefEntry *aa = (const RefEntry*)a;
  46. const RefEntry *bb = (const RefEntry*)b;
  47. if(aa->targetHash < bb->targetHash)
  48. return ZIP_CMP_LESS;
  49. if(aa->targetHash > bb->targetHash)
  50. return ZIP_CMP_MORE;
  51. return (enum ZIP_CMP)UA_ExpandedNodeId_order(aa->target, bb->target);
  52. }
  53. ZIP_HEAD(RefHead, RefEntry);
  54. typedef struct RefHead RefHead;
  55. ZIP_PROTTYPE(RefHead, RefEntry, RefEntry)
  56. ZIP_IMPL(RefHead, RefEntry, zipfields, RefEntry, zipfields, cmpTarget)
  57. typedef struct {
  58. UA_ExpandedNodeId *targets;
  59. RefHead head;
  60. size_t capacity; /* available space */
  61. size_t size; /* used space */
  62. } RefTree;
  63. static UA_StatusCode UA_FUNC_ATTR_WARN_UNUSED_RESULT
  64. RefTree_init(RefTree *rt) {
  65. size_t space = (sizeof(UA_ExpandedNodeId) + sizeof(RefEntry)) * UA_BROWSE_INITIAL_SIZE;
  66. rt->targets = (UA_ExpandedNodeId*)UA_malloc(space);
  67. if(!rt->targets)
  68. return UA_STATUSCODE_BADOUTOFMEMORY;
  69. rt->capacity = UA_BROWSE_INITIAL_SIZE;
  70. rt->size = 0;
  71. ZIP_INIT(&rt->head);
  72. return UA_STATUSCODE_GOOD;
  73. }
  74. static void
  75. RefTree_clear(RefTree *rt) {
  76. for(size_t i = 0; i < rt->size; i++)
  77. UA_ExpandedNodeId_clear(&rt->targets[i]);
  78. UA_free(rt->targets);
  79. }
  80. /* Double the capacity of the reftree */
  81. static UA_StatusCode UA_FUNC_ATTR_WARN_UNUSED_RESULT
  82. RefTree_double(RefTree *rt) {
  83. size_t capacity = rt->capacity * 2;
  84. UA_assert(capacity > 0);
  85. size_t space = (sizeof(UA_ExpandedNodeId) + sizeof(RefEntry)) * capacity;
  86. UA_ExpandedNodeId *newTargets = (UA_ExpandedNodeId*)UA_realloc(rt->targets, space);
  87. if(!newTargets)
  88. return UA_STATUSCODE_BADOUTOFMEMORY;
  89. /* Repair the pointers for the realloced array+tree */
  90. uintptr_t arraydiff = (uintptr_t)newTargets - (uintptr_t)rt->targets;
  91. RefEntry *reArray = (RefEntry*)
  92. ((uintptr_t)newTargets + (capacity * sizeof(UA_ExpandedNodeId)));
  93. uintptr_t entrydiff = (uintptr_t)reArray -
  94. ((uintptr_t)rt->targets + (rt->capacity * sizeof(UA_ExpandedNodeId)));
  95. RefEntry *oldReArray = (RefEntry*)
  96. ((uintptr_t)newTargets + (rt->capacity * sizeof(UA_ExpandedNodeId)));
  97. memmove(reArray, oldReArray, rt->size * sizeof(RefEntry));
  98. for(size_t i = 0; i < rt->size; i++) {
  99. if(reArray[i].zipfields.zip_left)
  100. *(uintptr_t*)&reArray[i].zipfields.zip_left += entrydiff;
  101. if(reArray[i].zipfields.zip_right)
  102. *(uintptr_t*)&reArray[i].zipfields.zip_right += entrydiff;
  103. *(uintptr_t*)&reArray[i].target += arraydiff;
  104. }
  105. rt->head.zip_root = (RefEntry*)((uintptr_t)rt->head.zip_root + entrydiff);
  106. rt->capacity = capacity;
  107. rt->targets = newTargets;
  108. return UA_STATUSCODE_GOOD;
  109. }
  110. static UA_StatusCode UA_FUNC_ATTR_WARN_UNUSED_RESULT
  111. RefTree_add(RefTree *rt, const UA_ExpandedNodeId *target) {
  112. /* Is the target already in the tree? */
  113. RefEntry dummy;
  114. dummy.target = target;
  115. dummy.targetHash = UA_ExpandedNodeId_hash(target);
  116. if(ZIP_FIND(RefHead, &rt->head, &dummy))
  117. return UA_STATUSCODE_GOOD;
  118. UA_StatusCode s = UA_STATUSCODE_GOOD;
  119. if(rt->capacity <= rt->size) {
  120. s = RefTree_double(rt);
  121. if(s != UA_STATUSCODE_GOOD)
  122. return s;
  123. }
  124. s = UA_ExpandedNodeId_copy(target, &rt->targets[rt->size]);
  125. if(s != UA_STATUSCODE_GOOD)
  126. return s;
  127. RefEntry *re = (RefEntry*)((uintptr_t)rt->targets +
  128. (sizeof(UA_ExpandedNodeId) * rt->capacity) +
  129. (sizeof(RefEntry) * rt->size));
  130. re->target = &rt->targets[rt->size];
  131. re->targetHash = dummy.targetHash;
  132. ZIP_INSERT(RefHead, &rt->head, re, ZIP_FFS32(UA_UInt32_random()));
  133. rt->size++;
  134. return UA_STATUSCODE_GOOD;
  135. }
  136. static UA_Boolean
  137. relevantReference(const UA_NodeId *refType, size_t relevantRefsSize,
  138. const UA_NodeId *relevantRefs) {
  139. if(!relevantRefs)
  140. return true;
  141. for(size_t i = 0; i < relevantRefsSize; i++) {
  142. if(UA_NodeId_equal(refType, &relevantRefs[i]))
  143. return true;
  144. }
  145. return false;
  146. }
  147. static UA_StatusCode
  148. addRelevantReferences(UA_Server *server, RefTree *rt, const UA_NodeId *nodeId,
  149. size_t refTypesSize, const UA_NodeId *refTypes,
  150. UA_BrowseDirection browseDirection) {
  151. const UA_Node *node = UA_NODESTORE_GET(server, nodeId);
  152. if(!node)
  153. return UA_STATUSCODE_BADNODEIDUNKNOWN;
  154. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  155. for(size_t i = 0; i < node->referencesSize; i++) {
  156. UA_NodeReferenceKind *rk = &node->references[i];
  157. /* Reference in the right direction? */
  158. if(rk->isInverse && browseDirection == UA_BROWSEDIRECTION_FORWARD)
  159. continue;
  160. if(!rk->isInverse && browseDirection == UA_BROWSEDIRECTION_INVERSE)
  161. continue;
  162. /* Is the reference part of the hierarchy of references we look for? */
  163. if(!relevantReference(&rk->referenceTypeId, refTypesSize, refTypes))
  164. continue;
  165. for(size_t k = 0; k < rk->refTargetsSize; k++) {
  166. retval = RefTree_add(rt, &rk->refTargets[k].target);
  167. if(retval != UA_STATUSCODE_GOOD)
  168. goto cleanup;
  169. }
  170. }
  171. cleanup:
  172. UA_NODESTORE_RELEASE(server, node);
  173. return retval;
  174. }
  175. UA_StatusCode
  176. browseRecursive(UA_Server *server,
  177. size_t startNodesSize, const UA_NodeId *startNodes,
  178. size_t refTypesSize, const UA_NodeId *refTypes,
  179. UA_BrowseDirection browseDirection, UA_Boolean includeStartNodes,
  180. size_t *resultsSize, UA_ExpandedNodeId **results) {
  181. RefTree rt;
  182. UA_StatusCode retval = RefTree_init(&rt);
  183. if(retval != UA_STATUSCODE_GOOD)
  184. return retval;
  185. /* Add the start nodes? */
  186. UA_ExpandedNodeId en = UA_EXPANDEDNODEID_NULL;
  187. for(size_t i = 0; i < startNodesSize && retval == UA_STATUSCODE_GOOD; i++) {
  188. if(includeStartNodes) {
  189. en.nodeId = startNodes[i];
  190. retval = RefTree_add(&rt, &en);
  191. } else {
  192. retval = addRelevantReferences(server, &rt, &startNodes[i],
  193. refTypesSize, refTypes, browseDirection);
  194. }
  195. }
  196. if(retval != UA_STATUSCODE_GOOD) {
  197. RefTree_clear(&rt);
  198. return retval;
  199. }
  200. /* Loop over the targets we have so far. This recurses, as new targets are
  201. * added to rt. */
  202. for(size_t i = 0; i < rt.size; i++) {
  203. /* Dont recurse into remote nodes */
  204. if(rt.targets[i].serverIndex > 0)
  205. continue;
  206. if(rt.targets[i].namespaceUri.data != NULL)
  207. continue;
  208. retval = addRelevantReferences(server, &rt, &rt.targets[i].nodeId,
  209. refTypesSize, refTypes, browseDirection);
  210. if(retval != UA_STATUSCODE_GOOD) {
  211. RefTree_clear(&rt);
  212. return retval;
  213. }
  214. }
  215. if(rt.size > 0) {
  216. *results = rt.targets;
  217. *resultsSize = rt.size;
  218. } else {
  219. RefTree_clear(&rt);
  220. }
  221. return UA_STATUSCODE_GOOD;
  222. }
  223. /* Only if IncludeSubtypes is selected */
  224. UA_StatusCode
  225. referenceSubtypes(UA_Server *server, const UA_NodeId *refType,
  226. size_t *refTypesSize, UA_NodeId **refTypes) {
  227. /* Leave refTypes == NULL */
  228. if(UA_NodeId_isNull(refType))
  229. return UA_STATUSCODE_GOOD;
  230. /* Browse recursive for the hierarchy of sub-references */
  231. UA_ExpandedNodeId *rt = NULL;
  232. size_t rtSize = 0;
  233. UA_NodeId hasSubtype = UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE);
  234. UA_StatusCode retval = browseRecursive(server, 1, refType, 1, &hasSubtype,
  235. UA_BROWSEDIRECTION_FORWARD, true, &rtSize, &rt);
  236. if(retval != UA_STATUSCODE_GOOD)
  237. return retval;
  238. UA_assert(rtSize > 0);
  239. /* Allocate space (realloc if non-NULL) */
  240. UA_NodeId *newRt = NULL;
  241. if(!*refTypes) {
  242. newRt = (UA_NodeId*)UA_malloc(rtSize * UA_TYPES[UA_TYPES_NODEID].memSize);
  243. } else {
  244. newRt = (UA_NodeId*)UA_realloc(*refTypes, (*refTypesSize + rtSize) *
  245. UA_TYPES[UA_TYPES_NODEID].memSize);
  246. }
  247. if(!newRt) {
  248. UA_Array_delete(rt, rtSize, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
  249. return UA_STATUSCODE_BADOUTOFMEMORY;
  250. }
  251. *refTypes = newRt;
  252. /* Move NodeIds */
  253. for(size_t i = 0; i < rtSize; i++) {
  254. (*refTypes)[*refTypesSize + i] = rt[i].nodeId;
  255. UA_NodeId_init(&rt[i].nodeId);
  256. }
  257. *refTypesSize += rtSize;
  258. UA_Array_delete(rt, rtSize, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
  259. return UA_STATUSCODE_GOOD;
  260. }
  261. UA_StatusCode
  262. UA_Server_browseRecursive(UA_Server *server, const UA_BrowseDescription *bd,
  263. size_t *resultsSize, UA_ExpandedNodeId **results) {
  264. /* Set the list of relevant reference types */
  265. UA_LOCK(server->serviceMutex);
  266. UA_NodeId *refTypes = NULL;
  267. size_t refTypesSize = 0;
  268. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  269. if(!UA_NodeId_isNull(&bd->referenceTypeId)) {
  270. if(!bd->includeSubtypes) {
  271. refTypes = (UA_NodeId*)(uintptr_t)&bd->referenceTypeId;
  272. refTypesSize = 1;
  273. } else {
  274. retval = referenceSubtypes(server, &bd->referenceTypeId,
  275. &refTypesSize, &refTypes);
  276. if(retval != UA_STATUSCODE_GOOD) {
  277. UA_UNLOCK(server->serviceMutex);
  278. return retval;
  279. }
  280. }
  281. }
  282. /* Browse */
  283. retval = browseRecursive(server, 1, &bd->nodeId, refTypesSize, refTypes,
  284. bd->browseDirection, false, resultsSize, results);
  285. /* Clean up */
  286. if(refTypes && bd->includeSubtypes)
  287. UA_Array_delete(refTypes, refTypesSize, &UA_TYPES[UA_TYPES_NODEID]);
  288. UA_UNLOCK(server->serviceMutex);
  289. return retval;
  290. }
  291. /**********/
  292. /* Browse */
  293. /**********/
  294. typedef struct {
  295. size_t size;
  296. size_t capacity;
  297. UA_ReferenceDescription *descr;
  298. } RefResult;
  299. static UA_StatusCode UA_FUNC_ATTR_WARN_UNUSED_RESULT
  300. RefResult_init(RefResult *rr) {
  301. memset(rr, 0, sizeof(RefResult));
  302. rr->descr = (UA_ReferenceDescription*)
  303. UA_Array_new(UA_BROWSE_INITIAL_SIZE, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]);
  304. if(!rr->descr)
  305. return UA_STATUSCODE_BADOUTOFMEMORY;
  306. rr->capacity = UA_BROWSE_INITIAL_SIZE;
  307. rr->size = 0;
  308. return UA_STATUSCODE_GOOD;
  309. }
  310. static UA_StatusCode UA_FUNC_ATTR_WARN_UNUSED_RESULT
  311. RefResult_double(RefResult *rr) {
  312. size_t newSize = rr->capacity * 2;
  313. UA_ReferenceDescription *rd = (UA_ReferenceDescription*)
  314. UA_realloc(rr->descr, newSize * sizeof(UA_ReferenceDescription));
  315. if(!rd)
  316. return UA_STATUSCODE_BADOUTOFMEMORY;
  317. memset(&rd[rr->size], 0, sizeof(UA_ReferenceDescription) * (newSize - rr->size));
  318. rr->descr = rd;
  319. rr->capacity = newSize;
  320. return UA_STATUSCODE_GOOD;
  321. }
  322. static void
  323. RefResult_clear(RefResult *rr) {
  324. UA_assert(rr->descr != NULL);
  325. for(size_t i = 0; i < rr->size; i++)
  326. UA_ReferenceDescription_clear(&rr->descr[i]);
  327. UA_free(rr->descr);
  328. }
  329. struct ContinuationPoint {
  330. ContinuationPoint *next;
  331. UA_ByteString identifier;
  332. UA_BrowseDescription browseDescription;
  333. UA_UInt32 maxReferences;
  334. size_t relevantReferencesSize;
  335. UA_NodeId *relevantReferences;
  336. /* The last point in the node references? */
  337. size_t referenceKindIndex;
  338. size_t targetIndex;
  339. };
  340. ContinuationPoint *
  341. ContinuationPoint_clear(ContinuationPoint *cp) {
  342. UA_ByteString_clear(&cp->identifier);
  343. UA_BrowseDescription_clear(&cp->browseDescription);
  344. UA_Array_delete(cp->relevantReferences, cp->relevantReferencesSize,
  345. &UA_TYPES[UA_TYPES_NODEID]);
  346. return cp->next;
  347. }
  348. /* Target node on top of the stack */
  349. static UA_StatusCode UA_FUNC_ATTR_WARN_UNUSED_RESULT
  350. addReferenceDescription(UA_Server *server, RefResult *rr, const UA_NodeReferenceKind *ref,
  351. UA_UInt32 mask, const UA_ExpandedNodeId *nodeId, const UA_Node *curr) {
  352. /* Ensure capacity is left */
  353. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  354. if(rr->size >= rr->capacity) {
  355. retval = RefResult_double(rr);
  356. if(retval != UA_STATUSCODE_GOOD)
  357. return retval;
  358. }
  359. UA_ReferenceDescription *descr = &rr->descr[rr->size];
  360. /* Fields without access to the actual node */
  361. retval = UA_ExpandedNodeId_copy(nodeId, &descr->nodeId);
  362. if(mask & UA_BROWSERESULTMASK_REFERENCETYPEID)
  363. retval |= UA_NodeId_copy(&ref->referenceTypeId, &descr->referenceTypeId);
  364. if(mask & UA_BROWSERESULTMASK_ISFORWARD)
  365. descr->isForward = !ref->isInverse;
  366. /* Remote references (ExpandedNodeId) are not further looked up here */
  367. if(!curr) {
  368. UA_ReferenceDescription_clear(descr);
  369. return retval;
  370. }
  371. /* Fields that require the actual node */
  372. if(mask & UA_BROWSERESULTMASK_NODECLASS)
  373. retval |= UA_NodeClass_copy(&curr->nodeClass, &descr->nodeClass);
  374. if(mask & UA_BROWSERESULTMASK_BROWSENAME)
  375. retval |= UA_QualifiedName_copy(&curr->browseName, &descr->browseName);
  376. if(mask & UA_BROWSERESULTMASK_DISPLAYNAME)
  377. retval |= UA_LocalizedText_copy(&curr->displayName, &descr->displayName);
  378. if(mask & UA_BROWSERESULTMASK_TYPEDEFINITION) {
  379. if(curr->nodeClass == UA_NODECLASS_OBJECT ||
  380. curr->nodeClass == UA_NODECLASS_VARIABLE) {
  381. const UA_Node *type = getNodeType(server, curr);
  382. if(type) {
  383. retval |= UA_NodeId_copy(&type->nodeId, &descr->typeDefinition.nodeId);
  384. UA_NODESTORE_RELEASE(server, type);
  385. }
  386. }
  387. }
  388. if(retval == UA_STATUSCODE_GOOD)
  389. rr->size++; /* Increase the counter */
  390. else
  391. UA_ReferenceDescription_clear(descr);
  392. return retval;
  393. }
  394. static UA_Boolean
  395. matchClassMask(const UA_Node *node, UA_UInt32 nodeClassMask) {
  396. if(nodeClassMask != UA_NODECLASS_UNSPECIFIED &&
  397. (node->nodeClass & nodeClassMask) == 0)
  398. return false;
  399. return true;
  400. }
  401. /* Returns whether the node / continuationpoint is done */
  402. static UA_StatusCode
  403. browseReferences(UA_Server *server, const UA_Node *node,
  404. ContinuationPoint *cp, RefResult *rr, UA_Boolean *done) {
  405. UA_assert(cp != NULL);
  406. const UA_BrowseDescription *bd= &cp->browseDescription;
  407. size_t referenceKindIndex = cp->referenceKindIndex;
  408. size_t targetIndex = cp->targetIndex;
  409. /* Loop over the node's references */
  410. const UA_Node *target = NULL;
  411. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  412. for(; referenceKindIndex < node->referencesSize; ++referenceKindIndex) {
  413. UA_NodeReferenceKind *rk = &node->references[referenceKindIndex];
  414. /* Reference in the right direction? */
  415. if(rk->isInverse && bd->browseDirection == UA_BROWSEDIRECTION_FORWARD)
  416. continue;
  417. if(!rk->isInverse && bd->browseDirection == UA_BROWSEDIRECTION_INVERSE)
  418. continue;
  419. /* Is the reference part of the hierarchy of references we look for? */
  420. if(!relevantReference(&rk->referenceTypeId, cp->relevantReferencesSize,
  421. cp->relevantReferences))
  422. continue;
  423. /* Loop over the targets */
  424. for(; targetIndex < rk->refTargetsSize; ++targetIndex) {
  425. target = NULL;
  426. /* Get the node if it is not a remote reference */
  427. if(rk->refTargets[targetIndex].target.serverIndex == 0 &&
  428. rk->refTargets[targetIndex].target.namespaceUri.data == NULL) {
  429. target = UA_NODESTORE_GET(server,
  430. &rk->refTargets[targetIndex].target.nodeId);
  431. /* Test if the node class matches */
  432. if(target && !matchClassMask(target, bd->nodeClassMask)) {
  433. if(target)
  434. UA_NODESTORE_RELEASE(server, target);
  435. continue;
  436. }
  437. }
  438. /* A match! Did we reach maxrefs? */
  439. if(rr->size >= cp->maxReferences) {
  440. cp->referenceKindIndex = referenceKindIndex;
  441. cp->targetIndex = targetIndex;
  442. if(target)
  443. UA_NODESTORE_RELEASE(server, target);
  444. return UA_STATUSCODE_GOOD;
  445. }
  446. /* Copy the node description. Target is on top of the stack */
  447. retval = addReferenceDescription(server, rr, rk, bd->resultMask,
  448. &rk->refTargets[targetIndex].target, target);
  449. UA_NODESTORE_RELEASE(server, target);
  450. if(retval != UA_STATUSCODE_GOOD)
  451. return retval;
  452. }
  453. targetIndex = 0; /* Start at index 0 for the next reference kind */
  454. }
  455. /* The node is done */
  456. *done = true;
  457. return UA_STATUSCODE_GOOD;
  458. }
  459. /* Results for a single browsedescription. This is the inner loop for both
  460. * Browse and BrowseNext. The ContinuationPoint contains all the data used.
  461. * Including the BrowseDescription. Returns whether there are remaining
  462. * references. */
  463. static UA_Boolean
  464. browseWithContinuation(UA_Server *server, UA_Session *session,
  465. ContinuationPoint *cp, UA_BrowseResult *result) {
  466. const UA_BrowseDescription *descr = &cp->browseDescription;
  467. /* Is the browsedirection valid? */
  468. if(descr->browseDirection != UA_BROWSEDIRECTION_BOTH &&
  469. descr->browseDirection != UA_BROWSEDIRECTION_FORWARD &&
  470. descr->browseDirection != UA_BROWSEDIRECTION_INVERSE) {
  471. result->statusCode = UA_STATUSCODE_BADBROWSEDIRECTIONINVALID;
  472. return true;
  473. }
  474. /* Is the reference type valid? */
  475. if(!UA_NodeId_isNull(&descr->referenceTypeId)) {
  476. const UA_Node *reftype = UA_NODESTORE_GET(server, &descr->referenceTypeId);
  477. if(!reftype) {
  478. result->statusCode = UA_STATUSCODE_BADREFERENCETYPEIDINVALID;
  479. return true;
  480. }
  481. UA_Boolean isRef = (reftype->nodeClass == UA_NODECLASS_REFERENCETYPE);
  482. UA_NODESTORE_RELEASE(server, reftype);
  483. if(!isRef) {
  484. result->statusCode = UA_STATUSCODE_BADREFERENCETYPEIDINVALID;
  485. return true;
  486. }
  487. }
  488. const UA_Node *node = UA_NODESTORE_GET(server, &descr->nodeId);
  489. if(!node) {
  490. result->statusCode = UA_STATUSCODE_BADNODEIDUNKNOWN;
  491. return true;
  492. }
  493. RefResult rr;
  494. result->statusCode = RefResult_init(&rr);
  495. if(result->statusCode != UA_STATUSCODE_GOOD) {
  496. UA_NODESTORE_RELEASE(server, node);
  497. return true;
  498. }
  499. /* Browse the references */
  500. UA_Boolean done = false;
  501. result->statusCode = browseReferences(server, node, cp, &rr, &done);
  502. UA_NODESTORE_RELEASE(server, node);
  503. if(result->statusCode != UA_STATUSCODE_GOOD) {
  504. RefResult_clear(&rr);
  505. return true;
  506. }
  507. /* Move results */
  508. if(rr.size > 0) {
  509. result->references = rr.descr;
  510. result->referencesSize = rr.size;
  511. } else {
  512. /* No relevant references, return array of length zero */
  513. RefResult_clear(&rr);
  514. result->references = (UA_ReferenceDescription*)UA_EMPTY_ARRAY_SENTINEL;
  515. }
  516. return done;
  517. }
  518. /* Start to browse with no previous cp */
  519. void
  520. Operation_Browse(UA_Server *server, UA_Session *session, const UA_UInt32 *maxrefs,
  521. const UA_BrowseDescription *descr, UA_BrowseResult *result) {
  522. /* Stack-allocate a temporary cp */
  523. UA_STACKARRAY(ContinuationPoint, cp, 1);
  524. memset(cp, 0, sizeof(ContinuationPoint));
  525. cp->maxReferences = *maxrefs;
  526. cp->browseDescription = *descr; /* Shallow copy. Deep-copy later if we persist the cp. */
  527. /* How many references can we return at most? */
  528. if(cp->maxReferences == 0) {
  529. if(server->config.maxReferencesPerNode != 0) {
  530. cp->maxReferences = server->config.maxReferencesPerNode;
  531. } else {
  532. cp->maxReferences = UA_INT32_MAX;
  533. }
  534. } else {
  535. if(server->config.maxReferencesPerNode != 0 &&
  536. cp->maxReferences > server->config.maxReferencesPerNode) {
  537. cp->maxReferences= server->config.maxReferencesPerNode;
  538. }
  539. }
  540. /* Get the list of relevant reference types */
  541. if(!UA_NodeId_isNull(&descr->referenceTypeId)) {
  542. if(!descr->includeSubtypes) {
  543. cp->relevantReferences = (UA_NodeId*)(uintptr_t)&descr->referenceTypeId;
  544. cp->relevantReferencesSize = 1;
  545. } else {
  546. result->statusCode =
  547. referenceSubtypes(server, &descr->referenceTypeId,
  548. &cp->relevantReferencesSize, &cp->relevantReferences);
  549. if(result->statusCode != UA_STATUSCODE_GOOD)
  550. return;
  551. }
  552. }
  553. UA_Boolean done = browseWithContinuation(server, session, cp, result);
  554. /* Exit early if done or an error occurred */
  555. if(done || result->statusCode != UA_STATUSCODE_GOOD) {
  556. if(descr->includeSubtypes)
  557. UA_Array_delete(cp->relevantReferences, cp->relevantReferencesSize,
  558. &UA_TYPES[UA_TYPES_NODEID]);
  559. return;
  560. }
  561. /* Persist the new continuation point */
  562. ContinuationPoint *cp2 = NULL;
  563. UA_Guid *ident = NULL;
  564. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  565. /* Enough space for the continuation point? */
  566. if(session->availableContinuationPoints <= 0) {
  567. retval = UA_STATUSCODE_BADNOCONTINUATIONPOINTS;
  568. goto cleanup;
  569. }
  570. /* Allocate and fill the data structure */
  571. cp2 = (ContinuationPoint*)UA_malloc(sizeof(ContinuationPoint));
  572. if(!cp2) {
  573. retval = UA_STATUSCODE_BADOUTOFMEMORY;
  574. goto cleanup;
  575. }
  576. memset(cp2, 0, sizeof(ContinuationPoint));
  577. cp2->referenceKindIndex = cp->referenceKindIndex;
  578. cp2->targetIndex = cp->targetIndex;
  579. cp2->maxReferences = cp->maxReferences;
  580. if(descr->includeSubtypes) {
  581. cp2->relevantReferences = cp->relevantReferences;
  582. cp2->relevantReferencesSize = cp->relevantReferencesSize;
  583. } else {
  584. retval = UA_Array_copy(cp->relevantReferences, cp->relevantReferencesSize,
  585. (void**)&cp2->relevantReferences, &UA_TYPES[UA_TYPES_NODEID]);
  586. if(retval != UA_STATUSCODE_GOOD)
  587. goto cleanup;
  588. cp2->relevantReferencesSize = cp->relevantReferencesSize;
  589. }
  590. /* Copy the description */
  591. retval = UA_BrowseDescription_copy(descr, &cp2->browseDescription);
  592. if(retval != UA_STATUSCODE_GOOD)
  593. goto cleanup;
  594. /* Create a random bytestring via a Guid */
  595. ident = UA_Guid_new();
  596. if(!ident) {
  597. retval = UA_STATUSCODE_BADOUTOFMEMORY;
  598. goto cleanup;
  599. }
  600. *ident = UA_Guid_random();
  601. cp2->identifier.data = (UA_Byte*)ident;
  602. cp2->identifier.length = sizeof(UA_Guid);
  603. /* Return the cp identifier */
  604. retval = UA_ByteString_copy(&cp2->identifier, &result->continuationPoint);
  605. if(retval != UA_STATUSCODE_GOOD)
  606. goto cleanup;
  607. /* Attach the cp to the session */
  608. cp2->next = session->continuationPoints;
  609. session->continuationPoints = cp2;
  610. --session->availableContinuationPoints;
  611. return;
  612. cleanup:
  613. if(cp2) {
  614. ContinuationPoint_clear(cp2);
  615. UA_free(cp2);
  616. }
  617. UA_BrowseResult_clear(result);
  618. result->statusCode = retval;
  619. }
  620. void Service_Browse(UA_Server *server, UA_Session *session,
  621. const UA_BrowseRequest *request, UA_BrowseResponse *response) {
  622. UA_LOG_DEBUG_SESSION(&server->config.logger, session, "Processing BrowseRequest");
  623. UA_LOCK_ASSERT(server->serviceMutex, 1);
  624. /* Test the number of operations in the request */
  625. if(server->config.maxNodesPerBrowse != 0 &&
  626. request->nodesToBrowseSize > server->config.maxNodesPerBrowse) {
  627. response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS;
  628. return;
  629. }
  630. /* No views supported at the moment */
  631. if(!UA_NodeId_isNull(&request->view.viewId)) {
  632. response->responseHeader.serviceResult = UA_STATUSCODE_BADVIEWIDUNKNOWN;
  633. return;
  634. }
  635. response->responseHeader.serviceResult =
  636. UA_Server_processServiceOperations(server, session, (UA_ServiceOperation)Operation_Browse,
  637. &request->requestedMaxReferencesPerNode,
  638. &request->nodesToBrowseSize, &UA_TYPES[UA_TYPES_BROWSEDESCRIPTION],
  639. &response->resultsSize, &UA_TYPES[UA_TYPES_BROWSERESULT]);
  640. }
  641. UA_BrowseResult
  642. UA_Server_browse(UA_Server *server, UA_UInt32 maxReferences,
  643. const UA_BrowseDescription *bd) {
  644. UA_BrowseResult result;
  645. UA_BrowseResult_init(&result);
  646. UA_LOCK(server->serviceMutex);
  647. Operation_Browse(server, &server->adminSession, &maxReferences, bd, &result);
  648. UA_UNLOCK(server->serviceMutex);
  649. return result;
  650. }
  651. static void
  652. Operation_BrowseNext(UA_Server *server, UA_Session *session,
  653. const UA_Boolean *releaseContinuationPoints,
  654. const UA_ByteString *continuationPoint, UA_BrowseResult *result) {
  655. /* Find the continuation point */
  656. ContinuationPoint **prev = &session->continuationPoints, *cp;
  657. while((cp = *prev)) {
  658. if(UA_ByteString_equal(&cp->identifier, continuationPoint))
  659. break;
  660. prev = &cp->next;
  661. }
  662. if(!cp) {
  663. result->statusCode = UA_STATUSCODE_BADCONTINUATIONPOINTINVALID;
  664. return;
  665. }
  666. /* Remove the cp */
  667. if(*releaseContinuationPoints) {
  668. *prev = ContinuationPoint_clear(cp);
  669. UA_free(cp);
  670. ++session->availableContinuationPoints;
  671. return;
  672. }
  673. /* Continue browsing */
  674. UA_Boolean done = browseWithContinuation(server, session, cp, result);
  675. if(done) {
  676. /* Remove the cp if there are no references left */
  677. *prev = ContinuationPoint_clear(cp);
  678. UA_free(cp);
  679. ++session->availableContinuationPoints;
  680. } else {
  681. /* Return the cp identifier */
  682. UA_StatusCode retval = UA_ByteString_copy(&cp->identifier, &result->continuationPoint);
  683. if(retval != UA_STATUSCODE_GOOD) {
  684. UA_BrowseResult_clear(result);
  685. result->statusCode = retval;
  686. }
  687. }
  688. }
  689. void
  690. Service_BrowseNext(UA_Server *server, UA_Session *session,
  691. const UA_BrowseNextRequest *request,
  692. UA_BrowseNextResponse *response) {
  693. UA_LOG_DEBUG_SESSION(&server->config.logger, session,
  694. "Processing BrowseNextRequest");
  695. UA_LOCK_ASSERT(server->serviceMutex, 1);
  696. UA_Boolean releaseContinuationPoints = request->releaseContinuationPoints; /* request is const */
  697. response->responseHeader.serviceResult =
  698. UA_Server_processServiceOperations(server, session, (UA_ServiceOperation)Operation_BrowseNext,
  699. &releaseContinuationPoints,
  700. &request->continuationPointsSize, &UA_TYPES[UA_TYPES_BYTESTRING],
  701. &response->resultsSize, &UA_TYPES[UA_TYPES_BROWSERESULT]);
  702. }
  703. UA_BrowseResult
  704. UA_Server_browseNext(UA_Server *server, UA_Boolean releaseContinuationPoint,
  705. const UA_ByteString *continuationPoint) {
  706. UA_BrowseResult result;
  707. UA_BrowseResult_init(&result);
  708. UA_LOCK(server->serviceMutex);
  709. Operation_BrowseNext(server, &server->adminSession, &releaseContinuationPoint,
  710. continuationPoint, &result);
  711. UA_UNLOCK(server->serviceMutex);
  712. return result;
  713. }
  714. /***********************/
  715. /* TranslateBrowsePath */
  716. /***********************/
  717. static void
  718. walkBrowsePathElementReferenceTargets(UA_BrowsePathResult *result, size_t *targetsSize,
  719. UA_NodeId **next, size_t *nextSize, size_t *nextCount,
  720. UA_UInt32 elemDepth, const UA_NodeReferenceKind *rk) {
  721. /* Loop over the targets */
  722. for(size_t i = 0; i < rk->refTargetsSize; i++) {
  723. UA_ExpandedNodeId *targetId = &rk->refTargets[i].target;
  724. /* Does the reference point to an external server? Then add to the
  725. * targets with the right path depth. */
  726. if(targetId->serverIndex != 0) {
  727. UA_BrowsePathTarget *tempTargets =
  728. (UA_BrowsePathTarget*)UA_realloc(result->targets,
  729. sizeof(UA_BrowsePathTarget) * (*targetsSize) * 2);
  730. if(!tempTargets) {
  731. result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
  732. return;
  733. }
  734. result->targets = tempTargets;
  735. (*targetsSize) *= 2;
  736. result->statusCode = UA_ExpandedNodeId_copy(targetId,
  737. &result->targets[result->targetsSize].targetId);
  738. result->targets[result->targetsSize].remainingPathIndex = elemDepth;
  739. continue;
  740. }
  741. /* Can we store the node in the array of candidates for deep-search? */
  742. if(*nextSize <= *nextCount) {
  743. UA_NodeId *tempNext =
  744. (UA_NodeId*)UA_realloc(*next, sizeof(UA_NodeId) * (*nextSize) * 2);
  745. if(!tempNext) {
  746. result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
  747. return;
  748. }
  749. *next = tempNext;
  750. (*nextSize) *= 2;
  751. }
  752. /* Add the node to the next array for the following path element */
  753. result->statusCode = UA_NodeId_copy(&targetId->nodeId,
  754. &(*next)[*nextCount]);
  755. if(result->statusCode != UA_STATUSCODE_GOOD)
  756. return;
  757. ++(*nextCount);
  758. }
  759. }
  760. static void
  761. walkBrowsePathElement(UA_Server *server, UA_Session *session, UA_UInt32 nodeClassMask,
  762. UA_BrowsePathResult *result, size_t *targetsSize,
  763. const UA_RelativePathElement *elem, UA_UInt32 elemDepth,
  764. const UA_QualifiedName *targetName,
  765. const UA_NodeId *current, const size_t currentCount,
  766. UA_NodeId **next, size_t *nextSize, size_t *nextCount) {
  767. /* Return all references? */
  768. UA_Boolean all_refs = UA_NodeId_isNull(&elem->referenceTypeId);
  769. if(!all_refs) {
  770. const UA_Node *rootRef = UA_NODESTORE_GET(server, &elem->referenceTypeId);
  771. if(!rootRef)
  772. return;
  773. UA_Boolean match = (rootRef->nodeClass == UA_NODECLASS_REFERENCETYPE);
  774. UA_NODESTORE_RELEASE(server, rootRef);
  775. if(!match)
  776. return;
  777. }
  778. /* Iterate over all nodes at the current depth-level */
  779. for(size_t i = 0; i < currentCount; ++i) {
  780. /* Get the node */
  781. const UA_Node *node = UA_NODESTORE_GET(server, &current[i]);
  782. if(!node) {
  783. /* If we cannot find the node at depth 0, the starting node does not exist */
  784. if(elemDepth == 0)
  785. result->statusCode = UA_STATUSCODE_BADNODEIDUNKNOWN;
  786. continue;
  787. }
  788. /* Test whether the node fits the class mask */
  789. if(!matchClassMask(node, nodeClassMask)) {
  790. UA_NODESTORE_RELEASE(server, node);
  791. continue;
  792. }
  793. /* Test whether the node has the target name required in the previous
  794. * path element */
  795. if(targetName && (targetName->namespaceIndex != node->browseName.namespaceIndex ||
  796. !UA_String_equal(&targetName->name, &node->browseName.name))) {
  797. UA_NODESTORE_RELEASE(server, node);
  798. continue;
  799. }
  800. /* Loop over the nodes references */
  801. for(size_t r = 0; r < node->referencesSize &&
  802. result->statusCode == UA_STATUSCODE_GOOD; ++r) {
  803. UA_NodeReferenceKind *rk = &node->references[r];
  804. /* Does the direction of the reference match? */
  805. if(rk->isInverse != elem->isInverse)
  806. continue;
  807. /* Is the node relevant? */
  808. if(!all_refs) {
  809. if(!elem->includeSubtypes && !UA_NodeId_equal(&rk->referenceTypeId, &elem->referenceTypeId))
  810. continue;
  811. if(!isNodeInTree(server, &rk->referenceTypeId, &elem->referenceTypeId, &subtypeId, 1))
  812. continue;
  813. }
  814. /* Walk over the reference targets */
  815. walkBrowsePathElementReferenceTargets(result, targetsSize, next, nextSize,
  816. nextCount, elemDepth, rk);
  817. }
  818. UA_NODESTORE_RELEASE(server, node);
  819. }
  820. }
  821. /* This assumes that result->targets has enough room for all currentCount elements */
  822. static void
  823. addBrowsePathTargets(UA_Server *server, UA_Session *session, UA_UInt32 nodeClassMask,
  824. UA_BrowsePathResult *result, const UA_QualifiedName *targetName,
  825. UA_NodeId *current, size_t currentCount) {
  826. for(size_t i = 0; i < currentCount; i++) {
  827. const UA_Node *node = UA_NODESTORE_GET(server, &current[i]);
  828. if(!node) {
  829. UA_NodeId_clear(&current[i]);
  830. continue;
  831. }
  832. /* Test whether the node fits the class mask */
  833. UA_Boolean skip = !matchClassMask(node, nodeClassMask);
  834. /* Test whether the node has the target name required in the
  835. * previous path element */
  836. if(targetName->namespaceIndex != node->browseName.namespaceIndex ||
  837. !UA_String_equal(&targetName->name, &node->browseName.name))
  838. skip = true;
  839. UA_NODESTORE_RELEASE(server, node);
  840. if(skip) {
  841. UA_NodeId_clear(&current[i]);
  842. continue;
  843. }
  844. /* Move the nodeid to the target array */
  845. UA_BrowsePathTarget_init(&result->targets[result->targetsSize]);
  846. result->targets[result->targetsSize].targetId.nodeId = current[i];
  847. result->targets[result->targetsSize].remainingPathIndex = UA_UINT32_MAX;
  848. ++result->targetsSize;
  849. }
  850. }
  851. static void
  852. walkBrowsePath(UA_Server *server, UA_Session *session, const UA_BrowsePath *path,
  853. UA_UInt32 nodeClassMask, UA_BrowsePathResult *result, size_t targetsSize,
  854. UA_NodeId **current, size_t *currentSize, size_t *currentCount,
  855. UA_NodeId **next, size_t *nextSize, size_t *nextCount) {
  856. UA_assert(*currentCount == 1);
  857. UA_assert(*nextCount == 0);
  858. /* Points to the targetName of the _previous_ path element */
  859. const UA_QualifiedName *targetName = NULL;
  860. /* Iterate over path elements */
  861. UA_assert(path->relativePath.elementsSize > 0);
  862. for(UA_UInt32 i = 0; i < path->relativePath.elementsSize; ++i) {
  863. walkBrowsePathElement(server, session, nodeClassMask, result, &targetsSize,
  864. &path->relativePath.elements[i], i, targetName,
  865. *current, *currentCount, next, nextSize, nextCount);
  866. /* Clean members of current */
  867. for(size_t j = 0; j < *currentCount; j++)
  868. UA_NodeId_clear(&(*current)[j]);
  869. *currentCount = 0;
  870. /* When no targets are left or an error occurred. None of next's
  871. * elements will be copied to result->targets */
  872. if(*nextCount == 0 || result->statusCode != UA_STATUSCODE_GOOD) {
  873. UA_assert(*currentCount == 0);
  874. UA_assert(*nextCount == 0);
  875. return;
  876. }
  877. /* Exchange current and next for the next depth */
  878. size_t tSize = *currentSize; size_t tCount = *currentCount; UA_NodeId *tT = *current;
  879. *currentSize = *nextSize; *currentCount = *nextCount; *current = *next;
  880. *nextSize = tSize; *nextCount = tCount; *next = tT;
  881. /* Store the target name of the previous path element */
  882. targetName = &path->relativePath.elements[i].targetName;
  883. }
  884. UA_assert(targetName != NULL);
  885. UA_assert(*nextCount == 0);
  886. /* After the last BrowsePathElement, move members from current to the
  887. * result targets */
  888. /* Realloc if more space is needed */
  889. if(targetsSize < result->targetsSize + (*currentCount)) {
  890. UA_BrowsePathTarget *newTargets =
  891. (UA_BrowsePathTarget*)UA_realloc(result->targets, sizeof(UA_BrowsePathTarget) *
  892. (result->targetsSize + (*currentCount)));
  893. if(!newTargets) {
  894. result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
  895. for(size_t i = 0; i < *currentCount; ++i)
  896. UA_NodeId_clear(&(*current)[i]);
  897. *currentCount = 0;
  898. return;
  899. }
  900. result->targets = newTargets;
  901. }
  902. /* Move the elements of current to the targets */
  903. addBrowsePathTargets(server, session, nodeClassMask, result, targetName, *current, *currentCount);
  904. *currentCount = 0;
  905. }
  906. static void
  907. Operation_TranslateBrowsePathToNodeIds(UA_Server *server, UA_Session *session,
  908. const UA_UInt32 *nodeClassMask, const UA_BrowsePath *path,
  909. UA_BrowsePathResult *result) {
  910. UA_LOCK_ASSERT(server->serviceMutex, 1);
  911. if(path->relativePath.elementsSize <= 0) {
  912. result->statusCode = UA_STATUSCODE_BADNOTHINGTODO;
  913. return;
  914. }
  915. /* RelativePath elements must not have an empty targetName */
  916. for(size_t i = 0; i < path->relativePath.elementsSize; ++i) {
  917. if(UA_QualifiedName_isNull(&path->relativePath.elements[i].targetName)) {
  918. result->statusCode = UA_STATUSCODE_BADBROWSENAMEINVALID;
  919. return;
  920. }
  921. }
  922. /* Allocate memory for the targets */
  923. size_t targetsSize = 10; /* When to realloc; the member count is stored in
  924. * result->targetsSize */
  925. result->targets =
  926. (UA_BrowsePathTarget*)UA_malloc(sizeof(UA_BrowsePathTarget) * targetsSize);
  927. if(!result->targets) {
  928. result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
  929. return;
  930. }
  931. /* Allocate memory for two temporary arrays. One with the results for the
  932. * previous depth of the path. The other for the new results at the current
  933. * depth. The two arrays alternate as we descend down the tree. */
  934. size_t currentSize = 10; /* When to realloc */
  935. size_t currentCount = 0; /* Current elements */
  936. UA_NodeId *current = (UA_NodeId*)UA_malloc(sizeof(UA_NodeId) * currentSize);
  937. if(!current) {
  938. result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
  939. UA_free(result->targets);
  940. return;
  941. }
  942. size_t nextSize = 10; /* When to realloc */
  943. size_t nextCount = 0; /* Current elements */
  944. UA_NodeId *next = (UA_NodeId*)UA_malloc(sizeof(UA_NodeId) * nextSize);
  945. if(!next) {
  946. result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
  947. UA_free(result->targets);
  948. UA_free(current);
  949. return;
  950. }
  951. /* Copy the starting node into current */
  952. result->statusCode = UA_NodeId_copy(&path->startingNode, &current[0]);
  953. if(result->statusCode != UA_STATUSCODE_GOOD) {
  954. UA_free(result->targets);
  955. UA_free(current);
  956. UA_free(next);
  957. return;
  958. }
  959. currentCount = 1;
  960. /* Walk the path elements */
  961. walkBrowsePath(server, session, path, *nodeClassMask, result, targetsSize,
  962. &current, &currentSize, &currentCount,
  963. &next, &nextSize, &nextCount);
  964. UA_assert(currentCount == 0);
  965. UA_assert(nextCount == 0);
  966. /* No results => BadNoMatch status code */
  967. if(result->targetsSize == 0 && result->statusCode == UA_STATUSCODE_GOOD)
  968. result->statusCode = UA_STATUSCODE_BADNOMATCH;
  969. /* Clean up the temporary arrays and the targets */
  970. UA_free(current);
  971. UA_free(next);
  972. if(result->statusCode != UA_STATUSCODE_GOOD) {
  973. for(size_t i = 0; i < result->targetsSize; ++i)
  974. UA_BrowsePathTarget_clear(&result->targets[i]);
  975. UA_free(result->targets);
  976. result->targets = NULL;
  977. result->targetsSize = 0;
  978. }
  979. }
  980. UA_BrowsePathResult
  981. translateBrowsePathToNodeIds(UA_Server *server,
  982. const UA_BrowsePath *browsePath) {
  983. UA_LOCK_ASSERT(server->serviceMutex, 1);
  984. UA_BrowsePathResult result;
  985. UA_BrowsePathResult_init(&result);
  986. UA_UInt32 nodeClassMask = 0; /* All node classes */
  987. Operation_TranslateBrowsePathToNodeIds(server, &server->adminSession, &nodeClassMask,
  988. browsePath, &result);
  989. return result;
  990. }
  991. UA_BrowsePathResult
  992. UA_Server_translateBrowsePathToNodeIds(UA_Server *server,
  993. const UA_BrowsePath *browsePath) {
  994. UA_LOCK(server->serviceMutex);
  995. UA_BrowsePathResult result = translateBrowsePathToNodeIds(server, browsePath);
  996. UA_UNLOCK(server->serviceMutex);
  997. return result;
  998. }
  999. void
  1000. Service_TranslateBrowsePathsToNodeIds(UA_Server *server, UA_Session *session,
  1001. const UA_TranslateBrowsePathsToNodeIdsRequest *request,
  1002. UA_TranslateBrowsePathsToNodeIdsResponse *response) {
  1003. UA_LOG_DEBUG_SESSION(&server->config.logger, session,
  1004. "Processing TranslateBrowsePathsToNodeIdsRequest");
  1005. UA_LOCK_ASSERT(server->serviceMutex, 1);
  1006. /* Test the number of operations in the request */
  1007. if(server->config.maxNodesPerTranslateBrowsePathsToNodeIds != 0 &&
  1008. request->browsePathsSize > server->config.maxNodesPerTranslateBrowsePathsToNodeIds) {
  1009. response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS;
  1010. return;
  1011. }
  1012. UA_UInt32 nodeClassMask = 0; /* All node classes */
  1013. response->responseHeader.serviceResult =
  1014. UA_Server_processServiceOperations(server, session,
  1015. (UA_ServiceOperation)Operation_TranslateBrowsePathToNodeIds,
  1016. &nodeClassMask,
  1017. &request->browsePathsSize, &UA_TYPES[UA_TYPES_BROWSEPATH],
  1018. &response->resultsSize, &UA_TYPES[UA_TYPES_BROWSEPATHRESULT]);
  1019. }
  1020. UA_BrowsePathResult
  1021. browseSimplifiedBrowsePath(UA_Server *server, const UA_NodeId origin,
  1022. size_t browsePathSize, const UA_QualifiedName *browsePath) {
  1023. UA_LOCK_ASSERT(server->serviceMutex, 1);
  1024. /* Construct the BrowsePath */
  1025. UA_BrowsePath bp;
  1026. UA_BrowsePath_init(&bp);
  1027. bp.startingNode = origin;
  1028. UA_STACKARRAY(UA_RelativePathElement, rpe, browsePathSize);
  1029. memset(rpe, 0, sizeof(UA_RelativePathElement) * browsePathSize);
  1030. for(size_t j = 0; j < browsePathSize; j++) {
  1031. rpe[j].referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HIERARCHICALREFERENCES);
  1032. rpe[j].includeSubtypes = true;
  1033. rpe[j].targetName = browsePath[j];
  1034. }
  1035. bp.relativePath.elements = rpe;
  1036. bp.relativePath.elementsSize = browsePathSize;
  1037. /* Browse */
  1038. UA_BrowsePathResult bpr;
  1039. UA_BrowsePathResult_init(&bpr);
  1040. UA_UInt32 nodeClassMask = UA_NODECLASS_OBJECT | UA_NODECLASS_VARIABLE;
  1041. Operation_TranslateBrowsePathToNodeIds(server, &server->adminSession, &nodeClassMask, &bp, &bpr);
  1042. return bpr;
  1043. }
  1044. UA_BrowsePathResult
  1045. UA_Server_browseSimplifiedBrowsePath(UA_Server *server, const UA_NodeId origin,
  1046. size_t browsePathSize, const UA_QualifiedName *browsePath) {
  1047. UA_LOCK(server->serviceMutex);
  1048. UA_BrowsePathResult bpr = browseSimplifiedBrowsePath(server, origin, browsePathSize, browsePath);;
  1049. UA_UNLOCK(server->serviceMutex);
  1050. return bpr;
  1051. }
  1052. /************/
  1053. /* Register */
  1054. /************/
  1055. void Service_RegisterNodes(UA_Server *server, UA_Session *session,
  1056. const UA_RegisterNodesRequest *request,
  1057. UA_RegisterNodesResponse *response) {
  1058. UA_LOG_DEBUG_SESSION(&server->config.logger, session,
  1059. "Processing RegisterNodesRequest");
  1060. UA_LOCK_ASSERT(server->serviceMutex, 1);
  1061. //TODO: hang the nodeids to the session if really needed
  1062. if(request->nodesToRegisterSize == 0) {
  1063. response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
  1064. return;
  1065. }
  1066. /* Test the number of operations in the request */
  1067. if(server->config.maxNodesPerRegisterNodes != 0 &&
  1068. request->nodesToRegisterSize > server->config.maxNodesPerRegisterNodes) {
  1069. response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS;
  1070. return;
  1071. }
  1072. response->responseHeader.serviceResult =
  1073. UA_Array_copy(request->nodesToRegister, request->nodesToRegisterSize,
  1074. (void**)&response->registeredNodeIds, &UA_TYPES[UA_TYPES_NODEID]);
  1075. if(response->responseHeader.serviceResult == UA_STATUSCODE_GOOD)
  1076. response->registeredNodeIdsSize = request->nodesToRegisterSize;
  1077. }
  1078. void Service_UnregisterNodes(UA_Server *server, UA_Session *session,
  1079. const UA_UnregisterNodesRequest *request,
  1080. UA_UnregisterNodesResponse *response) {
  1081. UA_LOG_DEBUG_SESSION(&server->config.logger, session,
  1082. "Processing UnRegisterNodesRequest");
  1083. UA_LOCK_ASSERT(server->serviceMutex, 1);
  1084. //TODO: remove the nodeids from the session if really needed
  1085. if(request->nodesToUnregisterSize == 0)
  1086. response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
  1087. /* Test the number of operations in the request */
  1088. if(server->config.maxNodesPerRegisterNodes != 0 &&
  1089. request->nodesToUnregisterSize > server->config.maxNodesPerRegisterNodes) {
  1090. response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS;
  1091. return;
  1092. }
  1093. }