static int
watchman_send(struct watchman_connection *conn,
json_t *query, struct watchman_error *error)
{
int result;
if (use_bser_encoding) {
result = bser_write_to_file(query, conn->fp) == 0;
} else {
result = json_dumpf(query, conn->fp, JSON_COMPACT);
fputc('\n', conn->fp);
}
if (result) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
watchman_err(error, WATCHMAN_ERR_TIMEOUT,
"Timeout sending to watchman");
} else {
char *dump = json_dumps(query, 0);
watchman_err(error, WATCHMAN_ERR_OTHER,
"Failed to send watchman query %s", dump);
free(dump);
}
return 1;
}
return 0;
}
void ssm_json_dumpf(FILE *stream, const char *id, json_t *data)
{
json_t *root = json_pack("{s,s,s,o}", "id", id, "data", data);
json_dumpf(root, stdout, JSON_COMPACT); printf("\n");
fflush(stdout);
json_decref(root);
}
static int
watchman_send_simple_command(struct watchman_connection *conn,
struct watchman_error *error, ...)
{
int result = 0;
json_t *cmd_array = json_array();
va_list argptr;
va_start(argptr, error);
char *arg;
while ((arg = va_arg(argptr, char *))) {
json_array_append_new(cmd_array, json_string(arg));
}
if (use_bser_encoding) {
result = bser_write_to_file(cmd_array, conn->fp) == 0;
} else {
result = json_dumpf(cmd_array, conn->fp, JSON_COMPACT);
fputc('\n', conn->fp);
}
if (result) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
watchman_err(error, WATCHMAN_ERR_TIMEOUT,
"Timeout sending simple watchman command");
} else {
watchman_err(error, WATCHMAN_ERR_WATCHMAN_BROKEN,
"Failed to send simple watchman command");
}
result = 1;
}
json_decref(cmd_array);
return result;
}
int main( int argc, char *argv[] ) {
(void) argc;
GError *err = NULL;
ruminate_init(argv[0], &err);
die_if_error(err);
RType *rt = ruminate_get_type(stdout, &err);
die_if_error(err);
JsonState *st = json_state_new();
json_state_add_hook(st, g_quark_from_static_string("void"), &void_hook);
json_state_add_hook(st, g_quark_from_static_string("char *"), &char_ptr_hook);
json_state_set_flags(st, JSON_FLAG_SKIP_UNKNOWN);
printf("Hello World!");
json_t *serialized = json_serialize(st, rt, &stdout, &err);
die_if_error(err);
printf("\n");
json_dumpf(serialized, stdout, 0);
printf("\n");
json_decref(serialized);
r_type_unref(rt);
return EXIT_SUCCESS;
}
/**
* print empirical matrix of variance covariance
*/
void print_covariance(FILE *p_file_cov, gsl_matrix *covariance, struct s_data *p_data)
{
int i, k, row, ii, kk, col, col_csv;
double x;
#if FLAG_JSON
json_t *root;
json_t *json_print = json_array();
json_t *json_print_n;
#endif
struct s_iterator *p_it = p_data->p_it_all_no_theta_remainder;
struct s_router **routers = p_data->routers;
for (i=0; i< p_it->length; i++) {
for(k=0; k< routers[ p_it->ind[i] ]->n_gp; k++) {
row = p_it->offset[i]+k;
#if FLAG_JSON
json_print_n = json_array();
#endif
col_csv = 0;
for (ii=0; ii< p_it->length; ii++) {
for(kk=0; kk< routers[ p_it->ind[ii] ]->n_gp; kk++) {
col = p_it->offset[ii]+kk;
x = gsl_matrix_get(covariance, row, col);
#if FLAG_JSON
json_array_append_new(json_print_n, json_real(x));
#else
fprintf(p_file_cov,"%g%s", x, (col_csv < (p_it->nbtot-1)) ? ",": "");
#endif
col_csv++;
}
}
#if FLAG_JSON
json_array_append_new(json_print, json_print_n);
#else
fprintf(p_file_cov,"\n");
#endif
}
}
#if FLAG_JSON
root = json_pack("{s,s,s,o}", "flag", "cov", "msg", json_print);
json_dumpf(root, stdout, JSON_COMPACT); printf("\n");
fflush(stdout);
json_decref(root);
#endif
}
int ast_json_dump_file_format(struct ast_json *root, FILE *output, enum ast_json_encoding_format format)
{
/* Jansson's json_dump*, even though it's a read operation, isn't
* thread safe for concurrent reads. Locking is necessary.
* See http://www.digip.org/jansson/doc/2.4/portability.html#thread-safety. */
SCOPED_JSON_LOCK(root);
if (!root || !output) {
return -1;
}
return json_dumpf((json_t *)root, output, dump_flags(format));
}
void encode_other_than_array_or_object()
{
/* Encoding anything other than array or object should only
* succeed if the JSON_ENCODE_ANY flag is used */
json_t *json;
FILE *fp = NULL;
char *result;
json = json_string("foo");
if(json_dumps(json, 0) != NULL)
printf("json_dumps encoded a string!");
if(json_dumpf(json, fp, 0) == 0)
printf("json_dumpf encoded a string!");
result = json_dumps(json, JSON_ENCODE_ANY);
if(!result || strcmp(result, "\"foo\"") != 0)
printf("json_dumps failed to encode a string with JSON_ENCODE_ANY");
printf("encode_other_than_array_or_object() result1 = %s\n", result);
free(result);
json_decref(json);
json = json_integer(42);
if(json_dumps(json, 0) != NULL)
printf("json_dumps encoded an integer!");
if(json_dumpf(json, fp, 0) == 0)
printf("json_dumpf encoded an integer!");
result = json_dumps(json, JSON_ENCODE_ANY);
if(!result || strcmp(result, "42") != 0)
printf("json_dumps failed to encode an integer with JSON_ENCODE_ANY");
printf("encode_other_than_array_or_object() result2 = %s\n", result);
free(result);
json_decref(json);
}
void ssm_print_err(char *data)
{
#if SSM_JSON
json_t *root;
root = json_pack("{s,s,s,s}", "id", "err", "data", data);
json_dumpf(root, stderr, JSON_COMPACT); fprintf(stderr,"\n");
fflush(stderr);
json_decref(root);
#else
fprintf(stderr, "%s\n", data);
#endif
}
void ssm_print_log(char *data)
{
#if SSM_JSON
json_t *root;
root = json_pack("{s,s,s,s}", "id", "log", "data", data);
json_dumpf(root, stdout, JSON_COMPACT); printf("\n");
fflush(stdout);
json_decref(root);
#else
printf("%s\n", data);
#endif
}
static bool read_response(w_jbuffer_t *reader, int fd)
{
json_t *j;
json_error_t jerr;
if (no_pretty) {
// Just pass through what we get from the server.
// We use the buffer space from reader.
int x;
size_t res;
char *buf;
bool is_done = false;
while (!is_done) {
x = read(fd, reader->buf, reader->allocd);
if (x <= 0) {
return true;
}
if (memchr(reader->buf, '\n', x)) {
is_done = true;
}
buf = reader->buf;
while (x > 0) {
res = fwrite(buf, 1, x, stdout);
if (res == 0) {
break;
}
buf += res;
x -= res;
}
}
return true;
}
j = w_json_buffer_next(reader, fd, &jerr);
if (!j) {
w_log(W_LOG_ERR, "failed to parse response: %s\n",
jerr.text);
return false;
}
// Let's just pretty print the JSON response
json_dumpf(j, stdout, JSON_INDENT(4));
printf("\n");
json_decref(j);
return true;
}
static void encode_null()
{
if(json_dumps(NULL, JSON_ENCODE_ANY) != NULL)
fail("json_dumps didn't fail for NULL");
if(json_dumpf(NULL, stderr, JSON_ENCODE_ANY) != -1)
fail("json_dumpf didn't fail for NULL");
/* Don't test json_dump_file to avoid creating a file */
if(json_dump_callback(NULL, encode_null_callback, NULL, JSON_ENCODE_ANY) != -1)
fail("json_dump_callback didn't fail for NULL");
}
int main(int argc, const char* const argv[]){
if (argc < 2) {
printf("Usage: %s header.h\n", argv[0]);
printf("Standard clang arguments (-I, -D, etc.) may be used\n");
exit(1);
}
unsigned i;
char filename[] = "ffigen.tmp.XXXXXX";
int fd = mkstemp(filename);
FILE* file = fdopen(fd, "w");
fprintf(file, "#define _SIZE_T\n");
fprintf(file, "#define _PTRDIFF_T\n");
fprintf(file, "typedef __SIZE_TYPE__ size_t;\n");
fprintf(file, "typedef __PTRDIFF_TYPE__ ptrdiff_t;\n");
fprintf(file, "#include <%s>\n", argv[1]);
fclose(file);
int clang_argc = argc + 1;
const char** clang_argv = malloc(sizeof(char*) * clang_argc);
clang_argv[0] = "-x";
clang_argv[1] = "c";
clang_argv[2] = filename;
for (i=3; i < clang_argc; i++) {
clang_argv[i] = argv[i-1];
}
CXIndex Index = clang_createIndex(0, 0);
TU = clang_parseTranslationUnit(Index, 0, clang_argv, clang_argc,
0, 0, CXTranslationUnit_DetailedPreprocessingRecord);
json_t* json = json_object();
clang_visitChildren(clang_getTranslationUnitCursor(TU), visit_program, (CXClientData)json);
json_dumpf(json, stdout, JSON_INDENT(2) | JSON_PRESERVE_ORDER);
printf("\n");
json_decref(json);
for (i=0; i<clang_getNumDiagnostics(TU); i++) {
putstring(clang_formatDiagnostic(clang_getDiagnostic(TU, i), clang_defaultDiagnosticDisplayOptions()));
}
clang_disposeTranslationUnit(TU);
clang_disposeIndex(Index);
free(clang_argv);
unlink(filename);
return 0;
}
static int
watchman_send(struct watchman_connection *conn,
json_t *query, struct watchman_error *error)
{
int json_result = json_dumpf(query, conn->fp, JSON_COMPACT);
if (json_result) {
char *dump = json_dumps(query, 0);
watchman_err(error, "Failed to send watchman query %s", dump);
free(dump);
return 1;
}
fputc('\n', conn->fp);
return 0;
}
void CPUUsagePrintfIntervalJSON(CPUUsageContext_t *ctxt, FILE *outfile, size_t intervalIndex)
{
assert(ctxt);
assert(outfile);
CPUUsageIntervalStats_t *interval = CPUUsageGetInterval(ctxt, intervalIndex);
if (interval)
{
json_t *intervalJSON = CPUUsageIntervalToJSON(interval);
json_dumpf(intervalJSON, outfile, 0);
}
else
{
fprintf(outfile, "Invalid interval number %ld.\n", intervalIndex);
}
}
bool try_client_mode_command(const json_ref& cmd, bool pretty) {
auto client = std::make_shared<watchman_client>();
bool res;
client->client_mode = true;
res = dispatch_command(client.get(), cmd, CMD_CLIENT);
if (!client->responses.empty()) {
json_dumpf(
client->responses.front(),
stdout,
pretty ? JSON_INDENT(4) : JSON_COMPACT);
printf("\n");
}
return res;
}
static int
jcmd_jwk_exc(int argc, char *argv[])
{
jcmd_opt_auto_t opt = {};
json_auto_t *key = NULL;
json_t *tmpl = NULL;
if (!jcmd_opt_parse(argc, argv, cfgs, &opt, prefix))
return EXIT_FAILURE;
if (json_array_size(opt.keys) > 1 && json_array_remove(opt.keys, 0) < 0)
return EXIT_FAILURE;
if (json_array_size(opt.lcl) != 1) {
fprintf(stderr, "Local JWK must be specified exactly once!\n");
return EXIT_FAILURE;
}
if (json_array_size(opt.rem) != 1) {
fprintf(stderr, "Remote JWK must be specified exactly once!\n");
return EXIT_FAILURE;
}
key = jose_jwk_exc(NULL, json_array_get(opt.lcl, 0),
json_array_get(opt.rem, 0));
if (!key) {
fprintf(stderr, "Error performing exchange!\n");
return EXIT_FAILURE;
}
tmpl = json_array_get(opt.keys, json_array_size(opt.keys) - 1);
if (json_object_update(tmpl, key) < 0)
return EXIT_FAILURE;
if (json_dumpf(tmpl, opt.output, JSON_COMPACT | JSON_SORT_KEYS) < 0) {
fprintf(stderr, "Error writing JWK!\n");
return EXIT_FAILURE;
}
if (isatty(fileno(opt.output)))
fprintf(opt.output, "\n");
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
int indent = 0;
size_t flags = 0;
json_t *json;
json_error_t error;
if(argc != 1) {
fprintf(stderr, "usage: %s\n", argv[0]);
return 2;
}
indent = getenv_int("JSON_INDENT");
if(indent < 0 || indent > 255) {
fprintf(stderr, "invalid value for JSON_INDENT: %d\n", indent);
return 2;
}
if(indent > 0)
flags |= JSON_INDENT(indent);
if(getenv_int("JSON_COMPACT") > 0)
flags |= JSON_COMPACT;
if(getenv_int("JSON_ENSURE_ASCII"))
flags |= JSON_ENSURE_ASCII;
if(getenv_int("JSON_PRESERVE_ORDER"))
flags |= JSON_PRESERVE_ORDER;
if(getenv_int("JSON_SORT_KEYS"))
flags |= JSON_SORT_KEYS;
json = json_loadf(stdin, 0, &error);
if(!json) {
fprintf(stderr, "%d\n%s\n", error.line, error.text);
return 1;
}
json_dumpf(json, stdout, flags);
json_decref(json);
return 0;
}
/* encode a tpl (kv frame) as json. */
void *enc_worker(void *thread_id) {
char buf[MAX_BUF], *key, *val;
json_t *o = json_object();
int rc=-1, len, nc;
tpl_node *tn;
while (CF.shutdown == 0) {
len = nn_recv(CF.ingress_socket_pull, buf, MAX_BUF, 0);
if (len < 0) {
fprintf(stderr,"nn_recv: %s\n", nn_strerror(errno));
goto done;
}
/* decode, then re-encode as json */
json_object_clear(o);
tn = tpl_map("A(ss)",&key,&val); assert(tn);
if (tpl_load(tn,TPL_MEM,buf,len) < 0) goto done;
while(tpl_unpack(tn,1) > 0) {
json_t *jval = json_string(val);
json_object_set_new(o, key, jval);
free(key); key=NULL;
free(val); val=NULL;
}
tpl_free(tn);
/* dump the json object, then newline-terminate it. */
if (CF.verbose>1) json_dumpf(o, stderr, JSON_INDENT(1));
char *dump = json_dumps(o, JSON_INDENT(0));
size_t dump_len = strlen(dump);
/* give the buffer to nano, from here it goes to kaf thread */
nc = nn_send(CF.egress_socket_push, dump, dump_len, 0);
free(dump);
if (nc < 0) {
fprintf(stderr,"nn_send: %s\n", nn_strerror(errno));
goto done;
}
}
rc = 0;
done:
CF.shutdown = 1;
json_decref(o);
return NULL;
}
static void output_data_json(void)
{
json_t *obj = json_object();
assert(obj != NULL);
output_json_txid(obj);
bp_json_set_new_int(obj, "version", tx.nVersion);
bp_json_set_new_int(obj, "locktime", tx.nLockTime);
output_json_vin(obj);
output_json_vout(obj);
int rc = json_dumpf(obj, stdout, JSON_INDENT(4) | JSON_SORT_KEYS);
assert(rc == 0);
printf("\n");
if (opt_strict_free)
json_decref(obj);
}
void CPUUsagePrintfAllIntervalsJSON(CPUUsageContext_t *ctxt, FILE *outfile)
{
json_t *jWindow = json_object();
json_t *jIntervalsArray = json_array();
int numInterval = CPUUsageGetNumIntervals(ctxt);
for (int i = 0 ; i < numInterval; i++)
{
CPUUsageIntervalStats_t *curInterval = CPUUsageGetInterval(ctxt, i);
json_t *jCurInterval = CPUUsageIntervalToJSON(curInterval);
json_array_append_new(jIntervalsArray, jCurInterval);
}
json_object_set(jWindow, WINDOW_ALL_INTERVALS_KEY, jIntervalsArray);
json_decref(jIntervalsArray);
json_dumpf(jWindow, outfile, 0);
json_decref(jWindow);
}
static int
jwk_create (tc_argsd_t *arguments)
{
int rc;
gcry_sexp_t keyparm, key;
json_t *jwk;
rc = gcry_sexp_build (&keyparm, NULL,
"(genkey\n"
" (ecc\n"
" (curve \"NIST P-256\")\n"
" (flags param)"
"))");
if (rc) return rc;
rc = gcry_pk_genkey (&key, keyparm);
if (rc) return rc;
if (arguments->verbose)
show_sexp ("Gen key:\n", key);
gcry_sexp_release (keyparm);
jwk = gcry_pubkey2jwk (&key);
char *d = gcry_prikey2jwk (&key);
assert (NULL != d);
assert (0 == json_object_set (jwk, "d", json_string (d)));
json_dumpf(jwk, stdout, JSON_INDENT(2));
printf("\n");
return rc;
}
extern void error (
const errorSelection selection, const char *const format, ...)
{
va_list ap;
va_start (ap, format);
if (Option.json) {
char *reason;
vasprintf (&reason, format, ap);
json_t *response = json_object ();
json_object_set_new (response, "error", json_string (reason));
if (selected (selection, WARNING))
json_object_set_new (response, "warning", json_true ());
if (selected (selection, FATAL))
json_object_set_new (response, "fatal", json_true ());
if (selected (selection, PERROR)) {
json_object_set_new (response, "errno", json_integer (errno));
json_object_set_new (response, "perror", json_string (strerror (errno)));
}
json_dumpf (response, stdout, 0);
fprintf (stdout, "\n");
json_decref (response);
free (reason);
} else {
fprintf (errout, "%s: %s", getExecutableName (),
selected (selection, WARNING) ? "Warning: " : "");
vfprintf (errout, format, ap);
if (selected (selection, PERROR))
#ifdef HAVE_STRERROR
fprintf (errout, " : %s", strerror (errno));
#else
perror (" ");
#endif
fputs ("\n", errout);
}
va_end (ap);
if (! Option.json && selected (selection, FATAL))
exit (1);
}
/**
* remove summary (if any) and pipe hat. This is typicaly used for simulations
*/
void ssm_pipe_hat(FILE *stream, json_t *jparameters, ssm_input_t *input, ssm_hat_t *hat, ssm_par_t *par, ssm_calc_t *calc, ssm_nav_t *nav, ssm_options_t *opts, double t)
{
int i, index;
double x;
json_t *jresources = json_object_get(jparameters, "resources");
json_t *jsummary = NULL;
int index_summary;
for(index=0; index< json_array_size(jresources); index++){
json_t *el = json_array_get(jresources, index);
const char* name = json_string_value(json_object_get(el, "name"));
if (strcmp(name, "values") == 0) {
json_t *values = json_object_get(el, "data");
for(i=0; i<nav->theta_all->length; i++){
x = nav->theta_all->p[i]->f_2prior(gsl_vector_get(input, nav->theta_all->p[i]->offset), hat, par, calc, t);
json_object_set_new(values, nav->theta_all->p[i]->name, json_real(x));
}
} else if (strcmp(name, "summary") == 0){
jsummary = el;
index_summary = index;
}
}
if(jsummary){
json_array_remove(jresources, index_summary);
}
if(strcmp(opts->next, "") != 0){
char path[SSM_STR_BUFFSIZE];
snprintf(path, SSM_STR_BUFFSIZE, "%s/%s%d.json", opts->root, opts->next, opts->id);
json_dump_file(jparameters, path, JSON_INDENT(2));
} else {
json_dumpf(jparameters, stdout, JSON_COMPACT); printf("\n");
fflush(stdout);
}
}
static int
watchman_send_simple_command(struct watchman_connection *conn,
struct watchman_error *error, ...)
{
int result = 0;
json_t *cmd_array = json_array();
va_list argptr;
va_start(argptr, error);
char *arg;
while ((arg = va_arg(argptr, char *))) {
json_array_append_new(cmd_array, json_string(arg));
}
int json_result = json_dumpf(cmd_array, conn->fp, JSON_COMPACT);
if (json_result) {
watchman_err(error, "Failed to send simple watchman command");
result = 1;
}
fputc('\n', conn->fp);
json_decref(cmd_array);
return result;
}
/**
* for the webApp, we print the smoothed values
*/
void print_acceptance_rates(FILE *p_file, struct s_mcmc_calc_data *p, int m_full_iteration)
{
int k;
#if FLAG_JSON
json_t *root;
json_t *j_print = json_array();
#endif
#if FLAG_JSON
json_array_append_new(j_print, json_integer(m_full_iteration));
json_array_append_new(j_print, json_real(p->epsilon));
json_array_append_new(j_print, json_real(p->smoothed_global_acceptance_rate));
#else
fprintf(p_file, "%d,%g,%g", m_full_iteration, p->epsilon, p->global_acceptance_rate);
#endif
/* parameter specific acceptance rates */
if (!OPTION_FULL_UPDATE) {
for(k=0; k< (p->n_acceptance_rates); k++) {
#if FLAG_JSON
json_array_append_new(j_print, json_real(p->smoothed_acceptance_rates[k]));
#else
fprintf(p_file, ",%g", p->acceptance_rates[k]);
#endif
}
}
#if FLAG_JSON
root = json_pack("{s,s,s,o}", "flag", "pmcmc", "msg", j_print);
json_dumpf(root, stdout, JSON_COMPACT); printf("\n");
fflush(stdout);
json_decref(root);
#else
fprintf(p_file, "\n");
#endif
}
static void output_to_json(nghttp2_hd_deflater *deflater,
const uint8_t *buf, size_t len, size_t inputlen,
nghttp2_nv *nva, size_t nvlen,
int seq)
{
json_t *obj;
char *hex = NULL;
if(len > 0) {
hex = malloc(len * 2);
}
obj = json_object();
json_object_set_new(obj, "seq", json_integer(seq));
json_object_set_new(obj, "input_length", json_integer(inputlen));
json_object_set_new(obj, "output_length", json_integer(len));
json_object_set_new(obj, "percentage_of_original_size",
json_real((double)len / inputlen * 100));
to_hex(hex, buf, len);
if(len == 0) {
json_object_set_new(obj, "wire", json_string(""));
} else {
json_object_set_new(obj, "wire", json_pack("s#", hex, len * 2));
}
json_object_set_new(obj, "headers", dump_headers(nva, nvlen));
if(seq == 0) {
/* We only change the header table size only once at the beginning */
json_object_set_new(obj, "header_table_size",
json_integer(config.table_size));
}
if(config.dump_header_table) {
json_object_set_new(obj, "header_table",
dump_header_table(&deflater->ctx));
}
json_dumpf(obj, stdout, JSON_PRESERVE_ORDER | JSON_INDENT(2));
printf("\n");
json_decref(obj);
free(hex);
}
//database functions
void dbsave()
{
dprintf("saving database...");
DWORD ticks = GetTickCount();
JSON root = json_object();
CommentCacheSave(root);
LabelCacheSave(root);
BookmarkCacheSave(root);
FunctionCacheSave(root);
LoopCacheSave(root);
BpCacheSave(root);
WString wdbpath = StringUtils::Utf8ToUtf16(dbpath);
if(json_object_size(root))
{
FILE* jsonFile = 0;
if(_wfopen_s(&jsonFile, wdbpath.c_str(), L"wb"))
{
dputs("failed to open database file for editing!");
json_decref(root); //free root
return;
}
if(json_dumpf(root, jsonFile, JSON_INDENT(4)) == -1)
{
dputs("couldn't write JSON to database file...");
json_decref(root); //free root
return;
}
fclose(jsonFile);
if(!settingboolget("Engine", "DisableCompression"))
LZ4_compress_fileW(wdbpath.c_str(), wdbpath.c_str());
}
else //remove database when nothing is in there
DeleteFileW(wdbpath.c_str());
dprintf("%ums\n", GetTickCount() - ticks);
json_decref(root); //free root
}
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;
}
void MapFormat::saveToFile(String filename)
{
FILE* file = fopen(filename.c_str(), "w");
if (file)
{
json_t* rootObject = json_object();
json_t* nameJson = json_string(name);
json_t* descriptionJson = json_string(description);
json_t* firstRespawnJson = json_integer(firstRespawnOffset);
// json_t* sizeXjson = json_integer(Math::ICeil(size.x));
// json_t* sizeXjson = json_integer(Math::ICeil(size.y));
// json_t* sizeXjson = json_integer(Math::ICeil(size.z));
int blockSize = blocks.size();
json_t* blocksJson = json_array();
json_object_set(rootObject, "name", nameJson);
json_object_set(rootObject, "description", descriptionJson);
json_object_set(rootObject, "first-respawn", firstRespawnJson);
//
// fwrite(name, sizeof(char), sizeof(name), file);
// fwrite(description, sizeof(char), sizeof(description), file);
//// fwrite(&respawnTime, sizeof(respawnTime), 1, file);
// fwrite(&firstRespawnOffset, sizeof(firstRespawnOffset), 1, file);
// fwrite(&size, sizeof(size), 1, file);
// int a;
// fwrite(&a, sizeof(a), 1, file);
//
// int blockSize = blocks.size();
// fwrite(&(blockSize), sizeof(blockSize), 1, file);
for (int i = 0; i < blocks.size(); i++)
{
Block* block = blocks[i];
json_t* indBlock = json_object();
json_object_set(indBlock, "extra-args", json_integer(block->extraArgsBit));
json_object_set(indBlock, "origin-x", json_integer(Math::ICeil(block->origin.x)));
json_object_set(indBlock, "origin-y", json_integer(Math::ICeil(block->origin.y)));
json_object_set(indBlock, "origin-z", json_integer(Math::ICeil(block->origin.z)));
json_object_set(indBlock, "material-index", json_integer(block->materialIndex));
if (block->isPoint)
{
json_object_set(indBlock, "is-point", json_boolean(block->isPoint));
}
else if (block->isRespawn)
{
json_object_set(indBlock, "is-respawn", json_boolean(block->isRespawn));
}
if (Math::IFloor(block->rotation.valueDegrees()) != 0)
{
json_object_set(indBlock, "rotation", json_integer(Math::IFloor(block->rotation.valueDegrees())));
}
if ((block->linearSpeed && Math::IFloor(block->linearLocation.length()) > 0)|| block->rotationSpeed)
{
json_t* movableArgs = json_object();
if (block->linearSpeed > 0 && Math::IFloor(block->linearLocation.length()) > 0)
{
json_object_set(movableArgs, "linear-speed", json_integer(block->linearSpeed));
json_object_set(movableArgs, "linear-location-x", json_integer(Math::ICeil(block->linearLocation.x)));
json_object_set(movableArgs, "linear-location-y", json_integer(Math::ICeil(block->linearLocation.y)));
json_object_set(movableArgs, "linear-location-z", json_integer(Math::ICeil(block->linearLocation.z)));
if (block->isRotationMovement)
{
json_object_set(movableArgs, "rotation-movement", json_integer(1));
json_object_set(movableArgs, "is-rotation-right", json_integer(block->isRightRotationMovement ? 1 : 0));
}
}
if (block->rotationSpeed)
{
json_object_set(movableArgs, "rotation-speed", json_integer(Math::ICeil(block->rotationSpeed)));
}
json_object_set(indBlock, "movable-args", movableArgs);
}
if (block->specialBlockId != -1)
{
json_object_set(indBlock, "special-block", json_integer(block->specialBlockId));
}
json_array_append(blocksJson, indBlock);
}
json_object_set(rootObject, "blocks", blocksJson);
json_dumpf(rootObject, file, JSON_INDENT(4));
json_delete(rootObject);
fclose(file);
}
}
int main(void)
{
json_t *jwk;
struct MemoryStruct res;
struct timeval tval_before, tval_after, tval_result;
lca_init();
int fd = start();
if (lca_load_signing_key ("test_keys/atmel.key", &signing_key))
return -1;
jwk = gcry_pubkey2jwk (&signing_key);
assert (NULL != jwk);
json_dumpf (jwk, stdout, 0);
char *m1 = build_key_post (jwk);
printf ("Post key: %s\n", m1);
char *b = combine (postkey, m1);
char *c = combine (getkey, m1);
/* char *b = malloc (strlen(m1) + strlen(postkey) + 1); */
/* memset (b, 0, strlen(m1) + strlen(postkey) + 1); */
/* printf ("here"); */
/* strcpy (b, postkey); */
/* strcat (postkey, m1); */
curl_global_init(CURL_GLOBAL_ALL);
res = get (b);
free (res.memory);
res = get (c);
json_t *dm_key = get_dm_key (res.memory);
free (res.memory);
char *hello = build_hello (sub);
gettimeofday(&tval_before, NULL);
char *d = combine (posthello, hello);
res = get (d);
json_t *hello_rsp = verify_hello (res.memory, dm_key);
free (res.memory);
char *done = build_hello_rsp (sub, hello_rsp);
char *e = combine (postdone, done);
res = get (e);
json_t *done_rsp = verify_done (res.memory, dm_key);
free (res.memory);
gettimeofday(&tval_after, NULL);
free (e);
free (d);
free (b);
free (c);
/* we're done with libcurl, so clean it up */
curl_global_cleanup();
timersub(&tval_after, &tval_before, &tval_result);
printf("Time elapsed: %ld.%06ld\n", (long int)tval_result.tv_sec, (long int)tval_result.tv_usec);
return 0;
}
