Mercurial > pidgin.yaz
view src/signals.c @ 9417:9f6a28af7164
[gaim-migrate @ 10232]
" IDLETRACK.DLL uses Windows hooks to record the last
time the user pressed a key or moved the mouse.
Windows hooks are a bit unfriendly in that they force
the hook DLL into every process - so IDLETRACK.DLL
gets added to every process after Gaim runs. This can
mean that IDLETRACK.DLL doesn't get unloaded when
Gaim stops, which causes a warning about being unable
to write to IDLETRACK.DLL if you then upgrade Gaim.
Further, hooking is a common tactic employed by key
loggers. If the user has a program installed that checks
for global hooks then it will warn the user that Gaim may
contain a key logger.
From Windows 2000 onwards Microsoft introduced an
API function called GetLastInputInfo that returns the
timer tick at the point that the user last pressed a key
or moved the mouse. I have changed idletrack.c so that
it will try to use this if it can, which avoids all the
ugliness of having to use hooks, but it will fall back to
using hooks if the function isn't present.
This patch changes all three exported functions in
idletrack.c.
In wgaim_set_idlehooks it checks to see if
GetLastInputInfo is present. If it is then the address of
the function is recorded and no hooks are set. If it isn't
then we're running on an old verison of Windows and the
hooks are set as per current behaviour.
In wgaim_remove_idlehooks the module handle taken for
USER32.DLL by wgaim_set_idlehooks is released.
In wgaim_get_lastactive the GetLastInputInfo function
is called, if present. If it isn't present then the hooks will
have run and the shared memory they write to will be
read as per current behaviour. Both methods end up
getting the timer tick of the last user activity, which is
returned as per current behaviour." --Andrew Whewell
committer: Tailor Script <tailor@pidgin.im>
author | Luke Schierer <lschiere@pidgin.im> |
---|---|
date | Sun, 27 Jun 2004 22:29:53 +0000 |
parents | f4d981c9c4ab |
children | 1fac0336890c |
line wrap: on
line source
/** * @file signals.c Signal API * @ingroup core * * gaim * * Gaim is the legal property of its developers, whose names are too numerous * to list here. Please refer to the COPYRIGHT file distributed with this * source distribution. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "internal.h" #include "debug.h" #include "signals.h" #include "value.h" /* must include this to use G_VA_COPY */ #include <string.h> typedef struct { void *instance; GHashTable *signals; size_t signal_count; gulong next_signal_id; } GaimInstanceData; typedef struct { gulong id; GaimSignalMarshalFunc marshal; int num_values; GaimValue **values; GaimValue *ret_value; GList *handlers; size_t handler_count; gulong next_handler_id; } GaimSignalData; typedef struct { gulong id; GaimCallback cb; void *handle; void *data; gboolean use_vargs; } GaimSignalHandlerData; static GHashTable *instance_table = NULL; static void destroy_instance_data(GaimInstanceData *instance_data) { g_hash_table_destroy(instance_data->signals); g_free(instance_data); } static void destroy_signal_data(GaimSignalData *signal_data) { GaimSignalHandlerData *handler_data; GList *l; for (l = signal_data->handlers; l != NULL; l = l->next) { handler_data = (GaimSignalHandlerData *)l->data; g_free(l->data); } g_list_free(signal_data->handlers); if (signal_data->values != NULL) { int i; for (i = 0; i < signal_data->num_values; i++) gaim_value_destroy((GaimValue *)signal_data->values[i]); g_free(signal_data->values); } g_free(signal_data); } gulong gaim_signal_register(void *instance, const char *signal, GaimSignalMarshalFunc marshal, GaimValue *ret_value, int num_values, ...) { GaimInstanceData *instance_data; GaimSignalData *signal_data; va_list args; g_return_val_if_fail(instance != NULL, 0); g_return_val_if_fail(signal != NULL, 0); g_return_val_if_fail(marshal != NULL, 0); instance_data = (GaimInstanceData *)g_hash_table_lookup(instance_table, instance); if (instance_data == NULL) { instance_data = g_new0(GaimInstanceData, 1); instance_data->instance = instance; instance_data->next_signal_id = 1; instance_data->signals = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)destroy_signal_data); g_hash_table_insert(instance_table, instance, instance_data); } signal_data = g_new0(GaimSignalData, 1); signal_data->id = instance_data->next_signal_id; signal_data->marshal = marshal; signal_data->next_handler_id = 1; signal_data->ret_value = ret_value; signal_data->num_values = num_values; if (num_values > 0) { int i; signal_data->values = g_new0(GaimValue *, num_values); va_start(args, num_values); for (i = 0; i < num_values; i++) signal_data->values[i] = va_arg(args, GaimValue *); va_end(args); } g_hash_table_insert(instance_data->signals, g_strdup(signal), signal_data); instance_data->next_signal_id++; instance_data->signal_count++; return signal_data->id; } void gaim_signal_unregister(void *instance, const char *signal) { GaimInstanceData *instance_data; g_return_if_fail(instance != NULL); g_return_if_fail(signal != NULL); instance_data = (GaimInstanceData *)g_hash_table_lookup(instance_table, instance); g_return_if_fail(instance_data != NULL); g_hash_table_remove(instance_data->signals, signal); instance_data->signal_count--; if (instance_data->signal_count == 0) { /* Unregister the instance. */ g_hash_table_remove(instance_table, instance); } } void gaim_signals_unregister_by_instance(void *instance) { gboolean found; g_return_if_fail(instance != NULL); found = g_hash_table_remove(instance_table, instance); /* * Makes things easier (more annoying?) for developers who don't have * things registering and unregistering in the right order :) */ g_return_if_fail(found); } void gaim_signal_get_values(void *instance, const char *signal, GaimValue **ret_value, int *num_values, GaimValue ***values) { GaimInstanceData *instance_data; GaimSignalData *signal_data; g_return_if_fail(instance != NULL); g_return_if_fail(signal != NULL); g_return_if_fail(num_values != NULL); g_return_if_fail(values != NULL); /* Get the instance data */ instance_data = (GaimInstanceData *)g_hash_table_lookup(instance_table, instance); g_return_if_fail(instance_data != NULL); /* Get the signal data */ signal_data = (GaimSignalData *)g_hash_table_lookup(instance_data->signals, signal); g_return_if_fail(signal_data != NULL); *num_values = signal_data->num_values; *values = signal_data->values; if (ret_value != NULL) *ret_value = signal_data->ret_value; } static gulong signal_connect_common(void *instance, const char *signal, void *handle, GaimCallback func, void *data, gboolean use_vargs) { GaimInstanceData *instance_data; GaimSignalData *signal_data; GaimSignalHandlerData *handler_data; g_return_val_if_fail(instance != NULL, 0); g_return_val_if_fail(signal != NULL, 0); g_return_val_if_fail(handle != NULL, 0); g_return_val_if_fail(func != NULL, 0); /* Get the instance data */ instance_data = (GaimInstanceData *)g_hash_table_lookup(instance_table, instance); g_return_val_if_fail(instance_data != NULL, 0); /* Get the signal data */ signal_data = (GaimSignalData *)g_hash_table_lookup(instance_data->signals, signal); if (signal_data == NULL) { gaim_debug(GAIM_DEBUG_ERROR, "signals", "Signal data for %s not found!\n", signal); return 0; } /* Create the signal handler data */ handler_data = g_new0(GaimSignalHandlerData, 1); handler_data->id = signal_data->next_handler_id; handler_data->cb = func; handler_data->handle = handle; handler_data->data = data; handler_data->use_vargs = use_vargs; signal_data->handlers = g_list_append(signal_data->handlers, handler_data); signal_data->handler_count++; signal_data->next_handler_id++; return handler_data->id; } gulong gaim_signal_connect(void *instance, const char *signal, void *handle, GaimCallback func, void *data) { return signal_connect_common(instance, signal, handle, func, data, FALSE); } gulong gaim_signal_connect_vargs(void *instance, const char *signal, void *handle, GaimCallback func, void *data) { return signal_connect_common(instance, signal, handle, func, data, TRUE); } void gaim_signal_disconnect(void *instance, const char *signal, void *handle, GaimCallback func) { GaimInstanceData *instance_data; GaimSignalData *signal_data; GaimSignalHandlerData *handler_data; GList *l; gboolean found = FALSE; g_return_if_fail(instance != NULL); g_return_if_fail(signal != NULL); g_return_if_fail(handle != NULL); g_return_if_fail(func != NULL); /* Get the instance data */ instance_data = (GaimInstanceData *)g_hash_table_lookup(instance_table, instance); g_return_if_fail(instance_data != NULL); /* Get the signal data */ signal_data = (GaimSignalData *)g_hash_table_lookup(instance_data->signals, signal); if (signal_data == NULL) { gaim_debug(GAIM_DEBUG_ERROR, "signals", "Signal data for %s not found!\n", signal); return; } /* Find the handler data. */ for (l = signal_data->handlers; l != NULL; l = l->next) { handler_data = (GaimSignalHandlerData *)l->data; if (handler_data->handle == handle && handler_data->cb == func) { g_free(handler_data); signal_data->handlers = g_list_remove(signal_data->handlers, handler_data); signal_data->handler_count--; found = TRUE; break; } } /* See note somewhere about this actually helping developers.. */ g_return_if_fail(found); } /* * TODO: Make this all more efficient by storing a list of handlers, keyed * to a handle. */ static void disconnect_handle_from_signals(const char *signal, GaimSignalData *signal_data, void *handle) { GList *l, *l_next; GaimSignalHandlerData *handler_data; for (l = signal_data->handlers; l != NULL; l = l_next) { handler_data = (GaimSignalHandlerData *)l->data; l_next = l->next; if (handler_data->handle == handle) { g_free(handler_data); signal_data->handler_count--; signal_data->handlers = g_list_remove(signal_data->handlers, handler_data); } } } static void disconnect_handle_from_instance(void *instance, GaimInstanceData *instance_data, void *handle) { g_hash_table_foreach(instance_data->signals, (GHFunc)disconnect_handle_from_signals, handle); } void gaim_signals_disconnect_by_handle(void *handle) { g_return_if_fail(handle != NULL); g_hash_table_foreach(instance_table, (GHFunc)disconnect_handle_from_instance, handle); } void gaim_signal_emit(void *instance, const char *signal, ...) { va_list args; g_return_if_fail(instance != NULL); g_return_if_fail(signal != NULL); va_start(args, signal); gaim_signal_emit_vargs(instance, signal, args); va_end(args); } void gaim_signal_emit_vargs(void *instance, const char *signal, va_list args) { GaimInstanceData *instance_data; GaimSignalData *signal_data; GaimSignalHandlerData *handler_data; GList *l, *l_next; va_list tmp; g_return_if_fail(instance != NULL); g_return_if_fail(signal != NULL); instance_data = (GaimInstanceData *)g_hash_table_lookup(instance_table, instance); g_return_if_fail(instance_data != NULL); signal_data = (GaimSignalData *)g_hash_table_lookup(instance_data->signals, signal); if (signal_data == NULL) { gaim_debug(GAIM_DEBUG_ERROR, "signals", "Signal data for %s not found!\n", signal); return; } for (l = signal_data->handlers; l != NULL; l = l_next) { l_next = l->next; handler_data = (GaimSignalHandlerData *)l->data; /* This is necessary because a va_list may only be * evaluated once */ G_VA_COPY(tmp, args); if (handler_data->use_vargs) { ((void (*)(va_list, void *))handler_data->cb)(tmp, handler_data->data); } else { signal_data->marshal(handler_data->cb, tmp, handler_data->data, NULL); } va_end(tmp); } } void * gaim_signal_emit_return_1(void *instance, const char *signal, ...) { void *ret_val; va_list args; g_return_val_if_fail(instance != NULL, NULL); g_return_val_if_fail(signal != NULL, NULL); va_start(args, signal); ret_val = gaim_signal_emit_vargs_return_1(instance, signal, args); va_end(args); return ret_val; } void * gaim_signal_emit_vargs_return_1(void *instance, const char *signal, va_list args) { GaimInstanceData *instance_data; GaimSignalData *signal_data; GaimSignalHandlerData *handler_data; void *ret_val = NULL; GList *l, *l_next; va_list tmp; g_return_val_if_fail(instance != NULL, NULL); g_return_val_if_fail(signal != NULL, NULL); instance_data = (GaimInstanceData *)g_hash_table_lookup(instance_table, instance); g_return_val_if_fail(instance_data != NULL, NULL); signal_data = (GaimSignalData *)g_hash_table_lookup(instance_data->signals, signal); if (signal_data == NULL) { gaim_debug(GAIM_DEBUG_ERROR, "signals", "Signal data for %s not found!\n", signal); return 0; } for (l = signal_data->handlers; l != NULL; l = l_next) { l_next = l->next; handler_data = (GaimSignalHandlerData *)l->data; G_VA_COPY(tmp, args); if (handler_data->use_vargs) { ret_val = ((void *(*)(va_list, void *))handler_data->cb)( tmp, handler_data->data); } else { signal_data->marshal(handler_data->cb, tmp, handler_data->data, &ret_val); } va_end(tmp); } return ret_val; } void gaim_signals_init() { g_return_if_fail(instance_table == NULL); instance_table = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)destroy_instance_data); } void gaim_signals_uninit() { g_return_if_fail(instance_table != NULL); g_hash_table_destroy(instance_table); instance_table = NULL; } /************************************************************************** * Marshallers **************************************************************************/ void gaim_marshal_VOID(GaimCallback cb, va_list args, void *data, void **return_val) { ((void (*)(void *))cb)(data); } void gaim_marshal_VOID__INT(GaimCallback cb, va_list args, void *data, void **return_val) { gint arg1 = va_arg(args, gint); ((void (*)(gint, void *))cb)(arg1, data); } void gaim_marshal_VOID__INT_INT(GaimCallback cb, va_list args, void *data, void **return_val) { gint arg1 = va_arg(args, gint); gint arg2 = va_arg(args, gint); ((void (*)(gint, gint, void *))cb)(arg1, arg2, data); } void gaim_marshal_VOID__POINTER(GaimCallback cb, va_list args, void *data, void **return_val) { void *arg1 = va_arg(args, void *); ((void (*)(void *, void *))cb)(arg1, data); } void gaim_marshal_VOID__POINTER_POINTER(GaimCallback cb, va_list args, void *data, void **return_val) { void *arg1 = va_arg(args, void *); void *arg2 = va_arg(args, void *); ((void (*)(void *, void *, void *))cb)(arg1, arg2, data); } void gaim_marshal_VOID__POINTER_POINTER_UINT(GaimCallback cb, va_list args, void *data, void **return_val) { void *arg1 = va_arg(args, void *); void *arg2 = va_arg(args, void *); guint arg3 = va_arg(args, guint); ((void (*)(void *, void *, guint, void *))cb)(arg1, arg2, arg3, data); } void gaim_marshal_VOID__POINTER_POINTER_POINTER(GaimCallback cb, va_list args, void *data, void **return_val) { void *arg1 = va_arg(args, void *); void *arg2 = va_arg(args, void *); void *arg3 = va_arg(args, void *); ((void (*)(void *, void *, void *, void *))cb)(arg1, arg2, arg3, data); } void gaim_marshal_VOID__POINTER_POINTER_POINTER_POINTER(GaimCallback cb, va_list args, void *data, void **return_val) { void *arg1 = va_arg(args, void *); void *arg2 = va_arg(args, void *); void *arg3 = va_arg(args, void *); void *arg4 = va_arg(args, void *); ((void (*)(void *, void *, void *, void *, void *))cb)(arg1, arg2, arg3, arg4, data); } void gaim_marshal_VOID__POINTER_POINTER_POINTER_UINT(GaimCallback cb, va_list args, void *data, void **return_val) { void *arg1 = va_arg(args, void *); void *arg2 = va_arg(args, void *); void *arg3 = va_arg(args, void *); guint arg4 = va_arg(args, guint); ((void (*)(void *, void *, void *, guint, void *))cb)(arg1, arg2, arg3, arg4, data); } void gaim_marshal_VOID__POINTER_POINTER_POINTER_UINT_UINT(GaimCallback cb, va_list args, void *data, void **return_val) { void *arg1 = va_arg(args, void *); void *arg2 = va_arg(args, void *); void *arg3 = va_arg(args, void *); guint arg4 = va_arg(args, guint); guint arg5 = va_arg(args, guint); ((void (*)(void *, void *, void *, guint, guint, void *))cb)( arg1, arg2, arg3, arg4, arg5, data); } void gaim_marshal_INT__INT(GaimCallback cb, va_list args, void *data, void **return_val) { gint ret_val; gint arg1 = va_arg(args, gint); ret_val = ((gint (*)(gint, void *))cb)(arg1, data); if (return_val != NULL) *return_val = GINT_TO_POINTER(ret_val); } void gaim_marshal_INT__INT_INT(GaimCallback cb, va_list args, void *data, void **return_val) { gint ret_val; gint arg1 = va_arg(args, gint); gint arg2 = va_arg(args, gint); ret_val = ((gint (*)(gint, gint, void *))cb)(arg1, arg2, data); if (return_val != NULL) *return_val = GINT_TO_POINTER(ret_val); } void gaim_marshal_BOOLEAN__POINTER(GaimCallback cb, va_list args, void *data, void **return_val) { gboolean ret_val; void *arg1 = va_arg(args, void *); ret_val = ((gboolean (*)(void *, void *))cb)(arg1, data); if (return_val != NULL) *return_val = GINT_TO_POINTER(ret_val); } void gaim_marshal_BOOLEAN__POINTER_POINTER(GaimCallback cb, va_list args, void *data, void **return_val) { gboolean ret_val; void *arg1 = va_arg(args, void *); void *arg2 = va_arg(args, void *); ret_val = ((gboolean (*)(void *, void *, void *))cb)(arg1, arg2, data); if (return_val != NULL) *return_val = GINT_TO_POINTER(ret_val); } void gaim_marshal_BOOLEAN__POINTER_POINTER_POINTER(GaimCallback cb, va_list args, void *data, void **return_val) { gboolean ret_val; void *arg1 = va_arg(args, void *); void *arg2 = va_arg(args, void *); void *arg3 = va_arg(args, void *); ret_val = ((gboolean (*)(void *, void *, void *, void *))cb)(arg1, arg2, arg3, data); if (return_val != NULL) *return_val = GINT_TO_POINTER(ret_val); } void gaim_marshal_BOOLEAN__POINTER_POINTER_UINT(GaimCallback cb, va_list args, void *data, void **return_val) { gboolean ret_val; void *arg1 = va_arg(args, void *); void *arg2 = va_arg(args, void *); guint arg3 = va_arg(args, guint); ret_val = ((gboolean (*)(void *, void *, guint, void *))cb)( arg1, arg2, arg3, data); if (return_val != NULL) *return_val = GINT_TO_POINTER(ret_val); } void gaim_marshal_BOOLEAN__POINTER_POINTER_POINTER_UINT(GaimCallback cb, va_list args, void *data, void **return_val) { gboolean ret_val; void *arg1 = va_arg(args, void *); void *arg2 = va_arg(args, void *); void *arg3 = va_arg(args, void *); guint arg4 = va_arg(args, guint); ret_val = ((gboolean (*)(void *, void *, void *, guint, void *))cb)( arg1, arg2, arg3, arg4, data); if (return_val != NULL) *return_val = GINT_TO_POINTER(ret_val); } void gaim_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER(GaimCallback cb, va_list args, void *data, void **return_val) { gboolean ret_val; void *arg1 = va_arg(args, void *); void *arg2 = va_arg(args, void *); void *arg3 = va_arg(args, void *); void *arg4 = va_arg(args, void *); ret_val = ((gboolean (*)(void *, void *, void *, void *, void *))cb)( arg1, arg2, arg3, arg4, data); if (return_val != NULL) *return_val = GINT_TO_POINTER(ret_val); } void gaim_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER( GaimCallback cb, va_list args, void *data, void **return_val) { gboolean ret_val; void *arg1 = va_arg(args, void *); void *arg2 = va_arg(args, void *); void *arg3 = va_arg(args, void *); void *arg4 = va_arg(args, void *); void *arg5 = va_arg(args, void *); ret_val = ((gboolean (*)(void *, void *, void *, void *, void *, void *))cb)( arg1, arg2, arg3, arg4, arg5, data); if (return_val != NULL) *return_val = GINT_TO_POINTER(ret_val); }