ua_services_attribute.c 50 KB

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