From 477206d065651b6cd1c8e5fb05e4fdb6412a57c7 Mon Sep 17 00:00:00 2001 From: emanuel Date: Thu, 8 Apr 2021 14:30:55 +0100 Subject: [PATCH] Change SSP format --- src/cam.c | 30 +++++++++++++++--------------- src/cam.h | 2 +- src/denm.c | 14 ++++---------- src/denm.h | 3 +-- src/facilities.c | 14 ++++++++------ src/infrastructure.c | 32 ++++++++++++++++---------------- src/infrastructure.h | 3 +-- src/requests.c | 22 +++++++++++----------- 8 files changed, 57 insertions(+), 63 deletions(-) diff --git a/src/cam.c b/src/cam.c index 023813d..9d3861f 100644 --- a/src/cam.c +++ b/src/cam.c @@ -385,7 +385,7 @@ void lightship_reset_timer(lightship_t* lightship) { pthread_mutex_unlock(&lightship->lock); } -int check_cam(void* fc, BTPDataIndication_t *bdi, CAM_t* cam, ServiceSpecificPermissions_t* ssp) { +int check_cam(void* fc, BTPDataIndication_t *bdi, CAM_t* cam, uint8_t* ssp, uint32_t ssp_len) { int rv = 0; lightship_t *lightship = ((facilities_t*) fc)->lightship; @@ -397,53 +397,53 @@ int check_cam(void* fc, BTPDataIndication_t *bdi, CAM_t* cam, ServiceSpecificPer // Check permissions if (ssp) { if (cam->cam.camParameters.highFrequencyContainer.choice.rsuContainerHighFrequency.protectedCommunicationZonesRSU) { - if (!permissions_check(CID_PROTECTED_ZONES, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {rv = 1; return rv;} + if (!permissions_check(CID_PROTECTED_ZONES, ssp, ssp_len)) {rv = 1; return rv;} } if (cam->cam.camParameters.specialVehicleContainer) { switch (cam->cam.camParameters.specialVehicleContainer->present) { case SpecialVehicleContainer_PR_NOTHING: break; case SpecialVehicleContainer_PR_publicTransportContainer: - if (!permissions_check(CID_PUBLIC_TRANSPORT, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {rv = 1; return rv;} + if (!permissions_check(CID_PUBLIC_TRANSPORT, ssp, ssp_len)) {rv = 1; return rv;} break; case SpecialVehicleContainer_PR_specialTransportContainer: - if (!permissions_check(CID_SPECIAL_TRANSPORT, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {rv = 1; return rv;} + if (!permissions_check(CID_SPECIAL_TRANSPORT, ssp, ssp_len)) {rv = 1; return rv;} break; case SpecialVehicleContainer_PR_dangerousGoodsContainer: - if (!permissions_check(CID_DANGEROUS_GOODS, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {rv = 1; return rv;} + if (!permissions_check(CID_DANGEROUS_GOODS, ssp, ssp_len)) {rv = 1; return rv;} break; case SpecialVehicleContainer_PR_roadWorksContainerBasic: - if (!permissions_check(CID_ROADWORK, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {rv = 1; return rv;} + if (!permissions_check(CID_ROADWORK, ssp, ssp_len)) {rv = 1; return rv;} if (cam->cam.camParameters.specialVehicleContainer->choice.roadWorksContainerBasic.closedLanes) { - if (!permissions_check(CID_CLOSED_LANES, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {rv = 1; return rv;} + if (!permissions_check(CID_CLOSED_LANES, ssp, ssp_len)) {rv = 1; return rv;} } break; case SpecialVehicleContainer_PR_rescueContainer: - if (!permissions_check(CID_RESCUE, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {rv = 1; return rv;} + if (!permissions_check(CID_RESCUE, ssp, ssp_len)) {rv = 1; return rv;} break; case SpecialVehicleContainer_PR_emergencyContainer: - if (!permissions_check(CID_EMERGENCY, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {rv = 1; return rv;} + if (!permissions_check(CID_EMERGENCY, ssp, ssp_len)) {rv = 1; return rv;} if (cam->cam.camParameters.specialVehicleContainer->choice.emergencyContainer.emergencyPriority && cam->cam.camParameters.specialVehicleContainer->choice.emergencyContainer.emergencyPriority->buf) { // TODO verify bitmap uint8_t bm = *cam->cam.camParameters.specialVehicleContainer->choice.emergencyContainer.emergencyPriority->buf; if (bm & 0x02) { - if (!permissions_check(CID_REQUEST_FOR_RIGHT_OF_WAY, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {rv = 1; return rv;} + if (!permissions_check(CID_REQUEST_FOR_RIGHT_OF_WAY, ssp, ssp_len)) {rv = 1; return rv;} } if (bm & 0x01) { - if (!permissions_check(CID_REQUEST_FOR_FREE_CROSSING_AT_A_TRAFFIC_LIGHT, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {rv = 1; return rv;} + if (!permissions_check(CID_REQUEST_FOR_FREE_CROSSING_AT_A_TRAFFIC_LIGHT, ssp, ssp_len)) {rv = 1; return rv;} } } break; case SpecialVehicleContainer_PR_safetyCarContainer: - if (!permissions_check(CID_SAFETY_CAR, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {rv = 1; return rv;} + if (!permissions_check(CID_SAFETY_CAR, ssp, ssp_len)) {rv = 1; return rv;} if (cam->cam.camParameters.specialVehicleContainer->choice.safetyCarContainer.trafficRule) { switch (*cam->cam.camParameters.specialVehicleContainer->choice.safetyCarContainer.trafficRule) { case TrafficRule_noPassing: - if (!permissions_check(CID_NO_PASSING, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {rv = 1; return rv;} + if (!permissions_check(CID_NO_PASSING, ssp, ssp_len)) {rv = 1; return rv;} break; case TrafficRule_noPassingForTrucks: - if (!permissions_check(CID_NO_PASSING_FOR_TRUCKS, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {rv = 1; return rv;} + if (!permissions_check(CID_NO_PASSING_FOR_TRUCKS, ssp, ssp_len)) {rv = 1; return rv;} break; default: break; @@ -451,7 +451,7 @@ int check_cam(void* fc, BTPDataIndication_t *bdi, CAM_t* cam, ServiceSpecificPer } if (cam->cam.camParameters.specialVehicleContainer->choice.safetyCarContainer.speedLimit) { - if (!permissions_check(CID_SPEED_LIMIT, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {rv = 1; return rv;} + if (!permissions_check(CID_SPEED_LIMIT, ssp, ssp_len)) {rv = 1; return rv;} } break; } diff --git a/src/cam.h b/src/cam.h index 336b008..168783b 100644 --- a/src/cam.h +++ b/src/cam.h @@ -79,7 +79,7 @@ lightship_t* lightship_init(); int lightship_check(lightship_t *lightship, void* epv_s); void lightship_reset_timer(lightship_t *lightship); -int check_cam(void* fc, BTPDataIndication_t* bdi, CAM_t* cam, ServiceSpecificPermissions_t* ssp); +int check_cam(void* fc, BTPDataIndication_t* bdi, CAM_t* cam, uint8_t* ssp, uint32_t ssp_len); void* ca_service(void* fc); #endif diff --git a/src/denm.c b/src/denm.c index 94fa81b..b5c1454 100644 --- a/src/denm.c +++ b/src/denm.c @@ -71,7 +71,7 @@ static int permissions_check(int cause_code, uint8_t* permissions, uint8_t permi } -static enum EVENT_CHECK_RESULT event_check(den_t *den, DENM_t *denm, ServiceSpecificPermissions_t* ssp) { +static enum EVENT_CHECK_RESULT event_check(den_t *den, DENM_t *denm, uint8_t* ssp, uint32_t ssp_len) { int rv = 0; uint64_t e_detection_time, e_reference_time; @@ -84,13 +84,7 @@ static enum EVENT_CHECK_RESULT event_check(den_t *den, DENM_t *denm, ServiceSpec // Check if event cause code type is permitted by the issuing ticket if (ssp && denm->denm.situation) { - if ( - !permissions_check( - denm->denm.situation->eventType.causeCode, - ssp->choice.bitmapSsp.buf, - ssp->choice.bitmapSsp.size - ) - ) { + if (!permissions_check(denm->denm.situation->eventType.causeCode, ssp, ssp_len)) { return EVENT_INVALID; } } @@ -327,9 +321,9 @@ static int event_update(den_t *den, DENM_t *denm, int64_t* id) { else return 0; // Event updated } -int event_manage(den_t *den, DENM_t *denm, int64_t* id, ServiceSpecificPermissions_t* ssp) { +int event_manage(den_t *den, DENM_t *denm, int64_t* id, uint8_t* ssp, uint32_t ssp_len) { int rv = 0; - switch (rv = event_check(den, denm, ssp)) { + switch (rv = event_check(den, denm, ssp, ssp_len)) { case EVENT_NEW: syslog_debug("[facilities] [den] new event received"); if (event_add(den, denm, id)) { diff --git a/src/denm.h b/src/denm.h index c73ec11..d5f4a2b 100644 --- a/src/denm.h +++ b/src/denm.h @@ -5,7 +5,6 @@ #include #include #include -#include enum EVENT_STATE { EVENT_ACTIVE, @@ -66,7 +65,7 @@ typedef struct cc_ssp_bm { * @param ssp permissions * @return 0 if event OK, 1 if event NOK */ -int event_manage(den_t* den, DENM_t* denm, int64_t* id, ServiceSpecificPermissions_t* ssp); +int event_manage(den_t* den, DENM_t* denm, int64_t* id, uint8_t* ssp, uint32_t ssp_len); void* den_service(void* fc); diff --git a/src/facilities.c b/src/facilities.c index e6494a3..e4160cb 100644 --- a/src/facilities.c +++ b/src/facilities.c @@ -83,16 +83,18 @@ static int transport_indication(facilities_t *facilities, void* responder, uint8 } // Get permisisons - ServiceSpecificPermissions_t* ssp = NULL; + uint8_t* ssp = NULL; + uint16_t ssp_len; if (bdi->gnPermissions) { - ssp = &bdi->gnPermissions->ssp; + ssp = bdi->gnPermissions->ssp.buf; + ssp_len = bdi->gnPermissions->ssp.size; } // Manage message switch (bdi->destinationPort) { case Port_cam: - check_cam(facilities, bdi, its_msg, ssp); + check_cam(facilities, bdi, its_msg, ssp, ssp_len); break; case Port_denm: @@ -104,11 +106,11 @@ static int transport_indication(facilities_t *facilities, void* responder, uint8 free(xml_denm); #endif int64_t id = -1; - event_manage(facilities->den, its_msg, &id, ssp); + event_manage(facilities->den, its_msg, &id, ssp, ssp_len); break; case Port_ivim: - service_eval(facilities->infrastructure, SERVICE_IVI, its_msg, &id, ssp); + service_eval(facilities->infrastructure, SERVICE_IVI, its_msg, &id, ssp, ssp_len); break; default: @@ -118,7 +120,7 @@ static int transport_indication(facilities_t *facilities, void* responder, uint8 // Forward to application fdi = calloc(1, sizeof(FacilitiesDataIndication_t)); - fdi->itssMessageType = bdi->destinationPort; + fdi->itsMessageType = bdi->destinationPort; fdi->data.size = bdi->data.size; fdi->data.buf = malloc(bdi->data.size); diff --git a/src/infrastructure.c b/src/infrastructure.c index 15483bc..da12f69 100644 --- a/src/infrastructure.c +++ b/src/infrastructure.c @@ -61,7 +61,7 @@ static int permissions_check(int diid, uint8_t* permissions, uint8_t permissions } -static enum SERVICE_EVAL_RESULT service_check(infrastructure_t* infrastructure, enum SERVICE_TYPE type, void* its_msg, ServiceSpecificPermissions_t* ssp) { +static enum SERVICE_EVAL_RESULT service_check(infrastructure_t* infrastructure, enum SERVICE_TYPE type, void* its_msg, uint8_t* ssp, uint16_t ssp_len) { int rv = 0; struct timespec systemtime; @@ -121,7 +121,7 @@ static enum SERVICE_EVAL_RESULT service_check(infrastructure_t* infrastructure, switch (code->present) { case RSCode__code_PR_viennaConvention: - if (!permissions_check(IVI_DIID_ViennaCodeConvention, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_ViennaCodeConvention, ssp, ssp_len)) {return SERVICE_INVALID;} break; case RSCode__code_PR_iso14823: @@ -129,27 +129,27 @@ static enum SERVICE_EVAL_RESULT service_check(infrastructure_t* infrastructure, case ISO14823Code__pictogramCode__serviceCategoryCode_PR_trafficSignPictogram: switch (code->choice.iso14823.pictogramCode.serviceCategoryCode.choice.trafficSignPictogram) { case Pictogram_trafficSign_dangerWarning: - if (!permissions_check(IVI_DIID_TrafficSignPictogramDangerWarning, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_TrafficSignPictogramDangerWarning, ssp, ssp_len)) {return SERVICE_INVALID;} break; case Pictogram_trafficSign_regulatory: - if (!permissions_check(IVI_DIID_TrafficSignPictogramRegulatory, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_TrafficSignPictogramRegulatory, ssp, ssp_len)) {return SERVICE_INVALID;} break; case Pictogram_trafficSign_informative: - if (!permissions_check(IVI_DIID_TrafficSignPictogramInformative, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_TrafficSignPictogramInformative, ssp, ssp_len)) {return SERVICE_INVALID;} break; } break; case ISO14823Code__pictogramCode__serviceCategoryCode_PR_publicFacilitiesPictogram: - if (!permissions_check(IVI_DIID_ServiceCategoryCodePublicFacilitiesPictogram, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_ServiceCategoryCodePublicFacilitiesPictogram, ssp, ssp_len)) {return SERVICE_INVALID;} break; case ISO14823Code__pictogramCode__serviceCategoryCode_PR_ambientOrRoadConditionPictogram: switch (code->choice.iso14823.pictogramCode.serviceCategoryCode.choice.ambientOrRoadConditionPictogram) { case Pictogram_conditionsSign_ambientCondition: - if (!permissions_check(IVI_DIID_ServiceCategoryCodeAmbientOrRoadConditionPictogramAmbientCondition, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_ServiceCategoryCodeAmbientOrRoadConditionPictogramAmbientCondition, ssp, ssp_len)) {return SERVICE_INVALID;} break; case Pictogram_conditionsSign_roadCondition: - if (!permissions_check(IVI_DIID_ServiceCategoryCodeAmbientOrRoadConditionPictogramRoadCondition, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_ServiceCategoryCodeAmbientOrRoadConditionPictogramRoadCondition, ssp, ssp_len)) {return SERVICE_INVALID;} break; } break; @@ -159,7 +159,7 @@ static enum SERVICE_EVAL_RESULT service_check(infrastructure_t* infrastructure, break; case RSCode__code_PR_itisCodes: - if (!permissions_check(IVI_DIID_itisCodes, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_itisCodes, ssp, ssp_len)) {return SERVICE_INVALID;} break; default: @@ -169,21 +169,21 @@ static enum SERVICE_EVAL_RESULT service_check(infrastructure_t* infrastructure, } // end roadSIgn codes for if (gicp->laneStatus) { - if (!permissions_check(IVI_DIID_laneStatus, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_laneStatus, ssp, ssp_len)) {return SERVICE_INVALID;} } } // end giv list for break; case IviContainer_PR_rcc: - if (!permissions_check(IVI_DIID_rcc, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_rcc, ssp, ssp_len)) {return SERVICE_INVALID;} break; case IviContainer_PR_tc: - if (!permissions_check(IVI_DIID_tc, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_tc, ssp, ssp_len)) {return SERVICE_INVALID;} break; case IviContainer_PR_lac: - if (!permissions_check(IVI_DIID_lac, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_lac, ssp, ssp_len)) {return SERVICE_INVALID;} break; default: @@ -195,7 +195,7 @@ static enum SERVICE_EVAL_RESULT service_check(infrastructure_t* infrastructure, } // end optional if if (ivim->ivi.mandatory.iviStatus == IviStatus_negation) { - if (!permissions_check(IVI_DIID_StatusNegation, ssp->choice.bitmapSsp.buf, ssp->choice.bitmapSsp.size)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_StatusNegation, ssp, ssp_len)) {return SERVICE_INVALID;} } } // end parameters check @@ -456,9 +456,9 @@ static int service_update(infrastructure_t* infrastructure, enum SERVICE_TYPE ty else return 0; // Event updated } -enum SERVICE_EVAL_RESULT service_eval(infrastructure_t* infrastructure, enum SERVICE_TYPE type, void* its_msg, int64_t* id, ServiceSpecificPermissions_t* ssp) { +enum SERVICE_EVAL_RESULT service_eval(infrastructure_t* infrastructure, enum SERVICE_TYPE type, void* its_msg, int64_t* id, uint8_t* ssp, uint16_t ssp_len) { int rv = 0; - switch (rv = service_check(infrastructure, type, its_msg, ssp)) { + switch (rv = service_check(infrastructure, type, its_msg, ssp, ssp_len)) { case SERVICE_NEW: syslog_debug("[facilities] [infrastructure] new service received"); if (service_add(infrastructure, type, its_msg, id)) { diff --git a/src/infrastructure.h b/src/infrastructure.h index 407f0dd..1556766 100644 --- a/src/infrastructure.h +++ b/src/infrastructure.h @@ -5,7 +5,6 @@ #include #include #include -#include enum IVI_DIID_TYPE { IVI_DIID_ViennaCodeConvention, @@ -85,7 +84,7 @@ enum SERVICE_EVAL_RESULT { SERVICE_NUMBER_EXCEEDED }; -enum SERVICE_EVAL_RESULT service_eval(infrastructure_t* infrastructure, enum SERVICE_TYPE type, void* its_msg, int64_t* id, ServiceSpecificPermissions_t* ssp); +enum SERVICE_EVAL_RESULT service_eval(infrastructure_t* infrastructure, enum SERVICE_TYPE type, void* its_msg, int64_t* id, uint8_t* ssp, uint16_t ssp_len); void* infrastructure_service(void* fc); diff --git a/src/requests.c b/src/requests.c index b89f416..b3d5028 100644 --- a/src/requests.c +++ b/src/requests.c @@ -60,8 +60,8 @@ int facilities_request_single_message(facilities_t* facilities, void* responder, uint32_t transmission_interval = 0; uint64_t transmission_start = 0; - switch (fdreq->choice.singleMessage.itssMessageType) { - case ItssMessageType_cam: + switch (fdreq->choice.singleMessage.itsMessageType) { + case ItsMessageType_cam: its_msg_def = &asn_DEF_CAM; its_msg = calloc(1, sizeof(CAM_t)); bdr->destinationPort = Port_cam; @@ -69,7 +69,7 @@ int facilities_request_single_message(facilities_t* facilities, void* responder, bdr->gnTrafficClass = 1; break; - case ItssMessageType_denm: + case ItsMessageType_denm: its_msg_def = &asn_DEF_DENM; its_msg = calloc(1, sizeof(DENM_t)); bdr->destinationPort = Port_denm; @@ -77,7 +77,7 @@ int facilities_request_single_message(facilities_t* facilities, void* responder, bdr->gnTrafficClass = 2; break; - case ItssMessageType_ivim: + case ItsMessageType_ivim: its_msg_def = &asn_DEF_IVIM; its_msg = calloc(1, sizeof(IVIM_t)); bdr->destinationPort = Port_ivim; @@ -86,7 +86,7 @@ int facilities_request_single_message(facilities_t* facilities, void* responder, break; default: - syslog_err("[facilities] unrecognized FDRequest message type (%ld)", fdreq->choice.singleMessage.itssMessageType); + syslog_err("[facilities] unrecognized FDRequest message type (%ld)", fdreq->choice.singleMessage.itsMessageType); facilities_request_result_rejected(responder); rv = 1; goto cleanup; @@ -104,10 +104,10 @@ int facilities_request_single_message(facilities_t* facilities, void* responder, bool is_update = false; int managed_msg = false; - if (fdreq->choice.singleMessage.itssMessageType == ItssMessageType_denm) { + if (fdreq->choice.singleMessage.itsMessageType == ItsMessageType_denm) { managed_msg = true; - uint8_t event_type = event_manage(facilities->den, its_msg, &id, NULL); + uint8_t event_type = event_manage(facilities->den, its_msg, &id, NULL, 0); // Do not free its_msg! event_manage takes care of the msg // id will get set to another val if EVENT NEW or UPDATE or CANCELLATION or NEGATION if (event_type != EVENT_NEW && @@ -192,10 +192,10 @@ int facilities_request_single_message(facilities_t* facilities, void* responder, } } } - } else if (fdreq->choice.singleMessage.itssMessageType == ItssMessageType_ivim) { + } else if (fdreq->choice.singleMessage.itsMessageType == ItsMessageType_ivim) { managed_msg = true; - uint8_t service_type = service_eval(facilities->infrastructure, SERVICE_IVI, its_msg, &id, NULL); + uint8_t service_type = service_eval(facilities->infrastructure, SERVICE_IVI, its_msg, &id, NULL, 0); if (service_type != SERVICE_NEW && service_type != SERVICE_UPDATE && @@ -335,8 +335,8 @@ int facilities_request_active_events(facilities_t* facilities, void* responder, fdres->result->choice.events.list.array = malloc(nae * sizeof(DENM_t *)); for (int i = 0, j = 0; j < nae; ++i) { if (facilities->den->events[i]->state == EVENT_ACTIVE) { - fdres->result->choice.events.list.array[j] = calloc(1, sizeof(ItssMessage_t)); - fdres->result->choice.events.list.array[j]->itssMessageType = ItssMessageType_denm; + fdres->result->choice.events.list.array[j] = calloc(1, sizeof(ItsMessage_t)); + fdres->result->choice.events.list.array[j]->itsMessageType = ItsMessageType_denm; fdres->result->choice.events.list.array[j]->data.buf = malloc(2048); asn_enc_rval_t enc = uper_encode_to_buffer(&asn_DEF_DENM, NULL, facilities->den->events[i]->denm, fdres->result->choice.events.list.array[j]->data.buf, 2048); if (enc.encoded == -1) { /* encoding shouldn't fail as all saved DENMs are structurally valid */