ua_types.c 37 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102
  1. /* This Source Code Form is subject to the terms of the Mozilla Public
  2. * License, v. 2.0. If a copy of the MPL was not distributed with this
  3. * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  4. *
  5. * Copyright 2014-2017 (c) Julius Pfrommer, Fraunhofer IOSB
  6. * Copyright 2014, 2016-2017 (c) Florian Palm
  7. * Copyright 2014-2016 (c) Sten Grüner
  8. * Copyright 2014 (c) Leon Urbas
  9. * Copyright 2015 (c) Chris Iatrou
  10. * Copyright 2015 (c) Markus Graube
  11. * Copyright 2015 (c) Reza Ebrahimi
  12. * Copyright 2015-2016 (c) Oleksiy Vasylyev
  13. * Copyright 2017 (c) Stefan Profanter, fortiss GmbH
  14. * Copyright 2016 (c) Lorenz Haas
  15. */
  16. #include "ua_util.h"
  17. #include "ua_types.h"
  18. #include "ua_types_generated.h"
  19. #include "ua_types_generated_handling.h"
  20. #include "pcg_basic.h"
  21. #include "libc_time.h"
  22. /* Datatype Handling
  23. * -----------------
  24. * This file contains handling functions for the builtin types and functions
  25. * handling of structured types and arrays. These need type descriptions in a
  26. * UA_DataType structure. The UA_DataType structures as well as all non-builtin
  27. * datatypes are autogenerated. */
  28. /* Global definition of NULL type instances. These are always zeroed out, as
  29. * mandated by the C/C++ standard for global values with no initializer. */
  30. const UA_String UA_STRING_NULL = {0, NULL};
  31. const UA_ByteString UA_BYTESTRING_NULL = {0, NULL};
  32. const UA_Guid UA_GUID_NULL = {0, 0, 0, {0,0,0,0,0,0,0,0}};
  33. const UA_NodeId UA_NODEID_NULL = {0, UA_NODEIDTYPE_NUMERIC, {0}};
  34. const UA_ExpandedNodeId UA_EXPANDEDNODEID_NULL = {{0, UA_NODEIDTYPE_NUMERIC, {0}}, {0, NULL}, 0};
  35. /* TODO: The standard-defined types are ordered. See if binary search is
  36. * more efficient. */
  37. const UA_DataType *
  38. UA_findDataType(const UA_NodeId *typeId) {
  39. if(typeId->identifierType != UA_NODEIDTYPE_NUMERIC ||
  40. typeId->namespaceIndex != 0)
  41. return NULL;
  42. for(size_t i = 0; i < UA_TYPES_COUNT; ++i) {
  43. if(UA_TYPES[i].typeId.identifier.numeric == typeId->identifier.numeric)
  44. return &UA_TYPES[i];
  45. }
  46. return NULL;
  47. }
  48. /***************************/
  49. /* Random Number Generator */
  50. /***************************/
  51. static UA_THREAD_LOCAL pcg32_random_t UA_rng = PCG32_INITIALIZER;
  52. void
  53. UA_random_seed(u64 seed) {
  54. pcg32_srandom_r(&UA_rng, seed, (u64)UA_DateTime_now());
  55. }
  56. u32
  57. UA_UInt32_random(void) {
  58. return (u32)pcg32_random_r(&UA_rng);
  59. }
  60. /*****************/
  61. /* Builtin Types */
  62. /*****************/
  63. static void deleteMembers_noInit(void *p, const UA_DataType *type);
  64. static UA_StatusCode copy_noInit(const void *src, void *dst, const UA_DataType *type);
  65. UA_String
  66. UA_String_fromChars(char const src[]) {
  67. UA_String str;
  68. str.length = strlen(src);
  69. if(str.length > 0) {
  70. str.data = (u8*)UA_malloc(str.length);
  71. if(!str.data)
  72. return UA_STRING_NULL;
  73. memcpy(str.data, src, str.length);
  74. } else {
  75. str.data = (u8*)UA_EMPTY_ARRAY_SENTINEL;
  76. }
  77. return str;
  78. }
  79. UA_Boolean
  80. UA_String_equal(const UA_String *s1, const UA_String *s2) {
  81. if(s1->length != s2->length)
  82. return false;
  83. i32 is = memcmp((char const*)s1->data,
  84. (char const*)s2->data, s1->length);
  85. return (is == 0) ? true : false;
  86. }
  87. static void
  88. String_deleteMembers(UA_String *s, const UA_DataType *_) {
  89. UA_free((void*)((uintptr_t)s->data & ~(uintptr_t)UA_EMPTY_ARRAY_SENTINEL));
  90. }
  91. UA_Boolean
  92. UA_QualifiedName_equal(const UA_QualifiedName *qn1,
  93. const UA_QualifiedName *qn2) {
  94. if(qn1 == NULL || qn2 == NULL)
  95. return false;
  96. if(qn1->namespaceIndex != qn2->namespaceIndex)
  97. return false;
  98. if(qn1->name.length != qn2->name.length)
  99. return false;
  100. return (memcmp((char const*)qn1->name.data,
  101. (char const*)qn2->name.data, qn1->name.length) == 0);
  102. }
  103. /* DateTime */
  104. UA_DateTimeStruct
  105. UA_DateTime_toStruct(UA_DateTime t) {
  106. /* Calculating the the milli-, micro- and nanoseconds */
  107. UA_DateTimeStruct dateTimeStruct;
  108. dateTimeStruct.nanoSec = (u16)((t % 10) * 100);
  109. dateTimeStruct.microSec = (u16)((t % 10000) / 10);
  110. dateTimeStruct.milliSec = (u16)((t % 10000000) / 10000);
  111. /* Calculating the unix time with #include <time.h> */
  112. long long secSinceUnixEpoch = (long long)
  113. ((t - UA_DATETIME_UNIX_EPOCH) / UA_DATETIME_SEC);
  114. struct mytm ts;
  115. memset(&ts, 0, sizeof(struct mytm));
  116. __secs_to_tm(secSinceUnixEpoch, &ts);
  117. dateTimeStruct.sec = (u16)ts.tm_sec;
  118. dateTimeStruct.min = (u16)ts.tm_min;
  119. dateTimeStruct.hour = (u16)ts.tm_hour;
  120. dateTimeStruct.day = (u16)ts.tm_mday;
  121. dateTimeStruct.month = (u16)(ts.tm_mon + 1);
  122. dateTimeStruct.year = (u16)(ts.tm_year + 1900);
  123. return dateTimeStruct;
  124. }
  125. static void
  126. printNumber(u16 n, u8 *pos, size_t digits) {
  127. for(size_t i = digits; i > 0; --i) {
  128. pos[i-1] = (u8)((n % 10) + '0');
  129. n = n / 10;
  130. }
  131. }
  132. UA_String
  133. UA_DateTime_toString(UA_DateTime t) {
  134. /* length of the string is 31 (plus \0 at the end) */
  135. UA_String str = {31, (u8*)UA_malloc(32)};
  136. if(!str.data)
  137. return UA_STRING_NULL;
  138. UA_DateTimeStruct tSt = UA_DateTime_toStruct(t);
  139. printNumber(tSt.month, str.data, 2);
  140. str.data[2] = '/';
  141. printNumber(tSt.day, &str.data[3], 2);
  142. str.data[5] = '/';
  143. printNumber(tSt.year, &str.data[6], 4);
  144. str.data[10] = ' ';
  145. printNumber(tSt.hour, &str.data[11], 2);
  146. str.data[13] = ':';
  147. printNumber(tSt.min, &str.data[14], 2);
  148. str.data[16] = ':';
  149. printNumber(tSt.sec, &str.data[17], 2);
  150. str.data[19] = '.';
  151. printNumber(tSt.milliSec, &str.data[20], 3);
  152. str.data[23] = '.';
  153. printNumber(tSt.microSec, &str.data[24], 3);
  154. str.data[27] = '.';
  155. printNumber(tSt.nanoSec, &str.data[28], 3);
  156. return str;
  157. }
  158. /* Guid */
  159. UA_Boolean
  160. UA_Guid_equal(const UA_Guid *g1, const UA_Guid *g2) {
  161. if(memcmp(g1, g2, sizeof(UA_Guid)) == 0)
  162. return true;
  163. return false;
  164. }
  165. UA_Guid
  166. UA_Guid_random(void) {
  167. UA_Guid result;
  168. result.data1 = (u32)pcg32_random_r(&UA_rng);
  169. u32 r = (u32)pcg32_random_r(&UA_rng);
  170. result.data2 = (u16) r;
  171. result.data3 = (u16) (r >> 16);
  172. r = (u32)pcg32_random_r(&UA_rng);
  173. result.data4[0] = (u8)r;
  174. result.data4[1] = (u8)(r >> 4);
  175. result.data4[2] = (u8)(r >> 8);
  176. result.data4[3] = (u8)(r >> 12);
  177. r = (u32)pcg32_random_r(&UA_rng);
  178. result.data4[4] = (u8)r;
  179. result.data4[5] = (u8)(r >> 4);
  180. result.data4[6] = (u8)(r >> 8);
  181. result.data4[7] = (u8)(r >> 12);
  182. return result;
  183. }
  184. /* ByteString */
  185. UA_StatusCode
  186. UA_ByteString_allocBuffer(UA_ByteString *bs, size_t length) {
  187. UA_ByteString_init(bs);
  188. if(length == 0)
  189. return UA_STATUSCODE_GOOD;
  190. bs->data = (u8*)UA_malloc(length);
  191. if(!bs->data)
  192. return UA_STATUSCODE_BADOUTOFMEMORY;
  193. bs->length = length;
  194. return UA_STATUSCODE_GOOD;
  195. }
  196. /* NodeId */
  197. static void
  198. NodeId_deleteMembers(UA_NodeId *p, const UA_DataType *_) {
  199. switch(p->identifierType) {
  200. case UA_NODEIDTYPE_STRING:
  201. case UA_NODEIDTYPE_BYTESTRING:
  202. String_deleteMembers(&p->identifier.string, NULL);
  203. break;
  204. default: break;
  205. }
  206. }
  207. static UA_StatusCode
  208. NodeId_copy(UA_NodeId const *src, UA_NodeId *dst, const UA_DataType *_) {
  209. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  210. switch(src->identifierType) {
  211. case UA_NODEIDTYPE_NUMERIC:
  212. *dst = *src;
  213. return UA_STATUSCODE_GOOD;
  214. case UA_NODEIDTYPE_STRING:
  215. retval |= UA_String_copy(&src->identifier.string,
  216. &dst->identifier.string);
  217. break;
  218. case UA_NODEIDTYPE_GUID:
  219. retval |= UA_Guid_copy(&src->identifier.guid, &dst->identifier.guid);
  220. break;
  221. case UA_NODEIDTYPE_BYTESTRING:
  222. retval |= UA_ByteString_copy(&src->identifier.byteString,
  223. &dst->identifier.byteString);
  224. break;
  225. default:
  226. return UA_STATUSCODE_BADINTERNALERROR;
  227. }
  228. dst->namespaceIndex = src->namespaceIndex;
  229. dst->identifierType = src->identifierType;
  230. return retval;
  231. }
  232. UA_Boolean
  233. UA_NodeId_isNull(const UA_NodeId *p) {
  234. if(p->namespaceIndex != 0)
  235. return false;
  236. switch(p->identifierType) {
  237. case UA_NODEIDTYPE_NUMERIC:
  238. return (p->identifier.numeric == 0);
  239. case UA_NODEIDTYPE_GUID:
  240. return (p->identifier.guid.data1 == 0 &&
  241. p->identifier.guid.data2 == 0 &&
  242. p->identifier.guid.data3 == 0 &&
  243. p->identifier.guid.data4[0] == 0 &&
  244. p->identifier.guid.data4[1] == 0 &&
  245. p->identifier.guid.data4[2] == 0 &&
  246. p->identifier.guid.data4[3] == 0 &&
  247. p->identifier.guid.data4[4] == 0 &&
  248. p->identifier.guid.data4[5] == 0 &&
  249. p->identifier.guid.data4[6] == 0 &&
  250. p->identifier.guid.data4[7] == 0);
  251. default:
  252. break;
  253. }
  254. return (p->identifier.string.length == 0);
  255. }
  256. UA_Boolean
  257. UA_NodeId_equal(const UA_NodeId *n1, const UA_NodeId *n2) {
  258. if(n1->namespaceIndex != n2->namespaceIndex ||
  259. n1->identifierType!=n2->identifierType)
  260. return false;
  261. switch(n1->identifierType) {
  262. case UA_NODEIDTYPE_NUMERIC:
  263. if(n1->identifier.numeric == n2->identifier.numeric)
  264. return true;
  265. else
  266. return false;
  267. case UA_NODEIDTYPE_STRING:
  268. return UA_String_equal(&n1->identifier.string,
  269. &n2->identifier.string);
  270. case UA_NODEIDTYPE_GUID:
  271. return UA_Guid_equal(&n1->identifier.guid,
  272. &n2->identifier.guid);
  273. case UA_NODEIDTYPE_BYTESTRING:
  274. return UA_ByteString_equal(&n1->identifier.byteString,
  275. &n2->identifier.byteString);
  276. }
  277. return false;
  278. }
  279. UA_Boolean
  280. UA_ExpandedNodeId_equal(const UA_ExpandedNodeId *n1, const UA_ExpandedNodeId *n2) {
  281. if(n1 == NULL || n2 == NULL)
  282. return false;
  283. if(n1->serverIndex != n2->serverIndex)
  284. return false;
  285. if(!UA_String_equal(&n1->namespaceUri, &n2->namespaceUri))
  286. return false;
  287. return UA_NodeId_equal(&n1->nodeId, &n2->nodeId);
  288. }
  289. /* FNV non-cryptographic hash function. See
  290. * https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function */
  291. #define FNV_PRIME_32 16777619
  292. static u32
  293. fnv32(u32 fnv, const u8 *buf, size_t size) {
  294. for(size_t i = 0; i < size; ++i) {
  295. fnv = fnv ^ (buf[i]);
  296. fnv = fnv * FNV_PRIME_32;
  297. }
  298. return fnv;
  299. }
  300. u32
  301. UA_NodeId_hash(const UA_NodeId *n) {
  302. switch(n->identifierType) {
  303. case UA_NODEIDTYPE_NUMERIC:
  304. default:
  305. // shift knuth multiplication to use highest 32 bits and after addition make sure we don't have an integer overflow
  306. return (u32)((n->namespaceIndex + ((n->identifier.numeric * (u64)2654435761) >> (32))) & UINT32_C(4294967295)); /* Knuth's multiplicative hashing */
  307. case UA_NODEIDTYPE_STRING:
  308. case UA_NODEIDTYPE_BYTESTRING:
  309. return fnv32(n->namespaceIndex, n->identifier.string.data, n->identifier.string.length);
  310. case UA_NODEIDTYPE_GUID:
  311. return fnv32(n->namespaceIndex, (const u8*)&n->identifier.guid, sizeof(UA_Guid));
  312. }
  313. }
  314. /* ExpandedNodeId */
  315. static void
  316. ExpandedNodeId_deleteMembers(UA_ExpandedNodeId *p, const UA_DataType *_) {
  317. NodeId_deleteMembers(&p->nodeId, _);
  318. String_deleteMembers(&p->namespaceUri, NULL);
  319. }
  320. static UA_StatusCode
  321. ExpandedNodeId_copy(UA_ExpandedNodeId const *src, UA_ExpandedNodeId *dst,
  322. const UA_DataType *_) {
  323. UA_StatusCode retval = NodeId_copy(&src->nodeId, &dst->nodeId, NULL);
  324. retval |= UA_String_copy(&src->namespaceUri, &dst->namespaceUri);
  325. dst->serverIndex = src->serverIndex;
  326. return retval;
  327. }
  328. /* ExtensionObject */
  329. static void
  330. ExtensionObject_deleteMembers(UA_ExtensionObject *p, const UA_DataType *_) {
  331. switch(p->encoding) {
  332. case UA_EXTENSIONOBJECT_ENCODED_NOBODY:
  333. case UA_EXTENSIONOBJECT_ENCODED_BYTESTRING:
  334. case UA_EXTENSIONOBJECT_ENCODED_XML:
  335. NodeId_deleteMembers(&p->content.encoded.typeId, NULL);
  336. String_deleteMembers(&p->content.encoded.body, NULL);
  337. break;
  338. case UA_EXTENSIONOBJECT_DECODED:
  339. if(p->content.decoded.data)
  340. UA_delete(p->content.decoded.data, p->content.decoded.type);
  341. break;
  342. default:
  343. break;
  344. }
  345. }
  346. static UA_StatusCode
  347. ExtensionObject_copy(UA_ExtensionObject const *src, UA_ExtensionObject *dst,
  348. const UA_DataType *_) {
  349. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  350. switch(src->encoding) {
  351. case UA_EXTENSIONOBJECT_ENCODED_NOBODY:
  352. case UA_EXTENSIONOBJECT_ENCODED_BYTESTRING:
  353. case UA_EXTENSIONOBJECT_ENCODED_XML:
  354. dst->encoding = src->encoding;
  355. retval = NodeId_copy(&src->content.encoded.typeId,
  356. &dst->content.encoded.typeId, NULL);
  357. retval |= UA_ByteString_copy(&src->content.encoded.body,
  358. &dst->content.encoded.body);
  359. break;
  360. case UA_EXTENSIONOBJECT_DECODED:
  361. case UA_EXTENSIONOBJECT_DECODED_NODELETE:
  362. if(!src->content.decoded.type || !src->content.decoded.data)
  363. return UA_STATUSCODE_BADINTERNALERROR;
  364. dst->encoding = UA_EXTENSIONOBJECT_DECODED;
  365. dst->content.decoded.type = src->content.decoded.type;
  366. retval = UA_Array_copy(src->content.decoded.data, 1,
  367. &dst->content.decoded.data, src->content.decoded.type);
  368. break;
  369. default:
  370. break;
  371. }
  372. return retval;
  373. }
  374. /* Variant */
  375. static void
  376. Variant_deletemembers(UA_Variant *p, const UA_DataType *_) {
  377. if(p->storageType != UA_VARIANT_DATA)
  378. return;
  379. if(p->type && p->data > UA_EMPTY_ARRAY_SENTINEL) {
  380. if(p->arrayLength == 0)
  381. p->arrayLength = 1;
  382. UA_Array_delete(p->data, p->arrayLength, p->type);
  383. }
  384. if((void*)p->arrayDimensions > UA_EMPTY_ARRAY_SENTINEL)
  385. UA_free(p->arrayDimensions);
  386. }
  387. static UA_StatusCode
  388. Variant_copy(UA_Variant const *src, UA_Variant *dst, const UA_DataType *_) {
  389. size_t length = src->arrayLength;
  390. if(UA_Variant_isScalar(src))
  391. length = 1;
  392. UA_StatusCode retval = UA_Array_copy(src->data, length,
  393. &dst->data, src->type);
  394. if(retval != UA_STATUSCODE_GOOD)
  395. return retval;
  396. dst->arrayLength = src->arrayLength;
  397. dst->type = src->type;
  398. if(src->arrayDimensions) {
  399. retval = UA_Array_copy(src->arrayDimensions, src->arrayDimensionsSize,
  400. (void**)&dst->arrayDimensions, &UA_TYPES[UA_TYPES_INT32]);
  401. if(retval != UA_STATUSCODE_GOOD)
  402. return retval;
  403. dst->arrayDimensionsSize = src->arrayDimensionsSize;
  404. }
  405. return UA_STATUSCODE_GOOD;
  406. }
  407. void
  408. UA_Variant_setScalar(UA_Variant *v, void * UA_RESTRICT p,
  409. const UA_DataType *type) {
  410. UA_Variant_init(v);
  411. v->type = type;
  412. v->arrayLength = 0;
  413. v->data = p;
  414. }
  415. UA_StatusCode
  416. UA_Variant_setScalarCopy(UA_Variant *v, const void *p,
  417. const UA_DataType *type) {
  418. void *n = UA_malloc(type->memSize);
  419. if(!n)
  420. return UA_STATUSCODE_BADOUTOFMEMORY;
  421. UA_StatusCode retval = UA_copy(p, n, type);
  422. if(retval != UA_STATUSCODE_GOOD) {
  423. UA_free(n);
  424. //cppcheck-suppress memleak
  425. return retval;
  426. }
  427. UA_Variant_setScalar(v, n, type);
  428. //cppcheck-suppress memleak
  429. return UA_STATUSCODE_GOOD;
  430. }
  431. void UA_Variant_setArray(UA_Variant *v, void * UA_RESTRICT array,
  432. size_t arraySize, const UA_DataType *type) {
  433. UA_Variant_init(v);
  434. v->data = array;
  435. v->arrayLength = arraySize;
  436. v->type = type;
  437. }
  438. UA_StatusCode
  439. UA_Variant_setArrayCopy(UA_Variant *v, const void *array,
  440. size_t arraySize, const UA_DataType *type) {
  441. UA_Variant_init(v);
  442. UA_StatusCode retval = UA_Array_copy(array, arraySize, &v->data, type);
  443. if(retval != UA_STATUSCODE_GOOD)
  444. return retval;
  445. v->arrayLength = arraySize;
  446. v->type = type;
  447. return UA_STATUSCODE_GOOD;
  448. }
  449. /* Test if a range is compatible with a variant. If yes, the following values
  450. * are set:
  451. * - total: how many elements are in the range
  452. * - block: how big is each contiguous block of elements in the variant that
  453. * maps into the range
  454. * - stride: how many elements are between the blocks (beginning to beginning)
  455. * - first: where does the first block begin */
  456. static UA_StatusCode
  457. computeStrides(const UA_Variant *v, const UA_NumericRange range,
  458. size_t *total, size_t *block, size_t *stride, size_t *first) {
  459. /* Test for max array size (64bit only) */
  460. #if (SIZE_MAX > 0xffffffff)
  461. if(v->arrayLength > UA_UINT32_MAX)
  462. return UA_STATUSCODE_BADINTERNALERROR;
  463. #endif
  464. /* Test the integrity of the source variant dimensions, make dimensions
  465. * vector of one dimension if none defined */
  466. u32 arrayLength = (u32)v->arrayLength;
  467. const u32 *dims = &arrayLength;
  468. size_t dims_count = 1;
  469. if(v->arrayDimensionsSize > 0) {
  470. size_t elements = 1;
  471. dims_count = v->arrayDimensionsSize;
  472. dims = (u32*)v->arrayDimensions;
  473. for(size_t i = 0; i < dims_count; ++i)
  474. elements *= dims[i];
  475. if(elements != v->arrayLength)
  476. return UA_STATUSCODE_BADINTERNALERROR;
  477. }
  478. UA_assert(dims_count > 0);
  479. /* Test the integrity of the range and compute the max index used for every
  480. * dimension. The standard says in Part 4, Section 7.22:
  481. *
  482. * When reading a value, the indexes may not specify a range that is within
  483. * the bounds of the array. The Server shall return a partial result if some
  484. * elements exist within the range. */
  485. size_t count = 1;
  486. UA_UInt32 *realmax = (UA_UInt32*)UA_alloca(sizeof(UA_UInt32) * dims_count);
  487. if(range.dimensionsSize != dims_count)
  488. return UA_STATUSCODE_BADINDEXRANGENODATA;
  489. for(size_t i = 0; i < dims_count; ++i) {
  490. if(range.dimensions[i].min > range.dimensions[i].max)
  491. return UA_STATUSCODE_BADINDEXRANGEINVALID;
  492. if(range.dimensions[i].min >= dims[i])
  493. return UA_STATUSCODE_BADINDEXRANGENODATA;
  494. if(range.dimensions[i].max < dims[i])
  495. realmax[i] = range.dimensions[i].max;
  496. else
  497. realmax[i] = dims[i] - 1;
  498. count *= (realmax[i] - range.dimensions[i].min) + 1;
  499. }
  500. *total = count;
  501. /* Compute the stride length and the position of the first element */
  502. *block = count; /* Assume the range describes the entire array. */
  503. *stride = v->arrayLength; /* So it can be copied as a contiguous block. */
  504. *first = 0;
  505. size_t running_dimssize = 1;
  506. bool found_contiguous = false;
  507. for(size_t k = dims_count; k > 0;) {
  508. --k;
  509. size_t dimrange = 1 + realmax[k] - range.dimensions[k].min;
  510. if(!found_contiguous && dimrange != dims[k]) {
  511. /* Found the maximum block that can be copied contiguously */
  512. found_contiguous = true;
  513. *block = running_dimssize * dimrange;
  514. *stride = running_dimssize * dims[k];
  515. }
  516. *first += running_dimssize * range.dimensions[k].min;
  517. running_dimssize *= dims[k];
  518. }
  519. return UA_STATUSCODE_GOOD;
  520. }
  521. /* Is the type string-like? */
  522. static bool
  523. isStringLike(const UA_DataType *type) {
  524. if(type->membersSize == 1 && type->members[0].isArray &&
  525. type->members[0].namespaceZero &&
  526. type->members[0].memberTypeIndex == UA_TYPES_BYTE)
  527. return true;
  528. return false;
  529. }
  530. /* Returns the part of the string that lies within the rangedimension */
  531. static UA_StatusCode
  532. copySubString(const UA_String *src, UA_String *dst,
  533. const UA_NumericRangeDimension *dim) {
  534. if(dim->min > dim->max)
  535. return UA_STATUSCODE_BADINDEXRANGEINVALID;
  536. if(dim->min >= src->length)
  537. return UA_STATUSCODE_BADINDEXRANGENODATA;
  538. size_t length;
  539. if(dim->max < src->length)
  540. length = dim->max - dim->min + 1;
  541. else
  542. length = src->length - dim->min;
  543. UA_StatusCode retval = UA_ByteString_allocBuffer(dst, length);
  544. if(retval != UA_STATUSCODE_GOOD)
  545. return retval;
  546. memcpy(dst->data, &src->data[dim->min], length);
  547. return UA_STATUSCODE_GOOD;
  548. }
  549. UA_StatusCode
  550. UA_Variant_copyRange(const UA_Variant *src, UA_Variant *dst,
  551. const UA_NumericRange range) {
  552. if(!src->type)
  553. return UA_STATUSCODE_BADINVALIDARGUMENT;
  554. bool isScalar = UA_Variant_isScalar(src);
  555. bool stringLike = isStringLike(src->type);
  556. UA_Variant arraySrc;
  557. /* Extract the range for copying at this level. The remaining range is dealt
  558. * with in the "scalar" type that may define an array by itself (string,
  559. * variant, ...). */
  560. UA_NumericRange thisrange, nextrange;
  561. UA_NumericRangeDimension scalarThisDimension = {0,0}; /* a single entry */
  562. if(isScalar) {
  563. /* Replace scalar src with array of length 1 */
  564. arraySrc = *src;
  565. arraySrc.arrayLength = 1;
  566. src = &arraySrc;
  567. /* Deal with all range dimensions within the scalar */
  568. thisrange.dimensions = &scalarThisDimension;
  569. thisrange.dimensionsSize = 1;
  570. nextrange = range;
  571. } else {
  572. /* Deal with as many range dimensions as possible right now */
  573. size_t dims = src->arrayDimensionsSize;
  574. if(dims == 0)
  575. dims = 1;
  576. if(dims > range.dimensionsSize)
  577. return UA_STATUSCODE_BADINDEXRANGEINVALID;
  578. thisrange = range;
  579. thisrange.dimensionsSize = dims;
  580. nextrange.dimensions = &range.dimensions[dims];
  581. nextrange.dimensionsSize = range.dimensionsSize - dims;
  582. }
  583. /* Compute the strides */
  584. size_t count, block, stride, first;
  585. UA_StatusCode retval = computeStrides(src, thisrange, &count,
  586. &block, &stride, &first);
  587. if(retval != UA_STATUSCODE_GOOD)
  588. return retval;
  589. /* Allocate the array */
  590. UA_Variant_init(dst);
  591. dst->data = UA_Array_new(count, src->type);
  592. if(!dst->data)
  593. return UA_STATUSCODE_BADOUTOFMEMORY;
  594. /* Copy the range */
  595. size_t block_count = count / block;
  596. size_t elem_size = src->type->memSize;
  597. uintptr_t nextdst = (uintptr_t)dst->data;
  598. uintptr_t nextsrc = (uintptr_t)src->data + (elem_size * first);
  599. if(nextrange.dimensionsSize == 0) {
  600. /* no nextrange */
  601. if(src->type->pointerFree) {
  602. for(size_t i = 0; i < block_count; ++i) {
  603. memcpy((void*)nextdst, (void*)nextsrc, elem_size * block);
  604. nextdst += block * elem_size;
  605. nextsrc += stride * elem_size;
  606. }
  607. } else {
  608. for(size_t i = 0; i < block_count; ++i) {
  609. for(size_t j = 0; j < block; ++j) {
  610. retval = UA_copy((const void*)nextsrc,
  611. (void*)nextdst, src->type);
  612. nextdst += elem_size;
  613. nextsrc += elem_size;
  614. }
  615. nextsrc += (stride - block) * elem_size;
  616. }
  617. }
  618. } else {
  619. /* nextrange can only be used for variants and stringlike with remaining
  620. * range of dimension 1 */
  621. if(src->type != &UA_TYPES[UA_TYPES_VARIANT]) {
  622. if(!stringLike)
  623. retval = UA_STATUSCODE_BADINDEXRANGENODATA;
  624. if(nextrange.dimensionsSize != 1)
  625. retval = UA_STATUSCODE_BADINDEXRANGENODATA;
  626. }
  627. /* Copy the content */
  628. for(size_t i = 0; i < block_count; ++i) {
  629. for(size_t j = 0; j < block && retval == UA_STATUSCODE_GOOD; ++j) {
  630. if(stringLike)
  631. retval = copySubString((const UA_String*)nextsrc,
  632. (UA_String*)nextdst,
  633. nextrange.dimensions);
  634. else
  635. retval = UA_Variant_copyRange((const UA_Variant*)nextsrc,
  636. (UA_Variant*)nextdst,
  637. nextrange);
  638. nextdst += elem_size;
  639. nextsrc += elem_size;
  640. }
  641. nextsrc += (stride - block) * elem_size;
  642. }
  643. }
  644. /* Clean up if copying failed */
  645. if(retval != UA_STATUSCODE_GOOD) {
  646. UA_Array_delete(dst->data, count, src->type);
  647. dst->data = NULL;
  648. return retval;
  649. }
  650. /* Done if scalar */
  651. dst->type = src->type;
  652. if(isScalar)
  653. return retval;
  654. /* Copy array dimensions */
  655. dst->arrayLength = count;
  656. if(src->arrayDimensionsSize > 0) {
  657. dst->arrayDimensions =
  658. (u32*)UA_Array_new(thisrange.dimensionsSize, &UA_TYPES[UA_TYPES_UINT32]);
  659. if(!dst->arrayDimensions) {
  660. Variant_deletemembers(dst, NULL);
  661. return UA_STATUSCODE_BADOUTOFMEMORY;
  662. }
  663. dst->arrayDimensionsSize = thisrange.dimensionsSize;
  664. for(size_t k = 0; k < thisrange.dimensionsSize; ++k)
  665. dst->arrayDimensions[k] =
  666. thisrange.dimensions[k].max - thisrange.dimensions[k].min + 1;
  667. }
  668. return UA_STATUSCODE_GOOD;
  669. }
  670. /* TODO: Allow ranges to reach inside a scalars that are array-like, e.g.
  671. * variant and strings. This is already possible for reading... */
  672. static UA_StatusCode
  673. Variant_setRange(UA_Variant *v, void *array, size_t arraySize,
  674. const UA_NumericRange range, bool copy) {
  675. /* Compute the strides */
  676. size_t count, block, stride, first;
  677. UA_StatusCode retval = computeStrides(v, range, &count,
  678. &block, &stride, &first);
  679. if(retval != UA_STATUSCODE_GOOD)
  680. return retval;
  681. if(count != arraySize)
  682. return UA_STATUSCODE_BADINDEXRANGEINVALID;
  683. /* Move/copy the elements */
  684. size_t block_count = count / block;
  685. size_t elem_size = v->type->memSize;
  686. uintptr_t nextdst = (uintptr_t)v->data + (first * elem_size);
  687. uintptr_t nextsrc = (uintptr_t)array;
  688. if(v->type->pointerFree || !copy) {
  689. for(size_t i = 0; i < block_count; ++i) {
  690. memcpy((void*)nextdst, (void*)nextsrc, elem_size * block);
  691. nextsrc += block * elem_size;
  692. nextdst += stride * elem_size;
  693. }
  694. } else {
  695. for(size_t i = 0; i < block_count; ++i) {
  696. for(size_t j = 0; j < block; ++j) {
  697. deleteMembers_noInit((void*)nextdst, v->type);
  698. retval |= UA_copy((void*)nextsrc, (void*)nextdst, v->type);
  699. nextdst += elem_size;
  700. nextsrc += elem_size;
  701. }
  702. nextdst += (stride - block) * elem_size;
  703. }
  704. }
  705. /* If members were moved, initialize original array to prevent reuse */
  706. if(!copy && !v->type->pointerFree)
  707. memset(array, 0, sizeof(elem_size)*arraySize);
  708. return retval;
  709. }
  710. UA_StatusCode
  711. UA_Variant_setRange(UA_Variant *v, void * UA_RESTRICT array,
  712. size_t arraySize, const UA_NumericRange range) {
  713. return Variant_setRange(v, array, arraySize, range, false);
  714. }
  715. UA_StatusCode
  716. UA_Variant_setRangeCopy(UA_Variant *v, const void *array,
  717. size_t arraySize, const UA_NumericRange range) {
  718. return Variant_setRange(v, (void*)(uintptr_t)array,
  719. arraySize, range, true);
  720. }
  721. /* LocalizedText */
  722. static void
  723. LocalizedText_deleteMembers(UA_LocalizedText *p, const UA_DataType *_) {
  724. String_deleteMembers(&p->locale, NULL);
  725. String_deleteMembers(&p->text, NULL);
  726. }
  727. static UA_StatusCode
  728. LocalizedText_copy(UA_LocalizedText const *src, UA_LocalizedText *dst,
  729. const UA_DataType *_) {
  730. UA_StatusCode retval = UA_String_copy(&src->locale, &dst->locale);
  731. retval |= UA_String_copy(&src->text, &dst->text);
  732. return retval;
  733. }
  734. /* DataValue */
  735. static void
  736. DataValue_deleteMembers(UA_DataValue *p, const UA_DataType *_) {
  737. Variant_deletemembers(&p->value, NULL);
  738. }
  739. static UA_StatusCode
  740. DataValue_copy(UA_DataValue const *src, UA_DataValue *dst,
  741. const UA_DataType *_) {
  742. memcpy(dst, src, sizeof(UA_DataValue));
  743. UA_Variant_init(&dst->value);
  744. UA_StatusCode retval = Variant_copy(&src->value, &dst->value, NULL);
  745. if(retval != UA_STATUSCODE_GOOD)
  746. DataValue_deleteMembers(dst, NULL);
  747. return retval;
  748. }
  749. /* DiagnosticInfo */
  750. static void
  751. DiagnosticInfo_deleteMembers(UA_DiagnosticInfo *p, const UA_DataType *_) {
  752. String_deleteMembers(&p->additionalInfo, NULL);
  753. if(p->hasInnerDiagnosticInfo && p->innerDiagnosticInfo) {
  754. DiagnosticInfo_deleteMembers(p->innerDiagnosticInfo, NULL);
  755. UA_free(p->innerDiagnosticInfo);
  756. }
  757. }
  758. static UA_StatusCode
  759. DiagnosticInfo_copy(UA_DiagnosticInfo const *src, UA_DiagnosticInfo *dst,
  760. const UA_DataType *_) {
  761. memcpy(dst, src, sizeof(UA_DiagnosticInfo));
  762. UA_String_init(&dst->additionalInfo);
  763. dst->innerDiagnosticInfo = NULL;
  764. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  765. if(src->hasAdditionalInfo)
  766. retval = UA_String_copy(&src->additionalInfo, &dst->additionalInfo);
  767. if(src->hasInnerDiagnosticInfo && src->innerDiagnosticInfo) {
  768. dst->innerDiagnosticInfo = (UA_DiagnosticInfo*)UA_malloc(sizeof(UA_DiagnosticInfo));
  769. if(dst->innerDiagnosticInfo) {
  770. retval |= DiagnosticInfo_copy(src->innerDiagnosticInfo,
  771. dst->innerDiagnosticInfo, NULL);
  772. dst->hasInnerDiagnosticInfo = true;
  773. } else {
  774. dst->hasInnerDiagnosticInfo = false;
  775. retval |= UA_STATUSCODE_BADOUTOFMEMORY;
  776. }
  777. }
  778. return retval;
  779. }
  780. /********************/
  781. /* Structured Types */
  782. /********************/
  783. void *
  784. UA_new(const UA_DataType *type) {
  785. void *p = UA_calloc(1, type->memSize);
  786. return p;
  787. }
  788. static UA_StatusCode
  789. copyByte(const u8 *src, u8 *dst, const UA_DataType *_) {
  790. *dst = *src;
  791. return UA_STATUSCODE_GOOD;
  792. }
  793. static UA_StatusCode
  794. copy2Byte(const u16 *src, u16 *dst, const UA_DataType *_) {
  795. *dst = *src;
  796. return UA_STATUSCODE_GOOD;
  797. }
  798. static UA_StatusCode
  799. copy4Byte(const u32 *src, u32 *dst, const UA_DataType *_) {
  800. *dst = *src;
  801. return UA_STATUSCODE_GOOD;
  802. }
  803. static UA_StatusCode
  804. copy8Byte(const u64 *src, u64 *dst, const UA_DataType *_) {
  805. *dst = *src;
  806. return UA_STATUSCODE_GOOD;
  807. }
  808. static UA_StatusCode
  809. copyGuid(const UA_Guid *src, UA_Guid *dst, const UA_DataType *_) {
  810. *dst = *src;
  811. return UA_STATUSCODE_GOOD;
  812. }
  813. typedef UA_StatusCode
  814. (*UA_copySignature)(const void *src, void *dst, const UA_DataType *type);
  815. static const UA_copySignature copyJumpTable[UA_BUILTIN_TYPES_COUNT + 1] = {
  816. (UA_copySignature)copyByte, // Boolean
  817. (UA_copySignature)copyByte, // SByte
  818. (UA_copySignature)copyByte, // Byte
  819. (UA_copySignature)copy2Byte, // Int16
  820. (UA_copySignature)copy2Byte, // UInt16
  821. (UA_copySignature)copy4Byte, // Int32
  822. (UA_copySignature)copy4Byte, // UInt32
  823. (UA_copySignature)copy8Byte, // Int64
  824. (UA_copySignature)copy8Byte, // UInt64
  825. (UA_copySignature)copy4Byte, // Float
  826. (UA_copySignature)copy8Byte, // Double
  827. (UA_copySignature)copy_noInit, // String
  828. (UA_copySignature)copy8Byte, // DateTime
  829. (UA_copySignature)copyGuid, // Guid
  830. (UA_copySignature)copy_noInit, // ByteString
  831. (UA_copySignature)copy_noInit, // XmlElement
  832. (UA_copySignature)NodeId_copy,
  833. (UA_copySignature)ExpandedNodeId_copy,
  834. (UA_copySignature)copy4Byte, // StatusCode
  835. (UA_copySignature)copy_noInit, // QualifiedName
  836. (UA_copySignature)LocalizedText_copy, // LocalizedText
  837. (UA_copySignature)ExtensionObject_copy,
  838. (UA_copySignature)DataValue_copy,
  839. (UA_copySignature)Variant_copy,
  840. (UA_copySignature)DiagnosticInfo_copy,
  841. (UA_copySignature)copy_noInit // all others
  842. };
  843. static UA_StatusCode
  844. copy_noInit(const void *src, void *dst, const UA_DataType *type) {
  845. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  846. uintptr_t ptrs = (uintptr_t)src;
  847. uintptr_t ptrd = (uintptr_t)dst;
  848. u8 membersSize = type->membersSize;
  849. for(size_t i = 0; i < membersSize; ++i) {
  850. const UA_DataTypeMember *m= &type->members[i];
  851. const UA_DataType *typelists[2] = { UA_TYPES, &type[-type->typeIndex] };
  852. const UA_DataType *mt = &typelists[!m->namespaceZero][m->memberTypeIndex];
  853. if(!m->isArray) {
  854. ptrs += m->padding;
  855. ptrd += m->padding;
  856. size_t fi = mt->builtin ? mt->typeIndex : UA_BUILTIN_TYPES_COUNT;
  857. retval |= copyJumpTable[fi]((const void*)ptrs, (void*)ptrd, mt);
  858. ptrs += mt->memSize;
  859. ptrd += mt->memSize;
  860. } else {
  861. ptrs += m->padding;
  862. ptrd += m->padding;
  863. size_t *dst_size = (size_t*)ptrd;
  864. const size_t size = *((const size_t*)ptrs);
  865. ptrs += sizeof(size_t);
  866. ptrd += sizeof(size_t);
  867. retval |= UA_Array_copy(*(void* const*)ptrs, size, (void**)ptrd, mt);
  868. if(retval == UA_STATUSCODE_GOOD)
  869. *dst_size = size;
  870. else
  871. *dst_size = 0;
  872. ptrs += sizeof(void*);
  873. ptrd += sizeof(void*);
  874. }
  875. }
  876. return retval;
  877. }
  878. UA_StatusCode
  879. UA_copy(const void *src, void *dst, const UA_DataType *type) {
  880. memset(dst, 0, type->memSize); /* init */
  881. UA_StatusCode retval = copy_noInit(src, dst, type);
  882. if(retval != UA_STATUSCODE_GOOD)
  883. UA_deleteMembers(dst, type);
  884. return retval;
  885. }
  886. static void nopDeleteMembers(void *p, const UA_DataType *type) { }
  887. typedef void (*UA_deleteMembersSignature)(void *p, const UA_DataType *type);
  888. static const
  889. UA_deleteMembersSignature deleteMembersJumpTable[UA_BUILTIN_TYPES_COUNT + 1] = {
  890. (UA_deleteMembersSignature)nopDeleteMembers, // Boolean
  891. (UA_deleteMembersSignature)nopDeleteMembers, // SByte
  892. (UA_deleteMembersSignature)nopDeleteMembers, // Byte
  893. (UA_deleteMembersSignature)nopDeleteMembers, // Int16
  894. (UA_deleteMembersSignature)nopDeleteMembers, // UInt16
  895. (UA_deleteMembersSignature)nopDeleteMembers, // Int32
  896. (UA_deleteMembersSignature)nopDeleteMembers, // UInt32
  897. (UA_deleteMembersSignature)nopDeleteMembers, // Int64
  898. (UA_deleteMembersSignature)nopDeleteMembers, // UInt64
  899. (UA_deleteMembersSignature)nopDeleteMembers, // Float
  900. (UA_deleteMembersSignature)nopDeleteMembers, // Double
  901. (UA_deleteMembersSignature)String_deleteMembers, // String
  902. (UA_deleteMembersSignature)nopDeleteMembers, // DateTime
  903. (UA_deleteMembersSignature)nopDeleteMembers, // Guid
  904. (UA_deleteMembersSignature)String_deleteMembers, // ByteString
  905. (UA_deleteMembersSignature)String_deleteMembers, // XmlElement
  906. (UA_deleteMembersSignature)NodeId_deleteMembers,
  907. (UA_deleteMembersSignature)ExpandedNodeId_deleteMembers, // ExpandedNodeId
  908. (UA_deleteMembersSignature)nopDeleteMembers, // StatusCode
  909. (UA_deleteMembersSignature)deleteMembers_noInit, // QualifiedName
  910. (UA_deleteMembersSignature)LocalizedText_deleteMembers, // LocalizedText
  911. (UA_deleteMembersSignature)ExtensionObject_deleteMembers,
  912. (UA_deleteMembersSignature)DataValue_deleteMembers,
  913. (UA_deleteMembersSignature)Variant_deletemembers,
  914. (UA_deleteMembersSignature)DiagnosticInfo_deleteMembers,
  915. (UA_deleteMembersSignature)deleteMembers_noInit,
  916. };
  917. static void
  918. deleteMembers_noInit(void *p, const UA_DataType *type) {
  919. uintptr_t ptr = (uintptr_t)p;
  920. u8 membersSize = type->membersSize;
  921. for(size_t i = 0; i < membersSize; ++i) {
  922. const UA_DataTypeMember *m= &type->members[i];
  923. const UA_DataType *typelists[2] = { UA_TYPES, &type[-type->typeIndex] };
  924. const UA_DataType *mt = &typelists[!m->namespaceZero][m->memberTypeIndex];
  925. if(!m->isArray) {
  926. ptr += m->padding;
  927. size_t fi = mt->builtin ? mt->typeIndex : UA_BUILTIN_TYPES_COUNT;
  928. deleteMembersJumpTable[fi]((void*)ptr, mt);
  929. ptr += mt->memSize;
  930. } else {
  931. ptr += m->padding;
  932. size_t length = *(size_t*)ptr;
  933. ptr += sizeof(size_t);
  934. UA_Array_delete(*(void**)ptr, length, mt);
  935. ptr += sizeof(void*);
  936. }
  937. }
  938. }
  939. void
  940. UA_deleteMembers(void *p, const UA_DataType *type) {
  941. deleteMembers_noInit(p, type);
  942. memset(p, 0, type->memSize); /* init */
  943. }
  944. void
  945. UA_delete(void *p, const UA_DataType *type) {
  946. deleteMembers_noInit(p, type);
  947. UA_free(p);
  948. }
  949. /******************/
  950. /* Array Handling */
  951. /******************/
  952. void *
  953. UA_Array_new(size_t size, const UA_DataType *type) {
  954. if(size > UA_INT32_MAX)
  955. return NULL;
  956. if(size == 0)
  957. return UA_EMPTY_ARRAY_SENTINEL;
  958. return UA_calloc(size, type->memSize);
  959. }
  960. UA_StatusCode
  961. UA_Array_copy(const void *src, size_t size,
  962. void **dst, const UA_DataType *type) {
  963. if(size == 0) {
  964. if(src == NULL)
  965. *dst = NULL;
  966. else
  967. *dst= UA_EMPTY_ARRAY_SENTINEL;
  968. return UA_STATUSCODE_GOOD;
  969. }
  970. if(!type)
  971. return UA_STATUSCODE_BADINTERNALERROR;
  972. /* calloc, so we don't have to check retval in every iteration of copying */
  973. *dst = UA_calloc(size, type->memSize);
  974. if(!*dst)
  975. return UA_STATUSCODE_BADOUTOFMEMORY;
  976. if(type->pointerFree) {
  977. memcpy(*dst, src, type->memSize * size);
  978. return UA_STATUSCODE_GOOD;
  979. }
  980. uintptr_t ptrs = (uintptr_t)src;
  981. uintptr_t ptrd = (uintptr_t)*dst;
  982. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  983. for(size_t i = 0; i < size; ++i) {
  984. retval |= UA_copy((void*)ptrs, (void*)ptrd, type);
  985. ptrs += type->memSize;
  986. ptrd += type->memSize;
  987. }
  988. if(retval != UA_STATUSCODE_GOOD) {
  989. UA_Array_delete(*dst, size, type);
  990. *dst = NULL;
  991. }
  992. return retval;
  993. }
  994. void
  995. UA_Array_delete(void *p, size_t size, const UA_DataType *type) {
  996. if(!type->pointerFree) {
  997. uintptr_t ptr = (uintptr_t)p;
  998. for(size_t i = 0; i < size; ++i) {
  999. UA_deleteMembers((void*)ptr, type);
  1000. ptr += type->memSize;
  1001. }
  1002. }
  1003. UA_free((void*)((uintptr_t)p & ~(uintptr_t)UA_EMPTY_ARRAY_SENTINEL));
  1004. }