/**********************************************************************************************
* 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);
}
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;
}
asn_enc_rval_t
NativeInteger_encode_aper(
asn_TYPE_descriptor_t *td,
asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
asn_enc_rval_t er;
long native;
INTEGER_t tmpint;
if(!sptr) _ASN_ENCODE_FAILED;
native = *(long *)sptr;
ASN_DEBUG("Encoding NativeInteger %s %ld (APER)", td->name, native);
memset(&tmpint, 0, sizeof(tmpint));
if((specs&&specs->field_unsigned)
? asn_ulong2INTEGER(&tmpint, native)
: asn_long2INTEGER(&tmpint, native))
_ASN_ENCODE_FAILED;
er = INTEGER_encode_aper(td, constraints, &tmpint, po);
ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
return er;
}
static void
check(uint8_t *buf, int size, long check_long, int check_ret) {
char scratch[128];
char verify[32];
INTEGER_t val;
uint8_t *buf_end = buf + size;
int ret;
long rlong = 123;
assert(buf);
assert(size >= 0);
val.buf = buf;
val.size = size;
printf("Testing: [");
for(; buf < buf_end; buf++) {
if(buf != val.buf) printf(":");
printf("%02x", *buf);
}
printf("]: ");
ret = asn_INTEGER2long(&val, &rlong);
printf(" (%ld, %d) vs (%ld, %d)\n",
rlong, ret, check_long, check_ret);
assert(ret == check_ret);
printf("%ld %ld\n", rlong, check_long);
assert(rlong == check_long);
if(check_ret == 0) {
INTEGER_t val2;
long rlong2;
val2.buf = 0;
val2.size = 0;
ret = asn_long2INTEGER(&val2, rlong);
assert(ret == 0);
assert(val2.buf);
assert(val2.size <= val.size); /* At least as compact */
ret = asn_INTEGER2long(&val, &rlong2);
assert(ret == 0);
assert(rlong == rlong2);
}
shared_scratch_start = scratch;
ret = INTEGER_print(&asn_DEF_INTEGER, &val, 0, _print2buf, scratch);
assert(shared_scratch_start < scratch + sizeof(scratch));
assert(ret == 0);
ret = snprintf(verify, sizeof(verify), "%ld", check_long);
assert(ret < sizeof(verify));
ret = strcmp(scratch, verify);
printf(" [%s] vs [%s]: %d%s\n",
scratch, verify, ret,
(check_ret == -1)?" (expected to fail)":""
);
if(check_ret == -1) {
assert(strcmp(scratch, verify));
} else {
assert(strcmp(scratch, verify) == 0);
}
}
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;
}
void ldap_bind(int msgid, BindRequest_t *req, ev_loop *loop, ev_io *watcher)
{
ev_tstamp delay = 0.0;
LDAPMessage_t *res = XNEW0(LDAPMessage_t, 1);
res->messageID = msgid;
res->protocolOp.present = LDAPMessage__protocolOp_PR_bindResponse;
BindResponse_t *bindResponse = &res->protocolOp.choice.bindResponse;
OCTET_STRING_fromBuf(&bindResponse->matchedDN, (const char *)req->name.buf, req->name.size);
if (setting_anonymous && req->name.size == 0) {
/* allow anonymous */
asn_long2INTEGER(&bindResponse->resultCode, BindResponse__resultCode_success);
} else if (req->authentication.present == AuthenticationChoice_PR_simple) {
/* simple auth */
char *user = cn2name((const char *)req->name.buf);
char *pw = (char *)req->authentication.choice.simple.buf;
char *status = NULL;
if (!user) {
asn_long2INTEGER(&bindResponse->resultCode, BindResponse__resultCode_invalidDNSyntax);
} else if (PAM_SUCCESS != auth_pam(user, pw, &status, &delay)) {
asn_long2INTEGER(&bindResponse->resultCode, BindResponse__resultCode_invalidCredentials);
OCTET_STRING_fromString(&bindResponse->diagnosticMessage, status);
} else { /* Success! */
asn_long2INTEGER(&bindResponse->resultCode, BindResponse__resultCode_success);
}
free(user);
free(status);
} else {
/* sasl or anonymous auth */
asn_long2INTEGER(&bindResponse->resultCode, BindResponse__resultCode_authMethodNotSupported);
}
if (delay > 0.0) {
ev_timer *delay_timer = XNEW(ev_timer, 1);
delay_data_t *data = XNEW(delay_data_t, 1);
data->message = res;
data->watcher = watcher;
ev_timer_init(delay_timer, delay_cb, delay, 0.0);
delay_timer->data = data;
/* Stop the connection watcher to stop other requests while delayed. */
ev_io_stop(loop, watcher);
ev_timer_start(loop, delay_timer);
} else {
ldap_send(res, loop, watcher);
ldapmessage_free(res);
}
}
// ustawienie porzadanej wersji struktury SignedData.
// Funkcja ustawia (!), nie wykonuje weryfikacji, czy takie ustawienie
// jest sluszne.
long SignedData_set_CMSVersion(SignedData_t *sigData, CMSVersion_e version)
{
// long err = 0;
if ( sigData == NULL )
return ERR_WRONG_ARGUMENT;
asn_long2INTEGER( &(sigData->version), version);
return 0;
}
// ustawienie porzadanej wersji struktury EnvelopedData.
// Funkcja ustawia (!), nie wykonuje weryfikacji, czy takie ustawienie
// jest sluszne.
long EnvelopedData_set_CMSVersion(EnvelopedData_t *envData, CMSVersion_e version)
{
// long err = 0;
if ( envData == NULL )
return ERR_WRONG_ARGUMENT;
asn_long2INTEGER( &(envData->version), version);
return 0;
}
void ldap_search(int msgid, SearchRequest_t *req, ev_loop *loop, ev_io *watcher)
{
/* (user=$username$) => cn=$username$,BASEDN */
char user[BUF_SIZE];
LDAPMessage_t *res = XNEW0(LDAPMessage_t, 1);
AttributeValueAssertion_t *attr = &req->filter.choice.equalityMatch;
int bad_dn = strcmp((const char *)req->baseObject.buf, setting_basedn)
&& strcmp((const char *)req->baseObject.buf, "");
int bad_filter = req->filter.present != Filter_PR_equalityMatch
|| strcmp((const char *)attr->attributeDesc.buf, "user");
res->messageID = msgid;
if (!bad_dn && !bad_filter) {
/* result of search */
res->protocolOp.present = LDAPMessage__protocolOp_PR_searchResEntry;
SearchResultEntry_t *searchResEntry = &res->protocolOp.choice.searchResEntry;
snprintf(user, BUF_SIZE, "cn=%s,%s", (const char *)attr->assertionValue.buf, setting_basedn);
OCTET_STRING_fromString(&searchResEntry->objectName, user);
if (ldap_send(res, loop, watcher) <= 0) {
ldapmessage_free(res);
return;
}
ldapmessage_empty(res);
}
/* search is done */
res->protocolOp.present = LDAPMessage__protocolOp_PR_searchResDone;
SearchResultDone_t *searchResDone = &res->protocolOp.choice.searchResDone;
if (bad_dn) {
asn_long2INTEGER(&searchResDone->resultCode, LDAPResult__resultCode_other);
OCTET_STRING_fromString(&searchResDone->diagnosticMessage, "baseobject is invalid");
} else if (bad_filter) {
asn_long2INTEGER(&searchResDone->resultCode, LDAPResult__resultCode_other);
OCTET_STRING_fromString(&searchResDone->diagnosticMessage, "filter not supported");
} else {
asn_long2INTEGER(&searchResDone->resultCode, LDAPResult__resultCode_success);
OCTET_STRING_fromString(&searchResDone->matchedDN, setting_basedn);
}
ldap_send(res, loop, watcher);
ldapmessage_free(res);
}
// Ustawienie wersji struktury SignerInfo
// Nie nastepuje weryfikacja poprawnosci.
long SignerInfo_set_CMSVersion(
SignerInfo_t *signerInfo,
CMSVersion_e version)
{
if ( signerInfo == NULL )
return ERR_WRONG_ARGUMENT;
asn_long2INTEGER( &(signerInfo->version), version);
return 0;
}
int
main()
{
/* Initialize values which can't use static initializers. */
asn_long2INTEGER(&otp_format, 2); /* Alphanumeric */
asn_long2INTEGER(&kvno, 5);
OBJECT_IDENTIFIER_set_arcs(&alg_sha256.algorithm, sha256_arcs,
sizeof(*sha256_arcs),
sizeof(sha256_arcs) / sizeof(*sha256_arcs));
OBJECT_IDENTIFIER_set_arcs(&alg_sha1.algorithm, sha1_arcs,
sizeof(*sha1_arcs),
sizeof(sha1_arcs) / sizeof(*sha1_arcs));
printf("Minimal OTP-TOKEN-INFO:\n");
der_encode(&asn_DEF_OTP_TOKENINFO, &token_info_1, consume, NULL);
printbuf();
printf("\nMaximal OTP-TOKEN-INFO:\n");
der_encode(&asn_DEF_OTP_TOKENINFO, &token_info_2, consume, NULL);
printbuf();
printf("\nMinimal PA-OTP-CHALLENGE:\n");
der_encode(&asn_DEF_PA_OTP_CHALLENGE, &challenge_1, consume, NULL);
printbuf();
printf("\nMaximal PA-OTP-CHALLENGE:\n");
der_encode(&asn_DEF_PA_OTP_CHALLENGE, &challenge_2, consume, NULL);
printbuf();
printf("\nMinimal PA-OTP-REQUEST:\n");
der_encode(&asn_DEF_PA_OTP_REQUEST, &request_1, consume, NULL);
printbuf();
printf("\nMaximal PA-OTP-REQUEST:\n");
der_encode(&asn_DEF_PA_OTP_REQUEST, &request_2, consume, NULL);
printbuf();
printf("\nPA-OTP-ENC-REQUEST:\n");
der_encode(&asn_DEF_PA_OTP_ENC_REQUEST, &enc_request, consume, NULL);
printbuf();
printf("\n");
return 0;
}
MmsPdu_t*
mmsClient_createConfirmedRequestPdu(uint32_t invokeId)
{
MmsPdu_t* mmsPdu = (MmsPdu_t*) calloc(1, sizeof(MmsPdu_t));
mmsPdu->present = MmsPdu_PR_confirmedRequestPdu;
asn_long2INTEGER(&(mmsPdu->choice.confirmedRequestPdu.invokeID), invokeId);
return mmsPdu;
}
static int
createMmsWriteResponse(MmsServerConnection* connection,
int invokeId, ByteBuffer* response, MmsValueIndication indication)
{
MmsPdu_t* mmsPdu = mmsServer_createConfirmedResponse(invokeId);
mmsPdu->choice.confirmedResponsePdu.confirmedServiceResponse.present =
ConfirmedServiceResponse_PR_write;
WriteResponse_t* writeResponse =
&(mmsPdu->choice.confirmedResponsePdu.confirmedServiceResponse.choice.write);
writeResponse->list.count = 1;
writeResponse->list.size = 1;
writeResponse->list.array = calloc(1, sizeof(struct WriteResponse__Member*));
writeResponse->list.array[0] = calloc(1, sizeof(struct WriteResponse__Member));
if (indication == MMS_VALUE_OK)
writeResponse->list.array[0]->present = WriteResponse__Member_PR_success;
else {
writeResponse->list.array[0]->present = WriteResponse__Member_PR_failure;
if (indication == MMS_VALUE_VALUE_INVALID)
asn_long2INTEGER(&writeResponse->list.array[0]->choice.failure,
DataAccessError_objectvalueinvalid);
else if (indication == MMS_VALUE_ACCESS_DENIED)
asn_long2INTEGER(&writeResponse->list.array[0]->choice.failure,
DataAccessError_objectaccessdenied);
}
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);
asn_DEF_MmsPdu.free_struct(&asn_DEF_MmsPdu, mmsPdu, 0);
return 0;
}
static LDAPMessage_t *search_result_done(int messageId, LDAPDN_t *dn) {
LDAPMessage_t *msg = calloc(1, sizeof *msg);
SearchResultDone_t *done;
msg->messageID = messageId;
msg->protocolOp.present = LDAPMessage__protocolOp_PR_searchResDone;
done = &msg->protocolOp.choice.searchResDone;
asn_long2INTEGER(&done->resultCode, LDAPResult__resultCode_success);
OCTET_STRING_fromBuf(&done->matchedDN, dn->buf, dn->size);
OCTET_STRING_fromString(&done->diagnosticMessage, "OK");
return msg;
}
int
mmsClient_createGetNameListRequestDomainSpecific(long invokeId, char* domainName,
ByteBuffer* writeBuffer, MmsObjectClass objectClass)
{
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_domainSpecific;
request->objectScope.choice.domainSpecific.buf = domainName;
request->objectScope.choice.domainSpecific.size = strlen(domainName);
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,
mmsClient_write_out, (void*) writeBuffer);
if (DEBUG) xer_fprint(stdout, &asn_DEF_MmsPdu, mmsPdu);
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 AlternateAccess_t*
createAlternateAccess(uint32_t index, uint32_t elementCount)
{
AlternateAccess_t* alternateAccess = (AlternateAccess_t*) GLOBAL_CALLOC(1, sizeof(AlternateAccess_t));
alternateAccess->list.count = 1;
alternateAccess->list.array = (struct AlternateAccess__Member**) GLOBAL_CALLOC(1, sizeof(struct AlternateAccess__Member*));
alternateAccess->list.array[0] = (struct AlternateAccess__Member*) GLOBAL_CALLOC(1, sizeof(struct AlternateAccess__Member));
alternateAccess->list.array[0]->present = AlternateAccess__Member_PR_unnamed;
alternateAccess->list.array[0]->choice.unnamed = (AlternateAccessSelection_t*) GLOBAL_CALLOC(1, sizeof(AlternateAccessSelection_t));
alternateAccess->list.array[0]->choice.unnamed->present = AlternateAccessSelection_PR_selectAccess;
if (elementCount > 0) {
alternateAccess->list.array[0]->choice.unnamed->choice.selectAccess.present =
AlternateAccessSelection__selectAccess_PR_indexRange;
INTEGER_t* asnIndex =
&(alternateAccess->list.array[0]->choice.unnamed->choice.selectAccess.choice.indexRange.lowIndex);
asn_long2INTEGER(asnIndex, index);
asnIndex =
&(alternateAccess->list.array[0]->choice.unnamed->choice.selectAccess.choice.indexRange.numberOfElements);
asn_long2INTEGER(asnIndex, elementCount);
}
else {
alternateAccess->list.array[0]->choice.unnamed->choice.selectAccess.present =
AlternateAccessSelection__selectAccess_PR_index;
INTEGER_t* asnIndex =
&(alternateAccess->list.array[0]->choice.unnamed->choice.selectAccess.choice.index);
asn_long2INTEGER(asnIndex, index);
}
return alternateAccess;
}
static LDAPMessage_t *bind_response_ok(int messageId, LDAPDN_t *dn) {
LDAPMessage_t *msg = calloc(1, sizeof *msg);
BindResponse_t *resp;
msg->messageID = messageId;
msg->protocolOp.present = LDAPMessage__protocolOp_PR_bindResponse;
resp = &msg->protocolOp.choice.bindResponse;
asn_long2INTEGER(&resp->resultCode, BindResponse__resultCode_success);
OCTET_STRING_fromBuf(&resp->matchedDN, dn->buf, dn->size);
OCTET_STRING_fromString(&resp->diagnosticMessage, "OK");
return msg;
}
static void
createDeleteNamedVariableListResponse(uint32_t invokeId, ByteBuffer* response,
long numberMatched, long numberDeleted)
{
asn_enc_rval_t rval;
DeleteNamedVariableListResponse_t* _delete;
MmsPdu_t* mmsPdu = mmsServer_createConfirmedResponse(invokeId);
mmsPdu->choice.confirmedResponsePdu.confirmedServiceResponse.present =
ConfirmedServiceResponse_PR_deleteNamedVariableList;
_delete =
&(mmsPdu->choice.confirmedResponsePdu.confirmedServiceResponse.choice.deleteNamedVariableList);
asn_long2INTEGER(&(_delete->numberDeleted), numberDeleted);
asn_long2INTEGER(&(_delete->numberMatched), numberMatched);
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);
}
int main() {
char *buf;
int ret;
TCMessage_t msg;
ComponentPortion_t cp;
Component_t *cmp_arr;
Component_t cmp;
ConnectArg_t ca;
CalledPartyNumber_t *cpn_arr;
CalledPartyNumber_t cpn;
memset(&msg, 0, sizeof(msg));
memset(&cp, 0, sizeof(cp));
memset(&cmp, 0, sizeof(cmp));
memset(&ca, 0, sizeof(ca));
memset(&cpn, 0, sizeof(cpn));
msg.present = TCMessage_PR_begin;
msg.choice.begin.components = &cp;
cp.list.count = 1;
cmp_arr = &cmp;
cp.list.array = &cmp_arr;
cmp.present = Component_PR_invoke;
cmp.choice.invoke.opCode.present = OPERATION_PR_localValue;
asn_long2INTEGER(&cmp.choice.invoke.opCode.choice.localValue, 20); // connect
ca.destinationRoutingAddress.list.count = 1;
cpn_arr = &cpn;
ca.destinationRoutingAddress.list.array = &cpn_arr;
cpn.buf = "1234567890";
cpn.size = 10;
cmp.choice.invoke.parameter = ANY_new_fromType(&asn_DEF_ConnectArg, &ca);
ret = tcap_encode(&buf, &msg);
fprintf(stderr, "ret: %i\n", ret);
fwrite(buf, ret, 1, stdout);
free(buf);
asn_DEF_ANY.free_struct(&asn_DEF_ANY, cmp.choice.invoke.parameter, 0);
asn_DEF_INTEGER.free_struct(&asn_DEF_INTEGER, &cmp.choice.invoke.opCode.choice.localValue, 0);
return 0;
}
static int asn_DFL_2_set_0(int set_value, void **sptr) {
INTEGER_t *st = *sptr;
if(!st) {
if(!set_value) return -1; /* Not a default value */
st = (*sptr = CALLOC(1, sizeof(*st)));
if(!st) return -1;
}
if(set_value) {
/* Install default value 0 */
return asn_long2INTEGER(st, 0);
} else {
/* Test default value 0 */
long value;
if(asn_INTEGER2long(st, &value))
return -1;
return (value == 0);
}
}
asn_dec_rval_t
ENUMERATED_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
asn_dec_rval_t rval;
ENUMERATED_t *st = (ENUMERATED_t *)*sptr;
long value;
void *vptr = &value;
if(!st) {
st = (ENUMERATED_t *)(*sptr = CALLOC(1, sizeof(*st)));
if(!st) ASN__DECODE_FAILED;
}
rval = NativeEnumerated_decode_uper(opt_codec_ctx, td, constraints,
(void **)&vptr, pd);
if(rval.code == RC_OK)
if(asn_long2INTEGER(st, value))
rval.code = RC_FAIL;
return rval;
}
int
mmsClient_createMmsGetNameListRequestAssociationSpecific(long invokeId, ByteBuffer* writeBuffer,
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;
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,
(asn_app_consume_bytes_f*) mmsClient_write_out, (void*) writeBuffer);
asn_DEF_MmsPdu.free_struct(&asn_DEF_MmsPdu, mmsPdu, 0);
return rval.encoded;
}
int
mmsClient_createMmsGetNameListRequestVMDspecific(long invokeId, ByteBuffer* writeBuffer,
char* continueAfter)
{
MmsPdu_t* mmsPdu = mmsClient_createConfirmedRequestPdu(invokeId);
GetNameListRequest_t* request;
asn_enc_rval_t rval;
mmsPdu->choice.confirmedRequestPdu.confirmedServiceRequest.present =
ConfirmedServiceRequest_PR_getNameList;
request = &(mmsPdu->choice.confirmedRequestPdu.confirmedServiceRequest.choice.getNameList);
if (continueAfter != NULL) {
request->continueAfter = calloc(1, sizeof(Identifier_t));
request->continueAfter->buf = copyString(continueAfter);
request->continueAfter->size = strlen(continueAfter);
}
else
request->continueAfter = NULL;
request->objectScope.present = GetNameListRequest__objectScope_PR_vmdSpecific;
request->objectClass.present = ObjectClass_PR_basicObjectClass;
asn_long2INTEGER(&request->objectClass.choice.basicObjectClass,
ObjectClass__basicObjectClass_domain);
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
mmsServer_createMmsWriteResponse(MmsServerConnection* connection,
int invokeId, ByteBuffer* response, int numberOfItems, MmsDataAccessError* accessResults)
{
MmsPdu_t* mmsPdu = mmsServer_createConfirmedResponse(invokeId);
mmsPdu->choice.confirmedResponsePdu.confirmedServiceResponse.present =
ConfirmedServiceResponse_PR_write;
WriteResponse_t* writeResponse =
&(mmsPdu->choice.confirmedResponsePdu.confirmedServiceResponse.choice.write);
writeResponse->list.count = numberOfItems;
writeResponse->list.size = numberOfItems;
writeResponse->list.array = (struct WriteResponse__Member**) calloc(numberOfItems,
sizeof(struct WriteResponse__Member*));
int i;
for (i = 0; i < numberOfItems; i++) {
writeResponse->list.array[i] = (struct WriteResponse__Member*) calloc(1, sizeof(struct WriteResponse__Member));
if (accessResults[i] == DATA_ACCESS_ERROR_SUCCESS)
writeResponse->list.array[i]->present = WriteResponse__Member_PR_success;
else {
writeResponse->list.array[i]->present = WriteResponse__Member_PR_failure;
asn_long2INTEGER(&writeResponse->list.array[i]->choice.failure, (long) accessResults[i]);
}
}
der_encode(&asn_DEF_MmsPdu, mmsPdu, mmsServer_write_out, (void*) response);
asn_DEF_MmsPdu.free_struct(&asn_DEF_MmsPdu, mmsPdu, 0);
return 0;
}
int
main()
{
/* Initialize values which can't use static initializers. */
asn_long2INTEGER(&otp_format, 2); /* Alphanumeric */
OBJECT_IDENTIFIER_set_arcs(&alg_sha256.algorithm, sha256_arcs,
sizeof(*sha256_arcs),
sizeof(sha256_arcs) / sizeof(*sha256_arcs));
OBJECT_IDENTIFIER_set_arcs(&alg_sha1.algorithm, sha1_arcs,
sizeof(*sha1_arcs),
sizeof(sha1_arcs) / sizeof(*sha1_arcs));
OBJECT_IDENTIFIER_set_arcs(&other_info.algorithmID.algorithm, krb5_arcs,
sizeof(*krb5_arcs),
sizeof(krb5_arcs) / sizeof(*krb5_arcs));
printf("PrincipalName:\n");
der_encode(&asn_DEF_PrincipalName, &princ, consume, NULL);
printbuf();
/* Print this encoding and also use it to initialize two fields of
* other_info. */
printf("\nKRB5PrincipalName:\n");
der_encode(&asn_DEF_KRB5PrincipalName, &krb5princ, consume, NULL);
OCTET_STRING_fromBuf(&other_info.partyUInfo, buf, buf_pos);
OCTET_STRING_fromBuf(&other_info.partyVInfo, buf, buf_pos);
printbuf();
printf("\nOtherInfo:\n");
der_encode(&asn_DEF_OtherInfo, &other_info, consume, NULL);
printbuf();
free(other_info.partyUInfo.buf);
free(other_info.partyVInfo.buf);
printf("\nPkinitSuppPubInfo:\n");
der_encode(&asn_DEF_PkinitSuppPubInfo, &supp_pub_info, consume, NULL);
printbuf();
printf("\nMinimal OTP-TOKEN-INFO:\n");
der_encode(&asn_DEF_OTP_TOKENINFO, &token_info_1, consume, NULL);
printbuf();
printf("\nMaximal OTP-TOKEN-INFO:\n");
der_encode(&asn_DEF_OTP_TOKENINFO, &token_info_2, consume, NULL);
printbuf();
printf("\nMinimal PA-OTP-CHALLENGE:\n");
der_encode(&asn_DEF_PA_OTP_CHALLENGE, &challenge_1, consume, NULL);
printbuf();
printf("\nMaximal PA-OTP-CHALLENGE:\n");
der_encode(&asn_DEF_PA_OTP_CHALLENGE, &challenge_2, consume, NULL);
printbuf();
printf("\nMinimal PA-OTP-REQUEST:\n");
der_encode(&asn_DEF_PA_OTP_REQUEST, &request_1, consume, NULL);
printbuf();
printf("\nMaximal PA-OTP-REQUEST:\n");
der_encode(&asn_DEF_PA_OTP_REQUEST, &request_2, consume, NULL);
printbuf();
printf("\nPA-OTP-ENC-REQUEST:\n");
der_encode(&asn_DEF_PA_OTP_ENC_REQUEST, &enc_request, consume, NULL);
printbuf();
printf("\n");
return 0;
}
long _PR2_BMDDatagram_set_metadata( MetaDataBuf_t **mtds,
long no,
long type,
BMDDatagram_t **asn1_dtg)
{
long i = 0;
long lenOfOids = 0;
long lenOfMyIds = 0;
long lenOfOwnerIds = 0;
long lenOfOwnerTypes = 0;
long lenOfDatas = 0;
char **OID_str_array = NULL;
char **myId_str_array = NULL;
char **ownerId_str_array = NULL;
char **ownerType_str_array = NULL;
char *OIDs_str = NULL;
char *myIds_str = NULL;
char *ownerIds_str = NULL;
char *ownerTypes_str = NULL;
char *datas_str = NULL;
char *pointer_temp = NULL;
INTEGER_t *INTEGER_temp = NULL;
struct MetaDatas *tmp_mtd = NULL;
if(mtds==NULL) { BMD_FOK(BMD_ERR_PARAM1); }
if(no<0) { BMD_FOK(BMD_ERR_PARAM2); }
if( (type!=_PR2_SYS_MTD) && (type!=_PR2_ACT_MTD) &&
(type!=_PR2_ADD_MTD) && (type!=_PR2_PKI_MTD) )
{
BMD_FOK(BMD_ERR_PARAM3);
}
if(asn1_dtg==NULL) { BMD_FOK(BMD_ERR_PARAM4); }
if((*asn1_dtg)==NULL) { BMD_FOK(BMD_ERR_PARAM4); }
tmp_mtd=(struct MetaDatas *)malloc(sizeof(struct MetaDatas));
if(tmp_mtd == NULL) { BMD_FOK(NO_MEMORY); }
memset(tmp_mtd,0,sizeof(struct MetaDatas));
OID_str_array = (char **)malloc( (no + 1) * sizeof(char *));
if(OID_str_array == NULL) { BMD_FOK(NO_MEMORY); }
memset(OID_str_array, 0, (no + 1) * sizeof(char *));
myId_str_array = (char **)malloc( (no + 1) * sizeof(char *));
if(myId_str_array == NULL) { BMD_FOK(NO_MEMORY); }
memset(myId_str_array, 0, (no + 1) * sizeof(char *));
ownerId_str_array = (char **)malloc( (no + 1) * sizeof(char *));
if(ownerId_str_array == NULL) { BMD_FOK(NO_MEMORY); }
memset(ownerId_str_array, 0, (no + 1) * sizeof(char *));
ownerType_str_array = (char **)malloc( (no + 1) * sizeof(char *));
if(ownerType_str_array == NULL) { BMD_FOK(NO_MEMORY); }
memset(ownerType_str_array, 0, (no + 1) * sizeof(char *));
/*Konwersja na char* oraz zliczenie wielkosci potrzebnych buforow*/
for(i=0;i<no;i++)
{
OID_str_array[i]=(char*)malloc(sizeof(char)*(strlen(mtds[i]->OIDTableBuf)+1));
memset(OID_str_array[i], 0, strlen(mtds[i]->OIDTableBuf)+1);
memcpy(OID_str_array[i], mtds[i]->OIDTableBuf, strlen(mtds[i]->OIDTableBuf));
// PRINT_TEST("LIBBMDPRVDEBUG Encoding loop i: %li, OID_str_array[i]: %s\n", i, OID_str_array[i]);
lenOfOids = lenOfOids + (long)strlen(OID_str_array[i]) + 1;
asprintf(&(myId_str_array[i]), "%li", mtds[i]->myId);
if(myId_str_array[i] == NULL) { BMD_FOK(NO_MEMORY); }
// PRINT_TEST("LIBBMDPRVDEBUG Encoding loop i: %li, myId_str_array[i]: %s\n", i, myId_str_array[i]);
lenOfMyIds = lenOfMyIds + (long)strlen(myId_str_array[i]) + 1;
asprintf(&(ownerId_str_array[i]), "%li", mtds[i]->ownerId);
if(ownerId_str_array[i] == NULL) { BMD_FOK(NO_MEMORY); }
// PRINT_TEST("LIBBMDPRVDEBUG Encoding loop i: %li, ownerId_str_array[i]: %s\n", i, ownerId_str_array[i]);
lenOfOwnerIds = lenOfOwnerIds + (long)strlen(ownerId_str_array[i]) + 1;
asprintf(&(ownerType_str_array[i]), "%li", mtds[i]->ownerType);
if(ownerType_str_array[i] == NULL) { BMD_FOK(NO_MEMORY); }
// PRINT_TEST("LIBBMDPRVDEBUG Encoding loop i: %li, ownerType_str_array[i]: %s\n", i, ownerType_str_array[i]);
lenOfOwnerTypes = lenOfOwnerTypes + (long)strlen(ownerType_str_array[i]) + 1;
lenOfDatas = lenOfDatas + mtds[i]->AnySize + 1;
}
/*Po kolei tworze bufory przechowujace odpowiednie lancuchy i kopiuje do nich wczesniej pobrane dane*/
OIDs_str = malloc(lenOfOids * sizeof(char));
if(OIDs_str == NULL) { BMD_FOK(NO_MEMORY); }
memset(OIDs_str, 0, lenOfOids * sizeof(char));
pointer_temp = OIDs_str;
for(i = 0; i < no; i++)
{
memcpy(pointer_temp, OID_str_array[i], strlen(OID_str_array[i]));
// PRINT_VDEBUG("LIBBMDPRVDEBUG Encoding loop i: %li, OID_str: %s\n", i, pointer_temp);
pointer_temp = pointer_temp + strlen( OID_str_array[i] ) + 1;
INTEGER_temp = (INTEGER_t*)malloc(sizeof(INTEGER_t));
if(INTEGER_temp == NULL) { BMD_FOK(NO_MEMORY); }
memset(INTEGER_temp, 0, sizeof(INTEGER_t));
BMD_FOK(asn_long2INTEGER(INTEGER_temp, (long)strlen( OID_str_array[i] )));
asn_set_add( &(tmp_mtd->lenOfOids.list), INTEGER_temp);
INTEGER_temp = NULL;
free(OID_str_array[i]);
OID_str_array[i] = NULL;
}
free(OID_str_array); OID_str_array = NULL;
myIds_str = malloc(lenOfMyIds * sizeof(char));
if(myIds_str == NULL) { BMD_FOK(NO_MEMORY); }
memset(myIds_str, 0, lenOfMyIds * sizeof(char));
pointer_temp = myIds_str;
for(i = 0; i < no; i++)
{
memcpy(pointer_temp, myId_str_array[i], strlen(myId_str_array[i]));
// PRINT_VDEBUG("LIBBMDPRVDEBUG Encoding loop i: %li, myId_str: %s\n", i, pointer_temp);
pointer_temp = pointer_temp + strlen(myId_str_array[i]) + 1;
INTEGER_temp = (INTEGER_t*)malloc(sizeof(INTEGER_t));
if(INTEGER_temp == NULL) { BMD_FOK(NO_MEMORY); }
memset(INTEGER_temp, 0, sizeof(INTEGER_t));
BMD_FOK(asn_long2INTEGER(INTEGER_temp, (long)strlen(myId_str_array[i])));
asn_set_add( &(tmp_mtd->lenOfMyIds.list), INTEGER_temp);
INTEGER_temp = NULL;
free(myId_str_array[i]);
myId_str_array[i] = NULL;
}
free(myId_str_array); myId_str_array = NULL;
ownerIds_str = malloc(lenOfOwnerIds * sizeof(char));
if(ownerIds_str == NULL) { BMD_FOK(NO_MEMORY); }
memset(ownerIds_str, 0, lenOfOwnerIds * sizeof(char));
pointer_temp = ownerIds_str;
for(i = 0; i < no; i++)
{
memcpy(pointer_temp, ownerId_str_array[i], strlen(ownerId_str_array[i]));
// PRINT_VDEBUG("LIBBMDPRVDEBUG Encoding loop i: %li, ownerIds_str: %s\n", i, pointer_temp);
pointer_temp = pointer_temp + strlen(ownerId_str_array[i]) + 1;
INTEGER_temp = (INTEGER_t*)malloc(sizeof(INTEGER_t));
if(INTEGER_temp == NULL) { BMD_FOK(NO_MEMORY); }
memset(INTEGER_temp, 0, sizeof(INTEGER_t));
BMD_FOK(asn_long2INTEGER(INTEGER_temp, (long)strlen(ownerId_str_array[i])));
asn_set_add( &(tmp_mtd->lenOfOwnerIds.list), INTEGER_temp);
INTEGER_temp = NULL;
free(ownerId_str_array[i]);
ownerId_str_array[i] = NULL;
}
free(ownerId_str_array); ownerId_str_array = NULL;
ownerTypes_str = malloc(lenOfOwnerTypes * sizeof(char));
if(ownerTypes_str == NULL) { BMD_FOK(NO_MEMORY); }
memset(ownerTypes_str, 0, lenOfOwnerTypes * sizeof(char));
pointer_temp = ownerTypes_str;
for(i = 0; i < no; i++)
{
memcpy(pointer_temp, ownerType_str_array[i], strlen(ownerType_str_array[i]));
// PRINT_VDEBUG("LIBBMDPRVDEBUG Encoding loop i: %li, ownerType_str: %s\n", i, pointer_temp);
pointer_temp = pointer_temp + strlen(ownerType_str_array[i]) + 1;
INTEGER_temp = (INTEGER_t*)malloc(sizeof(INTEGER_t));
if(INTEGER_temp == NULL) { BMD_FOK(NO_MEMORY); }
memset(INTEGER_temp, 0, sizeof(INTEGER_t));
BMD_FOK(asn_long2INTEGER(INTEGER_temp, (long)strlen(ownerType_str_array[i])));
asn_set_add( &(tmp_mtd->lenOfOwnerTypes.list), INTEGER_temp);
INTEGER_temp = NULL;
free(ownerType_str_array[i]);
ownerType_str_array[i] = NULL;
}
free(ownerType_str_array); ownerType_str_array = NULL;
datas_str = malloc(lenOfDatas * sizeof(char));
if(datas_str == NULL) { BMD_FOK(NO_MEMORY); }
memset(datas_str, 0, lenOfDatas * sizeof(char));
pointer_temp = datas_str;
for(i = 0; i < no; i++)
{
memcpy(pointer_temp, mtds[i]->AnyBuf, mtds[i]->AnySize);
// PRINT_VDEBUG("LIBBMDPRVDEBUG Encoding loop i: %li, data string len: %li\n", i, mtds[i]->AnySize);
pointer_temp = pointer_temp + mtds[i]->AnySize + 1;
INTEGER_temp = (INTEGER_t*)malloc(sizeof(INTEGER_t));
if(INTEGER_temp == NULL) { BMD_FOK(NO_MEMORY); }
memset(INTEGER_temp, 0, sizeof(INTEGER_t));
BMD_FOK(asn_long2INTEGER(INTEGER_temp, mtds[i]->AnySize));
asn_set_add( &(tmp_mtd->lenOfDatas.list), INTEGER_temp);
INTEGER_temp = NULL;
}
BMD_FOK(OCTET_STRING_fromBuf( &(tmp_mtd->datas), datas_str, lenOfDatas));
free(datas_str); datas_str = NULL;
BMD_FOK(OCTET_STRING_fromBuf( &(tmp_mtd->oids), OIDs_str, lenOfOids));
free(OIDs_str); OIDs_str = NULL;
BMD_FOK(OCTET_STRING_fromBuf( &(tmp_mtd->myIds), myIds_str, lenOfMyIds));
free(myIds_str); myIds_str = NULL;
BMD_FOK(OCTET_STRING_fromBuf( &(tmp_mtd->ownerIds), ownerIds_str , lenOfOwnerIds));
free(ownerIds_str); ownerIds_str = NULL;
BMD_FOK(OCTET_STRING_fromBuf( &(tmp_mtd->ownerTypes), ownerTypes_str, lenOfOwnerTypes));
free(ownerTypes_str); ownerTypes_str = NULL;
switch(type)
{
case _PR2_SYS_MTD:
(*asn1_dtg)->sysMetaDatas = tmp_mtd;
break;
case _PR2_ACT_MTD:
(*asn1_dtg)->actionMetaDatas = tmp_mtd;
break;
case _PR2_ADD_MTD:
(*asn1_dtg)->additionalMetaDatas = tmp_mtd;
break;
case _PR2_PKI_MTD:
(*asn1_dtg)->pkiMetaDatas = tmp_mtd;
break;
};
tmp_mtd = NULL; /*Nie zwalniac*/
return BMD_OK;
}
static int
createTypeSpecification (
MmsTypeSpecification* namedVariable,
TypeSpecification_t* typeSpec)
{
if (namedVariable->type == MMS_ARRAY) {
typeSpec->present = TypeSpecification_PR_array;
typeSpec->choice.array.numberOfElements;
asn_long2INTEGER(&(typeSpec->choice.array.numberOfElements),
(long) namedVariable->typeSpec.array.elementCount);
typeSpec->choice.array.packed = NULL;
typeSpec->choice.array.elementType = (TypeSpecification *) calloc(1, sizeof(TypeSpecification_t));
createTypeSpecification(namedVariable->typeSpec.array.elementTypeSpec,
typeSpec->choice.array.elementType);
}
else if (namedVariable->type == MMS_STRUCTURE) {
typeSpec->present = TypeSpecification_PR_structure;
int componentCount = namedVariable->typeSpec.structure.elementCount;
typeSpec->choice.structure.components.list.count = componentCount;
typeSpec->choice.structure.components.list.size = componentCount;
typeSpec->choice.structure.components.list.array
= (StructComponent **) calloc(componentCount, sizeof(StructComponent_t*));
int i;
for (i = 0; i < componentCount; i++) {
typeSpec->choice.structure.components.list.array[i] =
(StructComponent *) calloc(1, sizeof(StructComponent_t));
typeSpec->choice.structure.components.list.array[i]->componentName =
(Identifier_t *) calloc(1, sizeof(Identifier_t));
typeSpec->choice.structure.components.list.array[i]->componentName->buf =
(uint8_t*) copyString(namedVariable->typeSpec.structure.elements[i]->name);
typeSpec->choice.structure.components.list.array[i]->componentName->size =
strlen(namedVariable->typeSpec.structure.elements[i]->name);
typeSpec->choice.structure.components.list.array[i]->componentType =
(TypeSpecification *) calloc(1, sizeof(TypeSpecification_t));
createTypeSpecification(namedVariable->typeSpec.structure.elements[i],
typeSpec->choice.structure.components.list.array[i]->componentType);
}
}
else {
switch (namedVariable->type) {
case MMS_BOOLEAN:
typeSpec->present = TypeSpecification_PR_boolean;
break;
case MMS_BIT_STRING:
typeSpec->present = TypeSpecification_PR_bitstring;
typeSpec->choice.bitstring = namedVariable->typeSpec.bitString;
break;
case MMS_INTEGER:
typeSpec->present = TypeSpecification_PR_integer;
typeSpec->choice.integer = namedVariable->typeSpec.integer;
break;
case MMS_UNSIGNED:
typeSpec->present = TypeSpecification_PR_unsigned;
typeSpec->choice.Unsigned = namedVariable->typeSpec.unsignedInteger;
break;
case MMS_FLOAT:
typeSpec->present = TypeSpecification_PR_floatingpoint;
typeSpec->choice.floatingpoint.exponentwidth =
namedVariable->typeSpec.floatingpoint.exponentWidth;
typeSpec->choice.floatingpoint.formatwidth =
namedVariable->typeSpec.floatingpoint.formatWidth;
break;
case MMS_OCTET_STRING:
typeSpec->present = TypeSpecification_PR_octetstring;
typeSpec->choice.octetstring = namedVariable->typeSpec.octetString;
break;
case MMS_VISIBLE_STRING:
typeSpec->present = TypeSpecification_PR_visiblestring;
typeSpec->choice.visiblestring = namedVariable->typeSpec.visibleString;
break;
case MMS_STRING:
typeSpec->present = TypeSpecification_PR_mMSString;
typeSpec->choice.mMSString = namedVariable->typeSpec.mmsString;
break;
case MMS_UTC_TIME:
typeSpec->present = TypeSpecification_PR_utctime;
break;
case MMS_BINARY_TIME:
typeSpec->present = TypeSpecification_PR_binarytime;
break;
default:
if (DEBUG) printf("MMS-SERVER: Unsupported type %i!\n", namedVariable->type);
return -1;
break;
}
}
return 1;
}
long _PR2_bmdDatagram2BMDDatagram( bmdDatagram_t *dtg,
BMDDatagram_t **asn1_dtg)
{
/*TODO Nie kasowac! Uzywam do testow nowego kodowania*/
/*
char *twl_buffer = NULL;
long twl_buffer_size = 0;
long twl_metadata_string_len = 0;
long twl_deserialised_len = 0;
bmdDatagram_t *twl_dtg = NULL;
char *twl_file = NULL;
FILE *fd = NULL;
*/
PRINT_INFO("LIBBMDPRINF Adding datagram to der datagram.\n");
/************************/
/* walidacja parametrow */
/************************/
if(dtg == NULL) { BMD_FOK(BMD_ERR_PARAM1); }
/*TODO Nie kasowac! Uzywam do testow nowego kodowania*/
/*
asprintf(&twl_file, "/tmp/twl_output_serialised_%li.%li.dtg", (long)getpid(), twl_number);
fd = fopen(twl_file, "a+");
if (fd > 0)
{
PR_bmdDatagram_print(dtg, WITH_TIME, fd);
fclose(fd);
}
BMD_FOK(PR2_bmdDatagram_serialize_count_bytes_TW( dtg, &twl_buffer_size, &twl_metadata_string_len));
twl_buffer = malloc(twl_buffer_size * sizeof(char));
if(twl_buffer == NULL) { BMD_FOK(NO_MEMORY); }
memset(twl_buffer, 0, twl_buffer_size * sizeof(char));
BMD_FOK(PR2_bmdDatagram_serialize_TW( dtg,
twl_buffer,
twl_buffer_size * sizeof(char),
twl_metadata_string_len));
BMD_FOK(PR2_bmdDatagram_deserialize_TW(twl_buffer, &twl_dtg, &twl_deserialised_len));
free(twl_buffer); twl_buffer = NULL;
asprintf(&twl_file, "/tmp/twl_output_deserialised_%li.%li.dtg", (long)getpid(), twl_number);
fd = fopen(twl_file, "a+");
if (fd > 0)
{
PR_bmdDatagram_print(twl_dtg, WITH_TIME, fd);
fclose(fd);
}
twl_number++;
*/
BMD_FOK(_PR2_BMDDatagram_init(asn1_dtg));
BMD_FOK(asn_long2INTEGER(&((*asn1_dtg)->protocolVersion),dtg->protocolVersion));
BMD_FOK(asn_long2INTEGER(&((*asn1_dtg)->datagramType),dtg->datagramType));
BMD_FOK(asn_long2INTEGER(&((*asn1_dtg)->randId),dtg->randId));
BMD_FOK(asn_long2INTEGER(&((*asn1_dtg)->filesRemaining),dtg->filesRemaining));
BMD_FOK(asn_long2INTEGER(&((*asn1_dtg)->datagramStatus),dtg->datagramStatus));
/* ustawienie protocolData */
if(dtg->protocolData)
{
(*asn1_dtg)->protocolData=(OCTET_STRING_t *)malloc(sizeof(OCTET_STRING_t));
memset((*asn1_dtg)->protocolData,0,sizeof(OCTET_STRING_t));
BMD_FOK(OCTET_STRING_fromBuf( (*asn1_dtg)->protocolData,
(const char *)dtg->protocolData->buf,
dtg->protocolData->size));
}
/* ustawienie protocolDataFilename */
if(dtg->protocolDataFilename)
{
(*asn1_dtg)->protocolDataFilename=(OCTET_STRING_t *)malloc(sizeof(OCTET_STRING_t));
memset((*asn1_dtg)->protocolDataFilename,0,sizeof(OCTET_STRING_t));
BMD_FOK(OCTET_STRING_fromBuf( (*asn1_dtg)->protocolDataFilename,
(const char *)dtg->protocolDataFilename->buf,
dtg->protocolDataFilename->size));
}
if(dtg->protocolDataFileLocationId)
{
(*asn1_dtg)->protocolDataFileLocationId=(OCTET_STRING_t *)malloc(sizeof(OCTET_STRING_t));
memset((*asn1_dtg)->protocolDataFileLocationId,0,sizeof(OCTET_STRING_t));
BMD_FOK(OCTET_STRING_fromBuf( (*asn1_dtg)->protocolDataFileLocationId,
(const char *)dtg->protocolDataFileLocationId->buf,
dtg->protocolDataFileLocationId->size));
}
/* ustawienie protocolDataFileId */
if(dtg->protocolDataFileId)
{
(*asn1_dtg)->protocolDataFileId=(OCTET_STRING_t *)malloc(sizeof(OCTET_STRING_t));
memset((*asn1_dtg)->protocolDataFileId,0,sizeof(OCTET_STRING_t));
BMD_FOK(OCTET_STRING_fromBuf( (*asn1_dtg)->protocolDataFileId,
(const char *)dtg->protocolDataFileId->buf,
dtg->protocolDataFileId->size));
}
/* ustawienie protocolDataOwner */
if(dtg->protocolDataOwner)
{
(*asn1_dtg)->protocolDataOwner=(OCTET_STRING_t *)malloc(sizeof(OCTET_STRING_t));
memset((*asn1_dtg)->protocolDataOwner,0,sizeof(OCTET_STRING_t));
BMD_FOK(OCTET_STRING_fromBuf( (*asn1_dtg)->protocolDataOwner,
(const char *)dtg->protocolDataOwner->buf,
dtg->protocolDataOwner->size));
}
/* ustawienie metadanych systemowych */
if(dtg->no_of_sysMetaData>0)
{
BMD_FOK(_PR2_BMDDatagram_set_metadata(dtg->sysMetaData, dtg->no_of_sysMetaData, _PR2_SYS_MTD,asn1_dtg));
}
/* ustawienie metadanych uzytkownika */
if(dtg->no_of_actionMetaData>0)
{
BMD_FOK(_PR2_BMDDatagram_set_metadata(dtg->actionMetaData, dtg->no_of_actionMetaData, _PR2_ACT_MTD,asn1_dtg));
}
/* ustawienie metadanych dodatkowych */
if(dtg->no_of_additionalMetaData>0)
{
BMD_FOK(_PR2_BMDDatagram_set_metadata(dtg->additionalMetaData, dtg->no_of_additionalMetaData, _PR2_ADD_MTD,asn1_dtg));
}
/* ustawienie metadanych PKI */
if(dtg->no_of_pkiMetaData>0)
{
BMD_FOK(_PR2_BMDDatagram_set_metadata(dtg->pkiMetaData, dtg->no_of_pkiMetaData, _PR2_PKI_MTD,asn1_dtg));
}
return BMD_OK;
}
void
mmsMsg_addResultToResultList(AccessResult_t* accessResult, MmsValue* value)
{
if (value == NULL) {
accessResult->present = AccessResult_PR_failure;
asn_long2INTEGER(&accessResult->choice.failure, DataAccessError_objectnonexistent);
if (DEBUG)
printf("ACCESS ERROR\n");
}
else {
switch (value->type) {
case MMS_ARRAY:
{
int size = value->value.structure.size;
accessResult->present = AccessResult_PR_array;
accessResult->choice.array.list.count = size;
accessResult->choice.array.list.size = size;
accessResult->choice.array.list.array = (Data_t**) GLOBAL_CALLOC(size, sizeof(Data_t*));
int i;
for (i = 0; i < size; i++) {
accessResult->choice.array.list.array[i] =
mmsMsg_createDataElement(value->value.structure.components[i]);
}
}
break;
case MMS_STRUCTURE:
{
int size = value->value.structure.size;
accessResult->present = AccessResult_PR_structure;
accessResult->choice.structure.list.count = size;
accessResult->choice.structure.list.size = size;
accessResult->choice.structure.list.array = (Data_t**) GLOBAL_CALLOC(size, sizeof(Data_t*));
int i;
for (i = 0; i < size; i++) {
accessResult->choice.structure.list.array[i] =
mmsMsg_createDataElement(value->value.structure.components[i]);
}
}
break;
case MMS_BIT_STRING:
{
accessResult->present = AccessResult_PR_bitstring;
accessResult->choice.bitstring.buf = value->value.bitString.buf;
int size = (value->value.bitString.size / 8) + ((value->value.bitString.size % 8) > 0);
int unused = 8 - (value->value.bitString.size % 8);
accessResult->choice.bitstring.size = size; /* size in bytes */
accessResult->choice.bitstring.bits_unused = unused;
}
break;
case MMS_BOOLEAN:
accessResult->present = AccessResult_PR_boolean;
accessResult->choice.boolean = value->value.boolean;
break;
case MMS_FLOAT:
accessResult->present = AccessResult_PR_floatingpoint;
mmsMsg_createFloatData(value, &accessResult->choice.floatingpoint.size,
&accessResult->choice.floatingpoint.buf);
break;
case MMS_UTC_TIME:
accessResult->present = AccessResult_PR_utctime;
accessResult->choice.utctime.buf = (uint8_t*) GLOBAL_MALLOC(8);
memcpy(accessResult->choice.utctime.buf, value->value.utcTime, 8);
accessResult->choice.utctime.size = 8;
break;
case MMS_INTEGER:
accessResult->present = AccessResult_PR_integer;
asn_long2INTEGER(&accessResult->choice.integer, (long) MmsValue_toInt32(value));
break;
case MMS_UNSIGNED:
accessResult->present = AccessResult_PR_unsigned;
asn_long2INTEGER(&accessResult->choice.Unsigned, (long) MmsValue_toInt32(value));
break;
case MMS_VISIBLE_STRING:
accessResult->present = AccessResult_PR_visiblestring;
if (value->value.visibleString.buf == NULL )
accessResult->choice.visiblestring.size = 0;
else {
accessResult->choice.visiblestring.buf = (uint8_t*) value->value.visibleString.buf;
accessResult->choice.visiblestring.size = strlen(value->value.visibleString.buf);
}
break;
case MMS_STRING:
accessResult->present = AccessResult_PR_mMSString;
if (value->value.visibleString.buf == NULL ) {
accessResult->choice.mMSString.size = 0;
}
else {
accessResult->choice.mMSString.buf = (uint8_t*) value->value.visibleString.buf;
accessResult->choice.mMSString.size = strlen(value->value.visibleString.buf);
}
break;
case MMS_BINARY_TIME:
accessResult->present = AccessResult_PR_binarytime;
accessResult->choice.binarytime.size = value->value.binaryTime.size;
accessResult->choice.binarytime.buf = value->value.binaryTime.buf;
break;
case MMS_OCTET_STRING:
accessResult->present = AccessResult_PR_octetstring;
if (value->value.octetString.buf != NULL ) {
accessResult->choice.octetstring.buf = value->value.octetString.buf;
accessResult->choice.octetstring.size = value->value.octetString.size;
}
else
accessResult->choice.octetstring.size = 0;
break;
default:
accessResult->present = AccessResult_PR_failure;
asn_long2INTEGER(&accessResult->choice.failure, DataAccessError_typeinconsistent);
break;
}
}
}
static void l2i(INTEGER_t *i, long l) {
int ret = asn_long2INTEGER(i, l);
assert(ret == 0);
}
