ua_types.c 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882
  1. #include <stdio.h> // printf
  2. #include <stdlib.h> // alloc, free, vsnprintf
  3. #include <string.h>
  4. #include <stdarg.h> // va_start, va_end
  5. #include <time.h>
  6. #include <sys/time.h>
  7. #include "util/ua_util.h"
  8. #include "ua_types.h"
  9. #include "ua_types_encoding_binary.h"
  10. #include "ua_namespace_0.h"
  11. /************/
  12. /* Built-In */
  13. /************/
  14. /* Boolean */
  15. UA_Int32 UA_Boolean_init(UA_Boolean *p) {
  16. if(p == UA_NULL) return UA_ERROR;
  17. *p = UA_FALSE;
  18. return UA_SUCCESS;
  19. }
  20. UA_TYPE_DELETE_DEFAULT(UA_Boolean)
  21. UA_TYPE_DELETEMEMBERS_NOACTION(UA_Boolean)
  22. UA_TYPE_NEW_DEFAULT(UA_Boolean)
  23. UA_TYPE_COPY_DEFAULT(UA_Boolean)
  24. /* SByte */
  25. UA_TYPE_DEFAULT(UA_SByte)
  26. /* Byte */
  27. UA_TYPE_DEFAULT(UA_Byte)
  28. /* Int16 */
  29. UA_TYPE_DEFAULT(UA_Int16)
  30. /* UInt16 */
  31. UA_TYPE_DEFAULT(UA_UInt16)
  32. /* Int32 */
  33. UA_TYPE_DEFAULT(UA_Int32)
  34. /* UInt32 */
  35. UA_TYPE_DEFAULT(UA_UInt32)
  36. /* Int64 */
  37. UA_TYPE_DEFAULT(UA_Int64)
  38. /* UInt64 */
  39. UA_TYPE_DEFAULT(UA_UInt64)
  40. /* Float */
  41. UA_TYPE_DELETE_DEFAULT(UA_Float)
  42. UA_TYPE_DELETEMEMBERS_NOACTION(UA_Float)
  43. UA_Int32 UA_Float_init(UA_Float *p) {
  44. if(p == UA_NULL) return UA_ERROR;
  45. *p = (UA_Float)0.0;
  46. return UA_SUCCESS;
  47. }
  48. UA_TYPE_NEW_DEFAULT(UA_Float)
  49. UA_TYPE_COPY_DEFAULT(UA_Float)
  50. /* Double */
  51. UA_TYPE_DEFAULT(UA_Double)
  52. /* String */
  53. UA_TYPE_NEW_DEFAULT(UA_String)
  54. UA_TYPE_DELETE_DEFAULT(UA_String)
  55. UA_Int32 UA_String_deleteMembers(UA_String *p) {
  56. UA_Int32 retval = UA_SUCCESS;
  57. if(p!= UA_NULL && p->data != UA_NULL) {
  58. retval |= UA_free(p->data);
  59. p->data = UA_NULL;
  60. p->length = -1;
  61. }
  62. return retval;
  63. }
  64. UA_Int32 UA_String_copy(UA_String const *src, UA_String *dst) {
  65. if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
  66. UA_Int32 retval = UA_SUCCESS;
  67. dst->data = UA_NULL;
  68. dst->length = -1;
  69. if(src->length > 0) {
  70. retval |= UA_alloc((void **)&dst->data, src->length);
  71. if(retval == UA_SUCCESS) {
  72. retval |= UA_memcpy((void *)dst->data, src->data, src->length);
  73. dst->length = src->length;
  74. }
  75. }
  76. return retval;
  77. }
  78. UA_Int32 UA_String_copycstring(char const *src, UA_String *dst) {
  79. UA_Int32 retval = UA_SUCCESS;
  80. dst->length = strlen(src);
  81. dst->data = UA_NULL;
  82. if(dst->length > 0) {
  83. retval |= UA_alloc((void **)&dst->data, dst->length);
  84. if(retval == UA_SUCCESS)
  85. retval |= UA_memcpy((void *)dst->data, src, dst->length);
  86. }
  87. return retval;
  88. }
  89. #define UA_STRING_COPYPRINTF_BUFSIZE 1024
  90. UA_Int32 UA_String_copyprintf(char const *fmt, UA_String *dst, ...) {
  91. UA_Int32 retval = UA_SUCCESS;
  92. char src[UA_STRING_COPYPRINTF_BUFSIZE];
  93. UA_Int32 len;
  94. va_list ap;
  95. va_start(ap, dst);
  96. #pragma GCC diagnostic push
  97. #pragma GCC diagnostic ignored "-Wformat-nonliteral"
  98. // vsnprintf should only take a literal and no variable to be secure
  99. len = vsnprintf(src, UA_STRING_COPYPRINTF_BUFSIZE, fmt, ap);
  100. #pragma GCC diagnostic pop
  101. va_end(ap);
  102. if(len < 0) { // FIXME: old glibc 2.0 would return -1 when truncated
  103. dst->length = 0;
  104. dst->data = UA_NULL;
  105. retval = UA_ERR_INVALID_VALUE;
  106. } else {
  107. // since glibc 2.1 vsnprintf returns len that would have resulted if buf were large enough
  108. dst->length = ( len > UA_STRING_COPYPRINTF_BUFSIZE ? UA_STRING_COPYPRINTF_BUFSIZE : len );
  109. retval |= UA_alloc((void **)&dst->data, dst->length);
  110. if(retval == UA_SUCCESS)
  111. retval |= UA_memcpy((void *)dst->data, src, dst->length);
  112. }
  113. return retval;
  114. }
  115. UA_Int32 UA_String_init(UA_String *p) {
  116. if(p == UA_NULL) return UA_ERROR;
  117. p->length = -1;
  118. p->data = UA_NULL;
  119. return UA_SUCCESS;
  120. }
  121. UA_Int32 UA_String_equal(const UA_String *string1, const UA_String *string2) {
  122. UA_Int32 retval;
  123. if(string1->length == 0 && string2->length == 0)
  124. retval = UA_EQUAL;
  125. else if(string1->length == -1 && string2->length == -1)
  126. retval = UA_EQUAL;
  127. else if(string1->length != string2->length)
  128. retval = UA_NOT_EQUAL;
  129. else {
  130. // casts are needed to overcome signed warnings
  131. UA_Int32 is = strncmp((char const *)string1->data, (char const *)string2->data, string1->length);
  132. retval = (is == 0) ? UA_EQUAL : UA_NOT_EQUAL;
  133. }
  134. return retval;
  135. }
  136. void UA_String_printf(char const *label, const UA_String *string) {
  137. printf("%s {Length=%d, Data=%.*s}\n", label, string->length,
  138. string->length, (char *)string->data);
  139. }
  140. void UA_String_printx(char const *label, const UA_String *string) {
  141. if(string == UA_NULL) {
  142. printf("%s {NULL}\n", label); return;
  143. }
  144. printf("%s {Length=%d, Data=", label, string->length);
  145. if(string->length > 0) {
  146. for(UA_Int32 i = 0;i < string->length;i++) {
  147. printf("%c%d", i == 0 ? '{' : ',', (string->data)[i]);
  148. // if (i > 0 && !(i%20)) { printf("\n\t"); }
  149. }
  150. } else
  151. printf("{");
  152. printf("}}\n");
  153. }
  154. void UA_String_printx_hex(char const *label, const UA_String *string) {
  155. printf("%s {Length=%d, Data=", label, string->length);
  156. if(string->length > 0) {
  157. for(UA_Int32 i = 0;i < string->length;i++)
  158. printf("%c%x", i == 0 ? '{' : ',', (string->data)[i]);
  159. } else
  160. printf("{");
  161. printf("}}\n");
  162. }
  163. /* DateTime */
  164. UA_TYPE_AS(UA_DateTime, UA_Int64)
  165. // Number of seconds from 1 Jan. 1601 00:00 to 1 Jan 1970 00:00 UTC
  166. #define FILETIME_UNIXTIME_BIAS_SEC 11644473600LL
  167. // Factors
  168. #define HUNDRED_NANOSEC_PER_USEC 10LL
  169. #define HUNDRED_NANOSEC_PER_SEC (HUNDRED_NANOSEC_PER_USEC * 1000000LL)
  170. // IEC 62541-6 §5.2.2.5 A DateTime value shall be encoded as a 64-bit signed integer
  171. // which represents the number of 100 nanosecond intervals since January 1, 1601 (UTC).
  172. UA_DateTime UA_DateTime_now() {
  173. UA_DateTime dateTime;
  174. struct timeval tv;
  175. gettimeofday(&tv, UA_NULL);
  176. dateTime = (tv.tv_sec + FILETIME_UNIXTIME_BIAS_SEC)
  177. * HUNDRED_NANOSEC_PER_SEC + tv.tv_usec * HUNDRED_NANOSEC_PER_USEC;
  178. return dateTime;
  179. }
  180. UA_DateTimeStruct UA_DateTime_toStruct(UA_DateTime time) {
  181. UA_DateTimeStruct dateTimeStruct;
  182. //calcualting the the milli-, micro- and nanoseconds
  183. UA_DateTime timeTemp;
  184. timeTemp = (time-((time/10)*10))*100; //getting the last digit -> *100 for the 100 nanaseconds resolution
  185. dateTimeStruct.nanoSec = timeTemp; //123 456 7 -> 700 nanosec;
  186. timeTemp = (time-((time/10000)*10000))/10;
  187. dateTimeStruct.microSec = timeTemp; //123 456 7 -> 456 microsec
  188. timeTemp = (time-((time/10000000)*10000000))/10000;
  189. dateTimeStruct.milliSec = timeTemp; //123 456 7 -> 123 millisec
  190. //calculating the unix time with #include <time.h>
  191. time_t timeInSec = time/10000000; //converting the nanoseconds time in unixtime
  192. struct tm ts;
  193. ts = *gmtime(&timeInSec);
  194. //strftime(buf, sizeof(buf), "%a %Y-%m-%d %H:%M:%S %Z", &ts);
  195. //printf("%s\n", buf);
  196. dateTimeStruct.sec = ts.tm_sec;
  197. dateTimeStruct.min = ts.tm_min;
  198. dateTimeStruct.hour = ts.tm_hour;
  199. dateTimeStruct.day = ts.tm_mday;
  200. dateTimeStruct.mounth = ts.tm_mon+1;
  201. dateTimeStruct.year = ts.tm_year + 1900;
  202. return dateTimeStruct;
  203. }
  204. UA_Int32 UA_DateTime_toString(UA_DateTime time, UA_String *timeString) {
  205. char *charBuf = (char *)(*timeString).data;
  206. UA_DateTimeStruct tSt = UA_DateTime_toStruct(time);
  207. sprintf(charBuf, "%2d/%2d/%4d %2d:%2d:%2d.%3d.%3d.%3d", tSt.mounth, tSt.day, tSt.year,
  208. tSt.hour, tSt.min, tSt.sec, tSt.milliSec, tSt.microSec, tSt.nanoSec);
  209. return UA_SUCCESS;
  210. }
  211. /* Guid */
  212. UA_TYPE_DELETE_DEFAULT(UA_Guid)
  213. UA_Int32 UA_Guid_deleteMembers(UA_Guid *p) {
  214. return UA_SUCCESS;
  215. }
  216. UA_Int32 UA_Guid_equal(const UA_Guid *g1, const UA_Guid *g2) {
  217. return memcmp(g1, g2, sizeof(UA_Guid));
  218. }
  219. UA_Int32 UA_Guid_init(UA_Guid *p) {
  220. if(p == UA_NULL) return UA_ERROR;
  221. p->data1 = 0;
  222. p->data2 = 0;
  223. p->data3 = 0;
  224. memset(p->data4, 8, sizeof(UA_Byte));
  225. return UA_SUCCESS;
  226. }
  227. UA_TYPE_NEW_DEFAULT(UA_Guid)
  228. UA_Int32 UA_Guid_copy(UA_Guid const *src, UA_Guid *dst) {
  229. if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
  230. UA_Int32 retval = UA_SUCCESS;
  231. retval |= UA_memcpy((void *)dst, (void *)src, sizeof(UA_Guid));
  232. return retval;
  233. }
  234. /* ByteString */
  235. UA_TYPE_AS(UA_ByteString, UA_String)
  236. UA_Int32 UA_ByteString_equal(const UA_ByteString *string1, const UA_ByteString *string2) {
  237. return UA_String_equal((const UA_String *)string1, (const UA_String *)string2);
  238. }
  239. void UA_ByteString_printf(char *label, const UA_ByteString *string) {
  240. UA_String_printf(label, (UA_String *)string);
  241. }
  242. void UA_ByteString_printx(char *label, const UA_ByteString *string) {
  243. UA_String_printx(label, (UA_String *)string);
  244. }
  245. void UA_ByteString_printx_hex(char *label, const UA_ByteString *string) {
  246. UA_String_printx_hex(label, (UA_String *)string);
  247. }
  248. UA_Byte UA_Byte_securityPoliceNoneData[] = "http://opcfoundation.org/UA/SecurityPolicy#None";
  249. // sizeof()-1 : discard the implicit null-terminator of the c-char-string
  250. UA_ByteString UA_ByteString_securityPoliceNone =
  251. { sizeof(UA_Byte_securityPoliceNoneData)-1, UA_Byte_securityPoliceNoneData };
  252. UA_Int32 UA_ByteString_newMembers(UA_ByteString *p, UA_Int32 length) {
  253. UA_Int32 retval = UA_SUCCESS;
  254. if((retval |= UA_alloc((void **)&p->data, length)) == UA_SUCCESS)
  255. p->length = length;
  256. else {
  257. p->length = -1;
  258. p->data = UA_NULL;
  259. }
  260. return retval;
  261. }
  262. /* XmlElement */
  263. UA_TYPE_AS(UA_XmlElement, UA_ByteString)
  264. /* NodeId */
  265. UA_Boolean UA_NodeId_isBasicType(UA_NodeId const *id) {
  266. return (id->namespace == 0 && id->identifier.numeric <= UA_DIAGNOSTICINFO);
  267. }
  268. UA_TYPE_DELETE_DEFAULT(UA_NodeId)
  269. UA_Int32 UA_NodeId_deleteMembers(UA_NodeId *p) {
  270. UA_Int32 retval = UA_SUCCESS;
  271. if(p == UA_NULL) return retval;
  272. switch(p->encodingByte & UA_NODEIDTYPE_MASK) {
  273. case UA_NODEIDTYPE_TWOBYTE:
  274. case UA_NODEIDTYPE_FOURBYTE:
  275. case UA_NODEIDTYPE_NUMERIC:
  276. // nothing to do
  277. break;
  278. case UA_NODEIDTYPE_STRING: // Table 6, second entry
  279. retval |= UA_String_deleteMembers(&p->identifier.string);
  280. break;
  281. case UA_NODEIDTYPE_GUID: // Table 6, third entry
  282. retval |= UA_Guid_deleteMembers(&p->identifier.guid);
  283. break;
  284. case UA_NODEIDTYPE_BYTESTRING: // Table 6, "OPAQUE"
  285. retval |= UA_ByteString_deleteMembers(&p->identifier.byteString);
  286. break;
  287. }
  288. return retval;
  289. }
  290. void UA_NodeId_printf(char *label, const UA_NodeId *node) {
  291. UA_Int32 l;
  292. printf("%s {encodingByte=%d, namespace=%d,", label, (int)( node->encodingByte), (int)(node->namespace));
  293. switch(node->encodingByte & UA_NODEIDTYPE_MASK) {
  294. case UA_NODEIDTYPE_TWOBYTE:
  295. case UA_NODEIDTYPE_FOURBYTE:
  296. case UA_NODEIDTYPE_NUMERIC:
  297. printf("identifier=%d\n", node->identifier.numeric);
  298. break;
  299. case UA_NODEIDTYPE_STRING:
  300. l = ( node->identifier.string.length < 0 ) ? 0 : node->identifier.string.length;
  301. printf("identifier={length=%d, data=%.*s}",
  302. node->identifier.string.length, l,
  303. (char *)(node->identifier.string.data));
  304. break;
  305. case UA_NODEIDTYPE_BYTESTRING:
  306. l = ( node->identifier.byteString.length < 0 ) ? 0 : node->identifier.byteString.length;
  307. printf("identifier={Length=%d, data=%.*s}",
  308. node->identifier.byteString.length, l,
  309. (char *)(node->identifier.byteString.data));
  310. break;
  311. case UA_NODEIDTYPE_GUID:
  312. printf(
  313. "guid={data1=%d, data2=%d, data3=%d, data4={length=%d, data=%.*s}}",
  314. node->identifier.guid.data1, node->identifier.guid.data2,
  315. node->identifier.guid.data3, 8,
  316. 8,
  317. (char *)(node->identifier.guid.data4));
  318. break;
  319. default:
  320. printf("ups! shit happens");
  321. break;
  322. }
  323. printf("}\n");
  324. }
  325. UA_Int32 UA_NodeId_equal(const UA_NodeId *n1, const UA_NodeId *n2) {
  326. if(n1 == UA_NULL || n2 == UA_NULL || n1->encodingByte != n2->encodingByte || n1->namespace != n2->namespace)
  327. return UA_NOT_EQUAL;
  328. switch(n1->encodingByte & UA_NODEIDTYPE_MASK) {
  329. case UA_NODEIDTYPE_TWOBYTE:
  330. case UA_NODEIDTYPE_FOURBYTE:
  331. case UA_NODEIDTYPE_NUMERIC:
  332. if(n1->identifier.numeric == n2->identifier.numeric)
  333. return UA_EQUAL;
  334. else
  335. return UA_NOT_EQUAL;
  336. case UA_NODEIDTYPE_STRING:
  337. return UA_String_equal(&n1->identifier.string, &n2->identifier.string);
  338. case UA_NODEIDTYPE_GUID:
  339. return UA_Guid_equal(&n1->identifier.guid, &n2->identifier.guid);
  340. case UA_NODEIDTYPE_BYTESTRING:
  341. return UA_ByteString_equal(&n1->identifier.byteString, &n2->identifier.byteString);
  342. }
  343. return UA_NOT_EQUAL;
  344. }
  345. UA_Int32 UA_NodeId_init(UA_NodeId *p) {
  346. if(p == UA_NULL) return UA_ERROR;
  347. p->encodingByte = UA_NODEIDTYPE_TWOBYTE;
  348. p->namespace = 0;
  349. memset(&p->identifier, 0, sizeof(p->identifier));
  350. return UA_SUCCESS;
  351. }
  352. UA_TYPE_NEW_DEFAULT(UA_NodeId)
  353. UA_Int32 UA_NodeId_copy(UA_NodeId const *src, UA_NodeId *dst) {
  354. if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
  355. UA_Int32 retval = UA_SUCCESS;
  356. retval |= UA_Byte_copy(&src->encodingByte, &dst->encodingByte);
  357. switch(src->encodingByte & UA_NODEIDTYPE_MASK) {
  358. case UA_NODEIDTYPE_TWOBYTE:
  359. case UA_NODEIDTYPE_FOURBYTE:
  360. case UA_NODEIDTYPE_NUMERIC:
  361. // nothing to do
  362. retval |= UA_UInt16_copy(&src->namespace, &dst->namespace);
  363. retval |= UA_UInt32_copy(&src->identifier.numeric, &dst->identifier.numeric);
  364. break;
  365. case UA_NODEIDTYPE_STRING: // Table 6, second entry
  366. retval |= UA_String_copy(&src->identifier.string, &dst->identifier.string);
  367. break;
  368. case UA_NODEIDTYPE_GUID: // Table 6, third entry
  369. retval |= UA_Guid_copy(&src->identifier.guid, &dst->identifier.guid);
  370. break;
  371. case UA_NODEIDTYPE_BYTESTRING: // Table 6, "OPAQUE"
  372. retval |= UA_ByteString_copy(&src->identifier.byteString, &dst->identifier.byteString);
  373. break;
  374. }
  375. return retval;
  376. }
  377. UA_Boolean UA_NodeId_isNull(const UA_NodeId *p) {
  378. switch(p->encodingByte & UA_NODEIDTYPE_MASK) {
  379. case UA_NODEIDTYPE_TWOBYTE:
  380. if(p->identifier.numeric != 0) return UA_FALSE;
  381. break;
  382. case UA_NODEIDTYPE_FOURBYTE:
  383. case UA_NODEIDTYPE_NUMERIC:
  384. if(p->namespace != 0 || p->identifier.numeric != 0) return UA_FALSE;
  385. break;
  386. case UA_NODEIDTYPE_STRING:
  387. if(p->namespace != 0 || p->identifier.string.length != 0) return UA_FALSE;
  388. break;
  389. case UA_NODEIDTYPE_GUID:
  390. if(p->namespace != 0 ||
  391. memcmp(&p->identifier.guid, (char[sizeof(UA_Guid)]) { 0 }, sizeof(UA_Guid)) != 0) return UA_FALSE;
  392. break;
  393. case UA_NODEIDTYPE_BYTESTRING:
  394. if(p->namespace != 0 || p->identifier.byteString.length != 0) return UA_FALSE;
  395. break;
  396. default:
  397. return UA_FALSE;
  398. }
  399. return UA_TRUE;
  400. }
  401. /* ExpandedNodeId */
  402. UA_TYPE_DELETE_DEFAULT(UA_ExpandedNodeId)
  403. UA_Int32 UA_ExpandedNodeId_deleteMembers(UA_ExpandedNodeId *p) {
  404. UA_Int32 retval = UA_SUCCESS;
  405. if(p == UA_NULL) return retval;
  406. retval |= UA_NodeId_deleteMembers(&p->nodeId);
  407. retval |= UA_String_deleteMembers(&p->namespaceUri);
  408. return retval;
  409. }
  410. UA_Int32 UA_ExpandedNodeId_init(UA_ExpandedNodeId *p) {
  411. if(p == UA_NULL) return UA_ERROR;
  412. UA_NodeId_init(&p->nodeId);
  413. UA_String_init(&p->namespaceUri);
  414. p->serverIndex = 0;
  415. return UA_SUCCESS;
  416. }
  417. UA_TYPE_NEW_DEFAULT(UA_ExpandedNodeId)
  418. UA_Int32 UA_ExpandedNodeId_copy(UA_ExpandedNodeId const *src, UA_ExpandedNodeId *dst) {
  419. if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
  420. UA_Int32 retval = UA_SUCCESS;
  421. UA_String_copy(&src->namespaceUri, &dst->namespaceUri);
  422. UA_NodeId_copy(&src->nodeId, &dst->nodeId);
  423. UA_UInt32_copy(&src->serverIndex, &dst->serverIndex);
  424. return retval;
  425. }
  426. UA_Boolean UA_ExpandedNodeId_isNull(const UA_ExpandedNodeId *p) {
  427. return UA_NodeId_isNull(&p->nodeId);
  428. }
  429. /* StatusCode */
  430. UA_TYPE_AS(UA_StatusCode, UA_UInt32)
  431. /* QualifiedName */
  432. UA_TYPE_DELETE_DEFAULT(UA_QualifiedName)
  433. UA_Int32 UA_QualifiedName_deleteMembers(UA_QualifiedName *p) {
  434. UA_Int32 retval = UA_SUCCESS;
  435. if(p == UA_NULL) return retval;
  436. retval |= UA_String_deleteMembers(&p->name);
  437. return retval;
  438. }
  439. UA_Int32 UA_QualifiedName_init(UA_QualifiedName *p) {
  440. if(p == UA_NULL) return UA_ERROR;
  441. UA_String_init(&p->name);
  442. p->namespaceIndex = 0;
  443. return UA_SUCCESS;
  444. }
  445. UA_TYPE_NEW_DEFAULT(UA_QualifiedName)
  446. UA_Int32 UA_QualifiedName_copy(UA_QualifiedName const *src, UA_QualifiedName *dst) {
  447. if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
  448. UA_Int32 retval = UA_SUCCESS;
  449. retval |= UA_String_copy(&src->name, &dst->name);
  450. retval |= UA_UInt16_copy(&src->namespaceIndex, &dst->namespaceIndex);
  451. return retval;
  452. }
  453. void UA_QualifiedName_printf(char const *label, const UA_QualifiedName *qn) {
  454. printf("%s {NamespaceIndex=%u, Length=%d, Data=%.*s}\n", label, qn->namespaceIndex,
  455. qn->name.length, qn->name.length, (char *)qn->name.data);
  456. }
  457. /* LocalizedText */
  458. UA_TYPE_DELETE_DEFAULT(UA_LocalizedText)
  459. UA_Int32 UA_LocalizedText_deleteMembers(UA_LocalizedText *p) {
  460. if(p == UA_NULL) return UA_SUCCESS;
  461. UA_Int32 retval = UA_SUCCESS;
  462. retval |= UA_String_deleteMembers(&p->locale);
  463. retval |= UA_String_deleteMembers(&p->text);
  464. return retval;
  465. }
  466. UA_Int32 UA_LocalizedText_init(UA_LocalizedText *p) {
  467. if(p == UA_NULL) return UA_ERROR;
  468. UA_String_init(&p->locale);
  469. UA_String_init(&p->text);
  470. return UA_SUCCESS;
  471. }
  472. UA_TYPE_NEW_DEFAULT(UA_LocalizedText)
  473. UA_Int32 UA_LocalizedText_copycstring(char const *src, UA_LocalizedText *dst) {
  474. if(dst == UA_NULL) return UA_ERROR;
  475. UA_LocalizedText_init(dst);
  476. UA_Int32 retval = UA_SUCCESS;
  477. retval |= UA_String_copycstring("EN", &dst->locale); // TODO: Are language codes upper case?
  478. if(retval != UA_SUCCESS) return retval;
  479. retval |= UA_String_copycstring(src, &dst->text);
  480. return retval;
  481. }
  482. UA_Int32 UA_LocalizedText_copy(UA_LocalizedText const *src, UA_LocalizedText *dst) {
  483. if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
  484. UA_Int32 retval = UA_SUCCESS;
  485. retval |= UA_LocalizedText_init(dst);
  486. retval |= UA_String_copy(&src->locale, &dst->locale);
  487. if(retval != UA_SUCCESS) return retval;
  488. retval |= UA_String_copy(&src->text, &dst->text);
  489. return retval;
  490. }
  491. /* ExtensionObject */
  492. UA_TYPE_DELETE_DEFAULT(UA_ExtensionObject)
  493. UA_Int32 UA_ExtensionObject_deleteMembers(UA_ExtensionObject *p) {
  494. UA_Int32 retval = UA_SUCCESS;
  495. if(p == UA_NULL) return retval;
  496. retval |= UA_NodeId_deleteMembers(&p->typeId);
  497. retval |= UA_ByteString_deleteMembers(&p->body);
  498. return retval;
  499. }
  500. UA_Int32 UA_ExtensionObject_init(UA_ExtensionObject *p) {
  501. if(p == UA_NULL) return UA_ERROR;
  502. UA_ByteString_init(&p->body);
  503. p->encoding = 0;
  504. UA_NodeId_init(&p->typeId);
  505. return UA_SUCCESS;
  506. }
  507. UA_TYPE_NEW_DEFAULT(UA_ExtensionObject)
  508. UA_Int32 UA_ExtensionObject_copy(UA_ExtensionObject const *src, UA_ExtensionObject *dst) {
  509. if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
  510. UA_Int32 retval = UA_SUCCESS;
  511. retval |= UA_Byte_copy(&src->encoding, &dst->encoding);
  512. retval |= UA_ByteString_copy(&src->body, &dst->body);
  513. retval |= UA_NodeId_copy(&src->typeId, &dst->typeId);
  514. return retval;
  515. }
  516. /* DataValue */
  517. UA_TYPE_DELETE_DEFAULT(UA_DataValue)
  518. UA_Int32 UA_DataValue_deleteMembers(UA_DataValue *p) {
  519. UA_Int32 retval = UA_SUCCESS;
  520. if(p == UA_NULL) return retval;
  521. UA_Variant_deleteMembers(&p->value);
  522. return retval;
  523. }
  524. UA_Int32 UA_DataValue_init(UA_DataValue *p) {
  525. if(p == UA_NULL) return UA_ERROR;
  526. p->encodingMask = 0;
  527. p->serverPicoseconds = 0;
  528. UA_DateTime_init(&p->serverTimestamp);
  529. p->sourcePicoseconds = 0;
  530. UA_DateTime_init(&p->sourceTimestamp);
  531. UA_StatusCode_init(&p->status);
  532. UA_Variant_init(&p->value);
  533. return UA_SUCCESS;
  534. }
  535. UA_TYPE_NEW_DEFAULT(UA_DataValue)
  536. UA_Int32 UA_DataValue_copy(UA_DataValue const *src, UA_DataValue *dst) {
  537. if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
  538. UA_Int32 retval = UA_SUCCESS;
  539. UA_Byte_copy(&src->encodingMask, &dst->encodingMask);
  540. UA_Int16_copy(&src->serverPicoseconds, &dst->serverPicoseconds);
  541. UA_DateTime_copy(&src->serverTimestamp, &dst->serverTimestamp);
  542. UA_Int16_copy(&src->sourcePicoseconds, &dst->sourcePicoseconds);
  543. UA_DateTime_copy(&src->sourceTimestamp, &dst->sourceTimestamp);
  544. UA_StatusCode_copy(&src->status, &dst->status);
  545. UA_Variant_copy(&src->value, &dst->value);
  546. return retval;
  547. }
  548. /* Variant */
  549. UA_TYPE_DELETE_DEFAULT(UA_Variant)
  550. UA_Int32 UA_Variant_deleteMembers(UA_Variant *p) {
  551. UA_Int32 retval = UA_SUCCESS;
  552. if(p == UA_NULL) return retval;
  553. UA_Boolean hasDimensions = p->arrayDimensions != UA_NULL;
  554. if(p->data != UA_NULL) {
  555. retval |= UA_Array_delete(p->data, p->arrayLength, p->vt);
  556. p->data = UA_NULL;
  557. }
  558. if(hasDimensions) {
  559. UA_free(p->arrayDimensions);
  560. p->arrayDimensions = UA_NULL;
  561. }
  562. return retval;
  563. }
  564. UA_Int32 UA_Variant_init(UA_Variant *p) {
  565. if(p == UA_NULL) return UA_ERROR;
  566. p->arrayLength = -1; // no element, p->data == UA_NULL
  567. p->data = UA_NULL;
  568. p->arrayDimensions = UA_NULL;
  569. p->arrayDimensionsLength = -1;
  570. p->vt = &UA_.types[UA_INVALIDTYPE];
  571. return UA_SUCCESS;
  572. }
  573. UA_TYPE_NEW_DEFAULT(UA_Variant)
  574. UA_Int32 UA_Variant_copy(UA_Variant const *src, UA_Variant *dst) {
  575. if(src == UA_NULL || dst == UA_NULL)
  576. return UA_ERROR;
  577. UA_Int32 retval = UA_SUCCESS;
  578. dst->vt = src->vt;
  579. retval |= UA_Int32_copy(&src->arrayLength, &dst->arrayLength);
  580. retval |= UA_Int32_copy(&src->arrayDimensionsLength, &dst->arrayDimensionsLength);
  581. retval |= UA_Array_copy(src->data, src->arrayLength, src->vt, &dst->data);
  582. UA_Boolean hasDimensions = src->arrayDimensions != UA_NULL;
  583. if(hasDimensions)
  584. retval |= UA_Array_copy(src->arrayDimensions, src->arrayDimensionsLength,
  585. &UA_.types[UA_INT32], (void **)&dst->arrayDimensions);
  586. return retval;
  587. }
  588. UA_Int32 UA_Variant_copySetValue(UA_Variant *v, UA_VTable_Entry *vt, const void *value) {
  589. if(v == UA_NULL || vt == UA_NULL || value == UA_NULL)
  590. return UA_ERROR;
  591. UA_Variant_init(v);
  592. v->vt = vt;
  593. v->arrayLength = 1; // no array but a single entry
  594. UA_Int32 retval = UA_SUCCESS;
  595. retval |= vt->new(&v->data);
  596. if(retval == UA_SUCCESS)
  597. retval |= vt->copy(value, v->data);
  598. return retval;
  599. }
  600. UA_Int32 UA_Variant_copySetArray(UA_Variant *v, UA_VTable_Entry *vt, UA_Int32 arrayLength, const void *array) {
  601. if(v == UA_NULL || vt == UA_NULL || array == UA_NULL)
  602. return UA_ERROR;
  603. UA_Variant_init(v);
  604. v->vt = vt;
  605. v->arrayLength = arrayLength;
  606. return UA_Array_copy(array, arrayLength, vt, &v->data);
  607. }
  608. UA_Int32 UA_Variant_borrowSetValue(UA_Variant *v, UA_VTable_Entry *vt, const void *value) {
  609. if(v == UA_NULL || vt == UA_NULL || value == UA_NULL)
  610. return UA_ERROR;
  611. UA_Variant_init(v);
  612. v->vt = &UA_borrowed_.types[UA_ns0ToVTableIndex(&vt->typeId)];
  613. v->arrayLength = 1; // no array but a single entry
  614. v->data = (void *)value;
  615. return UA_SUCCESS;
  616. }
  617. UA_Int32 UA_Variant_borrowSetArray(UA_Variant *v, UA_VTable_Entry *vt, UA_Int32 arrayLength, const void *array) {
  618. if(v == UA_NULL || vt == UA_NULL || array == UA_NULL)
  619. return UA_ERROR;
  620. UA_Variant_init(v);
  621. v->vt = &UA_borrowed_.types[UA_ns0ToVTableIndex(&vt->typeId)];
  622. v->arrayLength = arrayLength;
  623. v->data = (void *)array;
  624. return UA_SUCCESS;
  625. }
  626. /* DiagnosticInfo */
  627. UA_TYPE_DELETE_DEFAULT(UA_DiagnosticInfo)
  628. UA_Int32 UA_DiagnosticInfo_deleteMembers(UA_DiagnosticInfo *p) {
  629. UA_Int32 retval = UA_SUCCESS;
  630. if(p == UA_NULL) return retval;
  631. if((p->encodingMask & UA_DIAGNOSTICINFO_ENCODINGMASK_INNERDIAGNOSTICINFO) && p->innerDiagnosticInfo != UA_NULL) {
  632. retval |= UA_DiagnosticInfo_delete(p->innerDiagnosticInfo);
  633. retval |= UA_String_deleteMembers(&p->additionalInfo);
  634. p->innerDiagnosticInfo = UA_NULL;
  635. }
  636. return retval;
  637. }
  638. UA_Int32 UA_DiagnosticInfo_init(UA_DiagnosticInfo *p) {
  639. if(p == UA_NULL) return UA_ERROR;
  640. UA_String_init(&p->additionalInfo);
  641. p->encodingMask = 0;
  642. p->innerDiagnosticInfo = UA_NULL;
  643. UA_StatusCode_init(&p->innerStatusCode);
  644. p->locale = 0;
  645. p->localizedText = 0;
  646. p->namespaceUri = 0;
  647. p->symbolicId = 0;
  648. return UA_SUCCESS;
  649. }
  650. UA_TYPE_NEW_DEFAULT(UA_DiagnosticInfo)
  651. UA_Int32 UA_DiagnosticInfo_copy(UA_DiagnosticInfo const *src, UA_DiagnosticInfo *dst) {
  652. if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
  653. UA_Int32 retval = UA_SUCCESS;
  654. retval |= UA_String_copy(&src->additionalInfo, &dst->additionalInfo);
  655. retval |= UA_Byte_copy(&src->encodingMask, &dst->encodingMask);
  656. retval |= UA_StatusCode_copy(&src->innerStatusCode, &dst->innerStatusCode);
  657. if(src->innerDiagnosticInfo) {
  658. retval |= UA_alloc((void **)&dst->innerDiagnosticInfo, sizeof(UA_DiagnosticInfo));
  659. if(retval == UA_SUCCESS)
  660. retval |= UA_DiagnosticInfo_copy(src->innerDiagnosticInfo, dst->innerDiagnosticInfo);
  661. } else
  662. dst->innerDiagnosticInfo = UA_NULL;
  663. retval |= UA_Int32_copy(&src->locale, &dst->locale);
  664. retval |= UA_Int32_copy(&src->localizedText, &dst->localizedText);
  665. retval |= UA_Int32_copy(&src->namespaceUri, &dst->namespaceUri);
  666. retval |= UA_Int32_copy(&src->symbolicId, &dst->symbolicId);
  667. return retval;
  668. }
  669. /* InvalidType */
  670. UA_Int32 UA_InvalidType_free(UA_InvalidType *p) {
  671. return UA_ERR_INVALID_VALUE;
  672. }
  673. UA_Int32 UA_InvalidType_delete(UA_InvalidType *p) {
  674. return UA_ERR_INVALID_VALUE;
  675. }
  676. UA_Int32 UA_InvalidType_deleteMembers(UA_InvalidType *p) {
  677. return UA_ERR_INVALID_VALUE;
  678. }
  679. UA_Int32 UA_InvalidType_init(UA_InvalidType *p) {
  680. return UA_ERR_INVALID_VALUE;
  681. }
  682. UA_Int32 UA_InvalidType_copy(UA_InvalidType const *src, UA_InvalidType *dst) {
  683. return UA_ERR_INVALID_VALUE;
  684. }
  685. UA_Int32 UA_InvalidType_new(UA_InvalidType **p) {
  686. return UA_ERR_INVALID_VALUE;
  687. }
  688. /*********/
  689. /* Array */
  690. /*********/
  691. UA_Int32 UA_Array_new(void **p, UA_Int32 noElements, UA_VTable_Entry *vt) {
  692. if(vt == UA_NULL)
  693. return UA_ERROR;
  694. if(noElements <= 0) {
  695. *p = UA_NULL;
  696. return UA_SUCCESS;
  697. }
  698. // FIXME! Arrays cannot be larger than 2**20.
  699. // This was randomly chosen so that the development VM does not blow up.
  700. if(noElements > 1048576) {
  701. *p = UA_NULL;
  702. return UA_ERROR;
  703. }
  704. UA_Int32 retval = UA_SUCCESS;
  705. retval = UA_alloc(p, vt->memSize * noElements);
  706. if(retval != UA_SUCCESS)
  707. return retval;
  708. retval = UA_Array_init(*p, noElements, vt);
  709. if(retval != UA_SUCCESS) {
  710. UA_free(*p);
  711. *p = UA_NULL;
  712. }
  713. return retval;
  714. }
  715. UA_Int32 UA_Array_init(void *p, UA_Int32 noElements, UA_VTable_Entry *vt) {
  716. if(p == UA_NULL || vt == UA_NULL)
  717. return UA_ERROR;
  718. UA_Int32 retval = UA_SUCCESS;
  719. char *cp = (char *)p; // so compilers allow pointer arithmetic
  720. UA_UInt32 memSize = vt->memSize;
  721. for(UA_Int32 i = 0;i < noElements && retval == UA_SUCCESS;i++) {
  722. retval |= vt->init(cp);
  723. cp += memSize;
  724. }
  725. return retval;
  726. }
  727. UA_Int32 UA_Array_delete(void *p, UA_Int32 noElements, UA_VTable_Entry *vt) {
  728. if(p == UA_NULL)
  729. return UA_SUCCESS;
  730. if(vt == UA_NULL)
  731. return UA_ERROR;
  732. char *cp = (char *)p; // so compilers allow pointer arithmetic
  733. UA_UInt32 memSize = vt->memSize;
  734. UA_Int32 retval = UA_SUCCESS;
  735. for(UA_Int32 i = 0;i < noElements;i++) {
  736. retval |= vt->deleteMembers(cp);
  737. cp += memSize;
  738. }
  739. UA_free(p);
  740. return retval;
  741. }
  742. UA_Int32 UA_Array_copy(const void *src, UA_Int32 noElements, UA_VTable_Entry *vt, void **dst) {
  743. if(src == UA_NULL || dst == UA_NULL || vt == UA_NULL)
  744. return UA_ERROR;
  745. UA_Int32 retval = UA_Array_new(dst, noElements, vt);
  746. if(retval != UA_SUCCESS){
  747. *dst = UA_NULL;
  748. return retval;
  749. }
  750. char *csrc = (char *)src; // so compilers allow pointer arithmetic
  751. char *cdst = (char *)*dst;
  752. UA_UInt32 memSize = vt->memSize;
  753. UA_Int32 i = 0;
  754. for(;i < noElements && retval == UA_SUCCESS;i++) {
  755. retval |= vt->copy(csrc, cdst);
  756. csrc += memSize;
  757. cdst += memSize;
  758. }
  759. if(retval != UA_SUCCESS) {
  760. i--; // undo last increase
  761. UA_Array_delete(*dst, i, vt);
  762. *dst = UA_NULL;
  763. }
  764. return retval;
  765. }