struct uhub_plugin* plugin_open(const char* filename) { struct uhub_plugin* plugin; LOG_PLUGIN("plugin_open: \"%s\"", filename); plugin = (struct uhub_plugin*) hub_malloc_zero(sizeof(struct uhub_plugin)); if (!plugin) { return 0; } #ifdef HAVE_DLOPEN plugin->handle = dlopen(filename, RTLD_LAZY); #else plugin->handle = LoadLibraryExA(filename, NULL, 0); #endif if (!plugin->handle) { #ifdef HAVE_DLOPEN LOG_ERROR("Unable to open plugin %s: %s", filename, dlerror()); #else LOG_ERROR("Unable to open plugin %s: %d", filename, GetLastError()); #endif hub_free(plugin); return 0; } plugin->filename = strdup(filename); plugin->internals = hub_malloc_zero(sizeof(struct plugin_hub_internals)); return plugin; }
struct ADC_client* ADC_client_create(const char* nickname, const char* description, void* ptr) { ADC_TRACE; struct ADC_client* client = (struct ADC_client*) hub_malloc_zero(sizeof(struct ADC_client)); ADC_client_set_state(client, ps_none); client->nick = hub_strdup(nickname); client->desc = hub_strdup(description); client->send_queue = ioq_send_create(); client->recv_queue = ioq_recv_create(); client->ptr = ptr; if (!g_adc_client) { g_adc_client = (struct ADC_client_global*) hub_malloc_zero(sizeof(struct ADC_client_global)); #ifdef SSL_SUPPORT g_adc_client->ctx = net_ssl_context_create("1.2", "HIGH"); #endif } g_adc_client->references++; return client; }
int uman_init(struct hub_info* hub) { struct hub_user_manager* users = NULL; if (!hub) return -1; users = (struct hub_user_manager*) hub_malloc_zero(sizeof(struct hub_user_manager)); if (!users) return -1; users->list = list_create(); users->sids = sid_pool_create(net_get_max_sockets()); if (!users->list) { list_destroy(users->list); hub_free(users); return -1; } if (net_backend_get_timeout_queue()) { users->timeout = hub_malloc_zero(sizeof(struct timeout_evt)); timeout_evt_initialize(users->timeout, timer_statistics, hub); timeout_queue_insert(net_backend_get_timeout_queue(), users->timeout, TIMEOUT_STATS); } hub->users = users; return 0; }
struct net_backend* net_backend_init_select(struct net_backend_handler* handler, struct net_backend_common* common) { struct net_backend_select* backend; if (getenv("EVENT_NOSELECT")) return 0; backend = hub_malloc_zero(sizeof(struct net_backend_select)); FD_ZERO(&backend->rfds); FD_ZERO(&backend->wfds); backend->conns = hub_malloc_zero(sizeof(struct net_connection_select*) * common->max); backend->common = common; net_backend_set_handlers(handler); return (struct net_backend*) backend; }
void timeout_queue_initialize(struct timeout_queue* t, time_t now, size_t max) { t->last = now; t->max = max; memset(&t->lock, 0, sizeof(t->lock)); t->events = hub_malloc_zero(max * sizeof(struct timeout_evt*)); }
static int check_cmd_addr(const char* cmd, struct linked_list* list, char* line, int line_count) { char* data; struct ip_range* range = 0; if (!strncmp(line, cmd, strlen(cmd))) { data = &line[strlen(cmd)]; data[0] = '\0'; data++; data = strip_white_space(data); if (!*data) { LOG_FATAL("ACL parse error on line %d", line_count); return -1; } range = hub_malloc_zero(sizeof(struct ip_range)); if (!range) { LOG_ERROR("ACL parse error. Out of memory!"); return -1; } if (ip_convert_address_to_range(data, range)) { add_ip_range(list, range); return 1; } hub_free(range); } return 0; }
struct hub_user* user_create(struct hub_info* hub, struct net_connection* con, struct ip_addr_encap* addr) { struct hub_user* user = NULL; LOG_TRACE("user_create(), hub=%p, con[sd=%d]", hub, net_con_get_sd(con)); user = (struct hub_user*) hub_malloc_zero(sizeof(struct hub_user)); if (user == NULL) return NULL; /* OOM */ user->send_queue = ioq_send_create(); user->recv_queue = ioq_recv_create(); user->connection = con; net_con_reinitialize(user->connection, net_event, user, NET_EVENT_READ); memcpy(&user->id.addr, addr, sizeof(struct ip_addr_encap)); user_set_state(user, state_protocol); flood_control_reset(&user->flood_chat); flood_control_reset(&user->flood_connect); flood_control_reset(&user->flood_search); flood_control_reset(&user->flood_update); flood_control_reset(&user->flood_extras); user->hub = hub; return user; }
ssize_t net_con_ssl_handshake(struct net_connection* con, enum net_con_ssl_mode ssl_mode, struct ssl_context_handle* ssl_ctx) { uhub_assert(con); uhub_assert(ssl_ctx); struct net_context_openssl* ctx = (struct net_context_openssl*) ssl_ctx; struct net_ssl_openssl* handle = (struct net_ssl_openssl*) hub_malloc_zero(sizeof(struct net_ssl_openssl)); if (ssl_mode == net_con_ssl_mode_server) { handle->ssl = SSL_new(ctx->ssl); if (!handle->ssl) { LOG_ERROR("Unable to create new SSL stream\n"); return -1; } SSL_set_fd(handle->ssl, con->sd); handle->bio = SSL_get_rbio(handle->ssl); con->ssl = (struct ssl_handle*) handle; return net_con_ssl_accept(con); } else { handle->ssl = SSL_new(ctx->ssl); SSL_set_fd(handle->ssl, con->sd); handle->bio = SSL_get_rbio(handle->ssl); con->ssl = (struct ssl_handle*) handle; return net_con_ssl_connect(con); } }
static void command_register(struct plugin_handle* plugin) { struct example_plugin_data* data = (struct example_plugin_data*) hub_malloc(sizeof(struct example_plugin_data)); data->example = hub_malloc_zero(sizeof(struct plugin_command_handle)); PLUGIN_COMMAND_INITIALIZE(data->example, (void*) data, "example", "", auth_cred_guest, example_command_handler, "This is an example command that is added dynamically by loading the mod_example plug-in."); plugin->hub.command_add(plugin, data->example); plugin->ptr = data; }
static void insert_user(struct linked_list* users, const char* nick, const char* pass, enum auth_credentials cred) { struct auth_info* data = (struct auth_info*) hub_malloc_zero(sizeof(struct auth_info)); strncpy(data->nickname, nick, MAX_NICK_LEN); strncpy(data->password, pass, MAX_PASS_LEN); data->credentials = cred; list_append(users, data); }
static struct patterns_data* parse_config(const char* line, struct plugin_handle* plugin) { struct patterns_data* data = (struct patterns_data*) hub_malloc_zero(sizeof(struct patterns_data)); struct cfg_tokens* tokens = cfg_tokenize(line); char* token = cfg_token_get_first(tokens); if (!data) return 0; while (token) { struct cfg_settings* setting = cfg_settings_split(token); if (!setting) { set_error_message(plugin, "Unable to parse startup parameters"); cfg_tokens_free(tokens); hub_free(data); return 0; } if (strcmp(cfg_settings_get_key(setting), "file") == 0) { if (!data->db) { if (sqlite3_open(cfg_settings_get_value(setting), &data->db)) { cfg_tokens_free(tokens); cfg_settings_free(setting); hub_free(data); set_error_message(plugin, "Unable to open database file"); return 0; } } } else { set_error_message(plugin, "Unknown startup parameters given"); cfg_tokens_free(tokens); cfg_settings_free(setting); hub_free(data); return 0; } cfg_settings_free(setting); token = cfg_token_get_next(tokens); } cfg_tokens_free(tokens); if (!data->db) { set_error_message(plugin, "No database file is given, use file=<database>"); hub_free(data); return 0; } return data; }
static struct log_data* parse_config(const char* line, struct plugin_handle* plugin) { struct log_data* data = (struct log_data*) hub_malloc_zero(sizeof(struct log_data)); struct cfg_tokens* tokens = cfg_tokenize(line); char* token = cfg_token_get_first(tokens); uhub_assert(data != NULL); data->srvtdiff = 0; while (token) { struct cfg_settings* setting = cfg_settings_split(token); if (!setting) { set_error_message(plugin, "Unable to parse startup parameters"); cfg_tokens_free(tokens); hub_free(data); return 0; } if (strcmp(cfg_settings_get_key(setting), "file") == 0) { if (!data->db) { if (sqlite3_open(cfg_settings_get_value(setting), &data->db)) { cfg_tokens_free(tokens); cfg_settings_free(setting); hub_free(data); set_error_message(plugin, "Unable to open database file"); return 0; } } } else if (strcmp(cfg_settings_get_key(setting), "server_time_diff") == 0) { data->srvtdiff = uhub_atoi(cfg_settings_get_value(setting)); } else { set_error_message(plugin, "Unknown startup parameters given"); cfg_tokens_free(tokens); cfg_settings_free(setting); hub_free(data); return 0; } cfg_settings_free(setting); token = cfg_token_get_next(tokens); } cfg_tokens_free(tokens); return data; }
struct plugin_handle* plugin_load(const char* filename, const char* config, struct hub_info* hub) { plugin_register_f register_f; plugin_unregister_f unregister_f; int ret; struct plugin_handle* handle = (struct plugin_handle*) hub_malloc_zero(sizeof(struct plugin_handle)); struct uhub_plugin* plugin = plugin_open(filename); struct plugin_hub_internals* internals = (struct plugin_hub_internals*) plugin->internals; if (!plugin) return NULL; if (!handle) { plugin_close(plugin); return NULL; } handle->handle = plugin; register_f = plugin_lookup_symbol(plugin, "plugin_register"); unregister_f = plugin_lookup_symbol(plugin, "plugin_unregister"); // register hub internals internals->unregister = unregister_f; internals->hub = hub; internals->callback_data = plugin_callback_data_create(); // setup callback functions, where the plugin can contact the hub. plugin_register_callback_functions(handle); if (register_f && unregister_f) { ret = register_f(handle, config); if (ret == 0) { if (handle->plugin_api_version == PLUGIN_API_VERSION && handle->plugin_funcs_size == sizeof(struct plugin_funcs)) { LOG_INFO("Loaded plugin: %s: %s, version %s.", filename, handle->name, handle->version); LOG_PLUGIN("Plugin API version: %d (func table size: " PRINTF_SIZE_T ")", handle->plugin_api_version, handle->plugin_funcs_size); return handle; } else { LOG_ERROR("Unable to load plugin: %s - API version mistmatch", filename); } } else { LOG_ERROR("Unable to load plugin: %s - Failed to initialize: %s", filename, handle->error_msg); } } plugin_close(plugin); hub_free(handle); return NULL; }
static struct chat_history_data* parse_config(const char* line, struct plugin_handle* plugin) { struct chat_history_data* data = (struct chat_history_data*) hub_malloc_zero(sizeof(struct chat_history_data)); struct cfg_tokens* tokens = cfg_tokenize(line); char* token = cfg_token_get_first(tokens); uhub_assert(data != NULL); data->history_max = 200; data->history_default = 25; data->history_connect = 5; data->chat_history = list_create(); while (token) { struct cfg_settings* setting = cfg_settings_split(token); if (!setting) { set_error_message(plugin, "Unable to parse startup parameters"); cfg_tokens_free(tokens); hub_free(data); return 0; } if (strcmp(cfg_settings_get_key(setting), "history_max") == 0) { data->history_max = (size_t) uhub_atoi(cfg_settings_get_value(setting)); } else if (strcmp(cfg_settings_get_key(setting), "history_default") == 0) { data->history_default = (size_t) uhub_atoi(cfg_settings_get_value(setting)); } else if (strcmp(cfg_settings_get_key(setting), "history_connect") == 0) { data->history_connect = (size_t) uhub_atoi(cfg_settings_get_value(setting)); } else { set_error_message(plugin, "Unknown startup parameters given"); cfg_tokens_free(tokens); cfg_settings_free(setting); hub_free(data); return 0; } cfg_settings_free(setting); token = cfg_token_get_next(tokens); } cfg_tokens_free(tokens); return data; }
int plugin_register(struct plugin_handle* plugin, const char* config) { struct topic_plugin_data* data = (struct topic_plugin_data*) hub_malloc(sizeof(struct topic_plugin_data)); data->topic = (struct plugin_command_handle*) hub_malloc_zero(sizeof(struct plugin_command_handle)); data->resettopic = (struct plugin_command_handle*) hub_malloc_zero(sizeof(struct plugin_command_handle)); data->showtopic = (struct plugin_command_handle*) hub_malloc_zero(sizeof(struct plugin_command_handle)); PLUGIN_INITIALIZE(plugin, "Topic plugin", "1.0", "Add commands for changing the hub topic (description)"); PLUGIN_COMMAND_INITIALIZE(data->topic, (void*) data, "topic", "+m", auth_cred_operator, command_topic_handler, "Set new topic"); PLUGIN_COMMAND_INITIALIZE(data->resettopic, (void*) data, "resettopic", "", auth_cred_operator, command_resettopic_handler, "Set topic to default"); PLUGIN_COMMAND_INITIALIZE(data->showtopic, (void*) data, "showtopic", "", auth_cred_guest, command_showtopic_handler, "Shows the current topic"); plugin->hub.command_add(plugin, data->topic); plugin->hub.command_add(plugin, data->resettopic); plugin->hub.command_add(plugin, data->showtopic); plugin->ptr = data; return 0; }
void net_con_set_timeout(struct net_connection* con, int seconds) { if (!con->timeout) { con->timeout = hub_malloc_zero(sizeof(struct timeout_evt)); timeout_evt_initialize(con->timeout, timeout_callback, con); timeout_queue_insert(net_backend_get_timeout_queue(), con->timeout, seconds); } else { timeout_queue_reschedule(net_backend_get_timeout_queue(), con->timeout, seconds); } }
struct net_backend* net_backend_init_epoll(struct net_backend_handler* handler, struct net_backend_common* common) { struct net_backend_epoll* backend; if (getenv("EVENT_NOEPOLL")) return 0; backend = hub_malloc_zero(sizeof(struct net_backend_epoll)); backend->epfd = epoll_create(common->max); if (backend->epfd == -1) { LOG_WARN("Unable to create epoll socket."); hub_free(backend); return 0; } backend->conns = hub_malloc_zero(sizeof(struct net_connection_epoll*) * common->max); backend->common = common; net_backend_set_handlers(handler); return (struct net_backend*) backend; }
struct plugin_handle* plugin_load(const char* filename, const char* config) { plugin_register_f register_f; plugin_unregister_f unregister_f; int ret; struct plugin_handle* handle = hub_malloc_zero(sizeof(struct plugin_handle)); struct uhub_plugin* plugin = plugin_open(filename); if (!plugin) return NULL; if (!handle) { plugin_close(plugin); return NULL; } handle->handle = plugin; register_f = plugin_lookup_symbol(plugin, "plugin_register"); unregister_f = plugin_lookup_symbol(plugin, "plugin_unregister"); if (register_f && unregister_f) { ret = register_f(handle, config); if (ret == 0) { if (handle->plugin_api_version == PLUGIN_API_VERSION && handle->plugin_funcs_size == sizeof(struct plugin_funcs)) { LOG_INFO("Loaded plugin: %s: %s, version %s.", filename, handle->name, handle->version); LOG_TRACE("Plugin API version: %d (func table size: " PRINTF_SIZE_T ")", handle->plugin_api_version, handle->plugin_funcs_size); plugin->unregister = unregister_f; return handle; } else { LOG_ERROR("Unable to load plugin: %s - API version mistmatch", filename); } } else { LOG_ERROR("Unable to load plugin: %s - Failed to initialize: %s", filename, handle->error_msg); } } plugin_close(plugin); hub_free(handle); return NULL; }
static int check_cmd_user(const char* cmd, int status, struct linked_list* list, char* line, int line_count) { char* data; char* data_extra; struct auth_info* info = 0; if (!strncmp(line, cmd, strlen(cmd))) { data = &line[strlen(cmd)]; data_extra = 0; data[0] = '\0'; data++; data = strip_white_space(data); if (!*data) { LOG_FATAL("ACL parse error on line %d", line_count); return -1; } info = hub_malloc_zero(sizeof(struct auth_info)); if (!info) { LOG_ERROR("ACL parse error. Out of memory!"); return -1; } if (strncmp(cmd, "user_", 5) == 0) { data_extra = strrchr(data, ':'); if (data_extra) { data_extra[0] = 0; data_extra++; } } strncpy(info->nickname, data, MAX_NICK_LEN); if (data_extra) strncpy(info->password, data_extra, MAX_PASS_LEN); info->credentials = status; list_append(list, info); LOG_DEBUG("ACL: Added user '%s' (%s)", info->nickname, auth_cred_to_string(info->credentials)); return 1; } return 0; }
static struct acl_data* parse_config(const char* line) { struct acl_data* data = (struct acl_data*) hub_malloc_zero(sizeof(struct acl_data)); struct cfg_tokens* tokens = cfg_tokenize(line); char* token = cfg_token_get_first(tokens); if (!data) return 0; // set defaults data->readonly = 1; data->exclusive = 0; data->users = list_create(); while (token) { char* split = strchr(token, '='); size_t len = strlen(token); size_t key = split ? (split - token) : len; if (key == 4 && strncmp(token, "file", 4) == 0) { if (data->file) hub_free(data->file); data->file = strdup(split + 1); } else if (key == 8 && strncmp(token, "readonly", 8) == 0) { if (!string_to_boolean(split + 1, &data->readonly)) data->readonly = 1; } else if (key == 9 && strncmp(token, "exclusive", 9) == 0) { if (!string_to_boolean(split + 1, &data->exclusive)) data->exclusive = 1; } else { cfg_tokens_free(tokens); free_acl(data); return 0; } token = cfg_token_get_next(tokens); } cfg_tokens_free(tokens); return data; }
static struct sql_data* parse_config(const char* line, struct plugin_handle* plugin) { struct sql_data* data = (struct sql_data*) hub_malloc_zero(sizeof(struct sql_data)); struct cfg_tokens* tokens = cfg_tokenize(line); char* token = cfg_token_get_first(tokens); if (!data) return 0; while (token) { char* split = strchr(token, '='); size_t len = strlen(token); size_t key = split ? (split - token) : len; if (key == 4 && strncmp(token, "file", 4) == 0 && data->db == 0) { if (sqlite3_open(split + 1, &data->db)) { cfg_tokens_free(tokens); hub_free(data); set_error_message(plugin, "Unable to open database file"); return 0; } } else if (key == 9 && strncmp(token, "exclusive", 9) == 0) { if (!string_to_boolean(split + 1, &data->exclusive)) data->exclusive = 1; } else { set_error_message(plugin, "Unable to parse startup parameters"); cfg_tokens_free(tokens); hub_free(data); return 0; } token = cfg_token_get_next(tokens); } cfg_tokens_free(tokens); if (!data->db) { set_error_message(plugin, "No database file is given, use file=<database>"); hub_free(data); return 0; } return data; }
void hub_logout_log(struct hub_info* hub, struct hub_user* user) { struct hub_logout_info* loginfo = hub_malloc_zero(sizeof(struct hub_logout_info)); if (!loginfo) return; loginfo->time = time(NULL); memcpy(loginfo->cid, user->id.cid, sizeof(loginfo->cid)); memcpy(loginfo->nick, user->id.nick, sizeof(loginfo->nick)); memcpy(&loginfo->addr, &user->id.addr, sizeof(struct ip_addr_encap)); loginfo->reason = user->quit_reason; list_append(hub->logout_info, loginfo); while (list_size(hub->logout_info) > (size_t) hub->config->max_logout_log) { list_remove_first(hub->logout_info, hub_free); } }
void hub_plugins_load(struct hub_info* hub) { if (!hub->config->file_plugins || !*hub->config->file_plugins) return; hub->plugins = hub_malloc_zero(sizeof(struct uhub_plugins)); if (!hub->plugins) return; if (plugin_initialize(hub->config, hub->plugins) < 0) { hub_free(hub->plugins); hub->plugins = 0; return; } }
struct hub_probe* probe_create(struct hub_info* hub, int sd, struct ip_addr_encap* addr) { struct hub_probe* probe = (struct hub_probe*) hub_malloc_zero(sizeof(struct hub_probe)); if (probe == NULL) return NULL; /* OOM */ LOG_TRACE("probe_create(): %p", probe); probe->hub = hub; probe->connection = net_con_create(); net_con_initialize(probe->connection, sd, probe_net_event, probe, NET_EVENT_READ); net_con_set_timeout(probe->connection, TIMEOUT_CONNECTED); memcpy(&probe->addr, addr, sizeof(struct ip_addr_encap)); return probe; }
static int net_connect_job_schedule(struct net_connect_handle* handle, struct ip_addr_encap* addr) { struct net_connect_job* job; struct sockaddr_in* addr4; struct sockaddr_in6* addr6; if (addr->af == AF_INET6 && !net_is_ipv6_supported()) { LOG_TRACE("net_connect_job_schedule(): Skipping IPv6 support since IPv6 is not supported."); return 0; } else { job = hub_malloc_zero(sizeof(struct net_connect_job)); job->handle = handle; if (addr->af == AF_INET6) { addr6 = (struct sockaddr_in6*) &job->addr; LOG_TRACE("net_connect_job_schedule(): Scheduling IPv6 connect job."); addr6->sin6_family = AF_INET6; addr6->sin6_port = htons(handle->port); memcpy(&addr6->sin6_addr, &addr->internal_ip_data.in6, sizeof(struct in6_addr)); // prepend job->next = handle->job6; handle->job6 = job; } else { addr4 = (struct sockaddr_in*) &job->addr; LOG_TRACE("net_connect_job_schedule(): Scheduling IPv4 connect job."); addr4->sin_family = AF_INET; addr4->sin_port = htons(handle->port); memcpy(&addr4->sin_addr, &addr->internal_ip_data.in, sizeof(struct in_addr)); // prepend job->next = handle->job4; handle->job4 = job; } } return 1; }
int event_queue_initialize(struct event_queue** queue, event_queue_callback callback, void* ptr) { *queue = (struct event_queue*) hub_malloc_zero(sizeof(struct event_queue)); if (!(*queue)) return -1; (*queue)->q1 = list_create(); (*queue)->q2 = list_create(); if (!(*queue)->q1 || !(*queue)->q2) { list_destroy((*queue)->q1); list_destroy((*queue)->q2); return -1; } (*queue)->callback = callback; (*queue)->callback_data = ptr; return 0; }
struct net_connect_handle* net_con_connect(const char* address, uint16_t port, net_connect_cb callback, void* ptr) { struct net_connect_handle* handle = hub_malloc_zero(sizeof(struct net_connect_handle)); handle->address = hub_strdup(address); handle->port = port; handle->ptr = ptr; handle->callback = callback; // FIXME: Check if DNS resolving is necessary ? handle->dns = net_dns_gethostbyname(address, AF_UNSPEC, net_con_connect_dns_callback, handle); if (!handle->dns) { LOG_TRACE("net_con_connect(): Unable to create DNS lookup job."); hub_free((char*) handle->address); hub_free(handle); return NULL; } return handle; }
struct sid_pool* sid_pool_create(sid_t max) { struct sid_pool* pool = hub_malloc(sizeof(struct sid_pool)); if (!pool) return 0; pool->min = 1; pool->max = max + 1; pool->count = 0; pool->map = hub_malloc_zero(sizeof(struct hub_user*) * pool->max); if (!pool->map) { hub_free(pool); return 0; } pool->map[0] = (struct hub_user*) pool; /* hack to reserve the first sid. */ #ifdef DEBUG_SID LOG_DUMP("SID_POOL: max=%d", (int) pool->max); #endif return pool; }
struct uhub_plugin* plugin_open(const char* filename) { LOG_TRACE("plugin_open: \"%s\"", filename); #ifdef HAVE_DLOPEN struct uhub_plugin* plugin = (struct uhub_plugin*) hub_malloc_zero(sizeof(struct uhub_plugin)); if (!plugin) { return 0; } plugin->handle = dlopen(filename, RTLD_LAZY); if (!plugin->handle) { LOG_ERROR("Unable to open plugin %s: %s", filename, dlerror()); hub_free(plugin); return 0; } return plugin; #else return 0; #endif }
/** * Create a new SSL context. */ struct ssl_context_handle* net_ssl_context_create(const char* tls_version, const char* tls_ciphersuite) { struct net_context_openssl* ctx = (struct net_context_openssl*) hub_malloc_zero(sizeof(struct net_context_openssl)); const SSL_METHOD* ssl_method = get_ssl_method(tls_version); if (!ssl_method) { hub_free(ctx); return 0; } ctx->ssl = SSL_CTX_new(ssl_method); /* Disable SSLv2 */ SSL_CTX_set_options(ctx->ssl, SSL_OP_NO_SSLv2); // FIXME: Why did we need this again? SSL_CTX_set_quiet_shutdown(ctx->ssl, 1); #ifdef SSL_OP_NO_COMPRESSION /* Disable compression */ LOG_TRACE("Disabling SSL compression."); /* "CRIME" attack */ SSL_CTX_set_options(ctx->ssl, SSL_OP_NO_COMPRESSION); #endif /* Set preferred cipher suite */ if (SSL_CTX_set_cipher_list(ctx->ssl, tls_ciphersuite) != 1) { LOG_ERROR("Unable to set cipher suite."); SSL_CTX_free(ctx->ssl); hub_free(ctx); return 0; } return (struct ssl_context_handle*) ctx; }