ua_services_attribute.c 26 KB

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