#endif
int addressfamily = AF_UNSPEC;
-int maxtimeout = 900;
int seconds_till_retry = 5;
int max_connection_burst = 100;
#endif
}
-static bool bind_to_address(connection_t *c) {
+static bool bind_to_address(meshlink_handle_t *mesh, connection_t *c) {
int s = -1;
for(int i = 0; i < mesh->listen_sockets && mesh->listen_socket[i].bindto; i++) {
return nfd;
}
-int setup_vpn_in_socket(const sockaddr_t *sa) {
+int setup_vpn_in_socket(meshlink_handle_t *mesh, const sockaddr_t *sa) {
int nfd;
char *addrstr;
int option;
return nfd;
} /* int setup_vpn_in_socket */
-static void retry_outgoing_handler(void *data) {
- setup_outgoing_connection(data);
+static void retry_outgoing_handler(event_loop_t *loop, void *data) {
+ meshlink_handle_t *mesh = loop->data;
+ outgoing_t *outgoing = data;
+ setup_outgoing_connection(mesh, outgoing);
}
-void retry_outgoing(outgoing_t *outgoing) {
+void retry_outgoing(meshlink_handle_t *mesh, outgoing_t *outgoing) {
outgoing->timeout += 5;
- if(outgoing->timeout > maxtimeout)
- outgoing->timeout = maxtimeout;
+ if(outgoing->timeout > mesh->maxtimeout)
+ outgoing->timeout = mesh->maxtimeout;
- timeout_add(&outgoing->ev, retry_outgoing_handler, outgoing, &(struct timeval){outgoing->timeout, rand() % 100000});
+ timeout_add(&mesh->loop, &outgoing->ev, retry_outgoing_handler, outgoing, &(struct timeval){outgoing->timeout, rand() % 100000});
logger(DEBUG_CONNECTIONS, LOG_NOTICE, "Trying to re-establish outgoing connection in %d seconds", outgoing->timeout);
}
-void finish_connecting(connection_t *c) {
+void finish_connecting(meshlink_handle_t *mesh, connection_t *c) {
logger(DEBUG_CONNECTIONS, LOG_INFO, "Connected to %s (%s)", c->name, c->hostname);
- c->last_ping_time = now.tv_sec;
+ c->last_ping_time = mesh->loop.now.tv_sec;
c->status.connecting = false;
- send_id(c);
+ send_id(mesh, c);
}
-static void do_outgoing_pipe(connection_t *c, char *command) {
+static void do_outgoing_pipe(meshlink_handle_t *mesh, connection_t *c, char *command) {
#ifndef HAVE_MINGW
int fd[2];
#endif
}
-static void handle_meta_write(connection_t *c) {
+static void handle_meta_write(meshlink_handle_t *mesh, connection_t *c) {
if(c->outbuf.len <= c->outbuf.offset)
return;
logger(DEBUG_CONNECTIONS, LOG_ERR, "Could not send %d bytes of data to %s (%s): %s", c->outbuf.len - c->outbuf.offset, c->name, c->hostname, strerror(errno));
}
- terminate_connection(c, c->status.active);
+ terminate_connection(mesh, c, c->status.active);
return;
}
buffer_read(&c->outbuf, outlen);
if(!c->outbuf.len)
- io_set(&c->io, IO_READ);
+ io_set(&mesh->loop, &c->io, IO_READ);
}
-static void handle_meta_io(void *data, int flags) {
+static void handle_meta_io(event_loop_t *loop, void *data, int flags) {
+ meshlink_handle_t *mesh = loop->data;
connection_t *c = data;
if(c->status.connecting) {
getsockopt(c->socket, SOL_SOCKET, SO_ERROR, (void *)&result, &len);
if(!result)
- finish_connecting(c);
+ finish_connecting(mesh, c);
else {
logger(DEBUG_CONNECTIONS, LOG_DEBUG, "Error while connecting to %s (%s): %s", c->name, c->hostname, sockstrerror(result));
- terminate_connection(c, false);
+ terminate_connection(mesh, c, false);
return;
}
}
if(flags & IO_WRITE)
- handle_meta_write(c);
+ handle_meta_write(mesh, c);
else
- handle_meta_connection_data(c);
+ handle_meta_connection_data(mesh, c);
}
-bool do_outgoing_connection(outgoing_t *outgoing) {
+bool do_outgoing_connection(meshlink_handle_t *mesh, outgoing_t *outgoing) {
char *address, *port, *space;
struct addrinfo *proxyai = NULL;
int result;
if(!outgoing->ai) {
if(!outgoing->cfg) {
logger(DEBUG_CONNECTIONS, LOG_ERR, "Could not set up a meta connection to %s", outgoing->name);
- retry_outgoing(outgoing);
+ retry_outgoing(mesh, outgoing);
return false;
}
c->socket = socket(c->address.sa.sa_family, SOCK_STREAM, IPPROTO_TCP);
configure_tcp(c);
} else if(mesh->proxytype == PROXY_EXEC) {
- do_outgoing_pipe(c, mesh->proxyhost);
+ do_outgoing_pipe(mesh, c, mesh->proxyhost);
} else {
proxyai = str2addrinfo(mesh->proxyhost, mesh->proxyport, SOCK_STREAM);
if(!proxyai) {
setsockopt(c->socket, SOL_IPV6, IPV6_V6ONLY, (void *)&option, sizeof option);
#endif
- bind_to_address(c);
+ bind_to_address(mesh, c);
}
/* Connect */
c->status.connecting = true;
c->name = xstrdup(outgoing->name);
c->outcompression = mesh->self->connection->outcompression;
- c->last_ping_time = now.tv_sec;
+ c->last_ping_time = mesh->loop.now.tv_sec;
- connection_add(c);
+ connection_add(mesh, c);
- io_add(&c->io, handle_meta_io, c, c->socket, IO_READ|IO_WRITE);
+ io_add(&mesh->loop, &c->io, handle_meta_io, c, c->socket, IO_READ|IO_WRITE);
return true;
}
return ai;
}
-void setup_outgoing_connection(outgoing_t *outgoing) {
- timeout_del(&outgoing->ev);
+void setup_outgoing_connection(meshlink_handle_t *mesh, outgoing_t *outgoing) {
+ timeout_del(&mesh->loop, &outgoing->ev);
- node_t *n = lookup_node(outgoing->name);
+ node_t *n = lookup_node(mesh, outgoing->name);
if(n && n->connection) {
logger(DEBUG_CONNECTIONS, LOG_INFO, "Already connected to %s", outgoing->name);
}
init_configuration(&outgoing->config_tree);
- read_host_config(outgoing->config_tree, outgoing->name);
+ read_host_config(mesh, outgoing->config_tree, outgoing->name);
outgoing->cfg = lookup_config(outgoing->config_tree, "Address");
if(!outgoing->cfg) {
}
}
- do_outgoing_connection(outgoing);
+ do_outgoing_connection(mesh, outgoing);
}
/*
accept a new tcp connect and create a
new connection
*/
-void handle_new_meta_connection(void *data, int flags) {
+void handle_new_meta_connection(event_loop_t *loop, void *data, int flags) {
+ meshlink_handle_t *mesh = loop->data;
listen_socket_t *l = data;
connection_t *c;
sockaddr_t sa;
static int samehost_burst;
static int samehost_burst_time;
- if(now.tv_sec - samehost_burst_time > samehost_burst)
+ if(mesh->loop.now.tv_sec - samehost_burst_time > samehost_burst)
samehost_burst = 0;
else
- samehost_burst -= now.tv_sec - samehost_burst_time;
+ samehost_burst -= mesh->loop.now.tv_sec - samehost_burst_time;
- samehost_burst_time = now.tv_sec;
+ samehost_burst_time = mesh->loop.now.tv_sec;
samehost_burst++;
if(samehost_burst > max_connection_burst) {
static int connection_burst;
static int connection_burst_time;
- if(now.tv_sec - connection_burst_time > connection_burst)
+ if(mesh->loop.now.tv_sec - connection_burst_time > connection_burst)
connection_burst = 0;
else
- connection_burst -= now.tv_sec - connection_burst_time;
+ connection_burst -= mesh->loop.now.tv_sec - connection_burst_time;
- connection_burst_time = now.tv_sec;
+ connection_burst_time = mesh->loop.now.tv_sec;
connection_burst++;
if(connection_burst >= max_connection_burst) {
c->address = sa;
c->hostname = sockaddr2hostname(&sa);
c->socket = fd;
- c->last_ping_time = now.tv_sec;
+ c->last_ping_time = mesh->loop.now.tv_sec;
logger(DEBUG_CONNECTIONS, LOG_NOTICE, "Connection from %s", c->hostname);
- io_add(&c->io, handle_meta_io, c, c->socket, IO_READ);
+ io_add(&mesh->loop, &c->io, handle_meta_io, c, c->socket, IO_READ);
configure_tcp(c);
- connection_add(c);
+ connection_add(mesh, c);
c->allow_request = ID;
- send_id(c);
+ send_id(mesh, c);
}
-static void free_outgoing(outgoing_t *outgoing) {
- timeout_del(&outgoing->ev);
+static void free_outgoing(meshlink_handle_t *mesh, outgoing_t *outgoing) {
+ timeout_del(&mesh->loop, &outgoing->ev);
if(outgoing->ai)
freeaddrinfo(outgoing->ai);
free(outgoing);
}
-void try_outgoing_connections(void) {
+void try_outgoing_connections(meshlink_handle_t *mesh) {
/* If there is no outgoing list yet, create one. Otherwise, mark all outgoings as deleted. */
if(!mesh->outgoings) {
outgoing_t *outgoing = xzalloc(sizeof *outgoing);
outgoing->name = name;
list_insert_tail(mesh->outgoings, outgoing);
- setup_outgoing_connection(outgoing);
+ setup_outgoing_connection(mesh, outgoing);
}
}
if(c->outgoing && c->outgoing->timeout == -1) {
c->outgoing = NULL;
logger(DEBUG_CONNECTIONS, LOG_INFO, "No more outgoing connection to %s", c->name);
- terminate_connection(c, c->status.active);
+ terminate_connection(mesh, c, c->status.active);
}
}