lib/jsoninfo/src/olsrd_jsoninfo_helpers.c

   1 /*
   2  * The olsr.org Optimized Link-State Routing daemon(olsrd)
   3  * Copyright (c) 2004
   4  *
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * * Redistributions of source code must retain the above copyright
  12  *   notice, this list of conditions and the following disclaimer.
  13  * * Redistributions in binary form must reproduce the above copyright
  14  *   notice, this list of conditions and the following disclaimer in
  15  *   the documentation and/or other materials provided with the
  16  *   distribution.
  17  * * Neither the name of olsr.org, olsrd nor the names of its
  18  *   contributors may be used to endorse or promote products derived
  19  *   from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  25  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  29  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32  * POSSIBILITY OF SUCH DAMAGE.
  33  *
  34  * Visit http://www.olsr.org for more information.
  35  *
  36  * If you find this software useful feel free to make a donation
  37  * to the project. For more information see the website or contact
  38  * the copyright holders.
  39  *
  40  */
  41
  42 #include "olsrd_jsoninfo_helpers.h"
  43 #include "olsr.h"
  44 #include "ipcalc.h"
  45
  46 #include <stdbool.h>
  47 #include <assert.h>
  48 #include <unistd.h>
  49 #include <math.h>
  50 #include <float.h>
  51
  52 #ifdef __linux__
  53 #include <fcntl.h>
  54 #endif /* __linux__ */
  55
  56 static const char * empty = "";
  57
  58 char uuid[UUIDLEN];
  59
  60 /* JSON support functions */
  61
  62 /* JSON does not allow commas dangling at the end of arrays, so we need to
  63  * count which entry number we're at in order to make sure we don't tack a
  64  * dangling comma on at the end */
  65 #define ENTRY_NUMBER_MAX_DEPTH 16
  66 static int entrynumber[ENTRY_NUMBER_MAX_DEPTH] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  67 static int currentjsondepth = 0;
  68
  69 void abuf_json_reset_entry_number_and_depth(void) {
  70   entrynumber[0] = 0;
  71   currentjsondepth = 0;
  72 }
  73
  74 static void abuf_json_new_indent(struct autobuf *abuf) {
  75   assert(abuf);
  76
  77   if (currentjsondepth) {
  78     int i = currentjsondepth;
  79
  80     abuf_puts(abuf, "\n");
  81     while (i-- > 0) {
  82       abuf_puts(abuf, "  ");
  83     }
  84   }
  85 }
  86
  87 void abuf_json_insert_comma(struct autobuf *abuf) {
  88   assert(abuf);
  89
  90   if (entrynumber[currentjsondepth])
  91     abuf_appendf(abuf, ",");
  92 }
  93
  94 void abuf_json_mark_output(bool open, struct autobuf *abuf) {
  95   assert(abuf);
  96
  97   if (open) {
  98     assert(!currentjsondepth);
  99     abuf_json_new_indent(abuf);
 100     abuf_puts(abuf, "{");
 101     currentjsondepth++;
 102     entrynumber[currentjsondepth] = 0;
 103   } else {
 104     assert(currentjsondepth == 1);
 105     entrynumber[currentjsondepth] = 0;
 106     currentjsondepth--;
 107     abuf_json_new_indent(abuf);
 108     abuf_puts(abuf, "\n}");
 109   }
 110 }
 111
 112 void abuf_json_mark_object(bool open, bool array, struct autobuf *abuf, const char* header) {
 113   assert(abuf);
 114
 115   if (open) {
 116     abuf_json_insert_comma(abuf);
 117     abuf_json_new_indent(abuf);
 118     if (header) {
 119       abuf_appendf(abuf, "\"%s\": %s", header, array ? "[" : "{");
 120     } else {
 121       abuf_appendf(abuf, "%s", array ? "[" : "{");
 122     }
 123     entrynumber[currentjsondepth]++;
 124     currentjsondepth++;
 125     assert(currentjsondepth < ENTRY_NUMBER_MAX_DEPTH);
 126     entrynumber[currentjsondepth] = 0;
 127   } else {
 128     entrynumber[currentjsondepth] = 0;
 129     currentjsondepth--;
 130     assert(currentjsondepth >= 0);
 131     abuf_json_new_indent(abuf);
 132     abuf_appendf(abuf, "%s", array ? "]" : "}");
 133   }
 134 }
 135
 136 void abuf_json_mark_array_entry(bool open, struct autobuf *abuf) {
 137   assert(abuf);
 138
 139   abuf_json_mark_object(open, false, abuf, NULL);
 140 }
 141
 142 void abuf_json_boolean(struct autobuf *abuf, const char* key, bool value) {
 143   assert(abuf);
 144   assert(key);
 145
 146   abuf_json_insert_comma(abuf);
 147   abuf_json_new_indent(abuf);
 148   abuf_appendf(abuf, "\"%s\": %s", key, value ? "true" : "false");
 149   entrynumber[currentjsondepth]++;
 150 }
 151
 152 void abuf_json_string(struct autobuf *abuf, const char* key, const char* value) {
 153   const char * val;
 154
 155   assert(abuf);
 156   assert(key || value);
 157
 158   if (!value) {
 159     val = empty;
 160   } else {
 161     val = value;
 162   }
 163
 164   abuf_json_insert_comma(abuf);
 165   abuf_json_new_indent(abuf);
 166   if (!key) {
 167     abuf_appendf(abuf, "\"%s\"", value);
 168   } else {
 169     abuf_appendf(abuf, "\"%s\": \"%s\"", key, val);
 170   }
 171   entrynumber[currentjsondepth]++;
 172 }
 173
 174 void abuf_json_int(struct autobuf *abuf, const char* key, long long value) {
 175   const char * fmt;
 176
 177   assert(abuf);
 178   assert(key);
 179
 180 #ifndef _WIN32
 181   fmt = "\"%s\": %lld";
 182 #else
 183   fmt = "\"%s\": %ld";
 184 #endif
 185
 186   abuf_json_insert_comma(abuf);
 187   abuf_json_new_indent(abuf);
 188   abuf_appendf(abuf, fmt, key, value);
 189   entrynumber[currentjsondepth]++;
 190 }
 191
 192 void abuf_json_float(struct autobuf *abuf, const char* key, double value) {
 193   double v = value;
 194   int isInf = isinf(v);
 195
 196   assert(abuf);
 197   assert(key);
 198
 199   if (isnan(v)) {
 200     v = 0.0;
 201   } else if (isInf < 0) {
 202     v = -DBL_MAX;
 203   } else if (isInf > 0) {
 204     v = DBL_MAX;
 205   }
 206
 207   abuf_json_insert_comma(abuf);
 208   abuf_json_new_indent(abuf);
 209   abuf_appendf(abuf, "\"%s\": %f", key, v);
 210   entrynumber[currentjsondepth]++;
 211 }
 212
 213 void abuf_json_ip_address(struct autobuf *abuf, const char* key, union olsr_ip_addr *ip) {
 214   struct ipaddr_str ipStr;
 215   const char * value;
 216
 217   assert(abuf);
 218   assert(key || ip);
 219
 220   if (!ip) {
 221     value = empty;
 222   } else {
 223     value = olsr_ip_to_string(&ipStr, ip);
 224   }
 225
 226   abuf_json_insert_comma(abuf);
 227   abuf_json_new_indent(abuf);
 228   if (!key) {
 229     abuf_appendf(abuf, "\"%s\"", value);
 230   } else {
 231     abuf_appendf(abuf, "\"%s\": \"%s\"", key, value);
 232   }
 233   entrynumber[currentjsondepth]++;
 234 }
 235
 236 void abuf_json_ip_address46(struct autobuf *abuf, const char* key, void *ip, int af) {
 237   struct ipaddr_str ipStr;
 238   const char * value;
 239
 240   assert(abuf);
 241   assert(key || ip);
 242
 243   if (!ip) {
 244     value = empty;
 245   } else if (af == AF_INET) {
 246     value = ip4_to_string(&ipStr, *((const struct in_addr*) ip));
 247   } else {
 248     value = ip6_to_string(&ipStr, (const struct in6_addr * const ) ip);
 249   }
 250
 251   abuf_json_insert_comma(abuf);
 252   abuf_json_new_indent(abuf);
 253   if (!key) {
 254     abuf_appendf(abuf, "\"%s\"", value);
 255   } else {
 256     abuf_appendf(abuf, "\"%s\": \"%s\"", key, value);
 257   }
 258   entrynumber[currentjsondepth]++;
 259 }
 260
 261 int read_uuid_from_file(const char * name, const char *file) {
 262   FILE *f;
 263   char* end;
 264   int r = 0;
 265   size_t chars;
 266
 267   assert(name);
 268   assert(file);
 269
 270   memset(uuid, 0, sizeof(uuid));
 271
 272   f = fopen(file, "r");
 273   olsr_printf(1, "(%s) Reading UUID from '%s'\n", name, file);
 274   if (!f) {
 275     olsr_printf(1, "(%s) Could not open '%s': %s\n", name, file, strerror(errno));
 276     return -1;
 277   }
 278   chars = fread(uuid, 1, sizeof(uuid) - 1, f);
 279   if (chars > 0) {
 280     uuid[chars] = '\0'; /* null-terminate the string */
 281
 282     /* we only use the first line of the file */
 283     end = strchr(uuid, '\n');
 284     if (end)
 285       *end = 0;
 286     r = 0;
 287   } else {
 288     olsr_printf(1, "(%s) Could not read UUID from '%s': %s\n", name, file, strerror(errno));
 289     r = -1;
 290   }
 291
 292   fclose(f);
 293   return r;
 294 }