diff --git a/src/cam.c b/src/cam.c index 4909570..10165e9 100644 --- a/src/cam.c +++ b/src/cam.c @@ -29,22 +29,22 @@ #define RAD_PER_DEG M_PI_2/180.0 const cid_ssp_bm_t CID_SSP_BM_MAP[] = { - {"CenDsrcTollingZone/ProtectedCommunicationZonesRSU", CID_PROTECTED_ZONES, 0x8000}, - {"publicTransport/publicTransportContainer", CID_PUBLIC_TRANSPORT, 0x4000}, - {"specialTransport/specialTransportContainer", CID_SPECIAL_TRANSPORT, 0x2000}, - {"dangerousGoods/dangerousGoodsContainer", CID_DANGEROUS_GOODS, 0x1000}, - {"roadwork/roadWorksContainerBasic", CID_ROADWORK, 0x0800}, - {"rescue/rescueContainer", CID_RESCUE, 0x0400}, - {"emergency/emergencyContainer", CID_EMERGENCY, 0x0200}, - {"safetyCar/safetyCarContainer", CID_SAFETY_CAR, 0x0100}, - {"closedLanes/RoadworksContainerBasic", CID_CLOSED_LANES, 0x0080}, - {"requestForRightOfWay/EmergencyContainer: EmergencyPriority", CID_REQUEST_FOR_RIGHT_OF_WAY, 0x0040}, - {"requestForFreeCrossingAtATrafficLight/EmergencyContainer: EmergencyPriority", CID_REQUEST_FOR_FREE_CROSSING_AT_A_TRAFFIC_LIGHT, 0x0020}, - {"noPassing/SafetyCarContainer: TrafficRule", CID_NO_PASSING, 0x0010}, - {"noPassingForTrucks/SafetyCarContainer: TrafficRule", CID_NO_PASSING_FOR_TRUCKS, 0x0008}, - {"speedLimit/SafetyCarContainer", CID_SPEED_LIMIT, 0x0004}, - {"reserved0", CID_RESERVED, 0x0002}, - {"reserved1", CID_RESERVED, 0x0001}, + {"CenDsrcTollingZone/ProtectedCommunicationZonesRSU", 0x8000}, + {"publicTransport/publicTransportContainer", 0x4000}, + {"specialTransport/specialTransportContainer", 0x2000}, + {"dangerousGoods/dangerousGoodsContainer", 0x1000}, + {"roadwork/roadWorksContainerBasic", 0x0800}, + {"rescue/rescueContainer", 0x0400}, + {"emergency/emergencyContainer", 0x0200}, + {"safetyCar/safetyCarContainer", 0x0100}, + {"closedLanes/RoadworksContainerBasic", 0x0080}, + {"requestForRightOfWay/EmergencyContainer: EmergencyPriority", 0x0040}, + {"requestForFreeCrossingAtATrafficLight/EmergencyContainer: EmergencyPriority", 0x0020}, + {"noPassing/SafetyCarContainer: TrafficRule", 0x0010}, + {"noPassingForTrucks/SafetyCarContainer: TrafficRule", 0x0008}, + {"speedLimit/SafetyCarContainer", 0x0004}, + {"reserved0", 0x0002}, + {"reserved1", 0x0001}, }; static int permissions_check(int cid, uint8_t* permissions, uint8_t permissions_len) { @@ -64,14 +64,8 @@ static int permissions_check(int cid, uint8_t* permissions, uint8_t permissions_ uint16_t perms_int = *(uint16_t*)(permissions+1); - uint16_t perm_val; - for (int i = 0; i < 16; ++i) { - if (cid == CID_SSP_BM_MAP[i].cid) { - perm_val = CID_SSP_BM_MAP[i].bitmap_val; - perm_val = (perm_val>>8) | (perm_val<<8); - break; - } - } + uint16_t perm_val = CID_SSP_BM_MAP[cid].bitmap_val; + perm_val = (perm_val>>8) | (perm_val<<8); if ((perm_val & perms_int) == perm_val) return 1; else return 0; @@ -387,7 +381,7 @@ void lightship_reset_timer(lightship_t* lightship) { pthread_mutex_unlock(&lightship->lock); } -int check_cam(void* fc, BTPDataIndication_t *bdi, CAM_t* cam, uint8_t* ssp, uint32_t ssp_len) { +enum CAM_CHECK_R 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; @@ -400,53 +394,105 @@ int check_cam(void* fc, BTPDataIndication_t *bdi, CAM_t* cam, uint8_t* ssp, uint if (ssp) { if (cam->cam.camParameters.highFrequencyContainer.present == HighFrequencyContainer_PR_rsuContainerHighFrequency && cam->cam.camParameters.highFrequencyContainer.choice.rsuContainerHighFrequency.protectedCommunicationZonesRSU) { - if (!permissions_check(CID_PROTECTED_ZONES, ssp, ssp_len)) {rv = 1; return rv;} + if (!permissions_check(CID_PROTECTED_ZONES, ssp, ssp_len)) { + rv = CAM_BAD_PERMISSIONS; + syslog_debug("[facilities] [ca] received cam does not have permissions for '%s'", CID_SSP_BM_MAP[CID_PROTECTED_ZONES].container); + 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, ssp_len)) {rv = 1; return rv;} + if (!permissions_check(CID_PUBLIC_TRANSPORT, ssp, ssp_len)) { + rv = CAM_BAD_PERMISSIONS; + syslog_debug("[facilities] [ca] received cam does not have permissions for '%s'", CID_SSP_BM_MAP[CID_PUBLIC_TRANSPORT].container); + return rv; + } break; case SpecialVehicleContainer_PR_specialTransportContainer: - if (!permissions_check(CID_SPECIAL_TRANSPORT, ssp, ssp_len)) {rv = 1; return rv;} + if (!permissions_check(CID_SPECIAL_TRANSPORT, ssp, ssp_len)) { + rv = CAM_BAD_PERMISSIONS; + syslog_debug("[facilities] [ca] received cam does not have permissions for '%s'", CID_SSP_BM_MAP[CID_SPECIAL_TRANSPORT].container); + return rv; + } break; case SpecialVehicleContainer_PR_dangerousGoodsContainer: - if (!permissions_check(CID_DANGEROUS_GOODS, ssp, ssp_len)) {rv = 1; return rv;} + if (!permissions_check(CID_DANGEROUS_GOODS, ssp, ssp_len)) { + rv = CAM_BAD_PERMISSIONS; + syslog_debug("[facilities] [ca] received cam does not have permissions for '%s'", CID_SSP_BM_MAP[CID_DANGEROUS_GOODS].container); + return rv; + } break; case SpecialVehicleContainer_PR_roadWorksContainerBasic: - if (!permissions_check(CID_ROADWORK, ssp, ssp_len)) {rv = 1; return rv;} + if (!permissions_check(CID_ROADWORK, ssp, ssp_len)) { + rv = CAM_BAD_PERMISSIONS; + syslog_debug("[facilities] [ca] received cam does not have permissions for '%s'", CID_SSP_BM_MAP[CID_ROADWORK].container); + return rv; + } if (cam->cam.camParameters.specialVehicleContainer->choice.roadWorksContainerBasic.closedLanes) { - if (!permissions_check(CID_CLOSED_LANES, ssp, ssp_len)) {rv = 1; return rv;} + if (!permissions_check(CID_CLOSED_LANES, ssp, ssp_len)) { + rv = CAM_BAD_PERMISSIONS; + syslog_debug("[facilities] [ca] received cam does not have permissions for '%s'", CID_SSP_BM_MAP[CID_CLOSED_LANES].container); + return rv; + } } break; case SpecialVehicleContainer_PR_rescueContainer: - if (!permissions_check(CID_RESCUE, ssp, ssp_len)) {rv = 1; return rv;} + if (!permissions_check(CID_RESCUE, ssp, ssp_len)) { + rv = CAM_BAD_PERMISSIONS; + syslog_debug("[facilities] [ca] received cam does not have permissions for '%s'", CID_SSP_BM_MAP[CID_RESCUE].container); + return rv; + } break; case SpecialVehicleContainer_PR_emergencyContainer: - if (!permissions_check(CID_EMERGENCY, ssp, ssp_len)) {rv = 1; return rv;} + if (!permissions_check(CID_EMERGENCY, ssp, ssp_len)) { + rv = CAM_BAD_PERMISSIONS; + syslog_debug("[facilities] [ca] received cam does not have permissions for '%s'", CID_SSP_BM_MAP[CID_EMERGENCY].container); + 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, ssp_len)) {rv = 1; return rv;} + if (!permissions_check(CID_REQUEST_FOR_RIGHT_OF_WAY, ssp, ssp_len)) { + rv = CAM_BAD_PERMISSIONS; + syslog_debug("[facilities] [ca] received cam does not have permissions for '%s'", CID_SSP_BM_MAP[CID_REQUEST_FOR_RIGHT_OF_WAY].container); + return rv; + } } if (bm & 0x01) { - if (!permissions_check(CID_REQUEST_FOR_FREE_CROSSING_AT_A_TRAFFIC_LIGHT, ssp, ssp_len)) {rv = 1; return rv;} + if (!permissions_check(CID_REQUEST_FOR_FREE_CROSSING_AT_A_TRAFFIC_LIGHT, ssp, ssp_len)) { + rv = CAM_BAD_PERMISSIONS; + syslog_debug("[facilities] [ca] received cam does not have permissions for '%s'", CID_SSP_BM_MAP[CID_REQUEST_FOR_FREE_CROSSING_AT_A_TRAFFIC_LIGHT].container); + return rv; + } } } break; case SpecialVehicleContainer_PR_safetyCarContainer: - if (!permissions_check(CID_SAFETY_CAR, ssp, ssp_len)) {rv = 1; return rv;} + if (!permissions_check(CID_SAFETY_CAR, ssp, ssp_len)) { + rv = CAM_BAD_PERMISSIONS; + syslog_debug("[facilities] [ca] received cam does not have permissions for '%s'", CID_SSP_BM_MAP[CID_SAFETY_CAR].container); + 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, ssp_len)) {rv = 1; return rv;} + if (!permissions_check(CID_NO_PASSING, ssp, ssp_len)) { + rv = CAM_BAD_PERMISSIONS; + syslog_debug("[facilities] [ca] received cam does not have permissions for '%s'", CID_SSP_BM_MAP[CID_NO_PASSING].container); + return rv; + } break; case TrafficRule_noPassingForTrucks: - if (!permissions_check(CID_NO_PASSING_FOR_TRUCKS, ssp, ssp_len)) {rv = 1; return rv;} + if (!permissions_check(CID_NO_PASSING_FOR_TRUCKS, ssp, ssp_len)) { + rv = CAM_BAD_PERMISSIONS; + syslog_debug("[facilities] [ca] received cam does not have permissions for '%s'", CID_SSP_BM_MAP[CID_NO_PASSING_FOR_TRUCKS].container); + return rv; + } break; default: break; @@ -454,7 +500,11 @@ int check_cam(void* fc, BTPDataIndication_t *bdi, CAM_t* cam, uint8_t* ssp, uint } if (cam->cam.camParameters.specialVehicleContainer->choice.safetyCarContainer.speedLimit) { - if (!permissions_check(CID_SPEED_LIMIT, ssp, ssp_len)) {rv = 1; return rv;} + if (!permissions_check(CID_SPEED_LIMIT, ssp, ssp_len)) { + rv = CAM_BAD_PERMISSIONS; + syslog_debug("[facilities] [ca] received cam does not have permissions for '%s'", CID_SSP_BM_MAP[CID_SPEED_LIMIT].container); + return rv; + } } break; } diff --git a/src/cam.h b/src/cam.h index 168783b..bbfb856 100644 --- a/src/cam.h +++ b/src/cam.h @@ -13,29 +13,35 @@ #define PATH_HISTORY_MAX_LEN POS_HISTORY_MAX_LEN-1 typedef enum CID_CAM { - CID_RESERVED, - CID_PROTECTED_ZONES, - CID_PUBLIC_TRANSPORT, - CID_SPECIAL_TRANSPORT, - CID_DANGEROUS_GOODS, - CID_ROADWORK, - CID_RESCUE, - CID_EMERGENCY, - CID_SAFETY_CAR, - CID_CLOSED_LANES, - CID_REQUEST_FOR_RIGHT_OF_WAY, - CID_REQUEST_FOR_FREE_CROSSING_AT_A_TRAFFIC_LIGHT, - CID_NO_PASSING, - CID_NO_PASSING_FOR_TRUCKS, - CID_SPEED_LIMIT + CID_PROTECTED_ZONES, + CID_PUBLIC_TRANSPORT, + CID_SPECIAL_TRANSPORT, + CID_DANGEROUS_GOODS, + CID_ROADWORK, + CID_RESCUE, + CID_EMERGENCY, + CID_SAFETY_CAR, + CID_CLOSED_LANES, + CID_REQUEST_FOR_RIGHT_OF_WAY, + CID_REQUEST_FOR_FREE_CROSSING_AT_A_TRAFFIC_LIGHT, + CID_NO_PASSING, + CID_NO_PASSING_FOR_TRUCKS, + CID_SPEED_LIMIT, + CID_RESERVED0, + CID_RESERVED1, } CID_CAM_e; typedef struct cid_ssp_bm { const char* container; - const int cid; const uint32_t bitmap_val; } cid_ssp_bm_t; +enum CAM_CHECK_R { + CAM_OK, + CAM_INVALID, + CAM_BAD_PERMISSIONS +}; + typedef struct pos_vector { uint64_t ts; uint16_t heading; @@ -79,7 +85,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, uint8_t* ssp, uint32_t ssp_len); +enum CAM_CHECK_R 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 e1d79ff..2800a8e 100644 --- a/src/denm.c +++ b/src/denm.c @@ -76,7 +76,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, uint8_t* ssp, uint32_t ssp_len) { +static enum EVENT_CHECK_R 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; @@ -90,7 +90,7 @@ static enum EVENT_CHECK_RESULT event_check(den_t *den, DENM_t *denm, uint8_t* ss // 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, ssp_len)) { - return EVENT_INVALID; + return EVENT_BAD_PERMISSIONS; } } @@ -326,7 +326,7 @@ 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, uint8_t* ssp, uint32_t ssp_len) { +enum EVENT_CHECK_R 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, ssp_len)) { case EVENT_NEW: @@ -350,7 +350,7 @@ int event_manage(den_t *den, DENM_t *denm, int64_t* id, uint8_t* ssp, uint32_t s if (event_update(den, denm, id)) { syslog_debug("[facilities] [den] failed cancelling event, event not found"); ASN_STRUCT_FREE(asn_DEF_DENM, denm); - rv = -1; + rv = EVENT_NUMBER_EXCEEDED; } break; case EVENT_NEGATION: @@ -358,7 +358,7 @@ int event_manage(den_t *den, DENM_t *denm, int64_t* id, uint8_t* ssp, uint32_t s if (event_update(den, denm, id)) { syslog_debug("[facilities] [den] failed negating event, event not found"); ASN_STRUCT_FREE(asn_DEF_DENM, denm); - rv = -1; + rv = EVENT_NUMBER_EXCEEDED; } break; case EVENT_UPDATE: @@ -366,7 +366,7 @@ int event_manage(den_t *den, DENM_t *denm, int64_t* id, uint8_t* ssp, uint32_t s if (event_update(den, denm, id)) { syslog_debug("[facilities] [den] failed updating event, event not found"); ASN_STRUCT_FREE(asn_DEF_DENM, denm); - rv = -1; + rv = EVENT_NUMBER_EXCEEDED; } break; case EVENT_REPEATED: @@ -377,6 +377,10 @@ int event_manage(den_t *den, DENM_t *denm, int64_t* id, uint8_t* ssp, uint32_t s syslog_debug("[facilities] [den] max events reached, ignoring"); ASN_STRUCT_FREE(asn_DEF_DENM, denm); break; + case EVENT_BAD_PERMISSIONS: + syslog_debug("[facilities] [den] permisisons check failed for the received event, ignoring"); + ASN_STRUCT_FREE(asn_DEF_DENM, denm); + break; } return rv; } diff --git a/src/denm.h b/src/denm.h index d5f4a2b..f098487 100644 --- a/src/denm.h +++ b/src/denm.h @@ -38,7 +38,7 @@ typedef struct den { pthread_mutex_t lock; } den_t; -enum EVENT_CHECK_RESULT { +enum EVENT_CHECK_R { EVENT_NEW, EVENT_INVALID, EVENT_PASSED, @@ -46,7 +46,8 @@ enum EVENT_CHECK_RESULT { EVENT_NEGATION, EVENT_UPDATE, EVENT_REPEATED, - EVENT_NUMBER_EXCEEDED + EVENT_NUMBER_EXCEEDED, + EVENT_BAD_PERMISSIONS }; typedef struct cc_ssp_bm { @@ -65,7 +66,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, uint8_t* ssp, uint32_t ssp_len); +enum EVENT_CHECK_R 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 7015cb5..8697a0d 100644 --- a/src/facilities.c +++ b/src/facilities.c @@ -2,6 +2,7 @@ #include "cam.h" #include "config.h" #include "denm.h" +#include "infrastructure.h" #include "requests.h" #include "cpm.h" @@ -104,13 +105,21 @@ static int transport_indication(facilities_t *facilities, void* responder, uint8 ssp_len = bdi->gnPermissions->ssp.size; } + bool fwd = false; // Manage message switch (bdi->destinationPort) { case Port_cam: - - check_cam(facilities, bdi, its_msg, ssp, ssp_len); - + switch (check_cam(facilities, bdi, its_msg, ssp, ssp_len)) { + case CAM_OK: + fwd = true; + break; + case CAM_INVALID: + case CAM_BAD_PERMISSIONS: + default: + break; + } break; + case Port_denm: ; #ifdef DEBUG @@ -120,11 +129,38 @@ 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, ssp_len); + switch (event_manage(facilities->den, its_msg, &id, ssp, ssp_len)) { + case EVENT_NEW: + case EVENT_CANCELLATION: + case EVENT_NEGATION: + case EVENT_UPDATE: + case EVENT_NUMBER_EXCEEDED: + fwd = true; + break; + case EVENT_INVALID: + case EVENT_PASSED: + case EVENT_REPEATED: + case EVENT_BAD_PERMISSIONS: + break; + } break; case Port_ivim: - service_eval(facilities->infrastructure, SERVICE_IVI, its_msg, &id, ssp, ssp_len); + switch (service_eval(facilities->infrastructure, SERVICE_IVI, its_msg, &id, ssp, ssp_len)) { + case SERVICE_NEW: + case SERVICE_CANCELLATION: + case SERVICE_NEGATION: + case SERVICE_UPDATE: + case SERVICE_NUMBER_EXCEEDED: + fwd = true; + break; + case SERVICE_INVALID: + case SERVICE_REPEATED: + case SERVICE_PASSED: + case SERVICE_BAD_PERMISSIONS: + default: + break; + } break; default: @@ -132,20 +168,22 @@ static int transport_indication(facilities_t *facilities, void* responder, uint8 } // Forward to application - fdi = calloc(1, sizeof(FacilitiesDataIndication_t)); + if (fwd) { + fdi = calloc(1, sizeof(FacilitiesDataIndication_t)); - fdi->itsMessageType = bdi->destinationPort; + fdi->itsMessageType = bdi->destinationPort; - fdi->data.size = bdi->data.size; - fdi->data.buf = malloc(bdi->data.size); - memcpy(fdi->data.buf, bdi->data.buf, bdi->data.size); + fdi->data.size = bdi->data.size; + fdi->data.buf = malloc(bdi->data.size); + memcpy(fdi->data.buf, bdi->data.buf, bdi->data.size); - uint8_t buffer[PACKET_MAX_LEN]; - buffer[0] = 4; // Facilities - asn_enc_rval_t enc = oer_encode_to_buffer(&asn_DEF_FacilitiesDataIndication, NULL, fdi, buffer+1, PACKET_MAX_LEN-1); + uint8_t buffer[PACKET_MAX_LEN]; + buffer[0] = 4; // Facilities + asn_enc_rval_t enc = oer_encode_to_buffer(&asn_DEF_FacilitiesDataIndication, NULL, fdi, buffer+1, PACKET_MAX_LEN-1); - queue_add(facilities->tx_queue, buffer, enc.encoded+1, 5); - pthread_cond_signal(&facilities->tx_queue->trigger); + queue_add(facilities->tx_queue, buffer, enc.encoded+1, 5); + pthread_cond_signal(&facilities->tx_queue->trigger); + } cleanup: if (handled_msg && bdi->destinationPort != Port_denm && bdi->destinationPort != Port_ivim) { diff --git a/src/infrastructure.c b/src/infrastructure.c index 7288946..4838f3e 100644 --- a/src/infrastructure.c +++ b/src/infrastructure.c @@ -63,7 +63,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, uint8_t* ssp, uint16_t ssp_len) { +static enum SERVICE_EVAL_R 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; @@ -123,7 +123,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, ssp_len)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_ViennaCodeConvention, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;} break; case RSCode__code_PR_iso14823: @@ -131,27 +131,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, ssp_len)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_TrafficSignPictogramDangerWarning, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;} break; case Pictogram_trafficSign_regulatory: - if (!permissions_check(IVI_DIID_TrafficSignPictogramRegulatory, ssp, ssp_len)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_TrafficSignPictogramRegulatory, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;} break; case Pictogram_trafficSign_informative: - if (!permissions_check(IVI_DIID_TrafficSignPictogramInformative, ssp, ssp_len)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_TrafficSignPictogramInformative, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;} break; } break; case ISO14823Code__pictogramCode__serviceCategoryCode_PR_publicFacilitiesPictogram: - if (!permissions_check(IVI_DIID_ServiceCategoryCodePublicFacilitiesPictogram, ssp, ssp_len)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_ServiceCategoryCodePublicFacilitiesPictogram, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;} 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, ssp_len)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_ServiceCategoryCodeAmbientOrRoadConditionPictogramAmbientCondition, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;} break; case Pictogram_conditionsSign_roadCondition: - if (!permissions_check(IVI_DIID_ServiceCategoryCodeAmbientOrRoadConditionPictogramRoadCondition, ssp, ssp_len)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_ServiceCategoryCodeAmbientOrRoadConditionPictogramRoadCondition, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;} break; } break; @@ -161,7 +161,7 @@ static enum SERVICE_EVAL_RESULT service_check(infrastructure_t* infrastructure, break; case RSCode__code_PR_itisCodes: - if (!permissions_check(IVI_DIID_itisCodes, ssp, ssp_len)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_itisCodes, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;} break; default: @@ -171,21 +171,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, ssp_len)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_laneStatus, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;} } } // end giv list for break; case IviContainer_PR_rcc: - if (!permissions_check(IVI_DIID_rcc, ssp, ssp_len)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_rcc, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;} break; case IviContainer_PR_tc: - if (!permissions_check(IVI_DIID_tc, ssp, ssp_len)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_tc, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;} break; case IviContainer_PR_lac: - if (!permissions_check(IVI_DIID_lac, ssp, ssp_len)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_lac, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;} break; default: @@ -197,7 +197,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, ssp_len)) {return SERVICE_INVALID;} + if (!permissions_check(IVI_DIID_StatusNegation, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;} } } // end parameters check @@ -458,7 +458,7 @@ 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, uint8_t* ssp, uint16_t ssp_len) { +enum SERVICE_EVAL_R 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, ssp_len)) { case SERVICE_NEW: @@ -509,6 +509,10 @@ enum SERVICE_EVAL_RESULT service_eval(infrastructure_t* infrastructure, enum SER syslog_debug("[facilities] [infrastructure] max services reached, ignoring"); ASN_STRUCT_FREE(asn_DEF_IVIM, its_msg); break; + case SERVICE_BAD_PERMISSIONS: + syslog_debug("[facilities] [infrastructure] invalid service permissions, ignoring"); + ASN_STRUCT_FREE(asn_DEF_IVIM, its_msg); + break; } return rv; } diff --git a/src/infrastructure.h b/src/infrastructure.h index 1556766..200ca22 100644 --- a/src/infrastructure.h +++ b/src/infrastructure.h @@ -73,18 +73,19 @@ typedef struct infrastructure { pthread_mutex_t lock; } infrastructure_t; -enum SERVICE_EVAL_RESULT { +enum SERVICE_EVAL_R { SERVICE_NEW, - SERVICE_INVALID, - SERVICE_PASSED, SERVICE_CANCELLATION, SERVICE_NEGATION, SERVICE_UPDATE, + SERVICE_INVALID, SERVICE_REPEATED, - SERVICE_NUMBER_EXCEEDED + SERVICE_PASSED, + SERVICE_NUMBER_EXCEEDED, + SERVICE_BAD_PERMISSIONS }; -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); +enum SERVICE_EVAL_R 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);