enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 3 Projects Releases Wiki Activity

efl-net: namespace events to avoid naming conflicts 

Reviewed-by: Cedric BAIL <cedric.bail@free.fr>
Differential Revision: https://phab.enlightenment.org/D8260
This commit is contained in:
Mike Blumenkrantz 2019-03-08 10:47:32 -05:00 committed by Cedric BAIL
parent 1d1effea90
commit 36661a436e
36 changed files with 94 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/bin/eeze/eeze_scanner/eeze_scanner.c
View File

@ -513,7 +513,7 @@ main(void)
}
efl_event_callback_add(server, EFL_NET_SERVER_EVENT_CLIENT_ADD, cl_add, NULL);
efl_event_callback_add(server, EFL_NET_SERVER_EVENT_ERROR, server_error, NULL);
efl_event_callback_add(server, EFL_NET_SERVER_EVENT_SERVER_ERROR, server_error, NULL);
#ifdef EFL_NET_SERVER_UNIX_CLASS
{

4
src/bin/efl/efl_debugd.c
View File

@ -570,7 +570,7 @@ _local_server_create(void)
}
efl_event_callback_add(_local_server, EFL_NET_SERVER_EVENT_CLIENT_ADD, _client_add, NULL);
efl_event_callback_add(_local_server, EFL_NET_SERVER_EVENT_ERROR, _error, NULL);
efl_event_callback_add(_local_server, EFL_NET_SERVER_EVENT_SERVER_ERROR, _error, NULL);
#ifdef EFL_NET_SERVER_UNIX_CLASS
{
@ -620,7 +620,7 @@ _remote_server_create(void)
efl_net_server_fd_reuse_address_set(inner_server, EINA_TRUE);
}
efl_event_callback_add(_remote_server, EFL_NET_SERVER_EVENT_CLIENT_ADD, _client_add, NULL);
efl_event_callback_add(_remote_server, EFL_NET_SERVER_EVENT_ERROR, _error, NULL);
efl_event_callback_add(_remote_server, EFL_NET_SERVER_EVENT_SERVER_ERROR, _error, NULL);
sprintf(address, "127.0.0.1:%d", REMOTE_SERVER_PORT);
err = efl_net_server_serve(_remote_server, address);

2
src/examples/ecore/efl_io_buffered_stream_example.c
View File

@ -236,7 +236,7 @@ efl_main(void *data EINA_UNUSED,
/* The TCP client to use to send/receive network data */
dialer = efl_add(EFL_NET_DIALER_TCP_CLASS, ev->object,
efl_name_set(efl_added, "dialer"),
efl_event_callback_add(efl_added, EFL_NET_DIALER_EVENT_CONNECTED, _dialer_connected, NULL));
efl_event_callback_add(efl_added, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _dialer_connected, NULL));
if (!dialer)
{
fprintf(stderr, "ERROR: could not create Efl_Net_Dialer_Tcp\n");

6
src/examples/ecore/efl_io_copier_example.c
View File

@ -77,9 +77,9 @@ _dialer_connected(void *data EINA_UNUSED, const Efl_Event *event)
}
EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
{ EFL_NET_DIALER_EVENT_RESOLVED, _dialer_resolved },
{ EFL_NET_DIALER_EVENT_ERROR, _dialer_error },
{ EFL_NET_DIALER_EVENT_CONNECTED, _dialer_connected });
{ EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _dialer_resolved },
{ EFL_NET_DIALER_EVENT_DIALER_ERROR, _dialer_error },
{ EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _dialer_connected });
static void
_http_headers_done(void *data EINA_UNUSED, const Efl_Event *event)

2
src/examples/ecore/efl_io_queue_example.c
View File

@ -305,7 +305,7 @@ efl_main(void *data EINA_UNUSED,
/* The TCP client to use to send/receive network data */
dialer = efl_add(EFL_NET_DIALER_TCP_CLASS, loop,
efl_name_set(efl_added, "dialer"),
efl_event_callback_add(efl_added, EFL_NET_DIALER_EVENT_CONNECTED, _dialer_connected, NULL));
efl_event_callback_add(efl_added, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _dialer_connected, NULL));
if (!dialer)
{
fprintf(stderr, "ERROR: could not create Efl_Net_Dialer_Tcp\n");

6
src/examples/ecore/efl_net_dialer_http_example.c
View File

@ -71,9 +71,9 @@ _http_headers_done(void *data EINA_UNUSED, const Efl_Event *event)
EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
{ EFL_NET_DIALER_HTTP_EVENT_HEADERS_DONE, _http_headers_done },
{ EFL_NET_DIALER_EVENT_CONNECTED, _connected },
{ EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
{ EFL_NET_DIALER_EVENT_ERROR, _error },
{ EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
{ EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
{ EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
{ EFL_IO_CLOSER_EVENT_CLOSED, _closed },
{ EFL_IO_READER_EVENT_EOS, _eos });

4
src/examples/ecore/efl_net_dialer_simple_example.c
View File

@ -176,8 +176,8 @@ _done(void *data EINA_UNUSED, const Efl_Event *event)
}
EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
{ EFL_NET_DIALER_EVENT_CONNECTED, _connected }, /* optional */
{ EFL_NET_DIALER_EVENT_RESOLVED, _resolved }, /* optional */
{ EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected }, /* optional */
{ EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved }, /* optional */
{ EFL_IO_READER_EVENT_CAN_READ_CHANGED, _can_read }, /* optional, can be used to read data, here just for monitoring */
{ EFL_IO_READER_EVENT_EOS, _eos }, /* recommended, notifies no more incoming data */
{ EFL_IO_BUFFERED_STREAM_EVENT_LINE, _line }, /* optional, could use 'slice,changed' or 'can_read,changed' instead */

6
src/examples/ecore/efl_net_dialer_udp_example.c
View File

@ -156,9 +156,9 @@ _error(void *data EINA_UNUSED, const Efl_Event *event)
}
EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
{ EFL_NET_DIALER_EVENT_CONNECTED, _connected },
{ EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
{ EFL_NET_DIALER_EVENT_ERROR, _error },
{ EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
{ EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
{ EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
{ EFL_IO_READER_EVENT_CAN_READ_CHANGED, _can_read },
{ EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED, _can_write }
);

6
src/examples/ecore/efl_net_dialer_unix_example.c
View File

@ -108,9 +108,9 @@ _error(void *data EINA_UNUSED, const Efl_Event *event)
}
EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
{ EFL_NET_DIALER_EVENT_CONNECTED, _connected },
{ EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
{ EFL_NET_DIALER_EVENT_ERROR, _error },
{ EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
{ EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
{ EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
{ EFL_IO_READER_EVENT_EOS, _eos },
{ EFL_IO_READER_EVENT_CAN_READ_CHANGED, _can_read },
{ EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED, _can_write }

4
src/examples/ecore/efl_net_dialer_websocket_autobahntestee.c
View File

@ -247,8 +247,8 @@ EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
{ EFL_NET_DIALER_WEBSOCKET_EVENT_CLOSED_REASON, _ws_closed_reason },
{ EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_TEXT, _ws_message_text },
{ EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_BINARY, _ws_message_binary },
{ EFL_NET_DIALER_EVENT_CONNECTED, _connected },
{ EFL_NET_DIALER_EVENT_ERROR, _error },
{ EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
{ EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
{ EFL_IO_CLOSER_EVENT_CLOSED, _closed },
{ EFL_IO_READER_EVENT_EOS, _eos },
{ EFL_EVENT_DEL, _del });

6
src/examples/ecore/efl_net_dialer_websocket_example.c
View File

@ -145,9 +145,9 @@ EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
{ EFL_NET_DIALER_WEBSOCKET_EVENT_CLOSED_REASON, _ws_closed_reason },
{ EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_TEXT, _ws_message_text },
{ EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_BINARY, _ws_message_binary },
{ EFL_NET_DIALER_EVENT_CONNECTED, _connected },
{ EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
{ EFL_NET_DIALER_EVENT_ERROR, _error },
{ EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
{ EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
{ EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
{ EFL_IO_CLOSER_EVENT_CLOSED, _closed },
{ EFL_IO_READER_EVENT_EOS, _eos });

6
src/examples/ecore/efl_net_dialer_windows_example.c
View File

@ -106,9 +106,9 @@ _error(void *data EINA_UNUSED, const Efl_Event *event)
}
EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
{ EFL_NET_DIALER_EVENT_CONNECTED, _connected },
{ EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
{ EFL_NET_DIALER_EVENT_ERROR, _error },
{ EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
{ EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
{ EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
{ EFL_IO_READER_EVENT_EOS, _eos },
{ EFL_IO_READER_EVENT_CAN_READ_CHANGED, _can_read },
{ EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED, _can_write }

2
src/examples/ecore/efl_net_server_example.c
View File

@ -450,7 +450,7 @@ _server_serving(void *data EINA_UNUSED, const Efl_Event *event)
EFL_CALLBACKS_ARRAY_DEFINE(server_cbs,
{ EFL_NET_SERVER_EVENT_CLIENT_ADD, _server_client_add },
{ EFL_NET_SERVER_EVENT_CLIENT_REJECTED, _server_client_rejected },
{ EFL_NET_SERVER_EVENT_ERROR, _server_error },
{ EFL_NET_SERVER_EVENT_SERVER_ERROR, _server_error },
{ EFL_NET_SERVER_EVENT_SERVING, _server_serving });
static const char * protocols[] = {

2
src/examples/ecore/efl_net_server_simple_example.c
View File

@ -254,7 +254,7 @@ _server_serving(void *data EINA_UNUSED, const Efl_Event *event)
EFL_CALLBACKS_ARRAY_DEFINE(server_cbs,
{ EFL_NET_SERVER_EVENT_CLIENT_ADD, _server_client_add },
{ EFL_NET_SERVER_EVENT_CLIENT_REJECTED, _server_client_rejected },
{ EFL_NET_SERVER_EVENT_ERROR, _server_error },
{ EFL_NET_SERVER_EVENT_SERVER_ERROR, _server_error },
{ EFL_NET_SERVER_EVENT_SERVING, _server_serving });
static const char * protocols[] = {

6
src/examples/ecore/efl_net_socket_ssl_dialer_example.c
View File

@ -177,9 +177,9 @@ _error(void *data EINA_UNUSED, const Efl_Event *event)
}
EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
{ EFL_NET_DIALER_EVENT_CONNECTED, _connected },
{ EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
{ EFL_NET_DIALER_EVENT_ERROR, _error });
{ EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
{ EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
{ EFL_NET_DIALER_EVENT_DIALER_ERROR, _error });
static char *

2
src/examples/ecore/efl_net_socket_ssl_server_example.c
View File

@ -153,7 +153,7 @@ _server_serving(void *data EINA_UNUSED, const Efl_Event *event)
EFL_CALLBACKS_ARRAY_DEFINE(server_cbs,
{ EFL_NET_SERVER_EVENT_CLIENT_ADD, _server_client_add },
{ EFL_NET_SERVER_EVENT_ERROR, _server_error },
{ EFL_NET_SERVER_EVENT_SERVER_ERROR, _server_error },
{ EFL_NET_SERVER_EVENT_SERVING, _server_serving });
static const char *ciphers_strs[] = {

8
src/lib/ecore_con/ecore_con_legacy.c
View File

@ -1420,9 +1420,9 @@ EFL_CALLBACKS_ARRAY_DEFINE(_ecore_con_server_dialer_cbs,
{ EFL_IO_BUFFERED_STREAM_EVENT_READ_FINISHED, _ecore_con_server_dialer_read_finished },
{ EFL_IO_BUFFERED_STREAM_EVENT_FINISHED, _ecore_con_server_dialer_finished },
{ EFL_IO_BUFFERED_STREAM_EVENT_ERROR, _ecore_con_server_dialer_error },
{ EFL_NET_DIALER_EVENT_ERROR, _ecore_con_server_dialer_error },
{ EFL_NET_DIALER_EVENT_RESOLVED, _ecore_con_server_dialer_resolved },
{ EFL_NET_DIALER_EVENT_CONNECTED, _ecore_con_server_dialer_connected });
{ EFL_NET_DIALER_EVENT_DIALER_ERROR, _ecore_con_server_dialer_error },
{ EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _ecore_con_server_dialer_resolved },
{ EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _ecore_con_server_dialer_connected });
static void
_ecore_con_server_server_client_add(void *data, const Efl_Event *event)
@ -1495,7 +1495,7 @@ _ecore_con_server_server_error(void *data, const Efl_Event *event)
EFL_CALLBACKS_ARRAY_DEFINE(_ecore_con_server_server_cbs,
{ EFL_NET_SERVER_EVENT_CLIENT_ADD, _ecore_con_server_server_client_add },
{ EFL_NET_SERVER_EVENT_SERVING, _ecore_con_server_server_serving },
{ EFL_NET_SERVER_EVENT_ERROR, _ecore_con_server_server_error });
{ EFL_NET_SERVER_EVENT_SERVER_ERROR, _ecore_con_server_server_error });
/**
* @addtogroup Ecore_Con_Server_Group Ecore Connection Server Functions

2
src/lib/ecore_con/ecore_con_url.c
View File

@ -508,7 +508,7 @@ _ecore_con_url_dialer_headers_done(void *data, const Efl_Event *event EINA_UNUSE
EFL_CALLBACKS_ARRAY_DEFINE(ecore_con_url_dialer_cbs,
{ EFL_IO_READER_EVENT_CAN_READ_CHANGED, _ecore_con_url_dialer_can_read_changed },
{ EFL_IO_READER_EVENT_EOS, _ecore_con_url_dialer_eos },
{ EFL_NET_DIALER_EVENT_ERROR, _ecore_con_url_dialer_error },
{ EFL_NET_DIALER_EVENT_DIALER_ERROR, _ecore_con_url_dialer_error },
{ EFL_NET_DIALER_HTTP_EVENT_HEADERS_DONE, _ecore_con_url_dialer_headers_done });
static Eina_Bool

6
src/lib/ecore_con/efl_net_dialer.eo
View File

@ -112,7 +112,7 @@ interface @beta Efl.Net.Dialer extends Efl.Net.Socket {
events {
/* FIXME: Might be NULL, but @nullable does not work on event types */
resolved: string; [[Notifies @.address_dial was resolved to
dialer,resolved: string; [[Notifies @.address_dial was resolved to
@Efl.Net.Socket.address_remote.
This is emitted before "connected" and may
@ -124,9 +124,9 @@ interface @beta Efl.Net.Dialer extends Efl.Net.Socket {
may be emitted multiple times, such as
HTTP.
]]
error: Eina.Error; [[Some error happened and the socket
dialer,error: Eina.Error; [[Some error happened and the socket
stopped working.
]]
connected: void; [[Notifies the socket is connected to the remote peer.]]
dialer,connected: void; [[Notifies the socket is connected to the remote peer.]]
}
}

6
src/lib/ecore_con/efl_net_dialer_http.c
View File

@ -318,7 +318,7 @@ _efl_net_dialer_http_curlm_check(Efl_Net_Dialer_Http_Curlm *cm)
efl_ref(dialer);
pd = efl_data_scope_get(dialer, MY_CLASS);
if (pd->error)
efl_event_callback_call(dialer, EFL_NET_DIALER_EVENT_ERROR, &pd->error);
efl_event_callback_call(dialer, EFL_NET_DIALER_EVENT_DIALER_ERROR, &pd->error);
if (pd->recv.used > 0) pd->pending_eos = EINA_TRUE;
else
{
@ -1460,7 +1460,7 @@ _efl_net_dialer_http_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Http_Dat
* allow_redirects will trigger more than once
*/
pd->connected = connected;
if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
}
EOLIAN static Eina_Bool
@ -1524,7 +1524,7 @@ EOLIAN static void
_efl_net_dialer_http_efl_net_socket_address_remote_set(Eo *o, Efl_Net_Dialer_Http_Data *pd, const char *address)
{
if (eina_stringshare_replace(&pd->address_remote, address))
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
}
EOLIAN static const char *

12
src/lib/ecore_con/efl_net_dialer_simple.c
View File

@ -33,14 +33,14 @@ static void
_efl_net_dialer_simple_inner_io_resolved(void *data, const Efl_Event *event)
{
Eo *o = data;
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, event->info);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, event->info);
}
static void
_efl_net_dialer_simple_inner_io_error(void *data, const Efl_Event *event)
{
Eo *o = data;
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, event->info);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, event->info);
}
static void
@ -48,13 +48,13 @@ _efl_net_dialer_simple_inner_io_connected(void *data, const Efl_Event *event)
{
Eo *o = data;
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, event->info);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, event->info);
}
EFL_CALLBACKS_ARRAY_DEFINE(_efl_net_dialer_simple_inner_io_cbs,
{ EFL_NET_DIALER_EVENT_RESOLVED, _efl_net_dialer_simple_inner_io_resolved },
{ EFL_NET_DIALER_EVENT_ERROR, _efl_net_dialer_simple_inner_io_error },
{ EFL_NET_DIALER_EVENT_CONNECTED, _efl_net_dialer_simple_inner_io_connected });
{ EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _efl_net_dialer_simple_inner_io_resolved },
{ EFL_NET_DIALER_EVENT_DIALER_ERROR, _efl_net_dialer_simple_inner_io_error },
{ EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _efl_net_dialer_simple_inner_io_connected });
EOLIAN static Efl_Object *
_efl_net_dialer_simple_efl_object_finalize(Eo *o, Efl_Net_Dialer_Simple_Data *pd)

6
src/lib/ecore_con/efl_net_dialer_ssl.c
View File

@ -50,7 +50,7 @@ _efl_net_dialer_ssl_error(void *data EINA_UNUSED, const Efl_Event *event)
{
Eo *o = event->object;
Eina_Error *perr = event->info;
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, perr);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, perr);
}
EFL_CALLBACKS_ARRAY_DEFINE(_efl_net_dialer_ssl_cbs,
@ -134,7 +134,7 @@ _efl_net_dialer_ssl_connect_timeout(Eo *o, void *data EINA_UNUSED, const Eina_Va
efl_ref(o);
efl_io_reader_eos_set(o, EINA_TRUE);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
efl_unref(o);
return v;
}
@ -205,7 +205,7 @@ _efl_net_dialer_ssl_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Ssl_Data
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);
if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
}
EOLIAN static Eina_Bool

10
src/lib/ecore_con/efl_net_dialer_tcp.c
View File

@ -99,7 +99,7 @@ _efl_net_dialer_tcp_connect_timeout(Eo *o, void *data EINA_UNUSED, const Eina_Va
efl_ref(o);
efl_io_reader_eos_set(o, EINA_TRUE);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
efl_unref(o);
return v;
}
@ -128,7 +128,7 @@ _efl_net_dialer_tcp_connected(void *data, const struct sockaddr *addr, socklen_t
efl_loop_fd_set(o, sockfd);
if (efl_net_socket_address_remote_get(o))
{
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
efl_net_dialer_connected_set(o, EINA_TRUE);
}
else
@ -148,11 +148,11 @@ _efl_net_dialer_tcp_connected(void *data, const struct sockaddr *addr, socklen_t
if (efl_net_ip_port_fmt(buf, sizeof(buf), addr))
{
efl_net_socket_address_remote_set(o, buf);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
}
}
efl_io_reader_eos_set(o, EINA_TRUE);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
}
efl_unref(o);
@ -245,7 +245,7 @@ _efl_net_dialer_tcp_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Tcp_Data
if (!connected) _efl_net_dialer_tcp_async_stop(pd);
if (pd->connected == connected) return;
pd->connected = connected;
if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
}
EOLIAN static Eina_Bool

10
src/lib/ecore_con/efl_net_dialer_udp.c
View File

@ -95,7 +95,7 @@ _efl_net_dialer_udp_resolver_timeout(Eo *o, void *data EINA_UNUSED, const Eina_V
efl_ref(o);
efl_io_reader_eos_set(o, EINA_TRUE);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
efl_unref(o);
return v;
}
@ -184,7 +184,7 @@ _efl_net_dialer_udp_resolved_bind(Eo *o, Efl_Net_Dialer_Udp_Data *pd EINA_UNUSED
if (remote_address)
{
efl_net_socket_udp_init(o, remote_address);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
efl_del(remote_address);
}
efl_net_dialer_connected_set(o, EINA_TRUE);
@ -230,12 +230,12 @@ _efl_net_dialer_udp_resolved(void *data, const char *host EINA_UNUSED, const cha
if (efl_net_ip_port_fmt(buf, sizeof(buf), result->ai_addr))
{
efl_net_socket_address_remote_set(o, buf);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
}
}
efl_io_reader_eos_set(o, EINA_TRUE);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
}
freeaddrinfo(result);
@ -319,7 +319,7 @@ _efl_net_dialer_udp_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Udp_Data
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);
if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
}
EOLIAN static Eina_Bool

8
src/lib/ecore_con/efl_net_dialer_unix.c
View File

@ -84,7 +84,7 @@ _efl_net_dialer_unix_connect_timeout(Eo *o, void *data EINA_UNUSED, const Eina_V
efl_ref(o);
efl_io_reader_eos_set(o, EINA_TRUE);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
efl_unref(o);
return v;
}
@ -105,7 +105,7 @@ _efl_net_dialer_unix_connected(void *data, const struct sockaddr *addr, socklen_
efl_loop_fd_set(o, sockfd);
if (efl_net_socket_address_remote_get(o))
{
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
efl_net_dialer_connected_set(o, EINA_TRUE);
}
else
@ -120,7 +120,7 @@ _efl_net_dialer_unix_connected(void *data, const struct sockaddr *addr, socklen_
if (err)
{
efl_io_reader_eos_set(o, EINA_TRUE);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
}
efl_unref(o);
@ -222,7 +222,7 @@ _efl_net_dialer_unix_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Unix_Dat
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);
if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
}
EOLIAN static Eina_Bool

16
src/lib/ecore_con/efl_net_dialer_websocket.c
View File

@ -350,7 +350,7 @@ _efl_net_dialer_websocket_job_send(Eo *o, Efl_Net_Dialer_Websocket_Data *pd)
if ((err) && (err != EAGAIN))
{
ERR("could not write to HTTP socket #%d '%s'", err, eina_error_msg_get(err));
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
}
}
@ -730,7 +730,7 @@ _efl_net_dialer_websocket_job_receive(Eo *o, Efl_Net_Dialer_Websocket_Data *pd)
eina_error_msg_get(err));
efl_ref(o);
efl_io_closer_close(pd->http);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
efl_unref(o);
}
@ -819,7 +819,7 @@ _efl_net_dialer_websocket_http_error(void *data, const Efl_Event *event)
return;
efl_ref(o);
if (!efl_io_closer_closed_get(o)) efl_io_closer_close(o);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, perr);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, perr);
efl_unref(o);
}
@ -846,7 +846,7 @@ _efl_net_dialer_websocket_http_headers_done(void *data, const Efl_Event *event E
status, EFL_NET_HTTP_STATUS_SWITCHING_PROTOCOLS);
efl_ref(o);
efl_io_closer_close(pd->http);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
efl_unref(o);
return;
}
@ -887,7 +887,7 @@ _efl_net_dialer_websocket_http_headers_done(void *data, const Efl_Event *event E
upgraded, connection_websocket, accepted);
efl_ref(o);
efl_io_closer_close(pd->http);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
efl_unref(o);
return;
}
@ -934,7 +934,7 @@ EFL_CALLBACKS_ARRAY_DEFINE(_efl_net_dialer_websocket_http_cbs,
{EFL_IO_READER_EVENT_CAN_READ_CHANGED, _efl_net_dialer_websocket_http_can_read_changed},
{EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED, _efl_net_dialer_websocket_http_can_write_changed},
{EFL_IO_CLOSER_EVENT_CLOSED, _efl_net_dialer_websocket_http_closed},
{EFL_NET_DIALER_EVENT_ERROR, _efl_net_dialer_websocket_http_error},
{EFL_NET_DIALER_EVENT_DIALER_ERROR, _efl_net_dialer_websocket_http_error},
{EFL_NET_DIALER_HTTP_EVENT_HEADERS_DONE, _efl_net_dialer_websocket_http_headers_done});
EOLIAN static Efl_Object *
@ -1182,7 +1182,7 @@ _efl_net_dialer_websocket_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Web
if (pd->connected == connected) return;
pd->connected = connected;
if (connected)
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
}
EOLIAN static Eina_Bool
@ -1225,7 +1225,7 @@ EOLIAN static void
_efl_net_dialer_websocket_efl_net_socket_address_remote_set(Eo *o EINA_UNUSED, Efl_Net_Dialer_Websocket_Data *pd, const char *address)
{
if (eina_stringshare_replace(&pd->address_remote, address))
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
}
EOLIAN static const char *

4
src/lib/ecore_con/efl_net_dialer_windows.c
View File

@ -100,7 +100,7 @@ _efl_net_dialer_windows_efl_net_dialer_dial(Eo *o, Efl_Net_Dialer_Windows_Data *
efl_net_socket_address_remote_set(o, sstr);
efl_net_socket_address_local_set(o, cstr);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
efl_net_dialer_connected_set(o, EINA_TRUE);
return _efl_net_socket_windows_io_start(o);
@ -125,7 +125,7 @@ _efl_net_dialer_windows_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Windo
{
if (pd->connected == connected) return;
pd->connected = connected;
if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
}
EOLIAN static Eina_Bool

2
src/lib/ecore_con/efl_net_server.eo
View File

@ -26,7 +26,7 @@ interface @beta Efl.Net.Server {
excess, see @.clients_limit.
]]
error: Eina.Error; [[An error has occurred and the server needs
server,error: Eina.Error; [[An error has occurred and the server needs
to be stopped.
]]
serving: void; [[Notifies the server is ready to accept clients.

4
src/lib/ecore_con/efl_net_server_fd.c
View File

@ -81,7 +81,7 @@ _efl_net_server_fd_event_error(void *data EINA_UNUSED, const Efl_Event *event)
Eina_Error err = EBADF;
efl_net_server_serving_set(o, EINA_FALSE);
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
}
EOLIAN static Efl_Object *
@ -474,7 +474,7 @@ _efl_net_server_fd_process_incoming_data(Eo *o, Efl_Net_Server_Fd_Data *pd)
{
Eina_Error err = efl_net_socket_error_get();
ERR("accept(" SOCKET_FMT "): %s", fd, eina_error_msg_get(err));
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
return;
}

4
src/lib/ecore_con/efl_net_server_simple.c
View File

@ -109,7 +109,7 @@ static void
_efl_net_server_simple_inner_server_error(void *data, const Efl_Event *event)
{
Eo *o = data;
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, event->info);
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, event->info);
}
static void
@ -122,7 +122,7 @@ _efl_net_server_simple_inner_server_serving(void *data, const Efl_Event *event)
EFL_CALLBACKS_ARRAY_DEFINE(_efl_net_server_simple_inner_server_cbs,
{ EFL_NET_SERVER_EVENT_CLIENT_ADD, _efl_net_server_simple_inner_server_client_add },
{ EFL_NET_SERVER_EVENT_CLIENT_REJECTED, _efl_net_server_simple_inner_server_client_rejected },
{ EFL_NET_SERVER_EVENT_ERROR, _efl_net_server_simple_inner_server_error },
{ EFL_NET_SERVER_EVENT_SERVER_ERROR, _efl_net_server_simple_inner_server_error },
{ EFL_NET_SERVER_EVENT_SERVING, _efl_net_server_simple_inner_server_serving });
EOLIAN static Efl_Object *

2
src/lib/ecore_con/efl_net_server_tcp.c
View File

@ -138,7 +138,7 @@ _efl_net_server_tcp_resolved(void *data, const char *host EINA_UNUSED, const cha
freeaddrinfo(result);
end:
if (err) efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
if (err) efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
efl_unref(o);
}

8
src/lib/ecore_con/efl_net_server_udp.c
View File

@ -142,7 +142,7 @@ _efl_net_server_udp_resolved_bind(Eo *o, Efl_Net_Server_Udp_Data *pd, const stru
if (mr)
{
ERR("could not join pending multicast group '%s': %s", mcast_addr, eina_error_msg_get(mr));
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &mr);
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &mr);
}
}
@ -191,7 +191,7 @@ _efl_net_server_udp_resolved(void *data, const char *host EINA_UNUSED, const cha
freeaddrinfo(result);
end:
if (err) efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
if (err) efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
efl_unref(o);
}
@ -328,7 +328,7 @@ _efl_net_server_udp_efl_net_server_fd_process_incoming_data(Eo *o, Efl_Net_Serve
Eina_Error err = efl_net_socket_error_get();
ERR("recvfrom(" SOCKET_FMT ", %p, %zu, 0, %p, %d): %s", fd, buf, buflen, &addr, addrlen, eina_error_msg_get(err));
free(buf);
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
return;
}
if ((size_t)r < buflen)
@ -341,7 +341,7 @@ _efl_net_server_udp_efl_net_server_fd_process_incoming_data(Eo *o, Efl_Net_Serve
free(buf);
ERR("Out of memory on efl net udp data incoming");
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
return;
}
}

2
src/lib/ecore_con/efl_net_server_unix.c
View File

@ -165,7 +165,7 @@ _efl_net_server_unix_bind(Eo *o, Efl_Net_Server_Unix_Data *pd)
error:
if (err)
{
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
if (fd != INVALID_SOCKET) closesocket(fd);
efl_loop_fd_set(o, SOCKET_TO_LOOP_FD(INVALID_SOCKET));
}

2
src/lib/ecore_con/efl_net_server_windows.c
View File

@ -151,7 +151,7 @@ _efl_net_server_windows_client_listen_failure(void *data, Eo *client EINA_UNUSED
}
if (err)
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
// TODO: create a new one on failure?

6
src/lib/ecore_con/efl_net_socket_ssl.c
View File

@ -225,7 +225,7 @@ efl_net_socket_ssl_sock_resolved(void *data, const Efl_Event *event EINA_UNUSED)
if (pd->torndown) return;
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
}
static void
@ -250,8 +250,8 @@ efl_net_socket_ssl_sock_connected(void *data, const Efl_Event *event EINA_UNUSED
}
EFL_CALLBACKS_ARRAY_DEFINE(efl_net_socket_ssl_sock_dialer_cbs,
{EFL_NET_DIALER_EVENT_RESOLVED, efl_net_socket_ssl_sock_resolved},
{EFL_NET_DIALER_EVENT_CONNECTED, efl_net_socket_ssl_sock_connected});
{EFL_NET_DIALER_EVENT_DIALER_RESOLVED, efl_net_socket_ssl_sock_resolved},
{EFL_NET_DIALER_EVENT_DIALER_CONNECTED, efl_net_socket_ssl_sock_connected});
static void
_efl_net_socket_ssl_context_del(void *data, const Efl_Event *event EINA_UNUSED)

4
src/lib/ecore_ipc/ecore_ipc.c
View File

@ -607,8 +607,8 @@ _ecore_ipc_dialer_connected(void *data, const Efl_Event *event EINA_UNUSED)
EFL_CALLBACKS_ARRAY_DEFINE(_ecore_ipc_dialer_cbs,
{ EFL_IO_READER_EVENT_EOS, _ecore_ipc_dialer_eos },
{ EFL_NET_DIALER_EVENT_ERROR, _ecore_ipc_dialer_error },
{ EFL_NET_DIALER_EVENT_CONNECTED, _ecore_ipc_dialer_connected });
{ EFL_NET_DIALER_EVENT_DIALER_ERROR, _ecore_ipc_dialer_error },
{ EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _ecore_ipc_dialer_connected });
static Eina_Bool ecore_ipc_server_data_process(Ecore_Ipc_Server *svr, void *data, int size, Eina_Bool *stolen);