ua_server_addressspace.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452
  1. #include "ua_server.h"
  2. #include "ua_server_internal.h"
  3. UA_StatusCode
  4. UA_Server_addVariableNode(UA_Server *server, UA_Variant *value, const UA_QualifiedName browseName,
  5. UA_NodeId nodeId, const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId,
  6. UA_NodeId *createdNodeId) {
  7. UA_VariableNode *node = UA_VariableNode_new();
  8. node->value.variant = *value; // copy content
  9. UA_NodeId_copy(&nodeId, &node->nodeId);
  10. UA_QualifiedName_copy(&browseName, &node->browseName);
  11. UA_String_copy(&browseName.name, &node->displayName.text);
  12. UA_ExpandedNodeId parentId;
  13. UA_ExpandedNodeId_init(&parentId);
  14. UA_NodeId_copy(&parentNodeId, &parentId.nodeId);
  15. UA_AddNodesResult res = UA_Server_addNodeWithSession(server, &adminSession, (UA_Node*)node,
  16. parentId, referenceTypeId);
  17. UA_Server_addReference(server, res.addedNodeId, UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
  18. UA_EXPANDEDNODEID_NUMERIC(0, value->type->typeId.identifier.numeric));
  19. if(res.statusCode != UA_STATUSCODE_GOOD) {
  20. UA_Variant_init(&node->value.variant);
  21. UA_VariableNode_delete(node);
  22. } else
  23. UA_free(value);
  24. if (createdNodeId != UA_NULL)
  25. UA_NodeId_copy(&res.addedNodeId, createdNodeId);
  26. UA_AddNodesResult_deleteMembers(&res);
  27. UA_ExpandedNodeId_deleteMembers(&parentId);
  28. return res.statusCode;
  29. }
  30. UA_StatusCode
  31. UA_Server_addObjectNode(UA_Server *server, const UA_QualifiedName browseName, UA_NodeId nodeId,
  32. const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId,
  33. const UA_NodeId typeDefinition,
  34. UA_NodeId *createdNodeId) {
  35. UA_ObjectNode *node = UA_ObjectNode_new();
  36. UA_NodeId_copy(&nodeId, &node->nodeId);
  37. UA_QualifiedName_copy(&browseName, &node->browseName);
  38. UA_String_copy(&browseName.name, &node->displayName.text);
  39. UA_ExpandedNodeId parentId; // we need an expandednodeid
  40. UA_ExpandedNodeId_init(&parentId);
  41. UA_NodeId_copy(&parentNodeId, &parentId.nodeId);
  42. UA_AddNodesResult res = UA_Server_addNodeWithSession(server, &adminSession, (UA_Node*)node,
  43. parentId, referenceTypeId);
  44. if(res.statusCode != UA_STATUSCODE_GOOD)
  45. UA_ObjectNode_delete(node);
  46. if (createdNodeId != UA_NULL)
  47. UA_NodeId_copy(&res.addedNodeId, createdNodeId);
  48. UA_AddNodesResult_deleteMembers(&res);
  49. UA_ExpandedNodeId_deleteMembers(&parentId);
  50. if(!UA_NodeId_isNull(&typeDefinition)) {
  51. UA_ExpandedNodeId typeDefid; // we need an expandednodeid
  52. UA_ExpandedNodeId_init(&typeDefid);
  53. UA_NodeId_copy(&typeDefinition, &typeDefid.nodeId);
  54. UA_Server_addReference(server, res.addedNodeId, UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
  55. typeDefid);
  56. UA_ExpandedNodeId_deleteMembers(&typeDefid);
  57. }
  58. return res.statusCode;
  59. }
  60. UA_StatusCode
  61. UA_Server_addDataSourceVariableNode(UA_Server *server, UA_DataSource dataSource,
  62. const UA_QualifiedName browseName, UA_NodeId nodeId,
  63. const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId,
  64. UA_NodeId *createdNodeId) {
  65. UA_VariableNode *node = UA_VariableNode_new();
  66. node->valueSource = UA_VALUESOURCE_DATASOURCE;
  67. node->value.dataSource = dataSource;
  68. UA_NodeId_copy(&nodeId, &node->nodeId);
  69. UA_QualifiedName_copy(&browseName, &node->browseName);
  70. UA_String_copy(&browseName.name, &node->displayName.text);
  71. UA_ExpandedNodeId parentId; // dummy exapndednodeid
  72. UA_ExpandedNodeId_init(&parentId);
  73. UA_NodeId_copy(&parentNodeId, &parentId.nodeId);
  74. UA_AddNodesResult res = UA_Server_addNodeWithSession(server, &adminSession, (UA_Node*)node,
  75. parentId, referenceTypeId);
  76. UA_Server_addReference(server, res.addedNodeId, UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
  77. UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE));
  78. if(res.statusCode != UA_STATUSCODE_GOOD)
  79. UA_VariableNode_delete(node);
  80. if (createdNodeId != UA_NULL)
  81. UA_NodeId_copy(&res.addedNodeId, createdNodeId);
  82. UA_AddNodesResult_deleteMembers(&res);
  83. UA_ExpandedNodeId_deleteMembers(&parentId);
  84. return res.statusCode;
  85. }
  86. /* Userspace Version of addOneWayReferenceWithSession*/
  87. UA_StatusCode
  88. UA_Server_AddMonodirectionalReference(UA_Server *server, UA_NodeId sourceNodeId, UA_ExpandedNodeId targetNodeId,
  89. UA_NodeId referenceTypeId, UA_Boolean isforward) {
  90. UA_AddReferencesItem ref;
  91. UA_AddReferencesItem_init(&ref);
  92. UA_StatusCode retval = UA_NodeId_copy(&sourceNodeId, &ref.sourceNodeId);
  93. retval |= UA_ExpandedNodeId_copy(&targetNodeId, &ref.targetNodeId);
  94. retval |= UA_NodeId_copy(&referenceTypeId, &ref.referenceTypeId);
  95. if(retval != UA_STATUSCODE_GOOD)
  96. goto cleanup;
  97. const UA_Node *target = UA_NodeStore_get(server->nodestore, &ref.targetNodeId.nodeId);
  98. if(!target) {
  99. retval = UA_STATUSCODE_BADNODEIDINVALID;
  100. goto cleanup;
  101. }
  102. if(isforward == UA_TRUE)
  103. ref.isForward = UA_TRUE;
  104. ref.targetNodeClass = target->nodeClass;
  105. UA_NodeStore_release(target);
  106. retval = addOneWayReferenceWithSession(server, (UA_Session *) UA_NULL, &ref);
  107. cleanup:
  108. UA_AddReferencesItem_deleteMembers(&ref);
  109. return retval;
  110. }
  111. /* Adds a one-way reference to the local nodestore */
  112. UA_StatusCode
  113. addOneWayReferenceWithSession(UA_Server *server, UA_Session *session, const UA_AddReferencesItem *item) {
  114. const UA_Node *node = UA_NodeStore_get(server->nodestore, &item->sourceNodeId);
  115. if(!node)
  116. return UA_STATUSCODE_BADINTERNALERROR;
  117. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  118. #ifndef UA_MULTITHREADING
  119. size_t i = node->referencesSize;
  120. if(node->referencesSize < 0)
  121. i = 0;
  122. size_t refssize = (i+1) | 3; // so the realloc is not necessary every time
  123. UA_ReferenceNode *new_refs = UA_realloc(node->references, sizeof(UA_ReferenceNode) * refssize);
  124. if(!new_refs)
  125. retval = UA_STATUSCODE_BADOUTOFMEMORY;
  126. else {
  127. UA_ReferenceNode_init(&new_refs[i]);
  128. retval = UA_NodeId_copy(&item->referenceTypeId, &new_refs[i].referenceTypeId);
  129. new_refs[i].isInverse = !item->isForward;
  130. retval |= UA_ExpandedNodeId_copy(&item->targetNodeId, &new_refs[i].targetId);
  131. /* hack. be careful! possible only in the single-threaded case. */
  132. UA_Node *mutable_node = (UA_Node*)(uintptr_t)node;
  133. mutable_node->references = new_refs;
  134. if(retval != UA_STATUSCODE_GOOD) {
  135. UA_NodeId_deleteMembers(&new_refs[node->referencesSize].referenceTypeId);
  136. UA_ExpandedNodeId_deleteMembers(&new_refs[node->referencesSize].targetId);
  137. } else
  138. mutable_node->referencesSize = i+1;
  139. }
  140. UA_NodeStore_release(node);
  141. return retval;
  142. #else
  143. UA_Node *newNode = UA_NULL;
  144. void (*deleteNode)(UA_Node*) = UA_NULL;
  145. switch(node->nodeClass) {
  146. case UA_NODECLASS_OBJECT:
  147. newNode = (UA_Node*)UA_ObjectNode_new();
  148. UA_ObjectNode_copy((const UA_ObjectNode*)node, (UA_ObjectNode*)newNode);
  149. deleteNode = (void (*)(UA_Node*))UA_ObjectNode_delete;
  150. break;
  151. case UA_NODECLASS_VARIABLE:
  152. newNode = (UA_Node*)UA_VariableNode_new();
  153. UA_VariableNode_copy((const UA_VariableNode*)node, (UA_VariableNode*)newNode);
  154. deleteNode = (void (*)(UA_Node*))UA_VariableNode_delete;
  155. break;
  156. case UA_NODECLASS_METHOD:
  157. newNode = (UA_Node*)UA_MethodNode_new();
  158. UA_MethodNode_copy((const UA_MethodNode*)node, (UA_MethodNode*)newNode);
  159. deleteNode = (void (*)(UA_Node*))UA_MethodNode_delete;
  160. break;
  161. case UA_NODECLASS_OBJECTTYPE:
  162. newNode = (UA_Node*)UA_ObjectTypeNode_new();
  163. UA_ObjectTypeNode_copy((const UA_ObjectTypeNode*)node, (UA_ObjectTypeNode*)newNode);
  164. deleteNode = (void (*)(UA_Node*))UA_ObjectTypeNode_delete;
  165. break;
  166. case UA_NODECLASS_VARIABLETYPE:
  167. newNode = (UA_Node*)UA_VariableTypeNode_new();
  168. UA_VariableTypeNode_copy((const UA_VariableTypeNode*)node, (UA_VariableTypeNode*)newNode);
  169. deleteNode = (void (*)(UA_Node*))UA_VariableTypeNode_delete;
  170. break;
  171. case UA_NODECLASS_REFERENCETYPE:
  172. newNode = (UA_Node*)UA_ReferenceTypeNode_new();
  173. UA_ReferenceTypeNode_copy((const UA_ReferenceTypeNode*)node, (UA_ReferenceTypeNode*)newNode);
  174. deleteNode = (void (*)(UA_Node*))UA_ReferenceTypeNode_delete;
  175. break;
  176. case UA_NODECLASS_DATATYPE:
  177. newNode = (UA_Node*)UA_DataTypeNode_new();
  178. UA_DataTypeNode_copy((const UA_DataTypeNode*)node, (UA_DataTypeNode*)newNode);
  179. deleteNode = (void (*)(UA_Node*))UA_DataTypeNode_delete;
  180. break;
  181. case UA_NODECLASS_VIEW:
  182. newNode = (UA_Node*)UA_ViewNode_new();
  183. UA_ViewNode_copy((const UA_ViewNode*)node, (UA_ViewNode*)newNode);
  184. deleteNode = (void (*)(UA_Node*))UA_ViewNode_delete;
  185. break;
  186. default:
  187. return UA_STATUSCODE_BADINTERNALERROR;
  188. }
  189. UA_Int32 count = node->referencesSize;
  190. if(count < 0)
  191. count = 0;
  192. UA_ReferenceNode *old_refs = newNode->references;
  193. UA_ReferenceNode *new_refs = UA_malloc(sizeof(UA_ReferenceNode)*(count+1));
  194. if(!new_refs) {
  195. deleteNode(newNode);
  196. UA_NodeStore_release(node);
  197. return UA_STATUSCODE_BADOUTOFMEMORY;
  198. }
  199. // insert the new reference
  200. UA_memcpy(new_refs, old_refs, sizeof(UA_ReferenceNode)*count);
  201. UA_ReferenceNode_init(&new_refs[count]);
  202. retval = UA_NodeId_copy(&item->referenceTypeId, &new_refs[count].referenceTypeId);
  203. new_refs[count].isInverse = !item->isForward;
  204. retval |= UA_ExpandedNodeId_copy(&item->targetNodeId, &new_refs[count].targetId);
  205. if(retval != UA_STATUSCODE_GOOD) {
  206. UA_Array_delete(new_refs, &UA_TYPES[UA_TYPES_REFERENCENODE], ++count);
  207. newNode->references = UA_NULL;
  208. newNode->referencesSize = 0;
  209. deleteNode(newNode);
  210. UA_NodeStore_release(node);
  211. return UA_STATUSCODE_BADOUTOFMEMORY;
  212. }
  213. UA_free(old_refs);
  214. newNode->references = new_refs;
  215. newNode->referencesSize = ++count;
  216. retval = UA_NodeStore_replace(server->nodestore, node, newNode, UA_NULL);
  217. UA_NodeStore_release(node);
  218. if(retval == UA_STATUSCODE_BADINTERNALERROR) {
  219. /* presumably because the node was replaced and an old version was updated at the same time.
  220. just try again */
  221. deleteNode(newNode);
  222. return addOneWayReferenceWithSession(server, session, item);
  223. }
  224. return retval;
  225. #endif
  226. }
  227. /* userland version of addReferenceWithSession */
  228. UA_StatusCode UA_Server_addReference(UA_Server *server, const UA_NodeId sourceId, const UA_NodeId refTypeId,
  229. const UA_ExpandedNodeId targetId) {
  230. UA_AddReferencesItem item;
  231. UA_AddReferencesItem_init(&item);
  232. item.sourceNodeId = sourceId;
  233. item.referenceTypeId = refTypeId;
  234. item.isForward = UA_TRUE;
  235. item.targetNodeId = targetId;
  236. return UA_Server_addReferenceWithSession(server, &adminSession, &item);
  237. }
  238. UA_StatusCode UA_Server_addReferenceWithSession(UA_Server *server, UA_Session *session,
  239. const UA_AddReferencesItem *item) {
  240. if(item->targetServerUri.length > 0)
  241. return UA_STATUSCODE_BADNOTIMPLEMENTED; // currently no expandednodeids are allowed
  242. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  243. #ifdef UA_EXTERNAL_NAMESPACES
  244. UA_ExternalNodeStore *ensFirst = UA_NULL;
  245. UA_ExternalNodeStore *ensSecond = UA_NULL;
  246. for(size_t j = 0;j<server->externalNamespacesSize && (!ensFirst || !ensSecond);j++) {
  247. if(item->sourceNodeId.namespaceIndex == server->externalNamespaces[j].index)
  248. ensFirst = &server->externalNamespaces[j].externalNodeStore;
  249. if(item->targetNodeId.nodeId.namespaceIndex == server->externalNamespaces[j].index)
  250. ensSecond = &server->externalNamespaces[j].externalNodeStore;
  251. }
  252. if(ensFirst) {
  253. // todo: use external nodestore
  254. } else
  255. #endif
  256. retval = addOneWayReferenceWithSession(server, session, item);
  257. if(retval)
  258. return retval;
  259. UA_AddReferencesItem secondItem;
  260. secondItem = *item;
  261. secondItem.targetNodeId.nodeId = item->sourceNodeId;
  262. secondItem.sourceNodeId = item->targetNodeId.nodeId;
  263. secondItem.isForward = !item->isForward;
  264. #ifdef UA_EXTERNAL_NAMESPACES
  265. if(ensSecond) {
  266. // todo: use external nodestore
  267. } else
  268. #endif
  269. retval = addOneWayReferenceWithSession (server, session, &secondItem);
  270. // todo: remove reference if the second direction failed
  271. return retval;
  272. }
  273. /* userland version of addNodeWithSession */
  274. UA_AddNodesResult
  275. UA_Server_addNode(UA_Server *server, UA_Node *node, const UA_ExpandedNodeId parentNodeId,
  276. const UA_NodeId referenceTypeId) {
  277. return UA_Server_addNodeWithSession(server, &adminSession, node, parentNodeId, referenceTypeId);
  278. }
  279. UA_AddNodesResult
  280. UA_Server_addNodeWithSession(UA_Server *server, UA_Session *session, UA_Node *node,
  281. const UA_ExpandedNodeId parentNodeId, const UA_NodeId referenceTypeId) {
  282. UA_AddNodesResult result;
  283. UA_AddNodesResult_init(&result);
  284. if(node->nodeId.namespaceIndex >= server->namespacesSize) {
  285. result.statusCode = UA_STATUSCODE_BADNODEIDINVALID;
  286. return result;
  287. }
  288. const UA_Node *parent = UA_NodeStore_get(server->nodestore, &parentNodeId.nodeId);
  289. if(!parent) {
  290. result.statusCode = UA_STATUSCODE_BADPARENTNODEIDINVALID;
  291. return result;
  292. }
  293. const UA_ReferenceTypeNode *referenceType =
  294. (const UA_ReferenceTypeNode *)UA_NodeStore_get(server->nodestore, &referenceTypeId);
  295. if(!referenceType) {
  296. result.statusCode = UA_STATUSCODE_BADREFERENCETYPEIDINVALID;
  297. goto ret;
  298. }
  299. if(referenceType->nodeClass != UA_NODECLASS_REFERENCETYPE) {
  300. result.statusCode = UA_STATUSCODE_BADREFERENCETYPEIDINVALID;
  301. goto ret2;
  302. }
  303. if(referenceType->isAbstract == UA_TRUE) {
  304. result.statusCode = UA_STATUSCODE_BADREFERENCENOTALLOWED;
  305. goto ret2;
  306. }
  307. // todo: test if the referencetype is hierarchical
  308. //FIXME: a bit dirty workaround of preserving namespace
  309. //namespace index is assumed to be valid
  310. const UA_Node *managed = UA_NULL;
  311. UA_NodeId tempNodeid;
  312. UA_NodeId_init(&tempNodeid);
  313. UA_NodeId_copy(&node->nodeId, &tempNodeid);
  314. tempNodeid.namespaceIndex = 0;
  315. if(UA_NodeId_isNull(&tempNodeid)) {
  316. if(UA_NodeStore_insert(server->nodestore, node, &managed) != UA_STATUSCODE_GOOD) {
  317. result.statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
  318. goto ret2;
  319. }
  320. result.addedNodeId = managed->nodeId; // cannot fail as unique nodeids are numeric
  321. } else {
  322. if(UA_NodeId_copy(&node->nodeId, &result.addedNodeId) != UA_STATUSCODE_GOOD) {
  323. result.statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
  324. goto ret2;
  325. }
  326. if(UA_NodeStore_insert(server->nodestore, node, &managed) != UA_STATUSCODE_GOOD) {
  327. result.statusCode = UA_STATUSCODE_BADNODEIDEXISTS; // todo: differentiate out of memory
  328. UA_NodeId_deleteMembers(&result.addedNodeId);
  329. goto ret2;
  330. }
  331. }
  332. // reference back to the parent
  333. UA_AddReferencesItem item;
  334. UA_AddReferencesItem_init(&item);
  335. item.sourceNodeId = managed->nodeId;
  336. item.referenceTypeId = referenceType->nodeId;
  337. item.isForward = UA_FALSE;
  338. item.targetNodeId.nodeId = parent->nodeId;
  339. UA_Server_addReferenceWithSession(server, session, &item);
  340. // todo: error handling. remove new node from nodestore
  341. UA_NodeStore_release(managed);
  342. ret2:
  343. UA_NodeId_deleteMembers(&tempNodeid);
  344. UA_NodeStore_release((const UA_Node*)referenceType);
  345. ret:
  346. UA_NodeStore_release(parent);
  347. return result;
  348. }
  349. #ifdef ENABLE_METHODCALLS
  350. UA_StatusCode
  351. UA_Server_addMethodNode(UA_Server *server, const UA_QualifiedName browseName, UA_NodeId nodeId,
  352. const UA_ExpandedNodeId parentNodeId, const UA_NodeId referenceTypeId,
  353. UA_MethodCallback method, UA_Int32 inputArgumentsSize,
  354. const UA_Argument *inputArguments, UA_Int32 outputArgumentsSize,
  355. const UA_Argument *outputArguments,
  356. UA_NodeId *createdNodeId) {
  357. UA_MethodNode *newMethod = UA_MethodNode_new();
  358. UA_NodeId_copy(&nodeId, &newMethod->nodeId);
  359. UA_QualifiedName_copy(&browseName, &newMethod->browseName);
  360. UA_String_copy(&browseName.name, &newMethod->displayName.text);
  361. newMethod->attachedMethod = method;
  362. newMethod->executable = UA_TRUE;
  363. newMethod->userExecutable = UA_TRUE;
  364. UA_AddNodesResult addRes = UA_Server_addNode(server, (UA_Node*)newMethod, parentNodeId, referenceTypeId);
  365. if(addRes.statusCode != UA_STATUSCODE_GOOD) {
  366. UA_MethodNode_delete(newMethod);
  367. return addRes.statusCode;
  368. }
  369. UA_ExpandedNodeId methodExpandedNodeId;
  370. UA_ExpandedNodeId_init(&methodExpandedNodeId);
  371. UA_NodeId_copy(&addRes.addedNodeId, &methodExpandedNodeId.nodeId);
  372. if (createdNodeId != UA_NULL)
  373. UA_NodeId_copy(&addRes.addedNodeId, createdNodeId);
  374. UA_AddNodesResult_deleteMembers(&addRes);
  375. /* create InputArguments */
  376. UA_NodeId argId = UA_NODEID_NUMERIC(nodeId.namespaceIndex, 0);
  377. UA_VariableNode *inputArgumentsVariableNode = UA_VariableNode_new();
  378. UA_StatusCode retval = UA_NodeId_copy(&argId, &inputArgumentsVariableNode->nodeId);
  379. inputArgumentsVariableNode->browseName = UA_QUALIFIEDNAME_ALLOC(0,"InputArguments");
  380. inputArgumentsVariableNode->displayName = UA_LOCALIZEDTEXT_ALLOC("en_US", "InputArguments");
  381. inputArgumentsVariableNode->description = UA_LOCALIZEDTEXT_ALLOC("en_US", "InputArguments");
  382. inputArgumentsVariableNode->valueRank = 1;
  383. UA_Variant_setArrayCopy(&inputArgumentsVariableNode->value.variant, inputArguments,
  384. inputArgumentsSize, &UA_TYPES[UA_TYPES_ARGUMENT]);
  385. addRes = UA_Server_addNode(server, (UA_Node*)inputArgumentsVariableNode, methodExpandedNodeId,
  386. UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY));
  387. if(addRes.statusCode != UA_STATUSCODE_GOOD) {
  388. UA_ExpandedNodeId_deleteMembers(&methodExpandedNodeId);
  389. // TODO Remove node
  390. return addRes.statusCode;
  391. }
  392. UA_AddNodesResult_deleteMembers(&addRes);
  393. /* create OutputArguments */
  394. argId = UA_NODEID_NUMERIC(nodeId.namespaceIndex, 0);
  395. UA_VariableNode *outputArgumentsVariableNode = UA_VariableNode_new();
  396. retval |= UA_NodeId_copy(&argId, &outputArgumentsVariableNode->nodeId);
  397. outputArgumentsVariableNode->browseName = UA_QUALIFIEDNAME_ALLOC(0,"OutputArguments");
  398. outputArgumentsVariableNode->displayName = UA_LOCALIZEDTEXT_ALLOC("en_US", "OutputArguments");
  399. outputArgumentsVariableNode->description = UA_LOCALIZEDTEXT_ALLOC("en_US", "OutputArguments");
  400. outputArgumentsVariableNode->valueRank = 1;
  401. UA_Variant_setArrayCopy(&outputArgumentsVariableNode->value.variant, outputArguments,
  402. outputArgumentsSize, &UA_TYPES[UA_TYPES_ARGUMENT]);
  403. addRes = UA_Server_addNode(server, (UA_Node*)outputArgumentsVariableNode, methodExpandedNodeId,
  404. UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY));
  405. UA_ExpandedNodeId_deleteMembers(&methodExpandedNodeId);
  406. if(addRes.statusCode != UA_STATUSCODE_GOOD)
  407. // TODO Remove node
  408. retval = addRes.statusCode;
  409. UA_AddNodesResult_deleteMembers(&addRes);
  410. return retval;
  411. }
  412. #endif