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