40437f70648d25e680b05fafc7053a6488e26cfc
[olsrd.git] / lib / jsoninfo / src / olsrd_jsoninfo.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.h"
43
44 #include <unistd.h>
45 #include <ctype.h>
46 #include <libgen.h>
47
48 #include "ipcalc.h"
49 #include "builddata.h"
50 #include "neighbor_table.h"
51 #include "mpr_selector_set.h"
52 #include "mid_set.h"
53 #include "routing_table.h"
54 #include "lq_plugin.h"
55 #include "gateway.h"
56 #include "olsrd_plugin.h"
57 #include "../../info/info_types.h"
58 #include "../../info/http_headers.h"
59 #include "gateway_default_handler.h"
60 #include "egressTypes.h"
61 #include "olsrd_jsoninfo_helpers.h"
62
63 struct timeval start_time;
64
65 void plugin_init(const char *plugin_name) {
66   /* Get start time */
67   gettimeofday(&start_time, NULL);
68
69   if (!strlen(uuidfile)) {
70     strscpy(uuidfile, "uuid.txt", sizeof(uuidfile));
71   }
72   read_uuid_from_file(plugin_name, uuidfile);
73 }
74
75 bool isCommand(const char *str, unsigned int siw) {
76   const char * cmd;
77   switch (siw) {
78     case SIW_OLSRD_CONF:
79       cmd = "/olsrd.conf";
80       break;
81
82     case SIW_ALL:
83       cmd = "/all";
84       break;
85
86     case SIW_RUNTIME_ALL:
87       cmd = "/runtime";
88       break;
89
90     case SIW_STARTUP_ALL:
91       cmd = "/startup";
92       break;
93
94     case SIW_NEIGHBORS:
95       cmd = "/neighbors";
96       break;
97
98     case SIW_LINKS:
99       cmd = "/links";
100       break;
101
102     case SIW_ROUTES:
103       cmd = "/routes";
104       break;
105
106     case SIW_HNA:
107       cmd = "/hna";
108       break;
109
110     case SIW_MID:
111       cmd = "/mid";
112       break;
113
114     case SIW_TOPOLOGY:
115       cmd = "/topology";
116       break;
117
118     case SIW_GATEWAYS:
119       cmd = "/gateways";
120       break;
121
122     case SIW_INTERFACES:
123       cmd = "/interfaces";
124       break;
125
126     case SIW_2HOP:
127       cmd = "/2hop";
128       break;
129
130     case SIW_SGW:
131       cmd = "/sgw";
132       break;
133
134     case SIW_VERSION:
135       cmd = "/version";
136       break;
137
138     case SIW_CONFIG:
139       cmd = "/config";
140       break;
141
142     case SIW_PLUGINS:
143       cmd = "/plugins";
144       break;
145
146     case SIW_NEIGHBORS_FREIFUNK:
147       cmd = "/neighbours";
148       break;
149
150     default:
151       return false;
152   }
153
154   return !strcmp(str, cmd);
155 }
156
157 const char * determine_mime_type(unsigned int send_what) {
158   return (send_what & SIW_OLSRD_CONF) ? "text/plain; charset=utf-8" : "application/json; charset=utf-8";
159 }
160
161 void output_start(struct autobuf *abuf) {
162   /* global variables for tracking when to put a comma in for JSON */
163   abuf_json_reset_entry_number_and_depth();
164   abuf_json_mark_output(true, abuf);
165
166   abuf_json_int(abuf, "systemTime", time(NULL));
167   abuf_json_int(abuf, "timeSinceStartup", now_times);
168   if (*uuid) {
169     abuf_json_string(abuf, "uuid", uuid);
170   }
171 }
172
173 void output_end(struct autobuf *abuf) {
174   abuf_json_mark_output(false, abuf);
175   abuf_puts(abuf, "\n");
176 }
177
178 void output_error(struct autobuf *abuf, unsigned int status, const char * req, bool http_headers) {
179   struct autobuf abufInternal;
180
181   if (http_headers || (status == INFO_HTTP_OK)) {
182     return;
183   }
184
185   abuf_init(&abufInternal, 1024);
186
187   output_start(abuf);
188
189   switch (status) {
190     case INFO_HTTP_NOTFOUND:
191       abuf_appendf(&abufInternal, "Invalid request '%s'", req);
192       abuf_json_string(abuf, "error", abufInternal.buf);
193       break;
194
195     case INFO_HTTP_NOCONTENT:
196       abuf_json_string(abuf, "error", "no content");
197       break;
198
199     default:
200       abuf_appendf(&abufInternal, "Unknown status %d for request '%s'", status, req);
201       abuf_json_string(abuf, "error", abufInternal.buf);
202       break;
203   }
204
205   output_end(abuf);
206 }
207
208 static void ipc_print_neighbors_internal(struct autobuf *abuf, bool list_2hop) {
209   struct ipaddr_str neighAddrBuf;
210   struct neighbor_entry *neigh;
211
212   if (!list_2hop) {
213     abuf_json_mark_object(true, true, abuf, "neighbors");
214   } else {
215     abuf_json_mark_object(true, true, abuf, "2hop");
216   }
217
218   /* Neighbors */
219   OLSR_FOR_ALL_NBR_ENTRIES(neigh) {
220     struct neighbor_2_list_entry *list_2;
221     int thop_cnt = 0;
222
223     abuf_json_mark_array_entry(true, abuf);
224
225     abuf_json_string(abuf, "ipAddress", olsr_ip_to_string(&neighAddrBuf, &neigh->neighbor_main_addr));
226     abuf_json_boolean(abuf, "symmetric", (neigh->status == SYM));
227     abuf_json_int(abuf, "willingness", neigh->willingness);
228     abuf_json_boolean(abuf, "isMultiPointRelay", neigh->is_mpr);
229     abuf_json_boolean(abuf, "wasMultiPointRelay", neigh->was_mpr);
230     abuf_json_boolean(abuf, "multiPointRelaySelector", olsr_lookup_mprs_set(&neigh->neighbor_main_addr) != NULL);
231     abuf_json_boolean(abuf, "skip", neigh->skip);
232     abuf_json_int(abuf, "neighbor2nocov", neigh->neighbor_2_nocov);
233     abuf_json_int(abuf, "linkcount", neigh->linkcount);
234
235     if (list_2hop) {
236       abuf_json_mark_object(true, true, abuf, "twoHopNeighbors");
237     }
238
239     thop_cnt = 0;
240     for (list_2 = neigh->neighbor_2_list.next; list_2 != &neigh->neighbor_2_list; list_2 = list_2->next) {
241       if (list_2hop && list_2->neighbor_2) {
242         abuf_json_mark_array_entry(true, abuf);
243         abuf_json_string(abuf, "ipAddress", list_2->neighbor_2 ? olsr_ip_to_string(&neighAddrBuf, &list_2->neighbor_2->neighbor_2_addr) : "");
244         abuf_json_mark_array_entry(false, abuf);
245       }
246       thop_cnt++;
247     }
248
249     if (list_2hop) {
250       abuf_json_mark_object(false, true, abuf, NULL);
251     }
252     abuf_json_int(abuf, "twoHopNeighborCount", thop_cnt);
253
254     abuf_json_mark_array_entry(false, abuf);
255   } OLSR_FOR_ALL_NBR_ENTRIES_END(neigh);
256   abuf_json_mark_object(false, true, abuf, NULL);
257 }
258
259 void ipc_print_neighbors(struct autobuf *abuf) {
260   ipc_print_neighbors_internal(abuf, false);
261 }
262
263 void ipc_print_links(struct autobuf *abuf) {
264   struct link_entry *my_link;
265
266   abuf_json_mark_object(true, true, abuf, "links");
267
268   OLSR_FOR_ALL_LINK_ENTRIES(my_link) {
269     struct ipaddr_str localAddr;
270     struct ipaddr_str remoteAddr;
271     struct lqtextbuffer lqBuffer;
272     const char* lqString = get_link_entry_text(my_link, '\t', &lqBuffer);
273     char * nlqString = strrchr(lqString, '\t');
274
275     if (nlqString) {
276       *nlqString = '\0';
277       nlqString++;
278     }
279
280     abuf_json_mark_array_entry(true, abuf);
281
282     abuf_json_string(abuf, "localIP", olsr_ip_to_string(&localAddr, &my_link->local_iface_addr));
283     abuf_json_string(abuf, "remoteIP", olsr_ip_to_string(&remoteAddr, &my_link->neighbor_iface_addr));
284     abuf_json_string(abuf, "olsrInterface", (my_link->inter && my_link->inter->int_name) ? my_link->inter->int_name : "");
285     abuf_json_string(abuf, "ifName", my_link->if_name ? my_link->if_name : "");
286     abuf_json_int(abuf, "validityTime", my_link->link_timer ? (long) (my_link->link_timer->timer_clock - now_times) : 0);
287     abuf_json_int(abuf, "symmetryTime", my_link->link_sym_timer ? (long) (my_link->link_sym_timer->timer_clock - now_times) : 0);
288     abuf_json_int(abuf, "asymmetryTime", my_link->ASYM_time);
289     abuf_json_int(abuf, "vtime", (long) my_link->vtime);
290     // neighbor (no need to print, can be looked up via neighbours)
291     abuf_json_string(abuf, "currentLinkStatus", linkTypeToString(lookup_link_status(my_link)));
292     abuf_json_string(abuf, "previousLinkStatus", linkTypeToString(my_link->prev_status));
293
294     abuf_json_float(abuf, "hysteresis", my_link->L_link_quality);
295     abuf_json_boolean(abuf, "pending", my_link->L_link_pending != 0);
296     abuf_json_int(abuf, "lostLinkTime", (long) my_link->L_LOST_LINK_time);
297     abuf_json_int(abuf, "helloTime", my_link->link_hello_timer ? (long) (my_link->link_hello_timer->timer_clock - now_times) : 0);
298     abuf_json_int(abuf, "lastHelloTime", (long) my_link->last_htime);
299     abuf_json_boolean(abuf, "seqnoValid", my_link->olsr_seqno_valid);
300     abuf_json_int(abuf, "seqno", my_link->olsr_seqno);
301
302     abuf_json_int(abuf, "lossHelloInterval", (long) my_link->loss_helloint);
303     abuf_json_int(abuf, "lossTime", my_link->link_loss_timer ? (long) (my_link->link_loss_timer->timer_clock - now_times) : 0);
304
305     abuf_json_int(abuf, "lossMultiplier", (long) my_link->loss_link_multiplier);
306
307     abuf_json_int(abuf, "linkCost", MIN(my_link->linkcost, LINK_COST_BROKEN));
308
309     abuf_json_float(abuf, "linkQuality", atof(lqString));
310     abuf_json_float(abuf, "neighborLinkQuality", nlqString ? atof(nlqString) : 0.0);
311
312     abuf_json_mark_array_entry(false, abuf);
313   } OLSR_FOR_ALL_LINK_ENTRIES_END(my_link);
314   abuf_json_mark_object(false, true, abuf, NULL);
315 }
316
317 void ipc_print_routes(struct autobuf *abuf) {
318   struct rt_entry *rt;
319
320   abuf_json_mark_object(true, true, abuf, "routes");
321
322   /* Walk the route table */
323   OLSR_FOR_ALL_RT_ENTRIES(rt) {
324     struct ipaddr_str dstAddr;
325     struct ipaddr_str nexthopAddr;
326     struct lqtextbuffer costbuffer;
327
328     if (rt->rt_best) {
329       abuf_json_mark_array_entry(true, abuf);
330       abuf_json_string(abuf, "destination", olsr_ip_to_string(&dstAddr, &rt->rt_dst.prefix));
331       abuf_json_int(abuf, "genmask", rt->rt_dst.prefix_len);
332       abuf_json_string(abuf, "gateway", olsr_ip_to_string(&nexthopAddr, &rt->rt_best->rtp_nexthop.gateway));
333       abuf_json_int(abuf, "metric", rt->rt_best->rtp_metric.hops);
334       abuf_json_float(abuf, "etx", atof(get_linkcost_text(rt->rt_best->rtp_metric.cost, true, &costbuffer)));
335       abuf_json_int(abuf, "rtpMetricCost", MIN(ROUTE_COST_BROKEN, rt->rt_best->rtp_metric.cost));
336       abuf_json_string(abuf, "networkInterface", if_ifwithindex_name(rt->rt_best->rtp_nexthop.iif_index));
337       abuf_json_mark_array_entry(false, abuf);
338     }
339   } OLSR_FOR_ALL_RT_ENTRIES_END(rt);
340
341   abuf_json_mark_object(false, true, abuf, NULL);
342 }
343
344 void ipc_print_topology(struct autobuf *abuf) {
345   struct tc_entry *tc;
346
347   abuf_json_mark_object(true, true, abuf, "topology");
348
349   /* Topology */
350   OLSR_FOR_ALL_TC_ENTRIES(tc) {
351     struct tc_edge_entry *tc_edge;
352     OLSR_FOR_ALL_TC_EDGE_ENTRIES(tc, tc_edge) {
353       if (tc_edge->edge_inv) {
354         struct ipaddr_str dstAddr;
355         struct ipaddr_str lastHopAddr;
356         struct lqtextbuffer lqbuffer;
357
358         const char* lqString = get_tc_edge_entry_text(tc_edge, '\t', &lqbuffer);
359         char * nlqString = strrchr(lqString, '\t');
360
361         if (nlqString) {
362           *nlqString = '\0';
363           nlqString++;
364         }
365
366         abuf_json_mark_array_entry(true, abuf);
367
368         // vertex_node
369         abuf_json_string(abuf, "lastHopIP", olsr_ip_to_string(&lastHopAddr, &tc->addr));
370         // cand_tree_node
371         abuf_json_int(abuf, "pathCost", MIN(tc->path_cost, ROUTE_COST_BROKEN));
372         // path_list_node
373         // edge_tree
374         // prefix_tree
375         // next_hop
376         // edge_gc_timer
377         abuf_json_int(abuf, "validityTime", tc->validity_timer ? (tc->validity_timer->timer_clock - now_times) : 0);
378         abuf_json_int(abuf, "refCount", tc->refcount);
379         abuf_json_int(abuf, "msgSeq", tc->msg_seq);
380         abuf_json_int(abuf, "msgHops", tc->msg_hops);
381         abuf_json_int(abuf, "hops", tc->hops);
382         abuf_json_int(abuf, "ansn", tc->ansn);
383         abuf_json_int(abuf, "tcIgnored", tc->ignored);
384
385         abuf_json_int(abuf, "errSeq", tc->err_seq);
386         abuf_json_boolean(abuf, "errSeqValid", tc->err_seq_valid);
387
388         // edge_node
389         abuf_json_string(abuf, "destinationIP", olsr_ip_to_string(&dstAddr, &tc_edge->T_dest_addr));
390         // tc
391         abuf_json_int(abuf, "tcEdgeCost", MIN(LINK_COST_BROKEN, tc_edge->cost));
392         abuf_json_int(abuf, "ansnEdge", tc_edge->ansn);
393         abuf_json_float(abuf, "linkQuality", atof(lqString));
394         abuf_json_float(abuf, "neighborLinkQuality", nlqString ? atof(nlqString) : 0.0);
395
396         abuf_json_mark_array_entry(false, abuf);
397       }
398     } OLSR_FOR_ALL_TC_EDGE_ENTRIES_END(tc, tc_edge);
399   } OLSR_FOR_ALL_TC_ENTRIES_END(tc);
400
401   abuf_json_mark_object(false, true, abuf, NULL);
402 }
403
404 void ipc_print_hna(struct autobuf *abuf) {
405   struct ip_prefix_list *hna;
406   struct hna_entry *tmp_hna;
407   struct ipaddr_str prefixbuf;
408   struct ipaddr_str gwaddrbuf;
409
410   olsr_ip_to_string(&gwaddrbuf, &olsr_cnf->main_addr);
411
412   abuf_json_mark_object(true, true, abuf, "hna");
413
414   /* Announced HNA entries */
415   for (hna = olsr_cnf->hna_entries; hna != NULL ; hna = hna->next) {
416     abuf_json_mark_array_entry(true, abuf);
417     abuf_json_string(abuf, "gateway", gwaddrbuf.buf);
418     abuf_json_string(abuf, "destination", olsr_ip_to_string(&prefixbuf, &hna->net.prefix));
419     abuf_json_int(abuf, "genmask", hna->net.prefix_len);
420     abuf_json_int(abuf, "validityTime", 0);
421     abuf_json_mark_array_entry(false, abuf);
422   }
423
424   OLSR_FOR_ALL_HNA_ENTRIES(tmp_hna) {
425     struct hna_net *tmp_net;
426
427     olsr_ip_to_string(&gwaddrbuf, &tmp_hna->A_gateway_addr);
428
429     /* Check all networks */
430     for (tmp_net = tmp_hna->networks.next; tmp_net != &tmp_hna->networks; tmp_net = tmp_net->next) {
431       abuf_json_mark_array_entry(true, abuf);
432       abuf_json_string(abuf, "gateway", gwaddrbuf.buf);
433       abuf_json_string(abuf, "destination", olsr_ip_to_string(&prefixbuf, &tmp_net->hna_prefix.prefix));
434       abuf_json_int(abuf, "genmask", tmp_net->hna_prefix.prefix_len);
435       abuf_json_int(abuf, "validityTime", tmp_net->hna_net_timer ? (tmp_net->hna_net_timer->timer_clock - now_times) : 0);
436       abuf_json_mark_array_entry(false, abuf);
437     }
438   } OLSR_FOR_ALL_HNA_ENTRIES_END(tmp_hna);
439
440   abuf_json_mark_object(false, true, abuf, NULL);
441 }
442
443 void ipc_print_mid(struct autobuf *abuf) {
444   int idx;
445
446   abuf_json_mark_object(true, true, abuf, "mid");
447
448   /* MID */
449   for (idx = 0; idx < HASHSIZE; idx++) {
450     struct mid_entry * entry = mid_set[idx].next;
451
452     while (entry != &mid_set[idx]) {
453       struct ipaddr_str midAddr;
454
455       abuf_json_mark_array_entry(true, abuf);
456       abuf_json_string(abuf, "ipAddress", olsr_ip_to_string(&midAddr, &entry->main_addr));
457       abuf_json_int(abuf, "validityTime", entry->mid_timer ? (entry->mid_timer->timer_clock - now_times) : 0);
458       {
459         struct mid_address * alias = entry->aliases;
460
461         abuf_json_mark_object(true, true, abuf, "aliases");
462         while (alias) {
463           struct ipaddr_str aliasAddr;
464
465           abuf_json_mark_array_entry(true, abuf);
466           abuf_json_string(abuf, "ipAddress", olsr_ip_to_string(&aliasAddr, &alias->alias));
467           abuf_json_int(abuf, "validityTime", alias->vtime - now_times);
468           abuf_json_mark_array_entry(false, abuf);
469
470           alias = alias->next_alias;
471         }
472         abuf_json_mark_object(false, true, abuf, NULL); // aliases
473       }
474       abuf_json_mark_array_entry(false, abuf); // entry
475
476       entry = entry->next;
477     }
478   }
479   abuf_json_mark_object(false, true, abuf, NULL); // mid
480 }
481
482 #ifdef __linux__
483
484 static void ipc_print_gateway_entry(struct autobuf *abuf, bool ipv6, struct gateway_entry * current_gw, struct gateway_entry * gw) {
485   struct tc_entry* tc = olsr_lookup_tc_entry(&gw->originator);
486
487   abuf_json_boolean(abuf, "selected", current_gw && (current_gw == gw));
488   abuf_json_boolean(abuf, "selectable", isGwSelectable(gw, ipv6));
489   abuf_json_ip_address(abuf, "originator", &gw->originator);
490   abuf_json_ip_address(abuf, "prefix", &gw->external_prefix.prefix);
491   abuf_json_int(abuf, "prefixLen", gw->external_prefix.prefix_len);
492   abuf_json_int(abuf, "uplink", gw->uplink);
493   abuf_json_int(abuf, "downlink", gw->downlink);
494   abuf_json_int(abuf, "cost", gw->path_cost);
495   abuf_json_boolean(abuf, "IPv4", gw->ipv4);
496   abuf_json_boolean(abuf, "IPv4-NAT", gw->ipv4nat);
497   abuf_json_boolean(abuf, "IPv6", gw->ipv6);
498   abuf_json_int(abuf, "expireTime", gw->expire_timer ? (gw->expire_timer->timer_clock - now_times) : 0);
499   abuf_json_int(abuf, "cleanupTime", gw->cleanup_timer ? (gw->cleanup_timer->timer_clock - now_times) : 0);
500
501   abuf_json_int(abuf, "pathcost", !tc ? ROUTE_COST_BROKEN : tc->path_cost);
502   abuf_json_int(abuf, "hops", !tc ? 0 : tc->hops);
503 }
504
505 static void ipc_print_gateways_ipvx(struct autobuf *abuf, bool ipv6) {
506   abuf_json_mark_object(true, true, abuf, ipv6 ? "ipv6" : "ipv4");
507
508   if (olsr_cnf->smart_gw_active) {
509     struct gateway_entry * current_gw = olsr_get_inet_gateway(ipv6);
510     struct gateway_entry * gw;
511     OLSR_FOR_ALL_GATEWAY_ENTRIES(gw) {
512       if ((!ipv6 && !gw->ipv4) || (ipv6 && !gw->ipv6)) {
513         /* gw does not advertise the requested IP version */
514         continue;
515       }
516
517       abuf_json_mark_array_entry(true, abuf);
518       ipc_print_gateway_entry(abuf, ipv6, current_gw, gw);
519       abuf_json_mark_array_entry(false, abuf);
520     } OLSR_FOR_ALL_GATEWAY_ENTRIES_END(gw)
521   }
522
523   abuf_json_mark_object(false, true, abuf, NULL);
524 }
525 #endif /* __linux__ */
526
527 void ipc_print_gateways(struct autobuf *abuf) {
528 #ifndef __linux__
529   abuf_json_string(abuf, "error", "Gateway mode is only supported in Linux");
530 #else /* __linux__ */
531   abuf_json_mark_object(true, false, abuf, "gateways");
532
533   ipc_print_gateways_ipvx(abuf, false);
534   ipc_print_gateways_ipvx(abuf, true);
535
536   abuf_json_mark_object(false, false, abuf, NULL);
537 #endif /* __linux__ */
538 }
539
540 #ifdef __linux__
541
542 /** interface names for smart gateway tunnel interfaces, IPv4 */
543 extern struct interfaceName * sgwTunnel4InterfaceNames;
544
545 /** interface names for smart gateway tunnel interfaces, IPv6 */
546 extern struct interfaceName * sgwTunnel6InterfaceNames;
547
548 /**
549  * Construct the sgw table for a given ip version
550  *
551  * @param abuf the string buffer
552  * @param ipv6 true for IPv6, false for IPv4
553  * @param fmtv the format for printing
554  */
555 static void sgw_ipvx(struct autobuf *abuf, bool ipv6) {
556   struct interfaceName * sgwTunnelInterfaceNames = !ipv6 ? sgwTunnel4InterfaceNames : sgwTunnel6InterfaceNames;
557
558   abuf_json_mark_object(true, true, abuf, ipv6 ? "ipv6" : "ipv4");
559
560   if (olsr_cnf->smart_gw_active && sgwTunnelInterfaceNames) {
561     struct gateway_entry * current_gw = olsr_get_inet_gateway(ipv6);
562     int i;
563     for (i = 0; i < olsr_cnf->smart_gw_use_count; i++) {
564       struct interfaceName * node = &sgwTunnelInterfaceNames[i];
565       struct gateway_entry * gw = node->gw;
566
567       if (!gw) {
568         continue;
569       }
570
571       abuf_json_mark_array_entry(true, abuf);
572       ipc_print_gateway_entry(abuf, ipv6, current_gw, gw);
573       abuf_json_ip_address(abuf, "destination", &gw->originator);
574       abuf_json_string(abuf, "tunnel", node->name);
575       abuf_json_int(abuf, "tableNr", node->tableNr);
576       abuf_json_int(abuf, "ruleNr", node->ruleNr);
577       abuf_json_int(abuf, "bypassRuleNr", node->bypassRuleNr);
578       abuf_json_mark_array_entry(false, abuf);
579     }
580   }
581
582   abuf_json_mark_object(false, true, abuf, NULL);
583 }
584 #endif /* __linux__ */
585
586 void ipc_print_sgw(struct autobuf *abuf) {
587 #ifndef __linux__
588   abuf_json_string(abuf, "error", "Gateway mode is only supported in Linux");
589 #else
590   abuf_json_mark_object(true, false, abuf, "sgw");
591
592   sgw_ipvx(abuf, false);
593   sgw_ipvx(abuf, true);
594
595   abuf_json_mark_object(false, false, abuf, NULL);
596 #endif /* __linux__ */
597 }
598
599 void ipc_print_version(struct autobuf *abuf) {
600   abuf_json_mark_object(true, false, abuf, "version");
601
602   abuf_json_string(abuf, "version", olsrd_version);
603
604   abuf_json_string(abuf, "date", build_date);
605   abuf_json_string(abuf, "host", build_host);
606   abuf_json_string(abuf, "gitDescriptor", git_descriptor);
607   abuf_json_string(abuf, "gitSha", git_sha);
608   abuf_json_string(abuf, "releaseVersion", release_version);
609   abuf_json_string(abuf, "sourceHash", source_hash);
610
611   abuf_json_mark_object(false, false, abuf, NULL);
612 }
613
614 void ipc_print_olsrd_conf(struct autobuf *abuf) {
615   olsrd_write_cnf_autobuf(abuf, olsr_cnf);
616 }
617
618 void ipc_print_interfaces(struct autobuf *abuf) {
619 #ifdef __linux__
620   int linklen;
621   char path[PATH_MAX];
622   char linkpath[PATH_MAX];
623 #endif /* __linux__ */
624   char ipv6_buf[INET6_ADDRSTRLEN]; /* buffer for IPv6 inet_htop */
625   const struct olsr_if *ifs;
626
627   abuf_json_mark_object(true, true, abuf, "interfaces");
628   for (ifs = olsr_cnf->interfaces; ifs != NULL ; ifs = ifs->next) {
629     struct olsr_lq_mult *mult;
630     const struct interface_olsr * const rifs = ifs->interf;
631
632     abuf_json_mark_array_entry(true, abuf);
633     abuf_json_string(abuf, "name", ifs->name);
634
635     abuf_json_mark_object(true, true, abuf, "linkQualityMultipliers");
636     for (mult = ifs->cnf->lq_mult; mult != NULL ; mult = mult->next) {
637       abuf_json_mark_array_entry(true, abuf);
638       abuf_json_string(abuf, "route", inet_ntop(olsr_cnf->ip_version, &mult->addr, ipv6_buf, sizeof(ipv6_buf)));
639       abuf_json_float(abuf, "multiplier", mult->value / 65535.0);
640       abuf_json_mark_array_entry(false, abuf);
641     }
642     abuf_json_mark_object(false, true, abuf, NULL); // linkQualityMultipliers
643
644     if (!rifs) {
645       abuf_json_string(abuf, "state", "down");
646     } else {
647       abuf_json_string(abuf, "state", "up");
648       abuf_json_string(abuf, "nameFromKernel", rifs->int_name);
649       abuf_json_int(abuf, "interfaceMode", rifs->mode);
650       abuf_json_boolean(abuf, "emulatedHostClientInterface", rifs->is_hcif);
651       abuf_json_boolean(abuf, "sendTcImmediately", rifs->immediate_send_tc);
652       abuf_json_int(abuf, "fishEyeTtlIndex", rifs->ttl_index);
653       abuf_json_int(abuf, "olsrForwardingTimeout", rifs->fwdtimer);
654       abuf_json_int(abuf, "olsrMessageSequenceNumber", rifs->olsr_seqnum);
655       abuf_json_int(abuf, "olsrInterfaceMetric", rifs->int_metric);
656       abuf_json_int(abuf, "olsrMTU", rifs->int_mtu);
657       abuf_json_int(abuf, "helloEmissionInterval", rifs->hello_etime);
658       abuf_json_int(abuf, "helloValidityTime", me_to_reltime(rifs->valtimes.hello));
659       abuf_json_int(abuf, "tcValidityTime", me_to_reltime(rifs->valtimes.tc));
660       abuf_json_int(abuf, "midValidityTime", me_to_reltime(rifs->valtimes.mid));
661       abuf_json_int(abuf, "hnaValidityTime", me_to_reltime(rifs->valtimes.hna));
662       abuf_json_boolean(abuf, "wireless", rifs->is_wireless);
663
664 #ifdef __linux__
665       abuf_json_boolean(abuf, "icmpRedirect", rifs->nic_state.redirect);
666       abuf_json_boolean(abuf, "spoofFilter", rifs->nic_state.spoof);
667 #endif /* __linux__ */
668
669       if (olsr_cnf->ip_version == AF_INET) {
670         struct ipaddr_str addrbuf;
671         struct ipaddr_str maskbuf;
672         struct ipaddr_str bcastbuf;
673
674         abuf_json_string(abuf, "ipv4Address", ip4_to_string(&addrbuf, rifs->int_addr.sin_addr));
675         abuf_json_string(abuf, "netmask", ip4_to_string(&maskbuf, rifs->int_netmask.sin_addr));
676         abuf_json_string(abuf, "broadcast", ip4_to_string(&bcastbuf, rifs->int_broadaddr.sin_addr));
677       } else {
678         struct ipaddr_str addrbuf;
679         struct ipaddr_str maskbuf;
680
681         abuf_json_string(abuf, "ipv6Address", ip6_to_string(&addrbuf, &rifs->int6_addr.sin6_addr));
682         abuf_json_string(abuf, "multicast", ip6_to_string(&maskbuf, &rifs->int6_multaddr.sin6_addr));
683       }
684     }
685 #ifdef __linux__
686     snprintf(path, PATH_MAX, "/sys/class/net/%s/device/driver/module", ifs->name);
687     linklen = readlink(path, linkpath, PATH_MAX - 1);
688     if (linklen > 1) {
689       linkpath[linklen] = '\0';
690       abuf_json_string(abuf, "kernelModule", basename(linkpath));
691     }
692
693     abuf_json_sys_class_net(abuf, "addressLength", ifs->name, "addr_len");
694     abuf_json_sys_class_net(abuf, "carrier", ifs->name, "carrier");
695     abuf_json_sys_class_net(abuf, "dormant", ifs->name, "dormant");
696     abuf_json_sys_class_net(abuf, "features", ifs->name, "features");
697     abuf_json_sys_class_net(abuf, "flags", ifs->name, "flags");
698     abuf_json_sys_class_net(abuf, "linkMode", ifs->name, "link_mode");
699     abuf_json_sys_class_net(abuf, "macAddress", ifs->name, "address");
700     abuf_json_sys_class_net(abuf, "ethernetMTU", ifs->name, "mtu");
701     abuf_json_sys_class_net(abuf, "operationalState", ifs->name, "operstate");
702     abuf_json_sys_class_net(abuf, "txQueueLength", ifs->name, "tx_queue_len");
703     abuf_json_sys_class_net(abuf, "collisions", ifs->name, "statistics/collisions");
704     abuf_json_sys_class_net(abuf, "multicastPackets", ifs->name, "statistics/multicast");
705     abuf_json_sys_class_net(abuf, "rxBytes", ifs->name, "statistics/rx_bytes");
706     abuf_json_sys_class_net(abuf, "rxCompressed", ifs->name, "statistics/rx_compressed");
707     abuf_json_sys_class_net(abuf, "rxCrcErrors", ifs->name, "statistics/rx_crc_errors");
708     abuf_json_sys_class_net(abuf, "rxDropped", ifs->name, "statistics/rx_dropped");
709     abuf_json_sys_class_net(abuf, "rxErrors", ifs->name, "statistics/rx_errors");
710     abuf_json_sys_class_net(abuf, "rxFifoErrors", ifs->name, "statistics/rx_fifo_errors");
711     abuf_json_sys_class_net(abuf, "rxFrameErrors", ifs->name, "statistics/rx_frame_errors");
712     abuf_json_sys_class_net(abuf, "rxLengthErrors", ifs->name, "statistics/rx_length_errors");
713     abuf_json_sys_class_net(abuf, "rxMissedErrors", ifs->name, "statistics/rx_missed_errors");
714     abuf_json_sys_class_net(abuf, "rxOverErrors", ifs->name, "statistics/rx_over_errors");
715     abuf_json_sys_class_net(abuf, "rxPackets", ifs->name, "statistics/rx_packets");
716     abuf_json_sys_class_net(abuf, "txAbortedErrors", ifs->name, "statistics/tx_aborted_errors");
717     abuf_json_sys_class_net(abuf, "txBytes", ifs->name, "statistics/tx_bytes");
718     abuf_json_sys_class_net(abuf, "txCarrierErrors", ifs->name, "statistics/tx_carrier_errors");
719     abuf_json_sys_class_net(abuf, "txCompressed", ifs->name, "statistics/tx_compressed");
720     abuf_json_sys_class_net(abuf, "txDropped", ifs->name, "statistics/tx_dropped");
721     abuf_json_sys_class_net(abuf, "txErrors", ifs->name, "statistics/tx_errors");
722     abuf_json_sys_class_net(abuf, "txFifoErrors", ifs->name, "statistics/tx_fifo_errors");
723     abuf_json_sys_class_net(abuf, "txHeartbeatErrors", ifs->name, "statistics/tx_heartbeat_errors");
724     abuf_json_sys_class_net(abuf, "txPackets", ifs->name, "statistics/tx_packets");
725     abuf_json_sys_class_net(abuf, "txWindowErrors", ifs->name, "statistics/tx_window_errors");
726     abuf_json_sys_class_net(abuf, "beaconing", ifs->name, "wireless/beacon");
727     abuf_json_sys_class_net(abuf, "encryptionKey", ifs->name, "wireless/crypt");
728     abuf_json_sys_class_net(abuf, "fragmentationThreshold", ifs->name, "wireless/fragment");
729     abuf_json_sys_class_net(abuf, "signalLevel", ifs->name, "wireless/level");
730     abuf_json_sys_class_net(abuf, "linkQuality", ifs->name, "wireless/link");
731     abuf_json_sys_class_net(abuf, "misc", ifs->name, "wireless/misc");
732     abuf_json_sys_class_net(abuf, "noiseLevel", ifs->name, "wireless/noise");
733     abuf_json_sys_class_net(abuf, "nwid", ifs->name, "wireless/nwid");
734     abuf_json_sys_class_net(abuf, "wirelessRetries", ifs->name, "wireless/retries");
735     abuf_json_sys_class_net(abuf, "wirelessStatus", ifs->name, "wireless/status");
736 #endif /* __linux__ */
737     abuf_json_mark_array_entry(false, abuf);
738   }
739   abuf_json_mark_object(false, true, abuf, NULL); // interfaces
740 }
741
742 void ipc_print_twohop(struct autobuf *abuf) {
743   ipc_print_neighbors_internal(abuf, true);
744 }
745
746 void ipc_print_config(struct autobuf *abuf) {
747   struct ip_prefix_list *hna;
748   struct ipaddr_str buf, mainaddrbuf;
749   struct ip_prefix_list *ipcn;
750   struct olsr_lq_mult *mult;
751   char ipv6_buf[INET6_ADDRSTRLEN]; /* buffer for IPv6 inet_htop */
752
753   abuf_json_mark_object(true, false, abuf, "config");
754
755   abuf_json_int(abuf, "olsrPort", olsr_cnf->olsrport);
756   abuf_json_int(abuf, "debugLevel", olsr_cnf->debug_level);
757   abuf_json_boolean(abuf, "noFork", olsr_cnf->no_fork);
758   abuf_json_boolean(abuf, "hostEmulation", olsr_cnf->host_emul);
759   abuf_json_int(abuf, "ipVersion", olsr_cnf->ip_version);
760   abuf_json_boolean(abuf, "allowNoInterfaces", olsr_cnf->allow_no_interfaces);
761   abuf_json_int(abuf, "typeOfService", olsr_cnf->tos);
762   abuf_json_int(abuf, "rtProto", olsr_cnf->rt_proto);
763   abuf_json_int(abuf, "rtTable", olsr_cnf->rt_table);
764   abuf_json_int(abuf, "rtTableDefault", olsr_cnf->rt_table_default);
765   abuf_json_int(abuf, "rtTableTunnel", olsr_cnf->rt_table_tunnel);
766   abuf_json_int(abuf, "rtTablePriority", olsr_cnf->rt_table_pri);
767   abuf_json_int(abuf, "rtTableTunnelPriority", olsr_cnf->rt_table_tunnel_pri);
768   abuf_json_int(abuf, "rtTableDefauiltOlsrPriority", olsr_cnf->rt_table_defaultolsr_pri);
769   abuf_json_int(abuf, "rtTableDefaultPriority", olsr_cnf->rt_table_default_pri);
770   abuf_json_int(abuf, "willingness", olsr_cnf->willingness);
771   abuf_json_boolean(abuf, "willingnessAuto", olsr_cnf->willingness_auto);
772
773   abuf_json_int(abuf, "brokenLinkCost", LINK_COST_BROKEN);
774   abuf_json_int(abuf, "brokenRouteCost", ROUTE_COST_BROKEN);
775
776   abuf_json_string(abuf, "fibMetrics", FIB_METRIC_TXT[olsr_cnf->fib_metric]);
777
778   abuf_json_string(abuf, "defaultIpv6Multicast", inet_ntop(AF_INET6, &olsr_cnf->interface_defaults->ipv6_multicast.v6, ipv6_buf, sizeof(ipv6_buf)));
779   if (olsr_cnf->interface_defaults->ipv4_multicast.v4.s_addr)
780     abuf_json_string(abuf, "defaultIpv4Broadcast", inet_ntoa(olsr_cnf->interface_defaults->ipv4_multicast.v4));
781   else
782     abuf_json_string(abuf, "defaultIpv4Broadcast", "auto");
783
784   if (olsr_cnf->interface_defaults->mode == IF_MODE_ETHER)
785     abuf_json_string(abuf, "defaultInterfaceMode", "ether");
786   else
787     abuf_json_string(abuf, "defaultInterfaceMode", "mesh");
788
789   abuf_json_float(abuf, "defaultHelloEmissionInterval", olsr_cnf->interface_defaults->hello_params.emission_interval);
790   abuf_json_float(abuf, "defaultHelloValidityTime", olsr_cnf->interface_defaults->hello_params.validity_time);
791   abuf_json_float(abuf, "defaultTcEmissionInterval", olsr_cnf->interface_defaults->tc_params.emission_interval);
792   abuf_json_float(abuf, "defaultTcValidityTime", olsr_cnf->interface_defaults->tc_params.validity_time);
793   abuf_json_float(abuf, "defaultMidEmissionInterval", olsr_cnf->interface_defaults->mid_params.emission_interval);
794   abuf_json_float(abuf, "defaultMidValidityTime", olsr_cnf->interface_defaults->mid_params.validity_time);
795   abuf_json_float(abuf, "defaultHnaEmissionInterval", olsr_cnf->interface_defaults->hna_params.emission_interval);
796   abuf_json_float(abuf, "defaultHnaValidityTime", olsr_cnf->interface_defaults->hna_params.validity_time);
797   abuf_json_boolean(abuf, "defaultAutoDetectChanges", olsr_cnf->interface_defaults->autodetect_chg);
798
799   abuf_json_mark_object(true, true, abuf, "defaultLinkQualityMultipliers");
800   for (mult = olsr_cnf->interface_defaults->lq_mult; mult != NULL ; mult = mult->next) {
801     abuf_json_mark_array_entry(true, abuf);
802     abuf_json_string(abuf, "route", inet_ntop(olsr_cnf->ip_version, &mult->addr, ipv6_buf, sizeof(ipv6_buf)));
803     abuf_json_float(abuf, "multiplier", mult->value / 65535.0);
804     abuf_json_mark_array_entry(false, abuf);
805   }
806   abuf_json_mark_object(false, true, abuf, NULL);
807
808   abuf_json_mark_object(true, true, abuf, "hna");
809   for (hna = olsr_cnf->hna_entries; hna != NULL ; hna = hna->next) {
810     abuf_json_mark_array_entry(true, abuf);
811     abuf_json_string(abuf, "destination", olsr_ip_to_string(&buf, &hna->net.prefix));
812     abuf_json_int(abuf, "genmask", hna->net.prefix_len);
813     abuf_json_string(abuf, "gateway", olsr_ip_to_string(&mainaddrbuf, &olsr_cnf->main_addr));
814     abuf_json_mark_array_entry(false, abuf);
815   }
816   abuf_json_mark_object(false, true, abuf, NULL);
817
818   abuf_json_int(abuf, "totalIpcConnectionsAllowed", olsr_cnf->ipc_connections);
819   abuf_json_mark_object(true, true, abuf, "ipcAllowedAddresses");
820   if (olsr_cnf->ipc_connections) {
821     for (ipcn = olsr_cnf->ipc_nets; ipcn != NULL ; ipcn = ipcn->next) {
822       abuf_json_mark_array_entry(true, abuf);
823       abuf_json_string(abuf, "ipAddress", olsr_ip_to_string(&mainaddrbuf, &ipcn->net.prefix));
824       abuf_json_int(abuf, "netmask", ipcn->net.prefix_len);
825       abuf_json_mark_array_entry(false, abuf);
826     }
827   }
828   abuf_json_mark_object(false, true, abuf, NULL);
829
830   // keep all time in ms, so convert these two, which are in seconds
831   abuf_json_int(abuf, "pollRate", olsr_cnf->pollrate * 1000);
832   abuf_json_int(abuf, "nicChangePollInterval", olsr_cnf->nic_chgs_pollrate * 1000);
833   abuf_json_boolean(abuf, "clearScreen", olsr_cnf->clear_screen);
834   abuf_json_int(abuf, "tcRedundancy", olsr_cnf->tc_redundancy);
835   abuf_json_int(abuf, "mprCoverage", olsr_cnf->mpr_coverage);
836
837   if (!olsr_cnf->lq_level) {
838     abuf_json_boolean(abuf, "useHysteresis", olsr_cnf->use_hysteresis);
839     if (olsr_cnf->use_hysteresis) {
840       abuf_json_float(abuf, "hysteresisScaling", olsr_cnf->hysteresis_param.scaling);
841       abuf_json_float(abuf, "hysteresisLowThreshold", olsr_cnf->hysteresis_param.thr_low);
842       abuf_json_float(abuf, "hysteresisHighThreshold", olsr_cnf->hysteresis_param.thr_high);
843     }
844   }
845   abuf_json_int(abuf, "linkQualityLevel", olsr_cnf->lq_level);
846   abuf_json_float(abuf, "linkQualityAging", olsr_cnf->lq_aging);
847   abuf_json_boolean(abuf, "linkQualityFisheye", olsr_cnf->lq_fish);
848   abuf_json_string(abuf, "linkQualityAlgorithm", olsr_cnf->lq_algorithm);
849   // keep all time in ms, so convert this from seconds
850   abuf_json_int(abuf, "minTcValidTime", olsr_cnf->min_tc_vtime * 1000);
851   abuf_json_boolean(abuf, "setIpForward", olsr_cnf->set_ip_forward);
852   abuf_json_string(abuf, "lockFile", olsr_cnf->lock_file);
853   abuf_json_boolean(abuf, "useNiit", olsr_cnf->use_niit);
854
855 #ifdef __linux__
856   abuf_json_boolean(abuf, "smartGateway", olsr_cnf->smart_gw_active);
857   if (olsr_cnf->smart_gw_active) {
858     abuf_json_boolean(abuf, "smartGatewayAlwaysRemoveServerTunnel", olsr_cnf->smart_gw_always_remove_server_tunnel);
859     abuf_json_int(abuf, "smartGatewayUseCount", olsr_cnf->smart_gw_use_count);
860     abuf_json_string(abuf, "smartGatewayInstanceId", olsr_cnf->smart_gw_instance_id);
861     abuf_json_string(abuf, "smartGatewayPolicyRoutingScript", olsr_cnf->smart_gw_policyrouting_script);
862     {
863       struct autobuf egressbuf;
864       struct sgw_egress_if * egressif = olsr_cnf->smart_gw_egress_interfaces;
865
866       abuf_init(&egressbuf, (olsr_cnf->smart_gw_egress_interfaces_count * IFNAMSIZ) /* interface names */
867       + (olsr_cnf->smart_gw_egress_interfaces_count - 1) /* commas */);
868       while (egressif) {
869         if (egressbuf.len) {
870           abuf_puts(&egressbuf, ",");
871         }
872         abuf_appendf(&egressbuf, "%s", egressif->name);
873         egressif = egressif->next;
874       }
875       abuf_json_string(abuf, "smartGatewayEgressInterfaces", egressbuf.buf);
876       abuf_free(&egressbuf);
877     }
878     abuf_json_int(abuf, "smartGatewayTablesOffset", olsr_cnf->smart_gw_offset_tables);
879     abuf_json_int(abuf, "smartGatewayRulesOffset", olsr_cnf->smart_gw_offset_rules);
880     abuf_json_boolean(abuf, "smartGatewayAllowNat", olsr_cnf->smart_gw_allow_nat);
881     abuf_json_boolean(abuf, "smartGatewayUplinkNat", olsr_cnf->smart_gw_uplink_nat);
882     abuf_json_int(abuf, "smartGatewayPeriod", olsr_cnf->smart_gw_period);
883     abuf_json_int(abuf, "smartGatewayStableCount", olsr_cnf->smart_gw_stablecount);
884     abuf_json_int(abuf, "smartGatewayThreshold", olsr_cnf->smart_gw_thresh);
885     abuf_json_int(abuf, "smartGatewayUplink", olsr_cnf->smart_gw_uplink);
886     abuf_json_int(abuf, "smartGatewayDownlink", olsr_cnf->smart_gw_downlink);
887     abuf_json_int(abuf, "smartGatewayType", olsr_cnf->smart_gw_type);
888     abuf_json_string(abuf, "smartGatewayPrefix", olsr_ip_to_string(&mainaddrbuf, &olsr_cnf->smart_gw_prefix.prefix));
889     abuf_json_int(abuf, "smartGatewayPrefixLength", olsr_cnf->smart_gw_prefix.prefix_len);
890   }
891 #endif /* __linux__ */
892
893   abuf_json_string(abuf, "mainIpAddress", olsr_ip_to_string(&mainaddrbuf, &olsr_cnf->main_addr));
894   abuf_json_string(abuf, "unicastSourceIpAddress", olsr_ip_to_string(&mainaddrbuf, &olsr_cnf->unicast_src_ip));
895
896   abuf_json_boolean(abuf, "useSourceIpRoutes", olsr_cnf->use_src_ip_routes);
897
898   abuf_json_int(abuf, "maxPrefixLength", olsr_cnf->maxplen);
899   abuf_json_int(abuf, "ipSize", olsr_cnf->ipsize);
900   abuf_json_boolean(abuf, "deleteInternetGatewaysAtStartup", olsr_cnf->del_gws);
901   // keep all time in ms, so convert this from seconds
902   abuf_json_int(abuf, "willingnessUpdateInterval", olsr_cnf->will_int * 1000);
903   abuf_json_float(abuf, "maxSendMessageJitter", olsr_cnf->max_jitter);
904   abuf_json_int(abuf, "exitValue", olsr_cnf->exit_value);
905   // keep all time in ms, so convert this from seconds
906   abuf_json_int(abuf, "maxTcValidTime", olsr_cnf->max_tc_vtime * 1000);
907
908   abuf_json_int(abuf, "niit4to6InterfaceIndex", olsr_cnf->niit4to6_if_index);
909   abuf_json_int(abuf, "niit6to4InterfaceIndex", olsr_cnf->niit6to4_if_index);
910
911   abuf_json_boolean(abuf, "hasIpv4Gateway", olsr_cnf->has_ipv4_gateway);
912   abuf_json_boolean(abuf, "hasIpv6Gateway", olsr_cnf->has_ipv6_gateway);
913
914   abuf_json_int(abuf, "ioctlSocket", olsr_cnf->ioctl_s);
915 #ifdef __linux__
916   abuf_json_int(abuf, "routeNetlinkSocket", olsr_cnf->rtnl_s);
917   abuf_json_int(abuf, "routeMonitorSocket", olsr_cnf->rt_monitor_socket);
918 #endif /* __linux__ */
919
920 #if defined __FreeBSD__ || defined __FreeBSD_kernel__ || defined __APPLE__ || defined __NetBSD__ || defined __OpenBSD__
921   abuf_json_int(abuf, "routeChangeSocket", olsr_cnf->rts);
922 #endif /* defined __FreeBSD__ || defined __FreeBSD_kernel__ || defined __APPLE__ || defined __NetBSD__ || defined __OpenBSD__ */
923   abuf_json_float(abuf, "linkQualityNatThreshold", olsr_cnf->lq_nat_thresh);
924
925   abuf_json_string(abuf, "olsrdVersion", olsrd_version);
926   abuf_json_string(abuf, "olsrdBuildDate", build_date);
927   abuf_json_string(abuf, "olsrdBuildHost", build_host);
928
929 #if defined _WIN32 || defined _WIN64
930   abuf_json_string(abuf, "os", "Windows");
931 #elif defined __gnu_linux__
932   abuf_json_string(abuf, "os", "GNU/Linux");
933 #elif defined __ANDROID__
934   abuf_json_string(abuf, "os", "Android");
935 #elif defined __APPLE__
936   abuf_json_string(abuf, "os", "Mac OS X");
937 #elif defined __NetBSD__
938   abuf_json_string(abuf, "os", "NetBSD");
939 #elif defined __OpenBSD__
940   abuf_json_string(abuf, "os", "OpenBSD");
941 #elif defined __FreeBSD__ || defined __FreeBSD_kernel__
942   abuf_json_string(abuf, "os", "FreeBSD");
943 #else /* OS detection */
944   abuf_json_string(abuf, "os", "Undefined");
945 #endif /* OS detection */
946
947   abuf_json_int(abuf, "startTime", start_time.tv_sec);
948
949   abuf_json_mark_object(false, false, abuf, NULL);
950 }
951
952 void ipc_print_plugins(struct autobuf *abuf) {
953   abuf_json_mark_object(true, true, abuf, "plugins");
954   if (olsr_cnf->plugins) {
955     struct plugin_entry *plugin;
956
957     for (plugin = olsr_cnf->plugins; plugin; plugin = plugin->next) {
958       struct plugin_param *param;
959
960       abuf_json_mark_array_entry(true, abuf);
961       abuf_json_string(abuf, "plugin", plugin->name);
962       for (param = plugin->params; param; param = param->next) {
963         abuf_json_string(abuf, param->key, param->value);
964       }
965       abuf_json_mark_array_entry(false, abuf);
966     }
967   }
968   abuf_json_mark_object(false, true, abuf, NULL);
969 }