git.meshlink.io Git - meshlink/blob - src/devtools.c

   1 /*
   2     devtools.c -- Debugging and quality control functions.
   3     Copyright (C) 2014, 2017 Guus Sliepen <guus@meshlink.io>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License along
  16     with this program; if not, write to the Free Software Foundation, Inc.,
  17     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "system.h"
  21 #include <assert.h>
  22
  23 #include "logger.h"
  24 #include "meshlink_internal.h"
  25 #include "node.h"
  26 #include "splay_tree.h"
  27 #include "netutl.h"
  28 #include "xalloc.h"
  29
  30 #include "devtools.h"
  31
  32 /* Return an array of edges in the current network graph.
  33  * Data captures the current state and will not be updated.
  34  * Caller must deallocate data when done.
  35  */
  36 devtool_edge_t *devtool_get_all_edges(meshlink_handle_t *mesh, devtool_edge_t *edges, size_t *nmemb) {
  37         if(!mesh || !nmemb || (*nmemb && !edges)) {
  38                 meshlink_errno = MESHLINK_EINVAL;
  39                 return NULL;
  40         }
  41
  42         pthread_mutex_lock(&(mesh->mesh_mutex));
  43
  44         devtool_edge_t *result = NULL;
  45         int result_size = 0;
  46
  47         result_size = mesh->edges->count / 2;
  48
  49         // if result is smaller than edges, we have to dealloc all the excess devtool_edge_t
  50         if(result_size > *nmemb)
  51                 result = realloc(edges, result_size * sizeof(*result));
  52         else
  53                 result = edges;
  54
  55         if(result) {
  56                 devtool_edge_t *p = result;
  57                 int n = 0;
  58
  59                 for splay_each(edge_t, e, mesh->edges) {
  60                         // skip edges that do not represent a two-directional connection
  61                         if((!e->reverse) || (e->reverse->to != e->from))
  62                                 continue;
  63
  64                         // don't count edges twice
  65                         if(e->to < e->from)
  66                                 continue;
  67
  68                         assert(n < result_size);
  69
  70                         p->from = (meshlink_node_t *)e->from;
  71                         p->to = (meshlink_node_t *)e->to;
  72                         p->address = e->address.storage;
  73                         p->options = e->options;
  74                         p->weight = e->weight;
  75
  76                         n++;
  77                         p++;
  78                 }
  79
  80                 // shrink result to the actual amount of memory used
  81                 result = realloc(result, n * sizeof(*result));
  82                 *nmemb = n;
  83         } else {
  84                 *nmemb = 0;
  85                 meshlink_errno = MESHLINK_ENOMEM;
  86         }
  87
  88         pthread_mutex_unlock(&(mesh->mesh_mutex));
  89
  90         return result;
  91 }
  92
  93 static bool fstrwrite(const char *str, FILE *stream) {
  94         size_t len = strlen(str);
  95
  96         if(fwrite((void *)str, 1, len, stream) != len)
  97                 return false;
  98
  99         return true;
 100 }
 101
 102 static const char *__itoa(int value) {
 103         static char buffer[sizeof(int) * 8 + 1];        // not thread safe
 104
 105         if(snprintf(buffer, sizeof(buffer), "%d", value) == -1)
 106                 return "";
 107
 108         return buffer;
 109 }
 110
 111 bool devtool_export_json_all_edges_state(meshlink_handle_t *mesh, FILE *stream) {
 112         bool result = true;
 113
 114         pthread_mutex_lock(&(mesh->mesh_mutex));
 115
 116         // export edges and nodes
 117         size_t node_count = 0;
 118         size_t edge_count = 0;
 119
 120         meshlink_node_t **nodes = meshlink_get_all_nodes(mesh, NULL, &node_count);
 121         devtool_edge_t *edges = devtool_get_all_edges(mesh, NULL, &edge_count);
 122
 123         if((!nodes && node_count != 0) || (!edges && edge_count != 0))
 124                 goto fail;
 125
 126         // export begin
 127         if(!fstrwrite("{\n", stream))
 128                 goto fail;
 129
 130         // export nodes
 131         if(!fstrwrite("\t\"nodes\": {\n", stream))
 132                 goto fail;
 133
 134         for(size_t i = 0; i < node_count; ++i) {
 135                 if(!fstrwrite("\t\t\"", stream) || !fstrwrite(((node_t *)nodes[i])->name, stream) || !fstrwrite("\": {\n", stream))
 136                         goto fail;
 137
 138                 if(!fstrwrite("\t\t\t\"name\": \"", stream) || !fstrwrite(((node_t *)nodes[i])->name, stream) || !fstrwrite("\",\n", stream))
 139                         goto fail;
 140
 141                 if(!fstrwrite("\t\t\t\"options\": ", stream) || !fstrwrite(__itoa(((node_t *)nodes[i])->options), stream) || !fstrwrite(",\n", stream))
 142                         goto fail;
 143
 144                 if(!fstrwrite("\t\t\t\"devclass\": ", stream) || !fstrwrite(__itoa(((node_t *)nodes[i])->devclass), stream) || !fstrwrite("\n", stream))
 145                         goto fail;
 146
 147                 if(!fstrwrite((i + 1) != node_count ? "\t\t},\n" : "\t\t}\n", stream))
 148                         goto fail;
 149         }
 150
 151         if(!fstrwrite("\t},\n", stream))
 152                 goto fail;
 153
 154         // export edges
 155
 156         if(!fstrwrite("\t\"edges\": {\n", stream))
 157                 goto fail;
 158
 159         for(size_t i = 0; i < edge_count; ++i) {
 160                 if(!fstrwrite("\t\t\"", stream) || !fstrwrite(edges[i].from->name, stream) || !fstrwrite("_to_", stream) || !fstrwrite(edges[i].to->name, stream) || !fstrwrite("\": {\n", stream))
 161                         goto fail;
 162
 163                 if(!fstrwrite("\t\t\t\"from\": \"", stream) || !fstrwrite(edges[i].from->name, stream) || !fstrwrite("\",\n", stream))
 164                         goto fail;
 165
 166                 if(!fstrwrite("\t\t\t\"to\": \"", stream) || !fstrwrite(edges[i].to->name, stream) || !fstrwrite("\",\n", stream))
 167                         goto fail;
 168
 169                 char *host = NULL, *port = NULL, *address = NULL;
 170                 sockaddr2str((const sockaddr_t *) & (edges[i].address), &host, &port);
 171
 172                 if(host && port)
 173                         xasprintf(&address, "{ \"host\": \"%s\", \"port\": %s }", host, port);
 174
 175                 free(host);
 176                 free(port);
 177
 178                 if(!fstrwrite("\t\t\t\"address\": ", stream) || !fstrwrite(address ? address : "null", stream) || !fstrwrite(",\n", stream)) {
 179                         free(address);
 180                         goto fail;
 181                 }
 182
 183                 free(address);
 184
 185                 if(!fstrwrite("\t\t\t\"options\": ", stream) || !fstrwrite(__itoa(edges[i].options), stream) || !fstrwrite(",\n", stream))
 186                         goto fail;
 187
 188                 if(!fstrwrite("\t\t\t\"weight\": ", stream) || !fstrwrite(__itoa(edges[i].weight), stream) || !fstrwrite("\n", stream))
 189                         goto fail;
 190
 191                 if(!fstrwrite((i + 1) != edge_count ? "\t\t},\n" : "\t\t}\n", stream))
 192                         goto fail;
 193         }
 194
 195         if(!fstrwrite("\t}\n", stream))
 196                 goto fail;
 197
 198         // DONE!
 199
 200         if(!fstrwrite("}", stream))
 201                 goto fail;
 202
 203         goto done;
 204
 205 fail:
 206         result = false;
 207
 208 done:
 209         free(nodes);
 210         free(edges);
 211
 212         pthread_mutex_unlock(&(mesh->mesh_mutex));
 213
 214         return result;
 215 }