H2O: Another clean-up (#4889)

Also fix the per-thread clean-up by calling the appropriate OpenSSL
functions.

frameworks/C/h2o/h2o.dockerfile

@@ -30,4 +30,4 @@ RUN wget -qO "$H2O_ARCHIVE" "https://github.com/h2o/h2o/archive/$H2O_ARCHIVE" &&
           -DCMAKE_AR=/usr/bin/gcc-ar -DCMAKE_RANLIB=/usr/bin/gcc-ranlib . && \
     make -j "$(nproc)" install
 
-CMD ["./start-servers.sh"]
+CMD ["./h2o.sh"]

frameworks/C/h2o/src/cache.c

@@ -54,7 +54,7 @@ int cache_create(size_t concurrency,
 	pthread_mutexattr_t attr;
 
 	if (pthread_mutexattr_init(&attr))
-		return EXIT_FAILURE;
+		return 1;
 
 	if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP))
 		goto error;
@@ -83,12 +83,12 @@ int cache_create(size_t concurrency,
 	}
 
 	pthread_mutexattr_destroy(&attr);
-	return EXIT_SUCCESS;
+	return 0;
 error_malloc:
 	free(cache->cache);
 error:
 	pthread_mutexattr_destroy(&attr);
-	return EXIT_FAILURE;
+	return 1;
 }
 
 void cache_destroy(cache_t *cache)

frameworks/C/h2o/src/database.c

@@ -93,7 +93,7 @@ static int do_execute_query(db_conn_t *db_conn, bool direct_notification)
 	                                   db_conn->param->paramFormats,
 	                                   db_conn->param->resultFormat) :
 	               PQsendQuery(db_conn->conn, db_conn->param->command);
-	int ret = EXIT_FAILURE;
+	int ret = 1;
 
 	if (ec) {
 		if (db_conn->param->flags & IS_SINGLE_ROW)
@@ -115,7 +115,7 @@ static int do_execute_query(db_conn_t *db_conn, bool direct_notification)
 			on_database_error(db_conn, DB_ERROR);
 		}
 		else {
-			ret = EXIT_SUCCESS;
+			ret = 0;
 
 			if (send_status)
 				h2o_socket_notify_write(db_conn->sock, on_database_write_ready);
@@ -470,7 +470,7 @@ void add_prepared_statement(const char *name, const char *query, list_t **prepar
 
 int execute_query(thread_context_t *ctx, db_query_param_t *param)
 {
-	int ret = EXIT_FAILURE;
+	int ret = 1;
 
 	if (ctx->db_state.free_db_conn_num) {
 		db_conn_t * const db_conn = H2O_STRUCT_FROM_MEMBER(db_conn_t, l, ctx->db_state.db_conn);
@@ -489,7 +489,7 @@ int execute_query(thread_context_t *ctx, db_query_param_t *param)
 			*ctx->db_state.queries.tail = &param->l;
 			ctx->db_state.queries.tail = &param->l.next;
 			ctx->db_state.query_num++;
-			ret = EXIT_SUCCESS;
+			ret = 0;
 		}
 	}
 

frameworks/C/h2o/src/handlers/world.c

@@ -756,9 +756,9 @@ static int serialize_item(uint32_t id, uint32_t random_number, yajl_gen gen)
 	CHECK_YAJL_STATUS(yajl_gen_string, gen, YAJL_STRLIT(RANDOM_NUM_KEY));
 	CHECK_YAJL_STATUS(gen_integer, random_number, buf, sizeof(buf), gen);
 	CHECK_YAJL_STATUS(yajl_gen_map_close, gen);
-	return EXIT_SUCCESS;
+	return 0;
 error_yajl:
-	return EXIT_FAILURE;
+	return 1;
 }
 
 static void serialize_items(const query_result_t *res,

frameworks/C/h2o/src/main.c

@@ -126,13 +126,13 @@ static int initialize_global_data(const config_t *config, global_data_t *global_
 		printf("Number of processors: %zu\nMaximum cache line size: %zu\n",
 		       h2o_numproc(),
 		       global_data->memory_alignment);
-		return EXIT_SUCCESS;
+		return 0;
 	}
 
 error:
 	close(global_data->signal_fd);
 	free_global_data(global_data);
-	return EXIT_FAILURE;
+	return 1;
 }
 
 static int parse_options(int argc, char *argv[], config_t *config)
@@ -158,7 +158,7 @@ static int parse_options(int argc, char *argv[], config_t *config)
 		\
 		if (errno) { \
 			print_library_error(__FILE__, __LINE__, "strtoll", errno); \
-			return EXIT_FAILURE; \
+			return 1; \
 		} \
 		\
 		(out) = n; \
@@ -208,14 +208,14 @@ static int parse_options(int argc, char *argv[], config_t *config)
 				break;
 			default:
 				fprintf(stderr, USAGE_MESSAGE, *argv);
-				return EXIT_FAILURE;
+				return 1;
 
 #undef PARSE_NUMBER
 		}
 	}
 
 	set_default_options(config);
-	return EXIT_SUCCESS;
+	return 0;
 }
 
 static void run_postinitialization_tasks(list_t **tasks, thread_context_t *ctx)
@@ -292,10 +292,10 @@ int main(int argc, char *argv[])
 	config_t config;
 	int rc = EXIT_FAILURE;
 
-	if (parse_options(argc, argv, &config) == EXIT_SUCCESS) {
+	if (!parse_options(argc, argv, &config)) {
 		global_data_t global_data;
 
-		if (initialize_global_data(&config, &global_data) == EXIT_SUCCESS) {
+		if (!initialize_global_data(&config, &global_data)) {
 			thread_context_t ctx;
 
 			setup_process();

frameworks/C/h2o/src/request_handler.c

@@ -135,11 +135,11 @@ int send_json_response(json_generator_t *gen, bool free_gen, h2o_req_t *req)
 {
 	const unsigned char *buf;
 	size_t len;
-	int ret = EXIT_FAILURE;
+	int ret = 1;
 
 	if (yajl_gen_get_buf(gen->gen, &buf, &len) == yajl_gen_status_ok) {
 		set_default_response_param(JSON, len, req);
-		ret = EXIT_SUCCESS;
+		ret = 0;
 
 		if (free_gen) {
 			thread_context_t * const ctx = H2O_STRUCT_FROM_MEMBER(thread_context_t,

frameworks/C/h2o/src/thread.c

@@ -37,6 +37,7 @@
 #include "global_data.h"
 #include "request_handler.h"
 #include "thread.h"
+#include "tls.h"
 #include "utility.h"
 
 static void *run_thread(void *arg);
@@ -101,6 +102,9 @@ void free_thread_context(thread_context_t *ctx)
 			ctx->json_generator = gen->l.next;
 			free_json_generator(gen, NULL, NULL, 0);
 		} while (ctx->json_generator);
+
+	if (ctx->global_data->ssl_ctx)
+		cleanup_openssl_thread_state();
 }
 
 global_thread_data_t *initialize_global_thread_data(const config_t *config,

frameworks/C/h2o/src/tls.c

@@ -131,7 +131,6 @@ void cleanup_openssl(global_data_t *global_data)
 	ERR_free_strings();
 	CONF_modules_unload(1);
 	EVP_cleanup();
-	CRYPTO_cleanup_all_ex_data();
 
 	for (size_t i = 0; i < openssl_global_data.num_lock; i++)
 		CHECK_ERROR(pthread_mutex_destroy, openssl_global_data.lock + i);
@@ -140,6 +139,12 @@ void cleanup_openssl(global_data_t *global_data)
 	CHECK_ERROR(pthread_mutexattr_destroy, &openssl_global_data.lock_attr);
 }
 
+void cleanup_openssl_thread_state(void)
+{
+	ERR_remove_thread_state(NULL);
+	CRYPTO_cleanup_all_ex_data();
+}
+
 void initialize_openssl(const config_t *config, global_data_t *global_data)
 {
 	SSL_library_init();

frameworks/C/h2o/src/tls.h

@@ -24,6 +24,7 @@
 #include "global_data.h"
 
 void cleanup_openssl(global_data_t *global_data);
+void cleanup_openssl_thread_state(void);
 void initialize_openssl(const config_t *config, global_data_t *global_data);
 
 #endif // TLS_H_