DDS_ReturnCode_t dds_seq_from_array (void *seq, void *array, unsigned length)
{
DDS_VoidSeq *sp = (DDS_VoidSeq *) seq;
if (dds_seq_require (seq, length))
return (DDS_RETCODE_OUT_OF_RESOURCES);
memcpy (sp->_buffer, array, length * sp->_esize);
return (DDS_RETCODE_OK);
}
static bool simplechat_ChatMessage_set_val_cb(uintptr_t out_data, const char *name, CDR_TypeCode_t type, qeo_t2d_types_t *value /* cast me */){
org_qeo_sample_simplechat_ChatMessage_t *chat_msg = (org_qeo_sample_simplechat_ChatMessage_t *)out_data;
if (strcmp(name, "from") == 0){
chat_msg->from = strdup(value->string_val);
} else if (strcmp(name, "fromExtra") == 0){
ck_assert_str_eq(value->typeref.name, org_qeo_UUID_type[0].name);
value->typeref.ref = (uintptr_t)&chat_msg->fromExtra;
value->typeref.ucbs = &_uuid_ucbs;
} else if (strcmp(name, "message") == 0){
chat_msg->message = strdup(value->string_val);
} else if (strcmp(name, "extraInfo") == 0){
value->seq.seq_ref = (uintptr_t)&chat_msg->extraInfo;
value->seq.ucbs = &_sc_extraInfo_ucbs;
DDS_SEQ_INIT(chat_msg->extraInfo);
ck_assert_int_eq(dds_seq_require(&chat_msg->extraInfo,value->seq.seq_size), DDS_RETCODE_OK);
printf("allocating extraInfo sequence with size %zu\n", value->seq.seq_size);
} else if (strcmp(name, "list") == 0){
value->seq.seq_ref = (uintptr_t)&chat_msg->list;
value->seq.ucbs = &_sc_list_ucbs;
DDS_SEQ_INIT(chat_msg->list);
ck_assert_int_eq(dds_seq_require(&chat_msg->list,value->seq.seq_size), DDS_RETCODE_OK);
printf("allocating list sequence with size %zu\n", value->seq.seq_size);
} else if (strcmp(name, "maincolor") == 0){
chat_msg->maincolor = value->enum_val;
} else if (strcmp(name, "colorlist") == 0){
value->seq.seq_ref = (uintptr_t)&chat_msg->colorlist;
value->seq.ucbs = &_sc_colorlist_ucbs;
DDS_SEQ_INIT(chat_msg->colorlist);
ck_assert_int_eq(dds_seq_require(&chat_msg->colorlist,value->seq.seq_size), DDS_RETCODE_OK);
printf("allocating colorlist sequence with size %zu\n", value->seq.seq_size);
} else {
qeo_log_e("unknown field %s", name);
return false;
}
return true;
}
DDS_ReturnCode_t dds_seq_copy (void *dst, void *src)
{
DDS_VoidSeq *dp = (DDS_VoidSeq *) dst;
DDS_VoidSeq *sp = (DDS_VoidSeq *) src;
if (!dp || !sp || dp->_esize != sp->_esize)
return (DDS_RETCODE_BAD_PARAMETER);
if (sp->_length && dds_seq_require (dst, sp->_length))
return (DDS_RETCODE_OUT_OF_RESOURCES);
dp->_length = sp->_length;
if (sp->_buffer)
memcpy (dp->_buffer, sp->_buffer, sizeof (uint32_t) * sp->_length);
return (DDS_RETCODE_OK);
}
void DDS_Security_write_volatile_data (Domain_t *dp,
DDS_DataHolder *dh)
{
DDS_ParticipantVolatileSecureMessage msg;
DDS_ReturnCode_t error;
memset (&msg, 0, sizeof (msg));
msg.message_class_id = GMCLASSID_SECURITY_VOL_DATA;
DDS_SEQ_INIT (msg.message_data);
error = dds_seq_require (&msg.message_data, 1);
if (error)
return;
DDS_SEQ_ITEM (msg.message_data, 0) = *dh;
ctt_send (dp, NULL, NULL, NULL, &msg);
}
void test_dyn_array1 (void)
{
DDS_DynamicTypeSupport ts;
DDS_DynamicTypeBuilder sb, abc20;
DDS_TypeDescriptor *desc;
DDS_MemberDescriptor *md;
DDS_DynamicType s, ac20;
DDS_BoundSeq bounds;
DDS_DynamicData dd, dda, dd2;
DDS_ReturnCode_t rc;
unsigned i;
v_printf ("test_dyn_array1 - ");
/* 1. Create the type. */
desc = DDS_TypeDescriptor__alloc ();
fail_unless (desc != NULL);
desc->kind = DDS_STRUCTURE_TYPE;
desc->name = "dstruct1";
sb = DDS_DynamicTypeBuilderFactory_create_type (desc);
fail_unless (sb != NULL);
md = DDS_MemberDescriptor__alloc ();
fail_unless (md != NULL);
DDS_SEQ_INIT (bounds);
dds_seq_require (&bounds, 1);
DDS_SEQ_LENGTH (bounds) = 1;
DDS_SEQ_ITEM (bounds, 0) = 20;
abc20 = DDS_DynamicTypeBuilderFactory_create_array_type (
DDS_DynamicTypeBuilderFactory_get_primitive_type (DDS_CHAR_8_TYPE),
&bounds);
fail_unless (abc20 != NULL);
dds_seq_cleanup (&bounds);
ac20 = DDS_DynamicTypeBuilder_build (abc20);
fail_unless (ac20 != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (abc20);
md->name = "char_a";
md->index = md->id = 0;
md->type = ac20;
rc = DDS_DynamicTypeBuilder_add_member (sb, md);
fail_unless (rc == DDS_RETCODE_OK);
s = DDS_DynamicTypeBuilder_build (sb);
fail_unless (s != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (sb);
ts = DDS_DynamicTypeSupport_create_type_support (s);
fail_unless (ts != NULL);
DDS_TypeDescriptor__free (desc);
DDS_MemberDescriptor__free (md);
/* 2. Create a Dynamic Data item for this type. */
dd = DDS_DynamicDataFactory_create_data (s);
fail_unless (dd != NULL);
dda = DDS_DynamicDataFactory_create_data (ac20);
fail_unless (dda != NULL);
for (i = 0; i < 20; i++) {
SET_FIELD (dda, i, char8, i + '0');
}
SET_FIELD (dd, 0, complex, dda);
marshallDynamic (dd, &dd2, ts);
DDS_DynamicDataFactory_delete_data (dd);
DDS_DynamicDataFactory_delete_data (dda);
DDS_DynamicTypeBuilderFactory_delete_type (ac20);
DDS_DynamicTypeBuilderFactory_delete_type (s);
DDS_DynamicTypeSupport_delete_type_support (ts);
v_printf ("success!\r\n");
}
void test_dyn_oseq (void)
{
DDS_DynamicTypeSupport ts;
DDS_DynamicTypeBuilder sb, oseqb;
DDS_TypeDescriptor *desc;
DDS_MemberDescriptor *md;
DDS_DynamicType s, oseq;
DDS_DynamicData dd, dda, dd2;
DDS_ReturnCode_t rc;
DDS_ByteSeq values;
unsigned i;
v_printf ("test_dyn_oseq - ");
/* 1. Create the type. */
desc = DDS_TypeDescriptor__alloc ();
fail_unless (desc != NULL);
desc->kind = DDS_STRUCTURE_TYPE;
desc->name = "dstruct3";
sb = DDS_DynamicTypeBuilderFactory_create_type (desc);
fail_unless (sb != NULL);
md = DDS_MemberDescriptor__alloc ();
fail_unless (md != NULL);
ADD_FIELD (sb, md, "anuint", 0, 0, DDS_UINT_32_TYPE);
oseqb = DDS_DynamicTypeBuilderFactory_create_sequence_type (
DDS_DynamicTypeBuilderFactory_get_primitive_type (DDS_BYTE_TYPE),
0);
fail_unless (oseqb != NULL);
oseq = DDS_DynamicTypeBuilder_build (oseqb);
fail_unless (oseq != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (oseqb);
md->name = "oseq";
md->index = md->id = 1;
md->type = oseq;
rc = DDS_DynamicTypeBuilder_add_member (sb, md);
fail_unless (rc == DDS_RETCODE_OK);
ADD_FIELD (sb, md, "ch", 2, 2, DDS_CHAR_8_TYPE);
s = DDS_DynamicTypeBuilder_build (sb);
fail_unless (s != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (sb);
ts = DDS_DynamicTypeSupport_create_type_support (s);
fail_unless (ts != NULL);
DDS_TypeDescriptor__free (desc);
DDS_MemberDescriptor__free (md);
/* 2. Create a Dynamic Data item for this type. */
dd = DDS_DynamicDataFactory_create_data (s);
fail_unless (dd != NULL);
dda = DDS_DynamicDataFactory_create_data (oseq);
fail_unless (dda != NULL);
SET_FIELD (dd, 0, uint32, 1000);
DDS_SEQ_INIT (values);
rc = dds_seq_require (&values, 21);
fail_unless (rc == DDS_RETCODE_OK);
for (i = 0; i < 21; i++)
DDS_SEQ_ITEM (values, i) = i + '0';
rc = DDS_DynamicData_set_byte_values (dda, 0, &values);
fail_unless (rc == DDS_RETCODE_OK);
SET_FIELD (dd, 1, complex, dda);
SET_FIELD (dd, 2, char8, 'X');
marshallDynamic (dd, &dd2, ts);
DDS_DynamicDataFactory_delete_data (dd);
DDS_DynamicDataFactory_delete_data (dda);
DDS_DynamicTypeBuilderFactory_delete_type (oseq);
DDS_DynamicTypeBuilderFactory_delete_type (s);
DDS_DynamicTypeSupport_delete_type_support (ts);
v_printf ("success!\r\n");
}
void test_dyn_array2 (void)
{
DDS_DynamicTypeSupport ts;
DDS_DynamicTypeBuilder sb1, sb1a, abi64, abs1a;
DDS_DynamicType s1, s1a, ai64, as1a;
DDS_TypeDescriptor *desc;
DDS_MemberDescriptor *md;
DDS_DynamicData dd, dds, dda, ddas, dd2;
DDS_ReturnCode_t rc;
DDS_BoundSeq bounds;
unsigned i, j;
v_printf ("test_dyn_array2 - ");
/* 1. Create the type. */
desc = DDS_TypeDescriptor__alloc ();
fail_unless (desc != NULL);
desc->kind = DDS_STRUCTURE_TYPE;
desc->name = "dstruct2a";
sb1a = DDS_DynamicTypeBuilderFactory_create_type (desc);
fail_unless (sb1a != NULL);
md = DDS_MemberDescriptor__alloc ();
fail_unless (md != NULL);
DDS_SEQ_INIT (bounds);
dds_seq_require (&bounds, 1);
DDS_SEQ_LENGTH (bounds) = 1;
DDS_SEQ_ITEM (bounds, 0) = 5;
abi64 = DDS_DynamicTypeBuilderFactory_create_array_type (
DDS_DynamicTypeBuilderFactory_get_primitive_type (DDS_INT_64_TYPE),
&bounds);
fail_unless (abi64 != NULL);
ai64 = DDS_DynamicTypeBuilder_build (abi64);
fail_unless (ai64 != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (abi64);
md->name = "i64";
md->index = md->id = 0;
md->type = ai64;
rc = DDS_DynamicTypeBuilder_add_member (sb1a, md);
fail_unless (rc == DDS_RETCODE_OK);
ADD_FIELD (sb1a, md, "ch", 1, 1, DDS_CHAR_8_TYPE);
s1a = DDS_DynamicTypeBuilder_build (sb1a);
fail_unless (s1a != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (sb1a);
DDS_SEQ_ITEM (bounds, 0) = 7;
abs1a = DDS_DynamicTypeBuilderFactory_create_array_type (s1a, &bounds);
fail_unless (abs1a != NULL);
dds_seq_cleanup (&bounds);
as1a = DDS_DynamicTypeBuilder_build (abs1a);
fail_unless (as1a != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (abs1a);
desc->kind = DDS_STRUCTURE_TYPE;
desc->name = "dstruct2";
sb1 = DDS_DynamicTypeBuilderFactory_create_type (desc);
fail_unless (sb1 != NULL);
ADD_FIELD (sb1, md, "c", 0, 0, DDS_CHAR_8_TYPE);
md->name = "str2";
md->index = md->id = 1;
md->type = as1a;
rc = DDS_DynamicTypeBuilder_add_member (sb1, md);
fail_unless (rc == DDS_RETCODE_OK);
ADD_FIELD (sb1, md, "u16", 2, 2, DDS_UINT_16_TYPE);
s1 = DDS_DynamicTypeBuilder_build (sb1);
fail_unless (s1 != NULL);
DDS_DynamicTypeBuilderFactory_delete_type (sb1);
ts = DDS_DynamicTypeSupport_create_type_support (s1);
fail_unless (ts != NULL);
DDS_TypeDescriptor__free (desc);
DDS_MemberDescriptor__free (md);
/* 2. Create a Dynamic Data item for this type. */
dd = DDS_DynamicDataFactory_create_data (s1);
fail_unless (dd != NULL);
ddas = DDS_DynamicDataFactory_create_data (as1a);
fail_unless (ddas != NULL);
SET_FIELD (dd, 0, char8, 'A');
for (i = 0; i < 7; i++) {
dds = DDS_DynamicDataFactory_create_data (s1a);
fail_unless (dds != NULL);
dda = DDS_DynamicDataFactory_create_data (ai64);
fail_unless (dda != NULL);
for (j = 0; j < 5; j++) {
SET_FIELD (dda, j, int64, ((i + 6) * j) << i);
}
SET_FIELD (dds, 0, complex, dda);
DDS_DynamicDataFactory_delete_data (dda);
SET_FIELD (dds, 1, char8, i + 0x30);
SET_FIELD (ddas, i, complex, dds);
DDS_DynamicDataFactory_delete_data (dds);
}
SET_FIELD (dd, 1, complex, ddas);
DDS_DynamicDataFactory_delete_data (ddas);
SET_FIELD (dd, 2, uint16, 1366);
marshallDynamic (dd, &dd2, ts);
DDS_DynamicDataFactory_delete_data (dd);
DDS_DynamicTypeBuilderFactory_delete_type (s1);
DDS_DynamicTypeBuilderFactory_delete_type (as1a);
DDS_DynamicTypeBuilderFactory_delete_type (s1a);
DDS_DynamicTypeBuilderFactory_delete_type (ai64);
DDS_DynamicTypeSupport_delete_type_support (ts);
v_printf ("success!\r\n");
}
static qeocore_type_t *build_enum(const qeo_factory_t *factory, json_t *typedesc){
qeocore_type_t *qeoType = NULL;
qeocore_enum_constants_t vals = DDS_SEQ_INITIALIZER(qeocore_enum_constant_t);
const char *enumstr = NULL;
DDS_ReturnCode_t ddsret;
assert(typedesc != NULL);
assert(factory != NULL);
do {
json_t *type_enum = json_object_get(typedesc, KEY_ENUM);
if ((NULL == type_enum) || !json_is_string(type_enum)) {
qeo_log_e("Invalid type_enum (%p)", type_enum);
return qeoType;
}
json_t *values = json_object_get(typedesc, KEY_VALUES);
if ((NULL == values) || !json_is_object(values)) {
qeo_log_e("Invalid values (%p)", values);
return qeoType;
}
enumstr = json_string_value(type_enum);
//Replace all "::" with ".", because there's a mismatch in topic definitions found in the TSM structs, with "." and the QDM topic definitions with "::"
find_and_replace((char *) enumstr, "::", ".");
if ((ddsret = dds_seq_require(&vals, json_object_size(values))) != DDS_RETCODE_OK){
qeo_log_e("dds_seq_require failed (%d)", ddsret);
return NULL;
}
void *iter = json_object_iter(values);
while (iter) {
json_int_t labelint;
const char *name = json_object_iter_key(iter);
json_t *label = json_object_iter_value(iter);
if (!json_is_integer(label)){
qeo_log_e("not a integer");
}
labelint = json_integer_value(label);
if (labelint >= json_object_size(values)){
qeo_log_e("Currently we only support 0,1,2..[n-1] as labels");
break;
}
DDS_SEQ_ITEM(vals, labelint).name = (char *)name;
iter = json_object_iter_next(values, iter);
}
qeoType = qeocore_type_enum_new(enumstr, &vals);
if (qeoType == NULL){
qeo_log_e("Cannot register enum");
}
dds_seq_cleanup(&vals);
} while(0);
return qeoType;
}
static Token_t *sp_get_perm_token (const SEC_PERM *pp, Permissions_t id)
{
Token_t *tp;
unsigned char *p;
DDS_SecurityReqData data;
DDS_PermissionsToken *token;
size_t cred_len;
DDS_ReturnCode_t error;
ARG_NOT_USED (pp)
tp = xmalloc (sizeof (Token_t));
if (!tp)
return (NULL);
token = DDS_DataHolder__alloc (GMCLASSID_SECURITY_PERMISSIONS_TOKEN);
if (!token) {
xfree (tp);
return (NULL);
}
token->binary_value1 = DDS_OctetSeq__alloc ();
if (!token->binary_value1)
goto free_dh;
error = dds_seq_require (token->binary_value1, 32);
if (error)
goto free_dh;
data.handle = id;
data.data = NULL;
data.kdata = NULL;
data.length = 0;
data.rlength = 0;
error = sec_access_control_request (DDS_GET_PERM_CRED, &data);
if (error)
goto free_dh;
cred_len = data.rlength;
p = xmalloc (cred_len);
if (!p)
goto free_dh;
data.data = p;
data.kdata = NULL;
data.length = cred_len;
error = sec_access_control_request (DDS_GET_PERM_CRED, &data);
if (error)
goto free_p;
error = sec_hash_sha256 ((unsigned char *) p,
cred_len,
DDS_SEQ_DATA (*token->binary_value1));
xfree (p);
if (error)
goto free_dh;
tp->data = token;
tp->nusers = 1;
tp->encoding = 0;
tp->integral = 0;
tp->next = NULL;
return (tp);
free_p:
xfree (p);
free_dh:
DDS_DataHolder__free (token);
xfree (tp);
return (NULL);
}
static Token_t *sd_get_perm_token (const SEC_PERM *pp, Permissions_t perm)
{
Token_t *token;
DDS_IdentityToken *tp;
DDS_OctetSeq *p;
PermissionsData_t *pdp;
DDS_SecurityReqData data;
char buf [128];
char *bp;
MD5_CONTEXT md5;
DDS_ReturnCode_t ret;
ARG_NOT_USED (pp)
token = xmalloc (sizeof (Token_t));
if (!token)
return (NULL);
pdp = perm_lookup (perm, NULL);
if (!pdp)
goto no_perm;
data.handle = pdp->id;
data.data = NULL;
data.length = 0;
ret = sec_authentication_request (DDS_GET_ID_NAME, &data);
if (ret || !data.rlength)
goto no_perm;
if (data.rlength >= sizeof (buf)) {
bp = Alloc (data.rlength);
if (!bp)
goto no_perm;
}
else
bp = buf;
data.handle = pdp->id;
data.data = bp;
data.length = data.rlength;
ret = sec_authentication_request (DDS_GET_ID_NAME, &data);
if (ret)
goto done;
tp = DDS_DataHolder__alloc (GMCLASSID_SECURITY_DTLS_PERM_TOKEN);
if (!tp)
goto done;
tp->binary_value1 = p = DDS_OctetSeq__alloc ();
if (!p)
goto out_of_mem;
ret = dds_seq_require (p, 16);
if (ret) {
DDS_DataHolder__free (tp);
return (NULL);
}
md5_init (&md5);
md5_update (&md5, (unsigned char *) bp, strlen (bp));
md5_final (DDS_SEQ_DATA (*p), &md5);
if (bp != buf)
Free (bp);
token->data = tp;
token->encoding = PID_V_PERMS;
token->integral = 0;
token->nusers = 1;
token->next = NULL;
return (token);
out_of_mem:
DDS_DataHolder__free (tp);
done:
if (bp != buf)
Free (bp);
no_perm:
xfree (token);
return (NULL);
}
