ua_services_view.c 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680
  1. #include "ua_server_internal.h"
  2. #include "ua_services.h"
  3. #include "ua_statuscodes.h"
  4. #include "ua_nodestore.h"
  5. #include "ua_util.h"
  6. static UA_StatusCode
  7. fillReferenceDescription(UA_NodeStore *ns, const UA_Node *curr, UA_ReferenceNode *ref,
  8. UA_UInt32 mask, UA_ReferenceDescription *descr) {
  9. UA_ReferenceDescription_init(descr);
  10. UA_StatusCode retval = UA_NodeId_copy(&curr->nodeId, &descr->nodeId.nodeId);
  11. //TODO: ExpandedNodeId is mocked up
  12. descr->nodeId.serverIndex = 0;
  13. descr->nodeId.namespaceUri.length = -1;
  14. if(mask & UA_BROWSERESULTMASK_REFERENCETYPEID)
  15. retval |= UA_NodeId_copy(&ref->referenceTypeId, &descr->referenceTypeId);
  16. if(mask & UA_BROWSERESULTMASK_ISFORWARD)
  17. descr->isForward = !ref->isInverse;
  18. if(mask & UA_BROWSERESULTMASK_NODECLASS)
  19. retval |= UA_NodeClass_copy(&curr->nodeClass, &descr->nodeClass);
  20. if(mask & UA_BROWSERESULTMASK_BROWSENAME)
  21. retval |= UA_QualifiedName_copy(&curr->browseName, &descr->browseName);
  22. if(mask & UA_BROWSERESULTMASK_DISPLAYNAME)
  23. retval |= UA_LocalizedText_copy(&curr->displayName, &descr->displayName);
  24. if(mask & UA_BROWSERESULTMASK_TYPEDEFINITION){
  25. if(curr->nodeClass == UA_NODECLASS_OBJECT || curr->nodeClass == UA_NODECLASS_VARIABLE) {
  26. for(UA_Int32 i = 0; i < curr->referencesSize; i++) {
  27. UA_ReferenceNode *refnode = &curr->references[i];
  28. if(refnode->referenceTypeId.identifier.numeric != UA_NS0ID_HASTYPEDEFINITION)
  29. continue;
  30. retval |= UA_ExpandedNodeId_copy(&refnode->targetId, &descr->typeDefinition);
  31. break;
  32. }
  33. }
  34. }
  35. if(retval)
  36. UA_ReferenceDescription_deleteMembers(descr);
  37. return retval;
  38. }
  39. /* Tests if the node is relevant to the browse request and shall be returned. If
  40. so, it is retrieved from the Nodestore. If not, null is returned. */
  41. static const UA_Node *
  42. isRelevantNode(UA_Server *server, const UA_BrowseDescription *descr, UA_Boolean return_all,
  43. UA_ReferenceNode *reference, UA_NodeId *relevant, size_t relevant_count, UA_Boolean *isExternal) {
  44. if(reference->isInverse == UA_TRUE && descr->browseDirection == UA_BROWSEDIRECTION_FORWARD)
  45. return UA_NULL;
  46. else if(reference->isInverse == UA_FALSE && descr->browseDirection == UA_BROWSEDIRECTION_INVERSE)
  47. return UA_NULL;
  48. if(!return_all) {
  49. for(size_t i = 0; i < relevant_count; i++) {
  50. if(UA_NodeId_equal(&reference->referenceTypeId, &relevant[i]))
  51. goto is_relevant;
  52. }
  53. return UA_NULL;
  54. }
  55. is_relevant: ;
  56. *isExternal = UA_FALSE;
  57. #ifdef UA_EXTERNAL_NAMESPACES
  58. const UA_Node *node = NULL;
  59. size_t nsIndex;
  60. for(nsIndex = 0; nsIndex < server->externalNamespacesSize; nsIndex++) {
  61. if(reference->targetId.nodeId.namespaceIndex != server->externalNamespaces[nsIndex].index)
  62. continue;
  63. else{
  64. *isExternal = UA_TRUE;
  65. break;
  66. }
  67. }
  68. if(*isExternal == UA_FALSE) {
  69. node = UA_NodeStore_get(server->nodestore, &reference->targetId.nodeId);
  70. } else {
  71. /* prepare a read request in the external nodestore */
  72. UA_ExternalNodeStore *ens = &server->externalNamespaces[nsIndex].externalNodeStore;
  73. UA_ReadValueId *readValueIds = UA_Array_new(&UA_TYPES[UA_TYPES_READVALUEID], 6);
  74. UA_UInt32 *indices = UA_Array_new(&UA_TYPES[UA_TYPES_UINT32], 6);
  75. UA_UInt32 indicesSize = 6;
  76. UA_DataValue *readNodesResults = UA_Array_new(&UA_TYPES[UA_TYPES_DATAVALUE], 6);
  77. UA_DiagnosticInfo *diagnosticInfos = UA_Array_new(&UA_TYPES[UA_TYPES_DIAGNOSTICINFO], 6);
  78. for(UA_UInt32 i = 0; i<6; i++){
  79. readValueIds[i].nodeId = reference->targetId.nodeId;
  80. UA_String_init(&(readValueIds[i].indexRange));
  81. UA_QualifiedName_init(&(readValueIds[i].dataEncoding));
  82. indices[i] = i;
  83. UA_DataValue_init(&(readNodesResults[i]));
  84. UA_DiagnosticInfo_init(&(diagnosticInfos[i]));
  85. }
  86. readValueIds[0].attributeId = UA_ATTRIBUTEID_NODECLASS;
  87. readValueIds[1].attributeId = UA_ATTRIBUTEID_BROWSENAME;
  88. readValueIds[2].attributeId = UA_ATTRIBUTEID_DISPLAYNAME;
  89. readValueIds[3].attributeId = UA_ATTRIBUTEID_DESCRIPTION;
  90. readValueIds[4].attributeId = UA_ATTRIBUTEID_WRITEMASK;
  91. readValueIds[5].attributeId = UA_ATTRIBUTEID_USERWRITEMASK;
  92. ens->readNodes(ens->ensHandle, NULL, readValueIds,
  93. indices, indicesSize, readNodesResults, UA_FALSE, diagnosticInfos);
  94. /* create and fill a dummy nodeStructure */
  95. UA_Node *tempNode = (UA_Node*) UA_ObjectNode_new();
  96. UA_NodeId_copy(&(reference->targetId.nodeId), &(tempNode->nodeId));
  97. if(readNodesResults[0].status == UA_STATUSCODE_GOOD)
  98. UA_NodeClass_copy((UA_NodeClass*)readNodesResults[0].value.data, &(tempNode->nodeClass));
  99. if(readNodesResults[1].status == UA_STATUSCODE_GOOD)
  100. UA_QualifiedName_copy((UA_QualifiedName*)readNodesResults[1].value.data, &(tempNode->browseName));
  101. if(readNodesResults[2].status == UA_STATUSCODE_GOOD)
  102. UA_LocalizedText_copy((UA_LocalizedText*)readNodesResults[2].value.data, &(tempNode->displayName));
  103. if(readNodesResults[3].status == UA_STATUSCODE_GOOD)
  104. UA_LocalizedText_copy((UA_LocalizedText*)readNodesResults[3].value.data, &(tempNode->description));
  105. if(readNodesResults[4].status == UA_STATUSCODE_GOOD)
  106. UA_UInt32_copy((UA_UInt32*)readNodesResults[4].value.data, &(tempNode->writeMask));
  107. if(readNodesResults[5].status == UA_STATUSCODE_GOOD)
  108. UA_UInt32_copy((UA_UInt32*)readNodesResults[5].value.data, &(tempNode->userWriteMask));
  109. UA_Array_delete(readValueIds, &UA_TYPES[UA_TYPES_READVALUEID], 6);
  110. UA_Array_delete(indices, &UA_TYPES[UA_TYPES_UINT32], 6);
  111. UA_Array_delete(readNodesResults, &UA_TYPES[UA_TYPES_DATAVALUE], 6);
  112. UA_Array_delete(diagnosticInfos, &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], 6);
  113. node = tempNode;
  114. }
  115. #else
  116. const UA_Node *node = UA_NodeStore_get(server->nodestore, &reference->targetId.nodeId);
  117. #endif
  118. if(node && descr->nodeClassMask != 0 && (node->nodeClass & descr->nodeClassMask) == 0) {
  119. #ifdef UA_EXTERNAL_NAMESPACES
  120. if(*isExternal == UA_TRUE){
  121. UA_ObjectNode_delete((UA_ObjectNode*)node);
  122. } else
  123. #endif
  124. UA_NodeStore_release(node);
  125. return UA_NULL;
  126. }
  127. return node;
  128. }
  129. /**
  130. * We find all subtypes by a single iteration over the array. We start with an array with a single
  131. * root nodeid at the beginning. When we find relevant references, we add the nodeids to the back of
  132. * the array and increase the size. Since the hierarchy is not cyclic, we can safely progress in the
  133. * array to process the newly found referencetype nodeids (emulated recursion).
  134. */
  135. static UA_StatusCode
  136. findSubTypes(UA_NodeStore *ns, const UA_NodeId *root, UA_NodeId **reftypes, size_t *reftypes_count) {
  137. const UA_Node *node = UA_NodeStore_get(ns, root);
  138. if(!node)
  139. return UA_STATUSCODE_BADNOMATCH;
  140. if(node->nodeClass != UA_NODECLASS_REFERENCETYPE) {
  141. UA_NodeStore_release(node);
  142. return UA_STATUSCODE_BADREFERENCETYPEIDINVALID;
  143. }
  144. UA_NodeStore_release(node);
  145. size_t results_size = 20; // probably too big, but saves mallocs
  146. UA_NodeId *results = UA_malloc(sizeof(UA_NodeId) * results_size);
  147. if(!results)
  148. return UA_STATUSCODE_BADOUTOFMEMORY;
  149. UA_StatusCode retval = UA_NodeId_copy(root, &results[0]);
  150. if(retval != UA_STATUSCODE_GOOD) {
  151. UA_free(results);
  152. return retval;
  153. }
  154. size_t index = 0; // where are we currently in the array?
  155. size_t last = 0; // where is the last element in the array?
  156. do {
  157. node = UA_NodeStore_get(ns, &results[index]);
  158. if(!node || node->nodeClass != UA_NODECLASS_REFERENCETYPE)
  159. continue;
  160. for(UA_Int32 i = 0; i < node->referencesSize; i++) {
  161. if(node->references[i].referenceTypeId.identifier.numeric != UA_NS0ID_HASSUBTYPE ||
  162. node->references[i].isInverse == UA_TRUE)
  163. continue;
  164. if(++last >= results_size) { // is the array big enough?
  165. UA_NodeId *new_results = UA_realloc(results, sizeof(UA_NodeId) * results_size * 2);
  166. if(!new_results) {
  167. retval = UA_STATUSCODE_BADOUTOFMEMORY;
  168. break;
  169. }
  170. results = new_results;
  171. results_size *= 2;
  172. }
  173. retval = UA_NodeId_copy(&node->references[i].targetId.nodeId, &results[last]);
  174. if(retval != UA_STATUSCODE_GOOD) {
  175. last--; // for array_delete
  176. break;
  177. }
  178. }
  179. UA_NodeStore_release(node);
  180. } while(++index <= last && retval == UA_STATUSCODE_GOOD);
  181. if(retval) {
  182. UA_Array_delete(results, &UA_TYPES[UA_TYPES_NODEID], last);
  183. return retval;
  184. }
  185. *reftypes = results;
  186. *reftypes_count = last + 1;
  187. return UA_STATUSCODE_GOOD;
  188. }
  189. static void removeCp(struct ContinuationPointEntry *cp, UA_Session* session) {
  190. session->availableContinuationPoints++;
  191. UA_ByteString_deleteMembers(&cp->identifier);
  192. UA_BrowseDescription_deleteMembers(&cp->browseDescription);
  193. LIST_REMOVE(cp, pointers);
  194. UA_free(cp);
  195. }
  196. /**
  197. * Results for a single browsedescription. This is the inner loop for both Browse and BrowseNext
  198. * @param session Session to save continuationpoints
  199. * @param ns The nodstore where the to-be-browsed node can be found
  200. * @param cp If cp is not null, we continue from here
  201. * If cp is null, we can add a new continuation point if possible and necessary.
  202. * @param descr If no cp is set, we take the browsedescription from there
  203. * @param maxrefs The maximum number of references the client has requested
  204. * @param result The entry in the request
  205. */
  206. void
  207. Service_Browse_single(UA_Server *server, UA_Session *session, struct ContinuationPointEntry *cp,
  208. const UA_BrowseDescription *descr, UA_UInt32 maxrefs, UA_BrowseResult *result) {
  209. UA_UInt32 continuationIndex = 0;
  210. size_t referencesCount = 0;
  211. UA_Int32 referencesIndex = 0;
  212. /* set the browsedescription if a cp is given */
  213. if(cp) {
  214. descr = &cp->browseDescription;
  215. maxrefs = cp->maxReferences;
  216. continuationIndex = cp->continuationIndex;
  217. }
  218. /* is the browsedirection valid? */
  219. if(descr->browseDirection != UA_BROWSEDIRECTION_BOTH &&
  220. descr->browseDirection != UA_BROWSEDIRECTION_FORWARD &&
  221. descr->browseDirection != UA_BROWSEDIRECTION_INVERSE) {
  222. result->statusCode = UA_STATUSCODE_BADBROWSEDIRECTIONINVALID;
  223. return;
  224. }
  225. /* get the references that match the browsedescription */
  226. size_t relevant_refs_size = 0;
  227. UA_NodeId *relevant_refs = UA_NULL;
  228. UA_Boolean all_refs = UA_NodeId_isNull(&descr->referenceTypeId);
  229. if(!all_refs) {
  230. if(descr->includeSubtypes) {
  231. result->statusCode = findSubTypes(server->nodestore, &descr->referenceTypeId,
  232. &relevant_refs, &relevant_refs_size);
  233. if(result->statusCode != UA_STATUSCODE_GOOD)
  234. return;
  235. } else {
  236. const UA_Node *rootRef = UA_NodeStore_get(server->nodestore, &descr->referenceTypeId);
  237. if(!rootRef) {
  238. result->statusCode = UA_STATUSCODE_BADREFERENCETYPEIDINVALID;
  239. return;
  240. }
  241. if(rootRef->nodeClass != UA_NODECLASS_REFERENCETYPE) {
  242. UA_NodeStore_release(rootRef);
  243. result->statusCode = UA_STATUSCODE_BADREFERENCETYPEIDINVALID;
  244. return;
  245. }
  246. UA_NodeStore_release(rootRef);
  247. relevant_refs = (UA_NodeId*)(uintptr_t)&descr->referenceTypeId;
  248. relevant_refs_size = 1;
  249. }
  250. }
  251. /* get the node */
  252. const UA_Node *node = UA_NodeStore_get(server->nodestore, &descr->nodeId);
  253. if(!node) {
  254. result->statusCode = UA_STATUSCODE_BADNODEIDUNKNOWN;
  255. if(!all_refs && descr->includeSubtypes)
  256. UA_Array_delete(relevant_refs, &UA_TYPES[UA_TYPES_NODEID], relevant_refs_size);
  257. return;
  258. }
  259. /* if the node has no references, just return */
  260. if(node->referencesSize <= 0) {
  261. result->referencesSize = 0;
  262. UA_NodeStore_release(node);
  263. if(!all_refs && descr->includeSubtypes)
  264. UA_Array_delete(relevant_refs, &UA_TYPES[UA_TYPES_NODEID], relevant_refs_size);
  265. return;
  266. }
  267. /* how many references can we return at most? */
  268. UA_UInt32 real_maxrefs = maxrefs;
  269. if(real_maxrefs == 0)
  270. real_maxrefs = node->referencesSize;
  271. result->references = UA_malloc(sizeof(UA_ReferenceDescription) * real_maxrefs);
  272. if(!result->references) {
  273. result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
  274. goto cleanup;
  275. }
  276. /* loop over the node's references */
  277. size_t skipped = 0;
  278. UA_Boolean isExternal = UA_FALSE;
  279. for(; referencesIndex < node->referencesSize && referencesCount < real_maxrefs; referencesIndex++) {
  280. isExternal = UA_FALSE;
  281. const UA_Node *current = isRelevantNode(server, descr, all_refs, &node->references[referencesIndex],
  282. relevant_refs, relevant_refs_size, &isExternal);
  283. if(!current)
  284. continue;
  285. if(skipped < continuationIndex) {
  286. #ifdef UA_EXTERNAL_NAMESPACES
  287. if(isExternal == UA_TRUE)
  288. /* relevant_node returns a node malloced with UA_ObjectNode_new if it is external (there is no UA_Node_new function) */
  289. UA_ObjectNode_delete((UA_ObjectNode*)current);
  290. else
  291. UA_NodeStore_release(current);
  292. #else
  293. UA_NodeStore_release(current);
  294. #endif
  295. skipped++;
  296. continue;
  297. }
  298. UA_StatusCode retval = fillReferenceDescription(server->nodestore, current, &node->references[referencesIndex],
  299. descr->resultMask, &result->references[referencesCount]);
  300. #ifdef UA_EXTERNAL_NAMESPACES
  301. if(isExternal == UA_TRUE)
  302. UA_ObjectNode_delete((UA_ObjectNode*)current);
  303. else
  304. UA_NodeStore_release(current);
  305. #else
  306. UA_NodeStore_release(current);
  307. #endif
  308. if(retval != UA_STATUSCODE_GOOD) {
  309. UA_Array_delete(result->references, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION], referencesCount);
  310. result->references = UA_NULL;
  311. result->referencesSize = 0;
  312. result->statusCode = UA_STATUSCODE_UNCERTAINNOTALLNODESAVAILABLE;
  313. goto cleanup;
  314. }
  315. referencesCount++;
  316. }
  317. result->referencesSize = referencesCount;
  318. if(referencesCount == 0) {
  319. UA_free(result->references);
  320. result->references = UA_NULL;
  321. }
  322. cleanup:
  323. UA_NodeStore_release(node);
  324. if(!all_refs && descr->includeSubtypes)
  325. UA_Array_delete(relevant_refs, &UA_TYPES[UA_TYPES_NODEID], relevant_refs_size);
  326. if(result->statusCode != UA_STATUSCODE_GOOD)
  327. return;
  328. /* create, update, delete continuation points */
  329. if(cp) {
  330. if(referencesIndex == node->referencesSize) {
  331. /* all done, remove a finished continuationPoint */
  332. removeCp(cp, session);
  333. } else {
  334. /* update the cp and return the cp identifier */
  335. cp->continuationIndex += referencesCount;
  336. UA_ByteString_copy(&cp->identifier, &result->continuationPoint);
  337. }
  338. } else if(maxrefs != 0 && referencesCount >= maxrefs) {
  339. /* create a cp */
  340. if(session->availableContinuationPoints <= 0 ||
  341. !(cp = UA_malloc(sizeof(struct ContinuationPointEntry)))) {
  342. result->statusCode = UA_STATUSCODE_BADNOCONTINUATIONPOINTS;
  343. return;
  344. }
  345. UA_BrowseDescription_copy(descr, &cp->browseDescription);
  346. cp->maxReferences = maxrefs;
  347. cp->continuationIndex = referencesCount;
  348. UA_Guid *ident = UA_Guid_new();
  349. UA_UInt32 seed = (uintptr_t)cp;
  350. *ident = UA_Guid_random(&seed);
  351. cp->identifier.data = (UA_Byte*)ident;
  352. cp->identifier.length = sizeof(UA_Guid);
  353. UA_ByteString_copy(&cp->identifier, &result->continuationPoint);
  354. /* store the cp */
  355. LIST_INSERT_HEAD(&session->continuationPoints, cp, pointers);
  356. session->availableContinuationPoints--;
  357. }
  358. }
  359. void Service_Browse(UA_Server *server, UA_Session *session, const UA_BrowseRequest *request,
  360. UA_BrowseResponse *response) {
  361. if(!UA_NodeId_isNull(&request->view.viewId)) {
  362. response->responseHeader.serviceResult = UA_STATUSCODE_BADVIEWIDUNKNOWN;
  363. return;
  364. }
  365. if(request->nodesToBrowseSize <= 0) {
  366. response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
  367. return;
  368. }
  369. size_t size = request->nodesToBrowseSize;
  370. response->results = UA_Array_new(&UA_TYPES[UA_TYPES_BROWSERESULT], size);
  371. if(!response->results) {
  372. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  373. return;
  374. }
  375. response->resultsSize = size;
  376. #ifdef UA_EXTERNAL_NAMESPACES
  377. #ifdef NO_ALLOCA
  378. UA_Boolean isExternal[size];
  379. UA_UInt32 indices[size];
  380. #else
  381. UA_Boolean *isExternal = UA_alloca(sizeof(UA_Boolean) * size);
  382. UA_UInt32 *indices = UA_alloca(sizeof(UA_UInt32) * size);
  383. #endif /*NO_ALLOCA */
  384. UA_memset(isExternal, UA_FALSE, sizeof(UA_Boolean) * size);
  385. for(size_t j = 0; j < server->externalNamespacesSize; j++) {
  386. size_t indexSize = 0;
  387. for(size_t i = 0; i < size; i++) {
  388. if(request->nodesToBrowse[i].nodeId.namespaceIndex != server->externalNamespaces[j].index)
  389. continue;
  390. isExternal[i] = UA_TRUE;
  391. indices[indexSize] = i;
  392. indexSize++;
  393. }
  394. if(indexSize == 0)
  395. continue;
  396. UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
  397. ens->browseNodes(ens->ensHandle, &request->requestHeader, request->nodesToBrowse, indices, indexSize,
  398. request->requestedMaxReferencesPerNode, response->results, response->diagnosticInfos);
  399. }
  400. #endif
  401. for(size_t i = 0; i < size; i++) {
  402. #ifdef UA_EXTERNAL_NAMESPACES
  403. if(!isExternal[i])
  404. #endif
  405. Service_Browse_single(server, session, UA_NULL, &request->nodesToBrowse[i],
  406. request->requestedMaxReferencesPerNode, &response->results[i]);
  407. }
  408. }
  409. void Service_BrowseNext(UA_Server *server, UA_Session *session, const UA_BrowseNextRequest *request,
  410. UA_BrowseNextResponse *response) {
  411. if(request->continuationPointsSize <= 0) {
  412. response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
  413. return;
  414. }
  415. size_t size = request->continuationPointsSize;
  416. if(!request->releaseContinuationPoints) {
  417. /* continue with the cp */
  418. response->results = UA_Array_new(&UA_TYPES[UA_TYPES_BROWSERESULT], size);
  419. if(!response->results) {
  420. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  421. return;
  422. }
  423. response->resultsSize = size;
  424. for(size_t i = 0; i < size; i++) {
  425. struct ContinuationPointEntry *cp;
  426. LIST_FOREACH(cp, &session->continuationPoints, pointers) {
  427. if(UA_ByteString_equal(&cp->identifier, &request->continuationPoints[i])) {
  428. Service_Browse_single(server, session, cp, UA_NULL, 0, &response->results[i]);
  429. break;
  430. }
  431. }
  432. if(!cp)
  433. response->results[i].statusCode = UA_STATUSCODE_BADCONTINUATIONPOINTINVALID;
  434. }
  435. } else {
  436. /* remove the cp */
  437. response->results = UA_Array_new(&UA_TYPES[UA_TYPES_BROWSERESULT], size);
  438. if(!response->results) {
  439. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  440. return;
  441. }
  442. response->resultsSize = size;
  443. for(size_t i = 0; i < size; i++) {
  444. struct ContinuationPointEntry *cp = UA_NULL;
  445. LIST_FOREACH(cp, &session->continuationPoints, pointers) {
  446. if(UA_ByteString_equal(&cp->identifier, &request->continuationPoints[i])) {
  447. removeCp(cp, session);
  448. break;
  449. }
  450. }
  451. if(!cp)
  452. response->results[i].statusCode = UA_STATUSCODE_BADCONTINUATIONPOINTINVALID;
  453. }
  454. }
  455. }
  456. /***********************/
  457. /* TranslateBrowsePath */
  458. /***********************/
  459. static UA_StatusCode
  460. walkBrowsePath(UA_Server *server, UA_Session *session, const UA_Node *node, const UA_RelativePath *path,
  461. UA_Int32 pathindex, UA_BrowsePathTarget **targets, UA_Int32 *targets_size,
  462. UA_Int32 *target_count) {
  463. const UA_RelativePathElement *elem = &path->elements[pathindex];
  464. if(elem->targetName.name.length == -1)
  465. return UA_STATUSCODE_BADBROWSENAMEINVALID;
  466. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  467. UA_NodeId *reftypes = UA_NULL;
  468. size_t reftypes_count = 1; // all_refs or no subtypes => 1
  469. UA_Boolean all_refs = UA_FALSE;
  470. if(UA_NodeId_isNull(&elem->referenceTypeId))
  471. all_refs = UA_TRUE;
  472. else if(!elem->includeSubtypes)
  473. reftypes = (UA_NodeId*)(uintptr_t)&elem->referenceTypeId; // ptr magic due to const cast
  474. else {
  475. retval = findSubTypes(server->nodestore, &elem->referenceTypeId, &reftypes, &reftypes_count);
  476. if(retval != UA_STATUSCODE_GOOD)
  477. return retval;
  478. }
  479. for(UA_Int32 i = 0; i < node->referencesSize && retval == UA_STATUSCODE_GOOD; i++) {
  480. UA_Boolean match = all_refs;
  481. for(size_t j = 0; j < reftypes_count && !match; j++) {
  482. if(node->references[i].isInverse == elem->isInverse &&
  483. UA_NodeId_equal(&node->references[i].referenceTypeId, &reftypes[j]))
  484. match = UA_TRUE;
  485. }
  486. if(!match)
  487. continue;
  488. // get the node, todo: expandednodeid
  489. const UA_Node *next = UA_NodeStore_get(server->nodestore, &node->references[i].targetId.nodeId);
  490. if(!next)
  491. continue;
  492. // test the browsename
  493. if(elem->targetName.namespaceIndex != next->browseName.namespaceIndex ||
  494. !UA_String_equal(&elem->targetName.name, &next->browseName.name)) {
  495. UA_NodeStore_release(next);
  496. continue;
  497. }
  498. if(pathindex + 1 < path->elementsSize) {
  499. // recursion if the path is longer
  500. retval = walkBrowsePath(server, session, next, path, pathindex + 1,
  501. targets, targets_size, target_count);
  502. UA_NodeStore_release(next);
  503. } else {
  504. // add the browsetarget
  505. if(*target_count >= *targets_size) {
  506. UA_BrowsePathTarget *newtargets;
  507. newtargets = UA_realloc(targets, sizeof(UA_BrowsePathTarget) * (*targets_size) * 2);
  508. if(!newtargets) {
  509. retval = UA_STATUSCODE_BADOUTOFMEMORY;
  510. UA_NodeStore_release(next);
  511. break;
  512. }
  513. *targets = newtargets;
  514. *targets_size *= 2;
  515. }
  516. UA_BrowsePathTarget *res = *targets;
  517. UA_ExpandedNodeId_init(&res[*target_count].targetId);
  518. retval = UA_NodeId_copy(&next->nodeId, &res[*target_count].targetId.nodeId);
  519. UA_NodeStore_release(next);
  520. if(retval != UA_STATUSCODE_GOOD)
  521. break;
  522. res[*target_count].remainingPathIndex = UA_UINT32_MAX;
  523. *target_count += 1;
  524. }
  525. }
  526. if(!all_refs && elem->includeSubtypes)
  527. UA_Array_delete(reftypes, &UA_TYPES[UA_TYPES_NODEID], (UA_Int32)reftypes_count);
  528. return retval;
  529. }
  530. static void
  531. translateBrowsePath(UA_Server *server, UA_Session *session, const UA_BrowsePath *path,
  532. UA_BrowsePathResult *result) {
  533. if(path->relativePath.elementsSize <= 0) {
  534. result->statusCode = UA_STATUSCODE_BADNOTHINGTODO;
  535. return;
  536. }
  537. UA_Int32 arraySize = 10;
  538. result->targets = UA_malloc(sizeof(UA_BrowsePathTarget) * arraySize);
  539. if(!result->targets) {
  540. result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
  541. return;
  542. }
  543. result->targetsSize = 0;
  544. const UA_Node *firstNode = UA_NodeStore_get(server->nodestore, &path->startingNode);
  545. if(!firstNode) {
  546. result->statusCode = UA_STATUSCODE_BADNODEIDUNKNOWN;
  547. UA_free(result->targets);
  548. result->targets = UA_NULL;
  549. return;
  550. }
  551. result->statusCode = walkBrowsePath(server, session, firstNode, &path->relativePath, 0,
  552. &result->targets, &arraySize, &result->targetsSize);
  553. UA_NodeStore_release(firstNode);
  554. if(result->targetsSize == 0 && result->statusCode == UA_STATUSCODE_GOOD)
  555. result->statusCode = UA_STATUSCODE_BADNOMATCH;
  556. if(result->statusCode != UA_STATUSCODE_GOOD) {
  557. UA_Array_delete(result->targets, &UA_TYPES[UA_TYPES_BROWSEPATHTARGET], result->targetsSize);
  558. result->targets = UA_NULL;
  559. result->targetsSize = -1;
  560. }
  561. }
  562. void Service_TranslateBrowsePathsToNodeIds(UA_Server *server, UA_Session *session,
  563. const UA_TranslateBrowsePathsToNodeIdsRequest *request,
  564. UA_TranslateBrowsePathsToNodeIdsResponse *response) {
  565. if(request->browsePathsSize <= 0) {
  566. response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
  567. return;
  568. }
  569. size_t size = request->browsePathsSize;
  570. response->results = UA_Array_new(&UA_TYPES[UA_TYPES_BROWSEPATHRESULT], size);
  571. if(!response->results) {
  572. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  573. return;
  574. }
  575. #ifdef UA_EXTERNAL_NAMESPACES
  576. #ifdef NO_ALLOCA
  577. UA_Boolean isExternal[size];
  578. UA_UInt32 indices[size];
  579. #else
  580. UA_Boolean *isExternal = UA_alloca(sizeof(UA_Boolean) * size);
  581. UA_UInt32 *indices = UA_alloca(sizeof(UA_UInt32) * size);
  582. #endif /*NO_ALLOCA */
  583. UA_memset(isExternal, UA_FALSE, sizeof(UA_Boolean) * size);
  584. for(size_t j = 0; j < server->externalNamespacesSize; j++) {
  585. size_t indexSize = 0;
  586. for(size_t i = 0;i < size;i++) {
  587. if(request->browsePaths[i].startingNode.namespaceIndex != server->externalNamespaces[j].index)
  588. continue;
  589. isExternal[i] = UA_TRUE;
  590. indices[indexSize] = i;
  591. indexSize++;
  592. }
  593. if(indexSize == 0)
  594. continue;
  595. UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
  596. ens->translateBrowsePathsToNodeIds(ens->ensHandle, &request->requestHeader, request->browsePaths,
  597. indices, indexSize, response->results, response->diagnosticInfos);
  598. }
  599. #endif
  600. response->resultsSize = size;
  601. for(size_t i = 0; i < size; i++) {
  602. #ifdef UA_EXTERNAL_NAMESPACES
  603. if(!isExternal[i])
  604. #endif
  605. translateBrowsePath(server, session, &request->browsePaths[i], &response->results[i]);
  606. }
  607. }
  608. void Service_RegisterNodes(UA_Server *server, UA_Session *session, const UA_RegisterNodesRequest *request,
  609. UA_RegisterNodesResponse *response) {
  610. //TODO: hang the nodeids to the session if really needed
  611. response->responseHeader.timestamp = UA_DateTime_now();
  612. if(request->nodesToRegisterSize <= 0)
  613. response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
  614. else {
  615. response->responseHeader.serviceResult =
  616. UA_Array_copy(request->nodesToRegister, (void**)&response->registeredNodeIds, &UA_TYPES[UA_TYPES_NODEID],
  617. request->nodesToRegisterSize);
  618. if(response->responseHeader.serviceResult == UA_STATUSCODE_GOOD)
  619. response->registeredNodeIdsSize = request->nodesToRegisterSize;
  620. }
  621. }
  622. void Service_UnregisterNodes(UA_Server *server, UA_Session *session, const UA_UnregisterNodesRequest *request,
  623. UA_UnregisterNodesResponse *response) {
  624. //TODO: remove the nodeids from the session if really needed
  625. response->responseHeader.timestamp = UA_DateTime_now();
  626. if(request->nodesToUnregisterSize==0)
  627. response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
  628. }