int
mmsClient_createMmsGetNameListRequestAssociationSpecific(long invokeId, ByteBuffer* writeBuffer)
{
MmsPdu_t* mmsPdu = mmsClient_createConfirmedRequestPdu(invokeId);
mmsPdu->choice.confirmedRequestPdu.confirmedServiceRequest.present =
ConfirmedServiceRequest_PR_getNameList;
GetNameListRequest_t* request;
request = &(mmsPdu->choice.confirmedRequestPdu.confirmedServiceRequest.choice.getNameList);
request->continueAfter = NULL;
request->objectScope.present = GetNameListRequest__objectScope_PR_aaSpecific;
request->objectClass.present = ObjectClass_PR_basicObjectClass;
asn_long2INTEGER(&request->objectClass.choice.basicObjectClass,
ObjectClass__basicObjectClass_namedVariableList);
asn_enc_rval_t rval;
rval = der_encode(&asn_DEF_MmsPdu, mmsPdu,
mmsClient_write_out, (void*) writeBuffer);
if (DEBUG) xer_fprint(stdout, &asn_DEF_MmsPdu, mmsPdu);
asn_DEF_MmsPdu.free_struct(&asn_DEF_MmsPdu, mmsPdu, 0);
return rval.encoded;
}
int
ANY_fromType(ANY_t *st, asn_TYPE_descriptor_t *td, void *sptr) {
struct _callback_arg arg;
asn_enc_rval_t erval;
if(!st || !td) {
errno = EINVAL;
return -1;
}
if(!sptr) {
if(st->buf) FREEMEM(st->buf);
st->size = 0;
return 0;
}
arg.offset = arg.size = 0;
arg.buffer = 0;
erval = der_encode(td, sptr, ANY__consume_bytes, &arg);
if(erval.encoded == -1) {
if(arg.buffer) FREEMEM(arg.buffer);
return -1;
}
assert((size_t)erval.encoded == arg.offset);
if(st->buf) FREEMEM(st->buf);
st->buf = arg.buffer;
st->size = arg.offset;
return 0;
}
GByteArray *
namespace_info_marshall(namespace_info_t * namespace_info, const char *version, GError ** err)
{
asn_enc_rval_t encRet;
GByteArray *result = NULL;
NamespaceInfo_t asn1_namespace_info;
/*sanity checks */
if (!namespace_info) {
GSETERROR(err, "Invalid parameter");
goto error_params;
}
memset(&asn1_namespace_info, 0x00, sizeof(NamespaceInfo_t));
/* convert version to an int to easy compare */
// FIXME ugly piece of code!
gint64 versint64 = 0;
if(NULL != version) {
char *r = strchr(version,'.');
if(r) {
char tmp[256];
memset(tmp, '\0', 256);
g_snprintf(tmp, 256, "%.*s%s", (int)(r - version), version, r + 1);
versint64 = g_ascii_strtoll(tmp, NULL, 10);
TRACE("marshalling int64 : %"G_GINT64_FORMAT, versint64);
}
}
/*fills an ASN.1 structure */
if (!namespace_info_API2ASN(namespace_info, versint64, &asn1_namespace_info)) {
GSETERROR(err, "API to ASN.1 mapping error");
goto error_mapping;
}
/*serialize the ASN.1 structure */
if (!(result = g_byte_array_sized_new(4096))) {
GSETERROR(err, "memory allocation failure");
goto error_alloc_gba;
}
encRet = der_encode(&asn_DEF_NamespaceInfo, &asn1_namespace_info, write_in_gba, result);
if (encRet.encoded == -1) {
GSETERROR(err, "ASN.1 encoding error");
goto error_encode;
}
/*free the ASN.1 structure */
namespace_info_cleanASN(&asn1_namespace_info, TRUE);
return result;
error_encode:
g_byte_array_free(result, TRUE);
error_alloc_gba:
error_mapping:
namespace_info_cleanASN(&asn1_namespace_info, TRUE);
error_params:
return NULL;
}
void test_P2pResponse_dnm()
{
/// Building a P2pRequest ///
uint8_t macAddrDst[ETH_ALEN] = { 0xaf, 0xbe, 0xcd, 0xdc, 0xeb, 0xfa };
DNDSMessage_t *msg; // a DNDS Message
DNDSMessage_new(&msg);
DNDSMessage_set_channel(msg, 0);
DNDSMessage_set_pdu(msg, pdu_PR_dnm); // Dynamic Network Message
DNMessage_set_seqNumber(msg, 0);
DNMessage_set_ackNumber(msg, 801);
DNMessage_set_operation(msg, dnop_PR_p2pResponse);
P2pResponse_set_macAddrDst(msg, macAddrDst);
P2pResponse_set_result(msg, DNDSResult_success);
/// Encoding part
asn_enc_rval_t ec; // Encoder return value
FILE *fp = fopen("dnds.ber", "wb"); // BER output
ec = der_encode(&asn_DEF_DNDSMessage, msg, write_out, fp);
fclose(fp);
xer_fprint(stdout, &asn_DEF_DNDSMessage, msg);
DNDSMessage_del(msg);
}
static void
compare(T_t *tp, uint8_t *cmp_buf, int cmp_buf_size) {
asn_enc_rval_t erval;
int i;
buf_size = cmp_buf_size + 100;
buf = alloca(buf_size);
buf_pos = 0;
/*
* Try to re-create using DER encoding.
*/
erval = der_encode(&asn_DEF_T, tp, buf_fill, 0);
assert(erval.encoded != -1);
if(erval.encoded != cmp_buf_size) {
printf("%lld != %d\n", (long long)erval.encoded, cmp_buf_size);
}
assert(erval.encoded == cmp_buf_size);
for(i = 0; i < cmp_buf_size; i++) {
if(buf[i] != cmp_buf[i]) {
fprintf(stderr, "Recreated buffer content mismatch:\n");
fprintf(stderr, "Byte %d, %x != %x (%d != %d)\n",
i,
buf[i], cmp_buf[i],
buf[i], cmp_buf[i]
);
}
assert(buf[i] == cmp_buf[i]);
}
}
static bool encode_GSSSessionData(apr_pool_t *mempool,
GSSSessionData_t *gsessdata,
unsigned char **buf, int *len)
{
asn_enc_rval_t rval;
unsigned char *buffer = NULL;
size_t buflen;
bool ret = false;
/* dry run to compute the size */
rval = der_encode(&asn_DEF_GSSSessionData, gsessdata, NULL, NULL);
if (rval.encoded == -1) goto done;
buflen = rval.encoded;
buffer = apr_pcalloc(mempool, buflen);
/* now for real */
rval = der_encode_to_buffer(&asn_DEF_GSSSessionData,
gsessdata, buffer, buflen);
if (rval.encoded == -1) goto done;
*buf = buffer;
*len = buflen;
ret = true;
done:
return ret;
}
static int
save_object(void *bs, asn_TYPE_descriptor_t *td) {
asn_enc_rval_t rval; /* Return value */
int i;
rval = der_encode(td, bs, _buf_writer, 0);
if (rval.encoded == -1) {
fprintf(stderr,
"Cannot encode %s: %s\n",
rval.failed_type->name, strerror(errno));
assert(rval.encoded != -1);
return -1; /* JIC */
}
buf[buf_offset++] = 123; /* Finalize with garbage */
asn_fprint(stderr, td, bs);
xer_fprint(stderr, td, bs);
printf("OUT: [");
for(i = 0; i < buf_offset; i++)
printf(" %02x", buf[i]);
printf("]\n");
return 0;
}
void test_ModifyResponse()
{
/// Building a ModifyResponse ///
DNDSMessage_t *msg; // a DNDS Message
DNDSMessage_new(&msg);
DNDSMessage_set_channel(msg, 0);
DNDSMessage_set_pdu(msg, pdu_PR_dsm);
DSMessage_set_seqNumber(msg, 0);
DSMessage_set_ackNumber(msg, 300);
DSMessage_set_operation(msg, dsop_PR_modifyResponse);
ModifyResponse_set_result(msg, DNDSResult_success);
/// Encoding part
asn_enc_rval_t ec; // Encoder return value
FILE *fp = fopen("dnds.ber", "wb"); // BER output
ec = der_encode(&asn_DEF_DNDSMessage, msg, write_out, fp);
fclose(fp);
xer_fprint(stdout, &asn_DEF_DNDSMessage, msg);
DNDSMessage_del(msg);
}
void test_NetinfoRequest()
{
/// Building a NetinfoRequest ///
DNDSMessage_t *msg; // a DNDS Message
DNDSMessage_new(&msg);
DNDSMessage_set_channel(msg, 0);
DNDSMessage_set_pdu(msg, pdu_PR_dnm);
DNMessage_set_seqNumber(msg, 600);
DNMessage_set_ackNumber(msg, 0);
DNMessage_set_operation(msg, dnop_PR_netinfoRequest);
uint8_t macAddr[ETH_ALEN] = { 0xd, 0xe, 0xa, 0xd, 0xb, 0xe };
NetinfoRequest_set_ipLocal(msg, "192.168.10.10");
NetinfoRequest_set_macAddr(msg, macAddr);
/// Encoding part
asn_enc_rval_t ec; // Encoder return value
FILE *fp = fopen("dnds.ber", "wb"); // BER output
ec = der_encode(&asn_DEF_DNDSMessage, msg, write_out, fp);
fclose(fp);
xer_fprint(stdout, &asn_DEF_DNDSMessage, msg);
DNDSMessage_del(msg);
}
void test_DelRequest()
{
#if 0
/// Building a DelRequest ///
DNDSMessage_t *msg; // a DNDS Message
DNDSObject_t *objAcl; // a DNDS Object
DNDSMessage_new(&msg);
DNDSMessage_set_channel(msg, 0);
DNDSMessage_set_pdu(msg, pdu_PR_dsm); // Directory Service Message
DSMessage_set_seqNumber(msg, 200);
DSMessage_set_ackNumber(msg, 0);
DSMessage_set_operation(msg, dsop_PR_delRequest);
DelRequest_set_objectType(msg, DNDSObject_PR_acl, &objAcl);
Acl_set_id(objAcl, 1);
Acl_set_contextId(objAcl, 2);
Acl_set_description(objAcl, "une description", 15);
/// Encoding part
asn_enc_rval_t ec; // Encoder return value
FILE *fp = fopen("dnds.ber", "wb"); // BER output
ec = der_encode(&asn_DEF_DNDSMessage, msg, write_out, fp);
fclose(fp);
xer_fprint(stdout, &asn_DEF_DNDSMessage, msg);
DNDSMessage_del(msg);
#endif
}
void test_ModifyRequest()
{
#if 0
/// Building a ModifyRequest ///
DNDSMessage_t *msg; // a DNDS Message
DNDSObject_t *objAclGroup;
DNDSMessage_new(&msg);
DNDSMessage_set_channel(msg, 0);
DNDSMessage_set_pdu(msg, pdu_PR_dsm);
DSMessage_set_seqNumber(msg, 300);
DSMessage_set_ackNumber(msg, 0);
DSMessage_set_operation(msg, dsop_PR_modifyRequest);
ModifyRequest_set_objectType(msg, DNDSObject_PR_aclgroup, &objAclGroup);
AclGroup_set_id(objAclGroup, 1);
AclGroup_set_contextId(objAclGroup, 1);
AclGroup_set_name(objAclGroup, "group-name", 10);
AclGroup_set_description(objAclGroup, "a description", 13);
/// Encoding part
asn_enc_rval_t ec; // Encoder return value
FILE *fp = fopen("dnds.ber", "wb"); // BER output
ec = der_encode(&asn_DEF_DNDSMessage, msg, write_out, fp);
fclose(fp);
xer_fprint(stdout, &asn_DEF_DNDSMessage, msg);
DNDSMessage_del(msg);
#endif
}
void test_TerminateRequest()
{
/// Building a TerminateRequest ///
DNDSMessage_t *msg; // a DNDS Message
DNDSMessage_new(&msg);
DNDSMessage_set_channel(msg, 0);
DNDSMessage_set_pdu(msg, pdu_PR_dsm);
DSMessage_set_seqNumber(msg, 0);
DSMessage_set_ackNumber(msg, 400);
DSMessage_set_operation(msg, dsop_PR_terminateRequest);
/// Encoding part
asn_enc_rval_t ec; // Encoder return value
FILE *fp = fopen("dnds.ber", "wb"); // BER output
ec = der_encode(&asn_DEF_DNDSMessage, msg, write_out, fp);
fclose(fp);
xer_fprint(stdout, &asn_DEF_DNDSMessage, msg);
DNDSMessage_del(msg);
}
int
mmsClient_createReadRequestAlternateAccessIndex(uint32_t invokeId, const char* domainId, const char* itemId,
uint32_t index, uint32_t elementCount, ByteBuffer* writeBuffer)
{
MmsPdu_t* mmsPdu = mmsClient_createConfirmedRequestPdu(invokeId);
ReadRequest_t* readRequest = createReadRequest(mmsPdu);
readRequest->specificationWithResult = NULL;
readRequest->variableAccessSpecification.present = VariableAccessSpecification_PR_listOfVariable;
readRequest->variableAccessSpecification.choice.listOfVariable.list.array = (ListOfVariableSeq_t**) GLOBAL_CALLOC(1, sizeof(ListOfVariableSeq_t*));
readRequest->variableAccessSpecification.choice.listOfVariable.list.count = 1;
ListOfVariableSeq_t* variableIdentifier = createVariableIdentifier(domainId, itemId);
readRequest->variableAccessSpecification.choice.listOfVariable.list.array[0] = variableIdentifier;
variableIdentifier->alternateAccess = createAlternateAccess(index, elementCount);
asn_enc_rval_t rval;
rval = der_encode(&asn_DEF_MmsPdu, mmsPdu,
(asn_app_consume_bytes_f*) mmsClient_write_out, (void*) writeBuffer);
variableIdentifier->variableSpecification.choice.name.choice.domainspecific.domainId.buf = 0;
variableIdentifier->variableSpecification.choice.name.choice.domainspecific.domainId.size = 0;
variableIdentifier->variableSpecification.choice.name.choice.domainspecific.itemId.buf = 0;
variableIdentifier->variableSpecification.choice.name.choice.domainspecific.itemId.size = 0;
asn_DEF_MmsPdu.free_struct(&asn_DEF_MmsPdu, mmsPdu, 0);
return rval.encoded;
}
void test_P2pRequest_dnm()
{
/// Building a P2pRequest ///
int ret;
uint8_t macAddrSrc[ETH_ALEN] = { 0xe6, 0x1b, 0x23, 0x0c, 0x0c, 0x5d };
uint8_t macAddrDst[ETH_ALEN] = { 0xe6, 0x1b, 0x23, 0x0c, 0x0c, 0x5d };
DNDSMessage_t *msg; // a DNDS Message
DNDSMessage_new(&msg);
DNDSMessage_set_channel(msg, 0);
DNDSMessage_set_pdu(msg, pdu_PR_dnm); // Dynamic Network Message
DNMessage_set_seqNumber(msg, 801);
DNMessage_set_ackNumber(msg, 0);
DNMessage_set_operation(msg, dnop_PR_p2pRequest);
P2pRequest_set_ipAddrDst(msg, "66.55.44.33");
P2pRequest_set_port(msg, 9000);
P2pRequest_set_side(msg, P2pSide_client);
P2pRequest_set_macAddrDst(msg, macAddrDst);
/// Encoding part
asn_enc_rval_t ec; // Encoder return value
FILE *fp = fopen("dnds.ber", "wb"); // BER output
ec = der_encode(&asn_DEF_DNDSMessage, msg, write_out, fp);
fclose(fp);
xer_fprint(stdout, &asn_DEF_DNDSMessage, msg);
DNDSMessage_del(msg);
}
static void
save_object_as(PDU_t *st, enum der_or_xer how) {
asn_enc_rval_t rval; /* Return value */
buf_offset = 0;
/*
* Save object using specified method.
*/
switch(how) {
case AS_DER:
rval = der_encode(&asn_DEF_PDU, st,
_buf_writer, 0);
break;
case AS_XER:
rval = xer_encode(&asn_DEF_PDU, st, XER_F_BASIC,
_buf_writer, 0);
break;
case AS_CXER:
rval = xer_encode(&asn_DEF_PDU, st, XER_F_CANONICAL,
_buf_writer, 0);
break;
}
if (rval.encoded == -1) {
fprintf(stderr,
"Cannot encode %s: %s\n",
rval.failed_type->name, strerror(errno));
assert(rval.encoded != -1);
return;
}
fprintf(stderr, "SAVED OBJECT IN SIZE %d\n", buf_offset);
}
void test_SearchRequest_context()
{
/// Building a SearchRequest context ///
int ret;
DNDSMessage_t *msg; // a DNDS Message
DNDSMessage_new(&msg);
DNDSMessage_set_channel(msg, 0);
DNDSMessage_set_pdu(msg, pdu_PR_dsm); // Directory Service Message
DSMessage_set_seqNumber(msg, 800);
DSMessage_set_ackNumber(msg, 0);
DSMessage_set_operation(msg, dsop_PR_searchRequest);
SearchRequest_set_searchType(msg, SearchType_all);
SearchRequest_set_objectName(msg, ObjectName_context);
/// Encoding part
asn_enc_rval_t ec; // Encoder return value
FILE *fp = fopen("dnds.ber", "wb"); // BER output
ec = der_encode(&asn_DEF_DNDSMessage, msg, write_out, fp);
fclose(fp);
xer_fprint(stdout, &asn_DEF_DNDSMessage, msg);
DNDSMessage_del(msg);
}
void test_NodeConnectInfo()
{
/// Building a NodeConnectInfo ///
int ret;
DNDSMessage_t *msg;
DNDSMessage_new(&msg);
DNDSMessage_set_channel(msg, 0);
DNDSMessage_set_pdu(msg, pdu_PR_dsm); // Directory Service Message
DSMessage_set_seqNumber(msg, 800);
DSMessage_set_ackNumber(msg, 0);
//DSMessage_set_operation(msg, dsop_PR_nodeConnectInfo);
//NodeConnectInfo_set_certName(msg, "unique_name@context", 19);
//NodeConnectInfo_set_ipAddr(msg, "44.128.0.1");
//NodeConnectInfo_set_state(msg, ConnectState_connected);
/// Encoding part
asn_enc_rval_t ec; // Encoder return value
FILE *fp = fopen("dnds.ber", "wb"); // BER output
ec = der_encode(&asn_DEF_DNDSMessage, msg, write_out, fp);
fclose(fp);
xer_fprint(stdout, &asn_DEF_DNDSMessage, msg);
DNDSMessage_del(msg);
}
test_AddRequest_context()
{
/// Building context AddRequest ///
DNDSMessage_t *msg;
DNDSObject_t *obj;
DNDSMessage_new(&msg);
DNDSMessage_set_channel(msg, 0);
DNDSMessage_set_pdu(msg, pdu_PR_dsm);
DSMessage_set_seqNumber(msg, 0);
DSMessage_set_ackNumber(msg, 0);
DSMessage_set_operation(msg, dsop_PR_addRequest);
AddRequest_set_objectType(msg, DNDSObject_PR_context, &obj);
Context_set_clientId(obj, 100);
Context_set_description(obj, "home network1", 13);
Context_set_network(obj, "44.128.0.0");
Context_set_netmask(obj, "255.255.255.0");
/// Encoding part
asn_enc_rval_t ec; // Encoder return value
FILE *fp = fopen("dnds.ber", "wb"); // BER output
ec = der_encode(&asn_DEF_DNDSMessage, msg, write_out, fp);
fclose(fp);
xer_fprint(stdout, &asn_DEF_DNDSMessage, msg);
DNDSMessage_del(msg);
}
test_AddRequest_node()
{
/// Building node AddRequest ///
DNDSMessage_t *msg;
DNDSObject_t *obj;
DNDSMessage_new(&msg);
DNDSMessage_set_channel(msg, 0);
DNDSMessage_set_pdu(msg, pdu_PR_dsm);
DSMessage_set_seqNumber(msg, 0);
DSMessage_set_ackNumber(msg, 0);
DSMessage_set_operation(msg, dsop_PR_addRequest);
AddRequest_set_objectType(msg, DNDSObject_PR_node, &obj);
Node_set_contextId(obj, 100);
Node_set_description(obj, "voip node 1", 11);
/// Encoding part
asn_enc_rval_t ec; // Encoder return value
FILE *fp = fopen("dnds.ber", "wb"); // BER output
ec = der_encode(&asn_DEF_DNDSMessage, msg, write_out, fp);
fclose(fp);
xer_fprint(stdout, &asn_DEF_DNDSMessage, msg);
DNDSMessage_del(msg);
}
void test_DNDS_ethernet()
{
/// Building an message ethernet frame ///
DNDSMessage_t *msg; // a DNDS Message
DNDSMessage_new(&msg);
DNDSMessage_set_channel(msg, 0);
DNDSMessage_set_pdu(msg, pdu_PR_ethernet); // ethernet frame
uint8_t *frame = strdup("0110101010101");
size_t frame_size = 13;
DNDSMessage_set_ethernet(msg, frame, frame_size);
/// Encoding part
asn_enc_rval_t ec; // Encoder return value
FILE *fp = fopen("dnds.ber", "wb"); // BER output
ec = der_encode(&asn_DEF_DNDSMessage, msg, write_out, fp);
fclose(fp);
xer_fprint(stdout, &asn_DEF_DNDSMessage, msg);
// XXX free(frame)
DNDSMessage_del(msg);
}
void test_NetinfoResponse()
{
/// Building a NetinfoResponse ///
DNDSMessage_t *msg; // a DNDS Message
DNDSMessage_new(&msg);
DNDSMessage_set_channel(msg, 0);
DNDSMessage_set_pdu(msg, pdu_PR_dnm);
DNMessage_set_seqNumber(msg, 0);
DNMessage_set_ackNumber(msg, 600);
DNMessage_set_operation(msg, dnop_PR_netinfoResponse);
NetinfoResponse_set_ipAddress(msg, "192.168.10.5");
NetinfoResponse_set_netmask(msg, "255.255.255.0");
NetinfoResponse_set_result(msg, DNDSResult_success);
/// Encoding part
asn_enc_rval_t ec; // Encoder return value
FILE *fp = fopen("dnds.ber", "wb"); // BER output
ec = der_encode(&asn_DEF_DNDSMessage, msg, write_out, fp);
fclose(fp);
xer_fprint(stdout, &asn_DEF_DNDSMessage, msg);
DNDSMessage_del(msg);
}
static void
compare(T_t *tp, uint8_t *cmp_buf, size_t cmp_buf_size) {
asn_enc_rval_t erval;
buf_size = cmp_buf_size + 100;
uint8_t scratch[buf_size];
buf = scratch;
buf_pos = 0;
/*
* Try to re-create using DER encoding.
*/
erval = der_encode(&asn_DEF_T, tp, buf_fill, 0);
assert(erval.encoded != -1);
if((size_t)erval.encoded != cmp_buf_size) {
printf("%zd != %zd\n", erval.encoded, cmp_buf_size);
assert((size_t)erval.encoded == cmp_buf_size);
}
for(size_t i = 0; i < cmp_buf_size; i++) {
if(buf[i] != cmp_buf[i]) {
fprintf(stderr, "Recreated buffer content mismatch:\n");
fprintf(stderr, "Byte %zd, %x != %x (%d != %d)\n",
i,
buf[i], cmp_buf[i],
buf[i], cmp_buf[i]
);
}
assert(buf[i] == cmp_buf[i]);
}
buf = 0;
}
/**********************************************************************************************
* writeMmsRejectPdu
*********************************************************************************************/
static void writeMmsRejectPdu(int* invokeId, int reason, ByteBuffer* response) {
MmsPdu_t* mmsPdu = calloc(1, sizeof(MmsPdu_t));
asn_enc_rval_t rval;
mmsPdu->present = MmsPdu_PR_rejectPDU;
if (invokeId != NULL) {
mmsPdu->choice.rejectPDU.originalInvokeID = calloc(1, sizeof(Unsigned32_t));
asn_long2INTEGER(mmsPdu->choice.rejectPDU.originalInvokeID, *invokeId);
}
if (reason == REJECT_UNRECOGNIZED_SERVICE) {
mmsPdu->choice.rejectPDU.rejectReason.present = RejectPDU__rejectReason_PR_confirmedRequestPDU;
mmsPdu->choice.rejectPDU.rejectReason.choice.confirmedResponsePDU =
RejectPDU__rejectReason__confirmedRequestPDU_unrecognizedService;
}
else if(reason == REJECT_UNKNOWN_PDU_TYPE) {
mmsPdu->choice.rejectPDU.rejectReason.present = RejectPDU__rejectReason_PR_pduError;
asn_long2INTEGER(&mmsPdu->choice.rejectPDU.rejectReason.choice.pduError,
RejectPDU__rejectReason__pduError_unknownPduType);
}
else {
mmsPdu->choice.rejectPDU.rejectReason.present = RejectPDU__rejectReason_PR_confirmedRequestPDU;
mmsPdu->choice.rejectPDU.rejectReason.choice.confirmedResponsePDU =
RejectPDU__rejectReason__confirmedRequestPDU_other;
}
rval = der_encode(&asn_DEF_MmsPdu, mmsPdu,mmsServer_write_out, (void*) response);
if (DEBUG) xer_fprint(stdout, &asn_DEF_MmsPdu, mmsPdu);
asn_DEF_MmsPdu.free_struct(&asn_DEF_MmsPdu, mmsPdu, 0);
}
void test_AuthResponse_dnm()
{
/// Building an AuthRequest ///
DNDSMessage_t *msg; // a DNDS Message
DNDSMessage_new(&msg);
DNDSMessage_set_channel(msg, 0);
DNDSMessage_set_pdu(msg, pdu_PR_dnm); // Dynamic Network Message
DNMessage_set_seqNumber(msg, 0);
DNMessage_set_ackNumber(msg, 100);
DNMessage_set_operation(msg, dnop_PR_authResponse);
AuthResponse_set_result(msg, DNDSResult_success);
/// Encoding part
asn_enc_rval_t ec; // Encoder return value
FILE *fp = fopen("dnds.ber", "wb"); // BER output
ec = der_encode(&asn_DEF_DNDSMessage, msg, write_out, fp);
fclose(fp);
xer_fprint(stdout, &asn_DEF_DNDSMessage, msg);
DNDSMessage_del(msg);
}
void test_AuthRequest()
{
/// Building an AuthRequest ///
DNDSMessage_t *msg; // a DNDS Message
DNDSMessage_new(&msg);
DNDSMessage_set_channel(msg, 0);
DNDSMessage_set_pdu(msg, pdu_PR_dsm); // Directory Service Message
DSMessage_set_seqNumber(msg, 100);
DSMessage_set_ackNumber(msg, 0);
DSMessage_set_operation(msg, dnop_PR_authRequest);
AuthRequest_set_certName(msg, "nib@1", 5);
/// Encoding part
asn_enc_rval_t ec; // Encoder return value
FILE *fp = fopen("dnds.ber", "wb"); // BER output
ec = der_encode(&asn_DEF_DNDSMessage, msg, write_out, fp);
fclose(fp);
xer_fprint(stdout, &asn_DEF_DNDSMessage, msg);
DNDSMessage_del(msg);
}
void test_SearchResponse()
{
printf("TEST SEARCH RESPONSE\n");
/// Building a SearchResponse
DNDSMessage_t *msg; // A DNDS Message
DNDSMessage_new(&msg);
DNDSMessage_set_channel(msg, 0);
DNDSMessage_set_pdu(msg, pdu_PR_dsm);
DSMessage_set_seqNumber(msg, 0);
DSMessage_set_ackNumber(msg, 1);
DSMessage_set_action(msg, action_listNode);
DSMessage_set_operation(msg, dsop_PR_searchResponse);
SearchResponse_set_result(msg, DNDSResult_success);
SearchResponse_set_searchType(msg, SearchType_object);
/*
/// objContext
DNDSObject_t *objContext;
DNDSObject_new(&objContext);
DNDSObject_set_objectType(objContext, DNDSObject_PR_context);
Context_set_id(objContext, 40);
SearchResponse_add_object(msg, objContext);
*/
/// Node
DNDSObject_t *objNode;
DNDSObject_new(&objNode);
DNDSObject_set_objectType(objNode, DNDSObject_PR_node);
// Node_set_contextId(objNode, 10);
Node_set_description(objNode, "yo", strlen("yo"));
Node_set_uuid(objNode, "abc", strlen("abc"));
Node_set_certificate(objNode, "certificate", 11);
Node_set_certificateKey(objNode, "key", 3);
Node_set_status(objNode, 2);
SearchResponse_add_object(msg, objNode);
/// Encoding part
asn_enc_rval_t ec; // Encoder return value
FILE *fp = fopen("dnds.ber", "wb"); // BER output
ec = der_encode(&asn_DEF_DNDSMessage, msg, write_out, fp);
fclose(fp);
xer_fprint(stdout, &asn_DEF_DNDSMessage, msg);
DNDSMessage_del(msg);
}
int
mmsClient_createWriteRequest(uint32_t invokeId, char* domainId, char* itemId, MmsValue* value,
ByteBuffer* writeBuffer)
{
//TODO reuse code to send information report!
MmsPdu_t* mmsPdu = mmsClient_createConfirmedRequestPdu(invokeId);
mmsPdu->choice.confirmedRequestPdu.confirmedServiceRequest.present =
ConfirmedServiceRequest_PR_write;
WriteRequest_t* request =
&(mmsPdu->choice.confirmedRequestPdu.confirmedServiceRequest.choice.write);
/* Create list of variable specifications */
request->variableAccessSpecification.present = VariableAccessSpecification_PR_listOfVariable;
request->variableAccessSpecification.choice.listOfVariable.list.count = 1;
request->variableAccessSpecification.choice.listOfVariable.list.size = 1;
request->variableAccessSpecification.choice.listOfVariable.list.array =
(ListOfVariableSeq_t**) calloc(1, sizeof(ListOfVariableSeq_t*));
request->variableAccessSpecification.choice.listOfVariable.list.array[0] = (ListOfVariableSeq_t*)
createNewDomainVariableSpecification(domainId, itemId);
/* Create list of typed data values */
request->listOfData.list.count = 1;
request->listOfData.list.size = 1;
request->listOfData.list.array = (Data_t**) calloc(1, sizeof(struct Data*));
request->listOfData.list.array[0] = mmsMsg_createBasicDataElement(value);
asn_enc_rval_t rval;
rval = der_encode(&asn_DEF_MmsPdu, mmsPdu,
(asn_app_consume_bytes_f*) mmsClient_write_out, (void*) writeBuffer);
if (DEBUG) xer_fprint(stdout, &asn_DEF_MmsPdu, mmsPdu);
/* Free ASN structure */
request->variableAccessSpecification.choice.listOfVariable.list.count = 0;
free(request->variableAccessSpecification.choice.listOfVariable.list.array[0]);
free(request->variableAccessSpecification.choice.listOfVariable.list.array);
request->variableAccessSpecification.choice.listOfVariable.list.array = 0;
request->listOfData.list.count = 0;
deleteDataElement(request->listOfData.list.array[0]);
free(request->listOfData.list.array);
request->listOfData.list.array = 0;
asn_DEF_MmsPdu.free_struct(&asn_DEF_MmsPdu, mmsPdu, 0);
return rval.encoded;
}
int
mmsClient_createGetNameListRequestDomainOrVMDSpecific(long invokeId, const char* domainName,
ByteBuffer* writeBuffer, MmsObjectClass objectClass, const char* continueAfter)
{
MmsPdu_t* mmsPdu = mmsClient_createConfirmedRequestPdu(invokeId);
mmsPdu->choice.confirmedRequestPdu.confirmedServiceRequest.present =
ConfirmedServiceRequest_PR_getNameList;
GetNameListRequest_t* request;
request = &(mmsPdu->choice.confirmedRequestPdu.confirmedServiceRequest.choice.getNameList);
if (continueAfter != NULL) {
request->continueAfter = (Identifier_t*) GLOBAL_CALLOC(1, sizeof(Identifier_t));
request->continueAfter->buf = (uint8_t*) copyString(continueAfter);
request->continueAfter->size = strlen(continueAfter);
}
else
request->continueAfter = NULL;
if (domainName != NULL) {
request->objectScope.present = GetNameListRequest__objectScope_PR_domainSpecific;
request->objectScope.choice.domainSpecific.buf = (uint8_t*) domainName;
request->objectScope.choice.domainSpecific.size = strlen(domainName);
}
else {
request->objectScope.present = GetNameListRequest__objectScope_PR_vmdSpecific;
}
request->objectClass.present = ObjectClass_PR_basicObjectClass;
if (objectClass == MMS_NAMED_VARIABLE)
asn_long2INTEGER(&request->objectClass.choice.basicObjectClass,
ObjectClass__basicObjectClass_namedVariable);
else if (objectClass == MMS_NAMED_VARIABLE_LIST)
asn_long2INTEGER(&request->objectClass.choice.basicObjectClass,
ObjectClass__basicObjectClass_namedVariableList);
asn_enc_rval_t rval;
rval = der_encode(&asn_DEF_MmsPdu, mmsPdu,
(asn_app_consume_bytes_f*) mmsClient_write_out, (void*) writeBuffer);
request->objectScope.choice.domainSpecific.buf = 0;
request->objectScope.choice.domainSpecific.size = 0;
asn_DEF_MmsPdu.free_struct(&asn_DEF_MmsPdu, mmsPdu, 0);
return rval.encoded;
}
static int
createVariableAccessAttributesResponse(
MmsServerConnection* connection,
char* domainId,
char* nameId,
int invokeId,
ByteBuffer* response)
{
MmsDevice* device = MmsServer_getDevice(connection->server);
MmsDomain* domain = MmsDevice_getDomain(device, domainId);
if (domain == NULL) {
if (DEBUG) printf("mms_server: domain %s not known\n", domainId);
return -1;
}
MmsTypeSpecification* namedVariable = MmsDomain_getNamedVariable(domain, nameId);
if (namedVariable == NULL) {
if (DEBUG) printf("mms_server: named variable %s not known\n", nameId);
return -1;
}
MmsPdu_t* mmsPdu = mmsServer_createConfirmedResponse(invokeId);
mmsPdu->choice.confirmedResponsePdu.confirmedServiceResponse.present =
ConfirmedServiceResponse_PR_getVariableAccessAttributes;
GetVariableAccessAttributesResponse_t* getVarAccessAttr;
getVarAccessAttr = &(mmsPdu->choice.confirmedResponsePdu.
confirmedServiceResponse.choice.getVariableAccessAttributes);
getVarAccessAttr->mmsDeletable = 0;
createTypeSpecification(namedVariable, &getVarAccessAttr->typeSpecification);
asn_enc_rval_t rval;
rval = der_encode(&asn_DEF_MmsPdu, mmsPdu,
mmsServer_write_out, (void*) response);
if (DEBUG) xer_fprint(stdout, &asn_DEF_MmsPdu, mmsPdu);
deleteVariableAccessAttributesResponse(getVarAccessAttr);
asn_DEF_MmsPdu.free_struct(&asn_DEF_MmsPdu, mmsPdu, 0);
return 0;
}
/**
* Request a single value
*/
int
mmsClient_createReadRequest(uint32_t invokeId, const char* domainId, const char* itemId, ByteBuffer* writeBuffer)
{
MmsPdu_t* mmsPdu = mmsClient_createConfirmedRequestPdu(invokeId);
ReadRequest_t* readRequest = createReadRequest(mmsPdu);
readRequest->specificationWithResult = NULL;
readRequest->variableAccessSpecification.present = VariableAccessSpecification_PR_listOfVariable;
readRequest->variableAccessSpecification.choice.listOfVariable.list.array =
(ListOfVariableSeq_t**) GLOBAL_CALLOC(1, sizeof(ListOfVariableSeq_t*));
readRequest->variableAccessSpecification.choice.listOfVariable.list.count = 1;
ListOfVariableSeq_t* listOfVars = (ListOfVariableSeq_t*) GLOBAL_CALLOC(1, sizeof(ListOfVariableSeq_t));
readRequest->variableAccessSpecification.choice.listOfVariable.list.array[0] = listOfVars;
listOfVars->alternateAccess = NULL;
listOfVars->variableSpecification.present = VariableSpecification_PR_name;
if (domainId != NULL) {
listOfVars->variableSpecification.choice.name.present = ObjectName_PR_domainspecific;
listOfVars->variableSpecification.choice.name.choice.domainspecific.domainId.buf = (uint8_t*) domainId;
listOfVars->variableSpecification.choice.name.choice.domainspecific.domainId.size = strlen(domainId);
listOfVars->variableSpecification.choice.name.choice.domainspecific.itemId.buf = (uint8_t*) itemId;
listOfVars->variableSpecification.choice.name.choice.domainspecific.itemId.size = strlen(itemId);
}
else {
listOfVars->variableSpecification.choice.name.present = ObjectName_PR_vmdspecific;
listOfVars->variableSpecification.choice.name.choice.vmdspecific.buf = (uint8_t*) itemId;
listOfVars->variableSpecification.choice.name.choice.vmdspecific.size = strlen(itemId);
}
asn_enc_rval_t rval;
rval = der_encode(&asn_DEF_MmsPdu, mmsPdu,
(asn_app_consume_bytes_f*) mmsClient_write_out, (void*) writeBuffer);
/* clean up data structures */
GLOBAL_FREEMEM(listOfVars);
GLOBAL_FREEMEM(readRequest->variableAccessSpecification.choice.listOfVariable.list.array);
readRequest->variableAccessSpecification.choice.listOfVariable.list.array = NULL;
readRequest->variableAccessSpecification.choice.listOfVariable.list.count = 0;
asn_DEF_MmsPdu.free_struct(&asn_DEF_MmsPdu, mmsPdu, 0);
return rval.encoded;
}
