/********************************************************************************************** * 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); }