ua_services_attribute.c 29 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742
  1. #include "ua_server_internal.h"
  2. #include "ua_services.h"
  3. /******************/
  4. /* Read Attribute */
  5. /******************/
  6. static size_t
  7. readNumber(UA_Byte *buf, size_t buflen, UA_UInt32 *number) {
  8. UA_UInt32 n = 0;
  9. size_t progress = 0;
  10. /* read numbers until the end or a non-number character appears */
  11. UA_Byte c;
  12. while(progress < buflen) {
  13. c = buf[progress];
  14. if('0' > c || '9' < c)
  15. break;
  16. n = (n*10) + (UA_UInt32)(c-'0');
  17. progress++;
  18. }
  19. *number = n;
  20. return progress;
  21. }
  22. static size_t
  23. readDimension(UA_Byte *buf, size_t buflen, struct UA_NumericRangeDimension *dim) {
  24. size_t progress = readNumber(buf, buflen, &dim->min);
  25. if(progress == 0)
  26. return 0;
  27. if(buflen <= progress || buf[progress] != ':') {
  28. dim->max = dim->min;
  29. return progress;
  30. }
  31. progress++;
  32. size_t progress2 = readNumber(&buf[progress], buflen - progress, &dim->max);
  33. if(progress2 == 0)
  34. return 0;
  35. return progress + progress2;
  36. }
  37. #ifndef UA_BUILD_UNIT_TESTS
  38. static
  39. #endif
  40. UA_StatusCode parse_numericrange(const UA_String *str, UA_NumericRange *range) {
  41. size_t idx = 0;
  42. size_t dimensionsMax = 0;
  43. struct UA_NumericRangeDimension *dimensions = NULL;
  44. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  45. size_t pos = 0;
  46. do {
  47. /* alloc dimensions */
  48. if(idx >= dimensionsMax) {
  49. struct UA_NumericRangeDimension *newds;
  50. newds = UA_realloc(dimensions, sizeof(struct UA_NumericRangeDimension) * (dimensionsMax + 2));
  51. if(!newds) {
  52. retval = UA_STATUSCODE_BADOUTOFMEMORY;
  53. break;
  54. }
  55. dimensions = newds;
  56. dimensionsMax = dimensionsMax + 2;
  57. }
  58. /* read the dimension */
  59. size_t progress = readDimension(&str->data[pos], str->length - pos, &dimensions[idx]);
  60. if(progress == 0) {
  61. retval = UA_STATUSCODE_BADINDEXRANGEINVALID;
  62. break;
  63. }
  64. pos += progress;
  65. idx++;
  66. /* loop into the next dimension */
  67. if(pos >= str->length)
  68. break;
  69. } while(str->data[pos] == ',' && pos++);
  70. if(retval == UA_STATUSCODE_GOOD && idx > 0) {
  71. range->dimensions = dimensions;
  72. range->dimensionsSize = idx;
  73. } else
  74. UA_free(dimensions);
  75. return retval;
  76. }
  77. #define CHECK_NODECLASS(CLASS) \
  78. if(!(node->nodeClass & (CLASS))) { \
  79. retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID; \
  80. break; \
  81. }
  82. static void handleServerTimestamps(UA_TimestampsToReturn timestamps, UA_DataValue* v) {
  83. if(v && (timestamps == UA_TIMESTAMPSTORETURN_SERVER || timestamps == UA_TIMESTAMPSTORETURN_BOTH)) {
  84. v->hasServerTimestamp = true;
  85. v->serverTimestamp = UA_DateTime_now();
  86. }
  87. }
  88. static void handleSourceTimestamps(UA_TimestampsToReturn timestamps, UA_DataValue* v) {
  89. if(timestamps == UA_TIMESTAMPSTORETURN_SOURCE || timestamps == UA_TIMESTAMPSTORETURN_BOTH) {
  90. v->hasSourceTimestamp = true;
  91. v->sourceTimestamp = UA_DateTime_now();
  92. }
  93. }
  94. /* force cast for zero-copy reading. ensure that the variant is never written into. */
  95. static void forceVariantSetScalar(UA_Variant *v, const void *p, const UA_DataType *t) {
  96. UA_Variant_init(v);
  97. v->type = t;
  98. v->data = (void*)(uintptr_t)p;
  99. v->storageType = UA_VARIANT_DATA_NODELETE;
  100. }
  101. static UA_StatusCode getVariableNodeValue(const UA_VariableNode *vn, const UA_TimestampsToReturn timestamps,
  102. const UA_ReadValueId *id, UA_DataValue *v) {
  103. UA_NumericRange range;
  104. UA_NumericRange *rangeptr = NULL;
  105. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  106. if(id->indexRange.length > 0) {
  107. retval = parse_numericrange(&id->indexRange, &range);
  108. if(retval != UA_STATUSCODE_GOOD)
  109. return retval;
  110. rangeptr = &range;
  111. }
  112. if(vn->valueSource == UA_VALUESOURCE_VARIANT) {
  113. if(vn->value.variant.callback.onRead)
  114. vn->value.variant.callback.onRead(vn->value.variant.callback.handle, vn->nodeId,
  115. &v->value, rangeptr);
  116. if(!rangeptr) {
  117. v->value = vn->value.variant.value;
  118. v->value.storageType = UA_VARIANT_DATA_NODELETE;
  119. } else
  120. retval = UA_Variant_copyRange(&vn->value.variant.value, &v->value, range);
  121. if(retval == UA_STATUSCODE_GOOD)
  122. handleSourceTimestamps(timestamps, v);
  123. } else {
  124. if(vn->value.dataSource.read == NULL) {
  125. retval = UA_STATUSCODE_BADINTERNALERROR;
  126. } else {
  127. UA_Boolean sourceTimeStamp = (timestamps == UA_TIMESTAMPSTORETURN_SOURCE ||
  128. timestamps == UA_TIMESTAMPSTORETURN_BOTH);
  129. retval = vn->value.dataSource.read(vn->value.dataSource.handle, vn->nodeId,
  130. sourceTimeStamp, rangeptr, v);
  131. }
  132. }
  133. if(rangeptr)
  134. UA_free(range.dimensions);
  135. return retval;
  136. }
  137. static UA_StatusCode getVariableNodeDataType(const UA_VariableNode *vn, UA_DataValue *v) {
  138. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  139. if(vn->valueSource == UA_VALUESOURCE_VARIANT) {
  140. forceVariantSetScalar(&v->value, &vn->value.variant.value.type->typeId,
  141. &UA_TYPES[UA_TYPES_NODEID]);
  142. } else {
  143. if(vn->value.dataSource.read == NULL)
  144. return UA_STATUSCODE_BADINTERNALERROR;
  145. /* Read from the datasource to see the data type */
  146. UA_DataValue val;
  147. UA_DataValue_init(&val);
  148. val.hasValue = false; // always assume we are not given a value by userspace
  149. retval = vn->value.dataSource.read(vn->value.dataSource.handle, vn->nodeId, false, NULL, &val);
  150. if(retval != UA_STATUSCODE_GOOD)
  151. return retval;
  152. if (val.hasValue && val.value.type != NULL)
  153. retval = UA_Variant_setScalarCopy(&v->value, &val.value.type->typeId, &UA_TYPES[UA_TYPES_NODEID]);
  154. UA_DataValue_deleteMembers(&val);
  155. }
  156. return retval;
  157. }
  158. static UA_StatusCode getVariableNodeArrayDimensions(const UA_VariableNode *vn, UA_DataValue *v) {
  159. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  160. if(vn->valueSource == UA_VALUESOURCE_VARIANT) {
  161. UA_Variant_setArray(&v->value, vn->value.variant.value.arrayDimensions,
  162. vn->value.variant.value.arrayDimensionsSize, &UA_TYPES[UA_TYPES_INT32]);
  163. v->value.storageType = UA_VARIANT_DATA_NODELETE;
  164. } else {
  165. if(vn->value.dataSource.read == NULL)
  166. return UA_STATUSCODE_BADINTERNALERROR;
  167. /* Read the datasource to see the array dimensions */
  168. UA_DataValue val;
  169. UA_DataValue_init(&val);
  170. retval = vn->value.dataSource.read(vn->value.dataSource.handle, vn->nodeId, false, NULL, &val);
  171. if(retval != UA_STATUSCODE_GOOD)
  172. return retval;
  173. retval = UA_Variant_setArrayCopy(&v->value, val.value.arrayDimensions,
  174. val.value.arrayDimensionsSize, &UA_TYPES[UA_TYPES_INT32]);
  175. UA_DataValue_deleteMembers(&val);
  176. }
  177. return retval;
  178. }
  179. static const UA_String binEncoding = {sizeof("DefaultBinary")-1, (UA_Byte*)"DefaultBinary"};
  180. /* clang complains about unused variables */
  181. // static const UA_String xmlEncoding = {sizeof("DefaultXml")-1, (UA_Byte*)"DefaultXml"};
  182. /** Reads a single attribute from a node in the nodestore. */
  183. void Service_Read_single(UA_Server *server, UA_Session *session, const UA_TimestampsToReturn timestamps,
  184. const UA_ReadValueId *id, UA_DataValue *v) {
  185. if(id->dataEncoding.name.length > 0 && !UA_String_equal(&binEncoding, &id->dataEncoding.name)) {
  186. v->hasStatus = true;
  187. v->status = UA_STATUSCODE_BADDATAENCODINGUNSUPPORTED;
  188. return;
  189. }
  190. //index range for a non-value
  191. if(id->indexRange.length > 0 && id->attributeId != UA_ATTRIBUTEID_VALUE){
  192. v->hasStatus = true;
  193. v->status = UA_STATUSCODE_BADINDEXRANGENODATA;
  194. return;
  195. }
  196. UA_Node const *node = UA_NodeStore_get(server->nodestore, &id->nodeId);
  197. if(!node) {
  198. v->hasStatus = true;
  199. v->status = UA_STATUSCODE_BADNODEIDUNKNOWN;
  200. return;
  201. }
  202. /* When setting the value fails in the switch, we get an error code and set hasValue to false */
  203. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  204. v->hasValue = true;
  205. switch(id->attributeId) {
  206. case UA_ATTRIBUTEID_NODEID:
  207. forceVariantSetScalar(&v->value, &node->nodeId, &UA_TYPES[UA_TYPES_NODEID]);
  208. break;
  209. case UA_ATTRIBUTEID_NODECLASS:
  210. forceVariantSetScalar(&v->value, &node->nodeClass, &UA_TYPES[UA_TYPES_NODECLASS]);
  211. break;
  212. case UA_ATTRIBUTEID_BROWSENAME:
  213. forceVariantSetScalar(&v->value, &node->browseName, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
  214. break;
  215. case UA_ATTRIBUTEID_DISPLAYNAME:
  216. forceVariantSetScalar(&v->value, &node->displayName, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
  217. break;
  218. case UA_ATTRIBUTEID_DESCRIPTION:
  219. forceVariantSetScalar(&v->value, &node->description, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
  220. break;
  221. case UA_ATTRIBUTEID_WRITEMASK:
  222. forceVariantSetScalar(&v->value, &node->writeMask, &UA_TYPES[UA_TYPES_UINT32]);
  223. break;
  224. case UA_ATTRIBUTEID_USERWRITEMASK:
  225. forceVariantSetScalar(&v->value, &node->userWriteMask, &UA_TYPES[UA_TYPES_UINT32]);
  226. break;
  227. case UA_ATTRIBUTEID_ISABSTRACT:
  228. CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE | UA_NODECLASS_OBJECTTYPE |
  229. UA_NODECLASS_VARIABLETYPE | UA_NODECLASS_DATATYPE);
  230. forceVariantSetScalar(&v->value, &((const UA_ReferenceTypeNode*)node)->isAbstract,
  231. &UA_TYPES[UA_TYPES_BOOLEAN]);
  232. break;
  233. case UA_ATTRIBUTEID_SYMMETRIC:
  234. CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
  235. forceVariantSetScalar(&v->value, &((const UA_ReferenceTypeNode*)node)->symmetric,
  236. &UA_TYPES[UA_TYPES_BOOLEAN]);
  237. break;
  238. case UA_ATTRIBUTEID_INVERSENAME:
  239. CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
  240. forceVariantSetScalar(&v->value, &((const UA_ReferenceTypeNode*)node)->inverseName,
  241. &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
  242. break;
  243. case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
  244. CHECK_NODECLASS(UA_NODECLASS_VIEW);
  245. forceVariantSetScalar(&v->value, &((const UA_ViewNode*)node)->containsNoLoops,
  246. &UA_TYPES[UA_TYPES_BOOLEAN]);
  247. break;
  248. case UA_ATTRIBUTEID_EVENTNOTIFIER:
  249. CHECK_NODECLASS(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
  250. forceVariantSetScalar(&v->value, &((const UA_ViewNode*)node)->eventNotifier,
  251. &UA_TYPES[UA_TYPES_BYTE]);
  252. break;
  253. case UA_ATTRIBUTEID_VALUE:
  254. CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  255. retval = getVariableNodeValue((const UA_VariableNode*)node, timestamps, id, v);
  256. break;
  257. case UA_ATTRIBUTEID_DATATYPE:
  258. CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  259. retval = getVariableNodeDataType((const UA_VariableNode*)node, v);
  260. break;
  261. case UA_ATTRIBUTEID_VALUERANK:
  262. CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  263. forceVariantSetScalar(&v->value, &((const UA_VariableTypeNode*)node)->valueRank,
  264. &UA_TYPES[UA_TYPES_INT32]);
  265. break;
  266. case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
  267. CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  268. retval = getVariableNodeArrayDimensions((const UA_VariableNode*)node, v);
  269. break;
  270. case UA_ATTRIBUTEID_ACCESSLEVEL:
  271. CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
  272. forceVariantSetScalar(&v->value, &((const UA_VariableNode*)node)->accessLevel,
  273. &UA_TYPES[UA_TYPES_BYTE]);
  274. break;
  275. case UA_ATTRIBUTEID_USERACCESSLEVEL:
  276. CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
  277. forceVariantSetScalar(&v->value, &((const UA_VariableNode*)node)->userAccessLevel,
  278. &UA_TYPES[UA_TYPES_BYTE]);
  279. break;
  280. case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
  281. CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
  282. forceVariantSetScalar(&v->value, &((const UA_VariableNode*)node)->minimumSamplingInterval,
  283. &UA_TYPES[UA_TYPES_DOUBLE]);
  284. break;
  285. case UA_ATTRIBUTEID_HISTORIZING:
  286. CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
  287. forceVariantSetScalar(&v->value, &((const UA_VariableNode*)node)->historizing,
  288. &UA_TYPES[UA_TYPES_BOOLEAN]);
  289. break;
  290. case UA_ATTRIBUTEID_EXECUTABLE:
  291. CHECK_NODECLASS(UA_NODECLASS_METHOD);
  292. forceVariantSetScalar(&v->value, &((const UA_MethodNode*)node)->executable,
  293. &UA_TYPES[UA_TYPES_BOOLEAN]);
  294. break;
  295. case UA_ATTRIBUTEID_USEREXECUTABLE:
  296. CHECK_NODECLASS(UA_NODECLASS_METHOD);
  297. forceVariantSetScalar(&v->value, &((const UA_MethodNode*)node)->userExecutable,
  298. &UA_TYPES[UA_TYPES_BOOLEAN]);
  299. break;
  300. default:
  301. retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
  302. break;
  303. }
  304. if(retval != UA_STATUSCODE_GOOD) {
  305. v->hasValue = false;
  306. v->hasStatus = true;
  307. v->status = retval;
  308. }
  309. // Todo: what if the timestamp from the datasource are already present?
  310. handleServerTimestamps(timestamps, v);
  311. }
  312. void Service_Read(UA_Server *server, UA_Session *session, const UA_ReadRequest *request,
  313. UA_ReadResponse *response) {
  314. UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SESSION,
  315. "Processing ReadRequest for Session (ns=%i,i=%i)",
  316. session->sessionId.namespaceIndex, session->sessionId.identifier.numeric);
  317. if(request->nodesToReadSize <= 0) {
  318. response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
  319. return;
  320. }
  321. if(request->timestampsToReturn > 3){
  322. response->responseHeader.serviceResult = UA_STATUSCODE_BADTIMESTAMPSTORETURNINVALID;
  323. return;
  324. }
  325. size_t size = request->nodesToReadSize;
  326. response->results = UA_Array_new(size, &UA_TYPES[UA_TYPES_DATAVALUE]);
  327. if(!response->results) {
  328. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  329. return;
  330. }
  331. response->resultsSize = size;
  332. if(request->maxAge < 0) {
  333. response->responseHeader.serviceResult = UA_STATUSCODE_BADMAXAGEINVALID;
  334. return;
  335. }
  336. #ifdef UA_ENABLE_EXTERNAL_NAMESPACES
  337. UA_Boolean isExternal[size];
  338. UA_UInt32 indices[size];
  339. memset(isExternal, false, sizeof(UA_Boolean) * size);
  340. for(size_t j = 0;j<server->externalNamespacesSize;j++) {
  341. size_t indexSize = 0;
  342. for(size_t i = 0;i < size;i++) {
  343. if(request->nodesToRead[i].nodeId.namespaceIndex != server->externalNamespaces[j].index)
  344. continue;
  345. isExternal[i] = true;
  346. indices[indexSize] = i;
  347. indexSize++;
  348. }
  349. if(indexSize == 0)
  350. continue;
  351. UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
  352. ens->readNodes(ens->ensHandle, &request->requestHeader, request->nodesToRead,
  353. indices, indexSize, response->results, false, response->diagnosticInfos);
  354. }
  355. #endif
  356. for(size_t i = 0;i < size;i++) {
  357. #ifdef UA_ENABLE_EXTERNAL_NAMESPACES
  358. if(!isExternal[i])
  359. #endif
  360. Service_Read_single(server, session, request->timestampsToReturn,
  361. &request->nodesToRead[i], &response->results[i]);
  362. }
  363. #ifdef UA_ENABLE_NONSTANDARD_STATELESS
  364. /* Add an expiry header for caching */
  365. if(session->sessionId.namespaceIndex == 0 && session->sessionId.identifierType == UA_NODEIDTYPE_NUMERIC && session->sessionId.identifier.numeric == 0){
  366. UA_ExtensionObject additionalHeader;
  367. UA_ExtensionObject_init(&additionalHeader);
  368. additionalHeader.encoding = UA_EXTENSIONOBJECT_ENCODED_BYTESTRING;
  369. additionalHeader.content.encoded.typeId =UA_TYPES[UA_TYPES_VARIANT].typeId;
  370. UA_Variant variant;
  371. UA_Variant_init(&variant);
  372. UA_DateTime* expireArray = NULL;
  373. expireArray = UA_Array_new(request->nodesToReadSize, &UA_TYPES[UA_TYPES_DATETIME]);
  374. variant.data = expireArray;
  375. /*expires in 20 seconds*/
  376. for(UA_UInt32 i = 0;i < response->resultsSize;i++) {
  377. expireArray[i] = UA_DateTime_now() + 20 * 100 * 1000 * 1000;
  378. }
  379. UA_Variant_setArray(&variant, expireArray, request->nodesToReadSize, &UA_TYPES[UA_TYPES_DATETIME]);
  380. size_t offset = 0;
  381. UA_ByteString str;
  382. UA_ByteString_allocBuffer(&str, 65536);
  383. UA_StatusCode retval = UA_encodeBinary(&variant, &UA_TYPES[UA_TYPES_VARIANT], &str, &offset);
  384. UA_Array_delete(expireArray, request->nodesToReadSize, &UA_TYPES[UA_TYPES_DATETIME]);
  385. if(retval == UA_STATUSCODE_GOOD){
  386. additionalHeader.content.encoded.body.data = str.data;
  387. additionalHeader.content.encoded.body.length = offset;
  388. response->responseHeader.additionalHeader = additionalHeader;
  389. }
  390. }
  391. #endif
  392. }
  393. /*******************/
  394. /* Write Attribute */
  395. /*******************/
  396. UA_StatusCode UA_Server_editNode(UA_Server *server, UA_Session *session, const UA_NodeId *nodeId,
  397. UA_EditNodeCallback callback, const void *data) {
  398. UA_StatusCode retval;
  399. do {
  400. #ifndef UA_ENABLE_MULTITHREADING
  401. const UA_Node *node = UA_NodeStore_get(server->nodestore, nodeId);
  402. if(!node)
  403. return UA_STATUSCODE_BADNODEIDUNKNOWN;
  404. UA_Node *editNode = (UA_Node*)(uintptr_t)node; // dirty cast. use only here.
  405. retval = callback(server, session, editNode, data);
  406. return retval;
  407. #else
  408. UA_Node *copy = UA_NodeStore_getCopy(server->nodestore, nodeId);
  409. if(!copy)
  410. return UA_STATUSCODE_BADOUTOFMEMORY;
  411. retval = callback(server, session, copy, data);
  412. if(retval != UA_STATUSCODE_GOOD) {
  413. UA_NodeStore_deleteNode(copy);
  414. return retval;
  415. }
  416. retval = UA_NodeStore_replace(server->nodestore, copy);
  417. #endif
  418. } while(retval != UA_STATUSCODE_GOOD);
  419. return UA_STATUSCODE_GOOD;
  420. }
  421. #define CHECK_DATATYPE(EXP_DT) \
  422. if(!wvalue->value.hasValue || \
  423. &UA_TYPES[UA_TYPES_##EXP_DT] != wvalue->value.value.type || \
  424. !UA_Variant_isScalar(&wvalue->value.value)) { \
  425. retval = UA_STATUSCODE_BADTYPEMISMATCH; \
  426. break; \
  427. }
  428. #define CHECK_NODECLASS_WRITE(CLASS) \
  429. if((node->nodeClass & (CLASS)) == 0) { \
  430. retval = UA_STATUSCODE_BADNODECLASSINVALID; \
  431. break; \
  432. }
  433. static UA_StatusCode
  434. Service_Write_single_ValueDataSource(UA_Server *server, UA_Session *session, const UA_VariableNode *node,
  435. const UA_WriteValue *wvalue) {
  436. UA_assert(wvalue->attributeId == UA_ATTRIBUTEID_VALUE);
  437. UA_assert(node->nodeClass == UA_NODECLASS_VARIABLE || node->nodeClass == UA_NODECLASS_VARIABLETYPE);
  438. UA_assert(node->valueSource == UA_VALUESOURCE_DATASOURCE);
  439. if(node->value.dataSource.write == NULL)
  440. return UA_STATUSCODE_BADWRITENOTSUPPORTED;
  441. UA_StatusCode retval;
  442. if(wvalue->indexRange.length <= 0) {
  443. retval = node->value.dataSource.write(node->value.dataSource.handle, node->nodeId,
  444. &wvalue->value.value, NULL);
  445. } else {
  446. UA_NumericRange range;
  447. retval = parse_numericrange(&wvalue->indexRange, &range);
  448. if(retval != UA_STATUSCODE_GOOD)
  449. return retval;
  450. retval = node->value.dataSource.write(node->value.dataSource.handle, node->nodeId,
  451. &wvalue->value.value, &range);
  452. UA_free(range.dimensions);
  453. }
  454. return retval;
  455. }
  456. enum type_equivalence {
  457. TYPE_EQUIVALENCE_NONE,
  458. TYPE_EQUIVALENCE_ENUM,
  459. TYPE_EQUIVALENCE_OPAQUE
  460. };
  461. static enum type_equivalence typeEquivalence(const UA_DataType *t) {
  462. if(t->membersSize != 1 || !t->members[0].namespaceZero)
  463. return TYPE_EQUIVALENCE_NONE;
  464. if(t->members[0].memberTypeIndex == UA_TYPES_INT32)
  465. return TYPE_EQUIVALENCE_ENUM;
  466. if(t->members[0].memberTypeIndex == UA_TYPES_BYTE && t->members[0].isArray)
  467. return TYPE_EQUIVALENCE_OPAQUE;
  468. return TYPE_EQUIVALENCE_NONE;
  469. }
  470. static UA_StatusCode
  471. CopyValueIntoNode(UA_VariableNode *node, const UA_WriteValue *wvalue) {
  472. UA_assert(wvalue->attributeId == UA_ATTRIBUTEID_VALUE);
  473. UA_assert(node->nodeClass == UA_NODECLASS_VARIABLE || node->nodeClass == UA_NODECLASS_VARIABLETYPE);
  474. UA_assert(node->valueSource == UA_VALUESOURCE_VARIANT);
  475. /* Parse the range */
  476. UA_NumericRange range;
  477. UA_NumericRange *rangeptr = NULL;
  478. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  479. if(wvalue->indexRange.length > 0) {
  480. retval = parse_numericrange(&wvalue->indexRange, &range);
  481. if(retval != UA_STATUSCODE_GOOD)
  482. return retval;
  483. rangeptr = &range;
  484. }
  485. /* The nodeid on the wire may be != the nodeid in the node: opaque types, enums and bytestrings.
  486. nodeV contains the correct type definition. */
  487. const UA_Variant *newV = &wvalue->value.value;
  488. UA_Variant *oldV = &node->value.variant.value;
  489. UA_Variant cast_v;
  490. if (oldV->type != NULL) { // Don't run NodeId_equal on a NULL pointer (happens if the variable never held a variant)
  491. if(!UA_NodeId_equal(&oldV->type->typeId, &newV->type->typeId)) {
  492. cast_v = wvalue->value.value;
  493. newV = &cast_v;
  494. enum type_equivalence te1 = typeEquivalence(oldV->type);
  495. enum type_equivalence te2 = typeEquivalence(newV->type);
  496. if(te1 != TYPE_EQUIVALENCE_NONE && te1 == te2) {
  497. /* An enum was sent as an int32, or an opaque type as a bytestring. This is
  498. detected with the typeIndex indicated the "true" datatype. */
  499. cast_v.type = oldV->type;
  500. } else if(oldV->type == &UA_TYPES[UA_TYPES_BYTE] && !UA_Variant_isScalar(oldV) &&
  501. newV->type == &UA_TYPES[UA_TYPES_BYTESTRING] && UA_Variant_isScalar(newV)) {
  502. /* a string is written to a byte array */
  503. UA_ByteString *str = (UA_ByteString*) newV->data;
  504. cast_v.arrayLength = str->length;
  505. cast_v.data = str->data;
  506. cast_v.type = &UA_TYPES[UA_TYPES_BYTE];
  507. } else {
  508. if(rangeptr)
  509. UA_free(range.dimensions);
  510. return UA_STATUSCODE_BADTYPEMISMATCH;
  511. }
  512. }
  513. }
  514. if(!rangeptr) {
  515. UA_Variant_deleteMembers(&node->value.variant.value);
  516. UA_Variant_copy(newV, &node->value.variant.value);
  517. } else
  518. retval = UA_Variant_setRangeCopy(&node->value.variant.value, newV->data, newV->arrayLength, range);
  519. if(node->value.variant.callback.onWrite)
  520. node->value.variant.callback.onWrite(node->value.variant.callback.handle, node->nodeId,
  521. &node->value.variant.value, rangeptr);
  522. if(rangeptr)
  523. UA_free(range.dimensions);
  524. return retval;
  525. }
  526. static UA_StatusCode
  527. CopyAttributeIntoNode(UA_Server *server, UA_Session *session,
  528. UA_Node *node, const UA_WriteValue *wvalue) {
  529. if(!wvalue->value.hasValue)
  530. return UA_STATUSCODE_BADNODATA;
  531. void *value = wvalue->value.value.data;
  532. void *target = NULL;
  533. const UA_DataType *attr_type = NULL;
  534. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  535. switch(wvalue->attributeId) {
  536. case UA_ATTRIBUTEID_NODEID:
  537. case UA_ATTRIBUTEID_NODECLASS:
  538. case UA_ATTRIBUTEID_DATATYPE:
  539. retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
  540. break;
  541. case UA_ATTRIBUTEID_BROWSENAME:
  542. CHECK_DATATYPE(QUALIFIEDNAME);
  543. target = &node->browseName;
  544. attr_type = &UA_TYPES[UA_TYPES_QUALIFIEDNAME];
  545. break;
  546. case UA_ATTRIBUTEID_DISPLAYNAME:
  547. CHECK_DATATYPE(LOCALIZEDTEXT);
  548. target = &node->displayName;
  549. attr_type = &UA_TYPES[UA_TYPES_LOCALIZEDTEXT];
  550. break;
  551. case UA_ATTRIBUTEID_DESCRIPTION:
  552. CHECK_DATATYPE(LOCALIZEDTEXT);
  553. target = &node->description;
  554. attr_type = &UA_TYPES[UA_TYPES_LOCALIZEDTEXT];
  555. break;
  556. case UA_ATTRIBUTEID_WRITEMASK:
  557. CHECK_DATATYPE(UINT32);
  558. node->writeMask = *(UA_UInt32*)value;
  559. break;
  560. case UA_ATTRIBUTEID_USERWRITEMASK:
  561. CHECK_DATATYPE(UINT32);
  562. node->userWriteMask = *(UA_UInt32*)value;
  563. break;
  564. case UA_ATTRIBUTEID_ISABSTRACT:
  565. CHECK_NODECLASS_WRITE(UA_NODECLASS_OBJECTTYPE | UA_NODECLASS_REFERENCETYPE |
  566. UA_NODECLASS_VARIABLETYPE | UA_NODECLASS_DATATYPE);
  567. CHECK_DATATYPE(BOOLEAN);
  568. ((UA_ObjectTypeNode*)node)->isAbstract = *(UA_Boolean*)value;
  569. break;
  570. case UA_ATTRIBUTEID_SYMMETRIC:
  571. CHECK_NODECLASS_WRITE(UA_NODECLASS_REFERENCETYPE);
  572. CHECK_DATATYPE(BOOLEAN);
  573. ((UA_ReferenceTypeNode*)node)->symmetric = *(UA_Boolean*)value;
  574. break;
  575. case UA_ATTRIBUTEID_INVERSENAME:
  576. CHECK_NODECLASS_WRITE(UA_NODECLASS_REFERENCETYPE);
  577. CHECK_DATATYPE(LOCALIZEDTEXT);
  578. target = &((UA_ReferenceTypeNode*)node)->inverseName;
  579. attr_type = &UA_TYPES[UA_TYPES_LOCALIZEDTEXT];
  580. break;
  581. case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
  582. CHECK_NODECLASS_WRITE(UA_NODECLASS_VIEW);
  583. CHECK_DATATYPE(BOOLEAN);
  584. ((UA_ViewNode*)node)->containsNoLoops = *(UA_Boolean*)value;
  585. break;
  586. case UA_ATTRIBUTEID_EVENTNOTIFIER:
  587. CHECK_NODECLASS_WRITE(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
  588. CHECK_DATATYPE(BYTE);
  589. ((UA_ViewNode*)node)->eventNotifier = *(UA_Byte*)value;
  590. break;
  591. case UA_ATTRIBUTEID_VALUE:
  592. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  593. if(((const UA_VariableNode*)node)->valueSource == UA_VALUESOURCE_VARIANT)
  594. retval = CopyValueIntoNode((UA_VariableNode*)node, wvalue);
  595. else
  596. retval = Service_Write_single_ValueDataSource(server, session, (const UA_VariableNode*)node, wvalue);
  597. break;
  598. case UA_ATTRIBUTEID_ACCESSLEVEL:
  599. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
  600. CHECK_DATATYPE(BYTE);
  601. ((UA_VariableNode*)node)->accessLevel = *(UA_Byte*)value;
  602. break;
  603. case UA_ATTRIBUTEID_USERACCESSLEVEL:
  604. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
  605. CHECK_DATATYPE(BYTE);
  606. ((UA_VariableNode*)node)->userAccessLevel = *(UA_Byte*)value;
  607. break;
  608. case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
  609. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
  610. CHECK_DATATYPE(DOUBLE);
  611. ((UA_VariableNode*)node)->minimumSamplingInterval = *(UA_Double*)value;
  612. break;
  613. case UA_ATTRIBUTEID_HISTORIZING:
  614. CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
  615. CHECK_DATATYPE(BOOLEAN);
  616. ((UA_VariableNode*)node)->historizing = *(UA_Boolean*)value;
  617. break;
  618. case UA_ATTRIBUTEID_EXECUTABLE:
  619. CHECK_NODECLASS_WRITE(UA_NODECLASS_METHOD);
  620. CHECK_DATATYPE(BOOLEAN);
  621. ((UA_MethodNode*)node)->executable = *(UA_Boolean*)value;
  622. break;
  623. case UA_ATTRIBUTEID_USEREXECUTABLE:
  624. CHECK_NODECLASS_WRITE(UA_NODECLASS_METHOD);
  625. CHECK_DATATYPE(BOOLEAN);
  626. ((UA_MethodNode*)node)->userExecutable = *(UA_Boolean*)value;
  627. break;
  628. default:
  629. retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
  630. break;
  631. }
  632. if(attr_type) {
  633. UA_deleteMembers(target, attr_type);
  634. retval = UA_copy(value, target, attr_type);
  635. }
  636. return retval;
  637. }
  638. UA_StatusCode Service_Write_single(UA_Server *server, UA_Session *session, const UA_WriteValue *wvalue) {
  639. return UA_Server_editNode(server, session, &wvalue->nodeId, (UA_EditNodeCallback)CopyAttributeIntoNode, wvalue);
  640. }
  641. void Service_Write(UA_Server *server, UA_Session *session, const UA_WriteRequest *request,
  642. UA_WriteResponse *response) {
  643. UA_assert(server != NULL && session != NULL && request != NULL && response != NULL);
  644. UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SESSION,
  645. "Processing WriteRequest for Session (ns=%i,i=%i)",
  646. session->sessionId.namespaceIndex, session->sessionId.identifier.numeric);
  647. if(request->nodesToWriteSize <= 0) {
  648. response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
  649. return;
  650. }
  651. response->results = UA_Array_new(request->nodesToWriteSize, &UA_TYPES[UA_TYPES_STATUSCODE]);
  652. if(!response->results) {
  653. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  654. return;
  655. }
  656. #ifdef UA_ENABLE_EXTERNAL_NAMESPACES
  657. UA_Boolean isExternal[request->nodesToWriteSize];
  658. UA_UInt32 indices[request->nodesToWriteSize];
  659. memset(isExternal, false, sizeof(UA_Boolean)*request->nodesToWriteSize);
  660. for(size_t j = 0; j < server->externalNamespacesSize; j++) {
  661. UA_UInt32 indexSize = 0;
  662. for(size_t i = 0; i < request->nodesToWriteSize; i++) {
  663. if(request->nodesToWrite[i].nodeId.namespaceIndex !=
  664. server->externalNamespaces[j].index)
  665. continue;
  666. isExternal[i] = true;
  667. indices[indexSize] = i;
  668. indexSize++;
  669. }
  670. if(indexSize == 0)
  671. continue;
  672. UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
  673. ens->writeNodes(ens->ensHandle, &request->requestHeader, request->nodesToWrite,
  674. indices, indexSize, response->results, response->diagnosticInfos);
  675. }
  676. #endif
  677. response->resultsSize = request->nodesToWriteSize;
  678. for(size_t i = 0;i < request->nodesToWriteSize;i++) {
  679. #ifdef UA_ENABLE_EXTERNAL_NAMESPACES
  680. if(!isExternal[i])
  681. #endif
  682. response->results[i] = Service_Write_single(server, session, &request->nodesToWrite[i]);
  683. }
  684. }