diff options
Diffstat (limited to 'main/lua-ldbus/0001-fix-lua_State-usage-for-callbacks.patch')
| -rw-r--r-- | main/lua-ldbus/0001-fix-lua_State-usage-for-callbacks.patch | 612 |
1 files changed, 612 insertions, 0 deletions
diff --git a/main/lua-ldbus/0001-fix-lua_State-usage-for-callbacks.patch b/main/lua-ldbus/0001-fix-lua_State-usage-for-callbacks.patch new file mode 100644 index 0000000000..f62b5a22ad --- /dev/null +++ b/main/lua-ldbus/0001-fix-lua_State-usage-for-callbacks.patch @@ -0,0 +1,612 @@ +From 09fd539b42fd74e13b46970b8718f11bebbb23c2 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Timo=20Ter=C3=A4s?= <timo.teras@iki.fi> +Date: Thu, 15 Oct 2015 13:44:00 +0300 +Subject: [PATCH] fix lua_State usage for callbacks + +We cannot store the lua_State at callback registration time, as that +lua coroutine might've been GC'ed at the callback invocation time. + +This patch solves it by storing the invoking lua_State before calling +any dbus function that might call the callbacks. The callbacks are +then executed in the lua_State which called the dbus method invoking +the callback. + +As side effect, we need to only track the lua reference for callbacks, +and avoid one malloc/free pair. +--- + src/connection.c | 127 ++++++++++++++++++++++------------------------------- + src/ldbus.c | 20 +++++++++ + src/ldbus.h | 23 +++++++--- + src/pending_call.c | 26 ++++------- + src/timeout.c | 26 +++-------- + src/timeout.h | 4 +- + src/watch.c | 28 +++--------- + src/watch.h | 4 +- + 8 files changed, 115 insertions(+), 143 deletions(-) + +diff --git a/src/connection.c b/src/connection.c +index 8bbe74b..3c71034 100644 +--- a/src/connection.c ++++ b/src/connection.c +@@ -46,10 +46,10 @@ static int ldbus_connection_gc(lua_State *L) { + If you dbus_connection_unref() for the last time without closing the connection, + the results are undefined + */ +- dbus_connection_close(udata->connection); ++ ldbus_call(L, dbus_connection_close(udata->connection)); + } + +- dbus_connection_unref(udata->connection); ++ ldbus_call(L, dbus_connection_unref(udata->connection)); + + return 0; + } +@@ -96,7 +96,7 @@ static int ldbus_connection_send(lua_State *L) { + DBusMessage *message = check_DBusMessage(L, 2); + + unsigned int serial; +- lua_pushboolean(L, dbus_connection_send(connection, message, &serial)); ++ lua_pushboolean(L, ldbus_wrap(L, dbus_connection_send(connection, message, &serial))); + lua_pushinteger(L, serial); + + return 2; +@@ -108,7 +108,7 @@ static int ldbus_connection_send_with_reply(lua_State *L) { + int timeout_milliseconds = lua_isnoneornil(L, 3) ? (-1) : (luaL_checknumber(L, 3) * 1000); + + DBusPendingCall *pending; +- if (!dbus_connection_send_with_reply(connection, message, &pending, timeout_milliseconds)) { ++ if (!ldbus_wrap(L, dbus_connection_send_with_reply(connection, message, &pending, timeout_milliseconds))) { + return luaL_error(L, LDBUS_NO_MEMORY); + } + +@@ -123,7 +123,7 @@ static int ldbus_connection_send_with_reply_and_block(lua_State *L) { + DBusMessage *reply; + DBusError error; + dbus_error_init(&error); +- reply = dbus_connection_send_with_reply_and_block(connection, message, timeout_milliseconds, &error); ++ reply = ldbus_wrap(L, dbus_connection_send_with_reply_and_block(connection, message, timeout_milliseconds, &error)); + if (dbus_error_is_set(&error)) { + lua_pushnil(L); + lua_pushstring(L, error.message); +@@ -147,7 +147,7 @@ static int ldbus_connection_read_write_dispatch(lua_State *L) { + DBusConnection *connection = check_DBusConnection(L, 1); + int timeout_milliseconds = luaL_optinteger(L, 2, -1); + +- lua_pushboolean(L, dbus_connection_read_write_dispatch(connection, timeout_milliseconds)); ++ lua_pushboolean(L, ldbus_wrap(L, dbus_connection_read_write_dispatch(connection, timeout_milliseconds))); + + return 1; + } +@@ -156,7 +156,7 @@ static int ldbus_connection_read_write(lua_State *L) { + DBusConnection *connection = check_DBusConnection(L, 1); + int timeout_milliseconds = luaL_optinteger(L, 2, -1); + +- lua_pushboolean(L, dbus_connection_read_write(connection, timeout_milliseconds)); ++ lua_pushboolean(L, ldbus_wrap(L, dbus_connection_read_write(connection, timeout_milliseconds))); + + return 1; + } +@@ -164,7 +164,7 @@ static int ldbus_connection_read_write(lua_State *L) { + static int ldbus_connection_pop_message(lua_State *L) { + DBusConnection *connection = check_DBusConnection(L, 1); + +- DBusMessage *message = dbus_connection_pop_message(connection); ++ DBusMessage *message = ldbus_wrap(L, dbus_connection_pop_message(connection)); + + if (message == NULL) { + lua_pushnil(L); +@@ -183,16 +183,15 @@ static int ldbus_connection_get_dispatch_status(lua_State *L) { + + static int ldbus_connection_dispatch(lua_State *L) { + DBusConnection *connection = check_DBusConnection(L, 1); +- +- lua_pushstring(L, DispatchStatus_lst [ dbus_connection_dispatch(connection) ]); ++ lua_pushstring(L, DispatchStatus_lst [ ldbus_wrap(L, dbus_connection_dispatch(connection)) ]); + return 1; + } + + static int ldbus_connection_set_watch_functions(lua_State *L) { +- ldbus_watch_udata *data; +- + DBusConnection *connection = check_DBusConnection(L, 1); + int has_toggle = lua_isnil(L, 4); ++ intptr_t ref; ++ + lua_settop(L, 4); + /* Place a table below the 3 callback argument */ + lua_createtable(L, 0, 3); +@@ -206,25 +205,22 @@ static int ldbus_connection_set_watch_functions(lua_State *L) { + luaL_requiref(L, "ldbus.watch", luaopen_ldbus_watch, FALSE); + lua_pop(L, 1); + +- if ((data = malloc(sizeof(ldbus_watch_udata))) == NULL) return luaL_error(L, LDBUS_NO_MEMORY); +- data->L = L; +- data->ref = luaL_ref(L, LUA_REGISTRYINDEX); +- +- if (!dbus_connection_set_watch_functions(connection, ++ ref = luaL_ref(L, LUA_REGISTRYINDEX); ++ if (!ldbus_wrap(L, dbus_connection_set_watch_functions(connection, + ldbus_watch_add_function, ldbus_watch_remove_function, + has_toggle ? NULL : ldbus_watch_toggled_function, +- (void *)data, ldbus_watch_free_data_function)) { +- free(data); ++ (void *) ref, ldbus_watch_free_data_function))) { ++ luaL_unref(L, LUA_REGISTRYINDEX, ref); + return luaL_error(L, LDBUS_NO_MEMORY); +- }; ++ } + lua_pushboolean(L, TRUE); + return 1; + } + + static int ldbus_connection_set_timeout_functions(lua_State *L) { +- ldbus_timeout_udata *data; +- + DBusConnection *connection = check_DBusConnection(L, 1); ++ intptr_t ref; ++ + lua_settop(L, 4); + /* Place a table below the 3 callback argument */ + lua_createtable(L, 0, 3); +@@ -238,52 +234,41 @@ static int ldbus_connection_set_timeout_functions(lua_State *L) { + luaL_requiref(L, "ldbus.timeout", lua_open_ldbus_timeout, FALSE); + lua_pop(L, 1); + +- if ((data = malloc(sizeof(ldbus_timeout_udata))) == NULL) return luaL_error(L, LDBUS_NO_MEMORY); +- data->L = L; +- data->ref = luaL_ref(L, LUA_REGISTRYINDEX); +- +- if (!dbus_connection_set_timeout_functions(connection, ++ ref = luaL_ref(L, LUA_REGISTRYINDEX); ++ if (!ldbus_wrap(L, dbus_connection_set_timeout_functions(connection, + ldbus_timeout_add_function, ldbus_timeout_remove_function, ldbus_timeout_toggled_function, +- (void *)data, ldbus_timeout_free_data_function)) { +- free(data); ++ (void *)ref, ldbus_timeout_free_data_function))) { ++ luaL_unref(L, LUA_REGISTRYINDEX, ref); + return luaL_error(L, LDBUS_NO_MEMORY); + }; + lua_pushboolean(L, TRUE); + return 1; + } + +-static void free_data_function(void *data) { +- lua_State *L = ((ldbus_callback_udata*)data)->L; +- int ref = ((ldbus_callback_udata*)data)->ref; +- luaL_unref(L, LUA_REGISTRYINDEX, ref); +- free(data); +-} +- + static void wakeup_main_function(void *data) { +- lua_State *L = ((ldbus_callback_udata*)data)->L; +- int ref = ((ldbus_callback_udata*)data)->ref; ++ lua_State *L = ldbus_get_state(); ++ intptr_t ref = (intptr_t) data; ++ + lua_rawgeti(L, LUA_REGISTRYINDEX, ref); + lua_pcall(L, 0, 0, 0); + } + + static int ldbus_connection_set_wakeup_main_function(lua_State *L) { + DBusConnection *connection = check_DBusConnection(L, 1); +- ldbus_callback_udata *data; ++ intptr_t ref; ++ + luaL_checktype(L, 2, LUA_TFUNCTION); + lua_settop(L, 2); +- if ((data = malloc(sizeof(ldbus_callback_udata))) == NULL) { +- return luaL_error(L, LDBUS_NO_MEMORY); +- } +- data->L = L; +- data->ref = luaL_ref(L, LUA_REGISTRYINDEX); +- dbus_connection_set_wakeup_main_function(connection, wakeup_main_function, data, free_data_function); ++ ref = luaL_ref(L, LUA_REGISTRYINDEX); ++ dbus_connection_set_wakeup_main_function(connection, wakeup_main_function, (void*) ref, ldbus_free_ref); + lua_pushboolean(L, 1); + return 1; + } + + static void dispatch_status_function(DBusConnection *connection, DBusDispatchStatus new_status, void *data) { +- lua_State *L = ((ldbus_callback_udata*)data)->L; +- int ref = ((ldbus_callback_udata*)data)->ref; ++ lua_State *L = ldbus_get_state(); ++ intptr_t ref = (intptr_t) data; ++ + UNUSED(connection); + lua_rawgeti(L, LUA_REGISTRYINDEX, ref); + lua_pushstring(L, DispatchStatus_lst[new_status]); +@@ -292,15 +277,12 @@ static void dispatch_status_function(DBusConnection *connection, DBusDispatchSta + + static int ldbus_connection_set_dispatch_status_function(lua_State *L) { + DBusConnection *connection = check_DBusConnection(L, 1); +- ldbus_callback_udata *data; ++ intptr_t ref; ++ + luaL_checktype(L, 2, LUA_TFUNCTION); + lua_settop(L, 2); +- if ((data = malloc(sizeof(ldbus_callback_udata))) == NULL) { +- return luaL_error(L, LDBUS_NO_MEMORY); +- } +- data->L = L; +- data->ref = luaL_ref(L, LUA_REGISTRYINDEX); +- dbus_connection_set_dispatch_status_function(connection, dispatch_status_function, data, free_data_function); ++ ref = luaL_ref(L, LUA_REGISTRYINDEX); ++ dbus_connection_set_dispatch_status_function(connection, dispatch_status_function, (void *) ref, ldbus_free_ref); + lua_pushboolean(L, 1); + return 1; + } +@@ -356,16 +338,17 @@ static int ldbus_connection_has_messages_to_send(lua_State *L) { + } + + static void unregister_function(DBusConnection *connection, void *data) { +- lua_State *L = ((ldbus_callback_udata*)data)->L; +- int ref = ((ldbus_callback_udata*)data)->ref; ++ lua_State *L = ldbus_get_state(); ++ intptr_t ref = (intptr_t) data; ++ + UNUSED(connection); + luaL_unref(L, LUA_REGISTRYINDEX, ref); +- free(data); + } + + static DBusHandlerResult message_function(DBusConnection *connection, DBusMessage *message, void *data) { +- lua_State *L = ((ldbus_callback_udata*)data)->L; +- int ref = ((ldbus_callback_udata*)data)->ref; ++ lua_State *L = ldbus_get_state(); ++ intptr_t ref = (intptr_t) data; ++ + UNUSED(connection); + if (!lua_checkstack(L, 2)) { + return DBUS_HANDLER_RESULT_NEED_MEMORY; +@@ -396,16 +379,13 @@ static const DBusObjectPathVTable VTable = { + static int ldbus_connection_register_object_path(lua_State *L) { + DBusConnection *connection = check_DBusConnection(L, 1); + const char *path = luaL_checkstring(L, 2); +- ldbus_callback_udata *data; ++ intptr_t ref; ++ + luaL_checktype(L, 3, LUA_TFUNCTION); + lua_settop(L, 3); +- if ((data = malloc(sizeof(ldbus_callback_udata))) == NULL) { +- return luaL_error(L, LDBUS_NO_MEMORY); +- } +- data->L = L; +- data->ref = luaL_ref(L, LUA_REGISTRYINDEX); +- if (!dbus_connection_register_object_path(connection, path, &VTable, data)) { +- free(data); ++ ref = luaL_ref(L, LUA_REGISTRYINDEX); ++ if (!dbus_connection_register_object_path(connection, path, &VTable, (void*) ref)) { ++ luaL_unref(L, LUA_REGISTRYINDEX, ref); + return luaL_error(L, "unknown error"); + } + lua_pushboolean(L, 1); +@@ -415,16 +395,13 @@ static int ldbus_connection_register_object_path(lua_State *L) { + static int ldbus_connection_register_fallback(lua_State *L) { + DBusConnection *connection = check_DBusConnection(L, 1); + const char *path = luaL_checkstring(L, 2); +- ldbus_callback_udata *data; ++ intptr_t ref; ++ + luaL_checktype(L, 3, LUA_TFUNCTION); + lua_settop(L, 3); +- if ((data = malloc(sizeof(ldbus_callback_udata))) == NULL) { +- return luaL_error(L, LDBUS_NO_MEMORY); +- } +- data->L = L; +- data->ref = luaL_ref(L, LUA_REGISTRYINDEX); +- if (!dbus_connection_register_fallback(connection, path, &VTable, data)) { +- free(data); ++ ref = luaL_ref(L, LUA_REGISTRYINDEX); ++ if (!dbus_connection_register_fallback(connection, path, &VTable, (void*) ref)) { ++ luaL_unref(L, LUA_REGISTRYINDEX, ref); + return luaL_error(L, "unknown error"); + } + lua_pushboolean(L, 1); +diff --git a/src/ldbus.c b/src/ldbus.c +index 0ce3333..ab32257 100644 +--- a/src/ldbus.c ++++ b/src/ldbus.c +@@ -12,6 +12,26 @@ + #include "watch.h" + #include "ldbus.h" + ++static __thread lua_State *__ldbus_state; ++ ++lua_State *ldbus_get_state() ++{ ++ return __ldbus_state; ++} ++ ++lua_State *ldbus_set_state(lua_State *L) ++{ ++ lua_State *old = __ldbus_state; ++ __ldbus_state = L; ++ return old; ++} ++ ++void ldbus_free_ref(void *data) { ++ lua_State *L = ldbus_get_state(); ++ intptr_t ref = (intptr_t) data; ++ luaL_unref(L, LUA_REGISTRYINDEX, ref); ++} ++ + int tostring(lua_State *L) { + if (!luaL_getmetafield(L, 1, "__udtype")) { + lua_pushstring(L, "object with a generic __tostring metamethod but no __type metafield"); +diff --git a/src/ldbus.h b/src/ldbus.h +index a33422f..9c01263 100644 +--- a/src/ldbus.h ++++ b/src/ldbus.h +@@ -1,23 +1,36 @@ + #ifndef LDBUS_H + #define LDBUS_H + ++#include <stdint.h> + #include <lua.h> + + #define UNUSED(x) (void)(x) + #define LDBUS_INTERNAL __attribute__ ((visibility ("internal"))) + #define LDBUS_NO_MEMORY "no memory" + +-typedef struct { +- lua_State* L; +- int ref; +-} ldbus_callback_udata; +- + enum ldbus_callback_indexes { + DBUS_LUA_FUNC_ADD, + DBUS_LUA_FUNC_REMOVE, + DBUS_LUA_FUNC_TOGGLE + }; + ++#define ldbus_wrap(L, func) __extension__ ({ \ ++ lua_State *old = ldbus_set_state(L); \ ++ __auto_type result = (func); \ ++ ldbus_set_state(old); \ ++ result; \ ++}) ++ ++#define ldbus_call(L, func) __extension__ ({ \ ++ lua_State *old = ldbus_set_state(L); \ ++ (func); \ ++ ldbus_set_state(old); \ ++}) ++ ++LDBUS_INTERNAL lua_State *ldbus_get_state(); ++LDBUS_INTERNAL lua_State *ldbus_set_state(lua_State *); ++LDBUS_INTERNAL void ldbus_free_ref(void *ref); ++ + LDBUS_INTERNAL int tostring(lua_State *); + + int luaopen_ldbus(lua_State *); +diff --git a/src/pending_call.c b/src/pending_call.c +index 0dbc6ef..98b5d11 100644 +--- a/src/pending_call.c ++++ b/src/pending_call.c +@@ -17,36 +17,28 @@ static DBusPendingCall* checkPendingCall(lua_State *L, int arg) { + + static int ldbus_pending_call_unref(lua_State *L) { + DBusPendingCall* pending = checkPendingCall(L, 1); +- dbus_pending_call_unref(pending); ++ ldbus_call(L, dbus_pending_call_unref(pending)); + return 0; + } + + static void pending_notify_function(DBusPendingCall *pending, void *data) { +- lua_State *L = ((ldbus_callback_udata*)data)->L; +- int ref = ((ldbus_callback_udata*)data)->ref; ++ lua_State *L = ldbus_get_state(); ++ intptr_t ref = (intptr_t) data; ++ + UNUSED(pending); + lua_rawgeti(L, LUA_REGISTRYINDEX, ref); + lua_pcall(L, 0, 0, 0); + } + +-static void free_data_function(void *data) { +- lua_State *L = ((ldbus_callback_udata*)data)->L; +- int ref = ((ldbus_callback_udata*)data)->ref; +- luaL_unref(L, LUA_REGISTRYINDEX, ref); +- free(data); +-} +- + static int ldbus_pending_call_set_notify(lua_State *L) { + DBusPendingCall* pending = checkPendingCall(L, 1); +- ldbus_callback_udata *data; ++ intptr_t ref; ++ + luaL_checktype(L, 2, LUA_TFUNCTION); + lua_settop(L, 2); +- if ((data = malloc(sizeof(ldbus_callback_udata))) == NULL) { +- return luaL_error(L, LDBUS_NO_MEMORY); +- } +- data->L = L; +- data->ref = luaL_ref(L, LUA_REGISTRYINDEX); +- if (!dbus_pending_call_set_notify(pending, pending_notify_function, data, free_data_function)) { ++ ref = luaL_ref(L, LUA_REGISTRYINDEX); ++ if (!ldbus_wrap(L, dbus_pending_call_set_notify(pending, pending_notify_function, (void*) ref, ldbus_free_ref))) { ++ luaL_unref(L, LUA_REGISTRYINDEX, ref); + return luaL_error(L, LDBUS_NO_MEMORY); + } + lua_pushboolean(L, 1); +diff --git a/src/timeout.c b/src/timeout.c +index 573700d..b4cdfe5 100644 +--- a/src/timeout.c ++++ b/src/timeout.c +@@ -27,7 +27,7 @@ static int ldbus_timeout_handle(lua_State *L) { + if (timeout == NULL) { + lua_pushnil(L); + } else { +- lua_pushboolean(L, dbus_timeout_handle(timeout)); ++ lua_pushboolean(L, ldbus_wrap(L, dbus_timeout_handle(timeout))); + } + return 1; + } +@@ -46,8 +46,8 @@ LDBUS_INTERNAL void push_DBusTimeout(lua_State *L, DBusTimeout *timeout) { + } + + LDBUS_INTERNAL dbus_bool_t ldbus_timeout_add_function(DBusTimeout *timeout, void *data) { +- lua_State *L = ((ldbus_timeout_udata*)data)->L; +- int ref = ((ldbus_timeout_udata*)data)->ref; ++ lua_State *L = ldbus_get_state(); ++ intptr_t ref = (intptr_t) data; + + if (!lua_checkstack(L, 4)) return FALSE; + +@@ -63,9 +63,8 @@ LDBUS_INTERNAL dbus_bool_t ldbus_timeout_add_function(DBusTimeout *timeout, void + } + + LDBUS_INTERNAL void ldbus_timeout_remove_function(DBusTimeout *timeout, void *data) { +- lua_State *L = ((ldbus_timeout_udata*)data)->L; +- int ref = ((ldbus_timeout_udata*)data)->ref; +- ++ lua_State *L = ldbus_get_state(); ++ intptr_t ref = (intptr_t) data; + DBusTimeout **udata; + + /* Lookup remove callback from ref in `data` */ +@@ -94,13 +93,11 @@ LDBUS_INTERNAL void ldbus_timeout_remove_function(DBusTimeout *timeout, void *da + if (udata != NULL) { + *udata = NULL; + } +- +- return; + } + + LDBUS_INTERNAL void ldbus_timeout_toggled_function(DBusTimeout *timeout, void *data) { +- lua_State *L = ((ldbus_timeout_udata*)data)->L; +- int ref = ((ldbus_timeout_udata*)data)->ref; ++ lua_State *L = ldbus_get_state(); ++ intptr_t ref = (intptr_t) data; + + /* Lookup remove callback from ref in `data` */ + lua_rawgeti(L, LUA_REGISTRYINDEX, ref); +@@ -114,15 +111,6 @@ LDBUS_INTERNAL void ldbus_timeout_toggled_function(DBusTimeout *timeout, void *d + + /* Call the callback, with looked-up timeout as argument */ + lua_pcall(L, 1, 0, 0); +- return; +-} +- +-LDBUS_INTERNAL void ldbus_timeout_free_data_function(void *data) { +- lua_State *L = ((ldbus_timeout_udata*)data)->L; +- int ref = ((ldbus_timeout_udata*)data)->ref; +- +- luaL_unref(L, LUA_REGISTRYINDEX, ref); +- free(data); + } + + int lua_open_ldbus_timeout(lua_State *L) { +diff --git a/src/timeout.h b/src/timeout.h +index 5794563..4eab6e6 100644 +--- a/src/timeout.h ++++ b/src/timeout.h +@@ -12,13 +12,11 @@ + + #define check_DBusTimeout(L, arg) (*(DBusTimeout **)luaL_checkudata((L), (arg), DBUS_TIMEOUT_METATABLE)) + +-typedef ldbus_callback_udata ldbus_timeout_udata; +- + LDBUS_INTERNAL void push_DBusTimeout(lua_State *L, DBusTimeout *timeout); + LDBUS_INTERNAL dbus_bool_t ldbus_timeout_add_function(DBusTimeout *timeout, void *data); + LDBUS_INTERNAL void ldbus_timeout_remove_function(DBusTimeout *timeout, void *data); + LDBUS_INTERNAL void ldbus_timeout_toggled_function(DBusTimeout *timeout, void *data); +-LDBUS_INTERNAL void ldbus_timeout_free_data_function(void *data); ++#define ldbus_timeout_free_data_function ldbus_free_ref + + int lua_open_ldbus_timeout(lua_State *L); + +diff --git a/src/watch.c b/src/watch.c +index 2773212..173bc96 100644 +--- a/src/watch.c ++++ b/src/watch.c +@@ -42,11 +42,9 @@ static int ldbus_watch_get_flags(lua_State *L) { + static int ldbus_watch_handle(lua_State *L) { + DBusWatch *watch = check_DBusWatch(L, 1); + int flags; +- dbus_bool_t ok; + luaL_argcheck(L, watch != NULL, 1, "watch invalid"); + flags = luaL_checkinteger(L, 2); +- ok = dbus_watch_handle(watch, flags); +- lua_pushboolean(L, ok); ++ lua_pushboolean(L, ldbus_wrap(L, dbus_watch_handle(watch, flags))); + return 1; + } + +@@ -64,8 +62,8 @@ LDBUS_INTERNAL void push_DBusWatch(lua_State *L, DBusWatch *watch) { + } + + LDBUS_INTERNAL dbus_bool_t ldbus_watch_add_function(DBusWatch *watch, void *data) { +- lua_State *L = ((ldbus_watch_udata*)data)->L; +- int ref = ((ldbus_watch_udata*)data)->ref; ++ lua_State *L = ldbus_get_state(); ++ intptr_t ref = (intptr_t) data; + + if (!lua_checkstack(L, 4)) return FALSE; + +@@ -81,9 +79,8 @@ LDBUS_INTERNAL dbus_bool_t ldbus_watch_add_function(DBusWatch *watch, void *data + } + + LDBUS_INTERNAL void ldbus_watch_remove_function(DBusWatch *watch, void *data) { +- lua_State *L = ((ldbus_watch_udata*)data)->L; +- int ref = ((ldbus_watch_udata*)data)->ref; +- ++ lua_State *L = ldbus_get_state(); ++ intptr_t ref = (intptr_t) data; + DBusWatch **udata; + + /* Lookup remove callback from ref in `data` */ +@@ -112,13 +109,11 @@ LDBUS_INTERNAL void ldbus_watch_remove_function(DBusWatch *watch, void *data) { + if (udata != NULL) { + *udata = NULL; + } +- +- return; + } + + LDBUS_INTERNAL void ldbus_watch_toggled_function(DBusWatch *watch, void *data) { +- lua_State *L = ((ldbus_watch_udata*)data)->L; +- int ref = ((ldbus_watch_udata*)data)->ref; ++ lua_State *L = ldbus_get_state(); ++ intptr_t ref = (intptr_t) data; + + /* Lookup remove callback from ref in `data` */ + lua_rawgeti(L, LUA_REGISTRYINDEX, ref); +@@ -132,15 +127,6 @@ LDBUS_INTERNAL void ldbus_watch_toggled_function(DBusWatch *watch, void *data) { + + /* Call the callback, with looked-up watch as argument */ + lua_pcall(L, 1, 0, 0); +- return; +-} +- +-LDBUS_INTERNAL void ldbus_watch_free_data_function(void *data) { +- lua_State *L = ((ldbus_watch_udata*)data)->L; +- int ref = ((ldbus_watch_udata*)data)->ref; +- +- luaL_unref(L, LUA_REGISTRYINDEX, ref); +- free(data); + } + + int luaopen_ldbus_watch(lua_State *L) { +diff --git a/src/watch.h b/src/watch.h +index f37f877..d3abf08 100644 +--- a/src/watch.h ++++ b/src/watch.h +@@ -12,13 +12,11 @@ + + #define check_DBusWatch(L, arg) (*(DBusWatch **)luaL_checkudata((L), (arg), DBUS_WATCH_METATABLE)) + +-typedef ldbus_callback_udata ldbus_watch_udata; +- + LDBUS_INTERNAL void push_DBusWatch(lua_State *L, DBusWatch *watch); + LDBUS_INTERNAL dbus_bool_t ldbus_watch_add_function(DBusWatch *watch, void *data); + LDBUS_INTERNAL void ldbus_watch_remove_function(DBusWatch *watch, void *data); + LDBUS_INTERNAL void ldbus_watch_toggled_function(DBusWatch *watch, void *data); +-LDBUS_INTERNAL void ldbus_watch_free_data_function(void *data); ++#define ldbus_watch_free_data_function ldbus_free_ref + + int luaopen_ldbus_watch(lua_State *L); + +-- +2.6.1 + |