ua_services_attribute.c 65 KB

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