jsoninfo: helpers: add asserts
[olsrd.git] / 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
50 #ifdef __linux__
51 #include <fcntl.h>
52 #endif /* __linux__ */
53
54 static const char * empty = "";
55
56 char uuid[UUIDLEN];
57
58 /* JSON support functions */
59
60 /* JSON does not allow commas dangling at the end of arrays, so we need to
61  * count which entry number we're at in order to make sure we don't tack a
62  * dangling comma on at the end */
63 #define ENTRY_NUMBER_MAX_DEPTH 16
64 static int entrynumber[ENTRY_NUMBER_MAX_DEPTH] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
65 static int currentjsondepth = 0;
66
67 void abuf_json_reset_entry_number_and_depth(void) {
68   entrynumber[0] = 0;
69   currentjsondepth = 0;
70 }
71
72 static void abuf_json_new_indent(struct autobuf *abuf) {
73   assert(abuf);
74
75   if (currentjsondepth) {
76     int i = currentjsondepth;
77
78     abuf_puts(abuf, "\n");
79     while (i-- > 0) {
80       abuf_puts(abuf, "  ");
81     }
82   }
83 }
84
85 void abuf_json_insert_comma(struct autobuf *abuf) {
86   assert(abuf);
87
88   if (entrynumber[currentjsondepth])
89     abuf_appendf(abuf, ",");
90 }
91
92 void abuf_json_mark_output(bool open, struct autobuf *abuf) {
93   assert(abuf);
94
95   if (open) {
96     assert(!currentjsondepth);
97     abuf_json_new_indent(abuf);
98     abuf_puts(abuf, "{");
99     currentjsondepth++;
100     entrynumber[currentjsondepth] = 0;
101   } else {
102     assert(currentjsondepth == 1);
103     entrynumber[currentjsondepth] = 0;
104     currentjsondepth--;
105     abuf_json_new_indent(abuf);
106     abuf_puts(abuf, "\n}");
107   }
108 }
109
110 void abuf_json_mark_object(bool open, bool array, struct autobuf *abuf, const char* header) {
111   assert(abuf);
112
113   if (open) {
114     abuf_json_insert_comma(abuf);
115     abuf_json_new_indent(abuf);
116     if (header) {
117       abuf_appendf(abuf, "\"%s\": %s", header, array ? "[" : "{");
118     } else {
119       abuf_appendf(abuf, "%s", array ? "[" : "{");
120     }
121     entrynumber[currentjsondepth]++;
122     currentjsondepth++;
123     assert(currentjsondepth < ENTRY_NUMBER_MAX_DEPTH);
124     entrynumber[currentjsondepth] = 0;
125   } else {
126     entrynumber[currentjsondepth] = 0;
127     currentjsondepth--;
128     assert(currentjsondepth >= 0);
129     abuf_json_new_indent(abuf);
130     abuf_appendf(abuf, "%s", array ? "]" : "}");
131   }
132 }
133
134 void abuf_json_mark_array_entry(bool open, struct autobuf *abuf) {
135   assert(abuf);
136
137   abuf_json_mark_object(open, false, abuf, NULL);
138 }
139
140 void abuf_json_boolean(struct autobuf *abuf, const char* key, bool value) {
141   assert(abuf);
142   assert(key);
143
144   abuf_json_insert_comma(abuf);
145   abuf_json_new_indent(abuf);
146   abuf_appendf(abuf, "\"%s\": %s", key, value ? "true" : "false");
147   entrynumber[currentjsondepth]++;
148 }
149
150 void abuf_json_string(struct autobuf *abuf, const char* key, const char* value) {
151   assert(abuf);
152   assert(key);
153
154   abuf_json_insert_comma(abuf);
155   abuf_json_new_indent(abuf);
156   abuf_appendf(abuf, "\"%s\": \"%s\"", key, value);
157   entrynumber[currentjsondepth]++;
158 }
159
160 void abuf_json_int(struct autobuf *abuf, const char* key, long long value) {
161   const char * fmt;
162
163   assert(abuf);
164   assert(key);
165
166 #ifndef _WIN32
167   fmt = "\"%s\": %lld";
168 #else
169   fmt = "\"%s\": %ld";
170 #endif
171
172   abuf_json_insert_comma(abuf);
173   abuf_json_new_indent(abuf);
174   abuf_appendf(abuf, fmt, key, value);
175   entrynumber[currentjsondepth]++;
176 }
177
178 void abuf_json_float(struct autobuf *abuf, const char* key, double value) {
179   assert(abuf);
180   assert(key);
181
182   abuf_json_insert_comma(abuf);
183   abuf_json_new_indent(abuf);
184   abuf_appendf(abuf, "\"%s\": %f", key, value);
185   entrynumber[currentjsondepth]++;
186 }
187
188 void abuf_json_ip_address(struct autobuf *abuf, const char* key, union olsr_ip_addr *ip) {
189   struct ipaddr_str ipStr;
190   const char * value;
191
192   assert(abuf);
193   assert(key);
194
195   if (!ip) {
196     value = empty;
197   } else {
198     value = olsr_ip_to_string(&ipStr, ip);
199   }
200
201   abuf_json_insert_comma(abuf);
202   abuf_json_new_indent(abuf);
203   abuf_appendf(abuf, "\"%s\": \"%s\"", key, value);
204   entrynumber[currentjsondepth]++;
205 }
206
207 /* Linux specific functions for getting system info */
208
209 #ifdef __linux__
210 static int get_string_from_file(const char* filename, char* buf, int len) {
211   int bytes = -1;
212   int fd;
213
214   assert(filename);
215   assert(buf);
216
217   fd = open(filename, O_RDONLY);
218
219   buf[0] = '\0';
220   if (fd > -1) {
221     bytes = read(fd, buf, len);
222     if (bytes < len)
223       buf[bytes - 1] = '\0'; // remove trailing \n
224     else
225       buf[len - 1] = '\0';
226     close(fd);
227   }
228   return bytes;
229 }
230
231 static int abuf_json_sysdata(struct autobuf *abuf, const char* key, const char* syspath) {
232   char buf[256];
233   int ret;
234
235   assert(abuf);
236   assert(key);
237   assert(syspath);
238
239   ret = get_string_from_file(syspath, buf, sizeof(buf));
240   if (*buf)
241     abuf_json_string(abuf, key, buf);
242   return ret;
243 }
244
245 void abuf_json_sys_class_net(struct autobuf *abuf, const char* key, const char* ifname, const char* datapoint) {
246   char filename[256];
247
248   assert(abuf);
249   assert(key);
250   assert(ifname);
251   assert(datapoint);
252
253   snprintf(filename, sizeof(filename) - 1, "/sys/class/net/%s/%s", ifname, datapoint);
254   filename[sizeof(filename) - 1] = '\0';
255   abuf_json_sysdata(abuf, key, filename);
256 }
257 #endif /* __linux__ */
258
259 int read_uuid_from_file(const char * name, const char *file) {
260   FILE *f;
261   char* end;
262   int r = 0;
263   size_t chars;
264
265   assert(name);
266   assert(file);
267
268   memset(uuid, 0, sizeof(uuid));
269
270   f = fopen(file, "r");
271   olsr_printf(1, "(%s) Reading UUID from '%s'\n", name, file);
272   if (!f) {
273     olsr_printf(1, "(%s) Could not open '%s': %s\n", name, file, strerror(errno));
274     return -1;
275   }
276   chars = fread(uuid, 1, sizeof(uuid) - 1, f);
277   if (chars > 0) {
278     uuid[chars] = '\0'; /* null-terminate the string */
279
280     /* we only use the first line of the file */
281     end = strchr(uuid, '\n');
282     if (end)
283       *end = 0;
284     r = 0;
285   } else {
286     olsr_printf(1, "(%s) Could not read UUID from '%s': %s\n", name, file, strerror(errno));
287     r = -1;
288   }
289
290   fclose(f);
291   return r;
292 }