ua_services_attribute.c 50 KB

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