diff --git a/lib/fpga/card.c b/lib/fpga/card.c
index 4a504f0c4..832214cb1 100644
--- a/lib/fpga/card.c
+++ b/lib/fpga/card.c
@@ -100,10 +100,9 @@ int fpga_card_parse(struct fpga_card *c, config_setting_t *cfg)
 		const char *vlnv;
 
 		struct fpga_ip_type *vt;
-		struct fpga_ip ip = {
-			.card = c,
-			.state = STATE_DESTROYED
-		};
+		struct fpga_ip *ip = alloc(sizeof(struct fpga_ip));
+		
+		ip->card = c;
 
 		if (!config_setting_lookup_string(cfg, "vlnv", &vlnv))
 			cerror(cfg, "FPGA IP core %s is missing the VLNV identifier", c->name);
@@ -112,15 +111,15 @@ int fpga_card_parse(struct fpga_card *c, config_setting_t *cfg)
 		if (!vt)
 			cerror(cfg, "FPGA IP core VLNV identifier '%s' is invalid", vlnv);
 
-		ret = fpga_ip_init(&ip, vt);
+		ret = fpga_ip_init(ip, vt);
 		if (ret)
 			error("Failed to initalize FPGA IP core");
 
-		ret = fpga_ip_parse(&ip, cfg_ip);
+		ret = fpga_ip_parse(ip, cfg_ip);
 		if (ret)
 			cerror(cfg_ip, "Failed to parse FPGA IP core");
 
-		list_push(&c->ips, memdup(&ip, sizeof(ip)));
+		list_push(&c->ips, ip);
 	}
 
 	c->cfg = cfg;
@@ -139,13 +138,13 @@ int fpga_card_parse_list(struct list *cards, config_setting_t *cfg)
 	for (int i = 0; i < config_setting_length(cfg); i++) {
 		config_setting_t *cfg_fpga = config_setting_get_elem(cfg, i);
 
-		struct fpga_card c;
+		struct fpga_card *c = alloc(sizeof(struct fpga_card));
 
-		ret = fpga_card_parse(&c, cfg_fpga);
+		ret = fpga_card_parse(c, cfg_fpga);
 		if (ret)
 			cerror(cfg_fpga, "Failed to parse FPGA card configuration");
 
-		list_push(cards, memdup(&c, sizeof(c)));
+		list_push(cards, c);
 	}
 
 	return 0;
diff --git a/lib/fpga/ips/model.c b/lib/fpga/ips/model.c
index 4567dd803..9214cfb22 100644
--- a/lib/fpga/ips/model.c
+++ b/lib/fpga/ips/model.c
@@ -47,7 +47,6 @@ static int model_xsg_map_parse(uint32_t *map, size_t len, struct list *parameter
 {
 #define copy_string(off) strndup((char *) (data + (off)), (length - (off)) * 4);
 	int j;
-	struct model_param p, *e;
 	struct model_info *i;
 
 	/* Check magic */
@@ -64,21 +63,21 @@ static int model_xsg_map_parse(uint32_t *map, size_t len, struct list *parameter
 			case XSG_BLOCK_GATEWAY_OUT:
 				if (length < 4)
 					break; /* block is to small to describe a gateway */
+				
+				struct model_param *e, *p = alloc(sizeof(struct model_param));
 
-				memset(&p, 0, sizeof(p));
+				p->name          =  copy_string(3);
+				p->default_value.flt =  *((float *) &data[1]);
+				p->offset        = data[2];
+				p->direction     = type & 0x1;
+				p->type          = (data[0] >> 0) & 0xFF;
+				p->binpt         = (data[0] >> 8) & 0xFF;
 
-				p.name          =  copy_string(3);
-				p.default_value.flt =  *((float *) &data[1]);
-				p.offset        = data[2];
-				p.direction     = type & 0x1;
-				p.type          = (data[0] >> 0) & 0xFF;
-				p.binpt         = (data[0] >> 8) & 0xFF;
-
-				e = list_lookup(parameters, p.name);
+				e = list_lookup(parameters, p->name);
 				if (e)
-					model_param_update(e, &p);
+					model_param_update(e, p);
 				else
-					list_push(parameters, memdup(&p, sizeof(p)));
+					list_push(parameters, p);
 				break;
 
 			case XSG_BLOCK_INFO:
@@ -137,7 +136,6 @@ static int model_xsg_map_read(uint32_t *map, size_t len, void *baseaddr)
 int model_parse(struct fpga_ip *c)
 {
 	struct model *m = c->_vd;
-	struct model_param p;
 
 	config_setting_t *cfg_params, *cfg_param;
 
@@ -153,12 +151,12 @@ int model_parse(struct fpga_ip *c)
 		for (int i = 0; i < config_setting_length(cfg_params); i++) {
 			cfg_param = config_setting_get_elem(cfg_params, i);
 
-			memset(&p, 0, sizeof(p));
+			struct model_param *p = alloc(sizeof(struct model_param));
 
-			p.name = config_setting_name(cfg_param);
-			p.default_value.flt = config_setting_get_float(cfg_param);
+			p->name = config_setting_name(cfg_param);
+			p->default_value.flt = config_setting_get_float(cfg_param);
 
-			list_push(&m->parameters, memdup(&p, sizeof(p)));
+			list_push(&m->parameters, p);
 		}
 	}
 
diff --git a/lib/fpga/ips/switch.c b/lib/fpga/ips/switch.c
index 20d6c370d..65dfb43ad 100644
--- a/lib/fpga/ips/switch.c
+++ b/lib/fpga/ips/switch.c
@@ -107,33 +107,34 @@ int switch_parse(struct fpga_ip *c)
 	for (int i = 0; i < config_setting_length(cfg_sw); i++) {
 		cfg_path = config_setting_get_elem(cfg_sw, i);
 
-		struct sw_path path;
+		struct sw_path *p = alloc(sizeof(struct sw_path));
 		int reverse;
 
 		if (!config_setting_lookup_bool(cfg_path, "reverse", &reverse))
 			reverse = 0;
 
-		if (!config_setting_lookup_string(cfg_path, "in", &path.in) &&
-		    !config_setting_lookup_string(cfg_path, "from", &path.in) &&
-		    !config_setting_lookup_string(cfg_path, "src", &path.in) &&
-		    !config_setting_lookup_string(cfg_path, "source", &path.in))
+		if (!config_setting_lookup_string(cfg_path, "in", &p->in) &&
+		    !config_setting_lookup_string(cfg_path, "from", &p->in) &&
+		    !config_setting_lookup_string(cfg_path, "src", &p->in) &&
+		    !config_setting_lookup_string(cfg_path, "source", &p->in))
 			cerror(cfg_path, "Path is missing 'in' setting");
 
-		if (!config_setting_lookup_string(cfg_path, "out", &path.out) &&
-		    !config_setting_lookup_string(cfg_path, "to", &path.out) &&
-		    !config_setting_lookup_string(cfg_path, "dst", &path.out) &&
-		    !config_setting_lookup_string(cfg_path, "dest", &path.out) &&
-		    !config_setting_lookup_string(cfg_path, "sink", &path.out))
+		if (!config_setting_lookup_string(cfg_path, "out", &p->out) &&
+		    !config_setting_lookup_string(cfg_path, "to", &p->out) &&
+		    !config_setting_lookup_string(cfg_path, "dst", &p->out) &&
+		    !config_setting_lookup_string(cfg_path, "dest", &p->out) &&
+		    !config_setting_lookup_string(cfg_path, "sink", &p->out))
 			cerror(cfg_path, "Path is missing 'out' setting");
 
-		list_push(&sw->paths, memdup(&path, sizeof(path)));
+		list_push(&sw->paths, p);
 
 		if (reverse) {
-			const char *tmp = path.in;
-			path.in = path.out;
-			path.out = tmp;
+			struct sw_path *r = memdup(p, sizeof(struct sw_path));
+			
+			r->in = p->out;
+			r->out = p->in;
 
-			list_push(&sw->paths, memdup(&path, sizeof(path)));
+			list_push(&sw->paths, r);
 		}
 	}
 
diff --git a/lib/hook.c b/lib/hook.c
index 4461ad751..3353a6fb7 100644
--- a/lib/hook.c
+++ b/lib/hook.c
@@ -183,17 +183,17 @@ int hook_parse_list(struct list *list, config_setting_t *cfg, struct path *o)
 		if (!p)
 			continue; /* We ignore all non hook settings in this libconfig object setting */
 
-		struct hook h = { .state = STATE_DESTROYED };
-
-		ret = hook_init(&h, &p->hook, o);
+		struct hook *h = alloc(sizeof(struct hook));
+		
+		ret = hook_init(h, &p->hook, o);
 		if (ret)
 			continue;
 
-		ret = hook_parse(&h, cfg_hook);
+		ret = hook_parse(h, cfg_hook);
 		if (ret)
 			continue;
 
-		list_push(list, memdup(&h, sizeof(h)));
+		list_push(list, h);
 	}
 
 	return 0;
diff --git a/lib/kernel/pci.c b/lib/kernel/pci.c
index 8ca007587..3efa25874 100644
--- a/lib/kernel/pci.c
+++ b/lib/kernel/pci.c
@@ -18,7 +18,7 @@
 
 int pci_init(struct pci *p)
 {
-	struct dirent *entry;
+	struct dirent *e;
 	DIR *dp;
 	FILE *f;
 	char path[PATH_MAX];
@@ -32,17 +32,17 @@ int pci_init(struct pci *p)
 		return -1;
 	}
 
-	while ((entry = readdir(dp))) {
-		struct pci_device d;
+	while ((e = readdir(dp))) {
+		struct pci_device *d = alloc(sizeof(struct pci_device));
 
 		struct { const char *s; int *p; } map[] = {
-			{ "vendor", &d.id.vendor },
-			{ "device", &d.id.device }
+			{ "vendor", &d->id.vendor },
+			{ "device", &d->id.device }
 		};
 
 		/* Read vendor & device id */
 		for (int i = 0; i < 2; i++) {
-			snprintf(path, sizeof(path), "%s/bus/pci/devices/%s/%s", SYSFS_PATH, entry->d_name, map[i].s);
+			snprintf(path, sizeof(path), "%s/bus/pci/devices/%s/%s", SYSFS_PATH, e->d_name, map[i].s);
 
 			f = fopen(path, "r");
 			if (!f)
@@ -56,11 +56,11 @@ int pci_init(struct pci *p)
 		}
 
 		/* Get slot id */
-		ret = sscanf(entry->d_name, "%4x:%2x:%2x.%u", &d.slot.domain, &d.slot.bus, &d.slot.device, &d.slot.function);
+		ret = sscanf(e->d_name, "%4x:%2x:%2x.%u", &d->slot.domain, &d->slot.bus, &d->slot.device, &d->slot.function);
 		if (ret != 4)
-			error("Failed to parse PCI slot number: %s", entry->d_name);
+			error("Failed to parse PCI slot number: %s", e->d_name);
 
-		list_push(&p->devices, memdup(&d, sizeof(d)));
+		list_push(&p->devices, d);
 	}
 
 	closedir(dp);
diff --git a/lib/mapping.c b/lib/mapping.c
index 8dcc7280c..823459077 100644
--- a/lib/mapping.c
+++ b/lib/mapping.c
@@ -204,20 +204,21 @@ int mapping_parse(struct mapping *m, config_setting_t *cfg)
 	m->real_length = 0;
 
 	for (int i = 0; i < config_setting_length(cfg); i++) {
-		struct mapping_entry e;
 		config_setting_t *cfg_mapping;
 
 		cfg_mapping = config_setting_get_elem(cfg, i);
 		if (!cfg_mapping)
 			return -1;
 
-		ret = mapping_entry_parse(&e, cfg_mapping);
+		struct mapping_entry *e = alloc(sizeof(struct mapping_entry));
+
+		ret = mapping_entry_parse(e, cfg_mapping);
 		if (ret)
 			return ret;
 
-		list_push(&m->entries, memdup(&e, sizeof(e)));
+		list_push(&m->entries, e);
 
-		m->real_length += e.length;
+		m->real_length += e->length;
 	}
 
 	m->state = STATE_PARSED;
diff --git a/lib/nodes/ngsi.c b/lib/nodes/ngsi.c
index 3799724bf..e642c7f27 100644
--- a/lib/nodes/ngsi.c
+++ b/lib/nodes/ngsi.c
@@ -204,48 +204,49 @@ static int ngsi_parse_mapping(struct list *mapping, config_setting_t *cfg)
 
 	list_init(mapping);
 
-	for (int j = 0; j < config_setting_length(cfg); j++) { INDENT
+	for (int j = 0; j < config_setting_length(cfg); j++) {
 		const char *token = config_setting_get_string_elem(cfg, j);
 		if (!token)
 			return -2;
 
-		struct ngsi_attribute map = {
-			.index = j
-		};
+		struct ngsi_attribute *a = alloc(sizeof(struct ngsi_attribute));
+
+		a->index = j;
 
 		/* Parse Attribute: AttributeName(AttributeType) */
 		int bytes;
-		if (sscanf(token, "%m[^(](%m[^)])%n", &map.name, &map.type, &bytes) != 2)
+		if (sscanf(token, "%m[^(](%m[^)])%n", &a->name, &a->type, &bytes) != 2)
 			cerror(cfg, "Invalid mapping token: '%s'", token);
 
 		token += bytes;
 
 		/* MetadataName(MetadataType)=MetadataValue */
-		list_init(&map.metadata);
-		struct ngsi_metadata meta;
-		while (sscanf(token, " %m[^(](%m[^)])=%ms%n", &meta.name, &meta.type, &meta.value, &bytes) == 3) { INDENT
-			list_push(&map.metadata, memdup(&meta, sizeof(meta)));
+		list_init(&a->metadata);
+		
+		struct ngsi_metadata m;
+		while (sscanf(token, " %m[^(](%m[^)])=%ms%n", &m.name, &m.type, &m.value, &bytes) == 3) {
+			list_push(&a->metadata, memdup(&m, sizeof(m)));
 			token += bytes;
 		}
 
-		/* Static metadata */
-		struct ngsi_metadata source = {
+		/* Metadata: source(string)=name */
+		struct ngsi_metadata s = {
 			.name = "source",
 			.type = "string",
-			.value = name,
+			.value = name
 		};
 
-		struct ngsi_metadata index = {
+		/* Metadata: index(integer)=j */
+		struct ngsi_metadata i = {
 			.name = "index",
-			.type = "integer",
-			.value = alloc(11)
+			.type = "integer"
 		};
-		snprintf(index.value, 11, "%u", j);
+		asprintf(&i.value, "%u", j);
 
-		list_push(&map.metadata, memdup(&index, sizeof(index)));
-		list_push(&map.metadata, memdup(&source, sizeof(source)));
+		list_push(&a->metadata, memdup(&s, sizeof(s)));
+		list_push(&a->metadata, memdup(&i, sizeof(i)));
 
-		list_push(mapping, memdup(&map, sizeof(map)));
+		list_push(mapping, a);
 	}
 
 	return 0;
diff --git a/lib/nodes/socket.c b/lib/nodes/socket.c
index 8dfef86c9..2872edc39 100644
--- a/lib/nodes/socket.c
+++ b/lib/nodes/socket.c
@@ -78,13 +78,12 @@ int socket_init(struct super_node *sn)
 		}
 
 		/* If not found, create a new interface */
-		struct interface j = { .sockets.state = STATE_DESTROYED };
+		i = alloc(sizeof(struct interface));
 
-		ret = if_init(&j, link);
+		ret = if_init(i, link);
 		if (ret)
 			continue;
 
-		i = memdup(&j, sizeof(j));
 		list_push(&interfaces, i);
 
 found:		list_push(&i->sockets, s);
diff --git a/lib/nodes/websocket.c b/lib/nodes/websocket.c
index 44bb11227..6e7547ae7 100644
--- a/lib/nodes/websocket.c
+++ b/lib/nodes/websocket.c
@@ -533,28 +533,26 @@ int websocket_parse(struct node *n, config_setting_t *cfg)
 			if (!uri)
 				cerror(cfg_dests, "The 'destinations' setting must be an array of URLs");
 
-			struct websocket_destination d;
+			struct websocket_destination *d = alloc(sizeof(struct websocket_destination));
 
-			memset(&d, 0, sizeof(d));
-
-			d.uri = strdup(uri);
-			if (!d.uri)
+			d->uri = strdup(uri);
+			if (!d->uri)
 				serror("Failed to allocate memory");
 
-			ret = lws_parse_uri(d.uri, &prot, &ads, &d.info.port, &path);
+			ret = lws_parse_uri(d->uri, &prot, &ads, &d->info.port, &path);
 			if (ret)
 				cerror(cfg_dests, "Failed to parse websocket URI: '%s'", uri);
 
-			d.info.ssl_connection = !strcmp(prot, "https");
-			d.info.address = strdup(ads);
-			d.info.host    = d.info.address;
-			d.info.origin  = d.info.address;
-			d.info.ietf_version_or_minus_one = -1;
-			d.info.protocol = "live";
+			d->info.ssl_connection = !strcmp(prot, "https");
+			d->info.address = strdup(ads);
+			d->info.host    = d->info.address;
+			d->info.origin  = d->info.address;
+			d->info.ietf_version_or_minus_one = -1;
+			d->info.protocol = "live";
 
-			ret = asprintf((char **) &d.info.path, "/%s", path);
+			ret = asprintf((char **) &d->info.path, "/%s", path);
 
-			list_push(&w->destinations, memdup(&d, sizeof(d)));
+			list_push(&w->destinations, d);
 		}
 	}
 
diff --git a/lib/path.c b/lib/path.c
index 1aba62ea9..948935ce6 100644
--- a/lib/path.c
+++ b/lib/path.c
@@ -243,12 +243,12 @@ int path_parse(struct path *p, config_setting_t *cfg, struct list *nodes)
 	for (size_t i = 0; i < list_length(&destinations); i++) {
 		struct node *n = list_at(&destinations, i);
 
-		struct path_destination pd = {
-			.node = n,
-			.queuelen = p->queuelen
-		};
+		struct path_destination *pd = alloc(sizeof(struct path_destination));
+		
+		pd->node = n;
+		pd->queuelen = p->queuelen;
 
-		list_push(&p->destinations, memdup(&pd, sizeof(pd)));
+		list_push(&p->destinations, pd);
 	}
 
 	list_destroy(&destinations, NULL, false);
@@ -286,15 +286,18 @@ int path_init2(struct path *p)
 		struct plugin *q = list_at(&plugins, i);
 
 		if (q->type == PLUGIN_TYPE_HOOK) {
-			struct hook h = { .state = STATE_DESTROYED };
 			struct hook_type *vt = &q->hook;
 
 			if (vt->builtin) {
-				ret = hook_init(&h, vt, p);
-				if (ret)
+				struct hook *h = alloc(sizeof(struct hook));
+				
+				ret = hook_init(h, vt, p);
+				if (ret) {
+					free(h);
 					return ret;
+				}
 
-				list_push(&p->hooks, memdup(&h, sizeof(h)));
+				list_push(&p->hooks, h);
 			}
 		}
 	}
@@ -461,13 +464,13 @@ int path_reverse(struct path *p, struct path *r)
 
 	for (size_t i = 0; i < list_length(&p->hooks); i++) {
 		struct hook *h = list_at(&p->hooks, i);
-		struct hook hc = { .state = STATE_DESTROYED };
+		struct hook *g = alloc(sizeof(struct hook));
 
-		ret = hook_init(&hc, h->_vt, p);
+		ret = hook_init(g, h->_vt, r);
 		if (ret)
 			return ret;
 
-		list_push(&r->hooks, memdup(&hc, sizeof(hc)));
+		list_push(&r->hooks, g);
 	}
 
 	return 0;
diff --git a/lib/super_node.c b/lib/super_node.c
index 519641b38..a47f6f371 100644
--- a/lib/super_node.c
+++ b/lib/super_node.c
@@ -213,17 +213,17 @@ int super_node_parse(struct super_node *sn, config_setting_t *cfg)
 		for (int i = 0; i < config_setting_length(cfg_plugins); i++) {
 			struct config_setting_t *cfg_plugin = config_setting_get_elem(cfg_plugins, i);
 
-			struct plugin plugin = { .state = STATE_DESTROYED };
+			struct plugin *p = alloc(sizeof(struct plugin));
 
-			ret = plugin_init(&plugin);
+			ret = plugin_init(p);
 			if (ret)
 				cerror(cfg_plugin, "Failed to initialize plugin");
 
-			ret = plugin_parse(&plugin, cfg_plugin);
+			ret = plugin_parse(p, cfg_plugin);
 			if (ret)
 				cerror(cfg_plugin, "Failed to parse plugin");
 
-			list_push(&sn->plugins, memdup(&plugin, sizeof(plugin)));
+			list_push(&sn->plugins, p);
 		}
 	}
 
@@ -272,30 +272,30 @@ int super_node_parse(struct super_node *sn, config_setting_t *cfg)
 		for (int i = 0; i < config_setting_length(cfg_paths); i++) {
 			config_setting_t *cfg_path = config_setting_get_elem(cfg_paths, i);
 
-			struct path p = { .state = STATE_DESTROYED };
+			struct path *p = alloc(sizeof(struct path));
 
-			ret = path_init(&p, sn);
+			ret = path_init(p, sn);
 			if (ret)
 				cerror(cfg_path, "Failed to init path");
 
-			ret = path_parse(&p, cfg_path, &sn->nodes);
+			ret = path_parse(p, cfg_path, &sn->nodes);
 			if (ret)
 				cerror(cfg_path, "Failed to parse path");
 
-			list_push(&sn->paths, memdup(&p, sizeof(p)));
+			list_push(&sn->paths, p);
 
-			if (p.reverse) {
-				struct path r = { .state = STATE_DESTROYED };
+			if (p->reverse) {
+				struct path *r = alloc(sizeof(struct path));
 
-				ret = path_init(&r, sn);
+				ret = path_init(r, sn);
 				if (ret)
 					cerror(cfg_path, "Failed to init path");
 
-				ret = path_reverse(&p, &r);
+				ret = path_reverse(p, r);
 				if (ret)
-					cerror(cfg_path, "Failed to reverse path %s", path_name(&p));
+					cerror(cfg_path, "Failed to reverse path %s", path_name(p));
 
-				list_push(&sn->paths, memdup(&r, sizeof(p)));
+				list_push(&sn->paths, r);
 			}
 		}
 	}