Andre Dieb <andre.dieb@gmail.com>
Mathieu Taillefumier <mathieu.taillefumier@free.fr>
Rui Miguel Silva Seabra <rms@1407.org>
-Saumsung Electronics <tbd>
+Samsung Electronics <tbd>
Samsung SAIT <tbd>
Nicolas Aguirre <aguirre.nicolas@gmail.com>
Brett Nash <nash@nash.id.au>
##--##--##--##--##--##--##--##--##--##--##--##--##--##--##--##--##
##--##--##--##--##--##--##--##--##--##--##--##--##--##--##--##--##
-AC_INIT([ecore], [v_ver.beta], [enlightenment-devel@lists.sourceforge.net])
+AC_INIT([ecore], [v_ver.beta2], [enlightenment-devel@lists.sourceforge.net])
AC_PREREQ([2.52])
AC_CONFIG_SRCDIR([configure.ac])
AC_CONFIG_MACRO_DIR([m4])
])
AC_SUBST(cocoa_ldflags)
-### commented out to avoid ERR<31094> - Failed to create epoll fd! / Failed to add poll on fd
-#want_epoll=yes
+want_epoll=yes
AC_ARG_ENABLE(epoll,
AC_HELP_STRING([--enable-epoll], [enable or disable epoll support]),
[want_epoll=$enableval])
fi
-# basic pthread support
+# thread support
-EFL_CHECK_PTHREAD([no], [have_pthread="yes"], [have_pthread="no"])
+EFL_CHECK_THREADS(
+ [
+ if test "x${_efl_have_posix_threads}" = "xyes" ; then
+ have_threads="POSIX"
+ else
+ if test "x${_efl_have_win32_threads}" = "xyes" ; then
+ have_threads="Win32"
+ else
+ have_threads="no"
+ fi
+ fi
+ ],
+ [have_threads="no"])
### Checks for types
AC_CHECK_SIZEOF(int, 4)
echo " Core:"
echo
echo " Ecore........................: always"
-echo " Thread support.............: $have_pthread"
+echo " Thread support.............: $have_threads"
echo " GLib support...............: $have_glib"
echo " Always integrate GLib......: $want_glib_integration_always"
echo " Use g_main_loop............: $want_g_main_loop"
-ecore (1.0.0.001+svn.51480slp2+build28) unstable; urgency=low
-
- * [ecore_evas] Patch code for rotation.
- * Git: 165.213.180.234:/git/slp/pkgs/ecore
- * Tag: ecore_1.0.0.001+svn.51480slp2+build28
-
- -- Doyoun Kang <doyoun.kang@samsung.com> Mon, 29 Nov 2010 10:14:56 +0900
-
-ecore (1.0.0.001+svn.51480slp2+build27) unstable; urgency=low
-
- * [ecore_evas.c] change FPS rate print it every 0.1 sec
- * Git: 165.213.180.234:/git/slp/pkgs/ecore
- * Tag: ecore_1.0.0.001+svn.51480slp2+build27
-
- -- Seokjae Jeong <seok.j.jeong@samsung.com> Sat, 27 Nov 2010 15:06:21 +0900
-
-ecore (1.0.0.001+svn.51480slp2+build26) unstable; urgency=low
-
- * [ecore_imf] remove unused typedefs
- * Git: 165.213.180.234:/git/slp/pkgs/ecore
- * Tag: ecore_1.0.0.001+svn.51480slp2+build26
-
- -- Jihoon Kim <jihoon48.kim@samsung.com> Fri, 26 Nov 2010 17:56:05 +0900
-
-ecore (1.0.0.001+svn.51480slp2+build25) unstable; urgency=low
-
- * [SVN 54830 Merge]
- * Update to SVN Revision 54830.
- * Git: 165.213.180.234:/git/slp/pkgs/ecore
- * Tag: ecore_1.0.0.001+svn.51480slp2+build25
-
- -- Juyung Seo <juyung.seo@samsung.com> Fri, 26 Nov 2010 15:31:53 +0900
-
ecore (1.0.0.001+svn.51480slp2+build19) unstable; urgency=low
* libcurl-dev -> libcurl4-openssl-dev
--- /dev/null
+#include <stdio.h>
+#include <Ecore.h>
+#include <Ecore_Con.h>
+
+/* Ecore_Con client example
+ * 2010 Mike Blumenkrantz
+ */
+
+#define NUM_CLIENTS 10000
+
+static Eina_Counter *counter;
+static int add = 0;
+static int del = 0;
+
+Eina_Bool
+_add(void *data, int type, Ecore_Con_Event_Server_Add *ev)
+{
+ ++add;
+ printf("Connection #%i!\n", add);
+ if (add == NUM_CLIENTS)
+ ecore_main_loop_quit();
+
+ return ECORE_CALLBACK_RENEW;
+}
+
+Eina_Bool
+_del(void *data, int type, Ecore_Con_Event_Server_Add *ev)
+{
+ ++del;
+ printf("Connection lost! #%i!\n", del);
+
+ return ECORE_CALLBACK_RENEW;
+}
+
+static void
+_spawn(void *data)
+{
+ int x;
+
+ for (x = 0; x < NUM_CLIENTS; x++)
+ {
+// printf("Creating connection %i\n", x);
+ if (!ecore_con_server_connect(ECORE_CON_REMOTE_NODELAY, "127.0.0.1", 8080, NULL))
+ {
+ printf("CRITICAL ERROR!\n"
+ "Could not create connection #%i!\n", x);
+ exit(1);
+ }
+ }
+ printf("***Job done***\n");
+}
+
+int main(void)
+{
+ double done;
+ eina_init();
+ ecore_init();
+ ecore_con_init();
+
+ eina_log_domain_level_set("ecore_con", EINA_LOG_LEVEL_ERR);
+ eina_log_domain_level_set("eina", EINA_LOG_LEVEL_ERR);
+ counter = eina_counter_new("client");
+ eina_counter_start(counter);
+ done = ecore_time_get();
+
+ ecore_job_add(_spawn, NULL);
+
+/* set event handler for server connect */
+ ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD, (Ecore_Event_Handler_Cb)_add, NULL);
+ ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD, (Ecore_Event_Handler_Cb)_del, NULL);
+
+/* start client */
+ ecore_main_loop_begin();
+ eina_counter_stop(counter, 1);
+ printf("\nTime elapsed for %i connections: %f seconds\n%s", NUM_CLIENTS, ecore_time_get() - done, eina_counter_dump(counter));
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <Ecore.h>
+#include <Ecore_Con.h>
+
+/* Ecore_Con server example
+ * 2010 Mike Blumenkrantz
+ */
+
+static Ecore_Con_Server *svr;
+static int add;
+static int del;
+
+Eina_Bool
+_add(void *data, int type, Ecore_Con_Event_Client_Add *ev)
+{
+ ++add;
+// printf ("%s ", ecore_con_client_ip_get(ev->client));
+ printf("Client #%i!\n", add);
+ return ECORE_CALLBACK_RENEW;
+}
+
+Eina_Bool
+_del(void *data, int type, Ecore_Con_Event_Client_Del *ev)
+{
+ ++del;
+ printf("Disconnected #%i!\n", del);
+ if (add == del)
+ ecore_main_loop_quit();
+ return ECORE_CALLBACK_RENEW;
+}
+
+int main(int argc, const char *argv[])
+{
+ ecore_init();
+ ecore_con_init();
+ ecore_app_args_set(argc, argv);
+ eina_log_domain_level_set("ecore_con", EINA_LOG_LEVEL_ERR);
+ eina_log_domain_level_set("eina", EINA_LOG_LEVEL_ERR);
+
+
+/* to use a PEM certificate with TLS and SSL3, uncomment the lines below */
+// if (!(svr = ecore_con_server_add(ECORE_CON_REMOTE_NODELAY | ECORE_CON_USE_MIXED | ECORE_CON_LOAD_CERT, "127.0.0.1", 8080, NULL)))
+
+/* to use simple tcp with ssl/tls, use this line */
+ svr = ecore_con_server_add(ECORE_CON_REMOTE_NODELAY , "127.0.0.1", 8080, NULL);
+ if (!svr)
+ exit(1);
+
+ ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_ADD, (Ecore_Event_Handler_Cb)_add, NULL);
+ ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DEL, (Ecore_Event_Handler_Cb)_del, NULL);
+
+/* start server */
+ ecore_main_loop_begin();
+ if (add && del)
+ {
+ printf("Restarting server after %i connections\n", add);
+ add = del = 0;
+ ecore_con_server_del(svr);
+ ecore_app_restart();
+ }
+ return 0;
+}
--- /dev/null
+dnl Copyright (C) 2010 Vincent Torri <vtorri at univ-evry dot fr>
+dnl rwlock code added by Mike Blumenkrantz <mike at zentific dot com>
+dnl This code is public domain and can be freely used or copied.
+
+dnl Macro that check if POSIX or Win32 threads library is available or not.
+
+dnl Usage: EFL_CHECK_THREADS(ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND])
+dnl Call AC_SUBST(EFL_PTHREAD_CFLAGS)
+dnl Call AC_SUBST(EFL_PTHREAD_LIBS)
+dnl Defines EFL_HAVE_POSIX_THREADS or EFL_HAVE_WIN32_THREADS, and EFL_HAVE_THREADS
+
+AC_DEFUN([EFL_CHECK_THREADS],
+[
+
+dnl configure option
+
+AC_ARG_ENABLE([posix-threads],
+ [AC_HELP_STRING([--disable-posix-threads], [enable POSIX threads code @<:@default=auto@:>@])],
+ [
+ if test "x${enableval}" = "xyes" ; then
+ _efl_enable_posix_threads="yes"
+ else
+ _efl_enable_posix_threads="no"
+ fi
+ ],
+ [_efl_enable_posix_threads="auto"])
+
+AC_MSG_CHECKING([whether to build POSIX threads code])
+AC_MSG_RESULT([${_efl_enable_posix_threads}])
+
+AC_ARG_ENABLE([win32-threads],
+ [AC_HELP_STRING([--disable-win32-threads], [enable Win32 threads code @<:@default=no@:>@])],
+ [
+ if test "x${enableval}" = "xyes" ; then
+ _efl_enable_win32_threads="yes"
+ else
+ _efl_enable_win32_threads="no"
+ fi
+ ],
+ [_efl_enable_win32_threads="no"])
+
+AC_MSG_CHECKING([whether to build Windows threads code])
+AC_MSG_RESULT([${_efl_enable_win32_threads}])
+
+dnl
+dnl * no + no
+dnl * yes + no : win32: error, other : pthread
+dnl * yes + yes : win32 : wthread, other : pthread
+dnl * no + yes : win32 : wthread, other : error
+
+if test "x${_efl_enable_posix_threads}" = "xyes" && test "x${_efl_enable_win32_threads}" = "xyes" ; then
+ case "$host_os" in
+ mingw*)
+ _efl_enable_posix_threads=no
+ ;;
+ *)
+ _efl_enable_win32_threads=no
+ ;;
+ esac
+fi
+
+if test "x${_efl_enable_win32_threads}" = "xyes" ; then
+ case "$host_os" in
+ mingw*)
+ ;;
+ *)
+ AC_MSG_ERROR([Win32 threads support requested but non Windows system found.])
+ ;;
+ esac
+fi
+
+if test "x${_efl_enable_posix_threads}" = "xyes" ; then
+ case "$host_os" in
+ mingw*)
+ AC_MSG_ERROR([POSIX threads support requested but Windows system found.])
+ ;;
+ *)
+ ;;
+ esac
+fi
+
+dnl check if the compiler supports POSIX threads
+
+case "$host_os" in
+ mingw*)
+ ;;
+ solaris*)
+ _efl_threads_cflags="-mt"
+ _efl_threads_libs="-mt"
+ ;;
+ *)
+ _efl_threads_cflags="-pthread"
+ _efl_threads_libs="-pthread"
+ ;;
+esac
+
+_efl_have_posix_threads="no"
+_efl_have_win32_threads="no"
+
+if test "x${_efl_enable_posix_threads}" = "xyes" || test "x${_efl_enable_posix_threads}" = "xauto" ; then
+
+ SAVE_CFLAGS=${CFLAGS}
+ CFLAGS="${CFLAGS} ${_efl_threads_cflags}"
+ SAVE_LIBS=${LIBS}
+ LIBS="${LIBS} ${_efl_threads_libs}"
+ AC_LINK_IFELSE(
+ [AC_LANG_PROGRAM([[
+#include <pthread.h>
+ ]],
+ [[
+pthread_t id;
+id = pthread_self();
+ ]])],
+ [_efl_have_posix_threads="yes"],
+ [_efl_have_posix_threads="no"])
+ CFLAGS=${SAVE_CFLAGS}
+ LIBS=${SAVE_LIBS}
+
+fi
+
+AC_MSG_CHECKING([whether system support POSIX threads])
+AC_MSG_RESULT([${_efl_have_posix_threads}])
+if test "$x{_efl_enable_posix_threads}" = "xyes" && test "x${_efl_have_posix_threads}" = "xno"; then
+ AC_MSG_ERROR([POSIX threads support requested but not found.])
+fi
+
+EFL_PTHREAD_CFLAGS=""
+EFL_PTHREAD_LIBS=""
+if test "x${_efl_have_posix_threads}" = "xyes" ; then
+ EFL_PTHREAD_CFLAGS=${_efl_threads_cflags}
+ EFL_PTHREAD_LIBS=${_efl_threads_libs}
+fi
+
+AC_SUBST(EFL_PTHREAD_CFLAGS)
+AC_SUBST(EFL_PTHREAD_LIBS)
+
+_efl_enable_debug_threads="no"
+AC_ARG_ENABLE([debug-threads],
+ [AC_HELP_STRING([--enable-debug-threads], [disable assert when you forgot to call eina_threads_init])],
+ [_efl_enable_debug_threads="${enableval}"])
+
+have_debug_threads="no"
+if test "x${_efl_have_posix_threads}" = "xyes" -a "x${_efl_enable_debug_threads}" = "xyes"; then
+ have_debug_threads="yes"
+ AC_DEFINE([EFL_DEBUG_THREADS], [1], [Assert when forgot to call eina_threads_init])
+fi
+
+if test "x${_efl_have_posix_threads}" = "xyes" ; then
+ AC_DEFINE([EFL_HAVE_POSIX_THREADS], [1], [Define to mention that POSIX threads are supported])
+fi
+
+if test "x${_efl_enable_win32_threads}" = "xyes" ; then
+ _efl_have_win32_threads="yes"
+ AC_DEFINE([EFL_HAVE_WIN32_THREADS], [1], [Define to mention that Win32 threads are supported])
+fi
+
+if test "x${_efl_have_posix_threads}" = "xyes" || test "x${_efl_have_win32_threads}" = "xyes" ; then
+ AC_DEFINE([EFL_HAVE_THREADS], [1], [Define to mention that POSIX or Win32 threads are supported])
+fi
+
+AS_IF([test "x$_efl_have_posix_threads" = "xyes" || test "x$_efl_have_win32_threads" = "xyes"], [$1], [$2])
+])
+
+dnl Usage: EFL_CHECK_SPINLOCK(ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND])
+dnl Defines EFL_HAVE_POSIX_THREADS_SPINLOCK
+AC_DEFUN([EFL_CHECK_SPINLOCK],
+[
+
+dnl check if the compiler supports pthreads spinlock
+
+_efl_have_posix_threads_spinlock="no"
+
+if test "x${_efl_have_posix_threads}" = "xyes" ; then
+
+ SAVE_CFLAGS=${CFLAGS}
+ CFLAGS="${CFLAGS} ${EFL_PTHREAD_CFLAGS}"
+ SAVE_LIBS=${LIBS}
+ LIBS="${LIBS} ${EFL_PTHREAD_LIBS}"
+ AC_LINK_IFELSE(
+ [AC_LANG_PROGRAM([[
+#include <pthread.h>
+ ]],
+ [[
+pthread_spinlock_t lock;
+int res;
+res = pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE);
+ ]])],
+ [_efl_have_posix_threads_spinlock="yes"],
+ [_efl_have_posix_threads_spinlock="no"])
+ CFLAGS=${SAVE_CFLAGS}
+ LIBS=${SAVE_LIBS}
+
+fi
+
+AC_MSG_CHECKING([whether to build POSIX threads spinlock code])
+AC_MSG_RESULT([${_efl_have_posix_threads_spinlock}])
+if test "x${_efl_enable_posix_threads}" = "xyes" && test "x${_efl_have_posix_threads_spinlock}" = "xno" ; then
+ AC_MSG_WARN([POSIX threads support requested but spinlocks are not supported])
+fi
+
+if test "x${_efl_have_posix_threads_spinlock}" = "xyes" ; then
+ AC_DEFINE([EFL_HAVE_POSIX_THREADS_SPINLOCK], [1], [Define to mention that POSIX threads spinlocks are supported])
+fi
+AS_IF([test "x$_efl_have_posix_threads_spinlock" = "xyes"], [$1], [$2])
+])
+
## Process this file with automake to produce Makefile.in
MAINTAINERCLEANFILES = Makefile.in
-SUBDIRS = \
-ecore \
-ecore_input \
-ecore_input_evas \
-ecore_fb \
-ecore_directfb \
-ecore_con \
-ecore_x \
-ecore_win32 \
-ecore_wince \
-ecore_sdl \
-ecore_cocoa \
-ecore_ipc \
-ecore_evas \
-ecore_config \
-ecore_file \
-ecore_imf \
-ecore_imf_evas
+SUBDIRS = ecore
+
+if BUILD_ECORE_INPUT
+SUBDIRS += ecore_input
+endif
+
+if BUILD_ECORE_INPUT_EVAS
+
+SUBDIRS += ecore_input_evas
+endif
+
+if BUILD_ECORE_FB
+SUBDIRS += ecore_fb
+endif
+
+if BUILD_ECORE_DIRECTFB
+SUBDIRS += ecore_directfb
+endif
+
+if BUILD_ECORE_CON
+SUBDIRS += ecore_con
+endif
+
+if BUILD_ECORE_X
+SUBDIRS += ecore_x
+endif
+
+if BUILD_ECORE_WIN32
+SUBDIRS += ecore_win32
+endif
+
+if BUILD_ECORE_WINCE
+SUBDIRS += ecore_wince
+endif
+
+if BUILD_ECORE_SDL
+SUBDIRS += ecore_sdl
+endif
+
+if BUILD_ECORE_COCOA
+SUBDIRS += ecore_cocoa
+endif
+
+if BUILD_ECORE_IPC
+SUBDIRS += ecore_ipc
+endif
+
+if BUILD_ECORE_EVAS
+SUBDIRS += ecore_evas
+endif
+
+if BUILD_ECORE_CONFIG
+SUBDIRS += ecore_config
+endif
+
+if BUILD_ECORE_FILE
+SUBDIRS += ecore_file
+endif
+
+if BUILD_ECORE_IMF
+SUBDIRS += ecore_imf
+endif
+
+if BUILD_ECORE_IMF_EVAS
+SUBDIRS += ecore_imf_evas
+endif
*/
typedef Eina_Bool (*Ecore_Event_Handler_Cb) (void *data, int type, void *event);
/**
- * @typedef Ecore_Thread_Heavy_Cb Ecore_Thread_Heavy_Cb
- * A callback used to run cpu intensive or blocking I/O operations.
+ * @typedef Ecore_Thread_Cb Ecore_Thread_Cb
+ * A callback used by Ecore_Thread helper.
*/
- typedef void (*Ecore_Thread_Heavy_Cb) (Ecore_Thread *thread, void *data);
+ typedef void (*Ecore_Thread_Cb) (void *data, Ecore_Thread *thread);
/**
* @typedef Ecore_Thread_Notify_Cb Ecore_Thread_Notify_Cb
* A callback used by the main loop to receive data sent by an @ref Ecore_Thread_Group.
*/
- typedef void (*Ecore_Thread_Notify_Cb) (Ecore_Thread *thread, void *msg_data, void *data);
+ typedef void (*Ecore_Thread_Notify_Cb) (void *data, Ecore_Thread *thread, void *msg_data);
/**
* @typedef Ecore_Task_Cb Ecore_Task_Cb
* A callback run for a task (timer, idler, poller, animater, etc)
EAPI void *ecore_event_handler_del(Ecore_Event_Handler *event_handler);
EAPI Ecore_Event *ecore_event_add(int type, void *ev, Ecore_End_Cb func_free, void *data);
EAPI void *ecore_event_del(Ecore_Event *event);
+ EAPI void *ecore_event_handler_data_get(Ecore_Event_Handler *eh);
+ EAPI void *ecore_event_handler_data_set(Ecore_Event_Handler *eh, void *data);
EAPI int ecore_event_type_new(void);
EAPI Ecore_Event_Filter *ecore_event_filter_add(Ecore_Data_Cb func_start, Ecore_Filter_Cb func_filter, Ecore_End_Cb func_end, const void *data);
EAPI void *ecore_event_filter_del(Ecore_Event_Filter *ef);
* @{
*/
- EAPI Ecore_Thread *ecore_thread_run(Ecore_Thread_Heavy_Cb func_blocking,
- Ecore_Cb func_end,
- Ecore_Cb func_cancel,
+ EAPI Ecore_Thread *ecore_thread_run(Ecore_Thread_Cb func_blocking,
+ Ecore_Thread_Cb func_end,
+ Ecore_Thread_Cb func_cancel,
const void *data);
- EAPI Ecore_Thread *ecore_thread_feedback_run(Ecore_Thread_Heavy_Cb func_heavy,
+ EAPI Ecore_Thread *ecore_thread_feedback_run(Ecore_Thread_Cb func_heavy,
Ecore_Thread_Notify_Cb func_notify,
- Ecore_Cb func_end,
- Ecore_Cb func_cancel,
+ Ecore_Thread_Cb func_end,
+ Ecore_Thread_Cb func_cancel,
const void *data,
Eina_Bool try_no_queue);
EAPI Eina_Bool ecore_thread_cancel(Ecore_Thread *thread);
union
{
const char *strv;
- unsigned char boolv;
+ Eina_Bool boolv;
short shortv;
int intv;
long longv;
struct _Ecore_Getopt_Desc_Callback
{
- unsigned char (*func)(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
+ Eina_Bool (*func)(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
const void *data;
Ecore_Getopt_Desc_Arg_Requirement arg_req;
const char *def;
const char *copyright; /**< if exists, --copyright will work */
const char *license; /**< if exists, --license will work */
const char *description; /**< long description, possible multiline */
- unsigned char strict : 1; /**< fail on errors */
+ Eina_Bool strict : 1; /**< fail on errors */
const Ecore_Getopt_Desc descs[]; /* NULL terminated. */
};
EAPI void ecore_getopt_help(FILE *fp, const Ecore_Getopt *info);
- EAPI unsigned char ecore_getopt_parser_has_duplicates(const Ecore_Getopt *parser);
+ EAPI Eina_Bool ecore_getopt_parser_has_duplicates(const Ecore_Getopt *parser);
EAPI int ecore_getopt_parse(const Ecore_Getopt *parser, Ecore_Getopt_Value *values, int argc, char **argv);
EAPI Eina_List *ecore_getopt_list_free(Eina_List *list);
/* helper functions to be used with ECORE_GETOPT_CALLBACK_*() */
- EAPI unsigned char ecore_getopt_callback_geometry_parse(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
- EAPI unsigned char ecore_getopt_callback_size_parse(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
+ EAPI Eina_Bool ecore_getopt_callback_geometry_parse(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
+ EAPI Eina_Bool ecore_getopt_callback_size_parse(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
#ifdef __cplusplus
endif
libecore_la_LIBADD = @dlopen_libs@ @EINA_LIBS@ @EVIL_LIBS@ @GLIB_LIBS@ @WIN32_LIBS@ @LTLIBINTL@ @EFL_PTHREAD_LIBS@ @rt_libs@ -lm
-libecore_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@
+libecore_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@ @EFL_PTHREAD_LIBS@
EXTRA_DIST = ecore_private.h
static int event_handlers_alloc_num = 0;
static Eina_List *event_handlers_delete_list = NULL;
+static Ecore_Event_Handler *event_handlers_add_list = NULL;
+
static Ecore_Event_Filter *event_filters = NULL;
static Ecore_Event_Filter *event_filter_current = NULL;
static Ecore_Event *event_filter_event_current = NULL;
event_handlers[i] = NULL;
}
}
- event_handlers[type] = (Ecore_Event_Handler *) eina_inlist_append(EINA_INLIST_GET(event_handlers[type]), EINA_INLIST_GET(eh));
+ if (ecore_raw_event_type == type)
+ event_handlers_add_list = (Ecore_Event_Handler *)eina_inlist_append(EINA_INLIST_GET(event_handlers_add_list), EINA_INLIST_GET(eh));
+ else
+ event_handlers[type] = (Ecore_Event_Handler *)eina_inlist_append(EINA_INLIST_GET(event_handlers[type]), EINA_INLIST_GET(eh));
return eh;
}
return event_handler->data;
}
+/**
+ * @brief Get the data associated with an #Ecore_Event_Handler
+ * @param eh The event handler
+ * @return The data
+ * This function returns the data previously associated with @p eh.
+ */
+EAPI void *
+ecore_event_handler_data_get(Ecore_Event_Handler *eh)
+{
+ if (!ECORE_MAGIC_CHECK(eh, ECORE_MAGIC_EVENT_HANDLER))
+ {
+ ECORE_MAGIC_FAIL(eh, ECORE_MAGIC_EVENT_HANDLER, "ecore_event_handler_data_get");
+ return NULL;
+ }
+ return eh->data;
+}
+
+/**
+ * @brief Set the data associated with an #Ecore_Event_Handler
+ * @param eh The event handler
+ * @param data The data to associate
+ * @return The previous data
+ * This function sets @p data to @p eh and returns the old data pointer
+ * which was previously associated with @p eh.
+ */
+EAPI void *
+ecore_event_handler_data_set(Ecore_Event_Handler *eh, void *data)
+{
+ void *old;
+ if (!ECORE_MAGIC_CHECK(eh, ECORE_MAGIC_EVENT_HANDLER))
+ {
+ ECORE_MAGIC_FAIL(eh, ECORE_MAGIC_EVENT_HANDLER, "ecore_event_handler_data_set");
+ return NULL;
+ }
+ old = eh->data;
+ eh->data = data;
+ return old;
+}
+
static void
_ecore_event_generic_free (void *data __UNUSED__, void *event)
{
while ((event_handler_current) && (!e->delete_me))
{
- Ecore_Event_Handler *eh = event_handler_current;
+ eh = event_handler_current;
if (!eh->delete_me)
{
Eina_Bool ret;
event_handler_current = (Ecore_Event_Handler *)EINA_INLIST_GET(event_handler_current)->next;
}
}
+ while (event_handlers_add_list)
+ {
+ eh = event_handlers_add_list;
+ event_handlers_add_list = (Ecore_Event_Handler *)eina_inlist_remove(EINA_INLIST_GET(event_handlers_add_list), EINA_INLIST_GET(eh));
+ event_handlers[eh->type] = (Ecore_Event_Handler *)eina_inlist_append(EINA_INLIST_GET(event_handlers[eh->type]), EINA_INLIST_GET(eh));
+ }
/* if no handlers were set for EXIT signal - then default is */
/* to quit the main loop */
if ((e->type == ECORE_EVENT_SIGNAL_EXIT) && (handle_count == 0))
fputc('\n', fp);
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_desc_is_sentinel(const Ecore_Getopt_Desc *desc)
{
return (desc->shortname == '\0') && (!desc->longname);
va_end(ap);
}
-static unsigned char
-_ecore_getopt_parse_bool(const char *str, unsigned char *v)
+static Eina_Bool
+_ecore_getopt_parse_bool(const char *str, Eina_Bool *v)
{
if ((strcmp(str, "0") == 0) ||
(strcasecmp(str, "f") == 0) ||
(strcasecmp(str, "off") == 0)
)
{
- *v = 0;
- return 1;
+ *v = EINA_FALSE;
+ return EINA_TRUE;
}
else if ((strcmp(str, "1") == 0) ||
(strcasecmp(str, "t") == 0) ||
(strcasecmp(str, "on") == 0)
)
{
- *v = 1;
- return 1;
+ *v = EINA_TRUE;
+ return EINA_TRUE;
}
- return 0;
+ return EINA_FALSE;
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_long(const char *str, long int *v)
{
char *endptr = NULL;
return endptr > str;
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_double(const char *str, double *v)
{
char *endptr = NULL;
return endptr > str;
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_store(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *value, const char *arg_val)
{
const Ecore_Getopt_Desc_Store *store = &desc->action_param.store;
long int v;
double d;
- unsigned char b;
+ Eina_Bool b;
if (!value->ptrp)
{
_ecore_getopt_desc_print_error(desc, _("value has no pointer set.\n"));
- return 0;
+ return EINA_FALSE;
}
switch (store->arg_req)
{
case ECORE_GETOPT_TYPE_STR:
*value->strp = (char *)arg_val;
- return 1;
+ return EINA_TRUE;
case ECORE_GETOPT_TYPE_BOOL:
if (_ecore_getopt_parse_bool(arg_val, &b))
{
*value->boolp = b;
- return 1;
+ return EINA_TRUE;
}
else
{
_ecore_getopt_desc_print_error
(desc, _("unknown boolean value %s.\n"), arg_val);
- return 0;
+ return EINA_FALSE;
}
case ECORE_GETOPT_TYPE_SHORT:
if (!_ecore_getopt_parse_long(arg_val, &v))
goto error;
*value->shortp = v;
- return 1;
+ return EINA_TRUE;
case ECORE_GETOPT_TYPE_INT:
if (!_ecore_getopt_parse_long(arg_val, &v))
goto error;
*value->intp = v;
- return 1;
+ return EINA_TRUE;
case ECORE_GETOPT_TYPE_LONG:
if (!_ecore_getopt_parse_long(arg_val, &v))
goto error;
*value->longp = v;
- return 1;
+ return EINA_TRUE;
case ECORE_GETOPT_TYPE_USHORT:
if (!_ecore_getopt_parse_long(arg_val, &v))
goto error;
*value->ushortp = v;
- return 1;
+ return EINA_TRUE;
case ECORE_GETOPT_TYPE_UINT:
if (!_ecore_getopt_parse_long(arg_val, &v))
goto error;
*value->uintp = v;
- return 1;
+ return EINA_TRUE;
case ECORE_GETOPT_TYPE_ULONG:
if (!_ecore_getopt_parse_long(arg_val, &v))
goto error;
*value->ulongp = v;
- return 1;
+ return EINA_TRUE;
case ECORE_GETOPT_TYPE_DOUBLE:
if (!_ecore_getopt_parse_double(arg_val, &d))
goto error;
break;
}
- return 1;
+ return EINA_TRUE;
error:
_ecore_getopt_desc_print_error
(desc, _("invalid number format %s\n"), arg_val);
- return 0;
+ return EINA_FALSE;
use_optional:
switch (store->type)
break;
}
- return 1;
+ return EINA_TRUE;
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_store_const(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val __UNUSED__)
{
if (!val->ptrp)
{
_ecore_getopt_desc_print_error(desc, _("value has no pointer set.\n"));
- return 0;
+ return EINA_FALSE;
}
*val->ptrp = (void *)desc->action_param.store_const;
- return 1;
+ return EINA_TRUE;
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_store_true(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val __UNUSED__)
{
if (!val->boolp)
{
_ecore_getopt_desc_print_error(desc, _("value has no pointer set.\n"));
- return 0;
+ return EINA_FALSE;
}
- *val->boolp = 1;
- return 1;
+ *val->boolp = EINA_TRUE;
+ return EINA_TRUE;
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_store_false(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val __UNUSED__)
{
if (!val->boolp)
{
_ecore_getopt_desc_print_error(desc, _("value has no pointer set.\n"));
- return 0;
+ return EINA_FALSE;
}
- *val->boolp = 0;
- return 1;
+ *val->boolp = EINA_FALSE;
+ return EINA_TRUE;
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_choice(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val)
{
const char * const *pchoice;
if (!val->strp)
{
_ecore_getopt_desc_print_error(desc, _("value has no pointer set.\n"));
- return 0;
+ return EINA_FALSE;
}
pchoice = desc->action_param.choices;
if (strcmp(*pchoice, arg_val) == 0)
{
*val->strp = (char *)*pchoice;
- return 1;
+ return EINA_TRUE;
}
_ecore_getopt_desc_print_error
}
fputs(".\n", stderr);
- return 0;
+ return EINA_FALSE;
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_append(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val)
{
void *data;
long int v;
double d;
- unsigned char b;
+ Eina_Bool b;
if (!arg_val)
{
_ecore_getopt_desc_print_error
(desc, _("missing parameter to append.\n"));
- return 0;
+ return EINA_FALSE;
}
if (!val->listp)
{
_ecore_getopt_desc_print_error(desc, _("value has no pointer set.\n"));
- return 0;
+ return EINA_FALSE;
}
switch (desc->action_param.append_type)
{
if (_ecore_getopt_parse_bool(arg_val, &b))
{
- data = malloc(sizeof(unsigned char));
+ data = malloc(sizeof(Eina_Bool));
if (data)
- *(unsigned char *)data = b;
+ *(Eina_Bool *)data = b;
}
else
{
- _ecore_getopt_desc_print_error
- (desc, _("unknown boolean value %s.\n"), arg_val);
- return 0;
+ _ecore_getopt_desc_print_error(desc, _("unknown boolean value %s.\n"), arg_val);
+ return EINA_FALSE;
}
}
break;
default:
{
_ecore_getopt_desc_print_error(desc, _("could not parse value.\n"));
- return 0;
+ return EINA_FALSE;
}
}
*val->listp = eina_list_append(*val->listp, data);
- return 1;
+ return EINA_TRUE;
error:
_ecore_getopt_desc_print_error
(desc, _("invalid number format %s\n"), arg_val);
- return 0;
+ return EINA_FALSE;
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_count(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val __UNUSED__)
{
if (!val->intp)
{
_ecore_getopt_desc_print_error(desc, _("value has no pointer set.\n"));
- return 0;
+ return EINA_FALSE;
}
(*val->intp)++;
- return 1;
+ return EINA_TRUE;
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_callback(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val)
{
const Ecore_Getopt_Desc_Callback *cb = &desc->action_param.callback;
if ((!arg_val) || (arg_val[0] == '\0'))
{
_ecore_getopt_desc_print_error(desc, _("missing parameter.\n"));
- return 0;
+ return EINA_FALSE;
}
if (!val->ptrp)
{
- _ecore_getopt_desc_print_error
- (desc, _("value has no pointer set.\n"));
- return 0;
+ _ecore_getopt_desc_print_error(desc, _("value has no pointer set.\n"));
+ return EINA_FALSE;
}
}
if (!cb->func)
{
_ecore_getopt_desc_print_error(desc, _("missing callback function!\n"));
- return 0;
+ return EINA_FALSE;
}
return cb->func(parser, desc, arg_val, (void *)cb->data, val);
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_help(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc __UNUSED__, Ecore_Getopt_Value *val, const char *arg_val __UNUSED__)
{
if (val->boolp)
- (*val->boolp) = 1;
+ (*val->boolp) = EINA_TRUE;
ecore_getopt_help(stdout, parser);
- return 1;
+ return EINA_TRUE;
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_version(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val __UNUSED__)
{
if (val->boolp)
- (*val->boolp) = 1;
+ (*val->boolp) = EINA_TRUE;
if (!parser->version)
{
_ecore_getopt_desc_print_error(desc, _("no version was defined.\n"));
- return 0;
+ return EINA_FALSE;
}
_ecore_getopt_version(stdout, parser);
- return 1;
+ return EINA_TRUE;
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_copyright(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val __UNUSED__)
{
if (val->boolp)
- (*val->boolp) = 1;
+ (*val->boolp) = EINA_TRUE;
if (!parser->copyright)
{
_ecore_getopt_desc_print_error(desc, _("no copyright was defined.\n"));
- return 0;
+ return EINA_FALSE;
}
_ecore_getopt_copyright(stdout, parser);
- return 1;
+ return EINA_TRUE;
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_license(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val __UNUSED__)
{
if (val->boolp)
- (*val->boolp) = 1;
+ (*val->boolp) = EINA_TRUE;
if (!parser->license)
{
_ecore_getopt_desc_print_error(desc, _("no license was defined.\n"));
- return 0;
+ return EINA_FALSE;
}
_ecore_getopt_license(stdout, parser);
- return 1;
+ return EINA_TRUE;
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_desc_handle(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *value, const char *arg_val)
{
switch (desc->action)
case ECORE_GETOPT_ACTION_LICENSE:
return _ecore_getopt_parse_license(parser, desc, value, arg_val);
default:
- return 0;
+ return EINA_FALSE;
}
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_arg_long(const Ecore_Getopt *parser, Ecore_Getopt_Value *values, int argc __UNUSED__, char **argv, int *idx, int *nonargs, const char *arg)
{
const Ecore_Getopt_Desc *desc;
const char *arg_val;
int desc_idx;
Ecore_Getopt_Value *value;
- unsigned char ret;
+ Eina_Bool ret;
desc = _ecore_getopt_parse_find_long(parser, arg);
if (!desc)
{
fprintf(stderr, _("ERROR: unknown option --%s, ignored.\n"), arg);
if (parser->strict)
- return 0;
+ return EINA_FALSE;
(*idx)++;
- return 1;
+ return EINA_TRUE;
}
(*idx)++;
fprintf
(stderr, _("ERROR: option --%s requires an argument!\n"), arg);
if (parser->strict)
- return 0;
- return 1;
+ return EINA_FALSE;
+ return EINA_TRUE;
}
}
else
value = values + desc_idx;
ret = _ecore_getopt_desc_handle(parser, desc, value, arg_val);
if ((!ret) && parser->strict)
- return 0;
+ return EINA_FALSE;
- return 1;
+ return EINA_TRUE;
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_arg_short(const Ecore_Getopt *parser, Ecore_Getopt_Value *values, int argc __UNUSED__, char **argv, int *idx, int *nonargs, const char *arg)
{
int run = 1;
const char *arg_val;
int desc_idx;
Ecore_Getopt_Value *value;
- unsigned char ret;
+ Eina_Bool ret;
desc = _ecore_getopt_parse_find_short(parser, arg[0]);
if (!desc)
fprintf
(stderr, _("ERROR: unknown option -%c, ignored.\n"), arg[0]);
if (parser->strict)
- return 0;
+ return EINA_FALSE;
arg++;
continue;
(stderr, _("ERROR: option -%c requires an argument!\n"),
opt);
if (parser->strict)
- return 0;
- return 1;
+ return EINA_FALSE;
+ return EINA_TRUE;
}
}
else
value = values + desc_idx;
ret = _ecore_getopt_desc_handle(parser, desc, value, arg_val);
if ((!ret) && parser->strict)
- return 0;
+ return EINA_FALSE;
}
if (run)
(*idx)++;
- return 1;
+ return EINA_TRUE;
}
-static unsigned char
+static Eina_Bool
_ecore_getopt_parse_arg(const Ecore_Getopt *parser, Ecore_Getopt_Value *values, int argc, char **argv, int *idx, int *nonargs)
{
char *arg = argv[*idx];
*dst = arg;
(*nonargs)--;
- return 1;
+ return EINA_TRUE;
}
if (arg[1] == '-')
- return _ecore_getopt_parse_arg_long
- (parser, values, argc, argv, idx, nonargs, arg + 2);
+ return _ecore_getopt_parse_arg_long(parser, values, argc, argv, idx, nonargs, arg + 2);
else
- return _ecore_getopt_parse_arg_short
- (parser, values, argc, argv, idx, nonargs, arg + 1);
+ return _ecore_getopt_parse_arg_short(parser, values, argc, argv, idx, nonargs, arg + 1);
}
static const Ecore_Getopt_Desc *
/**
* Check parser for duplicate entries, print them out.
*
- * @return 1 if there are duplicates, 0 otherwise.
+ * @return EINA_TRUE if there are duplicates, EINA_FALSE otherwise.
*/
-unsigned char
+Eina_Bool
ecore_getopt_parser_has_duplicates(const Ecore_Getopt *parser)
{
const Ecore_Getopt_Desc *desc = parser->descs;
other = _ecore_getopt_parse_find_short_other(parser, desc);
if (other)
{
- _ecore_getopt_desc_print_error
- (desc, "short name -%c already exists.", desc->shortname);
+ _ecore_getopt_desc_print_error(desc, "short name -%c already exists.", desc->shortname);
if (other->longname)
fprintf(stderr, " Other is --%s.\n", other->longname);
else
fputc('\n', stderr);
- return 1;
+ return EINA_TRUE;
}
}
other = _ecore_getopt_parse_find_long_other(parser, desc);
if (other)
{
- _ecore_getopt_desc_print_error
- (desc, "long name --%s already exists.", desc->longname);
+ _ecore_getopt_desc_print_error(desc, "long name --%s already exists.", desc->longname);
if (other->shortname)
fprintf(stderr, " Other is -%c.\n", other->shortname);
else
fputc('\n', stderr);
- return 1;
+ return EINA_TRUE;
}
}
}
- return 0;
+ return EINA_FALSE;
}
static const Ecore_Getopt_Desc *
*
* @c callback_data value is ignored, you can safely use @c NULL.
*/
-unsigned char
+Eina_Bool
ecore_getopt_callback_geometry_parse(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc __UNUSED__, const char *str, void *data __UNUSED__, Ecore_Getopt_Value *storage)
{
Eina_Rectangle *v = (Eina_Rectangle *)storage->ptrp;
if (sscanf(str, "%d:%d:%d:%d", &v->x, &v->y, &v->w, &v->h) != 4)
{
fprintf(stderr, _("ERROR: incorrect geometry value '%s'\n"), str);
- return 0;
+ return EINA_FALSE;
}
- return 1;
+ return EINA_TRUE;
}
/**
*
* @c callback_data value is ignored, you can safely use @c NULL.
*/
-unsigned char
+Eina_Bool
ecore_getopt_callback_size_parse(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc __UNUSED__, const char *str, void *data __UNUSED__, Ecore_Getopt_Value *storage)
{
Eina_Rectangle *v = (Eina_Rectangle *)storage->ptrp;
if (sscanf(str, "%dx%d", &v->w, &v->h) != 2)
{
fprintf(stderr, _("ERROR: incorrect size value '%s'\n"), str);
- return 0;
+ return EINA_FALSE;
}
v->x = 0;
v->y = 0;
- return 1;
+ return EINA_TRUE;
}
static int do_quit = 0;
static Ecore_Fd_Handler *fd_handlers = NULL;
static Ecore_Fd_Handler *fd_handler_current = NULL;
-static int fd_handlers_delete_me = 0;
+static Eina_List *fd_handlers_with_prep = NULL;
+static Eina_List *fd_handlers_with_buffer = NULL;
+static Eina_List *fd_handlers_to_delete = NULL;
+
#ifdef _WIN32
static Ecore_Win32_Handler *win32_handlers = NULL;
static Ecore_Win32_Handler *win32_handler_current = NULL;
ERR("deleted fd in epoll");
continue;
}
- if (ev->events & EPOLLIN) fdh->read_active = 1;
- if (ev->events & EPOLLOUT) fdh->write_active = 1;
- if (ev->events & EPOLLERR) fdh->error_active = 1;
+ if (ev[i].events & EPOLLIN) fdh->read_active = 1;
+ if (ev[i].events & EPOLLOUT) fdh->write_active = 1;
+ if (ev[i].events & EPOLLERR) fdh->error_active = 1;
}
return ret;
else
*next_time = 0;
- _ecore_main_prepare_handlers();
+ if (fd_handlers_with_prep)
+ _ecore_main_prepare_handlers();
}
in_main_loop--;
{
INF("work");
_ecore_main_fd_handlers_call();
- _ecore_main_fd_handlers_buf_call();
+ if (fd_handlers_with_buffer)
+ _ecore_main_fd_handlers_buf_call();
while (_ecore_signal_count_get()) _ecore_signal_call();
_ecore_event_call();
_ecore_main_fd_handlers_cleanup();
fdh->func = func;
fdh->data = (void *)data;
fdh->buf_func = buf_func;
+ if (buf_func)
+ fd_handlers_with_buffer = eina_list_append(fd_handlers_with_buffer, fdh);
fdh->buf_data = (void *)buf_data;
fd_handlers = (Ecore_Fd_Handler *)
eina_inlist_append(EINA_INLIST_GET(fd_handlers),
"ecore_main_fd_handler_del");
return NULL;
}
+ if (fd_handler->delete_me)
+ /* FIXME: should this return NULL instead? */
+ return fd_handler->data;
+
fd_handler->delete_me = 1;
- fd_handlers_delete_me = 1;
_ecore_main_fdh_poll_del(fd_handler);
+ fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fd_handler);
+ if (fd_handler->prep_func && fd_handlers_with_prep)
+ fd_handlers_with_prep = eina_list_remove(fd_handlers_with_prep, fd_handler);
+ if (fd_handler->buf_func && fd_handlers_with_buffer)
+ fd_handlers_with_buffer = eina_list_remove(fd_handlers_with_buffer, fd_handler);
return fd_handler->data;
}
}
#endif
+/**
+ * @brief Set the prepare callback with data for a given #Ecore_Fd_Handler
+ * @param fd_handler The fd handler
+ * @param func The prep function
+ * @param data The data to pass to the prep function
+ * This function will be called prior to the the fd handler's callback function.
+ */
EAPI void
ecore_main_fd_handler_prepare_callback_set(Ecore_Fd_Handler *fd_handler, Ecore_Fd_Prep_Cb func, const void *data)
{
}
fd_handler->prep_func = func;
fd_handler->prep_data = (void *)data;
+ if (fd_handlers_with_prep && (!eina_list_data_find(fd_handlers_with_prep, fd_handler)))
+ /* FIXME: THIS WILL NOT SCALE WITH LOTS OF PREP FUNCTIONS!!! */
+ fd_handlers_with_prep = eina_list_append(fd_handlers_with_prep, fd_handler);
}
/**
ECORE_MAGIC_SET(fdh, ECORE_MAGIC_NONE);
free(fdh);
}
- fd_handlers_delete_me = 0;
+ if (fd_handlers_with_buffer)
+ eina_list_free(fd_handlers_with_buffer);
+ fd_handlers_with_buffer = NULL;
+ if (fd_handlers_with_prep)
+ eina_list_free(fd_handlers_with_prep);
+ fd_handlers_with_prep = NULL;
+ if (fd_handlers_to_delete)
+ eina_list_free(fd_handlers_to_delete);
+ fd_handlers_to_delete = NULL;
fd_handler_current = NULL;
#ifdef _WIN32
_ecore_main_prepare_handlers(void)
{
Ecore_Fd_Handler *fdh;
+ Eina_List *l, *l2;
- /* call the prepare callback for all handlers */
- EINA_INLIST_FOREACH(fd_handlers, fdh)
+ /* call the prepare callback for all handlers with prep functions */
+ EINA_LIST_FOREACH_SAFE(fd_handlers_with_prep, l, l2, fdh)
{
+ if (!fdh) fd_handlers_with_prep = eina_list_remove_list(l, fd_handlers_with_prep);
if (!fdh->delete_me && fdh->prep_func)
{
fdh->references++;
- fdh->prep_func (fdh->prep_data, fdh);
+ fdh->prep_func(fdh->prep_data, fdh);
fdh->references--;
}
+ else
+ fd_handlers_with_prep = eina_list_remove_list(fd_handlers_with_prep, l);
}
}
FD_ZERO(&exfds);
/* call the prepare callback for all handlers */
- _ecore_main_prepare_handlers();
+ if (fd_handlers_with_prep)
+ _ecore_main_prepare_handlers();
#ifndef HAVE_EPOLL
Ecore_Fd_Handler *fdh;
if (!fdh->func(fdh->data, fdh))
{
ERR("Fd function err returned 0, remove it");
- fdh->delete_me = 1;
- fd_handlers_delete_me = 1;
+ if (!fdh->delete_me)
+ {
+ fdh->delete_me = 1;
+ fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fdh);
+ }
found++;
}
fdh->references--;
else
{
ERR("Problematic fd found at %d! setting it for delete", fdh->fd);
- fdh->delete_me = 1;
- fd_handlers_delete_me = 1;
+ if (!fdh->delete_me)
+ {
+ fdh->delete_me = 1;
+ fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fdh);
+ }
+
found++;
}
}
_ecore_main_fd_handlers_cleanup(void)
{
Ecore_Fd_Handler *fdh;
- Eina_Inlist *l;
- int deleted_in_use = 0;
+ Eina_List *l, *l2;
- if (!fd_handlers_delete_me) return;
- for (l = EINA_INLIST_GET(fd_handlers); l; )
+ if (!fd_handlers_to_delete) return;
+ EINA_LIST_FOREACH_SAFE(fd_handlers_to_delete, l, l2, fdh)
{
- fdh = (Ecore_Fd_Handler *) l;
-
- l = l->next;
- if (fdh->delete_me)
- {
- if (fdh->references)
- {
- deleted_in_use++;
- continue;
- }
-
- fd_handlers = (Ecore_Fd_Handler *)
- eina_inlist_remove(EINA_INLIST_GET(fd_handlers),
- EINA_INLIST_GET(fdh));
- ECORE_MAGIC_SET(fdh, ECORE_MAGIC_NONE);
- free(fdh);
- }
+ if (!fdh) fd_handlers_to_delete = eina_list_remove_list(l, fd_handlers_to_delete);
+ /* fdh->delete_me should be set for all fdhs at the start of the list */
+ if (fdh->references)
+ continue;
+ if (fdh->buf_func && fd_handlers_with_buffer)
+ fd_handlers_with_buffer = eina_list_remove(fd_handlers_with_buffer, fdh);
+ if (fdh->prep_func && fd_handlers_with_prep)
+ fd_handlers_with_prep = eina_list_remove(fd_handlers_with_prep, fdh);
+ fd_handlers = (Ecore_Fd_Handler *)
+ eina_inlist_remove(EINA_INLIST_GET(fd_handlers), EINA_INLIST_GET(fdh));
+ ECORE_MAGIC_SET(fdh, ECORE_MAGIC_NONE);
+ free(fdh);
+ fd_handlers_to_delete = eina_list_remove_list(fd_handlers_to_delete, l);
}
- if (!deleted_in_use) fd_handlers_delete_me = 0;
}
#ifdef _WIN32
fdh->references++;
if (!fdh->func(fdh->data, fdh))
{
- fdh->delete_me = 1;
- fd_handlers_delete_me = 1;
+ if (!fdh->delete_me)
+ {
+ fdh->delete_me = 1;
+ fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fdh);
+ }
+
}
fdh->references--;
_ecore_main_fd_handlers_buf_call(void)
{
Ecore_Fd_Handler *fdh;
+ Eina_List *l, *l2;
int ret;
ret = 0;
- EINA_INLIST_FOREACH(fd_handlers, fdh)
+ EINA_LIST_FOREACH_SAFE(fd_handlers_with_buffer, l, l2, fdh)
{
- if (!fdh->delete_me)
+ if (!fdh) fd_handlers_with_buffer = eina_list_remove_list(l, fd_handlers_with_buffer);
+ if ((!fdh->delete_me) && fdh->buf_func)
{
- if (fdh->buf_func)
+ fdh->references++;
+ if (fdh->buf_func(fdh->buf_data, fdh))
{
- fdh->references++;
- if (fdh->buf_func(fdh->buf_data, fdh))
- {
- ret |= fdh->func(fdh->data, fdh);
- fdh->read_active = 1;
- }
- fdh->references--;
+ ret |= fdh->func(fdh->data, fdh);
+ fdh->read_active = 1;
}
+ fdh->references--;
}
+ else
+ fd_handlers_with_buffer = eina_list_remove_list(fd_handlers_with_buffer, l);
}
return ret;
}
}
/* if these calls caused any buffered events to appear - deal with them */
- _ecore_main_fd_handlers_buf_call();
+ if (fd_handlers_with_buffer)
+ _ecore_main_fd_handlers_buf_call();
/* if there are any - jump to processing them */
if (_ecore_event_exist())
/* post events onto the ecore event pipe if necessary */
process_events:
_ecore_main_fd_handlers_call();
- _ecore_main_fd_handlers_buf_call();
+ if (fd_handlers_with_buffer)
+ _ecore_main_fd_handlers_buf_call();
/* process signals into events .... */
while (_ecore_signal_count_get()) _ecore_signal_call();
/* handle events ... */
# include <config.h>
#endif
+#include <sys/time.h>
+
#ifdef HAVE_EVIL
# include <Evil.h>
#endif
-#ifdef EFL_HAVE_PTHREAD
-# include <pthread.h>
-# ifdef __linux__
-# include <sched.h>
-# include <sys/time.h>
-# include <sys/resource.h>
-# include <unistd.h>
-# include <sys/syscall.h>
-# include <errno.h>
-# endif
-#endif
-
#include "Ecore.h"
#include "ecore_private.h"
+#ifdef EFL_HAVE_THREADS
+
+# ifdef EFL_HAVE_POSIX_THREADS
+# include <pthread.h>
+# ifdef __linux__
+# include <sched.h>
+# include <sys/resource.h>
+# include <unistd.h>
+# include <sys/syscall.h>
+# include <errno.h>
+# endif
+
+# define PH(x) pthread_t x
+# define PHE(x, y) pthread_equal(x, y)
+# define PHS() pthread_self()
+# define PHC(x, f, d) pthread_create(&(x), NULL, (void*) f, d)
+# define PHJ(x, p) pthread_join(x, (void**)(&(p)))
+# define PHA(x) pthread_cancel(x)
+
+# define CD(x) pthread_cond_t x
+# define CDI(x) pthread_cond_init(&(x), NULL);
+# define CDD(x) pthread_cond_destroy(&(x));
+# define CDB(x) pthread_cond_broadcast(&(x));
+# define CDW(x, y, t) pthread_cond_timedwait(&(x), &(y), t);
+
+# define LK(x) pthread_mutex_t x
+# define LKI(x) pthread_mutex_init(&(x), NULL);
+# define LKD(x) pthread_mutex_destroy(&(x));
+# define LKL(x) pthread_mutex_lock(&(x));
+# define LKU(x) pthread_mutex_unlock(&(x));
+
+# define LRWK(x) pthread_rwlock_t x
+# define LRWKI(x) pthread_rwlock_init(&(x), NULL);
+# define LRWKD(x) pthread_rwlock_destroy(&(x));
+# define LRWKWL(x) pthread_rwlock_wrlock(&(x));
+# define LRWKRL(x) pthread_rwlock_rdlock(&(x));
+# define LRWKU(x) pthread_rwlock_unlock(&(x));
+
+# else /* EFL_HAVE_WIN32_THREADS */
+
+# define WIN32_LEAN_AND_MEAN
+# include <windows.h>
+# undef WIN32_LEAN_AND_MEAN
+
+typedef struct
+{
+ HANDLE thread;
+ void *val;
+} win32_thread;
+
+# define PH(x) win32_thread *x
+# define PHE(x, y) ((x) == (y))
+# define PHS() (HANDLE)GetCurrentThreadId()
+
+int _ecore_thread_win32_create(win32_thread **x, LPTHREAD_START_ROUTINE f, void *d)
+{
+ win32_thread *t;
+ t = (win32_thread *)calloc(1, sizeof(win32_thread));
+ if (!t)
+ return -1;
+
+ (t)->thread = CreateThread(NULL, 0, f, d, 0, NULL);
+ if (!t->thread)
+ {
+ free(t);
+ return -1;
+ }
+ t->val = d;
+ *x = t;
+
+ return 0;
+}
+# define PHC(x, f, d) _ecore_thread_win32_create(&(x), (LPTHREAD_START_ROUTINE)f, d)
+
+int _ecore_thread_win32_join(win32_thread *x, void **res)
+{
+ if (!PHE(x, PHS()))
+ {
+ WaitForSingleObject(x->thread, INFINITE);
+ CloseHandle(x->thread);
+ }
+ if (res) *res = x->val;
+
+ return 0;
+}
+
+# define PHJ(x, p) _ecore_thread_win32_join(x, (void**)(&(p)))
+# define PHA(x) TerminateThread(x->thread, 0)
+
+# define LK(x) HANDLE x
+# define LKI(x) x = CreateMutex(NULL, FALSE, NULL)
+# define LKD(x) CloseHandle(x)
+# define LKL(x) WaitForSingleObject(x, INFINITE)
+# define LKU(x) ReleaseMutex(x)
+
+typedef struct
+{
+ HANDLE semaphore;
+ LONG threads_count;
+ CRITICAL_SECTION threads_count_lock;
+} win32_cond;
+
+# define CD(x) win32_cond *x
+
+# define CDI(x) \
+ do { \
+ x = (win32_cond *)calloc(1, sizeof(win32_cond)); \
+ if (x) \
+ { \
+ x->semaphore = CreateSemaphore(NULL, 0, 0x7fffffff, NULL); \
+ if (x->semaphore) \
+ InitializeCriticalSection(&x->threads_count_lock); \
+ else \
+ { \
+ free(x); \
+ x = NULL; \
+ } \
+ } \
+ } while (0)
+
+# define CDD(x) \
+ do { \
+ CloseHandle(x->semaphore); \
+ free(x); \
+ x = NULL; \
+ } while (0)
+
+# define CDB(x) \
+do { \
+ EnterCriticalSection(&x->threads_count_lock); \
+ if (x->threads_count > 0) \
+ ReleaseSemaphore(x->semaphore, x->threads_count, NULL); \
+ LeaveCriticalSection (&x->threads_count_lock); \
+ } while (0)
+
+int _ecore_thread_win32_cond_timedwait(win32_cond *c, HANDLE *external_mutex, struct timeval *t)
+{
+ DWORD res;
+ DWORD val = t->tv_sec * 1000 + (t->tv_usec / 1000);
+ LKL(external_mutex);
+ EnterCriticalSection (&c->threads_count_lock);
+ c->threads_count++;
+ LeaveCriticalSection (&c->threads_count_lock);
+ LKU(external_mutex);
+ res = WaitForSingleObject(c->semaphore, val);
+ if (res == WAIT_OBJECT_0)
+ return 0;
+ else
+ return -1;
+}
+# define CDW(x, y, t) _ecore_thread_win32_cond_timedwait(x, y, t)
+
+typedef struct
+{
+ LONG readers_count;
+ LONG writers_count;
+ int readers;
+ int writers;
+ LK(mutex);
+ CD(cond_read);
+ CD(cond_write);
+} win32_rwl;
+
+# define LRWK(x) win32_rwl *x
+# define LRWKI(x) \
+ do { \
+ x = (win32_rwl *)calloc(1, sizeof(win32_rwl)); \
+ if (x) \
+ { \
+ LKI(x->mutex); \
+ if (x->mutex) \
+ { \
+ CDI(x->cond_read); \
+ if (x->cond_read) \
+ { \
+ CDI(x->cond_write); \
+ if (!x->cond_write) \
+ { \
+ CDD(x->cond_read); \
+ LKD(x->mutex); \
+ free(x); \
+ x = NULL; \
+ } \
+ } \
+ else \
+ { \
+ LKD(x->mutex); \
+ free(x); \
+ x = NULL; \
+ } \
+ } \
+ else \
+ { \
+ free(x); \
+ x = NULL; \
+ } \
+ } \
+ } while (0)
+
+# define LRWKD(x) \
+ do { \
+ LKU(x->mutex); \
+ LKD(x->mutex); \
+ CDD(x->cond_write); \
+ CDD(x->cond_read); \
+ free(x); \
+ } while (0)
+# define LRWKWL(x) \
+ do { \
+ DWORD res; \
+ LKU(x->mutex); \
+ if (x->writers || x->readers > 0) \
+ { \
+ x->writers_count++; \
+ while (x->writers || x->readers > 0) \
+ { \
+ EnterCriticalSection(&x->cond_write->threads_count_lock); \
+ x->cond_read->threads_count++; \
+ LeaveCriticalSection(&x->cond_write->threads_count_lock); \
+ res = WaitForSingleObject(x->cond_write->semaphore, INFINITE); \
+ if (res != WAIT_OBJECT_0) break; \
+ } \
+ x->writers_count--; \
+ } \
+ if (res == 0) x->writers_count = 1; \
+ LKU(x->mutex); \
+ } while (0)
+# define LRWKRL(x) \
+ do { \
+ DWORD res; \
+ LKL(x->mutex); \
+ if (x->writers) \
+ { \
+ x->readers_count++; \
+ while (x->writers) \
+ { \
+ EnterCriticalSection(&x->cond_write->threads_count_lock); \
+ x->cond_read->threads_count++; \
+ LeaveCriticalSection(&x->cond_write->threads_count_lock); \
+ res = WaitForSingleObject(x->cond_write->semaphore, INFINITE); \
+ if (res != WAIT_OBJECT_0) break; \
+ } \
+ x->readers_count--; \
+ } \
+ if (res == 0) \
+ x->readers++; \
+ LKU(x->mutex); \
+ } while (0)
+# define LRWKU(x) \
+ do { \
+ LKL(x->mutex); \
+ if (x->writers) \
+ { \
+ x->writers = 0; \
+ if (x->readers_count == 1) \
+ { \
+ EnterCriticalSection(&x->cond_read->threads_count_lock); \
+ if (x->cond_read->threads_count > 0) \
+ ReleaseSemaphore(x->cond_read->semaphore, 1, 0); \
+ LeaveCriticalSection(&x->cond_read->threads_count_lock); \
+ } \
+ else if (x->readers_count > 0) \
+ CDB(x->cond_read); \
+ else if (x->writers_count > 0) \
+ { \
+ EnterCriticalSection (&x->cond_write->threads_count_lock); \
+ if (x->cond_write->threads_count > 0) \
+ ReleaseSemaphore(x->cond_write->semaphore, 1, 0); \
+ LeaveCriticalSection (&x->cond_write->threads_count_lock); \
+ } \
+ } \
+ else if (x->readers > 0) \
+ { \
+ x->readers--; \
+ if (x->readers == 0 && x->writers_count > 0) \
+ { \
+ EnterCriticalSection (&x->cond_write->threads_count_lock); \
+ if (x->cond_write->threads_count > 0) \
+ ReleaseSemaphore(x->cond_write->semaphore, 1, 0); \
+ LeaveCriticalSection (&x->cond_write->threads_count_lock); \
+ } \
+ } \
+ LKU(x->mutex); \
+ } while (0)
+
+# endif
+
+#endif
+
typedef struct _Ecore_Pthread_Worker Ecore_Pthread_Worker;
typedef struct _Ecore_Pthread Ecore_Pthread;
typedef struct _Ecore_Thread_Data Ecore_Thread_Data;
{
union {
struct {
- Ecore_Thread_Heavy_Cb func_blocking;
+ Ecore_Thread_Cb func_blocking;
} short_run;
struct {
- Ecore_Thread_Heavy_Cb func_heavy;
+ Ecore_Thread_Cb func_heavy;
Ecore_Thread_Notify_Cb func_notify;
Ecore_Pipe *notify;
+ Ecore_Pipe *direct_pipe;
+ Ecore_Pthread_Worker *direct_worker;
+
int send;
int received;
} feedback_run;
} u;
- Ecore_Cb func_cancel;
- Ecore_Cb func_end;
-#ifdef EFL_HAVE_PTHREAD
- pthread_t self;
+ Ecore_Thread_Cb func_cancel;
+ Ecore_Thread_Cb func_end;
+#ifdef EFL_HAVE_THREADS
+ PH(self);
Eina_Hash *hash;
- pthread_cond_t cond;
- pthread_mutex_t mutex;
+ CD(cond);
+ LK(mutex);
#endif
const void *data;
Eina_Bool kill : 1;
};
-#ifdef EFL_HAVE_PTHREAD
+#ifdef EFL_HAVE_THREADS
typedef struct _Ecore_Pthread_Data Ecore_Pthread_Data;
struct _Ecore_Pthread_Data
{
+ Ecore_Pthread_Worker *death_job;
Ecore_Pipe *p;
void *data;
- pthread_t thread;
+ PH(thread);
};
#endif
+static void _ecore_thread_handler(void *data __UNUSED__, void *buffer, unsigned int nbyte);
+
static int _ecore_thread_count_max = 0;
static int ECORE_THREAD_PIPE_DEL = 0;
+static Eina_Array *_ecore_thread_pipe = NULL;
-#ifdef EFL_HAVE_PTHREAD
+static Ecore_Pipe*
+_ecore_thread_pipe_get(void)
+{
+ if (eina_array_count_get(_ecore_thread_pipe) > 0)
+ return eina_array_pop(_ecore_thread_pipe);
+
+ return ecore_pipe_add(_ecore_thread_handler, NULL);
+}
+
+#ifdef EFL_HAVE_THREADS
static int _ecore_thread_count = 0;
+static Ecore_Event_Handler *del_handler = NULL;
static Eina_List *_ecore_active_job_threads = NULL;
static Eina_List *_ecore_pending_job_threads = NULL;
static Eina_List *_ecore_pending_job_threads_feedback = NULL;
-static Ecore_Event_Handler *del_handler = NULL;
-static pthread_mutex_t _ecore_pending_job_threads_mutex = PTHREAD_MUTEX_INITIALIZER;
+static LK(_ecore_pending_job_threads_mutex);
static Eina_Hash *_ecore_thread_global_hash = NULL;
-static pthread_rwlock_t _ecore_thread_global_hash_lock = PTHREAD_RWLOCK_INITIALIZER;
-static pthread_mutex_t _ecore_thread_global_hash_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t _ecore_thread_global_hash_cond = PTHREAD_COND_INITIALIZER;
-static pthread_t main_loop_thread;
+static LRWK(_ecore_thread_global_hash_lock);
+static LK(_ecore_thread_global_hash_mutex);
+static CD(_ecore_thread_global_hash_cond);
+
+static PH(main_loop_thread);
static Eina_Bool have_main_loop_thread = 0;
+static Eina_Trash *_ecore_thread_worker_trash = NULL;
+static int _ecore_thread_worker_count = 0;
+
+static void
+_ecore_thread_worker_free(Ecore_Pthread_Worker *worker)
+{
+ if (_ecore_thread_worker_count > (_ecore_thread_count_max + 1) * 16)
+ {
+ free(worker);
+ return ;
+ }
+
+ eina_trash_push(&_ecore_thread_worker_trash, worker);
+}
+
static void
_ecore_thread_data_free(void *data)
{
{
Ecore_Pipe *p = event;
- ecore_pipe_del(p);
+ eina_array_push(_ecore_thread_pipe, p);
eina_threads_shutdown();
}
}
static void
-_ecore_thread_end(Ecore_Pthread_Data *pth)
+_ecore_thread_end(Ecore_Pthread_Data *pth, __UNUSED__ Ecore_Thread *work)
{
Ecore_Pipe *p;
- if (pthread_join(pth->thread, (void **) &p) != 0)
+ if (PHJ(pth->thread, p) != 0)
return ;
_ecore_active_job_threads = eina_list_remove(_ecore_active_job_threads, pth);
if (work->cancel)
{
if (work->func_cancel)
- work->func_cancel((void *) work->data);
+ work->func_cancel((void *) work->data, (Ecore_Thread *) work);
}
else
{
if (work->func_end)
- work->func_end((void *) work->data);
+ work->func_end((void *) work->data, (Ecore_Thread *) work);
}
if (work->feedback_run)
- ecore_pipe_del(work->u.feedback_run.notify);
- pthread_cond_destroy(&work->cond);
- pthread_mutex_destroy(&work->mutex);
+ {
+ ecore_pipe_del(work->u.feedback_run.notify);
+
+ if (work->u.feedback_run.direct_pipe)
+ eina_array_push(_ecore_thread_pipe, work->u.feedback_run.direct_pipe);
+ if (work->u.feedback_run.direct_worker)
+ _ecore_thread_worker_free(work->u.feedback_run.direct_worker);
+ }
+ CDD(work->cond);
+ LKD(work->mutex);
if (work->hash)
eina_hash_free(work->hash);
free(work);
work->u.feedback_run.received++;
if (work->u.feedback_run.func_notify)
- work->u.feedback_run.func_notify((Ecore_Thread *) work, user_data, (void *) work->data);
+ work->u.feedback_run.func_notify((void *) work->data, (Ecore_Thread *) work, user_data);
/* Force reading all notify event before killing the thread */
if (work->kill && work->u.feedback_run.send == work->u.feedback_run.received)
while (_ecore_pending_job_threads)
{
- pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
+ LKL(_ecore_pending_job_threads_mutex);
if (!_ecore_pending_job_threads)
{
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
break;
}
_ecore_pending_job_threads = eina_list_remove_list(_ecore_pending_job_threads,
_ecore_pending_job_threads);
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
if (!work->cancel)
- work->u.short_run.func_blocking((Ecore_Thread*) work, (void *) work->data);
+ work->u.short_run.func_blocking((void *) work->data, (Ecore_Thread*) work);
ecore_pipe_write(end_pipe, &work, sizeof (Ecore_Pthread_Worker *));
}
}
static void
-_ecore_feedback_job(Ecore_Pipe *end_pipe, pthread_t thread)
+_ecore_feedback_job(Ecore_Pipe *end_pipe, PH(thread))
{
Ecore_Pthread_Worker *work;
while (_ecore_pending_job_threads_feedback)
{
- pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
+ LKL(_ecore_pending_job_threads_mutex);
if (!_ecore_pending_job_threads_feedback)
{
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
break;
}
_ecore_pending_job_threads_feedback = eina_list_remove_list(_ecore_pending_job_threads_feedback,
_ecore_pending_job_threads_feedback);
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
work->self = thread;
if (!work->cancel)
- work->u.feedback_run.func_heavy((Ecore_Thread *) work, (void *) work->data);
+ work->u.feedback_run.func_heavy((void *) work->data, (Ecore_Thread *) work);
ecore_pipe_write(end_pipe, &work, sizeof (Ecore_Pthread_Worker *));
}
{
Ecore_Pthread_Data *pth;
+#ifdef EFL_POSIX_THREADS
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+#endif
+
eina_sched_prio_drop();
pth = malloc(sizeof (Ecore_Pthread_Data));
if (!pth) return NULL;
- pth->p = ecore_pipe_add(_ecore_thread_handler, NULL);
+ pth->p = work->u.feedback_run.direct_pipe;
if (!pth->p)
{
free(pth);
return NULL;
}
- pth->thread = pthread_self();
+ pth->thread = PHS();
work->self = pth->thread;
- work->u.feedback_run.func_heavy((Ecore_Thread *) work, (void *) work->data);
+ work->u.feedback_run.func_heavy((void *) work->data, (Ecore_Thread *) work);
ecore_pipe_write(pth->p, &work, sizeof (Ecore_Pthread_Worker *));
- work = malloc(sizeof (Ecore_Pthread_Worker));
+ work = work->u.feedback_run.direct_worker;
if (!work)
{
- ecore_pipe_del(pth->p);
free(pth);
return NULL;
}
work->feedback_run = EINA_FALSE;
work->kill = EINA_FALSE;
work->hash = NULL;
- pthread_cond_init(&work->cond, NULL);
- pthread_mutex_init(&work->mutex, NULL);
+ CDI(work->cond);
+ LKI(work->mutex);
ecore_pipe_write(pth->p, &work, sizeof (Ecore_Pthread_Worker *));
{
Ecore_Pthread_Worker *work;
+#ifdef EFL_POSIX_THREADS
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
+#endif
+
eina_sched_prio_drop();
- pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
+ LKL(_ecore_pending_job_threads_mutex);
_ecore_thread_count++;
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
restart:
if (_ecore_pending_job_threads) _ecore_short_job(pth->p);
/* FIXME: Check if there is feedback running task todo, and switch to feedback run handler. */
- pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
- if (_ecore_pending_job_threads)
+ LKL(_ecore_pending_job_threads_mutex);
+ if (_ecore_pending_job_threads || _ecore_pending_job_threads_feedback)
{
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
goto restart;
}
- if (_ecore_pending_job_threads_feedback)
- {
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
- goto restart;
- }
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
/* Sleep a little to prevent premature death */
usleep(200);
- pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
- if (_ecore_pending_job_threads)
- {
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
- goto restart;
- }
- if (_ecore_pending_job_threads_feedback)
+ LKL(_ecore_pending_job_threads_mutex);
+ if (_ecore_pending_job_threads || _ecore_pending_job_threads_feedback)
{
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
goto restart;
}
_ecore_thread_count--;
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
- work = malloc(sizeof (Ecore_Pthread_Worker));
+ work = pth->death_job;
if (!work) return NULL;
work->data = pth;
work->feedback_run = EINA_FALSE;
work->kill = EINA_FALSE;
work->hash = NULL;
- pthread_cond_init(&work->cond, NULL);
- pthread_mutex_init(&work->mutex, NULL);
+ CDI(work->cond);
+ LKI(work->mutex);
ecore_pipe_write(pth->p, &work, sizeof (Ecore_Pthread_Worker *));
#endif
+static Ecore_Pthread_Worker *
+_ecore_thread_worker_new(void)
+{
+ Ecore_Pthread_Worker *result;
+
+#ifdef EFL_HAVE_THREADS
+ result = eina_trash_pop(&_ecore_thread_worker_trash);
+
+ if (!result) result = malloc(sizeof (Ecore_Pthread_Worker));
+ else _ecore_thread_worker_count--;
+
+ return result;
+#else
+ return malloc(sizeof (Ecore_Pthread_Worker));
+#endif
+}
+
void
_ecore_thread_init(void)
{
_ecore_thread_count_max = 1;
ECORE_THREAD_PIPE_DEL = ecore_event_type_new();
-#ifdef EFL_HAVE_PTHREAD
+ _ecore_thread_pipe = eina_array_new(8);
+
+#ifdef EFL_HAVE_THREADS
del_handler = ecore_event_handler_add(ECORE_THREAD_PIPE_DEL, _ecore_thread_pipe_del, NULL);
- main_loop_thread = pthread_self();
+ main_loop_thread = PHS();
have_main_loop_thread = 1;
+
+ LKI(_ecore_pending_job_threads_mutex);
+ LRWKI(_ecore_thread_global_hash_lock);
+ LKI(_ecore_thread_global_hash_mutex);
+ CDI(_ecore_thread_global_hash_cond);
#endif
}
_ecore_thread_shutdown(void)
{
/* FIXME: If function are still running in the background, should we kill them ? */
-#ifdef EFL_HAVE_PTHREAD
+ Ecore_Pipe *p;
+ Eina_Array_Iterator it;
+ unsigned int i;
+
+#ifdef EFL_HAVE_THREADS
Ecore_Pthread_Worker *work;
Ecore_Pthread_Data *pth;
- pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
+ LKL(_ecore_pending_job_threads_mutex);
EINA_LIST_FREE(_ecore_pending_job_threads, work)
{
if (work->func_cancel)
- work->func_cancel((void *)work->data);
+ work->func_cancel((void *)work->data, (Ecore_Thread *) work);
free(work);
}
EINA_LIST_FREE(_ecore_pending_job_threads_feedback, work)
{
if (work->func_cancel)
- work->func_cancel((void *)work->data);
+ work->func_cancel((void *)work->data, (Ecore_Thread *) work);
free(work);
}
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
+ /* Improve emergency shutdown */
EINA_LIST_FREE(_ecore_active_job_threads, pth)
{
Ecore_Pipe *p;
- pthread_cancel(pth->thread);
- pthread_join(pth->thread, (void **) &p);
+ PHA(pth->thread);
+ PHJ(pth->thread, p);
ecore_pipe_del(pth->p);
}
ecore_event_handler_del(del_handler);
have_main_loop_thread = 0;
del_handler = NULL;
+
+ LKD(_ecore_pending_job_threads_mutex);
+ LRWKD(_ecore_thread_global_hash_lock);
+ LKD(_ecore_thread_global_hash_mutex);
+ CDD(_ecore_thread_global_hash_cond);
#endif
+
+ EINA_ARRAY_ITER_NEXT(_ecore_thread_pipe, i, p, it)
+ ecore_pipe_del(p);
+
+ eina_array_free(_ecore_thread_pipe);
+ _ecore_thread_pipe = NULL;
}
/**
* host CPU can handle.
*/
EAPI Ecore_Thread *
-ecore_thread_run(Ecore_Thread_Heavy_Cb func_blocking,
- Ecore_Cb func_end,
- Ecore_Cb func_cancel,
+ecore_thread_run(Ecore_Thread_Cb func_blocking,
+ Ecore_Thread_Cb func_end,
+ Ecore_Thread_Cb func_cancel,
const void *data)
{
Ecore_Pthread_Worker *work;
-#ifdef EFL_HAVE_PTHREAD
+#ifdef EFL_HAVE_THREADS
Ecore_Pthread_Data *pth = NULL;
#endif
if (!func_blocking) return NULL;
- work = malloc(sizeof (Ecore_Pthread_Worker));
+ work = _ecore_thread_worker_new();
if (!work)
{
if (func_cancel)
- func_cancel((void *) data);
+ func_cancel((void *) data, NULL);
return NULL;
}
work->kill = EINA_FALSE;
work->data = data;
-#ifdef EFL_HAVE_PTHREAD
+#ifdef EFL_HAVE_THREADS
work->hash = NULL;
- pthread_cond_init(&work->cond, NULL);
- pthread_mutex_init(&work->mutex, NULL);
+ CDI(work->cond);
+ LKI(work->mutex);
- pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
+ LKL(_ecore_pending_job_threads_mutex);
_ecore_pending_job_threads = eina_list_append(_ecore_pending_job_threads, work);
if (_ecore_thread_count == _ecore_thread_count_max)
{
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
return (Ecore_Thread *) work;
}
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
/* One more thread could be created. */
pth = malloc(sizeof (Ecore_Pthread_Data));
if (!pth) goto on_error;
- pth->p = ecore_pipe_add(_ecore_thread_handler, NULL);
- if (!pth->p) goto on_error;
+ pth->p = _ecore_thread_pipe_get();
+ pth->death_job = _ecore_thread_worker_new();
+ if (!pth->p || !pth->death_job) goto on_error;
eina_threads_init();
- if (pthread_create(&pth->thread, NULL, (void *) _ecore_thread_worker, pth) == 0)
+ if (PHC(pth->thread, _ecore_thread_worker, pth) == 0)
return (Ecore_Thread *) work;
eina_threads_shutdown();
on_error:
if (pth)
{
- if (pth->p) ecore_pipe_del(pth->p);
- pth->p = NULL;
+ if (pth->p) eina_array_push(_ecore_thread_pipe, pth->p);
+ if (pth->death_job) _ecore_thread_worker_free(pth->death_job);
free(pth);
}
if (_ecore_thread_count == 0)
{
- pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
+ LKL(_ecore_pending_job_threads_mutex);
_ecore_pending_job_threads = eina_list_remove(_ecore_pending_job_threads, work);
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
if (work->func_cancel)
- work->func_cancel((void *) work->data);
+ work->func_cancel((void *) work->data, (Ecore_Thread *) work);
free(work);
work = NULL;
}
If no thread and as we don't want to break app that rely on this
facility, we will lock the interface until we are done.
*/
- func_blocking((Ecore_Thread *) work, (void *)data);
- func_end((void *)data);
+ func_blocking((void *)data, (Ecore_Thread *) work);
+ if (work->cancel == EINA_FALSE) func_end((void *)data, (Ecore_Thread *) work);
+ else func_end((void *)data, (Ecore_Thread *) work);
+
+ free(work);
return NULL;
#endif
EAPI Eina_Bool
ecore_thread_cancel(Ecore_Thread *thread)
{
-#ifdef EFL_HAVE_PTHREAD
+#ifdef EFL_HAVE_THREADS
Ecore_Pthread_Worker *work = (Ecore_Pthread_Worker *)thread;
Eina_List *l;
goto on_exit;
}
- pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
+ LKL(_ecore_pending_job_threads_mutex);
if ((have_main_loop_thread) &&
- (pthread_equal(main_loop_thread, pthread_self())))
+ (PHE(main_loop_thread, PHS())))
{
if (!work->feedback_run)
EINA_LIST_FOREACH(_ecore_pending_job_threads, l, work)
{
_ecore_pending_job_threads = eina_list_remove_list(_ecore_pending_job_threads, l);
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
if (work->func_cancel)
- work->func_cancel((void *) work->data);
+ work->func_cancel((void *) work->data, (Ecore_Thread *) work);
free(work);
return EINA_TRUE;
{
_ecore_pending_job_threads_feedback = eina_list_remove_list(_ecore_pending_job_threads_feedback, l);
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
if (work->func_cancel)
- work->func_cancel((void *) work->data);
+ work->func_cancel((void *) work->data, (Ecore_Thread *) work);
free(work);
return EINA_TRUE;
}
}
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
/* Delay the destruction */
on_exit:
* the CPU down, so be careful with that. Of course if it can't start a new thread, it will
* try to use one from the pool.
*/
-EAPI Ecore_Thread *ecore_thread_feedback_run(Ecore_Thread_Heavy_Cb func_heavy,
+EAPI Ecore_Thread *ecore_thread_feedback_run(Ecore_Thread_Cb func_heavy,
Ecore_Thread_Notify_Cb func_notify,
- Ecore_Cb func_end,
- Ecore_Cb func_cancel,
+ Ecore_Thread_Cb func_end,
+ Ecore_Thread_Cb func_cancel,
const void *data,
Eina_Bool try_no_queue)
{
-#ifdef EFL_HAVE_PTHREAD
+#ifdef EFL_HAVE_THREADS
Ecore_Pthread_Worker *worker;
Ecore_Pthread_Data *pth = NULL;
if (!func_heavy) return NULL;
- worker = malloc(sizeof (Ecore_Pthread_Worker));
+ worker = _ecore_thread_worker_new();
if (!worker) goto on_error;
worker->u.feedback_run.func_heavy = func_heavy;
worker->u.feedback_run.func_notify = func_notify;
worker->hash = NULL;
- pthread_cond_init(&worker->cond, NULL);
- pthread_mutex_init(&worker->mutex, NULL);
+ CDI(worker->cond);
+ LKI(worker->mutex);
worker->func_cancel = func_cancel;
worker->func_end = func_end;
worker->data = data;
worker->u.feedback_run.received = 0;
worker->u.feedback_run.notify = ecore_pipe_add(_ecore_notify_handler, worker);
+ worker->u.feedback_run.direct_pipe = NULL;
+ worker->u.feedback_run.direct_worker = NULL;
if (!try_no_queue)
{
- pthread_t t;
+ PH(t);
+
+ worker->u.feedback_run.direct_pipe = _ecore_thread_pipe_get();
+ worker->u.feedback_run.direct_worker = _ecore_thread_worker_new();
- if (pthread_create(&t, NULL, (void *) _ecore_direct_worker, worker) == 0)
+ if (PHC(t, _ecore_direct_worker, worker) == 0)
return (Ecore_Thread *) worker;
}
- pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
+ LKL(_ecore_pending_job_threads_mutex);
_ecore_pending_job_threads_feedback = eina_list_append(_ecore_pending_job_threads_feedback, worker);
if (_ecore_thread_count == _ecore_thread_count_max)
{
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
return (Ecore_Thread *) worker;
}
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
/* One more thread could be created. */
pth = malloc(sizeof (Ecore_Pthread_Data));
if (!pth) goto on_error;
- pth->p = ecore_pipe_add(_ecore_thread_handler, NULL);
- if (!pth->p) goto on_error;
+ pth->p = _ecore_thread_pipe_get();
+ pth->death_job = _ecore_thread_worker_new();
+ if (!pth->p || !pth->death_job) goto on_error;
eina_threads_init();
- if (pthread_create(&pth->thread, NULL, (void *) _ecore_thread_worker, pth) == 0)
+ if (PHC(pth->thread, _ecore_thread_worker, pth) == 0)
return (Ecore_Thread *) worker;
eina_threads_shutdown();
on_error:
if (pth)
{
- if (pth->p) ecore_pipe_del(pth->p);
+ if (pth->p) eina_array_push(_ecore_thread_pipe, pth->p);
+ if (pth->death_job) _ecore_thread_worker_free(pth->death_job);
free(pth);
}
if (_ecore_thread_count == 0)
{
- pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
+ LKL(_ecore_pending_job_threads_mutex);
_ecore_pending_job_threads_feedback = eina_list_remove(_ecore_pending_job_threads_feedback,
worker);
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
- if (func_cancel) func_cancel((void *) data);
+ if (func_cancel) func_cancel((void *) data, NULL);
if (worker)
{
worker.feedback_run = EINA_TRUE;
worker.kill = EINA_FALSE;
- func_heavy((Ecore_Thread *) &worker, (void *)data);
+ func_heavy((void *)data, (Ecore_Thread *) &worker);
- if (worker.func_cancel) func_cancel((void *)data);
- else func_end((void *)data);
+ if (worker.cancel) func_cancel((void *)data, (Ecore_Thread *) &worker);
+ else func_end((void *)data, (Ecore_Thread *) &worker);
return NULL;
#endif
if (!worker) return EINA_FALSE;
if (!worker->feedback_run) return EINA_FALSE;
-#ifdef EFL_HAVE_PTHREAD
- if (!pthread_equal(worker->self, pthread_self())) return EINA_FALSE;
+#ifdef EFL_HAVE_THREADS
+ if (!PHE(worker->self, PHS())) return EINA_FALSE;
worker->u.feedback_run.send++;
ecore_pipe_write(worker->u.feedback_run.notify, &data, sizeof (void *));
return EINA_TRUE;
#else
- worker->u.feedback_run.func_notify(thread, (void*) data, (void*) worker->data);
+ worker->u.feedback_run.func_notify((void*) worker->data, thread, (void*) data);
return EINA_TRUE;
#endif
EAPI int
ecore_thread_active_get(void)
{
-#ifdef EFL_HAVE_PTHREAD
+#ifdef EFL_HAVE_THREADS
return _ecore_thread_count;
#else
return 0;
ecore_thread_pending_get(void)
{
int ret;
-#ifdef EFL_HAVE_PTHREAD
- pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
+#ifdef EFL_HAVE_THREADS
+ LKL(_ecore_pending_job_threads_mutex);
ret = eina_list_count(_ecore_pending_job_threads);
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
return ret;
#else
return 0;
ecore_thread_pending_feedback_get(void)
{
int ret;
-#ifdef EFL_HAVE_PTHREAD
- pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
+#ifdef EFL_HAVE_THREADS
+ LKL(_ecore_pending_job_threads_mutex);
ret = eina_list_count(_ecore_pending_job_threads_feedback);
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
return ret;
#else
return 0;
ecore_thread_pending_total_get(void)
{
int ret;
-#ifdef EFL_HAVE_PTHREAD
- pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
+#ifdef EFL_HAVE_THREADS
+ LKL(_ecore_pending_job_threads_mutex);
ret = eina_list_count(_ecore_pending_job_threads) + eina_list_count(_ecore_pending_job_threads_feedback);
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
return ret;
#else
return 0;
ecore_thread_available_get(void)
{
int ret;
-#ifdef EFL_HAVE_PTHREAD
- pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
+#ifdef EFL_HAVE_THREADS
+ LKL(_ecore_pending_job_threads_mutex);
ret = _ecore_thread_count_max - _ecore_thread_count;
- pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
+ LKU(_ecore_pending_job_threads_mutex);
return ret;
#else
return 0;
if ((!thread) || (!key) || (!value))
return EINA_FALSE;
-#ifdef EFL_HAVE_PTHREAD
- if (!pthread_equal(worker->self, pthread_self())) return EINA_FALSE;
+#ifdef EFL_HAVE_THREADS
+ if (!PHE(worker->self, PHS())) return EINA_FALSE;
if (!worker->hash)
worker->hash = eina_hash_string_small_new(_ecore_thread_data_free);
ret = eina_hash_direct_add(worker->hash, key, d);
else
ret = eina_hash_add(worker->hash, key, d);
- pthread_cond_broadcast(&worker->cond);
+ CDB(worker->cond);
return ret;
#else
return EINA_TRUE;
void *ret;
if ((!thread) || (!key) || (!value))
return NULL;
-#ifdef EFL_HAVE_PTHREAD
- if (!pthread_equal(worker->self, pthread_self())) return NULL;
+#ifdef EFL_HAVE_THREADS
+ if (!PHE(worker->self, PHS())) return NULL;
if (!worker->hash)
worker->hash = eina_hash_string_small_new(_ecore_thread_data_free);
d->cb = cb;
r = eina_hash_set(worker->hash, key, d);
- pthread_cond_broadcast(&worker->cond);
+ CDB(worker->cond);
ret = r->data;
free(r);
return ret;
if ((!thread) || (!key))
return NULL;
-#ifdef EFL_HAVE_PTHREAD
- if (!pthread_equal(worker->self, pthread_self())) return NULL;
+#ifdef EFL_HAVE_THREADS
+ if (!PHE(worker->self, PHS())) return NULL;
if (!worker->hash)
return NULL;
Ecore_Thread_Data *d;
if ((!thread) || (!key))
return EINA_FALSE;
-#ifdef EFL_HAVE_PTHREAD
- if (!pthread_equal(worker->self, pthread_self())) return EINA_FALSE;
+#ifdef EFL_HAVE_THREADS
+ if (!PHE(worker->self, PHS())) return EINA_FALSE;
if (!worker->hash)
return EINA_FALSE;
if ((!key) || (!value))
return EINA_FALSE;
-#ifdef EFL_HAVE_PTHREAD
- pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
+#ifdef EFL_HAVE_THREADS
+ LRWKWL(_ecore_thread_global_hash_lock);
if (!_ecore_thread_global_hash)
_ecore_thread_global_hash = eina_hash_string_small_new(_ecore_thread_data_free);
- pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
+ LRWKU(_ecore_thread_global_hash_lock);
if (!(d = malloc(sizeof(Ecore_Thread_Data))))
return EINA_FALSE;
if (!_ecore_thread_global_hash)
return EINA_FALSE;
- pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
+ LRWKWL(_ecore_thread_global_hash_lock);
if (direct)
ret = eina_hash_direct_add(_ecore_thread_global_hash, key, d);
else
ret = eina_hash_add(_ecore_thread_global_hash, key, d);
- pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
- pthread_cond_broadcast(&_ecore_thread_global_hash_cond);
+ LRWKU(_ecore_thread_global_hash_lock);
+ CDB(_ecore_thread_global_hash_cond);
return ret;
#else
return EINA_TRUE;
if ((!key) || (!value))
return NULL;
-#ifdef EFL_HAVE_PTHREAD
- pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
+#ifdef EFL_HAVE_THREADS
+ LRWKWL(_ecore_thread_global_hash_lock);
if (!_ecore_thread_global_hash)
_ecore_thread_global_hash = eina_hash_string_small_new(_ecore_thread_data_free);
- pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
+ LRWKU(_ecore_thread_global_hash_lock);
if (!_ecore_thread_global_hash)
return NULL;
d->data = value;
d->cb = cb;
- pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
+ LRWKWL(_ecore_thread_global_hash_lock);
r = eina_hash_set(_ecore_thread_global_hash, key, d);
- pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
- pthread_cond_broadcast(&_ecore_thread_global_hash_cond);
+ LRWKU(_ecore_thread_global_hash_lock);
+ CDB(_ecore_thread_global_hash_cond);
ret = r->data;
free(r);
Ecore_Thread_Data *ret;
if (!key)
return NULL;
-#ifdef EFL_HAVE_PTHREAD
+#ifdef EFL_HAVE_THREADS
if (!_ecore_thread_global_hash) return NULL;
- pthread_rwlock_rdlock(&_ecore_thread_global_hash_lock);
+ LRWKRL(_ecore_thread_global_hash_lock);
ret = eina_hash_find(_ecore_thread_global_hash, key);
- pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
+ LRWKU(_ecore_thread_global_hash_lock);
return ret->data;
#else
return NULL;
if (!key)
return EINA_FALSE;
-#ifdef EFL_HAVE_PTHREAD
+#ifdef EFL_HAVE_THREADS
if (!_ecore_thread_global_hash)
return EINA_FALSE;
- pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
+ LRWKWL(_ecore_thread_global_hash_lock);
if ((d = eina_hash_find(_ecore_thread_global_hash, key)))
_ecore_thread_data_free(d);
ret = eina_hash_del_by_key(_ecore_thread_global_hash, key);
- pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
+ LRWKU(_ecore_thread_global_hash_lock);
return ret;
#else
return EINA_TRUE;
Ecore_Thread_Data *ret = NULL;
if (!key)
return NULL;
-#ifdef EFL_HAVE_PTHREAD
+#ifdef EFL_HAVE_THREADS
if (!_ecore_thread_global_hash)
return NULL;
if (seconds > 0)
while (1)
{
+#ifndef _WIN32
struct timespec t = { 0, 0 };
t.tv_sec = (long int)time;
t.tv_nsec = (long int)((time - (double)t.tv_sec) * 1000000000);
- pthread_rwlock_rdlock(&_ecore_thread_global_hash_lock);
+#else
+ struct timeval t = { 0, 0 };
+
+ t.tv_sec = (long int)time;
+ t.tv_usec = (long int)((time - (double)t.tv_sec) * 1000000);
+#endif
+ LRWKRL(_ecore_thread_global_hash_lock);
ret = eina_hash_find(_ecore_thread_global_hash, key);
- pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
+ LRWKU(_ecore_thread_global_hash_lock);
if ((ret) || (!seconds) || ((seconds > 0) && (time <= ecore_time_get())))
break;
- pthread_mutex_lock(&_ecore_thread_global_hash_mutex);
- pthread_cond_timedwait(&_ecore_thread_global_hash_cond, &_ecore_thread_global_hash_mutex, &t);
- pthread_mutex_unlock(&_ecore_thread_global_hash_mutex);
+ LKL(_ecore_thread_global_hash_mutex);
+ CDW(_ecore_thread_global_hash_cond, _ecore_thread_global_hash_mutex, &t);
+ LKU(_ecore_thread_global_hash_mutex);
}
if (ret) return ret->data;
return NULL;
@EVAS_CFLAGS@ \
@EINA_CFLAGS@
-if BUILD_ECORE_COCOA
-
lib_LTLIBRARIES = libecore_cocoa.la
includes_HEADERS = \
Ecore_Cocoa.h \
libecore_cocoa_la_LDFLAGS = @cocoa_ldflags@ -version-info @version_info@ @release_info@
-endif
-
EXTRA_DIST = ecore_cocoa_private.h
EAPI double ecore_con_client_uptime_get(Ecore_Con_Client *cl);
EAPI double ecore_con_client_timeout_get(Ecore_Con_Client *cl);
EAPI void ecore_con_client_timeout_set(Ecore_Con_Client *cl, double timeout);
+EAPI Eina_Bool ecore_con_client_connected_get(Ecore_Con_Client *cl);
/**
* @}
@CARES_CFLAGS@ \
@WIN32_CPPFLAGS@
-if BUILD_ECORE_CON
-
lib_LTLIBRARIES = libecore_con.la
includes_HEADERS = Ecore_Con.h
includesdir = $(includedir)/ecore-@VMAJ@
libecore_con_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@
-endif
-
EXTRA_DIST = ecore_con_private.h
static Eina_Bool _ecore_con_client_timer(Ecore_Con_Client *cl);
static void _ecore_con_cl_timer_update(Ecore_Con_Client *cl);
-static void _ecore_con_cb_tcp_connect(void *data, Ecore_Con_Info *info);
-static void _ecore_con_cb_udp_connect(void *data, Ecore_Con_Info *info);
-static void _ecore_con_cb_tcp_listen(void *data, Ecore_Con_Info *info);
-static void _ecore_con_cb_udp_listen(void *data, Ecore_Con_Info *info);
+static void _ecore_con_cb_tcp_connect(void *data,
+ Ecore_Con_Info *info);
+static void _ecore_con_cb_udp_connect(void *data,
+ Ecore_Con_Info *info);
+static void _ecore_con_cb_tcp_listen(void *data,
+ Ecore_Con_Info *info);
+static void _ecore_con_cb_udp_listen(void *data,
+ Ecore_Con_Info *info);
static void _ecore_con_server_free(Ecore_Con_Server *svr);
static void _ecore_con_client_free(Ecore_Con_Client *cl);
-static Eina_Bool _ecore_con_svr_tcp_handler(void *data, Ecore_Fd_Handler *fd_handler);
-static Eina_Bool _ecore_con_cl_handler(void *data, Ecore_Fd_Handler *fd_handler);
-static Eina_Bool _ecore_con_cl_udp_handler(void *data, Ecore_Fd_Handler *fd_handler);
-static Eina_Bool _ecore_con_svr_udp_handler(void *data, Ecore_Fd_Handler *fd_handler);
+static Eina_Bool _ecore_con_svr_tcp_handler(void *data,
+ Ecore_Fd_Handler *fd_handler);
+static Eina_Bool _ecore_con_cl_handler(void *data,
+ Ecore_Fd_Handler *fd_handler);
+static Eina_Bool _ecore_con_cl_udp_handler(void *data,
+ Ecore_Fd_Handler *fd_handler);
+static Eina_Bool _ecore_con_svr_udp_handler(void *data,
+ Ecore_Fd_Handler *fd_handler);
static void _ecore_con_svr_cl_read(Ecore_Con_Client *cl);
-static Eina_Bool _ecore_con_svr_cl_handler(void *data, Ecore_Fd_Handler *fd_handler);
-
-static void _ecore_con_server_flush(Ecore_Con_Server *svr);
-static void _ecore_con_client_flush(Ecore_Con_Client *cl);
-
-static void _ecore_con_event_client_add_free(void *data, void *ev);
-static void _ecore_con_event_client_del_free(void *data, void *ev);
-static void _ecore_con_event_client_data_free(void *data, void *ev);
-static void _ecore_con_event_server_add_free(void *data, void *ev);
-static void _ecore_con_event_server_del_free(void *data, void *ev);
-static void _ecore_con_event_server_data_free(void *data, void *ev);
-
-static void _ecore_con_lookup_done(void *data, Ecore_Con_Info *infos);
+static Eina_Bool _ecore_con_svr_cl_handler(void *data,
+ Ecore_Fd_Handler *fd_handler);
+
+static void _ecore_con_server_flush(Ecore_Con_Server *svr);
+static void _ecore_con_client_flush(Ecore_Con_Client *cl);
+
+static void _ecore_con_event_client_add_free(void *data,
+ void *ev);
+static void _ecore_con_event_client_del_free(void *data,
+ void *ev);
+static void _ecore_con_event_client_data_free(void *data,
+ void *ev);
+static void _ecore_con_event_server_add_free(void *data,
+ void *ev);
+static void _ecore_con_event_server_del_free(void *data,
+ void *ev);
+static void _ecore_con_event_server_data_free(void *data,
+ void *ev);
+
+static void _ecore_con_lookup_done(void *data,
+ Ecore_Con_Info *infos);
+
+static const char *
+_ecore_con_pretty_ip(struct sockaddr *client_addr,
+ socklen_t size);
EAPI int ECORE_CON_EVENT_CLIENT_ADD = 0;
EAPI int ECORE_CON_EVENT_CLIENT_DEL = 0;
ecore_con_init(void)
{
if (++_ecore_con_init_count != 1)
- return _ecore_con_init_count;
+ return _ecore_con_init_count;
#ifdef HAVE_EVIL
if (!evil_init())
- return --_ecore_con_init_count;
+ return --_ecore_con_init_count;
#endif
if (!ecore_init())
- return --_ecore_con_init_count;
+ return --_ecore_con_init_count;
_ecore_con_log_dom = eina_log_domain_register
- ("ecore_con", ECORE_CON_DEFAULT_LOG_COLOR);
- if(_ecore_con_log_dom < 0)
+ ("ecore_con", ECORE_CON_DEFAULT_LOG_COLOR);
+ if (_ecore_con_log_dom < 0)
{
EINA_LOG_ERR("Impossible to create a log domain for Ecore Con.");
ecore_shutdown();
ECORE_CON_EVENT_CLIENT_DATA = ecore_event_type_new();
ECORE_CON_EVENT_SERVER_DATA = ecore_event_type_new();
+
+ eina_magic_string_set(ECORE_MAGIC_CON_SERVER, "Ecore_Con_Server");
+ eina_magic_string_set(ECORE_MAGIC_CON_CLIENT, "Ecore_Con_Server");
+ eina_magic_string_set(ECORE_MAGIC_CON_URL, "Ecore_Con_Url");
+
/* TODO Remember return value, if it fails, use gethostbyname() */
ecore_con_ssl_init();
ecore_con_info_init();
EAPI int
ecore_con_shutdown(void)
{
+ Eina_List *l, *l2;
+ Ecore_Con_Server *svr;
+
if (--_ecore_con_init_count != 0)
- return _ecore_con_init_count;
+ return _ecore_con_init_count;
- while (servers)
- _ecore_con_server_free(eina_list_data_get(servers));
+ EINA_LIST_FOREACH_SAFE(servers, l, l2, svr)
+ _ecore_con_server_free(svr);
ecore_con_info_shutdown();
ecore_con_ssl_shutdown();
* @return EINA_TRUE if the request did not fail to be set up, EINA_FALSE if it failed.
*/
EAPI Eina_Bool
-ecore_con_lookup(const char *name, Ecore_Con_Dns_Cb done_cb, const void *data)
+ecore_con_lookup(const char *name,
+ Ecore_Con_Dns_Cb done_cb,
+ const void *data)
{
Ecore_Con_Server *svr;
Ecore_Con_Lookup *lk;
struct addrinfo hints;
if (!name || !done_cb)
- return EINA_FALSE;
+ return EINA_FALSE;
svr = calloc(1, sizeof(Ecore_Con_Server));
if (!svr)
- return EINA_FALSE;
+ return EINA_FALSE;
lk = malloc(sizeof (Ecore_Con_Lookup));
if (!lk)
svr->name = strdup(name);
if (!svr->name)
- goto on_error;
+ goto on_error;
svr->type = ECORE_CON_REMOTE_TCP;
svr->port = 1025;
if (ecore_con_info_get(svr, _ecore_con_lookup_done, svr,
&hints))
- return EINA_TRUE;
+ return EINA_TRUE;
free(svr->name);
on_error:
* @}
*/
-
/**
* @addtogroup Ecore_Con_Server_Group Ecore Connection Server Functions
*
/**
* @example ecore_con_server_example.c
* Shows how to write a simple server using the Ecore_Con library.
-*/
+ */
/**
* Creates a server to listen for connections.
*/
EAPI Ecore_Con_Server *
ecore_con_server_add(Ecore_Con_Type compl_type,
- const char *name,
- int port,
- const void *data)
+ const char *name,
+ int port,
+ const void *data)
{
Ecore_Con_Server *svr;
Ecore_Con_Type type;
if (port < 0 || !name)
- return NULL; /* local user socket: FILE: ~/.ecore/[name]/[port] */
+ return NULL; /* local user socket: FILE: ~/.ecore/[name]/[port] */
/* local system socket: FILE: /tmp/.ecore_service|[name]|[port] */
/* remote system socket: TCP/IP: [name]:[port] */
svr = calloc(1, sizeof(Ecore_Con_Server));
if (!svr)
- return NULL;
+ return NULL;
svr->name = strdup(name);
if (!svr->name)
- goto error;
+ goto error;
svr->type = compl_type;
svr->port = port;
if ((type == ECORE_CON_LOCAL_USER) ||
(type == ECORE_CON_LOCAL_SYSTEM) ||
(type == ECORE_CON_LOCAL_ABSTRACT))
- /* Local */
- if (!ecore_con_local_listen(svr, _ecore_con_svr_tcp_handler, svr))
- goto error;
+ /* Local */
+ if (!ecore_con_local_listen(svr, _ecore_con_svr_tcp_handler, svr))
+ goto error;
if ((type == ECORE_CON_REMOTE_TCP) ||
(type == ECORE_CON_REMOTE_NODELAY))
{
/* TCP */
- if (!ecore_con_info_tcp_listen(svr, _ecore_con_cb_tcp_listen,
- svr))
+ if (!ecore_con_info_tcp_listen(svr, _ecore_con_cb_tcp_listen,
+ svr))
goto error;
}
else if ((type == ECORE_CON_REMOTE_MCAST) ||
(type == ECORE_CON_REMOTE_UDP))
- /* UDP and MCAST */
- if (!ecore_con_info_udp_listen(svr, _ecore_con_cb_udp_listen,
- svr))
- goto error;
+ /* UDP and MCAST */
+ if (!ecore_con_info_udp_listen(svr, _ecore_con_cb_udp_listen,
+ svr))
+ goto error;
servers = eina_list_append(servers, svr);
ECORE_MAGIC_SET(svr, ECORE_MAGIC_CON_SERVER);
error:
if (svr->name)
- free(svr->name);
+ free(svr->name);
if (svr->path)
- free(svr->path);
+ free(svr->path);
#ifndef _WIN32
if (svr->fd >= 0)
- close(svr->fd);
+ close(svr->fd);
if (svr->fd_handler)
- ecore_main_fd_handler_del(svr->fd_handler);
+ ecore_main_fd_handler_del(svr->fd_handler);
if (svr->write_buf)
- free(svr->write_buf);
+ free(svr->write_buf);
if (svr->ip)
- free(svr->ip);
+ eina_stringshare_del(svr->ip);
#endif
- ecore_con_ssl_server_shutdown(svr);
+ ecore_con_ssl_server_shutdown(svr);
free(svr);
return NULL;
}
*/
EAPI Ecore_Con_Server *
ecore_con_server_connect(Ecore_Con_Type compl_type,
- const char *name,
- int port,
- const void *data)
+ const char *name,
+ int port,
+ const void *data)
{
Ecore_Con_Server *svr;
Ecore_Con_Type type;
if (!name)
- return NULL;
+ return NULL;
/* local user socket: FILE: ~/.ecore/[name]/[port] */
/* local system socket: FILE: /tmp/.ecore_service|[name]|[port] */
/* remote system socket: TCP/IP: [name]:[port] */
svr = calloc(1, sizeof(Ecore_Con_Server));
if (!svr)
- return NULL;
+ return NULL;
svr->name = strdup(name);
if (!svr->name)
- goto error;
+ goto error;
svr->type = compl_type;
svr->port = port;
(type == ECORE_CON_REMOTE_UDP) ||
(type == ECORE_CON_REMOTE_BROADCAST)) &&
(port < 0))
- goto error;
+ goto error;
if ((type == ECORE_CON_LOCAL_USER) ||
(type == ECORE_CON_LOCAL_SYSTEM) ||
(type == ECORE_CON_LOCAL_ABSTRACT))
- /* Local */
- if (!ecore_con_local_connect(svr, _ecore_con_cl_handler, svr,
- _ecore_con_event_server_add_free))
- goto
- error;
+ /* Local */
+ if (!ecore_con_local_connect(svr, _ecore_con_cl_handler, svr,
+ _ecore_con_event_server_add_free))
+ goto
+ error;
if ((type == ECORE_CON_REMOTE_TCP) ||
(type == ECORE_CON_REMOTE_NODELAY))
{
/* TCP */
- if (!ecore_con_info_tcp_connect(svr, _ecore_con_cb_tcp_connect,
- svr))
+ if (!ecore_con_info_tcp_connect(svr, _ecore_con_cb_tcp_connect,
+ svr))
goto error;
}
else if ((type == ECORE_CON_REMOTE_UDP) ||
(type == ECORE_CON_REMOTE_BROADCAST))
- /* UDP and MCAST */
- if (!ecore_con_info_udp_connect(svr, _ecore_con_cb_udp_connect,
- svr))
- goto error;
+ /* UDP and MCAST */
+ if (!ecore_con_info_udp_connect(svr, _ecore_con_cb_udp_connect,
+ svr))
+ goto error;
servers = eina_list_append(servers, svr);
ECORE_MAGIC_SET(svr, ECORE_MAGIC_CON_SERVER);
error:
if (svr->name)
- free(svr->name);
+ free(svr->name);
if (svr->path)
- free(svr->path);
+ free(svr->path);
if (svr->fd >= 0)
- close(svr->fd);
+ close(svr->fd);
if (svr->fd_handler)
- ecore_main_fd_handler_del(svr->fd_handler);
+ ecore_main_fd_handler_del(svr->fd_handler);
ecore_con_ssl_server_shutdown(svr);
free(svr);
* disables the idle timeout.
*/
EAPI void
-ecore_con_server_timeout_set(Ecore_Con_Server *svr, double timeout)
+ecore_con_server_timeout_set(Ecore_Con_Server *svr,
+ double timeout)
{
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
{
}
if (svr->delete_me)
- return NULL;
+ return NULL;
data = svr->data;
- svr->data = NULL;
svr->delete_me = EINA_TRUE;
if (svr->event_count > 0)
{
}
}
else
- _ecore_con_server_free(svr);
+ _ecore_con_server_free(svr);
return data;
}
* @return The previously associated data, if any.
*/
EAPI void *
-ecore_con_server_data_set(Ecore_Con_Server *svr, void *data)
+ecore_con_server_data_set(Ecore_Con_Server *svr,
+ void *data)
{
void *ret = NULL;
}
if (svr->connecting)
- return EINA_FALSE;
+ return EINA_FALSE;
return EINA_TRUE;
}
*/
EAPI int
ecore_con_server_send(Ecore_Con_Server *svr,
- const void *data,
- int size)
+ const void *data,
+ int size)
{
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
{
return 0;
}
- if (svr->dead)
- return 0;
+ EINA_SAFETY_ON_TRUE_RETURN_VAL(svr->dead, 0);
- if (!data)
- return 0;
+ EINA_SAFETY_ON_NULL_RETURN_VAL(data, 0);
- if (size < 1)
- return 0;
+ EINA_SAFETY_ON_TRUE_RETURN_VAL(size < 1, 0);
if (svr->fd_handler)
- ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_READ | ECORE_FD_WRITE);
+ ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_READ | ECORE_FD_WRITE);
if (svr->write_buf)
{
unsigned char *newbuf;
newbuf = realloc(svr->write_buf, svr->write_buf_size + size);
- if (newbuf)
- svr->write_buf = newbuf;
- else
- return 0;
+ EINA_SAFETY_ON_NULL_RETURN_VAL(newbuf, 0);
+ svr->write_buf = newbuf;
memcpy(svr->write_buf + svr->write_buf_size, data, size);
svr->write_buf_size += size;
}
else
{
svr->write_buf = malloc(size);
- if (!svr->write_buf)
- return 0;
+ EINA_SAFETY_ON_NULL_RETURN_VAL(svr->write_buf, 0);
svr->write_buf_size = size;
memcpy(svr->write_buf, data, size);
*/
EAPI void
ecore_con_server_client_limit_set(Ecore_Con_Server *svr,
- int client_limit,
- char reject_excess_clients)
+ int client_limit,
+ char reject_excess_clients)
{
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
{
return svr->ip;
}
-
/**
* @brief Check how long a server has been connected
* @param svr The server to check
return ecore_time_get() - svr->start_time;
}
+
/**
* Flushes all pending data to the given server. Will return when done.
*
_ecore_con_server_flush(svr);
}
-
/**
* @}
*/
/**
* @example ecore_con_client_example.c
* Shows how to write a simple client that connects to the example server.
-*/
+ */
/**
* Sends the given data to the given client.
*/
EAPI int
ecore_con_client_send(Ecore_Con_Client *cl,
- const void *data,
- int size)
+ const void *data,
+ int size)
{
if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_CON_CLIENT))
{
return 0;
}
- if (cl->dead)
- return 0;
+ EINA_SAFETY_ON_TRUE_RETURN_VAL(cl->dead, 0);
- if (!data)
- return 0;
+ EINA_SAFETY_ON_NULL_RETURN_VAL(data, 0);
- if (size < 1)
- return 0;
+ EINA_SAFETY_ON_TRUE_RETURN_VAL(size < 1, 0);
if (cl->fd_handler)
- ecore_main_fd_handler_active_set(
- cl->fd_handler, ECORE_FD_READ | ECORE_FD_WRITE);
+ ecore_main_fd_handler_active_set(cl->fd_handler, ECORE_FD_READ | ECORE_FD_WRITE);
- if(cl->host_server && ((cl->host_server->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_UDP))
- sendto(cl->host_server->fd, data, size, 0, (struct sockaddr *)cl->client_addr,
- cl->client_addr_len);
+ if (cl->host_server && ((cl->host_server->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_UDP))
+ sendto(cl->host_server->fd, data, size, 0, (struct sockaddr *)cl->client_addr,
+ cl->client_addr_len);
else if (cl->buf)
{
unsigned char *newbuf;
newbuf = realloc(cl->buf, cl->buf_size + size);
- if (newbuf)
- cl->buf = newbuf;
- else
- return 0;
+ EINA_SAFETY_ON_NULL_RETURN_VAL(newbuf, 0);
+
+ cl->buf = newbuf;
memcpy(cl->buf + cl->buf_size, data, size);
cl->buf_size += size;
else
{
cl->buf = malloc(size);
- if (!cl->buf)
- return 0;
+ EINA_SAFETY_ON_NULL_RETURN_VAL(cl->buf, 0);
cl->buf_size = size;
memcpy(cl->buf, data, size);
}
/**
+ * Returns whether the client is still connected
+ * @param cl The given client.
+ * @return #EINA_TRUE if connected, else EINA_FALSE
+ */
+EAPI Eina_Bool
+ecore_con_client_connected_get(Ecore_Con_Client *cl)
+{
+ if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_CON_CLIENT))
+ {
+ ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_CON_CLIENT,
+ "ecore_con_client_connected_get");
+ return EINA_FALSE;
+ }
+
+ return !cl->dead;
+}
+
+/**
* Set the time after which the client will be disconnected when inactive
* @param cl The client object
* @param timeout The timeout, in seconds, to disconnect after
* disables the idle timeout.
*/
EAPI void
-ecore_con_client_timeout_set(Ecore_Con_Client *cl, double timeout)
+ecore_con_client_timeout_set(Ecore_Con_Client *cl,
+ double timeout)
{
if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_CON_CLIENT))
{
return NULL;
}
- if (cl->client_addr && cl->host_server &&
- (((cl->host_server->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_UDP) ||
- ((cl->host_server->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_MCAST)))
- free(cl->client_addr);
+ if (cl->client_addr)
+ free(cl->client_addr);
+ cl->client_addr = NULL;
data = cl->data;
-
- cl->data = NULL;
cl->delete_me = EINA_TRUE;
if (cl->event_count > 0)
{
* @param data What to set the data to.
*/
EAPI void
-ecore_con_client_data_set(Ecore_Con_Client *cl, const void *data)
+ecore_con_client_data_set(Ecore_Con_Client *cl,
+ const void *data)
{
if (!ECORE_MAGIC_CHECK(cl, ECORE_MAGIC_CON_CLIENT))
{
ECORE_MAGIC_FAIL(cl, ECORE_MAGIC_CON_CLIENT, "ecore_con_client_ip_get");
return NULL;
}
+ if (!cl->ip)
+ cl->ip = _ecore_con_pretty_ip(cl->client_addr, cl->client_addr_len);
return cl->ip;
}
Ecore_Con_Client *cl;
double t_start, t;
+ if ((!svr->write_buf) && svr->delete_me && (!svr->dead) && (svr->event_count < 1))
+ {
+ /* this is a catch-all for cases when a server is not properly killed. */
+
+ Ecore_Con_Event_Server_Del *e;
+
+ svr->dead = EINA_TRUE;
+ e = calloc(1, sizeof(Ecore_Con_Event_Server_Del));
+ EINA_SAFETY_ON_NULL_RETURN(e);
+
+ svr->event_count++;
+ e->server = svr;
+ ecore_event_add(ECORE_CON_EVENT_SERVER_DEL, e,
+ _ecore_con_event_server_del_free, NULL);
+ return;
+ }
+
+ if (svr->event_count > 0)
+ return;
ECORE_MAGIC_SET(svr, ECORE_MAGIC_NONE);
t_start = ecore_time_get();
while ((svr->write_buf) && (!svr->dead))
}
if (svr->write_buf)
- free(svr->write_buf);
+ free(svr->write_buf);
EINA_LIST_FREE(svr->clients, cl)
_ecore_con_client_free(cl);
if ((svr->created) && (svr->path) && (svr->ppid == getpid()))
- unlink(svr->path);
+ unlink(svr->path);
ecore_con_ssl_server_shutdown(svr);
if (svr->fd >= 0)
- close(svr->fd);
+ close(svr->fd);
if (svr->name)
- free(svr->name);
+ free(svr->name);
if (svr->path)
- free(svr->path);
+ free(svr->path);
if (svr->ip)
- free(svr->ip);
+ eina_stringshare_del(svr->ip);
if (svr->fd_handler)
- ecore_main_fd_handler_del(svr->fd_handler);
+ ecore_main_fd_handler_del(svr->fd_handler);
servers = eina_list_remove(servers, svr);
+ svr->data = NULL;
free(svr);
}
if ((!cl->buf) && cl->delete_me && (!cl->dead) && (cl->event_count < 1))
{
- /* this is a catch-all for cases when a client is not properly killed.
- * the only example case I've found so far is if a client ssl handshakes
- * and then immediately disconnects without sending any further data.
- */
+ /* this is a catch-all for cases when a client is not properly killed. */
- /* we lost our client! */
- Ecore_Con_Event_Client_Del *e;
+ /* we lost our client! */
+ Ecore_Con_Event_Client_Del *e;
- cl->dead = EINA_TRUE;
- e = calloc(1, sizeof(Ecore_Con_Event_Client_Del));
- if (e)
- {
- cl->event_count++;
- _ecore_con_cl_timer_update(cl);
- e->client = cl;
- ecore_event_add(ECORE_CON_EVENT_CLIENT_DEL, e,
- _ecore_con_event_client_del_free, NULL);
- return;
- }
+ cl->dead = EINA_TRUE;
+ e = calloc(1, sizeof(Ecore_Con_Event_Client_Del));
+ EINA_SAFETY_ON_NULL_RETURN(e);
+
+ cl->event_count++;
+ _ecore_con_cl_timer_update(cl);
+ e->client = cl;
+ ecore_event_add(ECORE_CON_EVENT_CLIENT_DEL, e,
+ _ecore_con_event_client_del_free, NULL);
+ return;
}
+ if (cl->event_count > 0)
+ return;
ECORE_MAGIC_SET(cl, ECORE_MAGIC_NONE);
t_start = ecore_time_get();
while ((cl->buf) && (!cl->dead))
}
}
if (cl->buf)
- free(cl->buf);
+ free(cl->buf);
if (cl->host_server->type & ECORE_CON_SSL)
ecore_con_ssl_client_shutdown(cl);
if (cl->fd >= 0)
- close(cl->fd);
+ close(cl->fd);
if (cl->fd_handler)
- ecore_main_fd_handler_del(cl->fd_handler);
+ ecore_main_fd_handler_del(cl->fd_handler);
if (cl->ip)
- free(cl->ip);
-
- free(cl);
+ eina_stringshare_del(cl->ip);
+ cl->data = NULL;
+ free(cl);
return;
}
Ecore_Con_Event_Server_Del *e;
e = calloc(1, sizeof(Ecore_Con_Event_Server_Del));
- if (e)
- {
- svr->event_count++;
- e->server = svr;
- ecore_event_add(ECORE_CON_EVENT_SERVER_DEL, e,
- _ecore_con_event_server_del_free, NULL);
- }
+ EINA_SAFETY_ON_NULL_RETURN(e);
+
+ svr->event_count++;
+ e->server = svr;
+ ecore_event_add(ECORE_CON_EVENT_SERVER_DEL, e,
+ _ecore_con_event_server_del_free, NULL);
}
svr->dead = EINA_TRUE;
if (svr->fd_handler)
- ecore_main_fd_handler_del(svr->fd_handler);
+ ecore_main_fd_handler_del(svr->fd_handler);
svr->fd_handler = NULL;
}
}
static void
-_ecore_con_cb_tcp_listen(void *data, Ecore_Con_Info *net_info)
+_ecore_con_cb_tcp_listen(void *data,
+ Ecore_Con_Info *net_info)
{
Ecore_Con_Server *svr;
struct linger lin;
svr = data;
- if(!net_info)
- goto error;
+ if (!net_info)
+ goto error;
svr->fd = socket(net_info->info.ai_family, net_info->info.ai_socktype,
net_info->info.ai_protocol);
if (svr->fd < 0)
- goto error;
+ goto error;
if (fcntl(svr->fd, F_SETFL, O_NONBLOCK) < 0)
- goto error;
+ goto error;
if (fcntl(svr->fd, F_SETFD, FD_CLOEXEC) < 0)
- goto error;
+ goto error;
lin.l_onoff = 1;
lin.l_linger = 0;
if (setsockopt(svr->fd, SOL_SOCKET, SO_LINGER, (const void *)&lin,
sizeof(struct linger)) < 0)
- goto error;
+ goto error;
if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_NODELAY)
{
if (setsockopt(svr->fd, IPPROTO_TCP, TCP_NODELAY, (char *)&flag,
sizeof(int)) < 0)
- goto error;
+ goto error;
}
if (bind(svr->fd, net_info->info.ai_addr,
net_info->info.ai_addrlen) < 0)
- goto error;
+ goto error;
if (listen(svr->fd, 4096) < 0)
- goto error;
+ goto error;
svr->fd_handler = ecore_main_fd_handler_add(svr->fd, ECORE_FD_READ,
- _ecore_con_svr_tcp_handler, svr, NULL, NULL);
+ _ecore_con_svr_tcp_handler, svr, NULL, NULL);
if (!svr->fd_handler)
- goto error;
+ goto error;
return;
}
static void
-_ecore_con_cb_udp_listen(void *data, Ecore_Con_Info *net_info)
+_ecore_con_cb_udp_listen(void *data,
+ Ecore_Con_Info *net_info)
{
Ecore_Con_Server *svr;
Ecore_Con_Type type;
type &= ECORE_CON_TYPE;
if (!net_info)
- goto error;
+ goto error;
svr->fd = socket(net_info->info.ai_family, net_info->info.ai_socktype,
net_info->info.ai_protocol);
- if(svr->fd < 0)
- goto error;
+ if (svr->fd < 0)
+ goto error;
if (type == ECORE_CON_REMOTE_MCAST)
{
{
if (!inet_pton(net_info->info.ai_family, net_info->ip,
&mreq.imr_multiaddr))
- goto error;
+ goto error;
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
if (setsockopt(svr->fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
- (const void *)&mreq,sizeof(mreq)) != 0)
- goto error;
+ (const void *)&mreq, sizeof(mreq)) != 0)
+ goto error;
}
else if (net_info->info.ai_family == AF_INET6)
{
if (!inet_pton(net_info->info.ai_family, net_info->ip,
&mreq6.ipv6mr_multiaddr))
- goto error;
+ goto error;
mreq6.ipv6mr_interface = htonl(INADDR_ANY);
if (setsockopt(svr->fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
- (const void *)&mreq6,sizeof(mreq6)) != 0)
- goto error;
+ (const void *)&mreq6, sizeof(mreq6)) != 0)
+ goto error;
}
if (setsockopt(svr->fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&on,
sizeof(on)) != 0)
- goto error;
+ goto error;
}
if (fcntl(svr->fd, F_SETFL, O_NONBLOCK) < 0)
- goto error;
+ goto error;
if (fcntl(svr->fd, F_SETFD, FD_CLOEXEC) < 0)
- goto error;
+ goto error;
if (bind(svr->fd, net_info->info.ai_addr,
net_info->info.ai_addrlen) < 0)
- goto error;
+ goto error;
svr->fd_handler =
- ecore_main_fd_handler_add(svr->fd, ECORE_FD_READ,
- _ecore_con_svr_udp_handler, svr, NULL, NULL);
+ ecore_main_fd_handler_add(svr->fd, ECORE_FD_READ,
+ _ecore_con_svr_udp_handler, svr, NULL, NULL);
if (!svr->fd_handler)
- goto error;
+ goto error;
- svr->ip = strdup(net_info->ip);
+ svr->ip = eina_stringshare_add(net_info->ip);
return;
}
static void
-_ecore_con_cb_tcp_connect(void *data, Ecore_Con_Info *net_info)
+_ecore_con_cb_tcp_connect(void *data,
+ Ecore_Con_Info *net_info)
{
Ecore_Con_Server *svr;
int res;
svr = data;
if (!net_info)
- goto error;
+ goto error;
svr->fd = socket(net_info->info.ai_family, net_info->info.ai_socktype,
net_info->info.ai_protocol);
if (svr->fd < 0)
- goto error;
+ goto error;
if (fcntl(svr->fd, F_SETFL, O_NONBLOCK) < 0)
- goto error;
+ goto error;
if (fcntl(svr->fd, F_SETFD, FD_CLOEXEC) < 0)
- goto error;
+ goto error;
if (setsockopt(svr->fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&curstate,
sizeof(curstate)) < 0)
- goto error;
+ goto error;
if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_NODELAY)
{
if (setsockopt(svr->fd, IPPROTO_TCP, TCP_NODELAY, (char *)&flag,
sizeof(int)) < 0)
- goto error;
+ goto error;
}
res = connect(svr->fd, net_info->info.ai_addr, net_info->info.ai_addrlen);
if (res == SOCKET_ERROR)
{
if (WSAGetLastError() != WSAEINPROGRESS)
- goto error;
+ goto error;
#else
if (res < 0)
{
if (errno != EINPROGRESS)
- goto error;
+ goto error;
#endif
svr->connecting = EINA_TRUE;
svr->fd_handler =
- ecore_main_fd_handler_add(svr->fd, ECORE_FD_READ | ECORE_FD_WRITE,
- _ecore_con_cl_handler, svr, NULL, NULL);
+ ecore_main_fd_handler_add(svr->fd, ECORE_FD_READ | ECORE_FD_WRITE,
+ _ecore_con_cl_handler, svr, NULL, NULL);
}
else
- svr->fd_handler = ecore_main_fd_handler_add(svr->fd, ECORE_FD_READ,
- _ecore_con_cl_handler, svr, NULL, NULL);
+ svr->fd_handler = ecore_main_fd_handler_add(svr->fd, ECORE_FD_READ,
+ _ecore_con_cl_handler, svr, NULL, NULL);
if (svr->type & ECORE_CON_SSL)
{
}
if (!svr->fd_handler)
- goto error;
+ goto error;
- svr->ip = strdup(net_info->ip);
+ svr->ip = eina_stringshare_add(net_info->ip);
return;
}
static void
-_ecore_con_cb_udp_connect(void *data, Ecore_Con_Info *net_info)
+_ecore_con_cb_udp_connect(void *data,
+ Ecore_Con_Info *net_info)
{
Ecore_Con_Server *svr;
int curstate = 0;
svr = data;
if (!net_info)
- goto error;
+ goto error;
svr->fd = socket(net_info->info.ai_family, net_info->info.ai_socktype,
net_info->info.ai_protocol);
if (svr->fd < 0)
- goto error;
+ goto error;
if (fcntl(svr->fd, F_SETFL, O_NONBLOCK) < 0)
- goto error;
+ goto error;
if (fcntl(svr->fd, F_SETFD, FD_CLOEXEC) < 0)
- goto error;
+ goto error;
if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_BROADCAST)
{
if (setsockopt(svr->fd, SOL_SOCKET, SO_BROADCAST,
(const void *)&broadcast,
sizeof(broadcast)) < 0)
- goto error;
+ goto error;
}
else if (setsockopt(svr->fd, SOL_SOCKET, SO_REUSEADDR,
(const void *)&curstate, sizeof(curstate)) < 0)
- goto error;
+ goto error;
if (connect(svr->fd, net_info->info.ai_addr, net_info->info.ai_addrlen) < 0)
- goto error;
+ goto error;
svr->fd_handler = ecore_main_fd_handler_add(svr->fd, ECORE_FD_READ | ECORE_FD_WRITE,
- _ecore_con_cl_udp_handler, svr, NULL, NULL);
+ _ecore_con_cl_udp_handler, svr, NULL, NULL);
if (!svr->fd_handler)
- goto error;
+ goto error;
- svr->ip = strdup(net_info->ip);
+ svr->ip = eina_stringshare_add(net_info->ip);
return;
int so_err = 0;
unsigned int size = sizeof(int);
+ errno = 0;
res = getsockopt(svr->fd, SOL_SOCKET, SO_ERROR, (void *)&so_err, &size);
#ifdef _WIN32
if (res == SOCKET_ERROR)
- so_err = -1;
+ so_err = WSAGetLastError();
- if (so_err == WSAEINPROGRESS && !svr->dead)
- return ECORE_CON_INPROGRESS;
+ if ((so_err == WSAEINPROGRESS) && !svr->dead)
+ return ECORE_CON_INPROGRESS;
#else
if (res < 0)
- so_err = -1;
+ so_err = errno;
- if (so_err == EINPROGRESS && !svr->dead)
- return ECORE_CON_INPROGRESS;
+ if ((so_err == EINPROGRESS) && !svr->dead)
+ return ECORE_CON_INPROGRESS;
#endif
- if (so_err != 0)
+ if (so_err)
{
/* we lost our server! */
+ ERR("Connection lost: %s", strerror(so_err));
_ecore_con_server_kill(svr);
return ECORE_CON_DISCONNECTED;
}
if ((!svr->delete_me) && (!svr->handshaking) && svr->connecting)
{
/* we got our server! */
- Ecore_Con_Event_Server_Add *e;
+ Ecore_Con_Event_Server_Add *e;
- svr->connecting = EINA_FALSE;
- e = calloc(1, sizeof(Ecore_Con_Event_Server_Add));
- if (e)
- {
- svr->event_count++;
- svr->start_time = ecore_time_get();
- e->server = svr;
- ecore_event_add(ECORE_CON_EVENT_SERVER_ADD, e,
- _ecore_con_event_server_add_free, NULL);
- }
+ svr->connecting = EINA_FALSE;
+ e = calloc(1, sizeof(Ecore_Con_Event_Server_Add));
+ EINA_SAFETY_ON_NULL_RETURN_VAL(e, ECORE_CON_CONNECTED);
+
+ svr->event_count++;
+ svr->start_time = ecore_time_get();
+ e->server = svr;
+ ecore_event_add(ECORE_CON_EVENT_SERVER_ADD, e,
+ _ecore_con_event_server_add_free, NULL);
}
if (svr->fd_handler && (!svr->write_buf))
- ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_READ);
+ ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_READ);
if (!svr->dead)
- return ECORE_CON_CONNECTED;
+ return ECORE_CON_CONNECTED;
else
- return ECORE_CON_DISCONNECTED;
+ return ECORE_CON_DISCONNECTED;
}
-static char *
-_ecore_con_pretty_ip(struct sockaddr *client_addr, socklen_t size)
+static const char *
+_ecore_con_pretty_ip(struct sockaddr *client_addr,
+ socklen_t size)
{
char ipbuf[INET6_ADDRSTRLEN + 1];
sa6->sin6_addr.s6_addr[13],
sa6->sin6_addr.s6_addr[14],
sa6->sin6_addr.s6_addr[15]);
- return strdup(ipbuf);
+ return eina_stringshare_add(ipbuf);
}
}
- if (getnameinfo(client_addr, size,
- ipbuf, sizeof (ipbuf), NULL, 0,
- NI_NUMERICHOST))
- return strdup("0.0.0.0");
+ if (getnameinfo(client_addr, size, ipbuf, sizeof (ipbuf), NULL, 0, NI_NUMERICHOST))
+ return eina_stringshare_add("0.0.0.0");
ipbuf[sizeof (ipbuf) - 1] = 0;
- return strdup(ipbuf);
+ return eina_stringshare_add(ipbuf);
}
static Eina_Bool
-_ecore_con_svr_tcp_handler(void *data, Ecore_Fd_Handler *fd_handler __UNUSED__)
+_ecore_con_svr_tcp_handler(void *data,
+ Ecore_Fd_Handler *fd_handler __UNUSED__)
{
Ecore_Con_Server *svr;
Ecore_Con_Client *cl = NULL;
+ unsigned char client_addr[256];
+ unsigned int client_addr_len = sizeof(client_addr);
int new_fd;
- unsigned char incoming[256];
- size_t size_in;
svr = data;
if (svr->dead)
- return ECORE_CALLBACK_RENEW;
+ return ECORE_CALLBACK_RENEW;
if (svr->delete_me)
- return ECORE_CALLBACK_RENEW;
+ return ECORE_CALLBACK_RENEW;
if ((svr->client_limit >= 0) && (!svr->reject_excess_clients) &&
(svr->client_count >= (unsigned int)svr->client_limit))
return ECORE_CALLBACK_RENEW;
/* a new client */
-
- size_in = sizeof(incoming);
-
- memset(&incoming, 0, size_in);
- new_fd = accept(svr->fd, (struct sockaddr *)&incoming, (socklen_t *)&size_in);
+ memset(&client_addr, 0, client_addr_len);
+ new_fd = accept(svr->fd, (struct sockaddr *)&client_addr, (socklen_t *)&client_addr_len);
if (new_fd < 0)
/* error! */
return ECORE_CALLBACK_RENEW;
cl->host_server = svr;
cl->fd_handler = ecore_main_fd_handler_add(cl->fd, ECORE_FD_READ,
- _ecore_con_svr_cl_handler, cl, NULL, NULL);
+ _ecore_con_svr_cl_handler, cl, NULL, NULL);
ECORE_MAGIC_SET(cl, ECORE_MAGIC_CON_CLIENT);
-
if (svr->type & ECORE_CON_SSL)
{
cl->handshaking = EINA_TRUE;
goto error;
}
+ cl->client_addr = malloc(client_addr_len);
+ if (!cl->client_addr)
+ goto error;
+ cl->client_addr_len = client_addr_len;
+ memcpy(cl->client_addr, &client_addr, client_addr_len);
+
svr->clients = eina_list_append(svr->clients, cl);
svr->client_count++;
- if (!svr->path)
- cl->ip = _ecore_con_pretty_ip((struct sockaddr *)&incoming, size_in);
-
+
if ((!cl->delete_me) && (!cl->handshaking))
{
Ecore_Con_Event_Client_Add *e;
e = calloc(1, sizeof(Ecore_Con_Event_Client_Add));
- if (e)
- {
- cl->event_count++;
- _ecore_con_cl_timer_update(cl);
- e->client = cl;
- ecore_event_add(ECORE_CON_EVENT_CLIENT_ADD, e,
- _ecore_con_event_client_add_free, NULL);
- }
+ EINA_SAFETY_ON_NULL_RETURN_VAL(e, ECORE_CALLBACK_RENEW);
+
+ cl->event_count++;
+ _ecore_con_cl_timer_update(cl);
+ e->client = cl;
+ ecore_event_add(ECORE_CON_EVENT_CLIENT_ADD, e,
+ _ecore_con_event_client_add_free, NULL);
+
}
return ECORE_CALLBACK_RENEW;
return ECORE_CALLBACK_RENEW;
}
-
static void
_ecore_con_cl_read(Ecore_Con_Server *svr)
{
- unsigned char *inbuf = NULL;
- int inbuf_num = 0;
- int tries;
+ DBG("svr=%p", svr);
+ int num = 0;
+ Eina_Bool lost_server = EINA_TRUE;
+ unsigned char buf[READBUFSIZ];
/* only possible with non-ssl connections */
if (svr->connecting && (svr_try_connect_plain(svr) != ECORE_CON_CONNECTED))
- return;
+ return;
- for (tries = 0; tries < 16; tries++)
+ if (svr->handshaking)
{
- int num = 0;
- Eina_Bool lost_server = EINA_TRUE;
- unsigned char buf[READBUFSIZ];
-
- if (svr->handshaking)
- {
- DBG("Continuing ssl handshake");
- if (!ecore_con_ssl_server_init(svr))
- lost_server = EINA_FALSE;
- }
+ DBG("Continuing ssl handshake");
+ if (!ecore_con_ssl_server_init(svr))
+ lost_server = EINA_FALSE;
+ }
- if (!(svr->type & ECORE_CON_SSL))
- {
- num = read(svr->fd, buf, READBUFSIZ);
- if ((num < 0) && (errno == EAGAIN))
- lost_server = EINA_FALSE;
- }
- else if (!(num = ecore_con_ssl_server_read(svr, buf, READBUFSIZ)))
+ if (!(svr->type & ECORE_CON_SSL))
+ {
+ errno = 0;
+ num = read(svr->fd, buf, sizeof(buf));
+ if ((num > 0) || (errno == EAGAIN))
+ lost_server = EINA_FALSE;
+ }
+ else
+ {
+ num = ecore_con_ssl_server_read(svr, buf, sizeof(buf));
+ if (num > 0)
lost_server = EINA_FALSE;
+ }
- if (num < 1)
- {
- if (inbuf && (!svr->delete_me))
- {
- Ecore_Con_Event_Server_Data *e;
-
- e = malloc(sizeof(Ecore_Con_Event_Server_Data));
- if (e)
- {
- svr->event_count++;
- e->server = svr;
- e->data = inbuf;
- e->size = inbuf_num;
- ecore_event_add(ECORE_CON_EVENT_SERVER_DATA, e,
- _ecore_con_event_server_data_free, NULL);
- }
- }
-
- if (lost_server)
- _ecore_con_server_kill(svr);
+ if (lost_server)
+ _ecore_con_server_kill(svr);
- break;
- }
+ if ((num > 0) && (!svr->delete_me))
+ {
+ Ecore_Con_Event_Server_Data *e;
+
+ e = malloc(sizeof(Ecore_Con_Event_Server_Data));
+ EINA_SAFETY_ON_NULL_RETURN(e);
+
+ svr->event_count++;
+ e->server = svr;
+ e->data = malloc(num);
+ if (!e->data)
+ {
+ ERR("alloc!");
+ free(e);
+ return;
+ }
+ memcpy(e->data, buf, num);
+ e->size = num;
+ ecore_event_add(ECORE_CON_EVENT_SERVER_DATA, e,
+ _ecore_con_event_server_data_free, NULL);
+ }
- inbuf = realloc(inbuf, inbuf_num + num);
- memcpy(inbuf + inbuf_num, buf, num);
- inbuf_num += num;
- }
-/* #if USE_OPENSSL */
-/* if (svr->fd_handler) */
-/* { */
-/* if (svr->ssl && ssl_err == SSL_ERROR_WANT_READ) */
-/* ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_READ); */
-/* else if (svr->ssl && ssl_err == SSL_ERROR_WANT_WRITE) */
-/* ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_WRITE); */
-/* } */
-/* #endif */
}
static Eina_Bool
-_ecore_con_cl_handler(void *data, Ecore_Fd_Handler *fd_handler)
+_ecore_con_cl_handler(void *data,
+ Ecore_Fd_Handler *fd_handler)
{
Ecore_Con_Server *svr;
Eina_Bool want_read, want_write;
svr = data;
if (svr->dead)
- return ECORE_CALLBACK_RENEW;
+ return ECORE_CALLBACK_RENEW;
if (svr->delete_me)
- return ECORE_CALLBACK_RENEW;
+ return ECORE_CALLBACK_RENEW;
want_read = ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_READ);
want_write = ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_WRITE);
if (svr->handshaking && (want_read || want_write))
{
DBG("Continuing ssl handshake: preparing to %s...", want_read ? "read" : "write");
-#ifdef PRINT_LOTS_OF_DEBUG
- if (want_read)
- {
- char buf[32768];
- ssize_t len;
- len = recv(svr->fd, buf, sizeof(buf), MSG_DONTWAIT | MSG_PEEK);
- DBG("%zu bytes in buffer", len);
- }
+#ifdef ISCOMFITOR
+ if (want_read)
+ {
+ char buf[READBUFSIZ];
+ ssize_t len;
+ len = recv(svr->fd, buf, sizeof(buf), MSG_DONTWAIT | MSG_PEEK);
+ DBG("%zu bytes in buffer", len);
+ }
#endif
if (ecore_con_ssl_server_init(svr))
{
ERR("ssl handshaking failed!");
+ svr->handshaking = EINA_FALSE;
Ecore_Con_Event_Server_Del *e;
e = calloc(1, sizeof(Ecore_Con_Event_Server_Del));
- if (e)
- {
- svr->event_count++;
- e->server = svr;
- ecore_event_add(ECORE_CON_EVENT_SERVER_DEL, e,
- _ecore_con_event_server_del_free, NULL);
- }
+ EINA_SAFETY_ON_NULL_RETURN_VAL(e, ECORE_CALLBACK_RENEW);
+
+ svr->event_count++;
+ e->server = svr;
+ ecore_event_add(ECORE_CON_EVENT_SERVER_DEL, e,
+ _ecore_con_event_server_del_free, NULL);
}
else if (!svr->ssl_state)
{
/* we got our server! */
- Ecore_Con_Event_Server_Add *e;
-
- svr->connecting = EINA_FALSE;
- e = calloc(1, sizeof(Ecore_Con_Event_Server_Add));
- if (e)
- {
- svr->event_count++;
- svr->start_time = ecore_time_get();
- e->server = svr;
- ecore_event_add(ECORE_CON_EVENT_SERVER_ADD, e,
- _ecore_con_event_server_add_free, NULL);
- }
- }
+ Ecore_Con_Event_Server_Add *e;
- }
+ svr->connecting = EINA_FALSE;
+ e = calloc(1, sizeof(Ecore_Con_Event_Server_Add));
+ EINA_SAFETY_ON_NULL_RETURN_VAL(e, ECORE_CALLBACK_RENEW);
+ svr->event_count++;
+ svr->start_time = ecore_time_get();
+ e->server = svr;
+ ecore_event_add(ECORE_CON_EVENT_SERVER_ADD, e,
+ _ecore_con_event_server_add_free, NULL);
+ }
+ }
else if (want_read)
_ecore_con_cl_read(svr);
- else if (want_write)
- { /* only possible with non-ssl connections */
+ else if (want_write) /* only possible with non-ssl connections */
+ {
if (svr->connecting && (!svr_try_connect_plain(svr)))
- return ECORE_CALLBACK_RENEW;
+ return ECORE_CALLBACK_RENEW;
_ecore_con_server_flush(svr);
}
}
static Eina_Bool
-_ecore_con_cl_udp_handler(void *data, Ecore_Fd_Handler *fd_handler)
+_ecore_con_cl_udp_handler(void *data,
+ Ecore_Fd_Handler *fd_handler)
{
+ Ecore_Con_Event_Server_Data *e;
+ unsigned char *inbuf;
+ unsigned char buf[READBUFSIZ];
+ int num;
Ecore_Con_Server *svr;
+ Eina_Bool want_read, want_write;
- svr = data;
- if (svr->dead)
- return ECORE_CALLBACK_RENEW;
+ want_read = ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_READ);
+ want_write = ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_WRITE);
- if (svr->delete_me)
- return ECORE_CALLBACK_RENEW;
+ svr = data;
+ if (svr->dead || svr->delete_me || ((!want_read) && (!want_write)))
+ return ECORE_CALLBACK_RENEW;
- if (ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_READ))
+ if (want_write)
{
- unsigned char buf[65536];
- int num;
-
- errno = 0;
- num = read(svr->fd, buf, 65536);
- if (num > 0)
- {
- if (!svr->delete_me)
- {
- Ecore_Con_Event_Server_Data *e;
- unsigned char *inbuf;
-
- inbuf = malloc(num);
- if(!inbuf)
- return 1;
-
- memcpy(inbuf, buf, num);
-
- e = calloc(1, sizeof(Ecore_Con_Event_Server_Data));
- if (e)
- {
- svr->event_count++;
- e->server = svr;
- e->data = inbuf;
- e->size = num;
- ecore_event_add(ECORE_CON_EVENT_SERVER_DATA, e,
- _ecore_con_event_server_data_free,
- NULL);
- }
- }
- }
- else if ((errno == EIO) || (errno == EBADF) ||
- (errno == EPIPE) || (errno == EINVAL) ||
- (errno == ENOSPC) || (errno == ECONNREFUSED))
- _ecore_con_server_kill(svr);
+ _ecore_con_server_flush(svr);
+ return ECORE_CALLBACK_RENEW;
}
- else if (ecore_main_fd_handler_active_get(fd_handler,
- ECORE_FD_WRITE))
- _ecore_con_server_flush(svr);
+
+ errno = 0;
+ num = read(svr->fd, buf, READBUFSIZ);
+
+ if ((errno == EIO) || (errno == EBADF) || (errno == EPIPE) || (errno == EINVAL) ||
+ (errno == ENOSPC) || (errno == ECONNREFUSED))
+ _ecore_con_server_kill(svr);
+
+ if ((num < 1) || (svr->delete_me))
+ return ECORE_CALLBACK_RENEW;
+
+ inbuf = malloc(num);
+ if (!inbuf)
+ return ECORE_CALLBACK_RENEW;
+
+ memcpy(inbuf, buf, num);
+
+ e = calloc(1, sizeof(Ecore_Con_Event_Server_Data));
+ EINA_SAFETY_ON_NULL_RETURN_VAL(e, ECORE_CALLBACK_RENEW);
+
+ svr->event_count++;
+ e->server = svr;
+ e->data = inbuf;
+ e->size = num;
+ ecore_event_add(ECORE_CON_EVENT_SERVER_DATA, e,
+ _ecore_con_event_server_data_free, NULL);
return ECORE_CALLBACK_RENEW;
}
static Eina_Bool
-_ecore_con_svr_udp_handler(void *data, Ecore_Fd_Handler *fd_handler)
+_ecore_con_svr_udp_handler(void *data,
+ Ecore_Fd_Handler *fd_handler)
{
+ unsigned char buf[READBUFSIZ];
+ unsigned char client_addr[256];
+ unsigned int client_addr_len = sizeof(client_addr);
+ int num;
Ecore_Con_Server *svr;
Ecore_Con_Client *cl = NULL;
svr = data;
- if (svr->dead)
- return ECORE_CALLBACK_RENEW;
- if (svr->delete_me)
- return ECORE_CALLBACK_RENEW;
+ if (svr->delete_me || svr->dead)
+ return ECORE_CALLBACK_RENEW;
- if (ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_READ))
+ if (ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_WRITE))
{
- unsigned char buf[READBUFSIZ];
- unsigned char client_addr[256];
- unsigned int client_addr_len = sizeof(client_addr);
- int num;
+ _ecore_con_client_flush(cl);
+ return ECORE_CALLBACK_RENEW;
+ }
- errno = 0;
+ if (!ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_READ))
+ return ECORE_CALLBACK_RENEW;
+
+ errno = 0;
#ifdef _WIN32
- num = fcntl(svr->fd, F_SETFL, O_NONBLOCK);
- if (num >= 0)
- num =
- recvfrom(svr->fd, buf, sizeof(buf), 0,
- (struct sockaddr *)&client_addr,
- &client_addr_len);
+ num = fcntl(svr->fd, F_SETFL, O_NONBLOCK);
+ if (num >= 0)
+ num = recvfrom(svr->fd, buf, sizeof(buf), 0,
+ (struct sockaddr *)&client_addr,
+ &client_addr_len);
#else
- num =
- recvfrom(svr->fd, buf, sizeof(buf), MSG_DONTWAIT,
- (struct sockaddr *)&client_addr,
- &client_addr_len);
+ num = recvfrom(svr->fd, buf, sizeof(buf), MSG_DONTWAIT,
+ (struct sockaddr *)&client_addr,
+ &client_addr_len);
#endif
- if (num > 0)
- {
- if (!svr->delete_me)
- {
- Ecore_Con_Event_Client_Data *e;
- unsigned char *inbuf;
-
- /* Create a new client for use in the client data event */
- cl = calloc(1, sizeof(Ecore_Con_Client));
- if(!cl)
- return ECORE_CALLBACK_RENEW;
-
- cl->buf = NULL;
- cl->fd = 0;
- cl->fd_handler = NULL;
- cl->host_server = svr;
- cl->client_addr = calloc(1, client_addr_len);
- cl->client_addr_len = client_addr_len;
- if(!cl->client_addr)
- {
- free(cl);
- return ECORE_CALLBACK_RENEW;
- }
-
- memcpy(cl->client_addr, &client_addr, client_addr_len);
- ECORE_MAGIC_SET(cl, ECORE_MAGIC_CON_CLIENT);
- svr->clients = eina_list_append(svr->clients, cl);
- svr->client_count++;
-
- cl->ip = _ecore_con_pretty_ip(cl->client_addr,
- cl->client_addr_len);
-
- inbuf = malloc(num);
- if(!inbuf)
- {
- free(cl->client_addr);
- free(cl);
- return ECORE_CALLBACK_RENEW;
- }
-
- memcpy(inbuf, buf, num);
-
- e = calloc(1, sizeof(Ecore_Con_Event_Client_Data));
- if (e)
- {
- svr->event_count++;
- _ecore_con_cl_timer_update(cl);
- e->client = cl;
- e->data = inbuf;
- e->size = num;
- ecore_event_add(ECORE_CON_EVENT_CLIENT_DATA, e,
- _ecore_con_event_client_data_free,
- NULL);
- }
-
- if (!cl->delete_me)
- {
- Ecore_Con_Event_Client_Add *add;
-
- add = calloc(1, sizeof(Ecore_Con_Event_Client_Add));
- if(add)
- {
-/*cl->event_count++;*/
- add->client = cl;
- _ecore_con_cl_timer_update(cl);
- ecore_event_add(ECORE_CON_EVENT_CLIENT_ADD, add,
- _ecore_con_event_client_add_free, NULL);
- }
- }
- }
- }
- else if ((errno == EIO) || (errno == EBADF) ||
- (errno == EPIPE) || (errno == EINVAL) ||
- (errno == ENOSPC) || (errno == ECONNREFUSED))
+ if ((errno == EIO) || (errno == EBADF) || (errno == EPIPE) ||
+ (errno == EINVAL) || (errno == ENOSPC) || (errno == ECONNREFUSED))
+ {
+ if (!svr->delete_me)
{
- if (!svr->delete_me)
- {
- /* we lost our client! */
- Ecore_Con_Event_Client_Del *e;
-
- e = calloc(1, sizeof(Ecore_Con_Event_Client_Del));
- if (e)
- {
- svr->event_count++;
- /* be explicit here */
- e->client = NULL;
- ecore_event_add(ECORE_CON_EVENT_CLIENT_DEL, e,
- _ecore_con_event_client_del_free, NULL);
- }
- }
-
- svr->dead = EINA_TRUE;
- if (svr->fd_handler)
- ecore_main_fd_handler_del(svr->fd_handler);
+/* we lost our client! */
+ Ecore_Con_Event_Client_Del *e;
- svr->fd_handler = NULL;
+ e = calloc(1, sizeof(Ecore_Con_Event_Client_Del));
+ EINA_SAFETY_ON_NULL_RETURN_VAL(e, ECORE_CALLBACK_RENEW);
+
+ svr->event_count++;
+ /* be explicit here */
+ e->client = NULL;
+ ecore_event_add(ECORE_CON_EVENT_CLIENT_DEL, e,
+ _ecore_con_event_client_del_free, NULL);
}
+
+ svr->dead = EINA_TRUE;
+ svr->fd_handler = NULL;
+ return ECORE_CALLBACK_CANCEL;
}
- else if (ecore_main_fd_handler_active_get(fd_handler,
- ECORE_FD_WRITE))
- _ecore_con_client_flush(cl);
+
+
+/* Create a new client for use in the client data event */
+ cl = calloc(1, sizeof(Ecore_Con_Client));
+ EINA_SAFETY_ON_NULL_RETURN_VAL(cl, ECORE_CALLBACK_RENEW);
+
+ cl->host_server = svr;
+ cl->client_addr = malloc(client_addr_len);
+ if (!cl->client_addr)
+ {
+ free(cl);
+ return ECORE_CALLBACK_RENEW;
+ }
+ cl->client_addr_len = client_addr_len;
+
+ memcpy(cl->client_addr, &client_addr, client_addr_len);
+ ECORE_MAGIC_SET(cl, ECORE_MAGIC_CON_CLIENT);
+ svr->clients = eina_list_append(svr->clients, cl);
+ svr->client_count++;
+
+ { /* indent to keep it all nicely separated */
+ Ecore_Con_Event_Client_Add *add;
+
+ add = calloc(1, sizeof(Ecore_Con_Event_Client_Add));
+ EINA_SAFETY_ON_NULL_RETURN_VAL(add, ECORE_CALLBACK_RENEW);
+
+ /*cl->event_count++;*/
+ add->client = cl;
+ _ecore_con_cl_timer_update(cl);
+ ecore_event_add(ECORE_CON_EVENT_CLIENT_ADD, add,
+ _ecore_con_event_client_add_free, NULL);
+ }
+
+
+ {
+ Ecore_Con_Event_Client_Data *e;
+ e = calloc(1, sizeof(Ecore_Con_Event_Client_Data));
+ EINA_SAFETY_ON_NULL_RETURN_VAL(e, ECORE_CALLBACK_RENEW);
+
+ svr->event_count++;
+ _ecore_con_cl_timer_update(cl);
+ e->client = cl;
+ e->data = malloc(num);
+ if (!e->data)
+ {
+ free(cl->client_addr);
+ free(cl);
+ return ECORE_CALLBACK_RENEW;
+ }
+
+ memcpy(e->data, buf, num);
+ e->size = num;
+ ecore_event_add(ECORE_CON_EVENT_CLIENT_DATA, e,
+ _ecore_con_event_client_data_free, NULL);
+ }
return ECORE_CALLBACK_RENEW;
}
static void
_ecore_con_svr_cl_read(Ecore_Con_Client *cl)
{
- unsigned char *inbuf = NULL;
- int inbuf_num = 0;
- int tries;
+ DBG("cl=%p", cl);
+ int num = 0;
+ Eina_Bool lost_client = EINA_TRUE;
+ unsigned char buf[READBUFSIZ];
- for (tries = 0; tries < 16; tries++)
+ if (cl->handshaking)
{
- int num = 0;
- Eina_Bool lost_client = EINA_TRUE;
- unsigned char buf[READBUFSIZ];
-
- errno = 0;
+ /* add an extra handshake attempt just before read, even though
+ * read also attempts to handshake, to try to finish sooner
+ */
+ if (ecore_con_ssl_client_init(cl))
+ lost_client = EINA_FALSE;
- if (cl->handshaking)
- {
- if (ecore_con_ssl_client_init(cl))
- lost_client = EINA_FALSE;
+ _ecore_con_cl_timer_update(cl);
+ }
- _ecore_con_cl_timer_update(cl);
- }
+ if (!(cl->host_server->type & ECORE_CON_SSL))
+ {
+ errno = 0;
+ num = read(cl->fd, buf, sizeof(buf));
+ if ((num > 0) || (errno == EAGAIN))
+ lost_client = EINA_FALSE;
+ }
+ else
+ {
+ num = ecore_con_ssl_client_read(cl, buf, sizeof(buf));
+ if (num > 0)
+ lost_client = EINA_FALSE;
+ }
- if (!(cl->host_server->type & ECORE_CON_SSL))
+ if (lost_client)
+ {
+ if (!cl->delete_me)
{
- if ((num = read(cl->fd, buf, READBUFSIZ)) <= 0)
- if ((num < 0) && (errno == EAGAIN))
- lost_client = EINA_FALSE;
+ /* we lost our client! */
+ Ecore_Con_Event_Client_Del *e;
- }
- else if (!(num = ecore_con_ssl_client_read(cl, buf, READBUFSIZ)))
- lost_client = EINA_FALSE;
+ e = calloc(1, sizeof(Ecore_Con_Event_Client_Del));
+ EINA_SAFETY_ON_NULL_RETURN(e);
- if (num > 0)
- {
- inbuf = realloc(inbuf, inbuf_num + num);
- memcpy(inbuf + inbuf_num, buf, num);
- inbuf_num += num;
- continue;
+ cl->event_count++;
+ _ecore_con_cl_timer_update(cl);
+ e->client = cl;
+ ecore_event_add(ECORE_CON_EVENT_CLIENT_DEL, e,
+ _ecore_con_event_client_del_free, NULL);
}
+ INF("Lost client %s", (cl->ip) ? cl->ip : "");
+ cl->dead = EINA_TRUE;
+ if (cl->fd_handler)
+ ecore_main_fd_handler_del(cl->fd_handler);
- if (inbuf && (!cl->delete_me))
- {
- Ecore_Con_Event_Client_Data *e;
-
- e = malloc(sizeof(Ecore_Con_Event_Client_Data));
- if (e)
- {
- cl->event_count++;
- _ecore_con_cl_timer_update(cl);
- e->client = cl;
- e->data = inbuf;
- e->size = inbuf_num;
- ecore_event_add(ECORE_CON_EVENT_CLIENT_DATA, e,
- _ecore_con_event_client_data_free, NULL);
- }
- }
+ cl->fd_handler = NULL;
+ return;
+ }
- if (lost_client && (!cl->delete_me))
- {
- /* we lost our client! */
- Ecore_Con_Event_Client_Del *e;
+ if ((num > 0) && (!cl->delete_me))
+ {
+ Ecore_Con_Event_Client_Data *e;
- e = calloc(1, sizeof(Ecore_Con_Event_Client_Del));
- if (e)
- {
- cl->event_count++;
- _ecore_con_cl_timer_update(cl);
- e->client = cl;
- ecore_event_add(ECORE_CON_EVENT_CLIENT_DEL, e,
- _ecore_con_event_client_del_free, NULL);
- }
- }
+ e = malloc(sizeof(Ecore_Con_Event_Client_Data));
+ EINA_SAFETY_ON_NULL_RETURN(e);
- if (lost_client)
+ cl->event_count++;
+ _ecore_con_cl_timer_update(cl);
+ e->client = cl;
+ e->data = malloc(num);
+ if (!e->data)
{
- cl->dead = EINA_TRUE;
- if (cl->fd_handler)
- ecore_main_fd_handler_del(cl->fd_handler);
-
- cl->fd_handler = NULL;
+ ERR("alloc!");
+ free(e);
+ return;
}
-
- break;
+ memcpy(e->data, buf, num);
+ e->size = num;
+ ecore_event_add(ECORE_CON_EVENT_CLIENT_DATA, e,
+ _ecore_con_event_client_data_free, NULL);
}
+
+
}
static Eina_Bool
-_ecore_con_svr_cl_handler(void *data, Ecore_Fd_Handler *fd_handler)
+_ecore_con_svr_cl_handler(void *data,
+ Ecore_Fd_Handler *fd_handler)
{
Ecore_Con_Client *cl;
cl = data;
if (cl->dead)
- return ECORE_CALLBACK_RENEW;
+ return ECORE_CALLBACK_RENEW;
if (cl->delete_me)
- return ECORE_CALLBACK_RENEW;
+ return ECORE_CALLBACK_RENEW;
if (cl->handshaking && ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_READ | ECORE_FD_WRITE))
{
if (ecore_con_ssl_client_init(cl))
{
ERR("ssl handshaking failed!");
+ cl->handshaking = EINA_FALSE;
/* we lost our client! */
Ecore_Con_Event_Client_Del *e;
cl->dead = EINA_TRUE;
+ INF("Lost client %s", (cl->ip) ? cl->ip : "");
e = calloc(1, sizeof(Ecore_Con_Event_Client_Del));
- if (e)
- {
- cl->event_count++;
- _ecore_con_cl_timer_update(cl);
- e->client = cl;
- ecore_event_add(ECORE_CON_EVENT_CLIENT_DEL, e,
- _ecore_con_event_client_del_free, NULL);
- }
+ EINA_SAFETY_ON_NULL_RETURN_VAL(e, ECORE_CALLBACK_RENEW);
+ cl->event_count++;
+ _ecore_con_cl_timer_update(cl);
+ e->client = cl;
+ ecore_event_add(ECORE_CON_EVENT_CLIENT_DEL, e,
+ _ecore_con_event_client_del_free, NULL);
}
else if (!cl->ssl_state)
{
- Ecore_Con_Event_Client_Add *add;
-
- add = calloc(1, sizeof(Ecore_Con_Event_Client_Add));
- if(add)
- {
-/*cl->event_count++;*/
- add->client = cl;
- _ecore_con_cl_timer_update(cl);
- ecore_event_add(ECORE_CON_EVENT_CLIENT_ADD, add,
- _ecore_con_event_client_add_free, NULL);
- }
+ Ecore_Con_Event_Client_Add *e;
+
+ e = calloc(1, sizeof(Ecore_Con_Event_Client_Add));
+ EINA_SAFETY_ON_NULL_RETURN_VAL(e, ECORE_CALLBACK_RENEW);
+
+ e->client = cl;
+ cl->event_count++;
+ _ecore_con_cl_timer_update(cl);
+ ecore_event_add(ECORE_CON_EVENT_CLIENT_ADD, e,
+ _ecore_con_event_client_add_free, NULL);
}
}
-
else if (ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_READ))
_ecore_con_svr_cl_read(cl);
int count, num;
if (!svr->write_buf)
- return;
+ return;
/* check whether we need to write anything at all.
* we must not write zero bytes with SSL_write() since it
* causes undefined behaviour
*/
if (svr->write_buf_size == svr->write_buf_offset)
- return;
+ return;
num = svr->write_buf_size - svr->write_buf_offset;
}
if (!(svr->type & ECORE_CON_SSL))
- count = write(svr->fd, svr->write_buf + svr->write_buf_offset, num);
+ count = write(svr->fd, svr->write_buf + svr->write_buf_offset, num);
else
- count = ecore_con_ssl_server_write(svr, svr->write_buf + svr->write_buf_offset, num);
+ count = ecore_con_ssl_server_write(svr, svr->write_buf + svr->write_buf_offset, num);
if (count < 0)
{
/* we lost our server! */
- _ecore_con_server_kill(svr);
- return;
+ _ecore_con_server_kill(svr);
+ return;
}
svr->write_buf_offset += count;
free(svr->write_buf);
svr->write_buf = NULL;
if (svr->fd_handler)
- ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_READ);
+ ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_READ);
}
+ else if (count < num)
+ ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_WRITE);
}
static void
int num, count = 0;
if (!cl->buf)
- return;
+ return;
if (cl->handshaking)
{
count = -1;
_ecore_con_cl_timer_update(cl);
- return;
}
if (!count)
{
num = cl->buf_size - cl->buf_offset;
if (!(cl->host_server->type & ECORE_CON_SSL))
- count = write(cl->fd, cl->buf + cl->buf_offset, num);
+ count = write(cl->fd, cl->buf + cl->buf_offset, num);
else
- count = ecore_con_ssl_client_write(cl, cl->buf + cl->buf_offset, num);
+ count = ecore_con_ssl_client_write(cl, cl->buf + cl->buf_offset, num);
}
if (count < 0)
{
if ((errno == EIO) || (errno == EBADF) || (errno == EPIPE) ||
(errno == EINVAL) || (errno == ENOSPC) || (errno == ECONNREFUSED))
- if (!cl->delete_me)
- {
- /* we lost our client! */
+ if (!cl->delete_me)
+ {
+ /* we lost our client! */
Ecore_Con_Event_Client_Del *e;
e = calloc(1, sizeof(Ecore_Con_Event_Client_Del));
- if (e)
- {
- cl->event_count++;
- _ecore_con_cl_timer_update(cl);
- e->client = cl;
- ecore_event_add(ECORE_CON_EVENT_CLIENT_DEL, e,
- _ecore_con_event_client_del_free, NULL);
- }
+ EINA_SAFETY_ON_NULL_RETURN(e);
+
+ cl->event_count++;
+ _ecore_con_cl_timer_update(cl);
+ e->client = cl;
+ ecore_event_add(ECORE_CON_EVENT_CLIENT_DEL, e,
+ _ecore_con_event_client_del_free, NULL);
cl->dead = EINA_TRUE;
+ INF("Lost client %s", (cl->ip) ? cl->ip : "");
if (cl->fd_handler)
- ecore_main_fd_handler_del(cl->fd_handler);
+ ecore_main_fd_handler_del(cl->fd_handler);
cl->fd_handler = NULL;
- }
+ }
return;
}
free(cl->buf);
cl->buf = NULL;
if (cl->fd_handler)
- ecore_main_fd_handler_active_set(cl->fd_handler, ECORE_FD_READ);
+ ecore_main_fd_handler_active_set(cl->fd_handler, ECORE_FD_READ);
}
+ else if (count < num)
+ ecore_main_fd_handler_active_set(cl->fd_handler, ECORE_FD_WRITE);
}
static void
-_ecore_con_event_client_add_free(void *data __UNUSED__, void *ev)
+_ecore_con_event_client_add_free(void *data __UNUSED__,
+ void *ev)
{
Ecore_Con_Event_Client_Add *e;
e = ev;
e->client->event_count--;
- if ((e->client->event_count == 0) &&
+ if ((e->client->event_count <= 0) &&
(e->client->delete_me))
- ecore_con_client_del(e->client);
+ ecore_con_client_del(e->client);
free(e);
}
static void
-_ecore_con_event_client_del_free(void *data __UNUSED__, void *ev)
+_ecore_con_event_client_del_free(void *data __UNUSED__,
+ void *ev)
{
Ecore_Con_Event_Client_Del *e;
e = ev;
e->client->event_count--;
- if ((e->client->event_count == 0) && (e->client->delete_me))
- ecore_con_client_del(e->client);
+ if ((e->client->event_count <= 0) && (e->client->delete_me))
+ ecore_con_client_del(e->client);
- free(e);
+ free(e);
}
static void
-_ecore_con_event_client_data_free(void *data __UNUSED__, void *ev)
+_ecore_con_event_client_data_free(void *data __UNUSED__,
+ void *ev)
{
Ecore_Con_Event_Client_Data *e;
e = ev;
e->client->event_count--;
if (e->data)
- free(e->data);
+ free(e->data);
- if (((e->client->event_count == 0) && (e->client->delete_me)) ||
+ if (((e->client->event_count <= 0) && (e->client->delete_me)) ||
((e->client->host_server &&
((e->client->host_server->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_UDP ||
(e->client->host_server->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_MCAST))))
- ecore_con_client_del(e->client);
+ ecore_con_client_del(e->client);
free(e);
}
static void
-_ecore_con_event_server_add_free(void *data __UNUSED__, void *ev)
+_ecore_con_event_server_add_free(void *data __UNUSED__,
+ void *ev)
{
Ecore_Con_Event_Server_Add *e;
e = ev;
e->server->event_count--;
- if ((e->server->event_count == 0) &&
+ if ((e->server->event_count <= 0) &&
(e->server->delete_me))
- _ecore_con_server_free(e->server);
+ _ecore_con_server_free(e->server);
free(e);
}
static void
-_ecore_con_event_server_del_free(void *data __UNUSED__, void *ev)
+_ecore_con_event_server_del_free(void *data __UNUSED__,
+ void *ev)
{
Ecore_Con_Event_Server_Del *e;
e = ev;
e->server->event_count--;
- if ((e->server->event_count == 0) &&
+ if ((e->server->event_count <= 0) &&
(e->server->delete_me))
- _ecore_con_server_free(e->server);
+ _ecore_con_server_free(e->server);
- free(e);
+ free(e);
}
static void
-_ecore_con_event_server_data_free(void *data __UNUSED__, void *ev)
+_ecore_con_event_server_data_free(void *data __UNUSED__,
+ void *ev)
{
Ecore_Con_Event_Server_Data *e;
e = ev;
e->server->event_count--;
if (e->data)
- free(e->data);
+ free(e->data);
- if ((e->server->event_count == 0) &&
+ if ((e->server->event_count <= 0) &&
(e->server->delete_me))
- _ecore_con_server_free(e->server);
+ _ecore_con_server_free(e->server);
free(e);
}
static void
-_ecore_con_lookup_done(void *data, Ecore_Con_Info *infos)
+_ecore_con_lookup_done(void *data,
+ Ecore_Con_Info *infos)
{
Ecore_Con_Server *svr;
Ecore_Con_Lookup *lk;
lk = svr->data;
if (infos)
- lk->done_cb(infos->info.ai_canonname, infos->ip,
- infos->info.ai_addr, infos->info.ai_addrlen,
- (void *)lk->data);
+ lk->done_cb(infos->info.ai_canonname, infos->ip,
+ infos->info.ai_addr, infos->info.ai_addrlen,
+ (void *)lk->data);
else
- lk->done_cb(NULL, NULL, NULL, 0, (void *)lk->data);
+ lk->done_cb(NULL, NULL, NULL, 0, (void *)lk->data);
free(svr->name);
free(lk);
free(svr);
}
+
#include "Ecore_Con.h"
#include "ecore_con_private.h"
-typedef struct _Ecore_Con_FD Ecore_Con_FD;
+typedef struct _Ecore_Con_FD Ecore_Con_FD;
typedef struct _Ecore_Con_CAres Ecore_Con_CAres;
struct _Ecore_Con_FD
{
Ecore_Fd_Handler *handler;
- int active;
- int fd;
+ int active;
+ int fd;
};
struct _Ecore_Con_CAres
{
Ecore_Con_Server *svr;
Ecore_Con_Info_Cb done_cb;
- void *data;
- struct addrinfo hints;
- Ecore_Con_Info *result;
+ void *data;
+ struct addrinfo hints;
+ Ecore_Con_Info *result;
union {
- struct in_addr v4;
+ struct in_addr v4;
struct in6_addr v6;
} addr;
static Ecore_Timer *tm = NULL;
static fd_set info_readers, info_writers;
-static void _ecore_con_info_ares_nameinfo(Ecore_Con_CAres *arg, int status,
- int timeouts, char *node,
- char *service);
-static void _ecore_con_info_ares_host_cb(Ecore_Con_CAres *arg, int status,
- int timeouts,
- struct hostent *hostent);
-static Eina_Bool _ecore_con_info_cares_fd_cb(void *data,
+static void _ecore_con_info_ares_nameinfo(Ecore_Con_CAres *arg,
+ int status,
+ int timeouts,
+ char *node,
+ char *service);
+static void _ecore_con_info_ares_host_cb(Ecore_Con_CAres *arg,
+ int status,
+ int timeouts,
+ struct hostent *hostent);
+static Eina_Bool _ecore_con_info_cares_fd_cb(void *data,
Ecore_Fd_Handler *fd_handler);
static Eina_Bool _ecore_con_info_cares_timeout_cb(void *data);
static void _ecore_con_info_cares_clean(void);
if (info_init == 0)
{
if (ares_library_init(ARES_LIB_INIT_ALL) != 0)
- return 0;
+ return 0;
if (ares_init(&info_channel) != ARES_SUCCESS)
{
if (info_init == 0)
{
/* Cancel all ongoing request */
- ares_cancel(info_channel);
- ares_destroy(info_channel);
+ ares_cancel(info_channel);
+ ares_destroy(info_channel);
- /* Destroy FD handler here. */
- /* Shutdown ares */
- ares_library_cleanup();
+ /* Destroy FD handler here. */
+ /* Shutdown ares */
+ ares_library_cleanup();
}
return info_init;
int
ecore_con_info_tcp_connect(Ecore_Con_Server *svr,
Ecore_Con_Info_Cb done_cb,
- void *data)
+ void *data)
{
struct addrinfo hints;
int
ecore_con_info_tcp_listen(Ecore_Con_Server *svr,
Ecore_Con_Info_Cb done_cb,
- void *data)
+ void *data)
{
struct addrinfo hints;
int
ecore_con_info_udp_connect(Ecore_Con_Server *svr,
Ecore_Con_Info_Cb done_cb,
- void *data)
+ void *data)
{
struct addrinfo hints;
int
ecore_con_info_udp_listen(Ecore_Con_Server *svr,
Ecore_Con_Info_Cb done_cb,
- void *data)
+ void *data)
{
struct addrinfo hints;
int
ecore_con_info_mcast_listen(Ecore_Con_Server *svr,
Ecore_Con_Info_Cb done_cb,
- void *data)
+ void *data)
{
struct addrinfo hints;
static Eina_Bool
_ecore_con_info_ares_getnameinfo(Ecore_Con_CAres *arg,
- int addrtype, const char *name,
- struct sockaddr *addr, int addrlen)
+ int addrtype,
+ const char *name,
+ struct sockaddr *addr,
+ int addrlen)
{
int length = 0;
if (name)
- length = strlen(name) + 1;
+ length = strlen(name) + 1;
else
- length = 1;
+ length = 1;
arg->result = malloc(sizeof (Ecore_Con_Info) + length);
if (!arg->result)
- return EINA_FALSE;
+ return EINA_FALSE;
/* FIXME: What to do when hint is not set ? */
arg->result->info.ai_flags = arg->hints.ai_flags;
arg->result->info.ai_canonname = (char *)(arg->result + 1);
if (!name)
- *arg->result->info.ai_canonname = '\0';
+ *arg->result->info.ai_canonname = '\0';
else
- strcpy(arg->result->info.ai_canonname, name);
+ strcpy(arg->result->info.ai_canonname, name);
arg->result->info.ai_next = NULL;
ares_getnameinfo(
- info_channel, addr, addrlen,
- ARES_NI_NUMERICSERV | ARES_NI_NUMERICHOST |
- ARES_NI_LOOKUPSERVICE | ARES_NI_LOOKUPHOST,
- (ares_nameinfo_callback)_ecore_con_info_ares_nameinfo, arg);
+ info_channel, addr, addrlen,
+ ARES_NI_NUMERICSERV | ARES_NI_NUMERICHOST |
+ ARES_NI_LOOKUPSERVICE | ARES_NI_LOOKUPHOST,
+ (ares_nameinfo_callback)_ecore_con_info_ares_nameinfo, arg);
return EINA_TRUE;
}
-
EAPI int
ecore_con_info_get(Ecore_Con_Server *svr,
Ecore_Con_Info_Cb done_cb,
- void *data,
- struct addrinfo *hints)
+ void *data,
+ struct addrinfo *hints)
{
Ecore_Con_CAres *cares;
int ai_family = AF_INET6;
cares = calloc(1, sizeof (Ecore_Con_CAres));
if (!cares)
- return 0;
+ return 0;
cares->svr = svr;
cares->done_cb = done_cb;
}
static int
-_ecore_con_info_fds_search(const Ecore_Con_FD *fd1, const Ecore_Con_FD *fd2)
+_ecore_con_info_fds_search(const Ecore_Con_FD *fd1,
+ const Ecore_Con_FD *fd2)
{
return fd1->fd - fd2->fd;
}
fdl.fd = fd;
search = eina_list_search_unsorted(
- info_fds, (Eina_Compare_Cb)_ecore_con_info_fds_search, &fdl);
+ info_fds, (Eina_Compare_Cb)_ecore_con_info_fds_search, &fdl);
if (search)
{
int flags = 0;
if (FD_ISSET(i, &readers))
- flags |= ECORE_FD_READ;
+ flags |= ECORE_FD_READ;
if (FD_ISSET(i, &writers))
- flags |= ECORE_FD_WRITE;
+ flags |= ECORE_FD_WRITE;
if (flags)
- if (!_ecore_con_info_fds_lookup(i))
- {
- ecf = malloc(sizeof (Ecore_Con_FD));
- if (ecf)
- {
- ecf->fd = i;
- ecf->active = active;
- ecf->handler = ecore_main_fd_handler_add(
- i, ECORE_FD_WRITE | ECORE_FD_READ,
- _ecore_con_info_cares_fd_cb,
- NULL, NULL, NULL);
- info_fds = eina_list_append(info_fds, ecf);
- }
- }
-
+ if (!_ecore_con_info_fds_lookup(i))
+ {
+ ecf = malloc(sizeof (Ecore_Con_FD));
+ if (ecf)
+ {
+ ecf->fd = i;
+ ecf->active = active;
+ ecf->handler = ecore_main_fd_handler_add(
+ i, ECORE_FD_WRITE | ECORE_FD_READ,
+ _ecore_con_info_cares_fd_cb,
+ NULL, NULL, NULL);
+ info_fds = eina_list_append(info_fds, ecf);
+ }
+ }
}
info_readers = readers;
info_writers = writers;
EINA_LIST_FOREACH_SAFE(info_fds, l, l_next, ecf)
- {
- if (ecf->active != active)
- {
- ecore_main_fd_handler_del(ecf->handler);
- free(ecf);
- info_fds = eina_list_remove_list(info_fds, l);
- }
- }
+ {
+ if (ecf->active != active)
+ {
+ ecore_main_fd_handler_del(ecf->handler);
+ free(ecf);
+ info_fds = eina_list_remove_list(info_fds, l);
+ }
+ }
if (!info_fds)
{
if (tm)
- ecore_timer_del(tm);
+ ecore_timer_del(tm);
tm = NULL;
}
ares_timeout(info_channel, NULL, &tv);
if (tm)
- ecore_timer_delay(tm, tv.tv_sec);
+ ecore_timer_delay(tm, tv.tv_sec);
else
- tm =
- ecore_timer_add((double)tv.tv_sec,
- _ecore_con_info_cares_timeout_cb,
- NULL);
+ tm =
+ ecore_timer_add((double)tv.tv_sec,
+ _ecore_con_info_cares_timeout_cb,
+ NULL);
}
}
static Eina_Bool
-_ecore_con_info_cares_timeout_cb(void *data)
+_ecore_con_info_cares_timeout_cb(void *data __UNUSED__)
{
ares_process(info_channel, &info_readers, &info_writers);
_ecore_con_info_cares_clean();
}
static Eina_Bool
-_ecore_con_info_cares_fd_cb(void *data, Ecore_Fd_Handler *fd_handler)
+_ecore_con_info_cares_fd_cb(void *data __UNUSED__,
+ Ecore_Fd_Handler *fd_handler __UNUSED__)
{
ares_process(info_channel, &info_readers, &info_writers);
_ecore_con_info_cares_clean();
}
static void
-_ecore_con_info_ares_host_cb(Ecore_Con_CAres *arg, int status, int timeouts,
- struct hostent *hostent)
+_ecore_con_info_ares_host_cb(Ecore_Con_CAres *arg,
+ int status,
+ int timeouts __UNUSED__,
+ struct hostent *hostent)
{
struct sockaddr *addr;
int addrlen;
- int length = 0;
/* Found something ? */
switch (status)
{
case ARES_SUCCESS:
- if (!hostent->h_addr_list[0])
- {
- fprintf(stderr, "No IP found\n");
- goto on_error;
- }
+ if (!hostent->h_addr_list[0])
+ {
+ ERR("No IP found");
+ goto on_error;
+ }
- switch (hostent->h_addrtype)
+ switch (hostent->h_addrtype)
+ {
+ case AF_INET:
{
- case AF_INET:
- {
- struct sockaddr_in *addri;
+ struct sockaddr_in *addri;
- addrlen = sizeof (struct sockaddr_in);
- addri = malloc(addrlen);
+ addrlen = sizeof (struct sockaddr_in);
+ addri = malloc(addrlen);
- if (!addri)
- goto on_mem_error;
+ if (!addri)
+ goto on_mem_error;
- addri->sin_family = AF_INET;
- addri->sin_port = htons(arg->svr->port);
+ addri->sin_family = AF_INET;
+ addri->sin_port = htons(arg->svr->port);
- memcpy(&addri->sin_addr.s_addr,
- hostent->h_addr_list[0], sizeof (struct in_addr));
+ memcpy(&addri->sin_addr.s_addr,
+ hostent->h_addr_list[0], sizeof (struct in_addr));
- addr = (struct sockaddr *)addri;
- break;
- }
-
- case AF_INET6:
- {
- struct sockaddr_in6 *addri6;
+ addr = (struct sockaddr *)addri;
+ break;
+ }
- addrlen = sizeof (struct sockaddr_in6);
- addri6 = malloc(addrlen);
+ case AF_INET6:
+ {
+ struct sockaddr_in6 *addri6;
- if (!addri6)
- goto on_mem_error;
+ addrlen = sizeof (struct sockaddr_in6);
+ addri6 = malloc(addrlen);
- addri6->sin6_family = AF_INET6;
- addri6->sin6_port = htons(arg->svr->port);
- addri6->sin6_flowinfo = 0;
- addri6->sin6_scope_id = 0;
+ if (!addri6)
+ goto on_mem_error;
- memcpy(&addri6->sin6_addr.s6_addr,
- hostent->h_addr_list[0], sizeof (struct in6_addr));
+ addri6->sin6_family = AF_INET6;
+ addri6->sin6_port = htons(arg->svr->port);
+ addri6->sin6_flowinfo = 0;
+ addri6->sin6_scope_id = 0;
- addr = (struct sockaddr *)addri6;
- break;
- }
+ memcpy(&addri6->sin6_addr.s6_addr,
+ hostent->h_addr_list[0], sizeof (struct in6_addr));
- default:
- fprintf(stderr, "Unknown addrtype %i\n", hostent->h_addrtype);
- goto on_error;
+ addr = (struct sockaddr *)addri6;
+ break;
}
- if (!_ecore_con_info_ares_getnameinfo(arg, hostent->h_addrtype,
- hostent->h_name,
- addr, addrlen))
- goto on_error;
+ default:
+ ERR("Unknown addrtype %i", hostent->h_addrtype);
+ goto on_error;
+ }
+
+ if (!_ecore_con_info_ares_getnameinfo(arg, hostent->h_addrtype,
+ hostent->h_name,
+ addr, addrlen))
+ goto on_error;
- break;
+ break;
case ARES_ENOTFOUND: /* address notfound */
- if (arg->byaddr)
- {
- /* This happen when host doesn't have a reverse. */
+ if (arg->byaddr)
+ {
+ /* This happen when host doesn't have a reverse. */
if (arg->isv6)
{
struct sockaddr_in6 *addri6;
addri6 = malloc(addrlen);
if (!addri6)
- goto on_mem_error;
+ goto on_mem_error;
addri6->sin6_family = AF_INET6;
addri6->sin6_port = htons(arg->svr->port);
addri = malloc(addrlen);
if (!addri)
- goto on_mem_error;
+ goto on_mem_error;
addri->sin_family = AF_INET;
addri->sin_port = htons(arg->svr->port);
AF_INET,
NULL, addr,
addrlen))
- goto on_error;
+ goto on_error;
break;
- }
+ }
case ARES_ENOTIMP: /* unknown family */
case ARES_EBADNAME: /* not a valid internet address */
case ARES_ENOMEM: /* not enough memory */
case ARES_EDESTRUCTION: /* request canceled, shuting down */
- goto on_error;
+ goto on_error;
default:
- fprintf(stderr,
- "Unknown status returned by c-ares: %i assuming error\n",
- status);
- goto on_error;
+ ERR("Unknown status returned by c-ares: %i assuming error",
+ status);
+ goto on_error;
}
return;
on_mem_error:
- fprintf(stderr, "Not enough memory\n");
+ ERR("Not enough memory");
on_error:
arg->done_cb(arg->data, NULL);
}
static void
-_ecore_con_info_ares_nameinfo(Ecore_Con_CAres *arg, int status, int timeouts,
- char *node,
- char *service)
+_ecore_con_info_ares_nameinfo(Ecore_Con_CAres *arg,
+ int status,
+ int timeouts __UNUSED__,
+ char *node,
+ char *service)
{
switch (status)
{
case ARES_SUCCESS:
- if (node)
- strcpy(arg->result->ip, node);
- else
- *arg->result->ip = '\0';
+ if (node)
+ strcpy(arg->result->ip, node);
+ else
+ *arg->result->ip = '\0';
- if (service)
- strcpy(arg->result->service, service);
- else
- *arg->result->service = '\0';
+ if (service)
+ strcpy(arg->result->service, service);
+ else
+ *arg->result->service = '\0';
- arg->done_cb(arg->data, arg->result);
- break;
+ arg->done_cb(arg->data, arg->result);
+ break;
case ARES_ENOTIMP:
case ARES_ENOTFOUND:
case ARES_ENOMEM:
case ARES_EDESTRUCTION:
case ARES_EBADFLAGS:
- arg->done_cb(arg->data, NULL);
- break;
+ arg->done_cb(arg->data, NULL);
+ break;
}
free(arg->result->info.ai_addr);
free(arg->result);
free(arg);
}
+
# ifdef __cplusplus
extern "C"
# endif
-void *alloca (size_t);
+void *alloca(size_t);
#endif
#include <string.h>
struct _CB_Data
{
- EINA_INLIST;
- Ecore_Con_Info_Cb cb_done;
- void *data;
- Ecore_Fd_Handler *fdh;
- pid_t pid;
+ EINA_INLIST;
+ Ecore_Con_Info_Cb cb_done;
+ void *data;
+ Ecore_Fd_Handler *fdh;
+ pid_t pid;
Ecore_Event_Handler *handler;
- int fd2;
+ int fd2;
};
-
static void _ecore_con_info_readdata(CB_Data *cbdata);
static void _ecore_con_info_slave_free(CB_Data *cbdata);
-static Eina_Bool _ecore_con_info_data_handler(void *data,
+static Eina_Bool _ecore_con_info_data_handler(void *data,
Ecore_Fd_Handler *fd_handler);
-static Eina_Bool _ecore_con_info_exit_handler(void *data, int type __UNUSED__,
- void *event);
+static Eina_Bool _ecore_con_info_exit_handler(void *data,
+ int type __UNUSED__,
+ void *event);
static int info_init = 0;
static CB_Data *info_slaves = NULL;
{
info_init--;
if (info_init == 0)
- while (info_slaves) _ecore_con_info_slave_free(info_slaves);
+ while (info_slaves) _ecore_con_info_slave_free(info_slaves);
return info_init;
}
int
ecore_con_info_tcp_connect(Ecore_Con_Server *svr,
Ecore_Con_Info_Cb done_cb,
- void *data)
+ void *data)
{
struct addrinfo hints;
int
ecore_con_info_tcp_listen(Ecore_Con_Server *svr,
Ecore_Con_Info_Cb done_cb,
- void *data)
+ void *data)
{
struct addrinfo hints;
int
ecore_con_info_udp_connect(Ecore_Con_Server *svr,
Ecore_Con_Info_Cb done_cb,
- void *data)
+ void *data)
{
struct addrinfo hints;
int
ecore_con_info_udp_listen(Ecore_Con_Server *svr,
Ecore_Con_Info_Cb done_cb,
- void *data)
+ void *data)
{
struct addrinfo hints;
int
ecore_con_info_mcast_listen(Ecore_Con_Server *svr,
Ecore_Con_Info_Cb done_cb,
- void *data)
+ void *data)
{
struct addrinfo hints;
EAPI int
ecore_con_info_get(Ecore_Con_Server *svr,
Ecore_Con_Info_Cb done_cb,
- void *data,
- struct addrinfo *hints)
+ void *data,
+ struct addrinfo *hints)
{
CB_Data *cbdata;
int fd[2];
if (pipe(fd) < 0)
- return 0;
+ return 0;
cbdata = calloc(1, sizeof(CB_Data));
if (!cbdata)
if (!getaddrinfo(svr->name, service, hints, &result) && result)
{
if (result->ai_canonname)
- canonname_len = strlen(result->ai_canonname) + 1;
+ canonname_len = strlen(result->ai_canonname) + 1;
tosend_len = sizeof(Ecore_Con_Info) + result->ai_addrlen +
- canonname_len;
+ canonname_len;
if (!(tosend = alloca(tosend_len))) goto on_error;
memset(tosend, 0, tosend_len);
hbuf, sizeof(hbuf), sbuf, sizeof(sbuf),
NI_NUMERICHOST | NI_NUMERICSERV))
{
- memcpy(container->ip, hbuf, sizeof(container->ip));
+ memcpy(container->ip, hbuf, sizeof(container->ip));
memcpy(container->service, sbuf, sizeof(container->service));
}
on_error:
if (result)
- freeaddrinfo(result);
+ freeaddrinfo(result);
err = write(fd[1], "", 1);
close(fd[1]);
/* PARENT */
cbdata->handler =
- ecore_event_handler_add(ECORE_EXE_EVENT_DEL, _ecore_con_info_exit_handler,
- cbdata);
+ ecore_event_handler_add(ECORE_EXE_EVENT_DEL, _ecore_con_info_exit_handler,
+ cbdata);
close(fd[1]);
if (!cbdata->handler)
{
}
info_slaves = (CB_Data *)eina_inlist_append(EINA_INLIST_GET(
- info_slaves),
+ info_slaves),
EINA_INLIST_GET(cbdata));
return 1;
}
recv = (Ecore_Con_Info *)torecv;
recv->info.ai_addr =
- (struct sockaddr *)(torecv + sizeof(Ecore_Con_Info));
+ (struct sockaddr *)(torecv + sizeof(Ecore_Con_Info));
if ((size_t)torecv_len !=
(sizeof(Ecore_Con_Info) + recv->info.ai_addrlen))
- recv->info.ai_canonname = (char *)
- (torecv + sizeof(Ecore_Con_Info) + recv->info.ai_addrlen);
+ recv->info.ai_canonname = (char *)
+ (torecv + sizeof(Ecore_Con_Info) + recv->info.ai_addrlen);
else
- recv->info.ai_canonname = NULL;
+ recv->info.ai_canonname = NULL;
recv->info.ai_next = NULL;
free(torecv);
}
else
- cbdata->cb_done(cbdata->data, NULL);
+ cbdata->cb_done(cbdata->data, NULL);
}
else
- cbdata->cb_done(cbdata->data, NULL);
+ cbdata->cb_done(cbdata->data, NULL);
cbdata->cb_done = NULL;
}
}
static Eina_Bool
-_ecore_con_info_data_handler(void *data, Ecore_Fd_Handler *fd_handler)
+_ecore_con_info_data_handler(void *data,
+ Ecore_Fd_Handler *fd_handler)
{
CB_Data *cbdata;
{
if (ecore_main_fd_handler_active_get(fd_handler,
ECORE_FD_READ))
- _ecore_con_info_readdata(cbdata);
+ _ecore_con_info_readdata(cbdata);
else
{
cbdata->cb_done(cbdata->data, NULL);
}
static Eina_Bool
-_ecore_con_info_exit_handler(void *data, int type __UNUSED__, void *event)
+_ecore_con_info_exit_handler(void *data,
+ int type __UNUSED__,
+ void *event)
{
CB_Data *cbdata;
Ecore_Exe_Event_Del *ev;
ev = event;
cbdata = data;
if (cbdata->pid != ev->pid)
- return ECORE_CALLBACK_RENEW;
+ return ECORE_CALLBACK_RENEW;
return ECORE_CALLBACK_CANCEL; /* FIXME: Woot ??? */
_ecore_con_info_slave_free(cbdata);
return ECORE_CALLBACK_CANCEL;
}
+
#include "Ecore_Con.h"
#include "ecore_con_private.h"
-
-#define LENGTH_OF_SOCKADDR_UN(s) (strlen((s)->sun_path) + \
- (size_t)(((struct sockaddr_un *)NULL)-> \
- sun_path))
-#define LENGTH_OF_ABSTRACT_SOCKADDR_UN(s, path) (strlen(path) + 1 + \
+#define LENGTH_OF_SOCKADDR_UN(s) (strlen((s)->sun_path) + \
+ (size_t)(((struct sockaddr_un *)NULL)-> \
+ sun_path))
+#define LENGTH_OF_ABSTRACT_SOCKADDR_UN(s, path) (strlen(path) + 1 + \
(size_t)(((struct sockaddr_un \
*)NULL)->sun_path))
-
static int _ecore_con_local_init_count = 0;
int
ecore_con_local_init(void)
{
if (++_ecore_con_local_init_count != 1)
- return _ecore_con_local_init_count;
+ return _ecore_con_local_init_count;
return _ecore_con_local_init_count;
}
ecore_con_local_shutdown(void)
{
if (--_ecore_con_local_init_count != 0)
- return _ecore_con_local_init_count;
+ return _ecore_con_local_init_count;
return _ecore_con_local_init_count;
}
int
-ecore_con_local_connect(Ecore_Con_Server *svr,
- Eina_Bool (*cb_done)(void *data,
- Ecore_Fd_Handler *fd_handler),
- void *data __UNUSED__,
- void (*cb_free)(void *data, void *ev))
+ecore_con_local_connect(Ecore_Con_Server *svr,
+ Eina_Bool (*cb_done)(void *data,
+ Ecore_Fd_Handler *fd_handler),
+ void *data __UNUSED__,
+ void (*cb_free)(void *data,
+ void *ev))
{
char buf[4096];
struct sockaddr_un socket_unix;
{
homedir = getenv("HOME");
if (!homedir)
- homedir = getenv("TMP");
+ homedir = getenv("TMP");
if (!homedir)
- homedir = "/tmp";
+ homedir = "/tmp";
snprintf(buf, sizeof(buf), "%s/.ecore/%s/%i", homedir, svr->name,
svr->port);
if (svr->port < 0)
{
if (svr->name[0] == '/')
- strncpy(buf, svr->name, sizeof(buf));
+ strncpy(buf, svr->name, sizeof(buf));
else
- snprintf(buf, sizeof(buf), "/tmp/.ecore_service|%s", svr->name);
+ snprintf(buf, sizeof(buf), "/tmp/.ecore_service|%s", svr->name);
}
else
{
if (svr->name[0] ==
'/')
- snprintf(buf, sizeof(buf), "%s|%i", svr->name,
- svr->port);
+ snprintf(buf, sizeof(buf), "%s|%i", svr->name,
+ svr->port);
else
- snprintf(buf, sizeof(buf), "/tmp/.ecore_service|%s|%i",
- svr->name,
- svr->port);
+ snprintf(buf, sizeof(buf), "/tmp/.ecore_service|%s|%i",
+ svr->name,
+ svr->port);
}
}
else if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_ABSTRACT)
- strncpy(buf, svr->name,
- sizeof(buf));
+ strncpy(buf, svr->name,
+ sizeof(buf));
svr->fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (svr->fd < 0)
- return 0;
+ return 0;
if (fcntl(svr->fd, F_SETFL, O_NONBLOCK) < 0)
- return 0;
+ return 0;
if (fcntl(svr->fd, F_SETFD, FD_CLOEXEC) < 0)
- return 0;
+ return 0;
if (setsockopt(svr->fd, SOL_SOCKET, SO_REUSEADDR, (const void *)&curstate,
sizeof(curstate)) < 0)
- return 0;
+ return 0;
socket_unix.sun_family = AF_UNIX;
if (connect(svr->fd, (struct sockaddr *)&socket_unix,
socket_unix_len) < 0)
- return 0;
+ return 0;
svr->path = strdup(buf);
if (!svr->path)
- return 0;
+ return 0;
if (svr->type & ECORE_CON_SSL)
- ecore_con_ssl_server_init(svr);
+ ecore_con_ssl_server_init(svr);
svr->fd_handler =
- ecore_main_fd_handler_add(svr->fd, ECORE_FD_READ,
- cb_done, svr, NULL, NULL);
+ ecore_main_fd_handler_add(svr->fd, ECORE_FD_READ,
+ cb_done, svr, NULL, NULL);
if (!svr->fd_handler)
- return 0;
+ return 0;
if (!svr->delete_me)
{
/* we got our server! */
- Ecore_Con_Event_Server_Add *e;
-
- e = calloc(1, sizeof(Ecore_Con_Event_Server_Add));
- if (e)
- {
- svr->event_count++;
- e->server = svr;
- ecore_event_add(ECORE_CON_EVENT_SERVER_ADD, e,
- cb_free, NULL);
- }
+ Ecore_Con_Event_Server_Add *e;
+
+ e = calloc(1, sizeof(Ecore_Con_Event_Server_Add));
+ if (e)
+ {
+ svr->event_count++;
+ e->server = svr;
+ ecore_event_add(ECORE_CON_EVENT_SERVER_ADD, e,
+ cb_free, NULL);
+ }
}
return 1;
int
ecore_con_local_listen(
- Ecore_Con_Server *svr,
- Eina_Bool (*
- cb_listen)(void *data,
- Ecore_Fd_Handler *
- fd_handler),
- void *data
- __UNUSED__)
+ Ecore_Con_Server *svr,
+ Eina_Bool (*
+ cb_listen)(void *data,
+ Ecore_Fd_Handler *
+ fd_handler),
+ void *data
+ __UNUSED__)
{
char buf[4096];
struct sockaddr_un socket_unix;
{
homedir = getenv("HOME");
if (!homedir)
- homedir = getenv("TMP");
+ homedir = getenv("TMP");
if (!homedir)
- homedir = "/tmp";
+ homedir = "/tmp";
mask = S_IRUSR | S_IWUSR | S_IXUSR;
snprintf(buf, sizeof(buf), "%s/.ecore", homedir);
if (stat(buf, &st) < 0)
- mkdir(buf, mask);
+ mkdir(buf, mask);
snprintf(buf, sizeof(buf), "%s/.ecore/%s", homedir, svr->name);
if (stat(buf, &st) < 0)
- mkdir(buf, mask);
+ mkdir(buf, mask);
- snprintf(buf,
+ snprintf(buf,
sizeof(buf),
"%s/.ecore/%s/%i",
homedir,
if (svr->name[0] == '/')
{
if (svr->port >= 0)
- snprintf(buf,
- sizeof(buf),
- "%s|%i",
- svr->name,
- svr->port);
+ snprintf(buf,
+ sizeof(buf),
+ "%s|%i",
+ svr->name,
+ svr->port);
else
- snprintf(buf,
- sizeof(buf),
- "%s",
- svr->name);
+ snprintf(buf,
+ sizeof(buf),
+ "%s",
+ svr->name);
}
else
- snprintf(buf,
- sizeof(buf),
- "/tmp/.ecore_service|%s|%i",
- svr->name,
- svr->port);
+ snprintf(buf,
+ sizeof(buf),
+ "/tmp/.ecore_service|%s|%i",
+ svr->name,
+ svr->port);
}
else if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_ABSTRACT)
- strncpy(buf, svr->name,
- sizeof(buf));
+ strncpy(buf, svr->name,
+ sizeof(buf));
pmode = umask(mask);
start:
svr->fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (svr->fd < 0)
- goto error_umask;
+ goto error_umask;
if (fcntl(svr->fd, F_SETFL, O_NONBLOCK) < 0)
- goto error_umask;
+ goto error_umask;
if (fcntl(svr->fd, F_SETFD, FD_CLOEXEC) < 0)
- goto error_umask;
+ goto error_umask;
lin.l_onoff = 1;
lin.l_linger = 0;
if (setsockopt(svr->fd, SOL_SOCKET, SO_LINGER, (const void *)&lin,
sizeof(struct linger)) < 0)
- goto error_umask;
+ goto error_umask;
socket_unix.sun_family = AF_UNIX;
if ((svr->type & ECORE_CON_TYPE) == ECORE_CON_LOCAL_ABSTRACT)
(connect(svr->fd, (struct sockaddr *)&socket_unix,
socket_unix_len) < 0) &&
(unlink(buf) >= 0))
- goto start;
+ goto start;
else
- goto error_umask;
+ goto error_umask;
}
if (listen(svr->fd, 4096) < 0)
- goto error_umask;
+ goto error_umask;
svr->path = strdup(buf);
if (!svr->path)
- goto error_umask;
+ goto error_umask;
svr->fd_handler =
- ecore_main_fd_handler_add(svr->fd, ECORE_FD_READ,
- cb_listen, svr, NULL, NULL);
+ ecore_main_fd_handler_add(svr->fd, ECORE_FD_READ,
+ cb_listen, svr, NULL, NULL);
umask(pmode);
if (!svr->fd_handler)
- goto error;
+ goto error;
return 1;
error:
return 0;
}
+
int buf_size;
int buf_offset;
unsigned char *buf;
- char *ip;
+ const char *ip;
int event_count;
struct sockaddr *client_addr;
int client_addr_len;
#endif
double start_time;
double client_disconnect_time;
- char *ip;
+ const char *ip;
Eina_Bool dead : 1;
Eina_Bool created : 1; /* EINA_TRUE if server is our listening server */
Eina_Bool connecting : 1; /* EINA_FALSE if just initialized or connected */
static void
_gnutls_print_errors(int ret)
{
- if (ret)
- ERR("gnutls returned with error: %s - %s", gnutls_strerror_name(ret), gnutls_strerror(ret));
+ if (ret)
+ ERR("gnutls returned with error: %s - %s", gnutls_strerror_name(ret), gnutls_strerror(ret));
}
+static void
+_gnutls_log_func(int level,
+ const char *str)
+{
+ DBG("|<%d>| %s", level, str);
+}
-static const char*
+static const char *
SSL_GNUTLS_PRINT_HANDSHAKE_STATUS(gnutls_handshake_description_t status)
{
switch (status)
{
case GNUTLS_HANDSHAKE_HELLO_REQUEST:
return "Hello request";
+
case GNUTLS_HANDSHAKE_CLIENT_HELLO:
return "Client hello";
+
case GNUTLS_HANDSHAKE_SERVER_HELLO:
return "Server hello";
+
case GNUTLS_HANDSHAKE_NEW_SESSION_TICKET:
return "New session ticket";
+
case GNUTLS_HANDSHAKE_CERTIFICATE_PKT:
return "Certificate packet";
+
case GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE:
return "Server key exchange";
+
case GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST:
return "Certificate request";
+
case GNUTLS_HANDSHAKE_SERVER_HELLO_DONE:
return "Server hello done";
+
case GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY:
return "Certificate verify";
+
case GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE:
return "Client key exchange";
+
case GNUTLS_HANDSHAKE_FINISHED:
return "Finished";
+
case GNUTLS_HANDSHAKE_SUPPLEMENTAL:
return "Supplemental";
}
ERR("openssl error: %s", ERR_reason_error_string(err));
} while (1);
}
-#endif
-#define SSL_ERROR_CHECK_GOTO_ERROR(X) \
-do \
- { \
- if ((X)) \
- { \
- ERR("Error at %s:%s:%d!", __FILE__, __PRETTY_FUNCTION__, __LINE__); \
- goto error; \
- } \
- } \
-while (0)
+#endif
+#define SSL_ERROR_CHECK_GOTO_ERROR(X) \
+ do \
+ { \
+ if ((X)) \
+ { \
+ ERR("Error at %s:%s:%d!", __FILE__, __PRETTY_FUNCTION__, __LINE__); \
+ goto error; \
+ } \
+ } \
+ while (0)
static Ecore_Con_Ssl_Error
- SSL_SUFFIX(_ecore_con_ssl_init) (void);
+ SSL_SUFFIX(_ecore_con_ssl_init) (void);
static Ecore_Con_Ssl_Error
- SSL_SUFFIX(_ecore_con_ssl_shutdown) (void);
+ SSL_SUFFIX(_ecore_con_ssl_shutdown) (void);
-static Eina_Bool SSL_SUFFIX(_ecore_con_ssl_server_cafile_add) (Ecore_Con_Server *svr, const char *ca_file);
-static Eina_Bool SSL_SUFFIX(_ecore_con_ssl_server_crl_add) (Ecore_Con_Server *svr, const char *crl_file);
-static Eina_Bool SSL_SUFFIX(_ecore_con_ssl_server_cert_add) (Ecore_Con_Server *svr, const char *cert);
-static Eina_Bool SSL_SUFFIX(_ecore_con_ssl_server_privkey_add) (Ecore_Con_Server *svr, const char *key_file);
+static Eina_Bool SSL_SUFFIX(_ecore_con_ssl_server_cafile_add) (Ecore_Con_Server * svr, const char *ca_file);
+static Eina_Bool SSL_SUFFIX(_ecore_con_ssl_server_crl_add) (Ecore_Con_Server * svr, const char *crl_file);
+static Eina_Bool SSL_SUFFIX(_ecore_con_ssl_server_cert_add) (Ecore_Con_Server * svr, const char *cert);
+static Eina_Bool SSL_SUFFIX(_ecore_con_ssl_server_privkey_add) (Ecore_Con_Server * svr, const char *key_file);
-static Ecore_Con_Ssl_Error SSL_SUFFIX(_ecore_con_ssl_server_prepare)(Ecore_Con_Server *svr, int ssl_type);
+static Ecore_Con_Ssl_Error SSL_SUFFIX(_ecore_con_ssl_server_prepare) (Ecore_Con_Server * svr, int ssl_type);
static Ecore_Con_Ssl_Error
- SSL_SUFFIX(_ecore_con_ssl_server_init) (Ecore_Con_Server * svr);
+ SSL_SUFFIX(_ecore_con_ssl_server_init) (Ecore_Con_Server * svr);
static Ecore_Con_Ssl_Error
- SSL_SUFFIX(_ecore_con_ssl_server_shutdown) (Ecore_Con_Server *
+ SSL_SUFFIX(_ecore_con_ssl_server_shutdown) (Ecore_Con_Server *
svr);
static int
- SSL_SUFFIX(_ecore_con_ssl_server_read) (Ecore_Con_Server * svr,
+SSL_SUFFIX(_ecore_con_ssl_server_read) (Ecore_Con_Server * svr,
unsigned char *buf, int size);
static int
- SSL_SUFFIX(_ecore_con_ssl_server_write) (Ecore_Con_Server *
+SSL_SUFFIX(_ecore_con_ssl_server_write) (Ecore_Con_Server *
svr,
unsigned char *buf, int size);
static Ecore_Con_Ssl_Error
- SSL_SUFFIX(_ecore_con_ssl_client_init) (Ecore_Con_Client * cl);
+ SSL_SUFFIX(_ecore_con_ssl_client_init) (Ecore_Con_Client * cl);
static Ecore_Con_Ssl_Error
- SSL_SUFFIX(_ecore_con_ssl_client_shutdown) (Ecore_Con_Client *
+ SSL_SUFFIX(_ecore_con_ssl_client_shutdown) (Ecore_Con_Client *
cl);
static int
- SSL_SUFFIX(_ecore_con_ssl_client_read) (Ecore_Con_Client * cl,
+SSL_SUFFIX(_ecore_con_ssl_client_read) (Ecore_Con_Client * cl,
unsigned char *buf, int size);
static int
- SSL_SUFFIX(_ecore_con_ssl_client_write) (Ecore_Con_Client * cl,
+SSL_SUFFIX(_ecore_con_ssl_client_write) (Ecore_Con_Client * cl,
unsigned char *buf, int size);
/*
ecore_con_ssl_init(void)
{
if (!_init_con_ssl_init_count++)
- SSL_SUFFIX(_ecore_con_ssl_init) ();
+ SSL_SUFFIX(_ecore_con_ssl_init) ();
return _init_con_ssl_init_count;
}
}
Ecore_Con_Ssl_Error
-ecore_con_ssl_server_prepare(Ecore_Con_Server *svr, int ssl_type)
+ecore_con_ssl_server_prepare(Ecore_Con_Server *svr,
+ int ssl_type)
{
if (!ssl_type)
return ECORE_CON_SSL_ERROR_NONE;
}
int
-ecore_con_ssl_server_read(Ecore_Con_Server *svr, unsigned char *buf, int size)
+ecore_con_ssl_server_read(Ecore_Con_Server *svr,
+ unsigned char *buf,
+ int size)
{
return SSL_SUFFIX(_ecore_con_ssl_server_read) (svr, buf, size);
}
int
-ecore_con_ssl_server_write(Ecore_Con_Server *svr, unsigned char *buf, int size)
+ecore_con_ssl_server_write(Ecore_Con_Server *svr,
+ unsigned char *buf,
+ int size)
{
return SSL_SUFFIX(_ecore_con_ssl_server_write) (svr, buf, size);
}
}
int
-ecore_con_ssl_client_read(Ecore_Con_Client *cl, unsigned char *buf, int size)
+ecore_con_ssl_client_read(Ecore_Con_Client *cl,
+ unsigned char *buf,
+ int size)
{
return SSL_SUFFIX(_ecore_con_ssl_client_read) (cl, buf, size);
}
int
-ecore_con_ssl_client_write(Ecore_Con_Client *cl, unsigned char *buf, int size)
+ecore_con_ssl_client_write(Ecore_Con_Client *cl,
+ unsigned char *buf,
+ int size)
{
return SSL_SUFFIX(_ecore_con_ssl_client_write) (cl, buf, size);
}
}
svr->verify = EINA_TRUE;
}
-
+
/**
* @brief Add an ssl certificate for use in ecore_con functions.
*
EAPI Eina_Bool
ecore_con_ssl_server_cert_add(Ecore_Con_Server *svr,
- const char *cert)
+ const char *cert)
{
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
{
return EINA_FALSE;
}
- return SSL_SUFFIX(_ecore_con_ssl_server_cert_add)(svr, cert);
+ return SSL_SUFFIX(_ecore_con_ssl_server_cert_add) (svr, cert);
}
/**
EAPI Eina_Bool
ecore_con_ssl_server_cafile_add(Ecore_Con_Server *svr,
- const char *ca_file)
+ const char *ca_file)
{
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
{
return EINA_FALSE;
}
- return SSL_SUFFIX(_ecore_con_ssl_server_cafile_add)(svr, ca_file);
+ return SSL_SUFFIX(_ecore_con_ssl_server_cafile_add) (svr, ca_file);
}
/**
EAPI Eina_Bool
ecore_con_ssl_server_privkey_add(Ecore_Con_Server *svr,
- const char *key_file)
+ const char *key_file)
{
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
{
return EINA_FALSE;
}
- return SSL_SUFFIX(_ecore_con_ssl_server_privkey_add)(svr, key_file);
+ return SSL_SUFFIX(_ecore_con_ssl_server_privkey_add) (svr, key_file);
}
/**
EAPI Eina_Bool
ecore_con_ssl_server_crl_add(Ecore_Con_Server *svr,
- const char *crl_file)
+ const char *crl_file)
{
if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
{
return EINA_FALSE;
}
- return SSL_SUFFIX(_ecore_con_ssl_server_crl_add)(svr, crl_file);
+ return SSL_SUFFIX(_ecore_con_ssl_server_crl_add) (svr, crl_file);
}
/**
_ecore_con_ssl_init_gnutls(void)
{
#ifdef EFL_HAVE_PTHREAD
- if (gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread))
- WRN(
- "YOU ARE USING PTHREADS, BUT I CANNOT INITIALIZE THREADSAFE GCRYPT OPERATIONS!");
-
+ if (gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread))
+ WRN("YOU ARE USING PTHREADS, BUT I CANNOT INITIALIZE THREADSAFE GCRYPT OPERATIONS!");
#endif
if (gnutls_global_init())
- return ECORE_CON_SSL_ERROR_INIT_FAILED;
+ return ECORE_CON_SSL_ERROR_INIT_FAILED;
+ gnutls_global_set_log_level(9);
+ gnutls_global_set_log_function(_gnutls_log_func);
return ECORE_CON_SSL_ERROR_NONE;
}
}
static Ecore_Con_Ssl_Error
-_ecore_con_ssl_server_prepare_gnutls(Ecore_Con_Server *svr, int ssl_type __UNUSED__)
+_ecore_con_ssl_server_prepare_gnutls(Ecore_Con_Server *svr,
+ int ssl_type)
{
int ret;
+ if (ssl_type & ECORE_CON_USE_SSL2)
+ return ECORE_CON_SSL_ERROR_SSL2_NOT_SUPPORTED;
+
+ switch (ssl_type)
+ {
+ case ECORE_CON_USE_SSL3:
+ case ECORE_CON_USE_SSL3 | ECORE_CON_LOAD_CERT:
+ case ECORE_CON_USE_TLS:
+ case ECORE_CON_USE_TLS | ECORE_CON_LOAD_CERT:
+ case ECORE_CON_USE_MIXED:
+ case ECORE_CON_USE_MIXED | ECORE_CON_LOAD_CERT:
+ break;
+
+ default:
+ return ECORE_CON_SSL_ERROR_NONE;
+ }
+
SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_certificate_allocate_credentials(&svr->cert));
- if (svr->created)
+ if ((!svr->use_cert) && svr->created)
{
SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_dh_params_init(&svr->dh_params));
INF("Generating DH params");
SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_anon_allocate_server_credentials(&svr->anoncred_s));
/* TODO: implement PSK */
- SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_psk_allocate_server_credentials(&svr->pskcred_s));
+ // SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_psk_allocate_server_credentials(&svr->pskcred_s));
gnutls_anon_set_server_dh_params(svr->anoncred_s, svr->dh_params);
gnutls_certificate_set_dh_params(svr->cert, svr->dh_params);
- gnutls_psk_set_server_dh_params(svr->pskcred_s, svr->dh_params);
+ //gnutls_psk_set_server_dh_params(svr->pskcred_s, svr->dh_params);
+ INF("DH params successfully generated and applied!");
}
- else
+ else if (!svr->use_cert)
{
- SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_psk_allocate_client_credentials(&svr->pskcred_c));
- SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_anon_allocate_client_credentials(&svr->anoncred_c));
+ //SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_psk_allocate_client_credentials(&svr->pskcred_c));
+ SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_anon_allocate_client_credentials(&svr->anoncred_c));
}
return ECORE_CON_SSL_ERROR_NONE;
return ECORE_CON_SSL_ERROR_SERVER_INIT_FAILED;
}
-/* Tries to connect an Ecore_Con_Server to an SSL host.
- * Returns 1 on success, -1 on fatal errors and 0 if the caller
- * should try again later.
- */
static Ecore_Con_Ssl_Error
_ecore_con_ssl_server_init_gnutls(Ecore_Con_Server *svr)
{
{
case ECORE_CON_SSL_STATE_DONE:
return ECORE_CON_SSL_ERROR_NONE;
+
case ECORE_CON_SSL_STATE_INIT:
if (svr->type & ECORE_CON_USE_SSL2) /* not supported because of security issues */
return ECORE_CON_SSL_ERROR_SSL2_NOT_SUPPORTED;
{
case ECORE_CON_USE_SSL3:
case ECORE_CON_USE_SSL3 | ECORE_CON_LOAD_CERT:
- priority = "NONE:%VERIFY_ALLOW_X509_V1_CA_CRT:+RSA:+DHE-RSA:+DHE-DSS:+ANON-DH:+COMP-DEFLATE:+COMP-NULL:+CTYPE-X509:+SHA1:+SHA256:+SHA384:+SHA512:+AES-256-CBC:+AES-128-CBC:+3DES-CBC:!VERS-TLS1.0:!VERS-TLS1.1";
- break;
+ priority = "NONE:%VERIFY_ALLOW_X509_V1_CA_CRT:+RSA:+DHE-RSA:+DHE-DSS:+ANON-DH:+COMP-DEFLATE:+COMP-NULL:+CTYPE-X509:+SHA1:+SHA256:+SHA384:+SHA512:+AES-256-CBC:+AES-128-CBC:+3DES-CBC:!VERS-TLS1.0:!VERS-TLS1.1";
+ break;
case ECORE_CON_USE_TLS:
case ECORE_CON_USE_TLS | ECORE_CON_LOAD_CERT:
- priority = "NONE:%VERIFY_ALLOW_X509_V1_CA_CRT:+RSA:+DHE-RSA:+DHE-DSS:+ANON-DH:+COMP-DEFLATE:+COMP-NULL:+CTYPE-X509:+SHA1:+SHA256:+SHA384:+SHA512:+AES-256-CBC:+AES-128-CBC:+3DES-CBC:!VERS-SSL3.0";
- break;
+ priority = "NONE:%VERIFY_ALLOW_X509_V1_CA_CRT:+RSA:+DHE-RSA:+DHE-DSS:+ANON-DH:+COMP-DEFLATE:+COMP-NULL:+CTYPE-X509:+SHA1:+SHA256:+SHA384:+SHA512:+AES-256-CBC:+AES-128-CBC:+3DES-CBC:!VERS-SSL3.0";
+ break;
case ECORE_CON_USE_MIXED:
case ECORE_CON_USE_MIXED | ECORE_CON_LOAD_CERT:
- break;
+ break;
default:
- return ECORE_CON_SSL_ERROR_NONE;
+ return ECORE_CON_SSL_ERROR_NONE;
}
SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_init(&svr->session, GNUTLS_CLIENT));
SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_session_ticket_enable_client(svr->session));
SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_server_name_set(svr->session, GNUTLS_NAME_DNS, svr->name, strlen(svr->name)));
+ INF("Applying priority string: %s", priority);
SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_priority_set_direct(svr->session, priority, NULL));
SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_credentials_set(svr->session, GNUTLS_CRD_CERTIFICATE, svr->cert));
- SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_credentials_set(svr->session, GNUTLS_CRD_PSK, svr->pskcred_c));
- SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_credentials_set(svr->session, GNUTLS_CRD_ANON, svr->anoncred_c));
+ // SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_credentials_set(svr->session, GNUTLS_CRD_PSK, svr->pskcred_c));
+ if (!svr->use_cert)
+ SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_credentials_set(svr->session, GNUTLS_CRD_ANON, svr->anoncred_c));
gnutls_dh_set_prime_bits(svr->session, 512);
gnutls_transport_set_ptr(svr->session, (gnutls_transport_ptr_t)svr->fd);
svr->ssl_state = ECORE_CON_SSL_STATE_HANDSHAKING;
+
case ECORE_CON_SSL_STATE_HANDSHAKING:
+ if (!svr->session)
+ {
+ DBG("Server was previously lost, going to error condition");
+ goto error;
+ }
ret = gnutls_handshake(svr->session);
DBG("calling gnutls_handshake(): returned with '%s'", gnutls_strerror_name(ret));
SSL_ERROR_CHECK_GOTO_ERROR(gnutls_error_is_fatal(ret));
ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_READ);
return ECORE_CON_SSL_ERROR_NONE;
}
+
default:
break;
}
goto error;
}
-
SSL_ERROR_CHECK_GOTO_ERROR(!(cert_list = gnutls_certificate_get_peers(svr->session, &cert_list_size)));
SSL_ERROR_CHECK_GOTO_ERROR(!cert_list_size);
_gnutls_print_errors(ret);
if ((ret == GNUTLS_E_WARNING_ALERT_RECEIVED) || (ret == GNUTLS_E_FATAL_ALERT_RECEIVED))
ERR("Also received alert: %s", gnutls_alert_get_name(gnutls_alert_get(svr->session)));
- if (svr->ssl_state != ECORE_CON_SSL_STATE_DONE)
+ if (svr->session && (svr->ssl_state != ECORE_CON_SSL_STATE_DONE))
{
- ERR("last out: %s", SSL_GNUTLS_PRINT_HANDSHAKE_STATUS(gnutls_handshake_get_last_out(svr->session)));
- ERR("last in: %s", SSL_GNUTLS_PRINT_HANDSHAKE_STATUS(gnutls_handshake_get_last_in(svr->session)));
+ ERR("last out: %s", SSL_GNUTLS_PRINT_HANDSHAKE_STATUS(gnutls_handshake_get_last_out(svr->session)));
+ ERR("last in: %s", SSL_GNUTLS_PRINT_HANDSHAKE_STATUS(gnutls_handshake_get_last_in(svr->session)));
}
if (cert)
gnutls_x509_crt_deinit(cert);
}
static Eina_Bool
-_ecore_con_ssl_server_cafile_add_gnutls(Ecore_Con_Server *svr, const char *ca_file)
+_ecore_con_ssl_server_cafile_add_gnutls(Ecore_Con_Server *svr,
+ const char *ca_file)
{
SSL_ERROR_CHECK_GOTO_ERROR(gnutls_certificate_set_x509_trust_file(svr->cert, ca_file,
- GNUTLS_X509_FMT_PEM) < 1);
+ GNUTLS_X509_FMT_PEM) < 1);
return EINA_TRUE;
error:
}
static Eina_Bool
-_ecore_con_ssl_server_crl_add_gnutls(Ecore_Con_Server *svr, const char *crl_file)
+_ecore_con_ssl_server_crl_add_gnutls(Ecore_Con_Server *svr,
+ const char *crl_file)
{
SSL_ERROR_CHECK_GOTO_ERROR(gnutls_certificate_set_x509_crl_file(svr->cert, crl_file,
- GNUTLS_X509_FMT_PEM) < 1);
+ GNUTLS_X509_FMT_PEM) < 1);
return EINA_TRUE;
error:
return EINA_FALSE;
}
-
static Eina_Bool
-_ecore_con_ssl_server_privkey_add_gnutls(Ecore_Con_Server *svr, const char *key_file)
+_ecore_con_ssl_server_privkey_add_gnutls(Ecore_Con_Server *svr,
+ const char *key_file)
{
SSL_ERROR_CHECK_GOTO_ERROR(gnutls_certificate_set_x509_key_file(svr->cert, svr->cert_file, key_file,
- GNUTLS_X509_FMT_PEM));
+ GNUTLS_X509_FMT_PEM));
return EINA_TRUE;
error:
return EINA_FALSE;
}
-
static Eina_Bool
-_ecore_con_ssl_server_cert_add_gnutls(Ecore_Con_Server *svr, const char *cert_file)
+_ecore_con_ssl_server_cert_add_gnutls(Ecore_Con_Server *svr,
+ const char *cert_file)
{
if (!(svr->cert_file = strdup(cert_file)))
return EINA_FALSE;
return EINA_TRUE;
}
-
static Ecore_Con_Ssl_Error
_ecore_con_ssl_server_shutdown_gnutls(Ecore_Con_Server *svr)
{
}
if (svr->anoncred_s)
gnutls_anon_free_server_credentials(svr->anoncred_s);
- if (svr->pskcred_s)
- gnutls_psk_free_server_credentials(svr->pskcred_s);
+ // if (svr->pskcred_s)
+ // gnutls_psk_free_server_credentials(svr->pskcred_s);
svr->anoncred_s = NULL;
svr->pskcred_s = NULL;
{
if (svr->anoncred_c)
gnutls_anon_free_client_credentials(svr->anoncred_c);
- if (svr->pskcred_c)
- gnutls_psk_free_client_credentials(svr->pskcred_c);
+ // if (svr->pskcred_c)
+ // gnutls_psk_free_client_credentials(svr->pskcred_c);
svr->anoncred_c = NULL;
svr->pskcred_c = NULL;
return ECORE_CON_SSL_ERROR_NONE;
}
-
static int
-_ecore_con_ssl_server_read_gnutls(Ecore_Con_Server *svr, unsigned char *buf,
- int size)
+_ecore_con_ssl_server_read_gnutls(Ecore_Con_Server *svr,
+ unsigned char *buf,
+ int size)
{
int num;
return 0;
return -1;
}
-
+
num = gnutls_record_recv(svr->session, buf, size);
if (num > 0)
- return num;
+ return num;
if (num == GNUTLS_E_REHANDSHAKE)
{
if (!_ecore_con_ssl_server_init_gnutls(svr))
return 0;
}
- else if ((num == GNUTLS_E_AGAIN) || (num == GNUTLS_E_INTERRUPTED))
- return 0;
+ else if (!gnutls_error_is_fatal(num))
+ return 0;
return -1;
}
static int
-_ecore_con_ssl_server_write_gnutls(Ecore_Con_Server *svr, unsigned char *buf,
- int size)
+_ecore_con_ssl_server_write_gnutls(Ecore_Con_Server *svr,
+ unsigned char *buf,
+ int size)
{
int num;
-
if (svr->ssl_state == ECORE_CON_SSL_STATE_HANDSHAKING)
{
DBG("Continuing gnutls handshake");
num = gnutls_record_send(svr->session, buf, size);
if (num > 0)
- return num;
+ return num;
if (num == GNUTLS_E_REHANDSHAKE)
{
- WRN("Rehandshake request ignored");
- return 0;
+ WRN("Rehandshake request ignored");
+ return 0;
/* this is only partly functional I think? */
svr->handshaking = EINA_TRUE;
svr->ssl_state = ECORE_CON_SSL_STATE_HANDSHAKING;
if (!_ecore_con_ssl_server_init_gnutls(svr))
return 0;
}
- else if ((num == GNUTLS_E_AGAIN) || (num == GNUTLS_E_INTERRUPTED))
- return 0;
+ else if (!gnutls_error_is_fatal(num))
+ return 0;
return -1;
}
-
static Ecore_Con_Ssl_Error
_ecore_con_ssl_client_init_gnutls(Ecore_Con_Client *cl)
{
+ const gnutls_datum_t *cert_list;
+ unsigned int iter, cert_list_size;
+ gnutls_x509_crt_t cert = NULL;
const char *priority = "NONE:%VERIFY_ALLOW_X509_V1_CA_CRT:+RSA:+DHE-RSA:+DHE-DSS:+ANON-DH:+COMP-DEFLATE:+COMP-NULL:+CTYPE-X509:+SHA1:+SHA256:+SHA384:+SHA512:+AES-256-CBC:+AES-128-CBC:+3DES-CBC:+VERS-TLS1.2:+VERS-TLS1.1:+VERS-TLS1.0:+VERS-SSL3.0";
int ret = 0;
{
case ECORE_CON_SSL_STATE_DONE:
return ECORE_CON_SSL_ERROR_NONE;
+
case ECORE_CON_SSL_STATE_INIT:
if (cl->host_server->type & ECORE_CON_USE_SSL2) /* not supported because of security issues */
return ECORE_CON_SSL_ERROR_SSL2_NOT_SUPPORTED;
{
case ECORE_CON_USE_SSL3:
case ECORE_CON_USE_SSL3 | ECORE_CON_LOAD_CERT:
- priority = "NONE:%VERIFY_ALLOW_X509_V1_CA_CRT:+RSA:+DHE-RSA:+DHE-DSS:+ANON-DH:+COMP-DEFLATE:+COMP-NULL:+CTYPE-X509:+SHA1:+SHA256:+SHA384:+SHA512:+AES-256-CBC:+AES-128-CBC:+3DES-CBC:!VERS-TLS1.0:!VERS-TLS1.1";
- break;
+ priority = "NONE:%VERIFY_ALLOW_X509_V1_CA_CRT:+RSA:+DHE-RSA:+DHE-DSS:+ANON-DH:+COMP-DEFLATE:+COMP-NULL:+CTYPE-X509:+SHA1:+SHA256:+SHA384:+SHA512:+AES-256-CBC:+AES-128-CBC:+3DES-CBC:!VERS-TLS1.0:!VERS-TLS1.1";
+ break;
case ECORE_CON_USE_TLS:
case ECORE_CON_USE_TLS | ECORE_CON_LOAD_CERT:
- priority = "NONE:%VERIFY_ALLOW_X509_V1_CA_CRT:+RSA:+DHE-RSA:+DHE-DSS:+ANON-DH:+COMP-DEFLATE:+COMP-NULL:+CTYPE-X509:+SHA1:+SHA256:+SHA384:+SHA512:+AES-256-CBC:+AES-128-CBC:+3DES-CBC:!VERS-SSL3.0";
- break;
+ priority = "NONE:%VERIFY_ALLOW_X509_V1_CA_CRT:+RSA:+DHE-RSA:+DHE-DSS:+ANON-DH:+COMP-DEFLATE:+COMP-NULL:+CTYPE-X509:+SHA1:+SHA256:+SHA384:+SHA512:+AES-256-CBC:+AES-128-CBC:+3DES-CBC:!VERS-SSL3.0";
+ break;
+
+ case ECORE_CON_USE_MIXED:
+ case ECORE_CON_USE_MIXED | ECORE_CON_LOAD_CERT:
+ break;
default:
- return ECORE_CON_SSL_ERROR_NONE;
+ return ECORE_CON_SSL_ERROR_NONE;
}
_client_connected++;
SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_init(&cl->session, GNUTLS_SERVER));
-#ifdef USE_GNUTLS_2_10
SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_session_ticket_key_generate(&cl->session_ticket));
SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_session_ticket_enable_server(cl->session, &cl->session_ticket));
-#endif
+ INF("Applying priority string: %s", priority);
SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_priority_set_direct(cl->session, priority, NULL));
+ SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_credentials_set(cl->session, GNUTLS_CRD_CERTIFICATE, cl->host_server->cert));
+ // SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_credentials_set(cl->session, GNUTLS_CRD_PSK, cl->host_server->pskcred_s));
+ if (!cl->host_server->use_cert)
+ SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_credentials_set(cl->session, GNUTLS_CRD_ANON, cl->host_server->anoncred_s));
gnutls_certificate_server_set_request(cl->session, GNUTLS_CERT_REQUEST);
gnutls_dh_set_prime_bits(cl->session, 2048);
gnutls_transport_set_ptr(cl->session, (gnutls_transport_ptr_t)cl->fd);
cl->ssl_state = ECORE_CON_SSL_STATE_HANDSHAKING;
+
case ECORE_CON_SSL_STATE_HANDSHAKING:
+ if (!cl->session)
+ {
+ DBG("Client was previously lost, going to error condition");
+ goto error;
+ }
DBG("calling gnutls_handshake()");
ret = gnutls_handshake(cl->session);
SSL_ERROR_CHECK_GOTO_ERROR(gnutls_error_is_fatal(ret));
ecore_main_fd_handler_active_set(cl->fd_handler, ECORE_FD_READ);
return ECORE_CON_SSL_ERROR_NONE;
}
+
default:
break;
}
- /* TODO: add cert verification support */
+ if (!cl->host_server->verify)
+ /* not verifying certificates, so we're done! */
+ return ECORE_CON_SSL_ERROR_NONE;
+ ret = 0;
+ /* use CRL/CA lists to verify */
+ SSL_ERROR_CHECK_GOTO_ERROR(ret = gnutls_certificate_verify_peers2(cl->session, &iter));
+ if (iter & GNUTLS_CERT_INVALID)
+ ERR("The certificate is not trusted.");
+ else if (iter & GNUTLS_CERT_SIGNER_NOT_FOUND)
+ ERR("The certificate hasn't got a known issuer.");
+ else if (iter & GNUTLS_CERT_REVOKED)
+ ERR("The certificate has been revoked.");
+ else if (iter & GNUTLS_CERT_EXPIRED)
+ ERR("The certificate has expired");
+ else if (iter & GNUTLS_CERT_NOT_ACTIVATED)
+ ERR("The certificate is not yet activated");
+
+ if (iter)
+ goto error;
+
+ if (gnutls_certificate_type_get(cl->session) != GNUTLS_CRT_X509)
+ {
+ ERR("Warning: PGP certificates are not yet supported!");
+ goto error;
+ }
+
+ SSL_ERROR_CHECK_GOTO_ERROR(!(cert_list = gnutls_certificate_get_peers(cl->session, &cert_list_size)));
+ SSL_ERROR_CHECK_GOTO_ERROR(!cert_list_size);
+
+ SSL_ERROR_CHECK_GOTO_ERROR(gnutls_x509_crt_init(&cert));
+ SSL_ERROR_CHECK_GOTO_ERROR(gnutls_x509_crt_import(cert, &cert_list[0], GNUTLS_X509_FMT_DER));
+
+ SSL_ERROR_CHECK_GOTO_ERROR(!gnutls_x509_crt_check_hostname(cert, cl->host_server->name));
+ gnutls_x509_crt_deinit(cert);
+ DBG("SSL certificate verification succeeded!");
return ECORE_CON_SSL_ERROR_NONE;
error:
_gnutls_print_errors(ret);
if ((ret == GNUTLS_E_WARNING_ALERT_RECEIVED) || (ret == GNUTLS_E_FATAL_ALERT_RECEIVED))
ERR("Also received alert: %s", gnutls_alert_get_name(gnutls_alert_get(cl->session)));
- ERR("last out: %s", SSL_GNUTLS_PRINT_HANDSHAKE_STATUS(gnutls_handshake_get_last_out(cl->session)));
- ERR("last in: %s", SSL_GNUTLS_PRINT_HANDSHAKE_STATUS(gnutls_handshake_get_last_in(cl->session)));
+ if (cl->session && (cl->ssl_state != ECORE_CON_SSL_STATE_DONE))
+ {
+ ERR("last out: %s", SSL_GNUTLS_PRINT_HANDSHAKE_STATUS(gnutls_handshake_get_last_out(cl->session)));
+ ERR("last in: %s", SSL_GNUTLS_PRINT_HANDSHAKE_STATUS(gnutls_handshake_get_last_in(cl->session)));
+ }
+ if (cert)
+ gnutls_x509_crt_deinit(cert);
_ecore_con_ssl_client_shutdown_gnutls(cl);
return ECORE_CON_SSL_ERROR_SERVER_INIT_FAILED;
}
return ECORE_CON_SSL_ERROR_NONE;
}
-
static int
-_ecore_con_ssl_client_read_gnutls(Ecore_Con_Client *cl, unsigned char *buf,
- int size)
+_ecore_con_ssl_client_read_gnutls(Ecore_Con_Client *cl,
+ unsigned char *buf,
+ int size)
{
int num;
num = gnutls_record_recv(cl->session, buf, size);
if (num > 0)
- return num;
+ return num;
if (num == GNUTLS_E_REHANDSHAKE)
{
cl->ssl_state = ECORE_CON_SSL_STATE_HANDSHAKING;
if (!_ecore_con_ssl_client_init_gnutls(cl))
return 0;
- WRN("Rehandshake request ignored");
- return 0;
+ WRN("Rehandshake request ignored");
+ return 0;
}
- else if ((num == GNUTLS_E_AGAIN) || (num == GNUTLS_E_INTERRUPTED))
- return 0;
+ else if (!gnutls_error_is_fatal(num))
+ return 0;
return -1;
}
static int
-_ecore_con_ssl_client_write_gnutls(Ecore_Con_Client *cl, unsigned char *buf,
- int size)
+_ecore_con_ssl_client_write_gnutls(Ecore_Con_Client *cl,
+ unsigned char *buf,
+ int size)
{
int num;
-
if (cl->ssl_state == ECORE_CON_SSL_STATE_HANDSHAKING)
{
if (!_ecore_con_ssl_client_init_gnutls(cl))
num = gnutls_record_send(cl->session, buf, size);
if (num > 0)
- return num;
+ return num;
if (num == GNUTLS_E_REHANDSHAKE)
{
if (!_ecore_con_ssl_client_init_gnutls(cl))
return 0;
}
- else if ((num == GNUTLS_E_AGAIN) || (num == GNUTLS_E_INTERRUPTED))
- return 0;
+ else if (!gnutls_error_is_fatal(num))
+ return 0;
return -1;
}
}
static Ecore_Con_Ssl_Error
-_ecore_con_ssl_server_prepare_openssl(Ecore_Con_Server *svr, int ssl_type)
+_ecore_con_ssl_server_prepare_openssl(Ecore_Con_Server *svr,
+ int ssl_type)
{
long options;
int dh = 0;
{
case ECORE_CON_USE_SSL3:
case ECORE_CON_USE_SSL3 | ECORE_CON_LOAD_CERT:
- if (!svr->created)
- SSL_ERROR_CHECK_GOTO_ERROR(!(svr->ssl_ctx = SSL_CTX_new(SSLv3_client_method())));
- else
- SSL_ERROR_CHECK_GOTO_ERROR(!(svr->ssl_ctx = SSL_CTX_new(SSLv3_server_method())));
- break;
+ if (!svr->created)
+ SSL_ERROR_CHECK_GOTO_ERROR(!(svr->ssl_ctx = SSL_CTX_new(SSLv3_client_method())));
+ else
+ SSL_ERROR_CHECK_GOTO_ERROR(!(svr->ssl_ctx = SSL_CTX_new(SSLv3_server_method())));
+ break;
case ECORE_CON_USE_TLS:
case ECORE_CON_USE_TLS | ECORE_CON_LOAD_CERT:
- if (!svr->created)
- SSL_ERROR_CHECK_GOTO_ERROR(!(svr->ssl_ctx = SSL_CTX_new(TLSv1_client_method())));
- else
- SSL_ERROR_CHECK_GOTO_ERROR(!(svr->ssl_ctx = SSL_CTX_new(TLSv1_server_method())));
- break;
+ if (!svr->created)
+ SSL_ERROR_CHECK_GOTO_ERROR(!(svr->ssl_ctx = SSL_CTX_new(TLSv1_client_method())));
+ else
+ SSL_ERROR_CHECK_GOTO_ERROR(!(svr->ssl_ctx = SSL_CTX_new(TLSv1_server_method())));
+ break;
case ECORE_CON_USE_MIXED:
case ECORE_CON_USE_MIXED | ECORE_CON_LOAD_CERT:
- if (!svr->created)
- SSL_ERROR_CHECK_GOTO_ERROR(!(svr->ssl_ctx = SSL_CTX_new(SSLv23_client_method())));
- else
- SSL_ERROR_CHECK_GOTO_ERROR(!(svr->ssl_ctx = SSL_CTX_new(SSLv23_server_method())));
- options = SSL_CTX_get_options(svr->ssl_ctx);
- SSL_CTX_set_options(svr->ssl_ctx, options | SSL_OP_NO_SSLv2 | SSL_OP_SINGLE_DH_USE);
- break;
+ if (!svr->created)
+ SSL_ERROR_CHECK_GOTO_ERROR(!(svr->ssl_ctx = SSL_CTX_new(SSLv23_client_method())));
+ else
+ SSL_ERROR_CHECK_GOTO_ERROR(!(svr->ssl_ctx = SSL_CTX_new(SSLv23_server_method())));
+ options = SSL_CTX_get_options(svr->ssl_ctx);
+ SSL_CTX_set_options(svr->ssl_ctx, options | SSL_OP_NO_SSLv2 | SSL_OP_SINGLE_DH_USE);
+ break;
default:
- break;
+ return ECORE_CON_SSL_ERROR_NONE;
}
if ((!svr->use_cert) && svr->created)
SSL_ERROR_CHECK_GOTO_ERROR(!DH_generate_key(dh_params));
SSL_ERROR_CHECK_GOTO_ERROR(!SSL_CTX_set_tmp_dh(svr->ssl_ctx, dh_params));
DH_free(dh_params);
+ INF("DH params successfully generated and applied!");
SSL_ERROR_CHECK_GOTO_ERROR(!SSL_CTX_set_cipher_list(svr->ssl_ctx, "aNULL:!eNULL:!LOW:!EXPORT:@STRENGTH"));
}
else if (!svr->use_cert)
SSL_ERROR_CHECK_GOTO_ERROR(!SSL_CTX_set_cipher_list(svr->ssl_ctx, "aNULL:!eNULL:!LOW:!EXPORT:!ECDH:RSA:AES:!PSK:@STRENGTH"));
- SSL_CTX_set_verify(svr->ssl_ctx, SSL_VERIFY_PEER, NULL);
-
return ECORE_CON_SSL_ERROR_NONE;
error:
return ECORE_CON_SSL_ERROR_SERVER_INIT_FAILED;
}
-
-
-
static Ecore_Con_Ssl_Error
_ecore_con_ssl_server_init_openssl(Ecore_Con_Server *svr)
{
{
case ECORE_CON_SSL_STATE_DONE:
return ECORE_CON_SSL_ERROR_NONE;
+
case ECORE_CON_SSL_STATE_INIT:
SSL_ERROR_CHECK_GOTO_ERROR(!(svr->ssl = SSL_new(svr->ssl_ctx)));
SSL_ERROR_CHECK_GOTO_ERROR(!SSL_set_fd(svr->ssl, svr->fd));
SSL_set_connect_state(svr->ssl);
svr->ssl_state = ECORE_CON_SSL_STATE_HANDSHAKING;
- case ECORE_CON_SSL_STATE_HANDSHAKING:
+
+ case ECORE_CON_SSL_STATE_HANDSHAKING:
+ if (!svr->ssl)
+ {
+ DBG("Server was previously lost, going to error condition");
+ goto error;
+ }
ret = SSL_do_handshake(svr->ssl);
svr->ssl_err = SSL_get_error(svr->ssl, ret);
SSL_ERROR_CHECK_GOTO_ERROR((svr->ssl_err == SSL_ERROR_SYSCALL) || (svr->ssl_err == SSL_ERROR_SSL));
ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_WRITE);
return ECORE_CON_SSL_ERROR_NONE;
}
+
default:
break;
}
{
/* print session info into DBG */
- SSL_SESSION *s;
- BIO *b;
- char log[4096];
-
-
- memset(log, 0, sizeof(log));
- s = SSL_get_session(svr->ssl);
- b = BIO_new(BIO_s_mem());
- SSL_SESSION_print(b, s);
- while (BIO_read(b, log, sizeof(log)) > 0)
- DBG("%s", log);
-
- BIO_free(b);
+ SSL_SESSION *s;
+ BIO *b;
+ char log[4096];
+
+ memset(log, 0, sizeof(log));
+ s = SSL_get_session(svr->ssl);
+ b = BIO_new(BIO_s_mem());
+ SSL_SESSION_print(b, s);
+ while (BIO_read(b, log, sizeof(log)) > 0)
+ DBG("%s", log);
+
+ BIO_free(b);
}
if (!svr->verify)
/* not verifying certificates, so we're done! */
return ECORE_CON_SSL_ERROR_NONE;
+ SSL_set_verify(svr->ssl, SSL_VERIFY_PEER, NULL);
/* use CRL/CA lists to verify */
if (SSL_get_peer_certificate(svr->ssl))
SSL_ERROR_CHECK_GOTO_ERROR(SSL_get_verify_result(svr->ssl));
}
static Eina_Bool
-_ecore_con_ssl_server_cafile_add_openssl(Ecore_Con_Server *svr, const char *ca_file)
+_ecore_con_ssl_server_cafile_add_openssl(Ecore_Con_Server *svr,
+ const char *ca_file)
{
SSL_ERROR_CHECK_GOTO_ERROR(!SSL_CTX_load_verify_locations(svr->ssl_ctx, ca_file, NULL));
return EINA_TRUE;
}
static Eina_Bool
-_ecore_con_ssl_server_crl_add_openssl(Ecore_Con_Server *svr, const char *crl_file)
+_ecore_con_ssl_server_crl_add_openssl(Ecore_Con_Server *svr,
+ const char *crl_file)
{
X509_STORE *st;
X509_LOOKUP *lu;
}
static Eina_Bool
-_ecore_con_ssl_server_privkey_add_openssl(Ecore_Con_Server *svr, const char *key_file)
+_ecore_con_ssl_server_privkey_add_openssl(Ecore_Con_Server *svr,
+ const char *key_file)
{
FILE *fp = NULL;
EVP_PKEY *privkey = NULL;
if (!(fp = fopen(key_file, "r")))
- goto error;
+ goto error;
SSL_ERROR_CHECK_GOTO_ERROR(!(privkey = PEM_read_PrivateKey(fp, NULL, NULL, NULL)));
error:
if (fp)
- fclose(fp);
+ fclose(fp);
_openssl_print_errors();
return EINA_FALSE;
}
-
static Eina_Bool
-_ecore_con_ssl_server_cert_add_openssl(Ecore_Con_Server *svr, const char *cert_file)
+_ecore_con_ssl_server_cert_add_openssl(Ecore_Con_Server *svr,
+ const char *cert_file)
{
FILE *fp = NULL;
X509 *cert = NULL;
if (!(fp = fopen(cert_file, "r")))
- goto error;
+ goto error;
SSL_ERROR_CHECK_GOTO_ERROR(!(cert = PEM_read_X509(fp, NULL, NULL, NULL)));
error:
if (fp)
- fclose(fp);
+ fclose(fp);
_openssl_print_errors();
return EINA_FALSE;
}
if (svr->ssl)
{
if (!SSL_shutdown(svr->ssl))
- SSL_shutdown(svr->ssl);
+ SSL_shutdown(svr->ssl);
SSL_free(svr->ssl);
}
if (svr->ssl_ctx)
- SSL_CTX_free(svr->ssl_ctx);
+ SSL_CTX_free(svr->ssl_ctx);
svr->ssl = NULL;
svr->ssl_ctx = NULL;
}
static int
-_ecore_con_ssl_server_read_openssl(Ecore_Con_Server *svr, unsigned char *buf,
- int size)
+_ecore_con_ssl_server_read_openssl(Ecore_Con_Server *svr,
+ unsigned char *buf,
+ int size)
{
int num;
if (svr->fd_handler)
{
if (svr->ssl && svr->ssl_err == SSL_ERROR_WANT_READ)
- ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_READ);
+ ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_READ);
else if (svr->ssl && svr->ssl_err == SSL_ERROR_WANT_WRITE)
- ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_WRITE);
+ ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_WRITE);
}
if ((svr->ssl_err == SSL_ERROR_ZERO_RETURN) ||
(svr->ssl_err == SSL_ERROR_SYSCALL) ||
(svr->ssl_err == SSL_ERROR_SSL))
- return -1;
+ return -1;
if (num < 0)
- return 0;
+ return 0;
return num;
}
static int
-_ecore_con_ssl_server_write_openssl(Ecore_Con_Server *svr, unsigned char *buf,
- int size)
+_ecore_con_ssl_server_write_openssl(Ecore_Con_Server *svr,
+ unsigned char *buf,
+ int size)
{
int num;
if (svr->fd_handler)
{
if (svr->ssl && svr->ssl_err == SSL_ERROR_WANT_READ)
- ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_READ);
+ ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_READ);
else if (svr->ssl && svr->ssl_err == SSL_ERROR_WANT_WRITE)
- ecore_main_fd_handler_active_set( svr->fd_handler, ECORE_FD_WRITE);
+ ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_WRITE);
}
if ((svr->ssl_err == SSL_ERROR_ZERO_RETURN) ||
(svr->ssl_err == SSL_ERROR_SYSCALL) ||
(svr->ssl_err == SSL_ERROR_SSL))
- return -1;
+ return -1;
if (num < 0)
- return 0;
+ return 0;
return num;
}
{
case ECORE_CON_SSL_STATE_DONE:
return ECORE_CON_SSL_ERROR_NONE;
+
case ECORE_CON_SSL_STATE_INIT:
SSL_ERROR_CHECK_GOTO_ERROR(!(cl->ssl = SSL_new(cl->host_server->ssl_ctx)));
SSL_ERROR_CHECK_GOTO_ERROR(!SSL_set_fd(cl->ssl, cl->fd));
SSL_set_accept_state(cl->ssl);
cl->ssl_state = ECORE_CON_SSL_STATE_HANDSHAKING;
+
case ECORE_CON_SSL_STATE_HANDSHAKING:
+ if (!cl->ssl)
+ {
+ DBG("Client was previously lost, going to error condition");
+ goto error;
+ }
ret = SSL_do_handshake(cl->ssl);
cl->ssl_err = SSL_get_error(cl->ssl, ret);
SSL_ERROR_CHECK_GOTO_ERROR((cl->ssl_err == SSL_ERROR_SYSCALL) || (cl->ssl_err == SSL_ERROR_SSL));
else
{
if (cl->ssl_err == SSL_ERROR_WANT_READ)
- ecore_main_fd_handler_active_set(cl->fd_handler, ECORE_FD_READ);
+ ecore_main_fd_handler_active_set(cl->fd_handler, ECORE_FD_READ);
else if (cl->ssl_err == SSL_ERROR_WANT_WRITE)
- ecore_main_fd_handler_active_set(cl->fd_handler, ECORE_FD_WRITE);
+ ecore_main_fd_handler_active_set(cl->fd_handler, ECORE_FD_WRITE);
return ECORE_CON_SSL_ERROR_NONE;
}
+
default:
break;
}
{
/* print session info into DBG */
- SSL_SESSION *s;
- BIO *b;
- char log[4096];
-
-
- memset(log, 0, sizeof(log));
- s = SSL_get_session(cl->ssl);
- b = BIO_new(BIO_s_mem());
- SSL_SESSION_print(b, s);
- while (BIO_read(b, log, sizeof(log)) > 0)
- DBG("%s", log);
-
- BIO_free(b);
+ SSL_SESSION *s;
+ BIO *b;
+ char log[4096];
+
+ memset(log, 0, sizeof(log));
+ s = SSL_get_session(cl->ssl);
+ b = BIO_new(BIO_s_mem());
+ SSL_SESSION_print(b, s);
+ while (BIO_read(b, log, sizeof(log)) > 0)
+ DBG("%s", log);
+
+ BIO_free(b);
}
-
if (!cl->host_server->verify)
/* not verifying certificates, so we're done! */
return ECORE_CON_SSL_ERROR_NONE;
-
+ SSL_set_verify(cl->ssl, SSL_VERIFY_PEER, NULL);
/* use CRL/CA lists to verify */
if (SSL_get_peer_certificate(cl->ssl))
SSL_ERROR_CHECK_GOTO_ERROR(SSL_get_verify_result(cl->ssl));
return ECORE_CON_SSL_ERROR_SERVER_INIT_FAILED;
}
-
static Ecore_Con_Ssl_Error
_ecore_con_ssl_client_shutdown_openssl(Ecore_Con_Client *cl)
{
if (cl->ssl)
{
if (!SSL_shutdown(cl->ssl))
- SSL_shutdown(cl->ssl);
+ SSL_shutdown(cl->ssl);
SSL_free(cl->ssl);
}
}
static int
-_ecore_con_ssl_client_read_openssl(Ecore_Con_Client *cl, unsigned char *buf,
- int size)
+_ecore_con_ssl_client_read_openssl(Ecore_Con_Client *cl,
+ unsigned char *buf,
+ int size)
{
int num;
if (cl->fd_handler)
{
if (cl->ssl && cl->ssl_err == SSL_ERROR_WANT_READ)
- ecore_main_fd_handler_active_set(cl->fd_handler, ECORE_FD_READ);
+ ecore_main_fd_handler_active_set(cl->fd_handler, ECORE_FD_READ);
else if (cl->ssl && cl->ssl_err == SSL_ERROR_WANT_WRITE)
- ecore_main_fd_handler_active_set( cl->fd_handler, ECORE_FD_WRITE);
+ ecore_main_fd_handler_active_set(cl->fd_handler, ECORE_FD_WRITE);
}
if ((cl->ssl_err == SSL_ERROR_ZERO_RETURN) ||
(cl->ssl_err == SSL_ERROR_SYSCALL) ||
(cl->ssl_err == SSL_ERROR_SSL))
- return -1;
+ return -1;
if (num < 0)
- return 0;
+ return 0;
return num;
}
static int
-_ecore_con_ssl_client_write_openssl(Ecore_Con_Client *cl, unsigned char *buf,
- int size)
+_ecore_con_ssl_client_write_openssl(Ecore_Con_Client *cl,
+ unsigned char *buf,
+ int size)
{
int num;
if (cl->fd_handler)
{
if (cl->ssl && cl->ssl_err == SSL_ERROR_WANT_READ)
- ecore_main_fd_handler_active_set(cl->fd_handler, ECORE_FD_READ);
+ ecore_main_fd_handler_active_set(cl->fd_handler, ECORE_FD_READ);
else if (cl->ssl && cl->ssl_err == SSL_ERROR_WANT_WRITE)
- ecore_main_fd_handler_active_set( cl->fd_handler, ECORE_FD_WRITE);
+ ecore_main_fd_handler_active_set(cl->fd_handler, ECORE_FD_WRITE);
}
if ((cl->ssl_err == SSL_ERROR_ZERO_RETURN) ||
(cl->ssl_err == SSL_ERROR_SYSCALL) ||
(cl->ssl_err == SSL_ERROR_SSL))
- return -1;
+ return -1;
if (num < 0)
- return 0;
+ return 0;
return num;
}
}
static Ecore_Con_Ssl_Error
-_ecore_con_ssl_server_prepare_none(Ecore_Con_Server *svr __UNUSED__, int ssl_type __UNUSED__)
+_ecore_con_ssl_server_prepare_none(Ecore_Con_Server *svr __UNUSED__,
+ int ssl_type __UNUSED__)
{
return ECORE_CON_SSL_ERROR_NONE;
}
}
static Eina_Bool
-_ecore_con_ssl_server_cafile_add_none(Ecore_Con_Server *svr __UNUSED__, const char *ca_file __UNUSED__)
+_ecore_con_ssl_server_cafile_add_none(Ecore_Con_Server *svr __UNUSED__,
+ const char *ca_file __UNUSED__)
{
return EINA_FALSE;
}
static Eina_Bool
-_ecore_con_ssl_server_cert_add_none(Ecore_Con_Server *svr __UNUSED__, const char *cert_file __UNUSED__)
+_ecore_con_ssl_server_cert_add_none(Ecore_Con_Server *svr __UNUSED__,
+ const char *cert_file __UNUSED__)
{
return EINA_FALSE;
}
static Eina_Bool
-_ecore_con_ssl_server_privkey_add_none(Ecore_Con_Server *svr __UNUSED__, const char *key_file __UNUSED__)
+_ecore_con_ssl_server_privkey_add_none(Ecore_Con_Server *svr __UNUSED__,
+ const char *key_file __UNUSED__)
{
return EINA_FALSE;
}
static Eina_Bool
-_ecore_con_ssl_server_crl_add_none(Ecore_Con_Server *svr __UNUSED__, const char *crl_file __UNUSED__)
+_ecore_con_ssl_server_crl_add_none(Ecore_Con_Server *svr __UNUSED__,
+ const char *crl_file __UNUSED__)
{
return EINA_FALSE;
}
}
static int
-_ecore_con_ssl_server_read_none(Ecore_Con_Server *svr __UNUSED__, unsigned char *buf __UNUSED__,
- int size __UNUSED__)
+_ecore_con_ssl_server_read_none(Ecore_Con_Server *svr __UNUSED__,
+ unsigned char *buf __UNUSED__,
+ int size __UNUSED__)
{
return -1;
}
static int
-_ecore_con_ssl_server_write_none(Ecore_Con_Server *svr __UNUSED__, unsigned char *buf __UNUSED__,
- int size __UNUSED__)
+_ecore_con_ssl_server_write_none(Ecore_Con_Server *svr __UNUSED__,
+ unsigned char *buf __UNUSED__,
+ int size __UNUSED__)
{
return -1;
}
}
static int
-_ecore_con_ssl_client_read_none(Ecore_Con_Client *cl __UNUSED__, unsigned char *buf __UNUSED__,
- int size __UNUSED__)
+_ecore_con_ssl_client_read_none(Ecore_Con_Client *cl __UNUSED__,
+ unsigned char *buf __UNUSED__,
+ int size __UNUSED__)
{
return -1;
}
static int
-_ecore_con_ssl_client_write_none(Ecore_Con_Client *cl __UNUSED__, unsigned char *buf __UNUSED__,
- int size __UNUSED__)
+_ecore_con_ssl_client_write_none(Ecore_Con_Client *cl __UNUSED__,
+ unsigned char *buf __UNUSED__,
+ int size __UNUSED__)
{
return -1;
}
int ECORE_CON_EVENT_URL_PROGRESS = 0;
#ifdef HAVE_CURL
-static Eina_Bool _ecore_con_url_fd_handler(void *data,
+static Eina_Bool _ecore_con_url_fd_handler(void *data,
Ecore_Fd_Handler *fd_handler);
static Eina_Bool _ecore_con_url_perform(Ecore_Con_Url *url_con);
-static size_t _ecore_con_url_header_cb(void *ptr, size_t size, size_t nitems,
- void *stream);
-static size_t _ecore_con_url_data_cb(void *buffer,
- size_t size,
- size_t nitems,
- void *userp);
-static int _ecore_con_url_progress_cb(void *clientp, double dltotal,
- double dlnow, double ultotal,
- double ulnow);
-static size_t _ecore_con_url_read_cb(void *ptr, size_t size, size_t nitems,
- void *stream);
-static void _ecore_con_event_url_free(void *data __UNUSED__, void *ev);
+static size_t _ecore_con_url_header_cb(void *ptr,
+ size_t size,
+ size_t nitems,
+ void *stream);
+static size_t _ecore_con_url_data_cb(void *buffer,
+ size_t size,
+ size_t nitems,
+ void *userp);
+static int _ecore_con_url_progress_cb(void *clientp,
+ double dltotal,
+ double dlnow,
+ double ultotal,
+ double ulnow);
+static size_t _ecore_con_url_read_cb(void *ptr,
+ size_t size,
+ size_t nitems,
+ void *stream);
+static void _ecore_con_event_url_free(void *data __UNUSED__,
+ void *ev);
static int _ecore_con_url_process_completed_jobs(
- Ecore_Con_Url *url_con_to_match);
+ Ecore_Con_Url *url_con_to_match);
static Eina_Bool _ecore_con_url_idler_handler(void *data);
static Ecore_Idler *_fd_idler_handler = NULL;
typedef struct _Ecore_Con_Url_Event Ecore_Con_Url_Event;
struct _Ecore_Con_Url_Event
{
- int type;
+ int type;
void *ev;
};
}
static void
-_url_complete_push_event(int type, void *ev)
+_url_complete_push_event(int type,
+ void *ev)
{
Ecore_Con_Url_Event *lev;
_init_count++;
if (_init_count > 1)
- return _init_count;
+ return _init_count;
if (!ECORE_CON_EVENT_URL_DATA)
{
if (curl_global_init(CURL_GLOBAL_NOTHING))
{
while (_url_con_list)
- ecore_con_url_free(eina_list_data_get(_url_con_list));
+ ecore_con_url_free(eina_list_data_get(_url_con_list));
return 0;
}
if (!_curlm)
{
while (_url_con_list)
- ecore_con_url_free(eina_list_data_get(_url_con_list));
+ ecore_con_url_free(eina_list_data_get(_url_con_list));
_init_count--;
return 0;
curl_multi_timeout(_curlm, &ms);
if (ms <= 0)
- ms = 1000;
+ ms = 1000;
_curl_timeout =
- ecore_timer_add((double)ms / 1000, _ecore_con_url_idler_handler,
- (void *)0xACE);
+ ecore_timer_add((double)ms / 1000, _ecore_con_url_idler_handler,
+ (void *)0xACE);
ecore_timer_freeze(_curl_timeout);
}
{
#ifdef HAVE_CURL
if (!_init_count)
- return 0;
+ return 0;
_init_count--;
if (_init_count != 0)
- return _init_count;
+ return _init_count;
if (_fd_idler_handler)
- ecore_idler_del(_fd_idler_handler);
+ ecore_idler_del(_fd_idler_handler);
_fd_idler_handler = NULL;
if (_curl_timeout)
- ecore_timer_del(_curl_timeout);
+ ecore_timer_del(_curl_timeout);
_curl_timeout = NULL;
while (_url_con_list)
- ecore_con_url_free(eina_list_data_get(_url_con_list));
+ ecore_con_url_free(eina_list_data_get(_url_con_list));
if (_curlm)
{
CURLcode ret;
if (!_init_count)
- return NULL;
+ return NULL;
url_con = calloc(1, sizeof(Ecore_Con_Url));
if (!url_con)
- return NULL;
+ return NULL;
url_con->fd = -1;
url_con->write_fd = -1;
curl_easy_setopt(url_con->curl_easy, CURLOPT_PROGRESSFUNCTION,
_ecore_con_url_progress_cb);
curl_easy_setopt(url_con->curl_easy, CURLOPT_PROGRESSDATA, url_con);
- curl_easy_setopt(url_con->curl_easy, CURLOPT_NOPROGRESS, EINA_FALSE);
+ curl_easy_setopt(url_con->curl_easy, CURLOPT_NOPROGRESS, EINA_FALSE);
curl_easy_setopt(url_con->curl_easy, CURLOPT_HEADERFUNCTION,
_ecore_con_url_header_cb);
- curl_easy_setopt(url_con->curl_easy, CURLOPT_HEADERDATA, url_con);
+ curl_easy_setopt(url_con->curl_easy, CURLOPT_HEADERDATA, url_con);
/*
* FIXME: Check that these timeouts are sensible defaults
* FIXME: Provide a means to change these timeouts
*/
curl_easy_setopt(url_con->curl_easy, CURLOPT_CONNECTTIMEOUT, 30);
- curl_easy_setopt(url_con->curl_easy, CURLOPT_TIMEOUT, 300);
+ curl_easy_setopt(url_con->curl_easy, CURLOPT_TIMEOUT, 300);
curl_easy_setopt(url_con->curl_easy, CURLOPT_FOLLOWLOCATION, 1);
return url_con;
* @see ecore_con_url_url_set()
*/
EAPI Ecore_Con_Url *
-ecore_con_url_custom_new(const char *url, const char *custom_request)
+ecore_con_url_custom_new(const char *url,
+ const char *custom_request)
{
#ifdef HAVE_CURL
Ecore_Con_Url *url_con;
CURLcode ret;
if (!url)
- return NULL;
+ return NULL;
if (!custom_request)
- return NULL;
+ return NULL;
url_con = ecore_con_url_new(url);
if (!url_con)
- return NULL;
+ return NULL;
ret = curl_easy_setopt(url_con->curl_easy, CURLOPT_CUSTOMREQUEST, custom_request);
if (ret != CURLE_OK)
CURLMcode ret;
if (!url_con)
- return;
+ return;
if (!ECORE_MAGIC_CHECK(url_con, ECORE_MAGIC_CON_URL))
{
{
FD_CLR(url_con->fd, &_current_fd_set);
if (url_con->fd_handler)
- ecore_main_fd_handler_del(url_con->fd_handler);
+ ecore_main_fd_handler_del(url_con->fd_handler);
url_con->fd = -1;
url_con->fd_handler = NULL;
{
// FIXME: For an unknown reason, progress continue to arrive after destruction
// this prevent any further call to the callback.
- curl_easy_setopt(url_con->curl_easy, CURLOPT_PROGRESSFUNCTION, NULL);
+ curl_easy_setopt(url_con->curl_easy, CURLOPT_PROGRESSFUNCTION, NULL);
- if (url_con->active)
- {
- url_con->active = EINA_FALSE;
+ if (url_con->active)
+ {
+ url_con->active = EINA_FALSE;
- ret = curl_multi_remove_handle(_curlm, url_con->curl_easy);
- if (ret != CURLM_OK)
- ERR("curl_multi_remove_handle failed: %s",
- curl_multi_strerror(ret));
- }
+ ret = curl_multi_remove_handle(_curlm, url_con->curl_easy);
+ if (ret != CURLM_OK)
+ ERR("curl_multi_remove_handle failed: %s",
+ curl_multi_strerror(ret));
+ }
- curl_easy_cleanup(url_con->curl_easy);
+ curl_easy_cleanup(url_con->curl_easy);
}
_url_con_list = eina_list_remove(_url_con_list, url_con);
*
*/
EAPI Eina_Bool
-ecore_con_url_url_set(Ecore_Con_Url *url_con, const char *url)
+ecore_con_url_url_set(Ecore_Con_Url *url_con,
+ const char *url)
{
#ifdef HAVE_CURL
if (!ECORE_MAGIC_CHECK(url_con, ECORE_MAGIC_CON_URL))
}
if (url_con->active)
- return EINA_FALSE;
+ return EINA_FALSE;
if (url_con->url)
- free(url_con->url);
+ free(url_con->url);
url_con->url = NULL;
if (url)
- url_con->url = strdup(url);
+ url_con->url = strdup(url);
if (url_con->url)
- curl_easy_setopt(url_con->curl_easy, CURLOPT_URL,
- url_con->url);
+ curl_easy_setopt(url_con->curl_easy, CURLOPT_URL,
+ url_con->url);
else
- curl_easy_setopt(url_con->curl_easy, CURLOPT_URL, "");
+ curl_easy_setopt(url_con->curl_easy, CURLOPT_URL, "");
return EINA_TRUE;
#else
* @see ecore_con_url_data_get()
*/
EAPI void
-ecore_con_url_data_set(Ecore_Con_Url *url_con, void *data)
+ecore_con_url_data_set(Ecore_Con_Url *url_con,
+ void *data)
{
#ifdef HAVE_CURL
if (!ECORE_MAGIC_CHECK(url_con, ECORE_MAGIC_CON_URL))
* @see ecore_con_url_additional_headers_clear()
*/
EAPI void
-ecore_con_url_additional_header_add(Ecore_Con_Url *url_con, const char *key,
- const char *value)
+ecore_con_url_additional_header_add(Ecore_Con_Url *url_con,
+ const char *key,
+ const char *value)
{
#ifdef HAVE_CURL
char *tmp;
tmp = malloc(strlen(key) + strlen(value) + 3);
if (!tmp)
- return;
+ return;
sprintf(tmp, "%s: %s", key, value);
url_con->additional_headers = eina_list_append(url_con->additional_headers,
* @sa ecore_con_url_send()
*/
EAPI void
-ecore_con_url_time(Ecore_Con_Url *url_con, Ecore_Con_Url_Time condition,
- double timestamp)
+ecore_con_url_time(Ecore_Con_Url *url_con,
+ Ecore_Con_Url_Time condition,
+ double timestamp)
{
#ifdef HAVE_CURL
if (!ECORE_MAGIC_CHECK(url_con, ECORE_MAGIC_CON_URL))
*
*/
EAPI void
-ecore_con_url_fd_set(Ecore_Con_Url *url_con, int fd)
+ecore_con_url_fd_set(Ecore_Con_Url *url_con,
+ int fd)
{
#ifdef HAVE_CURL
if (!ECORE_MAGIC_CHECK(url_con, ECORE_MAGIC_CON_URL))
*
*/
EAPI Eina_Bool
-ecore_con_url_httpauth_set(Ecore_Con_Url *url_con, const char *username,
- const char *password, Eina_Bool safe)
+ecore_con_url_httpauth_set(Ecore_Con_Url *url_con,
+ const char *username,
+ const char *password,
+ Eina_Bool safe)
{
#ifdef HAVE_CURL
CURLcode ret;
if ((username) && (password))
{
if (safe)
- curl_easy_setopt(url_con->curl_easy, CURLOPT_HTTPAUTH,
- CURLAUTH_ANYSAFE);
+ curl_easy_setopt(url_con->curl_easy, CURLOPT_HTTPAUTH,
+ CURLAUTH_ANYSAFE);
else
- curl_easy_setopt(url_con->curl_easy, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
+ curl_easy_setopt(url_con->curl_easy, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
ret = curl_easy_setopt(url_con->curl_easy, CURLOPT_USERNAME, username);
if (ret != CURLE_OK)
* @see ecore_con_url_time()
*/
EAPI Eina_Bool
-ecore_con_url_send(Ecore_Con_Url *url_con, const void *data, long length,
- const char *content_type)
+ecore_con_url_send(Ecore_Con_Url *url_con,
+ const void *data,
+ long length,
+ const char *content_type)
{
#ifdef HAVE_CURL
Eina_List *l;
}
if (url_con->active)
- return EINA_FALSE;
+ return EINA_FALSE;
if (!url_con->url)
- return EINA_FALSE;
+ return EINA_FALSE;
/* Free response headers from previous send() calls */
EINA_LIST_FREE(url_con->response_headers, s)
url_con->headers = curl_slist_append(url_con->headers, tmp);
}
- curl_easy_setopt(url_con->curl_easy, CURLOPT_POSTFIELDS, data);
+ curl_easy_setopt(url_con->curl_easy, CURLOPT_POSTFIELDS, data);
curl_easy_setopt(url_con->curl_easy, CURLOPT_POSTFIELDSIZE, length);
}
switch (url_con->time_condition)
{
case ECORE_CON_URL_TIME_NONE:
- curl_easy_setopt(url_con->curl_easy, CURLOPT_TIMECONDITION,
- CURL_TIMECOND_NONE);
- break;
+ curl_easy_setopt(url_con->curl_easy, CURLOPT_TIMECONDITION,
+ CURL_TIMECOND_NONE);
+ break;
case ECORE_CON_URL_TIME_IFMODSINCE:
- curl_easy_setopt(url_con->curl_easy, CURLOPT_TIMECONDITION,
- CURL_TIMECOND_IFMODSINCE);
- curl_easy_setopt(url_con->curl_easy, CURLOPT_TIMEVALUE,
- (long)url_con->timestamp);
- break;
+ curl_easy_setopt(url_con->curl_easy, CURLOPT_TIMECONDITION,
+ CURL_TIMECOND_IFMODSINCE);
+ curl_easy_setopt(url_con->curl_easy, CURLOPT_TIMEVALUE,
+ (long)url_con->timestamp);
+ break;
case ECORE_CON_URL_TIME_IFUNMODSINCE:
- curl_easy_setopt(url_con->curl_easy, CURLOPT_TIMECONDITION,
- CURL_TIMECOND_IFUNMODSINCE);
- curl_easy_setopt(url_con->curl_easy, CURLOPT_TIMEVALUE,
- (long)url_con->timestamp);
- break;
+ curl_easy_setopt(url_con->curl_easy, CURLOPT_TIMECONDITION,
+ CURL_TIMECOND_IFUNMODSINCE);
+ curl_easy_setopt(url_con->curl_easy, CURLOPT_TIMEVALUE,
+ (long)url_con->timestamp);
+ break;
}
/* Additional headers */
* and @p pass to directory @p upload_dir
*/
EAPI Eina_Bool
-ecore_con_url_ftp_upload(Ecore_Con_Url *url_con, const char *filename,
- const char *user, const char *pass,
- const char *upload_dir)
+ecore_con_url_ftp_upload(Ecore_Con_Url *url_con,
+ const char *filename,
+ const char *user,
+ const char *pass,
+ const char *upload_dir)
{
#ifdef HAVE_CURL
char url[4096];
}
if (url_con->active)
- return EINA_FALSE;
+ return EINA_FALSE;
if (!url_con->url)
- return EINA_FALSE;
+ return EINA_FALSE;
if (filename)
{
if (stat(filename, &file_info))
- return EINA_FALSE;
+ return EINA_FALSE;
snprintf(userpwd, sizeof(userpwd), "%s:%s", user, pass);
ret = curl_easy_setopt(url_con->curl_easy, CURLOPT_USERPWD, userpwd);
snprintf(url, sizeof(url), "ftp://%s/%s/%s", url_con->url,
upload_dir, basename(tmp));
else
- snprintf(url, sizeof(url), "ftp://%s/%s", url_con->url,
+ snprintf(url, sizeof(url), "ftp://%s/%s", url_con->url,
basename(tmp));
if (!ecore_con_url_url_set(url_con, url))
curl_easy_setopt(url_con->curl_easy, CURLOPT_INFILESIZE_LARGE,
(curl_off_t)file_info.st_size);
- curl_easy_setopt(url_con->curl_easy, CURLOPT_UPLOAD, 1);
+ curl_easy_setopt(url_con->curl_easy, CURLOPT_UPLOAD, 1);
curl_easy_setopt(url_con->curl_easy, CURLOPT_READFUNCTION,
_ecore_con_url_read_cb);
* @param verbose Whether or not to enable libcurl's verbose output.
*/
EAPI void
-ecore_con_url_verbose_set(Ecore_Con_Url *url_con, Eina_Bool verbose)
+ecore_con_url_verbose_set(Ecore_Con_Url *url_con,
+ Eina_Bool verbose)
{
#ifdef HAVE_CURL
if (!ECORE_MAGIC_CHECK(url_con, ECORE_MAGIC_CON_URL))
}
if (url_con->active)
- return;
+ return;
if (!url_con->url)
- return;
+ return;
curl_easy_setopt(url_con->curl_easy, CURLOPT_VERBOSE, (int)verbose);
#else
* @return FIXME: To be more documented.
*/
EAPI void
-ecore_con_url_ftp_use_epsv_set(Ecore_Con_Url *url_con, Eina_Bool use_epsv)
+ecore_con_url_ftp_use_epsv_set(Ecore_Con_Url *url_con,
+ Eina_Bool use_epsv)
{
#ifdef HAVE_CURL
if (!ECORE_MAGIC_CHECK(url_con, ECORE_MAGIC_CON_URL))
}
if (url_con->active)
- return;
+ return;
if (!url_con->url)
- return;
+ return;
curl_easy_setopt(url_con->curl_easy, CURLOPT_FTP_USE_EPSV, (int)use_epsv);
#endif
int deleted = 0;
if (!_url_con_list)
- return 0;
+ return 0;
EINA_LIST_FOREACH(_url_con_list, l, url_con)
- {
- if (url_con->active && url_con->fd_handler)
- {
- ecore_main_fd_handler_del(url_con->fd_handler);
- url_con->fd_handler = NULL;
- deleted++;
- }
- }
+ {
+ if (url_con->active && url_con->fd_handler)
+ {
+ ecore_main_fd_handler_del(url_con->fd_handler);
+ url_con->fd_handler = NULL;
+ deleted++;
+ }
+ }
return deleted;
}
int activated = 0;
if (!_url_con_list)
- return 0;
+ return 0;
EINA_LIST_FOREACH(_url_con_list, l, url_con)
- {
- if (!url_con->fd_handler && url_con->fd != -1)
- {
- url_con->fd_handler =
- ecore_main_fd_handler_add(url_con->fd, url_con->flags,
- _ecore_con_url_fd_handler,
- NULL, NULL, NULL);
- activated++;
- }
- }
+ {
+ if (!url_con->fd_handler && url_con->fd != -1)
+ {
+ url_con->fd_handler =
+ ecore_main_fd_handler_add(url_con->fd, url_con->flags,
+ _ecore_con_url_fd_handler,
+ NULL, NULL, NULL);
+ activated++;
+ }
+ }
return activated;
}
static size_t
-_ecore_con_url_data_cb(void *buffer, size_t size, size_t nitems, void *userp)
+_ecore_con_url_data_cb(void *buffer,
+ size_t size,
+ size_t nitems,
+ void *userp)
{
Ecore_Con_Url *url_con;
Ecore_Con_Event_Url_Data *e;
url_con = (Ecore_Con_Url *)userp;
if (!url_con)
- return -1;
+ return -1;
if (!ECORE_MAGIC_CHECK(url_con, ECORE_MAGIC_CON_URL))
{
if (url_con->write_fd < 0)
{
e =
- malloc(sizeof(Ecore_Con_Event_Url_Data) + sizeof(unsigned char) *
- (real_size - 1));
+ malloc(sizeof(Ecore_Con_Event_Url_Data) + sizeof(unsigned char) *
+ (real_size - 1));
if (e)
{
e->url_con = url_con;
e->size = real_size;
memcpy(e->data, buffer, real_size);
- ecore_event_add(ECORE_CON_EVENT_URL_DATA, e,
+ ecore_event_add(ECORE_CON_EVENT_URL_DATA, e,
_ecore_con_event_url_free, NULL);
}
}
if (count < 0)
{
if (errno != EAGAIN && errno != EINTR)
- return -1;
+ return -1;
}
else
{
return real_size;
}
-#define ECORE_CON_URL_TRANSMISSION(Transmit, Event, Url_con, Total, Now) \
- { \
- Ecore_Con_Event_Url_Progress *e; \
- if ((Total != 0) || (Now != 0)) \
- { \
- e = calloc(1, sizeof(Ecore_Con_Event_Url_Progress)); \
- if (e) \
- { \
- e->url_con = url_con; \
- e->total = Total; \
- e->now = Now; \
- ecore_event_add(Event, e, _ecore_con_event_url_free, NULL); \
- } \
- } \
- }
+#define ECORE_CON_URL_TRANSMISSION(Transmit, Event, Url_con, Total, Now) \
+ { \
+ Ecore_Con_Event_Url_Progress *e; \
+ if ((Total != 0) || (Now != 0)) \
+ { \
+ e = calloc(1, sizeof(Ecore_Con_Event_Url_Progress)); \
+ if (e) \
+ { \
+ e->url_con = url_con; \
+ e->total = Total; \
+ e->now = Now; \
+ ecore_event_add(Event, e, _ecore_con_event_url_free, NULL); \
+ } \
+ } \
+ }
static size_t
-_ecore_con_url_header_cb(void *ptr, size_t size, size_t nitems, void *stream)
+_ecore_con_url_header_cb(void *ptr,
+ size_t size,
+ size_t nitems,
+ void *stream)
{
size_t real_size = size * nitems;
Ecore_Con_Url *url_con = stream;
char *header = malloc(sizeof(char) * (real_size + 1));
if (!header)
- return real_size;
+ return real_size;
memcpy(header, ptr, real_size);
header[real_size] = '\0';
}
static int
-_ecore_con_url_progress_cb(void *clientp, double dltotal, double dlnow,
+_ecore_con_url_progress_cb(void *clientp,
+ double dltotal,
+ double dlnow,
double ultotal,
double ulnow)
{
}
static size_t
-_ecore_con_url_read_cb(void *ptr, size_t size, size_t nitems, void *stream)
+_ecore_con_url_read_cb(void *ptr,
+ size_t size,
+ size_t nitems,
+ void *stream)
{
size_t retcode = fread(ptr, size, nitems, stream);
if (!completed_immediately)
{
if (url_con->fd_handler)
- ecore_main_fd_handler_del(url_con->fd_handler);
+ ecore_main_fd_handler_del(url_con->fd_handler);
url_con->fd_handler = NULL;
{
flags = 0;
if (FD_ISSET(fd, &read_set))
- flags |= ECORE_FD_READ;
+ flags |= ECORE_FD_READ;
if (FD_ISSET(fd, &write_set))
- flags |= ECORE_FD_WRITE;
+ flags |= ECORE_FD_WRITE;
if (FD_ISSET(fd, &exc_set))
- flags |= ECORE_FD_ERROR;
+ flags |= ECORE_FD_ERROR;
if (flags)
{
curl_multi_strerror(ret));
if (ms == 0)
- ms = 1000;
+ ms = 1000;
FD_SET(fd, &_current_fd_set);
url_con->fd = fd;
url_con->flags = flags;
url_con->fd_handler =
- ecore_main_fd_handler_add(fd, flags,
- _ecore_con_url_fd_handler,
- NULL, NULL, NULL);
+ ecore_main_fd_handler_add(fd, flags,
+ _ecore_con_url_fd_handler,
+ NULL, NULL, NULL);
break;
}
}
if (!url_con->fd_handler)
{
/* Failed to set up an fd_handler */
- ecore_timer_freeze(_curl_timeout);
+ ecore_timer_freeze(_curl_timeout);
- ret = curl_multi_remove_handle(_curlm, url_con->curl_easy);
- if (ret != CURLM_OK)
- ERR("curl_multi_remove_handle failed: %s",
- curl_multi_strerror(ret));
+ ret = curl_multi_remove_handle(_curlm, url_con->curl_easy);
+ if (ret != CURLM_OK)
+ ERR("curl_multi_remove_handle failed: %s",
+ curl_multi_strerror(ret));
- url_con->active = EINA_FALSE;
- url_con->fd = -1;
- return EINA_FALSE;
+ url_con->active = EINA_FALSE;
+ url_con->fd = -1;
+ return EINA_FALSE;
}
ecore_timer_thaw(_curl_timeout);
start = ecore_time_get();
while (curl_multi_perform(_curlm, &still_running) == CURLM_CALL_MULTI_PERFORM)
- /* make this not more than a frametime to keep interactivity high */
- if ((ecore_time_get() - start) > ecore_animator_frametime_get())
- {
- done = 0;
- break;
- }
+ /* make this not more than a frametime to keep interactivity high */
+ if ((ecore_time_get() - start) > ecore_animator_frametime_get())
+ {
+ done = 0;
+ break;
+ }
_ecore_con_url_process_completed_jobs(NULL);
_fd_idler_handler = NULL;
if (!_url_con_list)
- ecore_timer_freeze(_curl_timeout);
+ ecore_timer_freeze(_curl_timeout);
return data ==
(void *)0xACE ? ECORE_CALLBACK_RENEW : ECORE_CALLBACK_CANCEL;
}
static Eina_Bool
-_ecore_con_url_fd_handler(void *data __UNUSED__,
+_ecore_con_url_fd_handler(void *data __UNUSED__,
Ecore_Fd_Handler *fd_handler __UNUSED__)
{
_ecore_con_url_suspend_fd_handler();
if (!_fd_idler_handler)
- _fd_idler_handler = ecore_idler_add(
- _ecore_con_url_idler_handler, NULL);
+ _fd_idler_handler = ecore_idler_add(
+ _ecore_con_url_idler_handler, NULL);
return ECORE_CALLBACK_RENEW;
}
while ((curlmsg = curl_multi_info_read(_curlm, &n_remaining)))
{
if (curlmsg->msg != CURLMSG_DONE)
- continue;
+ continue;
/* find the job which is done */
EINA_LIST_FOREACH(_url_con_list, l, url_con)
- {
- if (curlmsg->easy_handle == url_con->curl_easy)
- {
- if (url_con_to_match &&
- (url_con == url_con_to_match))
- job_matched = 1;
-
- if(url_con->fd != -1)
- {
- FD_CLR(url_con->fd, &_current_fd_set);
- if (url_con->fd_handler)
- ecore_main_fd_handler_del(
+ {
+ if (curlmsg->easy_handle == url_con->curl_easy)
+ {
+ if (url_con_to_match &&
+ (url_con == url_con_to_match))
+ job_matched = 1;
+
+ if(url_con->fd != -1)
+ {
+ FD_CLR(url_con->fd, &_current_fd_set);
+ if (url_con->fd_handler)
+ ecore_main_fd_handler_del(
url_con->fd_handler);
- url_con->fd = -1;
- url_con->fd_handler = NULL;
- }
-
- _url_con_list = eina_list_remove(_url_con_list, url_con);
- url_con->active = EINA_FALSE;
- e = calloc(1, sizeof(Ecore_Con_Event_Url_Complete));
- if (e)
- {
- e->url_con = url_con;
- e->status = 0;
- if (curlmsg->data.result == CURLE_OK)
- {
- long status; /* curl API uses long, not int */
-
- status = 0;
- curl_easy_getinfo(curlmsg->easy_handle,
- CURLINFO_RESPONSE_CODE,
- &status);
- e->status = status;
- }
-
- _url_complete_push_event(ECORE_CON_EVENT_URL_COMPLETE, e);
- }
-
- ret = curl_multi_remove_handle(_curlm, url_con->curl_easy);
- if (ret != CURLM_OK)
- ERR("curl_multi_remove_handle failed: %s",
- curl_multi_strerror(ret));
-
- break;
- }
- }
+ url_con->fd = -1;
+ url_con->fd_handler = NULL;
+ }
+
+ _url_con_list = eina_list_remove(_url_con_list, url_con);
+ url_con->active = EINA_FALSE;
+ e = calloc(1, sizeof(Ecore_Con_Event_Url_Complete));
+ if (e)
+ {
+ e->url_con = url_con;
+ e->status = 0;
+ if (curlmsg->data.result == CURLE_OK)
+ {
+ long status; /* curl API uses long, not int */
+
+ status = 0;
+ curl_easy_getinfo(curlmsg->easy_handle,
+ CURLINFO_RESPONSE_CODE,
+ &status);
+ e->status = status;
+ }
+
+ _url_complete_push_event(ECORE_CON_EVENT_URL_COMPLETE, e);
+ }
+
+ ret = curl_multi_remove_handle(_curlm, url_con->curl_easy);
+ if (ret != CURLM_OK)
+ ERR("curl_multi_remove_handle failed: %s",
+ curl_multi_strerror(ret));
+
+ break;
+ }
+ }
}
return job_matched;
}
static void
-_ecore_con_event_url_free(void *data __UNUSED__, void *ev)
+_ecore_con_event_url_free(void *data __UNUSED__,
+ void *ev)
{
free(ev);
}
CLEANFILES = $(DB)
-if BUILD_ECORE_CONFIG
-
#DB = system.db
#$(DB): Makefile
# edb_ed $(top_builddir)/src/lib/ecore_config/$(DB) add /e/theme/name str "winter"
endif
-endif
-
EXTRA_DIST = \
ecore_config_ipc.h \
ecore_config_private.h \
-I$(top_builddir)/src/lib/ecore \
@DIRECTFB_CFLAGS@ @EINA_CFLAGS@
-if BUILD_ECORE_DIRECTFB
-
lib_LTLIBRARIES = libecore_directfb.la
includes_HEADERS = Ecore_DirectFB.h
includesdir = $(includedir)/ecore-@VMAJ@
libecore_directfb_la_DEPENDENCIES = \
$(top_builddir)/src/lib/ecore/libecore.la
-endif
-
EXTRA_DIST = \
Ecore_DirectFB.h \
ecore_directfb.c \
EAPI const void *ecore_evas_buffer_pixels_get(Ecore_Evas *ee);
EAPI Evas_Object *ecore_evas_object_image_new(Ecore_Evas *ee_target);
+EAPI Ecore_Evas *ecore_evas_object_ecore_evas_get(Evas_Object *obj);
+EAPI Evas *ecore_evas_object_evas_get(Evas_Object *obj);
EAPI Ecore_Evas *ecore_evas_software_gdi_new(Ecore_Win32_Window *parent,
int x,
AM_CFLAGS = @WIN32_CFLAGS@
-if BUILD_ECORE_EVAS
-
lib_LTLIBRARIES = libecore_evas.la
includes_HEADERS = Ecore_Evas.h
includesdir = $(includedir)/ecore-@VMAJ@
libecore_evas_la_LDFLAGS = @cocoa_ldflags@ -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@
-endif
-
EXTRA_DIST = \
ecore_evas_private.h
#endif
/* Last chance to have a window */
+#ifdef BUILD_ECORE_EVAS_OPENGL_SDL
+ {"opengl_sdl", _ecore_evas_constructor_opengl_sdl},
+#endif
+
#ifdef BUILD_ECORE_EVAS_SOFTWARE_SDL
{"sdl", _ecore_evas_constructor_sdl},
{"software_16_sdl", _ecore_evas_constructor_sdl16},
#endif
-#ifdef BUILD_ECORE_EVAS_OPENGL_SDL
- {"opengl_sdl", _ecore_evas_constructor_opengl_sdl},
-#endif
-
/* independent */
#ifdef BUILD_ECORE_EVAS_SOFTWARE_BUFFER
{"buffer", _ecore_evas_constructor_buffer},
rlapse = tim;
flapse = frames;
}
- else if ((tim - rlapse) >= 0.1)
+ else if ((tim - rlapse) >= 0.5)
{
- printf("%.6f \t", tim);
printf("FRAME: %i, FPS: %3.1f, RTIME %3.0f%%\n",
frames,
(frames - flapse) / (tim - rlapse),
(100.0 * rtime) / (tim - rlapse)
);
- fflush(stdout);
rlapse = tim;
flapse = frames;
rtime = 0.0;
#endif
}
+EAPI Evas *
+ecore_evas_object_evas_get(Evas_Object *obj)
+{
+ Ecore_Evas *ee;
+
+ ee = evas_object_data_get(obj, "Ecore_Evas");
+ if (!ee) return NULL;
+
+ return ecore_evas_get(ee);
+}
+
+EAPI Ecore_Evas *
+ecore_evas_object_ecore_evas_get(Evas_Object *obj)
+{
+ return evas_object_data_get(obj, "Ecore_Evas");
+}
+
EAPI Evas_Object *
ecore_evas_object_image_new(Ecore_Evas *ee_target)
{
if (!ee) return NULL;
o = evas_object_image_add(ee_target->evas);
-
+ evas_object_image_content_hint_set(o, EVAS_IMAGE_CONTENT_HINT_DYNAMIC);
+ evas_object_image_colorspace_set(o, EVAS_COLORSPACE_ARGB8888);
+
ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
_ecore_evas_buffer_init();
{
Ecore_Evas *ee;
Ecore_Fb_Event_Mouse_Wheel *e;
+ unsigned long long event_time;
e = event;
ee = _ecore_evas_fb_match();
if (!ee) return EINA_TRUE; /* pass on event */
- _ecore_evas_mouse_move_process_fb(ee, e->x, e->y, (unsigned int)((unsigned long long)(ecore_time_get() * 1000.0) & 0xffffffff));
+ event_time = (unsigned int)((unsigned long long)(ecore_time_get() * 1000.0) & 0xffffffff);
+ _ecore_evas_mouse_move_process_fb(ee, e->x, e->y, event_time);
+ evas_event_feed_mouse_wheel(ee->evas, e->direction, e->wheel, event_time, NULL);
return EINA_FALSE; /* dont pass it on */
}
}
}
-/* added by gl77.lee 101001 - for EFL rotation effect */
#define _USE_WIN_ROT_EFFECT 1
#if _USE_WIN_ROT_EFFECT
}
#endif /* end of _USE_WIN_ROT_EFFECT */
-
-
static void
_ecore_evas_x_rotation_set(Ecore_Evas *ee, int rotation, int resize)
{
if (ee->rotation == rotation) return;
if (!strcmp(ee->driver, "xrender_x11")) return;
- #if _USE_WIN_ROT_EFFECT
+#if _USE_WIN_ROT_EFFECT
int angles[2];
angles[0] = rotation;
angles[1] = ee->rotation;
- #endif /* end of _USE_WIN_ROT_EFFECT */
-
+#endif /* end of _USE_WIN_ROT_EFFECT */
+
if (!strcmp(ee->driver, "opengl_x11"))
{
#ifdef BUILD_ECORE_EVAS_OPENGL_X11
einfo->info.rotation = rotation;
_ecore_evas_x_rotation_set_internal
(ee, rotation, resize, (Evas_Engine_Info *)einfo);
-
- /* added by doyoun.kang 100218 - for rotation */
- #if _USE_WIN_ROT_EFFECT
- ecore_x_window_prop_property_set (ee->prop.window,
- ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
- ECORE_X_ATOM_CARDINAL, 32, &angles, 2);
- #else
- ecore_x_window_prop_property_set (ee->prop.window,
- ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
- ECORE_X_ATOM_CARDINAL, 32, &rotation, 1);
- #endif
-
+# if _USE_WIN_ROT_EFFECT
+ ecore_x_window_prop_property_set (ee->prop.window,
+ ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
+ ECORE_X_ATOM_CARDINAL, 32, &angles, 2);
+# else
+ ecore_x_window_prop_property_set (ee->prop.window,
+ ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
+ ECORE_X_ATOM_CARDINAL, 32, &rotation, 1);
+# endif
#endif /* BUILD_ECORE_EVAS_OPENGL_X11 */
}
else if (!strcmp(ee->driver, "software_x11"))
einfo->info.rotation = rotation;
_ecore_evas_x_rotation_set_internal
(ee, rotation, resize, (Evas_Engine_Info *)einfo);
-
- /* added by doyoun.kang 100218 - for rotation */
- #if _USE_WIN_ROT_EFFECT
- ecore_x_window_prop_property_set (ee->prop.window,
- ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
- ECORE_X_ATOM_CARDINAL, 32, &angles, 2);
- #else
- ecore_x_window_prop_property_set (ee->prop.window,
- ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
- ECORE_X_ATOM_CARDINAL, 32, &rotation, 1);
- #endif
-
+# if _USE_WIN_ROT_EFFECT
+ ecore_x_window_prop_property_set (ee->prop.window,
+ ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
+ ECORE_X_ATOM_CARDINAL, 32, &angles, 2);
+# else
+ ecore_x_window_prop_property_set (ee->prop.window,
+ ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
+ ECORE_X_ATOM_CARDINAL, 32, &rotation, 1);
+# endif
#endif /* BUILD_ECORE_EVAS_SOFTWARE_X11 */
}
else if (!strcmp(ee->driver, "software_16_x11"))
einfo->info.rotation = rotation;
_ecore_evas_x_rotation_set_internal
(ee, rotation, resize, (Evas_Engine_Info *)einfo);
-
- /* added by doyoun.kang 100218 - for rotation */
- #if _USE_WIN_ROT_EFFECT
- ecore_x_window_prop_property_set (ee->prop.window,
- ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
- ECORE_X_ATOM_CARDINAL, 32, &angles, 2);
- #else
- ecore_x_window_prop_property_set (ee->prop.window,
- ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
- ECORE_X_ATOM_CARDINAL, 32, &rotation, 1);
- #endif
-
+# if _USE_WIN_ROT_EFFECT
+ ecore_x_window_prop_property_set (ee->prop.window,
+ ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
+ ECORE_X_ATOM_CARDINAL, 32, &angles, 2);
+# else
+ ecore_x_window_prop_property_set (ee->prop.window,
+ ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
+ ECORE_X_ATOM_CARDINAL, 32, &rotation, 1);
+# endif
#endif /* BUILD_ECORE_EVAS_SOFTWARE_16_X11 */
}
else if (!strcmp(ee->driver, "software_8_x11"))
einfo->info.rotation = rotation;
_ecore_evas_x_rotation_set_internal
(ee, rotation, resize, (Evas_Engine_Info *)einfo);
+# if _USE_WIN_ROT_EFFECT
+ ecore_x_window_prop_property_set (ee->prop.window,
+ ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
+ ECORE_X_ATOM_CARDINAL, 32, &angles, 2);
+# else
+ ecore_x_window_prop_property_set (ee->prop.window,
+ ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE,
+ ECORE_X_ATOM_CARDINAL, 32, &rotation, 1);
+# endif
#endif /* BUILD_ECORE_EVAS_SOFTWARE_8_X11 */
}
- #if _USE_WIN_ROT_EFFECT
- _ecore_evas_x_rotation_effect_setup();
- _ecore_evas_x_flush_pre(ee, NULL, NULL);
- #endif /* end of _USE_WIN_ROT_EFFECT */
+#if _USE_WIN_ROT_EFFECT
+ _ecore_evas_x_rotation_effect_setup();
+ _ecore_evas_x_flush_pre(ee, NULL, NULL);
+#endif /* end of _USE_WIN_ROT_EFFECT */
}
static void
@TSLIB_CFLAGS@ \
@EINA_CFLAGS@
-if BUILD_ECORE_FB
lib_LTLIBRARIES = libecore_fb.la
includes_HEADERS = Ecore_Fb.h
libecore_fb_la_LDFLAGS = -version-info @version_info@ @release_info@
-endif
-
EXTRA_DIST = \
ecore_fb_private.h \
ecore_fb_keytable.h
lib_ecore_con_la = $(top_builddir)/src/lib/ecore_con/libecore_con.la
endif
-if BUILD_ECORE_FILE
-
lib_LTLIBRARIES = libecore_file.la
includes_HEADERS = Ecore_File.h
includesdir = $(includedir)/ecore-@VMAJ@
libecore_file_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@
-endif
-
EXTRA_DIST = ecore_file_private.h
{
struct stat st;
+ /* Windows: path like C: or D: etc are valid, but stat() returns an error */
+#ifdef _WIN32
+ if ((strlen(path) == 2) &&
+ ((path[0] >= 'a' && path[0] <= 'z') ||
+ (path[0] >= 'A' && path[0] <= 'Z')) &&
+ (path[1] == ':'))
+ return EINA_TRUE;
+#endif
+
if (stat(path, &st) < 0)
return ecore_file_mkdir(path);
else if (!S_ISDIR(st.st_mode))
* @return EINA_TRUE on success, EINA_FALSE otherwise.
*
* This function create @p path and all the subdirectories it
- * contains. The separator is '/' so, on Windows, '\' must be replaced
- * by '/'. If @p path exists, this function returns EINA_TRUE
- * immediatly. It returns EINA_TRUE on success, EINA_FALSE otherwise.
+ * contains. The separator is '/' or '\'. If @p path exists, this
+ * function returns EINA_TRUE immediatly. It returns EINA_TRUE on
+ * success, EINA_FALSE otherwise.
*/
EAPI Eina_Bool
ecore_file_mkpath(const char *path)
for (i = 0; path[i] != '\0'; ss[i] = path[i], i++)
{
if (i == sizeof(ss) - 1) return EINA_FALSE;
- if ((path[i] == '/') && (i > 0))
+ if (((path[i] == '/') || (path[i] == '\\')) && (i > 0))
{
ss[i] = '\0';
if (!_ecore_file_mkpath_if_not_exists(ss))
if(job_ret) *job_ret = job;
return job ? EINA_TRUE : EINA_FALSE;
}
+# else
+ else if ((!strncmp(url, "http://", 7)) ||
+ (!strncmp(url, "ftp://", 6)))
+ {
+ (void)completion_cb;
+ (void)progress_cb;
+ (void)data;
+ (void)job_ret;
+ return EINA_FALSE;
+ }
# endif
else
{
* IN_ACCESS, IN_ATTRIB, IN_CLOSE_WRITE, IN_CLOSE_NOWRITE, IN_OPEN
* - Read all events first, then call the callbacks. This will prevent several
* callbacks with the typic save cycle (delete file, new file)
+ * - Listen to IN_IGNORED, emitted when the watch is removed
*/
#ifdef HAVE_INOTIFY
{
int fd;
- _monitors = ECORE_FILE_MONITOR(eina_inlist_remove(EINA_INLIST_GET(_monitors), EINA_INLIST_GET(em)));
+ if (_monitors)
+ _monitors = ECORE_FILE_MONITOR(eina_inlist_remove(EINA_INLIST_GET(_monitors), EINA_INLIST_GET(em)));
fd = ecore_main_fd_handler_fd_get(_fdh);
if (ECORE_FILE_MONITOR_INOTIFY(em)->wd)
isdir = mask & IN_ISDIR;
#if 0
- _ecore_file_monitor_inotify_print(file, mask);
+ _ecore_file_monitor_inotify_print(buf, mask);
#endif
- if (mask & IN_MODIFY)
+ if (mask & IN_ATTRIB)
+ {
+ em->func(em->data, em, ECORE_FILE_EVENT_MODIFIED, buf);
+ }
+ if (mask & IN_CLOSE_WRITE)
{
if (!isdir)
em->func(em->data, em, ECORE_FILE_EVENT_MODIFIED, buf);
_ecore_file_monitor_inotify_monitor(Ecore_File_Monitor *em, const char *path)
{
int mask;
- mask = IN_MODIFY|
+ mask = IN_ATTRIB|IN_CLOSE_WRITE|
IN_MOVED_FROM|IN_MOVED_TO|
IN_DELETE|IN_CREATE|
IN_DELETE_SELF|IN_MOVE_SELF|
else
type = "file";
+ if (mask & IN_ACCESS)
+ INF("Inotify accessed %s: %s", type, file);
if (mask & IN_MODIFY)
- {
- WRN("Inotify modified %s: %s", type, file);
- }
+ INF("Inotify modified %s: %s", type, file);
+ if (mask & IN_ATTRIB)
+ INF("Inotify attributes %s: %s", type, file);
+ if (mask & IN_CLOSE_WRITE)
+ INF("Inotify close write %s: %s", type, file);
+ if (mask & IN_CLOSE_NOWRITE)
+ INF("Inotify close write %s: %s", type, file);
+ if (mask & IN_OPEN)
+ INF("Inotify open %s: %s", type, file);
if (mask & IN_MOVED_FROM)
- {
- WRN("Inotify moved from %s: %s", type, file);
- }
+ INF("Inotify moved from %s: %s", type, file);
if (mask & IN_MOVED_TO)
- {
- WRN("Inotify moved to %s: %s", type, file);
- }
+ INF("Inotify moved to %s: %s", type, file);
if (mask & IN_DELETE)
- {
- WRN("Inotify delete %s: %s", type, file);
- }
+ INF("Inotify delete %s: %s", type, file);
if (mask & IN_CREATE)
- {
- WRN("Inotify create %s: %s", type, file);
- }
+ INF("Inotify create %s: %s", type, file);
if (mask & IN_DELETE_SELF)
- {
- WRN("Inotify delete self %s: %s", type, file);
- }
+ INF("Inotify delete self %s: %s", type, file);
if (mask & IN_MOVE_SELF)
- {
- WRN("Inotify move self %s: %s", type, file);
- }
+ INF("Inotify move self %s: %s", type, file);
if (mask & IN_UNMOUNT)
- {
- WRN("Inotify unmount %s: %s", type, file);
- }
+ INF("Inotify unmount %s: %s", type, file);
}
#endif
#endif /* HAVE_INOTIFY */
f->name = strdup(file);
f->mtime = ecore_file_mod_time(buf);
- f->is_dir = ecore_file_mod_time(buf);
+ f->is_dir = ecore_file_is_dir(buf);
if (f->is_dir)
event = ECORE_FILE_EVENT_CREATED_DIRECTORY;
else
# include <config.h>
#endif
+#undef alloca
+#ifdef HAVE_ALLOCA_H
+# include <alloca.h>
+#elif defined __GNUC__
+# define alloca __builtin_alloca
+#elif defined _AIX
+# define alloca __alloca
+#elif defined _MSC_VER
+# include <malloc.h>
+# define alloca _alloca
+#else
+# include <stddef.h>
+# ifdef __cplusplus
+extern "C"
+# endif
+void *alloca (size_t);
+#endif
+
#include <stdio.h>
#include <string.h>
char *dir;
EINA_LIST_FREE(__ecore_file_path_bin, dir)
- free(dir);
+ eina_stringshare_del(dir);
}
Eina_List *
_ecore_file_path_from_env(const char *env)
{
Eina_List *path = NULL;
- char *env_path, *p, *last;
+ char *env_tmp, *env_path, *p, *last;
- env_path = getenv(env);
- if (!env_path)
+ env_tmp = getenv(env);
+ if (!env_tmp)
return path;
- env_path = strdup(env_path);
+ env_path = alloca(sizeof(char) * strlen(env_tmp) + 1);
+ memset(env_path, 0, strlen(env_tmp));
+ strcpy(env_path, env_tmp);
last = env_path;
for (p = env_path; *p; p++)
{
if (!*p)
{
if (!ecore_file_path_dir_exists(last))
- path = eina_list_append(path, strdup(last));
+ path = eina_list_append(path, eina_stringshare_add(last));
last = p + 1;
}
}
if (p > last)
- path = eina_list_append(path, strdup(last));
+ path = eina_list_append(path, eina_stringshare_add(last));
- free(env_path);
return path;
}
if (ctx->klass->del) ctx->klass->del(ctx);
ECORE_MAGIC_SET(ctx, ECORE_MAGIC_NONE);
-
+
EINA_LIST_FREE(ctx->private_key_list, data)
free(data);
}
}
-EAPI void
+EAPI void
ecore_imf_context_preedit_string_with_attributes_get(Ecore_IMF_Context *ctx, char **str, Eina_List **attrs, int *cursor_pos)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
else
{
if (str) *str = strdup("");
- if (attrs) *attrs = NULL;
+ if (attrs) *attrs = NULL;
if (cursor_pos) *cursor_pos = 0;
}
}
}
/*** ImControl Related APIs */
-EAPI void
+EAPI void
ecore_imf_context_input_panel_show(Ecore_IMF_Context *ctx)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
if (ctx->klass->show) ctx->klass->show(ctx);
}
-EAPI void
+EAPI void
ecore_imf_context_input_panel_hide(Ecore_IMF_Context *ctx)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
if (ctx->klass->hide) ctx->klass->hide(ctx);
}
-EAPI void
+EAPI void
ecore_imf_context_control_panel_show (Ecore_IMF_Context *ctx)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
if (ctx->klass->control_panel_show) ctx->klass->control_panel_show(ctx);
}
-EAPI void
+EAPI void
ecore_imf_context_control_panel_hide (Ecore_IMF_Context *ctx)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
if (ctx->klass->control_panel_hide) ctx->klass->control_panel_hide(ctx);
}
-EAPI void
+EAPI void
ecore_imf_context_input_panel_language_set (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Lang lang)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_input_panel_language_set");
return;
}
+
if (ctx->klass->input_panel_language_set) ctx->klass->input_panel_language_set(ctx, lang);
ctx->input_panel_lang = lang;
}
-EAPI Ecore_IMF_Input_Panel_Lang
+EAPI Ecore_IMF_Input_Panel_Lang
ecore_imf_context_input_panel_language_get (Ecore_IMF_Context *ctx)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
return ctx->input_panel_lang;
}
-EAPI int
+EAPI int
ecore_imf_context_ise_get_ise_language (Ecore_IMF_Context *ctx, const char* ise_name, char ***langlist)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
}
if (ctx->klass->ise_get_ise_language)
- {
- return ctx->klass->ise_get_ise_language(ctx, ise_name, langlist);
- }
+ return ctx->klass->ise_get_ise_language(ctx, ise_name, langlist);
else
return -1;
}
-EAPI void ecore_imf_context_keyboard_language_set (Ecore_IMF_Context *ctx, Ecore_IMF_Keyboard_Lang lang)
+EAPI void
+ecore_imf_context_keyboard_language_set (Ecore_IMF_Context *ctx, Ecore_IMF_Keyboard_Lang lang)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
{
// if (ctx->klass->ise_set_language) ctx->klass->ise_set_language(ctx, lang);
}
-EAPI Ecore_IMF_Keyboard_Lang ecore_imf_context_keyboard_language_get (Ecore_IMF_Context *ctx)
+EAPI Ecore_IMF_Keyboard_Lang
+ecore_imf_context_keyboard_language_get (Ecore_IMF_Context *ctx)
{
Ecore_IMF_Keyboard_Lang lang = ECORE_IMF_KEYBOARD_LANG_NATIVE;
+
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
{
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_keyboard_language_get");
return lang;
}
-EAPI void
+EAPI void
ecore_imf_context_ise_set_isf_language (Ecore_IMF_Context *ctx, const char* lang)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
if (ctx->klass->ise_set_isf_language) ctx->klass->ise_set_isf_language(ctx, lang);
}
-EAPI void
+EAPI void
ecore_imf_context_input_panel_imdata_set (Ecore_IMF_Context *ctx, const char * data, int len)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
if (ctx->klass->input_panel_imdata_set) ctx->klass->input_panel_imdata_set(ctx, data, len);
}
-EAPI void
+EAPI void
ecore_imf_context_input_panel_imdata_get (Ecore_IMF_Context *ctx, char * data, int *len)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
if (ctx->klass->input_panel_imdata_get) ctx->klass->input_panel_imdata_get(ctx, data, len);
}
-EAPI void
+EAPI void
ecore_imf_context_input_panel_use_effect_set (Ecore_IMF_Context *ctx, Eina_Bool use_effect)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
ctx->use_effect = use_effect;
}
-EAPI Eina_Bool
+EAPI Eina_Bool
ecore_imf_context_input_panel_use_effect_get (Ecore_IMF_Context *ctx)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
return ctx->use_effect;
}
-EAPI void
+EAPI void
ecore_imf_context_input_panel_geometry_get (Ecore_IMF_Context *ctx, int *x, int *y, int *w, int *h)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
if (ctx->klass->input_panel_geometry_get) ctx->klass->input_panel_geometry_get(ctx, x, y, w, h);
}
-EAPI void
+EAPI void
ecore_imf_context_input_panel_private_key_set (Ecore_IMF_Context *ctx, int layout_index, int key_index, const char *img_path, const char* label, int key_value, const char* key_string)
{
+ Private_Key_Item *key_item;
+ Eina_List *l;
+ Eina_Bool exist = EINA_FALSE;
+
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
{
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_input_panel_private_key_set");
return;
}
- Private_Key_Item *key_item;
- Eina_List *l;
- Eina_Bool exist = EINA_FALSE;
-
EINA_LIST_FOREACH(ctx->private_key_list, l, key_item)
{
- if (key_item && key_item->layout_idx == layout_index && key_item->key_idx == key_index)
+ if (key_item && key_item->layout_idx == layout_index &&
+ key_item->key_idx == key_index)
{
// if exist in the list
- exist = EINA_TRUE;
+ exist = EINA_TRUE;
if (label)
{
key_item->type = 0;
strcpy(key_item->data, label);
- }
+ }
else
{
key_item->type = 1;
{
key_item->type = 0;
strcpy(key_item->data, label);
- }
+ }
else
{
key_item->type = 1;
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
{
- ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_input_panel_private_key_list_get");
- return NULL;
+ ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_input_panel_private_key_list_get");
+ return NULL;
}
return ctx->private_key_list;
EAPI void
ecore_imf_context_input_panel_key_disabled_set (Ecore_IMF_Context *ctx, int layout_index, int key_index, Eina_Bool disabled)
{
+ Disable_Key_Item *key_item;
+ Eina_List *l;
+ Eina_Bool exist = EINA_FALSE;
+
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
{
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_input_panel_key_disabled_set");
return;
}
- Disable_Key_Item *key_item;
- Eina_List *l;
- Eina_Bool exist = EINA_FALSE;
-
EINA_LIST_FOREACH(ctx->disabled_key_list, l, key_item)
{
if (key_item && key_item->layout_idx == layout_index && key_item->key_idx == key_index)
EAPI Eina_List *
ecore_imf_context_input_panel_key_disabled_list_get (Ecore_IMF_Context *ctx)
{
- return ctx->disabled_key_list;
+ return ctx->disabled_key_list;
}
-EAPI void
+EAPI void
ecore_imf_context_input_panel_layout_set (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Layout layout)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
return ECORE_IMF_INPUT_PANEL_LAYOUT_INVALID;
}
-EAPI void
+EAPI void
ecore_imf_context_input_panel_reset (Ecore_IMF_Context *ctx)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
if (ctx->klass->input_panel_reset) ctx->klass->input_panel_reset(ctx);
}
-EAPI void
+EAPI void
ecore_imf_context_input_panel_orient_set (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Orient orientation)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
ctx->input_panel_orient = orientation;
}
-EAPI Ecore_IMF_Input_Panel_Orient
+EAPI Ecore_IMF_Input_Panel_Orient
ecore_imf_context_input_panel_orient_get (Ecore_IMF_Context *ctx)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_ise_set_active_ise_by_name");
return;
}
+
if (!name)
{
printf ("input parameters error!!! \n");
ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_ise_set_active_ise_by_uuid");
return;
}
+
if (!uuid)
{
printf ("input parameters error!!! \n");
if (ctx->klass->ise_set_active_ise_by_uuid) ctx->klass->ise_set_active_ise_by_uuid(ctx, uuid);
}
-EAPI int
+EAPI int
ecore_imf_context_ise_get_iselist (Ecore_IMF_Context *ctx, char*** iselist)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
{
- ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_ise_get_iselist");
- return -1;
- }
+ ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_ise_get_iselist");
+ return -1;
+ }
if (ctx->klass->ise_get_iselist)
- {
- return ctx->klass->ise_get_iselist(ctx, iselist);
- }
+ return ctx->klass->ise_get_iselist(ctx, iselist);
else
- return -1;
+ return -1;
}
-EAPI Ecore_IMF_Input_Panel_State
+EAPI Ecore_IMF_Input_Panel_State
ecore_imf_context_input_panel_state_get (Ecore_IMF_Context *ctx)
{
Ecore_IMF_Input_Panel_State state = ECORE_IMF_INPUT_PANEL_STATE_INVALID;
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
{
- ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_input_panel_state_get");
- return ECORE_IMF_INPUT_PANEL_STATE_INVALID;
+ ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_input_panel_state_get");
+ return ECORE_IMF_INPUT_PANEL_STATE_INVALID;
}
if (ctx->klass->input_panel_state_get)
- {
- state = ctx->klass->input_panel_state_get(ctx);
- }
-
+ state = ctx->klass->input_panel_state_get(ctx);
+
return state;
}
-EAPI void
+EAPI void
ecore_imf_context_input_panel_event_callback_add (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Event type, void (*pEventCallBackFunc) (void *data, Ecore_IMF_Context *ctx, int value), const void *data)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
{
- ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_input_panel_event_callback_add");
- return;
+ ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_input_panel_event_callback_add");
+ return;
}
if (ctx->klass->input_panel_event_callback_add)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
{
- ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_input_panel_event_callback_del");
- return;
+ ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_input_panel_event_callback_del");
+ return;
}
if (ctx->klass->input_panel_event_callback_del)
}
}
-EAPI void
+EAPI void
ecore_imf_context_input_panel_move (Ecore_IMF_Context *ctx, int x, int y)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
{
- ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_input_panel_move");
- return;
+ ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_input_panel_move");
+ return;
}
if (ctx->klass->input_panel_move) ctx->klass->input_panel_move(ctx, x, y);
ctx->input_panel_y = y;
}
-EAPI void
+EAPI void
ecore_imf_context_input_panel_caps_mode_set (Ecore_IMF_Context *ctx, Ecore_IMF_Input_Panel_Caps_Mode mode)
{
if (!ECORE_MAGIC_CHECK(ctx, ECORE_MAGIC_CONTEXT))
{
- ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_input_panel_caps_mode_set");
- return;
+ ECORE_MAGIC_FAIL(ctx, ECORE_MAGIC_CONTEXT,"ecore_imf_context_input_panel_caps_mode_set");
+ return;
}
if (ctx->klass->input_panel_caps_mode_set) ctx->klass->input_panel_caps_mode_set(ctx, mode);
MAINTAINERCLEANFILES = Makefile.in
-if BUILD_ECORE_IMF_EVAS
AM_CPPFLAGS = \
-I$(top_srcdir)/src/lib/ecore \
-I$(top_srcdir)/src/lib/ecore_imf \
@EINA_LIBS@
libecore_imf_evas_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@
-endif
@EINA_CFLAGS@ \
@EVIL_CFLAGS@
-if BUILD_ECORE_INPUT
-
lib_LTLIBRARIES = libecore_input.la
includes_HEADERS = Ecore_Input.h
includesdir = $(includedir)/ecore-@VMAJ@
libecore_input_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@
-endif
-
EXTRA_DIST = ecore_input_private.h
@EINA_CFLAGS@ \
@EVIL_CFLAGS@
-if BUILD_ECORE_INPUT_EVAS
-
lib_LTLIBRARIES = libecore_input_evas.la
includes_HEADERS = Ecore_Input_Evas.h
includesdir = $(includedir)/ecore-@VMAJ@
libecore_input_evas_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@
-endif
-
EXTRA_DIST = ecore_input_evas_private.h
{
Ecore_Input_Window *lookup;
- lookup = _ecore_event_window_match(e->window);
+ lookup = _ecore_event_window_match(e->event_window);
if (!lookup) return ECORE_CALLBACK_RENEW;
ecore_event_evas_modifier_lock_update(lookup->evas, e->modifiers);
if (press == ECORE_DOWN)
Ecore_Input_Window *lookup;
Evas_Button_Flags flags = EVAS_BUTTON_NONE;
- lookup = _ecore_event_window_match(e->window);
+ lookup = _ecore_event_window_match(e->event_window);
if (!lookup) return ECORE_CALLBACK_RENEW;
if (e->double_click) flags |= EVAS_BUTTON_DOUBLE_CLICK;
if (e->triple_click) flags |= EVAS_BUTTON_TRIPLE_CLICK;
Ecore_Input_Window *lookup;
e = event;
- lookup = _ecore_event_window_match(e->window);
+ lookup = _ecore_event_window_match(e->event_window);
if (!lookup) return ECORE_CALLBACK_RENEW;
if (e->multi.device == 0)
{
{
Ecore_Input_Window *lookup;
- lookup = _ecore_event_window_match(e->window);
+ lookup = _ecore_event_window_match(e->event_window);
if (!lookup) return ECORE_CALLBACK_RENEW;
ecore_event_evas_modifier_lock_update(lookup->evas, e->modifiers);
switch (io)
Ecore_Input_Window *lookup;
e = event;
- lookup = _ecore_event_window_match(e->window);
+ lookup = _ecore_event_window_match(e->event_window);
if (!lookup) return ECORE_CALLBACK_RENEW;
ecore_event_evas_modifier_lock_update(lookup->evas, e->modifiers);
evas_event_feed_mouse_wheel(lookup->evas, e->direction, e->z, e->timestamp, NULL);
-I$(top_srcdir)/src/lib/ecore_ipc \
@SSL_CFLAGS@ @EINA_CFLAGS@
-if BUILD_ECORE_IPC
-
lib_LTLIBRARIES = libecore_ipc.la
includes_HEADERS = Ecore_Ipc.h
includesdir = $(includedir)/ecore-@VMAJ@
libecore_ipc_la_LDFLAGS = -no-undefined -version-info @version_info@ @release_info@
-endif
-
EXTRA_DIST = ecore_ipc_private.h
@EVAS_CFLAGS@ \
@EINA_CFLAGS@
-if BUILD_ECORE_SDL
-
lib_LTLIBRARIES = libecore_sdl.la
includes_HEADERS = Ecore_Sdl.h
includesdir = $(includedir)/ecore-@VMAJ@
libecore_sdl_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@
-endif
-
EXTRA_DIST = Ecore_Sdl_Keys.h ecore_sdl_private.h
ev->timestamp = time;
ev->window = 0;
+ ev->event_window = 0;
ev->modifiers = _ecore_sdl_event_modifiers(SDL_GetModState());
ev->key = NULL;
ev->compose = NULL;
ev->timestamp = time;
ev->window = 0;
+ ev->event_window = 0;
ev->modifiers = 0; /* FIXME: keep modifier around. */
ev->x = event.motion.x;
ev->y = event.motion.y;
ev->timestamp = time;
ev->window = 0;
+ ev->event_window = 0;
ev->modifiers = 0; /* FIXME: keep modifier around. */
ev->direction = 0;
ev->z = event.button.button == SDL_BUTTON_WHEELDOWN ? -1 : 1;
ev->timestamp = time;
ev->window = 0;
+ ev->event_window = 0;
ev->modifiers = 0; /* FIXME: keep modifier around. */
ev->buttons = event.button.button;
ev->double_click = 0;
if (!ev) return ;
ev->timestamp = time;
ev->window = 0;
+ ev->event_window = 0;
ev->modifiers = 0; /* FIXME: keep modifier around. */
ev->buttons = event.button.button;
ev->double_click = 0;
@EINA_CFLAGS@ \
@WIN32_CPPFLAGS@
-
-if BUILD_ECORE_WIN32
-
lib_LTLIBRARIES = libecore_win32.la
includes_HEADERS = Ecore_Win32.h
libecore_win32_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@
-endif
-
EXTRA_DIST = \
ecore_win32_private.h \
ecore_win32_dnd_enumformatetc.h \
DEFINE_OLEGUID(IID_IDropTarget, 0x00000122L, 0, 0);
DEFINE_OLEGUID(IID_IUnknown, 0x00000000L, 0, 0);
+#define IDI_ICON 101
+
static int _ecore_win32_init_count = 0;
LRESULT CALLBACK
* Ecore_Win32 is a library that wraps Windows graphic functions
* and integrate them nicely into the Ecore main loop.
*
+ * @section Ecore_Win32_Sec_Init Initialisation / Shutdown
+ *
+ * To fill...
+ *
+ * @section Ecore_Win32_Sec_Icons How to set icons to an application
+ *
+ * It is possible to also sets the icon of the application easily:
+ *
+ * @li Create an icon with your favorite image creator. The Gimp is a
+ * good choice. Create several images of size 16, 32 and 48. You can
+ * also create images of size 24, 64, 128 and 256. Paste all of them
+ * in the image of size 16 as a layer. Save the image of size 16 with
+ * the name my_icon.ico. Put it where the source code of the
+ * application is located.
+ * @li Create my_icon_rc.rc file with your code editor and add in it:
+ * @code
+ * 101 ICON DISCARDABLE "my_icon.ico"
+ * @endcode
+ * @li With Visual Studio, put that file in the 'Resource file' part
+ * of the project.
+ * @li With MinGW, you have to compile it with windres:
+ * @code
+ * windres my_icon_rc.rc my_icon_rc.o
+ * @endcode
+ * and add my_icon_rc.o to the object files of the application.
+ *
+ * @note The value 101 must not be changed, it's the ID used
+ * internally by Ecore_Win32 to get the icons.
+ *
* @{
*/
EAPI int
ecore_win32_init()
{
- WNDCLASS wc;
+ WNDCLASSEX wc;
+ HICON icon;
+ HICON icon_sm;
if (++_ecore_win32_init_count != 1)
return _ecore_win32_init_count;
goto shutdown_ecore_event;
}
- memset (&wc, 0, sizeof (WNDCLASS));
+ icon = LoadImage(_ecore_win32_instance,
+ MAKEINTRESOURCE(IDI_ICON),
+ IMAGE_ICON,
+ GetSystemMetrics(SM_CXICON),
+ GetSystemMetrics(SM_CYICON),
+ LR_DEFAULTCOLOR);
+ icon_sm = LoadImage(_ecore_win32_instance,
+ MAKEINTRESOURCE(IDI_ICON),
+ IMAGE_ICON,
+ GetSystemMetrics(SM_CXSMICON),
+ GetSystemMetrics(SM_CYSMICON),
+ LR_DEFAULTCOLOR);
+ if (!icon)
+ icon = LoadIcon (NULL, IDI_APPLICATION);
+ if (!icon_sm)
+ icon_sm = LoadIcon (NULL, IDI_APPLICATION);
+
+ memset (&wc, 0, sizeof (WNDCLASSEX));
+ wc.cbSize = sizeof (WNDCLASSEX);
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = _ecore_win32_window_procedure;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = _ecore_win32_instance;
- wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
+ wc.hIcon = icon;
wc.hCursor = LoadCursor (NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(1 + COLOR_BTNFACE);
wc.lpszMenuName = NULL;
wc.lpszClassName = ECORE_WIN32_WINDOW_CLASS;
+ wc.hIconSm = icon_sm;
- if(!RegisterClass(&wc))
+ if(!RegisterClassEx(&wc))
{
ERR("RegisterClass() failed");
goto free_library;
/**
* @addtogroup Ecore_Win32_Group Ecore_Win32 library
*
- * Ecore_Win32 is a library that wraps Windows CE graphic functions
- * and integrate them nicely into the Ecore main loop.
- *
* @{
*/
INF("key pressed");
- e = (Ecore_Event_Key *)malloc(sizeof(Ecore_Event_Key));
+ e = (Ecore_Event_Key *)calloc(1, sizeof(Ecore_Event_Key));
if (!e) return;
if (is_keystroke)
free(e);
return;
}
+ e->event_window = e->window;
e->timestamp = msg->time;
_ecore_win32_event_last_time = e->timestamp;
free(e);
return;
}
+ e->event_window = e->window;
e->timestamp = msg->time;
_ecore_win32_event_last_time = e->timestamp;
if (!e) return;
e->window = (Ecore_Window)window;
+ e->event_window = e->window;
e->direction = 0;
/* wheel delta is positive or negative, never 0 */
e->z = GET_WHEEL_DELTA_WPARAM(msg->window_param) > 0 ? -1 : 1;
if (!e) return;
e->window = (Ecore_Window)window;
+ e->event_window = e->window;
e->x = GET_X_LPARAM(msg->data_param);
e->y = GET_Y_LPARAM(msg->data_param);
e->timestamp = msg->time;
if (!e) return;
e->window = (Ecore_Window)window;
+ e->event_window = e->window;
e->buttons = button;
e->x = GET_X_LPARAM(msg->data_param);
e->y = GET_Y_LPARAM(msg->data_param);
if (!e) return;
e->window = (Ecore_Window)window;
+ e->event_window = e->window;
e->x = GET_X_LPARAM(msg->data_param);
e->y = GET_Y_LPARAM(msg->data_param);
e->timestamp = msg->time;
if (!e) return;
e->window = (Ecore_Window)window;
+ e->event_window = e->window;
e->buttons = button;
e->x = GET_X_LPARAM(msg->data_param);
e->y = GET_Y_LPARAM(msg->data_param);
if (!e) return;
e->window = (Ecore_Window)GetWindowLong(msg->window, GWL_USERDATA);
+ e->event_window = e->window;
e->x = GET_X_LPARAM(msg->data_param);
e->y = GET_Y_LPARAM(msg->data_param);
e->timestamp = msg->time;
if (!e) return;
e->window = (Ecore_Window)GetWindowLong(msg->window, GWL_USERDATA);
+ e->event_window = e->window;
e->x = msg->x;
e->y = msg->y;
e->timestamp = msg->time;
if (!e) return;
e->window = (Ecore_Window)GetWindowLong(msg->window, GWL_USERDATA);
+ e->event_window = e->window;
e->x = msg->x;
e->y = msg->y;
e->timestamp = msg->time;
AM_CFLAGS = @WIN32_CFLAGS@
-
-if BUILD_ECORE_WINCE
-
lib_LTLIBRARIES = libecore_wince.la
includes_HEADERS = Ecore_WinCE.h
libecore_wince_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@
-endif
-
EXTRA_DIST = ecore_wince_private.h
}
e->window = (Ecore_Window)GetWindowLong(msg->window, GWL_USERDATA);
+ e->event_window = e->window;
if (!e->window)
{
free(e);
}
e->window = (Ecore_Window)GetWindowLong(msg->window, GWL_USERDATA);
+ e->event_window = e->window;
if (!e->window)
{
free(e);
if (!e) return;
e->window = (Ecore_Window)window;
+ e->event_window = e->window;
e->x = LOWORD(msg->data_param);
e->y = HIWORD(msg->data_param);
e->timestamp = msg->time;
if (!e) return;
e->window = (Ecore_Window)window;
+ e->event_window = e->window;
e->buttons = button;
e->x = LOWORD(msg->data_param);
e->y = HIWORD(msg->data_param);
if (!e) return;
e->window = (Ecore_Window)window;
+ e->event_window = e->window;
e->x = LOWORD(msg->data_param);
e->y = HIWORD(msg->data_param);
e->timestamp = msg->time;
if (!e) return;
e->window = (Ecore_Window)window;
+ e->event_window = e->window;
e->buttons = button;
e->x = LOWORD(msg->data_param);
e->y = HIWORD(msg->data_param);
if (!e) return;
e->window = (Ecore_Window)GetWindowLong(msg->window, GWL_USERDATA);
+ e->event_window = e->window;
e->x = LOWORD(msg->data_param);
e->y = HIWORD(msg->data_param);
e->timestamp = msg->time;
if (!e) return;
e->window = (Ecore_Window)window;
+ e->event_window = e->window;
e->x = msg->x;
e->y = msg->y;
e->timestamp = msg->time;
if (!e) return;
e->window = (Ecore_Window)window;
+ e->event_window = e->window;
e->x = msg->x;
e->y = msg->y;
e->timestamp = msg->time;
unsigned char *data;
int length;
int format;
-
int (*free)(void *data);
};
MAINTAINERCLEANFILES = Makefile.in
-if BUILD_ECORE_X
-
SUBDIRS = xlib xcb
if BUILD_ECORE_X_XCB
Ecore_X_Cursor.h
includesdir = $(includedir)/ecore-@VMAJ@
-endif
-
EXTRA_DIST = ecore_x_atoms_decl.h
EAPI int ECORE_X_EVENT_WINDOW_PROPERTY = 0;
EAPI int ECORE_X_EVENT_WINDOW_COLORMAP = 0;
EAPI int ECORE_X_EVENT_WINDOW_MAPPING = 0;
+EAPI int ECORE_X_EVENT_MAPPING_CHANGE = 0;
EAPI int ECORE_X_EVENT_SELECTION_CLEAR = 0;
EAPI int ECORE_X_EVENT_SELECTION_REQUEST = 0;
EAPI int ECORE_X_EVENT_SELECTION_NOTIFY = 0;
EAPI int ECORE_X_EVENT_DAMAGE_NOTIFY = 0;
EAPI int ECORE_X_EVENT_WINDOW_DELETE_REQUEST = 0;
-/*
- EAPI int ECORE_X_EVENT_WINDOW_PROP_TITLE_CHANGE = 0;
- EAPI int ECORE_X_EVENT_WINDOW_PROP_VISIBLE_TITLE_CHANGE = 0;
- EAPI int ECORE_X_EVENT_WINDOW_PROP_NAME_CLASS_CHANGE = 0;
- EAPI int ECORE_X_EVENT_WINDOW_PROP_ICON_NAME_CHANGE = 0;
- EAPI int ECORE_X_EVENT_WINDOW_PROP_VISIBLE_ICON_NAME_CHANGE = 0;
- EAPI int ECORE_X_EVENT_WINDOW_PROP_CLIENT_MACHINE_CHANGE = 0;
- EAPI int ECORE_X_EVENT_WINDOW_PROP_PID_CHANGE = 0;
- EAPI int ECORE_X_EVENT_WINDOW_PROP_DESKTOP_CHANGE = 0;
- */
EAPI int ECORE_X_EVENT_WINDOW_MOVE_RESIZE_REQUEST = 0;
EAPI int ECORE_X_EVENT_WINDOW_STATE_REQUEST = 0;
ECORE_X_EVENT_WINDOW_PROPERTY = ecore_event_type_new();
ECORE_X_EVENT_WINDOW_COLORMAP = ecore_event_type_new();
ECORE_X_EVENT_WINDOW_MAPPING = ecore_event_type_new();
+ ECORE_X_EVENT_MAPPING_CHANGE = ecore_event_type_new();
ECORE_X_EVENT_SELECTION_CLEAR = ecore_event_type_new();
ECORE_X_EVENT_SELECTION_REQUEST = ecore_event_type_new();
ECORE_X_EVENT_SELECTION_NOTIFY = ecore_event_type_new();
ECORE_X_EVENT_DAMAGE_NOTIFY = ecore_event_type_new();
ECORE_X_EVENT_WINDOW_DELETE_REQUEST = ecore_event_type_new();
- /*
- ECORE_X_EVENT_WINDOW_PROP_TITLE_CHANGE = ecore_event_type_new();
- ECORE_X_EVENT_WINDOW_PROP_VISIBLE_TITLE_CHANGE = ecore_event_type_new();
- ECORE_X_EVENT_WINDOW_PROP_NAME_CLASS_CHANGE = ecore_event_type_new();
- ECORE_X_EVENT_WINDOW_PROP_ICON_NAME_CHANGE = ecore_event_type_new();
- ECORE_X_EVENT_WINDOW_PROP_VISIBLE_ICON_NAME_CHANGE = ecore_event_type_new();
- ECORE_X_EVENT_WINDOW_PROP_CLIENT_MACHINE_CHANGE = ecore_event_type_new();
- ECORE_X_EVENT_WINDOW_PROP_PID_CHANGE = ecore_event_type_new();
- ECORE_X_EVENT_WINDOW_PROP_DESKTOP_CHANGE = ecore_event_type_new();
- */
-
ECORE_X_EVENT_DESKTOP_CHANGE = ecore_event_type_new();
ECORE_X_EVENT_WINDOW_MOVE_RESIZE_REQUEST = ecore_event_type_new();
ECORE_X_EVENT_WINDOW_STATE_REQUEST = ecore_event_type_new();
#define CODESET "INVALID"
#endif /* ifndef CODESET */
-#if 0
-static void _ecore_x_event_free_window_prop_name_class_change(void *data, void *ev);
-static void _ecore_x_event_free_window_prop_title_change(void *data, void *ev);
-static void _ecore_x_event_free_window_prop_visible_title_change(void *data, void *ev);
-static void _ecore_x_event_free_window_prop_icon_name_change(void *data, void *ev);
-static void _ecore_x_event_free_window_prop_visible_icon_name_change(void *data, void *ev);
-static void _ecore_x_event_free_window_prop_client_machine_change(void *data, void *ev);
-#endif /* if 0 */
-
static Ecore_X_Window _ecore_xcb_mouse_down_last_window = 0;
static Ecore_X_Window _ecore_xcb_mouse_down_last_last_window = 0;
static Ecore_X_Window _ecore_xcb_mouse_down_last_event_window = 0;
free(reply);
} /* ecore_x_event_mask_unset */
-#if 0
-static void
-_ecore_x_event_free_window_prop_name_class_change(void *data, void *ev)
-{
- Ecore_X_Event_Window_Prop_Name_Class_Change *e;
-
- e = ev;
- if (e->name)
- free(e->name);
-
- if (e->clas)
- free(e->clas);
-
- free(e);
-} /* _ecore_x_event_free_window_prop_name_class_change */
-
-static void
-_ecore_x_event_free_window_prop_title_change(void *data, void *ev)
-{
- Ecore_X_Event_Window_Prop_Title_Change *e;
-
- e = ev;
- if (e->title)
- free(e->title);
-
- free(e);
-} /* _ecore_x_event_free_window_prop_title_change */
-
-static void
-_ecore_x_event_free_window_prop_visible_title_change(void *data, void *ev)
-{
- Ecore_X_Event_Window_Prop_Visible_Title_Change *e;
-
- e = ev;
- if (e->title)
- free(e->title);
-
- free(e);
-} /* _ecore_x_event_free_window_prop_visible_title_change */
-
-static void
-_ecore_x_event_free_window_prop_icon_name_change(void *data, void *ev)
-{
- Ecore_X_Event_Window_Prop_Icon_Name_Change *e;
-
- e = ev;
- if (e->name)
- free(e->name);
-
- free(e);
-} /* _ecore_x_event_free_window_prop_icon_name_change */
-
-static void
-_ecore_x_event_free_window_prop_visible_icon_name_change(void *data, void *ev)
-{
- Ecore_X_Event_Window_Prop_Visible_Icon_Name_Change *e;
-
- e = ev;
- if (e->name)
- free(e->name);
-
- free(e);
-} /* _ecore_x_event_free_window_prop_visible_icon_name_change */
-
-static void
-_ecore_x_event_free_window_prop_client_machine_change(void *data, void *ev)
-{
- Ecore_X_Event_Window_Prop_Client_Machine_Change *e;
-
- e = ev;
- if (e->name)
- free(e->name);
-
- free(e);
-} /* _ecore_x_event_free_window_prop_client_machine_change */
-
-#endif /* if 0 */
-
static void
_ecore_x_event_free_xdnd_enter(void *data __UNUSED__, void *ev)
{
void
_ecore_x_event_handle_property_notify(xcb_generic_event_t *event)
{
-#if 0 /* for now i disabled this. nice idea though this is - it leaves a lot
- * to be desired for efficiency that is better left to the app layer
- */
- if (xevent->xproperty.atom == ECORE_X_ATOM_WM_CLASS)
- {
- Ecore_X_Event_Window_Prop_Name_Class_Change *e;
-
- e = calloc(1, sizeof(Ecore_X_Event_Window_Prop_Name_Class_Change));
- if (!e)
- return;
-
- ecore_x_window_prop_name_class_get(xevent->xproperty.window,
- &(e->name), &(e->clas));
- e->time = xevent->xproperty.time;
- _ecore_x_event_last_time = e->time;
- ecore_event_add(ECORE_X_EVENT_WINDOW_PROP_NAME_CLASS_CHANGE, e, _ecore_x_event_free_window_prop_name_class_change, NULL);
- }
- else if ((xevent->xproperty.atom == ECORE_X_ATOM_WM_NAME) || (xevent->xproperty.atom == ECORE_X_ATOM_NET_WM_NAME))
- {
- Ecore_X_Event_Window_Prop_Title_Change *e;
-
- e = calloc(1, sizeof(Ecore_X_Event_Window_Prop_Title_Change));
- if (!e)
- return;
-
- e->title = ecore_x_window_prop_title_get(xevent->xproperty.window);
- e->time = xevent->xproperty.time;
- _ecore_x_event_last_time = e->time;
- ecore_event_add(ECORE_X_EVENT_WINDOW_PROP_TITLE_CHANGE, e, _ecore_x_event_free_window_prop_title_change, NULL);
- }
- else if (xevent->xproperty.atom == ECORE_X_ATOM_NET_WM_VISIBLE_NAME)
- {
- Ecore_X_Event_Window_Prop_Visible_Title_Change *e;
-
- e = calloc(1, sizeof(Ecore_X_Event_Window_Prop_Visible_Title_Change));
- if (!e)
- return;
-
- e->title = ecore_x_window_prop_visible_title_get(xevent->xproperty.window);
- e->time = xevent->xproperty.time;
- _ecore_x_event_last_time = e->time;
- ecore_event_add(ECORE_X_EVENT_WINDOW_PROP_VISIBLE_TITLE_CHANGE, e, _ecore_x_event_free_window_prop_visible_title_change, NULL);
- }
- else if ((xevent->xproperty.atom == ECORE_X_ATOM_WM_ICON_NAME) || (xevent->xproperty.atom == ECORE_X_ATOM_NET_WM_ICON_NAME))
- {
- Ecore_X_Event_Window_Prop_Icon_Name_Change *e;
-
- e = calloc(1, sizeof(Ecore_X_Event_Window_Prop_Icon_Name_Change));
- if (!e)
- return;
-
- e->name = ecore_x_window_prop_icon_name_get(xevent->xproperty.window);
- e->time = xevent->xproperty.time;
- _ecore_x_event_last_time = e->time;
- ecore_event_add(ECORE_X_EVENT_WINDOW_PROP_ICON_NAME_CHANGE, e, _ecore_x_event_free_window_prop_icon_name_change, NULL);
- }
- else if (xevent->xproperty.atom == ECORE_X_ATOM_NET_WM_VISIBLE_ICON_NAME)
- {
- Ecore_X_Event_Window_Prop_Visible_Icon_Name_Change *e;
-
- e = calloc(1, sizeof(Ecore_X_Event_Window_Prop_Visible_Icon_Name_Change));
- if (!e)
- return;
-
- e->name = ecore_x_window_prop_visible_icon_name_get(xevent->xproperty.window);
- e->time = xevent->xproperty.time;
- _ecore_x_event_last_time = e->time;
- ecore_event_add(ECORE_X_EVENT_WINDOW_PROP_VISIBLE_ICON_NAME_CHANGE, e, _ecore_x_event_free_window_prop_visible_icon_name_change, NULL);
- }
- else if (xevent->xproperty.atom == ECORE_X_ATOM_WM_CLIENT_MACHINE)
- {
- Ecore_X_Event_Window_Prop_Client_Machine_Change *e;
-
- e = calloc(1, sizeof(Ecore_X_Event_Window_Prop_Client_Machine_Change));
- if (!e)
- return;
-
- e->name = ecore_x_window_prop_client_machine_get(xevent->xproperty.window);
- e->time = xevent->xproperty.time;
- _ecore_x_event_last_time = e->time;
- ecore_event_add(ECORE_X_EVENT_WINDOW_PROP_CLIENT_MACHINE_CHANGE, e, _ecore_x_event_free_window_prop_client_machine_change, NULL);
- }
- else if (xevent->xproperty.atom == ECORE_X_ATOM_NET_WM_PID)
- {
- Ecore_X_Event_Window_Prop_Pid_Change *e;
-
- e = calloc(1, sizeof(Ecore_X_Event_Window_Prop_Pid_Change));
- if (!e)
- return;
-
- e->pid = ecore_x_window_prop_pid_get(xevent->xproperty.window);
- e->time = xevent->xproperty.time;
- _ecore_x_event_last_time = e->time;
- ecore_event_add(ECORE_X_EVENT_WINDOW_PROP_PID_CHANGE, e, NULL, NULL);
- }
- else if (xevent->xproperty.atom == ECORE_X_ATOM_NET_WM_DESKTOP)
- {
- Ecore_X_Event_Window_Prop_Desktop_Change *e;
-
- e = calloc(1, sizeof(Ecore_X_Event_Window_Prop_Desktop_Change));
- if (!e)
- return;
-
- e->desktop = ecore_x_window_prop_desktop_get(xevent->xproperty.window);
- ecore_event_add(ECORE_X_EVENT_WINDOW_PROP_PID_CHANGE, e, NULL, NULL);
- }
- else
-#endif /* if 0 */
{
xcb_property_notify_event_t *ev;
Ecore_X_Event_Window_Property *e;
EAPI int ECORE_X_EVENT_WINDOW_PROPERTY = 0;
EAPI int ECORE_X_EVENT_WINDOW_COLORMAP = 0;
EAPI int ECORE_X_EVENT_WINDOW_MAPPING = 0;
+EAPI int ECORE_X_EVENT_MAPPING_CHANGE = 0;
EAPI int ECORE_X_EVENT_SELECTION_CLEAR = 0;
EAPI int ECORE_X_EVENT_SELECTION_REQUEST = 0;
EAPI int ECORE_X_EVENT_SELECTION_NOTIFY = 0;
EAPI int ECORE_X_EVENT_RANDR_OUTPUT_CHANGE = 0;
EAPI int ECORE_X_EVENT_RANDR_OUTPUT_PROPERTY_NOTIFY = 0;
EAPI int ECORE_X_EVENT_WINDOW_DELETE_REQUEST = 0;
-/*
- EAPI int ECORE_X_EVENT_WINDOW_PROP_TITLE_CHANGE = 0;
- EAPI int ECORE_X_EVENT_WINDOW_PROP_VISIBLE_TITLE_CHANGE = 0;
- EAPI int ECORE_X_EVENT_WINDOW_PROP_NAME_CLASS_CHANGE = 0;
- EAPI int ECORE_X_EVENT_WINDOW_PROP_ICON_NAME_CHANGE = 0;
- EAPI int ECORE_X_EVENT_WINDOW_PROP_VISIBLE_ICON_NAME_CHANGE = 0;
- EAPI int ECORE_X_EVENT_WINDOW_PROP_CLIENT_MACHINE_CHANGE = 0;
- EAPI int ECORE_X_EVENT_WINDOW_PROP_PID_CHANGE = 0;
- EAPI int ECORE_X_EVENT_WINDOW_PROP_DESKTOP_CHANGE = 0;
- */
-
EAPI int ECORE_X_EVENT_WINDOW_MOVE_RESIZE_REQUEST = 0;
EAPI int ECORE_X_EVENT_WINDOW_STATE_REQUEST = 0;
EAPI int ECORE_X_EVENT_FRAME_EXTENTS_REQUEST = 0;
ECORE_X_EVENT_WINDOW_PROPERTY = ecore_event_type_new();
ECORE_X_EVENT_WINDOW_COLORMAP = ecore_event_type_new();
ECORE_X_EVENT_WINDOW_MAPPING = ecore_event_type_new();
+ ECORE_X_EVENT_MAPPING_CHANGE = ecore_event_type_new();
ECORE_X_EVENT_SELECTION_CLEAR = ecore_event_type_new();
ECORE_X_EVENT_SELECTION_REQUEST = ecore_event_type_new();
ECORE_X_EVENT_SELECTION_NOTIFY = ecore_event_type_new();
ECORE_X_EVENT_DAMAGE_NOTIFY = ecore_event_type_new();
ECORE_X_EVENT_WINDOW_DELETE_REQUEST = ecore_event_type_new();
- /*
- ECORE_X_EVENT_WINDOW_PROP_TITLE_CHANGE = ecore_event_type_new();
- ECORE_X_EVENT_WINDOW_PROP_VISIBLE_TITLE_CHANGE = ecore_event_type_new();
- ECORE_X_EVENT_WINDOW_PROP_NAME_CLASS_CHANGE = ecore_event_type_new();
- ECORE_X_EVENT_WINDOW_PROP_ICON_NAME_CHANGE = ecore_event_type_new();
- ECORE_X_EVENT_WINDOW_PROP_VISIBLE_ICON_NAME_CHANGE = ecore_event_type_new();
- ECORE_X_EVENT_WINDOW_PROP_CLIENT_MACHINE_CHANGE = ecore_event_type_new();
- ECORE_X_EVENT_WINDOW_PROP_PID_CHANGE = ecore_event_type_new();
- ECORE_X_EVENT_WINDOW_PROP_DESKTOP_CHANGE = ecore_event_type_new();
- */
ECORE_X_EVENT_DESKTOP_CHANGE = ecore_event_type_new();
ECORE_X_EVENT_WINDOW_MOVE_RESIZE_REQUEST = ecore_event_type_new();
#define CODESET "INVALID"
#endif /* ifndef CODESET */
-#if 0
-static void _ecore_x_event_free_window_prop_name_class_change(void *data,
- void *ev);
-static void _ecore_x_event_free_window_prop_title_change(void *data, void *ev);
-static void _ecore_x_event_free_window_prop_visible_title_change(void *data,
- void *ev);
-static void _ecore_x_event_free_window_prop_icon_name_change(void *data,
- void *ev);
-static void _ecore_x_event_free_window_prop_visible_icon_name_change(void *data,
- void *ev);
-static void _ecore_x_event_free_window_prop_client_machine_change(void *data,
- void *ev);
-#endif /* if 0 */
-
static Window _ecore_x_mouse_down_last_win = 0;
static Window _ecore_x_mouse_down_last_last_win = 0;
static Window _ecore_x_mouse_down_last_event_win = 0;
XChangeWindowAttributes(_ecore_x_disp, w, CWEventMask, &s_attr);
} /* ecore_x_event_mask_unset */
-#if 0
-static void
-_ecore_x_event_free_window_prop_name_class_change(void *data, void *ev)
-{
- Ecore_X_Event_Window_Prop_Name_Class_Change *e;
-
- e = ev;
- if (e->name)
- free(e->name);
-
- if (e->clas)
- free(e->clas);
-
- free(e);
-} /* _ecore_x_event_free_window_prop_name_class_change */
-
-static void
-_ecore_x_event_free_window_prop_title_change(void *data, void *ev)
-{
- Ecore_X_Event_Window_Prop_Title_Change *e;
-
- e = ev;
- if (e->title)
- free(e->title);
-
- free(e);
-} /* _ecore_x_event_free_window_prop_title_change */
-
-static void
-_ecore_x_event_free_window_prop_visible_title_change(void *data, void *ev)
-{
- Ecore_X_Event_Window_Prop_Visible_Title_Change *e;
-
- e = ev;
- if (e->title)
- free(e->title);
-
- free(e);
-} /* _ecore_x_event_free_window_prop_visible_title_change */
-
-static void
-_ecore_x_event_free_window_prop_icon_name_change(void *data, void *ev)
-{
- Ecore_X_Event_Window_Prop_Icon_Name_Change *e;
-
- e = ev;
- if (e->name)
- free(e->name);
-
- free(e);
-} /* _ecore_x_event_free_window_prop_icon_name_change */
-
-static void
-_ecore_x_event_free_window_prop_visible_icon_name_change(void *data, void *ev)
-{
- Ecore_X_Event_Window_Prop_Visible_Icon_Name_Change *e;
-
- e = ev;
- if (e->name)
- free(e->name);
-
- free(e);
-} /* _ecore_x_event_free_window_prop_visible_icon_name_change */
-
-static void
-_ecore_x_event_free_window_prop_client_machine_change(void *data, void *ev)
-{
- Ecore_X_Event_Window_Prop_Client_Machine_Change *e;
-
- e = ev;
- if (e->name)
- free(e->name);
-
- free(e);
-} /* _ecore_x_event_free_window_prop_client_machine_change */
-
-#endif /* if 0 */
-
static void
_ecore_x_event_free_xdnd_enter(void *data __UNUSED__, void *ev)
{
_ecore_x_event_handle_property_notify(XEvent *xevent)
{
_ecore_x_last_event_mouse_move = 0;
-#if 0 /* for now i disabled this. nice idea though this is - it leaves a lot
- * to be desired for efficiency that is better left to the app layer
- */
- if (xevent->xproperty.atom == ECORE_X_ATOM_WM_CLASS)
- {
- Ecore_X_Event_Window_Prop_Name_Class_Change *e;
-
- e = calloc(1, sizeof(Ecore_X_Event_Window_Prop_Name_Class_Change));
- if (!e)
- return;
-
- ecore_x_window_prop_name_class_get(xevent->xproperty.window,
- &(e->name), &(e->clas));
- e->time = xevent->xproperty.time;
- _ecore_x_event_last_time = e->time;
- ecore_event_add(ECORE_X_EVENT_WINDOW_PROP_NAME_CLASS_CHANGE, e,
- _ecore_x_event_free_window_prop_name_class_change, NULL);
- }
- else if ((xevent->xproperty.atom == ECORE_X_ATOM_WM_NAME) ||
- (xevent->xproperty.atom == ECORE_X_ATOM_NET_WM_NAME))
- {
- Ecore_X_Event_Window_Prop_Title_Change *e;
-
- e = calloc(1, sizeof(Ecore_X_Event_Window_Prop_Title_Change));
- if (!e)
- return;
-
- e->title = ecore_x_window_prop_title_get(xevent->xproperty.window);
- e->time = xevent->xproperty.time;
- _ecore_x_event_last_time = e->time;
- ecore_event_add(ECORE_X_EVENT_WINDOW_PROP_TITLE_CHANGE, e,
- _ecore_x_event_free_window_prop_title_change, NULL);
- }
- else if (xevent->xproperty.atom == ECORE_X_ATOM_NET_WM_VISIBLE_NAME)
- {
- Ecore_X_Event_Window_Prop_Visible_Title_Change *e;
-
- e = calloc(1, sizeof(Ecore_X_Event_Window_Prop_Visible_Title_Change));
- if (!e)
- return;
-
- e->title = ecore_x_window_prop_visible_title_get(
- xevent->xproperty.window);
- e->time = xevent->xproperty.time;
- _ecore_x_event_last_time = e->time;
- ecore_event_add(ECORE_X_EVENT_WINDOW_PROP_VISIBLE_TITLE_CHANGE,
- e,
- _ecore_x_event_free_window_prop_visible_title_change,
- NULL);
- }
- else if ((xevent->xproperty.atom == ECORE_X_ATOM_WM_ICON_NAME) ||
- (xevent->xproperty.atom == ECORE_X_ATOM_NET_WM_ICON_NAME))
- {
- Ecore_X_Event_Window_Prop_Icon_Name_Change *e;
-
- e = calloc(1, sizeof(Ecore_X_Event_Window_Prop_Icon_Name_Change));
- if (!e)
- return;
-
- e->name = ecore_x_window_prop_icon_name_get(xevent->xproperty.window);
- e->time = xevent->xproperty.time;
- _ecore_x_event_last_time = e->time;
- ecore_event_add(ECORE_X_EVENT_WINDOW_PROP_ICON_NAME_CHANGE, e,
- _ecore_x_event_free_window_prop_icon_name_change, NULL);
- }
- else if (xevent->xproperty.atom == ECORE_X_ATOM_NET_WM_VISIBLE_ICON_NAME)
- {
- Ecore_X_Event_Window_Prop_Visible_Icon_Name_Change *e;
-
- e = calloc(1, sizeof(Ecore_X_Event_Window_Prop_Visible_Icon_Name_Change));
- if (!e)
- return;
-
- e->name = ecore_x_window_prop_visible_icon_name_get(
- xevent->xproperty.window);
- e->time = xevent->xproperty.time;
- _ecore_x_event_last_time = e->time;
- ecore_event_add(
- ECORE_X_EVENT_WINDOW_PROP_VISIBLE_ICON_NAME_CHANGE,
- e,
- _ecore_x_event_free_window_prop_visible_icon_name_change,
- NULL);
- }
- else if (xevent->xproperty.atom == ECORE_X_ATOM_WM_CLIENT_MACHINE)
- {
- Ecore_X_Event_Window_Prop_Client_Machine_Change *e;
-
- e = calloc(1, sizeof(Ecore_X_Event_Window_Prop_Client_Machine_Change));
- if (!e)
- return;
-
- e->name = ecore_x_window_prop_client_machine_get(
- xevent->xproperty.window);
- e->time = xevent->xproperty.time;
- _ecore_x_event_last_time = e->time;
- ecore_event_add(ECORE_X_EVENT_WINDOW_PROP_CLIENT_MACHINE_CHANGE,
- e,
- _ecore_x_event_free_window_prop_client_machine_change,
- NULL);
- }
- else if (xevent->xproperty.atom == ECORE_X_ATOM_NET_WM_PID)
- {
- Ecore_X_Event_Window_Prop_Pid_Change *e;
-
- e = calloc(1, sizeof(Ecore_X_Event_Window_Prop_Pid_Change));
- if (!e)
- return;
-
- e->pid = ecore_x_window_prop_pid_get(xevent->xproperty.window);
- e->time = xevent->xproperty.time;
- _ecore_x_event_last_time = e->time;
- ecore_event_add(ECORE_X_EVENT_WINDOW_PROP_PID_CHANGE, e, NULL, NULL);
- }
- else if (xevent->xproperty.atom == ECORE_X_ATOM_NET_WM_DESKTOP)
- {
- Ecore_X_Event_Window_Prop_Desktop_Change *e;
-
- e = calloc(1, sizeof(Ecore_X_Event_Window_Prop_Desktop_Change));
- if (!e)
- return;
-
- e->desktop = ecore_x_window_prop_desktop_get(xevent->xproperty.window);
- ecore_event_add(ECORE_X_EVENT_WINDOW_PROP_PID_CHANGE, e, NULL, NULL);
- }
- else
-#endif /* if 0 */
{
Ecore_X_Event_Window_Property *e;
e->cmap = xevent->xcolormap.colormap;
e->time = _ecore_x_event_last_time;
if (xevent->xcolormap.state == ColormapInstalled)
- e->installed = 1;
+ e->installed = EINA_TRUE;
else
- e->installed = 0;
+ e->installed = EINA_FALSE;
ecore_event_add(ECORE_X_EVENT_WINDOW_COLORMAP, e, NULL, NULL);
} /* _ecore_x_event_handle_colormap_notify */
{
Ecore_X_Event_Xdnd_Finished *e;
Ecore_X_DND_Source *source;
- int completed = 1;
+ Eina_Bool completed = EINA_TRUE;
LOGFN(__FILE__, __LINE__, __FUNCTION__);
source = _ecore_x_dnd_source_get();
}
else if (source->version >= 5)
{
- completed = 0;
+ completed = EINA_FALSE;
source->state = ECORE_X_DND_SOURCE_CONVERTING;
/* FIXME: Probably need to add a timer to switch back to idle
void
_ecore_x_event_handle_mapping_notify(XEvent *xevent)
{
+ Ecore_X_Event_Mapping_Change *e;
+
_ecore_x_last_event_mouse_move = 0;
XRefreshKeyboardMapping((XMappingEvent *)xevent);
+ e = calloc(1, sizeof(Ecore_X_Event_Mapping_Change));
+ if (!e) return;
+ switch (xevent->xmapping.request)
+ {
+ case MappingModifier:
+ e->type = ECORE_X_MAPPING_MODIFIER;
+ break;
+ case MappingKeyboard:
+ e->type = ECORE_X_MAPPING_KEYBOARD;
+ break;
+ case MappingPointer:
+ default:
+ e->type = ECORE_X_MAPPING_MOUSE;
+ break;
+ }
+ e->keycode = xevent->xmapping.first_keycode;
+ e->num = xevent->xmapping.count;
+ ecore_event_add(ECORE_X_EVENT_MAPPING_CHANGE, e, NULL, NULL);
} /* _ecore_x_event_handle_mapping_notify */
void
e->win = screensaver_event->window;
if (screensaver_event->state == ScreenSaverOn)
- e->on = 1;
+ e->on = EINA_TRUE;
else
- e->on = 0;
+ e->on = EINA_FALSE;
e->time = screensaver_event->time;
ecore_event_add(ECORE_X_EVENT_SCREENSAVER_NOTIFY, e, NULL, NULL);
e->output = randr_event->output;
e->property = randr_event->property;
e->time = randr_event->timestamp;
- e->state = randr_event->state;
+ if (randr_event->state == PropertyNewValue)
+ e->state = ECORE_X_RANDR_PROPERTY_CHANGE_ADD;
+ else
+ e->state = ECORE_X_RANDR_PROPERTY_CHANGE_DEL;
ecore_event_add(ECORE_X_EVENT_RANDR_OUTPUT_PROPERTY_NOTIFY, e, NULL, NULL);
} /* _ecore_x_event_handle_randr_notify_output_property */
projects / framework / uifw / ecore.git / commitdiff