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

126
src/cam.c
View File

@ -29,22 +29,22 @@
#define RAD_PER_DEG M_PI_2/180.0 #define RAD_PER_DEG M_PI_2/180.0
const cid_ssp_bm_t CID_SSP_BM_MAP[] = { const cid_ssp_bm_t CID_SSP_BM_MAP[] = {
{"CenDsrcTollingZone/ProtectedCommunicationZonesRSU", CID_PROTECTED_ZONES, 0x8000}, {"CenDsrcTollingZone/ProtectedCommunicationZonesRSU", 0x8000},
{"publicTransport/publicTransportContainer", CID_PUBLIC_TRANSPORT, 0x4000}, {"publicTransport/publicTransportContainer", 0x4000},
{"specialTransport/specialTransportContainer", CID_SPECIAL_TRANSPORT, 0x2000}, {"specialTransport/specialTransportContainer", 0x2000},
{"dangerousGoods/dangerousGoodsContainer", CID_DANGEROUS_GOODS, 0x1000}, {"dangerousGoods/dangerousGoodsContainer", 0x1000},
{"roadwork/roadWorksContainerBasic", CID_ROADWORK, 0x0800}, {"roadwork/roadWorksContainerBasic", 0x0800},
{"rescue/rescueContainer", CID_RESCUE, 0x0400}, {"rescue/rescueContainer", 0x0400},
{"emergency/emergencyContainer", CID_EMERGENCY, 0x0200}, {"emergency/emergencyContainer", 0x0200},
{"safetyCar/safetyCarContainer", CID_SAFETY_CAR, 0x0100}, {"safetyCar/safetyCarContainer", 0x0100},
{"closedLanes/RoadworksContainerBasic", CID_CLOSED_LANES, 0x0080}, {"closedLanes/RoadworksContainerBasic", 0x0080},
{"requestForRightOfWay/EmergencyContainer: EmergencyPriority", CID_REQUEST_FOR_RIGHT_OF_WAY, 0x0040}, {"requestForRightOfWay/EmergencyContainer: EmergencyPriority", 0x0040},
{"requestForFreeCrossingAtATrafficLight/EmergencyContainer: EmergencyPriority", CID_REQUEST_FOR_FREE_CROSSING_AT_A_TRAFFIC_LIGHT, 0x0020}, {"requestForFreeCrossingAtATrafficLight/EmergencyContainer: EmergencyPriority", 0x0020},
{"noPassing/SafetyCarContainer: TrafficRule", CID_NO_PASSING, 0x0010}, {"noPassing/SafetyCarContainer: TrafficRule", 0x0010},
{"noPassingForTrucks/SafetyCarContainer: TrafficRule", CID_NO_PASSING_FOR_TRUCKS, 0x0008}, {"noPassingForTrucks/SafetyCarContainer: TrafficRule", 0x0008},
{"speedLimit/SafetyCarContainer", CID_SPEED_LIMIT, 0x0004}, {"speedLimit/SafetyCarContainer", 0x0004},
{"reserved0", CID_RESERVED, 0x0002}, {"reserved0", 0x0002},
{"reserved1", CID_RESERVED, 0x0001}, {"reserved1", 0x0001},
}; };
static int permissions_check(int cid, uint8_t* permissions, uint8_t permissions_len) { 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 perms_int = *(uint16_t*)(permissions+1);
uint16_t perm_val; uint16_t perm_val = CID_SSP_BM_MAP[cid].bitmap_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); perm_val = (perm_val>>8) | (perm_val<<8);
break;
}
}
if ((perm_val & perms_int) == perm_val) return 1; if ((perm_val & perms_int) == perm_val) return 1;
else return 0; else return 0;
@ -387,7 +381,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, 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; int rv = 0;
lightship_t *lightship = ((facilities_t*) fc)->lightship; 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 (ssp) {
if (cam->cam.camParameters.highFrequencyContainer.present == HighFrequencyContainer_PR_rsuContainerHighFrequency && if (cam->cam.camParameters.highFrequencyContainer.present == HighFrequencyContainer_PR_rsuContainerHighFrequency &&
cam->cam.camParameters.highFrequencyContainer.choice.rsuContainerHighFrequency.protectedCommunicationZonesRSU) { 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) { 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, 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; break;
case SpecialVehicleContainer_PR_specialTransportContainer: 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; break;
case SpecialVehicleContainer_PR_dangerousGoodsContainer: 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; break;
case SpecialVehicleContainer_PR_roadWorksContainerBasic: 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 (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; break;
case SpecialVehicleContainer_PR_rescueContainer: 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; break;
case SpecialVehicleContainer_PR_emergencyContainer: 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 && 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, 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 (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; break;
case SpecialVehicleContainer_PR_safetyCarContainer: 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) { 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, 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; break;
case TrafficRule_noPassingForTrucks: 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; break;
default: default:
break; 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 (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; break;
} }

14
src/cam.h
View File

@ -13,7 +13,6 @@
#define PATH_HISTORY_MAX_LEN POS_HISTORY_MAX_LEN-1 #define PATH_HISTORY_MAX_LEN POS_HISTORY_MAX_LEN-1
typedef enum CID_CAM { typedef enum CID_CAM {
CID_RESERVED,
CID_PROTECTED_ZONES, CID_PROTECTED_ZONES,
CID_PUBLIC_TRANSPORT, CID_PUBLIC_TRANSPORT,
CID_SPECIAL_TRANSPORT, CID_SPECIAL_TRANSPORT,
@ -27,15 +26,22 @@ typedef enum CID_CAM {
CID_REQUEST_FOR_FREE_CROSSING_AT_A_TRAFFIC_LIGHT, CID_REQUEST_FOR_FREE_CROSSING_AT_A_TRAFFIC_LIGHT,
CID_NO_PASSING, CID_NO_PASSING,
CID_NO_PASSING_FOR_TRUCKS, CID_NO_PASSING_FOR_TRUCKS,
CID_SPEED_LIMIT CID_SPEED_LIMIT,
CID_RESERVED0,
CID_RESERVED1,
} CID_CAM_e; } CID_CAM_e;
typedef struct cid_ssp_bm { typedef struct cid_ssp_bm {
const char* container; const char* container;
const int cid;
const uint32_t bitmap_val; const uint32_t bitmap_val;
} cid_ssp_bm_t; } cid_ssp_bm_t;
enum CAM_CHECK_R {
CAM_OK,
CAM_INVALID,
CAM_BAD_PERMISSIONS
};
typedef struct pos_vector { typedef struct pos_vector {
uint64_t ts; uint64_t ts;
uint16_t heading; uint16_t heading;
@ -79,7 +85,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, 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); void* ca_service(void* fc);
#endif #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; int rv = 0;
uint64_t e_detection_time, e_reference_time; 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 // Check if event cause code type is permitted by the issuing ticket
if (ssp && denm->denm.situation) { if (ssp && denm->denm.situation) {
if (!permissions_check(denm->denm.situation->eventType.causeCode, ssp, ssp_len)) { 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 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; int rv = 0;
switch (rv = event_check(den, denm, ssp, ssp_len)) { switch (rv = event_check(den, denm, ssp, ssp_len)) {
case EVENT_NEW: 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)) { if (event_update(den, denm, id)) {
syslog_debug("[facilities] [den] failed cancelling event, event not found"); syslog_debug("[facilities] [den] failed cancelling event, event not found");
ASN_STRUCT_FREE(asn_DEF_DENM, denm); ASN_STRUCT_FREE(asn_DEF_DENM, denm);
rv = -1; rv = EVENT_NUMBER_EXCEEDED;
} }
break; break;
case EVENT_NEGATION: 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)) { if (event_update(den, denm, id)) {
syslog_debug("[facilities] [den] failed negating event, event not found"); syslog_debug("[facilities] [den] failed negating event, event not found");
ASN_STRUCT_FREE(asn_DEF_DENM, denm); ASN_STRUCT_FREE(asn_DEF_DENM, denm);
rv = -1; rv = EVENT_NUMBER_EXCEEDED;
} }
break; break;
case EVENT_UPDATE: 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)) { if (event_update(den, denm, id)) {
syslog_debug("[facilities] [den] failed updating event, event not found"); syslog_debug("[facilities] [den] failed updating event, event not found");
ASN_STRUCT_FREE(asn_DEF_DENM, denm); ASN_STRUCT_FREE(asn_DEF_DENM, denm);
rv = -1; rv = EVENT_NUMBER_EXCEEDED;
} }
break; break;
case EVENT_REPEATED: 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"); syslog_debug("[facilities] [den] max events reached, ignoring");
ASN_STRUCT_FREE(asn_DEF_DENM, denm); ASN_STRUCT_FREE(asn_DEF_DENM, denm);
break; 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; return rv;
} }

7
src/denm.h
View File

@ -38,7 +38,7 @@ typedef struct den {
pthread_mutex_t lock; pthread_mutex_t lock;
} den_t; } den_t;
enum EVENT_CHECK_RESULT { enum EVENT_CHECK_R {
EVENT_NEW, EVENT_NEW,
EVENT_INVALID, EVENT_INVALID,
EVENT_PASSED, EVENT_PASSED,
@ -46,7 +46,8 @@ enum EVENT_CHECK_RESULT {
EVENT_NEGATION, EVENT_NEGATION,
EVENT_UPDATE, EVENT_UPDATE,
EVENT_REPEATED, EVENT_REPEATED,
EVENT_NUMBER_EXCEEDED EVENT_NUMBER_EXCEEDED,
EVENT_BAD_PERMISSIONS
}; };
typedef struct cc_ssp_bm { typedef struct cc_ssp_bm {
@ -65,7 +66,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, 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); void* den_service(void* fc);

48
src/facilities.c
View File

@ -2,6 +2,7 @@
#include "cam.h" #include "cam.h"
#include "config.h" #include "config.h"
#include "denm.h" #include "denm.h"
#include "infrastructure.h"
#include "requests.h" #include "requests.h"
#include "cpm.h" #include "cpm.h"
@ -104,13 +105,21 @@ static int transport_indication(facilities_t *facilities, void* responder, uint8
ssp_len = bdi->gnPermissions->ssp.size; ssp_len = bdi->gnPermissions->ssp.size;
} }
bool fwd = false;
// Manage message // Manage message
switch (bdi->destinationPort) { switch (bdi->destinationPort) {
case Port_cam: case Port_cam:
switch (check_cam(facilities, bdi, its_msg, ssp, ssp_len)) {
check_cam(facilities, bdi, its_msg, ssp, ssp_len); case CAM_OK:
fwd = true;
break; break;
case CAM_INVALID:
case CAM_BAD_PERMISSIONS:
default:
break;
}
break;
case Port_denm: case Port_denm:
; ;
#ifdef DEBUG #ifdef DEBUG
@ -120,11 +129,38 @@ 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, 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; break;
case Port_ivim: 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; break;
default: default:
@ -132,6 +168,7 @@ static int transport_indication(facilities_t *facilities, void* responder, uint8
} }
// Forward to application // Forward to application
if (fwd) {
fdi = calloc(1, sizeof(FacilitiesDataIndication_t)); fdi = calloc(1, sizeof(FacilitiesDataIndication_t));
fdi->itsMessageType = bdi->destinationPort; fdi->itsMessageType = bdi->destinationPort;
@ -146,6 +183,7 @@ static int transport_indication(facilities_t *facilities, void* responder, uint8
queue_add(facilities->tx_queue, buffer, enc.encoded+1, 5); queue_add(facilities->tx_queue, buffer, enc.encoded+1, 5);
pthread_cond_signal(&facilities->tx_queue->trigger); pthread_cond_signal(&facilities->tx_queue->trigger);
}
cleanup: cleanup:
if (handled_msg && bdi->destinationPort != Port_denm && bdi->destinationPort != Port_ivim) { 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; int rv = 0;
struct timespec systemtime; struct timespec systemtime;
@ -123,7 +123,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, ssp_len)) {return SERVICE_INVALID;} if (!permissions_check(IVI_DIID_ViennaCodeConvention, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;}
break; break;
case RSCode__code_PR_iso14823: 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: 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, ssp_len)) {return SERVICE_INVALID;} if (!permissions_check(IVI_DIID_TrafficSignPictogramDangerWarning, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;}
break; break;
case Pictogram_trafficSign_regulatory: 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; break;
case Pictogram_trafficSign_informative: 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;
} }
break; break;
case ISO14823Code__pictogramCode__serviceCategoryCode_PR_publicFacilitiesPictogram: 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; 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, ssp_len)) {return SERVICE_INVALID;} if (!permissions_check(IVI_DIID_ServiceCategoryCodeAmbientOrRoadConditionPictogramAmbientCondition, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;}
break; break;
case Pictogram_conditionsSign_roadCondition: 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;
} }
break; break;
@ -161,7 +161,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, ssp_len)) {return SERVICE_INVALID;} if (!permissions_check(IVI_DIID_itisCodes, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;}
break; break;
default: default:
@ -171,21 +171,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, ssp_len)) {return SERVICE_INVALID;} if (!permissions_check(IVI_DIID_laneStatus, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;}
} }
} // 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, ssp_len)) {return SERVICE_INVALID;} if (!permissions_check(IVI_DIID_rcc, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;}
break; break;
case IviContainer_PR_tc: 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; break;
case IviContainer_PR_lac: 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; break;
default: default:
@ -197,7 +197,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, ssp_len)) {return SERVICE_INVALID;} if (!permissions_check(IVI_DIID_StatusNegation, ssp, ssp_len)) {return SERVICE_BAD_PERMISSIONS;}
} }
} // end parameters check } // end parameters check
@ -458,7 +458,7 @@ 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, 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; int rv = 0;
switch (rv = service_check(infrastructure, type, its_msg, ssp, ssp_len)) { switch (rv = service_check(infrastructure, type, its_msg, ssp, ssp_len)) {
case SERVICE_NEW: 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"); syslog_debug("[facilities] [infrastructure] max services reached, ignoring");
ASN_STRUCT_FREE(asn_DEF_IVIM, its_msg); ASN_STRUCT_FREE(asn_DEF_IVIM, its_msg);
break; break;
case SERVICE_BAD_PERMISSIONS:
syslog_debug("[facilities] [infrastructure] invalid service permissions, ignoring");
ASN_STRUCT_FREE(asn_DEF_IVIM, its_msg);
break;
} }
return rv; return rv;
} }

11
src/infrastructure.h
View File

@ -73,18 +73,19 @@ typedef struct infrastructure {
pthread_mutex_t lock; pthread_mutex_t lock;
} infrastructure_t; } infrastructure_t;
enum SERVICE_EVAL_RESULT { enum SERVICE_EVAL_R {
SERVICE_NEW, SERVICE_NEW,
SERVICE_INVALID,
SERVICE_PASSED,
SERVICE_CANCELLATION, SERVICE_CANCELLATION,
SERVICE_NEGATION, SERVICE_NEGATION,
SERVICE_UPDATE, SERVICE_UPDATE,
SERVICE_INVALID,
SERVICE_REPEATED, 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); void* infrastructure_service(void* fc);