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

Permissions check debug, dont fwd up bad msgs

This commit is contained in:
emanuel 2021-04-22 18:29:49 +01:00
parent e2235a69ec
commit 88015dc131
7 changed files with 204 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
src/cam.c
View File

@ -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;
}

14
src/cam.h
View File

@ -13,7 +13,6 @@
#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,
@ -27,15 +26,22 @@ typedef enum CID_CAM {
CID_REQUEST_FOR_FREE_CROSSING_AT_A_TRAFFIC_LIGHT,
CID_NO_PASSING,
CID_NO_PASSING_FOR_TRUCKS,
CID_SPEED_LIMIT
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

16
src/denm.c
View File

@ -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;
}

7
src/denm.h
View File

@ -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);

68
src/facilities.c
View File

@ -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) {

34
src/infrastructure.c
View File

@ -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;
}

11
src/infrastructure.h
View File

@ -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);