From ec27ceac2769165e0454d3bf7fce3df1d8b5b8cf Mon Sep 17 00:00:00 2001 From: Guilherme Iscaro Date: Wed, 30 Aug 2017 17:24:27 -0300 Subject: [PATCH] efl_net: Use the new Eina_Future API. --- src/lib/ecore_con/ecore_con_legacy.c | 75 ++++++++++++++++++---------- src/lib/ecore_con/efl_net_dialer_http.c | 45 ++++++++--------- src/lib/ecore_con/efl_net_dialer_ssl.c | 39 +++++++-------- src/lib/ecore_con/efl_net_dialer_tcp.c | 39 +++++++-------- src/lib/ecore_con/efl_net_dialer_udp.c | 39 +++++++-------- src/lib/ecore_con/efl_net_dialer_unix.c | 43 +++++++--------- src/lib/ecore_con/efl_net_dialer_websocket.c | 34 ++++++------- src/lib/ecore_con/efl_net_server_windows.c | 20 ++++---- 8 files changed, 168 insertions(+), 166 deletions(-) diff --git a/src/lib/ecore_con/ecore_con_legacy.c b/src/lib/ecore_con/ecore_con_legacy.c index 1cb007f..ade01e2 100644 --- a/src/lib/ecore_con/ecore_con_legacy.c +++ b/src/lib/ecore_con/ecore_con_legacy.c @@ -31,7 +31,7 @@ struct _Ecore_Con_Server Eo *dialer; Eo *server; struct { - Efl_Future *job; + Eina_Future *job; Eina_Binbuf *pending_send; /* until job is fulfilled, no dialer exists, * this binbuf allows immediate * ecore_con_server_send() in that situation */ @@ -71,7 +71,7 @@ struct _Ecore_Con_Client const void *data; Eina_Stringshare *ip; struct { - Efl_Future *job; + Eina_Future *job; Eo *ctx; Eina_Bool upgrading; } ssl; @@ -289,7 +289,7 @@ _ecore_con_client_free(Ecore_Con_Client *cl) cl->socket = NULL; } - if (cl->ssl.job) efl_future_cancel(cl->ssl.job); + if (cl->ssl.job) eina_future_cancel(cl->ssl.job); if (cl->ssl.ctx) { @@ -813,8 +813,9 @@ EFL_CALLBACKS_ARRAY_DEFINE(_ecore_con_client_socket_ssl_cbs, { EFL_NET_SOCKET_SSL_EVENT_SSL_READY, _ecore_con_client_socket_ssl_ready }, { EFL_NET_SOCKET_SSL_EVENT_SSL_ERROR, _ecore_con_client_socket_ssl_error }); -static void -_ecore_con_client_ssl_upgrade_job(void *data, const Efl_Event *event EINA_UNUSED) +static Eina_Value +_ecore_con_client_ssl_upgrade_job(void *data, const Eina_Value v, + const Eina_Future *dead EINA_UNUSED) { Ecore_Con_Client *cl = data; Eo *loop = ecore_main_loop_get(); @@ -822,6 +823,9 @@ _ecore_con_client_ssl_upgrade_job(void *data, const Efl_Event *event EINA_UNUSED Eo *socket; Eo *tcp_socket; + //Canceled + if (v.type == EINA_VALUE_TYPE_ERROR) return v; + tcp_socket = cl->socket; cl->socket = NULL; /* take it, will be wrapped */ @@ -852,7 +856,7 @@ _ecore_con_client_ssl_upgrade_job(void *data, const Efl_Event *event EINA_UNUSED efl_io_buffered_stream_inner_io_get(cl->socket), cl->ssl.ctx, tcp_socket); - return; + return v; error_socket: efl_del(inner_socket); @@ -860,10 +864,18 @@ _ecore_con_client_ssl_upgrade_job(void *data, const Efl_Event *event EINA_UNUSED cl->socket = tcp_socket; /* put it back */ if (_ecore_con_post_event_client_error(cl, "Couldn't finish SSL setup")) _ecore_con_post_event_client_del(cl); + return v; } static Eo * _ecore_con_server_ssl_ctx_create(const Ecore_Con_Server *svr); +static void +_ecore_con_server_job_schedule(Ecore_Con_Server *svr, Eo *loop, + Eina_Future_Cb cb) +{ + eina_future_then(efl_loop_Eina_FutureXXX_job(loop), cb, svr, &svr->ssl.job); +} + EAPI Eina_Bool ecore_con_ssl_client_upgrade(Ecore_Con_Client *cl, Ecore_Con_Type compl_type) { @@ -905,8 +917,9 @@ ecore_con_ssl_client_upgrade(Ecore_Con_Client *cl, Ecore_Con_Type compl_type) cl->ssl.upgrading = EINA_TRUE; cl->ssl.ctx = ssl_ctx; - efl_future_use(&cl->ssl.job, efl_loop_job(efl_loop_get(cl->socket), cl)); - efl_future_then(cl->ssl.job, _ecore_con_client_ssl_upgrade_job, NULL, NULL, cl); + + eina_future_then(efl_loop_Eina_FutureXXX_job(efl_loop_get(cl->socket)), + _ecore_con_client_ssl_upgrade_job, cl, &cl->ssl.job); DBG("cl=%p SSL upgrading from %#x to type=%#x", cl, svr->type, compl_type); @@ -981,7 +994,7 @@ _ecore_con_server_free(Ecore_Con_Server *svr) svr->ssl.clients_ctx = NULL; } - if (svr->ssl.job) efl_future_cancel(svr->ssl.job); + if (svr->ssl.job) eina_future_cancel(svr->ssl.job); if (svr->ssl.pending_send) { @@ -1591,8 +1604,9 @@ _ecore_con_server_ssl_ctx_create(const Ecore_Con_Server *svr) efl_net_ssl_context_setup(efl_added, cipher, EINA_FALSE)); } -static void -_ecore_con_server_server_ssl_job(void *data, const Efl_Event *event EINA_UNUSED) +static Eina_Value +_ecore_con_server_server_ssl_job(void *data, const Eina_Value v, + const Eina_Future *dead EINA_UNUSED) { Ecore_Con_Server *svr = data; Eo *loop = ecore_main_loop_get(); @@ -1600,6 +1614,8 @@ _ecore_con_server_server_ssl_job(void *data, const Efl_Event *event EINA_UNUSED) Eo *inner_server; Eo *server; + if (v.type == EINA_VALUE_TYPE_ERROR) return v; + ssl_ctx = _ecore_con_server_ssl_ctx_create(svr); EINA_SAFETY_ON_NULL_GOTO(ssl_ctx, error_ssl_ctx); @@ -1624,12 +1640,12 @@ _ecore_con_server_server_ssl_job(void *data, const Efl_Event *event EINA_UNUSED) efl_net_server_simple_inner_server_get(svr->server), efl_net_server_ssl_context_get(efl_net_server_simple_inner_server_get(svr->server))); - return; + return v; error_serve: if (_ecore_con_post_event_server_error(svr, "Couldn't serve using SSL")) _ecore_con_post_event_server_del(svr); - return; + return v; error_server: efl_del(inner_server); @@ -1638,6 +1654,7 @@ _ecore_con_server_server_ssl_job(void *data, const Efl_Event *event EINA_UNUSED) error_ssl_ctx: if (_ecore_con_post_event_server_error(svr, "Couldn't finish SSL setup")) _ecore_con_post_event_server_del(svr); + return v; } /** @@ -1725,8 +1742,7 @@ ecore_con_server_add(Ecore_Con_Type compl_type, * > against loaded certificates. */ svr->ssl.upgrade_type = compl_type; - efl_future_use(&svr->ssl.job, efl_loop_job(loop, svr)); - efl_future_then(svr->ssl.job, _ecore_con_server_server_ssl_job, NULL, NULL, svr); + _ecore_con_server_job_schedule(svr, loop, _ecore_con_server_server_ssl_job); return svr; } @@ -1921,8 +1937,9 @@ _ecore_con_server_dialer_set(Ecore_Con_Server *svr, Eo *dialer) return EINA_TRUE; } -static void -_ecore_con_server_dialer_ssl_job(void *data, const Efl_Event *event EINA_UNUSED) +static Eina_Value +_ecore_con_server_dialer_ssl_job(void *data, const Eina_Value v, + const Eina_Future *dead EINA_UNUSED) { Ecore_Con_Server *svr = data; Eo *loop = ecore_main_loop_get(); @@ -1993,12 +2010,12 @@ _ecore_con_server_dialer_ssl_job(void *data, const Efl_Event *event EINA_UNUSED) svr->ssl.pending_send = NULL; } - return; + return v; error_dial: if (_ecore_con_post_event_server_error(svr, "Couldn't dial using SSL")) _ecore_con_post_event_server_del(svr); - return; + return v; error_dialer: efl_del(inner_dialer); @@ -2007,10 +2024,12 @@ _ecore_con_server_dialer_ssl_job(void *data, const Efl_Event *event EINA_UNUSED) error_ssl_ctx: if (_ecore_con_post_event_server_error(svr, "Couldn't finish SSL setup")) _ecore_con_post_event_server_del(svr); + return v; } -static void -_ecore_con_server_dialer_ssl_upgrade_job(void *data, const Efl_Event *event EINA_UNUSED) +static Eina_Value +_ecore_con_server_dialer_ssl_upgrade_job(void *data, const Eina_Value v, + const Eina_Future *dead EINA_UNUSED) { Ecore_Con_Server *svr = data; Eo *loop = ecore_main_loop_get(); @@ -2022,6 +2041,9 @@ _ecore_con_server_dialer_ssl_upgrade_job(void *data, const Efl_Event *event EINA Efl_Net_Ssl_Verify_Mode verify_mode = EFL_NET_SSL_VERIFY_MODE_NONE; /* was the default */ Ecore_Con_Type ssl_type = svr->ssl.upgrade_type & ECORE_CON_SSL; + //Canceled + if (v.type == EINA_VALUE_TYPE_ERROR) return v; + if (ssl_type & ECORE_CON_USE_MIXED) cipher = EFL_NET_SSL_CIPHER_AUTO; else if (ssl_type & ECORE_CON_USE_TLS) @@ -2078,7 +2100,7 @@ _ecore_con_server_dialer_ssl_upgrade_job(void *data, const Efl_Event *event EINA efl_io_buffered_stream_inner_io_get(svr->dialer), efl_net_dialer_ssl_context_get(efl_io_buffered_stream_inner_io_get(svr->dialer)), tcp_dialer); - return; + return v; error_dialer: efl_del(inner_dialer); @@ -2088,6 +2110,7 @@ _ecore_con_server_dialer_ssl_upgrade_job(void *data, const Efl_Event *event EINA error_ssl_ctx: if (_ecore_con_post_event_server_error(svr, "Couldn't finish SSL setup")) _ecore_con_post_event_server_del(svr); + return v; } /** @@ -2174,8 +2197,7 @@ ecore_con_server_connect(Ecore_Con_Type compl_type, * > has started to enable verification of certificates * > against loaded certificates. */ - efl_future_use(&svr->ssl.job, efl_loop_job(loop, svr)); - efl_future_then(svr->ssl.job, _ecore_con_server_dialer_ssl_job, NULL, NULL, svr); + _ecore_con_server_job_schedule(svr, loop, _ecore_con_server_dialer_ssl_job); return svr; } @@ -2535,8 +2557,9 @@ ecore_con_ssl_server_upgrade(Ecore_Con_Server *svr, Ecore_Con_Type compl_type) svr->ssl.upgrading = EINA_TRUE; svr->ssl.upgrade_type = compl_type; - efl_future_use(&svr->ssl.job, efl_loop_job(efl_loop_get(svr->dialer), svr)); - efl_future_then(svr->ssl.job, _ecore_con_server_dialer_ssl_upgrade_job, NULL, NULL, svr); + + _ecore_con_server_job_schedule(svr, efl_loop_get(svr->dialer), + _ecore_con_server_dialer_ssl_upgrade_job); DBG("svr=%p SSL upgrading from %#x to type=%#x", svr, svr->type, compl_type); diff --git a/src/lib/ecore_con/efl_net_dialer_http.c b/src/lib/ecore_con/efl_net_dialer_http.c index 064c000..4d64a20 100644 --- a/src/lib/ecore_con/efl_net_dialer_http.c +++ b/src/lib/ecore_con/efl_net_dialer_http.c @@ -207,7 +207,7 @@ typedef struct Eina_Bool verify_peer; Eina_Bool verify_hostname; } ssl; - Efl_Future *pending_close; + Eina_Future *pending_close; unsigned int in_curl_callback; SOCKET fd; Eina_Error error; @@ -796,27 +796,28 @@ _efl_net_dialer_http_curl_safe_begin(Eo *o, Efl_Net_Dialer_Http_Data *pd) return pd->easy; } -static void -_efl_net_dialer_http_curl_cleanup(void *data, const Efl_Event *ev EINA_UNUSED) +static Eina_Value +_efl_net_dialer_http_curl_cleanup(void *data, const Eina_Value v) { CURL *easy = data; DBG("cleanup curl=%p", easy); curl_easy_cleanup(easy); + return v; } -static void -_efl_net_dialer_http_curl_cleanup_error(void *data, const Efl_Event *ev) +static Eina_Value +_efl_net_dialer_http_curl_cleanup_error(void *data, const Eina_Error err) { - Efl_Future_Event_Failure *failure = ev->info; CURL *easy = data; - DBG("cleanup curl=%p, promise error=%d '%s'", easy, failure->error, eina_error_msg_get(failure->error)); + DBG("cleanup curl=%p, promise error=%d '%s'", easy, err, eina_error_msg_get(err)); curl_easy_cleanup(easy); + return EINA_VALUE_EMPTY; } static void _efl_net_dialer_http_curl_safe_end(Eo *o, Efl_Net_Dialer_Http_Data *pd, CURL *easy) { - Efl_Future *f; + Eina_Future *f; int refs; refs = efl_ref_get(o); @@ -828,7 +829,7 @@ _efl_net_dialer_http_curl_safe_end(Eo *o, Efl_Net_Dialer_Http_Data *pd, CURL *ea } if (pd->pending_close) - efl_future_cancel(pd->pending_close); + eina_future_cancel(pd->pending_close); if (!pd->easy) { @@ -861,12 +862,10 @@ _efl_net_dialer_http_curl_safe_end(Eo *o, Efl_Net_Dialer_Http_Data *pd, CURL *ea /* object deleted from CURL callback, CURL* easy was * dissociated and we must delete it ourselves. */ - f = efl_loop_job(ecore_main_loop_get(), easy); - efl_future_then(f, - _efl_net_dialer_http_curl_cleanup, - _efl_net_dialer_http_curl_cleanup_error, - NULL, - easy); + f = efl_loop_Eina_FutureXXX_job(ecore_main_loop_get()); + eina_future_then_from_desc(f, eina_future_cb_easy(.success = _efl_net_dialer_http_curl_cleanup, + .error = _efl_net_dialer_http_curl_cleanup_error, + .data = easy)); DBG("dialer=%p deleted from CURL callback, cleanup curl from job=%p.", o, f); } @@ -1144,7 +1143,7 @@ _efl_net_dialer_http_efl_object_destructor(Eo *o, Efl_Net_Dialer_Http_Data *pd) } else if (pd->pending_close) { - efl_future_cancel(pd->pending_close); + eina_future_cancel(pd->pending_close); efl_event_freeze(o); efl_io_closer_close(o); efl_event_thaw(o); @@ -1704,7 +1703,7 @@ _efl_net_dialer_http_efl_io_writer_can_write_set(Eo *o, Efl_Net_Dialer_Http_Data efl_event_callback_call(o, EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED, NULL); } -static void _efl_net_dialer_http_pending_close(void *data, const Efl_Event *ev); +static Eina_Value _efl_net_dialer_http_pending_close(Eo *o, Eina_Value value); EOLIAN static Eina_Error _efl_net_dialer_http_efl_io_closer_close(Eo *o, Efl_Net_Dialer_Http_Data *pd) @@ -1719,8 +1718,9 @@ _efl_net_dialer_http_efl_io_closer_close(Eo *o, Efl_Net_Dialer_Http_Data *pd) { if ((!pd->pending_close) && (pd->easy)) { - efl_future_use(&pd->pending_close, efl_loop_job(efl_loop_get(o), o)); - efl_future_then(pd->pending_close, _efl_net_dialer_http_pending_close, NULL, NULL, o); + efl_future_Eina_FutureXXX_then(o, efl_loop_Eina_FutureXXX_job(efl_loop_get(o)), + .success = _efl_net_dialer_http_pending_close, + .storage = &pd->pending_close); DBG("dialer=%p closed from CURL callback, schedule close job=%p", o, pd->pending_close); } return 0; @@ -1751,14 +1751,13 @@ _efl_net_dialer_http_efl_io_closer_close(Eo *o, Efl_Net_Dialer_Http_Data *pd) return err; } -static void -_efl_net_dialer_http_pending_close(void *data, const Efl_Event *ev EINA_UNUSED) +static Eina_Value +_efl_net_dialer_http_pending_close(Eo *o, const Eina_Value value EINA_UNUSED) { - Eo *o = data; Efl_Net_Dialer_Http_Data *pd = efl_data_scope_get(o, MY_CLASS); - pd->pending_close = NULL; /* XXX TODO this should be NULL-ified by efl_promise before calling this function */ _efl_net_dialer_http_efl_io_closer_close(o, pd); + return value; } EOLIAN static Eina_Bool diff --git a/src/lib/ecore_con/efl_net_dialer_ssl.c b/src/lib/ecore_con/efl_net_dialer_ssl.c index d873434..6bdae46 100644 --- a/src/lib/ecore_con/efl_net_dialer_ssl.c +++ b/src/lib/ecore_con/efl_net_dialer_ssl.c @@ -34,7 +34,7 @@ typedef struct _Efl_Net_Dialer_Ssl_Data { Eo *sock; Eo *ssl_ctx; - Efl_Future *connect_timeout; + Eina_Future *connect_timeout; Eina_Bool connected; } Efl_Net_Dialer_Ssl_Data; @@ -136,16 +136,24 @@ _efl_net_dialer_ssl_ssl_context_get(Eo *o EINA_UNUSED, Efl_Net_Dialer_Ssl_Data * return pd->ssl_ctx; } -static void -_efl_net_dialer_ssl_connect_timeout(void *data, const Efl_Event *ev EINA_UNUSED) +static Eina_Value +_efl_net_dialer_ssl_connect_timeout(Eo *o, const Eina_Value v) { - Eo *o = data; Eina_Error err = ETIMEDOUT; efl_ref(o); efl_io_reader_eos_set(o, EINA_TRUE); efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err); efl_unref(o); + return v; +} + +static void +_timeout_schedule(Eo *o, Efl_Net_Dialer_Ssl_Data *pd, double timeout) +{ + efl_future_Eina_FutureXXX_then(o, efl_loop_Eina_FutureXXX_timeout(efl_loop_get(o), timeout), + .success = _efl_net_dialer_ssl_connect_timeout, + .storage = &pd->connect_timeout); } EOLIAN static Eina_Error @@ -157,16 +165,10 @@ _efl_net_dialer_ssl_efl_net_dialer_dial(Eo *o, Efl_Net_Dialer_Ssl_Data *pd, cons EINA_SAFETY_ON_TRUE_RETURN_VAL(efl_net_dialer_connected_get(o), EISCONN); EINA_SAFETY_ON_TRUE_RETURN_VAL(efl_io_closer_closed_get(o), EBADF); - if (pd->connect_timeout) - efl_future_cancel(pd->connect_timeout); + if (pd->connect_timeout) eina_future_cancel(pd->connect_timeout); timeout = efl_net_dialer_timeout_dial_get(pd->sock); - if (timeout > 0.0) - { - efl_future_use(&pd->connect_timeout, efl_loop_timeout(efl_loop_get(o), timeout, o)); - efl_future_then(pd->connect_timeout, _efl_net_dialer_ssl_connect_timeout, NULL, NULL, o); - efl_future_link(o, pd->connect_timeout); - } + if (timeout > 0.0) _timeout_schedule(o, pd, timeout); return efl_net_dialer_dial(pd->sock, address); } @@ -190,18 +192,13 @@ _efl_net_dialer_ssl_efl_net_dialer_proxy_get(Eo *o EINA_UNUSED, Efl_Net_Dialer_S } EOLIAN static void -_efl_net_dialer_ssl_efl_net_dialer_timeout_dial_set(Eo *o EINA_UNUSED, Efl_Net_Dialer_Ssl_Data *pd, double seconds) +_efl_net_dialer_ssl_efl_net_dialer_timeout_dial_set(Eo *o, Efl_Net_Dialer_Ssl_Data *pd, double seconds) { efl_net_dialer_timeout_dial_set(pd->sock, seconds); - if (pd->connect_timeout) - efl_future_cancel(pd->connect_timeout); + if (pd->connect_timeout) eina_future_cancel(pd->connect_timeout); - if ((seconds > 0.0) && (!pd->connected)) - { - efl_future_use(&pd->connect_timeout, efl_loop_timeout(efl_loop_get(o), seconds, o)); - efl_future_then(pd->connect_timeout, _efl_net_dialer_ssl_connect_timeout, NULL, NULL, o); - } + if ((seconds > 0.0) && (!pd->connected)) _timeout_schedule(o, pd, seconds); } EOLIAN static double @@ -214,7 +211,7 @@ EOLIAN static void _efl_net_dialer_ssl_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Ssl_Data *pd, Eina_Bool connected) { if (pd->connect_timeout) - efl_future_cancel(pd->connect_timeout); + eina_future_cancel(pd->connect_timeout); if (pd->connected == connected) return; pd->connected = connected; if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL); diff --git a/src/lib/ecore_con/efl_net_dialer_tcp.c b/src/lib/ecore_con/efl_net_dialer_tcp.c index 8806cc3..a9d87cf 100644 --- a/src/lib/ecore_con/efl_net_dialer_tcp.c +++ b/src/lib/ecore_con/efl_net_dialer_tcp.c @@ -34,7 +34,7 @@ typedef struct _Efl_Net_Dialer_Tcp_Data { struct { Ecore_Thread *thread; - Efl_Future *timeout; + Eina_Future *timeout; } connect; Eina_Stringshare *address_dial; Eina_Stringshare *proxy; @@ -75,10 +75,9 @@ _efl_net_dialer_tcp_efl_object_destructor(Eo *o, Efl_Net_Dialer_Tcp_Data *pd) eina_stringshare_replace(&pd->proxy, NULL); } -static void -_efl_net_dialer_tcp_connect_timeout(void *data, const Efl_Event *ev EINA_UNUSED) +static Eina_Value +_efl_net_dialer_tcp_connect_timeout(Eo *o, const Eina_Value v) { - Eo *o = data; Efl_Net_Dialer_Tcp_Data *pd = efl_data_scope_get(o, MY_CLASS); Eina_Error err = ETIMEDOUT; @@ -92,6 +91,15 @@ _efl_net_dialer_tcp_connect_timeout(void *data, const Efl_Event *ev EINA_UNUSED) efl_io_reader_eos_set(o, EINA_TRUE); efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err); efl_unref(o); + return v; +} + +static void +_timeout_schedule(Eo *o, Efl_Net_Dialer_Tcp_Data *pd) +{ + efl_future_Eina_FutureXXX_then(o, efl_loop_Eina_FutureXXX_timeout(efl_loop_get(o), pd->timeout_dial), + .success = _efl_net_dialer_tcp_connect_timeout, + .storage = &pd->connect.timeout); } static void @@ -179,14 +187,8 @@ _efl_net_dialer_tcp_efl_net_dialer_dial(Eo *o, Efl_Net_Dialer_Tcp_Data *pd EINA_ efl_net_dialer_address_dial_set(o, address); - if (pd->connect.timeout) - efl_future_cancel(pd->connect.timeout); - if (pd->timeout_dial > 0.0) - { - efl_future_use(&pd->connect.timeout, efl_loop_timeout(efl_loop_get(o), pd->timeout_dial, o)); - efl_future_then(pd->connect.timeout, _efl_net_dialer_tcp_connect_timeout, NULL, NULL, o); - efl_future_link(o, pd->connect.timeout); - } + if (pd->connect.timeout) eina_future_cancel(pd->connect.timeout); + if (pd->timeout_dial > 0.0) _timeout_schedule(o, pd); return 0; } @@ -219,14 +221,8 @@ EOLIAN static void _efl_net_dialer_tcp_efl_net_dialer_timeout_dial_set(Eo *o EINA_UNUSED, Efl_Net_Dialer_Tcp_Data *pd, double seconds) { pd->timeout_dial = seconds; - if (pd->connect.timeout) - efl_future_cancel(pd->connect.timeout); - - if ((pd->timeout_dial > 0.0) && (pd->connect.thread)) - { - efl_future_use(&pd->connect.timeout, efl_loop_timeout(efl_loop_get(o), pd->timeout_dial, o)); - efl_future_then(pd->connect.timeout, _efl_net_dialer_tcp_connect_timeout, NULL, NULL, o); - } + if (pd->connect.timeout) eina_future_cancel(pd->connect.timeout); + if ((pd->timeout_dial > 0.0) && (pd->connect.thread)) _timeout_schedule(o, pd); } EOLIAN static double @@ -238,8 +234,7 @@ _efl_net_dialer_tcp_efl_net_dialer_timeout_dial_get(Eo *o EINA_UNUSED, Efl_Net_D EOLIAN static void _efl_net_dialer_tcp_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Tcp_Data *pd, Eina_Bool connected) { - if (pd->connect.timeout) - efl_future_cancel(pd->connect.timeout); + if (pd->connect.timeout) eina_future_cancel(pd->connect.timeout); if (pd->connected == connected) return; pd->connected = connected; if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL); diff --git a/src/lib/ecore_con/efl_net_dialer_udp.c b/src/lib/ecore_con/efl_net_dialer_udp.c index c85c770..bd2bf7e 100644 --- a/src/lib/ecore_con/efl_net_dialer_udp.c +++ b/src/lib/ecore_con/efl_net_dialer_udp.c @@ -35,7 +35,7 @@ typedef struct _Efl_Net_Dialer_Udp_Data { struct { Ecore_Thread *thread; - Efl_Future *timeout; + Eina_Future *timeout; } resolver; Eina_Stringshare *address_dial; Eina_Bool connected; @@ -75,10 +75,9 @@ _efl_net_dialer_udp_efl_object_destructor(Eo *o, Efl_Net_Dialer_Udp_Data *pd) eina_stringshare_replace(&pd->address_dial, NULL); } -static void -_efl_net_dialer_udp_resolver_timeout(void *data, const Efl_Event *ev EINA_UNUSED) +static Eina_Value +_efl_net_dialer_udp_resolver_timeout(Eo *o, const Eina_Value v) { - Eo *o = data; Efl_Net_Dialer_Udp_Data *pd = efl_data_scope_get(o, MY_CLASS); Eina_Error err = ETIMEDOUT; @@ -92,6 +91,15 @@ _efl_net_dialer_udp_resolver_timeout(void *data, const Efl_Event *ev EINA_UNUSED efl_io_reader_eos_set(o, EINA_TRUE); efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err); efl_unref(o); + return v; +} + +static void +_timeout_schedule(Eo *o, Efl_Net_Dialer_Udp_Data *pd) +{ + efl_future_Eina_FutureXXX_then(o, efl_loop_Eina_FutureXXX_timeout(efl_loop_get(o), pd->timeout_dial), + .success = _efl_net_dialer_udp_resolver_timeout, + .storage = &pd->resolver.timeout); } static Eina_Error @@ -267,14 +275,8 @@ _efl_net_dialer_udp_efl_net_dialer_dial(Eo *o, Efl_Net_Dialer_Udp_Data *pd EINA_ efl_net_dialer_address_dial_set(o, address); - if (pd->resolver.timeout) - efl_future_cancel(pd->resolver.timeout); - if (pd->timeout_dial > 0.0) - { - efl_future_use(&pd->resolver.timeout, efl_loop_timeout(efl_loop_get(o), pd->timeout_dial, o)); - efl_future_then(pd->resolver.timeout, _efl_net_dialer_udp_resolver_timeout, NULL, NULL, o); - efl_future_link(o, pd->resolver.timeout); - } + if (pd->resolver.timeout) eina_future_cancel(pd->resolver.timeout); + if (pd->timeout_dial > 0.0) _timeout_schedule(o, pd); return 0; } @@ -295,14 +297,8 @@ EOLIAN static void _efl_net_dialer_udp_efl_net_dialer_timeout_dial_set(Eo *o EINA_UNUSED, Efl_Net_Dialer_Udp_Data *pd, double seconds) { pd->timeout_dial = seconds; - if (pd->resolver.timeout) - efl_future_cancel(pd->resolver.timeout); - - if ((pd->timeout_dial > 0.0) && (pd->resolver.thread)) - { - efl_future_use(&pd->resolver.timeout, efl_loop_timeout(efl_loop_get(o), pd->timeout_dial, o)); - efl_future_then(pd->resolver.timeout, _efl_net_dialer_udp_resolver_timeout, NULL, NULL, o); - } + if (pd->resolver.timeout) eina_future_cancel(pd->resolver.timeout); + if ((pd->timeout_dial > 0.0) && (pd->resolver.thread)) _timeout_schedule(o, pd); } EOLIAN static double @@ -314,8 +310,7 @@ _efl_net_dialer_udp_efl_net_dialer_timeout_dial_get(Eo *o EINA_UNUSED, Efl_Net_D EOLIAN static void _efl_net_dialer_udp_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Udp_Data *pd, Eina_Bool connected) { - if (pd->resolver.timeout) - efl_future_cancel(pd->resolver.timeout); + if (pd->resolver.timeout) eina_future_cancel(pd->resolver.timeout); if (pd->connected == connected) return; pd->connected = connected; if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL); diff --git a/src/lib/ecore_con/efl_net_dialer_unix.c b/src/lib/ecore_con/efl_net_dialer_unix.c index 0493ff2..8a1db4b 100644 --- a/src/lib/ecore_con/efl_net_dialer_unix.c +++ b/src/lib/ecore_con/efl_net_dialer_unix.c @@ -25,9 +25,8 @@ typedef struct _Efl_Net_Dialer_Unix_Data { struct { Ecore_Thread *thread; - Efl_Future *timeout; + Eina_Future *timeout; } connect; - Efl_Future *connect_job; Eina_Stringshare *address_dial; Eina_Bool connected; double timeout_dial; @@ -65,10 +64,9 @@ _efl_net_dialer_unix_efl_object_destructor(Eo *o, Efl_Net_Dialer_Unix_Data *pd) eina_stringshare_replace(&pd->address_dial, NULL); } -static void -_efl_net_dialer_unix_connect_timeout(void *data, const Efl_Event *ev EINA_UNUSED) +static Eina_Value +_efl_net_dialer_unix_connect_timeout(Eo *o, const Eina_Value v) { - Eo *o = data; Efl_Net_Dialer_Unix_Data *pd = efl_data_scope_get(o, MY_CLASS); Eina_Error err = ETIMEDOUT; @@ -82,6 +80,7 @@ _efl_net_dialer_unix_connect_timeout(void *data, const Efl_Event *ev EINA_UNUSED efl_io_reader_eos_set(o, EINA_TRUE); efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err); efl_unref(o); + return v; } static void @@ -121,8 +120,16 @@ _efl_net_dialer_unix_connected(void *data, const struct sockaddr *addr, socklen_ efl_unref(o); } +static void +_timeout_schedule(Eo *o, Efl_Net_Dialer_Unix_Data *pd) +{ + efl_future_Eina_FutureXXX_then(o, efl_loop_Eina_FutureXXX_timeout(efl_loop_get(o), pd->timeout_dial), + .success = _efl_net_dialer_unix_connect_timeout, + .storage = &pd->connect.timeout); +} + EOLIAN static Eina_Error -_efl_net_dialer_unix_efl_net_dialer_dial(Eo *o, Efl_Net_Dialer_Unix_Data *pd EINA_UNUSED, const char *address) +_efl_net_dialer_unix_efl_net_dialer_dial(Eo *o, Efl_Net_Dialer_Unix_Data *pd, const char *address) { struct sockaddr_un addr = { .sun_family = AF_UNIX }; socklen_t addrlen; @@ -170,14 +177,8 @@ _efl_net_dialer_unix_efl_net_dialer_dial(Eo *o, Efl_Net_Dialer_Unix_Data *pd EIN efl_net_dialer_address_dial_set(o, address); - if (pd->connect.timeout) - efl_future_cancel(pd->connect.timeout); - if (pd->timeout_dial > 0.0) - { - efl_future_use(&pd->connect.timeout, efl_loop_timeout(efl_loop_get(o), pd->timeout_dial, o)); - efl_future_then(pd->connect.timeout, _efl_net_dialer_unix_connect_timeout, NULL, NULL, o); - efl_future_link(o, pd->connect.timeout); - } + if (pd->connect.timeout) eina_future_cancel(pd->connect.timeout); + if (pd->timeout_dial > 0.0) _timeout_schedule(o, pd); return 0; } @@ -195,17 +196,12 @@ _efl_net_dialer_unix_efl_net_dialer_address_dial_get(Eo *o EINA_UNUSED, Efl_Net_ } EOLIAN static void -_efl_net_dialer_unix_efl_net_dialer_timeout_dial_set(Eo *o EINA_UNUSED, Efl_Net_Dialer_Unix_Data *pd, double seconds) +_efl_net_dialer_unix_efl_net_dialer_timeout_dial_set(Eo *o, Efl_Net_Dialer_Unix_Data *pd, double seconds) { pd->timeout_dial = seconds; - if (pd->connect.timeout) - efl_future_cancel(pd->connect.timeout); - if ((pd->timeout_dial > 0.0) && (pd->connect.thread)) - { - efl_future_use(&pd->connect.timeout, efl_loop_timeout(efl_loop_get(o), pd->timeout_dial, o)); - efl_future_then(pd->connect.timeout, _efl_net_dialer_unix_connect_timeout, NULL, NULL, o); - } + if (pd->connect.timeout) eina_future_cancel(pd->connect.timeout); + if ((pd->timeout_dial > 0.0) && (pd->connect.thread)) _timeout_schedule(o, pd); } EOLIAN static double @@ -217,8 +213,7 @@ _efl_net_dialer_unix_efl_net_dialer_timeout_dial_get(Eo *o EINA_UNUSED, Efl_Net_ EOLIAN static void _efl_net_dialer_unix_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Unix_Data *pd, Eina_Bool connected) { - if (pd->connect.timeout) - efl_future_cancel(pd->connect.timeout); + if (pd->connect.timeout) eina_future_cancel(pd->connect.timeout); if (pd->connected == connected) return; pd->connected = connected; if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL); diff --git a/src/lib/ecore_con/efl_net_dialer_websocket.c b/src/lib/ecore_con/efl_net_dialer_websocket.c index b0a9dc4..596f5b4 100644 --- a/src/lib/ecore_con/efl_net_dialer_websocket.c +++ b/src/lib/ecore_con/efl_net_dialer_websocket.c @@ -159,8 +159,8 @@ typedef struct _Efl_Net_Dialer_Websocket_Pending_Read { typedef struct _Efl_Net_Dialer_Websocket_Data { Eo *http; - Efl_Future *close_timeout; - Efl_Future *job; + Eina_Future *close_timeout; + Eina_Future *job; Eina_Stringshare *address_dial; /* must rewrite ws->http, wss->https */ Eina_Stringshare *address_remote; /* must rewrite ws->http, wss->https */ struct { @@ -544,7 +544,7 @@ _efl_net_dialer_websocket_job_dispatch_frame(Eo *o, Efl_Net_Dialer_Websocket_Dat else efl_event_callback_call(o, EFL_IO_CLOSER_EVENT_CLOSED, NULL); if (pd->close_timeout) - efl_future_cancel(pd->close_timeout); + eina_future_cancel(pd->close_timeout); break; } @@ -734,10 +734,9 @@ _efl_net_dialer_websocket_job_receive(Eo *o, Efl_Net_Dialer_Websocket_Data *pd) efl_unref(o); } -static void -_efl_net_dialer_websocket_job(void *data, const Efl_Event *ev EINA_UNUSED) +static Eina_Value +_efl_net_dialer_websocket_job(Eo *o, const Eina_Value v) { - Eo *o = data; Efl_Net_Dialer_Websocket_Data *pd = efl_data_scope_get(o, MY_CLASS); efl_ref(o); @@ -752,6 +751,7 @@ _efl_net_dialer_websocket_job(void *data, const Efl_Event *ev EINA_UNUSED) _efl_net_dialer_websocket_job_schedule(o, pd); efl_unref(o); + return v; } static void @@ -763,9 +763,10 @@ _efl_net_dialer_websocket_job_schedule(Eo *o, Efl_Net_Dialer_Websocket_Data *pd) loop = efl_loop_get(o); if (!loop) return; - efl_future_use(&pd->job, efl_loop_job(loop, o)); - efl_future_then(pd->job, _efl_net_dialer_websocket_job, NULL, NULL, o); - efl_future_link(o, pd->job); + + efl_future_Eina_FutureXXX_then(o, efl_loop_Eina_FutureXXX_job(loop), + .success = _efl_net_dialer_websocket_job, + .storage = &pd->job); } static void @@ -1479,13 +1480,12 @@ _efl_net_dialer_websocket_binary_send(Eo *o, Efl_Net_Dialer_Websocket_Data *pd, blob.mem, blob.len); } -static void -_efl_net_dialer_websocket_close_request_timeout(void *data, const Efl_Event *ev EINA_UNUSED) +static Eina_Value +_efl_net_dialer_websocket_close_request_timeout(Eo *o, const Eina_Value v) { - Eo *o = data; - DBG("server did not close the TCP socket, timeout"); efl_event_callback_call(o, EFL_IO_CLOSER_EVENT_CLOSED, NULL); + return v; } EOLIAN static void @@ -1497,11 +1497,11 @@ _efl_net_dialer_websocket_close_request(Eo *o, Efl_Net_Dialer_Websocket_Data *pd EINA_SAFETY_ON_TRUE_RETURN(pd->close_requested); if (pd->close_timeout) - efl_future_cancel(pd->close_timeout); + eina_future_cancel(pd->close_timeout); - efl_future_use(&pd->close_timeout, efl_loop_timeout(efl_loop_get(o), 2.0, o)); - efl_future_then(pd->close_timeout, _efl_net_dialer_websocket_close_request_timeout, NULL, NULL, o); - efl_future_link(o, pd->close_timeout); + efl_future_Eina_FutureXXX_then(o, efl_loop_Eina_FutureXXX_timeout(efl_loop_get(o), 2.0), + .success = _efl_net_dialer_websocket_close_request_timeout, + .storage = &pd->close_timeout); efl_io_writer_can_write_set(o, EINA_FALSE); diff --git a/src/lib/ecore_con/efl_net_server_windows.c b/src/lib/ecore_con/efl_net_server_windows.c index 832782c..d588f77 100644 --- a/src/lib/ecore_con/efl_net_server_windows.c +++ b/src/lib/ecore_con/efl_net_server_windows.c @@ -34,7 +34,7 @@ typedef struct _Efl_Net_Server_Windows_Data Eina_List *pending_clients; Eina_Stringshare *address; /* includes prefix: \\.\pipe\, returned without it */ - Efl_Future *pending_announcer_job; + Eina_Future *pending_announcer_job; unsigned int clients_count; unsigned int clients_limit; Eina_Bool clients_reject_excess; @@ -316,22 +316,20 @@ _efl_net_server_windows_efl_net_server_address_get(Eo *o EINA_UNUSED, Efl_Net_Se return pd->address + strlen(PIPE_NS); } -static void -_efl_net_server_windows_pending_announce_job(void *data, const Efl_Event *ev EINA_UNUSED) +static Eina_Value +_efl_net_server_windows_pending_announce_job(Eo *o, const Eina_Value v) { - Eo *o = data; Efl_Net_Server_Windows_Data *pd = efl_data_scope_get(o, MY_CLASS); Eo *client; - pd->pending_announcer_job = NULL; - - if (!pd->pending_clients) return; - if ((pd->clients_limit > 0) && (pd->clients_limit <= pd->clients_count)) return; + if (!pd->pending_clients) return v; + if ((pd->clients_limit > 0) && (pd->clients_limit <= pd->clients_count)) return v; client = pd->pending_clients->data; pd->pending_clients = eina_list_remove_list(pd->pending_clients, pd->pending_clients); efl_net_server_client_announce(o, client); + return v; } static void @@ -345,9 +343,9 @@ _efl_net_server_windows_pending_announce_job_schedule(Eo *o, Efl_Net_Server_Wind loop = efl_loop_get(o); if (!loop) return; - efl_future_use(&pd->pending_announcer_job, efl_loop_job(loop, o)); - efl_future_then(pd->pending_announcer_job, _efl_net_server_windows_pending_announce_job, NULL, NULL, o); - efl_future_link(o, pd->pending_announcer_job); + efl_future_Eina_FutureXXX_then(o, efl_loop_Eina_FutureXXX_job(loop), + .success = _efl_net_server_windows_pending_announce_job, + .storage = &pd->pending_announcer_job); } EOLIAN static void -- 2.7.4