From: Guus Sliepen <guus@sliepen.org>
Date: Mon, 21 Apr 2014 18:55:14 +0000 (+0200)
Subject: Move myself to mesh->self.
X-Git-Url: https://git.meshlink.io/?a=commitdiff_plain;h=1e08f518b26db292ad81ce44fc0df06f4df3a869;p=meshlink

Move myself to mesh->self.
---

diff --git a/src/graph.c b/src/graph.c
index 233cf544..43e526b0 100644
--- a/src/graph.c
+++ b/src/graph.c
@@ -48,6 +48,7 @@
 #include "graph.h"
 #include "list.h"
 #include "logger.h"
+#include "meshlink_internal.h"
 #include "netutl.h"
 #include "node.h"
 #include "protocol.h"
@@ -125,15 +126,15 @@ static void sssp_bfs(void) {
 		n->distance = -1;
 	}
 
-	/* Begin with myself */
+	/* Begin with mesh->self */
 
-	myself->status.visited = true;
-	myself->status.indirect = false;
-	myself->nexthop = myself;
-	myself->prevedge = NULL;
-	myself->via = myself;
-	myself->distance = 0;
-	list_insert_head(todo_list, myself);
+	mesh->self->status.visited = true;
+	mesh->self->status.indirect = false;
+	mesh->self->nexthop = mesh->self;
+	mesh->self->prevedge = NULL;
+	mesh->self->via = mesh->self;
+	mesh->self->distance = 0;
+	list_insert_head(todo_list, mesh->self);
 
 	/* Loop while todo_list is filled */
 
@@ -173,7 +174,7 @@ static void sssp_bfs(void) {
 
 			e->to->status.visited = true;
 			e->to->status.indirect = indirect;
-			e->to->nexthop = (n->nexthop == myself) ? e->to : n->nexthop;
+			e->to->nexthop = (n->nexthop == mesh->self) ? e->to : n->nexthop;
 			e->to->prevedge = e;
 			e->to->via = indirect ? n->via : e->to;
 			e->to->options = e->options;
diff --git a/src/libmeshlink.c b/src/libmeshlink.c
index f85f32e8..cd9e8a74 100644
--- a/src/libmeshlink.c
+++ b/src/libmeshlink.c
@@ -421,14 +421,14 @@ bool tinc_send_packet(node_t *receiver, const char* buf, unsigned int len) {
 	packet.probe = false;
 	memset(hdr, 0, sizeof *hdr);
 	memcpy(hdr->destination,receiver->name,sizeof(hdr->destination));
-	memcpy(hdr->source,myself->name,sizeof(hdr->source));
+	memcpy(hdr->source,mesh->self->name,sizeof(hdr->source));
 
 	packet.len = sizeof(tincpackethdr) + len;
 	memcpy(packet.data+sizeof(tincpackethdr),buf,len);
 
-        myself->in_packets++;
-        myself->in_bytes += packet.len;
-        route(myself, &packet);
+        mesh->self->in_packets++;
+        mesh->self->in_bytes += packet.len;
+        route(mesh->self, &packet);
 
 return true;
 }
diff --git a/src/net.c b/src/net.c
index 87deb97b..4cae25c1 100644
--- a/src/net.c
+++ b/src/net.c
@@ -24,6 +24,7 @@
 #include "connection.h"
 #include "graph.h"
 #include "logger.h"
+#include "meshlink_internal.h"
 #include "meta.h"
 #include "net.h"
 #include "netutl.h"
@@ -100,7 +101,7 @@ void terminate_connection(connection_t *c, bool report) {
 
 		if(report && !c->node->status.reachable) {
 			edge_t *e;
-			e = lookup_edge(c->node, myself);
+			e = lookup_edge(c->node, mesh->self);
 			if(e) {
 				send_del_edge(everyone, e);
 				edge_del(e);
@@ -290,7 +291,7 @@ int reload_configuration(void) {
 		return EINVAL;
 	}
 
-	xasprintf(&fname, "%s" SLASH "hosts" SLASH "%s", confbase, myself->name);
+	xasprintf(&fname, "%s" SLASH "hosts" SLASH "%s", confbase, mesh->self->name);
 	read_config_file(config_tree, fname);
 	free(fname);
 
diff --git a/src/net_packet.c b/src/net_packet.c
index 41e2521d..7457b3bd 100644
--- a/src/net_packet.c
+++ b/src/net_packet.c
@@ -30,6 +30,7 @@
 #include "digest.h"
 #include "graph.h"
 #include "logger.h"
+#include "meshlink_internal.h"
 #include "net.h"
 #include "netutl.h"
 #include "protocol.h"
@@ -462,16 +463,16 @@ bool send_sptps_data(void *handle, uint8_t type, const char *data, size_t len) {
 
 	/* Send it via TCP if it is a handshake packet, TCPOnly is in use, or this packet is larger than the MTU. */
 
-	if(type >= SPTPS_HANDSHAKE || ((myself->options | to->options) & OPTION_TCPONLY) || (type != PKT_PROBE && len > to->minmtu)) {
+	if(type >= SPTPS_HANDSHAKE || ((mesh->self->options | to->options) & OPTION_TCPONLY) || (type != PKT_PROBE && len > to->minmtu)) {
 		char buf[len * 4 / 3 + 5];
 		b64encode(data, buf, len);
 		/* If no valid key is known yet, send the packets using ANS_KEY requests,
 		   to ensure we get to learn the reflexive UDP address. */
 		if(!to->status.validkey) {
-			to->incompression = myself->incompression;
-			return send_request(to->nexthop->connection, "%d %s %s %s -1 -1 -1 %d", ANS_KEY, myself->name, to->name, buf, to->incompression);
+			to->incompression = mesh->self->incompression;
+			return send_request(to->nexthop->connection, "%d %s %s %s -1 -1 -1 %d", ANS_KEY, mesh->self->name, to->name, buf, to->incompression);
 		} else {
-			return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, myself->name, to->name, REQ_SPTPS, buf);
+			return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, mesh->self->name, to->name, REQ_SPTPS, buf);
 		}
 	}
 
@@ -558,7 +559,7 @@ bool receive_sptps_record(void *handle, uint8_t type, const char *data, uint16_t
 void send_packet(node_t *n, vpn_packet_t *packet) {
 	node_t *via;
 
-	if(n == myself) {
+	if(n == mesh->self) {
 		n->out_packets++;
 		n->out_bytes += packet->len;
 		// TODO: send to application
@@ -585,8 +586,8 @@ void send_packet(node_t *n, vpn_packet_t *packet) {
 
 void broadcast_packet(const node_t *from, vpn_packet_t *packet) {
 	// Always give ourself a copy of the packet.
-	if(from != myself)
-		send_packet(myself, packet);
+	if(from != mesh->self)
+		send_packet(mesh->self, packet);
 
 	logger(DEBUG_TRAFFIC, LOG_INFO, "Broadcasting packet of %d bytes from %s (%s)",
 			   packet->len, from->name, from->hostname);
@@ -602,7 +603,7 @@ static node_t *try_harder(const sockaddr_t *from, const vpn_packet_t *pkt) {
 	static time_t last_hard_try = 0;
 
 	for splay_each(edge_t, e, edge_weight_tree) {
-		if(!e->to->status.reachable || e->to == myself)
+		if(!e->to->status.reachable || e->to == mesh->self)
 			continue;
 
 		if(sockaddrcmp_noport(from, &e->address)) {
diff --git a/src/net_setup.c b/src/net_setup.c
index 2cc7ddf5..63f02753 100644
--- a/src/net_setup.c
+++ b/src/net_setup.c
@@ -26,6 +26,7 @@
 #include "ecdsa.h"
 #include "graph.h"
 #include "logger.h"
+#include "meshlink_internal.h"
 #include "net.h"
 #include "netutl.h"
 #include "protocol.h"
@@ -102,13 +103,13 @@ static bool read_ecdsa_private_key(void) {
 		return false;
 	}
 
-	myself->connection->ecdsa = ecdsa_read_pem_private_key(fp);
+	mesh->self->connection->ecdsa = ecdsa_read_pem_private_key(fp);
 	fclose(fp);
 
-	if(!myself->connection->ecdsa)
+	if(!mesh->self->connection->ecdsa)
 		logger(DEBUG_ALWAYS, LOG_ERR, "Reading ECDSA private key file failed: %s", strerror(errno));
 
-	return myself->connection->ecdsa;
+	return mesh->self->connection->ecdsa;
 }
 
 static bool read_invitation_key(void) {
@@ -186,7 +187,7 @@ char *get_name(void) {
 		return NULL;
 
 	if(!check_id(name)) {
-		logger(DEBUG_ALWAYS, LOG_ERR, "Invalid name for myself!");
+		logger(DEBUG_ALWAYS, LOG_ERR, "Invalid name for mesh->self!");
 		free(name);
 		return NULL;
 	}
@@ -199,7 +200,7 @@ bool setup_myself_reloadable(void) {
 	keylifetime = 3600; // TODO: check if this can be removed as well
 	maxtimeout = 900;
 	autoconnect = 3;
-	myself->options |= OPTION_PMTU_DISCOVERY;
+	mesh->self->options |= OPTION_PMTU_DISCOVERY;
 
 	read_invitation_key();
 
@@ -286,7 +287,7 @@ static bool add_listen_address(char *address, bool bindto) {
 }
 
 /*
-  Configure node_t myself and set up the local sockets (listen only)
+  Configure node_t mesh->self and set up the local sockets (listen only)
 */
 bool setup_myself(void) {
 	char *name, *hostname, *cipher, *digest, *type;
@@ -298,10 +299,10 @@ bool setup_myself(void) {
 		return false;
 	}
 
-	myself = new_node();
-	myself->connection = new_connection();
-	myself->name = name;
-	myself->connection->name = xstrdup(name);
+	mesh->self = new_node();
+	mesh->self->connection = new_connection();
+	mesh->self->name = name;
+	mesh->self->connection->name = xstrdup(name);
 	read_host_config(config_tree, name);
 
 	if(!get_config_string(lookup_config(config_tree, "Port"), &myport))
@@ -309,11 +310,11 @@ bool setup_myself(void) {
 	else
 		port_specified = true;
 
-	myself->connection->options = 0;
-	myself->connection->protocol_major = PROT_MAJOR;
-	myself->connection->protocol_minor = PROT_MINOR;
+	mesh->self->connection->options = 0;
+	mesh->self->connection->protocol_major = PROT_MAJOR;
+	mesh->self->connection->protocol_minor = PROT_MINOR;
 
-	myself->options |= PROT_MINOR << 24;
+	mesh->self->options |= PROT_MINOR << 24;
 
 	if(!read_ecdsa_private_key())
 		return false;
@@ -341,16 +342,16 @@ bool setup_myself(void) {
 	/* Compression */
 
 	// TODO: drop compression in the packet layer?
-	myself->incompression = 0;
-	myself->connection->outcompression = 0;
+	mesh->self->incompression = 0;
+	mesh->self->connection->outcompression = 0;
 
 	/* Done */
 
-	myself->nexthop = myself;
-	myself->via = myself;
-	myself->status.reachable = true;
-	myself->last_state_change = now.tv_sec;
-	node_add(myself);
+	mesh->self->nexthop = mesh->self;
+	mesh->self->via = mesh->self;
+	mesh->self->status.reachable = true;
+	mesh->self->last_state_change = now.tv_sec;
+	node_add(mesh->self);
 
 	graph();
 
@@ -375,8 +376,8 @@ bool setup_myself(void) {
 	if(!myport)
 		myport = xstrdup("655");
 
-	xasprintf(&myself->hostname, "MYSELF port %s", myport);
-	myself->connection->hostname = xstrdup(myself->hostname);
+	xasprintf(&mesh->self->hostname, "MYSELF port %s", myport);
+	mesh->self->connection->hostname = xstrdup(mesh->self->hostname);
 
 	/* Done. */
 
@@ -418,9 +419,9 @@ void close_network_connections(void) {
 	if(outgoing_list)
 		list_delete_list(outgoing_list);
 
-	if(myself && myself->connection) {
-		terminate_connection(myself->connection, false);
-		free_connection(myself->connection);
+	if(mesh->self && mesh->self->connection) {
+		terminate_connection(mesh->self->connection, false);
+		free_connection(mesh->self->connection);
 	}
 
 	for(int i = 0; i < listen_sockets; i++) {
diff --git a/src/net_socket.c b/src/net_socket.c
index 0b1e1fb6..60f4de1d 100644
--- a/src/net_socket.c
+++ b/src/net_socket.c
@@ -23,6 +23,7 @@
 #include "connection.h"
 #include "list.h"
 #include "logger.h"
+#include "meshlink_internal.h"
 #include "meta.h"
 #include "net.h"
 #include "netutl.h"
@@ -198,12 +199,12 @@ int setup_vpn_in_socket(const sockaddr_t *sa) {
 #endif
 
 #if defined(SOL_IP) && defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DO)
-	if(myself->options & OPTION_PMTU_DISCOVERY) {
+	if(mesh->self->options & OPTION_PMTU_DISCOVERY) {
 		option = IP_PMTUDISC_DO;
 		setsockopt(nfd, SOL_IP, IP_MTU_DISCOVER, (void *)&option, sizeof(option));
 	}
 #elif defined(IPPROTO_IP) && defined(IP_DONTFRAGMENT)
-	if(myself->options & OPTION_PMTU_DISCOVERY) {
+	if(mesh->self->options & OPTION_PMTU_DISCOVERY) {
 		option = 1;
 		setsockopt(nfd, IPPROTO_IP, IP_DONTFRAGMENT, (void *)&option, sizeof(option));
 	}
@@ -212,12 +213,12 @@ int setup_vpn_in_socket(const sockaddr_t *sa) {
 #endif
 
 #if defined(SOL_IPV6) && defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO)
-	if(myself->options & OPTION_PMTU_DISCOVERY) {
+	if(mesh->self->options & OPTION_PMTU_DISCOVERY) {
 		option = IPV6_PMTUDISC_DO;
 		setsockopt(nfd, SOL_IPV6, IPV6_MTU_DISCOVER, (void *)&option, sizeof(option));
 	}
 #elif defined(IPPROTO_IPV6) && defined(IPV6_DONTFRAG)
-	if(myself->options & OPTION_PMTU_DISCOVERY) {
+	if(mesh->self->options & OPTION_PMTU_DISCOVERY) {
 		option = 1;
 		setsockopt(nfd, IPPROTO_IPV6, IPV6_DONTFRAG, (void *)&option, sizeof(option));
 	}
@@ -292,7 +293,7 @@ static void do_outgoing_pipe(connection_t *c, char *command) {
 	setenv("REMOTEADDRESS", host, true);
 	setenv("REMOTEPORT", port, true);
 	setenv("NODE", c->name, true);
-	setenv("NAME", myself->name, true);
+	setenv("NAME", mesh->self->name, true);
 
 	int result = system(command);
 	if(result < 0)
@@ -463,7 +464,7 @@ begin:
 
 	c->status.connecting = true;
 	c->name = xstrdup(outgoing->name);
-	c->outcompression = myself->connection->outcompression;
+	c->outcompression = mesh->self->connection->outcompression;
 	c->last_ping_time = now.tv_sec;
 
 	connection_add(c);
@@ -607,7 +608,7 @@ void handle_new_meta_connection(void *data, int flags) {
 
 	c = new_connection();
 	c->name = xstrdup("<unknown>");
-	c->outcompression = myself->connection->outcompression;
+	c->outcompression = mesh->self->connection->outcompression;
 
 	c->address = sa;
 	c->hostname = sockaddr2hostname(&sa);
diff --git a/src/node.c b/src/node.c
index 52797054..83f4a743 100644
--- a/src/node.c
+++ b/src/node.c
@@ -21,6 +21,7 @@
 
 #include "hash.h"
 #include "logger.h"
+#include "meshlink_internal.h"
 #include "net.h"
 #include "netutl.h"
 #include "node.h"
@@ -31,8 +32,6 @@
 splay_tree_t *node_tree;
 static hash_t *node_udp_cache;
 
-node_t *myself;
-
 static int node_compare(const node_t *a, const node_t *b) {
 	return strcmp(a->name, b->name);
 }
@@ -105,8 +104,8 @@ node_t *lookup_node_udp(const sockaddr_t *sa) {
 }
 
 void update_node_udp(node_t *n, const sockaddr_t *sa) {
-	if(n == myself) {
-		logger(DEBUG_ALWAYS, LOG_WARNING, "Trying to update UDP address of myself!");
+	if(n == mesh->self) {
+		logger(DEBUG_ALWAYS, LOG_WARNING, "Trying to update UDP address of mesh->self!");
 		return;
 	}
 
diff --git a/src/node.h b/src/node.h
index 2ae82e28..a341f2bb 100644
--- a/src/node.h
+++ b/src/node.h
@@ -88,7 +88,6 @@ typedef struct node_t {
 	uint64_t out_bytes;
 } node_t;
 
-extern struct node_t *myself;
 extern struct splay_tree_t *node_tree;
 
 extern void init_nodes(void);
diff --git a/src/protocol_auth.c b/src/protocol_auth.c
index 1a79264d..14686ac9 100644
--- a/src/protocol_auth.c
+++ b/src/protocol_auth.c
@@ -28,6 +28,7 @@
 #include "edge.h"
 #include "graph.h"
 #include "logger.h"
+#include "meshlink_internal.h"
 #include "meta.h"
 #include "net.h"
 #include "netutl.h"
@@ -130,13 +131,13 @@ static bool send_proxyrequest(connection_t *c) {
 bool send_id(connection_t *c) {
 	gettimeofday(&c->start, NULL);
 
-	int minor = myself->connection->protocol_minor;
+	int minor = mesh->self->connection->protocol_minor;
 
 	if(proxytype && c->outgoing)
 		if(!send_proxyrequest(c))
 			return false;
 
-	return send_request(c, "%d %s %d.%d", ID, myself->connection->name, myself->connection->protocol_major, minor);
+	return send_request(c, "%d %s %d.%d", ID, mesh->self->connection->name, mesh->self->connection->protocol_major, minor);
 }
 
 static bool finalize_invitation(connection_t *c, const char *data, uint16_t len) {
@@ -312,7 +313,7 @@ bool id_h(connection_t *c, const char *request) {
 
 	/* Check if version matches */
 
-	if(c->protocol_major != myself->connection->protocol_major) {
+	if(c->protocol_major != mesh->self->connection->protocol_major) {
 		logger(DEBUG_ALWAYS, LOG_ERR, "Peer %s (%s) uses incompatible version %d.%d",
 			c->name, c->hostname, c->protocol_major, c->protocol_minor);
 		return false;
@@ -348,14 +349,14 @@ bool id_h(connection_t *c, const char *request) {
 	}
 
 	c->allow_request = ACK;
-	char label[25 + strlen(myself->name) + strlen(c->name)];
+	char label[25 + strlen(mesh->self->name) + strlen(c->name)];
 
 	if(c->outgoing)
-		snprintf(label, sizeof label, "tinc TCP key expansion %s %s", myself->name, c->name);
+		snprintf(label, sizeof label, "tinc TCP key expansion %s %s", mesh->self->name, c->name);
 	else
-		snprintf(label, sizeof label, "tinc TCP key expansion %s %s", c->name, myself->name);
+		snprintf(label, sizeof label, "tinc TCP key expansion %s %s", c->name, mesh->self->name);
 
-	return sptps_start(&c->sptps, c, c->outgoing, false, myself->connection->ecdsa, c->ecdsa, label, sizeof label, send_meta_sptps, receive_meta_sptps);
+	return sptps_start(&c->sptps, c, c->outgoing, false, mesh->self->connection->ecdsa, c->ecdsa, label, sizeof label, send_meta_sptps, receive_meta_sptps);
 }
 
 bool send_ack(connection_t *c) {
@@ -372,7 +373,7 @@ bool send_ack(connection_t *c) {
 
 	/* Check some options */
 
-	if(myself->options & OPTION_PMTU_DISCOVERY)
+	if(mesh->self->options & OPTION_PMTU_DISCOVERY)
 		c->options |= OPTION_PMTU_DISCOVERY;
 
 	return send_request(c, "%d %s %d %x", ACK, myport, c->estimated_weight, (c->options & 0xffffff) | (PROT_MINOR << 24));
@@ -464,7 +465,7 @@ bool ack_h(connection_t *c, const char *request) {
 	/* Create an edge_t for this connection */
 
 	c->edge = new_edge();
-	c->edge->from = myself;
+	c->edge->from = mesh->self;
 	c->edge->to = n;
 	sockaddr2str(&c->address, &hisaddress, NULL);
 	c->edge->address = str2sockaddr(hisaddress, hisport);
diff --git a/src/protocol_edge.c b/src/protocol_edge.c
index 6da3c876..ecad9c6e 100644
--- a/src/protocol_edge.c
+++ b/src/protocol_edge.c
@@ -24,6 +24,7 @@
 #include "edge.h"
 #include "graph.h"
 #include "logger.h"
+#include "meshlink_internal.h"
 #include "meta.h"
 #include "net.h"
 #include "netutl.h"
@@ -104,7 +105,7 @@ bool add_edge_h(connection_t *c, const char *request) {
 
 	if(e) {
 		if(e->weight != weight || e->options != options || sockaddrcmp(&e->address, &address)) {
-			if(from == myself) {
+			if(from == mesh->self) {
 				logger(DEBUG_PROTOCOL, LOG_WARNING, "Got %s from %s (%s) for ourself which does not match existing entry",
 						   "ADD_EDGE", c->name, c->hostname);
 				send_add_edge(c, e);
@@ -117,7 +118,7 @@ bool add_edge_h(connection_t *c, const char *request) {
 			}
 		} else
 			return true;
-	} else if(from == myself) {
+	} else if(from == mesh->self) {
 		logger(DEBUG_PROTOCOL, LOG_WARNING, "Got %s from %s (%s) for ourself which does not exist",
 				   "ADD_EDGE", c->name, c->hostname);
 		contradicting_add_edge++;
@@ -203,7 +204,7 @@ bool del_edge_h(connection_t *c, const char *request) {
 		return true;
 	}
 
-	if(e->from == myself) {
+	if(e->from == mesh->self) {
 		logger(DEBUG_PROTOCOL, LOG_WARNING, "Got %s from %s (%s) for ourself",
 				   "DEL_EDGE", c->name, c->hostname);
 		contradicting_del_edge++;
@@ -226,7 +227,7 @@ bool del_edge_h(connection_t *c, const char *request) {
 	/* If the node is not reachable anymore but we remember it had an edge to us, clean it up */
 
 	if(!to->status.reachable) {
-		e = lookup_edge(to, myself);
+		e = lookup_edge(to, mesh->self);
 		if(e) {
 			send_del_edge(everyone, e);
 			edge_del(e);
diff --git a/src/protocol_key.c b/src/protocol_key.c
index 5cfa060b..ef182b34 100644
--- a/src/protocol_key.c
+++ b/src/protocol_key.c
@@ -23,6 +23,7 @@
 #include "connection.h"
 #include "crypto.h"
 #include "logger.h"
+#include "meshlink_internal.h"
 #include "net.h"
 #include "netutl.h"
 #include "node.h"
@@ -35,7 +36,7 @@
 static bool mykeyused = false;
 
 void send_key_changed(void) {
-	send_request(everyone, "%d %x %s", KEY_CHANGED, rand(), myself->name);
+	send_request(everyone, "%d %x %s", KEY_CHANGED, rand(), mesh->self->name);
 
 	/* Force key exchange for connections using SPTPS */
 
@@ -77,27 +78,27 @@ static bool send_initial_sptps_data(void *handle, uint8_t type, const char *data
 	to->sptps.send_data = send_sptps_data;
 	char buf[len * 4 / 3 + 5];
 	b64encode(data, buf, len);
-	return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, myself->name, to->name, REQ_KEY, buf);
+	return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, mesh->self->name, to->name, REQ_KEY, buf);
 }
 
 bool send_req_key(node_t *to) {
 	if(!node_read_ecdsa_public_key(to)) {
 		logger(DEBUG_PROTOCOL, LOG_DEBUG, "No ECDSA key known for %s (%s)", to->name, to->hostname);
-		send_request(to->nexthop->connection, "%d %s %s %d", REQ_KEY, myself->name, to->name, REQ_PUBKEY);
+		send_request(to->nexthop->connection, "%d %s %s %d", REQ_KEY, mesh->self->name, to->name, REQ_PUBKEY);
 		return true;
 	}
 
 	if(to->sptps.label)
 		logger(DEBUG_ALWAYS, LOG_DEBUG, "send_req_key(%s) called while sptps->label != NULL!", to->name);
 
-	char label[25 + strlen(myself->name) + strlen(to->name)];
-	snprintf(label, sizeof label, "tinc UDP key expansion %s %s", myself->name, to->name);
+	char label[25 + strlen(mesh->self->name) + strlen(to->name)];
+	snprintf(label, sizeof label, "tinc UDP key expansion %s %s", mesh->self->name, to->name);
 	sptps_stop(&to->sptps);
 	to->status.validkey = false;
 	to->status.waitingforkey = true;
 	to->last_req_key = now.tv_sec;
-	to->incompression = myself->incompression;
-	return sptps_start(&to->sptps, to, true, true, myself->connection->ecdsa, to->ecdsa, label, sizeof label, send_initial_sptps_data, receive_sptps_record);
+	to->incompression = mesh->self->incompression;
+	return sptps_start(&to->sptps, to, true, true, mesh->self->connection->ecdsa, to->ecdsa, label, sizeof label, send_initial_sptps_data, receive_sptps_record);
 }
 
 /* REQ_KEY is overloaded to allow arbitrary requests to be routed between two nodes. */
@@ -105,8 +106,8 @@ bool send_req_key(node_t *to) {
 static bool req_key_ext_h(connection_t *c, const char *request, node_t *from, int reqno) {
 	switch(reqno) {
 		case REQ_PUBKEY: {
-			char *pubkey = ecdsa_get_base64_public_key(myself->connection->ecdsa);
-			send_request(from->nexthop->connection, "%d %s %s %d %s", REQ_KEY, myself->name, from->name, ANS_PUBKEY, pubkey);
+			char *pubkey = ecdsa_get_base64_public_key(mesh->self->connection->ecdsa);
+			send_request(from->nexthop->connection, "%d %s %s %d %s", REQ_KEY, mesh->self->name, from->name, ANS_PUBKEY, pubkey);
 			free(pubkey);
 			return true;
 		}
@@ -131,7 +132,7 @@ static bool req_key_ext_h(connection_t *c, const char *request, node_t *from, in
 		case REQ_KEY: {
 			if(!node_read_ecdsa_public_key(from)) {
 				logger(DEBUG_PROTOCOL, LOG_DEBUG, "No ECDSA key known for %s (%s)", from->name, from->hostname);
-				send_request(from->nexthop->connection, "%d %s %s %d", REQ_KEY, myself->name, from->name, REQ_PUBKEY);
+				send_request(from->nexthop->connection, "%d %s %s %d", REQ_KEY, mesh->self->name, from->name, REQ_PUBKEY);
 				return true;
 			}
 
@@ -146,13 +147,13 @@ static bool req_key_ext_h(connection_t *c, const char *request, node_t *from, in
 				return true;
 			}
 
-			char label[25 + strlen(from->name) + strlen(myself->name)];
-			snprintf(label, sizeof label, "tinc UDP key expansion %s %s", from->name, myself->name);
+			char label[25 + strlen(from->name) + strlen(mesh->self->name)];
+			snprintf(label, sizeof label, "tinc UDP key expansion %s %s", from->name, mesh->self->name);
 			sptps_stop(&from->sptps);
 			from->status.validkey = false;
 			from->status.waitingforkey = true;
 			from->last_req_key = now.tv_sec;
-			sptps_start(&from->sptps, from, false, true, myself->connection->ecdsa, from->ecdsa, label, sizeof label, send_sptps_data, receive_sptps_record);
+			sptps_start(&from->sptps, from, false, true, mesh->self->connection->ecdsa, from->ecdsa, label, sizeof label, send_sptps_data, receive_sptps_record);
 			sptps_receive_data(&from->sptps, buf, len);
 			return true;
 		}
@@ -214,7 +215,7 @@ bool req_key_h(connection_t *c, const char *request) {
 
 	/* Check if this key request is for us */
 
-	if(to == myself) {                      /* Yes */
+	if(to == mesh->self) {                      /* Yes */
 		/* Is this an extended REQ_KEY message? */
 		if(reqno)
 			return req_key_ext_h(c, request, from, reqno);
@@ -278,7 +279,7 @@ bool ans_key_h(connection_t *c, const char *request) {
 
 	/* Forward it if necessary */
 
-	if(to != myself) {
+	if(to != mesh->self) {
 		if(!to->status.reachable) {
 			logger(DEBUG_ALWAYS, LOG_WARNING, "Got %s from %s (%s) destination %s which is not reachable",
 				   "ANS_KEY", c->name, c->hostname, to_name);
diff --git a/src/route.c b/src/route.c
index 450baf90..d999d11e 100644
--- a/src/route.c
+++ b/src/route.c
@@ -20,6 +20,7 @@
 #include "system.h"
 
 #include "logger.h"
+#include "meshlink_internal.h"
 #include "net.h"
 #include "route.h"
 #include "utils.h"
@@ -71,7 +72,7 @@ void route(node_t *source,vpn_packet_t *packet) {
     return;
     }
 
-    if (owner == myself ) {
+    if (owner == mesh->self ) {
     //TODO: implement sending received data from meshlink library to the application
     logger(DEBUG_TRAFFIC, LOG_WARNING, "I received a packet for me with payload: %s \n", packet->data + sizeof *hdr);
     (recv_callback)(packet->data + sizeof *hdr);
@@ -84,7 +85,7 @@ void route(node_t *source,vpn_packet_t *packet) {
     return;
     }
 
-    via = (owner->via == myself) ? owner->nexthop : owner->via;
+    via = (owner->via == mesh->self) ? owner->nexthop : owner->via;
     if(via == source) {
 	logger(DEBUG_TRAFFIC, LOG_ERR, "Routing loop for packet from %s (%s)!", source->name, source->hostname);
 	return;