int autoconnect = 3;
-bool node_read_ecdsa_public_key(node_t *n) {
+bool node_read_ecdsa_public_key(meshlink_handle_t *mesh, node_t *n) {
if(ecdsa_active(n->ecdsa))
return true;
char *p;
init_configuration(&config_tree);
- if(!read_host_config(config_tree, n->name))
+ if(!read_host_config(mesh, config_tree, n->name))
goto exit;
/* First, check for simple ECDSAPublicKey statement */
return n->ecdsa;
}
-bool read_ecdsa_public_key(connection_t *c) {
+bool read_ecdsa_public_key(meshlink_handle_t *mesh, connection_t *c) {
if(ecdsa_active(c->ecdsa))
return true;
if(!c->config_tree) {
init_configuration(&c->config_tree);
- if(!read_host_config(c->config_tree, c->name))
+ if(!read_host_config(mesh, c->config_tree, c->name))
return false;
}
return false;
}
-static bool read_ecdsa_private_key(void) {
+bool read_ecdsa_private_key(meshlink_handle_t *mesh) {
FILE *fp;
- char *fname;
+ char filename[PATH_MAX];
- xasprintf(&fname, "%s" SLASH "ecdsa_key.priv", mesh->confbase);
- fp = fopen(fname, "r");
- free(fname);
+ snprintf(filename,PATH_MAX, "%s" SLASH "ecdsa_key.priv", mesh->confbase);
+ fp = fopen(filename, "r");
if(!fp) {
logger(DEBUG_ALWAYS, LOG_ERR, "Error reading ECDSA private key file: %s", strerror(errno));
return mesh->self->connection->ecdsa;
}
-static bool read_invitation_key(void) {
+static bool read_invitation_key(meshlink_handle_t *mesh) {
FILE *fp;
- char *fname;
+ char filename[PATH_MAX];
if(mesh->invitation_key) {
ecdsa_free(mesh->invitation_key);
mesh->invitation_key = NULL;
}
- xasprintf(&fname, "%s" SLASH "invitations" SLASH "ecdsa_key.priv", mesh->confbase);
+ snprintf(filename,PATH_MAX, "%s" SLASH "invitations" SLASH "ecdsa_key.priv", mesh->confbase);
- fp = fopen(fname, "r");
+ fp = fopen(filename, "r");
if(fp) {
mesh->invitation_key = ecdsa_read_pem_private_key(fp);
fclose(fp);
if(!mesh->invitation_key)
- logger(DEBUG_ALWAYS, LOG_ERR, "Reading ECDSA private key file `%s' failed: %s", fname, strerror(errno));
+ logger(DEBUG_ALWAYS, LOG_ERR, "Reading ECDSA private key file `%s' failed: %s", filename, strerror(errno));
}
- free(fname);
return mesh->invitation_key;
}
-void load_all_nodes(void) {
+void load_all_nodes(meshlink_handle_t *mesh) {
DIR *dir;
struct dirent *ent;
- char *dname;
+ char dname[PATH_MAX];
- xasprintf(&dname, "%s" SLASH "hosts", mesh->confbase);
+ snprintf(dname,PATH_MAX, "%s" SLASH "hosts", mesh->confbase);
dir = opendir(dname);
if(!dir) {
logger(DEBUG_ALWAYS, LOG_ERR, "Could not open %s: %s", dname, strerror(errno));
- free(dname);
return;
}
if(!check_id(ent->d_name))
continue;
- node_t *n = lookup_node(ent->d_name);
+ node_t *n = lookup_node(mesh, ent->d_name);
if(n)
continue;
n = new_node();
n->name = xstrdup(ent->d_name);
- node_add(n);
+ node_add(mesh, n);
}
closedir(dir);
}
-char *get_name(void) {
+char *get_name(meshlink_handle_t *mesh) {
char *name = NULL;
get_config_string(lookup_config(mesh->config, "Name"), &name);
return name;
}
-bool setup_myself_reloadable(void) {
+bool setup_myself_reloadable(meshlink_handle_t *mesh) {
mesh->localdiscovery = true;
keylifetime = 3600; // TODO: check if this can be removed as well
- maxtimeout = 900;
+ mesh->maxtimeout = 900;
autoconnect = 3;
mesh->self->options |= OPTION_PMTU_DISCOVERY;
- read_invitation_key();
+ read_invitation_key(mesh);
return true;
}
/*
Add listening sockets.
*/
-static bool add_listen_address(char *address, bool bindto) {
+static bool add_listen_address(meshlink_handle_t *mesh, char *address, bool bindto) {
char *port = mesh->myport;
if(address) {
if(tcp_fd < 0)
continue;
- int udp_fd = setup_vpn_in_socket((sockaddr_t *) aip->ai_addr);
+ int udp_fd = setup_vpn_in_socket(mesh, (sockaddr_t *) aip->ai_addr);
if(tcp_fd < 0) {
close(tcp_fd);
continue;
}
- io_add(&mesh->listen_socket[mesh->listen_sockets].tcp, handle_new_meta_connection, &mesh->listen_socket[mesh->listen_sockets], tcp_fd, IO_READ);
- io_add(&mesh->listen_socket[mesh->listen_sockets].udp, handle_incoming_vpn_data, &mesh->listen_socket[mesh->listen_sockets], udp_fd, IO_READ);
+ io_add(&mesh->loop, &mesh->listen_socket[mesh->listen_sockets].tcp, handle_new_meta_connection, &mesh->listen_socket[mesh->listen_sockets], tcp_fd, IO_READ);
+ io_add(&mesh->loop, &mesh->listen_socket[mesh->listen_sockets].udp, handle_incoming_vpn_data, &mesh->listen_socket[mesh->listen_sockets], udp_fd, IO_READ);
- if(debug_level >= DEBUG_CONNECTIONS) {
+ if(mesh->debug_level >= DEBUG_CONNECTIONS) {
char *hostname = sockaddr2hostname((sockaddr_t *) aip->ai_addr);
logger(DEBUG_CONNECTIONS, LOG_NOTICE, "Listening on %s", hostname);
free(hostname);
/*
Configure node_t mesh->self and set up the local sockets (listen only)
*/
-bool setup_myself(void) {
- char *name, *hostname, *cipher, *digest, *type;
+bool setup_myself(meshlink_handle_t *mesh) {
+ char *name;
char *address = NULL;
- bool port_specified = false;
- if(!(name = get_name())) {
- logger(DEBUG_ALWAYS, LOG_ERR, "Name for tinc daemon required!");
+ if(!(name = get_name(mesh))) {
+ logger(DEBUG_ALWAYS, LOG_ERR, "Name for MeshLink instance required!");
return false;
}
mesh->self->connection = new_connection();
mesh->self->name = name;
mesh->self->connection->name = xstrdup(name);
- read_host_config(mesh->config, name);
+ read_host_config(mesh, mesh->config, name);
if(!get_config_string(lookup_config(mesh->config, "Port"), &mesh->myport))
mesh->myport = xstrdup("655");
- else
- port_specified = true;
mesh->self->connection->options = 0;
mesh->self->connection->protocol_major = PROT_MAJOR;
mesh->self->options |= PROT_MINOR << 24;
- if(!read_ecdsa_private_key())
+ if(!read_ecdsa_private_key(mesh))
return false;
/* Ensure mesh->myport is numeric */
/* Check some options */
- if(!setup_myself_reloadable())
+ if(!setup_myself_reloadable(mesh))
return false;
/* Compression */
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);
+ mesh->self->last_state_change = mesh->loop.now.tv_sec;
+ node_add(mesh, mesh->self);
- graph();
+ graph(mesh);
if(autoconnect)
- load_all_nodes();
+ load_all_nodes(mesh);
/* Open sockets */
mesh->listen_sockets = 0;
- int cfgs = 0;
- if(!add_listen_address(address, NULL))
+ if(!add_listen_address(mesh, address, NULL))
return false;
if(!mesh->listen_sockets) {
/* Done. */
- mesh->last_config_check = now.tv_sec;
+ mesh->last_config_check = mesh->loop.now.tv_sec;
return true;
}
/*
initialize network
*/
-bool setup_network(void) {
- init_connections();
- init_nodes();
- init_edges();
- init_requests();
-
- pinginterval = 60;
- pingtimeout = 5;
+bool setup_network(meshlink_handle_t *mesh) {
+ init_connections(mesh);
+ init_nodes(mesh);
+ init_edges(mesh);
+ init_requests(mesh);
+
+ mesh->pinginterval = 60;
+ mesh->pingtimeout = 5;
maxoutbufsize = 10 * MTU;
- if(!setup_myself())
+ if(!setup_myself(mesh))
return false;
return true;
/*
close all open network connections
*/
-void close_network_connections(void) {
+void close_network_connections(meshlink_handle_t *mesh) {
for(list_node_t *node = mesh->connections->head, *next; node; node = next) {
next = node->next;
connection_t *c = node->data;
c->outgoing = NULL;
- terminate_connection(c, false);
+ terminate_connection(mesh, c, false);
}
if(mesh->outgoings)
list_delete_list(mesh->outgoings);
if(mesh->self && mesh->self->connection) {
- terminate_connection(mesh->self->connection, false);
+ terminate_connection(mesh, mesh->self->connection, false);
free_connection(mesh->self->connection);
}
for(int i = 0; i < mesh->listen_sockets; i++) {
- io_del(&mesh->listen_socket[i].tcp);
- io_del(&mesh->listen_socket[i].udp);
+ io_del(&mesh->loop, &mesh->listen_socket[i].tcp);
+ io_del(&mesh->loop, &mesh->listen_socket[i].udp);
close(mesh->listen_socket[i].tcp.fd);
close(mesh->listen_socket[i].udp.fd);
}
- exit_requests();
- exit_edges();
- exit_nodes();
- exit_connections();
+ exit_requests(mesh);
+ exit_edges(mesh);
+ exit_nodes(mesh);
+ exit_connections(mesh);
if(mesh->myport) free(mesh->myport);