ua_services_attribute.c 29 KB

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