ua_services_attribute.c 58 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448
  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. *
  5. * Copyright 2014-2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer)
  6. * Copyright 2015-2016 (c) Sten Grüner
  7. * Copyright 2014-2017 (c) Florian Palm
  8. * Copyright 2015 (c) Christian Fimmers
  9. * Copyright 2015-2016 (c) Chris Iatrou
  10. * Copyright 2015-2016 (c) Oleksiy Vasylyev
  11. * Copyright 2015 (c) wuyangtang
  12. * Copyright 2017 (c) Stefan Profanter, fortiss GmbH
  13. * Copyright 2016 (c) Lorenz Haas
  14. * Copyright 2017 (c) frax2222
  15. * Copyright 2017 (c) Thomas Bender
  16. * Copyright 2017 (c) Julian Grothoff
  17. * Copyright 2017 (c) Jonas Green
  18. * Copyright 2017 (c) Henrik Norrman
  19. */
  20. #include "ua_server_internal.h"
  21. #include "ua_types_encoding_binary.h"
  22. #include "ua_services.h"
  23. /******************/
  24. /* Access Control */
  25. /******************/
  26. static UA_UInt32
  27. getUserWriteMask(UA_Server *server, const UA_Session *session,
  28. const UA_Node *node) {
  29. if(session == &adminSession)
  30. return 0xFFFFFFFF; /* the local admin user has all rights */
  31. return node->writeMask &
  32. server->config.accessControl.getUserRightsMask(server, &server->config.accessControl,
  33. &session->sessionId, session->sessionHandle,
  34. &node->nodeId, node->context);
  35. }
  36. static UA_Byte
  37. getAccessLevel(UA_Server *server, const UA_Session *session,
  38. const UA_VariableNode *node) {
  39. if(session == &adminSession)
  40. return 0xFF; /* the local admin user has all rights */
  41. return node->accessLevel;
  42. }
  43. static UA_Byte
  44. getUserAccessLevel(UA_Server *server, const UA_Session *session,
  45. const UA_VariableNode *node) {
  46. if(session == &adminSession)
  47. return 0xFF; /* the local admin user has all rights */
  48. return node->accessLevel &
  49. server->config.accessControl.getUserAccessLevel(server, &server->config.accessControl,
  50. &session->sessionId, session->sessionHandle,
  51. &node->nodeId, node->context);
  52. }
  53. static UA_Boolean
  54. getUserExecutable(UA_Server *server, const UA_Session *session,
  55. const UA_MethodNode *node) {
  56. if(session == &adminSession)
  57. return true; /* the local admin user has all rights */
  58. return node->executable &
  59. server->config.accessControl.getUserExecutable(server, &server->config.accessControl,
  60. &session->sessionId, session->sessionHandle,
  61. &node->nodeId, node->context);
  62. }
  63. /****************/
  64. /* Read Service */
  65. /****************/
  66. static UA_StatusCode
  67. readArrayDimensionsAttribute(const UA_VariableNode *vn, UA_DataValue *v) {
  68. UA_Variant_setArray(&v->value, vn->arrayDimensions,
  69. vn->arrayDimensionsSize, &UA_TYPES[UA_TYPES_UINT32]);
  70. v->value.storageType = UA_VARIANT_DATA_NODELETE;
  71. return UA_STATUSCODE_GOOD;
  72. }
  73. static void
  74. setScalarNoDelete(UA_Variant *v, const void * UA_RESTRICT p,
  75. const UA_DataType *type) {
  76. UA_Variant_setScalar(v, (void*)(uintptr_t)p, type);
  77. v->storageType = UA_VARIANT_DATA_NODELETE;
  78. }
  79. static UA_StatusCode
  80. readIsAbstractAttribute(const UA_Node *node, UA_Variant *v) {
  81. const UA_Boolean *isAbstract;
  82. switch(node->nodeClass) {
  83. case UA_NODECLASS_REFERENCETYPE:
  84. isAbstract = &((const UA_ReferenceTypeNode*)node)->isAbstract;
  85. break;
  86. case UA_NODECLASS_OBJECTTYPE:
  87. isAbstract = &((const UA_ObjectTypeNode*)node)->isAbstract;
  88. break;
  89. case UA_NODECLASS_VARIABLETYPE:
  90. isAbstract = &((const UA_VariableTypeNode*)node)->isAbstract;
  91. break;
  92. case UA_NODECLASS_DATATYPE:
  93. isAbstract = &((const UA_DataTypeNode*)node)->isAbstract;
  94. break;
  95. default:
  96. return UA_STATUSCODE_BADATTRIBUTEIDINVALID;
  97. }
  98. setScalarNoDelete(v, isAbstract, &UA_TYPES[UA_TYPES_BOOLEAN]);
  99. v->storageType = UA_VARIANT_DATA_NODELETE;
  100. return UA_STATUSCODE_GOOD;
  101. }
  102. static UA_StatusCode
  103. readValueAttributeFromNode(UA_Server *server, UA_Session *session,
  104. const UA_VariableNode *vn, UA_DataValue *v,
  105. UA_NumericRange *rangeptr) {
  106. if(vn->value.data.callback.onRead) {
  107. vn->value.data.callback.onRead(server, &session->sessionId,
  108. session->sessionHandle, &vn->nodeId,
  109. vn->context, rangeptr, &vn->value.data.value);
  110. const UA_Node *old = (const UA_Node *)vn;
  111. /* Reopen the node to see the changes from onRead */
  112. vn = (const UA_VariableNode*)UA_Nodestore_get(server, &vn->nodeId);
  113. UA_Nodestore_release(server, old);
  114. }
  115. if(rangeptr)
  116. return UA_Variant_copyRange(&vn->value.data.value.value, &v->value, *rangeptr);
  117. *v = vn->value.data.value;
  118. v->value.storageType = UA_VARIANT_DATA_NODELETE;
  119. return UA_STATUSCODE_GOOD;
  120. }
  121. static UA_StatusCode
  122. readValueAttributeFromDataSource(UA_Server *server, UA_Session *session,
  123. const UA_VariableNode *vn, UA_DataValue *v,
  124. UA_TimestampsToReturn timestamps,
  125. UA_NumericRange *rangeptr) {
  126. if(!vn->value.dataSource.read)
  127. return UA_STATUSCODE_BADINTERNALERROR;
  128. UA_Boolean sourceTimeStamp = (timestamps == UA_TIMESTAMPSTORETURN_SOURCE ||
  129. timestamps == UA_TIMESTAMPSTORETURN_BOTH);
  130. return vn->value.dataSource.read(server, &session->sessionId, session->sessionHandle,
  131. &vn->nodeId, vn->context, sourceTimeStamp, rangeptr, v);
  132. }
  133. static UA_StatusCode
  134. readValueAttributeComplete(UA_Server *server, UA_Session *session,
  135. const UA_VariableNode *vn, UA_TimestampsToReturn timestamps,
  136. const UA_String *indexRange, UA_DataValue *v) {
  137. /* Compute the index range */
  138. UA_NumericRange range;
  139. UA_NumericRange *rangeptr = NULL;
  140. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  141. if(indexRange && indexRange->length > 0) {
  142. retval = UA_NumericRange_parseFromString(&range, indexRange);
  143. if(retval != UA_STATUSCODE_GOOD)
  144. return retval;
  145. rangeptr = ⦥
  146. }
  147. /* Read the value */
  148. if(vn->valueSource == UA_VALUESOURCE_DATA)
  149. retval = readValueAttributeFromNode(server, session, vn, v, rangeptr);
  150. else
  151. retval = readValueAttributeFromDataSource(server, session, vn, v, timestamps, rangeptr);
  152. /* Clean up */
  153. if(rangeptr)
  154. UA_free(range.dimensions);
  155. return retval;
  156. }
  157. UA_StatusCode
  158. readValueAttribute(UA_Server *server, UA_Session *session,
  159. const UA_VariableNode *vn, UA_DataValue *v) {
  160. return readValueAttributeComplete(server, session, vn, UA_TIMESTAMPSTORETURN_NEITHER, NULL, v);
  161. }
  162. static const UA_String binEncoding = {sizeof("Default Binary")-1, (UA_Byte*)"Default Binary"};
  163. static const UA_String xmlEncoding = {sizeof("Default XML")-1, (UA_Byte*)"Default XML"};
  164. static const UA_String jsonEncoding = {sizeof("Default JSON")-1, (UA_Byte*)"Default JSON"};
  165. #define CHECK_NODECLASS(CLASS) \
  166. if(!(node->nodeClass & (CLASS))) { \
  167. retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID; \
  168. break; \
  169. }
  170. /* Returns a datavalue that may point into the node via the
  171. * UA_VARIANT_DATA_NODELETE tag. Don't access the returned DataValue once the
  172. * node has been released! */
  173. static void
  174. Read(const UA_Node *node, UA_Server *server, UA_Session *session,
  175. UA_TimestampsToReturn timestampsToReturn,
  176. const UA_ReadValueId *id, UA_DataValue *v) {
  177. UA_LOG_DEBUG_SESSION(server->config.logger, session,
  178. "Read the attribute %i", id->attributeId);
  179. /* Only Binary Encoding is supported */
  180. if(id->dataEncoding.name.length > 0 &&
  181. !UA_String_equal(&binEncoding, &id->dataEncoding.name)) {
  182. if(UA_String_equal(&xmlEncoding, &id->dataEncoding.name) ||
  183. UA_String_equal(&jsonEncoding, &id->dataEncoding.name))
  184. v->status = UA_STATUSCODE_BADDATAENCODINGUNSUPPORTED;
  185. else
  186. v->status = UA_STATUSCODE_BADDATAENCODINGINVALID;
  187. v->hasStatus = true;
  188. return;
  189. }
  190. /* Index range for an attribute other than value */
  191. if(id->indexRange.length > 0 && id->attributeId != UA_ATTRIBUTEID_VALUE) {
  192. v->hasStatus = true;
  193. v->status = UA_STATUSCODE_BADINDEXRANGENODATA;
  194. return;
  195. }
  196. /* Read the attribute */
  197. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  198. switch(id->attributeId) {
  199. case UA_ATTRIBUTEID_NODEID:
  200. setScalarNoDelete(&v->value, &node->nodeId, &UA_TYPES[UA_TYPES_NODEID]);
  201. break;
  202. case UA_ATTRIBUTEID_NODECLASS:
  203. setScalarNoDelete(&v->value, &node->nodeClass, &UA_TYPES[UA_TYPES_NODECLASS]);
  204. break;
  205. case UA_ATTRIBUTEID_BROWSENAME:
  206. setScalarNoDelete(&v->value, &node->browseName, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
  207. break;
  208. case UA_ATTRIBUTEID_DISPLAYNAME:
  209. setScalarNoDelete(&v->value, &node->displayName, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
  210. break;
  211. case UA_ATTRIBUTEID_DESCRIPTION:
  212. setScalarNoDelete(&v->value, &node->description, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
  213. break;
  214. case UA_ATTRIBUTEID_WRITEMASK:
  215. setScalarNoDelete(&v->value, &node->writeMask, &UA_TYPES[UA_TYPES_UINT32]);
  216. break;
  217. case UA_ATTRIBUTEID_USERWRITEMASK: {
  218. UA_UInt32 userWriteMask = getUserWriteMask(server, session, node);
  219. retval = UA_Variant_setScalarCopy(&v->value, &userWriteMask, &UA_TYPES[UA_TYPES_UINT32]);
  220. break; }
  221. case UA_ATTRIBUTEID_ISABSTRACT:
  222. retval = readIsAbstractAttribute(node, &v->value);
  223. break;
  224. case UA_ATTRIBUTEID_SYMMETRIC:
  225. CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
  226. setScalarNoDelete(&v->value, &((const UA_ReferenceTypeNode*)node)->symmetric,
  227. &UA_TYPES[UA_TYPES_BOOLEAN]);
  228. break;
  229. case UA_ATTRIBUTEID_INVERSENAME:
  230. CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
  231. setScalarNoDelete(&v->value, &((const UA_ReferenceTypeNode*)node)->inverseName,
  232. &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
  233. break;
  234. case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
  235. CHECK_NODECLASS(UA_NODECLASS_VIEW);
  236. setScalarNoDelete(&v->value, &((const UA_ViewNode*)node)->containsNoLoops,
  237. &UA_TYPES[UA_TYPES_BOOLEAN]);
  238. break;
  239. case UA_ATTRIBUTEID_EVENTNOTIFIER:
  240. CHECK_NODECLASS(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
  241. setScalarNoDelete(&v->value, &((const UA_ViewNode*)node)->eventNotifier,
  242. &UA_TYPES[UA_TYPES_BYTE]);
  243. break;
  244. case UA_ATTRIBUTEID_VALUE: {
  245. CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  246. /* VariableTypes don't have the AccessLevel concept. Always allow reading the value. */
  247. if(node->nodeClass == UA_NODECLASS_VARIABLE) {
  248. /* The access to a value variable is granted via the AccessLevel
  249. * and UserAccessLevel attributes */
  250. UA_Byte accessLevel = getAccessLevel(server, session, (const UA_VariableNode*)node);
  251. if(!(accessLevel & (UA_ACCESSLEVELMASK_READ))) {
  252. retval = UA_STATUSCODE_BADNOTREADABLE;
  253. break;
  254. }
  255. accessLevel = getUserAccessLevel(server, session,
  256. (const UA_VariableNode*)node);
  257. if(!(accessLevel & (UA_ACCESSLEVELMASK_READ))) {
  258. retval = UA_STATUSCODE_BADUSERACCESSDENIED;
  259. break;
  260. }
  261. }
  262. retval = readValueAttributeComplete(server, session, (const UA_VariableNode*)node,
  263. timestampsToReturn, &id->indexRange, v);
  264. break;
  265. }
  266. case UA_ATTRIBUTEID_DATATYPE:
  267. CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  268. setScalarNoDelete(&v->value, &((const UA_VariableTypeNode*)node)->dataType,
  269. &UA_TYPES[UA_TYPES_NODEID]);
  270. break;
  271. case UA_ATTRIBUTEID_VALUERANK:
  272. CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  273. setScalarNoDelete(&v->value, &((const UA_VariableTypeNode*)node)->valueRank,
  274. &UA_TYPES[UA_TYPES_INT32]);
  275. break;
  276. case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
  277. CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  278. retval = readArrayDimensionsAttribute((const UA_VariableNode*)node, v);
  279. break;
  280. case UA_ATTRIBUTEID_ACCESSLEVEL:
  281. CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
  282. setScalarNoDelete(&v->value, &((const UA_VariableNode*)node)->accessLevel,
  283. &UA_TYPES[UA_TYPES_BYTE]);
  284. break;
  285. case UA_ATTRIBUTEID_USERACCESSLEVEL: {
  286. CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
  287. UA_Byte userAccessLevel = getUserAccessLevel(server, session,
  288. (const UA_VariableNode*)node);
  289. retval = UA_Variant_setScalarCopy(&v->value, &userAccessLevel, &UA_TYPES[UA_TYPES_BYTE]);
  290. break; }
  291. case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
  292. CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
  293. setScalarNoDelete(&v->value, &((const UA_VariableNode*)node)->minimumSamplingInterval,
  294. &UA_TYPES[UA_TYPES_DOUBLE]);
  295. break;
  296. case UA_ATTRIBUTEID_HISTORIZING:
  297. CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
  298. setScalarNoDelete(&v->value, &((const UA_VariableNode*)node)->historizing,
  299. &UA_TYPES[UA_TYPES_BOOLEAN]);
  300. break;
  301. case UA_ATTRIBUTEID_EXECUTABLE:
  302. CHECK_NODECLASS(UA_NODECLASS_METHOD);
  303. setScalarNoDelete(&v->value, &((const UA_MethodNode*)node)->executable,
  304. &UA_TYPES[UA_TYPES_BOOLEAN]);
  305. break;
  306. case UA_ATTRIBUTEID_USEREXECUTABLE: {
  307. CHECK_NODECLASS(UA_NODECLASS_METHOD);
  308. UA_Boolean userExecutable = getUserExecutable(server, session,
  309. (const UA_MethodNode*)node);
  310. retval = UA_Variant_setScalarCopy(&v->value, &userExecutable, &UA_TYPES[UA_TYPES_BOOLEAN]);
  311. break; }
  312. default:
  313. retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
  314. }
  315. /* Return error code when reading has failed */
  316. if(retval != UA_STATUSCODE_GOOD) {
  317. v->hasStatus = true;
  318. v->status = retval;
  319. return;
  320. }
  321. v->hasValue = true;
  322. /* Create server timestamp */
  323. if(timestampsToReturn == UA_TIMESTAMPSTORETURN_SERVER ||
  324. timestampsToReturn == UA_TIMESTAMPSTORETURN_BOTH) {
  325. v->serverTimestamp = UA_DateTime_now();
  326. v->hasServerTimestamp = true;
  327. }
  328. /* Handle source time stamp */
  329. if(id->attributeId == UA_ATTRIBUTEID_VALUE) {
  330. if(timestampsToReturn == UA_TIMESTAMPSTORETURN_SERVER ||
  331. timestampsToReturn == UA_TIMESTAMPSTORETURN_NEITHER) {
  332. v->hasSourceTimestamp = false;
  333. v->hasSourcePicoseconds = false;
  334. } else if(!v->hasSourceTimestamp) {
  335. v->sourceTimestamp = UA_DateTime_now();
  336. v->hasSourceTimestamp = true;
  337. }
  338. }
  339. }
  340. static UA_StatusCode
  341. Operation_Read(UA_Server *server, UA_Session *session, UA_MessageContext *mc,
  342. UA_TimestampsToReturn timestampsToReturn, const UA_ReadValueId *id) {
  343. UA_DataValue dv;
  344. UA_DataValue_init(&dv);
  345. /* Get the node */
  346. const UA_Node *node = UA_Nodestore_get(server, &id->nodeId);
  347. /* Perform the read operation */
  348. if(node) {
  349. Read(node, server, session, timestampsToReturn, id, &dv);
  350. } else {
  351. dv.hasStatus = true;
  352. dv.status = UA_STATUSCODE_BADNODEIDUNKNOWN;
  353. }
  354. /* Encode (and send) the results */
  355. UA_StatusCode retval = UA_MessageContext_encode(mc, &dv, &UA_TYPES[UA_TYPES_DATAVALUE]);
  356. /* Free copied data and release the node */
  357. UA_Variant_deleteMembers(&dv.value);
  358. UA_Nodestore_release(server, node);
  359. return retval;
  360. }
  361. UA_StatusCode Service_Read(UA_Server *server, UA_Session *session, UA_MessageContext *mc,
  362. const UA_ReadRequest *request, UA_ResponseHeader *responseHeader) {
  363. UA_LOG_DEBUG_SESSION(server->config.logger, session,
  364. "Processing ReadRequest");
  365. /* Check if the timestampstoreturn is valid */
  366. if(request->timestampsToReturn > UA_TIMESTAMPSTORETURN_NEITHER)
  367. responseHeader->serviceResult = UA_STATUSCODE_BADTIMESTAMPSTORETURNINVALID;
  368. if(request->nodesToReadSize == 0)
  369. responseHeader->serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
  370. /* Check if maxAge is valid */
  371. if(request->maxAge < 0)
  372. responseHeader->serviceResult = UA_STATUSCODE_BADMAXAGEINVALID;
  373. /* Check if there are too many operations */
  374. if(server->config.maxNodesPerRead != 0 &&
  375. request->nodesToReadSize > server->config.maxNodesPerRead)
  376. responseHeader->serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS;
  377. /* Encode the response header */
  378. UA_StatusCode retval =
  379. UA_MessageContext_encode(mc, responseHeader, &UA_TYPES[UA_TYPES_RESPONSEHEADER]);
  380. if(retval != UA_STATUSCODE_GOOD)
  381. return retval;
  382. /* Process nothing if we return an error code for the entire service */
  383. UA_Int32 arraySize = (UA_Int32)request->nodesToReadSize;
  384. if(responseHeader->serviceResult != UA_STATUSCODE_GOOD)
  385. arraySize = 0;
  386. /* Process all ReadValueIds */
  387. retval = UA_MessageContext_encode(mc, &arraySize, &UA_TYPES[UA_TYPES_INT32]);
  388. if(retval != UA_STATUSCODE_GOOD)
  389. return retval;
  390. for(UA_Int32 i = 0; i < arraySize; i++) {
  391. retval = Operation_Read(server, session, mc, request->timestampsToReturn,
  392. &request->nodesToRead[i]);
  393. if(retval != UA_STATUSCODE_GOOD)
  394. return retval;
  395. }
  396. /* Don't return any DiagnosticInfo */
  397. arraySize = -1;
  398. return UA_MessageContext_encode(mc, &arraySize, &UA_TYPES[UA_TYPES_INT32]);
  399. }
  400. UA_DataValue
  401. UA_Server_readWithSession(UA_Server *server, UA_Session *session,
  402. const UA_ReadValueId *item,
  403. UA_TimestampsToReturn timestampsToReturn) {
  404. UA_DataValue dv;
  405. UA_DataValue_init(&dv);
  406. /* Get the node */
  407. const UA_Node *node = UA_Nodestore_get(server, &item->nodeId);
  408. if(!node) {
  409. dv.hasStatus = true;
  410. dv.status = UA_STATUSCODE_BADNODEIDUNKNOWN;
  411. return dv;
  412. }
  413. /* Perform the read operation */
  414. Read(node, server, session, timestampsToReturn, item, &dv);
  415. /* Do we have to copy the result before releasing the node? */
  416. if(dv.hasValue && dv.value.storageType == UA_VARIANT_DATA_NODELETE) {
  417. UA_DataValue dv2;
  418. UA_StatusCode retval = UA_DataValue_copy(&dv, &dv2);
  419. if(retval == UA_STATUSCODE_GOOD) {
  420. dv = dv2;
  421. } else {
  422. UA_DataValue_init(&dv);
  423. dv.hasStatus = true;
  424. dv.status = retval;
  425. }
  426. }
  427. /* Release the node and return */
  428. UA_Nodestore_release(server, node);
  429. return dv;
  430. }
  431. /* Exposes the Read service to local users */
  432. UA_DataValue
  433. UA_Server_read(UA_Server *server, const UA_ReadValueId *item,
  434. UA_TimestampsToReturn timestamps) {
  435. return UA_Server_readWithSession(server, &adminSession, item, timestamps);
  436. }
  437. /* Used in inline functions exposing the Read service with more syntactic sugar
  438. * for individual attributes */
  439. UA_StatusCode
  440. __UA_Server_read(UA_Server *server, const UA_NodeId *nodeId,
  441. const UA_AttributeId attributeId, void *v) {
  442. /* Call the read service */
  443. UA_ReadValueId item;
  444. UA_ReadValueId_init(&item);
  445. item.nodeId = *nodeId;
  446. item.attributeId = attributeId;
  447. UA_DataValue dv = UA_Server_read(server, &item, UA_TIMESTAMPSTORETURN_NEITHER);
  448. /* Check the return value */
  449. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  450. if(dv.hasStatus)
  451. retval = dv.status;
  452. else if(!dv.hasValue)
  453. retval = UA_STATUSCODE_BADUNEXPECTEDERROR;
  454. if(retval != UA_STATUSCODE_GOOD) {
  455. UA_DataValue_deleteMembers(&dv);
  456. return retval;
  457. }
  458. if(attributeId == UA_ATTRIBUTEID_VALUE ||
  459. attributeId == UA_ATTRIBUTEID_ARRAYDIMENSIONS) {
  460. /* Return the entire variant */
  461. memcpy(v, &dv.value, sizeof(UA_Variant));
  462. } else {
  463. /* Return the variant content only */
  464. memcpy(v, dv.value.data, dv.value.type->memSize);
  465. UA_free(dv.value.data);
  466. }
  467. return retval;
  468. }
  469. UA_StatusCode
  470. UA_Server_readObjectProperty(UA_Server *server, const UA_NodeId objectId,
  471. const UA_QualifiedName propertyName,
  472. UA_Variant *value) {
  473. UA_RelativePathElement rpe;
  474. UA_RelativePathElement_init(&rpe);
  475. rpe.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY);
  476. rpe.isInverse = false;
  477. rpe.includeSubtypes = false;
  478. rpe.targetName = propertyName;
  479. UA_BrowsePath bp;
  480. UA_BrowsePath_init(&bp);
  481. bp.startingNode = objectId;
  482. bp.relativePath.elementsSize = 1;
  483. bp.relativePath.elements = &rpe;
  484. UA_StatusCode retval;
  485. UA_BrowsePathResult bpr = UA_Server_translateBrowsePathToNodeIds(server, &bp);
  486. if(bpr.statusCode != UA_STATUSCODE_GOOD || bpr.targetsSize < 1) {
  487. retval = bpr.statusCode;
  488. UA_BrowsePathResult_deleteMembers(&bpr);
  489. return retval;
  490. }
  491. retval = UA_Server_readValue(server, bpr.targets[0].targetId.nodeId, value);
  492. UA_BrowsePathResult_deleteMembers(&bpr);
  493. return retval;
  494. }
  495. /*****************/
  496. /* Type Checking */
  497. /*****************/
  498. enum type_equivalence {
  499. TYPE_EQUIVALENCE_NONE,
  500. TYPE_EQUIVALENCE_ENUM,
  501. TYPE_EQUIVALENCE_OPAQUE
  502. };
  503. static enum type_equivalence
  504. typeEquivalence(const UA_DataType *t) {
  505. if(t->membersSize != 1 || !t->members[0].namespaceZero)
  506. return TYPE_EQUIVALENCE_NONE;
  507. if(t->members[0].memberTypeIndex == UA_TYPES_INT32)
  508. return TYPE_EQUIVALENCE_ENUM;
  509. if(t->members[0].memberTypeIndex == UA_TYPES_BYTE && t->members[0].isArray)
  510. return TYPE_EQUIVALENCE_OPAQUE;
  511. return TYPE_EQUIVALENCE_NONE;
  512. }
  513. static const UA_NodeId enumNodeId = {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_ENUMERATION}};
  514. UA_Boolean
  515. compatibleDataType(UA_Server *server, const UA_NodeId *dataType,
  516. const UA_NodeId *constraintDataType, UA_Boolean isValue) {
  517. /* Do not allow empty datatypes */
  518. if(UA_NodeId_isNull(dataType))
  519. return false;
  520. /* No constraint (TODO: use variant instead) */
  521. if(UA_NodeId_isNull(constraintDataType))
  522. return true;
  523. /* Same datatypes */
  524. if (UA_NodeId_equal(dataType, constraintDataType))
  525. return true;
  526. /* Variant allows any subtype */
  527. if(UA_NodeId_equal(constraintDataType, &UA_TYPES[UA_TYPES_VARIANT].typeId))
  528. return true;
  529. /* Is the value-type a subtype of the required type? */
  530. if(isNodeInTree(&server->config.nodestore, dataType, constraintDataType, &subtypeId, 1))
  531. return true;
  532. /* Enum allows Int32 (only) */
  533. if(UA_NodeId_equal(dataType, &UA_TYPES[UA_TYPES_INT32].typeId) &&
  534. isNodeInTree(&server->config.nodestore, constraintDataType, &enumNodeId, &subtypeId, 1))
  535. return true;
  536. /* More checks for the data type of real values (variants) */
  537. if(isValue) {
  538. /* If value is a built-in type: The target data type may be a sub type of
  539. * the built-in type. (e.g. UtcTime is sub-type of DateTime and has a
  540. * DateTime value). A type is builtin if its NodeId is in Namespace 0 and
  541. * has a numeric identifier <= 25 (DiagnosticInfo) */
  542. if(dataType->namespaceIndex == 0 &&
  543. dataType->identifierType == UA_NODEIDTYPE_NUMERIC &&
  544. dataType->identifier.numeric <= 25 &&
  545. isNodeInTree(&server->config.nodestore, constraintDataType,
  546. dataType, &subtypeId, 1))
  547. return true;
  548. }
  549. return false;
  550. }
  551. /* Test whether a ValueRank and the given arraydimensions are compatible.
  552. *
  553. * 5.6.2 Variable NodeClass: If the maximum is unknown the value shall be 0. The
  554. * number of elements shall be equal to the value of the ValueRank Attribute.
  555. * This Attribute shall be null if ValueRank <= 0. */
  556. UA_Boolean
  557. compatibleValueRankArrayDimensions(UA_Server *server, UA_Session *session,
  558. UA_Int32 valueRank, size_t arrayDimensionsSize) {
  559. /* ValueRank invalid */
  560. if(valueRank < -3) {
  561. UA_LOG_INFO_SESSION(server->config.logger, session, "The ValueRank is invalid (< -3)");
  562. return false;
  563. }
  564. /* case -3: the value can be a scalar or a one dimensional array */
  565. /* case -2: the value can be a scalar or an array with any number of dimensions */
  566. /* case -1: the value is a scalar */
  567. /* case 0: the value is an array with one or more dimensions */
  568. if(valueRank <= 0) {
  569. if(arrayDimensionsSize > 0) {
  570. UA_LOG_INFO_SESSION(server->config.logger, session,
  571. "No ArrayDimensions can be defined for a ValueRank <= 0");
  572. return false;
  573. }
  574. return true;
  575. }
  576. /* case >= 1: the value is an array with the specified number of dimensions */
  577. if(arrayDimensionsSize != (size_t)valueRank) {
  578. UA_LOG_INFO_SESSION(server->config.logger, session,
  579. "The number of ArrayDimensions is not equal to the (positive) ValueRank");
  580. return false;
  581. }
  582. return true;
  583. }
  584. UA_Boolean
  585. compatibleValueRanks(UA_Int32 valueRank, UA_Int32 constraintValueRank) {
  586. /* Check if the valuerank of the variabletype allows the change. */
  587. switch(constraintValueRank) {
  588. case -3: /* the value can be a scalar or a one dimensional array */
  589. if(valueRank != -1 && valueRank != 1)
  590. return false;
  591. break;
  592. case -2: /* the value can be a scalar or an array with any number of dimensions */
  593. break;
  594. case -1: /* the value is a scalar */
  595. if(valueRank != -1)
  596. return false;
  597. break;
  598. case 0: /* the value is an array with one or more dimensions */
  599. if(valueRank < (UA_Int32) 0)
  600. return false;
  601. break;
  602. default: /* >= 1: the value is an array with the specified number of dimensions */
  603. if(valueRank != constraintValueRank)
  604. return false;
  605. break;
  606. }
  607. return true;
  608. }
  609. /* Check if the ValueRank allows for the value dimension. This is more
  610. * permissive than checking for the ArrayDimensions attribute. Because the value
  611. * can have dimensions if the ValueRank < 0 */
  612. static UA_Boolean
  613. compatibleValueRankValue(UA_Int32 valueRank, const UA_Variant *value) {
  614. /* Invalid ValueRank */
  615. if(valueRank < -3)
  616. return false;
  617. /* Empty arrays (-1) always match */
  618. if(!value->data)
  619. return true;
  620. size_t arrayDims = value->arrayDimensionsSize;
  621. if(arrayDims == 0 && !UA_Variant_isScalar(value))
  622. arrayDims = 1; /* array but no arraydimensions -> implicit array dimension 1 */
  623. /* We cannot simply use compatibleValueRankArrayDimensions since we can have
  624. * defined ArrayDimensions for the value if the ValueRank is -2 */
  625. switch(valueRank) {
  626. case -3: /* The value can be a scalar or a one dimensional array */
  627. return (arrayDims <= 1);
  628. case -2: /* The value can be a scalar or an array with any number of dimensions */
  629. return true;
  630. case -1: /* The value is a scalar */
  631. return (arrayDims == 0);
  632. default:
  633. break;
  634. }
  635. UA_assert(valueRank >= 0);
  636. /* case 0: the value is an array with one or more dimensions */
  637. return (arrayDims == (UA_UInt32)valueRank);
  638. }
  639. UA_Boolean
  640. compatibleArrayDimensions(size_t constraintArrayDimensionsSize,
  641. const UA_UInt32 *constraintArrayDimensions,
  642. size_t testArrayDimensionsSize,
  643. const UA_UInt32 *testArrayDimensions) {
  644. /* No array dimensions defined -> everything is permitted if the value rank fits */
  645. if(constraintArrayDimensionsSize == 0)
  646. return true;
  647. /* Dimension count must match */
  648. if(testArrayDimensionsSize != constraintArrayDimensionsSize)
  649. return false;
  650. /* Dimension lengths must match; zero in the constraint is a wildcard */
  651. for(size_t i = 0; i < constraintArrayDimensionsSize; ++i) {
  652. if(constraintArrayDimensions[i] != testArrayDimensions[i] &&
  653. constraintArrayDimensions[i] != 0)
  654. return false;
  655. }
  656. return true;
  657. }
  658. UA_Boolean
  659. compatibleValueArrayDimensions(const UA_Variant *value, size_t targetArrayDimensionsSize,
  660. const UA_UInt32 *targetArrayDimensions) {
  661. size_t valueArrayDimensionsSize = value->arrayDimensionsSize;
  662. UA_UInt32 *valueArrayDimensions = value->arrayDimensions;
  663. UA_UInt32 tempArrayDimensions;
  664. if(valueArrayDimensions == 0 && !UA_Variant_isScalar(value)) {
  665. valueArrayDimensionsSize = 1;
  666. tempArrayDimensions = (UA_UInt32)value->arrayLength;
  667. valueArrayDimensions = &tempArrayDimensions;
  668. }
  669. return compatibleArrayDimensions(targetArrayDimensionsSize, targetArrayDimensions,
  670. valueArrayDimensionsSize, valueArrayDimensions);
  671. }
  672. UA_Boolean
  673. compatibleValue(UA_Server *server, UA_Session *session, const UA_NodeId *targetDataTypeId,
  674. UA_Int32 targetValueRank, size_t targetArrayDimensionsSize,
  675. const UA_UInt32 *targetArrayDimensions, const UA_Variant *value,
  676. const UA_NumericRange *range) {
  677. /* Empty value */
  678. if(!value->type) {
  679. /* Empty value is allowed for BaseDataType */
  680. if(UA_NodeId_equal(targetDataTypeId, &UA_TYPES[UA_TYPES_VARIANT].typeId) ||
  681. UA_NodeId_equal(targetDataTypeId, &UA_NODEID_NULL))
  682. return true;
  683. /* Workaround: Allow empty value if the target data type is abstract */
  684. const UA_Node *datatype = UA_Nodestore_get(server, targetDataTypeId);
  685. if(datatype && datatype->nodeClass == UA_NODECLASS_DATATYPE) {
  686. UA_Boolean isAbstract = ((const UA_DataTypeNode*)datatype)->isAbstract;
  687. UA_Nodestore_release(server, datatype);
  688. if(isAbstract)
  689. return true;
  690. }
  691. UA_LOG_INFO(server->config.logger, UA_LOGCATEGORY_SERVER,
  692. "Only Variables with data type BaseDataType should contain "
  693. "a null (empty) value");
  694. /* we allow addition of the node anyways since existing information models may have
  695. variables with no value, e.g. OldValues - ns=0;i=3024.
  696. See also #1889, https://github.com/open62541/open62541/pull/1889#issuecomment-403506538 */
  697. return true;
  698. }
  699. /* Has the value a subtype of the required type? BaseDataType (Variant) can
  700. * be anything... */
  701. if(!compatibleDataType(server, &value->type->typeId, targetDataTypeId, true))
  702. return false;
  703. /* Array dimensions are checked later when writing the range */
  704. if(range)
  705. return true;
  706. /* See if the array dimensions match. */
  707. if(!compatibleValueArrayDimensions(value, targetArrayDimensionsSize, targetArrayDimensions))
  708. return false;
  709. /* Check if the valuerank allows for the value dimension */
  710. return compatibleValueRankValue(targetValueRank, value);
  711. }
  712. /*****************/
  713. /* Write Service */
  714. /*****************/
  715. static void
  716. adjustValue(UA_Server *server, UA_Variant *value,
  717. const UA_NodeId *targetDataTypeId) {
  718. const UA_DataType *targetDataType = UA_findDataType(targetDataTypeId);
  719. if(!targetDataType)
  720. return;
  721. /* A string is written to a byte array. the valuerank and array dimensions
  722. * are checked later */
  723. if(targetDataType == &UA_TYPES[UA_TYPES_BYTE] &&
  724. value->type == &UA_TYPES[UA_TYPES_BYTESTRING] &&
  725. UA_Variant_isScalar(value)) {
  726. UA_ByteString *str = (UA_ByteString*)value->data;
  727. value->type = &UA_TYPES[UA_TYPES_BYTE];
  728. value->arrayLength = str->length;
  729. value->data = str->data;
  730. return;
  731. }
  732. /* An enum was sent as an int32, or an opaque type as a bytestring. This
  733. * is detected with the typeIndex indicating the "true" datatype. */
  734. enum type_equivalence te1 = typeEquivalence(targetDataType);
  735. enum type_equivalence te2 = typeEquivalence(value->type);
  736. if(te1 != TYPE_EQUIVALENCE_NONE && te1 == te2) {
  737. value->type = targetDataType;
  738. return;
  739. }
  740. /* No more possible equivalencies */
  741. }
  742. static UA_StatusCode
  743. writeArrayDimensionsAttribute(UA_Server *server, UA_Session *session,
  744. UA_VariableNode *node, const UA_VariableTypeNode *type,
  745. size_t arrayDimensionsSize, UA_UInt32 *arrayDimensions) {
  746. UA_assert(node != NULL);
  747. UA_assert(type != NULL);
  748. /* If this is a variabletype, there must be no instances or subtypes of it
  749. * when we do the change */
  750. if(node->nodeClass == UA_NODECLASS_VARIABLETYPE &&
  751. UA_Node_hasSubTypeOrInstances((UA_Node*)node)) {
  752. UA_LOG_INFO(server->config.logger, UA_LOGCATEGORY_SERVER,
  753. "Cannot change a variable type with existing instances");
  754. return UA_STATUSCODE_BADINTERNALERROR;
  755. }
  756. /* Check that the array dimensions match with the valuerank */
  757. if(!compatibleValueRankArrayDimensions(server, session, node->valueRank, arrayDimensionsSize)) {
  758. UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SERVER,
  759. "Cannot write the ArrayDimensions. The ValueRank does not match.");
  760. return UA_STATUSCODE_BADTYPEMISMATCH;
  761. }
  762. /* Check if the array dimensions match with the wildcards in the
  763. * variabletype (dimension length 0) */
  764. if(type->arrayDimensions &&
  765. !compatibleArrayDimensions(type->arrayDimensionsSize, type->arrayDimensions,
  766. arrayDimensionsSize, arrayDimensions)) {
  767. UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SERVER,
  768. "Array dimensions in the variable type do not match");
  769. return UA_STATUSCODE_BADTYPEMISMATCH;
  770. }
  771. /* Check if the current value is compatible with the array dimensions */
  772. UA_DataValue value;
  773. UA_DataValue_init(&value);
  774. UA_StatusCode retval = readValueAttribute(server, session, node, &value);
  775. if(retval != UA_STATUSCODE_GOOD)
  776. return retval;
  777. if(value.hasValue) {
  778. if(!compatibleValueArrayDimensions(&value.value, arrayDimensionsSize, arrayDimensions))
  779. retval = UA_STATUSCODE_BADTYPEMISMATCH;
  780. UA_DataValue_deleteMembers(&value);
  781. if(retval != UA_STATUSCODE_GOOD) {
  782. UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SERVER,
  783. "Array dimensions in the current value do not match");
  784. return retval;
  785. }
  786. }
  787. /* Ok, apply */
  788. UA_UInt32 *oldArrayDimensions = node->arrayDimensions;
  789. size_t oldArrayDimensionsSize = node->arrayDimensionsSize;
  790. retval = UA_Array_copy(arrayDimensions, arrayDimensionsSize,
  791. (void**)&node->arrayDimensions,
  792. &UA_TYPES[UA_TYPES_UINT32]);
  793. if(retval != UA_STATUSCODE_GOOD)
  794. return retval;
  795. UA_Array_delete(oldArrayDimensions, oldArrayDimensionsSize, &UA_TYPES[UA_TYPES_UINT32]);
  796. node->arrayDimensionsSize = arrayDimensionsSize;
  797. return UA_STATUSCODE_GOOD;
  798. }
  799. /* Stack layout: ... | node | type */
  800. static UA_StatusCode
  801. writeValueRankAttribute(UA_Server *server, UA_Session *session,
  802. UA_VariableNode *node, const UA_VariableTypeNode *type,
  803. UA_Int32 valueRank) {
  804. UA_assert(node != NULL);
  805. UA_assert(type != NULL);
  806. UA_Int32 constraintValueRank = type->valueRank;
  807. /* If this is a variabletype, there must be no instances or subtypes of it
  808. * when we do the change */
  809. if(node->nodeClass == UA_NODECLASS_VARIABLETYPE &&
  810. UA_Node_hasSubTypeOrInstances((const UA_Node*)node))
  811. return UA_STATUSCODE_BADINTERNALERROR;
  812. /* Check if the valuerank of the variabletype allows the change. */
  813. if(!compatibleValueRanks(valueRank, constraintValueRank))
  814. return UA_STATUSCODE_BADTYPEMISMATCH;
  815. /* Check if the new valuerank is compatible with the array dimensions. Use
  816. * the read service to handle data sources. */
  817. size_t arrayDims = node->arrayDimensionsSize;
  818. if(arrayDims == 0) {
  819. /* the value could be an array with no arrayDimensions defined.
  820. dimensions zero indicate a scalar for compatibleValueRankArrayDimensions. */
  821. UA_DataValue value;
  822. UA_DataValue_init(&value);
  823. UA_StatusCode retval = readValueAttribute(server, session, node, &value);
  824. if(retval != UA_STATUSCODE_GOOD)
  825. return retval;
  826. if(!value.hasValue || !value.value.type) {
  827. /* no value -> apply */
  828. node->valueRank = valueRank;
  829. return UA_STATUSCODE_GOOD;
  830. }
  831. if(!UA_Variant_isScalar(&value.value))
  832. arrayDims = 1;
  833. UA_DataValue_deleteMembers(&value);
  834. }
  835. if(!compatibleValueRankArrayDimensions(server, session, valueRank, arrayDims))
  836. return UA_STATUSCODE_BADTYPEMISMATCH;
  837. /* All good, apply the change */
  838. node->valueRank = valueRank;
  839. return UA_STATUSCODE_GOOD;
  840. }
  841. static UA_StatusCode
  842. writeDataTypeAttribute(UA_Server *server, UA_Session *session,
  843. UA_VariableNode *node, const UA_VariableTypeNode *type,
  844. const UA_NodeId *dataType) {
  845. UA_assert(node != NULL);
  846. UA_assert(type != NULL);
  847. /* If this is a variabletype, there must be no instances or subtypes of it
  848. when we do the change */
  849. if(node->nodeClass == UA_NODECLASS_VARIABLETYPE &&
  850. UA_Node_hasSubTypeOrInstances((const UA_Node*)node))
  851. return UA_STATUSCODE_BADINTERNALERROR;
  852. /* Does the new type match the constraints of the variabletype? */
  853. if(!compatibleDataType(server, dataType, &type->dataType, false))
  854. return UA_STATUSCODE_BADTYPEMISMATCH;
  855. /* Check if the current value would match the new type */
  856. UA_DataValue value;
  857. UA_DataValue_init(&value);
  858. UA_StatusCode retval = readValueAttribute(server, session, node, &value);
  859. if(retval != UA_STATUSCODE_GOOD)
  860. return retval;
  861. if(value.hasValue) {
  862. if(!compatibleValue(server, session, dataType, node->valueRank,
  863. node->arrayDimensionsSize, node->arrayDimensions,
  864. &value.value, NULL))
  865. retval = UA_STATUSCODE_BADTYPEMISMATCH;
  866. UA_DataValue_deleteMembers(&value);
  867. if(retval != UA_STATUSCODE_GOOD) {
  868. UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SERVER,
  869. "The current value does not match the new data type");
  870. return retval;
  871. }
  872. }
  873. /* Replace the datatype nodeid */
  874. UA_NodeId dtCopy = node->dataType;
  875. retval = UA_NodeId_copy(dataType, &node->dataType);
  876. if(retval != UA_STATUSCODE_GOOD) {
  877. node->dataType = dtCopy;
  878. return retval;
  879. }
  880. UA_NodeId_deleteMembers(&dtCopy);
  881. return UA_STATUSCODE_GOOD;
  882. }
  883. static UA_StatusCode
  884. writeValueAttributeWithoutRange(UA_VariableNode *node, const UA_DataValue *value) {
  885. UA_DataValue new_value;
  886. UA_StatusCode retval = UA_DataValue_copy(value, &new_value);
  887. if(retval != UA_STATUSCODE_GOOD)
  888. return retval;
  889. UA_DataValue_deleteMembers(&node->value.data.value);
  890. node->value.data.value = new_value;
  891. return UA_STATUSCODE_GOOD;
  892. }
  893. static UA_StatusCode
  894. writeValueAttributeWithRange(UA_VariableNode *node, const UA_DataValue *value,
  895. const UA_NumericRange *rangeptr) {
  896. /* Value on both sides? */
  897. if(value->status != node->value.data.value.status ||
  898. !value->hasValue || !node->value.data.value.hasValue)
  899. return UA_STATUSCODE_BADINDEXRANGEINVALID;
  900. /* Make scalar a one-entry array for range matching */
  901. UA_Variant editableValue;
  902. const UA_Variant *v = &value->value;
  903. if(UA_Variant_isScalar(&value->value)) {
  904. editableValue = value->value;
  905. editableValue.arrayLength = 1;
  906. v = &editableValue;
  907. }
  908. /* Check that the type is an exact match and not only "compatible" */
  909. if(!node->value.data.value.value.type || !v->type ||
  910. !UA_NodeId_equal(&node->value.data.value.value.type->typeId,
  911. &v->type->typeId))
  912. return UA_STATUSCODE_BADTYPEMISMATCH;
  913. /* Write the value */
  914. UA_StatusCode retval = UA_Variant_setRangeCopy(&node->value.data.value.value,
  915. v->data, v->arrayLength, *rangeptr);
  916. if(retval != UA_STATUSCODE_GOOD)
  917. return retval;
  918. /* Write the status and timestamps */
  919. node->value.data.value.hasStatus = value->hasStatus;
  920. node->value.data.value.status = value->status;
  921. node->value.data.value.hasSourceTimestamp = value->hasSourceTimestamp;
  922. node->value.data.value.sourceTimestamp = value->sourceTimestamp;
  923. node->value.data.value.hasSourcePicoseconds = value->hasSourcePicoseconds;
  924. node->value.data.value.sourcePicoseconds = value->sourcePicoseconds;
  925. return UA_STATUSCODE_GOOD;
  926. }
  927. /* Stack layout: ... | node */
  928. static UA_StatusCode
  929. writeValueAttribute(UA_Server *server, UA_Session *session,
  930. UA_VariableNode *node, const UA_DataValue *value,
  931. const UA_String *indexRange) {
  932. UA_assert(node != NULL);
  933. /* Parse the range */
  934. UA_NumericRange range;
  935. UA_NumericRange *rangeptr = NULL;
  936. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  937. if(indexRange && indexRange->length > 0) {
  938. retval = UA_NumericRange_parseFromString(&range, indexRange);
  939. if(retval != UA_STATUSCODE_GOOD)
  940. return retval;
  941. rangeptr = &range;
  942. }
  943. /* Created an editable version. The data is not touched. Only the variant
  944. * "container". */
  945. UA_DataValue adjustedValue = *value;
  946. /* Type checking. May change the type of editableValue */
  947. if(value->hasValue && value->value.type) {
  948. adjustValue(server, &adjustedValue.value, &node->dataType);
  949. /* The value may be an extension object, especially the nodeset compiler
  950. * uses extension objects to write variable values. If value is an
  951. * extension object we check if the current node value is also an
  952. * extension object. */
  953. const UA_NodeId nodeDataType = UA_NODEID_NUMERIC(0, UA_NS0ID_STRUCTURE);
  954. const UA_NodeId *nodeDataTypePtr = &node->dataType;
  955. if(value->value.type->typeId.identifierType == UA_NODEIDTYPE_NUMERIC &&
  956. value->value.type->typeId.identifier.numeric == UA_NS0ID_STRUCTURE)
  957. nodeDataTypePtr = &nodeDataType;
  958. if(!compatibleValue(server, session, nodeDataTypePtr, node->valueRank,
  959. node->arrayDimensionsSize, node->arrayDimensions,
  960. &adjustedValue.value, rangeptr)) {
  961. if(rangeptr)
  962. UA_free(range.dimensions);
  963. return UA_STATUSCODE_BADTYPEMISMATCH;
  964. }
  965. }
  966. /* Set the source timestamp if there is none */
  967. if(!adjustedValue.hasSourceTimestamp) {
  968. adjustedValue.sourceTimestamp = UA_DateTime_now();
  969. adjustedValue.hasSourceTimestamp = true;
  970. }
  971. /* Ok, do it */
  972. if(node->valueSource == UA_VALUESOURCE_DATA) {
  973. if(!rangeptr)
  974. retval = writeValueAttributeWithoutRange(node, &adjustedValue);
  975. else
  976. retval = writeValueAttributeWithRange(node, &adjustedValue, rangeptr);
  977. /* Callback after writing */
  978. if(retval == UA_STATUSCODE_GOOD && node->value.data.callback.onWrite)
  979. node->value.data.callback.onWrite(server, &session->sessionId,
  980. session->sessionHandle, &node->nodeId,
  981. node->context, rangeptr,
  982. &adjustedValue);
  983. } else {
  984. if(node->value.dataSource.write) {
  985. retval = node->value.dataSource.write(server, &session->sessionId,
  986. session->sessionHandle, &node->nodeId,
  987. node->context, rangeptr, &adjustedValue);
  988. } else {
  989. retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
  990. }
  991. }
  992. /* Clean up */
  993. if(rangeptr)
  994. UA_free(range.dimensions);
  995. return retval;
  996. }
  997. static UA_StatusCode
  998. writeIsAbstractAttribute(UA_Node *node, UA_Boolean value) {
  999. switch(node->nodeClass) {
  1000. case UA_NODECLASS_OBJECTTYPE:
  1001. ((UA_ObjectTypeNode*)node)->isAbstract = value;
  1002. break;
  1003. case UA_NODECLASS_REFERENCETYPE:
  1004. ((UA_ReferenceTypeNode*)node)->isAbstract = value;
  1005. break;
  1006. case UA_NODECLASS_VARIABLETYPE:
  1007. ((UA_VariableTypeNode*)node)->isAbstract = value;
  1008. break;
  1009. case UA_NODECLASS_DATATYPE:
  1010. ((UA_DataTypeNode*)node)->isAbstract = value;
  1011. break;
  1012. default:
  1013. return UA_STATUSCODE_BADNODECLASSINVALID;
  1014. }
  1015. return UA_STATUSCODE_GOOD;
  1016. }
  1017. /*****************/
  1018. /* Write Service */
  1019. /*****************/
  1020. #define CHECK_DATATYPE_SCALAR(EXP_DT) \
  1021. if(!wvalue->value.hasValue || \
  1022. &UA_TYPES[UA_TYPES_##EXP_DT] != wvalue->value.value.type || \
  1023. !UA_Variant_isScalar(&wvalue->value.value)) { \
  1024. retval = UA_STATUSCODE_BADTYPEMISMATCH; \
  1025. break; \
  1026. }
  1027. #define CHECK_DATATYPE_ARRAY(EXP_DT) \
  1028. if(!wvalue->value.hasValue || \
  1029. &UA_TYPES[UA_TYPES_##EXP_DT] != wvalue->value.value.type || \
  1030. UA_Variant_isScalar(&wvalue->value.value)) { \
  1031. retval = UA_STATUSCODE_BADTYPEMISMATCH; \
  1032. break; \
  1033. }
  1034. #define CHECK_NODECLASS_WRITE(CLASS) \
  1035. if((node->nodeClass & (CLASS)) == 0) { \
  1036. retval = UA_STATUSCODE_BADNODECLASSINVALID; \
  1037. break; \
  1038. }
  1039. #define CHECK_USERWRITEMASK(mask) \
  1040. if(!(userWriteMask & (mask))) { \
  1041. retval = UA_STATUSCODE_BADUSERACCESSDENIED; \
  1042. break; \
  1043. }
  1044. #define GET_NODETYPE \
  1045. type = (const UA_VariableTypeNode*) \
  1046. getNodeType(server, node); \
  1047. if(!type) { \
  1048. retval = UA_STATUSCODE_BADTYPEMISMATCH; \
  1049. break; \
  1050. }
  1051. /* This function implements the main part of the write service and operates on a
  1052. copy of the node (not in single-threaded mode). */
  1053. static UA_StatusCode
  1054. copyAttributeIntoNode(UA_Server *server, UA_Session *session,
  1055. UA_Node *node, const UA_WriteValue *wvalue) {
  1056. const void *value = wvalue->value.value.data;
  1057. UA_UInt32 userWriteMask = getUserWriteMask(server, session, node);
  1058. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  1059. const UA_VariableTypeNode *type;
  1060. switch(wvalue->attributeId) {
  1061. case UA_ATTRIBUTEID_NODEID:
  1062. case UA_ATTRIBUTEID_NODECLASS:
  1063. case UA_ATTRIBUTEID_USERWRITEMASK:
  1064. case UA_ATTRIBUTEID_USERACCESSLEVEL:
  1065. case UA_ATTRIBUTEID_USEREXECUTABLE:
  1066. retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
  1067. break;
  1068. case UA_ATTRIBUTEID_BROWSENAME:
  1069. CHECK_USERWRITEMASK(UA_WRITEMASK_BROWSENAME);
  1070. CHECK_DATATYPE_SCALAR(QUALIFIEDNAME);
  1071. UA_QualifiedName_deleteMembers(&node->browseName);
  1072. UA_QualifiedName_copy((const UA_QualifiedName *)value, &node->browseName);
  1073. break;
  1074. case UA_ATTRIBUTEID_DISPLAYNAME:
  1075. CHECK_USERWRITEMASK(UA_WRITEMASK_DISPLAYNAME);
  1076. CHECK_DATATYPE_SCALAR(LOCALIZEDTEXT);
  1077. UA_LocalizedText_deleteMembers(&node->displayName);
  1078. UA_LocalizedText_copy((const UA_LocalizedText *)value, &node->displayName);
  1079. break;
  1080. case UA_ATTRIBUTEID_DESCRIPTION:
  1081. CHECK_USERWRITEMASK(UA_WRITEMASK_DESCRIPTION);
  1082. CHECK_DATATYPE_SCALAR(LOCALIZEDTEXT);
  1083. UA_LocalizedText_deleteMembers(&node->description);
  1084. UA_LocalizedText_copy((const UA_LocalizedText *)value, &node->description);
  1085. break;
  1086. case UA_ATTRIBUTEID_WRITEMASK:
  1087. CHECK_USERWRITEMASK(UA_WRITEMASK_WRITEMASK);
  1088. CHECK_DATATYPE_SCALAR(UINT32);
  1089. node->writeMask = *(const UA_UInt32*)value;
  1090. break;
  1091. case UA_ATTRIBUTEID_ISABSTRACT:
  1092. CHECK_USERWRITEMASK(UA_WRITEMASK_ISABSTRACT);
  1093. CHECK_DATATYPE_SCALAR(BOOLEAN);
  1094. retval = writeIsAbstractAttribute(node, *(const UA_Boolean*)value);
  1095. break;
  1096. case UA_ATTRIBUTEID_SYMMETRIC:
  1097. CHECK_NODECLASS_WRITE(UA_NODECLASS_REFERENCETYPE);
  1098. CHECK_USERWRITEMASK(UA_WRITEMASK_SYMMETRIC);
  1099. CHECK_DATATYPE_SCALAR(BOOLEAN);
  1100. ((UA_ReferenceTypeNode*)node)->symmetric = *(const UA_Boolean*)value;
  1101. break;
  1102. case UA_ATTRIBUTEID_INVERSENAME:
  1103. CHECK_NODECLASS_WRITE(UA_NODECLASS_REFERENCETYPE);
  1104. CHECK_USERWRITEMASK(UA_WRITEMASK_INVERSENAME);
  1105. CHECK_DATATYPE_SCALAR(LOCALIZEDTEXT);
  1106. UA_LocalizedText_deleteMembers(&((UA_ReferenceTypeNode*)node)->inverseName);
  1107. UA_LocalizedText_copy((const UA_LocalizedText *)value,
  1108. &((UA_ReferenceTypeNode*)node)->inverseName);
  1109. break;
  1110. case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
  1111. CHECK_NODECLASS_WRITE(UA_NODECLASS_VIEW);
  1112. CHECK_USERWRITEMASK(UA_WRITEMASK_CONTAINSNOLOOPS);
  1113. CHECK_DATATYPE_SCALAR(BOOLEAN);
  1114. ((UA_ViewNode*)node)->containsNoLoops = *(const UA_Boolean*)value;
  1115. break;
  1116. case UA_ATTRIBUTEID_EVENTNOTIFIER:
  1117. CHECK_NODECLASS_WRITE(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
  1118. CHECK_USERWRITEMASK(UA_WRITEMASK_EVENTNOTIFIER);
  1119. CHECK_DATATYPE_SCALAR(BYTE);
  1120. ((UA_ViewNode*)node)->eventNotifier = *(const UA_Byte*)value;
  1121. break;
  1122. case UA_ATTRIBUTEID_VALUE:
  1123. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  1124. if(node->nodeClass == UA_NODECLASS_VARIABLE) {
  1125. /* The access to a value variable is granted via the AccessLevel
  1126. * and UserAccessLevel attributes */
  1127. UA_Byte accessLevel = getAccessLevel(server, session, (const UA_VariableNode*)node);
  1128. if(!(accessLevel & (UA_ACCESSLEVELMASK_WRITE))) {
  1129. retval = UA_STATUSCODE_BADNOTWRITABLE;
  1130. break;
  1131. }
  1132. accessLevel = getUserAccessLevel(server, session,
  1133. (const UA_VariableNode*)node);
  1134. if(!(accessLevel & (UA_ACCESSLEVELMASK_WRITE))) {
  1135. retval = UA_STATUSCODE_BADUSERACCESSDENIED;
  1136. break;
  1137. }
  1138. } else { /* UA_NODECLASS_VARIABLETYPE */
  1139. CHECK_USERWRITEMASK(UA_WRITEMASK_VALUEFORVARIABLETYPE);
  1140. }
  1141. retval = writeValueAttribute(server, session, (UA_VariableNode*)node,
  1142. &wvalue->value, &wvalue->indexRange);
  1143. break;
  1144. case UA_ATTRIBUTEID_DATATYPE:
  1145. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  1146. CHECK_USERWRITEMASK(UA_WRITEMASK_DATATYPE);
  1147. CHECK_DATATYPE_SCALAR(NODEID);
  1148. GET_NODETYPE
  1149. retval = writeDataTypeAttribute(server, session, (UA_VariableNode*)node,
  1150. type, (const UA_NodeId*)value);
  1151. UA_Nodestore_release(server, (const UA_Node*)type);
  1152. break;
  1153. case UA_ATTRIBUTEID_VALUERANK:
  1154. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  1155. CHECK_USERWRITEMASK(UA_WRITEMASK_VALUERANK);
  1156. CHECK_DATATYPE_SCALAR(INT32);
  1157. GET_NODETYPE
  1158. retval = writeValueRankAttribute(server, session, (UA_VariableNode*)node,
  1159. type, *(const UA_Int32*)value);
  1160. UA_Nodestore_release(server, (const UA_Node*)type);
  1161. break;
  1162. case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
  1163. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  1164. CHECK_USERWRITEMASK(UA_WRITEMASK_ARRRAYDIMENSIONS);
  1165. CHECK_DATATYPE_ARRAY(UINT32);
  1166. GET_NODETYPE
  1167. retval = writeArrayDimensionsAttribute(server, session, (UA_VariableNode*)node,
  1168. type, wvalue->value.value.arrayLength,
  1169. (UA_UInt32 *)wvalue->value.value.data);
  1170. UA_Nodestore_release(server, (const UA_Node*)type);
  1171. break;
  1172. case UA_ATTRIBUTEID_ACCESSLEVEL:
  1173. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
  1174. CHECK_USERWRITEMASK(UA_WRITEMASK_ACCESSLEVEL);
  1175. CHECK_DATATYPE_SCALAR(BYTE);
  1176. ((UA_VariableNode*)node)->accessLevel = *(const UA_Byte*)value;
  1177. break;
  1178. case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
  1179. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
  1180. CHECK_USERWRITEMASK(UA_WRITEMASK_MINIMUMSAMPLINGINTERVAL);
  1181. CHECK_DATATYPE_SCALAR(DOUBLE);
  1182. ((UA_VariableNode*)node)->minimumSamplingInterval = *(const UA_Double*)value;
  1183. break;
  1184. case UA_ATTRIBUTEID_HISTORIZING:
  1185. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
  1186. CHECK_USERWRITEMASK(UA_WRITEMASK_HISTORIZING);
  1187. CHECK_DATATYPE_SCALAR(BOOLEAN);
  1188. ((UA_VariableNode*)node)->historizing = *(const UA_Boolean*)value;
  1189. break;
  1190. case UA_ATTRIBUTEID_EXECUTABLE:
  1191. CHECK_NODECLASS_WRITE(UA_NODECLASS_METHOD);
  1192. CHECK_USERWRITEMASK(UA_WRITEMASK_EXECUTABLE);
  1193. CHECK_DATATYPE_SCALAR(BOOLEAN);
  1194. ((UA_MethodNode*)node)->executable = *(const UA_Boolean*)value;
  1195. break;
  1196. default:
  1197. retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
  1198. break;
  1199. }
  1200. if(retval != UA_STATUSCODE_GOOD)
  1201. UA_LOG_INFO_SESSION(server->config.logger, session,
  1202. "WriteRequest returned status code %s",
  1203. UA_StatusCode_name(retval));
  1204. return retval;
  1205. }
  1206. static void
  1207. Operation_Write(UA_Server *server, UA_Session *session, void *context,
  1208. UA_WriteValue *wv, UA_StatusCode *result) {
  1209. *result = UA_Server_editNode(server, session, &wv->nodeId,
  1210. (UA_EditNodeCallback)copyAttributeIntoNode, wv);
  1211. }
  1212. void
  1213. Service_Write(UA_Server *server, UA_Session *session,
  1214. const UA_WriteRequest *request,
  1215. UA_WriteResponse *response) {
  1216. UA_LOG_DEBUG_SESSION(server->config.logger, session,
  1217. "Processing WriteRequest");
  1218. if(server->config.maxNodesPerWrite != 0 &&
  1219. request->nodesToWriteSize > server->config.maxNodesPerWrite) {
  1220. response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS;
  1221. return;
  1222. }
  1223. response->responseHeader.serviceResult =
  1224. UA_Server_processServiceOperations(server, session, (UA_ServiceOperation)Operation_Write, NULL,
  1225. &request->nodesToWriteSize, &UA_TYPES[UA_TYPES_WRITEVALUE],
  1226. &response->resultsSize, &UA_TYPES[UA_TYPES_STATUSCODE]);
  1227. }
  1228. UA_StatusCode
  1229. UA_Server_writeWithSession(UA_Server *server, UA_Session *session,
  1230. const UA_WriteValue *value) {
  1231. return UA_Server_editNode(server, session, &value->nodeId,
  1232. (UA_EditNodeCallback)copyAttributeIntoNode,
  1233. /* casting away const qualifier because callback uses const anyway */
  1234. (UA_WriteValue *)(uintptr_t)value);
  1235. }
  1236. UA_StatusCode
  1237. UA_Server_write(UA_Server *server, const UA_WriteValue *value) {
  1238. return UA_Server_editNode(server, &adminSession, &value->nodeId,
  1239. (UA_EditNodeCallback)copyAttributeIntoNode,
  1240. /* casting away const qualifier because callback uses const anyway */
  1241. (UA_WriteValue *)(uintptr_t)value);
  1242. }
  1243. /* Convenience function to be wrapped into inline functions */
  1244. UA_StatusCode
  1245. __UA_Server_write(UA_Server *server, const UA_NodeId *nodeId,
  1246. const UA_AttributeId attributeId,
  1247. const UA_DataType *attr_type,
  1248. const void *attr) {
  1249. UA_WriteValue wvalue;
  1250. UA_WriteValue_init(&wvalue);
  1251. wvalue.nodeId = *nodeId;
  1252. wvalue.attributeId = attributeId;
  1253. wvalue.value.hasValue = true;
  1254. if(attr_type != &UA_TYPES[UA_TYPES_VARIANT]) {
  1255. /* hacked cast. the target WriteValue is used as const anyway */
  1256. UA_Variant_setScalar(&wvalue.value.value,
  1257. (void*)(uintptr_t)attr, attr_type);
  1258. } else {
  1259. wvalue.value.value = *(const UA_Variant*)attr;
  1260. }
  1261. return UA_Server_write(server, &wvalue);
  1262. }
  1263. UA_StatusCode UA_EXPORT
  1264. UA_Server_writeObjectProperty(UA_Server *server, const UA_NodeId objectId,
  1265. const UA_QualifiedName propertyName,
  1266. const UA_Variant value) {
  1267. UA_RelativePathElement rpe;
  1268. UA_RelativePathElement_init(&rpe);
  1269. rpe.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY);
  1270. rpe.isInverse = false;
  1271. rpe.includeSubtypes = false;
  1272. rpe.targetName = propertyName;
  1273. UA_BrowsePath bp;
  1274. UA_BrowsePath_init(&bp);
  1275. bp.startingNode = objectId;
  1276. bp.relativePath.elementsSize = 1;
  1277. bp.relativePath.elements = &rpe;
  1278. UA_StatusCode retval;
  1279. UA_BrowsePathResult bpr = UA_Server_translateBrowsePathToNodeIds(server, &bp);
  1280. if(bpr.statusCode != UA_STATUSCODE_GOOD || bpr.targetsSize < 1) {
  1281. retval = bpr.statusCode;
  1282. UA_BrowsePathResult_deleteMembers(&bpr);
  1283. return retval;
  1284. }
  1285. retval = UA_Server_writeValue(server, bpr.targets[0].targetId.nodeId, value);
  1286. UA_BrowsePathResult_deleteMembers(&bpr);
  1287. return retval;
  1288. }
  1289. UA_StatusCode UA_EXPORT
  1290. UA_Server_writeObjectProperty_scalar(UA_Server *server, const UA_NodeId objectId,
  1291. const UA_QualifiedName propertyName,
  1292. const void *value, const UA_DataType *type) {
  1293. UA_Variant var;
  1294. UA_Variant_init(&var);
  1295. UA_Variant_setScalar(&var, (void*)(uintptr_t)value, type);
  1296. return UA_Server_writeObjectProperty(server, objectId, propertyName, var);
  1297. }