ua_services_attribute.c 52 KB

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