early external data API work

1 files changed, 229 insertions, 3 deletions

diff --git a/src/openssl.c b/src/openssl.c
index c1b5436..4e0b898 100644
--- a/src/openssl.c
+++ b/src/openssl.c
@@ -87,6 +87,10 @@
 #define HAVE_SSL_CTX_SET_ALPN_PROTOS (OPENSSL_VERSION_NUMBER >= 0x1000200fL)
 #endif
 
+#ifndef HAVE_SSL_CTX_SET_ALPN_SELECT_CB
+#define HAVE_SSL_CTX_SET_ALPN_SELECT_CB HAVE_SSL_CTX_SET_ALPN_PROTOS
+#endif
+
 #ifndef HAVE_SSL_SET_ALPN_PROTOS
 #define HAVE_SSL_SET_ALPN_PROTOS HAVE_SSL_CTX_SET_ALPN_PROTOS
 #endif
@@ -99,6 +103,25 @@
 #define STRERROR_R_CHAR_P (defined __GLIBC__ && (_GNU_SOURCE || !(_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600)))
 #endif
 
+#ifndef LIST_HEAD
+#define LIST_HEAD(name, type) struct name { struct type *lh_first; }
+#define LIST_ENTRY(type) struct { struct type *le_next, **le_prev; }
+#define LIST_INIT(head) do { LIST_FIRST((head)) = NULL; } while (0)
+#define LIST_FIRST(head) ((head)->lh_first)
+#define LIST_NEXT(elm, field) ((elm)->field.le_next)
+#define LIST_REMOVE(elm, field) do { \
+	if (LIST_NEXT((elm), field) != NULL) \
+		LIST_NEXT((elm), field)->field.le_prev = (elm)->field.le_prev; \
+	*(elm)->field.le_prev = LIST_NEXT((elm), field); \
+} while (0)
+#define LIST_INSERT_HEAD(head, elm, field) do {
+	if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \
+		LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field); \
+	LIST_FIRST((head)) = (elm); \
+	(elm)->field.le_prev = &LIST_FIRST((head)); \
+} while (0)
+#endif
+
 #define BIGNUM_CLASS     "BIGNUM*"
 #define PKEY_CLASS       "EVP_PKEY*"
 #define X509_NAME_CLASS  "X509_NAME*"
@@ -581,6 +604,173 @@ static void *compat_EVP_PKEY_get0(EVP_PKEY *key) {
 #endif
 
 
+struct ex_state {
+	lua_State *mainthread;
+	LIST_HEAD(, ex_data) data;
+}; /* struct ex_state */
+
+struct ex_data {
+	struct ex_state *state;
+	int refs;
+	int arg[4];
+	LIST_ENTRY(ex_data) le;
+}; /* struct ex_data */
+
+enum {
+	EX_SSL_CTX_ALPN_SELECT_CB,
+};
+
+static struct ex_type {
+	int class_index;
+	int index;
+	void *(*get_ex_data)();
+	int (*set_ex_data)();
+} ex_type[] = {
+	[EX_SSL_CTX_ALPN_SELECT_CB] = { CRYPTO_EX_INDEX_SSL_CTX, -1, &SSL_CTX_get_ex_data, &SSL_CTX_set_ex_data },
+};
+
+static int ex_data_dup(CRYPTO_EX_DATA *to NOTUSED, CRYPTO_EX_DATA *from NOTUSED, void *from_d, int idx NOTUSED, long argl NOTUSED, void *argp NOTUSED) {
+	struct ex_data **data = from_d;
+
+	if (*data)
+		(*data)->refs++;
+
+	return 1;
+} /* ex_data_dup() */
+
+static void ex_data_free(void *parent NOTUSED, void *_data, CRYPTO_EX_DATA *ad NOTUSED, int idx NOTUSED, long argl NOTUSED, void *argp NOTUSED) {
+	struct ex_data *data = _data;
+
+	if (!data || --data->refs > 0)
+		return;
+
+	if (data->state)
+		LIST_REMOVE(data, le);
+
+	free(data);
+} /* ex_data_free() */
+
+static int ex_initonce(void) {
+	struct ex_type *type;
+
+	for (type = ex_type; type < endof(ex_type); type++) {
+		if (-1 == (type->index = CRYPTO_get_ex_new_index(type->class_index, 0, NULL, NULL, &ex_data_dup, &ex_data_free)))
+			return -1;
+	};
+
+	return 0;
+} /* ex_initonce() */
+
+static int ex__gc(lua_State *L) {
+	struct ex_state *state = lua_touserdata(L, 1);
+	struct ex_data *data;
+
+	if (!state)
+		return 0;
+
+	/* invalidate back references to Lua state */
+	for (data = LIST_FIRST(&state->data); data; data = LIST_NEXT(data, le)) {
+		data->state = NULL;
+	}
+
+	return 0;
+} /* ex__gc() */
+
+static void ex_init(lua_State *L) {
+	struct ex_state *state;
+	struct lua_State *thr;
+
+	state = prepudata(L, sizeof *state, NULL, &ex__gc);
+	LIST_INIT(&state->data);
+
+#if defined LUA_RIDX_MAINTHREAD
+	lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_MAINTHREAD);
+	state->mainthread = lua_tothread(L, -1);
+	lua_pop(L, 1);
+#else
+	lua_pushvalue(L, -1);
+	thr = lua_newthread(L);
+	lua_settable(L, LUA_REGISTRYINDEX);
+	state->mainthread = thr;
+#endif
+
+	lua_pushcfunction(L, &ex__gc);
+	lua_pushvalue(L, -2);
+	lua_settable(L, LUA_REGISTRYINDEX);
+
+	lua_pop(L, 1);
+} /* ex_init() */
+
+static struct ex_state *ex_get(lua_State *L) {
+	struct ex_state *state;
+
+	lua_pushcfunction(L, &ex__gc);
+	lua_gettable(L, LUA_REGISTRYINDEX);
+
+	luaL_checktype(L, -1, LUA_TUSERDATA);
+	state = lua_touserdata(L, -1);
+	lua_pop(L, 1);
+
+	return state;
+} /* ex_get() */
+
+static int ex_data_get(lua_State **L, int _type, void *obj) {
+	struct ex_type *type = &ex_type[_type];
+	struct ex_data *data;
+	int i;
+
+	if (!(data = type->get_ex_data(obj, type->index)))
+		return 0;
+	if (!data->state)
+		return 0;
+
+	if (!*L)
+		*L = data->state->mainthread;
+
+	for (i = 0; i < (int)countof(data->arg); i++) {
+		lua_rawgeti(*L, LUA_REGISTRYINDEX, data->arg[i]);
+	}
+
+	return i;
+} /* ex_data_get() */
+
+static int ex_data_set(lua_State *L, int _type, void *obj, int n) {
+	struct ex_type *type = &ex_type[_type];
+	struct ex_state *state;
+	struct ex_data *data;
+	int i, j;
+
+	if ((data = type->get_ex_data(obj, type->index)) && data->state) {
+		for (i = 0; i < (int)countof(data->arg); i++) {
+			luaL_unref(L, LUA_REGISTRYINDEX, data->arg[i]);
+			data->arg[i] = LUA_NOREF;
+		}
+	} else {
+		state = ex_get(L);
+
+		if (!(data = malloc(sizeof *data)))
+			return errno;
+
+		if (!type->set_ex_data(obj, type->index, data))
+			return -1;
+
+		data->state = state;
+		data->refs = 1;
+		for (i = 0; i < (int)countof(data->arg); i++)
+			data->arg[i] = LUA_NOREF;
+		LIST_INSERT_HEAD(&state->data, data, le);
+	}
+
+	for (i = n, j = 0; i > 0 && j < (int)countof(data->arg); i--, j++) {
+		lua_pushvalue(L, -i);
+		data->arg[j] = luaL_ref(L, LUA_REGISTRYINDEX);
+	}
+
+	lua_pop(L, n);
+
+	return 0;
+} /* ex_data_set() */
+
 static void initall(lua_State *L);
 
 
@@ -4609,6 +4799,32 @@ static int sx_setAlpnProtos(lua_State *L) {
 } /* sx_setAlpnProtos() */
 #endif
 
+#if HAVE_SSL_CTX_SET_ALPN_SELECT_CB
+static int sx_setAlpnSelect_cb(SSL *ssl, const unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg) {
+	lua_State *L = NULL;
+	int n;
+
+	n = ex_data_get(&L, EX_SSL_CTX_ALPN_SELECT_CB, ssl);
+
+	return 0;
+} /* sx_setAlpnSelect_cb() */
+
+static int sx_setAlpnSelect(lua_State *L) {
+	SSL_CTX *ctx = checksimple(L, 1, SSL_CTX_CLASS);
+	struct ex_data *data;
+	int error;
+
+	luaL_checktype(L, 2, LUA_TFUNCTION);
+	error = ex_data_set(L, EX_SSL_CTX_ALPN_SELECT_CB, ctx, 1);
+
+	SSL_CTX_set_alpn_select_cb(ctx, &sx_setAlpnSelect_cb, NULL);
+
+	lua_pushboolean(L, 1);
+
+	return 1;
+} /* sx_setAlpnSelect() */
+#endif
+
 
 static int sx__gc(lua_State *L) {
 	SSL_CTX **ud = luaL_checkudata(L, 1, SSL_CTX_CLASS);
@@ -5803,7 +6019,7 @@ int luaopen__openssl_des(lua_State *L) {
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #ifndef HAVE_DLADDR
-#define HAVE_DLADDR (!defined _AIX)
+#define HAVE_DLADDR (!defined _AIX) /* TODO: https://root.cern.ch/drupal/content/aix-and-dladdr */
 #endif
 
 static struct {
@@ -5847,8 +6063,8 @@ static unsigned long mt_gettid(void) {
 	return _lwp_self();
 #else
 	/*
-	 * pthread_t is an integer on Solaris and Linux, and a unique pointer
-	 * on OpenBSD.
+	 * pthread_t is an integer on Solaris and Linux, an unsigned integer
+	 * on AIX, and a unique pointer on OpenBSD.
 	 */
 	return (unsigned long)pthread_self();
 #endif
@@ -5940,10 +6156,20 @@ static void initall(lua_State *L) {
 		 * already been configured.
 		 */
 		OPENSSL_config(NULL);
+
+		if ((error = ex_initonce())) {
+			if (error == -1) {
+				throwssl(L, "openssl.init");
+			} else {
+				luaL_error(L, "openssl.init: %s", xstrerror(error));
+			}
+		}
 	}
 
 	pthread_mutex_unlock(&mutex);
 
+	ex_init(L);
+
 	addclass(L, BIGNUM_CLASS, bn_methods, bn_metatable);
 	addclass(L, PKEY_CLASS, pk_methods, pk_metatable);
 	addclass(L, X509_NAME_CLASS, xn_methods, xn_metatable);