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

453 lines
16 KiB
C
Raw Blame History

#include "denm.h"
#include "facilities.h"
#include <unistd.h>
#include <syslog.h>
#define syslog_info(msg, ...) syslog(LOG_INFO, msg, ##__VA_ARGS__)
#define syslog_emerg(msg, ...) syslog(LOG_EMERG, "%s:%d [" msg "]", __func__, __LINE__, ##__VA_ARGS__)
#define syslog_err(msg, ...) syslog(LOG_ERR, "%s:%d [" msg "]", __func__, __LINE__, ##__VA_ARGS__)
#ifndef NDEBUG
#define syslog_debug(msg, ...) syslog(LOG_DEBUG, "%s:%d " msg "", __func__, __LINE__, ##__VA_ARGS__)
#else
#define syslog_debug(msg, ...)
#endif
const cc_ssp_bm_t CC_SSP_BM_MAP[] = {
{"trafficCondition", 1, 0x800000},
{"accident", 2, 0x400000},
{"roadworks", 3, 0x200000},
{"adverseWeatherCondition-Adhesion", 6, 0x100000},
{"hazardousLocation-SurfaceCondition", 9, 0x080000},
{"hazardousLocation-ObstacleOnTheRoad", 10, 0x040000},
{"hazardousLocation-AnimalOnTheRoad", 11, 0x020000},
{"humanPresenceOnTheRoad", 12, 0x010000},
{"wrongWayDriving", 14, 0x008000},
{"rescueAndRecoveryWorkInProgress", 15, 0x004000},
{"adverseWeatherCondition-ExtremeWeatherCondition", 17, 0x002000},
{"adverseWeatherCondition-Visibility", 18, 0x001000},
{"adverseWeatherCondition-Precipitation", 19, 0x000800},
{"slowVehicle", 26, 0x000400},
{"dangerousEndOfQueue", 27, 0x000200},
{"vehicleBreakdown", 91, 0x000100},
{"postCrash", 92, 0x000080},
{"humanProblem", 93, 0x000040},
{"stationaryVehicle", 94, 0x000020},
{"emergencyVehicleApproaching", 95, 0x000010},
{"hazardousLocation-DangerousCurve", 96, 0x000008},
{"collisionRisk", 97, 0x000004},
{"signalViolation", 98, 0x000002},
{"dangerousSituation", 99, 0x000001},
};
static int permissions_check(int cause_code, uint8_t* permissions, uint8_t permissions_len) {
/* DENM SSP scheme
*
* byte | description
* ---------------------------------
* 0 | SSP version control
* 1-3 | Service-specific parameter
* 3-40 | Reserved
*/
if (permissions_len < 4) {
syslog_debug("[facilities] [den] permissions length too small");
return 0;
}
uint32_t perms_int = (*((uint32_t*) permissions)) >> 8;
uint32_t perm_val;
for (int i = 0; i < 24; ++i) {
if (cause_code == CC_SSP_BM_MAP[i].cause_code) {
perm_val = CC_SSP_BM_MAP[i].bitmap_val;
}
}
if ((perm_val & perms_int) == perm_val) return 1;
else return 0;
}
static enum EVENT_CHECK_RESULT event_check(den_t *den, DENM_t *denm, ServiceSpecificPermissions_t* ssp) {
int rv = 0;
uint64_t e_detection_time, e_reference_time;
asn_INTEGER2ulong((INTEGER_t*) &denm->denm.management.detectionTime, &e_detection_time);
asn_INTEGER2ulong((INTEGER_t*) &denm->denm.management.referenceTime, &e_reference_time);
if (e_detection_time > e_reference_time) {
return EVENT_INVALID;
}
// Check if event cause code type is permitted by the issuing ticket
if (ssp && denm->denm.situation) {
if (
!permissions_check(
denm->denm.situation->eventType.causeCode,
ssp->choice.bitmapSsp.buf,
ssp->choice.bitmapSsp.size
)
) {
return EVENT_INVALID;
}
}
struct timespec systemtime;
clock_gettime(CLOCK_REALTIME, &systemtime);
long now = (long) (systemtime.tv_sec * 1000 + systemtime.tv_nsec / 1E6);
now = now - 1072915200000; // Convert EPOCH to 2004/01/01 00:00:000
uint32_t e_validity_duration;
if (denm->denm.management.validityDuration != NULL) {
e_validity_duration = *(uint32_t *) denm->denm.management.validityDuration * 1000; // validityDuration comes in seconds
} else {
e_validity_duration = den->default_event_duration * 1000;
}
if (e_detection_time + e_validity_duration < now) {
return EVENT_PASSED;
}
bool is_new = true;
bool is_update = false;
bool exists_vacancy = false;
pthread_mutex_lock(&den->lock);
for (int i = 0; i < den->n_max_events; ++i) {
if (den->events[i]->enabled) {
if (den->events[i]->station_id == denm->denm.management.actionID.originatingStationID &&
den->events[i]->sn == denm->denm.management.actionID.sequenceNumber) {
is_new = false;
if (den->events[i]->reference_time < e_reference_time) is_update = true;
break;
}
}
}
if (is_new) {
for (int i = 0; i < den->n_max_events; ++i) {
if (!den->events[i]->enabled) {
exists_vacancy = true;
break;
}
}
}
pthread_mutex_unlock(&den->lock);
if (is_update) {
if (denm->denm.management.termination != NULL) {
if (*denm->denm.management.termination == 0) {
return EVENT_CANCELLATION;
} else if (*denm->denm.management.termination == 1) {
return EVENT_NEGATION;
}
}
return EVENT_UPDATE;
}
if (!is_new) {
return EVENT_REPEATED;
}
if (!exists_vacancy) {
return EVENT_NUMBER_EXCEEDED;
}
return EVENT_NEW;
}
static int event_add(den_t *den, DENM_t *denm, int64_t* id) {
struct timespec systemtime;
clock_gettime(CLOCK_REALTIME, &systemtime);
long now = (long) (systemtime.tv_sec * 1000 + systemtime.tv_nsec / 1E6);
now = now - 1072915200000; // Convert EPOCH to 2004/01/01 00:00:000
uint64_t e_detection_time, e_reference_time;
asn_INTEGER2ulong((INTEGER_t*) &denm->denm.management.detectionTime, &e_detection_time);
asn_INTEGER2ulong((INTEGER_t*) &denm->denm.management.referenceTime, &e_reference_time);
uint32_t e_validity_duration;
if (denm->denm.management.validityDuration != NULL) {
e_validity_duration = *(uint32_t *) denm->denm.management.validityDuration * 1000; // validityDuration comes in seconds
} else {
e_validity_duration = den->default_event_duration * 1000;
}
pthread_mutex_lock(&den->lock);
int index = -1;
for (int i = 0; i < den->n_max_events; ++i) {
if (!den->events[i]->enabled) {
index = i;
break;
}
}
uint8_t state = EVENT_ACTIVE;
if (denm->denm.management.termination != NULL) {
if (*(denm->denm.management.termination) == 0) {
state = EVENT_CANCELLED;
} else if (*(denm->denm.management.termination) == 1) {
state = EVENT_NEGATED;
}
}
switch (state) {
case EVENT_ACTIVE:
++den->n_active_events;
break;
case EVENT_CANCELLED:
++den->n_cancelled_events;
break;
case EVENT_NEGATED:
++den->n_negated_events;
break;
}
if (index != -1) {
den->events[index]->id = rand();
*id = den->events[index]->id;
den->events[index]->enabled = true;
den->events[index]->state = state;
den->events[index]->station_id = denm->denm.management.actionID.originatingStationID;
den->events[index]->sn = denm->denm.management.actionID.sequenceNumber;
den->events[index]->detection_time = e_detection_time;
den->events[index]->reference_time = e_reference_time;
den->events[index]->expiration_time = e_detection_time + e_validity_duration;
den->events[index]->latitude = denm->denm.management.eventPosition.latitude;
den->events[index]->longitude = denm->denm.management.eventPosition.longitude;
den->events[index]->denm = denm;
if (denm->denm.management.actionID.sequenceNumber > den->sn) {
den->sn = denm->denm.management.actionID.sequenceNumber;
}
}
pthread_mutex_unlock(&den->lock);
if (index == -1) return 1; // Max events reached
else return 0; // Event added to db
}
static int event_update(den_t *den, DENM_t *denm, int64_t* id) {
struct timespec systemtime;
clock_gettime(CLOCK_REALTIME, &systemtime);
long now = (long) (systemtime.tv_sec * 1000 + systemtime.tv_nsec / 1E6);
now = now - 1072915200000; // Convert EPOCH to 2004/01/01 00:00:000
uint64_t e_detection_time, e_reference_time;
asn_INTEGER2ulong((INTEGER_t*) &denm->denm.management.detectionTime, &e_detection_time);
asn_INTEGER2ulong((INTEGER_t*) &denm->denm.management.referenceTime, &e_reference_time);
uint8_t state = EVENT_ACTIVE;
if (denm->denm.management.termination != NULL) {
if (*(denm->denm.management.termination) == 0) {
state = EVENT_CANCELLED;
} else if (*(denm->denm.management.termination) == 1) {
state = EVENT_NEGATED;
}
}
int index = -1;
pthread_mutex_lock(&den->lock);
for (int i = 0; i < den->n_max_events; ++i) {
if (den->events[i]->enabled) {
if (den->events[i]->station_id == denm->denm.management.actionID.originatingStationID &&
den->events[i]->sn == denm->denm.management.actionID.sequenceNumber) {
index = i;
break;
}
}
}
switch (den->events[index]->state) {
case EVENT_ACTIVE:
--den->n_active_events;
break;
case EVENT_CANCELLED:
--den->n_cancelled_events;
break;
case EVENT_NEGATED:
--den->n_negated_events;
break;
}
switch (state) {
case EVENT_ACTIVE:
++den->n_active_events;
break;
case EVENT_CANCELLED:
++den->n_cancelled_events;
break;
case EVENT_NEGATED:
++den->n_negated_events;
break;
}
if (index != -1) {
*id = den->events[index]->id;
den->events[index]->state = state;
den->events[index]->detection_time = e_detection_time;
den->events[index]->reference_time = e_reference_time;
if (denm->denm.management.validityDuration != NULL) {
den->events[index]->expiration_time = e_detection_time + *(uint32_t *) denm->denm.management.validityDuration * 1000;
}
if (state == EVENT_CANCELLED || state == EVENT_NEGATED) { // Keep terminated events for 10 mins
den->events[index]->expiration_time = now + 600 * 1000;
}
den->events[index]->latitude = denm->denm.management.eventPosition.latitude;
den->events[index]->longitude = denm->denm.management.eventPosition.longitude;
ASN_STRUCT_FREE(asn_DEF_DENM, den->events[index]->denm);
den->events[index]->denm = denm;
}
pthread_mutex_unlock(&den->lock);
if (index == -1) return 1; // Event not found
else return 0; // Event updated
}
int event_manage(den_t *den, DENM_t *denm, int64_t* id, ServiceSpecificPermissions_t* ssp) {
int rv = 0;
switch (rv = event_check(den, denm, ssp)) {
case EVENT_NEW:
syslog_debug("[facilities] [den] new event received");
if (event_add(den, denm, id)) {
syslog_debug("[facilities] [den] failed adding event, max events reached");
ASN_STRUCT_FREE(asn_DEF_DENM, denm);
rv = -1;
}
break;
case EVENT_INVALID:
syslog_debug("[facilities] [den] invalid event received, ignoring");
ASN_STRUCT_FREE(asn_DEF_DENM, denm);
break;
case EVENT_PASSED:
syslog_debug("[facilities] [den] old event received, ignoring");
ASN_STRUCT_FREE(asn_DEF_DENM, denm);
break;
case EVENT_CANCELLATION:
syslog_debug("[facilities] [den] event cancellation received");
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;
}
break;
case EVENT_NEGATION:
syslog_debug("[facilities] [den] event negation received");
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;
}
break;
case EVENT_UPDATE:
syslog_debug("[facilities] [den] event update received");
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;
}
break;
case EVENT_REPEATED:
syslog_debug("[facilities] [den] repeated event received or referenceTime doesn't allow an update, ignoring");
ASN_STRUCT_FREE(asn_DEF_DENM, denm);
break;
case EVENT_NUMBER_EXCEEDED:
syslog_debug("[facilities] [den] max events reached, ignoring");
ASN_STRUCT_FREE(asn_DEF_DENM, denm);
break;
}
return rv;
}
void* den_service(void *fc) {
facilities_t *facilities = (facilities_t *) fc;
struct timespec systemtime;
uint64_t now;
den_t *den = facilities->den;
pthread_mutex_init(&den->lock, NULL);
den->events = malloc(den->n_max_events * sizeof(void*));
for (int i = 0; i < den->n_max_events; ++i) {
den->events[i] = calloc(1, sizeof(event_t));
}
uint32_t sleep4us = 5e5;
uint32_t sleep_count = 0;
while (!facilities->exit) {
clock_gettime(CLOCK_REALTIME, &systemtime);
now = (long)(systemtime.tv_sec * 1000 + systemtime.tv_nsec / 1E6);
now = now - 1072915200000; // Convert EPOCH to 2004/01/01 00:00:000
pthread_mutex_lock(&den->lock);
for (int i = 0; i < den->n_max_events; ++i) {
if (den->events[i]->enabled) {
if (now >= den->events[i]->expiration_time) { // Remove event
syslog_debug("[facilities] [den] removed event %d (expiration)", i);
den->events[i]->enabled = false;
ASN_STRUCT_FREE(asn_DEF_DENM, den->events[i]->denm);
switch (den->events[i]->state) {
case EVENT_ACTIVE:
--den->n_active_events;
break;
case EVENT_CANCELLED:
--den->n_cancelled_events;
break;
case EVENT_NEGATED:
--den->n_negated_events;
break;
}
} else {
switch (den->events[i]->state) {
case EVENT_ACTIVE:
syslog_debug("[facilities] [den] event %d expiring in %ld second(s)", i, (den->events[i]->expiration_time - now)/1000);
break;
case EVENT_CANCELLED:
break;
case EVENT_NEGATED:
break;
}
}
}
}
if (sleep4us * sleep_count > 5e6) { /* Print info every 5 seconds */
syslog_info("[facilities] [den] events :: [ %d active | %d cancelled | %d negated ]", den->n_active_events, den->n_cancelled_events, den->n_negated_events);
sleep_count = 0;
}
pthread_mutex_unlock(&den->lock);
++sleep_count;
usleep(sleep4us);
}
return NULL;
}
Reference in New Issue View Git Blame Copy Permalink