ua_services_attribute.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638
  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. static UA_StatusCode parse_numericrange(const UA_String str, UA_NumericRange *range) {
  8. if(str.length < 0 || str.length >= 1023)
  9. return UA_STATUSCODE_BADINTERNALERROR;
  10. #ifdef NO_ALLOCA
  11. char cstring[str.length+1];
  12. #else
  13. char *cstring = UA_alloca(str.length+1);
  14. #endif
  15. UA_memcpy(cstring, str.data, str.length);
  16. cstring[str.length] = 0;
  17. UA_Int32 index = 0;
  18. size_t dimensionsIndex = 0;
  19. size_t dimensionsMax = 3; // more should be uncommon, realloc if necessary
  20. struct UA_NumericRangeDimension *dimensions = UA_malloc(sizeof(struct UA_NumericRangeDimension) * 3);
  21. if(!dimensions)
  22. return UA_STATUSCODE_BADOUTOFMEMORY;
  23. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  24. do {
  25. UA_Int32 min, max;
  26. UA_Int32 progress;
  27. UA_Int32 res = sscanf(&cstring[index], "%" SCNu32 "%n", &min, &progress);
  28. if(res <= 0 || min < 0) {
  29. retval = UA_STATUSCODE_BADINDEXRANGEINVALID;
  30. break;
  31. }
  32. index += progress;
  33. if(index >= str.length || cstring[index] == ',')
  34. max = min;
  35. else {
  36. res = sscanf(&cstring[index], ":%" SCNu32 "%n", &max, &progress);
  37. if(res <= 0 || max < 0 || min >= max) {
  38. retval = UA_STATUSCODE_BADINDEXRANGEINVALID;
  39. break;
  40. }
  41. index += progress;
  42. }
  43. if(dimensionsIndex >= dimensionsMax) {
  44. struct UA_NumericRangeDimension *newDimensions =
  45. UA_realloc(dimensions, sizeof(struct UA_NumericRangeDimension) * 2 * dimensionsMax);
  46. if(!newDimensions) {
  47. UA_free(dimensions);
  48. return UA_STATUSCODE_BADOUTOFMEMORY;
  49. }
  50. dimensions = newDimensions;
  51. dimensionsMax *= 2;
  52. }
  53. dimensions[dimensionsIndex].min = min;
  54. dimensions[dimensionsIndex].max = max;
  55. dimensionsIndex++;
  56. } while(retval == UA_STATUSCODE_GOOD && index + 1 < str.length && cstring[index] == ',' && ++index);
  57. if(retval != UA_STATUSCODE_GOOD) {
  58. UA_free(dimensions);
  59. return retval;
  60. }
  61. range->dimensions = dimensions;
  62. range->dimensionsSize = dimensionsIndex;
  63. return retval;
  64. }
  65. #define CHECK_NODECLASS(CLASS) \
  66. if(!(node->nodeClass & (CLASS))) { \
  67. v->hasStatus = UA_TRUE; \
  68. v->status = UA_STATUSCODE_BADATTRIBUTEIDINVALID; \
  69. break; \
  70. }
  71. static void handleServerTimestamps(UA_TimestampsToReturn timestamps, UA_DataValue* v) {
  72. if (v && (timestamps == UA_TIMESTAMPSTORETURN_SERVER
  73. || timestamps == UA_TIMESTAMPSTORETURN_BOTH)) {
  74. v->hasServerTimestamp = UA_TRUE;
  75. v->serverTimestamp = UA_DateTime_now();
  76. }
  77. }
  78. static void handleSourceTimestamps(UA_TimestampsToReturn timestamps, UA_DataValue* v) {
  79. if(timestamps == UA_TIMESTAMPSTORETURN_SOURCE || timestamps == UA_TIMESTAMPSTORETURN_BOTH) {
  80. v->hasSourceTimestamp = UA_TRUE;
  81. v->sourceTimestamp = UA_DateTime_now();
  82. }
  83. }
  84. /** Reads a single attribute from a node in the nodestore. */
  85. static void readValue(UA_Server *server, UA_TimestampsToReturn timestamps,
  86. const UA_ReadValueId *id, UA_DataValue *v) {
  87. UA_String binEncoding = UA_STRING("DefaultBinary");
  88. UA_String xmlEncoding = UA_STRING("DefaultXml");
  89. if(id->dataEncoding.name.length >= 0){
  90. if(!UA_String_equal(&binEncoding, &id->dataEncoding.name) &&
  91. !UA_String_equal(&xmlEncoding, &id->dataEncoding.name)) {
  92. v->hasStatus = UA_TRUE;
  93. v->status = UA_STATUSCODE_BADDATAENCODINGINVALID;
  94. return;
  95. }
  96. }
  97. //index range for a non-value
  98. if(id->indexRange.length >= 0 && id->attributeId != UA_ATTRIBUTEID_VALUE){
  99. v->hasStatus = UA_TRUE;
  100. v->status = UA_STATUSCODE_BADINDEXRANGENODATA;
  101. return;
  102. }
  103. UA_Node const *node = UA_NodeStore_get(server->nodestore, &(id->nodeId));
  104. if(!node) {
  105. v->hasStatus = UA_TRUE;
  106. v->status = UA_STATUSCODE_BADNODEIDUNKNOWN;
  107. return;
  108. }
  109. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  110. switch(id->attributeId) {
  111. case UA_ATTRIBUTEID_NODEID:
  112. v->hasValue = UA_TRUE;
  113. retval |= UA_Variant_setScalarCopy(&v->value, &node->nodeId, &UA_TYPES[UA_TYPES_NODEID]);
  114. break;
  115. case UA_ATTRIBUTEID_NODECLASS:
  116. v->hasValue = UA_TRUE;
  117. retval |= UA_Variant_setScalarCopy(&v->value, &node->nodeClass, &UA_TYPES[UA_TYPES_INT32]);
  118. break;
  119. case UA_ATTRIBUTEID_BROWSENAME:
  120. v->hasValue = UA_TRUE;
  121. retval |= UA_Variant_setScalarCopy(&v->value, &node->browseName, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
  122. break;
  123. case UA_ATTRIBUTEID_DISPLAYNAME:
  124. retval |= UA_Variant_setScalarCopy(&v->value, &node->displayName, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
  125. if(retval == UA_STATUSCODE_GOOD)
  126. v->hasValue = UA_TRUE;
  127. break;
  128. case UA_ATTRIBUTEID_DESCRIPTION:
  129. v->hasValue = UA_TRUE;
  130. retval |= UA_Variant_setScalarCopy(&v->value, &node->description, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
  131. break;
  132. case UA_ATTRIBUTEID_WRITEMASK:
  133. v->hasValue = UA_TRUE;
  134. retval |= UA_Variant_setScalarCopy(&v->value, &node->writeMask, &UA_TYPES[UA_TYPES_UINT32]);
  135. break;
  136. case UA_ATTRIBUTEID_USERWRITEMASK:
  137. v->hasValue = UA_TRUE;
  138. retval |= UA_Variant_setScalarCopy(&v->value, &node->userWriteMask, &UA_TYPES[UA_TYPES_UINT32]);
  139. break;
  140. case UA_ATTRIBUTEID_ISABSTRACT:
  141. CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE | UA_NODECLASS_OBJECTTYPE | UA_NODECLASS_VARIABLETYPE |
  142. UA_NODECLASS_DATATYPE);
  143. v->hasValue = UA_TRUE;
  144. retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ReferenceTypeNode *)node)->isAbstract,
  145. &UA_TYPES[UA_TYPES_BOOLEAN]);
  146. break;
  147. case UA_ATTRIBUTEID_SYMMETRIC:
  148. CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
  149. v->hasValue = UA_TRUE;
  150. retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ReferenceTypeNode *)node)->symmetric,
  151. &UA_TYPES[UA_TYPES_BOOLEAN]);
  152. break;
  153. case UA_ATTRIBUTEID_INVERSENAME:
  154. CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
  155. v->hasValue = UA_TRUE;
  156. retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ReferenceTypeNode *)node)->inverseName,
  157. &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
  158. break;
  159. case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
  160. CHECK_NODECLASS(UA_NODECLASS_VIEW);
  161. v->hasValue = UA_TRUE;
  162. retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ViewNode *)node)->containsNoLoops,
  163. &UA_TYPES[UA_TYPES_BOOLEAN]);
  164. break;
  165. case UA_ATTRIBUTEID_EVENTNOTIFIER:
  166. CHECK_NODECLASS(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
  167. v->hasValue = UA_TRUE;
  168. if(node->nodeClass == UA_NODECLASS_VIEW){
  169. retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ViewNode *)node)->eventNotifier,
  170. &UA_TYPES[UA_TYPES_BYTE]);
  171. } else {
  172. retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_ObjectNode *)node)->eventNotifier,
  173. &UA_TYPES[UA_TYPES_BYTE]);
  174. }
  175. break;
  176. case UA_ATTRIBUTEID_VALUE:
  177. CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  178. {
  179. if(node->nodeClass != UA_NODECLASS_VARIABLE) {
  180. v->hasValue = UA_FALSE;
  181. handleSourceTimestamps(timestamps, v);
  182. }
  183. UA_Boolean hasRange = UA_FALSE;
  184. UA_NumericRange range;
  185. if(id->indexRange.length > 0) {
  186. retval = parse_numericrange(id->indexRange, &range);
  187. if(retval != UA_STATUSCODE_GOOD)
  188. break;
  189. hasRange = UA_TRUE;
  190. }
  191. const UA_VariableNode *vn = (const UA_VariableNode*)node;
  192. if(vn->valueSource == UA_VALUESOURCE_VARIANT) {
  193. if(hasRange)
  194. retval |= UA_Variant_copyRange(&vn->value.variant, &v->value, range);
  195. else
  196. retval |= UA_Variant_copy(&vn->value.variant, &v->value);
  197. if(retval == UA_STATUSCODE_GOOD) {
  198. v->hasValue = UA_TRUE;
  199. handleSourceTimestamps(timestamps, v);
  200. }
  201. } else {
  202. UA_DataValue val;
  203. UA_DataValue_init(&val);
  204. UA_Boolean sourceTimeStamp = (timestamps == UA_TIMESTAMPSTORETURN_SOURCE ||
  205. timestamps == UA_TIMESTAMPSTORETURN_BOTH);
  206. if(hasRange)
  207. retval |= vn->value.dataSource.read(vn->value.dataSource.handle, sourceTimeStamp, &range, &val);
  208. else
  209. retval |= vn->value.dataSource.read(vn->value.dataSource.handle, sourceTimeStamp, UA_NULL, &val);
  210. if(retval == UA_STATUSCODE_GOOD) {
  211. retval |= UA_DataValue_copy(&val, v); // todo: still too much copying necessary!!
  212. vn->value.dataSource.release(vn->value.dataSource.handle, &val);
  213. }
  214. }
  215. if(hasRange)
  216. UA_free(range.dimensions);
  217. }
  218. break;
  219. case UA_ATTRIBUTEID_DATATYPE: {
  220. CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  221. const UA_VariableNode *vn = (const UA_VariableNode*)node;
  222. if(vn->valueSource == UA_VALUESOURCE_VARIANT)
  223. retval = UA_Variant_setScalarCopy(&v->value, &vn->value.variant.type->typeId,
  224. &UA_TYPES[UA_TYPES_NODEID]);
  225. else {
  226. UA_DataValue val;
  227. UA_DataValue_init(&val);
  228. retval = vn->value.dataSource.read(vn->value.dataSource.handle, UA_FALSE, UA_NULL, &val);
  229. if(retval != UA_STATUSCODE_GOOD)
  230. break;
  231. retval = UA_Variant_setScalarCopy(&v->value, &val.value.type->typeId, &UA_TYPES[UA_TYPES_NODEID]);
  232. vn->value.dataSource.release(vn->value.dataSource.handle, &val);
  233. }
  234. if(retval == UA_STATUSCODE_GOOD)
  235. v->hasValue = UA_TRUE;
  236. }
  237. break;
  238. case UA_ATTRIBUTEID_VALUERANK:
  239. CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  240. v->hasValue = UA_TRUE;
  241. retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_VariableTypeNode *)node)->valueRank,
  242. &UA_TYPES[UA_TYPES_INT32]);
  243. break;
  244. case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
  245. CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
  246. {
  247. const UA_VariableNode *vn = (const UA_VariableNode *)node;
  248. if(vn->valueSource == UA_VALUESOURCE_VARIANT) {
  249. retval = UA_Variant_setArrayCopy(&v->value, vn->value.variant.arrayDimensions,
  250. vn->value.variant.arrayDimensionsSize,
  251. &UA_TYPES[UA_TYPES_INT32]);
  252. if(retval == UA_STATUSCODE_GOOD)
  253. v->hasValue = UA_TRUE;
  254. } else {
  255. UA_DataValue val;
  256. UA_DataValue_init(&val);
  257. retval |= vn->value.dataSource.read(vn->value.dataSource.handle, UA_FALSE, UA_NULL, &val);
  258. if(retval != UA_STATUSCODE_GOOD)
  259. break;
  260. if(!val.hasValue)
  261. retval = UA_STATUSCODE_BADNOTREADABLE;
  262. else
  263. retval = UA_Variant_setArrayCopy(&v->value, val.value.arrayDimensions,
  264. val.value.arrayDimensionsSize, &UA_TYPES[UA_TYPES_INT32]);
  265. vn->value.dataSource.release(vn->value.dataSource.handle, &val);
  266. }
  267. }
  268. break;
  269. case UA_ATTRIBUTEID_ACCESSLEVEL:
  270. CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
  271. v->hasValue = UA_TRUE;
  272. retval |= UA_Variant_setScalarCopy(&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. v->hasValue = UA_TRUE;
  278. retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_VariableNode *)node)->userAccessLevel,
  279. &UA_TYPES[UA_TYPES_BYTE]);
  280. break;
  281. case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
  282. CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
  283. v->hasValue = UA_TRUE;
  284. retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_VariableNode *)node)->minimumSamplingInterval,
  285. &UA_TYPES[UA_TYPES_DOUBLE]);
  286. break;
  287. case UA_ATTRIBUTEID_HISTORIZING:
  288. CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
  289. v->hasValue = UA_TRUE;
  290. retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_VariableNode *)node)->historizing,
  291. &UA_TYPES[UA_TYPES_BOOLEAN]);
  292. break;
  293. case UA_ATTRIBUTEID_EXECUTABLE:
  294. CHECK_NODECLASS(UA_NODECLASS_METHOD);
  295. v->hasValue = UA_TRUE;
  296. retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_MethodNode *)node)->executable,
  297. &UA_TYPES[UA_TYPES_BOOLEAN]);
  298. break;
  299. case UA_ATTRIBUTEID_USEREXECUTABLE:
  300. CHECK_NODECLASS(UA_NODECLASS_METHOD);
  301. v->hasValue = UA_TRUE;
  302. retval |= UA_Variant_setScalarCopy(&v->value, &((const UA_MethodNode *)node)->userExecutable,
  303. &UA_TYPES[UA_TYPES_BOOLEAN]);
  304. break;
  305. default:
  306. v->hasStatus = UA_TRUE;
  307. v->status = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
  308. break;
  309. }
  310. UA_NodeStore_release(node);
  311. if(retval != UA_STATUSCODE_GOOD) {
  312. v->hasStatus = UA_TRUE;
  313. v->status = retval;
  314. }
  315. handleServerTimestamps(timestamps, v);
  316. }
  317. void Service_Read(UA_Server *server, UA_Session *session, const UA_ReadRequest *request,
  318. UA_ReadResponse *response) {
  319. if(request->nodesToReadSize <= 0) {
  320. response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
  321. return;
  322. }
  323. if(request->timestampsToReturn > 3){
  324. response->responseHeader.serviceResult = UA_STATUSCODE_BADTIMESTAMPSTORETURNINVALID;
  325. return;
  326. }
  327. size_t size = request->nodesToReadSize;
  328. response->results = UA_Array_new(&UA_TYPES[UA_TYPES_DATAVALUE], size);
  329. if(!response->results) {
  330. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  331. return;
  332. }
  333. response->resultsSize = size;
  334. if(request->maxAge < 0) {
  335. response->responseHeader.serviceResult = UA_STATUSCODE_BADMAXAGEINVALID;
  336. return;
  337. }
  338. #ifdef UA_EXTERNAL_NAMESPACES
  339. #ifdef NO_ALLOCA
  340. UA_Boolean isExternal[size];
  341. UA_UInt32 indices[size];
  342. #else
  343. UA_Boolean *isExternal = UA_alloca(sizeof(UA_Boolean) * size);
  344. UA_UInt32 *indices = UA_alloca(sizeof(UA_UInt32) * size);
  345. #endif /*NO_ALLOCA */
  346. UA_memset(isExternal, UA_FALSE, sizeof(UA_Boolean) * size);
  347. for(size_t j = 0;j<server->externalNamespacesSize;j++) {
  348. size_t indexSize = 0;
  349. for(size_t i = 0;i < size;i++) {
  350. if(request->nodesToRead[i].nodeId.namespaceIndex != server->externalNamespaces[j].index)
  351. continue;
  352. isExternal[i] = UA_TRUE;
  353. indices[indexSize] = i;
  354. indexSize++;
  355. }
  356. if(indexSize == 0)
  357. continue;
  358. UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
  359. ens->readNodes(ens->ensHandle, &request->requestHeader, request->nodesToRead,
  360. indices, indexSize, response->results, UA_FALSE, response->diagnosticInfos);
  361. }
  362. #endif
  363. for(size_t i = 0;i < size;i++) {
  364. #ifdef UA_EXTERNAL_NAMESPACES
  365. if(!isExternal[i])
  366. #endif
  367. readValue(server, request->timestampsToReturn, &request->nodesToRead[i], &response->results[i]);
  368. }
  369. #ifdef EXTENSION_STATELESS
  370. if(session==&anonymousSession){
  371. /* expiry header */
  372. UA_ExtensionObject additionalHeader;
  373. UA_ExtensionObject_init(&additionalHeader);
  374. additionalHeader.encoding = UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING;
  375. UA_Variant variant;
  376. UA_Variant_init(&variant);
  377. variant.type = &UA_TYPES[UA_TYPES_DATETIME];
  378. variant.arrayLength = request->nodesToReadSize;
  379. UA_DateTime* expireArray = UA_NULL;
  380. expireArray = UA_Array_new(&UA_TYPES[UA_TYPES_DATETIME], request->nodesToReadSize);
  381. variant.data = expireArray;
  382. UA_ByteString str;
  383. UA_ByteString_init(&str);
  384. /*expires in 20 seconds*/
  385. for(UA_Int32 i = 0;i < response->resultsSize;i++) {
  386. expireArray[i] = UA_DateTime_now() + 20 * 100 * 1000 * 1000;
  387. }
  388. size_t offset = 0;
  389. str.data = UA_malloc(UA_Variant_calcSizeBinary(&variant));
  390. str.length = UA_Variant_calcSizeBinary(&variant);
  391. UA_Variant_encodeBinary(&variant, &str, &offset);
  392. additionalHeader.body = str;
  393. response->responseHeader.additionalHeader = additionalHeader;
  394. }
  395. #endif
  396. }
  397. static UA_StatusCode writeValue(UA_Server *server, UA_WriteValue *wvalue) {
  398. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  399. /* is there a value at all */
  400. if(!wvalue->value.hasValue)
  401. return UA_STATUSCODE_BADTYPEMISMATCH;
  402. // we might repeat writing, e.g. when the node got replaced mid-work
  403. UA_Boolean done = UA_FALSE;
  404. while(!done) {
  405. const UA_Node *node = UA_NodeStore_get(server->nodestore, &wvalue->nodeId);
  406. if(!node)
  407. return UA_STATUSCODE_BADNODEIDUNKNOWN;
  408. switch(wvalue->attributeId) {
  409. case UA_ATTRIBUTEID_NODEID:
  410. case UA_ATTRIBUTEID_NODECLASS:
  411. case UA_ATTRIBUTEID_BROWSENAME:
  412. case UA_ATTRIBUTEID_DISPLAYNAME:
  413. case UA_ATTRIBUTEID_DESCRIPTION:
  414. case UA_ATTRIBUTEID_WRITEMASK:
  415. case UA_ATTRIBUTEID_USERWRITEMASK:
  416. case UA_ATTRIBUTEID_ISABSTRACT:
  417. case UA_ATTRIBUTEID_SYMMETRIC:
  418. case UA_ATTRIBUTEID_INVERSENAME:
  419. case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
  420. case UA_ATTRIBUTEID_EVENTNOTIFIER:
  421. retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
  422. break;
  423. case UA_ATTRIBUTEID_VALUE: {
  424. if(node->nodeClass != UA_NODECLASS_VARIABLE &&
  425. node->nodeClass != UA_NODECLASS_VARIABLETYPE) {
  426. retval = UA_STATUSCODE_BADTYPEMISMATCH;
  427. break;
  428. }
  429. /* parse the range */
  430. UA_Boolean hasRange = UA_FALSE;
  431. UA_NumericRange range;
  432. if(wvalue->indexRange.length > 0) {
  433. retval = parse_numericrange(wvalue->indexRange, &range);
  434. if(retval != UA_STATUSCODE_GOOD)
  435. break;
  436. hasRange = UA_TRUE;
  437. }
  438. /* the relevant members are similar for variables and variabletypes */
  439. const UA_VariableNode *vn = (const UA_VariableNode*)node;
  440. if(vn->valueSource == UA_VALUESOURCE_DATASOURCE) {
  441. if(!vn->value.dataSource.write) {
  442. retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
  443. goto clean_up_range;
  444. }
  445. // todo: writing ranges
  446. if(hasRange)
  447. retval = vn->value.dataSource.write(vn->value.dataSource.handle, &wvalue->value.value, &range);
  448. else
  449. retval = vn->value.dataSource.write(vn->value.dataSource.handle, &wvalue->value.value, UA_NULL);
  450. done = UA_TRUE;
  451. goto clean_up_range;
  452. }
  453. const UA_Variant *oldV = &vn->value.variant;
  454. /* the nodeid on the wire may be != the nodeid in the node: opaque types, enums and bytestrings */
  455. if(!UA_NodeId_equal(&oldV->type->typeId, &wvalue->value.value.type->typeId)) {
  456. if(oldV->type->namespaceZero && wvalue->value.value.type->namespaceZero &&
  457. oldV->type->typeIndex == wvalue->value.value.type->typeIndex)
  458. /* An enum was sent as an int32, or an opaque type as a bytestring. This is
  459. detected with the typeIndex indicated the "true" datatype. */
  460. wvalue->value.value.type = oldV->type;
  461. else if(oldV->type == &UA_TYPES[UA_TYPES_BYTE] && !UA_Variant_isScalar(oldV) &&
  462. wvalue->value.value.type == &UA_TYPES[UA_TYPES_BYTESTRING] &&
  463. UA_Variant_isScalar(&wvalue->value.value)) {
  464. /* a string is written to a byte array */
  465. UA_ByteString *str = (UA_ByteString*) wvalue->value.value.data;
  466. wvalue->value.value.arrayLength = str->length;
  467. wvalue->value.value.data = str->data;
  468. wvalue->value.value.type = &UA_TYPES[UA_TYPES_BYTE];
  469. UA_free(str);
  470. } else {
  471. retval = UA_STATUSCODE_BADTYPEMISMATCH;
  472. goto clean_up_range;
  473. }
  474. }
  475. /* copy the node */
  476. UA_VariableNode *newVn = (node->nodeClass == UA_NODECLASS_VARIABLE) ?
  477. UA_VariableNode_new() : (UA_VariableNode*)UA_VariableTypeNode_new();
  478. if(!newVn) {
  479. retval = UA_STATUSCODE_BADOUTOFMEMORY;
  480. goto clean_up_range;
  481. }
  482. retval = (node->nodeClass == UA_NODECLASS_VARIABLE) ? UA_VariableNode_copy(vn, newVn) :
  483. UA_VariableTypeNode_copy((const UA_VariableTypeNode*)vn, (UA_VariableTypeNode*)newVn);
  484. if(retval != UA_STATUSCODE_GOOD)
  485. goto clean_up;
  486. /* insert the new value */
  487. if(hasRange)
  488. retval = UA_Variant_setRangeCopy(&newVn->value.variant, wvalue->value.value.data,
  489. wvalue->value.value.arrayLength, range);
  490. else {
  491. UA_Variant_deleteMembers(&newVn->value.variant);
  492. retval = UA_Variant_copy(&wvalue->value.value, &newVn->value.variant);
  493. }
  494. if(retval == UA_STATUSCODE_GOOD && UA_NodeStore_replace(server->nodestore, node,
  495. (UA_Node*)newVn, UA_NULL) == UA_STATUSCODE_GOOD) {
  496. done = UA_TRUE;
  497. goto clean_up_range;
  498. }
  499. clean_up:
  500. if(node->nodeClass == UA_NODECLASS_VARIABLE)
  501. UA_VariableNode_delete(newVn);
  502. else
  503. UA_VariableTypeNode_delete((UA_VariableTypeNode*)newVn);
  504. clean_up_range:
  505. if(hasRange)
  506. UA_free(range.dimensions);
  507. }
  508. break;
  509. case UA_ATTRIBUTEID_DATATYPE:
  510. case UA_ATTRIBUTEID_VALUERANK:
  511. case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
  512. case UA_ATTRIBUTEID_ACCESSLEVEL:
  513. case UA_ATTRIBUTEID_USERACCESSLEVEL:
  514. case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
  515. case UA_ATTRIBUTEID_HISTORIZING:
  516. case UA_ATTRIBUTEID_EXECUTABLE:
  517. case UA_ATTRIBUTEID_USEREXECUTABLE:
  518. retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
  519. break;
  520. default:
  521. retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
  522. break;
  523. }
  524. UA_NodeStore_release(node);
  525. if(retval != UA_STATUSCODE_GOOD)
  526. break;
  527. }
  528. return retval;
  529. }
  530. void Service_Write(UA_Server *server, UA_Session *session, const UA_WriteRequest *request,
  531. UA_WriteResponse *response) {
  532. UA_assert(server != UA_NULL && session != UA_NULL && request != UA_NULL && response != UA_NULL);
  533. if(request->nodesToWriteSize <= 0){
  534. response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
  535. return;
  536. }
  537. response->results = UA_Array_new(&UA_TYPES[UA_TYPES_STATUSCODE], request->nodesToWriteSize);
  538. if(!response->results) {
  539. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  540. return;
  541. }
  542. #ifdef UA_EXTERNAL_NAMESPACES
  543. #ifdef NO_ALLOCA
  544. UA_Boolean isExternal[request->nodesToWriteSize];
  545. UA_UInt32 indices[request->nodesToWriteSize];
  546. #else
  547. UA_Boolean *isExternal = UA_alloca(sizeof(UA_Boolean) * request->nodesToWriteSize);
  548. UA_UInt32 *indices = UA_alloca(sizeof(UA_UInt32) * request->nodesToWriteSize);
  549. #endif /*NO_ALLOCA */
  550. UA_memset(isExternal, UA_FALSE, sizeof(UA_Boolean)*request->nodesToWriteSize);
  551. for(size_t j = 0; j < server->externalNamespacesSize; j++) {
  552. UA_UInt32 indexSize = 0;
  553. for(UA_Int32 i = 0; i < request->nodesToWriteSize; i++) {
  554. if(request->nodesToWrite[i].nodeId.namespaceIndex !=
  555. server->externalNamespaces[j].index)
  556. continue;
  557. isExternal[i] = UA_TRUE;
  558. indices[indexSize] = i;
  559. indexSize++;
  560. }
  561. if(indexSize == 0)
  562. continue;
  563. UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
  564. ens->writeNodes(ens->ensHandle, &request->requestHeader, request->nodesToWrite,
  565. indices, indexSize, response->results, response->diagnosticInfos);
  566. }
  567. #endif
  568. response->resultsSize = request->nodesToWriteSize;
  569. for(UA_Int32 i = 0;i < request->nodesToWriteSize;i++) {
  570. #ifdef UA_EXTERNAL_NAMESPACES
  571. if(!isExternal[i])
  572. #endif
  573. response->results[i] = writeValue(server, &request->nodesToWrite[i]);
  574. }
  575. }