int save_policy_config(dnssec_kasp_policy_t *policy, const char *filename)
{
assert(policy);
assert(filename);
_json_cleanup_ json_t *config = NULL;
int r = encode_object(POLICY_ATTRS, policy, &config);
if (r != DNSSEC_EOK) {
return r;
}
_cleanup_fclose_ FILE *file = fopen(filename, "w");
if (!file) {
return DNSSEC_NOT_FOUND;
}
r = json_dumpf(config, file, JSON_DUMP_OPTIONS);
if (r != DNSSEC_EOK) {
return r;
}
fputc('\n', file);
return DNSSEC_EOK;
}
int encode_UE_ID(Buffer* buffer, struct UE_ID* uE_ID) {
return encode_object(buffer, uE_ID, &UE_ID_TYPE);
}
int encode_RAB_AsymmetryIndicator(Buffer* buffer, enum RAB_AsymmetryIndicator* rAB_AsymmetryIndicator) {
return encode_object(buffer, rAB_AsymmetryIndicator, &RAB_ASYMMETRYINDICATOR_TYPE);
}
int encode_EquipmentsToBeTraced(Buffer* buffer, struct EquipmentsToBeTraced* equipmentsToBeTraced) {
return encode_object(buffer, equipmentsToBeTraced, &EQUIPMENTSTOBETRACED_TYPE);
}
int encode_InformationRequestType(Buffer* buffer, struct InformationRequestType* informationRequestType) {
return encode_object(buffer, informationRequestType, &INFORMATIONREQUESTTYPE_TYPE);
}
int encode_SourceStatisticsDescriptor(Buffer* buffer, enum SourceStatisticsDescriptor* sourceStatisticsDescriptor) {
return encode_object(buffer, sourceStatisticsDescriptor, &SOURCESTATISTICSDESCRIPTOR_TYPE);
}
int encode_PriorityLevel(Buffer* buffer, int* priorityLevel) {
return encode_object(buffer, priorityLevel, &PRIORITYLEVEL_TYPE);
}
int encode_Interface(Buffer* buffer, enum Interface* interface) {
return encode_object(buffer, interface, &INTERFACE_TYPE);
}
int encode_Event(Buffer* buffer, enum Event* event) {
return encode_object(buffer, event, &EVENT_TYPE);
}
int encode_Alt_RAB_Parameter_MaxBitrateType(Buffer* buffer, enum Alt_RAB_Parameter_MaxBitrateType* alt_RAB_Parameter_MaxBitrateType) {
return encode_object(buffer, alt_RAB_Parameter_MaxBitrateType, &ALT_RAB_PARAMETER_MAXBITRATETYPE_TYPE);
}
int encode_ENB_ID(Buffer* buffer, struct ENB_ID* eNB_ID) {
return encode_object(buffer, eNB_ID, &ENB_ID_TYPE);
}
int encode_AlternativeRABConfigurationRequest(Buffer* buffer, enum AlternativeRABConfigurationRequest* alternativeRABConfigurationRequest) {
return encode_object(buffer, alternativeRABConfigurationRequest, &ALTERNATIVERABCONFIGURATIONREQUEST_TYPE);
}
int encode_QueuingAllowed(Buffer* buffer, enum QueuingAllowed* queuingAllowed) {
return encode_object(buffer, queuingAllowed, &QUEUINGALLOWED_TYPE);
}
int encode_MBMSCNDe_Registration(Buffer* buffer, enum MBMSCNDe_Registration* mBMSCNDe_Registration) {
return encode_object(buffer, mBMSCNDe_Registration, &MBMSCNDE_REGISTRATION_TYPE);
}
int encode_Pre_emptionVulnerability(Buffer* buffer, enum Pre_emptionVulnerability* pre_emptionVulnerability) {
return encode_object(buffer, pre_emptionVulnerability, &PRE_EMPTIONVULNERABILITY_TYPE);
}
static void * beacon_thread (void *arg)
#endif
{
int j;
time_t earliest;
time_t now;
/*
* Information from GPS.
*/
int fix = 0; /* 0 = none, 2 = 2D, 3 = 3D */
double my_lat = 0; /* degrees */
double my_lon = 0;
float my_course = 0; /* degrees */
float my_speed_knots = 0;
float my_speed_mph = 0;
float my_alt = 0; /* meters */
/*
* SmartBeaconing state.
*/
time_t sb_prev_time = 0; /* Time of most recent transmission. */
float sb_prev_course = 0; /* Most recent course reported. */
//float sb_prev_speed_mph; /* Most recent speed reported. */
int sb_every; /* Calculated time between transmissions. */
#if DEBUG
struct tm tm;
char hms[20];
now = time(NULL);
localtime_r (&now, &tm);
strftime (hms, sizeof(hms), "%H:%M:%S", &tm);
text_color_set(DW_COLOR_DEBUG);
dw_printf ("beacon_thread: started %s\n", hms);
#endif
now = time(NULL);
while (1) {
assert (g_misc_config_p->num_beacons >= 1);
/*
* Sleep until time for the earliest scheduled or
* the soonest we could transmit due to corner pegging.
*/
earliest = g_misc_config_p->beacon[0].next;
for (j=1; j<g_misc_config_p->num_beacons; j++) {
if (g_misc_config_p->beacon[j].btype == BEACON_IGNORE)
continue;
earliest = MIN(g_misc_config_p->beacon[j].next, earliest);
}
if (g_misc_config_p->sb_configured && g_using_gps) {
earliest = MIN(now + g_misc_config_p->sb_turn_time, earliest);
earliest = MIN(now + g_misc_config_p->sb_fast_rate, earliest);
}
if (earliest > now) {
SLEEP_SEC (earliest - now);
}
/*
* Woke up. See what needs to be done.
*/
now = time(NULL);
#if DEBUG
localtime_r (&now, &tm);
strftime (hms, sizeof(hms), "%H:%M:%S", &tm);
text_color_set(DW_COLOR_DEBUG);
dw_printf ("beacon_thread: woke up %s\n", hms);
#endif
/*
* Get information from GPS if being used.
* This needs to be done before the next scheduled tracker
* beacon because corner pegging make it sooner.
*/
#if DEBUG_SIM
FILE *fp;
char cs[40];
fp = fopen ("c:\\cygwin\\tmp\\cs", "r");
if (fp != NULL) {
fscanf (fp, "%f %f", &my_course, &my_speed_knots);
fclose (fp);
}
else {
fprintf (stderr, "Can't read /tmp/cs.\n");
}
fix = 3;
my_speed_mph = KNOTS_TO_MPH * my_speed_knots;
my_lat = 42.99;
my_lon = 71.99;
my_alt = 100;
#else
if (g_using_gps) {
fix = dwgps_read (&my_lat, &my_lon, &my_speed_knots, &my_course, &my_alt);
my_speed_mph = KNOTS_TO_MPH * my_speed_knots;
/* Don't complain here for no fix. */
/* Possibly at the point where about to transmit. */
}
#endif
/*
* Run SmartBeaconing calculation if configured and GPS data available.
*/
if (g_misc_config_p->sb_configured && g_using_gps && fix >= 2) {
if (my_speed_mph > g_misc_config_p->sb_fast_speed) {
sb_every = g_misc_config_p->sb_fast_rate;
}
else if (my_speed_mph < g_misc_config_p->sb_slow_speed) {
sb_every = g_misc_config_p->sb_slow_rate;
}
else {
/* Can't divide by 0 assuming sb_slow_speed > 0. */
sb_every = ( g_misc_config_p->sb_fast_rate * g_misc_config_p->sb_fast_speed ) / my_speed_mph;
}
#if DEBUG_SIM
text_color_set(DW_COLOR_DEBUG);
dw_printf ("SB: fast %d %d slow %d %d speed=%.1f every=%d\n",
g_misc_config_p->sb_fast_speed, g_misc_config_p->sb_fast_rate,
g_misc_config_p->sb_slow_speed, g_misc_config_p->sb_slow_rate,
my_speed_mph, sb_every);
#endif
/*
* Test for "Corner Pegging" if moving.
*/
if (my_speed_mph >= 1.0) {
int turn_threshold = g_misc_config_p->sb_turn_angle +
g_misc_config_p->sb_turn_slope / my_speed_mph;
#if DEBUG_SIM
text_color_set(DW_COLOR_DEBUG);
dw_printf ("SB-moving: course %.0f prev %.0f thresh %d\n",
my_course, sb_prev_course, turn_threshold);
#endif
if (heading_change(my_course, sb_prev_course) > turn_threshold &&
now >= sb_prev_time + g_misc_config_p->sb_turn_time) {
/* Send it now. */
for (j=0; j<g_misc_config_p->num_beacons; j++) {
if (g_misc_config_p->beacon[j].btype == BEACON_TRACKER) {
g_misc_config_p->beacon[j].next = now;
}
}
} /* significant change in direction */
} /* is moving */
} /* apply SmartBeaconing */
for (j=0; j<g_misc_config_p->num_beacons; j++) {
if (g_misc_config_p->beacon[j].btype == BEACON_IGNORE)
continue;
if (g_misc_config_p->beacon[j].next <= now) {
int strict = 1; /* Strict packet checking because they will go over air. */
char stemp[20];
char info[AX25_MAX_INFO_LEN];
char beacon_text[AX25_MAX_PACKET_LEN];
packet_t pp = NULL;
char mycall[AX25_MAX_ADDR_LEN];
/*
* Obtain source call for the beacon.
* This could potentially be different on different channels.
* When sending to IGate server, use call from first radio channel.
*
* Check added in version 1.0a. Previously used index of -1.
*/
strcpy (mycall, "NOCALL");
if (g_misc_config_p->beacon[j].chan == -1) {
strcpy (mycall, g_digi_config_p->mycall[0]);
}
else {
strcpy (mycall, g_digi_config_p->mycall[g_misc_config_p->beacon[j].chan]);
}
if (strlen(mycall) == 0 || strcmp(mycall, "NOCALL") == 0) {
text_color_set(DW_COLOR_ERROR);
dw_printf ("MYCALL not set for beacon in config file line %d.\n", g_misc_config_p->beacon[j].lineno);
continue;
}
/*
* Prepare the monitor format header.
*/
strcpy (beacon_text, mycall);
strcat (beacon_text, ">");
sprintf (stemp, "%s%1d%1d", APP_TOCALL, MAJOR_VERSION, MINOR_VERSION);
strcat (beacon_text, stemp);
if (g_misc_config_p->beacon[j].via) {
strcat (beacon_text, ",");
strcat (beacon_text, g_misc_config_p->beacon[j].via);
}
strcat (beacon_text, ":");
/*
* Add the info part depending on beacon type.
*/
switch (g_misc_config_p->beacon[j].btype) {
case BEACON_POSITION:
encode_position (g_misc_config_p->beacon[j].compress, g_misc_config_p->beacon[j].lat, g_misc_config_p->beacon[j].lon,
g_misc_config_p->beacon[j].symtab, g_misc_config_p->beacon[j].symbol,
g_misc_config_p->beacon[j].power, g_misc_config_p->beacon[j].height, g_misc_config_p->beacon[j].gain, g_misc_config_p->beacon[j].dir,
0, 0, /* course, speed */
g_misc_config_p->beacon[j].freq, g_misc_config_p->beacon[j].tone, g_misc_config_p->beacon[j].offset,
g_misc_config_p->beacon[j].comment,
info);
strcat (beacon_text, info);
g_misc_config_p->beacon[j].next = now + g_misc_config_p->beacon[j].every;
break;
case BEACON_OBJECT:
encode_object (g_misc_config_p->beacon[j].objname, g_misc_config_p->beacon[j].compress, 0, g_misc_config_p->beacon[j].lat, g_misc_config_p->beacon[j].lon,
g_misc_config_p->beacon[j].symtab, g_misc_config_p->beacon[j].symbol,
g_misc_config_p->beacon[j].power, g_misc_config_p->beacon[j].height, g_misc_config_p->beacon[j].gain, g_misc_config_p->beacon[j].dir,
0, 0, /* course, speed */
g_misc_config_p->beacon[j].freq, g_misc_config_p->beacon[j].tone, g_misc_config_p->beacon[j].offset, g_misc_config_p->beacon[j].comment,
info);
strcat (beacon_text, info);
g_misc_config_p->beacon[j].next = now + g_misc_config_p->beacon[j].every;
break;
case BEACON_TRACKER:
if (fix >= 2) {
int coarse; /* APRS encoder wants 1 - 360. */
/* 0 means none or unknown. */
coarse = (int)roundf(my_course);
if (coarse == 0) {
coarse = 360;
}
encode_position (g_misc_config_p->beacon[j].compress,
my_lat, my_lon,
g_misc_config_p->beacon[j].symtab, g_misc_config_p->beacon[j].symbol,
g_misc_config_p->beacon[j].power, g_misc_config_p->beacon[j].height, g_misc_config_p->beacon[j].gain, g_misc_config_p->beacon[j].dir,
coarse, (int)roundf(my_speed_knots),
g_misc_config_p->beacon[j].freq, g_misc_config_p->beacon[j].tone, g_misc_config_p->beacon[j].offset,
g_misc_config_p->beacon[j].comment,
info);
strcat (beacon_text, info);
/* Remember most recent tracker beacon. */
sb_prev_time = now;
sb_prev_course = my_course;
//sb_prev_speed_mph = my_speed_mph;
/* Calculate time for next transmission. */
if (g_misc_config_p->sb_configured) {
g_misc_config_p->beacon[j].next = now + sb_every;
}
else {
g_misc_config_p->beacon[j].next = now + g_misc_config_p->beacon[j].every;
}
}
else {
g_misc_config_p->beacon[j].next = now + 2;
continue; /* No fix. Try again in a couple seconds. */
}
break;
case BEACON_CUSTOM:
if (g_misc_config_p->beacon[j].custom_info != NULL) {
strcat (beacon_text, g_misc_config_p->beacon[j].custom_info);
}
else {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Internal error. custom_info is null. %s %d\n", __FILE__, __LINE__);
continue;
}
g_misc_config_p->beacon[j].next = now + g_misc_config_p->beacon[j].every;
break;
case BEACON_IGNORE:
default:
break;
} /* switch beacon type. */
/*
* Parse monitor format into form for transmission.
*/
pp = ax25_from_text (beacon_text, strict);
if (pp != NULL) {
/* Send to IGate server or radio. */
if (g_misc_config_p->beacon[j].chan == -1) {
#if 1
text_color_set(DW_COLOR_XMIT);
dw_printf ("[ig] %s\n", beacon_text);
#endif
igate_send_rec_packet (0, pp);
ax25_delete (pp);
}
else {
tq_append (g_misc_config_p->beacon[j].chan, TQ_PRIO_1_LO, pp);
}
}
else {
text_color_set(DW_COLOR_ERROR);
dw_printf ("Config file: Failed to parse packet constructed from line %d.\n", g_misc_config_p->beacon[j].lineno);
dw_printf ("%s\n", beacon_text);
}
} /* if time to send it */
} /* for each configured beacon */
} /* do forever */
} /* end beacon_thread */
int encode_ProvidedData(Buffer* buffer, struct ProvidedData* providedData) {
return encode_object(buffer, providedData, &PROVIDEDDATA_TYPE);
}
int encode_TraceActivationIndicator(Buffer* buffer, enum TraceActivationIndicator* traceActivationIndicator) {
return encode_object(buffer, traceActivationIndicator, &TRACEACTIVATIONINDICATOR_TYPE);
}
int encode_IuTransportAssociation(Buffer* buffer, struct IuTransportAssociation* iuTransportAssociation) {
return encode_object(buffer, iuTransportAssociation, &IUTRANSPORTASSOCIATION_TYPE);
}
int encode_TemporaryUE_ID(Buffer* buffer, struct TemporaryUE_ID* temporaryUE_ID) {
return encode_object(buffer, temporaryUE_ID, &TEMPORARYUE_ID_TYPE);
}
int encode_Cause(Buffer* buffer, struct Cause* cause) {
return encode_object(buffer, cause, &CAUSE_TYPE);
}
int encode_VelocityEstimate(Buffer* buffer, struct VelocityEstimate* velocityEstimate) {
return encode_object(buffer, velocityEstimate, &VELOCITYESTIMATE_TYPE);
}
int encode_CauseProtocol(Buffer* buffer, int* causeProtocol) {
return encode_object(buffer, causeProtocol, &CAUSEPROTOCOL_TYPE);
}
int encode_SignallingIndication(Buffer* buffer, enum SignallingIndication* signallingIndication) {
return encode_object(buffer, signallingIndication, &SIGNALLINGINDICATION_TYPE);
}
int encode_NonSearchingIndication(Buffer* buffer, enum NonSearchingIndication* nonSearchingIndication) {
return encode_object(buffer, nonSearchingIndication, &NONSEARCHINGINDICATION_TYPE);
}