diff options
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; @@ -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); } @@ -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]); } } @@ -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; @@ -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); @@ -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); } } } @@ -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); @@ -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"); } |