ua_types.c 35 KB

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