diff --git a/lib/fpga/card.c b/lib/fpga/card.c
index d0aa8c566..88d0b2fe4 100644
--- a/lib/fpga/card.c
+++ b/lib/fpga/card.c
@@ -59,9 +59,9 @@ int fpga_card_parse(struct fpga_card *c, json_t *cfg, const char *name)
 {
 	int ret;
 
-	json_t *cfg_ips;
-	json_t *cfg_slot = NULL;
-	json_t *cfg_id = NULL;
+	json_t *json_ips;
+	json_t *json_slot = NULL;
+	json_t *json_id = NULL;
 	json_error_t err;
 
 	c->name = strdup(name);
@@ -69,17 +69,17 @@ int fpga_card_parse(struct fpga_card *c, json_t *cfg, const char *name)
 	ret = json_unpack_ex(cfg, &err, 0, "{ s?: i, s?: b, s?: o, s?: o, s: o }"
 		"affinity", &c->affinity,
 		"do_reset", &c->do_reset,
-		"slot", &cfg_slot,
-		"id", &cfg_id,
-		"ips", &cfg_ips
+		"slot", &json_slot,
+		"id", &json_id,
+		"ips", &json_ips
 	);
 	if (ret)
 		jerror(&err, "Failed to parse FPGA vard configuration");
 
-	if (cfg_slot) {
+	if (json_slot) {
 		const char *err, *slot;
 
-		slot = json_string_value(cfg_slot);
+		slot = json_string_value(json_slot);
 		if (slot) {
 			ret = pci_device_parse_slot(&c->filter, slot, &err);
 			if (ret)
@@ -89,10 +89,10 @@ int fpga_card_parse(struct fpga_card *c, json_t *cfg, const char *name)
 			error("PCI slot must be a string");
 	}
 
-	if (cfg_id) {
+	if (json_id) {
 		const char *err, *id;
 
-		id = json_string_value(cfg_id);
+		id = json_string_value(json_id);
 		if (id) {
 			ret = pci_device_parse_id(&c->filter, (char*) id, &err);
 			if (ret)
@@ -102,12 +102,12 @@ int fpga_card_parse(struct fpga_card *c, json_t *cfg, const char *name)
 			error("PCI ID must be a string");
 	}
 
-	if (!json_is_object(cfg_ips))
+	if (!json_is_object(json_ips))
 		error("FPGA card IPs section must be an object");
 
 	const char *name_ip;
-	json_t *cfg_ip;
-	json_object_foreach(cfg_ips, name_ip, cfg_ip) {
+	json_t *json_ip;
+	json_object_foreach(json_ips, name_ip, json_ip) {
 		const char *vlnv;
 
 		struct fpga_ip_type *vt;
@@ -115,7 +115,7 @@ int fpga_card_parse(struct fpga_card *c, json_t *cfg, const char *name)
 
 		ip->card = c;
 
-		ret = json_unpack_ex(cfg_ip, &err, 0, "{ s: s }", "vlnv", &vlnv);
+		ret = json_unpack_ex(json_ip, &err, 0, "{ s: s }", "vlnv", &vlnv);
 		if (ret)
 			error("Failed to parse FPGA IP '%s' of card '%s'", name_ip, name);
 
@@ -127,7 +127,7 @@ int fpga_card_parse(struct fpga_card *c, json_t *cfg, const char *name)
 		if (ret)
 			error("Failed to initalize FPGA IP core");
 
-		ret = fpga_ip_parse(ip, cfg_ip, name_ip);
+		ret = fpga_ip_parse(ip, json_ip, name_ip);
 		if (ret)
 			error("Failed to parse FPGA IP core");
 
@@ -147,11 +147,11 @@ int fpga_card_parse_list(struct list *cards, json_t *cfg)
 		error("FPGA card configuration section must be a JSON object");
 
 	const char *name;
-	json_t *cfg_fpga;
-	json_object_foreach(cfg, name, cfg_fpga) {
+	json_t *json_fpga;
+	json_object_foreach(cfg, name, json_fpga) {
 		struct fpga_card *c = alloc(sizeof(struct fpga_card));
 
-		ret = fpga_card_parse(c, cfg_fpga, name);
+		ret = fpga_card_parse(c, json_fpga, name);
 		if (ret)
 			error("Failed to parse FPGA card configuration");
 
diff --git a/lib/fpga/ips/dft.c b/lib/fpga/ips/dft.c
index 9657287e6..a17c55006 100644
--- a/lib/fpga/ips/dft.c
+++ b/lib/fpga/ips/dft.c
@@ -19,33 +19,33 @@ int dft_parse(struct fpga_ip *c, json_t *cfg)
 
 	int ret;
 
-	json_t *cfg_harms;
+	json_t *json_harms;
 	json_error_t err;
 
 	ret = json_unpack_ex(cfg, &err, 0, "{ s: i, s: i, s: o }",
 		"period", &dft->period,
 		"decimation", &dft->decimation,
-		"harmonics", &cfg_harms
+		"harmonics", &json_harms
 	);
 	if (ret)
 		jerror(&err, "Failed to parse configuration of FPGA IP '%s'", c->name);
 
-	if (!json_is_array(cfg_harms))
+	if (!json_is_array(json_harms))
 		error("DFT IP core requires 'harmonics' to be an array of integers!");
 
-	dft->num_harmonics = json_array_size(cfg_harms);
+	dft->num_harmonics = json_array_size(json_harms);
 	if (dft->num_harmonics <= 0)
 		error("DFT IP core requires 'harmonics' to contain at least 1 value!");
 
 	dft->fharmonics = alloc(sizeof(float) * dft->num_harmonics);
 
 	size_t index;
-	json_t *cfg_harm;
-	json_array_foreach(cfg_harms, index, cfg_harm) {
-		if (!json_is_real(cfg_harm))
+	json_t *json_harm;
+	json_array_foreach(json_harms, index, json_harm) {
+		if (!json_is_real(json_harm))
 			error("DFT IP core requires all 'harmonics' values to be of floating point type");
 
-		dft->fharmonics[index] = (float) json_number_value(cfg_harm) / dft->period;
+		dft->fharmonics[index] = (float) json_number_value(json_harm) / dft->period;
 	}
 
 	return 0;
diff --git a/lib/fpga/ips/model.c b/lib/fpga/ips/model.c
index f8a0cb770..d8935db75 100644
--- a/lib/fpga/ips/model.c
+++ b/lib/fpga/ips/model.c
@@ -139,7 +139,7 @@ int model_parse(struct fpga_ip *c, json_t *cfg)
 
 	int ret;
 
-	json_t *cfg_params;
+	json_t *json_params;
 	json_error_t err;
 
 	if      (strcmp(c->vlnv.library, "hls") == 0)
@@ -149,17 +149,17 @@ int model_parse(struct fpga_ip *c, json_t *cfg)
 	else
 		error("Unsupported model type: %s", c->vlnv.library);
 
-	ret = json_unpack_ex(cfg, &err, 0, "{ s?: o }", "parameters", &cfg_params);
+	ret = json_unpack_ex(cfg, &err, 0, "{ s?: o }", "parameters", &json_params);
 	if (ret)
 		jerror(&err, "Failed to parse configuration of FPGA IP '%s'", c->name);
 
-	if (cfg_params) {
-		if (!json_is_object(cfg_params))
+	if (json_params) {
+		if (!json_is_object(json_params))
 			error("Setting 'parameters' must be a JSON object");
 
 		const char *name;
 		json_t *value;
-		json_object_foreach(cfg_params, name, value) {
+		json_object_foreach(json_params, name, value) {
 			if (!json_is_real(value))
 				error("Parameters of FPGA IP '%s' must be of type floating point", c->name);
 
diff --git a/lib/fpga/ips/switch.c b/lib/fpga/ips/switch.c
index 04f50b438..713fa6292 100644
--- a/lib/fpga/ips/switch.c
+++ b/lib/fpga/ips/switch.c
@@ -95,28 +95,28 @@ int switch_parse(struct fpga_ip *c, json_t *cfg)
 	int ret;
 	size_t index;
 	json_error_t err;
-	json_t *cfg_path, *cfg_paths = NULL;
+	json_t *json_path, *json_paths = NULL;
 
 	list_init(&sw->paths);
 
 	ret = json_unpack_ex(cfg, &err, 0, "{ s: i, s?: o }",
 		"num_ports", &sw->num_ports,
-		"paths", &cfg_paths
+		"paths", &json_paths
 	);
 	if (ret)
 		jerror(&err, "Failed to parse configuration of FPGA IP '%s'", c->name);
 
-	if (!cfg_paths)
+	if (!json_paths)
 		return 0; /* no switch config available */
 
-	if (!json_is_array(cfg_paths))
+	if (!json_is_array(json_paths))
 		error("Setting 'paths' of FPGA IP '%s' should be an array of JSON objects", c->name);
 
-	json_array_foreach(cfg_paths, index, cfg_path) {
+	json_array_foreach(json_paths, index, json_path) {
 		struct sw_path *p = alloc(sizeof(struct sw_path));
 		int reverse = 0;
 
-		ret = json_unpack_ex(cfg_path, &err, 0, "{ s?: b, s: s, s: s }",
+		ret = json_unpack_ex(json_path, &err, 0, "{ s?: b, s: s, s: s }",
 			"reverse", &reverse,
 			"in", &p->in,
 			"out", &p->out
diff --git a/lib/hook.c b/lib/hook.c
index 702efa7c4..016885d41 100644
--- a/lib/hook.c
+++ b/lib/hook.c
@@ -246,14 +246,14 @@ int hook_parse_list(struct list *list, json_t *cfg, struct path *o, struct node
 		error("Hooks must be configured as a list of objects");
 
 	size_t index;
-	json_t *cfg_hook;
-	json_array_foreach(cfg, index, cfg_hook) {
+	json_t *json_hook;
+	json_array_foreach(cfg, index, json_hook) {
 		int ret;
 		const char *type;
 		struct plugin *p;
 		json_error_t err;
 
-		ret = json_unpack_ex(cfg_hook, &err, 0, "{ s: s }", "type", &type);
+		ret = json_unpack_ex(json_hook, &err, 0, "{ s: s }", "type", &type);
 		if (ret)
 			jerror(&err, "Failed to parse hook");
 
@@ -267,7 +267,7 @@ int hook_parse_list(struct list *list, json_t *cfg, struct path *o, struct node
 		if (ret)
 			error("Failed to initialize hook: %s", p->name);
 
-		ret = hook_parse(h, cfg_hook);
+		ret = hook_parse(h, json_hook);
 		if (ret)
 			jerror(&err, "Failed to parse hook configuration");
 
diff --git a/lib/hooks/map.c b/lib/hooks/map.c
index d2426ac9b..0f6bd2687 100644
--- a/lib/hooks/map.c
+++ b/lib/hooks/map.c
@@ -59,15 +59,15 @@ static int map_parse(struct hook *h, json_t *cfg)
 	int ret;
 	struct map *m = h->_vd;
 	json_error_t err;
-	json_t *cfg_mapping;
+	json_t *json_mapping;
 
 	ret = json_unpack_ex(cfg, &err, 0, "{ s: o }",
-		"map", &cfg_mapping
+		"map", &json_mapping
 	);
 	if (ret)
 		jerror(&err, "Failed to parse configuration of hook '%s'", plugin_name(h->_vt));
 
-	ret = mapping_parse_list(&m->mapping, cfg_mapping, NULL);
+	ret = mapping_parse_list(&m->mapping, json_mapping, NULL);
 	if (ret)
 		return ret;
 
diff --git a/lib/kernel/tc.c b/lib/kernel/tc.c
index 2bcbbb7ce..6f5a37711 100644
--- a/lib/kernel/tc.c
+++ b/lib/kernel/tc.c
@@ -40,24 +40,24 @@ int tc_parse(struct rtnl_qdisc **netem, json_t *cfg)
 	const char *str;
 	int ret, val;
 
-	json_t *cfg_distribution = NULL;
-	json_t *cfg_limit = NULL;
-	json_t *cfg_delay = NULL;
-	json_t *cfg_jitter = NULL;
-	json_t *cfg_loss = NULL;
-	json_t *cfg_duplicate = NULL;
-	json_t *cfg_corruption = NULL;
+	json_t *json_distribution = NULL;
+	json_t *json_limit = NULL;
+	json_t *json_delay = NULL;
+	json_t *json_jitter = NULL;
+	json_t *json_loss = NULL;
+	json_t *json_duplicate = NULL;
+	json_t *json_corruption = NULL;
 
 	json_error_t err;
 
-		"distribution", &cfg_distribution,
-		"limit", &cfg_limit,
-		"delay", &cfg_delay,
-		"jitter", &cfg_jitter,
-		"loss", &cfg_loss,
-		"duplicate", &cfg_duplicate,
-		"corruption", &cfg_corruption
 	ret = json_unpack_ex(cfg, &err, 0, "{ s?: o, s?: o, s?: o, s?: o, s?: o, s?: o, s?: o }",
+		"distribution", &json_distribution,
+		"limit", &json_limit,
+		"delay", &json_delay,
+		"jitter", &json_jitter,
+		"loss", &json_loss,
+		"duplicate", &json_duplicate,
+		"corruption", &json_corruption
 	);
 	if (ret)
 		jerror(&err, "Failed to parse setting network emulation settings");
@@ -68,8 +68,8 @@ int tc_parse(struct rtnl_qdisc **netem, json_t *cfg)
 
 	rtnl_tc_set_kind(TC_CAST(ne), "netem");
 
-	if (cfg_distribution) {
-		str = json_string_value(cfg_distribution);
+	if (json_distribution) {
+		str = json_string_value(json_distribution);
 		if (!str)
 			error("Setting 'distribution' must be a JSON string");
 
@@ -77,10 +77,10 @@ int tc_parse(struct rtnl_qdisc **netem, json_t *cfg)
 			error("Invalid delay distribution '%s' in netem config", str);
 	}
 
-	if (cfg_limit) {
-		val = json_integer_value(cfg_limit);
+	if (json_limit) {
+		val = json_integer_value(json_limit);
 
-		if (!json_is_integer(cfg_limit) || val <= 0)
+		if (!json_is_integer(json_limit) || val <= 0)
 			error("Setting 'limit' must be a positive integer");
 
 		rtnl_netem_set_limit(ne, val);
@@ -88,46 +88,46 @@ int tc_parse(struct rtnl_qdisc **netem, json_t *cfg)
 	else
 		rtnl_netem_set_limit(ne, 0);
 
-	if (cfg_delay) {
-		val = json_integer_value(cfg_delay);
+	if (json_delay) {
+		val = json_integer_value(json_delay);
 
-		if (!json_is_integer(cfg_delay) || val <= 0)
+		if (!json_is_integer(json_delay) || val <= 0)
 			error("Setting 'delay' must be a positive integer");
 
 		rtnl_netem_set_delay(ne, val);
 	}
 
-	if (cfg_jitter) {
-		val = json_integer_value(cfg_jitter);
+	if (json_jitter) {
+		val = json_integer_value(json_jitter);
 
-		if (!json_is_integer(cfg_jitter) || val <= 0)
+		if (!json_is_integer(json_jitter) || val <= 0)
 			error("Setting 'jitter' must be a positive integer");
 
 		rtnl_netem_set_jitter(ne, val);
 	}
 
-	if (cfg_loss) {
-		val = json_integer_value(cfg_loss);
+	if (json_loss) {
+		val = json_integer_value(json_loss);
 
-		if (!json_is_integer(cfg_loss) || val < 0 || val > 100)
+		if (!json_is_integer(json_loss) || val < 0 || val > 100)
 			error("Setting 'loss' must be a positive integer within the range [ 0, 100 ]");
 
 		rtnl_netem_set_loss(ne, val);
 	}
 
-	if (cfg_duplicate) {
-		val = json_integer_value(cfg_duplicate);
+	if (json_duplicate) {
+		val = json_integer_value(json_duplicate);
 
-		if (!json_is_integer(cfg_duplicate) || val < 0 || val > 100)
+		if (!json_is_integer(json_duplicate) || val < 0 || val > 100)
 			error("Setting 'duplicate' must be a positive integer within the range [ 0, 100 ]");
 
 		rtnl_netem_set_duplicate(ne, val);
 	}
 
-	if (cfg_corruption) {
-		val = json_integer_value(cfg_corruption);
+	if (json_corruption) {
+		val = json_integer_value(json_corruption);
 
-		if (!json_is_integer(cfg_corruption) || val < 0 || val > 100)
+		if (!json_is_integer(json_corruption) || val < 0 || val > 100)
 			error("Setting 'corruption' must be a positive integer within the range [ 0, 100 ]");
 
 		rtnl_netem_set_corruption_probability(ne, val);
diff --git a/lib/nodes/cbuilder.c b/lib/nodes/cbuilder.c
index 409e75f5b..7ffda7a31 100644
--- a/lib/nodes/cbuilder.c
+++ b/lib/nodes/cbuilder.c
@@ -16,7 +16,7 @@
 int cbuilder_parse(struct node *n, json_t *cfg)
 {
 	struct cbuilder *cb = n->_vd;
-	json_t *cfg_param, *cfg_params = NULL;
+	json_t *json_param, *json_params = NULL;
 
 	const char *model;
 
@@ -27,7 +27,7 @@ int cbuilder_parse(struct node *n, json_t *cfg)
 	ret = json_unpack_ex(cfg, &err, 0, "{ s: F, s: s, s: b }",
 		"timestep", &cb->timestep,
 		"model", &model,
-		"parameters", &cfg_params
+		"parameters", &json_params
 	);
 	if (ret)
 		jerror(&err, "Failed to parse configuration of node %s", node_name(n));
@@ -36,18 +36,18 @@ int cbuilder_parse(struct node *n, json_t *cfg)
 	if (!cb->model)
 		error("Unknown model '%s' of node %s", model, node_name(n));
 
-	if (cfg_params) {
-		if (!json_is_array(cfg_params))
+	if (json_params) {
+		if (!json_is_array(json_params))
 			error("Setting 'parameters' of node %s must be an JSON array of numbers!", node_name(n));
 
-		cb->paramlen = json_array_size(cfg_params);
+		cb->paramlen = json_array_size(json_params);
 		cb->params = alloc(cb->paramlen * sizeof(double));
 
-		json_array_foreach(cfg_params, index, cfg_param) {
-			if (json_is_number(cfg_param))
+		json_array_foreach(json_params, index, json_param) {
+			if (json_is_number(json_param))
 				error("Setting 'parameters' of node %s must be an JSON array of numbers!", node_name(n));
 
-			cb->params[index] = json_number_value(cfg_params);
+			cb->params[index] = json_number_value(json_params);
 
 		}
 	}
diff --git a/lib/nodes/fpga.c b/lib/nodes/fpga.c
index 76856e87e..308a2b4f3 100644
--- a/lib/nodes/fpga.c
+++ b/lib/nodes/fpga.c
@@ -44,15 +44,15 @@ int fpga_init(struct super_node *sn)
 		error("Failed to initiliaze VFIO sub-system");
 
 #if 0
-	json_t *cfg, *cfg_fpgas;
+	json_t *cfg, *json_fpgas;
 
 	/* Parse FPGA configuration */
 	cfg = config_root_setting(&sn->cfg);
-	cfg_fpgas = config_setting_lookup(cfg, "fpgas");
-	if (!cfg_fpgas)
+	json_fpgas = config_setting_lookup(cfg, "fpgas");
+	if (!json_fpgas)
 		cerror(cfg, "Config file is missing 'fpgas' section");
 
-	ret = fpga_card_parse_list(&cards, cfg_fpgas);
+	ret = fpga_card_parse_list(&cards, json_fpgas);
 	if (ret)
 		cerror(cfg, "Failed to parse VILLASfpga config");
 #endif
diff --git a/lib/nodes/nanomsg.c b/lib/nodes/nanomsg.c
index 1b2029204..dafde69a1 100644
--- a/lib/nodes/nanomsg.c
+++ b/lib/nodes/nanomsg.c
@@ -51,12 +51,12 @@ static int nanomsg_parse_endpoints(struct list *l, json_t *cfg)
 	const char *ep;
 
 	size_t index;
-	json_t *cfg_val;
+	json_t *json_val;
 
 	switch (json_typeof(cfg)) {
 		case JSON_ARRAY:
-			json_array_foreach(cfg, index, cfg_val) {
-				ep = json_string_value(cfg_val);
+			json_array_foreach(cfg, index, json_val) {
+				ep = json_string_value(json_val);
 				if (!ep)
 					return -1;
 
@@ -86,28 +86,28 @@ int nanomsg_parse(struct node *n, json_t *cfg)
 
 	json_error_t err;
 
-	json_t *cfg_pub = NULL;
-	json_t *cfg_sub = NULL;
+	json_t *json_pub = NULL;
+	json_t *json_sub = NULL;
 
 	list_init(&m->publisher.endpoints);
 	list_init(&m->subscriber.endpoints);
 
 	ret = json_unpack_ex(cfg, &err, 0, "{ s?: o, s?: o, s?: s }",
-		"publish", &cfg_pub,
-		"subscribe", &cfg_sub,
+		"publish", &json_pub,
+		"subscribe", &json_sub,
 		"format", &format
 	);
 	if (ret)
 		jerror(&err, "Failed to parse configuration of node %s", node_name(n));
 
-	if (cfg_pub) {
-		ret = nanomsg_parse_endpoints(&m->publisher.endpoints, cfg_pub);
+	if (json_pub) {
+		ret = nanomsg_parse_endpoints(&m->publisher.endpoints, json_pub);
 		if (ret < 0)
 			error("Invalid type for 'publish' setting of node %s", node_name(n));
 	}
 
-	if (cfg_sub) {
-		ret = nanomsg_parse_endpoints(&m->subscriber.endpoints, cfg_sub);
+	if (json_sub) {
+		ret = nanomsg_parse_endpoints(&m->subscriber.endpoints, json_sub);
 		if (ret < 0)
 			error("Invalid type for 'subscribe' setting of node %s", node_name(n));
 	}
diff --git a/lib/nodes/ngsi.c b/lib/nodes/ngsi.c
index bfce5c3c8..b9802eaf4 100644
--- a/lib/nodes/ngsi.c
+++ b/lib/nodes/ngsi.c
@@ -205,12 +205,12 @@ static int ngsi_parse_mapping(struct list *mapping, json_t *cfg)
 	list_init(mapping);
 
 	size_t index;
-	json_t *cfg_token;
+	json_t *json_token;
 
-	json_array_foreach(cfg, index, cfg_token) {
+	json_array_foreach(cfg, index, json_token) {
 		const char *token;
 
-		token = json_string_value(cfg_token);
+		token = json_string_value(json_token);
 		if (!token)
 			return -2;
 
@@ -410,7 +410,7 @@ int ngsi_parse(struct node *n, json_t *cfg)
 
 	int ret;
 	json_error_t err;
-	json_t *cfg_mapping;
+	json_t *json_mapping;
 
 	/* Default values */
 	i->access_token = NULL; /* disabled by default */
@@ -426,12 +426,12 @@ int ngsi_parse(struct node *n, json_t *cfg)
 		"ssl_verify", &i->ssl_verify,
 		"timeout", &i->timeout,
 		"rate", &i->rate,
-		"mapping", &cfg_mapping
+		"mapping", &json_mapping
 	);
 	if (ret)
 		jerror(&err, "Failed to parse configuration of node %s", node_name(n));
 
-	ret = ngsi_parse_mapping(&i->mapping, cfg_mapping);
+	ret = ngsi_parse_mapping(&i->mapping, json_mapping);
 	if (ret)
 		error("Invalid setting 'mapping' of node %s", node_name(n));
 
diff --git a/lib/nodes/shmem.c b/lib/nodes/shmem.c
index 0f3c98e06..1dffb95b8 100644
--- a/lib/nodes/shmem.c
+++ b/lib/nodes/shmem.c
@@ -42,7 +42,7 @@ int shmem_parse(struct node *n, json_t *cfg)
 	const char *val;
 
 	int ret;
-	json_t *cfg_exec = NULL;
+	json_t *json_exec = NULL;
 	json_error_t err;
 
 	/* Default values */
@@ -56,21 +56,21 @@ int shmem_parse(struct node *n, json_t *cfg)
 		"in_name", &shm->in_name,
 		"queuelen", &shm->conf.queuelen,
 		"polling", &shm->conf.polling,
-		"exec", &cfg_exec
+		"exec", &json_exec
 	);
 	if (ret)
 		jerror(&err, "Failed to parse configuration of node %s", node_name(n));
 
-	if (cfg_exec) {
-		if (!json_is_array(cfg_exec))
+	if (json_exec) {
+		if (!json_is_array(json_exec))
 			error("Setting 'exec' of node %s must be a JSON array of strings", node_name(n));
 
-		shm->exec = alloc(sizeof(char *) * (json_array_size(cfg_exec) + 1));
+		shm->exec = alloc(sizeof(char *) * (json_array_size(json_exec) + 1));
 
 		size_t index;
-		json_t *cfg_val;
-		json_array_foreach(cfg_exec, index, cfg_val) {
-			val = json_string_value(cfg_exec);
+		json_t *json_val;
+		json_array_foreach(json_exec, index, json_val) {
+			val = json_string_value(json_exec);
 			if (!val)
 				error("Setting 'exec' of node %s must be a JSON array of strings", node_name(n));
 
diff --git a/lib/nodes/socket.c b/lib/nodes/socket.c
index 96fab8293..3cd02e1c2 100644
--- a/lib/nodes/socket.c
+++ b/lib/nodes/socket.c
@@ -389,7 +389,7 @@ int socket_parse(struct node *n, json_t *cfg)
 
 	int ret;
 
-	json_t *cfg_multicast = NULL;
+	json_t *json_multicast = NULL;
 	json_error_t err;
 
 	/* Default values */
@@ -401,7 +401,7 @@ int socket_parse(struct node *n, json_t *cfg)
 		"remote", &remote,
 		"local", &local,
 		"verify_source", &s->verify_source,
-		"multicast", &cfg_multicast,
+		"multicast", &json_multicast,
 		"format", &format
 	);
 	if (ret)
@@ -438,7 +438,7 @@ int socket_parse(struct node *n, json_t *cfg)
 			remote, node_name(n), gai_strerror(ret));
 	}
 
-	if (cfg_multicast) {
+	if (json_multicast) {
 		const char *group, *interface = NULL;
 
 		/* Default values */
@@ -447,7 +447,7 @@ int socket_parse(struct node *n, json_t *cfg)
 		s->multicast.loop = 0;
 		s->multicast.ttl = 255;
 
-		ret = json_unpack_ex(cfg_multicast, &err, 0, "{ s?: b, s: s, s?: s, s?: b, s?: i }",
+		ret = json_unpack_ex(json_multicast, &err, 0, "{ s?: b, s: s, s?: s, s?: b, s?: i }",
 			"enabled", &s->multicast.enabled,
 			"group", &group,
 			"interface", &interface,
@@ -473,18 +473,18 @@ int socket_parse(struct node *n, json_t *cfg)
 	}
 
 #ifdef WITH_NETEM
-	json_t *cfg_netem;
+	json_t *json_netem;
 
-	cfg_netem = json_object_get(cfg, "netem");
-	if (cfg_netem) {
+	json_netem = json_object_get(cfg, "netem");
+	if (json_netem) {
 		int enabled = 1;
 
-		ret = json_unpack_ex(cfg_netem, &err, 0, "{ s?: b }",  "enabled", &enabled);
+		ret = json_unpack_ex(json_netem, &err, 0, "{ s?: b }",  "enabled", &enabled);
 		if (ret)
 			jerror(&err, "Failed to parse setting 'netem' of node %s", node_name(n));
 
 		if (enabled)
-			tc_parse(&s->tc_qdisc, cfg_netem);
+			tc_parse(&s->tc_qdisc, json_netem);
 		else
 			s->tc_qdisc = NULL;
 	}
diff --git a/lib/nodes/test_rtt.c b/lib/nodes/test_rtt.c
index 9aa9d7d40..e46bbc9f5 100644
--- a/lib/nodes/test_rtt.c
+++ b/lib/nodes/test_rtt.c
@@ -82,8 +82,8 @@ int test_rtt_parse(struct node *n, json_t *cfg)
 	int numvalues = 0;
 
 	size_t index;
-	json_t *cfg_cases, *cfg_case, *cfg_val;
-	json_t *cfg_rates = NULL, *cfg_values = NULL;
+	json_t *json_cases, *json_case, *json_val;
+	json_t *json_rates = NULL, *json_values = NULL;
 	json_error_t err;
 
 	t->cooldown = 1.0;
@@ -96,7 +96,7 @@ int test_rtt_parse(struct node *n, json_t *cfg)
 		"output", &output,
 		"format", &format,
 		"cooldown", &t->cooldown,
-		"cases", &cfg_cases
+		"cases", &json_cases
 	);
 	if (ret)
 		jerror(&err, "Failed to parse configuration of node %s", node_name(n));
@@ -111,16 +111,16 @@ int test_rtt_parse(struct node *n, json_t *cfg)
 
 
 	/* Construct list of test cases */
-	if (!json_is_array(cfg_cases))
+	if (!json_is_array(json_cases))
 		error("The 'cases' setting of node %s must be an array.", node_name(n));
 
-	json_array_foreach(cfg_cases, index, cfg_case) {
+	json_array_foreach(json_cases, index, json_case) {
 		int limit = -1;
 		double duration = -1; /* in secs */
 
-		ret = json_unpack_ex(cfg_case, &err, 0, "{ s: o, s: o, s?: i, s?: F }",
-			"rates", &cfg_rates,
-			"values", &cfg_values,
+		ret = json_unpack_ex(json_case, &err, 0, "{ s: o, s: o, s?: i, s?: F }",
+			"rates", &json_rates,
+			"values", &json_values,
 			"limit", &limit,
 			"duration", &duration
 		);
@@ -128,16 +128,16 @@ int test_rtt_parse(struct node *n, json_t *cfg)
 		if (limit > 0 && duration > 0)
 			error("The settings 'duration' and 'limit' of node %s must be used exclusively", node_name(n));
 
-		if (json_is_array(cfg_rates))
-			numrates = json_array_size(cfg_rates);
-		else if (json_is_number(cfg_rates))
+		if (json_is_array(json_rates))
+			numrates = json_array_size(json_rates);
+		else if (json_is_number(json_rates))
 			numrates = 1;
 		else
 			error("The 'rates' setting of node %s must be a real or an array of real numbers", node_name(n));
 
-		if (json_is_array(cfg_values))
-			numvalues = json_array_size(cfg_values);
-		else if (json_is_integer(cfg_values))
+		if (json_is_array(json_values))
+			numvalues = json_array_size(json_values);
+		else if (json_is_integer(json_values))
 			numvalues = 1;
 		else
 			error("The 'values' setting of node %s must be an integer or an array of integers", node_name(n));
@@ -145,29 +145,29 @@ int test_rtt_parse(struct node *n, json_t *cfg)
 		rates  = realloc(rates, sizeof(rates[0]) * numrates);
 		values = realloc(values, sizeof(values[0]) * numvalues);
 
-		if (json_is_array(cfg_rates)) {
-			json_array_foreach(cfg_rates, index, cfg_val) {
-				if (!json_is_number(cfg_val))
+		if (json_is_array(json_rates)) {
+			json_array_foreach(json_rates, index, json_val) {
+				if (!json_is_number(json_val))
 					error("The 'rates' setting of node %s must be an array of real numbers", node_name(n));
 
-				rates[index] = json_integer_value(cfg_val);
+				rates[index] = json_integer_value(json_val);
 			}
 		}
 		else
-			rates[0] = json_number_value(cfg_rates);
+			rates[0] = json_number_value(json_rates);
 
-		if (json_is_array(cfg_values)) {
-			json_array_foreach(cfg_values, index, cfg_val) {
-				if (!json_is_integer(cfg_val))
+		if (json_is_array(json_values)) {
+			json_array_foreach(json_values, index, json_val) {
+				if (!json_is_integer(json_val))
 					error("The 'values' setting of node %s must be an array of integers", node_name(n));
 
-				values[index] = json_integer_value(cfg_val);
+				values[index] = json_integer_value(json_val);
 				if (values[index] < 2)
 					error("Each 'values' entry must be at least 2 or larger");
 			}
 		}
 		else {
-			values[0] = json_integer_value(cfg_values);
+			values[0] = json_integer_value(json_values);
 			if (values[0] <= 2)
 				error("Each 'values' entry must be at least 2 or larger");
 		}
diff --git a/lib/nodes/websocket.c b/lib/nodes/websocket.c
index c53d32596..90831f9d4 100644
--- a/lib/nodes/websocket.c
+++ b/lib/nodes/websocket.c
@@ -493,24 +493,24 @@ int websocket_parse(struct node *n, json_t *cfg)
 	int ret;
 
 	size_t index;
-	json_t *cfg_dests = NULL;
-	json_t *cfg_dest;
+	json_t *json_dests = NULL;
+	json_t *json_dest;
 	json_error_t err;
 
 	list_init(&w->destinations);
 
-	ret = json_unpack_ex(cfg, &err, 0, "{ s?: o }", "destinations", &cfg_dests);
+	ret = json_unpack_ex(cfg, &err, 0, "{ s?: o }", "destinations", &json_dests);
 	if (ret)
 		jerror(&err, "Failed to parse configuration of node %s", node_name(n));
 
-	if (cfg_dests) {
-		if (!json_is_array(cfg_dests))
+	if (json_dests) {
+		if (!json_is_array(json_dests))
 			error("The 'destinations' setting of node %s must be an array of URLs", node_name(n));
 
-		json_array_foreach(cfg_dests, index, cfg_dest) {
+		json_array_foreach(json_dests, index, json_dest) {
 			const char *uri, *prot, *ads, *path;
 
-			uri = json_string_value(cfg_dest);
+			uri = json_string_value(json_dest);
 			if (!uri)
 				error("The 'destinations' setting of node %s must be an array of URLs", node_name(n));
 
diff --git a/lib/nodes/zeromq.c b/lib/nodes/zeromq.c
index 19e2656e0..8b84fb31d 100644
--- a/lib/nodes/zeromq.c
+++ b/lib/nodes/zeromq.c
@@ -101,9 +101,9 @@ int zeromq_parse(struct node *n, json_t *cfg)
 	const char *format = "villas-human";
 
 	size_t index;
-	json_t *cfg_pub = NULL;
-	json_t *cfg_curve = NULL;
-	json_t *cfg_val;
+	json_t *json_pub = NULL;
+	json_t *json_curve = NULL;
+	json_t *json_val;
 	json_error_t err;
 
 	list_init(&z->publisher.endpoints);
@@ -113,8 +113,8 @@ int zeromq_parse(struct node *n, json_t *cfg)
 
 	ret = json_unpack_ex(cfg, &err, 0, "{ s?: s, s?: o, s?: o, s?: s, s?: s, s?: b, s?: s }",
 		"subscribe", &ep,
-		"publish", &cfg_pub,
-		"curve", &cfg_curve,
+		"publish", &json_pub,
+		"curve", &json_curve,
 		"filter", &filter,
 		"pattern", &type,
 		"ipv6", &z->ipv6,
@@ -130,11 +130,11 @@ int zeromq_parse(struct node *n, json_t *cfg)
 	if (!z->format)
 		error("Invalid format '%s' for node %s", format, node_name(n));
 
-	if (cfg_pub) {
-		switch (json_typeof(cfg_pub)) {
+	if (json_pub) {
+		switch (json_typeof(json_pub)) {
 			case JSON_ARRAY:
-				json_array_foreach(cfg_pub, index, cfg_val) {
-					ep = json_string_value(cfg_pub);
+				json_array_foreach(json_pub, index, json_val) {
+					ep = json_string_value(json_pub);
 					if (!ep)
 						error("All 'publish' settings must be strings");
 
@@ -143,7 +143,7 @@ int zeromq_parse(struct node *n, json_t *cfg)
 				break;
 
 			case JSON_STRING:
-				ep = json_string_value(cfg_pub);
+				ep = json_string_value(json_pub);
 
 				list_push(&z->publisher.endpoints, strdup(ep));
 
@@ -154,12 +154,12 @@ int zeromq_parse(struct node *n, json_t *cfg)
 		}
 	}
 
-	if (cfg_curve) {
+	if (json_curve) {
 		const char *public_key, *secret_key;
 
 		z->curve.enabled = true;
 
-		ret = json_unpack_ex(cfg_curve, &err, 0, "{ s: s, s: s, s?: b }",
+		ret = json_unpack_ex(json_curve, &err, 0, "{ s: s, s: s, s?: b }",
 			"public_key", &public_key,
 			"secret_key", &secret_key,
 			"enabled", &z->curve.enabled
diff --git a/lib/super_node.c b/lib/super_node.c
index 13d262172..7bc8b1926 100644
--- a/lib/super_node.c
+++ b/lib/super_node.c
@@ -106,7 +106,7 @@ int super_node_parse_uri(struct super_node *sn, const char *uri)
 			int ret;
 
 			config_t cfg;
-			config_setting_t *cfg_root = NULL;
+			config_setting_t *json_root = NULL;
 
 			warn("Failed to parse JSON configuration. Re-trying with old libconfig format.");
 			{ INDENT
@@ -140,9 +140,9 @@ int super_node_parse_uri(struct super_node *sn, const char *uri)
 				error("Failed to parse configuration");
 			}
 
-			cfg_root = config_root_setting(&cfg);
+			json_root = config_root_setting(&cfg);
 
-			sn->cfg = config_to_json(cfg_root);
+			sn->cfg = config_to_json(json_root);
 			if (sn->cfg == NULL)
 				error("Failed to convert JSON to configuration file");
 
@@ -177,20 +177,20 @@ int super_node_parse_json(struct super_node *sn, json_t *cfg)
 	assert(sn->state != STATE_STARTED);
 	assert(sn->state != STATE_DESTROYED);
 
-	json_t *cfg_nodes = NULL;
-	json_t *cfg_paths = NULL;
-	json_t *cfg_plugins = NULL;
-	json_t *cfg_logging = NULL;
-	json_t *cfg_web = NULL;
+	json_t *json_nodes = NULL;
+	json_t *json_paths = NULL;
+	json_t *json_plugins = NULL;
+	json_t *json_logging = NULL;
+	json_t *json_web = NULL;
 
 	json_error_t err;
 
 	ret = json_unpack_ex(cfg, &err, 0, "{ s?: o, s?: o, s?: o, s?: o, s?: o, s?: i, s?: i, s?: i, s?: F, s?: s }",
-		"http", &cfg_web,
-		"logging", &cfg_logging,
-		"plugins", &cfg_plugins,
-		"nodes", &cfg_nodes,
-		"paths", &cfg_paths,
+		"http", &json_web,
+		"logging", &json_logging,
+		"plugins", &json_plugins,
+		"nodes", &json_nodes,
+		"paths", &json_paths,
 		"hugepages", &sn->hugepages,
 		"affinity", &sn->affinity,
 		"priority", &sn->priority,
@@ -204,28 +204,28 @@ int super_node_parse_json(struct super_node *sn, json_t *cfg)
 		strncpy(sn->name, name, 128);
 
 #ifdef WITH_WEB
-	if (cfg_web)
-		web_parse(&sn->web, cfg_web);
+	if (json_web)
+		web_parse(&sn->web, json_web);
 #endif /* WITH_WEB */
 
-	if (cfg_logging)
-		log_parse(&sn->log, cfg_logging);
+	if (json_logging)
+		log_parse(&sn->log, json_logging);
 
 	/* Parse plugins */
-	if (cfg_plugins) {
-		if (!json_is_array(cfg_plugins))
+	if (json_plugins) {
+		if (!json_is_array(json_plugins))
 			error("Setting 'plugins' must be a list of strings");
 
 		size_t index;
-		json_t *cfg_plugin;
-		json_array_foreach(cfg_plugins, index, cfg_plugin) {
+		json_t *json_plugin;
+		json_array_foreach(json_plugins, index, json_plugin) {
 			struct plugin *p = alloc(sizeof(struct plugin));
 
 			ret = plugin_init(p);
 			if (ret)
 				error("Failed to initialize plugin");
 
-			ret = plugin_parse(p, cfg_plugin);
+			ret = plugin_parse(p, json_plugin);
 			if (ret)
 				error("Failed to parse plugin");
 
@@ -234,17 +234,17 @@ int super_node_parse_json(struct super_node *sn, json_t *cfg)
 	}
 
 	/* Parse nodes */
-	if (cfg_nodes) {
-		if (!json_is_object(cfg_nodes))
+	if (json_nodes) {
+		if (!json_is_object(json_nodes))
 			error("Setting 'nodes' must be a group with node name => group mappings.");
 
 		const char *name;
-		json_t *cfg_node;
-		json_object_foreach(cfg_nodes, name, cfg_node) {
+		json_t *json_node;
+		json_object_foreach(json_nodes, name, json_node) {
 			struct plugin *p;
 			const char *type;
 
-			ret = json_unpack_ex(cfg_node, &err, 0, "{ s: s }", "type", &type);
+			ret = json_unpack_ex(json_node, &err, 0, "{ s: s }", "type", &type);
 			if (ret)
 				jerror(&err, "Failed to parse node");
 
@@ -258,7 +258,7 @@ int super_node_parse_json(struct super_node *sn, json_t *cfg)
 			if (ret)
 				error("Failed to initialize node");
 
-			ret = node_parse(n, cfg_node, name);
+			ret = node_parse(n, json_node, name);
 			if (ret)
 				error("Failed to parse node");
 
@@ -267,20 +267,20 @@ int super_node_parse_json(struct super_node *sn, json_t *cfg)
 	}
 
 	/* Parse paths */
-	if (cfg_paths) {
-		if (!json_is_array(cfg_paths))
+	if (json_paths) {
+		if (!json_is_array(json_paths))
 			warn("Setting 'paths' must be a list.");
 
 		size_t index;
-		json_t *cfg_path;
-		json_array_foreach(cfg_paths, index, cfg_path) {
+		json_t *json_path;
+		json_array_foreach(json_paths, index, json_path) {
 			struct path *p = alloc(sizeof(struct path));
 
 			ret = path_init(p);
 			if (ret)
 				error("Failed to initialize path");
 
-			ret = path_parse(p, cfg_path, &sn->nodes);
+			ret = path_parse(p, json_path, &sn->nodes);
 			if (ret)
 				error("Failed to parse path");