}
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
{
}
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
{
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);
/* 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");
}
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)
/* 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");
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 });
}
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 */
}
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 }
);
}
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 }
{ 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 });
{ 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 });
}
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 }
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[] = {
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[] = {
}
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 *
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[] = {
{ 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)
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
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
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
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.]]
}
}
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
{
* 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
_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 *
_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
{
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)
{
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,
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;
}
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
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;
}
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
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);
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
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;
}
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);
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);
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
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;
}
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
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);
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
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);
}
}
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);
}
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);
}
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;
}
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;
}
{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 *
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
_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 *
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);
{
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
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.
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 *
{
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;
}
_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
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 *
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);
}
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);
}
}
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);
}
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)
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;
}
}
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));
}
}
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?
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
}
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)
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);