summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--src/async.c36
-rw-r--r--src/async.h6
-rw-r--r--src/buffer.h28
-rw-r--r--src/capabilities.c30
-rw-r--r--src/config.c180
-rw-r--r--src/config.h36
-rw-r--r--src/config.y43
-rw-r--r--src/fastd.c455
-rw-r--r--src/fastd.h98
-rw-r--r--src/handshake.c78
-rw-r--r--src/handshake.h26
-rw-r--r--src/log.c28
-rw-r--r--src/log.h38
-rw-r--r--src/method.h24
-rw-r--r--src/methods/cipher_test/cipher_test.c42
-rw-r--r--src/methods/common.c18
-rw-r--r--src/methods/common.h36
-rw-r--r--src/methods/composed_gmac/composed_gmac.c42
-rw-r--r--src/methods/generic_gmac/generic_gmac.c44
-rw-r--r--src/methods/generic_poly1305/generic_poly1305.c58
-rw-r--r--src/methods/null/null.c20
-rw-r--r--src/methods/xsalsa20_poly1305/xsalsa20_poly1305.c76
-rw-r--r--src/options.c110
-rw-r--r--src/peer.c284
-rw-r--r--src/peer.h58
-rw-r--r--src/peer_hashtable.c44
-rw-r--r--src/peer_hashtable.h10
-rw-r--r--src/poll.c186
-rw-r--r--src/poll.h16
-rw-r--r--src/protocols/ec25519_fhmqvc/ec25519_fhmqvc.c94
-rw-r--r--src/protocols/ec25519_fhmqvc/ec25519_fhmqvc.h26
-rw-r--r--src/protocols/ec25519_fhmqvc/handshake.c236
-rw-r--r--src/protocols/ec25519_fhmqvc/handshake.h8
-rw-r--r--src/protocols/ec25519_fhmqvc/state.c56
-rw-r--r--src/protocols/ec25519_fhmqvc/util.c8
-rw-r--r--src/random.c6
-rw-r--r--src/receive.c66
-rw-r--r--src/resolve.c24
-rw-r--r--src/send.c46
-rw-r--r--src/shell.c28
-rw-r--r--src/shell.h4
-rw-r--r--src/socket.c86
-rw-r--r--src/tuntap.c172
43 files changed, 1506 insertions, 1504 deletions
diff --git a/src/async.c b/src/async.c
index 0c37842..144a82c 100644
--- a/src/async.c
+++ b/src/async.c
@@ -28,26 +28,26 @@
#include "fastd.h"
-void fastd_async_init(fastd_context_t *ctx) {
- fastd_open_pipe(ctx, &ctx->async_rfd, &ctx->async_wfd);
+void fastd_async_init(void) {
+ fastd_open_pipe(&ctx.async_rfd, &ctx.async_wfd);
}
-static void handle_resolve_return(fastd_context_t *ctx) {
+static void handle_resolve_return(void) {
fastd_async_resolve_return_t resolve_return;
- while (read(ctx->async_rfd, &resolve_return, sizeof(resolve_return)) < 0) {
+ while (read(ctx.async_rfd, &resolve_return, sizeof(resolve_return)) < 0) {
if (errno != EINTR)
- exit_errno(ctx, "handle_resolve_return: read");
+ exit_errno("handle_resolve_return: read");
}
fastd_peer_address_t addresses[resolve_return.n_addr];
- while (read(ctx->async_rfd, &addresses, sizeof(addresses)) < 0) {
+ while (read(ctx.async_rfd, &addresses, sizeof(addresses)) < 0) {
if (errno != EINTR)
- exit_errno(ctx, "handle_resolve_return: read");
+ exit_errno("handle_resolve_return: read");
}
size_t i;
- for (i = 0; i < VECTOR_LEN(ctx->peers); i++) {
- fastd_peer_t *peer = VECTOR_INDEX(ctx->peers, i);
+ for (i = 0; i < VECTOR_LEN(ctx.peers); i++) {
+ fastd_peer_t *peer = VECTOR_INDEX(ctx.peers, i);
if (!peer->config)
continue;
@@ -61,7 +61,7 @@ static void handle_resolve_return(fastd_context_t *ctx) {
if (!remote)
continue;
- fastd_peer_handle_resolve(ctx, peer, remote, resolve_return.n_addr, addresses);
+ fastd_peer_handle_resolve(peer, remote, resolve_return.n_addr, addresses);
break;
}
@@ -69,30 +69,30 @@ static void handle_resolve_return(fastd_context_t *ctx) {
fastd_remote_unref(resolve_return.remote);
}
-void fastd_async_handle(fastd_context_t *ctx) {
+void fastd_async_handle(void) {
fastd_async_type_t type;
- while (read(ctx->async_rfd, &type, sizeof(type)) < 0) {
+ while (read(ctx.async_rfd, &type, sizeof(type)) < 0) {
if (errno != EINTR)
- exit_errno(ctx, "fastd_async_handle: read");
+ exit_errno("fastd_async_handle: read");
}
switch (type) {
case ASYNC_TYPE_RESOLVE_RETURN:
- handle_resolve_return(ctx);
+ handle_resolve_return();
break;
default:
- exit_bug(ctx, "fastd_async_handle: unknown type");
+ exit_bug("fastd_async_handle: unknown type");
}
}
-void fastd_async_enqueue(fastd_context_t *ctx, fastd_async_type_t type, const void *data, size_t len) {
+void fastd_async_enqueue(fastd_async_type_t type, const void *data, size_t len) {
struct iovec vec[2] = {
{ .iov_base = &type, .iov_len = sizeof(type) },
{ .iov_base = (void *)data, .iov_len = len },
};
- if (writev(ctx->async_wfd, vec, 2) < 0)
- pr_error_errno(ctx, "fastd_async_enqueue");
+ if (writev(ctx.async_wfd, vec, 2) < 0)
+ pr_error_errno("fastd_async_enqueue");
}
diff --git a/src/async.h b/src/async.h
index a983ee9..7e1921c 100644
--- a/src/async.h
+++ b/src/async.h
@@ -37,6 +37,6 @@ struct fastd_async_resolve_return {
};
-void fastd_async_init(fastd_context_t *ctx);
-void fastd_async_handle(fastd_context_t *ctx);
-void fastd_async_enqueue(fastd_context_t *ctx, fastd_async_type_t type, const void *data, size_t len);
+void fastd_async_init(void);
+void fastd_async_handle(void);
+void fastd_async_enqueue(fastd_async_type_t type, const void *data, size_t len);
diff --git a/src/buffer.h b/src/buffer.h
index d403785..489e509 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -38,18 +38,18 @@ struct fastd_buffer {
};
-static inline fastd_buffer_t fastd_buffer_alloc(const fastd_context_t *ctx, size_t len, size_t head_space, size_t tail_space) {
+static inline fastd_buffer_t fastd_buffer_alloc(const size_t len, size_t head_space, size_t tail_space) {
size_t base_len = head_space+len+tail_space;
void *ptr;
int err = posix_memalign(&ptr, 16, base_len);
if (err)
- exit_error(ctx, "posix_memalign: %s", strerror(err));
+ exit_error("posix_memalign: %s", strerror(err));
return (fastd_buffer_t){ .base = ptr, .base_len = base_len, .data = ptr+head_space, .len = len };
}
-static inline fastd_buffer_t fastd_buffer_dup(const fastd_context_t *ctx, fastd_buffer_t buffer, size_t head_space, size_t tail_space) {
- fastd_buffer_t new_buffer = fastd_buffer_alloc(ctx, buffer.len, head_space, tail_space);
+static inline fastd_buffer_t fastd_buffer_dup(const fastd_buffer_t buffer, size_t head_space, size_t tail_space) {
+ fastd_buffer_t new_buffer = fastd_buffer_alloc(buffer.len, head_space, tail_space);
memcpy(new_buffer.data, buffer.data, buffer.len);
return new_buffer;
}
@@ -59,34 +59,34 @@ static inline void fastd_buffer_free(fastd_buffer_t buffer) {
}
-static inline void fastd_buffer_pull_head(const fastd_context_t *ctx, fastd_buffer_t *buffer, size_t len) {
+static inline void fastd_buffer_pull_head(fastd_buffer_t *buffer, size_t len) {
if (len > (size_t)(buffer->data - buffer->base))
- exit_bug(ctx, "tried to pull buffer across base");
+ exit_bug("tried to pull buffer across base");
buffer->data -= len;
buffer->len += len;
}
-static inline void fastd_buffer_pull_head_zero(const fastd_context_t *ctx, fastd_buffer_t *buffer, size_t len) {
- fastd_buffer_pull_head(ctx, buffer, len);
+static inline void fastd_buffer_pull_head_zero(fastd_buffer_t *buffer, size_t len) {
+ fastd_buffer_pull_head(buffer, len);
memset(buffer->data, 0, len);
}
-static inline void fastd_buffer_pull_head_from(const fastd_context_t *ctx, fastd_buffer_t *buffer, const void *data, size_t len) {
- fastd_buffer_pull_head(ctx, buffer, len);
+static inline void fastd_buffer_pull_head_from(fastd_buffer_t *buffer, const void *data, size_t len) {
+ fastd_buffer_pull_head(buffer, len);
memcpy(buffer->data, data, len);
}
-static inline void fastd_buffer_push_head(const fastd_context_t *ctx, fastd_buffer_t *buffer, size_t len) {
+static inline void fastd_buffer_push_head(fastd_buffer_t *buffer, size_t len) {
if (buffer->len < len)
- exit_bug(ctx, "tried to push buffer across tail");
+ exit_bug("tried to push buffer across tail");
buffer->data += len;
buffer->len -= len;
}
-static inline void fastd_buffer_push_head_to(const fastd_context_t *ctx, fastd_buffer_t *buffer, void *data, size_t len) {
+static inline void fastd_buffer_push_head_to(fastd_buffer_t *buffer, void *data, size_t len) {
memcpy(data, buffer->data, len);
- fastd_buffer_push_head(ctx, buffer, len);
+ fastd_buffer_push_head(buffer, len);
}
diff --git a/src/capabilities.c b/src/capabilities.c
index 9c9d334..897ca3c 100644
--- a/src/capabilities.c
+++ b/src/capabilities.c
@@ -31,7 +31,7 @@
#include <sys/capability.h>
-static void try_cap(fastd_context_t *ctx, cap_value_t cap) {
+static void try_cap(cap_value_t cap) {
char *name = cap_to_name(cap);
if (!name)
return;
@@ -42,51 +42,51 @@ static void try_cap(fastd_context_t *ctx, cap_value_t cap) {
cap_flag_value_t val;
if (cap_get_flag(caps, cap, CAP_EFFECTIVE, &val) < 0) {
- pr_debug_errno(ctx, "cap_get_flag");
+ pr_debug_errno("cap_get_flag");
goto end_free;
}
if (val == CAP_SET)
goto end_free;
- pr_verbose(ctx, "Trying to acquire %s", name);
+ pr_verbose("Trying to acquire %s", name);
if (cap_set_flag(caps, CAP_EFFECTIVE, 1, &cap, CAP_SET) < 0) {
- pr_debug_errno(ctx, "cap_set_flags");
+ pr_debug_errno("cap_set_flags");
goto end_free;
}
if (cap_set_proc(caps) < 0) {
- pr_debug_errno(ctx, "cap_set_proc");
+ pr_debug_errno("cap_set_proc");
goto end_free;
}
- pr_verbose(ctx, "Acquired capability %s.", name);
+ pr_verbose("Acquired capability %s.", name);
end_free:
cap_free(caps);
cap_free(name);
}
-void fastd_cap_init(fastd_context_t *ctx) {
+void fastd_cap_init(void) {
/* interface creation */
- try_cap(ctx, CAP_NET_ADMIN);
+ try_cap(CAP_NET_ADMIN);
/* privileged binds */
- try_cap(ctx, CAP_NET_BIND_SERVICE);
+ try_cap(CAP_NET_BIND_SERVICE);
/* for device binds */
- try_cap(ctx, CAP_NET_RAW);
+ try_cap(CAP_NET_RAW);
}
-void fastd_cap_drop(fastd_context_t *ctx) {
+void fastd_cap_drop(void) {
cap_t caps = cap_init();
if (cap_set_proc(caps) < 0) {
- pr_debug_errno(ctx, "cap_set_proc");
+ pr_debug_errno("cap_set_proc");
}
else {
- pr_verbose(ctx, "Dropped capabilities.");
+ pr_verbose("Dropped capabilities.");
}
cap_free(caps);
@@ -96,10 +96,10 @@ void fastd_cap_drop(fastd_context_t *ctx) {
#else /* WITH_CAPABILITIES */
-void fastd_cap_init(fastd_context_t *ctx UNUSED) {
+void fastd_cap_init(void) {
}
-void fastd_cap_drop(fastd_context_t *ctx UNUSED) {
+void fastd_cap_drop(void) {
}
#endif /* WITH_CAPABILITIES */
diff --git a/src/config.c b/src/config.c
index fbddd7f..75c4709 100644
--- a/src/config.c
+++ b/src/config.c
@@ -84,19 +84,19 @@ static void default_config(void) {
conf.macs = fastd_mac_config_alloc();
}
-void fastd_config_protocol(fastd_context_t *ctx UNUSED, const char *name) {
+void fastd_config_protocol(const char *name) {
if (!strcmp(name, "ec25519-fhmqvc"))
conf.protocol = &fastd_protocol_ec25519_fhmqvc;
else
- exit_error(ctx, "config error: protocol `%s' not supported", name);
+ exit_error("config error: protocol `%s' not supported", name);
}
-void fastd_config_method(fastd_context_t *ctx, const char *name) {
+void fastd_config_method(const char *name) {
fastd_string_stack_t **method;
for (method = &conf.method_list; *method; method = &(*method)->next) {
if (!strcmp((*method)->str, name)) {
- pr_debug(ctx, "duplicate method name `%s', ignoring", name);
+ pr_debug("duplicate method name `%s', ignoring", name);
return;
}
}
@@ -104,20 +104,20 @@ void fastd_config_method(fastd_context_t *ctx, const char *name) {
*method = fastd_string_stack_dup(name);
}
-void fastd_config_cipher(fastd_context_t *ctx, const char *name, const char *impl) {
+void fastd_config_cipher(const char *name, const char *impl) {
if (!fastd_cipher_config(conf.ciphers, name, impl))
- exit_error(ctx, "config error: implementation `%s' is not supported for cipher `%s' (or cipher `%s' is not supported)", impl, name, name);
+ exit_error("config error: implementation `%s' is not supported for cipher `%s' (or cipher `%s' is not supported)", impl, name, name);
}
-void fastd_config_mac(fastd_context_t *ctx, const char *name, const char *impl) {
+void fastd_config_mac(const char *name, const char *impl) {
if (!fastd_mac_config(conf.macs, name, impl))
- exit_error(ctx, "config error: implementation `%s' is not supported for MAC `%s' (or MAC `%s' is not supported)", impl, name, name);
+ exit_error("config error: implementation `%s' is not supported for MAC `%s' (or MAC `%s' is not supported)", impl, name, name);
}
-void fastd_config_bind_address(fastd_context_t *ctx UNUSED, const fastd_peer_address_t *address, const char *bindtodev, bool default_v4, bool default_v6) {
+void fastd_config_bind_address(const fastd_peer_address_t *address, const char *bindtodev, bool default_v4, bool default_v6) {
#ifndef USE_BINDTODEVICE
if (bindtodev && !fastd_peer_address_is_v6_ll(address))
- exit_error(ctx, "config error: device bind configuration not supported on this system");
+ exit_error("config error: device bind configuration not supported on this system");
#endif
#ifndef USE_MULTIAF_BIND
@@ -125,8 +125,8 @@ void fastd_config_bind_address(fastd_context_t *ctx UNUSED, const fastd_peer_add
fastd_peer_address_t addr4 = { .in = { .sin_family = AF_INET, .sin_port = address->in.sin_port } };
fastd_peer_address_t addr6 = { .in6 = { .sin6_family = AF_INET6, .sin6_port = address->in.sin_port } };
- fastd_config_bind_address(ctx, &addr4, bindtodev, default_v4, default_v6);
- fastd_config_bind_address(ctx, &addr6, bindtodev, default_v4, default_v6);
+ fastd_config_bind_address(&addr4, bindtodev, default_v4, default_v6);
+ fastd_config_bind_address(&addr6, bindtodev, default_v4, default_v6);
return;
}
#endif
@@ -148,7 +148,7 @@ void fastd_config_bind_address(fastd_context_t *ctx UNUSED, const fastd_peer_add
conf.bind_addr_default_v6 = addr;
}
-void fastd_config_peer_group_push(fastd_context_t *ctx UNUSED, const char *name) {
+void fastd_config_peer_group_push(const char *name) {
fastd_peer_group_config_t *group = calloc(1, sizeof(fastd_peer_group_config_t));
group->name = strdup(name);
group->max_connections = -1;
@@ -161,7 +161,7 @@ void fastd_config_peer_group_push(fastd_context_t *ctx UNUSED, const char *name)
conf.peer_group = group;
}
-void fastd_config_peer_group_pop(fastd_context_t *ctx UNUSED) {
+void fastd_config_peer_group_pop(void) {
conf.peer_group = conf.peer_group->parent;
}
@@ -190,7 +190,7 @@ static bool has_peer_group_peer_dirs(const fastd_peer_group_config_t *group) {
return false;
}
-void fastd_config_add_log_file(fastd_context_t *ctx, const char *name, fastd_loglevel_t level) {
+void fastd_config_add_log_file(const char *name, fastd_loglevel_t level) {
char *name2 = strdup(name);
char *name3 = strdup(name);
@@ -215,12 +215,12 @@ void fastd_config_add_log_file(fastd_context_t *ctx, const char *name, fastd_log
conf.log_files = file;
if(chdir(oldcwd))
- pr_error(ctx, "can't chdir to `%s': %s", oldcwd, strerror(errno));
+ pr_error("can't chdir to `%s': %s", oldcwd, strerror(errno));
free(logdir);
}
else {
- pr_error(ctx, "change from directory `%s' to `%s' failed: %s", oldcwd, dir, strerror(errno));
+ pr_error("change from directory `%s' to `%s' failed: %s", oldcwd, dir, strerror(errno));
}
free(oldcwd);
@@ -228,7 +228,7 @@ void fastd_config_add_log_file(fastd_context_t *ctx, const char *name, fastd_log
free(name3);
}
-static void read_peer_dir(fastd_context_t *ctx, const char *dir) {
+static void read_peer_dir(const char *dir) {
DIR *dirh = opendir(".");
if (dirh) {
@@ -237,7 +237,7 @@ static void read_peer_dir(fastd_context_t *ctx, const char *dir) {
struct dirent *result = readdir(dirh);
if (!result) {
if (errno)
- pr_error_errno(ctx, "readdir");
+ pr_error_errno("readdir");
break;
}
@@ -246,57 +246,57 @@ static void read_peer_dir(fastd_context_t *ctx, const char *dir) {
continue;
if (result->d_name[strlen(result->d_name)-1] == '~') {
- pr_verbose(ctx, "ignoring file `%s' as it seems to be a backup file", result->d_name);
+ pr_verbose("ignoring file `%s' as it seems to be a backup file", result->d_name);
continue;
}
struct stat statbuf;
if (stat(result->d_name, &statbuf)) {
- pr_warn(ctx, "ignoring file `%s': stat failed: %s", result->d_name, strerror(errno));
+ pr_warn("ignoring file `%s': stat failed: %s", result->d_name, strerror(errno));
continue;
}
if ((statbuf.st_mode & S_IFMT) != S_IFREG) {
- pr_info(ctx, "ignoring file `%s': no regular file", result->d_name);
+ pr_info("ignoring file `%s': no regular file", result->d_name);
continue;
}
- fastd_peer_config_new(ctx);
+ fastd_peer_config_new();
conf.peers->name = strdup(result->d_name);
conf.peers->config_source_dir = dir;
- if (!fastd_read_config(ctx, result->d_name, true, 0)) {
- pr_warn(ctx, "peer config `%s' will be ignored", result->d_name);
- fastd_peer_config_delete(ctx);
+ if (!fastd_read_config(result->d_name, true, 0)) {
+ pr_warn("peer config `%s' will be ignored", result->d_name);
+ fastd_peer_config_delete();
}
}
if (closedir(dirh) < 0)
- pr_error_errno(ctx, "closedir");
+ pr_error_errno("closedir");
}
else {
- pr_error(ctx, "opendir for `%s' failed: %s", dir, strerror(errno));
+ pr_error("opendir for `%s' failed: %s", dir, strerror(errno));
}
}
-static void read_peer_dirs(fastd_context_t *ctx) {
+static void read_peer_dirs(void) {
char *oldcwd = get_current_dir_name();
fastd_string_stack_t *dir;
for (dir = conf.peer_group->peer_dirs; dir; dir = dir->next) {
if (!chdir(dir->str))
- read_peer_dir(ctx, dir->str);
+ read_peer_dir(dir->str);
else
- pr_error(ctx, "change from directory `%s' to `%s' failed: %s", oldcwd, dir->str, strerror(errno));
+ pr_error("change from directory `%s' to `%s' failed: %s", oldcwd, dir->str, strerror(errno));
}
if (chdir(oldcwd))
- pr_error(ctx, "can't chdir to `%s': %s", oldcwd, strerror(errno));
+ pr_error("can't chdir to `%s': %s", oldcwd, strerror(errno));
free(oldcwd);
}
-void fastd_add_peer_dir(fastd_context_t *ctx, const char *dir) {
+void fastd_add_peer_dir(const char *dir) {
char *oldcwd = get_current_dir_name();
if (!chdir(dir)) {
@@ -305,18 +305,18 @@ void fastd_add_peer_dir(fastd_context_t *ctx, const char *dir) {
free(newdir);
if(chdir(oldcwd))
- pr_error(ctx, "can't chdir to `%s': %s", oldcwd, strerror(errno));
+ pr_error("can't chdir to `%s': %s", oldcwd, strerror(errno));
}
else {
- pr_error(ctx, "change from directory `%s' to `%s' failed: %s", oldcwd, dir, strerror(errno));
+ pr_error("change from directory `%s' to `%s' failed: %s", oldcwd, dir, strerror(errno));
}
free(oldcwd);
}
-bool fastd_read_config(fastd_context_t *ctx, const char *filename, bool peer_config, int depth) {
+bool fastd_read_config(const char *filename, bool peer_config, int depth) {
if (depth >= MAX_CONFIG_DEPTH)
- exit_error(ctx, "maximum config include depth exceeded");
+ exit_error("maximum config include depth exceeded");
bool ret = true;
char *oldcwd = get_current_dir_name();
@@ -335,7 +335,7 @@ bool fastd_read_config(fastd_context_t *ctx, const char *filename, bool peer_con
else {
file = fopen(filename, "r");
if (!file) {
- pr_error(ctx, "can't open config file `%s': %s", filename, strerror(errno));
+ pr_error("can't open config file `%s': %s", filename, strerror(errno));
ret = false;
goto end_free;
}
@@ -348,7 +348,7 @@ bool fastd_read_config(fastd_context_t *ctx, const char *filename, bool peer_con
dir = dirname(filename2);
if (chdir(dir)) {
- pr_error(ctx, "change from directory `%s' to `%s' failed", oldcwd, dir);
+ pr_error("change from directory `%s' to `%s' failed", oldcwd, dir);
ret = false;
goto end_free;
}
@@ -363,13 +363,13 @@ bool fastd_read_config(fastd_context_t *ctx, const char *filename, bool peer_con
else
token = conf.peer_group->parent ? START_PEER_GROUP_CONFIG : START_CONFIG;
- int parse_ret = fastd_config_push_parse(ps, token, &token_val, &loc, ctx, filename, depth+1);
+ int parse_ret = fastd_config_push_parse(ps, token, &token_val, &loc, filename, depth+1);
while(parse_ret == YYPUSH_MORE) {
token = fastd_lex(&token_val, &loc, lex);
if (token < 0) {
- pr_error(ctx, "config error: %s at %s:%i:%i", token_val.error, filename, loc.first_line, loc.first_column);
+ pr_error("config error: %s at %s:%i:%i", token_val.error, filename, loc.first_line, loc.first_column);
ret = false;
goto end_free;
}
@@ -379,7 +379,7 @@ bool fastd_read_config(fastd_context_t *ctx, const char *filename, bool peer_con
strings = token_val.str;
}
- parse_ret = fastd_config_push_parse(ps, token, &token_val, &loc, ctx, filename, depth+1);
+ parse_ret = fastd_config_push_parse(ps, token, &token_val, &loc, filename, depth+1);
}
if (parse_ret)
@@ -392,7 +392,7 @@ bool fastd_read_config(fastd_context_t *ctx, const char *filename, bool peer_con
fastd_config_pstate_delete(ps);
if(chdir(oldcwd))
- pr_error(ctx, "can't chdir to `%s': %s", oldcwd, strerror(errno));
+ pr_error("can't chdir to `%s': %s", oldcwd, strerror(errno));
free(filename2);
free(oldcwd);
@@ -403,7 +403,7 @@ bool fastd_read_config(fastd_context_t *ctx, const char *filename, bool peer_con
return ret;
}
-static void assess_peers(fastd_context_t *ctx) {
+static void assess_peers(void) {
conf.has_floating = false;
fastd_peer_config_t *peer;
@@ -412,12 +412,12 @@ static void assess_peers(fastd_context_t *ctx) {
conf.has_floating = true;
if (peer->dynamic_float_deprecated)
- pr_warn(ctx, "peer `%s' uses deprecated float syntax, please update your configuration", peer->name);
+ pr_warn("peer `%s' uses deprecated float syntax, please update your configuration", peer->name);
}
}
-static void configure_user(fastd_context_t *ctx) {
+static void configure_user(void) {
conf.uid = getuid();
conf.gid = getgid();
@@ -433,10 +433,10 @@ static void configure_user(fastd_context_t *ctx) {
} while(error == ERANGE);
if (error)
- exit_errno(ctx, "getpwnam_r");
+ exit_errno("getpwnam_r");
if (!pwdr)
- exit_error(ctx, "config error: unable to find user `%s'.", conf.user);
+ exit_error("config error: unable to find user `%s'.", conf.user);
conf.uid = pwdr->pw_uid;
conf.gid = pwdr->pw_gid;
@@ -454,10 +454,10 @@ static void configure_user(fastd_context_t *ctx) {
} while(error == ERANGE);
if (error)
- exit_errno(ctx, "getgrnam_r");
+ exit_errno("getgrnam_r");
if (!grpr)
- exit_error(ctx, "config error: unable to find group `%s'.", conf.group);
+ exit_error("config error: unable to find group `%s'.", conf.group);
conf.gid = grpr->gr_gid;
}
@@ -469,7 +469,7 @@ static void configure_user(fastd_context_t *ctx) {
conf.groups = calloc(ngroups, sizeof(gid_t));
if (getgrouplist(conf.user, conf.gid, conf.groups, &ngroups) < 0)
- exit_errno(ctx, "getgrouplist");
+ exit_errno("getgrouplist");
conf.n_groups = ngroups;
}
@@ -500,7 +500,7 @@ static void configure_method_parameters(void) {
conf.min_decrypt_head_space = alignto(conf.min_decrypt_head_space, 16) + 8;
}
-static void configure_methods(fastd_context_t *ctx) {
+static void configure_methods(void) {
size_t n_methods = 0, i;
fastd_string_stack_t *method_name;
for (method_name = conf.method_list; method_name; method_name = method_name->next)
@@ -511,7 +511,7 @@ static void configure_methods(fastd_context_t *ctx) {
for (i = 0, method_name = conf.method_list; method_name; i++, method_name = method_name->next) {
conf.methods[i].name = method_name->str;
if (!fastd_method_create_by_name(method_name->str, &conf.methods[i].provider, &conf.methods[i].method))
- exit_error(ctx, "config error: method `%s' not supported", method_name->str);
+ exit_error("config error: method `%s' not supported", method_name->str);
}
configure_method_parameters();
@@ -526,81 +526,81 @@ static void destroy_methods(void) {
free(conf.methods);
}
-void fastd_configure(fastd_context_t *ctx, int argc, char *const argv[]) {
+void fastd_configure(int argc, char *const argv[]) {
default_config();
- fastd_config_handle_options(ctx, argc, argv);
+ fastd_config_handle_options(argc, argv);
if (!conf.log_stderr_level && !conf.log_syslog_level && !conf.log_files)
conf.log_stderr_level = FASTD_DEFAULT_LOG_LEVEL;
}
-static void config_check_base(fastd_context_t *ctx) {
+static void config_check_base(void) {
if (conf.ifname) {
if (strchr(conf.ifname, '/'))
- exit_error(ctx, "config error: invalid interface name");
+ exit_error("config error: invalid interface name");
}
if (conf.mode == MODE_TUN) {
if (conf.peers->next)
- exit_error(ctx, "config error: in TUN mode exactly one peer must be configured");
+ exit_error("config error: in TUN mode exactly one peer must be configured");
if (conf.peer_group->children)
- exit_error(ctx, "config error: in TUN mode peer groups can't be used");
+ exit_error("config error: in TUN mode peer groups can't be used");
if (has_peer_group_peer_dirs(conf.peer_group))
- exit_error(ctx, "config error: in TUN mode peer directories can't be used");
+ exit_error("config error: in TUN mode peer directories can't be used");
}
#ifndef USE_PMTU
if (conf.pmtu.set)
- exit_error(ctx, "config error: setting pmtu is not supported on this system");
+ exit_error("config error: setting pmtu is not supported on this system");
#endif
#ifndef USE_PACKET_MARK
if (conf.packet_mark)
- exit_error(ctx, "config error: setting a packet mark is not supported on this system");
+ exit_error("config error: setting a packet mark is not supported on this system");
#endif
}
-void fastd_config_check(fastd_context_t *ctx) {
- config_check_base(ctx);
+void fastd_config_check(void) {
+ config_check_base();
if (conf.mode == MODE_TUN) {
if (!conf.peers)
- exit_error(ctx, "config error: in TUN mode exactly one peer must be configured");
+ exit_error("config error: in TUN mode exactly one peer must be configured");
}
if (!conf.peers && !has_peer_group_peer_dirs(conf.peer_group))
- exit_error(ctx, "config error: neither fixed peers nor peer dirs have been configured");
+ exit_error("config error: neither fixed peers nor peer dirs have been configured");
if (!conf.method_list) {
- pr_warn(ctx, "no encryption method configured, falling back to method `null' (unencrypted)");
- fastd_config_method(ctx, "null");
+ pr_warn("no encryption method configured, falling back to method `null' (unencrypted)");
+ fastd_config_method("null");
}
- configure_user(ctx);
- configure_methods(ctx);
+ configure_user();
+ configure_methods();
}
-void fastd_config_verify(fastd_context_t *ctx) {
- config_check_base(ctx);
- configure_methods(ctx);
+void fastd_config_verify(void) {
+ config_check_base();
+ configure_methods();
fastd_peer_config_t *peer;
for (peer = conf.peers; peer; peer = peer->next)
- conf.protocol->peer_verify(ctx, peer);
+ conf.protocol->peer_verify(peer);
}
-static void peer_dirs_read_peer_group(fastd_context_t *ctx) {
- read_peer_dirs(ctx);
+static void peer_dirs_read_peer_group(void) {
+ read_peer_dirs();
fastd_peer_group_config_t *group;
for (group = conf.peer_group->children; group; group = group->next) {
conf.peer_group = group;
- peer_dirs_read_peer_group(ctx);
+ peer_dirs_read_peer_group();
}
}
-static void peer_dirs_handle_old_peers(fastd_context_t *ctx, fastd_peer_config_t **old_peers, fastd_peer_config_t **new_peers) {
+static void peer_dirs_handle_old_peers(fastd_peer_config_t **old_peers, fastd_peer_config_t **new_peers) {
fastd_peer_config_t **peer, **next, **new_peer, **new_next;
for (peer = old_peers; *peer; peer = next) {
next = &(*peer)->next;
@@ -615,7 +615,7 @@ static void peer_dirs_handle_old_peers(fastd_context_t *ctx, fastd_peer_config_t
if (((*peer)->config_source_dir == (*new_peer)->config_source_dir) && strequal((*peer)->name, (*new_peer)->name)) {
if (fastd_peer_config_equal(*peer, *new_peer)) {
- pr_verbose(ctx, "peer `%s' unchanged", (*peer)->name);
+ pr_verbose("peer `%s' unchanged", (*peer)->name);
fastd_peer_config_t *free_peer = *new_peer;
*new_peer = *new_next;
@@ -623,7 +623,7 @@ static void peer_dirs_handle_old_peers(fastd_context_t *ctx, fastd_peer_config_t
peer = NULL;
}
else {
- pr_verbose(ctx, "peer `%s' changed, resetting", (*peer)->name);
+ pr_verbose("peer `%s' changed, resetting", (*peer)->name);
new_peer = NULL;
}
@@ -633,18 +633,18 @@ static void peer_dirs_handle_old_peers(fastd_context_t *ctx, fastd_peer_config_t
/* no new peer was found, or the old one has changed */
if (peer && (!new_peer || !*new_peer)) {
- pr_verbose(ctx, "removing peer `%s'", (*peer)->name);
+ pr_verbose("removing peer `%s'", (*peer)->name);
fastd_peer_config_t *free_peer = *peer;
*peer = *next;
next = peer;
- fastd_peer_config_purge(ctx, free_peer);
+ fastd_peer_config_purge(free_peer);
}
}
}
-static void peer_dirs_handle_new_peers(fastd_context_t *ctx UNUSED, fastd_peer_config_t **peers, fastd_peer_config_t *new_peers) {
+static void peer_dirs_handle_new_peers(fastd_peer_config_t **peers, fastd_peer_config_t *new_peers) {
fastd_peer_config_t *peer;
for (peer = new_peers; peer; peer = peer->next) {
if (peer->next)
@@ -656,24 +656,24 @@ static void peer_dirs_handle_new_peers(fastd_context_t *ctx UNUSED, fastd_peer_c
}
}
-void fastd_config_load_peer_dirs(fastd_context_t *ctx) {
+void fastd_config_load_peer_dirs(void) {
fastd_peer_config_t *old_peers = conf.peers;
conf.peers = NULL;
- peer_dirs_read_peer_group(ctx);
+ peer_dirs_read_peer_group();
fastd_peer_config_t *new_peers = conf.peers;
conf.peers = old_peers;
- peer_dirs_handle_old_peers(ctx, &conf.peers, &new_peers);
- peer_dirs_handle_new_peers(ctx, &conf.peers, new_peers);
+ peer_dirs_handle_old_peers(&conf.peers, &new_peers);
+ peer_dirs_handle_new_peers(&conf.peers, new_peers);
- assess_peers(ctx);
+ assess_peers();
}
-void fastd_config_release(fastd_context_t *ctx) {
+void fastd_config_release(void) {
while (conf.peers)
- fastd_peer_config_delete(ctx);
+ fastd_peer_config_delete();
while (conf.log_files) {
fastd_log_file_t *next = conf.log_files->next;
diff --git a/src/config.h b/src/config.h
index 60663f4..18e516a 100644
--- a/src/config.h
+++ b/src/config.h
@@ -29,21 +29,21 @@
#include "fastd.h"
-void fastd_config_protocol(fastd_context_t *ctx, const char *name);
-void fastd_config_method(fastd_context_t *ctx, const char *name);
-void fastd_config_cipher(fastd_context_t *ctx, const char *name, const char *impl);
-void fastd_config_mac(fastd_context_t *ctx, const char *name, const char *impl);
-void fastd_config_add_log_file(fastd_context_t *ctx, const char *name, fastd_loglevel_t level);
-void fastd_config_bind_address(fastd_context_t *ctx, const fastd_peer_address_t *address, const char *bindtodev, bool default_v4, bool default_v6);
-void fastd_config_peer_group_push(fastd_context_t *ctx, const char *name);
-void fastd_config_peer_group_pop(fastd_context_t *ctx);
-void fastd_config_release(fastd_context_t *ctx);
-void fastd_config_handle_options(fastd_context_t *ctx, int argc, char *const argv[]);
-void fastd_config_verify(fastd_context_t *ctx);
-
-void fastd_configure(fastd_context_t *ctx, int argc, char *const argv[]);
-void fastd_config_check(fastd_context_t *ctx);
-void fastd_config_load_peer_dirs(fastd_context_t *ctx);
-
-void fastd_add_peer_dir(fastd_context_t *ctx, const char *dir);
-bool fastd_read_config(fastd_context_t *ctx, const char *filename, bool peer_config, int depth);
+void fastd_config_protocol(const char *name);
+void fastd_config_method(const char *name);
+void fastd_config_cipher(const char *name, const char *impl);
+void fastd_config_mac(const char *name, const char *impl);
+void fastd_config_add_log_file(const char *name, fastd_loglevel_t level);
+void fastd_config_bind_address(const fastd_peer_address_t *address, const char *bindtodev, bool default_v4, bool default_v6);
+void fastd_config_peer_group_push(const char *name);
+void fastd_config_peer_group_pop(void);
+void fastd_config_release(void);
+void fastd_config_handle_options(int argc, char *const argv[]);
+void fastd_config_verify(void);
+
+void fastd_configure(int argc, char *const argv[]);
+void fastd_config_check(void);
+void fastd_config_load_peer_dirs(void);
+
+void fastd_add_peer_dir(const char *dir);
+bool fastd_read_config(const char *filename, bool peer_config, int depth);
diff --git a/src/config.y b/src/config.y
index 6545288..78f2f70 100644
--- a/src/config.y
+++ b/src/config.y
@@ -28,7 +28,6 @@
%define api.push-pull push
%name-prefix "fastd_config_"
%locations
-%parse-param {fastd_context_t *ctx}
%parse-param {const char *filename}
%parse-param {int depth}
@@ -139,7 +138,7 @@
#include <limits.h>
- void fastd_config_error(YYLTYPE *loc, fastd_context_t *ctx, const char *filename, int depth, const char *s);
+ void fastd_config_error(YYLTYPE *loc, const char *filename, int depth, const char *s);
}
@@ -242,11 +241,11 @@ secure_handshakes:
;
cipher: TOK_STRING TOK_USE TOK_STRING {
- fastd_config_cipher(ctx, $1->str, $3->str);
+ fastd_config_cipher($1->str, $3->str);
}
mac: TOK_STRING TOK_USE TOK_STRING {
- fastd_config_mac(ctx, $1->str, $3->str);
+ fastd_config_mac($1->str, $3->str);
}
log: TOK_LEVEL log_level {
@@ -265,7 +264,7 @@ log: TOK_LEVEL log_level {
conf.log_syslog_level = $5;
}
| TOK_TO TOK_STRING maybe_log_level {
- fastd_config_add_log_file(ctx, $2->str, $3);
+ fastd_config_add_log_file($2->str, $3);
}
;
@@ -295,11 +294,11 @@ interface: TOK_STRING { free(conf.ifname); conf.ifname = strdup($1->str); }
;
bind: bind_address maybe_bind_interface maybe_bind_default {
- fastd_config_bind_address(ctx, &$1, $2 ? $2->str : NULL, $3 == AF_UNSPEC || $3 == AF_INET, $3 == AF_UNSPEC || $3 == AF_INET6);
+ fastd_config_bind_address(&$1, $2 ? $2->str : NULL, $3 == AF_UNSPEC || $3 == AF_INET, $3 == AF_UNSPEC || $3 == AF_INET6);
}
| TOK_ADDR6_SCOPED maybe_port maybe_bind_default {
fastd_peer_address_t addr = { .in6 = { .sin6_family = AF_INET6, .sin6_addr = $1.addr, .sin6_port = htons($2) } };
- fastd_config_bind_address(ctx, &addr, $1.ifname, $3 == AF_UNSPEC || $3 == AF_INET, $3 == AF_UNSPEC || $3 == AF_INET6);
+ fastd_config_bind_address(&addr, $1.ifname, $3 == AF_UNSPEC || $3 == AF_INET, $3 == AF_UNSPEC || $3 == AF_INET6);
}
;
@@ -351,7 +350,7 @@ packet_mark: TOK_UINT {
mtu: TOK_UINT {
if ($1 < 576 || $1 > 65535) {
- fastd_config_error(&@$, ctx, filename, depth, "invalid MTU");
+ fastd_config_error(&@$, filename, depth, "invalid MTU");
YYERROR;
}
@@ -367,12 +366,12 @@ mode: TOK_TAP { conf.mode = MODE_TAP; }
;
protocol: TOK_STRING {
- fastd_config_protocol(ctx, $1->str);
+ fastd_config_protocol($1->str);
}
;
method: TOK_STRING {
- fastd_config_method(ctx, $1->str);
+ fastd_config_method($1->str);
}
;
@@ -420,7 +419,7 @@ on_verify: sync_def_async TOK_STRING {
;
peer: TOK_STRING {
- fastd_peer_config_new(ctx);
+ fastd_peer_config_new();
conf.peers->name = strdup($1->str);
}
;
@@ -508,26 +507,26 @@ peer_key: TOK_STRING {
;
peer_include: TOK_STRING {
- if (!fastd_read_config(ctx, $1->str, true, depth))
+ if (!fastd_read_config($1->str, true, depth))
YYERROR;
}
;
peer_group: TOK_STRING {
- fastd_config_peer_group_push(ctx, $1->str);
+ fastd_config_peer_group_push($1->str);
}
;
peer_group_after:
{
- fastd_config_peer_group_pop(ctx);
+ fastd_config_peer_group_pop();
}
;
peer_limit: TOK_UINT {
if ($1 > INT_MAX) {
- fastd_config_error(&@$, ctx, filename, depth, "invalid peer limit");
+ fastd_config_error(&@$, filename, depth, "invalid peer limit");
YYERROR;
}
@@ -540,18 +539,18 @@ forward: boolean { conf.forward = $1; }
include: TOK_PEER TOK_STRING maybe_as {
- fastd_peer_config_new(ctx);
+ fastd_peer_config_new();
if ($3)
conf.peers->name = strdup($3->str);
- if (!fastd_read_config(ctx, $2->str, true, depth))
+ if (!fastd_read_config($2->str, true, depth))
YYERROR;
}
| TOK_PEERS TOK_FROM TOK_STRING {
- fastd_add_peer_dir(ctx, $3->str);
+ fastd_add_peer_dir($3->str);
}
| TOK_STRING {
- if (!fastd_read_config(ctx, $1->str, false, depth))
+ if (!fastd_read_config($1->str, false, depth))
YYERROR;
}
;
@@ -601,7 +600,7 @@ colon_or_port: ':'
port: colon_or_port TOK_UINT {
if ($2 < 1 || $2 > 65535) {
- fastd_config_error(&@$, ctx, filename, depth, "invalid port");
+ fastd_config_error(&@$, filename, depth, "invalid port");
YYERROR;
}
$$ = $2;
@@ -609,6 +608,6 @@ port: colon_or_port TOK_UINT {
;
%%
-void fastd_config_error(YYLTYPE *loc, fastd_context_t *ctx, const char *filename, int depth UNUSED, const char *s) {
- pr_error(ctx, "config error: %s at %s:%i:%i", s, filename, loc->first_line, loc->first_column);
+void fastd_config_error(YYLTYPE *loc, const char *filename, int depth UNUSED, const char *s) {
+ pr_error("config error: %s at %s:%i:%i", s, filename, loc->first_line, loc->first_column);
}
diff --git a/src/fastd.c b/src/fastd.c
index 47daada..2649ef2 100644
--- a/src/fastd.c
+++ b/src/fastd.c
@@ -58,6 +58,9 @@
#endif
+fastd_context_t ctx;
+
+
static volatile bool sighup = false;
static volatile bool terminate = false;
static volatile bool dump = false;
@@ -79,7 +82,7 @@ static void on_sigchld(int signo UNUSED) {
while (waitpid(-1, NULL, WNOHANG) > 0) {}
}
-static void init_signals(fastd_context_t *ctx) {
+static void init_signals(void) {
struct sigaction action;
action.sa_flags = 0;
@@ -90,56 +93,56 @@ static void init_signals(fastd_context_t *ctx) {
action.sa_handler = on_sighup;
if (sigaction(SIGHUP, &action, NULL))
- exit_errno(ctx, "sigaction");
+ exit_errno("sigaction");
action.sa_handler = on_terminate;
if (sigaction(SIGTERM, &action, NULL))
- exit_errno(ctx, "sigaction");
+ exit_errno("sigaction");
if (sigaction(SIGQUIT, &action, NULL))
- exit_errno(ctx, "sigaction");
+ exit_errno("sigaction");
if (sigaction(SIGINT, &action, NULL))
- exit_errno(ctx, "sigaction");
+ exit_errno("sigaction");
action.sa_handler = on_sigusr1;
if (sigaction(SIGUSR1, &action, NULL))
- exit_errno(ctx, "sigaction");
+ exit_errno("sigaction");
action.sa_handler = on_sigchld;
if (sigaction(SIGCHLD, &action, NULL))
- exit_errno(ctx, "sigaction");
+ exit_errno("sigaction");
action.sa_handler = SIG_IGN;
if (sigaction(SIGPIPE, &action, NULL))
- exit_errno(ctx, "sigaction");
+ exit_errno("sigaction");
if (sigaction(SIGTTIN, &action, NULL))
- exit_errno(ctx, "sigaction");
+ exit_errno("sigaction");
if (sigaction(SIGTTOU, &action, NULL))
- exit_errno(ctx, "sigaction");
+ exit_errno("sigaction");
}
-void fastd_open_pipe(fastd_context_t *ctx, int *readfd, int *writefd) {
+void fastd_open_pipe(int *readfd, int *writefd) {
int pipefd[2];
if (pipe(pipefd))
- exit_errno(ctx, "pipe");
+ exit_errno("pipe");
- fastd_setfd(ctx, pipefd[0], FD_CLOEXEC, 0);
- fastd_setfd(ctx, pipefd[1], FD_CLOEXEC, 0);
+ fastd_setfd(pipefd[0], FD_CLOEXEC, 0);
+ fastd_setfd(pipefd[1], FD_CLOEXEC, 0);
*readfd = pipefd[0];
*writefd = pipefd[1];
}
-static void init_log(fastd_context_t *ctx) {
+static void init_log(void) {
uid_t uid = geteuid();
gid_t gid = getegid();
if (conf.user || conf.group) {
if (setegid(conf.gid) < 0)
- pr_debug_errno(ctx, "setegid");
+ pr_debug_errno("setegid");
if (seteuid(conf.uid) < 0)
- pr_debug_errno(ctx, "seteuid");
+ pr_debug_errno("seteuid");
}
if (conf.log_syslog_level > LL_UNSPEC)
@@ -152,88 +155,88 @@ static void init_log(fastd_context_t *ctx) {
file->config = config;
file->fd = open(config->filename, O_WRONLY|O_APPEND|O_CREAT, 0600);
- file->next = ctx->log_files;
- ctx->log_files = file;
+ file->next = ctx.log_files;
+ ctx.log_files = file;
}
- ctx->log_initialized = true;
+ ctx.log_initialized = true;
if (seteuid(uid) < 0)
- pr_debug_errno(ctx, "seteuid");
+ pr_debug_errno("seteuid");
if (setegid(gid) < 0)
- pr_debug_errno(ctx, "setegid");
+ pr_debug_errno("setegid");
}
-static void close_log(fastd_context_t *ctx) {
- while (ctx->log_files) {
- fastd_log_fd_t *next = ctx->log_files->next;
+static void close_log(void) {
+ while (ctx.log_files) {
+ fastd_log_fd_t *next = ctx.log_files->next;
- close(ctx->log_files->fd);
- free(ctx->log_files);
+ close(ctx.log_files->fd);
+ free(ctx.log_files);
- ctx->log_files = next;
+ ctx.log_files = next;
}
closelog();
}
-static void init_sockets(fastd_context_t *ctx) {
- ctx->socks = malloc(conf.n_bind_addrs * sizeof(fastd_socket_t));
+static void init_sockets(void) {
+ ctx.socks = malloc(conf.n_bind_addrs * sizeof(fastd_socket_t));
unsigned i;
fastd_bind_address_t *addr = conf.bind_addrs;
for (i = 0; i < conf.n_bind_addrs; i++) {
- ctx->socks[i] = (fastd_socket_t){ .fd = -2, .addr = addr };
+ ctx.socks[i] = (fastd_socket_t){ .fd = -2, .addr = addr };
if (addr == conf.bind_addr_default_v4)
- ctx->sock_default_v4 = &ctx->socks[i];
+ ctx.sock_default_v4 = &ctx.socks[i];
if (addr == conf.bind_addr_default_v6)
- ctx->sock_default_v6 = &ctx->socks[i];
+ ctx.sock_default_v6 = &ctx.socks[i];
addr = addr->next;
}
- ctx->n_socks = conf.n_bind_addrs;
+ ctx.n_socks = conf.n_bind_addrs;
}
-void fastd_setfd(const fastd_context_t *ctx, int fd, int set, int unset) {
+void fastd_setfd(const int fd, int set, int unset) {
int flags = fcntl(fd, F_GETFD);
if (flags < 0)
- exit_errno(ctx, "Getting file descriptor flags failed: fcntl");
+ exit_errno("Getting file descriptor flags failed: fcntl");
if (fcntl(fd, F_SETFD, (flags|set) & (~unset)) < 0)
- exit_errno(ctx, "Setting file descriptor flags failed: fcntl");
+ exit_errno("Setting file descriptor flags failed: fcntl");
}
-void fastd_setfl(const fastd_context_t *ctx, int fd, int set, int unset) {
+void fastd_setfl(const int fd, int set, int unset) {
int flags = fcntl(fd, F_GETFL);
if (flags < 0)
- exit_errno(ctx, "Getting file status flags failed: fcntl");
+ exit_errno("Getting file status flags failed: fcntl");
if (fcntl(fd, F_SETFL, (flags|set) & (~unset)) < 0)
- exit_errno(ctx, "Setting file status flags failed: fcntl");
+ exit_errno("Setting file status flags failed: fcntl");
}
-static void close_sockets(fastd_context_t *ctx) {
+static void close_sockets(void) {
unsigned i;
- for (i = 0; i < ctx->n_socks; i++)
- fastd_socket_close(ctx, &ctx->socks[i]);
+ for (i = 0; i < ctx.n_socks; i++)
+ fastd_socket_close(&ctx.socks[i]);
- free(ctx->socks);
+ free(ctx.socks);
}
-static inline void handle_forward(fastd_context_t *ctx, fastd_peer_t *source_peer, fastd_buffer_t buffer) {
- fastd_eth_addr_t dest_addr = fastd_get_dest_address(ctx, buffer);
+static inline void handle_forward(fastd_peer_t *source_peer, fastd_buffer_t buffer) {
+ fastd_eth_addr_t dest_addr = fastd_get_dest_address(buffer);
if (fastd_eth_addr_is_unicast(dest_addr)) {
- fastd_peer_t *dest_peer = fastd_peer_find_by_eth_addr(ctx, dest_addr);
+ fastd_peer_t *dest_peer = fastd_peer_find_by_eth_addr(dest_addr);
if (dest_peer) {
if (dest_peer != source_peer)
- conf.protocol->send(ctx, dest_peer, buffer);
+ conf.protocol->send(dest_peer, buffer);
else
fastd_buffer_free(buffer);
@@ -241,50 +244,50 @@ static inline void handle_forward(fastd_context_t *ctx, fastd_peer_t *source_pee
}
}
- fastd_send_all(ctx, source_peer, buffer);
+ fastd_send_all(source_peer, buffer);
}
-void fastd_handle_receive(fastd_context_t *ctx, fastd_peer_t *peer, fastd_buffer_t buffer) {
+void fastd_handle_receive(fastd_peer_t *peer, fastd_buffer_t buffer) {
if (conf.mode == MODE_TAP) {
if (buffer.len < ETH_HLEN) {
- pr_debug(ctx, "received truncated packet");
+ pr_debug("received truncated packet");
fastd_buffer_free(buffer);
return;
}
- fastd_eth_addr_t src_addr = fastd_get_source_address(ctx, buffer);
+ fastd_eth_addr_t src_addr = fastd_get_source_address(buffer);
if (fastd_eth_addr_is_unicast(src_addr))
- fastd_peer_eth_addr_add(ctx, peer, src_addr);
+ fastd_peer_eth_addr_add(peer, src_addr);
}
- ctx->rx.packets++;
- ctx->rx.bytes += buffer.len;
+ ctx.rx.packets++;
+ ctx.rx.bytes += buffer.len;
- fastd_tuntap_write(ctx, buffer);
+ fastd_tuntap_write(buffer);
if (conf.mode == MODE_TAP && conf.forward) {
- handle_forward(ctx, peer, buffer);
+ handle_forward(peer, buffer);
return;
}
fastd_buffer_free(buffer);
}
-static inline void on_pre_up(fastd_context_t *ctx) {
- fastd_shell_command_exec(ctx, &conf.on_pre_up, NULL, NULL, NULL);
+static inline void on_pre_up(void) {
+ fastd_shell_command_exec(&conf.on_pre_up, NULL, NULL, NULL);
}
-static inline void on_up(fastd_context_t *ctx) {
- fastd_shell_command_exec(ctx, &conf.on_up, NULL, NULL, NULL);
+static inline void on_up(void) {
+ fastd_shell_command_exec(&conf.on_up, NULL, NULL, NULL);
}
-static inline void on_down(fastd_context_t *ctx) {
- fastd_shell_command_exec(ctx, &conf.on_down, NULL, NULL, NULL);
+static inline void on_down(void) {
+ fastd_shell_command_exec(&conf.on_down, NULL, NULL, NULL);
}
-static inline void on_post_down(fastd_context_t *ctx) {
- fastd_shell_command_exec(ctx, &conf.on_post_down, NULL, NULL, NULL);
+static inline void on_post_down(void) {
+ fastd_shell_command_exec(&conf.on_post_down, NULL, NULL, NULL);
}
static fastd_peer_group_t* init_peer_group(const fastd_peer_group_config_t *config, fastd_peer_group_t *parent) {
@@ -304,8 +307,8 @@ static fastd_peer_group_t* init_peer_group(const fastd_peer_group_config_t *conf
return ret;
}
-static void init_peer_groups(fastd_context_t *ctx) {
- ctx->peer_group = init_peer_group(conf.peer_group, NULL);
+static void init_peer_groups(void) {
+ ctx.peer_group = init_peer_group(conf.peer_group, NULL);
}
static void free_peer_group(fastd_peer_group_t *group) {
@@ -319,38 +322,38 @@ static void free_peer_group(fastd_peer_group_t *group) {
free(group);
}
-static void delete_peer_groups(fastd_context_t *ctx) {
- free_peer_group(ctx->peer_group);
+static void delete_peer_groups(void) {
+ free_peer_group(ctx.peer_group);
}
-static void init_peers(fastd_context_t *ctx) {
+static void init_peers(void) {
fastd_peer_config_t *peer_conf;
for (peer_conf = conf.peers; peer_conf; peer_conf = peer_conf->next)
- conf.protocol->peer_configure(ctx, peer_conf);
+ conf.protocol->peer_configure(peer_conf);
for (peer_conf = conf.peers; peer_conf; peer_conf = peer_conf->next) {
- bool enable = conf.protocol->peer_check(ctx, peer_conf);
+ bool enable = conf.protocol->peer_check(peer_conf);
if (enable && !peer_conf->enabled)
- fastd_peer_add(ctx, peer_conf);
+ fastd_peer_add(peer_conf);
peer_conf->enabled = enable;
}
size_t i;
- for (i = 0; i < VECTOR_LEN(ctx->peers);) {
- fastd_peer_t *peer = VECTOR_INDEX(ctx->peers, i);
+ for (i = 0; i < VECTOR_LEN(ctx.peers);) {
+ fastd_peer_t *peer = VECTOR_INDEX(ctx.peers, i);
if (peer->config) {
if (!peer->config->enabled) {
- pr_info(ctx, "previously enabled peer %P disabled, deleting.", peer);
- fastd_peer_delete(ctx, peer);
+ pr_info("previously enabled peer %P disabled, deleting.", peer);
+ fastd_peer_delete(peer);
continue;
}
}
else {
- if (!conf.protocol->peer_check_temporary(ctx, peer)) {
- fastd_peer_delete(ctx, peer);
+ if (!conf.protocol->peer_check_temporary(peer)) {
+ fastd_peer_delete(peer);
continue;
}
}
@@ -359,93 +362,93 @@ static void init_peers(fastd_context_t *ctx) {
}
}
-static void delete_peers(fastd_context_t *ctx) {
- while (VECTOR_LEN(ctx->peers))
- fastd_peer_delete(ctx, VECTOR_INDEX(ctx->peers, VECTOR_LEN(ctx->peers)-1));
+static void delete_peers(void) {
+ while (VECTOR_LEN(ctx.peers))
+ fastd_peer_delete(VECTOR_INDEX(ctx.peers, VECTOR_LEN(ctx.peers)-1));
}
-static void dump_state(fastd_context_t *ctx) {
- pr_info(ctx, "TX stats: %U packet(s), %U byte(s); dropped: %U packet(s), %U byte(s); error: %U packet(s), %U byte(s)",
- ctx->tx.packets, ctx->tx.bytes, ctx->tx_dropped.packets, ctx->tx_dropped.bytes, ctx->tx_error.packets, ctx->tx_error.bytes);
- pr_info(ctx, "RX stats: %U packet(s), %U byte(s)", ctx->rx.packets, ctx->rx.bytes);
+static void dump_state(void) {
+ pr_info("TX stats: %U packet(s), %U byte(s); dropped: %U packet(s), %U byte(s); error: %U packet(s), %U byte(s)",
+ ctx.tx.packets, ctx.tx.bytes, ctx.tx_dropped.packets, ctx.tx_dropped.bytes, ctx.tx_error.packets, ctx.tx_error.bytes);
+ pr_info("RX stats: %U packet(s), %U byte(s)", ctx.rx.packets, ctx.rx.bytes);
- pr_info(ctx, "dumping peers:");
+ pr_info("dumping peers:");
size_t i;
- for (i = 0; i < VECTOR_LEN(ctx->peers);) {
- fastd_peer_t *peer = VECTOR_INDEX(ctx->peers, i);
+ for (i = 0; i < VECTOR_LEN(ctx.peers);) {
+ fastd_peer_t *peer = VECTOR_INDEX(ctx.peers, i);
if (!fastd_peer_is_established(peer)) {
- pr_info(ctx, "peer %P not connected, address: %I", peer, &peer->address);
+ pr_info("peer %P not connected, address: %I", peer, &peer->address);
continue;
}
if (conf.mode == MODE_TAP) {
unsigned int eth_addresses = 0;
size_t i;
- for (i = 0; i < VECTOR_LEN(ctx->eth_addrs); i++) {
- if (VECTOR_INDEX(ctx->eth_addrs, i).peer == peer)
+ for (i = 0; i < VECTOR_LEN(ctx.eth_addrs); i++) {
+ if (VECTOR_INDEX(ctx.eth_addrs, i).peer == peer)
eth_addresses++;
}
- pr_info(ctx, "peer %P connected, address: %I, associated MAC addresses: %u", peer, &peer->address, eth_addresses);
+ pr_info("peer %P connected, address: %I, associated MAC addresses: %u", peer, &peer->address, eth_addresses);
}
else {
- pr_info(ctx, "peer %P connected, address: %I", peer, &peer->address);
+ pr_info("peer %P connected, address: %I", peer, &peer->address);
}
}
- pr_info(ctx, "dump finished.");
+ pr_info("dump finished.");
}
-static inline void no_valid_address_debug(fastd_context_t *ctx, const fastd_peer_t *peer) {
- pr_debug(ctx, "not sending a handshake to %P (no valid address resolved)", peer);
+static inline void no_valid_address_debug(const fastd_peer_t *peer) {
+ pr_debug("not sending a handshake to %P (no valid address resolved)", peer);
}
-static void send_handshake(fastd_context_t *ctx, fastd_peer_t *peer) {
+static void send_handshake(fastd_peer_t *peer) {
if (!fastd_peer_is_established(peer)) {
if (!peer->next_remote->n_addresses) {
- no_valid_address_debug(ctx, peer);
+ no_valid_address_debug(peer);
return;
}
- fastd_peer_claim_address(ctx, peer, NULL, NULL, &peer->next_remote->addresses[peer->next_remote->current_address]);
- fastd_peer_reset_socket(ctx, peer);
+ fastd_peer_claim_address(peer, NULL, NULL, &peer->next_remote->addresses[peer->next_remote->current_address]);
+ fastd_peer_reset_socket(peer);
}
if (!peer->sock)
return;
if (peer->address.sa.sa_family == AF_UNSPEC) {
- no_valid_address_debug(ctx, peer);
+ no_valid_address_debug(peer);
return;
}
- if (!fastd_timed_out(ctx, &peer->last_handshake_timeout)
+ if (!fastd_timed_out(&peer->last_handshake_timeout)
&& fastd_peer_address_equal(&peer->address, &peer->last_handshake_address)) {
- pr_debug(ctx, "not sending a handshake to %P as we sent one a short time ago", peer);
+ pr_debug("not sending a handshake to %P as we sent one a short time ago", peer);
return;
}
- pr_debug(ctx, "sending handshake to %P[%I]...", peer, &peer->address);
- peer->last_handshake_timeout = fastd_in_seconds(ctx, conf.min_handshake_interval);
+ pr_debug("sending handshake to %P[%I]...", peer, &peer->address);
+ peer->last_handshake_timeout = fastd_in_seconds(conf.min_handshake_interval);
peer->last_handshake_address = peer->address;
- conf.protocol->handshake_init(ctx, peer->sock, &peer->local_address, &peer->address, peer);
+ conf.protocol->handshake_init(peer->sock, &peer->local_address, &peer->address, peer);
}
-static void handle_handshake_queue(fastd_context_t *ctx) {
- if (!ctx->handshake_queue.next)
+static void handle_handshake_queue(void) {
+ if (!ctx.handshake_queue.next)
return;
- fastd_peer_t *peer = container_of(ctx->handshake_queue.next, fastd_peer_t, handshake_entry);
- if (!fastd_timed_out(ctx, &peer->next_handshake))
+ fastd_peer_t *peer = container_of(ctx.handshake_queue.next, fastd_peer_t, handshake_entry);
+ if (!fastd_timed_out(&peer->next_handshake))
return;
- fastd_peer_schedule_handshake_default(ctx, peer);
+ fastd_peer_schedule_handshake_default(peer);
- if (!fastd_peer_may_connect(ctx, peer)) {
+ if (!fastd_peer_may_connect(peer)) {
if (peer->next_remote != NULL) {
- pr_debug(ctx, "temporarily disabling handshakes with %P", peer);
+ pr_debug("temporarily disabling handshakes with %P", peer);
peer->next_remote = NULL;
}
@@ -453,7 +456,7 @@ static void handle_handshake_queue(fastd_context_t *ctx) {
}
if (peer->next_remote || fastd_peer_is_established(peer)) {
- send_handshake(ctx, peer);
+ send_handshake(peer);
if (fastd_peer_is_established(peer))
return;
@@ -470,27 +473,27 @@ static void handle_handshake_queue(fastd_context_t *ctx) {
peer->next_remote->current_address = 0;
if (fastd_remote_is_dynamic(peer->next_remote))
- fastd_resolve_peer(ctx, peer, peer->next_remote);
+ fastd_resolve_peer(peer, peer->next_remote);
}
-static void enable_temporaries(fastd_context_t *ctx) {
+static void enable_temporaries(void) {
size_t i;
- for (i = 0; i < VECTOR_LEN(ctx->peers_temp); i++)
- fastd_peer_enable_temporary(ctx, VECTOR_INDEX(ctx->peers_temp, i));
+ for (i = 0; i < VECTOR_LEN(ctx.peers_temp); i++)
+ fastd_peer_enable_temporary(VECTOR_INDEX(ctx.peers_temp, i));
- VECTOR_RESIZE(ctx->peers_temp, 0);
+ VECTOR_RESIZE(ctx.peers_temp, 0);
}
-static bool maintain_peer(fastd_context_t *ctx, fastd_peer_t *peer) {
+static bool maintain_peer(fastd_peer_t *peer) {
if (fastd_peer_is_temporary(peer) || fastd_peer_is_established(peer)) {
/* check for peer timeout */
- if (fastd_timed_out(ctx, &peer->timeout)) {
+ if (fastd_timed_out(&peer->timeout)) {
if (fastd_peer_is_temporary(peer)) {
- fastd_peer_delete(ctx, peer);
+ fastd_peer_delete(peer);
return false;
}
else {
- fastd_peer_reset(ctx, peer);
+ fastd_peer_reset(peer);
return true;
}
}
@@ -499,34 +502,34 @@ static bool maintain_peer(fastd_context_t *ctx, fastd_peer_t *peer) {
if (!fastd_peer_is_established(peer))
return true;
- if (!fastd_timed_out(ctx, &peer->keepalive_timeout))
+ if (!fastd_timed_out(&peer->keepalive_timeout))
return true;
- pr_debug2(ctx, "sending keepalive to %P", peer);
- conf.protocol->send(ctx, peer, fastd_buffer_alloc(ctx, 0, conf.min_encrypt_head_space, conf.min_encrypt_tail_space));
+ pr_debug2("sending keepalive to %P", peer);
+ conf.protocol->send(peer, fastd_buffer_alloc(0, conf.min_encrypt_head_space, conf.min_encrypt_tail_space));
}
return true;
}
-static void maintenance(fastd_context_t *ctx) {
- fastd_socket_handle_binds(ctx);
+static void maintenance(void) {
+ fastd_socket_handle_binds();
size_t i;
- for (i = 0; i < VECTOR_LEN(ctx->peers);) {
- fastd_peer_t *peer = VECTOR_INDEX(ctx->peers, i);
+ for (i = 0; i < VECTOR_LEN(ctx.peers);) {
+ fastd_peer_t *peer = VECTOR_INDEX(ctx.peers, i);
- if (maintain_peer(ctx, peer))
+ if (maintain_peer(peer))
i++;
}
- fastd_peer_eth_addr_cleanup(ctx);
+ fastd_peer_eth_addr_cleanup();
- ctx->next_maintenance.tv_sec += conf.maintenance_interval;
+ ctx.next_maintenance.tv_sec += conf.maintenance_interval;
}
-static void close_fds(fastd_context_t *ctx) {
+static void close_fds(void) {
struct rlimit rl;
int fd, maxfd;
@@ -543,12 +546,12 @@ static void close_fds(fastd_context_t *ctx) {
}
if (errno != EBADF)
- pr_error_errno(ctx, "close");
+ pr_error_errno("close");
}
}
}
-static void write_pid(fastd_context_t *ctx, pid_t pid) {
+static void write_pid(pid_t pid) {
if (!conf.pid_file)
return;
@@ -557,98 +560,98 @@ static void write_pid(fastd_context_t *ctx, pid_t pid) {
if (conf.user || conf.group) {
if (setegid(conf.gid) < 0)
- pr_debug_errno(ctx, "setegid");
+ pr_debug_errno("setegid");
if (seteuid(conf.uid) < 0)
- pr_debug_errno(ctx, "seteuid");
+ pr_debug_errno("seteuid");
}
int fd = open(conf.pid_file, O_WRONLY|O_CREAT|O_TRUNC, 0666);
if (fd < 0) {
- pr_error_errno(ctx, "can't write PID file: open");
+ pr_error_errno("can't write PID file: open");
goto end;
}
if (dprintf(fd, "%i", pid) < 0)
- pr_error_errno(ctx, "can't write PID file: dprintf");
+ pr_error_errno("can't write PID file: dprintf");
if (close(fd) < 0)
- pr_warn_errno(ctx, "close");
+ pr_warn_errno("close");
end:
if (seteuid(uid) < 0)
- pr_debug_errno(ctx, "seteuid");
+ pr_debug_errno("seteuid");
if (setegid(gid) < 0)
- pr_debug_errno(ctx, "setegid");
+ pr_debug_errno("setegid");
}
-static void set_user(fastd_context_t *ctx) {
+static void set_user(void) {
if (conf.user || conf.group) {
if (setgid(conf.gid) < 0)
- exit_errno(ctx, "setgid");
+ exit_errno("setgid");
if (setuid(conf.uid) < 0)
- exit_errno(ctx, "setuid");
+ exit_errno("setuid");
- pr_info(ctx, "Changed to UID %i, GID %i.", conf.uid, conf.gid);
+ pr_info("Changed to UID %i, GID %i.", conf.uid, conf.gid);
}
}
-static void set_groups(fastd_context_t *ctx) {
+static void set_groups(void) {
if (conf.groups) {
if (setgroups(conf.n_groups, conf.groups) < 0) {
if (errno != EPERM)
- pr_debug_errno(ctx, "setgroups");
+ pr_debug_errno("setgroups");
}
}
else if (conf.user || conf.group) {
if (setgroups(1, &conf.gid) < 0) {
if (errno != EPERM)
- pr_debug_errno(ctx, "setgroups");
+ pr_debug_errno("setgroups");
}
}
}
-static void drop_caps(fastd_context_t *ctx) {
- set_user(ctx);
- fastd_cap_drop(ctx);
+static void drop_caps(void) {
+ set_user();
+ fastd_cap_drop();
}
/* will double fork and forward potential exit codes from the child to the parent */
-static int daemonize(fastd_context_t *ctx) {
+static int daemonize(void) {
static const uint8_t ERROR_STATUS = 1;
uint8_t status = 1;
int parent_rpipe, parent_wpipe;
- fastd_open_pipe(ctx, &parent_rpipe, &parent_wpipe);
+ fastd_open_pipe(&parent_rpipe, &parent_wpipe);
pid_t fork1 = fork();
if (fork1 < 0) {
- exit_errno(ctx, "fork");
+ exit_errno("fork");
}
else if (fork1 == 0) {
/* child 1 */
if (close(parent_rpipe) < 0)
- pr_error_errno(ctx, "close");
+ pr_error_errno("close");
if (setsid() < 0)
- pr_error_errno(ctx, "setsid");
+ pr_error_errno("setsid");
int child_rpipe, child_wpipe;
- fastd_open_pipe(ctx, &child_rpipe, &child_wpipe);
+ fastd_open_pipe(&child_rpipe, &child_wpipe);
pid_t fork2 = fork();
if (fork2 < 0) {
write(parent_wpipe, &ERROR_STATUS, 1);
- exit_errno(ctx, "fork");
+ exit_errno("fork");
}
else if (fork2 == 0) {
/* child 2 */
if (close(child_rpipe) < 0 || close(parent_wpipe) < 0) {
write(child_wpipe, &ERROR_STATUS, 1);
- pr_error_errno(ctx, "close");
+ pr_error_errno("close");
}
return child_wpipe;
@@ -668,7 +671,7 @@ static int daemonize(fastd_context_t *ctx) {
if (ret < 0) {
write(child_wpipe, &ERROR_STATUS, 1);
- pr_error_errno(ctx, "waitpid");
+ pr_error_errno("waitpid");
}
if (WIFEXITED(child_status)) {
@@ -679,7 +682,7 @@ static int daemonize(fastd_context_t *ctx) {
else {
write(parent_wpipe, &ERROR_STATUS, 1);
if (WIFSIGNALED(child_status))
- exit_error(ctx, "child exited with signal %i", WTERMSIG(child_status));
+ exit_error("child exited with signal %i", WTERMSIG(child_status));
exit(1);
}
}
@@ -692,10 +695,10 @@ static int daemonize(fastd_context_t *ctx) {
action.sa_handler = SIG_IGN;
if (sigaction(SIGCHLD, &action, NULL))
- exit_errno(ctx, "sigaction");
+ exit_errno("sigaction");
if (read(parent_rpipe, &status, 1) < 0)
- exit_errno(ctx, "read");
+ exit_errno("read");
exit(status);
}
@@ -704,7 +707,7 @@ static int daemonize(fastd_context_t *ctx) {
}
#ifdef USE_SYSTEMD
-static void notify_systemd(fastd_context_t *ctx, const char *notify_socket) {
+static void notify_systemd(const char *notify_socket) {
int fd;
struct sockaddr_un sa = {};
@@ -722,20 +725,20 @@ static void notify_systemd(fastd_context_t *ctx, const char *notify_socket) {
sa.sun_path[0] = 0;
if (connect(fd, (struct sockaddr*)&sa, offsetof(struct sockaddr_un, sun_path) + strnlen(notify_socket, sizeof(sa.sun_path))) < 0) {
- pr_debug_errno(ctx, "unable to connect to notify socket: connect");
+ pr_debug_errno("unable to connect to notify socket: connect");
close(fd);
return;
}
dprintf(fd, "READY=1\nMAINPID=%lu", (unsigned long) getpid());
- pr_debug(ctx, "sent startup notification to systemd");
+ pr_debug("sent startup notification to systemd");
close(fd);
}
#endif
int main(int argc, char *argv[]) {
- fastd_context_t ctx = {};
+ memset(&ctx, 0, sizeof(ctx));
int status_fd = -1;
#ifdef USE_SYSTEMD
@@ -749,38 +752,38 @@ int main(int argc, char *argv[]) {
}
#endif
- close_fds(&ctx);
+ close_fds();
- fastd_random_bytes(&ctx, &ctx.randseed, sizeof(ctx.randseed), false);
+ fastd_random_bytes(&ctx.randseed, sizeof(ctx.randseed), false);
- fastd_configure(&ctx, argc, argv);
+ fastd_configure(argc, argv);
if (conf.verify_config) {
- fastd_config_verify(&ctx);
+ fastd_config_verify();
exit(0);
}
if (conf.generate_key) {
- conf.protocol->generate_key(&ctx);
+ conf.protocol->generate_key();
exit(0);
}
- conf.protocol_config = conf.protocol->init(&ctx);
+ conf.protocol_config = conf.protocol->init();
if (conf.show_key) {
conf.protocol->show_key();
exit(0);
}
- init_signals(&ctx);
+ init_signals();
if (conf.daemon)
- status_fd = daemonize(&ctx);
+ status_fd = daemonize();
if (chdir("/"))
- pr_error(&ctx, "can't chdir to `/': %s", strerror(errno));
+ pr_error("can't chdir to `/': %s", strerror(errno));
- init_log(&ctx);
+ init_log();
#ifdef HAVE_LIBSODIUM
sodium_init();
@@ -792,39 +795,39 @@ int main(int argc, char *argv[]) {
OPENSSL_config(NULL);
#endif
- fastd_config_check(&ctx);
+ fastd_config_check();
- fastd_update_time(&ctx);
+ fastd_update_time();
- ctx.next_maintenance = fastd_in_seconds(&ctx, conf.maintenance_interval);
+ ctx.next_maintenance = fastd_in_seconds(conf.maintenance_interval);
ctx.unknown_handshakes[0].timeout = ctx.now;
- pr_info(&ctx, "fastd " FASTD_VERSION " starting");
+ pr_info("fastd " FASTD_VERSION " starting");
- fastd_cap_init(&ctx);
+ fastd_cap_init();
/* change groups early as the can be relevant for file access (for PID file & log files) */
- set_groups(&ctx);
+ set_groups();
- init_sockets(&ctx);
- fastd_async_init(&ctx);
- fastd_poll_init(&ctx);
+ init_sockets();
+ fastd_async_init();
+ fastd_poll_init();
- if (!fastd_socket_handle_binds(&ctx))
- exit_error(&ctx, "unable to bind default socket");
+ if (!fastd_socket_handle_binds())
+ exit_error("unable to bind default socket");
- on_pre_up(&ctx);
+ on_pre_up();
- fastd_tuntap_open(&ctx);
+ fastd_tuntap_open();
- init_peer_groups(&ctx);
+ init_peer_groups();
- write_pid(&ctx, getpid());
+ write_pid(getpid());
#ifdef USE_SYSTEMD
if (notify_socket) {
- notify_systemd(&ctx, notify_socket);
+ notify_systemd(notify_socket);
free(notify_socket);
}
#endif
@@ -832,40 +835,40 @@ int main(int argc, char *argv[]) {
if (status_fd >= 0) {
static const uint8_t STATUS = 0;
if (write(status_fd, &STATUS, 1) < 0)
- exit_errno(&ctx, "status: write");
+ exit_errno("status: write");
if (close(status_fd))
- exit_errno(&ctx, "status: close");
+ exit_errno("status: close");
}
if (conf.drop_caps == DROP_CAPS_EARLY)
- drop_caps(&ctx);
+ drop_caps();
- on_up(&ctx);
+ on_up();
if (conf.drop_caps == DROP_CAPS_ON)
- drop_caps(&ctx);
+ drop_caps();
else if (conf.drop_caps == DROP_CAPS_OFF)
- set_user(&ctx);
+ set_user();
- fastd_config_load_peer_dirs(&ctx);
+ fastd_config_load_peer_dirs();
VECTOR_ALLOC(ctx.eth_addrs, 0);
VECTOR_ALLOC(ctx.peers, 0);
VECTOR_ALLOC(ctx.peers_temp, 0);
- fastd_peer_hashtable_init(&ctx);
+ fastd_peer_hashtable_init();
- init_peers(&ctx);
+ init_peers();
while (!terminate) {
- handle_handshake_queue(&ctx);
+ handle_handshake_queue();
- fastd_poll_handle(&ctx);
+ fastd_poll_handle();
- enable_temporaries(&ctx);
+ enable_temporaries();
- if (fastd_timed_out(&ctx, &ctx.next_maintenance))
- maintenance(&ctx);
+ if (fastd_timed_out(&ctx.next_maintenance))
+ maintenance();
sigset_t set, oldset;
sigemptyset(&set);
@@ -874,35 +877,35 @@ int main(int argc, char *argv[]) {
if (sighup) {
sighup = false;
- pr_info(&ctx, "reconfigure triggered");
+ pr_info("reconfigure triggered");
- close_log(&ctx);
- init_log(&ctx);
+ close_log();
+ init_log();
- fastd_config_load_peer_dirs(&ctx);
- init_peers(&ctx);
+ fastd_config_load_peer_dirs();
+ init_peers();
}
if (dump) {
dump = false;
- dump_state(&ctx);
+ dump_state();
}
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
}
- on_down(&ctx);
+ on_down();
- delete_peers(&ctx);
- delete_peer_groups(&ctx);
+ delete_peers();
+ delete_peer_groups();
- fastd_tuntap_close(&ctx);
- close_sockets(&ctx);
- fastd_poll_free(&ctx);
+ fastd_tuntap_close();
+ close_sockets();
+ fastd_poll_free();
- on_post_down(&ctx);
+ on_post_down();
- fastd_peer_hashtable_free(&ctx);
+ fastd_peer_hashtable_free();
VECTOR_FREE(ctx.peers_temp);
VECTOR_FREE(ctx.peers);
@@ -917,8 +920,8 @@ int main(int argc, char *argv[]) {
ERR_free_strings();
#endif
- close_log(&ctx);
- fastd_config_release(&ctx);
+ close_log();
+ fastd_config_release();
return 0;
}
diff --git a/src/fastd.h b/src/fastd.h
index 5cbd4d7..4913a35 100644
--- a/src/fastd.h
+++ b/src/fastd.h
@@ -52,26 +52,26 @@ struct __attribute__((__packed__)) fastd_eth_addr {
struct fastd_protocol {
const char *name;
- fastd_protocol_config_t* (*init)(fastd_context_t *ctx);
- void (*peer_verify)(fastd_context_t *ctx, fastd_peer_config_t *peer_conf);
- void (*peer_configure)(fastd_context_t *ctx, fastd_peer_config_t *peer_conf);
- bool (*peer_check)(fastd_context_t *ctx, fastd_peer_config_t *peer_conf);
- bool (*peer_check_temporary)(fastd_context_t *ctx, fastd_peer_t *peer);
+ fastd_protocol_config_t* (*init)(void);
+ void (*peer_verify)(fastd_peer_config_t *peer_conf);
+ void (*peer_configure)(fastd_peer_config_t *peer_conf);
+ bool (*peer_check)(fastd_peer_config_t *peer_conf);
+ bool (*peer_check_temporary)(fastd_peer_t *peer);
- void (*handshake_init)(fastd_context_t *ctx, const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer);
- void (*handshake_handle)(fastd_context_t *ctx, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, const fastd_handshake_t *handshake, const fastd_method_info_t *method);
+ void (*handshake_init)(const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer);
+ void (*handshake_handle)(fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, const fastd_handshake_t *handshake, const fastd_method_info_t *method);
- void (*handle_recv)(fastd_context_t *ctx, fastd_peer_t *peer, fastd_buffer_t buffer);
- void (*send)(fastd_context_t *ctx, fastd_peer_t *peer, fastd_buffer_t buffer);
+ void (*handle_recv)(fastd_peer_t *peer, fastd_buffer_t buffer);
+ void (*send)(fastd_peer_t *peer, fastd_buffer_t buffer);
- void (*init_peer_state)(fastd_context_t *ctx, fastd_peer_t *peer);
- void (*reset_peer_state)(fastd_context_t *ctx, fastd_peer_t *peer);
- void (*free_peer_state)(fastd_context_t *ctx, fastd_peer_t *peer);
+ void (*init_peer_state)(fastd_peer_t *peer);
+ void (*reset_peer_state)(fastd_peer_t *peer);
+ void (*free_peer_state)(fastd_peer_t *peer);
- void (*generate_key)(fastd_context_t *ctx);
+ void (*generate_key)(void);
void (*show_key)(void);
void (*set_shell_env)(const fastd_peer_t *peer);
- bool (*describe_peer)(const fastd_context_t *ctx, const fastd_peer_t *peer, char *buf, size_t len);
+ bool (*describe_peer)(const fastd_peer_t *peer, char *buf, size_t len);
};
union fastd_peer_address {
@@ -228,8 +228,6 @@ struct fastd_config {
bool verify_config;
};
-extern fastd_config_t conf;
-
struct fastd_context {
bool log_initialized;
fastd_log_fd_t *log_files;
@@ -288,36 +286,40 @@ struct fastd_string_stack {
};
-void fastd_send(fastd_context_t *ctx, const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, fastd_buffer_t buffer, size_t stat_size);
-void fastd_send_all(fastd_context_t *ctx, fastd_peer_t *source_peer, fastd_buffer_t buffer);
-void fastd_send_handshake(fastd_context_t *ctx, const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, fastd_buffer_t buffer);
-void fastd_receive(fastd_context_t *ctx, fastd_socket_t *sock);
+extern fastd_context_t ctx;
+extern fastd_config_t conf;
+
+
+void fastd_send(const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, fastd_buffer_t buffer, size_t stat_size);
+void fastd_send_all(fastd_peer_t *source_peer, fastd_buffer_t buffer);
+void fastd_send_handshake(const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, fastd_buffer_t buffer);
+void fastd_receive(fastd_socket_t *sock);
-void fastd_handle_receive(fastd_context_t *ctx, fastd_peer_t *peer, fastd_buffer_t buffer);
+void fastd_handle_receive(fastd_peer_t *peer, fastd_buffer_t buffer);
-bool fastd_socket_handle_binds(fastd_context_t *ctx);
-fastd_socket_t* fastd_socket_open(fastd_context_t *ctx, fastd_peer_t *peer, int af);
-void fastd_socket_close(fastd_context_t *ctx, fastd_socket_t *sock);
-void fastd_socket_error(fastd_context_t *ctx, fastd_socket_t *sock);
+bool fastd_socket_handle_binds(void);
+fastd_socket_t* fastd_socket_open(fastd_peer_t *peer, int af);
+void fastd_socket_close(fastd_socket_t *sock);
+void fastd_socket_error(fastd_socket_t *sock);
-void fastd_open_pipe(fastd_context_t *ctx, int *readfd, int *writefd);
-void fastd_setfd(const fastd_context_t *ctx, int fd, int set, int unset);
-void fastd_setfl(const fastd_context_t *ctx, int fd, int set, int unset);
+void fastd_open_pipe(int *readfd, int *writefd);
+void fastd_setfd(const int fd, int set, int unset);
+void fastd_setfl(const int fd, int set, int unset);
-void fastd_resolve_peer(fastd_context_t *ctx, fastd_peer_t *peer, fastd_remote_t *remote);
+void fastd_resolve_peer(fastd_peer_t *peer, fastd_remote_t *remote);
-void fastd_tuntap_open(fastd_context_t *ctx);
-fastd_buffer_t fastd_tuntap_read(fastd_context_t *ctx);
-void fastd_tuntap_write(fastd_context_t *ctx, fastd_buffer_t buffer);
-void fastd_tuntap_close(fastd_context_t *ctx);
+void fastd_tuntap_open(void);
+fastd_buffer_t fastd_tuntap_read(void);
+void fastd_tuntap_write(fastd_buffer_t buffer);
+void fastd_tuntap_close(void);
-void fastd_cap_init(fastd_context_t *ctx);
-void fastd_cap_drop(fastd_context_t *ctx);
+void fastd_cap_init(void);
+void fastd_cap_drop(void);
-void fastd_random_bytes(fastd_context_t *ctx, void *buffer, size_t len, bool secure);
+void fastd_random_bytes(void *buffer, size_t len, bool secure);
-static inline int fastd_rand(fastd_context_t *ctx, int min, int max) {
- unsigned int r = (unsigned int)rand_r(&ctx->randseed);
+static inline int fastd_rand(int min, int max) {
+ unsigned int r = (unsigned int)rand_r(&ctx.randseed);
return (r%(max-min) + min);
}
@@ -338,19 +340,19 @@ static inline size_t alignto(size_t l, size_t a) {
}
-static inline size_t fastd_max_inner_packet(const fastd_context_t *ctx) {
+static inline size_t fastd_max_inner_packet(void) {
switch (conf.mode) {
case MODE_TAP:
return conf.mtu+ETH_HLEN;
case MODE_TUN:
return conf.mtu;
default:
- exit_bug(ctx, "invalid mode");
+ exit_bug("invalid mode");
}
}
-static inline size_t fastd_max_outer_packet(const fastd_context_t *ctx) {
- return PACKET_TYPE_LEN + fastd_max_inner_packet(ctx) + conf.max_overhead;
+static inline size_t fastd_max_outer_packet(void) {
+ return PACKET_TYPE_LEN + fastd_max_inner_packet() + conf.max_overhead;
}
static inline bool fastd_peer_address_is_v6_ll(const fastd_peer_address_t *addr) {
@@ -401,18 +403,18 @@ static inline int timespec_diff(const struct timespec *tp1, const struct timespe
return ((tp1->tv_sec - tp2->tv_sec))*1000 + (tp1->tv_nsec - tp2->tv_nsec)/1e6;
}
-static inline bool fastd_timed_out(const fastd_context_t *ctx, const struct timespec *timeout) {
- return !timespec_after(timeout, &ctx->now);
+static inline bool fastd_timed_out(const struct timespec *timeout) {
+ return !timespec_after(timeout, &ctx.now);
}
-static inline struct timespec fastd_in_seconds(const fastd_context_t *ctx, int seconds) {
- struct timespec ret = ctx->now;
+static inline struct timespec fastd_in_seconds(const int seconds) {
+ struct timespec ret = ctx.now;
ret.tv_sec += seconds;
return ret;
}
-static inline void fastd_update_time(fastd_context_t *ctx) {
- clock_gettime(CLOCK_MONOTONIC, &ctx->now);
+static inline void fastd_update_time(void) {
+ clock_gettime(CLOCK_MONOTONIC, &ctx.now);
}
static inline bool strequal(const char *str1, const char *str2) {
diff --git a/src/handshake.c b/src/handshake.c
index f6a256d..2cb6cc3 100644
--- a/src/handshake.c
+++ b/src/handshake.c
@@ -97,7 +97,7 @@ static fastd_string_stack_t* parse_string_list(const uint8_t *data, size_t len)
return ret;
}
-static fastd_buffer_t new_handshake(fastd_context_t *ctx, uint8_t type, const fastd_method_info_t *method, bool with_method_list, size_t tail_space) {
+static fastd_buffer_t new_handshake(uint8_t type, const fastd_method_info_t *method, bool with_method_list, size_t tail_space) {
size_t version_len = strlen(FASTD_VERSION);
size_t protocol_len = strlen(conf.protocol->name);
size_t method_len = method ? strlen(method->name) : 0;
@@ -108,7 +108,7 @@ static fastd_buffer_t new_handshake(fastd_context_t *ctx, uint8_t type, const fa
if (with_method_list)
method_list = create_method_list(&method_list_len);
- fastd_buffer_t buffer = fastd_buffer_alloc(ctx, sizeof(fastd_handshake_packet_t), 1,
+ fastd_buffer_t buffer = fastd_buffer_alloc(sizeof(fastd_handshake_packet_t), 1,
3*5 + /* handshake type, mode, reply code */
6 + /* MTU */
4+version_len + /* version name */
@@ -121,35 +121,35 @@ static fastd_buffer_t new_handshake(fastd_context_t *ctx, uint8_t type, const fa
packet->rsv = 0;
packet->tlv_len = 0;
- fastd_handshake_add_uint8(ctx, &buffer, RECORD_HANDSHAKE_TYPE, type);
- fastd_handshake_add_uint8(ctx, &buffer, RECORD_MODE, conf.mode);
- fastd_handshake_add_uint16(ctx, &buffer, RECORD_MTU, conf.mtu);
+ fastd_handshake_add_uint8(&buffer, RECORD_HANDSHAKE_TYPE, type);
+ fastd_handshake_add_uint8(&buffer, RECORD_MODE, conf.mode);
+ fastd_handshake_add_uint16(&buffer, RECORD_MTU, conf.mtu);
- fastd_handshake_add(ctx, &buffer, RECORD_VERSION_NAME, version_len, FASTD_VERSION);
- fastd_handshake_add(ctx, &buffer, RECORD_PROTOCOL_NAME, protocol_len, conf.protocol->name);
+ fastd_handshake_add(&buffer, RECORD_VERSION_NAME, version_len, FASTD_VERSION);
+ fastd_handshake_add(&buffer, RECORD_PROTOCOL_NAME, protocol_len, conf.protocol->name);
if (method && (!with_method_list || !conf.secure_handshakes))
- fastd_handshake_add(ctx, &buffer, RECORD_METHOD_NAME, method_len, method->name);
+ fastd_handshake_add(&buffer, RECORD_METHOD_NAME, method_len, method->name);
if (with_method_list) {
- fastd_handshake_add(ctx, &buffer, RECORD_METHOD_LIST, method_list_len, method_list);
+ fastd_handshake_add(&buffer, RECORD_METHOD_LIST, method_list_len, method_list);
free(method_list);
}
return buffer;
}
-fastd_buffer_t fastd_handshake_new_init(fastd_context_t *ctx, size_t tail_space) {
- return new_handshake(ctx, 1, NULL, !conf.secure_handshakes, tail_space);
+fastd_buffer_t fastd_handshake_new_init(size_t tail_space) {
+ return new_handshake(1, NULL, !conf.secure_handshakes, tail_space);
}
-fastd_buffer_t fastd_handshake_new_reply(fastd_context_t *ctx, const fastd_handshake_t *handshake, const fastd_method_info_t *method, bool with_method_list, size_t tail_space) {
- fastd_buffer_t buffer = new_handshake(ctx, handshake->type+1, method, with_method_list, tail_space);
- fastd_handshake_add_uint8(ctx, &buffer, RECORD_REPLY_CODE, 0);
+fastd_buffer_t fastd_handshake_new_reply(const fastd_handshake_t *handshake, const fastd_method_info_t *method, bool with_method_list, size_t tail_space) {
+ fastd_buffer_t buffer = new_handshake(handshake->type+1, method, with_method_list, tail_space);
+ fastd_handshake_add_uint8(&buffer, RECORD_REPLY_CODE, 0);
return buffer;
}
-static void print_error(fastd_context_t *ctx, const char *prefix, const fastd_peer_address_t *remote_addr, uint8_t reply_code, uint8_t error_detail) {
+static void print_error(const char *prefix, const fastd_peer_address_t *remote_addr, uint8_t reply_code, uint8_t error_detail) {
const char *error_field_str;
if (error_detail >= RECORD_MAX)
@@ -162,32 +162,32 @@ static void print_error(fastd_context_t *ctx, const char *prefix, const fastd_pe
break;
case REPLY_MANDATORY_MISSING:
- pr_warn(ctx, "Handshake with %I failed: %s error: mandatory field `%s' missing", remote_addr, prefix, error_field_str);
+ pr_warn("Handshake with %I failed: %s error: mandatory field `%s' missing", remote_addr, prefix, error_field_str);
break;
case REPLY_UNACCEPTABLE_VALUE:
- pr_warn(ctx, "Handshake with %I failed: %s error: unacceptable value for field `%s'", remote_addr, prefix, error_field_str);
+ pr_warn("Handshake with %I failed: %s error: unacceptable value for field `%s'", remote_addr, prefix, error_field_str);
break;
default:
- pr_warn(ctx, "Handshake with %I failed: %s error: unknown code %i", remote_addr, prefix, reply_code);
+ pr_warn("Handshake with %I failed: %s error: unknown code %i", remote_addr, prefix, reply_code);
}
}
-static void send_error(fastd_context_t *ctx, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, const fastd_handshake_t *handshake, uint8_t reply_code, uint8_t error_detail) {
- print_error(ctx, "sending", remote_addr, reply_code, error_detail);
+static void send_error(fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, const fastd_handshake_t *handshake, uint8_t reply_code, uint8_t error_detail) {
+ print_error("sending", remote_addr, reply_code, error_detail);
- fastd_buffer_t buffer = fastd_buffer_alloc(ctx, sizeof(fastd_handshake_packet_t), 0, 3*5 /* enough space for handshake type, reply code and error detail */);
+ fastd_buffer_t buffer = fastd_buffer_alloc(sizeof(fastd_handshake_packet_t), 0, 3*5 /* enough space for handshake type, reply code and error detail */);
fastd_handshake_packet_t *reply = buffer.data;
reply->rsv = 0;
reply->tlv_len = 0;
- fastd_handshake_add_uint8(ctx, &buffer, RECORD_HANDSHAKE_TYPE, handshake->type+1);
- fastd_handshake_add_uint8(ctx, &buffer, RECORD_REPLY_CODE, reply_code);
- fastd_handshake_add_uint8(ctx, &buffer, RECORD_ERROR_DETAIL, error_detail);
+ fastd_handshake_add_uint8(&buffer, RECORD_HANDSHAKE_TYPE, handshake->type+1);
+ fastd_handshake_add_uint8(&buffer, RECORD_REPLY_CODE, reply_code);
+ fastd_handshake_add_uint8(&buffer, RECORD_ERROR_DETAIL, error_detail);
- fastd_send_handshake(ctx, sock, local_addr, remote_addr, peer, buffer);
+ fastd_send_handshake(sock, local_addr, remote_addr, peer, buffer);
}
static inline fastd_handshake_t parse_tlvs(const fastd_buffer_t *buffer) {
@@ -232,27 +232,27 @@ static inline fastd_handshake_t parse_tlvs(const fastd_buffer_t *buffer) {
return handshake;
}
-static inline void print_error_reply(fastd_context_t *ctx, const fastd_peer_address_t *remote_addr, const fastd_handshake_t *handshake) {
+static inline void print_error_reply(const fastd_peer_address_t *remote_addr, const fastd_handshake_t *handshake) {
uint8_t reply_code = AS_UINT8(handshake->records[RECORD_REPLY_CODE]);
uint8_t error_detail = RECORD_MAX;
if (handshake->records[RECORD_ERROR_DETAIL].length == 1)
error_detail = AS_UINT8(handshake->records[RECORD_ERROR_DETAIL]);
- print_error(ctx, "received", remote_addr, reply_code, error_detail);
+ print_error("received", remote_addr, reply_code, error_detail);
}
-static inline bool check_records(fastd_context_t *ctx, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, const fastd_handshake_t *handshake) {
+static inline bool check_records(fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, const fastd_handshake_t *handshake) {
if (handshake->records[RECORD_PROTOCOL_NAME].data) {
if (!record_equal(conf.protocol->name, &handshake->records[RECORD_PROTOCOL_NAME])) {
- send_error(ctx, sock, local_addr, remote_addr, peer, handshake, REPLY_UNACCEPTABLE_VALUE, RECORD_PROTOCOL_NAME);
+ send_error(sock, local_addr, remote_addr, peer, handshake, REPLY_UNACCEPTABLE_VALUE, RECORD_PROTOCOL_NAME);
return false;
}
}
if (handshake->records[RECORD_MODE].data) {
if (handshake->records[RECORD_MODE].length != 1 || AS_UINT8(handshake->records[RECORD_MODE]) != conf.mode) {
- send_error(ctx, sock, local_addr, remote_addr, peer, handshake, REPLY_UNACCEPTABLE_VALUE, RECORD_MODE);
+ send_error(sock, local_addr, remote_addr, peer, handshake, REPLY_UNACCEPTABLE_VALUE, RECORD_MODE);
return false;
}
}
@@ -260,7 +260,7 @@ static inline bool check_records(fastd_context_t *ctx, fastd_socket_t *sock, con
if (!conf.secure_handshakes || handshake->type > 1) {
if (handshake->records[RECORD_MTU].length == 2) {
if (AS_UINT16(handshake->records[RECORD_MTU]) != conf.mtu) {
- pr_warn(ctx, "MTU configuration differs with peer %I: local MTU is %u, remote MTU is %u",
+ pr_warn("MTU configuration differs with peer %I: local MTU is %u, remote MTU is %u",
remote_addr, conf.mtu, AS_UINT16(handshake->records[RECORD_MTU]));
}
}
@@ -268,12 +268,12 @@ static inline bool check_records(fastd_context_t *ctx, fastd_socket_t *sock, con
if (handshake->type > 1) {
if (handshake->records[RECORD_REPLY_CODE].length != 1) {
- pr_warn(ctx, "received handshake reply without reply code from %I", remote_addr);
+ pr_warn("received handshake reply without reply code from %I", remote_addr);
return false;
}
if (AS_UINT8(handshake->records[RECORD_REPLY_CODE]) != REPLY_SUCCESS) {
- print_error_reply(ctx, remote_addr, handshake);
+ print_error_reply(remote_addr, handshake);
return false;
}
}
@@ -314,25 +314,25 @@ static inline const fastd_method_info_t* get_method(const fastd_handshake_t *han
return get_method_by_name((const char*)handshake->records[RECORD_METHOD_NAME].data, handshake->records[RECORD_METHOD_NAME].length);
}
-void fastd_handshake_handle(fastd_context_t *ctx, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, fastd_buffer_t buffer) {
+void fastd_handshake_handle(fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, fastd_buffer_t buffer) {
char *peer_version = NULL;
const fastd_method_info_t *method = NULL;
fastd_handshake_t handshake = parse_tlvs(&buffer);
if (!handshake.tlv_data) {
- pr_warn(ctx, "received a short handshake from %I", remote_addr);
+ pr_warn("received a short handshake from %I", remote_addr);
goto end_free;
}
if (handshake.records[RECORD_HANDSHAKE_TYPE].length != 1) {
- pr_debug(ctx, "received handshake without handshake type from %I", remote_addr);
+ pr_debug("received handshake without handshake type from %I", remote_addr);
goto end_free;
}
handshake.type = AS_UINT8(handshake.records[RECORD_HANDSHAKE_TYPE]);
- if (!check_records(ctx, sock, local_addr, remote_addr, peer, &handshake))
+ if (!check_records(sock, local_addr, remote_addr, peer, &handshake))
goto end_free;
if (!conf.secure_handshakes || handshake.type > 1) {
@@ -343,11 +343,11 @@ void fastd_handshake_handle(fastd_context_t *ctx, fastd_socket_t *sock, const fa
}
if (handshake.type > 1 && !method) {
- send_error(ctx, sock, local_addr, remote_addr, peer, &handshake, REPLY_UNACCEPTABLE_VALUE, RECORD_METHOD_LIST);
+ send_error(sock, local_addr, remote_addr, peer, &handshake, REPLY_UNACCEPTABLE_VALUE, RECORD_METHOD_LIST);
goto end_free;
}
- conf.protocol->handshake_handle(ctx, sock, local_addr, remote_addr, peer, &handshake, method);
+ conf.protocol->handshake_handle(sock, local_addr, remote_addr, peer, &handshake, method);
end_free:
free(peer_version);
diff --git a/src/handshake.h b/src/handshake.h
index 5674b83..a401c2a 100644
--- a/src/handshake.h
+++ b/src/handshake.h
@@ -77,10 +77,10 @@ struct fastd_handshake {
};
-fastd_buffer_t fastd_handshake_new_init(fastd_context_t *ctx, size_t tail_space);
-fastd_buffer_t fastd_handshake_new_reply(fastd_context_t *ctx, const fastd_handshake_t *handshake, const fastd_method_info_t *method, bool with_method_list, size_t tail_space);
+fastd_buffer_t fastd_handshake_new_init(size_t tail_space);
+fastd_buffer_t fastd_handshake_new_reply(const fastd_handshake_t *handshake, const fastd_method_info_t *method, bool with_method_list, size_t tail_space);
-void fastd_handshake_handle(fastd_context_t *ctx, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, fastd_buffer_t buffer);
+void fastd_handshake_handle(fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, fastd_buffer_t buffer);
static inline void* fastd_handshake_tlv_data(const fastd_buffer_t *buffer) {
@@ -93,11 +93,11 @@ static inline uint16_t fastd_handshake_tlv_len(const fastd_buffer_t *buffer) {
return ntohs(packet->tlv_len);
}
-static inline uint8_t* fastd_handshake_extend(fastd_context_t *ctx, fastd_buffer_t *buffer, fastd_handshake_record_type_t type, size_t len) {
+static inline uint8_t* fastd_handshake_extend(fastd_buffer_t *buffer, fastd_handshake_record_type_t type, size_t len) {
uint8_t *dst = buffer->data + buffer->len;
if (buffer->data + buffer->len + 4 + len > buffer->base + buffer->base_len)
- exit_bug(ctx, "not enough buffer allocated for handshake");
+ exit_bug("not enough buffer allocated for handshake");
buffer->len += 4 + len;
@@ -112,27 +112,27 @@ static inline uint8_t* fastd_handshake_extend(fastd_context_t *ctx, fastd_buffer
return dst+4;
}
-static inline void fastd_handshake_add(fastd_context_t *ctx, fastd_buffer_t *buffer, fastd_handshake_record_type_t type, size_t len, const void *data) {
- uint8_t *dst = fastd_handshake_extend(ctx, buffer, type, len);
+static inline void fastd_handshake_add(fastd_buffer_t *buffer, fastd_handshake_record_type_t type, size_t len, const void *data) {
+ uint8_t *dst = fastd_handshake_extend(buffer, type, len);
memcpy(dst, data, len);
}
-static inline uint8_t* fastd_handshake_add_zero(fastd_context_t *ctx, fastd_buffer_t *buffer, fastd_handshake_record_type_t type, size_t len) {
- uint8_t *dst = fastd_handshake_extend(ctx, buffer, type, len);
+static inline uint8_t* fastd_handshake_add_zero(fastd_buffer_t *buffer, fastd_handshake_record_type_t type, size_t len) {
+ uint8_t *dst = fastd_handshake_extend(buffer, type, len);
memset(dst, 0, len);
return dst;
}
-static inline void fastd_handshake_add_uint8(fastd_context_t *ctx, fastd_buffer_t *buffer, fastd_handshake_record_type_t type, uint8_t value) {
- uint8_t *dst = fastd_handshake_extend(ctx, buffer, type, 1);
+static inline void fastd_handshake_add_uint8(fastd_buffer_t *buffer, fastd_handshake_record_type_t type, uint8_t value) {
+ uint8_t *dst = fastd_handshake_extend(buffer, type, 1);
dst[0] = value;
}
-static inline void fastd_handshake_add_uint16(fastd_context_t *ctx, fastd_buffer_t *buffer, fastd_handshake_record_type_t type, uint16_t value) {
- uint8_t *dst = fastd_handshake_extend(ctx, buffer, type, 2);
+static inline void fastd_handshake_add_uint16(fastd_buffer_t *buffer, fastd_handshake_record_type_t type, uint16_t value) {
+ uint8_t *dst = fastd_handshake_extend(buffer, type, 2);
dst[0] = value;
dst[1] = value >> 8;
diff --git a/src/log.c b/src/log.c
index aa04517..9bcbd14 100644
--- a/src/log.c
+++ b/src/log.c
@@ -44,7 +44,7 @@ static inline size_t snprintf_safe(char *buffer, size_t size, const char *format
return min_size_t(ret, size);
}
-static size_t snprint_peer_address(const fastd_context_t *ctx, char *buffer, size_t size, const fastd_peer_address_t *address, const char *iface, bool bind_address) {
+static size_t snprint_peer_address(char *buffer, size_t size, const fastd_peer_address_t *address, const char *iface, bool bind_address) {
char addr_buf[INET6_ADDRSTRLEN] = "";
switch (address->sa.sa_family) {
@@ -79,24 +79,24 @@ static size_t snprint_peer_address(const fastd_context_t *ctx, char *buffer, siz
return 0;
default:
- exit_bug(ctx, "unsupported address family");
+ exit_bug("unsupported address family");
}
}
-static size_t snprint_peer_str(const fastd_context_t *ctx, char *buffer, size_t size, const fastd_peer_t *peer) {
+static size_t snprint_peer_str(char *buffer, size_t size, const fastd_peer_t *peer) {
if (peer->config && peer->config->name) {
return snprintf_safe(buffer, size, "<%s>", peer->config->name);
}
else {
char buf[65];
- if (conf.protocol->describe_peer(ctx, peer, buf, sizeof(buf)))
+ if (conf.protocol->describe_peer(peer, buf, sizeof(buf)))
return snprintf_safe(buffer, size, "{%s}", buf);
else
return snprintf_safe(buffer, size, "(null)");
}
}
-static int fastd_vsnprintf(const fastd_context_t *ctx, char *buffer, size_t size, const char *format, va_list ap) {
+static int fastd_vsnprintf(char *buffer, size_t size, const char *format, va_list ap) {
char *buffer_start = buffer;
char *buffer_end = buffer+size;
@@ -159,7 +159,7 @@ static int fastd_vsnprintf(const fastd_context_t *ctx, char *buffer, size_t size
p = va_arg(ap, const fastd_peer_t*);
if (p)
- buffer += snprint_peer_str(ctx, buffer, buffer_end-buffer, (const fastd_peer_t*)p);
+ buffer += snprint_peer_str(buffer, buffer_end-buffer, (const fastd_peer_t*)p);
else
buffer += snprintf_safe(buffer, buffer_end-buffer, "(null)");
break;
@@ -172,13 +172,13 @@ static int fastd_vsnprintf(const fastd_context_t *ctx, char *buffer, size_t size
iface = (*format == 'L') ? va_arg(ap, const char*) : NULL;
if (p)
- buffer += snprint_peer_address(ctx, buffer, buffer_end-buffer, (const fastd_peer_address_t*)p, iface, *format != 'I');
+ buffer += snprint_peer_address(buffer, buffer_end-buffer, (const fastd_peer_address_t*)p, iface, *format != 'I');
else
buffer += snprintf_safe(buffer, buffer_end-buffer, "(null)");
break;
default:
- pr_warn(ctx, "fastd_vsnprintf: unknown format conversion specifier '%c'", *format);
+ pr_warn("fastd_vsnprintf: unknown format conversion specifier '%c'", *format);
*buffer_start = 0;
return -1;
}
@@ -228,18 +228,18 @@ static inline int get_syslog_level(fastd_loglevel_t log_level) {
}
}
-void fastd_logf(const fastd_context_t *ctx, fastd_loglevel_t level, const char *format, ...) {
+void fastd_logf(fastd_loglevel_t level, const char *format, ...) {
char buffer[1024];
char timestr[100] = "";
va_list ap;
va_start(ap, format);
- fastd_vsnprintf(ctx, buffer, sizeof(buffer), format, ap);
+ fastd_vsnprintf(buffer, sizeof(buffer), format, ap);
va_end(ap);
buffer[sizeof(buffer)-1] = 0;
- if (!ctx->log_initialized || level <= conf.log_stderr_level || conf.log_files) {
+ if (!ctx.log_initialized || level <= conf.log_stderr_level || conf.log_files) {
time_t t;
struct tm tm;
@@ -250,15 +250,15 @@ void fastd_logf(const fastd_context_t *ctx, fastd_loglevel_t level, const char *
}
}
- if (!ctx->log_initialized || level <= conf.log_stderr_level)
+ if (!ctx.log_initialized || level <= conf.log_stderr_level)
fprintf(stderr, "%s%s%s\n", timestr, get_log_prefix(level), buffer);
- if (ctx->log_initialized) {
+ if (ctx.log_initialized) {
if (level <= conf.log_syslog_level)
syslog(get_syslog_level(level), "%s", buffer);
fastd_log_fd_t *file;
- for (file = ctx->log_files; file; file = file->next) {
+ for (file = ctx.log_files; file; file = file->next) {
if (level <= file->config->level)
dprintf(file->fd, "%s%s%s\n", timestr, get_log_prefix(level), buffer);
}
diff --git a/src/log.h b/src/log.h
index 6e47590..0fe6b67 100644
--- a/src/log.h
+++ b/src/log.h
@@ -35,22 +35,22 @@
#define FASTD_DEFAULT_LOG_LEVEL LL_VERBOSE
-void fastd_logf(const fastd_context_t *ctx, fastd_loglevel_t level, const char *format, ...);
-
-#define pr_fatal(ctx, args...) fastd_logf(ctx, LL_FATAL, args)
-#define pr_error(ctx, args...) fastd_logf(ctx, LL_ERROR, args)
-#define pr_warn(ctx, args...) fastd_logf(ctx, LL_WARN, args)
-#define pr_info(ctx, args...) fastd_logf(ctx, LL_INFO, args)
-#define pr_verbose(ctx, args...) fastd_logf(ctx, LL_VERBOSE, args)
-#define pr_debug(ctx, args...) fastd_logf(ctx, LL_DEBUG, args)
-#define pr_debug2(ctx, args...) fastd_logf(ctx, LL_DEBUG2, args)
-
-#define pr_error_errno(ctx, message) pr_error(ctx, "%s: %s", message, strerror(errno))
-#define pr_warn_errno(ctx, message) pr_warn(ctx, "%s: %s", message, strerror(errno))
-#define pr_debug_errno(ctx, message) pr_debug(ctx, "%s: %s", message, strerror(errno))
-#define pr_debug2_errno(ctx, message) pr_debug2(ctx, "%s: %s", message, strerror(errno))
-
-#define exit_fatal(ctx, args...) do { pr_fatal(ctx, args); abort(); } while(0)
-#define exit_bug(ctx, message) exit_fatal(ctx, "BUG: %s", message)
-#define exit_error(ctx, args...) do { pr_error(ctx, args); exit(1); } while(0)
-#define exit_errno(ctx, message) exit_error(ctx, "%s: %s", message, strerror(errno))
+void fastd_logf(const fastd_loglevel_t level, const char *format, ...);
+
+#define pr_fatal(args...) fastd_logf(LL_FATAL, args)
+#define pr_error(args...) fastd_logf(LL_ERROR, args)
+#define pr_warn(args...) fastd_logf(LL_WARN, args)
+#define pr_info(args...) fastd_logf(LL_INFO, args)
+#define pr_verbose(args...) fastd_logf(LL_VERBOSE, args)
+#define pr_debug(args...) fastd_logf(LL_DEBUG, args)
+#define pr_debug2(args...) fastd_logf(LL_DEBUG2, args)
+
+#define pr_error_errno(message) pr_error("%s: %s", message, strerror(errno))
+#define pr_warn_errno(message) pr_warn("%s: %s", message, strerror(errno))
+#define pr_debug_errno(message) pr_debug("%s: %s", message, strerror(errno))
+#define pr_debug2_errno(message) pr_debug2("%s: %s", message, strerror(errno))
+
+#define exit_fatal(args...) do { pr_fatal(args); abort(); } while(0)
+#define exit_bug(message) exit_fatal("BUG: %s", message)
+#define exit_error(args...) do { pr_error(args); exit(1); } while(0)
+#define exit_errno(message) exit_error("%s: %s", message, strerror(errno))
diff --git a/src/method.h b/src/method.h
index b5ff2f5..d7f3304 100644
--- a/src/method.h
+++ b/src/method.h
@@ -45,18 +45,18 @@ struct fastd_method_provider {
bool (*create_by_name)(const char *name, fastd_method_t **method);
void (*destroy)(fastd_method_t *method);
- size_t (*key_length)(fastd_context_t *ctx, const fastd_method_t *method);
-
- fastd_method_session_state_t* (*session_init)(fastd_context_t *ctx, const fastd_method_t *method, const uint8_t *secret, bool initiator);
- fastd_method_session_state_t* (*session_init_compat)(fastd_context_t *ctx, const fastd_method_t *method, const uint8_t *secret, size_t length, bool initiator);
- bool (*session_is_valid)(fastd_context_t *ctx, fastd_method_session_state_t *session);
- bool (*session_is_initiator)(fastd_context_t *ctx, fastd_method_session_state_t *session);
- bool (*session_want_refresh)(fastd_context_t *ctx, fastd_method_session_state_t *session);
- void (*session_superseded)(fastd_context_t *ctx, fastd_method_session_state_t *session);
- void (*session_free)(fastd_context_t *ctx, fastd_method_session_state_t *session);
-
- bool (*encrypt)(fastd_context_t *ctx, fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in);
- bool (*decrypt)(fastd_context_t *ctx, fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in);
+ size_t (*key_length)(const fastd_method_t *method);
+
+ fastd_method_session_state_t* (*session_init)(const fastd_method_t *method, const uint8_t *secret, bool initiator);
+ fastd_method_session_state_t* (*session_init_compat)(const fastd_method_t *method, const uint8_t *secret, size_t length, bool initiator);
+ bool (*session_is_valid)(fastd_method_session_state_t *session);
+ bool (*session_is_initiator)(fastd_method_session_state_t *session);
+ bool (*session_want_refresh)(fastd_method_session_state_t *session);
+ void (*session_superseded)(fastd_method_session_state_t *session);
+ void (*session_free)(fastd_method_session_state_t *session);
+
+ bool (*encrypt)(fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in);
+ bool (*decrypt)(fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in);
};
diff --git a/src/methods/cipher_test/cipher_test.c b/src/methods/cipher_test/cipher_test.c
index 0cec4b0..52bca0f 100644
--- a/src/methods/cipher_test/cipher_test.c
+++ b/src/methods/cipher_test/cipher_test.c
@@ -70,49 +70,49 @@ static void method_destroy(fastd_method_t *method) {
free(method);
}
-static size_t method_key_length(fastd_context_t *ctx UNUSED, const fastd_method_t *method) {
+static size_t method_key_length(const fastd_method_t *method) {
return method->cipher_info->key_length;
}
-static fastd_method_session_state_t* method_session_init(fastd_context_t *ctx, const fastd_method_t *method, const uint8_t *secret, bool initiator) {
+static fastd_method_session_state_t* method_session_init(const fastd_method_t *method, const uint8_t *secret, bool initiator) {
fastd_method_session_state_t *session = malloc(sizeof(fastd_method_session_state_t));
- fastd_method_common_init(ctx, &session->common, initiator);
+ fastd_method_common_init(&session->common, initiator);
session->method = method;
session->cipher = fastd_cipher_get(method->cipher_info);
session->cipher_state = session->cipher->init(secret);
- pr_warn(ctx, "using cipher-test method; this method must be used for testing and benchmarks only");
+ pr_warn("using cipher-test method; this method must be used for testing and benchmarks only");
return session;
}
-static bool method_session_is_valid(fastd_context_t *ctx, fastd_method_session_state_t *session) {
- return (session && fastd_method_session_common_is_valid(ctx, &session->common));
+static bool method_session_is_valid(fastd_method_session_state_t *session) {
+ return (session && fastd_method_session_common_is_valid(&session->common));
}
-static bool method_session_is_initiator(fastd_context_t *ctx UNUSED, fastd_method_session_state_t *session) {
+static bool method_session_is_initiator(fastd_method_session_state_t *session) {
return fastd_method_session_common_is_initiator(&session->common);
}
-static bool method_session_want_refresh(fastd_context_t *ctx, fastd_method_session_state_t *session) {
- return fastd_method_session_common_want_refresh(ctx, &session->common);
+static bool method_session_want_refresh(fastd_method_session_state_t *session) {
+ return fastd_method_session_common_want_refresh(&session->common);
}
-static void method_session_superseded(fastd_context_t *ctx, fastd_method_session_state_t *session) {
- fastd_method_session_common_superseded(ctx, &session->common);
+static void method_session_superseded(fastd_method_session_state_t *session) {
+ fastd_method_session_common_superseded(&session->common);
}
-static void method_session_free(fastd_context_t *ctx UNUSED, fastd_method_session_state_t *session) {
+static void method_session_free(fastd_method_session_state_t *session) {
if (session) {
session->cipher->free(session->cipher_state);
free(session);
}
}
-static bool method_encrypt(fastd_context_t *ctx, fastd_peer_t *peer UNUSED, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
+static bool method_encrypt(fastd_peer_t *peer UNUSED, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
size_t tail_len = alignto(in.len, sizeof(fastd_block128_t))-in.len;
- *out = fastd_buffer_alloc(ctx, in.len, alignto(COMMON_HEADBYTES, 16), sizeof(fastd_block128_t)+tail_len);
+ *out = fastd_buffer_alloc(in.len, alignto(COMMON_HEADBYTES, 16), sizeof(fastd_block128_t)+tail_len);
if (tail_len)
memset(in.data+in.len, 0, tail_len);
@@ -134,23 +134,23 @@ static bool method_encrypt(fastd_context_t *ctx, fastd_peer_t *peer UNUSED, fast
fastd_buffer_free(in);
- fastd_method_put_common_header(ctx, out, session->common.send_nonce, 0);
+ fastd_method_put_common_header(out, session->common.send_nonce, 0);
fastd_method_increment_nonce(&session->common);
return true;
}
-static bool method_decrypt(fastd_context_t *ctx, fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
+static bool method_decrypt(fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
if (in.len < COMMON_HEADBYTES)
return false;
- if (!method_session_is_valid(ctx, session))
+ if (!method_session_is_valid(session))
return false;
uint8_t in_nonce[COMMON_NONCEBYTES];
uint8_t flags;
int64_t age;
- if (!fastd_method_handle_common_header(ctx, &session->common, &in, in_nonce, &flags, &age))
+ if (!fastd_method_handle_common_header(&session->common, &in, in_nonce, &flags, &age))
return false;
if (flags)
@@ -160,7 +160,7 @@ static bool method_decrypt(fastd_context_t *ctx, fastd_peer_t *peer, fastd_metho
fastd_method_expand_nonce(nonce, in_nonce, sizeof(nonce));
size_t tail_len = alignto(in.len, sizeof(fastd_block128_t))-in.len;
- *out = fastd_buffer_alloc(ctx, in.len, 0, tail_len);
+ *out = fastd_buffer_alloc(in.len, 0, tail_len);
int n_blocks = block_count(in.len, sizeof(fastd_block128_t));
@@ -174,9 +174,9 @@ static bool method_decrypt(fastd_context_t *ctx, fastd_peer_t *peer, fastd_metho
return false;
}
- if (!fastd_method_reorder_check(ctx, peer, &session->common, in_nonce, age)) {
+ if (!fastd_method_reorder_check(peer, &session->common, in_nonce, age)) {
fastd_buffer_free(*out);
- *out = fastd_buffer_alloc(ctx, 0, 0, 0);
+ *out = fastd_buffer_alloc(0, 0, 0);
}
fastd_buffer_free(in);
diff --git a/src/methods/common.c b/src/methods/common.c
index 166d3ab..17722cf 100644
--- a/src/methods/common.c
+++ b/src/methods/common.c
@@ -27,11 +27,11 @@
#include "common.h"
-void fastd_method_common_init(fastd_context_t *ctx, fastd_method_common_t *session, bool initiator) {
+void fastd_method_common_init(fastd_method_common_t *session, bool initiator) {
memset(session, 0, sizeof(*session));
- session->valid_till = fastd_in_seconds(ctx, conf.key_valid);
- session->refresh_after = fastd_in_seconds(ctx, conf.key_refresh - fastd_rand(ctx, 0, conf.key_refresh_splay));
+ session->valid_till = fastd_in_seconds(conf.key_valid);
+ session->refresh_after = fastd_in_seconds(conf.key_refresh - fastd_rand(0, conf.key_refresh_splay));
if (initiator) {
session->send_nonce[COMMON_NONCEBYTES-1] = 3;
@@ -42,7 +42,7 @@ void fastd_method_common_init(fastd_context_t *ctx, fastd_method_common_t *sessi
}
}
-bool fastd_method_is_nonce_valid(fastd_context_t *ctx, const fastd_method_common_t *session, const uint8_t nonce[COMMON_NONCEBYTES], int64_t *age) {
+bool fastd_method_is_nonce_valid(const fastd_method_common_t *session, const uint8_t nonce[COMMON_NONCEBYTES], int64_t *age) {
if ((nonce[0] & 1) != (session->receive_nonce[0] & 1))
return false;
@@ -57,7 +57,7 @@ bool fastd_method_is_nonce_valid(fastd_context_t *ctx, const fastd_method_common
*age >>= 1;
if (*age >= 0) {
- if (fastd_timed_out(ctx, &session->reorder_timeout))
+ if (fastd_timed_out(&session->reorder_timeout))
return false;
if (*age > 64)
@@ -67,7 +67,7 @@ bool fastd_method_is_nonce_valid(fastd_context_t *ctx, const fastd_method_common
return true;
}
-bool fastd_method_reorder_check(fastd_context_t *ctx, fastd_peer_t *peer, fastd_method_common_t *session, const uint8_t nonce[COMMON_NONCEBYTES], int64_t age) {
+bool fastd_method_reorder_check(fastd_peer_t *peer, fastd_method_common_t *session, const uint8_t nonce[COMMON_NONCEBYTES], int64_t age) {
if (age < 0) {
size_t shift = age < (-64) ? 64 : ((size_t)-age);
@@ -79,15 +79,15 @@ bool fastd_method_reorder_check(fastd_context_t *ctx, fastd_peer_t *peer, fastd_
session->receive_reorder_seen |= (1 << (shift-1));
memcpy(session->receive_nonce, nonce, COMMON_NONCEBYTES);
- session->reorder_timeout = fastd_in_seconds(ctx, conf.reorder_time);
+ session->reorder_timeout = fastd_in_seconds(conf.reorder_time);
return true;
}
else if (age == 0 || session->receive_reorder_seen & (1 << (age-1))) {
- pr_debug(ctx, "dropping duplicate packet from %P (age %u)", peer, (unsigned)age);
+ pr_debug("dropping duplicate packet from %P (age %u)", peer, (unsigned)age);
return false;
}
else {
- pr_debug2(ctx, "accepting reordered packet from %P (age %u)", peer, (unsigned)age);
+ pr_debug2("accepting reordered packet from %P (age %u)", peer, (unsigned)age);
session->receive_reorder_seen |= (1 << (age-1));
return true;
}
diff --git a/src/methods/common.h b/src/methods/common.h
index 510ad3f..ea4a13a 100644
--- a/src/methods/common.h
+++ b/src/methods/common.h
@@ -46,34 +46,34 @@ typedef struct fastd_method_common {
} fastd_method_common_t;
-void fastd_method_common_init(fastd_context_t *ctx, fastd_method_common_t *session, bool initiator);
-bool fastd_method_is_nonce_valid(fastd_context_t *ctx, const fastd_method_common_t *session, const uint8_t nonce[COMMON_NONCEBYTES], int64_t *age);
-bool fastd_method_reorder_check(fastd_context_t *ctx, fastd_peer_t *peer, fastd_method_common_t *session, const uint8_t nonce[COMMON_NONCEBYTES], int64_t age);
+void fastd_method_common_init(fastd_method_common_t *session, bool initiator);
+bool fastd_method_is_nonce_valid(const fastd_method_common_t *session, const uint8_t nonce[COMMON_NONCEBYTES], int64_t *age);
+bool fastd_method_reorder_check(fastd_peer_t *peer, fastd_method_common_t *session, const uint8_t nonce[COMMON_NONCEBYTES], int64_t age);
-static inline bool fastd_method_session_common_is_valid(fastd_context_t *ctx, const fastd_method_common_t *session) {
+static inline bool fastd_method_session_common_is_valid(const fastd_method_common_t *session) {
if (session->send_nonce[0] == 0xff && session->send_nonce[1] == 0xff)
return false;
- return (!fastd_timed_out(ctx, &session->valid_till));
+ return (!fastd_timed_out(&session->valid_till));
}
static inline bool fastd_method_session_common_is_initiator(const fastd_method_common_t *session) {
return (session->send_nonce[COMMON_NONCEBYTES-1] & 1);
}
-static inline bool fastd_method_session_common_want_refresh(fastd_context_t *ctx, const fastd_method_common_t *session) {
+static inline bool fastd_method_session_common_want_refresh(const fastd_method_common_t *session) {
if (session->send_nonce[0] == 0xff)
return true;
- if (fastd_method_session_common_is_initiator(session) && fastd_timed_out(ctx, &session->refresh_after))
+ if (fastd_method_session_common_is_initiator(session) && fastd_timed_out(&session->refresh_after))
return true;
return false;
}
-static inline void fastd_method_session_common_superseded(fastd_context_t *ctx, fastd_method_common_t *session) {
- struct timespec valid_max = fastd_in_seconds(ctx, conf.key_valid_old);
+static inline void fastd_method_session_common_superseded(fastd_method_common_t *session) {
+ struct timespec valid_max = fastd_in_seconds(conf.key_valid_old);
if (timespec_after(&session->valid_till, &valid_max))
session->valid_till = valid_max;
@@ -91,19 +91,19 @@ static inline void fastd_method_increment_nonce(fastd_method_common_t *session)
}
}
-static inline void fastd_method_put_common_header(fastd_context_t *ctx, fastd_buffer_t *buffer, const uint8_t nonce[COMMON_NONCEBYTES], uint8_t flags) {
- fastd_buffer_pull_head_from(ctx, buffer, nonce, COMMON_NONCEBYTES);
- fastd_buffer_pull_head_from(ctx, buffer, &flags, 1);
+static inline void fastd_method_put_common_header(fastd_buffer_t *buffer, const uint8_t nonce[COMMON_NONCEBYTES], uint8_t flags) {
+ fastd_buffer_pull_head_from(buffer, nonce, COMMON_NONCEBYTES);
+ fastd_buffer_pull_head_from(buffer, &flags, 1);
}
-static inline void fastd_method_take_common_header(fastd_context_t *ctx, fastd_buffer_t *buffer, uint8_t nonce[COMMON_NONCEBYTES], uint8_t *flags) {
- fastd_buffer_push_head_to(ctx, buffer, flags, 1);
- fastd_buffer_push_head_to(ctx, buffer, nonce, COMMON_NONCEBYTES);
+static inline void fastd_method_take_common_header(fastd_buffer_t *buffer, uint8_t nonce[COMMON_NONCEBYTES], uint8_t *flags) {
+ fastd_buffer_push_head_to(buffer, flags, 1);
+ fastd_buffer_push_head_to(buffer, nonce, COMMON_NONCEBYTES);
}
-static inline bool fastd_method_handle_common_header(fastd_context_t *ctx, const fastd_method_common_t *session, fastd_buffer_t *buffer, uint8_t nonce[COMMON_NONCEBYTES], uint8_t *flags, int64_t *age) {
- fastd_method_take_common_header(ctx, buffer, nonce, flags);
- return fastd_method_is_nonce_valid(ctx, session, nonce, age);
+static inline bool fastd_method_handle_common_header(const fastd_method_common_t *session, fastd_buffer_t *buffer, uint8_t nonce[COMMON_NONCEBYTES], uint8_t *flags, int64_t *age) {
+ fastd_method_take_common_header(buffer, nonce, flags);
+ return fastd_method_is_nonce_valid(session, nonce, age);
}
diff --git a/src/methods/composed_gmac/composed_gmac.c b/src/methods/composed_gmac/composed_gmac.c
index c848bbf..887fb5c 100644
--- a/src/methods/composed_gmac/composed_gmac.c
+++ b/src/methods/composed_gmac/composed_gmac.c
@@ -112,14 +112,14 @@ static void method_destroy(fastd_method_t *method) {
}
-static size_t method_key_length(fastd_context_t *ctx UNUSED, const fastd_method_t *method) {
+static size_t method_key_length(const fastd_method_t *method) {
return method->cipher_info->key_length + method->gmac_cipher_info->key_length;
}
-static fastd_method_session_state_t* method_session_init(fastd_context_t *ctx, const fastd_method_t *method, const uint8_t *secret, bool initiator) {
+static fastd_method_session_state_t* method_session_init(const fastd_method_t *method, const uint8_t *secret, bool initiator) {
fastd_method_session_state_t *session = malloc(sizeof(fastd_method_session_state_t));
- fastd_method_common_init(ctx, &session->common, initiator);
+ fastd_method_common_init(&session->common, initiator);
session->method = method;
session->cipher = fastd_cipher_get(method->cipher_info);
@@ -148,23 +148,23 @@ static fastd_method_session_state_t* method_session_init(fastd_context_t *ctx, c
return session;
}
-static bool method_session_is_valid(fastd_context_t *ctx, fastd_method_session_state_t *session) {
- return (session && fastd_method_session_common_is_valid(ctx, &session->common));
+static bool method_session_is_valid(fastd_method_session_state_t *session) {
+ return (session && fastd_method_session_common_is_valid(&session->common));
}
-static bool method_session_is_initiator(fastd_context_t *ctx UNUSED, fastd_method_session_state_t *session) {
+static bool method_session_is_initiator(fastd_method_session_state_t *session) {
return fastd_method_session_common_is_initiator(&session->common);
}
-static bool method_session_want_refresh(fastd_context_t *ctx, fastd_method_session_state_t *session) {
- return fastd_method_session_common_want_refresh(ctx, &session->common);
+static bool method_session_want_refresh(fastd_method_session_state_t *session) {
+ return fastd_method_session_common_want_refresh(&session->common);
}
-static void method_session_superseded(fastd_context_t *ctx, fastd_method_session_state_t *session) {
- fastd_method_session_common_superseded(ctx, &session->common);
+static void method_session_superseded(fastd_method_session_state_t *session) {
+ fastd_method_session_common_superseded(&session->common);
}
-static void method_session_free(fastd_context_t *ctx UNUSED, fastd_method_session_state_t *session) {
+static void method_session_free(fastd_method_session_state_t *session) {
if (session) {
session->cipher->free(session->cipher_state);
session->gmac_cipher->free(session->gmac_cipher_state);
@@ -183,9 +183,9 @@ static inline void put_size(fastd_block128_t *out, size_t len) {
out->b[7] = len << 3;
}
-static bool method_encrypt(fastd_context_t *ctx, fastd_peer_t *peer UNUSED, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
+static bool method_encrypt(fastd_peer_t *peer UNUSED, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
size_t tail_len = alignto(in.len, sizeof(fastd_block128_t))-in.len;
- *out = fastd_buffer_alloc(ctx, sizeof(fastd_block128_t)+in.len, alignto(COMMON_HEADBYTES, 16), sizeof(fastd_block128_t)+tail_len);
+ *out = fastd_buffer_alloc(sizeof(fastd_block128_t)+in.len, alignto(COMMON_HEADBYTES, 16), sizeof(fastd_block128_t)+tail_len);
if (tail_len)
memset(in.data+in.len, 0, tail_len);
@@ -226,23 +226,23 @@ static bool method_encrypt(fastd_context_t *ctx, fastd_peer_t *peer UNUSED, fast
fastd_buffer_free(in);
- fastd_method_put_common_header(ctx, out, session->common.send_nonce, 0);
+ fastd_method_put_common_header(out, session->common.send_nonce, 0);
fastd_method_increment_nonce(&session->common);
return true;
}
-static bool method_decrypt(fastd_context_t *ctx, fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
+static bool method_decrypt(fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
if (in.len < COMMON_HEADBYTES+sizeof(fastd_block128_t))
return false;
- if (!method_session_is_valid(ctx, session))
+ if (!method_session_is_valid(session))
return false;
uint8_t in_nonce[COMMON_NONCEBYTES];
uint8_t flags;
int64_t age;
- if (!fastd_method_handle_common_header(ctx, &session->common, &in, in_nonce, &flags, &age))
+ if (!fastd_method_handle_common_header(&session->common, &in, in_nonce, &flags, &age))
return false;
if (flags)
@@ -255,7 +255,7 @@ static bool method_decrypt(fastd_context_t *ctx, fastd_peer_t *peer, fastd_metho
fastd_method_expand_nonce(gmac_nonce, in_nonce, sizeof(gmac_nonce));
size_t tail_len = alignto(in.len, sizeof(fastd_block128_t))-in.len;
- *out = fastd_buffer_alloc(ctx, in.len, 0, tail_len);
+ *out = fastd_buffer_alloc(in.len, 0, tail_len);
int n_blocks = block_count(in.len, sizeof(fastd_block128_t));
@@ -282,11 +282,11 @@ static bool method_decrypt(fastd_context_t *ctx, fastd_peer_t *peer, fastd_metho
return false;
}
- fastd_buffer_push_head(ctx, out, sizeof(fastd_block128_t));
+ fastd_buffer_push_head(out, sizeof(fastd_block128_t));
- if (!fastd_method_reorder_check(ctx, peer, &session->common, in_nonce, age)) {
+ if (!fastd_method_reorder_check(peer, &session->common, in_nonce, age)) {
fastd_buffer_free(*out);
- *out = fastd_buffer_alloc(ctx, 0, 0, 0);
+ *out = fastd_buffer_alloc(0, 0, 0);
}
fastd_buffer_free(in);
diff --git a/src/methods/generic_gmac/generic_gmac.c b/src/methods/generic_gmac/generic_gmac.c
index 88c1880..6b84a95 100644
--- a/src/methods/generic_gmac/generic_gmac.c
+++ b/src/methods/generic_gmac/generic_gmac.c
@@ -89,14 +89,14 @@ static void method_destroy(fastd_method_t *method) {
free(method);
}
-static size_t method_key_length(fastd_context_t *ctx UNUSED, const fastd_method_t *method) {
+static size_t method_key_length(const fastd_method_t *method) {
return method->cipher_info->key_length;
}
-static fastd_method_session_state_t* method_session_init(fastd_context_t *ctx, const fastd_method_t *method, const uint8_t *secret, bool initiator) {
+static fastd_method_session_state_t* method_session_init(const fastd_method_t *method, const uint8_t *secret, bool initiator) {
fastd_method_session_state_t *session = malloc(sizeof(fastd_method_session_state_t));
- fastd_method_common_init(ctx, &session->common, initiator);
+ fastd_method_common_init(&session->common, initiator);
session->method = method;
session->cipher = fastd_cipher_get(method->cipher_info);
@@ -121,23 +121,23 @@ static fastd_method_session_state_t* method_session_init(fastd_context_t *ctx, c
return session;
}
-static bool method_session_is_valid(fastd_context_t *ctx, fastd_method_session_state_t *session) {
- return (session && fastd_method_session_common_is_valid(ctx, &session->common));
+static bool method_session_is_valid(fastd_method_session_state_t *session) {
+ return (session && fastd_method_session_common_is_valid(&session->common));
}
-static bool method_session_is_initiator(fastd_context_t *ctx UNUSED, fastd_method_session_state_t *session) {
+static bool method_session_is_initiator(fastd_method_session_state_t *session) {
return fastd_method_session_common_is_initiator(&session->common);
}
-static bool method_session_want_refresh(fastd_context_t *ctx, fastd_method_session_state_t *session) {
- return fastd_method_session_common_want_refresh(ctx, &session->common);
+static bool method_session_want_refresh(fastd_method_session_state_t *session) {
+ return fastd_method_session_common_want_refresh(&session->common);
}
-static void method_session_superseded(fastd_context_t *ctx, fastd_method_session_state_t *session) {
- fastd_method_session_common_superseded(ctx, &session->common);
+static void method_session_superseded(fastd_method_session_state_t *session) {
+ fastd_method_session_common_superseded(&session->common);
}
-static void method_session_free(fastd_context_t *ctx UNUSED, fastd_method_session_state_t *session) {
+static void method_session_free(fastd_method_session_state_t *session) {
if (session) {
session->cipher->free(session->cipher_state);
session->ghash->free(session->ghash_state);
@@ -155,11 +155,11 @@ static inline void put_size(fastd_block128_t *out, size_t len) {
out->b[15] = len << 3;
}
-static bool method_encrypt(fastd_context_t *ctx, fastd_peer_t *peer UNUSED, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
- fastd_buffer_pull_head_zero(ctx, &in, sizeof(fastd_block128_t));
+static bool method_encrypt(fastd_peer_t *peer UNUSED, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
+ fastd_buffer_pull_head_zero(&in, sizeof(fastd_block128_t));
size_t tail_len = alignto(in.len, sizeof(fastd_block128_t))-in.len;
- *out = fastd_buffer_alloc(ctx, in.len, alignto(COMMON_HEADBYTES, 16), sizeof(fastd_block128_t)+tail_len);
+ *out = fastd_buffer_alloc(in.len, alignto(COMMON_HEADBYTES, 16), sizeof(fastd_block128_t)+tail_len);
if (tail_len)
memset(in.data+in.len, 0, tail_len);
@@ -193,23 +193,23 @@ static bool method_encrypt(fastd_context_t *ctx, fastd_peer_t *peer UNUSED, fast
fastd_buffer_free(in);
- fastd_method_put_common_header(ctx, out, session->common.send_nonce, 0);
+ fastd_method_put_common_header(out, session->common.send_nonce, 0);
fastd_method_increment_nonce(&session->common);
return true;
}
-static bool method_decrypt(fastd_context_t *ctx, fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
+static bool method_decrypt(fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
if (in.len < COMMON_HEADBYTES+sizeof(fastd_block128_t))
return false;
- if (!method_session_is_valid(ctx, session))
+ if (!method_session_is_valid(session))
return false;
uint8_t in_nonce[COMMON_NONCEBYTES];
uint8_t flags;
int64_t age;
- if (!fastd_method_handle_common_header(ctx, &session->common, &in, in_nonce, &flags, &age))
+ if (!fastd_method_handle_common_header(&session->common, &in, in_nonce, &flags, &age))
return false;
if (flags)
@@ -219,7 +219,7 @@ static bool method_decrypt(fastd_context_t *ctx, fastd_peer_t *peer, fastd_metho
fastd_method_expand_nonce(nonce, in_nonce, sizeof(nonce));
size_t tail_len = alignto(in.len, sizeof(fastd_block128_t))-in.len;
- *out = fastd_buffer_alloc(ctx, in.len, 0, tail_len);
+ *out = fastd_buffer_alloc(in.len, 0, tail_len);
int n_blocks = block_count(in.len, sizeof(fastd_block128_t));
@@ -245,11 +245,11 @@ static bool method_decrypt(fastd_context_t *ctx, fastd_peer_t *peer, fastd_metho
fastd_buffer_free(in);
- fastd_buffer_push_head(ctx, out, sizeof(fastd_block128_t));
+ fastd_buffer_push_head(out, sizeof(fastd_block128_t));
- if (!fastd_method_reorder_check(ctx, peer, &session->common, in_nonce, age)) {
+ if (!fastd_method_reorder_check(peer, &session->common, in_nonce, age)) {
fastd_buffer_free(*out);
- *out = fastd_buffer_alloc(ctx, 0, 0, 0);
+ *out = fastd_buffer_alloc(0, 0, 0);
}
return true;
diff --git a/src/methods/generic_poly1305/generic_poly1305.c b/src/methods/generic_poly1305/generic_poly1305.c
index a8eb3d1..0e2641c 100644
--- a/src/methods/generic_poly1305/generic_poly1305.c
+++ b/src/methods/generic_poly1305/generic_poly1305.c
@@ -79,14 +79,14 @@ static void method_destroy(fastd_method_t *method) {
free(method);
}
-static size_t method_key_length(fastd_context_t *ctx UNUSED, const fastd_method_t *method) {
+static size_t method_key_length(const fastd_method_t *method) {
return method->cipher_info->key_length;
}
-static fastd_method_session_state_t* method_session_init(fastd_context_t *ctx, const fastd_method_t *method, const uint8_t *secret, bool initiator) {
+static fastd_method_session_state_t* method_session_init(const fastd_method_t *method, const uint8_t *secret, bool initiator) {
fastd_method_session_state_t *session = malloc(sizeof(fastd_method_session_state_t));
- fastd_method_common_init(ctx, &session->common, initiator);
+ fastd_method_common_init(&session->common, initiator);
session->method = method;
session->cipher = fastd_cipher_get(session->method->cipher_info);
session->cipher_state = session->cipher->init(secret);
@@ -94,34 +94,34 @@ static fastd_method_session_state_t* method_session_init(fastd_context_t *ctx, c
return session;
}
-static bool method_session_is_valid(fastd_context_t *ctx, fastd_method_session_state_t *session) {
- return (session && fastd_method_session_common_is_valid(ctx, &session->common));
+static bool method_session_is_valid(fastd_method_session_state_t *session) {
+ return (session && fastd_method_session_common_is_valid(&session->common));
}
-static bool method_session_is_initiator(fastd_context_t *ctx UNUSED, fastd_method_session_state_t *session) {
+static bool method_session_is_initiator(fastd_method_session_state_t *session) {
return fastd_method_session_common_is_initiator(&session->common);
}
-static bool method_session_want_refresh(fastd_context_t *ctx, fastd_method_session_state_t *session) {
- return fastd_method_session_common_want_refresh(ctx, &session->common);
+static bool method_session_want_refresh(fastd_method_session_state_t *session) {
+ return fastd_method_session_common_want_refresh(&session->common);
}
-static void method_session_superseded(fastd_context_t *ctx, fastd_method_session_state_t *session) {
- fastd_method_session_common_superseded(ctx, &session->common);
+static void method_session_superseded(fastd_method_session_state_t *session) {
+ fastd_method_session_common_superseded(&session->common);
}
-static void method_session_free(fastd_context_t *ctx UNUSED, fastd_method_session_state_t *session) {
+static void method_session_free(fastd_method_session_state_t *session) {
if (session) {
session->cipher->free(session->cipher_state);
free(session);
}
}
-static bool method_encrypt(fastd_context_t *ctx, fastd_peer_t *peer UNUSED, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
- fastd_buffer_pull_head_zero(ctx, &in, KEYBYTES);
+static bool method_encrypt(fastd_peer_t *peer UNUSED, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
+ fastd_buffer_pull_head_zero(&in, KEYBYTES);
size_t tail_len = alignto(in.len, sizeof(fastd_block128_t))-in.len;
- *out = fastd_buffer_alloc(ctx, in.len, alignto(COMMON_HEADBYTES, 16), sizeof(fastd_block128_t)+tail_len);
+ *out = fastd_buffer_alloc(in.len, alignto(COMMON_HEADBYTES, 16), sizeof(fastd_block128_t)+tail_len);
if (tail_len)
memset(in.data+in.len, 0, tail_len);
@@ -144,28 +144,28 @@ static bool method_encrypt(fastd_context_t *ctx, fastd_peer_t *peer UNUSED, fast
crypto_onetimeauth_poly1305(tag, outblocks->b+KEYBYTES, in.len - KEYBYTES, outblocks->b);
- fastd_buffer_push_head(ctx, out, KEYBYTES);
- fastd_buffer_pull_head_from(ctx, out, tag, TAGBYTES);
+ fastd_buffer_push_head(out, KEYBYTES);
+ fastd_buffer_pull_head_from(out, tag, TAGBYTES);
fastd_buffer_free(in);
- fastd_method_put_common_header(ctx, out, session->common.send_nonce, 0);
+ fastd_method_put_common_header(out, session->common.send_nonce, 0);
fastd_method_increment_nonce(&session->common);
return true;
}
-static bool method_decrypt(fastd_context_t *ctx, fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
+static bool method_decrypt(fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
if (in.len < COMMON_HEADBYTES+TAGBYTES)
return false;
- if (!method_session_is_valid(ctx, session))
+ if (!method_session_is_valid(session))
return false;
uint8_t in_nonce[COMMON_NONCEBYTES];
uint8_t flags;
int64_t age;
- if (!fastd_method_handle_common_header(ctx, &session->common, &in, in_nonce, &flags, &age))
+ if (!fastd_method_handle_common_header(&session->common, &in, in_nonce, &flags, &age))
return false;
if (flags)
@@ -175,11 +175,11 @@ static bool method_decrypt(fastd_context_t *ctx, fastd_peer_t *peer, fastd_metho
fastd_method_expand_nonce(nonce, in_nonce, sizeof(nonce));
uint8_t tag[TAGBYTES] __attribute__((aligned(8)));
- fastd_buffer_push_head_to(ctx, &in, tag, TAGBYTES);
- fastd_buffer_pull_head_zero(ctx, &in, KEYBYTES);
+ fastd_buffer_push_head_to(&in, tag, TAGBYTES);
+ fastd_buffer_pull_head_zero(&in, KEYBYTES);
size_t tail_len = alignto(in.len, sizeof(fastd_block128_t))-in.len;
- *out = fastd_buffer_alloc(ctx, in.len, 0, tail_len);
+ *out = fastd_buffer_alloc(in.len, 0, tail_len);
int n_blocks = block_count(in.len, sizeof(fastd_block128_t));
fastd_block128_t *inblocks = in.data;
@@ -198,20 +198,20 @@ static bool method_decrypt(fastd_context_t *ctx, fastd_peer_t *peer, fastd_metho
fastd_buffer_free(*out);
/* restore input buffer */
- fastd_buffer_push_head(ctx, &in, KEYBYTES);
- fastd_buffer_pull_head_from(ctx, &in, tag, TAGBYTES);
- fastd_method_put_common_header(ctx, &in, in_nonce, 0);
+ fastd_buffer_push_head(&in, KEYBYTES);
+ fastd_buffer_pull_head_from(&in, tag, TAGBYTES);
+ fastd_method_put_common_header(&in, in_nonce, 0);
return false;
}
fastd_buffer_free(in);
- fastd_buffer_push_head(ctx, out, KEYBYTES);
+ fastd_buffer_push_head(out, KEYBYTES);
- if (!fastd_method_reorder_check(ctx, peer, &session->common, in_nonce, age)) {
+ if (!fastd_method_reorder_check(peer, &session->common, in_nonce, age)) {
fastd_buffer_free(*out);
- *out = fastd_buffer_alloc(ctx, 0, 0, 0);
+ *out = fastd_buffer_alloc(0, 0, 0);
}
return true;
diff --git a/src/methods/null/null.c b/src/methods/null/null.c
index 9c7dc43..76fd961 100644
--- a/src/methods/null/null.c
+++ b/src/methods/null/null.c
@@ -40,11 +40,11 @@ static bool method_create_by_name(const char *name, fastd_method_t **method UNUS
static void method_destroy(fastd_method_t *method UNUSED) {
}
-static size_t method_key_length(fastd_context_t *ctx UNUSED, const fastd_method_t *method UNUSED) {
+static size_t method_key_length(const fastd_method_t *method UNUSED) {
return 0;
}
-static fastd_method_session_state_t* method_session_init(fastd_context_t *ctx UNUSED, const fastd_method_t *method UNUSED, const uint8_t *secret UNUSED, bool initiator) {
+static fastd_method_session_state_t* method_session_init(const fastd_method_t *method UNUSED, const uint8_t *secret UNUSED, bool initiator) {
fastd_method_session_state_t *session = malloc(sizeof(fastd_method_session_state_t));
session->valid = true;
@@ -53,31 +53,31 @@ static fastd_method_session_state_t* method_session_init(fastd_context_t *ctx UN
return session;
}
-static fastd_method_session_state_t* method_session_init_compat(fastd_context_t *ctx, const fastd_method_t *method, const uint8_t *secret, size_t length UNUSED, bool initiator) {
- return method_session_init(ctx, method, secret, initiator);
+static fastd_method_session_state_t* method_session_init_compat(const fastd_method_t *method, const uint8_t *secret, size_t length UNUSED, bool initiator) {
+ return method_session_init(method, secret, initiator);
}
-static bool method_session_is_valid(fastd_context_t *ctx UNUSED, fastd_method_session_state_t *session) {
+static bool method_session_is_valid(fastd_method_session_state_t *session) {
return (session && session->valid);
}
-static bool method_session_is_initiator(fastd_context_t *ctx UNUSED, fastd_method_session_state_t *session) {
+static bool method_session_is_initiator(fastd_method_session_state_t *session) {
return (session->initiator);
}
-static bool method_session_want_refresh(fastd_context_t *ctx UNUSED, fastd_method_session_state_t *session UNUSED) {
+static bool method_session_want_refresh(fastd_method_session_state_t *session UNUSED) {
return false;
}
-static void method_session_superseded(fastd_context_t *ctx UNUSED, fastd_method_session_state_t *session) {
+static void method_session_superseded(fastd_method_session_state_t *session) {
session->valid = false;
}
-static void method_session_free(fastd_context_t *ctx UNUSED, fastd_method_session_state_t *session) {
+static void method_session_free(fastd_method_session_state_t *session) {
free(session);
}
-static bool method_passthrough(fastd_context_t *ctx UNUSED, fastd_peer_t *peer UNUSED, fastd_method_session_state_t *session UNUSED, fastd_buffer_t *out, fastd_buffer_t in) {
+static bool method_passthrough(fastd_peer_t *peer UNUSED, fastd_method_session_state_t *session UNUSED, fastd_buffer_t *out, fastd_buffer_t in) {
*out = in;
return true;
}
diff --git a/src/methods/xsalsa20_poly1305/xsalsa20_poly1305.c b/src/methods/xsalsa20_poly1305/xsalsa20_poly1305.c
index e11826f..f06e0f8 100644
--- a/src/methods/xsalsa20_poly1305/xsalsa20_poly1305.c
+++ b/src/methods/xsalsa20_poly1305/xsalsa20_poly1305.c
@@ -45,44 +45,44 @@ static bool method_create_by_name(const char *name, fastd_method_t **method UNUS
static void method_destroy(fastd_method_t *method UNUSED) {
}
-static size_t method_key_length(fastd_context_t *ctx UNUSED, const fastd_method_t *method UNUSED) {
+static size_t method_key_length(const fastd_method_t *method UNUSED) {
return crypto_secretbox_xsalsa20poly1305_KEYBYTES;
}
-static fastd_method_session_state_t* method_session_init(fastd_context_t *ctx, const fastd_method_t *method UNUSED, const uint8_t *secret, bool initiator) {
+static fastd_method_session_state_t* method_session_init(const fastd_method_t *method UNUSED, const uint8_t *secret, bool initiator) {
fastd_method_session_state_t *session = malloc(sizeof(fastd_method_session_state_t));
- fastd_method_common_init(ctx, &session->common, initiator);
+ fastd_method_common_init(&session->common, initiator);
memcpy(session->key, secret, crypto_secretbox_xsalsa20poly1305_KEYBYTES);
return session;
}
-static fastd_method_session_state_t* method_session_init_compat(fastd_context_t *ctx, const fastd_method_t *method, const uint8_t *secret, size_t length, bool initiator) {
+static fastd_method_session_state_t* method_session_init_compat(const fastd_method_t *method, const uint8_t *secret, size_t length, bool initiator) {
if (length < crypto_secretbox_xsalsa20poly1305_KEYBYTES)
- exit_bug(ctx, "xsalsa20-poly1305: tried to init with short secret");
+ exit_bug("xsalsa20-poly1305: tried to init with short secret");
- return method_session_init(ctx, method, secret, initiator);
+ return method_session_init(method, secret, initiator);
}
-static bool method_session_is_valid(fastd_context_t *ctx, fastd_method_session_state_t *session) {
- return (session && fastd_method_session_common_is_valid(ctx, &session->common));
+static bool method_session_is_valid(fastd_method_session_state_t *session) {
+ return (session && fastd_method_session_common_is_valid(&session->common));
}
-static bool method_session_is_initiator(fastd_context_t *ctx UNUSED, fastd_method_session_state_t *session) {
+static bool method_session_is_initiator(fastd_method_session_state_t *session) {
return fastd_method_session_common_is_initiator(&session->common);
}
-static bool method_session_want_refresh(fastd_context_t *ctx, fastd_method_session_state_t *session) {
- return fastd_method_session_common_want_refresh(ctx, &session->common);
+static bool method_session_want_refresh(fastd_method_session_state_t *session) {
+ return fastd_method_session_common_want_refresh(&session->common);
}
-static void method_session_superseded(fastd_context_t *ctx, fastd_method_session_state_t *session) {
- fastd_method_session_common_superseded(ctx, &session->common);
+static void method_session_superseded(fastd_method_session_state_t *session) {
+ fastd_method_session_common_superseded(&session->common);
}
-static void method_session_free(fastd_context_t *ctx UNUSED, fastd_method_session_state_t *session) {
+static void method_session_free(fastd_method_session_state_t *session) {
if(session) {
secure_memzero(session, sizeof(fastd_method_session_state_t));
free(session);
@@ -96,30 +96,30 @@ static inline void memcpy_nonce(uint8_t *dst, const uint8_t *src) {
dst[i] = src[COMMON_NONCEBYTES-i-1];
}
-static inline void put_header(fastd_context_t *ctx, fastd_buffer_t *buffer, const uint8_t nonce[COMMON_NONCEBYTES], uint8_t flags) {
- fastd_buffer_pull_head_from(ctx, buffer, &flags, 1);
+static inline void put_header(fastd_buffer_t *buffer, const uint8_t nonce[COMMON_NONCEBYTES], uint8_t flags) {
+ fastd_buffer_pull_head_from(buffer, &flags, 1);
- fastd_buffer_pull_head(ctx, buffer, COMMON_NONCEBYTES);
+ fastd_buffer_pull_head(buffer, COMMON_NONCEBYTES);
memcpy_nonce(buffer->data, nonce);
}
-static inline void take_header(fastd_context_t *ctx, fastd_buffer_t *buffer, uint8_t nonce[COMMON_NONCEBYTES], uint8_t *flags) {
+static inline void take_header(fastd_buffer_t *buffer, uint8_t nonce[COMMON_NONCEBYTES], uint8_t *flags) {
memcpy_nonce(nonce, buffer->data );
- fastd_buffer_push_head(ctx, buffer, COMMON_NONCEBYTES);
+ fastd_buffer_push_head(buffer, COMMON_NONCEBYTES);
- fastd_buffer_push_head_to(ctx, buffer, flags, 1);
+ fastd_buffer_push_head_to(buffer, flags, 1);
}
-static inline bool handle_header(fastd_context_t *ctx, const fastd_method_common_t *session, fastd_buffer_t *buffer, uint8_t nonce[COMMON_NONCEBYTES], uint8_t *flags, int64_t *age) {
- take_header(ctx, buffer, nonce, flags);
- return fastd_method_is_nonce_valid(ctx, session, nonce, age);
+static inline bool handle_header(const fastd_method_common_t *session, fastd_buffer_t *buffer, uint8_t nonce[COMMON_NONCEBYTES], uint8_t *flags, int64_t *age) {
+ take_header(buffer, nonce, flags);
+ return fastd_method_is_nonce_valid(session, nonce, age);
}
-static bool method_encrypt(fastd_context_t *ctx, fastd_peer_t *peer UNUSED, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
- fastd_buffer_pull_head_zero(ctx, &in, crypto_secretbox_xsalsa20poly1305_ZEROBYTES);
+static bool method_encrypt(fastd_peer_t *peer UNUSED, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
+ fastd_buffer_pull_head_zero(&in, crypto_secretbox_xsalsa20poly1305_ZEROBYTES);
- *out = fastd_buffer_alloc(ctx, in.len, 0, 0);
+ *out = fastd_buffer_alloc(in.len, 0, 0);
uint8_t nonce[crypto_secretbox_xsalsa20poly1305_NONCEBYTES] __attribute__((aligned(8))) = {};
memcpy_nonce(nonce, session->common.send_nonce);
@@ -128,24 +128,24 @@ static bool method_encrypt(fastd_context_t *ctx, fastd_peer_t *peer UNUSED, fast
fastd_buffer_free(in);
- fastd_buffer_push_head(ctx, out, crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES);
- put_header(ctx, out, session->common.send_nonce, 0);
+ fastd_buffer_push_head(out, crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES);
+ put_header(out, session->common.send_nonce, 0);
fastd_method_increment_nonce(&session->common);
return true;
}
-static bool method_decrypt(fastd_context_t *ctx, fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
+static bool method_decrypt(fastd_peer_t *peer, fastd_method_session_state_t *session, fastd_buffer_t *out, fastd_buffer_t in) {
if (in.len < COMMON_HEADBYTES)
return false;
- if (!method_session_is_valid(ctx, session))
+ if (!method_session_is_valid(session))
return false;
uint8_t in_nonce[COMMON_NONCEBYTES];
uint8_t flags;
int64_t age;
- if (!handle_header(ctx, &session->common, &in, in_nonce, &flags, &age))
+ if (!handle_header(&session->common, &in, in_nonce, &flags, &age))
return false;
if (flags)
@@ -154,27 +154,27 @@ static bool method_decrypt(fastd_context_t *ctx, fastd_peer_t *peer, fastd_metho
uint8_t nonce[crypto_secretbox_xsalsa20poly1305_NONCEBYTES] __attribute__((aligned(8))) = {};
memcpy_nonce(nonce, in_nonce);
- fastd_buffer_pull_head_zero(ctx, &in, crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES);
+ fastd_buffer_pull_head_zero(&in, crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES);
- *out = fastd_buffer_alloc(ctx, in.len, 0, 0);
+ *out = fastd_buffer_alloc(in.len, 0, 0);
if (crypto_secretbox_xsalsa20poly1305_open(out->data, in.data, in.len, nonce, session->key) != 0) {
fastd_buffer_free(*out);
/* restore input buffer */
- fastd_buffer_push_head(ctx, &in, crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES);
- put_header(ctx, &in, in_nonce, 0);
+ fastd_buffer_push_head(&in, crypto_secretbox_xsalsa20poly1305_BOXZEROBYTES);
+ put_header(&in, in_nonce, 0);
return false;
}
fastd_buffer_free(in);
- if (!fastd_method_reorder_check(ctx, peer, &session->common, in_nonce, age)) {
+ if (!fastd_method_reorder_check(peer, &session->common, in_nonce, age)) {
fastd_buffer_free(*out);
- *out = fastd_buffer_alloc(ctx, crypto_secretbox_xsalsa20poly1305_ZEROBYTES, 0, 0);
+ *out = fastd_buffer_alloc(crypto_secretbox_xsalsa20poly1305_ZEROBYTES, 0, 0);
}
- fastd_buffer_push_head(ctx, out, crypto_secretbox_xsalsa20poly1305_ZEROBYTES);
+ fastd_buffer_push_head(out, crypto_secretbox_xsalsa20poly1305_ZEROBYTES);
return true;
}
diff --git a/src/options.c b/src/options.c
index 0817ed7..fef7cc1 100644
--- a/src/options.c
+++ b/src/options.c
@@ -48,7 +48,7 @@ static void print_usage(const char *options, const char *message) {
puts(message);
}
-static void usage(fastd_context_t *ctx UNUSED) {
+static void usage(void) {
puts("fastd (Fast and Secure Tunnelling Daemon) " FASTD_VERSION " usage:\n");
#define OR ", "
@@ -64,49 +64,49 @@ static void usage(fastd_context_t *ctx UNUSED) {
exit(0);
}
-static void version(fastd_context_t *ctx UNUSED) {
+static void version(void) {
puts("fastd " FASTD_VERSION);
exit(0);
}
-static void option_daemon(fastd_context_t *ctx UNUSED) {
+static void option_daemon(void) {
conf.daemon = true;
}
-static void option_pid_file(fastd_context_t *ctx UNUSED, const char *arg) {
+static void option_pid_file(const char *arg) {
free(conf.pid_file);
conf.pid_file = strdup(arg);
}
-static void option_config(fastd_context_t *ctx, const char *arg) {
+static void option_config(const char *arg) {
if (!strcmp(arg, "-"))
arg = NULL;
- if (!fastd_read_config(ctx, arg, false, 0))
+ if (!fastd_read_config(arg, false, 0))
exit(1);
}
-static void option_config_peer(fastd_context_t *ctx, const char *arg) {
- fastd_peer_config_new(ctx);
+static void option_config_peer(const char *arg) {
+ fastd_peer_config_new();
- if(!fastd_read_config(ctx, arg, true, 0))
+ if(!fastd_read_config(arg, true, 0))
exit(1);
}
-static void option_config_peer_dir(fastd_context_t *ctx, const char *arg) {
- fastd_add_peer_dir(ctx, arg);
+static void option_config_peer_dir(const char *arg) {
+ fastd_add_peer_dir(arg);
}
#ifdef WITH_CMDLINE_USER
-static void option_user(fastd_context_t *ctx UNUSED, const char *arg) {
+static void option_user(const char *arg) {
free(conf.user);
conf.user = strdup(arg);
}
-static void option_group(fastd_context_t *ctx UNUSED, const char *arg) {
+static void option_group(const char *arg) {
free(conf.group);
conf.group = strdup(arg);
}
@@ -115,7 +115,7 @@ static void option_group(fastd_context_t *ctx UNUSED, const char *arg) {
#ifdef WITH_CMDLINE_LOGGING
-static int parse_log_level(fastd_context_t *ctx, const char *arg) {
+static int parse_log_level(const char *arg) {
if (!strcmp(arg, "fatal"))
return LL_FATAL;
else if (!strcmp(arg, "error"))
@@ -131,27 +131,27 @@ static int parse_log_level(fastd_context_t *ctx, const char *arg) {
else if (!strcmp(arg, "debug2"))
return LL_DEBUG2;
else
- exit_error(ctx, "invalid log level `%s'", arg);
+ exit_error("invalid log level `%s'", arg);
}
-static void option_log_level(fastd_context_t *ctx, const char *arg) {
- conf.log_stderr_level = parse_log_level(ctx, arg);
+static void option_log_level(const char *arg) {
+ conf.log_stderr_level = parse_log_level(arg);
}
-static void option_syslog_level(fastd_context_t *ctx, const char *arg) {
- conf.log_syslog_level = parse_log_level(ctx, arg);
+static void option_syslog_level(const char *arg) {
+ conf.log_syslog_level = parse_log_level(arg);
}
-static void option_syslog_ident(fastd_context_t *ctx UNUSED, const char *arg) {
+static void option_syslog_ident(const char *arg) {
free(conf.log_syslog_ident);
conf.log_syslog_ident = strdup(arg);
}
-static void option_hide_ip_addresses(fastd_context_t *ctx UNUSED) {
+static void option_hide_ip_addresses(void) {
conf.hide_ip_addresses = true;
}
-static void option_hide_mac_addresses(fastd_context_t *ctx UNUSED) {
+static void option_hide_mac_addresses(void) {
conf.hide_mac_addresses = true;
}
@@ -159,31 +159,31 @@ static void option_hide_mac_addresses(fastd_context_t *ctx UNUSED) {
#ifdef WITH_CMDLINE_OPERATION
-static void option_mode(fastd_context_t *ctx, const char *arg) {
+static void option_mode(const char *arg) {
if (!strcmp(arg, "tap"))
conf.mode = MODE_TAP;
else if (!strcmp(arg, "tun"))
conf.mode = MODE_TUN;
else
- exit_error(ctx, "invalid mode `%s'", arg);
+ exit_error("invalid mode `%s'", arg);
}
-static void option_interface(fastd_context_t *ctx UNUSED, const char *arg) {
+static void option_interface(const char *arg) {
free(conf.ifname);
conf.ifname = strdup(arg);
}
-static void option_mtu(fastd_context_t *ctx, const char *arg) {
+static void option_mtu(const char *arg) {
char *endptr;
long mtu = strtol(arg, &endptr, 10);
if (*endptr || mtu < 576 || mtu > 65535)
- exit_error(ctx, "invalid mtu `%s'", arg);
+ exit_error("invalid mtu `%s'", arg);
conf.mtu = mtu;
}
-static void option_bind(fastd_context_t *ctx, const char *arg) {
+static void option_bind(const char *arg) {
long l;
char *charptr;
char *endptr;
@@ -193,7 +193,7 @@ static void option_bind(fastd_context_t *ctx, const char *arg) {
if (arg[0] == '[') {
charptr = strrchr(arg, ']');
if (!charptr || (charptr[1] != ':' && charptr[1] != '\0'))
- exit_error(ctx, "invalid bind address `%s'", arg);
+ exit_error("invalid bind address `%s'", arg);
addrstr = strndup(arg+1, charptr-arg-1);
@@ -215,7 +215,7 @@ static void option_bind(fastd_context_t *ctx, const char *arg) {
if (charptr) {
l = strtol(charptr+1, &endptr, 10);
if (*endptr || l < 1 || l > 65535)
- exit_error(ctx, "invalid bind port `%s'", charptr+1);
+ exit_error("invalid bind port `%s'", charptr+1);
}
else {
l = 0;
@@ -234,7 +234,7 @@ static void option_bind(fastd_context_t *ctx, const char *arg) {
}
if (inet_pton(AF_INET6, addrstr, &addr.in6.sin6_addr) != 1)
- exit_error(ctx, "invalid bind address `[%s]'", addrstr);
+ exit_error("invalid bind address `[%s]'", addrstr);
}
else if (strcmp(addrstr, "any") == 0) {
addr.in.sin_family = AF_UNSPEC;
@@ -245,23 +245,23 @@ static void option_bind(fastd_context_t *ctx, const char *arg) {
addr.in.sin_port = htons(l);
if (inet_pton(AF_INET, addrstr, &addr.in.sin_addr) != 1)
- exit_error(ctx, "invalid bind address `%s'", addrstr);
+ exit_error("invalid bind address `%s'", addrstr);
}
free(addrstr);
- fastd_config_bind_address(ctx, &addr, ifname, false, false);
+ fastd_config_bind_address(&addr, ifname, false, false);
}
-static void option_protocol(fastd_context_t *ctx, const char *arg) {
- fastd_config_protocol(ctx, arg);
+static void option_protocol(const char *arg) {
+ fastd_config_protocol(arg);
}
-static void option_method(fastd_context_t *ctx, const char *arg) {
- fastd_config_method(ctx, arg);
+static void option_method(const char *arg) {
+ fastd_config_method(arg);
}
-static void option_forward(fastd_context_t *ctx UNUSED) {
+static void option_forward(void) {
conf.forward = true;
}
@@ -269,55 +269,55 @@ static void option_forward(fastd_context_t *ctx UNUSED) {
#ifdef WITH_CMDLINE_COMMANDS
-static void option_on_pre_up(fastd_context_t *ctx UNUSED, const char *arg) {
+static void option_on_pre_up(const char *arg) {
fastd_shell_command_set(&conf.on_pre_up, arg, true);
}
-static void option_on_up(fastd_context_t *ctx UNUSED, const char *arg) {
+static void option_on_up(const char *arg) {
fastd_shell_command_set(&conf.on_up, arg, true);
}
-static void option_on_down(fastd_context_t *ctx UNUSED, const char *arg) {
+static void option_on_down(const char *arg) {
fastd_shell_command_set(&conf.on_down, arg, true);
}
-static void option_on_post_down(fastd_context_t *ctx UNUSED, const char *arg) {
+static void option_on_post_down(const char *arg) {
fastd_shell_command_set(&conf.on_post_down, arg, true);
}
-static void option_on_connect(fastd_context_t *ctx UNUSED, const char *arg) {
+static void option_on_connect(const char *arg) {
fastd_shell_command_set(&conf.on_connect, arg, false);
}
-static void option_on_establish(fastd_context_t *ctx UNUSED, const char *arg) {
+static void option_on_establish(const char *arg) {
fastd_shell_command_set(&conf.on_establish, arg, false);
}
-static void option_on_disestablish(fastd_context_t *ctx UNUSED, const char *arg) {
+static void option_on_disestablish(const char *arg) {
fastd_shell_command_set(&conf.on_disestablish, arg, false);
}
-static void option_on_verify(fastd_context_t *ctx UNUSED, const char *arg) {
+static void option_on_verify(const char *arg) {
fastd_shell_command_set(&conf.on_verify, arg, false);
}
#endif
-static void option_verify_config(fastd_context_t *ctx UNUSED) {
+static void option_verify_config(void) {
conf.verify_config = true;
}
-static void option_generate_key(fastd_context_t *ctx UNUSED) {
+static void option_generate_key(void) {
conf.generate_key = true;
conf.show_key = false;
}
-static void option_show_key(fastd_context_t *ctx UNUSED) {
+static void option_show_key(void) {
conf.generate_key = false;
conf.show_key = true;
}
-static void option_machine_readable(fastd_context_t *ctx UNUSED) {
+static void option_machine_readable(void) {
conf.machine_readable = true;
}
@@ -341,7 +341,7 @@ static bool config_match(const char *opt, ...) {
return match;
}
-void fastd_config_handle_options(fastd_context_t *ctx, int argc, char *const argv[]) {
+void fastd_config_handle_options(int argc, char *const argv[]) {
int i = 1;
while (i < argc) {
@@ -351,7 +351,7 @@ void fastd_config_handle_options(fastd_context_t *ctx, int argc, char *const arg
({ \
if(config_match(argv[i], options, NULL)) { \
i++; \
- func(ctx); \
+ func(); \
continue; \
} \
})
@@ -360,8 +360,8 @@ void fastd_config_handle_options(fastd_context_t *ctx, int argc, char *const arg
if(config_match(argv[i], options, NULL)) { \
i+=2; \
if (i > argc) \
- exit_error(ctx, "command line error: option `%s' needs an argument; see --help for usage", argv[i-2]); \
- func(ctx, argv[i-1]); \
+ exit_error("command line error: option `%s' needs an argument; see --help for usage", argv[i-2]); \
+ func(argv[i-1]); \
continue; \
} \
})
@@ -371,6 +371,6 @@ void fastd_config_handle_options(fastd_context_t *ctx, int argc, char *const arg
#undef OPTION
#undef OPTION_ARG
- exit_error(ctx, "command line error: unknown option `%s'; see --help for usage", argv[i]);
+ exit_error("command line error: unknown option `%s'; see --help for usage", argv[i]);
}
}
diff --git a/src/peer.c b/src/peer.c
index 9193441..faba121 100644
--- a/src/peer.c
+++ b/src/peer.c
@@ -32,28 +32,28 @@
#include <sys/wait.h>
-static inline void on_establish(fastd_context_t *ctx, const fastd_peer_t *peer) {
- fastd_shell_command_exec(ctx, &conf.on_establish, peer, &peer->local_address, &peer->address);
+static inline void on_establish(const fastd_peer_t *peer) {
+ fastd_shell_command_exec(&conf.on_establish, peer, &peer->local_address, &peer->address);
}
-static inline void on_disestablish(fastd_context_t *ctx, const fastd_peer_t *peer) {
- fastd_shell_command_exec(ctx, &conf.on_disestablish, peer, &peer->local_address, &peer->address);
+static inline void on_disestablish(const fastd_peer_t *peer) {
+ fastd_shell_command_exec(&conf.on_disestablish, peer, &peer->local_address, &peer->address);
}
-static inline void free_socket(fastd_context_t *ctx, fastd_peer_t *peer) {
+static inline void free_socket(fastd_peer_t *peer) {
if (peer->sock) {
if (fastd_peer_is_socket_dynamic(peer)) {
if (peer->sock->peer != peer)
- exit_bug(ctx, "dynamic peer socket mismatch");
+ exit_bug("dynamic peer socket mismatch");
- fastd_socket_close(ctx, peer->sock);
+ fastd_socket_close(peer->sock);
free(peer->sock);
peer->sock = NULL;
size_t i;
- for (i = 0; i < VECTOR_LEN(ctx->peers); i++) {
- if (VECTOR_INDEX(ctx->peers, i) == peer) {
- fastd_poll_set_fd_peer(ctx, i);
+ for (i = 0; i < VECTOR_LEN(ctx.peers); i++) {
+ if (VECTOR_INDEX(ctx.peers, i) == peer) {
+ fastd_poll_set_fd_peer(i);
break;
}
}
@@ -73,50 +73,50 @@ static inline bool has_group_config_constraints(const fastd_peer_group_config_t
return false;
}
-void fastd_peer_reset_socket(fastd_context_t *ctx, fastd_peer_t *peer) {
+void fastd_peer_reset_socket(fastd_peer_t *peer) {
if (peer->address.sa.sa_family == AF_UNSPEC) {
- free_socket(ctx, peer);
+ free_socket(peer);
return;
}
if (!fastd_peer_is_socket_dynamic(peer))
return;
- pr_debug(ctx, "resetting socket for peer %P", peer);
+ pr_debug("resetting socket for peer %P", peer);
- free_socket(ctx, peer);
+ free_socket(peer);
switch (peer->address.sa.sa_family) {
case AF_INET:
- if (ctx->sock_default_v4)
- peer->sock = ctx->sock_default_v4;
+ if (ctx.sock_default_v4)
+ peer->sock = ctx.sock_default_v4;
else
- peer->sock = fastd_socket_open(ctx, peer, AF_INET);
+ peer->sock = fastd_socket_open(peer, AF_INET);
break;
case AF_INET6:
- if (ctx->sock_default_v6)
- peer->sock = ctx->sock_default_v6;
+ if (ctx.sock_default_v6)
+ peer->sock = ctx.sock_default_v6;
else
- peer->sock = fastd_socket_open(ctx, peer, AF_INET6);
+ peer->sock = fastd_socket_open(peer, AF_INET6);
}
if (!peer->sock || !fastd_peer_is_socket_dynamic(peer))
return;
size_t i;
- for (i = 0; i < VECTOR_LEN(ctx->peers); i++) {
- if (VECTOR_INDEX(ctx->peers, i) == peer) {
- fastd_poll_set_fd_peer(ctx, i);
+ for (i = 0; i < VECTOR_LEN(ctx.peers); i++) {
+ if (VECTOR_INDEX(ctx.peers, i) == peer) {
+ fastd_poll_set_fd_peer(i);
break;
}
}
}
-void fastd_peer_schedule_handshake(fastd_context_t *ctx, fastd_peer_t *peer, int delay) {
- fastd_peer_unschedule_handshake(ctx, peer);
+void fastd_peer_schedule_handshake(fastd_peer_t *peer, int delay) {
+ fastd_peer_unschedule_handshake(peer);
- peer->next_handshake = ctx->now;
+ peer->next_handshake = ctx.now;
peer->next_handshake.tv_sec += delay/1000;
peer->next_handshake.tv_nsec += (delay%1000)*1e6;
@@ -127,7 +127,7 @@ void fastd_peer_schedule_handshake(fastd_context_t *ctx, fastd_peer_t *peer, int
}
fastd_dlist_head_t *list;
- for (list = &ctx->handshake_queue; list->next; list = list->next) {
+ for (list = &ctx.handshake_queue; list->next; list = list->next) {
fastd_peer_t *entry = container_of(list->next, fastd_peer_t, handshake_entry);
if (timespec_after(&entry->next_handshake, &peer->next_handshake))
@@ -167,43 +167,43 @@ static bool is_peer_in_group(fastd_peer_t *peer, fastd_peer_group_t *group) {
return is_group_in(peer->group, group);
}
-static void reset_peer(fastd_context_t *ctx, fastd_peer_t *peer) {
+static void reset_peer(fastd_peer_t *peer) {
if (fastd_peer_is_established(peer))
- on_disestablish(ctx, peer);
+ on_disestablish(peer);
- free_socket(ctx, peer);
+ free_socket(peer);
memset(&peer->local_address, 0, sizeof(peer->local_address));
- conf.protocol->reset_peer_state(ctx, peer);
+ conf.protocol->reset_peer_state(peer);
size_t i, deleted = 0;
- for (i = 0; i < VECTOR_LEN(ctx->eth_addrs); i++) {
- if (VECTOR_INDEX(ctx->eth_addrs, i).peer == peer) {
+ for (i = 0; i < VECTOR_LEN(ctx.eth_addrs); i++) {
+ if (VECTOR_INDEX(ctx.eth_addrs, i).peer == peer) {
deleted++;
}
else if (deleted) {
- VECTOR_INDEX(ctx->eth_addrs, i-deleted) = VECTOR_INDEX(ctx->eth_addrs, i);
+ VECTOR_INDEX(ctx.eth_addrs, i-deleted) = VECTOR_INDEX(ctx.eth_addrs, i);
}
}
- VECTOR_RESIZE(ctx->eth_addrs, VECTOR_LEN(ctx->eth_addrs)-deleted);
+ VECTOR_RESIZE(ctx.eth_addrs, VECTOR_LEN(ctx.eth_addrs)-deleted);
- fastd_peer_unschedule_handshake(ctx, peer);
+ fastd_peer_unschedule_handshake(peer);
}
-static void init_handshake(fastd_context_t *ctx, fastd_peer_t *peer) {
+static void init_handshake(fastd_peer_t *peer) {
unsigned delay = 0;
if (has_group_config_constraints(peer->group->conf))
- delay = fastd_rand(ctx, 0, 3000);
+ delay = fastd_rand(0, 3000);
if (!fastd_peer_is_established(peer))
peer->state = STATE_HANDSHAKE;
- fastd_peer_schedule_handshake(ctx, peer, delay);
+ fastd_peer_schedule_handshake(peer, delay);
}
-void fastd_peer_handle_resolve(fastd_context_t *ctx, fastd_peer_t *peer, fastd_remote_t *remote, size_t n_addresses, const fastd_peer_address_t *addresses) {
+void fastd_peer_handle_resolve(fastd_peer_t *peer, fastd_remote_t *remote, size_t n_addresses, const fastd_peer_address_t *addresses) {
remote->resolving = false;
free(remote->addresses);
@@ -214,10 +214,10 @@ void fastd_peer_handle_resolve(fastd_context_t *ctx, fastd_peer_t *peer, fastd_r
remote->current_address = 0;
if (peer->state == STATE_RESOLVING)
- init_handshake(ctx, peer);
+ init_handshake(peer);
}
-static void setup_peer(fastd_context_t *ctx, fastd_peer_t *peer) {
+static void setup_peer(fastd_peer_t *peer) {
peer->address.sa.sa_family = AF_UNSPEC;
peer->local_address.sa.sa_family = AF_UNSPEC;
@@ -225,60 +225,60 @@ static void setup_peer(fastd_context_t *ctx, fastd_peer_t *peer) {
fastd_remote_t *remote;
for (remote = peer->remotes; remote; remote = remote->next) {
- remote->last_resolve_timeout = ctx->now;
+ remote->last_resolve_timeout = ctx.now;
remote->resolving = false;
}
peer->next_remote = peer->remotes;
- peer->last_handshake_timeout = ctx->now;
+ peer->last_handshake_timeout = ctx.now;
peer->last_handshake_address.sa.sa_family = AF_UNSPEC;
- peer->last_handshake_response_timeout = ctx->now;
+ peer->last_handshake_response_timeout = ctx.now;
peer->last_handshake_response_address.sa.sa_family = AF_UNSPEC;
- peer->establish_handshake_timeout = ctx->now;
+ peer->establish_handshake_timeout = ctx.now;
if (!peer->protocol_state)
- conf.protocol->init_peer_state(ctx, peer);
+ conf.protocol->init_peer_state(peer);
if (peer->next_remote) {
peer->next_remote->current_address = 0;
if (fastd_remote_is_dynamic(peer->next_remote)) {
peer->state = STATE_RESOLVING;
- fastd_resolve_peer(ctx, peer, peer->next_remote);
+ fastd_resolve_peer(peer, peer->next_remote);
}
else {
- init_handshake(ctx, peer);
+ init_handshake(peer);
}
}
}
-static void delete_peer(fastd_context_t *ctx, fastd_peer_t *peer) {
- pr_debug(ctx, "deleting peer %P", peer);
+static void delete_peer(fastd_peer_t *peer) {
+ pr_debug("deleting peer %P", peer);
size_t i;
- for (i = 0; i < VECTOR_LEN(ctx->peers); i++) {
- if (VECTOR_INDEX(ctx->peers, i) == peer) {
- VECTOR_DELETE(ctx->peers, i);
- fastd_poll_delete_peer(ctx, i);
+ for (i = 0; i < VECTOR_LEN(ctx.peers); i++) {
+ if (VECTOR_INDEX(ctx.peers, i) == peer) {
+ VECTOR_DELETE(ctx.peers, i);
+ fastd_poll_delete_peer(i);
break;
}
}
- if (i == VECTOR_LEN(ctx->peers)) {
- for (i = 0; i < VECTOR_LEN(ctx->peers_temp); i++) {
- if (VECTOR_INDEX(ctx->peers_temp, i) == peer) {
- VECTOR_DELETE(ctx->peers_temp, i);
+ if (i == VECTOR_LEN(ctx.peers)) {
+ for (i = 0; i < VECTOR_LEN(ctx.peers_temp); i++) {
+ if (VECTOR_INDEX(ctx.peers_temp, i) == peer) {
+ VECTOR_DELETE(ctx.peers_temp, i);
break;
}
}
}
- fastd_peer_hashtable_remove(ctx, peer);
+ fastd_peer_hashtable_remove(peer);
- conf.protocol->free_peer_state(ctx, peer);
+ conf.protocol->free_peer_state(peer);
if (!peer->config)
free(peer->protocol_config);
@@ -294,7 +294,7 @@ static void delete_peer(fastd_context_t *ctx, fastd_peer_t *peer) {
}
-fastd_peer_config_t* fastd_peer_config_new(fastd_context_t *ctx UNUSED) {
+fastd_peer_config_t* fastd_peer_config_new(void) {
fastd_peer_config_t *peer = calloc(1, sizeof(fastd_peer_config_t));
peer->group = conf.peer_group;
@@ -320,19 +320,19 @@ void fastd_peer_config_free(fastd_peer_config_t *peer) {
free(peer);
}
-void fastd_peer_config_delete(fastd_context_t *ctx UNUSED) {
+void fastd_peer_config_delete(void) {
fastd_peer_config_t *peer = conf.peers, *next = peer->next;
fastd_peer_config_free(peer);
conf.peers = next;
}
-void fastd_peer_config_purge(fastd_context_t *ctx, fastd_peer_config_t *config) {
+void fastd_peer_config_purge(fastd_peer_config_t *config) {
size_t i;
- for (i = 0; i < VECTOR_LEN(ctx->peers); i++) {
- fastd_peer_t *peer = VECTOR_INDEX(ctx->peers, i);
+ for (i = 0; i < VECTOR_LEN(ctx.peers); i++) {
+ fastd_peer_t *peer = VECTOR_INDEX(ctx.peers, i);
if (peer->config == config) {
- fastd_peer_delete(ctx, peer);
+ fastd_peer_delete(peer);
break;
}
}
@@ -394,15 +394,15 @@ void fastd_peer_address_widen(fastd_peer_address_t *addr) {
}
-static inline void reset_peer_address(fastd_context_t *ctx, fastd_peer_t *peer) {
+static inline void reset_peer_address(fastd_peer_t *peer) {
if (fastd_peer_is_established(peer))
- fastd_peer_reset(ctx, peer);
+ fastd_peer_reset(peer);
- fastd_peer_hashtable_remove(ctx, peer);
+ fastd_peer_hashtable_remove(peer);
memset(&peer->address, 0, sizeof(fastd_peer_address_t));
}
-bool fastd_peer_owns_address(fastd_context_t *ctx UNUSED, const fastd_peer_t *peer, const fastd_peer_address_t *addr) {
+bool fastd_peer_owns_address(const fastd_peer_t *peer, const fastd_peer_address_t *addr) {
if (fastd_peer_is_floating(peer))
return false;
@@ -418,7 +418,7 @@ bool fastd_peer_owns_address(fastd_context_t *ctx UNUSED, const fastd_peer_t *pe
return false;
}
-bool fastd_peer_matches_address(fastd_context_t *ctx UNUSED, const fastd_peer_t *peer, const fastd_peer_address_t *addr) {
+bool fastd_peer_matches_address(const fastd_peer_t *peer, const fastd_peer_address_t *addr) {
if (fastd_peer_is_floating(peer))
return true;
@@ -434,21 +434,21 @@ bool fastd_peer_matches_address(fastd_context_t *ctx UNUSED, const fastd_peer_t
return false;
}
-bool fastd_peer_claim_address(fastd_context_t *ctx, fastd_peer_t *new_peer, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr) {
+bool fastd_peer_claim_address(fastd_peer_t *new_peer, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr) {
if (remote_addr->sa.sa_family == AF_UNSPEC) {
if (fastd_peer_is_established(new_peer))
- fastd_peer_reset(ctx, new_peer);
+ fastd_peer_reset(new_peer);
}
else {
size_t i;
- for (i = 0; i < VECTOR_LEN(ctx->peers); i++) {
- fastd_peer_t *peer = VECTOR_INDEX(ctx->peers, i);
+ for (i = 0; i < VECTOR_LEN(ctx.peers); i++) {
+ fastd_peer_t *peer = VECTOR_INDEX(ctx.peers, i);
if (peer == new_peer)
continue;
- if (fastd_peer_owns_address(ctx, peer, remote_addr)) {
- reset_peer_address(ctx, new_peer);
+ if (fastd_peer_owns_address(peer, remote_addr)) {
+ reset_peer_address(new_peer);
return false;
}
@@ -456,21 +456,21 @@ bool fastd_peer_claim_address(fastd_context_t *ctx, fastd_peer_t *new_peer, fast
if (fastd_peer_is_established(peer))
return false;
- reset_peer_address(ctx, peer);
+ reset_peer_address(peer);
break;
}
}
}
- fastd_peer_hashtable_remove(ctx, new_peer);
+ fastd_peer_hashtable_remove(new_peer);
new_peer->address = *remote_addr;
if (remote_addr->sa.sa_family != AF_UNSPEC)
- fastd_peer_hashtable_insert(ctx, new_peer);
+ fastd_peer_hashtable_insert(new_peer);
if (sock && sock->addr && sock != new_peer->sock) {
- free_socket(ctx, new_peer);
+ free_socket(new_peer);
new_peer->sock = sock;
}
@@ -512,23 +512,23 @@ bool fastd_peer_config_equal(const fastd_peer_config_t *peer1, const fastd_peer_
return true;
}
-void fastd_peer_reset(fastd_context_t *ctx, fastd_peer_t *peer) {
- pr_debug(ctx, "resetting peer %P", peer);
+void fastd_peer_reset(fastd_peer_t *peer) {
+ pr_debug("resetting peer %P", peer);
- reset_peer(ctx, peer);
- setup_peer(ctx, peer);
+ reset_peer(peer);
+ setup_peer(peer);
}
-void fastd_peer_delete(fastd_context_t *ctx, fastd_peer_t *peer) {
- reset_peer(ctx, peer);
- delete_peer(ctx, peer);
+void fastd_peer_delete(fastd_peer_t *peer) {
+ reset_peer(peer);
+ delete_peer(peer);
}
-static inline unsigned count_established_group_peers(fastd_context_t *ctx, fastd_peer_group_t *group) {
+static inline unsigned count_established_group_peers(fastd_peer_group_t *group) {
unsigned ret = 0;
size_t i;
- for (i = 0; i < VECTOR_LEN(ctx->peers); i++) {
- fastd_peer_t *peer = VECTOR_INDEX(ctx->peers, i);
+ for (i = 0; i < VECTOR_LEN(ctx.peers); i++) {
+ fastd_peer_t *peer = VECTOR_INDEX(ctx.peers, i);
if (fastd_peer_is_established(peer) && is_peer_in_group(peer, group))
ret++;
@@ -537,7 +537,7 @@ static inline unsigned count_established_group_peers(fastd_context_t *ctx, fastd
return ret;
}
-bool fastd_peer_may_connect(fastd_context_t *ctx, fastd_peer_t *peer) {
+bool fastd_peer_may_connect(fastd_peer_t *peer) {
if (fastd_peer_is_established(peer))
return true;
@@ -547,18 +547,18 @@ bool fastd_peer_may_connect(fastd_context_t *ctx, fastd_peer_t *peer) {
if (group->conf->max_connections < 0)
continue;
- if (count_established_group_peers(ctx, group) >= (unsigned)group->conf->max_connections)
+ if (count_established_group_peers(group) >= (unsigned)group->conf->max_connections)
return false;
}
return true;
}
-fastd_peer_t* fastd_peer_add(fastd_context_t *ctx, fastd_peer_config_t *peer_conf) {
+fastd_peer_t* fastd_peer_add(fastd_peer_config_t *peer_conf) {
fastd_peer_t *peer = calloc(1, sizeof(fastd_peer_t));
peer->config = peer_conf;
- peer->group = find_peer_group(ctx->peer_group, peer_conf->group);
+ peer->group = find_peer_group(ctx.peer_group, peer_conf->group);
peer->protocol_config = peer_conf->protocol_config;
fastd_remote_t **remote = &peer->remotes;
@@ -579,74 +579,74 @@ fastd_peer_t* fastd_peer_add(fastd_context_t *ctx, fastd_peer_config_t *peer_con
remote_config = remote_config->next;
}
- pr_verbose(ctx, "adding peer %P (group `%s')", peer, peer->group->conf->name);
+ pr_verbose("adding peer %P (group `%s')", peer, peer->group->conf->name);
- setup_peer(ctx, peer);
+ setup_peer(peer);
- VECTOR_ADD(ctx->peers, peer);
- fastd_poll_add_peer(ctx);
+ VECTOR_ADD(ctx.peers, peer);
+ fastd_poll_add_peer();
return peer;
}
-fastd_peer_t* fastd_peer_add_temporary(fastd_context_t *ctx) {
+fastd_peer_t* fastd_peer_add_temporary(void) {
if (!fastd_shell_command_isset(&conf.on_verify))
- exit_bug(ctx, "tried to add temporary peer without on-verify command");
+ exit_bug("tried to add temporary peer without on-verify command");
fastd_peer_t *peer = calloc(1, sizeof(fastd_peer_t));
- peer->group = ctx->peer_group;
- fastd_peer_seen(ctx, peer);
+ peer->group = ctx.peer_group;
+ fastd_peer_seen(peer);
- pr_debug(ctx, "adding temporary peer");
+ pr_debug("adding temporary peer");
- setup_peer(ctx, peer);
+ setup_peer(peer);
- VECTOR_ADD(ctx->peers_temp, peer);
+ VECTOR_ADD(ctx.peers_temp, peer);
return peer;
}
-bool fastd_peer_verify_temporary(fastd_context_t *ctx, fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr) {
+bool fastd_peer_verify_temporary(fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr) {
if (!fastd_shell_command_isset(&conf.on_verify))
- exit_bug(ctx, "tried to verify temporary peer without on-verify command");
+ exit_bug("tried to verify temporary peer without on-verify command");
/* TODO: async not supported yet */
int ret;
- if (!fastd_shell_command_exec_sync(ctx, &conf.on_verify, peer, local_addr, peer_addr, &ret))
+ if (!fastd_shell_command_exec_sync(&conf.on_verify, peer, local_addr, peer_addr, &ret))
return false;
if (WIFSIGNALED(ret)) {
- pr_error(ctx, "verify command exited with signal %i", WTERMSIG(ret));
+ pr_error("verify command exited with signal %i", WTERMSIG(ret));
return false;
}
else if (WEXITSTATUS(ret)) {
- pr_debug(ctx, "verify command exited with status %i", WEXITSTATUS(ret));
+ pr_debug("verify command exited with status %i", WEXITSTATUS(ret));
return false;
}
return true;
}
-void fastd_peer_enable_temporary(fastd_context_t *ctx, fastd_peer_t *peer) {
+void fastd_peer_enable_temporary(fastd_peer_t *peer) {
if (peer->config)
- exit_bug(ctx, "trying to re-enable non-temporary peer");
+ exit_bug("trying to re-enable non-temporary peer");
- VECTOR_ADD(ctx->peers, peer);
- fastd_poll_add_peer(ctx);
+ VECTOR_ADD(ctx.peers, peer);
+ fastd_poll_add_peer();
}
-void fastd_peer_set_established(fastd_context_t *ctx, fastd_peer_t *peer) {
+void fastd_peer_set_established(fastd_peer_t *peer) {
if (fastd_peer_is_established(peer))
return;
peer->state = STATE_ESTABLISHED;
- on_establish(ctx, peer);
- pr_info(ctx, "connection with %P established.", peer);
+ on_establish(peer);
+ pr_info("connection with %P established.", peer);
}
-fastd_eth_addr_t fastd_get_source_address(const fastd_context_t *ctx, fastd_buffer_t buffer) {
+fastd_eth_addr_t fastd_get_source_address(const fastd_buffer_t buffer) {
fastd_eth_addr_t ret;
switch (conf.mode) {
@@ -654,18 +654,18 @@ fastd_eth_addr_t fastd_get_source_address(const fastd_context_t *ctx, fastd_buff
memcpy(&ret, buffer.data+offsetof(struct ethhdr, h_source), ETH_ALEN);
return ret;
default:
- exit_bug(ctx, "invalid mode");
+ exit_bug("invalid mode");
}
}
-fastd_eth_addr_t fastd_get_dest_address(const fastd_context_t *ctx, fastd_buffer_t buffer) {
+fastd_eth_addr_t fastd_get_dest_address(const fastd_buffer_t buffer) {
fastd_eth_addr_t ret;
switch (conf.mode) {
case MODE_TAP:
memcpy(&ret, buffer.data+offsetof(struct ethhdr, h_dest), ETH_ALEN);
return ret;
default:
- exit_bug(ctx, "invalid mode");
+ exit_bug("invalid mode");
}
}
@@ -693,8 +693,8 @@ static inline int fastd_eth_addr_cmp(const fastd_eth_addr_t *addr1, const fastd_
return memcmp(addr1->data, addr2->data, ETH_ALEN);
}
-static inline fastd_peer_eth_addr_t* peer_get_by_addr(fastd_context_t *ctx, fastd_eth_addr_t addr) {
- fastd_eth_addr_t *ret = bsearch(&addr, &VECTOR_INDEX(ctx->eth_addrs, 0).addr, VECTOR_LEN(ctx->eth_addrs), sizeof(fastd_peer_eth_addr_t),
+static inline fastd_peer_eth_addr_t* peer_get_by_addr(fastd_eth_addr_t addr) {
+ fastd_eth_addr_t *ret = bsearch(&addr, &VECTOR_INDEX(ctx.eth_addrs, 0).addr, VECTOR_LEN(ctx.eth_addrs), sizeof(fastd_peer_eth_addr_t),
(int (*)(const void *, const void *))fastd_eth_addr_cmp);
if (ret)
@@ -703,19 +703,19 @@ static inline fastd_peer_eth_addr_t* peer_get_by_addr(fastd_context_t *ctx, fast
return NULL;
}
-void fastd_peer_eth_addr_add(fastd_context_t *ctx, fastd_peer_t *peer, fastd_eth_addr_t addr) {
- int min = 0, max = VECTOR_LEN(ctx->eth_addrs);
+void fastd_peer_eth_addr_add(fastd_peer_t *peer, fastd_eth_addr_t addr) {
+ int min = 0, max = VECTOR_LEN(ctx.eth_addrs);
if (!fastd_peer_is_established(peer))
- exit_bug(ctx, "tried to learn ethernet address on non-established peer");
+ exit_bug("tried to learn ethernet address on non-established peer");
while (max > min) {
int cur = (min+max)/2;
- int cmp = fastd_eth_addr_cmp(&addr, &VECTOR_INDEX(ctx->eth_addrs, cur).addr);
+ int cmp = fastd_eth_addr_cmp(&addr, &VECTOR_INDEX(ctx.eth_addrs, cur).addr);
if (cmp == 0) {
- VECTOR_INDEX(ctx->eth_addrs, cur).peer = peer;
- VECTOR_INDEX(ctx->eth_addrs, cur).timeout = fastd_in_seconds(ctx, conf.eth_addr_stale_time);
+ VECTOR_INDEX(ctx.eth_addrs, cur).peer = peer;
+ VECTOR_INDEX(ctx.eth_addrs, cur).timeout = fastd_in_seconds(conf.eth_addr_stale_time);
return; /* We're done here. */
}
else if (cmp < 0) {
@@ -726,30 +726,30 @@ void fastd_peer_eth_addr_add(fastd_context_t *ctx, fastd_peer_t *peer, fastd_eth
}
}
- VECTOR_INSERT(ctx->eth_addrs, ((fastd_peer_eth_addr_t) {addr, peer, fastd_in_seconds(ctx, conf.eth_addr_stale_time)}), min);
+ VECTOR_INSERT(ctx.eth_addrs, ((fastd_peer_eth_addr_t) {addr, peer, fastd_in_seconds(conf.eth_addr_stale_time)}), min);
- pr_debug(ctx, "learned new MAC address %E on peer %P", &addr, peer);
+ pr_debug("learned new MAC address %E on peer %P", &addr, peer);
}
-void fastd_peer_eth_addr_cleanup(fastd_context_t *ctx) {
+void fastd_peer_eth_addr_cleanup(void) {
size_t i, deleted = 0;
- for (i = 0; i < VECTOR_LEN(ctx->eth_addrs); i++) {
- if (fastd_timed_out(ctx, &VECTOR_INDEX(ctx->eth_addrs, i).timeout)) {
+ for (i = 0; i < VECTOR_LEN(ctx.eth_addrs); i++) {
+ if (fastd_timed_out(&VECTOR_INDEX(ctx.eth_addrs, i).timeout)) {
deleted++;
- pr_debug(ctx, "MAC address %E not seen for more than %u seconds, removing",
- &VECTOR_INDEX(ctx->eth_addrs, i).addr, conf.eth_addr_stale_time);
+ pr_debug("MAC address %E not seen for more than %u seconds, removing",
+ &VECTOR_INDEX(ctx.eth_addrs, i).addr, conf.eth_addr_stale_time);
}
else if (deleted) {
- VECTOR_INDEX(ctx->eth_addrs, i-deleted) = VECTOR_INDEX(ctx->eth_addrs, i);
+ VECTOR_INDEX(ctx.eth_addrs, i-deleted) = VECTOR_INDEX(ctx.eth_addrs, i);
}
}
- VECTOR_RESIZE(ctx->eth_addrs, VECTOR_LEN(ctx->eth_addrs)-deleted);
+ VECTOR_RESIZE(ctx.eth_addrs, VECTOR_LEN(ctx.eth_addrs)-deleted);
}
-fastd_peer_t* fastd_peer_find_by_eth_addr(fastd_context_t *ctx, const fastd_eth_addr_t addr) {
- fastd_peer_eth_addr_t *peer_eth_addr = peer_get_by_addr(ctx, addr);
+fastd_peer_t* fastd_peer_find_by_eth_addr(const fastd_eth_addr_t addr) {
+ fastd_peer_eth_addr_t *peer_eth_addr = peer_get_by_addr(addr);
if (peer_eth_addr)
return peer_eth_addr->peer;
diff --git a/src/peer.h b/src/peer.h
index 8d1afa2..1fa4822 100644
--- a/src/peer.h
+++ b/src/peer.h
@@ -122,41 +122,41 @@ static inline uint16_t fastd_peer_address_get_port(const fastd_peer_address_t *a
}
}
-fastd_peer_config_t* fastd_peer_config_new(fastd_context_t *ctx);
+fastd_peer_config_t* fastd_peer_config_new(void);
void fastd_peer_config_free(fastd_peer_config_t *peer);
-void fastd_peer_config_delete(fastd_context_t *ctx);
-void fastd_peer_config_purge(fastd_context_t *ctx, fastd_peer_config_t *config);
+void fastd_peer_config_delete(void);
+void fastd_peer_config_purge(fastd_peer_config_t *config);
bool fastd_peer_config_equal(const fastd_peer_config_t *peer1, const fastd_peer_config_t *peer2);
-void fastd_peer_reset(fastd_context_t *ctx, fastd_peer_t *peer);
-void fastd_peer_delete(fastd_context_t *ctx, fastd_peer_t *peer);
-fastd_peer_t* fastd_peer_add(fastd_context_t *ctx, fastd_peer_config_t *peer_conf);
-fastd_peer_t* fastd_peer_add_temporary(fastd_context_t *ctx);
-bool fastd_peer_verify_temporary(fastd_context_t *ctx, fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr);
-void fastd_peer_enable_temporary(fastd_context_t *ctx, fastd_peer_t *peer);
-void fastd_peer_set_established(fastd_context_t *ctx, fastd_peer_t *peer);
-bool fastd_peer_may_connect(fastd_context_t *ctx, fastd_peer_t *peer);
-void fastd_peer_handle_resolve(fastd_context_t *ctx, fastd_peer_t *peer, fastd_remote_t *remote, size_t n_addresses, const fastd_peer_address_t *addresses);
-bool fastd_peer_owns_address(fastd_context_t *ctx, const fastd_peer_t *peer, const fastd_peer_address_t *addr);
-bool fastd_peer_matches_address(fastd_context_t *ctx, const fastd_peer_t *peer, const fastd_peer_address_t *addr);
-bool fastd_peer_claim_address(fastd_context_t *ctx, fastd_peer_t *peer, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr);
-void fastd_peer_reset_socket(fastd_context_t *ctx, fastd_peer_t *peer);
-void fastd_peer_schedule_handshake(fastd_context_t *ctx, fastd_peer_t *peer, int delay);
-
-static inline void fastd_peer_schedule_handshake_default(fastd_context_t *ctx, fastd_peer_t *peer) {
- fastd_peer_schedule_handshake(ctx, peer, fastd_rand(ctx, 17500, 22500));
+void fastd_peer_reset(fastd_peer_t *peer);
+void fastd_peer_delete(fastd_peer_t *peer);
+fastd_peer_t* fastd_peer_add(fastd_peer_config_t *peer_conf);
+fastd_peer_t* fastd_peer_add_temporary(void);
+bool fastd_peer_verify_temporary(fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr);
+void fastd_peer_enable_temporary(fastd_peer_t *peer);
+void fastd_peer_set_established(fastd_peer_t *peer);
+bool fastd_peer_may_connect(fastd_peer_t *peer);
+void fastd_peer_handle_resolve(fastd_peer_t *peer, fastd_remote_t *remote, size_t n_addresses, const fastd_peer_address_t *addresses);
+bool fastd_peer_owns_address(const fastd_peer_t *peer, const fastd_peer_address_t *addr);
+bool fastd_peer_matches_address(const fastd_peer_t *peer, const fastd_peer_address_t *addr);
+bool fastd_peer_claim_address(fastd_peer_t *peer, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr);
+void fastd_peer_reset_socket(fastd_peer_t *peer);
+void fastd_peer_schedule_handshake(fastd_peer_t *peer, int delay);
+
+static inline void fastd_peer_schedule_handshake_default(fastd_peer_t *peer) {
+ fastd_peer_schedule_handshake(peer, fastd_rand(17500, 22500));
}
-static inline void fastd_peer_unschedule_handshake(fastd_context_t *ctx UNUSED, fastd_peer_t *peer) {
+static inline void fastd_peer_unschedule_handshake(fastd_peer_t *peer) {
fastd_dlist_remove(&peer->handshake_entry);
}
-static inline bool fastd_peer_handshake_scheduled(fastd_context_t *ctx UNUSED, fastd_peer_t *peer) {
+static inline bool fastd_peer_handshake_scheduled(fastd_peer_t *peer) {
return fastd_dlist_linked(&peer->handshake_entry);
}
-fastd_eth_addr_t fastd_get_source_address(const fastd_context_t *ctx, fastd_buffer_t buffer);
-fastd_eth_addr_t fastd_get_dest_address(const fastd_context_t *ctx, fastd_buffer_t buffer);
+fastd_eth_addr_t fastd_get_source_address(const fastd_buffer_t buffer);
+fastd_eth_addr_t fastd_get_dest_address(const fastd_buffer_t buffer);
static inline bool fastd_peer_config_is_floating(const fastd_peer_config_t *config) {
return (!config->remotes || config->floating);
@@ -197,8 +197,8 @@ static inline bool fastd_remote_is_dynamic(const fastd_remote_t *remote) {
return remote->config->hostname;
}
-static inline void fastd_peer_seen(fastd_context_t *ctx, fastd_peer_t *peer) {
- peer->timeout = fastd_in_seconds(ctx, conf.peer_stale_time);
+static inline void fastd_peer_seen(fastd_peer_t *peer) {
+ peer->timeout = fastd_in_seconds(conf.peer_stale_time);
}
static inline bool fastd_peer_is_socket_dynamic(const fastd_peer_t *peer) {
@@ -209,6 +209,6 @@ static inline bool fastd_eth_addr_is_unicast(fastd_eth_addr_t addr) {
return ((addr.data[0] & 1) == 0);
}
-void fastd_peer_eth_addr_add(fastd_context_t *ctx, fastd_peer_t *peer, fastd_eth_addr_t addr);
-void fastd_peer_eth_addr_cleanup(fastd_context_t *ctx);
-fastd_peer_t* fastd_peer_find_by_eth_addr(fastd_context_t *ctx, fastd_eth_addr_t addr);
+void fastd_peer_eth_addr_add(fastd_peer_t *peer, fastd_eth_addr_t addr);
+void fastd_peer_eth_addr_cleanup(void);
+fastd_peer_t* fastd_peer_find_by_eth_addr(fastd_eth_addr_t addr);
diff --git a/src/peer_hashtable.c b/src/peer_hashtable.c
index f6cc11e..003a16c 100644
--- a/src/peer_hashtable.c
+++ b/src/peer_hashtable.c
@@ -33,26 +33,26 @@
#define PEER_ADDR_HT_SIZE 64
-void fastd_peer_hashtable_init(fastd_context_t *ctx) {
- fastd_random_bytes(ctx, &ctx->peer_addr_ht_seed, sizeof(ctx->peer_addr_ht_seed), false);
+void fastd_peer_hashtable_init(void) {
+ fastd_random_bytes(&ctx.peer_addr_ht_seed, sizeof(ctx.peer_addr_ht_seed), false);
- ctx->peer_addr_ht = malloc(sizeof(*ctx->peer_addr_ht) * PEER_ADDR_HT_SIZE);
+ ctx.peer_addr_ht = malloc(sizeof(*ctx.peer_addr_ht) * PEER_ADDR_HT_SIZE);
size_t i;
for (i = 0; i < PEER_ADDR_HT_SIZE; i++)
- VECTOR_ALLOC(ctx->peer_addr_ht[i], 0);
+ VECTOR_ALLOC(ctx.peer_addr_ht[i], 0);
}
-void fastd_peer_hashtable_free(fastd_context_t *ctx) {
+void fastd_peer_hashtable_free(void) {
size_t i;
for (i = 0; i < PEER_ADDR_HT_SIZE; i++)
- VECTOR_FREE(ctx->peer_addr_ht[i]);
+ VECTOR_FREE(ctx.peer_addr_ht[i]);
- free(ctx->peer_addr_ht);
+ free(ctx.peer_addr_ht);
}
-static size_t peer_address_bucket(fastd_context_t *ctx, const fastd_peer_address_t *addr) {
- uint32_t hash = ctx->peer_addr_ht_seed;
+static size_t peer_address_bucket(const fastd_peer_address_t *addr) {
+ uint32_t hash = ctx.peer_addr_ht_seed;
switch(addr->sa.sa_family) {
case AF_INET:
@@ -64,7 +64,7 @@ static size_t peer_address_bucket(fastd_context_t *ctx, const fastd_peer_address
break;
default:
- exit_bug(ctx, "peer_address_bucket: unknown address family");
+ exit_bug("peer_address_bucket: unknown address family");
}
fastd_hash_final(&hash);
@@ -72,32 +72,32 @@ static size_t peer_address_bucket(fastd_context_t *ctx, const fastd_peer_address
return hash % PEER_ADDR_HT_SIZE;
}
-void fastd_peer_hashtable_insert(fastd_context_t *ctx, fastd_peer_t *peer) {
- size_t b = peer_address_bucket(ctx, &peer->address);
- VECTOR_ADD(ctx->peer_addr_ht[b], peer);
+void fastd_peer_hashtable_insert(fastd_peer_t *peer) {
+ size_t b = peer_address_bucket(&peer->address);
+ VECTOR_ADD(ctx.peer_addr_ht[b], peer);
}
-void fastd_peer_hashtable_remove(fastd_context_t *ctx, fastd_peer_t *peer) {
+void fastd_peer_hashtable_remove(fastd_peer_t *peer) {
if (!peer->address.sa.sa_family)
return;
- size_t b = peer_address_bucket(ctx, &peer->address);
+ size_t b = peer_address_bucket(&peer->address);
size_t i;
- for (i = 0; i < VECTOR_LEN(ctx->peer_addr_ht[b]); i++) {
- if (VECTOR_INDEX(ctx->peer_addr_ht[b], i) == peer) {
- VECTOR_DELETE(ctx->peer_addr_ht[b], i);
+ for (i = 0; i < VECTOR_LEN(ctx.peer_addr_ht[b]); i++) {
+ if (VECTOR_INDEX(ctx.peer_addr_ht[b], i) == peer) {
+ VECTOR_DELETE(ctx.peer_addr_ht[b], i);
break;
}
}
}
-fastd_peer_t *fastd_peer_hashtable_lookup(fastd_context_t *ctx, const fastd_peer_address_t *addr) {
- size_t b = peer_address_bucket(ctx, addr);
+fastd_peer_t *fastd_peer_hashtable_lookup(const fastd_peer_address_t *addr) {
+ size_t b = peer_address_bucket(addr);
size_t i;
- for (i = 0; i < VECTOR_LEN(ctx->peer_addr_ht[b]); i++) {
- fastd_peer_t *peer = VECTOR_INDEX(ctx->peer_addr_ht[b], i);
+ for (i = 0; i < VECTOR_LEN(ctx.peer_addr_ht[b]); i++) {
+ fastd_peer_t *peer = VECTOR_INDEX(ctx.peer_addr_ht[b], i);
if (fastd_peer_address_equal(&peer->address, addr))
return peer;
diff --git a/src/peer_hashtable.h b/src/peer_hashtable.h
index 5952ae4..6c026bc 100644
--- a/src/peer_hashtable.h
+++ b/src/peer_hashtable.h
@@ -30,9 +30,9 @@
#include "types.h"
-void fastd_peer_hashtable_init(fastd_context_t *ctx);
-void fastd_peer_hashtable_free(fastd_context_t *ctx);
+void fastd_peer_hashtable_init(void);
+void fastd_peer_hashtable_free(void);
-void fastd_peer_hashtable_insert(fastd_context_t *ctx, fastd_peer_t *peer);
-void fastd_peer_hashtable_remove(fastd_context_t *ctx, fastd_peer_t *peer);
-fastd_peer_t *fastd_peer_hashtable_lookup(fastd_context_t *ctx, const fastd_peer_address_t *addr);
+void fastd_peer_hashtable_insert(fastd_peer_t *peer);
+void fastd_peer_hashtable_remove(fastd_peer_t *peer);
+fastd_peer_t *fastd_peer_hashtable_lookup(const fastd_peer_address_t *addr);
diff --git a/src/poll.c b/src/poll.c
index 7fd6b6b..79b847a 100644
--- a/src/poll.c
+++ b/src/poll.c
@@ -35,48 +35,48 @@
#endif
-static inline bool handle_tap(fastd_context_t *ctx, fastd_buffer_t buffer) {
+static inline bool handle_tap(fastd_buffer_t buffer) {
if (conf.mode != MODE_TAP)
return false;
if (buffer.len < ETH_HLEN) {
- pr_debug(ctx, "truncated packet on tap interface");
+ pr_debug("truncated packet on tap interface");
fastd_buffer_free(buffer);
return true;
}
- fastd_eth_addr_t dest_addr = fastd_get_dest_address(ctx, buffer);
+ fastd_eth_addr_t dest_addr = fastd_get_dest_address(buffer);
if (!fastd_eth_addr_is_unicast(dest_addr))
return false;
- fastd_peer_t *peer = fastd_peer_find_by_eth_addr(ctx, dest_addr);
+ fastd_peer_t *peer = fastd_peer_find_by_eth_addr(dest_addr);
if (!peer)
return false;
- conf.protocol->send(ctx, peer, buffer);
+ conf.protocol->send(peer, buffer);
return true;
}
-static void handle_tuntap(fastd_context_t *ctx) {
- fastd_buffer_t buffer = fastd_tuntap_read(ctx);
+static void handle_tuntap(void) {
+ fastd_buffer_t buffer = fastd_tuntap_read();
if (!buffer.len)
return;
- if (handle_tap(ctx, buffer))
+ if (handle_tap(buffer))
return;
/* TUN mode or multicast packet */
- fastd_send_all(ctx, NULL, buffer);
+ fastd_send_all(NULL, buffer);
}
-static inline int handshake_timeout(fastd_context_t *ctx) {
- if (!ctx->handshake_queue.next)
+static inline int handshake_timeout(void) {
+ if (!ctx.handshake_queue.next)
return -1;
- fastd_peer_t *peer = container_of(ctx->handshake_queue.next, fastd_peer_t, handshake_entry);
+ fastd_peer_t *peer = container_of(ctx.handshake_queue.next, fastd_peer_t, handshake_entry);
- int diff_msec = timespec_diff(&peer->next_handshake, &ctx->now);
+ int diff_msec = timespec_diff(&peer->next_handshake, &ctx.now);
if (diff_msec < 0)
return 0;
else
@@ -90,45 +90,45 @@ static inline int handshake_timeout(fastd_context_t *ctx) {
#include <sys/epoll.h>
-void fastd_poll_init(fastd_context_t *ctx) {
- ctx->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
- if (ctx->epoll_fd < 0)
- exit_errno(ctx, "epoll_create1");
+void fastd_poll_init(void) {
+ ctx.epoll_fd = epoll_create1(EPOLL_CLOEXEC);
+ if (ctx.epoll_fd < 0)
+ exit_errno("epoll_create1");
struct epoll_event event = {
.events = EPOLLIN,
- .data.ptr = &ctx->async_rfd,
+ .data.ptr = &ctx.async_rfd,
};
- if (epoll_ctl(ctx->epoll_fd, EPOLL_CTL_ADD, ctx->async_rfd, &event) < 0)
- exit_errno(ctx, "epoll_ctl");
+ if (epoll_ctl(ctx.epoll_fd, EPOLL_CTL_ADD, ctx.async_rfd, &event) < 0)
+ exit_errno("epoll_ctl");
}
-void fastd_poll_free(fastd_context_t *ctx) {
- if (close(ctx->epoll_fd))
- pr_warn_errno(ctx, "closing EPOLL: close");
+void fastd_poll_free(void) {
+ if (close(ctx.epoll_fd))
+ pr_warn_errno("closing EPOLL: close");
}
-void fastd_poll_set_fd_tuntap(fastd_context_t *ctx) {
+void fastd_poll_set_fd_tuntap(void) {
struct epoll_event event = {
.events = EPOLLIN,
- .data.ptr = &ctx->tunfd,
+ .data.ptr = &ctx.tunfd,
};
- if (epoll_ctl(ctx->epoll_fd, EPOLL_CTL_ADD, ctx->tunfd, &event) < 0)
- exit_errno(ctx, "epoll_ctl");
+ if (epoll_ctl(ctx.epoll_fd, EPOLL_CTL_ADD, ctx.tunfd, &event) < 0)
+ exit_errno("epoll_ctl");
}
-void fastd_poll_set_fd_sock(fastd_context_t *ctx, size_t i) {
+void fastd_poll_set_fd_sock(size_t i) {
struct epoll_event event = {
.events = EPOLLIN,
- .data.ptr = &ctx->socks[i],
+ .data.ptr = &ctx.socks[i],
};
- if (epoll_ctl(ctx->epoll_fd, EPOLL_CTL_ADD, ctx->socks[i].fd, &event) < 0)
- exit_errno(ctx, "epoll_ctl");
+ if (epoll_ctl(ctx.epoll_fd, EPOLL_CTL_ADD, ctx.socks[i].fd, &event) < 0)
+ exit_errno("epoll_ctl");
}
-void fastd_poll_set_fd_peer(fastd_context_t *ctx, size_t i) {
- fastd_peer_t *peer = VECTOR_INDEX(ctx->peers, i);
+void fastd_poll_set_fd_peer(size_t i) {
+ fastd_peer_t *peer = VECTOR_INDEX(ctx.peers, i);
if (!peer->sock || !fastd_peer_is_socket_dynamic(peer))
return;
@@ -137,59 +137,59 @@ void fastd_poll_set_fd_peer(fastd_context_t *ctx, size_t i) {
.events = EPOLLIN,
.data.ptr = peer->sock,
};
- if (epoll_ctl(ctx->epoll_fd, EPOLL_CTL_ADD, peer->sock->fd, &event) < 0)
- exit_errno(ctx, "epoll_ctl");
+ if (epoll_ctl(ctx.epoll_fd, EPOLL_CTL_ADD, peer->sock->fd, &event) < 0)
+ exit_errno("epoll_ctl");
}
-void fastd_poll_add_peer(fastd_context_t *ctx UNUSED) {
+void fastd_poll_add_peer(void) {
}
-void fastd_poll_delete_peer(fastd_context_t *ctx UNUSED, size_t i UNUSED) {
+void fastd_poll_delete_peer(size_t i UNUSED) {
}
-void fastd_poll_handle(fastd_context_t *ctx) {
- int maintenance_timeout = timespec_diff(&ctx->next_maintenance, &ctx->now);
+void fastd_poll_handle(void) {
+ int maintenance_timeout = timespec_diff(&ctx.next_maintenance, &ctx.now);
if (maintenance_timeout < 0)
maintenance_timeout = 0;
- int timeout = handshake_timeout(ctx);
+ int timeout = handshake_timeout();
if (timeout < 0 || timeout > maintenance_timeout)
timeout = maintenance_timeout;
- fastd_update_time(ctx);
+ fastd_update_time();
struct epoll_event events[16];
- int ret = epoll_wait(ctx->epoll_fd, events, 16, timeout);
+ int ret = epoll_wait(ctx.epoll_fd, events, 16, timeout);
if (ret < 0) {
if (errno == EINTR)
return;
- exit_errno(ctx, "epoll_wait");
+ exit_errno("epoll_wait");
}
size_t i;
for (i = 0; i < (size_t)ret; i++) {
- if (events[i].data.ptr == &ctx->tunfd) {
+ if (events[i].data.ptr == &ctx.tunfd) {
if (events[i].events & EPOLLIN)
- handle_tuntap(ctx);
+ handle_tuntap();
}
- else if (events[i].data.ptr == &ctx->async_rfd) {
+ else if (events[i].data.ptr == &ctx.async_rfd) {
if (events[i].events & EPOLLIN)
- fastd_async_handle(ctx);
+ fastd_async_handle();
}
else {
fastd_socket_t *sock = events[i].data.ptr;
if (events[i].events & (EPOLLERR|EPOLLHUP)) {
if (sock->peer)
- fastd_peer_reset_socket(ctx, sock->peer);
+ fastd_peer_reset_socket(sock->peer);
else
- fastd_socket_error(ctx, sock);
+ fastd_socket_error(sock);
}
else if (events[i].events & EPOLLIN) {
- fastd_receive(ctx, sock);
+ fastd_receive(sock);
}
}
}
@@ -197,24 +197,24 @@ void fastd_poll_handle(fastd_context_t *ctx) {
#else
-void fastd_poll_init(fastd_context_t *ctx) {
- VECTOR_ALLOC(ctx->pollfds, 2 + ctx->n_socks);
+void fastd_poll_init(void) {
+ VECTOR_ALLOC(ctx.pollfds, 2 + ctx.n_socks);
- VECTOR_INDEX(ctx->pollfds, 0) = (struct pollfd) {
+ VECTOR_INDEX(ctx.pollfds, 0) = (struct pollfd) {
.fd = -1,
.events = POLLIN,
.revents = 0,
};
- VECTOR_INDEX(ctx->pollfds, 1) = (struct pollfd) {
- .fd = ctx->async_rfd,
+ VECTOR_INDEX(ctx.pollfds, 1) = (struct pollfd) {
+ .fd = ctx.async_rfd,
.events = POLLIN,
.revents = 0,
};
size_t i;
- for (i = 0; i < ctx->n_socks; i++) {
- VECTOR_INDEX(ctx->pollfds, 2+i) = (struct pollfd) {
+ for (i = 0; i < ctx.n_socks; i++) {
+ VECTOR_INDEX(ctx.pollfds, 2+i) = (struct pollfd) {
.fd = -1,
.events = POLLIN,
.revents = 0,
@@ -222,87 +222,87 @@ void fastd_poll_init(fastd_context_t *ctx) {
}
}
-void fastd_poll_free(fastd_context_t *ctx) {
- VECTOR_FREE(ctx->pollfds);
+void fastd_poll_free(void) {
+ VECTOR_FREE(ctx.pollfds);
}
-void fastd_poll_set_fd_tuntap(fastd_context_t *ctx) {
- VECTOR_INDEX(ctx->pollfds, 0).fd = ctx->tunfd;
+void fastd_poll_set_fd_tuntap(void) {
+ VECTOR_INDEX(ctx.pollfds, 0).fd = ctx.tunfd;
}
-void fastd_poll_set_fd_sock(fastd_context_t *ctx, size_t i) {
- VECTOR_INDEX(ctx->pollfds, 2+i).fd = ctx->socks[i].fd;
+void fastd_poll_set_fd_sock(size_t i) {
+ VECTOR_INDEX(ctx.pollfds, 2+i).fd = ctx.socks[i].fd;
}
-void fastd_poll_set_fd_peer(fastd_context_t *ctx, size_t i) {
- fastd_peer_t *peer = VECTOR_INDEX(ctx->peers, i);
+void fastd_poll_set_fd_peer(size_t i) {
+ fastd_peer_t *peer = VECTOR_INDEX(ctx.peers, i);
if (!peer->sock || !fastd_peer_is_socket_dynamic(peer))
- VECTOR_INDEX(ctx->pollfds, 2+ctx->n_socks+i).fd = -1;
+ VECTOR_INDEX(ctx.pollfds, 2+ctx.n_socks+i).fd = -1;
else
- VECTOR_INDEX(ctx->pollfds, 2+ctx->n_socks+i).fd = peer->sock->fd;
+ VECTOR_INDEX(ctx.pollfds, 2+ctx.n_socks+i).fd = peer->sock->fd;
}
-void fastd_poll_add_peer(fastd_context_t *ctx) {
+void fastd_poll_add_peer(void) {
struct pollfd pollfd = {
.fd = -1,
.events = POLLIN,
.revents = 0,
};
- VECTOR_ADD(ctx->pollfds, pollfd);
+ VECTOR_ADD(ctx.pollfds, pollfd);
}
-void fastd_poll_delete_peer(fastd_context_t *ctx, size_t i) {
- VECTOR_DELETE(ctx->pollfds, 2+ctx->n_socks+i);
+void fastd_poll_delete_peer(size_t i) {
+ VECTOR_DELETE(ctx.pollfds, 2+ctx.n_socks+i);
}
-void fastd_poll_handle(fastd_context_t *ctx) {
- int maintenance_timeout = timespec_diff(&ctx->next_maintenance, &ctx->now);
+void fastd_poll_handle(void) {
+ int maintenance_timeout = timespec_diff(&ctx.next_maintenance, &ctx.now);
if (maintenance_timeout < 0)
maintenance_timeout = 0;
- int timeout = handshake_timeout(ctx);
+ int timeout = handshake_timeout();
if (timeout < 0 || timeout > maintenance_timeout)
timeout = maintenance_timeout;
- int ret = poll(VECTOR_DATA(ctx->pollfds), VECTOR_LEN(ctx->pollfds), timeout);
+ int ret = poll(VECTOR_DATA(ctx.pollfds), VECTOR_LEN(ctx.pollfds), timeout);
if (ret < 0) {
if (errno == EINTR)
return;
- exit_errno(ctx, "poll");
+ exit_errno("poll");
}
- fastd_update_time(ctx);
+ fastd_update_time();
- if (VECTOR_INDEX(ctx->pollfds, 0).revents & POLLIN)
- handle_tuntap(ctx);
- if (VECTOR_INDEX(ctx->pollfds, 1).revents & POLLIN)
- fastd_async_handle(ctx);
+ if (VECTOR_INDEX(ctx.pollfds, 0).revents & POLLIN)
+ handle_tuntap();
+ if (VECTOR_INDEX(ctx.pollfds, 1).revents & POLLIN)
+ fastd_async_handle();
size_t i;
- for (i = 0; i < ctx->n_socks; i++) {
- if (VECTOR_INDEX(ctx->pollfds, 2+i).revents & (POLLERR|POLLHUP|POLLNVAL)) {
- fastd_socket_error(ctx, &ctx->socks[i]);
- VECTOR_INDEX(ctx->pollfds, 2+i).fd = -1;
+ for (i = 0; i < ctx.n_socks; i++) {
+ if (VECTOR_INDEX(ctx.pollfds, 2+i).revents & (POLLERR|POLLHUP|POLLNVAL)) {
+ fastd_socket_error(&ctx.socks[i]);
+ VECTOR_INDEX(ctx.pollfds, 2+i).fd = -1;
}
- else if (VECTOR_INDEX(ctx->pollfds, 2+i).revents & POLLIN) {
- fastd_receive(ctx, &ctx->socks[i]);
+ else if (VECTOR_INDEX(ctx.pollfds, 2+i).revents & POLLIN) {
+ fastd_receive(&ctx.socks[i]);
}
}
- for (i = 0; i < VECTOR_LEN(ctx->peers); i++) {
- fastd_peer_t *peer = VECTOR_INDEX(ctx->peers, i);
+ for (i = 0; i < VECTOR_LEN(ctx.peers); i++) {
+ fastd_peer_t *peer = VECTOR_INDEX(ctx.peers, i);
- if (VECTOR_INDEX(ctx->pollfds, 2+ctx->n_socks+i).revents & (POLLERR|POLLHUP|POLLNVAL)) {
- fastd_peer_reset_socket(ctx, peer);
+ if (VECTOR_INDEX(ctx.pollfds, 2+ctx.n_socks+i).revents & (POLLERR|POLLHUP|POLLNVAL)) {
+ fastd_peer_reset_socket(peer);
}
- else if (VECTOR_INDEX(ctx->pollfds, 2+ctx->n_socks+i).revents & POLLIN) {
- fastd_receive(ctx, peer->sock);
+ else if (VECTOR_INDEX(ctx.pollfds, 2+ctx.n_socks+i).revents & POLLIN) {
+ fastd_receive(peer->sock);
}
}
}
diff --git a/src/poll.h b/src/poll.h
index 4049824..dcf5d6c 100644
--- a/src/poll.h
+++ b/src/poll.h
@@ -30,14 +30,14 @@
#include "types.h"
-void fastd_poll_init(fastd_context_t *ctx);
-void fastd_poll_free(fastd_context_t *ctx);
+void fastd_poll_init(void);
+void fastd_poll_free(void);
-void fastd_poll_set_fd_tuntap(fastd_context_t *ctx);
-void fastd_poll_set_fd_sock(fastd_context_t *ctx, size_t i);
-void fastd_poll_set_fd_peer(fastd_context_t *ctx, size_t i);
+void fastd_poll_set_fd_tuntap(void);
+void fastd_poll_set_fd_sock(size_t i);
+void fastd_poll_set_fd_peer(size_t i);
-void fastd_poll_add_peer(fastd_context_t *ctx);
-void fastd_poll_delete_peer(fastd_context_t *ctx, size_t i);
+void fastd_poll_add_peer(void);
+void fastd_poll_delete_peer(size_t i);
-void fastd_poll_handle(fastd_context_t *ctx);
+void fastd_poll_handle(void);
diff --git a/src/protocols/ec25519_fhmqvc/ec25519_fhmqvc.c b/src/protocols/ec25519_fhmqvc/ec25519_fhmqvc.c
index 698746b..9d32f3b 100644
--- a/src/protocols/ec25519_fhmqvc/ec25519_fhmqvc.c
+++ b/src/protocols/ec25519_fhmqvc/ec25519_fhmqvc.c
@@ -38,25 +38,25 @@ static inline bool read_key(uint8_t key[32], const char *hexkey) {
return true;
}
-static inline void check_session_refresh(fastd_context_t *ctx, fastd_peer_t *peer) {
+static inline void check_session_refresh(fastd_peer_t *peer) {
protocol_session_t *session = &peer->protocol_state->session;
- if (!session->refreshing && session->method->provider->session_want_refresh(ctx, session->method_state)) {
- pr_verbose(ctx, "refreshing session with %P", peer);
+ if (!session->refreshing && session->method->provider->session_want_refresh(session->method_state)) {
+ pr_verbose("refreshing session with %P", peer);
session->handshakes_cleaned = true;
session->refreshing = true;
- fastd_peer_schedule_handshake(ctx, peer, 0);
+ fastd_peer_schedule_handshake(peer, 0);
}
}
-static fastd_protocol_config_t* protocol_init(fastd_context_t *ctx) {
+static fastd_protocol_config_t* protocol_init(void) {
fastd_protocol_config_t *protocol_config = malloc(sizeof(fastd_protocol_config_t));
if (!conf.secret)
- exit_error(ctx, "no secret key configured");
+ exit_error("no secret key configured");
if (!read_key(protocol_config->key.secret.p, conf.secret))
- exit_error(ctx, "invalid secret key");
+ exit_error("invalid secret key");
ecc_25519_work_t work;
ecc_25519_scalarmult_base(&work, &protocol_config->key.secret);
@@ -65,27 +65,27 @@ static fastd_protocol_config_t* protocol_init(fastd_context_t *ctx) {
return protocol_config;
}
-static void protocol_peer_verify(fastd_context_t *ctx, fastd_peer_config_t *peer_conf) {
+static void protocol_peer_verify(fastd_peer_config_t *peer_conf) {
if (!peer_conf->key)
- exit_error(ctx, "no key configured for peer `%s'", peer_conf->name);
+ exit_error("no key configured for peer `%s'", peer_conf->name);
aligned_int256_t key;
if (!read_key(key.u8, peer_conf->key))
- exit_error(ctx, "invalid key configured for peer `%s'", peer_conf->name);
+ exit_error("invalid key configured for peer `%s'", peer_conf->name);
}
-static void protocol_peer_configure(fastd_context_t *ctx, fastd_peer_config_t *peer_conf) {
+static void protocol_peer_configure(fastd_peer_config_t *peer_conf) {
if (peer_conf->protocol_config)
return;
if (!peer_conf->key) {
- pr_warn(ctx, "no key configured for `%s', disabling peer", peer_conf->name);
+ pr_warn("no key configured for `%s', disabling peer", peer_conf->name);
return;
}
aligned_int256_t key;
if (!read_key(key.u8, peer_conf->key)) {
- pr_warn(ctx, "invalid key configured for `%s', disabling peer", peer_conf->name);
+ pr_warn("invalid key configured for `%s', disabling peer", peer_conf->name);
return;
}
@@ -93,62 +93,62 @@ static void protocol_peer_configure(fastd_context_t *ctx, fastd_peer_config_t *p
peer_conf->protocol_config->public_key = key;
if (memcmp(&peer_conf->protocol_config->public_key, &conf.protocol_config->key.public, 32) == 0)
- pr_debug(ctx, "found own key as `%s', ignoring peer", peer_conf->name);
+ pr_debug("found own key as `%s', ignoring peer", peer_conf->name);
}
-static inline bool check_session(fastd_context_t *ctx, fastd_peer_t *peer) {
- if (is_session_valid(ctx, &peer->protocol_state->session))
+static inline bool check_session(fastd_peer_t *peer) {
+ if (is_session_valid(&peer->protocol_state->session))
return true;
- pr_verbose(ctx, "active session with %P timed out", peer);
- fastd_peer_reset(ctx, peer);
+ pr_verbose("active session with %P timed out", peer);
+ fastd_peer_reset(peer);
return false;
}
-static void protocol_handle_recv(fastd_context_t *ctx, fastd_peer_t *peer, fastd_buffer_t buffer) {
- if (!peer->protocol_state || !check_session(ctx, peer))
+static void protocol_handle_recv(fastd_peer_t *peer, fastd_buffer_t buffer) {
+ if (!peer->protocol_state || !check_session(peer))
goto fail;
fastd_buffer_t recv_buffer;
bool ok = false;
- if (is_session_valid(ctx, &peer->protocol_state->old_session)) {
- if (peer->protocol_state->old_session.method->provider->decrypt(ctx, peer, peer->protocol_state->old_session.method_state, &recv_buffer, buffer))
+ if (is_session_valid(&peer->protocol_state->old_session)) {
+ if (peer->protocol_state->old_session.method->provider->decrypt(peer, peer->protocol_state->old_session.method_state, &recv_buffer, buffer))
ok = true;
}
if (!ok) {
- if (peer->protocol_state->session.method->provider->decrypt(ctx, peer, peer->protocol_state->session.method_state, &recv_buffer, buffer)) {
+ if (peer->protocol_state->session.method->provider->decrypt(peer, peer->protocol_state->session.method_state, &recv_buffer, buffer)) {
ok = true;
if (peer->protocol_state->old_session.method) {
- pr_debug(ctx, "invalidating old session with %P", peer);
- peer->protocol_state->old_session.method->provider->session_free(ctx, peer->protocol_state->old_session.method_state);
+ pr_debug("invalidating old session with %P", peer);
+ peer->protocol_state->old_session.method->provider->session_free(peer->protocol_state->old_session.method_state);
peer->protocol_state->old_session = (protocol_session_t){};
}
if (!peer->protocol_state->session.handshakes_cleaned) {
- pr_debug(ctx, "cleaning left handshakes with %P", peer);
- fastd_peer_unschedule_handshake(ctx, peer);
+ pr_debug("cleaning left handshakes with %P", peer);
+ fastd_peer_unschedule_handshake(peer);
peer->protocol_state->session.handshakes_cleaned = true;
- if (peer->protocol_state->session.method->provider->session_is_initiator(ctx, peer->protocol_state->session.method_state))
- fastd_protocol_ec25519_fhmqvc_send_empty(ctx, peer, &peer->protocol_state->session);
+ if (peer->protocol_state->session.method->provider->session_is_initiator(peer->protocol_state->session.method_state))
+ fastd_protocol_ec25519_fhmqvc_send_empty(peer, &peer->protocol_state->session);
}
- check_session_refresh(ctx, peer);
+ check_session_refresh(peer);
}
}
if (!ok) {
- pr_verbose(ctx, "verification failed for packet received from %P", peer);
+ pr_verbose("verification failed for packet received from %P", peer);
goto fail;
}
- fastd_peer_seen(ctx, peer);
+ fastd_peer_seen(peer);
if (recv_buffer.len)
- fastd_handle_receive(ctx, peer, recv_buffer);
+ fastd_handle_receive(peer, recv_buffer);
else
fastd_buffer_free(recv_buffer);
@@ -158,39 +158,39 @@ static void protocol_handle_recv(fastd_context_t *ctx, fastd_peer_t *peer, fastd
fastd_buffer_free(buffer);
}
-static void session_send(fastd_context_t *ctx, fastd_peer_t *peer, fastd_buffer_t buffer, protocol_session_t *session) {
+static void session_send(fastd_peer_t *peer, fastd_buffer_t buffer, protocol_session_t *session) {
size_t stat_size = buffer.len;
fastd_buffer_t send_buffer;
- if (!session->method->provider->encrypt(ctx, peer, session->method_state, &send_buffer, buffer)) {
+ if (!session->method->provider->encrypt(peer, session->method_state, &send_buffer, buffer)) {
fastd_buffer_free(buffer);
- pr_error(ctx, "failed to encrypt packet for %P", peer);
+ pr_error("failed to encrypt packet for %P", peer);
return;
}
- fastd_send(ctx, peer->sock, &peer->local_address, &peer->address, peer, send_buffer, stat_size);
- peer->keepalive_timeout = fastd_in_seconds(ctx, conf.keepalive_timeout);
+ fastd_send(peer->sock, &peer->local_address, &peer->address, peer, send_buffer, stat_size);
+ peer->keepalive_timeout = fastd_in_seconds(conf.keepalive_timeout);
}
-static void protocol_send(fastd_context_t *ctx, fastd_peer_t *peer, fastd_buffer_t buffer) {
- if (!peer->protocol_state || !fastd_peer_is_established(peer) || !check_session(ctx, peer)) {
+static void protocol_send(fastd_peer_t *peer, fastd_buffer_t buffer) {
+ if (!peer->protocol_state || !fastd_peer_is_established(peer) || !check_session(peer)) {
fastd_buffer_free(buffer);
return;
}
- check_session_refresh(ctx, peer);
+ check_session_refresh(peer);
- if (peer->protocol_state->session.method->provider->session_is_initiator(ctx, peer->protocol_state->session.method_state) && is_session_valid(ctx, &peer->protocol_state->old_session)) {
- pr_debug2(ctx, "sending packet for old session to %P", peer);
- session_send(ctx, peer, buffer, &peer->protocol_state->old_session);
+ if (peer->protocol_state->session.method->provider->session_is_initiator(peer->protocol_state->session.method_state) && is_session_valid(&peer->protocol_state->old_session)) {
+ pr_debug2("sending packet for old session to %P", peer);
+ session_send(peer, buffer, &peer->protocol_state->old_session);
}
else {
- session_send(ctx, peer, buffer, &peer->protocol_state->session);
+ session_send(peer, buffer, &peer->protocol_state->session);
}
}
-void fastd_protocol_ec25519_fhmqvc_send_empty(fastd_context_t *ctx, fastd_peer_t *peer, protocol_session_t *session) {
- session_send(ctx, peer, fastd_buffer_alloc(ctx, 0, alignto(session->method->provider->min_encrypt_head_space, 8), session->method->provider->min_encrypt_tail_space), session);
+void fastd_protocol_ec25519_fhmqvc_send_empty(fastd_peer_t *peer, protocol_session_t *session) {
+ session_send(peer, fastd_buffer_alloc(0, alignto(session->method->provider->min_encrypt_head_space, 8), session->method->provider->min_encrypt_tail_space), session);
}
const fastd_protocol_t fastd_protocol_ec25519_fhmqvc = {
diff --git a/src/protocols/ec25519_fhmqvc/ec25519_fhmqvc.h b/src/protocols/ec25519_fhmqvc/ec25519_fhmqvc.h
index be316db..468a7b2 100644
--- a/src/protocols/ec25519_fhmqvc/ec25519_fhmqvc.h
+++ b/src/protocols/ec25519_fhmqvc/ec25519_fhmqvc.h
@@ -76,23 +76,23 @@ struct fastd_protocol_peer_state {
};
-bool fastd_protocol_ec25519_fhmqvc_peer_check(fastd_context_t *ctx, fastd_peer_config_t *peer_conf);
-bool fastd_protocol_ec25519_fhmqvc_peer_check_temporary(fastd_context_t *ctx, fastd_peer_t *peer);
+bool fastd_protocol_ec25519_fhmqvc_peer_check(fastd_peer_config_t *peer_conf);
+bool fastd_protocol_ec25519_fhmqvc_peer_check_temporary(fastd_peer_t *peer);
-void fastd_protocol_ec25519_fhmqvc_maintenance(fastd_context_t *ctx);
-void fastd_protocol_ec25519_fhmqvc_init_peer_state(fastd_context_t *ctx, fastd_peer_t *peer);
-void fastd_protocol_ec25519_fhmqvc_reset_peer_state(fastd_context_t *ctx, fastd_peer_t *peer);
-void fastd_protocol_ec25519_fhmqvc_free_peer_state(fastd_context_t *ctx, fastd_peer_t *peer);
+void fastd_protocol_ec25519_fhmqvc_maintenance(void);
+void fastd_protocol_ec25519_fhmqvc_init_peer_state(fastd_peer_t *peer);
+void fastd_protocol_ec25519_fhmqvc_reset_peer_state(fastd_peer_t *peer);
+void fastd_protocol_ec25519_fhmqvc_free_peer_state(fastd_peer_t *peer);
-void fastd_protocol_ec25519_fhmqvc_handshake_init(fastd_context_t *ctx, const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer);
-void fastd_protocol_ec25519_fhmqvc_handshake_handle(fastd_context_t *ctx, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, const fastd_handshake_t *handshake, const fastd_method_info_t *method);
+void fastd_protocol_ec25519_fhmqvc_handshake_init(const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer);
+void fastd_protocol_ec25519_fhmqvc_handshake_handle(fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, const fastd_handshake_t *handshake, const fastd_method_info_t *method);
-void fastd_protocol_ec25519_fhmqvc_send_empty(fastd_context_t *ctx, fastd_peer_t *peer, protocol_session_t *session);
+void fastd_protocol_ec25519_fhmqvc_send_empty(fastd_peer_t *peer, protocol_session_t *session);
-void fastd_protocol_ec25519_fhmqvc_generate_key(fastd_context_t *ctx);
+void fastd_protocol_ec25519_fhmqvc_generate_key(void);
void fastd_protocol_ec25519_fhmqvc_show_key(void);
void fastd_protocol_ec25519_fhmqvc_set_shell_env(const fastd_peer_t *peer);
-bool fastd_protocol_ec25519_fhmqvc_describe_peer(const fastd_context_t *ctx UNUSED, const fastd_peer_t *peer, char *buf, size_t len);
+bool fastd_protocol_ec25519_fhmqvc_describe_peer(const fastd_peer_t *peer, char *buf, size_t len);
static inline void hexdump(char out[65], const unsigned char d[32]) {
@@ -102,6 +102,6 @@ static inline void hexdump(char out[65], const unsigned char d[32]) {
}
-static inline bool is_session_valid(fastd_context_t *ctx, const protocol_session_t *session) {
- return (session->method && session->method->provider->session_is_valid(ctx, session->method_state));
+static inline bool is_session_valid(const protocol_session_t *session) {
+ return (session->method && session->method->provider->session_is_valid(session->method_state));
}
diff --git a/src/protocols/ec25519_fhmqvc/handshake.c b/src/protocols/ec25519_fhmqvc/handshake.c
index dda798b..df53157 100644
--- a/src/protocols/ec25519_fhmqvc/handshake.c
+++ b/src/protocols/ec25519_fhmqvc/handshake.c
@@ -68,46 +68,46 @@ static void derive_key(fastd_sha256_t *out, size_t blocks, const uint32_t *salt,
fastd_hkdf_sha256_expand(out, blocks, &prk, info, sizeof(info));
}
-static inline void supersede_session(fastd_context_t *ctx, fastd_peer_t *peer, const fastd_method_info_t *method) {
- if (is_session_valid(ctx, &peer->protocol_state->session) && !is_session_valid(ctx, &peer->protocol_state->old_session)) {
+static inline void supersede_session(fastd_peer_t *peer, const fastd_method_info_t *method) {
+ if (is_session_valid(&peer->protocol_state->session) && !is_session_valid(&peer->protocol_state->old_session)) {
if (peer->protocol_state->old_session.method)
- peer->protocol_state->old_session.method->provider->session_free(ctx, peer->protocol_state->old_session.method_state);
+ peer->protocol_state->old_session.method->provider->session_free(peer->protocol_state->old_session.method_state);
peer->protocol_state->old_session = peer->protocol_state->session;
}
else {
if (peer->protocol_state->session.method)
- peer->protocol_state->session.method->provider->session_free(ctx, peer->protocol_state->session.method_state);
+ peer->protocol_state->session.method->provider->session_free(peer->protocol_state->session.method_state);
}
if (peer->protocol_state->old_session.method) {
if (peer->protocol_state->old_session.method != method) {
- pr_debug(ctx, "method of %P has changed, terminating old session", peer);
- peer->protocol_state->old_session.method->provider->session_free(ctx, peer->protocol_state->old_session.method_state);
+ pr_debug("method of %P has changed, terminating old session", peer);
+ peer->protocol_state->old_session.method->provider->session_free(peer->protocol_state->old_session.method_state);
peer->protocol_state->old_session = (protocol_session_t){};
}
else {
- peer->protocol_state->old_session.method->provider->session_superseded(ctx, peer->protocol_state->old_session.method_state);
+ peer->protocol_state->old_session.method->provider->session_superseded(peer->protocol_state->old_session.method_state);
}
}
}
-static inline bool new_session(fastd_context_t *ctx, fastd_peer_t *peer, const fastd_method_info_t *method, bool initiator,
+static inline bool new_session(fastd_peer_t *peer, const fastd_method_info_t *method, bool initiator,
const aligned_int256_t *A, const aligned_int256_t *B, const aligned_int256_t *X, const aligned_int256_t *Y,
const aligned_int256_t *sigma, const uint32_t *salt, uint64_t serial) {
- supersede_session(ctx, peer, method);
+ supersede_session(peer, method);
if (salt) {
- size_t blocks = block_count(method->provider->key_length(ctx, method->method), sizeof(fastd_sha256_t));
+ size_t blocks = block_count(method->provider->key_length(method->method), sizeof(fastd_sha256_t));
fastd_sha256_t secret[blocks];
derive_key(secret, blocks, salt, method->name, A, B, X, Y, sigma);
- peer->protocol_state->session.method_state = method->provider->session_init(ctx, method->method, (const uint8_t*)secret, initiator);
+ peer->protocol_state->session.method_state = method->provider->session_init(method->method, (const uint8_t*)secret, initiator);
}
else {
fastd_sha256_t hash;
fastd_sha256_blocks(&hash, X->u32, Y->u32, A->u32, B->u32, sigma->u32, NULL);
- peer->protocol_state->session.method_state = method->provider->session_init_compat(ctx, method->method, hash.b, HASHBYTES, initiator);
+ peer->protocol_state->session.method_state = method->provider->session_init_compat(method->method, hash.b, HASHBYTES, initiator);
}
if (!peer->protocol_state->session.method_state)
@@ -121,44 +121,44 @@ static inline bool new_session(fastd_context_t *ctx, fastd_peer_t *peer, const f
return true;
}
-static bool establish(fastd_context_t *ctx, fastd_peer_t *peer, const fastd_method_info_t *method, fastd_socket_t *sock,
+static bool establish(fastd_peer_t *peer, const fastd_method_info_t *method, fastd_socket_t *sock,
const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, bool initiator,
const aligned_int256_t *A, const aligned_int256_t *B, const aligned_int256_t *X, const aligned_int256_t *Y,
const aligned_int256_t *sigma, const uint32_t *salt, uint64_t serial) {
if (serial <= peer->protocol_state->last_serial) {
- pr_debug(ctx, "ignoring handshake from %P[%I] because of handshake key reuse", peer, remote_addr);
+ pr_debug("ignoring handshake from %P[%I] because of handshake key reuse", peer, remote_addr);
return false;
}
if (!salt && !method->provider->session_init_compat) {
- pr_warn(ctx, "can't establish compat session with %P[%I] (method without compat support)", peer, remote_addr);
+ pr_warn("can't establish compat session with %P[%I] (method without compat support)", peer, remote_addr);
return false;
}
- pr_verbose(ctx, "%I authorized as %P", remote_addr, peer);
+ pr_verbose("%I authorized as %P", remote_addr, peer);
- if (!fastd_peer_claim_address(ctx, peer, sock, local_addr, remote_addr)) {
- pr_warn(ctx, "can't set address %I which is used by a fixed peer", remote_addr);
- fastd_peer_reset(ctx, peer);
+ if (!fastd_peer_claim_address(peer, sock, local_addr, remote_addr)) {
+ pr_warn("can't set address %I which is used by a fixed peer", remote_addr);
+ fastd_peer_reset(peer);
return false;
}
- if (!new_session(ctx, peer, method, initiator, A, B, X, Y, sigma, salt, serial)) {
- pr_error(ctx, "failed to initialize method session for %P (method `%s'%s)", peer, method->name, salt ? "" : " (compat mode)");
- fastd_peer_reset(ctx, peer);
+ if (!new_session(peer, method, initiator, A, B, X, Y, sigma, salt, serial)) {
+ pr_error("failed to initialize method session for %P (method `%s'%s)", peer, method->name, salt ? "" : " (compat mode)");
+ fastd_peer_reset(peer);
return false;
}
- peer->establish_handshake_timeout = fastd_in_seconds(ctx, conf.min_handshake_interval);
- fastd_peer_seen(ctx, peer);
- fastd_peer_set_established(ctx, peer);
+ peer->establish_handshake_timeout = fastd_in_seconds(conf.min_handshake_interval);
+ fastd_peer_seen(peer);
+ fastd_peer_set_established(peer);
- pr_verbose(ctx, "new session with %P established using method `%s'%s.", peer, method->name, salt ? "" : " (compat mode)");
+ pr_verbose("new session with %P established using method `%s'%s.", peer, method->name, salt ? "" : " (compat mode)");
if (initiator)
- fastd_peer_schedule_handshake_default(ctx, peer);
+ fastd_peer_schedule_handshake_default(peer);
else
- fastd_protocol_ec25519_fhmqvc_send_empty(ctx, peer, &peer->protocol_state->session);
+ fastd_protocol_ec25519_fhmqvc_send_empty(peer, &peer->protocol_state->session);
return true;
}
@@ -260,7 +260,7 @@ static bool update_shared_handshake_key(const fastd_peer_t *peer, const handshak
return true;
}
-static void clear_shared_handshake_key(fastd_context_t *ctx UNUSED, const fastd_peer_t *peer) {
+static void clear_shared_handshake_key(const fastd_peer_t *peer) {
memset(&peer->protocol_state->sigma, 0, sizeof(peer->protocol_state->sigma));
memset(&peer->protocol_state->shared_handshake_key, 0, sizeof(peer->protocol_state->shared_handshake_key));
memset(&peer->protocol_state->shared_handshake_key_compat, 0, sizeof(peer->protocol_state->shared_handshake_key_compat));
@@ -269,37 +269,37 @@ static void clear_shared_handshake_key(fastd_context_t *ctx UNUSED, const fastd_
memset(&peer->protocol_state->peer_handshake_key, 0, sizeof(peer->protocol_state->peer_handshake_key));
}
-static void respond_handshake(fastd_context_t *ctx, const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer,
+static void respond_handshake(const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer,
const handshake_key_t *handshake_key, const aligned_int256_t *peer_handshake_key, const fastd_handshake_t *handshake, const fastd_method_info_t *method) {
- pr_debug(ctx, "responding handshake with %P[%I]...", peer, remote_addr);
+ pr_debug("responding handshake with %P[%I]...", peer, remote_addr);
if (!update_shared_handshake_key(peer, handshake_key, peer_handshake_key))
return;
- fastd_buffer_t buffer = fastd_handshake_new_reply(ctx, handshake, method, true, 4*(4+PUBLICKEYBYTES) + 2*(4+HASHBYTES));
+ fastd_buffer_t buffer = fastd_handshake_new_reply(handshake, method, true, 4*(4+PUBLICKEYBYTES) + 2*(4+HASHBYTES));
- fastd_handshake_add(ctx, &buffer, RECORD_SENDER_KEY, PUBLICKEYBYTES, &conf.protocol_config->key.public);
- fastd_handshake_add(ctx, &buffer, RECORD_RECEIPIENT_KEY, PUBLICKEYBYTES, &peer->protocol_config->public_key);
- fastd_handshake_add(ctx, &buffer, RECORD_SENDER_HANDSHAKE_KEY, PUBLICKEYBYTES, &handshake_key->key.public);
- fastd_handshake_add(ctx, &buffer, RECORD_RECEIPIENT_HANDSHAKE_KEY, PUBLICKEYBYTES, peer_handshake_key);
+ fastd_handshake_add(&buffer, RECORD_SENDER_KEY, PUBLICKEYBYTES, &conf.protocol_config->key.public);
+ fastd_handshake_add(&buffer, RECORD_RECEIPIENT_KEY, PUBLICKEYBYTES, &peer->protocol_config->public_key);
+ fastd_handshake_add(&buffer, RECORD_SENDER_HANDSHAKE_KEY, PUBLICKEYBYTES, &handshake_key->key.public);
+ fastd_handshake_add(&buffer, RECORD_RECEIPIENT_HANDSHAKE_KEY, PUBLICKEYBYTES, peer_handshake_key);
fastd_sha256_t hmacbuf;
if (!conf.secure_handshakes) {
fastd_hmacsha256_blocks(&hmacbuf, peer->protocol_state->shared_handshake_key_compat.w, conf.protocol_config->key.public.u32, handshake_key->key.public.u32, NULL);
- fastd_handshake_add(ctx, &buffer, RECORD_T, HASHBYTES, hmacbuf.b);
+ fastd_handshake_add(&buffer, RECORD_T, HASHBYTES, hmacbuf.b);
}
- uint8_t *mac = fastd_handshake_add_zero(ctx, &buffer, RECORD_TLV_MAC, HASHBYTES);
+ uint8_t *mac = fastd_handshake_add_zero(&buffer, RECORD_TLV_MAC, HASHBYTES);
fastd_hmacsha256(&hmacbuf, peer->protocol_state->shared_handshake_key.w, fastd_handshake_tlv_data(&buffer), fastd_handshake_tlv_len(&buffer));
memcpy(mac, hmacbuf.b, HASHBYTES);
- fastd_send_handshake(ctx, sock, local_addr, remote_addr, peer, buffer);
+ fastd_send_handshake(sock, local_addr, remote_addr, peer, buffer);
}
-static void finish_handshake(fastd_context_t *ctx, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, const handshake_key_t *handshake_key, const aligned_int256_t *peer_handshake_key,
+static void finish_handshake(fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, const handshake_key_t *handshake_key, const aligned_int256_t *peer_handshake_key,
const fastd_handshake_t *handshake, const fastd_method_info_t *method) {
- pr_debug(ctx, "finishing handshake with %P[%I]...", peer, remote_addr);
+ pr_debug("finishing handshake with %P[%I]...", peer, remote_addr);
bool compat = !secure_handshake(handshake);
@@ -328,40 +328,40 @@ static void finish_handshake(fastd_context_t *ctx, fastd_socket_t *sock, const f
}
if (!valid) {
- pr_warn(ctx, "received invalid protocol handshake response from %P[%I]", peer, remote_addr);
+ pr_warn("received invalid protocol handshake response from %P[%I]", peer, remote_addr);
return;
}
- if (!establish(ctx, peer, method, sock, local_addr, remote_addr, true, &handshake_key->key.public, peer_handshake_key, &conf.protocol_config->key.public,
+ if (!establish(peer, method, sock, local_addr, remote_addr, true, &handshake_key->key.public, peer_handshake_key, &conf.protocol_config->key.public,
&peer->protocol_config->public_key, &sigma, compat ? NULL : shared_handshake_key.w, handshake_key->serial))
return;
- fastd_buffer_t buffer = fastd_handshake_new_reply(ctx, handshake, method, false, 4*(4+PUBLICKEYBYTES) + 2*(4+HASHBYTES));
+ fastd_buffer_t buffer = fastd_handshake_new_reply(handshake, method, false, 4*(4+PUBLICKEYBYTES) + 2*(4+HASHBYTES));
- fastd_handshake_add(ctx, &buffer, RECORD_SENDER_KEY, PUBLICKEYBYTES, &conf.protocol_config->key.public);
- fastd_handshake_add(ctx, &buffer, RECORD_RECEIPIENT_KEY, PUBLICKEYBYTES, &peer->protocol_config->public_key);
- fastd_handshake_add(ctx, &buffer, RECORD_SENDER_HANDSHAKE_KEY, PUBLICKEYBYTES, &handshake_key->key.public);
- fastd_handshake_add(ctx, &buffer, RECORD_RECEIPIENT_HANDSHAKE_KEY, PUBLICKEYBYTES, peer_handshake_key);
+ fastd_handshake_add(&buffer, RECORD_SENDER_KEY, PUBLICKEYBYTES, &conf.protocol_config->key.public);
+ fastd_handshake_add(&buffer, RECORD_RECEIPIENT_KEY, PUBLICKEYBYTES, &peer->protocol_config->public_key);
+ fastd_handshake_add(&buffer, RECORD_SENDER_HANDSHAKE_KEY, PUBLICKEYBYTES, &handshake_key->key.public);
+ fastd_handshake_add(&buffer, RECORD_RECEIPIENT_HANDSHAKE_KEY, PUBLICKEYBYTES, peer_handshake_key);
if (!compat) {
fastd_sha256_t hmacbuf;
- uint8_t *mac = fastd_handshake_add_zero(ctx, &buffer, RECORD_TLV_MAC, HASHBYTES);
+ uint8_t *mac = fastd_handshake_add_zero(&buffer, RECORD_TLV_MAC, HASHBYTES);
fastd_hmacsha256(&hmacbuf, shared_handshake_key.w, fastd_handshake_tlv_data(&buffer), fastd_handshake_tlv_len(&buffer));
memcpy(mac, hmacbuf.b, HASHBYTES);
}
else {
fastd_sha256_t hmacbuf;
fastd_hmacsha256_blocks(&hmacbuf, shared_handshake_key_compat.w, conf.protocol_config->key.public.u32, handshake_key->key.public.u32, NULL);
- fastd_handshake_add(ctx, &buffer, RECORD_T, HASHBYTES, hmacbuf.b);
+ fastd_handshake_add(&buffer, RECORD_T, HASHBYTES, hmacbuf.b);
}
- fastd_send_handshake(ctx, sock, local_addr, remote_addr, peer, buffer);
+ fastd_send_handshake(sock, local_addr, remote_addr, peer, buffer);
}
-static void handle_finish_handshake(fastd_context_t *ctx, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr,
+static void handle_finish_handshake(fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr,
fastd_peer_t *peer, const handshake_key_t *handshake_key, const aligned_int256_t *peer_handshake_key,
const fastd_handshake_t *handshake, const fastd_method_info_t *method) {
- pr_debug(ctx, "handling handshake finish with %P[%I]...", peer, remote_addr);
+ pr_debug("handling handshake finish with %P[%I]...", peer, remote_addr);
bool compat = !secure_handshake(handshake);
@@ -381,27 +381,27 @@ static void handle_finish_handshake(fastd_context_t *ctx, fastd_socket_t *sock,
}
if (!valid) {
- pr_warn(ctx, "received invalid protocol handshake finish from %P[%I]", peer, remote_addr);
+ pr_warn("received invalid protocol handshake finish from %P[%I]", peer, remote_addr);
return;
}
- establish(ctx, peer, method, sock, local_addr, remote_addr, false, peer_handshake_key, &handshake_key->key.public, &peer->protocol_config->public_key,
+ establish(peer, method, sock, local_addr, remote_addr, false, peer_handshake_key, &handshake_key->key.public, &peer->protocol_config->public_key,
&conf.protocol_config->key.public, &peer->protocol_state->sigma, compat ? NULL : peer->protocol_state->shared_handshake_key.w, handshake_key->serial);
- clear_shared_handshake_key(ctx, peer);
+ clear_shared_handshake_key(peer);
}
-static fastd_peer_t* find_sender_key(fastd_context_t *ctx, const fastd_peer_address_t *address, const unsigned char key[32]) {
+static fastd_peer_t* find_sender_key(const fastd_peer_address_t *address, const unsigned char key[32]) {
errno = 0;
fastd_peer_t *ret = NULL;
size_t i;
- for (i = 0; i < VECTOR_LEN(ctx->peers); i++) {
- fastd_peer_t *peer = VECTOR_INDEX(ctx->peers, i);
+ for (i = 0; i < VECTOR_LEN(ctx.peers); i++) {
+ fastd_peer_t *peer = VECTOR_INDEX(ctx.peers, i);
if (memcmp(&peer->protocol_config->public_key, key, PUBLICKEYBYTES) == 0) {
- if (!fastd_peer_matches_address(ctx, peer, address)) {
+ if (!fastd_peer_matches_address(peer, address)) {
errno = EPERM;
return NULL;
}
@@ -410,7 +410,7 @@ static fastd_peer_t* find_sender_key(fastd_context_t *ctx, const fastd_peer_addr
continue;
}
- if (fastd_peer_owns_address(ctx, peer, address)) {
+ if (fastd_peer_owns_address(peer, address)) {
errno = EPERM;
return NULL;
}
@@ -422,23 +422,23 @@ static fastd_peer_t* find_sender_key(fastd_context_t *ctx, const fastd_peer_addr
return ret;
}
-static fastd_peer_t* match_sender_key(fastd_context_t *ctx, const fastd_socket_t *sock, const fastd_peer_address_t *address, fastd_peer_t *peer, const unsigned char key[32]) {
+static fastd_peer_t* match_sender_key(const fastd_socket_t *sock, const fastd_peer_address_t *address, fastd_peer_t *peer, const unsigned char key[32]) {
errno = 0;
if (sock->peer && peer != sock->peer)
- exit_bug(ctx, "packet without correct peer set on dynamic socket");
+ exit_bug("packet without correct peer set on dynamic socket");
if (peer) {
if (memcmp(&peer->protocol_config->public_key, key, PUBLICKEYBYTES) == 0)
return peer;
- if (fastd_peer_owns_address(ctx, peer, address)) {
+ if (fastd_peer_owns_address(peer, address)) {
errno = EPERM;
return NULL;
}
}
- return find_sender_key(ctx, address, key);
+ return find_sender_key(address, key);
}
static size_t key_count(const unsigned char key[32]) {
@@ -456,7 +456,7 @@ static size_t key_count(const unsigned char key[32]) {
return ret;
}
-bool fastd_protocol_ec25519_fhmqvc_peer_check(fastd_context_t *ctx, fastd_peer_config_t *peer_conf) {
+bool fastd_protocol_ec25519_fhmqvc_peer_check(fastd_peer_config_t *peer_conf) {
if (!peer_conf->protocol_config)
return false;
@@ -466,18 +466,18 @@ bool fastd_protocol_ec25519_fhmqvc_peer_check(fastd_context_t *ctx, fastd_peer_c
if (key_count(peer_conf->protocol_config->public_key.u8) > 1) {
char buf[65];
hexdump(buf, peer_conf->protocol_config->public_key.u8);
- pr_warn(ctx, "more than one peer is configured with key %s, disabling %s", buf, peer_conf->name);
+ pr_warn("more than one peer is configured with key %s, disabling %s", buf, peer_conf->name);
return false;
}
return true;
}
-bool fastd_protocol_ec25519_fhmqvc_peer_check_temporary(fastd_context_t *ctx, fastd_peer_t *peer) {
+bool fastd_protocol_ec25519_fhmqvc_peer_check_temporary(fastd_peer_t *peer) {
if (key_count(peer->protocol_config->public_key.u8)) {
char buf[65];
hexdump(buf, peer->protocol_config->public_key.u8);
- pr_info(ctx, "key %s is configured now, deleting temporary peer.", buf);
+ pr_info("key %s is configured now, deleting temporary peer.", buf);
return false;
}
@@ -488,18 +488,18 @@ static inline bool allow_unknown(void) {
return fastd_shell_command_isset(&conf.on_verify);
}
-static inline fastd_peer_t* add_temporary(fastd_context_t *ctx, const fastd_peer_address_t *addr, const unsigned char key[32]) {
+static inline fastd_peer_t* add_temporary(const fastd_peer_address_t *addr, const unsigned char key[32]) {
if (!allow_unknown()) {
- pr_debug(ctx, "ignoring handshake from %I (unknown key)", addr);
+ pr_debug("ignoring handshake from %I (unknown key)", addr);
return NULL;
}
if (key_count(key)) {
- pr_debug(ctx, "ignoring handshake from %I (disabled key)", addr);
+ pr_debug("ignoring handshake from %I (disabled key)", addr);
return NULL;
}
- fastd_peer_t *peer = fastd_peer_add_temporary(ctx);
+ fastd_peer_t *peer = fastd_peer_add_temporary();
peer->protocol_config = malloc(sizeof(fastd_protocol_peer_config_t));
memcpy(&peer->protocol_config->public_key, key, PUBLICKEYBYTES);
@@ -511,79 +511,79 @@ static inline fastd_peer_t* add_temporary(fastd_context_t *ctx, const fastd_peer
}
-void fastd_protocol_ec25519_fhmqvc_handshake_init(fastd_context_t *ctx, const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer) {
- fastd_protocol_ec25519_fhmqvc_maintenance(ctx);
+void fastd_protocol_ec25519_fhmqvc_handshake_init(const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer) {
+ fastd_protocol_ec25519_fhmqvc_maintenance();
- fastd_buffer_t buffer = fastd_handshake_new_init(ctx, 3*(4+PUBLICKEYBYTES) /* sender key, receipient key, handshake key */);
+ fastd_buffer_t buffer = fastd_handshake_new_init(3*(4+PUBLICKEYBYTES) /* sender key, receipient key, handshake key */);
- fastd_handshake_add(ctx, &buffer, RECORD_SENDER_KEY, PUBLICKEYBYTES, &conf.protocol_config->key.public);
+ fastd_handshake_add(&buffer, RECORD_SENDER_KEY, PUBLICKEYBYTES, &conf.protocol_config->key.public);
if (peer)
- fastd_handshake_add(ctx, &buffer, RECORD_RECEIPIENT_KEY, PUBLICKEYBYTES, &peer->protocol_config->public_key);
+ fastd_handshake_add(&buffer, RECORD_RECEIPIENT_KEY, PUBLICKEYBYTES, &peer->protocol_config->public_key);
else
- pr_debug(ctx, "sending handshake to unknown peer %I", remote_addr);
+ pr_debug("sending handshake to unknown peer %I", remote_addr);
- fastd_handshake_add(ctx, &buffer, RECORD_SENDER_HANDSHAKE_KEY, PUBLICKEYBYTES, &ctx->protocol_state->handshake_key.key.public);
+ fastd_handshake_add(&buffer, RECORD_SENDER_HANDSHAKE_KEY, PUBLICKEYBYTES, &ctx.protocol_state->handshake_key.key.public);
if (!peer || !fastd_peer_is_established(peer))
- fastd_shell_command_exec(ctx, &conf.on_connect, peer, (local_addr && local_addr->sa.sa_family) ? local_addr : sock->bound_addr, remote_addr);
+ fastd_shell_command_exec(&conf.on_connect, peer, (local_addr && local_addr->sa.sa_family) ? local_addr : sock->bound_addr, remote_addr);
- fastd_send_handshake(ctx, sock, local_addr, remote_addr, peer, buffer);
+ fastd_send_handshake(sock, local_addr, remote_addr, peer, buffer);
}
-void fastd_protocol_ec25519_fhmqvc_handshake_handle(fastd_context_t *ctx, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr,
+void fastd_protocol_ec25519_fhmqvc_handshake_handle(fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr,
fastd_peer_t *peer, const fastd_handshake_t *handshake, const fastd_method_info_t *method) {
- fastd_protocol_ec25519_fhmqvc_maintenance(ctx);
+ fastd_protocol_ec25519_fhmqvc_maintenance();
if (!has_field(handshake, RECORD_SENDER_KEY, PUBLICKEYBYTES)) {
- pr_debug(ctx, "received handshake without sender key from %I", remote_addr);
+ pr_debug("received handshake without sender key from %I", remote_addr);
return;
}
- peer = match_sender_key(ctx, sock, remote_addr, peer, handshake->records[RECORD_SENDER_KEY].data);
+ peer = match_sender_key(sock, remote_addr, peer, handshake->records[RECORD_SENDER_KEY].data);
if (!peer) {
switch (errno) {
case EPERM:
- pr_debug(ctx, "ignoring handshake from %I (incorrect source address)", remote_addr);
+ pr_debug("ignoring handshake from %I (incorrect source address)", remote_addr);
return;
case ENOENT:
- peer = add_temporary(ctx, remote_addr, handshake->records[RECORD_SENDER_KEY].data);
+ peer = add_temporary(remote_addr, handshake->records[RECORD_SENDER_KEY].data);
if (peer)
break;
return;
default:
- exit_bug(ctx, "match_sender_key: unknown error");
+ exit_bug("match_sender_key: unknown error");
}
}
- if (fastd_peer_is_temporary(peer) && !fastd_peer_verify_temporary(ctx, peer, local_addr, remote_addr)) {
- pr_debug(ctx, "ignoring handshake from %P[%I] (verification failed)", peer, remote_addr);
- fastd_peer_delete(ctx, peer);
+ if (fastd_peer_is_temporary(peer) && !fastd_peer_verify_temporary(peer, local_addr, remote_addr)) {
+ pr_debug("ignoring handshake from %P[%I] (verification failed)", peer, remote_addr);
+ fastd_peer_delete(peer);
return;
}
- if (!fastd_peer_may_connect(ctx, peer)) {
- pr_debug(ctx, "ignoring handshake from %P[%I] because of local constraints", peer, remote_addr);
+ if (!fastd_peer_may_connect(peer)) {
+ pr_debug("ignoring handshake from %P[%I] because of local constraints", peer, remote_addr);
return;
}
- if (!fastd_timed_out(ctx, &peer->establish_handshake_timeout)) {
- pr_debug(ctx, "received repeated handshakes from %P[%I], ignoring", peer, remote_addr);
+ if (!fastd_timed_out(&peer->establish_handshake_timeout)) {
+ pr_debug("received repeated handshakes from %P[%I], ignoring", peer, remote_addr);
return;
}
if (has_field(handshake, RECORD_RECEIPIENT_KEY, PUBLICKEYBYTES)) {
if (memcmp(&conf.protocol_config->key.public, handshake->records[RECORD_RECEIPIENT_KEY].data, PUBLICKEYBYTES) != 0) {
- pr_debug(ctx, "received protocol handshake with wrong receipient key from %P[%I]", peer, remote_addr);
+ pr_debug("received protocol handshake with wrong receipient key from %P[%I]", peer, remote_addr);
return;
}
}
if (!has_field(handshake, RECORD_SENDER_HANDSHAKE_KEY, PUBLICKEYBYTES)) {
- pr_debug(ctx, "received handshake without sender handshake key from %P[%I]", peer, remote_addr);
+ pr_debug("received handshake without sender handshake key from %P[%I]", peer, remote_addr);
return;
}
@@ -591,65 +591,65 @@ void fastd_protocol_ec25519_fhmqvc_handshake_handle(fastd_context_t *ctx, fastd_
memcpy(&peer_handshake_key, handshake->records[RECORD_SENDER_HANDSHAKE_KEY].data, PUBLICKEYBYTES);
if (handshake->type == 1) {
- if (!fastd_timed_out(ctx, &peer->last_handshake_response_timeout)
+ if (!fastd_timed_out(&peer->last_handshake_response_timeout)
&& fastd_peer_address_equal(remote_addr, &peer->last_handshake_response_address)) {
- pr_debug(ctx, "not responding to repeated handshake from %P[%I]", peer, remote_addr);
+ pr_debug("not responding to repeated handshake from %P[%I]", peer, remote_addr);
return;
}
- pr_verbose(ctx, "received handshake from %P[%I]%s%s", peer, remote_addr, handshake->peer_version ? " using fastd " : "", handshake->peer_version ?: "");
+ pr_verbose("received handshake from %P[%I]%s%s", peer, remote_addr, handshake->peer_version ? " using fastd " : "", handshake->peer_version ?: "");
- peer->last_handshake_response_timeout = fastd_in_seconds(ctx, conf.min_handshake_interval);
+ peer->last_handshake_response_timeout = fastd_in_seconds(conf.min_handshake_interval);
peer->last_handshake_response_address = *remote_addr;
- respond_handshake(ctx, sock, local_addr, remote_addr, peer, &ctx->protocol_state->handshake_key, &peer_handshake_key, handshake, method);
+ respond_handshake(sock, local_addr, remote_addr, peer, &ctx.protocol_state->handshake_key, &peer_handshake_key, handshake, method);
return;
}
if (!has_field(handshake, RECORD_RECEIPIENT_KEY, PUBLICKEYBYTES)) {
- pr_debug(ctx, "received handshake reply without receipient key from %P[%I]", peer, remote_addr);
+ pr_debug("received handshake reply without receipient key from %P[%I]", peer, remote_addr);
return;
}
if (!has_field(handshake, RECORD_RECEIPIENT_HANDSHAKE_KEY, PUBLICKEYBYTES)) {
- pr_debug(ctx, "received handshake reply without receipient handshake key from %P[%I]", peer, remote_addr);
+ pr_debug("received handshake reply without receipient handshake key from %P[%I]", peer, remote_addr);
return;
}
if (!secure_handshake(handshake)) {
if (conf.secure_handshakes || !has_field(handshake, RECORD_T, HASHBYTES)) {
- pr_debug(ctx, "received handshake reply without HMAC from %P[%I]", peer, remote_addr);
+ pr_debug("received handshake reply without HMAC from %P[%I]", peer, remote_addr);
return;
}
}
handshake_key_t *handshake_key;
- if (is_handshake_key_valid(ctx, &ctx->protocol_state->handshake_key) &&
- memcmp(&ctx->protocol_state->handshake_key.key.public, handshake->records[RECORD_RECEIPIENT_HANDSHAKE_KEY].data, PUBLICKEYBYTES) == 0) {
- handshake_key = &ctx->protocol_state->handshake_key;
+ if (is_handshake_key_valid(&ctx.protocol_state->handshake_key) &&
+ memcmp(&ctx.protocol_state->handshake_key.key.public, handshake->records[RECORD_RECEIPIENT_HANDSHAKE_KEY].data, PUBLICKEYBYTES) == 0) {
+ handshake_key = &ctx.protocol_state->handshake_key;
}
- else if (is_handshake_key_valid(ctx, &ctx->protocol_state->prev_handshake_key) &&
- memcmp(&ctx->protocol_state->prev_handshake_key.key.public, handshake->records[RECORD_RECEIPIENT_HANDSHAKE_KEY].data, PUBLICKEYBYTES) == 0) {
- handshake_key = &ctx->protocol_state->prev_handshake_key;
+ else if (is_handshake_key_valid(&ctx.protocol_state->prev_handshake_key) &&
+ memcmp(&ctx.protocol_state->prev_handshake_key.key.public, handshake->records[RECORD_RECEIPIENT_HANDSHAKE_KEY].data, PUBLICKEYBYTES) == 0) {
+ handshake_key = &ctx.protocol_state->prev_handshake_key;
}
else {
- pr_debug(ctx, "received handshake reply with unexpected receipient handshake key from %P[%I]", peer, remote_addr);
+ pr_debug("received handshake reply with unexpected receipient handshake key from %P[%I]", peer, remote_addr);
return;
}
switch (handshake->type) {
case 2:
- pr_verbose(ctx, "received handshake response from %P[%I]%s%s", peer, remote_addr, handshake->peer_version ? " using fastd " : "", handshake->peer_version ?: "");
+ pr_verbose("received handshake response from %P[%I]%s%s", peer, remote_addr, handshake->peer_version ? " using fastd " : "", handshake->peer_version ?: "");
- finish_handshake(ctx, sock, local_addr, remote_addr, peer, handshake_key, &peer_handshake_key, handshake, method);
+ finish_handshake(sock, local_addr, remote_addr, peer, handshake_key, &peer_handshake_key, handshake, method);
break;
case 3:
- pr_debug(ctx, "received handshake finish from %P[%I]%s%s", peer, remote_addr, handshake->peer_version ? " using fastd " : "", handshake->peer_version ?: "");
+ pr_debug("received handshake finish from %P[%I]%s%s", peer, remote_addr, handshake->peer_version ? " using fastd " : "", handshake->peer_version ?: "");
- handle_finish_handshake(ctx, sock, local_addr, remote_addr, peer, handshake_key, &peer_handshake_key, handshake, method);
+ handle_finish_handshake(sock, local_addr, remote_addr, peer, handshake_key, &peer_handshake_key, handshake, method);
break;
default:
- pr_debug(ctx, "received handshake reply with unknown type %u from %P[%I]", handshake->type, peer, remote_addr);
+ pr_debug("received handshake reply with unknown type %u from %P[%I]", handshake->type, peer, remote_addr);
}
}
diff --git a/src/protocols/ec25519_fhmqvc/handshake.h b/src/protocols/ec25519_fhmqvc/handshake.h
index 867b0fa..1578913 100644
--- a/src/protocols/ec25519_fhmqvc/handshake.h
+++ b/src/protocols/ec25519_fhmqvc/handshake.h
@@ -43,10 +43,10 @@ struct fastd_protocol_state {
};
-static inline bool is_handshake_key_valid(fastd_context_t *ctx, const handshake_key_t *handshake_key) {
- return !fastd_timed_out(ctx, &handshake_key->valid_till);
+static inline bool is_handshake_key_valid(const handshake_key_t *handshake_key) {
+ return !fastd_timed_out(&handshake_key->valid_till);
}
-static inline bool is_handshake_key_preferred(fastd_context_t *ctx, const handshake_key_t *handshake_key) {
- return !fastd_timed_out(ctx, &handshake_key->preferred_till);
+static inline bool is_handshake_key_preferred(const handshake_key_t *handshake_key) {
+ return !fastd_timed_out(&handshake_key->preferred_till);
}
diff --git a/src/protocols/ec25519_fhmqvc/state.c b/src/protocols/ec25519_fhmqvc/state.c
index fe0dcde..7f3b847 100644
--- a/src/protocols/ec25519_fhmqvc/state.c
+++ b/src/protocols/ec25519_fhmqvc/state.c
@@ -28,17 +28,17 @@
#include "../../crypto.h"
-static void init_protocol_state(fastd_context_t *ctx) {
- if (!ctx->protocol_state) {
- ctx->protocol_state = calloc(1, sizeof(fastd_protocol_state_t));
+static void init_protocol_state(void) {
+ if (!ctx.protocol_state) {
+ ctx.protocol_state = calloc(1, sizeof(fastd_protocol_state_t));
- ctx->protocol_state->prev_handshake_key.preferred_till = ctx->now;
- ctx->protocol_state->handshake_key.preferred_till = ctx->now;
+ ctx.protocol_state->prev_handshake_key.preferred_till = ctx.now;
+ ctx.protocol_state->handshake_key.preferred_till = ctx.now;
}
}
-static void new_handshake_key(fastd_context_t *ctx, keypair_t *key) {
- fastd_random_bytes(ctx, key->secret.p, 32, false);
+static void new_handshake_key(keypair_t *key) {
+ fastd_random_bytes(key->secret.p, 32, false);
ecc_25519_gf_sanitize_secret(&key->secret, &key->secret);
ecc_25519_work_t work;
@@ -46,51 +46,51 @@ static void new_handshake_key(fastd_context_t *ctx, keypair_t *key) {
ecc_25519_store_packed(&key->public.int256, &work);
}
-void fastd_protocol_ec25519_fhmqvc_maintenance(fastd_context_t *ctx) {
- init_protocol_state(ctx);
+void fastd_protocol_ec25519_fhmqvc_maintenance(void) {
+ init_protocol_state();
- if (!is_handshake_key_preferred(ctx, &ctx->protocol_state->handshake_key)) {
- pr_debug(ctx, "generating new handshake key");
+ if (!is_handshake_key_preferred(&ctx.protocol_state->handshake_key)) {
+ pr_debug("generating new handshake key");
- ctx->protocol_state->prev_handshake_key = ctx->protocol_state->handshake_key;
+ ctx.protocol_state->prev_handshake_key = ctx.protocol_state->handshake_key;
- ctx->protocol_state->handshake_key.serial++;
+ ctx.protocol_state->handshake_key.serial++;
- new_handshake_key(ctx, &ctx->protocol_state->handshake_key.key);
+ new_handshake_key(&ctx.protocol_state->handshake_key.key);
- ctx->protocol_state->handshake_key.preferred_till = fastd_in_seconds(ctx, 15);
- ctx->protocol_state->handshake_key.valid_till = fastd_in_seconds(ctx, 30);
+ ctx.protocol_state->handshake_key.preferred_till = fastd_in_seconds(15);
+ ctx.protocol_state->handshake_key.valid_till = fastd_in_seconds(30);
}
}
-void fastd_protocol_ec25519_fhmqvc_init_peer_state(fastd_context_t *ctx, fastd_peer_t *peer) {
- init_protocol_state(ctx);
+void fastd_protocol_ec25519_fhmqvc_init_peer_state(fastd_peer_t *peer) {
+ init_protocol_state();
if (peer->protocol_state)
- exit_bug(ctx, "tried to reinit peer state");
+ exit_bug("tried to reinit peer state");
peer->protocol_state = calloc(1, sizeof(fastd_protocol_peer_state_t));
- peer->protocol_state->last_serial = ctx->protocol_state->handshake_key.serial;
+ peer->protocol_state->last_serial = ctx.protocol_state->handshake_key.serial;
}
-static void reset_session(fastd_context_t *ctx, protocol_session_t *session) {
+static void reset_session(protocol_session_t *session) {
if (session->method)
- session->method->provider->session_free(ctx, session->method_state);
+ session->method->provider->session_free(session->method_state);
secure_memzero(session, sizeof(protocol_session_t));
}
-void fastd_protocol_ec25519_fhmqvc_reset_peer_state(fastd_context_t *ctx, fastd_peer_t *peer) {
+void fastd_protocol_ec25519_fhmqvc_reset_peer_state(fastd_peer_t *peer) {
if (!peer->protocol_state)
return;
- reset_session(ctx, &peer->protocol_state->old_session);
- reset_session(ctx, &peer->protocol_state->session);
+ reset_session(&peer->protocol_state->old_session);
+ reset_session(&peer->protocol_state->session);
}
-void fastd_protocol_ec25519_fhmqvc_free_peer_state(fastd_context_t *ctx, fastd_peer_t *peer) {
+void fastd_protocol_ec25519_fhmqvc_free_peer_state(fastd_peer_t *peer) {
if (peer->protocol_state) {
- reset_session(ctx, &peer->protocol_state->old_session);
- reset_session(ctx, &peer->protocol_state->session);
+ reset_session(&peer->protocol_state->old_session);
+ reset_session(&peer->protocol_state->session);
free(peer->protocol_state);
}
diff --git a/src/protocols/ec25519_fhmqvc/util.c b/src/protocols/ec25519_fhmqvc/util.c
index a72ebbf..5bd23b3 100644
--- a/src/protocols/ec25519_fhmqvc/util.c
+++ b/src/protocols/ec25519_fhmqvc/util.c
@@ -34,14 +34,14 @@ static inline void print_hexdump(const char *desc, unsigned char d[32]) {
printf("%s%s\n", desc, buf);
}
-void fastd_protocol_ec25519_fhmqvc_generate_key(fastd_context_t *ctx) {
+void fastd_protocol_ec25519_fhmqvc_generate_key(void) {
ecc_int256_t secret_key;
ecc_int256_t public_key;
if (!conf.machine_readable)
- pr_info(ctx, "Reading 32 bytes from /dev/random...");
+ pr_info("Reading 32 bytes from /dev/random...");
- fastd_random_bytes(ctx, secret_key.p, 32, true);
+ fastd_random_bytes(secret_key.p, 32, true);
ecc_25519_gf_sanitize_secret(&secret_key, &secret_key);
ecc_25519_work_t work;
@@ -79,7 +79,7 @@ void fastd_protocol_ec25519_fhmqvc_set_shell_env(const fastd_peer_t *peer) {
}
}
-bool fastd_protocol_ec25519_fhmqvc_describe_peer(const fastd_context_t *ctx UNUSED, const fastd_peer_t *peer, char *buf, size_t len) {
+bool fastd_protocol_ec25519_fhmqvc_describe_peer(const fastd_peer_t *peer, char *buf, size_t len) {
if (peer && peer->protocol_config) {
char dumpbuf[65];
diff --git a/src/random.c b/src/random.c
index 9c7359f..ce7183b 100644
--- a/src/random.c
+++ b/src/random.c
@@ -30,7 +30,7 @@
#include <sys/stat.h>
-void fastd_random_bytes(fastd_context_t *ctx, void *buffer, size_t len, bool secure) {
+void fastd_random_bytes(void *buffer, size_t len, bool secure) {
int fd;
size_t read_bytes = 0;
@@ -40,7 +40,7 @@ void fastd_random_bytes(fastd_context_t *ctx, void *buffer, size_t len, bool sec
fd = open("/dev/urandom", O_RDONLY);
if (fd < 0)
- exit_errno(ctx, "unable to open random device");
+ exit_errno("unable to open random device");
while (read_bytes < len) {
ssize_t ret = read(fd, ((char*)buffer)+read_bytes, len-read_bytes);
@@ -49,7 +49,7 @@ void fastd_random_bytes(fastd_context_t *ctx, void *buffer, size_t len, bool sec
if (errno == EINTR)
continue;
- exit_errno(ctx, "unable to read from random device");
+ exit_errno("unable to read from random device");
}
read_bytes += ret;
diff --git a/src/receive.c b/src/receive.c
index 49f05fe..a8ec1ce 100644
--- a/src/receive.c
+++ b/src/receive.c
@@ -77,57 +77,57 @@ static inline void handle_socket_control(struct msghdr *message, const fastd_soc
}
}
-static bool backoff_unknown(fastd_context_t *ctx, const fastd_peer_address_t *addr) {
+static bool backoff_unknown(const fastd_peer_address_t *addr) {
size_t i;
- for (i = 0; i < array_size(ctx->unknown_handshakes); i++) {
- const fastd_handshake_timeout_t *t = &ctx->unknown_handshakes[(ctx->unknown_handshake_pos + i) % array_size(ctx->unknown_handshakes)];
+ for (i = 0; i < array_size(ctx.unknown_handshakes); i++) {
+ const fastd_handshake_timeout_t *t = &ctx.unknown_handshakes[(ctx.unknown_handshake_pos + i) % array_size(ctx.unknown_handshakes)];
- if (fastd_timed_out(ctx, &t->timeout))
+ if (fastd_timed_out(&t->timeout))
break;
if (fastd_peer_address_equal(addr, &t->address)) {
- pr_debug2(ctx, "sent a handshake to unknown address %I a short time ago, not sending again", addr);
+ pr_debug2("sent a handshake to unknown address %I a short time ago, not sending again", addr);
return true;
}
}
- if (ctx->unknown_handshake_pos == 0)
- ctx->unknown_handshake_pos = array_size(ctx->unknown_handshakes)-1;
+ if (ctx.unknown_handshake_pos == 0)
+ ctx.unknown_handshake_pos = array_size(ctx.unknown_handshakes)-1;
else
- ctx->unknown_handshake_pos--;
+ ctx.unknown_handshake_pos--;
- fastd_handshake_timeout_t *t = &ctx->unknown_handshakes[ctx->unknown_handshake_pos];
+ fastd_handshake_timeout_t *t = &ctx.unknown_handshakes[ctx.unknown_handshake_pos];
t->address = *addr;
- t->timeout = fastd_in_seconds(ctx, conf.min_handshake_interval);
+ t->timeout = fastd_in_seconds(conf.min_handshake_interval);
return false;
}
-static inline void handle_socket_receive_known(fastd_context_t *ctx, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, fastd_buffer_t buffer) {
- if (!fastd_peer_may_connect(ctx, peer)) {
+static inline void handle_socket_receive_known(fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, fastd_buffer_t buffer) {
+ if (!fastd_peer_may_connect(peer)) {
fastd_buffer_free(buffer);
return;
}
const uint8_t *packet_type = buffer.data;
- fastd_buffer_push_head(ctx, &buffer, 1);
+ fastd_buffer_push_head(&buffer, 1);
switch (*packet_type) {
case PACKET_DATA:
if (!fastd_peer_is_established(peer) || !fastd_peer_address_equal(&peer->local_address, local_addr)) {
fastd_buffer_free(buffer);
- if (!backoff_unknown(ctx, remote_addr))
- conf.protocol->handshake_init(ctx, sock, local_addr, remote_addr, NULL);
+ if (!backoff_unknown(remote_addr))
+ conf.protocol->handshake_init(sock, local_addr, remote_addr, NULL);
return;
}
- conf.protocol->handle_recv(ctx, peer, buffer);
+ conf.protocol->handle_recv(peer, buffer);
break;
case PACKET_HANDSHAKE:
- fastd_handshake_handle(ctx, sock, local_addr, remote_addr, peer, buffer);
+ fastd_handshake_handle(sock, local_addr, remote_addr, peer, buffer);
}
}
@@ -135,24 +135,24 @@ static inline bool allow_unknown_peers(void) {
return conf.has_floating || fastd_shell_command_isset(&conf.on_verify);
}
-static inline void handle_socket_receive_unknown(fastd_context_t *ctx, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_buffer_t buffer) {
+static inline void handle_socket_receive_unknown(fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_buffer_t buffer) {
const uint8_t *packet_type = buffer.data;
- fastd_buffer_push_head(ctx, &buffer, 1);
+ fastd_buffer_push_head(&buffer, 1);
switch (*packet_type) {
case PACKET_DATA:
fastd_buffer_free(buffer);
- if (!backoff_unknown(ctx, remote_addr))
- conf.protocol->handshake_init(ctx, sock, local_addr, remote_addr, NULL);
+ if (!backoff_unknown(remote_addr))
+ conf.protocol->handshake_init(sock, local_addr, remote_addr, NULL);
break;
case PACKET_HANDSHAKE:
- fastd_handshake_handle(ctx, sock, local_addr, remote_addr, NULL, buffer);
+ fastd_handshake_handle(sock, local_addr, remote_addr, NULL, buffer);
}
}
-static inline void handle_socket_receive(fastd_context_t *ctx, fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_buffer_t buffer) {
+static inline void handle_socket_receive(fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_buffer_t buffer) {
fastd_peer_t *peer = NULL;
if (sock->peer) {
@@ -164,24 +164,24 @@ static inline void handle_socket_receive(fastd_context_t *ctx, fastd_socket_t *s
peer = sock->peer;
}
else {
- peer = fastd_peer_hashtable_lookup(ctx, remote_addr);
+ peer = fastd_peer_hashtable_lookup(remote_addr);
}
if (peer) {
- handle_socket_receive_known(ctx, sock, local_addr, remote_addr, peer, buffer);
+ handle_socket_receive_known(sock, local_addr, remote_addr, peer, buffer);
}
else if (allow_unknown_peers()) {
- handle_socket_receive_unknown(ctx, sock, local_addr, remote_addr, buffer);
+ handle_socket_receive_unknown(sock, local_addr, remote_addr, buffer);
}
else {
- pr_debug(ctx, "received packet from unknown peer %I", remote_addr);
+ pr_debug("received packet from unknown peer %I", remote_addr);
fastd_buffer_free(buffer);
}
}
-void fastd_receive(fastd_context_t *ctx, fastd_socket_t *sock) {
- size_t max_len = fastd_max_outer_packet(ctx);
- fastd_buffer_t buffer = fastd_buffer_alloc(ctx, max_len, conf.min_decrypt_head_space, conf.min_decrypt_tail_space);
+void fastd_receive(fastd_socket_t *sock) {
+ size_t max_len = fastd_max_outer_packet();
+ fastd_buffer_t buffer = fastd_buffer_alloc(max_len, conf.min_decrypt_head_space, conf.min_decrypt_tail_space);
fastd_peer_address_t local_addr;
fastd_peer_address_t recvaddr;
struct iovec buffer_vec = { .iov_base = buffer.data, .iov_len = buffer.len };
@@ -199,7 +199,7 @@ void fastd_receive(fastd_context_t *ctx, fastd_socket_t *sock) {
ssize_t len = recvmsg(sock->fd, &message, 0);
if (len <= 0) {
if (len < 0 && errno != EINTR)
- pr_warn_errno(ctx, "recvmsg");
+ pr_warn_errno("recvmsg");
fastd_buffer_free(buffer);
return;
@@ -211,7 +211,7 @@ void fastd_receive(fastd_context_t *ctx, fastd_socket_t *sock) {
#ifdef USE_PKTINFO
if (!local_addr.sa.sa_family) {
- pr_error(ctx, "received packet without packet info");
+ pr_error("received packet without packet info");
fastd_buffer_free(buffer);
return;
}
@@ -219,5 +219,5 @@ void fastd_receive(fastd_context_t *ctx, fastd_socket_t *sock) {
fastd_peer_address_simplify(&recvaddr);
- handle_socket_receive(ctx, sock, &local_addr, &recvaddr, buffer);
+ handle_socket_receive(sock, &local_addr, &recvaddr, buffer);
}
diff --git a/src/resolve.c b/src/resolve.c
index c67fd53..e791687 100644
--- a/src/resolve.c
+++ b/src/resolve.c
@@ -33,7 +33,6 @@
typedef struct resolv_arg {
- fastd_context_t *ctx;
fastd_remote_t *remote;
char *hostname;
fastd_peer_address_t constraints;
@@ -63,7 +62,7 @@ static void* resolve_peer(void *varg) {
gai_ret = getaddrinfo(arg->hostname, portstr, &hints, &res);
if (gai_ret || !res) {
- pr_verbose(arg->ctx, "resolving host `%s' failed: %s", arg->hostname, gai_strerror(gai_ret));
+ pr_verbose("resolving host `%s' failed: %s", arg->hostname, gai_strerror(gai_ret));
}
else {
for (res2 = res; res2; res2 = res2->ai_next)
@@ -78,7 +77,7 @@ static void* resolve_peer(void *varg) {
n_addr = 0;
for (res2 = res; res2; res2 = res2->ai_next) {
if (res2->ai_addrlen > sizeof(fastd_peer_address_t) || (res2->ai_addr->sa_family != AF_INET && res2->ai_addr->sa_family != AF_INET6)) {
- pr_warn(arg->ctx, "resolving host `%s': unsupported address returned", arg->hostname);
+ pr_warn("resolving host `%s': unsupported address returned", arg->hostname);
continue;
}
@@ -90,12 +89,12 @@ static void* resolve_peer(void *varg) {
}
if (n_addr)
- pr_verbose(arg->ctx, "resolved host `%s' successfully", arg->hostname);
+ pr_verbose("resolved host `%s' successfully", arg->hostname);
}
ret->n_addr = n_addr;
- fastd_async_enqueue(arg->ctx, ASYNC_TYPE_RESOLVE_RETURN, ret, sizeof(fastd_async_resolve_return_t) + n_addr*sizeof(fastd_peer_address_t));
+ fastd_async_enqueue(ASYNC_TYPE_RESOLVE_RETURN, ret, sizeof(fastd_async_resolve_return_t) + n_addr*sizeof(fastd_peer_address_t));
freeaddrinfo(res);
free(arg->hostname);
@@ -104,36 +103,35 @@ static void* resolve_peer(void *varg) {
return NULL;
}
-void fastd_resolve_peer(fastd_context_t *ctx, fastd_peer_t *peer, fastd_remote_t *remote) {
+void fastd_resolve_peer(fastd_peer_t *peer, fastd_remote_t *remote) {
if (!peer->config)
- exit_bug(ctx, "trying to resolve temporary peer");
+ exit_bug("trying to resolve temporary peer");
if (remote->resolving) {
- pr_debug(ctx, "not resolving %P as there is already a resolve running", peer);
+ pr_debug("not resolving %P as there is already a resolve running", peer);
return;
}
- if (!fastd_timed_out(ctx, &remote->last_resolve_timeout)) {
+ if (!fastd_timed_out(&remote->last_resolve_timeout)) {
/* last resolve was just a few seconds ago */
return;
}
- pr_verbose(ctx, "resolving host `%s' for peer %P...", remote->config->hostname, peer);
+ pr_verbose("resolving host `%s' for peer %P...", remote->config->hostname, peer);
fastd_remote_ref(remote);
- remote->last_resolve_timeout = fastd_in_seconds(ctx, conf.min_resolve_interval);
+ remote->last_resolve_timeout = fastd_in_seconds(conf.min_resolve_interval);
remote->resolving = true;
resolv_arg_t *arg = malloc(sizeof(resolv_arg_t));
- arg->ctx = ctx;
arg->remote = remote;
arg->hostname = strdup(remote->config->hostname);
arg->constraints = remote->config->address;
pthread_t thread;
if (pthread_create(&thread, NULL, resolve_peer, arg) != 0) {
- pr_error_errno(ctx, "unable to create resolver thread");
+ pr_error_errno("unable to create resolver thread");
free(arg->hostname);
free(arg);
diff --git a/src/send.c b/src/send.c
index 025eff9..3e346ec 100644
--- a/src/send.c
+++ b/src/send.c
@@ -73,9 +73,9 @@ static inline void count_stat(fastd_stats_t *stats, size_t stat_size) {
}
}
-static void send_type(fastd_context_t *ctx, const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, uint8_t packet_type, fastd_buffer_t buffer, size_t stat_size) {
+static void send_type(const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, uint8_t packet_type, fastd_buffer_t buffer, size_t stat_size) {
if (!sock)
- exit_bug(ctx, "send: sock == NULL");
+ exit_bug("send: sock == NULL");
struct msghdr msg = {};
uint8_t cbuf[1024] __attribute__((aligned(8))) = {};
@@ -93,7 +93,7 @@ static void send_type(fastd_context_t *ctx, const fastd_socket_t *sock, const fa
break;
default:
- exit_bug(ctx, "unsupported address family");
+ exit_bug("unsupported address family");
}
if (sock->bound_addr->sa.sa_family == AF_INET6) {
@@ -125,10 +125,10 @@ static void send_type(fastd_context_t *ctx, const fastd_socket_t *sock, const fa
} while (ret < 0 && errno == EINTR);
if (ret < 0 && errno == EINVAL && msg.msg_controllen) {
- pr_debug2(ctx, "sendmsg failed, trying again without pktinfo");
+ pr_debug2("sendmsg failed, trying again without pktinfo");
- if (peer && !fastd_peer_handshake_scheduled(ctx, peer))
- fastd_peer_schedule_handshake_default(ctx, peer);
+ if (peer && !fastd_peer_handshake_scheduled(peer))
+ fastd_peer_schedule_handshake_default(peer);
msg.msg_control = NULL;
msg.msg_controllen = 0;
@@ -145,51 +145,51 @@ static void send_type(fastd_context_t *ctx, const fastd_socket_t *sock, const fa
#if EAGAIN != EWOULDBLOCK
case EWOULDBLOCK:
#endif
- pr_debug2_errno(ctx, "sendmsg");
- count_stat(&ctx->tx_dropped, stat_size);
+ pr_debug2_errno("sendmsg");
+ count_stat(&ctx.tx_dropped, stat_size);
break;
case ENETDOWN:
case ENETUNREACH:
case EHOSTUNREACH:
- pr_debug_errno(ctx, "sendmsg");
- count_stat(&ctx->tx_error, stat_size);
+ pr_debug_errno("sendmsg");
+ count_stat(&ctx.tx_error, stat_size);
break;
default:
- pr_warn_errno(ctx, "sendmsg");
- count_stat(&ctx->tx_error, stat_size);
+ pr_warn_errno("sendmsg");
+ count_stat(&ctx.tx_error, stat_size);
}
}
else {
- count_stat(&ctx->tx, stat_size);
+ count_stat(&ctx.tx, stat_size);
}
fastd_buffer_free(buffer);
}
-void fastd_send(fastd_context_t *ctx, const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, fastd_buffer_t buffer, size_t stat_size) {
- send_type(ctx, sock, local_addr, remote_addr, peer, PACKET_DATA, buffer, stat_size);
+void fastd_send(const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, fastd_buffer_t buffer, size_t stat_size) {
+ send_type(sock, local_addr, remote_addr, peer, PACKET_DATA, buffer, stat_size);
}
-void fastd_send_handshake(fastd_context_t *ctx, const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, fastd_buffer_t buffer) {
- send_type(ctx, sock, local_addr, remote_addr, peer, PACKET_HANDSHAKE, buffer, 0);
+void fastd_send_handshake(const fastd_socket_t *sock, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *remote_addr, fastd_peer_t *peer, fastd_buffer_t buffer) {
+ send_type(sock, local_addr, remote_addr, peer, PACKET_HANDSHAKE, buffer, 0);
}
-void fastd_send_all(fastd_context_t *ctx, fastd_peer_t *source_peer, fastd_buffer_t buffer) {
+void fastd_send_all(fastd_peer_t *source_peer, fastd_buffer_t buffer) {
size_t i;
- for (i = 0; i < VECTOR_LEN(ctx->peers); i++) {
- fastd_peer_t *dest_peer = VECTOR_INDEX(ctx->peers, i);
+ for (i = 0; i < VECTOR_LEN(ctx.peers); i++) {
+ fastd_peer_t *dest_peer = VECTOR_INDEX(ctx.peers, i);
if (dest_peer == source_peer || !fastd_peer_is_established(dest_peer))
continue;
/* optimization, primarily for TUN mode: don't duplicate the buffer for the last (or only) peer */
- if (i == VECTOR_LEN(ctx->peers)-1) {
- conf.protocol->send(ctx, dest_peer, buffer);
+ if (i == VECTOR_LEN(ctx.peers)-1) {
+ conf.protocol->send(dest_peer, buffer);
return;
}
- conf.protocol->send(ctx, dest_peer, fastd_buffer_dup(ctx, buffer, conf.min_encrypt_head_space, conf.min_encrypt_tail_space));
+ conf.protocol->send(dest_peer, fastd_buffer_dup(buffer, conf.min_encrypt_head_space, conf.min_encrypt_tail_space));
}
fastd_buffer_free(buffer);
diff --git a/src/shell.c b/src/shell.c
index 786dd2a..e35e986 100644
--- a/src/shell.c
+++ b/src/shell.c
@@ -32,15 +32,15 @@
#include <sys/wait.h>
-static void shell_command_setenv(fastd_context_t *ctx, pid_t pid, const fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr) {
+static void shell_command_setenv(pid_t pid, const fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr) {
/* both INET6_ADDRSTRLEN and IFNAMESIZE already include space for the zero termination, so there is no need to add space for the '%' here. */
char buf[INET6_ADDRSTRLEN+IF_NAMESIZE];
snprintf(buf, sizeof(buf), "%u", (unsigned)pid);
setenv("FASTD_PID", buf, 1);
- if (ctx->ifname) {
- setenv("INTERFACE", ctx->ifname, 1);
+ if (ctx.ifname) {
+ setenv("INTERFACE", ctx.ifname, 1);
}
else if (conf.ifname) {
char ifname[IF_NAMESIZE];
@@ -125,12 +125,12 @@ static void shell_command_setenv(fastd_context_t *ctx, pid_t pid, const fastd_pe
conf.protocol->set_shell_env(peer);
}
-static bool shell_command_do_exec(fastd_context_t *ctx, const fastd_shell_command_t *command, const fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr, pid_t *pid_ret) {
+static bool shell_command_do_exec(const fastd_shell_command_t *command, const fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr, pid_t *pid_ret) {
pid_t parent = getpid();
pid_t pid = fork();
if (pid < 0) {
- pr_error_errno(ctx, "shell_command_do_exec: fork");
+ pr_error_errno("shell_command_do_exec: fork");
return false;
}
else if (pid > 0) {
@@ -145,7 +145,7 @@ static bool shell_command_do_exec(fastd_context_t *ctx, const fastd_shell_comman
if (chdir(command->dir))
_exit(126);
- shell_command_setenv(ctx, parent, peer, local_addr, peer_addr);
+ shell_command_setenv(parent, peer, local_addr, peer_addr);
/* unblock SIGCHLD */
sigset_t set;
@@ -157,7 +157,7 @@ static bool shell_command_do_exec(fastd_context_t *ctx, const fastd_shell_comman
_exit(127);
}
-bool fastd_shell_command_exec_sync(fastd_context_t *ctx, const fastd_shell_command_t *command, const fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr, int *ret) {
+bool fastd_shell_command_exec_sync(const fastd_shell_command_t *command, const fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr, int *ret) {
if (!fastd_shell_command_isset(command))
return true;
@@ -168,7 +168,7 @@ bool fastd_shell_command_exec_sync(fastd_context_t *ctx, const fastd_shell_comma
pthread_sigmask(SIG_BLOCK, &set, &oldset);
pid_t pid;
- if (!shell_command_do_exec(ctx, command, peer, local_addr, peer_addr, &pid))
+ if (!shell_command_do_exec(command, peer, local_addr, peer_addr, &pid))
return false;
int status;
@@ -177,7 +177,7 @@ bool fastd_shell_command_exec_sync(fastd_context_t *ctx, const fastd_shell_comma
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
if (err <= 0) {
- pr_error_errno(ctx, "fastd_shell_command_exec_sync: waitpid");
+ pr_error_errno("fastd_shell_command_exec_sync: waitpid");
return false;
}
@@ -186,21 +186,21 @@ bool fastd_shell_command_exec_sync(fastd_context_t *ctx, const fastd_shell_comma
}
else {
if (WIFSIGNALED(status))
- pr_warn(ctx, "command exited with signal %i", WTERMSIG(status));
+ pr_warn("command exited with signal %i", WTERMSIG(status));
else if (WEXITSTATUS(status))
- pr_warn(ctx, "command exited with status %i", WEXITSTATUS(status));
+ pr_warn("command exited with status %i", WEXITSTATUS(status));
}
return true;
}
-void fastd_shell_command_exec(fastd_context_t *ctx, const fastd_shell_command_t *command, const fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr) {
+void fastd_shell_command_exec(const fastd_shell_command_t *command, const fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr) {
if (!fastd_shell_command_isset(command))
return;
if (command->sync)
- fastd_shell_command_exec_sync(ctx, command, peer, local_addr, peer_addr, NULL);
+ fastd_shell_command_exec_sync(command, peer, local_addr, peer_addr, NULL);
else
- shell_command_do_exec(ctx, command, peer, local_addr, peer_addr, NULL);
+ shell_command_do_exec(command, peer, local_addr, peer_addr, NULL);
}
diff --git a/src/shell.h b/src/shell.h
index 21a451b..30de630 100644
--- a/src/shell.h
+++ b/src/shell.h
@@ -58,5 +58,5 @@ static inline bool fastd_shell_command_isset(const fastd_shell_command_t *comman
return command->command;
}
-bool fastd_shell_command_exec_sync(fastd_context_t *ctx, const fastd_shell_command_t *command, const fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr, int *ret);
-void fastd_shell_command_exec(fastd_context_t *ctx, const fastd_shell_command_t *command, const fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr);
+bool fastd_shell_command_exec_sync(const fastd_shell_command_t *command, const fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr, int *ret);
+void fastd_shell_command_exec(const fastd_shell_command_t *command, const fastd_peer_t *peer, const fastd_peer_address_t *local_addr, const fastd_peer_address_t *peer_addr);
diff --git a/src/socket.c b/src/socket.c
index 70ff17a..77f73b4 100644
--- a/src/socket.c
+++ b/src/socket.c
@@ -30,7 +30,7 @@
#include <fcntl.h>
-static int bind_socket(fastd_context_t *ctx, const fastd_bind_address_t *addr, bool warn) {
+static int bind_socket(const fastd_bind_address_t *addr, bool warn) {
int fd = -1;
int af = AF_UNSPEC;
@@ -42,7 +42,7 @@ static int bind_socket(fastd_context_t *ctx, const fastd_bind_address_t *addr, b
int val = (addr->addr.sa.sa_family == AF_INET6);
if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &val, sizeof(val))) {
if (warn)
- pr_warn_errno(ctx, "setsockopt");
+ pr_warn_errno("setsockopt");
goto error;
}
}
@@ -50,7 +50,7 @@ static int bind_socket(fastd_context_t *ctx, const fastd_bind_address_t *addr, b
if (fd < 0 && addr->addr.sa.sa_family != AF_INET6) {
fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (fd < 0)
- exit_errno(ctx, "unable to create socket");
+ exit_errno("unable to create socket");
else
af = AF_INET;
}
@@ -58,26 +58,26 @@ static int bind_socket(fastd_context_t *ctx, const fastd_bind_address_t *addr, b
if (fd < 0)
goto error;
- fastd_setfd(ctx, fd, FD_CLOEXEC, 0);
- fastd_setfl(ctx, fd, O_NONBLOCK, 0);
+ fastd_setfd(fd, FD_CLOEXEC, 0);
+ fastd_setfl(fd, O_NONBLOCK, 0);
int one = 1;
#ifdef USE_PKTINFO
if (setsockopt(fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one))) {
- pr_error_errno(ctx, "setsockopt: unable to set IP_PKTINFO");
+ pr_error_errno("setsockopt: unable to set IP_PKTINFO");
goto error;
}
#endif
#ifdef USE_FREEBIND
if (setsockopt(fd, IPPROTO_IP, IP_FREEBIND, &one, sizeof(one)))
- pr_warn_errno(ctx, "setsockopt: unable to set IP_FREEBIND");
+ pr_warn_errno("setsockopt: unable to set IP_FREEBIND");
#endif
if (af == AF_INET6) {
if (setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one))) {
- pr_error_errno(ctx, "setsockopt: unable to set IPV6_RECVPKTINFO");
+ pr_error_errno("setsockopt: unable to set IPV6_RECVPKTINFO");
goto error;
}
}
@@ -86,7 +86,7 @@ static int bind_socket(fastd_context_t *ctx, const fastd_bind_address_t *addr, b
if (addr->bindtodev && !fastd_peer_address_is_v6_ll(&addr->addr)) {
if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, addr->bindtodev, strlen(addr->bindtodev))) {
if (warn)
- pr_warn_errno(ctx, "setsockopt: unable to bind to device");
+ pr_warn_errno("setsockopt: unable to bind to device");
goto error;
}
}
@@ -96,7 +96,7 @@ static int bind_socket(fastd_context_t *ctx, const fastd_bind_address_t *addr, b
if (conf.pmtu.set) {
int pmtu = conf.pmtu.state ? IP_PMTUDISC_DO : IP_PMTUDISC_DONT;
if (setsockopt(fd, IPPROTO_IP, IP_MTU_DISCOVER, &pmtu, sizeof(pmtu))) {
- pr_error_errno(ctx, "setsockopt: unable to set PMTU discovery");
+ pr_error_errno("setsockopt: unable to set PMTU discovery");
goto error;
}
}
@@ -105,7 +105,7 @@ static int bind_socket(fastd_context_t *ctx, const fastd_bind_address_t *addr, b
#ifdef USE_PACKET_MARK
if (conf.packet_mark) {
if (setsockopt(fd, SOL_SOCKET, SO_MARK, &conf.packet_mark, sizeof(conf.packet_mark))) {
- pr_error_errno(ctx, "setsockopt: unable to set packet mark");
+ pr_error_errno("setsockopt: unable to set packet mark");
goto error;
}
}
@@ -122,7 +122,7 @@ static int bind_socket(fastd_context_t *ctx, const fastd_bind_address_t *addr, b
if (!bind_address.in6.sin6_scope_id) {
if (warn)
- pr_warn_errno(ctx, "if_nametoindex");
+ pr_warn_errno("if_nametoindex");
goto error;
}
}
@@ -139,7 +139,7 @@ static int bind_socket(fastd_context_t *ctx, const fastd_bind_address_t *addr, b
if (bind(fd, &bind_address.sa, bind_address.sa.sa_family == AF_INET6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in))) {
if (warn)
- pr_warn_errno(ctx, "bind");
+ pr_warn_errno("bind");
goto error;
}
@@ -148,30 +148,30 @@ static int bind_socket(fastd_context_t *ctx, const fastd_bind_address_t *addr, b
error:
if (fd >= 0) {
if (close(fd))
- pr_error_errno(ctx, "close");
+ pr_error_errno("close");
}
if (warn) {
if (addr->bindtodev)
- pr_warn(ctx, fastd_peer_address_is_v6_ll(&addr->addr) ? "unable to bind to %L" : "unable to bind to %B on `%s'", &addr->addr, addr->bindtodev);
+ pr_warn(fastd_peer_address_is_v6_ll(&addr->addr) ? "unable to bind to %L" : "unable to bind to %B on `%s'", &addr->addr, addr->bindtodev);
else
- pr_warn(ctx, "unable to bind to %B", &addr->addr);
+ pr_warn("unable to bind to %B", &addr->addr);
}
return -1;
}
-static bool set_bound_address(fastd_context_t *ctx, fastd_socket_t *sock) {
+static bool set_bound_address(fastd_socket_t *sock) {
fastd_peer_address_t addr = {};
socklen_t len = sizeof(addr);
if (getsockname(sock->fd, &addr.sa, &len) < 0) {
- pr_error_errno(ctx, "getsockname");
+ pr_error_errno("getsockname");
return false;
}
if (len > sizeof(addr)) {
- pr_error(ctx, "getsockname: got strange long address");
+ pr_error("getsockname: got strange long address");
return false;
}
@@ -181,44 +181,44 @@ static bool set_bound_address(fastd_context_t *ctx, fastd_socket_t *sock) {
return true;
}
-bool fastd_socket_handle_binds(fastd_context_t *ctx) {
+bool fastd_socket_handle_binds(void) {
unsigned i;
- for (i = 0; i < ctx->n_socks; i++) {
- if (ctx->socks[i].fd >= 0)
+ for (i = 0; i < ctx.n_socks; i++) {
+ if (ctx.socks[i].fd >= 0)
continue;
- ctx->socks[i].fd = bind_socket(ctx, ctx->socks[i].addr, ctx->socks[i].fd < -1);
+ ctx.socks[i].fd = bind_socket(ctx.socks[i].addr, ctx.socks[i].fd < -1);
- if (ctx->socks[i].fd >= 0) {
- if (!set_bound_address(ctx, &ctx->socks[i])) {
- fastd_socket_close(ctx, &ctx->socks[i]);
+ if (ctx.socks[i].fd >= 0) {
+ if (!set_bound_address(&ctx.socks[i])) {
+ fastd_socket_close(&ctx.socks[i]);
continue;
}
- fastd_poll_set_fd_sock(ctx, i);
+ fastd_poll_set_fd_sock(i);
- fastd_peer_address_t bound_addr = *ctx->socks[i].bound_addr;
- if (!ctx->socks[i].addr->addr.sa.sa_family)
+ fastd_peer_address_t bound_addr = *ctx.socks[i].bound_addr;
+ if (!ctx.socks[i].addr->addr.sa.sa_family)
bound_addr.sa.sa_family = AF_UNSPEC;
- if (ctx->socks[i].addr->bindtodev && !fastd_peer_address_is_v6_ll(&bound_addr))
- pr_info(ctx, "successfully bound to %B on `%s'", &bound_addr, ctx->socks[i].addr->bindtodev);
+ if (ctx.socks[i].addr->bindtodev && !fastd_peer_address_is_v6_ll(&bound_addr))
+ pr_info("successfully bound to %B on `%s'", &bound_addr, ctx.socks[i].addr->bindtodev);
else
- pr_info(ctx, "successfully bound to %B", &bound_addr);
+ pr_info("successfully bound to %B", &bound_addr);
}
}
- if ((ctx->sock_default_v4 && ctx->sock_default_v4->fd < 0) || (ctx->sock_default_v6 && ctx->sock_default_v6->fd < 0))
+ if ((ctx.sock_default_v4 && ctx.sock_default_v4->fd < 0) || (ctx.sock_default_v6 && ctx.sock_default_v6->fd < 0))
return false;
return true;
}
-fastd_socket_t* fastd_socket_open(fastd_context_t *ctx, fastd_peer_t *peer, int af) {
+fastd_socket_t* fastd_socket_open(fastd_peer_t *peer, int af) {
const fastd_bind_address_t any_address = { .addr.sa.sa_family = af };
- int fd = bind_socket(ctx, &any_address, true);
+ int fd = bind_socket(&any_address, true);
if (fd < 0)
return NULL;
@@ -229,8 +229,8 @@ fastd_socket_t* fastd_socket_open(fastd_context_t *ctx, fastd_peer_t *peer, int
sock->bound_addr = NULL;
sock->peer = peer;
- if (!set_bound_address(ctx, sock)) {
- fastd_socket_close(ctx, sock);
+ if (!set_bound_address(sock)) {
+ fastd_socket_close(sock);
free(sock);
return NULL;
}
@@ -238,10 +238,10 @@ fastd_socket_t* fastd_socket_open(fastd_context_t *ctx, fastd_peer_t *peer, int
return sock;
}
-void fastd_socket_close(fastd_context_t *ctx, fastd_socket_t *sock) {
+void fastd_socket_close(fastd_socket_t *sock) {
if (sock->fd >= 0) {
if(close(sock->fd))
- pr_error_errno(ctx, "closing socket: close");
+ pr_error_errno("closing socket: close");
sock->fd = -2;
}
@@ -252,11 +252,11 @@ void fastd_socket_close(fastd_context_t *ctx, fastd_socket_t *sock) {
}
}
-void fastd_socket_error(fastd_context_t *ctx, fastd_socket_t *sock) {
+void fastd_socket_error(fastd_socket_t *sock) {
if (sock->addr->bindtodev)
- pr_warn(ctx, "socket bind %I on `%s' lost", &sock->addr->addr, sock->addr->bindtodev);
+ pr_warn("socket bind %I on `%s' lost", &sock->addr->addr, sock->addr->bindtodev);
else
- pr_warn(ctx, "socket bind %I lost", &sock->addr->addr);
+ pr_warn("socket bind %I lost", &sock->addr->addr);
- fastd_socket_close(ctx, sock);
+ fastd_socket_close(sock);
}
diff --git a/src/tuntap.c b/src/tuntap.c
index 0fc17a3..e5c0471 100644
--- a/src/tuntap.c
+++ b/src/tuntap.c
@@ -56,13 +56,13 @@ static const bool multiaf_tun = true;
#if defined(__linux__)
-void fastd_tuntap_open(fastd_context_t *ctx) {
+void fastd_tuntap_open(void) {
struct ifreq ifr = {};
- pr_debug(ctx, "initializing tun/tap device...");
+ pr_debug("initializing tun/tap device...");
- if ((ctx->tunfd = open("/dev/net/tun", O_RDWR|O_CLOEXEC|O_NONBLOCK)) < 0)
- exit_errno(ctx, "could not open tun/tap device file");
+ if ((ctx.tunfd = open("/dev/net/tun", O_RDWR|O_CLOEXEC|O_NONBLOCK)) < 0)
+ exit_errno("could not open tun/tap device file");
if (conf.ifname)
strncpy(ifr.ifr_name, conf.ifname, IFNAMSIZ-1);
@@ -77,87 +77,87 @@ void fastd_tuntap_open(fastd_context_t *ctx) {
break;
default:
- exit_bug(ctx, "invalid mode");
+ exit_bug("invalid mode");
}
ifr.ifr_flags |= IFF_NO_PI;
- if (ioctl(ctx->tunfd, TUNSETIFF, &ifr) < 0)
- exit_errno(ctx, "TUNSETIFF ioctl failed");
+ if (ioctl(ctx.tunfd, TUNSETIFF, &ifr) < 0)
+ exit_errno("TUNSETIFF ioctl failed");
- ctx->ifname = strndup(ifr.ifr_name, IFNAMSIZ-1);
+ ctx.ifname = strndup(ifr.ifr_name, IFNAMSIZ-1);
int ctl_sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (ctl_sock < 0)
- exit_errno(ctx, "socket");
+ exit_errno("socket");
if (ioctl(ctl_sock, SIOCGIFMTU, &ifr) < 0)
- exit_errno(ctx, "SIOCGIFMTU ioctl failed");
+ exit_errno("SIOCGIFMTU ioctl failed");
if (ifr.ifr_mtu != conf.mtu) {
ifr.ifr_mtu = conf.mtu;
if (ioctl(ctl_sock, SIOCSIFMTU, &ifr) < 0)
- exit_errno(ctx, "SIOCSIFMTU ioctl failed");
+ exit_errno("SIOCSIFMTU ioctl failed");
}
if (close(ctl_sock))
- pr_error_errno(ctx, "close");
+ pr_error_errno("close");
- fastd_poll_set_fd_tuntap(ctx);
+ fastd_poll_set_fd_tuntap();
- pr_debug(ctx, "tun/tap device initialized.");
+ pr_debug("tun/tap device initialized.");
}
#elif defined(__FreeBSD__) || defined(__OpenBSD__)
-static void set_tun_mtu(fastd_context_t *ctx) {
+static void set_tun_mtu(void) {
struct tuninfo tuninfo;
- if (ioctl(ctx->tunfd, TUNGIFINFO, &tuninfo) < 0)
- exit_errno(ctx, "TUNGIFINFO ioctl failed");
+ if (ioctl(ctx.tunfd, TUNGIFINFO, &tuninfo) < 0)
+ exit_errno("TUNGIFINFO ioctl failed");
tuninfo.mtu = conf.mtu;
- if (ioctl(ctx->tunfd, TUNSIFINFO, &tuninfo) < 0)
- exit_errno(ctx, "TUNSIFINFO ioctl failed");
+ if (ioctl(ctx.tunfd, TUNSIFINFO, &tuninfo) < 0)
+ exit_errno("TUNSIFINFO ioctl failed");
}
#ifdef __FreeBSD__
-static void set_tap_mtu(fastd_context_t *ctx) {
+static void set_tap_mtu(void) {
struct tapinfo tapinfo;
- if (ioctl(ctx->tunfd, TAPGIFINFO, &tapinfo) < 0)
- exit_errno(ctx, "TAPGIFINFO ioctl failed");
+ if (ioctl(ctx.tunfd, TAPGIFINFO, &tapinfo) < 0)
+ exit_errno("TAPGIFINFO ioctl failed");
tapinfo.mtu = conf.mtu;
- if (ioctl(ctx->tunfd, TAPSIFINFO, &tapinfo) < 0)
- exit_errno(ctx, "TAPSIFINFO ioctl failed");
+ if (ioctl(ctx.tunfd, TAPSIFINFO, &tapinfo) < 0)
+ exit_errno("TAPSIFINFO ioctl failed");
}
-static void setup_tun(fastd_context_t *ctx) {
+static void setup_tun(void) {
int one = 1;
- if (ioctl(ctx->tunfd, TUNSIFHEAD, &one) < 0)
- exit_errno(ctx, "TUNSIFHEAD ioctl failed");
+ if (ioctl(ctx.tunfd, TUNSIFHEAD, &one) < 0)
+ exit_errno("TUNSIFHEAD ioctl failed");
- set_tun_mtu(ctx);
+ set_tun_mtu();
}
-static void setup_tap(fastd_context_t *ctx) {
+static void setup_tap(void) {
struct ifreq ifr = {};
- if (ioctl(ctx->tunfd, TAPGIFNAME, &ifr) < 0)
- exit_errno(ctx, "TAPGIFNAME ioctl failed");
+ if (ioctl(ctx.tunfd, TAPGIFNAME, &ifr) < 0)
+ exit_errno("TAPGIFNAME ioctl failed");
- free(ctx->ifname);
- ctx->ifname = strndup(ifr.ifr_name, IFNAMSIZ-1);
+ free(ctx.ifname);
+ ctx.ifname = strndup(ifr.ifr_name, IFNAMSIZ-1);
- set_tap_mtu(ctx);
+ set_tap_mtu();
}
-void fastd_tuntap_open(fastd_context_t *ctx) {
- pr_debug(ctx, "initializing tun/tap device...");
+void fastd_tuntap_open(void) {
+ pr_debug("initializing tun/tap device...");
char ifname[5+IFNAMSIZ] = "/dev/";
const char *type;
@@ -172,12 +172,12 @@ void fastd_tuntap_open(fastd_context_t *ctx) {
break;
default:
- exit_bug(ctx, "invalid mode");
+ exit_bug("invalid mode");
}
if (conf.ifname) {
if (strncmp(conf.ifname, type, 3) != 0)
- exit_error(ctx, "`%s' doesn't seem to be a %s device", conf.ifname, type);
+ exit_error("`%s' doesn't seem to be a %s device", conf.ifname, type);
strncat(ifname, conf.ifname, IFNAMSIZ-1);
}
@@ -185,42 +185,42 @@ void fastd_tuntap_open(fastd_context_t *ctx) {
strncat(ifname, type, IFNAMSIZ-1);
}
- if ((ctx->tunfd = open(ifname, O_RDWR|O_CLOEXEC|O_NONBLOCK)) < 0)
- exit_errno(ctx, "could not open tun/tap device file");
+ if ((ctx.tunfd = open(ifname, O_RDWR|O_CLOEXEC|O_NONBLOCK)) < 0)
+ exit_errno("could not open tun/tap device file");
- if (!(ctx->ifname = fdevname_r(ctx->tunfd, malloc(IFNAMSIZ), IFNAMSIZ)))
- exit_errno(ctx, "could not get tun/tap interface name");
+ if (!(ctx.ifname = fdevname_r(ctx.tunfd, malloc(IFNAMSIZ), IFNAMSIZ)))
+ exit_errno("could not get tun/tap interface name");
switch (conf.mode) {
case MODE_TAP:
- setup_tap(ctx);
+ setup_tap();
break;
case MODE_TUN:
- setup_tun(ctx);
+ setup_tun();
break;
default:
- exit_bug(ctx, "invalid mode");
+ exit_bug("invalid mode");
}
- fastd_poll_set_fd_tuntap(ctx);
+ fastd_poll_set_fd_tuntap();
- pr_debug(ctx, "tun/tap device initialized.");
+ pr_debug("tun/tap device initialized.");
}
#else /* __OpenBSD__ */
-static void set_link0(fastd_context_t *ctx, bool set) {
+static void set_link0(bool set) {
struct ifreq ifr = {};
int ctl_sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (ctl_sock < 0)
- exit_errno(ctx, "socket");
+ exit_errno("socket");
- strncpy(ifr.ifr_name, ctx->ifname, IFNAMSIZ-1);
+ strncpy(ifr.ifr_name, ctx.ifname, IFNAMSIZ-1);
if (ioctl(ctl_sock, SIOCGIFFLAGS, &ifr) < 0)
- exit_errno(ctx, "SIOCGIFFLAGS ioctl failed");
+ exit_errno("SIOCGIFFLAGS ioctl failed");
if (set)
ifr.ifr_flags |= IFF_LINK0;
@@ -228,54 +228,54 @@ static void set_link0(fastd_context_t *ctx, bool set) {
ifr.ifr_flags &= ~IFF_LINK0;
if (ioctl(ctl_sock, SIOCSIFFLAGS, &ifr) < 0)
- exit_errno(ctx, "SIOCSIFFLAGS ioctl failed");
+ exit_errno("SIOCSIFFLAGS ioctl failed");
if (close(ctl_sock))
- pr_error_errno(ctx, "close");
+ pr_error_errno("close");
}
-static void setup_tun(fastd_context_t *ctx) {
- set_link0(ctx, false);
- set_tun_mtu(ctx);
+static void setup_tun(void) {
+ set_link0(false);
+ set_tun_mtu();
}
-static void setup_tap(fastd_context_t *ctx) {
- set_link0(ctx, true);
- set_tun_mtu(ctx);
+static void setup_tap(void) {
+ set_link0(true);
+ set_tun_mtu();
}
-void fastd_tuntap_open(fastd_context_t *ctx) {
+void fastd_tuntap_open(void) {
char ifname[5+IFNAMSIZ] = "/dev/";
if (!conf.ifname)
- exit_error(ctx, "config error: no interface name given.");
+ exit_error("config error: no interface name given.");
else if (strncmp(conf.ifname, "tun", 3) != 0)
- exit_error(ctx, "config error: `%s' doesn't seem to be a tun device", conf.ifname);
+ exit_error("config error: `%s' doesn't seem to be a tun device", conf.ifname);
else
strncat(ifname, conf.ifname, IFNAMSIZ-1);
- pr_debug(ctx, "initializing tun device...");
+ pr_debug("initializing tun device...");
- if ((ctx->tunfd = open(ifname, O_RDWR|O_CLOEXEC|O_NONBLOCK)) < 0)
- exit_errno(ctx, "could not open tun device file");
+ if ((ctx.tunfd = open(ifname, O_RDWR|O_CLOEXEC|O_NONBLOCK)) < 0)
+ exit_errno("could not open tun device file");
- ctx->ifname = strndup(conf.ifname, IFNAMSIZ-1);
+ ctx.ifname = strndup(conf.ifname, IFNAMSIZ-1);
switch (conf.mode) {
case MODE_TAP:
- setup_tap(ctx);
+ setup_tap();
break;
case MODE_TUN:
- setup_tun(ctx);
+ setup_tun();
break;
default:
- exit_bug(ctx, "invalid mode");
+ exit_bug("invalid mode");
}
- fastd_poll_set_fd_tuntap(ctx);
+ fastd_poll_set_fd_tuntap();
- pr_debug(ctx, "tun device initialized.");
+ pr_debug("tun device initialized.");
}
#endif
@@ -287,34 +287,34 @@ void fastd_tuntap_open(fastd_context_t *ctx) {
#endif
-fastd_buffer_t fastd_tuntap_read(fastd_context_t *ctx) {
- size_t max_len = fastd_max_inner_packet(ctx);
+fastd_buffer_t fastd_tuntap_read(void) {
+ size_t max_len = fastd_max_inner_packet();
fastd_buffer_t buffer;
if (multiaf_tun && conf.mode == MODE_TUN)
- buffer = fastd_buffer_alloc(ctx, max_len+4, conf.min_encrypt_head_space+12, conf.min_encrypt_tail_space);
+ buffer = fastd_buffer_alloc(max_len+4, conf.min_encrypt_head_space+12, conf.min_encrypt_tail_space);
else
- buffer = fastd_buffer_alloc(ctx, max_len, conf.min_encrypt_head_space, conf.min_encrypt_tail_space);
+ buffer = fastd_buffer_alloc(max_len, conf.min_encrypt_head_space, conf.min_encrypt_tail_space);
- ssize_t len = read(ctx->tunfd, buffer.data, max_len);
+ ssize_t len = read(ctx.tunfd, buffer.data, max_len);
if (len < 0) {
if (errno == EINTR) {
fastd_buffer_free(buffer);
return (fastd_buffer_t){};
}
- exit_errno(ctx, "read");
+ exit_errno("read");
}
buffer.len = len;
if (multiaf_tun && conf.mode == MODE_TUN)
- fastd_buffer_push_head(ctx, &buffer, 4);
+ fastd_buffer_push_head(&buffer, 4);
return buffer;
}
-void fastd_tuntap_write(fastd_context_t *ctx, fastd_buffer_t buffer) {
+void fastd_tuntap_write(fastd_buffer_t buffer) {
if (multiaf_tun && conf.mode == MODE_TUN) {
uint8_t version = *((uint8_t*)buffer.data) >> 4;
uint32_t af;
@@ -329,19 +329,19 @@ void fastd_tuntap_write(fastd_context_t *ctx, fastd_buffer_t buffer) {
break;
default:
- pr_warn(ctx, "fastd_tuntap_write: unknown IP version %u", version);
+ pr_warn("fastd_tuntap_write: unknown IP version %u", version);
return;
}
- fastd_buffer_pull_head(ctx, &buffer, 4);
+ fastd_buffer_pull_head(&buffer, 4);
memcpy(buffer.data, &af, 4);
}
- if (write(ctx->tunfd, buffer.data, buffer.len) < 0)
- pr_warn_errno(ctx, "write");
+ if (write(ctx.tunfd, buffer.data, buffer.len) < 0)
+ pr_warn_errno("write");
}
-void fastd_tuntap_close(fastd_context_t *ctx) {
- if (close(ctx->tunfd))
- pr_warn_errno(ctx, "closing tun/tap: close");
+void fastd_tuntap_close(void) {
+ if (close(ctx.tunfd))
+ pr_warn_errno("closing tun/tap: close");
}