ua_services_attribute.c 46 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166
  1. #include "ua_server_internal.h"
  2. #include "ua_services.h"
  3. #ifdef UA_ENABLE_NONSTANDARD_STATELESS
  4. #include "ua_types_encoding_binary.h"
  5. #endif
  6. /* Force cast from const data for zero-copy reading. The storage type is set to
  7. nodelete. So the value is not deleted. Use with care! */
  8. static void
  9. forceVariantSetScalar(UA_Variant *v, const void *p, const UA_DataType *t) {
  10. UA_Variant_init(v);
  11. v->type = t;
  12. v->data = (void*)(uintptr_t)p;
  13. v->storageType = UA_VARIANT_DATA_NODELETE;
  14. }
  15. /*****************/
  16. /* Type Checking */
  17. /*****************/
  18. enum type_equivalence {
  19. TYPE_EQUIVALENCE_NONE,
  20. TYPE_EQUIVALENCE_ENUM,
  21. TYPE_EQUIVALENCE_OPAQUE
  22. };
  23. static enum type_equivalence
  24. typeEquivalence(const UA_DataType *t) {
  25. if(t->membersSize != 1 || !t->members[0].namespaceZero)
  26. return TYPE_EQUIVALENCE_NONE;
  27. if(t->members[0].memberTypeIndex == UA_TYPES_INT32)
  28. return TYPE_EQUIVALENCE_ENUM;
  29. if(t->members[0].memberTypeIndex == UA_TYPES_BYTE && t->members[0].isArray)
  30. return TYPE_EQUIVALENCE_OPAQUE;
  31. return TYPE_EQUIVALENCE_NONE;
  32. }
  33. /* Test whether a valurank and the given arraydimensions are compatible. zero
  34. * array dimensions indicate a scalar */
  35. static UA_StatusCode
  36. compatibleValueRankArrayDimensions(UA_Int32 valueRank, size_t arrayDimensionsSize) {
  37. switch(valueRank) {
  38. case -3: /* the value can be a scalar or a one dimensional array */
  39. if(arrayDimensionsSize > 1)
  40. return UA_STATUSCODE_BADTYPEMISMATCH;
  41. break;
  42. case -2: /* the value can be a scalar or an array with any number of dimensions */
  43. break;
  44. case -1: /* the value is a scalar */
  45. if(arrayDimensionsSize > 0)
  46. return UA_STATUSCODE_BADTYPEMISMATCH;
  47. break;
  48. case 0: /* the value is an array with one or more dimensions */
  49. if(arrayDimensionsSize < 1)
  50. return UA_STATUSCODE_BADTYPEMISMATCH;
  51. break;
  52. default: /* >= 1: the value is an array with the specified number of dimensions */
  53. if(valueRank < 0)
  54. return UA_STATUSCODE_BADTYPEMISMATCH;
  55. /* Must hold if the array has a defined length. Null arrays (length -1)
  56. * need to be caught before. */
  57. if(arrayDimensionsSize != (size_t)valueRank)
  58. return UA_STATUSCODE_BADTYPEMISMATCH;
  59. }
  60. return UA_STATUSCODE_GOOD;
  61. }
  62. /* Check if the valuerank allows for the value dimension */
  63. static UA_StatusCode
  64. compatibleValueRankValue(UA_Int32 valueRank, const UA_Variant *value) {
  65. /* empty arrays (-1) always match */
  66. if(value->data == NULL)
  67. return UA_STATUSCODE_GOOD;
  68. size_t arrayDims = value->arrayDimensionsSize;
  69. if(!UA_Variant_isScalar(value))
  70. arrayDims = 1; /* array but no arraydimensions -> implicit array dimension 1 */
  71. return compatibleValueRankArrayDimensions(valueRank, arrayDims);
  72. }
  73. UA_StatusCode
  74. compatibleArrayDimensions(size_t constraintArrayDimensionsSize,
  75. const UA_UInt32 *constraintArrayDimensions,
  76. size_t testArrayDimensionsSize,
  77. const UA_UInt32 *testArrayDimensions) {
  78. if(testArrayDimensionsSize != constraintArrayDimensionsSize)
  79. return UA_STATUSCODE_BADTYPEMISMATCH;
  80. /* dimension size zero in the constraint is a wildcard */
  81. for(size_t i = 0; i < constraintArrayDimensionsSize; ++i) {
  82. if(constraintArrayDimensions[i] != testArrayDimensions[i] &&
  83. constraintArrayDimensions[i] != 0)
  84. return UA_STATUSCODE_BADTYPEMISMATCH;
  85. }
  86. return UA_STATUSCODE_GOOD;
  87. }
  88. /* Returns the pointer to a datavalue with a possibly transformed type to match
  89. the description */
  90. static const UA_Variant *
  91. convertToMatchingValue(UA_Server *server, const UA_Variant *value,
  92. const UA_NodeId *targetDataTypeId, UA_Variant *editableValue) {
  93. const UA_DataType *targetDataType = UA_findDataType(targetDataTypeId);
  94. if(!targetDataType)
  95. return NULL;
  96. /* A string is written to a byte array. the valuerank and array
  97. dimensions are checked later */
  98. if(targetDataType == &UA_TYPES[UA_TYPES_BYTE] &&
  99. value->type == &UA_TYPES[UA_TYPES_BYTESTRING] &&
  100. UA_Variant_isScalar(value)) {
  101. UA_ByteString *str = (UA_ByteString*)value->data;
  102. editableValue->storageType = UA_VARIANT_DATA_NODELETE;
  103. editableValue->type = &UA_TYPES[UA_TYPES_BYTE];
  104. editableValue->arrayLength = str->length;
  105. editableValue->data = str->data;
  106. return editableValue;
  107. }
  108. /* An enum was sent as an int32, or an opaque type as a bytestring. This
  109. * is detected with the typeIndex indicating the "true" datatype. */
  110. enum type_equivalence te1 = typeEquivalence(targetDataType);
  111. enum type_equivalence te2 = typeEquivalence(value->type);
  112. if(te1 != TYPE_EQUIVALENCE_NONE && te1 == te2) {
  113. *editableValue = *value;
  114. editableValue->storageType = UA_VARIANT_DATA_NODELETE;
  115. editableValue->type = targetDataType;
  116. return editableValue;
  117. }
  118. /* No more possible equivalencies */
  119. return NULL;
  120. }
  121. /* Test whether the value matches a variable definition given by
  122. * - datatype
  123. * - valueranke
  124. * - array dimensions.
  125. * Sometimes it can be necessary to transform the content of the value, e.g.
  126. * byte array to bytestring or uint32 to some enum. If editableValue is non-NULL,
  127. * we try to create a matching variant that points to the original data. */
  128. UA_StatusCode
  129. typeCheckValue(UA_Server *server, const UA_NodeId *targetDataTypeId,
  130. UA_Int32 targetValueRank, size_t targetArrayDimensionsSize,
  131. const UA_UInt32 *targetArrayDimensions, const UA_Variant *value,
  132. const UA_NumericRange *range, UA_Variant *editableValue) {
  133. /* Empty variant is only allowed for BaseDataType */
  134. UA_NodeId basedatatype = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATATYPE);
  135. if(!value->type) {
  136. if(UA_NodeId_equal(targetDataTypeId, &basedatatype))
  137. goto check_array;
  138. else
  139. return UA_STATUSCODE_BADTYPEMISMATCH;
  140. }
  141. /* See if the types match. The nodeid on the wire may be != the nodeid in
  142. * the node for opaque types, enums and bytestrings. value contains the
  143. * correct type definition after the following paragraph */
  144. if(UA_NodeId_equal(&value->type->typeId, targetDataTypeId))
  145. goto check_array;
  146. /* Has the value a subtype of the required type? */
  147. const UA_NodeId subtypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE);
  148. if(isNodeInTree(server->nodestore, &value->type->typeId, targetDataTypeId, &subtypeId, 1))
  149. goto check_array;
  150. /* Try to convert to a matching value if this is wanted */
  151. if(!editableValue)
  152. return UA_STATUSCODE_BADTYPEMISMATCH;
  153. value = convertToMatchingValue(server, value, targetDataTypeId, editableValue);
  154. if(!value)
  155. return UA_STATUSCODE_BADTYPEMISMATCH;
  156. check_array:
  157. if(range) /* array dimensions are checked later when writing the range */
  158. return UA_STATUSCODE_GOOD;
  159. /* See if the array dimensions match. When arrayDimensions are defined, they
  160. * already hold the valuerank. */
  161. if(targetArrayDimensionsSize > 0)
  162. return compatibleArrayDimensions(targetArrayDimensionsSize,
  163. targetArrayDimensions,
  164. value->arrayDimensionsSize,
  165. value->arrayDimensions);
  166. /* Check if the valuerank allows for the value dimension */
  167. return compatibleValueRankValue(targetValueRank, value);
  168. }
  169. /*****************************/
  170. /* ArrayDimensions Attribute */
  171. /*****************************/
  172. static UA_StatusCode
  173. readArrayDimensionsAttribute(const UA_VariableNode *vn, UA_DataValue *v) {
  174. UA_Variant_setArray(&v->value, vn->arrayDimensions,
  175. vn->arrayDimensionsSize, &UA_TYPES[UA_TYPES_INT32]);
  176. v->value.storageType = UA_VARIANT_DATA_NODELETE;
  177. v->hasValue = true;
  178. return UA_STATUSCODE_GOOD;
  179. }
  180. static UA_StatusCode
  181. writeArrayDimensionsAttribute(UA_Server *server, UA_VariableNode *node,
  182. size_t arrayDimensionsSize, UA_UInt32 *arrayDimensions) {
  183. /* If this is a variabletype, there must be no instances or subtypes of it
  184. * when we do the change */
  185. if(node->nodeClass == UA_NODECLASS_VARIABLETYPE &&
  186. UA_Node_hasSubTypeOrInstances((const UA_Node*)node))
  187. return UA_STATUSCODE_BADINTERNALERROR;
  188. /* Check that the array dimensions match with the valuerank */
  189. UA_StatusCode retval = compatibleValueRankArrayDimensions(node->valueRank, arrayDimensionsSize);
  190. if(retval != UA_STATUSCODE_GOOD) {
  191. UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SERVER,
  192. "The current value rank does not match the new array dimensions");
  193. return retval;
  194. }
  195. /* Get the VariableType */
  196. const UA_VariableTypeNode *vt = getVariableNodeType(server, (UA_VariableNode*)node);
  197. if(!vt)
  198. return UA_STATUSCODE_BADINTERNALERROR;
  199. /* Check if the array dimensions match with the wildcards in the
  200. * variabletype (dimension length 0) */
  201. if(vt->arrayDimensions) {
  202. retval = compatibleArrayDimensions(vt->arrayDimensionsSize, vt->arrayDimensions,
  203. arrayDimensionsSize, arrayDimensions);
  204. if(retval != UA_STATUSCODE_GOOD) {
  205. UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SERVER,
  206. "Array dimensions in the variable type do not match");
  207. return retval;
  208. }
  209. }
  210. /* Check if the current value is compatible with the array dimensions */
  211. UA_DataValue value;
  212. UA_DataValue_init(&value);
  213. retval = readValueAttribute(node, &value);
  214. if(retval != UA_STATUSCODE_GOOD)
  215. return retval;
  216. if(value.hasValue) {
  217. retval = compatibleArrayDimensions(arrayDimensionsSize, arrayDimensions,
  218. value.value.arrayDimensionsSize,
  219. value.value.arrayDimensions);
  220. UA_DataValue_deleteMembers(&value);
  221. if(retval != UA_STATUSCODE_GOOD) {
  222. UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SERVER,
  223. "Array dimensions in the current value do not match");
  224. return retval;
  225. }
  226. }
  227. /* Ok, apply */
  228. UA_UInt32 *oldArrayDimensions = node->arrayDimensions;
  229. retval = UA_Array_copy(arrayDimensions, arrayDimensionsSize,
  230. (void**)&node->arrayDimensions, &UA_TYPES[UA_TYPES_UINT32]);
  231. if(retval != UA_STATUSCODE_GOOD)
  232. return retval;
  233. UA_free(oldArrayDimensions);
  234. node->arrayDimensionsSize = arrayDimensionsSize;
  235. return UA_STATUSCODE_GOOD;
  236. }
  237. /***********************/
  238. /* ValueRank Attribute */
  239. /***********************/
  240. static UA_StatusCode
  241. writeValueRankAttributeWithVT(UA_Server *server, UA_VariableNode *node,
  242. UA_Int32 valueRank) {
  243. const UA_VariableTypeNode *vt = getVariableNodeType(server, node);
  244. if(!vt)
  245. return UA_STATUSCODE_BADINTERNALERROR;
  246. return writeValueRankAttribute(node, valueRank, vt->valueRank);
  247. }
  248. UA_StatusCode
  249. writeValueRankAttribute(UA_VariableNode *node, UA_Int32 valueRank,
  250. UA_Int32 constraintValueRank) {
  251. /* If this is a variabletype, there must be no instances or subtypes of it
  252. when we do the change */
  253. if(node->nodeClass == UA_NODECLASS_VARIABLETYPE &&
  254. UA_Node_hasSubTypeOrInstances((const UA_Node*)node))
  255. return UA_STATUSCODE_BADINTERNALERROR;
  256. /* Check if the valuerank of the variabletype allows the change. */
  257. switch(constraintValueRank) {
  258. case -3: /* the value can be a scalar or a one dimensional array */
  259. if(valueRank != -1 && valueRank != 1)
  260. return UA_STATUSCODE_BADTYPEMISMATCH;
  261. break;
  262. case -2: /* the value can be a scalar or an array with any number of dimensions */
  263. break;
  264. case -1: /* the value is a scalar */
  265. if(valueRank != -1)
  266. return UA_STATUSCODE_BADTYPEMISMATCH;
  267. break;
  268. case 0: /* the value is an array with one or more dimensions */
  269. if(valueRank < 0)
  270. return UA_STATUSCODE_BADTYPEMISMATCH;
  271. break;
  272. default: /* >= 1: the value is an array with the specified number of dimensions */
  273. if(valueRank != constraintValueRank)
  274. return UA_STATUSCODE_BADTYPEMISMATCH;
  275. break;
  276. }
  277. /* Check if the new valuerank is compatible with the array dimensions. Use
  278. * the read service to handle data sources. */
  279. size_t arrayDims = node->arrayDimensionsSize;
  280. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  281. if(arrayDims == 0) {
  282. /* the value could be an array with no arrayDimensions defined.
  283. dimensions zero indicate a scalar for compatibleValueRankArrayDimensions. */
  284. UA_DataValue value;
  285. UA_DataValue_init(&value);
  286. retval = readValueAttribute(node, &value);
  287. if(retval != UA_STATUSCODE_GOOD)
  288. return retval;
  289. if(!value.hasValue || value.value.data == NULL)
  290. goto apply; /* no value or null array */
  291. if(!UA_Variant_isScalar(&value.value))
  292. arrayDims = 1;
  293. UA_DataValue_deleteMembers(&value);
  294. }
  295. retval = compatibleValueRankArrayDimensions(valueRank, arrayDims);
  296. if(retval != UA_STATUSCODE_GOOD)
  297. return retval;
  298. /* All good, apply the change */
  299. apply:
  300. node->valueRank = valueRank;
  301. return UA_STATUSCODE_GOOD;
  302. }
  303. /**********************/
  304. /* DataType Attribute */
  305. /**********************/
  306. static UA_StatusCode
  307. writeDataTypeAttributeWithVT(UA_Server *server, UA_VariableNode *node,
  308. const UA_NodeId *dataType) {
  309. const UA_VariableTypeNode *vt = getVariableNodeType(server, node);
  310. if(!vt)
  311. return UA_STATUSCODE_BADINTERNALERROR;
  312. return writeDataTypeAttribute(server, node, dataType, &vt->dataType);
  313. }
  314. /* constraintDataType can be NULL, then we retrieve the vt */
  315. UA_StatusCode
  316. writeDataTypeAttribute(UA_Server *server, UA_VariableNode *node,
  317. const UA_NodeId *dataType, const UA_NodeId *constraintDataType) {
  318. /* If this is a variabletype, there must be no instances or subtypes of it
  319. when we do the change */
  320. if(node->nodeClass == UA_NODECLASS_VARIABLETYPE &&
  321. UA_Node_hasSubTypeOrInstances((const UA_Node*)node))
  322. return UA_STATUSCODE_BADINTERNALERROR;
  323. /* Does the new type match the constraints of the variabletype? */
  324. UA_NodeId subtypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE);
  325. if(!isNodeInTree(server->nodestore, dataType,
  326. constraintDataType, &subtypeId, 1))
  327. return UA_STATUSCODE_BADTYPEMISMATCH;
  328. /* Check if the current value would match the new type */
  329. UA_DataValue value;
  330. UA_DataValue_init(&value);
  331. UA_StatusCode retval = readValueAttribute(node, &value);
  332. if(retval != UA_STATUSCODE_GOOD)
  333. return retval;
  334. if(value.hasValue) {
  335. retval = typeCheckValue(server, dataType, node->valueRank,
  336. node->arrayDimensionsSize, node->arrayDimensions,
  337. &value.value, NULL, NULL);
  338. UA_DataValue_deleteMembers(&value);
  339. if(retval != UA_STATUSCODE_GOOD) {
  340. UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SERVER,
  341. "The current value does not match the new data type");
  342. return retval;
  343. }
  344. }
  345. /* Replace the datatype nodeid */
  346. UA_NodeId dtCopy = node->dataType;
  347. retval = UA_NodeId_copy(dataType, &node->dataType);
  348. if(retval != UA_STATUSCODE_GOOD) {
  349. node->dataType = dtCopy;
  350. return retval;
  351. }
  352. UA_NodeId_deleteMembers(&dtCopy);
  353. return UA_STATUSCODE_GOOD;
  354. }
  355. /*******************/
  356. /* Value Attribute */
  357. /*******************/
  358. static UA_StatusCode
  359. readValueAttributeFromNode(const UA_VariableNode *vn, UA_DataValue *v,
  360. UA_NumericRange *rangeptr) {
  361. if(vn->value.data.callback.onRead)
  362. vn->value.data.callback.onRead(vn->value.data.callback.handle,
  363. vn->nodeId, &v->value, rangeptr);
  364. if(rangeptr)
  365. return UA_Variant_copyRange(&vn->value.data.value.value, &v->value, *rangeptr);
  366. *v = vn->value.data.value;
  367. v->value.storageType = UA_VARIANT_DATA_NODELETE;
  368. return UA_STATUSCODE_GOOD;
  369. }
  370. static UA_StatusCode
  371. readValueAttributeFromDataSource(const UA_VariableNode *vn, UA_DataValue *v,
  372. UA_TimestampsToReturn timestamps,
  373. UA_NumericRange *rangeptr) {
  374. if(!vn->value.dataSource.read)
  375. return UA_STATUSCODE_BADINTERNALERROR;
  376. UA_Boolean sourceTimeStamp = (timestamps == UA_TIMESTAMPSTORETURN_SOURCE ||
  377. timestamps == UA_TIMESTAMPSTORETURN_BOTH);
  378. return vn->value.dataSource.read(vn->value.dataSource.handle, vn->nodeId,
  379. sourceTimeStamp, rangeptr, v);
  380. }
  381. static UA_StatusCode
  382. readValueAttributeComplete(const UA_VariableNode *vn, UA_TimestampsToReturn timestamps,
  383. const UA_String *indexRange, UA_DataValue *v) {
  384. /* Compute the index range */
  385. UA_NumericRange range;
  386. UA_NumericRange *rangeptr = NULL;
  387. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  388. if(indexRange && indexRange->length > 0) {
  389. retval = parse_numericrange(indexRange, &range);
  390. if(retval != UA_STATUSCODE_GOOD)
  391. return retval;
  392. rangeptr = &range;
  393. }
  394. /* Read the value */
  395. if(vn->valueSource == UA_VALUESOURCE_DATA)
  396. retval = readValueAttributeFromNode(vn, v, rangeptr);
  397. else
  398. retval = readValueAttributeFromDataSource(vn, v, timestamps, rangeptr);
  399. /* Clean up */
  400. if(rangeptr)
  401. UA_free(range.dimensions);
  402. return retval;
  403. }
  404. UA_StatusCode
  405. readValueAttribute(const UA_VariableNode *vn, UA_DataValue *v) {
  406. return readValueAttributeComplete(vn, UA_TIMESTAMPSTORETURN_NEITHER, NULL, v);
  407. }
  408. static UA_StatusCode
  409. writeValueAttributeWithoutRange(UA_VariableNode *node, const UA_DataValue *value) {
  410. UA_DataValue old_value = node->value.data.value; /* keep the pointers for restoring */
  411. UA_StatusCode retval = UA_DataValue_copy(value, &node->value.data.value);
  412. if(retval == UA_STATUSCODE_GOOD)
  413. UA_DataValue_deleteMembers(&old_value);
  414. else
  415. node->value.data.value = old_value;
  416. return retval;
  417. }
  418. static UA_StatusCode
  419. writeValueAttributeWithRange(UA_VariableNode *node, const UA_DataValue *value,
  420. const UA_NumericRange *rangeptr) {
  421. /* Value on both sides? */
  422. if(value->status != node->value.data.value.status ||
  423. !value->hasValue || !node->value.data.value.hasValue)
  424. return UA_STATUSCODE_BADINDEXRANGEINVALID;
  425. /* Make scalar a one-entry array for range matching */
  426. UA_Variant editableValue;
  427. const UA_Variant *v = &value->value;
  428. if(UA_Variant_isScalar(&value->value)) {
  429. editableValue = value->value;
  430. editableValue.arrayLength = 1;
  431. v = &editableValue;
  432. }
  433. /* Write the value */
  434. UA_StatusCode retval = UA_Variant_setRangeCopy(&node->value.data.value.value,
  435. v->data, v->arrayLength, *rangeptr);
  436. if(retval != UA_STATUSCODE_GOOD)
  437. return retval;
  438. /* Write the status and timestamps */
  439. node->value.data.value.hasStatus = value->hasStatus;
  440. node->value.data.value.status = value->status;
  441. node->value.data.value.hasSourceTimestamp = value->hasSourceTimestamp;
  442. node->value.data.value.sourceTimestamp = value->sourceTimestamp;
  443. node->value.data.value.hasSourcePicoseconds = value->hasSourcePicoseconds;
  444. node->value.data.value.sourcePicoseconds = value->sourcePicoseconds;
  445. return UA_STATUSCODE_GOOD;
  446. }
  447. UA_StatusCode
  448. writeValueAttribute(UA_Server *server, UA_VariableNode *node,
  449. const UA_DataValue *value, const UA_String *indexRange) {
  450. /* Parse the range */
  451. UA_NumericRange range;
  452. UA_NumericRange *rangeptr = NULL;
  453. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  454. if(indexRange && indexRange->length > 0) {
  455. retval = parse_numericrange(indexRange, &range);
  456. if(retval != UA_STATUSCODE_GOOD)
  457. return retval;
  458. rangeptr = &range;
  459. }
  460. /* Copy the value into an editable "container" where e.g. the datatype can
  461. * be adjusted. The data itself is not written into. */
  462. UA_DataValue editableValue = *value;
  463. editableValue.value.storageType = UA_VARIANT_DATA_NODELETE;
  464. /* Type checking. May change the type of editableValue */
  465. if(value->hasValue) {
  466. retval = typeCheckValue(server, &node->dataType, node->valueRank,
  467. node->arrayDimensionsSize, node->arrayDimensions,
  468. &value->value, rangeptr, &editableValue.value);
  469. if(retval != UA_STATUSCODE_GOOD)
  470. goto cleanup;
  471. }
  472. /* Set the source timestamp if there is none */
  473. if(!editableValue.hasSourceTimestamp) {
  474. editableValue.sourceTimestamp = UA_DateTime_now();
  475. editableValue.hasSourceTimestamp = true;
  476. }
  477. /* Ok, do it */
  478. if(node->valueSource == UA_VALUESOURCE_DATA) {
  479. if(!rangeptr)
  480. retval = writeValueAttributeWithoutRange(node, &editableValue);
  481. else
  482. retval = writeValueAttributeWithRange(node, &editableValue, rangeptr);
  483. /* Callback after writing */
  484. if(retval == UA_STATUSCODE_GOOD && node->value.data.callback.onWrite)
  485. node->value.data.callback.onWrite(node->value.data.callback.handle, node->nodeId,
  486. &node->value.data.value.value, rangeptr);
  487. } else {
  488. if(node->value.dataSource.write)
  489. retval = node->value.dataSource.write(node->value.dataSource.handle,
  490. node->nodeId, &editableValue.value, rangeptr);
  491. else
  492. retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
  493. }
  494. /* Clean up */
  495. cleanup:
  496. if(rangeptr)
  497. UA_free(range.dimensions);
  498. return retval;
  499. }
  500. /************************/
  501. /* IsAbstract Attribute */
  502. /************************/
  503. static UA_StatusCode
  504. readIsAbstractAttribute(const UA_Node *node, UA_Variant *v) {
  505. const UA_Boolean *isAbstract;
  506. switch(node->nodeClass) {
  507. case UA_NODECLASS_REFERENCETYPE:
  508. isAbstract = &((const UA_ReferenceTypeNode*)node)->isAbstract;
  509. break;
  510. case UA_NODECLASS_OBJECTTYPE:
  511. isAbstract = &((const UA_ObjectTypeNode*)node)->isAbstract;
  512. break;
  513. case UA_NODECLASS_VARIABLETYPE:
  514. isAbstract = &((const UA_VariableTypeNode*)node)->isAbstract;
  515. break;
  516. case UA_NODECLASS_DATATYPE:
  517. isAbstract = &((const UA_DataTypeNode*)node)->isAbstract;
  518. break;
  519. default:
  520. return UA_STATUSCODE_BADATTRIBUTEIDINVALID;
  521. }
  522. forceVariantSetScalar(v, isAbstract, &UA_TYPES[UA_TYPES_BOOLEAN]);
  523. return UA_STATUSCODE_GOOD;
  524. }
  525. static UA_StatusCode
  526. writeIsAbstractAttribute(UA_Node *node, UA_Boolean value) {
  527. switch(node->nodeClass) {
  528. case UA_NODECLASS_OBJECTTYPE:
  529. ((UA_ObjectTypeNode*)node)->isAbstract = value;
  530. break;
  531. case UA_NODECLASS_REFERENCETYPE:
  532. ((UA_ReferenceTypeNode*)node)->isAbstract = value;
  533. break;
  534. case UA_NODECLASS_VARIABLETYPE:
  535. ((UA_VariableTypeNode*)node)->isAbstract = value;
  536. break;
  537. case UA_NODECLASS_DATATYPE:
  538. ((UA_DataTypeNode*)node)->isAbstract = value;
  539. break;
  540. default:
  541. return UA_STATUSCODE_BADNODECLASSINVALID;
  542. }
  543. return UA_STATUSCODE_GOOD;
  544. }
  545. /****************/
  546. /* Read Service */
  547. /****************/
  548. static const UA_String binEncoding = {sizeof("DefaultBinary")-1, (UA_Byte*)"DefaultBinary"};
  549. /* static const UA_String xmlEncoding = {sizeof("DefaultXml")-1, (UA_Byte*)"DefaultXml"}; */
  550. #define CHECK_NODECLASS(CLASS) \
  551. if(!(node->nodeClass & (CLASS))) { \
  552. retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID; \
  553. break; \
  554. }
  555. void Service_Read_single(UA_Server *server, UA_Session *session,
  556. const UA_TimestampsToReturn timestamps,
  557. const UA_ReadValueId *id, UA_DataValue *v) {
  558. UA_LOG_DEBUG_SESSION(server->config.logger, session,
  559. "Read the attribute %i", id->attributeId);
  560. /* XML encoding is not supported */
  561. if(id->dataEncoding.name.length > 0 &&
  562. !UA_String_equal(&binEncoding, &id->dataEncoding.name)) {
  563. v->hasStatus = true;
  564. v->status = UA_STATUSCODE_BADDATAENCODINGUNSUPPORTED;
  565. return;
  566. }
  567. /* Index range for an attribute other than value */
  568. if(id->indexRange.length > 0 && id->attributeId != UA_ATTRIBUTEID_VALUE) {
  569. v->hasStatus = true;
  570. v->status = UA_STATUSCODE_BADINDEXRANGENODATA;
  571. return;
  572. }
  573. /* Get the node */
  574. const UA_Node *node = UA_NodeStore_get(server->nodestore, &id->nodeId);
  575. if(!node) {
  576. v->hasStatus = true;
  577. v->status = UA_STATUSCODE_BADNODEIDUNKNOWN;
  578. return;
  579. }
  580. /* Read the attribute */
  581. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  582. switch(id->attributeId) {
  583. case UA_ATTRIBUTEID_NODEID:
  584. forceVariantSetScalar(&v->value, &node->nodeId, &UA_TYPES[UA_TYPES_NODEID]);
  585. break;
  586. case UA_ATTRIBUTEID_NODECLASS:
  587. forceVariantSetScalar(&v->value, &node->nodeClass, &UA_TYPES[UA_TYPES_NODECLASS]);
  588. break;
  589. case UA_ATTRIBUTEID_BROWSENAME:
  590. forceVariantSetScalar(&v->value, &node->browseName, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
  591. break;
  592. case UA_ATTRIBUTEID_DISPLAYNAME:
  593. forceVariantSetScalar(&v->value, &node->displayName, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
  594. break;
  595. case UA_ATTRIBUTEID_DESCRIPTION:
  596. forceVariantSetScalar(&v->value, &node->description, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
  597. break;
  598. case UA_ATTRIBUTEID_WRITEMASK:
  599. forceVariantSetScalar(&v->value, &node->writeMask, &UA_TYPES[UA_TYPES_UINT32]);
  600. break;
  601. case UA_ATTRIBUTEID_USERWRITEMASK:
  602. forceVariantSetScalar(&v->value, &node->userWriteMask, &UA_TYPES[UA_TYPES_UINT32]);
  603. break;
  604. case UA_ATTRIBUTEID_ISABSTRACT:
  605. retval = readIsAbstractAttribute(node, &v->value);
  606. break;
  607. case UA_ATTRIBUTEID_SYMMETRIC:
  608. CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
  609. forceVariantSetScalar(&v->value, &((const UA_ReferenceTypeNode*)node)->symmetric,
  610. &UA_TYPES[UA_TYPES_BOOLEAN]);
  611. break;
  612. case UA_ATTRIBUTEID_INVERSENAME:
  613. CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
  614. forceVariantSetScalar(&v->value, &((const UA_ReferenceTypeNode*)node)->inverseName,
  615. &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
  616. break;
  617. case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
  618. CHECK_NODECLASS(UA_NODECLASS_VIEW);
  619. forceVariantSetScalar(&v->value, &((const UA_ViewNode*)node)->containsNoLoops,
  620. &UA_TYPES[UA_TYPES_BOOLEAN]);
  621. break;
  622. case UA_ATTRIBUTEID_EVENTNOTIFIER:
  623. CHECK_NODECLASS(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
  624. forceVariantSetScalar(&v->value, &((const UA_ViewNode*)node)->eventNotifier,
  625. &UA_TYPES[UA_TYPES_BYTE]);
  626. break;
  627. case UA_ATTRIBUTEID_VALUE:
  628. CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  629. retval = readValueAttributeComplete((const UA_VariableNode*)node,
  630. timestamps, &id->indexRange, v);
  631. break;
  632. case UA_ATTRIBUTEID_DATATYPE:
  633. CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  634. forceVariantSetScalar(&v->value, &((const UA_VariableTypeNode*)node)->dataType,
  635. &UA_TYPES[UA_TYPES_NODEID]);
  636. break;
  637. case UA_ATTRIBUTEID_VALUERANK:
  638. CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  639. forceVariantSetScalar(&v->value, &((const UA_VariableTypeNode*)node)->valueRank,
  640. &UA_TYPES[UA_TYPES_INT32]);
  641. break;
  642. case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
  643. CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  644. retval = readArrayDimensionsAttribute((const UA_VariableNode*)node, v);
  645. break;
  646. case UA_ATTRIBUTEID_ACCESSLEVEL:
  647. CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
  648. forceVariantSetScalar(&v->value, &((const UA_VariableNode*)node)->accessLevel,
  649. &UA_TYPES[UA_TYPES_BYTE]);
  650. break;
  651. case UA_ATTRIBUTEID_USERACCESSLEVEL:
  652. CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
  653. forceVariantSetScalar(&v->value, &((const UA_VariableNode*)node)->userAccessLevel,
  654. &UA_TYPES[UA_TYPES_BYTE]);
  655. break;
  656. case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
  657. CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
  658. forceVariantSetScalar(&v->value, &((const UA_VariableNode*)node)->minimumSamplingInterval,
  659. &UA_TYPES[UA_TYPES_DOUBLE]);
  660. break;
  661. case UA_ATTRIBUTEID_HISTORIZING:
  662. CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
  663. forceVariantSetScalar(&v->value, &((const UA_VariableNode*)node)->historizing,
  664. &UA_TYPES[UA_TYPES_BOOLEAN]);
  665. break;
  666. case UA_ATTRIBUTEID_EXECUTABLE:
  667. CHECK_NODECLASS(UA_NODECLASS_METHOD);
  668. forceVariantSetScalar(&v->value, &((const UA_MethodNode*)node)->executable,
  669. &UA_TYPES[UA_TYPES_BOOLEAN]);
  670. break;
  671. case UA_ATTRIBUTEID_USEREXECUTABLE:
  672. CHECK_NODECLASS(UA_NODECLASS_METHOD);
  673. forceVariantSetScalar(&v->value, &((const UA_MethodNode*)node)->userExecutable,
  674. &UA_TYPES[UA_TYPES_BOOLEAN]);
  675. break;
  676. default:
  677. retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
  678. }
  679. /* Return error code when reading has failed */
  680. if(retval != UA_STATUSCODE_GOOD) {
  681. v->hasStatus = true;
  682. v->status = retval;
  683. return;
  684. }
  685. v->hasValue = true;
  686. /* Create server timestamp */
  687. if(timestamps == UA_TIMESTAMPSTORETURN_SERVER ||
  688. timestamps == UA_TIMESTAMPSTORETURN_BOTH) {
  689. v->serverTimestamp = UA_DateTime_now();
  690. v->hasServerTimestamp = true;
  691. }
  692. /* Handle source time stamp */
  693. if(id->attributeId == UA_ATTRIBUTEID_VALUE) {
  694. if (timestamps == UA_TIMESTAMPSTORETURN_SERVER ||
  695. timestamps == UA_TIMESTAMPSTORETURN_NEITHER) {
  696. v->hasSourceTimestamp = false;
  697. v->hasSourcePicoseconds = false;
  698. } else if(!v->hasSourceTimestamp) {
  699. v->sourceTimestamp = UA_DateTime_now();
  700. v->hasSourceTimestamp = true;
  701. }
  702. }
  703. }
  704. void Service_Read(UA_Server *server, UA_Session *session,
  705. const UA_ReadRequest *request, UA_ReadResponse *response) {
  706. UA_LOG_DEBUG_SESSION(server->config.logger, session, "Processing ReadRequest");
  707. if(request->nodesToReadSize <= 0) {
  708. response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
  709. return;
  710. }
  711. /* check if the timestampstoreturn is valid */
  712. if(request->timestampsToReturn > UA_TIMESTAMPSTORETURN_NEITHER) {
  713. response->responseHeader.serviceResult = UA_STATUSCODE_BADTIMESTAMPSTORETURNINVALID;
  714. return;
  715. }
  716. size_t size = request->nodesToReadSize;
  717. response->results = UA_Array_new(size, &UA_TYPES[UA_TYPES_DATAVALUE]);
  718. if(!response->results) {
  719. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  720. return;
  721. }
  722. response->resultsSize = size;
  723. if(request->maxAge < 0) {
  724. response->responseHeader.serviceResult = UA_STATUSCODE_BADMAXAGEINVALID;
  725. return;
  726. }
  727. #ifdef UA_ENABLE_EXTERNAL_NAMESPACES
  728. UA_Boolean isExternal[size];
  729. UA_UInt32 indices[size];
  730. memset(isExternal, false, sizeof(UA_Boolean) * size);
  731. for(size_t j = 0;j<server->externalNamespacesSize;++j) {
  732. size_t indexSize = 0;
  733. for(size_t i = 0;i < size;++i) {
  734. if(request->nodesToRead[i].nodeId.namespaceIndex != server->externalNamespaces[j].index)
  735. continue;
  736. isExternal[i] = true;
  737. indices[indexSize] = (UA_UInt32)i;
  738. ++indexSize;
  739. }
  740. if(indexSize == 0)
  741. continue;
  742. UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
  743. ens->readNodes(ens->ensHandle, &request->requestHeader, request->nodesToRead,
  744. indices, (UA_UInt32)indexSize, response->results, false,
  745. response->diagnosticInfos);
  746. }
  747. #endif
  748. for(size_t i = 0;i < size;++i) {
  749. #ifdef UA_ENABLE_EXTERNAL_NAMESPACES
  750. if(!isExternal[i])
  751. #endif
  752. Service_Read_single(server, session, request->timestampsToReturn,
  753. &request->nodesToRead[i], &response->results[i]);
  754. }
  755. #ifdef UA_ENABLE_NONSTANDARD_STATELESS
  756. /* Add an expiry header for caching */
  757. if(session->sessionId.namespaceIndex == 0 &&
  758. session->sessionId.identifierType == UA_NODEIDTYPE_NUMERIC &&
  759. session->sessionId.identifier.numeric == 0){
  760. UA_ExtensionObject additionalHeader;
  761. UA_ExtensionObject_init(&additionalHeader);
  762. additionalHeader.encoding = UA_EXTENSIONOBJECT_ENCODED_BYTESTRING;
  763. additionalHeader.content.encoded.typeId =UA_TYPES[UA_TYPES_VARIANT].typeId;
  764. UA_Variant variant;
  765. UA_Variant_init(&variant);
  766. UA_DateTime* expireArray = NULL;
  767. expireArray = UA_Array_new(request->nodesToReadSize,
  768. &UA_TYPES[UA_TYPES_DATETIME]);
  769. variant.data = expireArray;
  770. /* expires in 20 seconds */
  771. for(UA_UInt32 i = 0;i < response->resultsSize;++i) {
  772. expireArray[i] = UA_DateTime_now() + 20 * 100 * 1000 * 1000;
  773. }
  774. UA_Variant_setArray(&variant, expireArray, request->nodesToReadSize,
  775. &UA_TYPES[UA_TYPES_DATETIME]);
  776. size_t offset = 0;
  777. UA_ByteString str;
  778. size_t strlength = UA_calcSizeBinary(&variant, &UA_TYPES[UA_TYPES_VARIANT]);
  779. UA_ByteString_allocBuffer(&str, strlength);
  780. /* No chunking callback for the encoding */
  781. UA_StatusCode retval = UA_encodeBinary(&variant, &UA_TYPES[UA_TYPES_VARIANT],
  782. NULL, NULL, &str, &offset);
  783. UA_Array_delete(expireArray, request->nodesToReadSize, &UA_TYPES[UA_TYPES_DATETIME]);
  784. if(retval == UA_STATUSCODE_GOOD){
  785. additionalHeader.content.encoded.body.data = str.data;
  786. additionalHeader.content.encoded.body.length = offset;
  787. response->responseHeader.additionalHeader = additionalHeader;
  788. }
  789. }
  790. #endif
  791. }
  792. /* Exposes the Read service to local users */
  793. UA_DataValue
  794. UA_Server_read(UA_Server *server, const UA_ReadValueId *item,
  795. UA_TimestampsToReturn timestamps) {
  796. UA_DataValue dv;
  797. UA_DataValue_init(&dv);
  798. UA_RCU_LOCK();
  799. Service_Read_single(server, &adminSession, timestamps, item, &dv);
  800. UA_RCU_UNLOCK();
  801. return dv;
  802. }
  803. /* Used in inline functions exposing the Read service with more syntactic sugar
  804. * for individual attributes */
  805. UA_StatusCode
  806. __UA_Server_read(UA_Server *server, const UA_NodeId *nodeId,
  807. const UA_AttributeId attributeId, void *v) {
  808. /* Call the read service */
  809. UA_ReadValueId item;
  810. UA_ReadValueId_init(&item);
  811. item.nodeId = *nodeId;
  812. item.attributeId = attributeId;
  813. UA_DataValue dv = UA_Server_read(server, &item, UA_TIMESTAMPSTORETURN_NEITHER);
  814. /* Check the return value */
  815. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  816. if(dv.hasStatus)
  817. retval = dv.hasStatus;
  818. else if(!dv.hasValue)
  819. retval = UA_STATUSCODE_BADUNEXPECTEDERROR;
  820. if(retval != UA_STATUSCODE_GOOD) {
  821. UA_DataValue_deleteMembers(&dv);
  822. return retval;
  823. }
  824. /* Prepare the result */
  825. if(attributeId == UA_ATTRIBUTEID_VALUE ||
  826. attributeId == UA_ATTRIBUTEID_ARRAYDIMENSIONS) {
  827. /* Return the entire variant */
  828. if(dv.value.storageType == UA_VARIANT_DATA_NODELETE) {
  829. retval = UA_Variant_copy(&dv.value, v);
  830. } else {
  831. /* storageType is UA_VARIANT_DATA. Copy the entire variant
  832. * (including pointers and all) */
  833. memcpy(v, &dv.value, sizeof(UA_Variant));
  834. }
  835. } else {
  836. /* Return the variant content only */
  837. if(dv.value.storageType == UA_VARIANT_DATA_NODELETE) {
  838. retval = UA_copy(dv.value.data, v, dv.value.type);
  839. } else {
  840. /* storageType is UA_VARIANT_DATA. Copy the content of the type
  841. * (including pointers and all) */
  842. memcpy(v, dv.value.data, dv.value.type->memSize);
  843. /* Delete the "carrier" in the variant */
  844. UA_free(dv.value.data);
  845. }
  846. }
  847. return retval;
  848. }
  849. /*****************/
  850. /* Write Service */
  851. /*****************/
  852. #define CHECK_DATATYPE_SCALAR(EXP_DT) \
  853. if(!wvalue->value.hasValue || \
  854. &UA_TYPES[UA_TYPES_##EXP_DT] != wvalue->value.value.type || \
  855. !UA_Variant_isScalar(&wvalue->value.value)) { \
  856. retval = UA_STATUSCODE_BADTYPEMISMATCH; \
  857. break; \
  858. }
  859. #define CHECK_DATATYPE_ARRAY(EXP_DT) \
  860. if(!wvalue->value.hasValue || \
  861. &UA_TYPES[UA_TYPES_##EXP_DT] != wvalue->value.value.type || \
  862. UA_Variant_isScalar(&wvalue->value.value)) { \
  863. retval = UA_STATUSCODE_BADTYPEMISMATCH; \
  864. break; \
  865. }
  866. #define CHECK_NODECLASS_WRITE(CLASS) \
  867. if((node->nodeClass & (CLASS)) == 0) { \
  868. retval = UA_STATUSCODE_BADNODECLASSINVALID; \
  869. break; \
  870. }
  871. /* This function implements the main part of the write service and operates on a
  872. copy of the node (not in single-threaded mode). */
  873. static UA_StatusCode
  874. CopyAttributeIntoNode(UA_Server *server, UA_Session *session,
  875. UA_Node *node, const UA_WriteValue *wvalue) {
  876. const void *value = wvalue->value.value.data;
  877. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  878. switch(wvalue->attributeId) {
  879. case UA_ATTRIBUTEID_NODEID:
  880. case UA_ATTRIBUTEID_NODECLASS:
  881. retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
  882. break;
  883. case UA_ATTRIBUTEID_BROWSENAME:
  884. CHECK_DATATYPE_SCALAR(QUALIFIEDNAME);
  885. UA_QualifiedName_deleteMembers(&node->browseName);
  886. UA_QualifiedName_copy(value, &node->browseName);
  887. break;
  888. case UA_ATTRIBUTEID_DISPLAYNAME:
  889. CHECK_DATATYPE_SCALAR(LOCALIZEDTEXT);
  890. UA_LocalizedText_deleteMembers(&node->displayName);
  891. UA_LocalizedText_copy(value, &node->displayName);
  892. break;
  893. case UA_ATTRIBUTEID_DESCRIPTION:
  894. CHECK_DATATYPE_SCALAR(LOCALIZEDTEXT);
  895. UA_LocalizedText_deleteMembers(&node->description);
  896. UA_LocalizedText_copy(value, &node->description);
  897. break;
  898. case UA_ATTRIBUTEID_WRITEMASK:
  899. CHECK_DATATYPE_SCALAR(UINT32);
  900. node->writeMask = *(const UA_UInt32*)value;
  901. break;
  902. case UA_ATTRIBUTEID_USERWRITEMASK:
  903. CHECK_DATATYPE_SCALAR(UINT32);
  904. node->userWriteMask = *(const UA_UInt32*)value;
  905. break;
  906. case UA_ATTRIBUTEID_ISABSTRACT:
  907. CHECK_DATATYPE_SCALAR(BOOLEAN);
  908. retval = writeIsAbstractAttribute(node, *(const UA_Boolean*)value);
  909. break;
  910. case UA_ATTRIBUTEID_SYMMETRIC:
  911. CHECK_NODECLASS_WRITE(UA_NODECLASS_REFERENCETYPE);
  912. CHECK_DATATYPE_SCALAR(BOOLEAN);
  913. ((UA_ReferenceTypeNode*)node)->symmetric = *(const UA_Boolean*)value;
  914. break;
  915. case UA_ATTRIBUTEID_INVERSENAME:
  916. CHECK_NODECLASS_WRITE(UA_NODECLASS_REFERENCETYPE);
  917. CHECK_DATATYPE_SCALAR(LOCALIZEDTEXT);
  918. UA_LocalizedText_deleteMembers(&((UA_ReferenceTypeNode*)node)->inverseName);
  919. UA_LocalizedText_copy(value, &((UA_ReferenceTypeNode*)node)->inverseName);
  920. break;
  921. case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
  922. CHECK_NODECLASS_WRITE(UA_NODECLASS_VIEW);
  923. CHECK_DATATYPE_SCALAR(BOOLEAN);
  924. ((UA_ViewNode*)node)->containsNoLoops = *(const UA_Boolean*)value;
  925. break;
  926. case UA_ATTRIBUTEID_EVENTNOTIFIER:
  927. CHECK_NODECLASS_WRITE(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
  928. CHECK_DATATYPE_SCALAR(BYTE);
  929. ((UA_ViewNode*)node)->eventNotifier = *(const UA_Byte*)value;
  930. break;
  931. case UA_ATTRIBUTEID_VALUE:
  932. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  933. retval = writeValueAttribute(server, (UA_VariableNode*)node,
  934. &wvalue->value, &wvalue->indexRange);
  935. break;
  936. case UA_ATTRIBUTEID_DATATYPE:
  937. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  938. CHECK_DATATYPE_SCALAR(NODEID);
  939. retval = writeDataTypeAttributeWithVT(server, (UA_VariableNode*)node, (const UA_NodeId*)value);
  940. break;
  941. case UA_ATTRIBUTEID_VALUERANK:
  942. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  943. CHECK_DATATYPE_SCALAR(INT32);
  944. retval = writeValueRankAttributeWithVT(server, (UA_VariableNode*)node, *(const UA_Int32*)value);
  945. break;
  946. case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
  947. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  948. CHECK_DATATYPE_ARRAY(UINT32);
  949. retval = writeArrayDimensionsAttribute(server, (UA_VariableNode*)node,
  950. wvalue->value.value.arrayLength,
  951. wvalue->value.value.data);
  952. break;
  953. case UA_ATTRIBUTEID_ACCESSLEVEL:
  954. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
  955. CHECK_DATATYPE_SCALAR(BYTE);
  956. ((UA_VariableNode*)node)->accessLevel = *(const UA_Byte*)value;
  957. break;
  958. case UA_ATTRIBUTEID_USERACCESSLEVEL:
  959. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
  960. CHECK_DATATYPE_SCALAR(BYTE);
  961. ((UA_VariableNode*)node)->userAccessLevel = *(const UA_Byte*)value;
  962. break;
  963. case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
  964. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
  965. CHECK_DATATYPE_SCALAR(DOUBLE);
  966. ((UA_VariableNode*)node)->minimumSamplingInterval = *(const UA_Double*)value;
  967. break;
  968. case UA_ATTRIBUTEID_HISTORIZING:
  969. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
  970. CHECK_DATATYPE_SCALAR(BOOLEAN);
  971. ((UA_VariableNode*)node)->historizing = *(const UA_Boolean*)value;
  972. break;
  973. case UA_ATTRIBUTEID_EXECUTABLE:
  974. CHECK_NODECLASS_WRITE(UA_NODECLASS_METHOD);
  975. CHECK_DATATYPE_SCALAR(BOOLEAN);
  976. ((UA_MethodNode*)node)->executable = *(const UA_Boolean*)value;
  977. break;
  978. case UA_ATTRIBUTEID_USEREXECUTABLE:
  979. CHECK_NODECLASS_WRITE(UA_NODECLASS_METHOD);
  980. CHECK_DATATYPE_SCALAR(BOOLEAN);
  981. ((UA_MethodNode*)node)->userExecutable = *(const UA_Boolean*)value;
  982. break;
  983. default:
  984. retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
  985. break;
  986. }
  987. if(retval != UA_STATUSCODE_GOOD)
  988. UA_LOG_INFO_SESSION(server->config.logger, session,
  989. "WriteRequest returned status code 0x%08x", retval);
  990. return retval;
  991. }
  992. void
  993. Service_Write(UA_Server *server, UA_Session *session,
  994. const UA_WriteRequest *request, UA_WriteResponse *response) {
  995. UA_LOG_DEBUG_SESSION(server->config.logger, session, "Processing WriteRequest");
  996. if(request->nodesToWriteSize <= 0) {
  997. response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
  998. return;
  999. }
  1000. response->results = UA_Array_new(request->nodesToWriteSize, &UA_TYPES[UA_TYPES_STATUSCODE]);
  1001. if(!response->results) {
  1002. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  1003. return;
  1004. }
  1005. response->resultsSize = request->nodesToWriteSize;
  1006. #ifndef UA_ENABLE_EXTERNAL_NAMESPACES
  1007. for(size_t i = 0;i < request->nodesToWriteSize;++i) {
  1008. response->results[i] = UA_Server_editNode(server, session, &request->nodesToWrite[i].nodeId,
  1009. (UA_EditNodeCallback)CopyAttributeIntoNode,
  1010. &request->nodesToWrite[i]);
  1011. }
  1012. #else
  1013. UA_Boolean isExternal[request->nodesToWriteSize];
  1014. UA_UInt32 indices[request->nodesToWriteSize];
  1015. memset(isExternal, false, sizeof(UA_Boolean)*request->nodesToWriteSize);
  1016. for(size_t j = 0; j < server->externalNamespacesSize; ++j) {
  1017. UA_UInt32 indexSize = 0;
  1018. for(size_t i = 0; i < request->nodesToWriteSize; ++i) {
  1019. if(request->nodesToWrite[i].nodeId.namespaceIndex !=
  1020. server->externalNamespaces[j].index)
  1021. continue;
  1022. isExternal[i] = true;
  1023. indices[indexSize] = (UA_UInt32)i;
  1024. ++indexSize;
  1025. }
  1026. if(indexSize == 0)
  1027. continue;
  1028. UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
  1029. ens->writeNodes(ens->ensHandle, &request->requestHeader, request->nodesToWrite,
  1030. indices, indexSize, response->results, response->diagnosticInfos);
  1031. }
  1032. for(size_t i = 0;i < request->nodesToWriteSize;++i) {
  1033. if(isExternal[i])
  1034. continue;
  1035. response->results[i] = UA_Server_editNode(server, session, &request->nodesToWrite[i].nodeId,
  1036. (UA_EditNodeCallback)CopyAttributeIntoNode,
  1037. &request->nodesToWrite[i]);
  1038. }
  1039. #endif
  1040. }
  1041. UA_StatusCode
  1042. UA_Server_write(UA_Server *server, const UA_WriteValue *value) {
  1043. UA_RCU_LOCK();
  1044. UA_StatusCode retval =
  1045. UA_Server_editNode(server, &adminSession, &value->nodeId,
  1046. (UA_EditNodeCallback)CopyAttributeIntoNode, value);
  1047. UA_RCU_UNLOCK();
  1048. return retval;
  1049. }
  1050. /* Convenience function to be wrapped into inline functions */
  1051. UA_StatusCode
  1052. __UA_Server_write(UA_Server *server, const UA_NodeId *nodeId,
  1053. const UA_AttributeId attributeId,
  1054. const UA_DataType *attr_type,
  1055. const void *value) {
  1056. UA_WriteValue wvalue;
  1057. UA_WriteValue_init(&wvalue);
  1058. wvalue.nodeId = *nodeId;
  1059. wvalue.attributeId = attributeId;
  1060. wvalue.value.hasValue = true;
  1061. if(attr_type != &UA_TYPES[UA_TYPES_VARIANT]) {
  1062. /* hacked cast. the target WriteValue is used as const anyway */
  1063. UA_Variant_setScalar(&wvalue.value.value, (void*)(uintptr_t)value, attr_type);
  1064. } else {
  1065. wvalue.value.value = *(const UA_Variant*)value;
  1066. }
  1067. return UA_Server_write(server, &wvalue);
  1068. }