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