/**
json 2 protocol4
*/
int json_decode_protocol4 (protocol4* self, json_t* root)
{
json_error_t error;
if (!root) {
fprintf(stderr, "error: on line %d: %s\n", error.line, error.text);
return 1;
}
if (!json_is_object(root)) {
fprintf(stderr, "error: root is not an object\n");
json_decref(root);
json_decref(root);
return 1;
}
json_t *network, *address, *magic;
network = json_object_get(root, "network");
address = json_object_get(root, "address");
magic = json_object_get(root, "magic");
if(!json_is_number(network) || !json_is_number(address) || !json_is_number(magic)) {
fprintf(stderr, "error: something is not a number\n");
json_decref(root);
return 1;
}
self->network = json_number_value(network);
self->address = json_number_value(address);
self->magic = json_number_value(magic);
return 0;
}
client_data_t * extract_json_summary(json_t *node, client_data_t *client) {
json_t *subnode, *subnode2;
size_t i;
/* Single data */
client->summary.uptime = json_ulong_obj(node, "uptime");
client->summary.time = json_ulong_obj(node, "time");
/* Sub data */
subnode = json_object_get(node, "memory");
json_check_object(subnode);
client->summary.ram_total = json_ulonglong_obj(subnode, "ram_total");
client->summary.ram_used = json_ulonglong_obj(subnode, "ram_used");
client->summary.swap_total = json_ulonglong_obj(subnode, "swap_total");
client->summary.swap_free = json_ulonglong_obj(subnode, "swap_free");
subnode = json_object_get(node, "battery");
json_check_object(subnode);
client->summary.battery_full = json_ulong_obj(subnode, "charge_full");
client->summary.battery_now = json_ulong_obj(subnode, "charge_now");
client->summary.battery_load = json_ulong_obj(subnode, "load");
client->summary.battery_status = json_ulong_obj(subnode, "status");
subnode = json_object_get(node, "cpu_usage");
json_check_array(subnode);
client->summary.cpu_count = json_array_size(subnode) - 1;
client->summary.cpu_usage = (long) json_number_value(json_array_get(subnode, 0));
subnode = json_object_get(node, "loadavg");
json_check_array(subnode);
for(i = 0; i < json_array_size(subnode) && i < 3; i++)
client->summary.loadavg[i] = (float) json_number_value(json_array_get(subnode, i));
subnode = json_object_get(node, "sensors");
json_check_object(subnode);
subnode2 = json_object_get(subnode, "cpu");
json_check_object(subnode2);
client->summary.sensors_cpu_avg = json_ulong_obj(subnode2, "average");
client->summary.sensors_cpu_crit = json_ulong_obj(subnode2, "critical");
subnode2 = json_object_get(subnode, "hdd");
json_check_object(subnode2);
client->summary.sensors_hdd_peak = json_ulong_obj(subnode2, "peak");
client->summary.sensors_hdd_avg = json_ulong_obj(subnode2, "average");
return client;
}
static void run_tests()
{
json_t *integer, *real;
json_int_t i;
double d;
integer = json_integer(5);
real = json_real(100.1);
if(!integer)
fail("unable to create integer");
if(!real)
fail("unable to create real");
i = json_integer_value(integer);
if(i != 5)
fail("wrong integer value");
d = json_real_value(real);
if(d != 100.1)
fail("wrong real value");
d = json_number_value(integer);
if(d != 5.0)
fail("wrong number value");
d = json_number_value(real);
if(d != 100.1)
fail("wrong number value");
json_decref(integer);
json_decref(real);
#ifdef NAN
real = json_real(NAN);
if(real != NULL)
fail("could construct a real from NaN");
real = json_real(1.0);
if(json_real_set(real, NAN) != -1)
fail("could set a real to NaN");
if(json_real_value(real) != 1.0)
fail("real value changed unexpectedly");
json_decref(real);
#endif
#ifdef INFINITY
test_inifity();
#endif
}
cxBool cxJsonPushValue(json_t *value)
{
if(json_is_integer(value)){
lua_pushinteger(gL,(int)json_integer_value(value));
}else if(json_is_string(value)){
lua_pushstring(gL, json_string_value(value));
}else if(json_is_number(value)){
lua_pushnumber(gL, json_number_value(value));
}else if(json_is_true(value)){
lua_pushboolean(gL, 1);
}else if(json_is_false(value)){
lua_pushboolean(gL, 0);
}else if(json_is_null(value)){
lua_pushnil(gL);
}else if(json_is_real(value)){
lua_pushnumber(gL, json_real_value(value));
}else if(json_is_object(value)){
cxJsonPushObject(value);
}else if(json_is_array(value)){
cxJsonPushArray(value);
}else{
return false;
}
return true;
}
static cxDouble jsonToDouble(json_t *v,cxDouble dv)
{
CX_RETURN(v == NULL,dv);
v = jsonParseRegisterValue(v);
if(json_is_string(v)){
return atof(json_string_value(v));
}
return json_number_value(v);
}
static cxInt jsonToInt(json_t *v,cxInt dv)
{
CX_RETURN(v == NULL,dv);
v = jsonParseRegisterValue(v);
if(json_is_string(v)){
return atoi(json_string_value(v));
}
return (cxInt)json_number_value(v);
}
/* Encode field header based on LTYPE and field number defined in the field structure.
* Call this from the callback before writing out field contents. */
static int checkreturn pb_encode_tag_for_field(pb_ostream_t *stream, const json_t *field) { // type,tag
int wiretype;
json_t *type = json_object_get(field, "type");
json_t *tag = json_object_get(field, "tag");
wiretype = pb__get_constant_type(json_string_value(type));
return pb_encode_tag(stream, wiretype, json_number_value(tag));
}
/**
json 2 protocol5
*/
int json_decode_protocol5 (protocol5* self, json_t* root)
{
json_error_t error;
if (!root) {
fprintf(stderr, "error: on line %d: %s\n", error.line, error.text);
return 1;
}
if (!json_is_object(root)) {
fprintf(stderr, "error: root is not an object\n");
json_decref(root);
json_decref(root);
return 1;
}
json_t *network, *address, *broadcast, *state, *dimmer;
network = json_object_get(root, "network");
address = json_object_get(root, "address");
broadcast = json_object_get(root, "broadcast");
state = json_object_get(root, "state");
dimmer = json_object_get(root, "dimmer");
if(!json_is_number(network) || !json_is_number(address) || !json_is_number(broadcast) ||
!json_is_number(state) || !json_is_number(dimmer))
{
fprintf(stderr, "error: something is not a number\n");
json_decref(root);
return 1;
}
self->network = json_number_value(network);
self->address = json_number_value(address);
self->broadcast = json_number_value(broadcast);
self->state = json_number_value(state);
self->dimmer = json_number_value(dimmer);
return 0;
}
bool w_perf_finish(w_perf_t *perf) {
gettimeofday(&perf->time_end, NULL);
w_timeval_sub(perf->time_end, perf->time_begin, &perf->duration);
#ifdef HAVE_SYS_RESOURCE_H
getrusage(RUSAGE_SELF, &perf->usage_end);
// Compute the delta for the usage
w_timeval_sub(perf->usage_end.ru_utime, perf->usage_begin.ru_utime,
&perf->usage.ru_utime);
w_timeval_sub(perf->usage_end.ru_stime, perf->usage_begin.ru_stime,
&perf->usage.ru_stime);
#define DIFFU(n) perf->usage.n = perf->usage_end.n - perf->usage_begin.n
DIFFU(ru_maxrss);
DIFFU(ru_ixrss);
DIFFU(ru_idrss);
DIFFU(ru_minflt);
DIFFU(ru_majflt);
DIFFU(ru_nswap);
DIFFU(ru_inblock);
DIFFU(ru_oublock);
DIFFU(ru_msgsnd);
DIFFU(ru_msgrcv);
DIFFU(ru_nsignals);
DIFFU(ru_nvcsw);
DIFFU(ru_nivcsw);
#undef DIFFU
#endif
if (!perf->will_log) {
if (perf->wall_time_elapsed_thresh == 0) {
json_t *thresh = cfg_get_json(NULL, "perf_sampling_thresh");
if (thresh) {
if (json_is_number(thresh)) {
perf->wall_time_elapsed_thresh = json_number_value(thresh);
} else {
json_unpack(thresh, "{s:f}", perf->description,
&perf->wall_time_elapsed_thresh);
}
}
}
if (perf->wall_time_elapsed_thresh > 0 &&
w_timeval_diff(perf->time_begin, perf->time_end) >
perf->wall_time_elapsed_thresh) {
perf->will_log = true;
}
}
return perf->will_log;
}
json_t* OBSAPIMessageHandler::HandleSetVolume(OBSAPIMessageHandler* handler, json_t* message)
{
json_t* channel = json_object_get(message, "channel");
json_t* volume = json_object_get(message, "volume");
json_t* finalValue = json_object_get(message, "final");
if(volume == NULL)
{
return GetErrorResponse("Volume not specified.");
}
if(!json_is_number(volume))
{
return GetErrorResponse("Volume not number.");
}
float val = (float) json_number_value(volume);
val = min(1.0f, max(0.0f, val));
if(finalValue == NULL)
{
return GetErrorResponse("Final not specified.");
}
if(!json_is_boolean(finalValue))
{
return GetErrorResponse("Final is not a boolean.");
}
if(channel != NULL && json_typeof(channel) == JSON_STRING)
{
const char* channelVal = json_string_value(channel);
if(stricmp(channelVal, "desktop") == 0)
{
OBSSetDesktopVolume(val, json_is_true(finalValue));
}
else if(stricmp(channelVal, "microphone") == 0)
{
OBSSetMicVolume(val, json_is_true(finalValue));
}
else
{
return GetErrorResponse("Invalid channel specified.");
}
}
else
{
return GetErrorResponse("Channel not specified.");
}
return GetOkResponse();
}
bool ParseResponse(const string & serverResponse, vector<m2::PointD> & outPoints)
{
try
{
my::Json parser(serverResponse.c_str());
json_t const * countries = json_object_get(parser.get(), "used_mwms");
size_t pointsCount = json_array_size(countries);
outPoints.reserve(pointsCount);
for (size_t i = 0; i < pointsCount; ++i)
{
json_t * pointArray = json_array_get(countries, i);
outPoints.push_back({json_number_value(json_array_get(pointArray, 0)),
json_number_value(json_array_get(pointArray, 1))});
}
return !outPoints.empty();
}
catch (my::Json::Exception&)
{
return false;
}
return false;
}
void on_request_gate_cb(pc_request_t *req, int status, json_t *resp) {
if (status == -1) {
printf("Fail to send request to server.\n");
} else if (status == 0) {
connectorHost = json_string_value(json_object_get(resp, "host"));
connectorPort = json_number_value(json_object_get(resp, "port"));
pc_client_t *client = pc_client_new();
struct sockaddr_in address;
memset(&address, 0, sizeof(struct sockaddr_in));
address.sin_family = AF_INET;
address.sin_port = htons(connectorPort);
address.sin_addr.s_addr = inet_addr(connectorHost);
// add pomelo events listener
pc_add_listener(client, "disconnect", on_disconnect);
pc_add_listener(client, "onChat", on_chat);
pc_add_listener(client, "onAdd", on_add);
pc_add_listener(client, "onLeave", on_leave);
printf("try to connect to connector server %s %d\n", connectorHost, connectorPort);
// try to connect to server.
if (pc_client_connect(client, &address)) {
printf("fail to connect connector server.\n");
pc_client_destroy(client);
return ;
}
const char *route = "connector.entryHandler.enter";
json_t *msg = json_object();
json_t *str = json_string(user);
json_t *channel_str = json_string(channel);
json_object_set_new(msg, "username", str);
json_object_set_new(msg, "rid", channel_str);
pc_request_t *request = pc_request_new();
printf("%s %s\n", user, channel);
pc_request(client, request, route, msg, on_request_connector_cb);
}
// release relative resource with pc_request_t
json_t *pc_msg = req->msg;
pc_client_t *pc_client = req->client;
json_decref(pc_msg);
pc_request_destroy(req);
pc_client_stop(pc_client);
}
void BinWriter::writeType(json_t *jtype)
{
TypeIndex *tindex = new TypeIndex;
typeIndexes.push_back(tindex);
tindex->position = bytes.getPosition();
utString package = json_string_value(json_object_get(jtype, "package"));
utString name = json_string_value(json_object_get(jtype, "name"));
utString fullname = package;
fullname += ".";
fullname += name;
tindex->iFullName = poolString(fullname.c_str());
int itype = poolJString(json_object_get(jtype, "type"));
int ipackagename = poolString(package.c_str());
int iname = poolString(name.c_str());
json_t *jtypeid = json_object_get(jtype, "typeid");
assert(jtypeid && json_is_number(jtypeid));
int itypeid = (int)json_number_value(jtypeid);
int isource = -1;
int ilinenumber = -1;
json_t *jsource = json_object_get(jtype, "source");
if (jsource && json_is_string(jsource))
{
isource = poolString(json_string_value(jsource));
ilinenumber = (int)json_integer_value(json_object_get(jtype, "line"));
}
bytes.writeInt(itype);
bytes.writeInt(ipackagename);
bytes.writeInt(iname);
bytes.writeInt(itypeid);
bytes.writeInt(isource);
bytes.writeInt(ilinenumber);
writeClass(jtype);
tindex->length = bytes.getPosition() - tindex->position;
}
double JSON::getArrayNumber(int index)
{
if (!isArray())
{
return 0.f;
}
json_t *jobject = json_array_get(_json, index);
if (!jobject || !json_is_number(jobject))
{
return 0.f;
}
return (double)json_number_value(jobject);
}
double JSON::getNumber(const char *key)
{
if (!_json)
{
return 0;
}
json_t *jreal = json_object_get(_json, key);
if (!jreal)
{
return 0;
}
return (double)json_number_value(jreal);
}
//native Float:json_number_value(Handle:hNumber);
static cell_t Native_json_number_value(IPluginContext *pContext, const cell_t *params) {
HandleError err;
HandleSecurity sec;
sec.pOwner = NULL;
sec.pIdentity = myself->GetIdentity();
// Param 1
json_t *object;
Handle_t hndlObject = static_cast<Handle_t>(params[1]);
if ((err=g_pHandleSys->ReadHandle(hndlObject, htJanssonObject, &sec, (void **)&object)) != HandleError_None)
{
return pContext->ThrowNativeError("Invalid <Real> handle %x (error %d)", hndlObject, err);
}
return sp_ftoc(json_number_value(object));
}
bool watchman_perf_sample::finish() {
gettimeofday(&time_end, nullptr);
w_timeval_sub(time_end, time_begin, &duration);
#ifdef HAVE_SYS_RESOURCE_H
getrusage(RUSAGE_SELF, &usage_end);
// Compute the delta for the usage
w_timeval_sub(usage_end.ru_utime, usage_begin.ru_utime, &usage.ru_utime);
w_timeval_sub(usage_end.ru_stime, usage_begin.ru_stime, &usage.ru_stime);
#define DIFFU(n) usage.n = usage_end.n - usage_begin.n
DIFFU(ru_maxrss);
DIFFU(ru_ixrss);
DIFFU(ru_idrss);
DIFFU(ru_minflt);
DIFFU(ru_majflt);
DIFFU(ru_nswap);
DIFFU(ru_inblock);
DIFFU(ru_oublock);
DIFFU(ru_msgsnd);
DIFFU(ru_msgrcv);
DIFFU(ru_nsignals);
DIFFU(ru_nvcsw);
DIFFU(ru_nivcsw);
#undef DIFFU
#endif
if (!will_log) {
if (wall_time_elapsed_thresh == 0) {
auto thresh = cfg_get_json("perf_sampling_thresh");
if (thresh) {
if (json_is_number(thresh)) {
wall_time_elapsed_thresh = json_number_value(thresh);
} else {
json_unpack(thresh, "{s:f}", description, &wall_time_elapsed_thresh);
}
}
}
if (wall_time_elapsed_thresh > 0 &&
w_timeval_diff(time_begin, time_end) > wall_time_elapsed_thresh) {
will_log = true;
}
}
return will_log;
}
static bool stratum_set_difficulty(struct stratum_ctx *sctx, json_t *params)
{
double diff;
diff = json_number_value(json_array_get(params, 0));
if (diff == 0)
return false;
pthread_mutex_lock(&sctx->work_lock);
sctx->next_diff = diff;
pthread_mutex_unlock(&sctx->work_lock);
if (opt_debug)
applog(LOG_DEBUG, "Stratum difficulty set to %g", diff);
return true;
}
map_table_t *json_to_map(bombyx_env_t *env, json_t *json)
{
size_t index;
json_t *value;
const char *key;
map_table_t *map;
// TODO: minimum map size (100?)
if (json_is_object(json))
{
map = map_table_create(json_object_size(json));
json_object_foreach(json, key, value)
{
var v = {0};
if (json_is_object(value))
{
// process recursively
v.type = VAR_MAP;
v.data = json_to_map(env, value);
v.data_size = sizeof(map_table_t);
}
else if (json_is_array(value))
{
v.type = VAR_ARRAY;
v.data = json_to_array(env, value);
v.data_size = sizeof(array_t);
}
else if (json_is_string(value))
{
v.type = VAR_STRING;
v.data = strdup(json_string_value(value));
v.data_size = json_string_length(value) + 1;
}
else if (json_is_number(value))
{
v.type = VAR_DOUBLE;
v.data = challoc(env->pool_of_doubles);
v.data_size = sizeof(double);
*(double *)v.data = json_number_value(value);
}
map_add(env, map, (char *)key, v);
}
}
int osd_object_get_id(json_object_t obj)
{
int id = -1;
json_object_t v = json_object_get(obj, "id");
if (json_isnull(v)) {
log_err("OpenSensorData: Object has no ID");
return -1;
}
if (json_isstring(v)) {
id = atoi(json_string_value(v));
} else if (json_isnumber(v)) {
id = json_number_value(v);
} else {
log_err("OpenSensorData: ID value is not a string nor a number!");
return -1;
}
return id;
}
ssm_var_t *ssm_var_new(json_t *jparameters, ssm_nav_t *nav)
{
gsl_matrix *m = gsl_matrix_calloc(nav->theta_all->length, nav->theta_all->length);
int i,j, index;
ssm_it_parameters_t *it = nav->theta_all;
json_t *jresource = json_object_get(jparameters, "resources");
for(index=0; index< json_array_size(jresource); index++){
json_t *el = json_array_get(jresource, index);
const char* name = json_string_value(json_object_get(el, "name"));
if (strcmp(name, "covariance") == 0) {
json_t *values = json_object_get(el, "data");
for(i=0; i<it->length; i++){
for(j=0; j<it->length; j++){
json_t *jcov_i = json_object_get(values, it->p[i]->name);
if(jcov_i){
json_t *jcov_ij = json_object_get(jcov_i, it->p[j]->name);
if(jcov_ij){
if(json_is_number(jcov_ij)) {
gsl_matrix_set(m, i, j, json_number_value(jcov_ij));
} else {
char str[SSM_STR_BUFFSIZE];
snprintf(str, SSM_STR_BUFFSIZE, "error: parameters.covariance.%s.%s is not a number\n", it->p[i]->name, it->p[j]->name);
ssm_print_err(str);
exit(EXIT_FAILURE);
}
}
}
}
}
break;
}
}
return m;
}
// gets a json value from a key
int json_object_get_double(json_t *object, char *key, double **value)
{
double *value_return = NULL;
int exit_code = 0;
check_not_null(object);
check_not_null(key);
check_not_null(value);
json_t *json_number_peek = json_object_get(object, key);
if (json_number_peek == NULL)
{
*value = NULL;
goto cleanup;
}
int json_typeof_result = json_typeof(json_number_peek);
if (json_typeof_result != JSON_INTEGER && json_typeof_result != JSON_REAL)
{
*value = NULL;
goto cleanup;
}
double value_peek = json_number_value(json_number_peek);
check_result(malloc_memcpy_double(&value_return, &value_peek), 0);
*value = value_return;
goto cleanup;
error:
if (value_return != NULL) { free(value_return); }
exit_code = -1;
cleanup:
return exit_code;
}
void Stimulus3DShaderDemo::receive_json_message(const std::string& topic_name,
const std::string& json_message) {
json_t *root;
json_error_t error;
root = json_loads(json_message.c_str(), 0, &error);
if(!root) {
throw std::runtime_error("error in json");
}
json_t *data_json = json_object_get(root, "data");
if (data_json==NULL) {
throw std::runtime_error("key not in JSON");
}
if(!json_is_number(data_json)){
throw std::runtime_error("error in json");
}
_example_param = json_number_value( data_json );
example_param_uniform->set(_example_param);
}
/*
* parse (optional) timestamp from payload
*/
static apr_byte_t oidc_jose_get_timestamp(apr_pool_t *pool, json_t *json,
const char *claim_name, apr_byte_t is_mandatory, double *result,
oidc_jose_error_t *err) {
*result = OIDC_JWT_CLAIM_TIME_EMPTY;
json_t *v = json_object_get(json, claim_name);
if (v != NULL) {
if (json_is_number(v)) {
*result = json_number_value(v);
} else if (is_mandatory) {
oidc_jose_error(err,
"mandatory JSON key \"%s\" was found but the type is not a number",
claim_name);
return FALSE;
}
} else if (is_mandatory) {
oidc_jose_error(err, "mandatory JSON key \"%s\" could not be found",
claim_name);
return FALSE;
}
return TRUE;
}
char *
build_hello_rsp (char *sub, json_t *hellorsp)
{
uint8_t *nonce = malloc (32);
gcry_create_nonce (nonce, 32);
char *bnonce;
int nl = base64url_encode_alloc (nonce, 32, &bnonce);
time_t current_time;
current_time = time(NULL);
json_t *obj = json_object();
double msg_id = json_number_value( json_object_get (hellorsp, "msg_id"));
const char *snonce = json_string_value( json_object_get (hellorsp, "jti"));
json_object_set_new(obj, "jti", json_string(bnonce));
json_object_set_new(obj, "sub", json_string(sub));
json_object_set_new(obj, "snonce", json_string(snonce));
json_object_set_new(obj, "Version", json_integer(1));
json_object_set_new(obj, "msg_id", json_integer(msg_id + 1));
json_object_set_new(obj, "iat", json_integer (current_time));
json_object_set_new(obj, "exp", json_integer (current_time + 60 * 5));
char * jwt = jwt_encode_old (obj, ES256, hard_sign);
assert (NULL != jwt);
return jwt;
}
/* Call the simple functions not covered by other tests of the public API */
int main()
{
json_t *value;
value = json_integer(1);
if(json_typeof(value) != JSON_INTEGER)
fail("json_typeof failed");
if(json_is_object(value))
fail("json_is_object failed");
if(json_is_array(value))
fail("json_is_array failed");
if(json_is_string(value))
fail("json_is_string failed");
if(!json_is_integer(value))
fail("json_is_integer failed");
if(json_is_real(value))
fail("json_is_real failed");
if(!json_is_number(value))
fail("json_is_number failed");
if(json_is_true(value))
fail("json_is_true failed");
if(json_is_false(value))
fail("json_is_false failed");
if(json_is_boolean(value))
fail("json_is_boolean failed");
if(json_is_null(value))
fail("json_is_null failed");
json_decref(value);
value = json_string("foo");
if(!value)
fail("json_string failed");
if(strcmp(json_string_value(value), "foo"))
fail("invalid string value");
if(json_string_set(value, "bar"))
fail("json_string_set failed");
if(strcmp(json_string_value(value), "bar"))
fail("invalid string value");
json_decref(value);
value = json_string(NULL);
if(value)
fail("json_string(NULL) failed");
/* invalid UTF-8 */
value = json_string("a\xefz");
if(value)
fail("json_string(<invalid utf-8>) failed");
value = json_string_nocheck("foo");
if(!value)
fail("json_string_nocheck failed");
if(strcmp(json_string_value(value), "foo"))
fail("invalid string value");
if(json_string_set_nocheck(value, "bar"))
fail("json_string_set_nocheck failed");
if(strcmp(json_string_value(value), "bar"))
fail("invalid string value");
json_decref(value);
/* invalid UTF-8 */
value = json_string_nocheck("qu\xff");
if(!value)
fail("json_string_nocheck failed");
if(strcmp(json_string_value(value), "qu\xff"))
fail("invalid string value");
if(json_string_set_nocheck(value, "\xfd\xfe\xff"))
fail("json_string_set_nocheck failed");
if(strcmp(json_string_value(value), "\xfd\xfe\xff"))
fail("invalid string value");
json_decref(value);
value = json_integer(123);
if(!value)
fail("json_integer failed");
if(json_integer_value(value) != 123)
fail("invalid integer value");
if(json_number_value(value) != 123.0)
fail("invalid number value");
if(json_integer_set(value, 321))
fail("json_integer_set failed");
if(json_integer_value(value) != 321)
fail("invalid integer value");
if(json_number_value(value) != 321.0)
fail("invalid number value");
json_decref(value);
value = json_real(123.123);
if(!value)
fail("json_real failed");
if(json_real_value(value) != 123.123)
fail("invalid integer value");
if(json_number_value(value) != 123.123)
fail("invalid number value");
if(json_real_set(value, 321.321))
fail("json_real_set failed");
if(json_real_value(value) != 321.321)
fail("invalid real value");
if(json_number_value(value) != 321.321)
fail("invalid number value");
json_decref(value);
value = json_true();
if(!value)
fail("json_true failed");
json_decref(value);
value = json_false();
if(!value)
fail("json_false failed");
json_decref(value);
value = json_null();
if(!value)
fail("json_null failed");
json_decref(value);
/* Test reference counting on singletons (true, false, null) */
value = json_true();
if(value->refcount != (size_t)-1)
fail("refcounting true works incorrectly");
json_decref(value);
if(value->refcount != (size_t)-1)
fail("refcounting true works incorrectly");
json_incref(value);
if(value->refcount != (size_t)-1)
fail("refcounting true works incorrectly");
value = json_false();
if(value->refcount != (size_t)-1)
fail("refcounting false works incorrectly");
json_decref(value);
if(value->refcount != (size_t)-1)
fail("refcounting false works incorrectly");
json_incref(value);
if(value->refcount != (size_t)-1)
fail("refcounting false works incorrectly");
value = json_null();
if(value->refcount != (size_t)-1)
fail("refcounting null works incorrectly");
json_decref(value);
if(value->refcount != (size_t)-1)
fail("refcounting null works incorrectly");
json_incref(value);
if(value->refcount != (size_t)-1)
fail("refcounting null works incorrectly");
return 0;
}
int delete_route(char *address, int netmask)
{
struct rtnl_handle rth = { .fd = -1 };
if (rtnl_open(&rth, 0) < 0) {
exit(1);
}
struct iplink_req req;
memset(&req, 0, sizeof(req));
req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
req.n.nlmsg_type = RTM_DELROUTE;
req.rtm.rtm_family = AF_UNSPEC;
req.rtm.rtm_table = RT_TABLE_MAIN;
req.rtm.rtm_scope = RT_SCOPE_NOWHERE;
inet_prefix dst;
get_prefix(&dst, address, req.rtm.rtm_family);
req.rtm.rtm_family = dst.family;
if (req.rtm.rtm_family == AF_UNSPEC) {
req.rtm.rtm_family = AF_INET;
}
req.rtm.rtm_dst_len = netmask;
if (dst.bytelen) {
addattr_l(&req.n, sizeof(req), RTA_DST, &dst.data, dst.bytelen);
}
ll_init_map(&rth);
struct nlmsghdr *answer;
int errnum = rtnl_talkE(&rth, &req.n, 0, 0, &answer, NULL, NULL);
if (errnum < 0) {
exit(2);
}
if (answer) {
switch (errnum) {
case 0: // Success
fprintf(stderr, "delete route to %s\n", address);
break;
case 3: // No such device
// fprintf(stderr, "already deleted.\n");
break;
default:
fprintf(stderr, "ERROR!\terrno: %d\n", errnum);
perror("Netlink");
exit(2);
break;
}
} else {
fprintf(stderr, "Something Wrong!\n");
exit(2);
}
return 0;
}
int delete_all_route()
{
struct rtnl_handle rth = { .fd = -1 };
if (rtnl_open(&rth, 0) < 0) {
exit(1);
}
int preferred_family = AF_PACKET;
if (rtnl_wilddump_request(&rth, preferred_family, RTM_GETROUTE) < 0) {
perror("Cannot send dump request");
exit(1);
}
struct nlmsg_list *rinfo = NULL;
if (rtnl_dump_filter(&rth, store_nlmsg, &rinfo, NULL, NULL) < 0) {
fprintf(stderr, "Dump terminated\n");
exit(1);
}
struct nlmsg_list *r, *n;
for (r = rinfo; r; r = n) {
n = r->next;
struct nlmsghdr *nlhdr = &(r->h);
if (nlhdr->nlmsg_type != RTM_NEWROUTE && nlhdr->nlmsg_type != RTM_DELROUTE) {
fprintf(stderr, "Not a route: %08x %08x %08x\n", nlhdr->nlmsg_len, nlhdr->nlmsg_type, nlhdr->nlmsg_flags);
return 0;
}
struct rtmsg *rtm = NLMSG_DATA(nlhdr);
int len = nlhdr->nlmsg_len - NLMSG_LENGTH(sizeof(*rtm));
if (len < 0) {
fprintf(stderr, "BUG: wrong nlmsg len %d\n", len);
return -1;
}
// Analyze rtattr Message
struct rtattr *tb[RTA_MAX + 1];
parse_rtattr(tb, RTA_MAX, RTM_RTA(rtm), len);
char dst_address[64] = "";
char abuf[256];
int host_len = calc_host_len(rtm);
if (tb[RTA_DST]) {
if (rtm->rtm_dst_len != host_len) {
sprintf(dst_address, "%s/%d", rt_addr_n2a(rtm->rtm_family, RTA_PAYLOAD(tb[RTA_DST]), RTA_DATA(tb[RTA_DST]), abuf, sizeof(abuf)), rtm->rtm_dst_len);
} else {
sprintf(dst_address, "%s", format_host(rtm->rtm_family, RTA_PAYLOAD(tb[RTA_DST]), RTA_DATA(tb[RTA_DST]), abuf, sizeof(abuf)));
}
} else if (rtm->rtm_dst_len) {
sprintf(dst_address, "0/%d", rtm->rtm_dst_len);
} else {
sprintf(dst_address, "default");
}
if (strncmp(dst_address, "127.0.0.0", 9) != 0 && strcmp(dst_address, "ff00::") != 0) {
delete_route((char *) dst_address, rtm->rtm_dst_len);
}
}
printf("delete all routes.\n\n");
free(r);
rtnl_close(&rth);
return 0;
}
// network is unreachableを回避するため、全経路を登録し終えるまでwhileループを回す
void modify_route(json_t *ipRouteEntry_json, int default_flag)
{
int end = 0;
while (end == 0) {
end = 1;
int i;
for (i = 0; i < (int) json_array_size(ipRouteEntry_json); i++) {
json_t *route_json = json_array_get(ipRouteEntry_json, i);
json_t *linux_json = json_object_get(route_json, "linux");
struct rtnl_handle rth = { .fd = -1 };
if (rtnl_open(&rth, 0) < 0) {
exit(1);
}
struct iplink_req req;
memset(&req, 0, sizeof(req));
req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL;
req.n.nlmsg_type = RTM_NEWROUTE;
req.rtm.rtm_family = AF_UNSPEC;
req.rtm.rtm_type = (int) json_number_value(json_object_get(route_json, "ipRouteType"));
if (req.rtm.rtm_type >= 5) { // 5以降は定義されていない
req.rtm.rtm_type = 1;
}
req.rtm.rtm_protocol = (int) json_number_value(json_object_get(route_json, "ipRouteProto"));
req.rtm.rtm_scope = (int) json_number_value(json_object_get(linux_json, "rtm_scope"));
req.rtm.rtm_table = (int) json_number_value(json_object_get(linux_json, "rtm_table"));
req.rtm.rtm_dst_len = (int) json_number_value(json_object_get(route_json, "ipRouteMask"));
char *route_name = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
const char *key;
json_t *value;
json_object_foreach(route_json, key, value) {
if (strcmp(key, "ipRouteDest") == 0) {
inet_prefix dst;
route_name = (char *) json_string_value(value);
get_prefix(&dst, route_name, req.rtm.rtm_family);
if (req.rtm.rtm_family == AF_UNSPEC) {
req.rtm.rtm_family = dst.family;
}
if (dst.bytelen) {
addattr_l(&req.n, sizeof(req), RTA_DST, &dst.data, dst.bytelen);
}
}
if (strcmp(key, "ipRouteIfIndex") == 0) {
addattr32(&req.n, sizeof(req), RTA_OIF, json_integer_value(value));
}
if (strcmp(key, "ipRouteNextHop") == 0) {
inet_prefix addr;
get_addr(&addr, (char *) json_string_value(value), req.rtm.rtm_family);
if (req.rtm.rtm_family == AF_UNSPEC) {
req.rtm.rtm_family = addr.family;
}
addattr_l(&req.n, sizeof(req), RTA_GATEWAY, &addr.data, addr.bytelen);
}
if (strcmp(key, "ipRouteMetric1") == 0) {
addattr32(&req.n, sizeof(req), RTA_PRIORITY, json_integer_value(value));
}
if (strcmp(key, "ipRouteInfo") == 0) {
inet_prefix addr;
get_addr(&addr, (char *) json_string_value(value), req.rtm.rtm_family);
if (req.rtm.rtm_family == AF_UNSPEC) {
req.rtm.rtm_family = addr.family;
}
addattr_l(&req.n, sizeof(req), RTA_PREFSRC, &addr.data, addr.bytelen);
}
}
ll_init_map(&rth);
if (req.rtm.rtm_family == AF_UNSPEC) {
req.rtm.rtm_family = AF_INET;
}
struct nlmsghdr *answer;
int errnum = rtnl_talkE(&rth, &req.n, 0, 0, &answer, NULL, NULL);
if (errnum < 0) {
exit(2);
}
if (answer) {
switch (errnum) {
case 0: // Success
fprintf(stderr, "arrange route to %s/%d\n", route_name, req.rtm.rtm_dst_len);
break;
case 17: // File exists
// fprintf(stderr, "route already exists.\n");
break;
case 19: // No such device
// fprintf(stderr, "No such device");
break;
case 101: // Network is unreachable
end = 0;
break;
default:
fprintf(stderr, "ERROR!\terrno: %d\n", errnum);
perror("Netlink");
exit(2);
break;
}
} else {
fprintf(stderr, "Something Wrong!\n");
exit(2);
}
}
}
}
int read_route_file(json_t *routes_json)
{
// routeの削除
delete_all_route();
json_t *ipRouteEntry_json = json_object_get(routes_json, "ipRouteEntry");
// defaultへの経路はGatewayへの経路が登録されてからでないとnetwork is unreachableになるので
// defaultへの経路とそうでないものを分ける
modify_route(ipRouteEntry_json, 0);
modify_route(ipRouteEntry_json, 1);
fprintf(stderr, "Success arranging all routes!\n\n");
return 0;
}
int schema_traverse(const avro_schema_t schema, json_t *json, json_t *dft,
avro_value_t *current_val, int quiet, int strjson, size_t max_str_sz) {
json = json ? json : dft;
if (!json) {
fprintf(stderr, "ERROR: Avro schema does not match JSON\n");
return 1;
}
switch (schema->type) {
case AVRO_RECORD:
{
if (!json_is_object(json)) {
if (!quiet)
fprintf(stderr, "ERROR: Expecting JSON object for Avro record, got something else\n");
return 1;
}
int len = avro_schema_record_size(schema), i;
for (i=0; i<len; i++) {
const char *name = avro_schema_record_field_name(schema, i);
avro_schema_t field_schema = avro_schema_record_field_get_by_index(schema, i);
json_t *json_val = json_object_get(json, name);
json_t *dft = avro_schema_record_field_default_get_by_index(schema, i);
avro_value_t field;
avro_value_get_by_index(current_val, i, &field, NULL);
if (schema_traverse(field_schema, json_val, dft, &field, quiet, strjson, max_str_sz))
return 1;
}
} break;
case AVRO_LINK:
/* TODO */
fprintf(stderr, "ERROR: AVRO_LINK is not implemented\n");
return 1;
break;
case AVRO_STRING:
if (!json_is_string(json)) {
if (json && strjson) {
/* -j specified, just dump the remaining json as string */
char * js = json_dumps(json, JSON_COMPACT|JSON_SORT_KEYS|JSON_ENCODE_ANY);
if (max_str_sz && (strlen(js) > max_str_sz))
js[max_str_sz] = 0; /* truncate the string - this will result in invalid JSON! */
avro_value_set_string(current_val, js);
free(js);
break;
}
if (!quiet)
fprintf(stderr, "ERROR: Expecting JSON string for Avro string, got something else\n");
return 1;
} else {
const char *js = json_string_value(json);
if (max_str_sz && (strlen(js) > max_str_sz)) {
/* truncate the string */
char *jst = malloc(strlen(js));
strcpy(jst, js);
jst[max_str_sz] = 0;
avro_value_set_string(current_val, jst);
free(jst);
} else
avro_value_set_string(current_val, js);
}
break;
case AVRO_BYTES:
if (!json_is_string(json)) {
if (!quiet)
fprintf(stderr, "ERROR: Expecting JSON string for Avro string, got something else\n");
return 1;
}
/* NB: Jansson uses null-terminated strings, so embedded nulls are NOT
supported, not even escaped ones */
const char *s = json_string_value(json);
avro_value_set_bytes(current_val, (void *)s, strlen(s));
break;
case AVRO_INT32:
if (!json_is_integer(json)) {
if (!quiet)
fprintf(stderr, "ERROR: Expecting JSON integer for Avro int, got something else\n");
return 1;
}
avro_value_set_int(current_val, json_integer_value(json));
break;
case AVRO_INT64:
if (!json_is_integer(json)) {
if (!quiet)
fprintf(stderr, "ERROR: Expecting JSON integer for Avro long, got something else\n");
return 1;
}
avro_value_set_long(current_val, json_integer_value(json));
break;
case AVRO_FLOAT:
if (!json_is_number(json)) {
if (!quiet)
fprintf(stderr, "ERROR: Expecting JSON number for Avro float, got something else\n");
return 1;
}
avro_value_set_float(current_val, json_number_value(json));
break;
case AVRO_DOUBLE:
if (!json_is_number(json)) {
if (!quiet)
fprintf(stderr, "ERROR: Expecting JSON number for Avro double, got something else\n");
return 1;
}
avro_value_set_double(current_val, json_number_value(json));
break;
case AVRO_BOOLEAN:
if (!json_is_boolean(json)) {
if (!quiet)
fprintf(stderr, "ERROR: Expecting JSON boolean for Avro boolean, got something else\n");
return 1;
}
avro_value_set_boolean(current_val, json_is_true(json));
break;
case AVRO_NULL:
if (!json_is_null(json)) {
if (!quiet)
fprintf(stderr, "ERROR: Expecting JSON null for Avro null, got something else\n");
return 1;
}
avro_value_set_null(current_val);
break;
case AVRO_ENUM:
// TODO ???
break;
case AVRO_ARRAY:
if (!json_is_array(json)) {
if (!quiet)
fprintf(stderr, "ERROR: Expecting JSON array for Avro array, got something else\n");
return 1;
} else {
int i, len = json_array_size(json);
avro_schema_t items = avro_schema_array_items(schema);
avro_value_t val;
for (i=0; i<len; i++) {
avro_value_append(current_val, &val, NULL);
if (schema_traverse(items, json_array_get(json, i), NULL, &val, quiet, strjson, max_str_sz))
return 1;
}
}
break;
case AVRO_MAP:
if (!json_is_object(json)) {
if (!quiet)
fprintf(stderr, "ERROR: Expecting JSON object for Avro map, got something else\n");
return 1;
} else {
avro_schema_t values = avro_schema_map_values(schema);
void *iter = json_object_iter(json);
avro_value_t val;
while (iter) {
avro_value_add(current_val, json_object_iter_key(iter), &val, 0, 0);
if (schema_traverse(values, json_object_iter_value(iter), NULL, &val, quiet, strjson, max_str_sz))
return 1;
iter = json_object_iter_next(json, iter);
}
}
break;
case AVRO_UNION:
{
int i;
avro_value_t branch;
for (i=0; i<avro_schema_union_size(schema); i++) {
avro_value_set_branch(current_val, i, &branch);
avro_schema_t type = avro_schema_union_branch(schema, i);
if (!schema_traverse(type, json, NULL, &branch, 1, strjson, max_str_sz))
break;
}
if (i==avro_schema_union_size(schema)) {
fprintf(stderr, "ERROR: No type in the Avro union matched the JSON type we got\n");
return 1;
}
break;
}
case AVRO_FIXED:
if (!json_is_string(json)) {
if (!quiet)
fprintf(stderr, "ERROR: Expecting JSON string for Avro fixed, got something else\n");
return 1;
}
/* NB: Jansson uses null-terminated strings, so embedded nulls are NOT
supported, not even escaped ones */
const char *f = json_string_value(json);
if (avro_value_set_fixed(current_val, (void *)f, strlen(f))) {
fprintf(stderr, "ERROR: Setting Avro fixed value FAILED\n");
return 1;
}
break;
default:
fprintf(stderr, "ERROR: Unknown type: %d\n", schema->type);
return 1;
}
return 0;
}
static int gen_jansson_value(yajl_gen gen, json_t *value) {
json_error_t jerr;
const char *str;
size_t len;
int rc;
int type = json_typeof(value);
switch(type) {
case JSON_OBJECT:
yajl_gen_map_open(gen);
gen_jansson_object(gen,value);
yajl_gen_map_close(gen);
break;
case JSON_ARRAY:
yajl_gen_array_open(gen);
gen_jansson_array(gen,value);
yajl_gen_array_close(gen);
break;
case JSON_STRING:
rc = json_unpack_ex(value, &jerr, 0, "s%", &str,&len);
if(rc != 0) {
rdlog(LOG_ERR,"Couldn't extract string: %s",jerr.text);
return 0;
}
yajl_gen_string(gen, (const unsigned char *)str, len);
break;
case JSON_INTEGER:
{
json_int_t i = json_integer_value(value);
yajl_gen_integer(gen,i);
}
break;
case JSON_REAL:
{
double d = json_number_value(value);
yajl_gen_double(gen,d);
}
break;
case JSON_TRUE:
yajl_gen_bool(gen,1);
break;
case JSON_FALSE:
yajl_gen_bool(gen,0);
break;
case JSON_NULL:
yajl_gen_null(gen);
break;
default:
rdlog(LOG_ERR,"Unkown jansson type %d",type);
break;
};
return 1;
}
ssm_nav_t *ssm_nav_new(json_t *jparameters, ssm_options_t *opts)
{
char str[SSM_STR_BUFFSIZE];
ssm_nav_t *nav = malloc(sizeof (ssm_nav_t));
if (nav == NULL) {
ssm_print_err("Allocation impossible for ssm_nav_t *");
exit(EXIT_FAILURE);
}
nav->implementation = opts->implementation;
nav->noises_off = opts->noises_off;
nav->print = opts->print;
nav->parameters = _ssm_parameters_new(&nav->parameters_length);
nav->states = _ssm_states_new(&nav->states_length, nav->parameters);
nav->observed = _ssm_observed_new(&nav->observed_length);
nav->states_sv = ssm_it_states_sv_new(nav->states);
nav->states_remainders = ssm_it_states_remainders_new(nav->states);
nav->states_inc = ssm_it_states_inc_new(nav->states);
nav->states_sv_inc = ssm_it_states_sv_inc_new(nav->states);
nav->states_diff = ssm_it_states_diff_new(nav->states);
nav->par_all = ssm_it_parameters_all_new(nav->parameters);
nav->par_noise = ssm_it_parameters_noise_new(nav->parameters);
nav->par_disp = ssm_it_parameters_disp_new(nav->parameters);
nav->par_icsv = ssm_it_parameters_icsv_new(nav->parameters);
nav->par_icdiff = ssm_it_parameters_icdiff_new(nav->parameters);
//theta: we over-allocate the iterators
nav->theta_all = _ssm_it_parameters_new(nav->par_all->length);
nav->theta_no_icsv_no_icdiff = _ssm_it_parameters_new(nav->par_all->length);
nav->theta_icsv_icdiff = _ssm_it_parameters_new(nav->par_all->length);
//json_t jparameters with diagonal covariance term to 0.0 won't be infered: re-compute length and content
nav->theta_all->length = 0;
nav->theta_no_icsv_no_icdiff->length = 0;
nav->theta_icsv_icdiff->length = 0;
int index, i;
json_t *jresource = json_object_get(jparameters, "resources");
for(index=0; index< json_array_size(jresource); index++){
json_t *el = json_array_get(jresource, index);
const char *name = json_string_value(json_object_get(el, "name"));
if (strcmp(name, "covariance") == 0) {
json_t *values = json_object_get(el, "data");
//for all the parameters: if covariance term and covariance term >0.0, fill theta_*
for(i=0; i<nav->par_all->length; i++){
json_t *jcov_i = json_object_get(values, nav->par_all->p[i]->name);
if(jcov_i){
json_t *jcov_ii = json_object_get(jcov_i, nav->par_all->p[i]->name);
if(jcov_ii){
if(!json_is_number(jcov_ii)) {
snprintf(str, SSM_STR_BUFFSIZE, "error: parameters.covariance.%s.%s is not a number\n", nav->par_all->p[i]->name, nav->par_all->p[i]->name);
ssm_print_err(str);
exit(EXIT_FAILURE);
}
if(json_number_value(jcov_ii) > 0.0){
if( ssm_in_par(nav->par_noise, nav->par_all->p[i]->name) ) {
if(!(nav->noises_off & SSM_NO_WHITE_NOISE)){
nav->theta_all->p[nav->theta_all->length] = nav->par_all->p[i];
nav->theta_all->p[nav->theta_all->length]->offset_theta = nav->theta_all->length;
nav->theta_all->length += 1;
}
} else if( ssm_in_par(nav->par_disp, nav->par_all->p[i]->name) ) {
if(!(nav->noises_off & SSM_NO_DIFF)){
nav->theta_all->p[nav->theta_all->length] = nav->par_all->p[i];
nav->theta_all->p[nav->theta_all->length]->offset_theta = nav->theta_all->length;
nav->theta_all->length += 1;
}
} else {
nav->theta_all->p[nav->theta_all->length] = nav->par_all->p[i];
nav->theta_all->p[nav->theta_all->length]->offset_theta = nav->theta_all->length;
nav->theta_all->length += 1;
}
int in_icsv = ssm_in_par(nav->par_icsv, nav->par_all->p[i]->name);
int in_icdiff =ssm_in_par(nav->par_icdiff, nav->par_all->p[i]->name);
if(!in_icsv && !in_icdiff){
nav->theta_no_icsv_no_icdiff->p[nav->theta_no_icsv_no_icdiff->length] = nav->par_all->p[i];
nav->theta_no_icsv_no_icdiff->length += 1;
} else if (in_icsv || in_icdiff){
if(in_icdiff){
if(!(nav->noises_off & SSM_NO_DIFF)){ //diffusion is allowed
nav->theta_icsv_icdiff->p[nav->theta_icsv_icdiff->length] = nav->par_all->p[i];
nav->theta_icsv_icdiff->length += 1;
} else {
nav->theta_no_icsv_no_icdiff->p[nav->theta_no_icsv_no_icdiff->length] = nav->par_all->p[i];
nav->theta_no_icsv_no_icdiff->length += 1;
}
} else {
nav->theta_icsv_icdiff->p[nav->theta_icsv_icdiff->length] = nav->par_all->p[i];
nav->theta_icsv_icdiff->length += 1;
}
}
}
}
}
}
break;
}
}
//files (CSV open and print headers)
if(opts->print & SSM_PRINT_TRACE){
#if SSM_JSON
nav->trace = stdout;
#else
snprintf(str, SSM_STR_BUFFSIZE, "%s/trace_%d.csv", opts->root, opts->id);
nav->trace = fopen(str, "w");
ssm_print_header_trace(nav->trace, nav);
#endif
} else {
nav->trace = NULL;
}
if(opts->print & SSM_PRINT_X){
#if SSM_JSON
nav->X = stdout;
#else
snprintf(str, SSM_STR_BUFFSIZE, "%s/X_%d.csv", opts->root, opts->id);
nav->X = fopen(str, "w");
ssm_print_header_X(nav->X, nav);
#endif
} else {
nav->X = NULL;
}
if(opts->print & SSM_PRINT_HAT){
#if SSM_JSON
nav->hat = stdout;
#else
snprintf(str, SSM_STR_BUFFSIZE, "%s/hat_%d.csv", opts->root, opts->id);
nav->hat = fopen(str, "w");
ssm_print_header_hat(nav->hat, nav);
#endif
} else {
nav->hat = NULL;
}
if(opts->print & SSM_PRINT_DIAG){
#if SSM_JSON
nav->diag = stdout;
#else
snprintf(str, SSM_STR_BUFFSIZE, "%s/diag_%d.csv", opts->root, opts->id);
nav->diag = fopen(str, "w");
if(opts->algo & (SSM_SMC | SSM_KALMAN)){
ssm_print_header_pred_res(nav->diag, nav);
} else if (opts->algo & (SSM_PMCMC | SSM_KMCMC)){
ssm_print_header_ar(nav->diag);
} else if (opts->algo & SSM_MIF){
ssm_mif_print_header_mean_var_theoretical_ess(nav->diag, nav);
}
#endif
} else {
nav->diag = NULL;
}
return nav;
}
