TiagoRG
/
it2s-itss-facilities
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Change SSP format

This commit is contained in:
emanuel 2021-04-08 14:30:55 +01:00
parent 071be441c1
commit 477206d065
8 changed files with 57 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/cam.c
View File

@ -385,7 +385,7 @@ void lightship_reset_timer(lightship_t* lightship) {
pthread_mutex_unlock(&lightship->lock); 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; int rv = 0;
lightship_t *lightship = ((facilities_t*) fc)->lightship; 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 // Check permissions
if (ssp) { if (ssp) {
if (cam->cam.camParameters.highFrequencyContainer.choice.rsuContainerHighFrequency.protectedCommunicationZonesRSU) { 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) { if (cam->cam.camParameters.specialVehicleContainer) {
switch (cam->cam.camParameters.specialVehicleContainer->present) { switch (cam->cam.camParameters.specialVehicleContainer->present) {
case SpecialVehicleContainer_PR_NOTHING: case SpecialVehicleContainer_PR_NOTHING:
break; break;
case SpecialVehicleContainer_PR_publicTransportContainer: 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; break;
case SpecialVehicleContainer_PR_specialTransportContainer: 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; break;
case SpecialVehicleContainer_PR_dangerousGoodsContainer: 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; break;
case SpecialVehicleContainer_PR_roadWorksContainerBasic: 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 (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; break;
case SpecialVehicleContainer_PR_rescueContainer: 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; break;
case SpecialVehicleContainer_PR_emergencyContainer: 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 && if (cam->cam.camParameters.specialVehicleContainer->choice.emergencyContainer.emergencyPriority &&
cam->cam.camParameters.specialVehicleContainer->choice.emergencyContainer.emergencyPriority->buf) { cam->cam.camParameters.specialVehicleContainer->choice.emergencyContainer.emergencyPriority->buf) {
// TODO verify bitmap // TODO verify bitmap
uint8_t bm = *cam->cam.camParameters.specialVehicleContainer->choice.emergencyContainer.emergencyPriority->buf; uint8_t bm = *cam->cam.camParameters.specialVehicleContainer->choice.emergencyContainer.emergencyPriority->buf;
if (bm & 0x02) { 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 (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; break;
case SpecialVehicleContainer_PR_safetyCarContainer: 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) { if (cam->cam.camParameters.specialVehicleContainer->choice.safetyCarContainer.trafficRule) {
switch (*cam->cam.camParameters.specialVehicleContainer->choice.safetyCarContainer.trafficRule) { switch (*cam->cam.camParameters.specialVehicleContainer->choice.safetyCarContainer.trafficRule) {
case TrafficRule_noPassing: 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; break;
case TrafficRule_noPassingForTrucks: 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; break;
default: default:
break; 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 (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; break;
} }

2
src/cam.h
View File

@ -79,7 +79,7 @@ lightship_t* lightship_init();
int lightship_check(lightship_t *lightship, void* epv_s); int lightship_check(lightship_t *lightship, void* epv_s);
void lightship_reset_timer(lightship_t *lightship); 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); void* ca_service(void* fc);
#endif #endif

14
src/denm.c
View File

@ -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; int rv = 0;
uint64_t e_detection_time, e_reference_time; 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 // Check if event cause code type is permitted by the issuing ticket
if (ssp && denm->denm.situation) { if (ssp && denm->denm.situation) {
if ( if (!permissions_check(denm->denm.situation->eventType.causeCode, ssp, ssp_len)) {
!permissions_check(
denm->denm.situation->eventType.causeCode,
ssp->choice.bitmapSsp.buf,
ssp->choice.bitmapSsp.size
)
) {
return EVENT_INVALID; 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 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; int rv = 0;
switch (rv = event_check(den, denm, ssp)) { switch (rv = event_check(den, denm, ssp, ssp_len)) {
case EVENT_NEW: case EVENT_NEW:
syslog_debug("[facilities] [den] new event received"); syslog_debug("[facilities] [den] new event received");
if (event_add(den, denm, id)) { if (event_add(den, denm, id)) {

3
src/denm.h
View File

@ -5,7 +5,6 @@
#include <denmv2/DENM.h> #include <denmv2/DENM.h>
#include <pthread.h> #include <pthread.h>
#include <stdbool.h> #include <stdbool.h>
#include <itss-transport/ServiceSpecificPermissions.h>
enum EVENT_STATE { enum EVENT_STATE {
EVENT_ACTIVE, EVENT_ACTIVE,
@ -66,7 +65,7 @@ typedef struct cc_ssp_bm {
* @param ssp permissions * @param ssp permissions
* @return 0 if event OK, 1 if event NOK * @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); void* den_service(void* fc);

14
src/facilities.c
View File

@ -83,16 +83,18 @@ static int transport_indication(facilities_t *facilities, void* responder, uint8
} }
// Get permisisons // Get permisisons
ServiceSpecificPermissions_t* ssp = NULL; uint8_t* ssp = NULL;
uint16_t ssp_len;
if (bdi->gnPermissions) { if (bdi->gnPermissions) {
ssp = &bdi->gnPermissions->ssp; ssp = bdi->gnPermissions->ssp.buf;
ssp_len = bdi->gnPermissions->ssp.size;
} }
// Manage message // Manage message
switch (bdi->destinationPort) { switch (bdi->destinationPort) {
case Port_cam: case Port_cam:
check_cam(facilities, bdi, its_msg, ssp); check_cam(facilities, bdi, its_msg, ssp, ssp_len);
break; break;
case Port_denm: case Port_denm:
@ -104,11 +106,11 @@ static int transport_indication(facilities_t *facilities, void* responder, uint8
free(xml_denm); free(xml_denm);
#endif #endif
int64_t id = -1; int64_t id = -1;
event_manage(facilities->den, its_msg, &id, ssp); event_manage(facilities->den, its_msg, &id, ssp, ssp_len);
break; break;
case Port_ivim: 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; break;
default: default:
@ -118,7 +120,7 @@ static int transport_indication(facilities_t *facilities, void* responder, uint8
// Forward to application // Forward to application
fdi = calloc(1, sizeof(FacilitiesDataIndication_t)); fdi = calloc(1, sizeof(FacilitiesDataIndication_t));
fdi->itssMessageType = bdi->destinationPort; fdi->itsMessageType = bdi->destinationPort;
fdi->data.size = bdi->data.size; fdi->data.size = bdi->data.size;
fdi->data.buf = malloc(bdi->data.size); fdi->data.buf = malloc(bdi->data.size);

32
src/infrastructure.c
View File

@ -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; int rv = 0;
struct timespec systemtime; struct timespec systemtime;
@ -121,7 +121,7 @@ static enum SERVICE_EVAL_RESULT service_check(infrastructure_t* infrastructure,
switch (code->present) { switch (code->present) {
case RSCode__code_PR_viennaConvention: 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; break;
case RSCode__code_PR_iso14823: 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: case ISO14823Code__pictogramCode__serviceCategoryCode_PR_trafficSignPictogram:
switch (code->choice.iso14823.pictogramCode.serviceCategoryCode.choice.trafficSignPictogram) { switch (code->choice.iso14823.pictogramCode.serviceCategoryCode.choice.trafficSignPictogram) {
case Pictogram_trafficSign_dangerWarning: 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; break;
case Pictogram_trafficSign_regulatory: 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; break;
case Pictogram_trafficSign_informative: 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;
} }
break; break;
case ISO14823Code__pictogramCode__serviceCategoryCode_PR_publicFacilitiesPictogram: 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; break;
case ISO14823Code__pictogramCode__serviceCategoryCode_PR_ambientOrRoadConditionPictogram: case ISO14823Code__pictogramCode__serviceCategoryCode_PR_ambientOrRoadConditionPictogram:
switch (code->choice.iso14823.pictogramCode.serviceCategoryCode.choice.ambientOrRoadConditionPictogram) { switch (code->choice.iso14823.pictogramCode.serviceCategoryCode.choice.ambientOrRoadConditionPictogram) {
case Pictogram_conditionsSign_ambientCondition: 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; break;
case Pictogram_conditionsSign_roadCondition: 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;
} }
break; break;
@ -159,7 +159,7 @@ static enum SERVICE_EVAL_RESULT service_check(infrastructure_t* infrastructure,
break; break;
case RSCode__code_PR_itisCodes: 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; break;
default: default:
@ -169,21 +169,21 @@ static enum SERVICE_EVAL_RESULT service_check(infrastructure_t* infrastructure,
} // end roadSIgn codes for } // end roadSIgn codes for
if (gicp->laneStatus) { 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 } // end giv list for
break; break;
case IviContainer_PR_rcc: 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; break;
case IviContainer_PR_tc: 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; break;
case IviContainer_PR_lac: 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; break;
default: default:
@ -195,7 +195,7 @@ static enum SERVICE_EVAL_RESULT service_check(infrastructure_t* infrastructure,
} // end optional if } // end optional if
if (ivim->ivi.mandatory.iviStatus == IviStatus_negation) { 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 } // end parameters check
@ -456,9 +456,9 @@ static int service_update(infrastructure_t* infrastructure, enum SERVICE_TYPE ty
else return 0; // Event updated 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; 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: case SERVICE_NEW:
syslog_debug("[facilities] [infrastructure] new service received"); syslog_debug("[facilities] [infrastructure] new service received");
if (service_add(infrastructure, type, its_msg, id)) { if (service_add(infrastructure, type, its_msg, id)) {

3
src/infrastructure.h
View File

@ -5,7 +5,6 @@
#include <ivim/IVIM.h> #include <ivim/IVIM.h>
#include <pthread.h> #include <pthread.h>
#include <stdbool.h> #include <stdbool.h>
#include <itss-transport/ServiceSpecificPermissions.h>
enum IVI_DIID_TYPE { enum IVI_DIID_TYPE {
IVI_DIID_ViennaCodeConvention, IVI_DIID_ViennaCodeConvention,
@ -85,7 +84,7 @@ enum SERVICE_EVAL_RESULT {
SERVICE_NUMBER_EXCEEDED 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); void* infrastructure_service(void* fc);

22
src/requests.c
View File

@ -60,8 +60,8 @@ int facilities_request_single_message(facilities_t* facilities, void* responder,
uint32_t transmission_interval = 0; uint32_t transmission_interval = 0;
uint64_t transmission_start = 0; uint64_t transmission_start = 0;
switch (fdreq->choice.singleMessage.itssMessageType) { switch (fdreq->choice.singleMessage.itsMessageType) {
case ItssMessageType_cam: case ItsMessageType_cam:
its_msg_def = &asn_DEF_CAM; its_msg_def = &asn_DEF_CAM;
its_msg = calloc(1, sizeof(CAM_t)); its_msg = calloc(1, sizeof(CAM_t));
bdr->destinationPort = Port_cam; bdr->destinationPort = Port_cam;
@ -69,7 +69,7 @@ int facilities_request_single_message(facilities_t* facilities, void* responder,
bdr->gnTrafficClass = 1; bdr->gnTrafficClass = 1;
break; break;
case ItssMessageType_denm: case ItsMessageType_denm:
its_msg_def = &asn_DEF_DENM; its_msg_def = &asn_DEF_DENM;
its_msg = calloc(1, sizeof(DENM_t)); its_msg = calloc(1, sizeof(DENM_t));
bdr->destinationPort = Port_denm; bdr->destinationPort = Port_denm;
@ -77,7 +77,7 @@ int facilities_request_single_message(facilities_t* facilities, void* responder,
bdr->gnTrafficClass = 2; bdr->gnTrafficClass = 2;
break; break;
case ItssMessageType_ivim: case ItsMessageType_ivim:
its_msg_def = &asn_DEF_IVIM; its_msg_def = &asn_DEF_IVIM;
its_msg = calloc(1, sizeof(IVIM_t)); its_msg = calloc(1, sizeof(IVIM_t));
bdr->destinationPort = Port_ivim; bdr->destinationPort = Port_ivim;
@ -86,7 +86,7 @@ int facilities_request_single_message(facilities_t* facilities, void* responder,
break; break;
default: 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); facilities_request_result_rejected(responder);
rv = 1; rv = 1;
goto cleanup; goto cleanup;
@ -104,10 +104,10 @@ int facilities_request_single_message(facilities_t* facilities, void* responder,
bool is_update = false; bool is_update = false;
int managed_msg = false; int managed_msg = false;
if (fdreq->choice.singleMessage.itssMessageType == ItssMessageType_denm) { if (fdreq->choice.singleMessage.itsMessageType == ItsMessageType_denm) {
managed_msg = true; 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 // 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 // id will get set to another val if EVENT NEW or UPDATE or CANCELLATION or NEGATION
if (event_type != EVENT_NEW && 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; 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 && if (service_type != SERVICE_NEW &&
service_type != SERVICE_UPDATE && 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 *)); fdres->result->choice.events.list.array = malloc(nae * sizeof(DENM_t *));
for (int i = 0, j = 0; j < nae; ++i) { for (int i = 0, j = 0; j < nae; ++i) {
if (facilities->den->events[i]->state == EVENT_ACTIVE) { 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] = calloc(1, sizeof(ItsMessage_t));
fdres->result->choice.events.list.array[j]->itssMessageType = ItssMessageType_denm; fdres->result->choice.events.list.array[j]->itsMessageType = ItsMessageType_denm;
fdres->result->choice.events.list.array[j]->data.buf = malloc(2048); 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); 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 */ if (enc.encoded == -1) { /* encoding shouldn't fail as all saved DENMs are structurally valid */