ua_services_attribute.c 52 KB

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