}
void
-_ecore_con_server_kill(Ecore_Con_Server *svr)
+_ecore_con_server_kill(Ecore_Con_Server *obj)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
if (svr->delete_me)
DBG("Multi kill request for svr %p", svr);
else
- ecore_con_event_server_del(svr);
+ ecore_con_event_server_del(obj);
if (svr->fd_handler)
ecore_main_fd_handler_del(svr->fd_handler);
ecore_con_shutdown(void)
{
Eina_List *l, *l2;
- Ecore_Con_Server *svr;
+ Ecore_Con_Server *obj;
if (--_ecore_con_init_count != 0)
return _ecore_con_init_count;
EINA_LOG_STATE_START,
EINA_LOG_STATE_SHUTDOWN);
- EINA_LIST_FOREACH_SAFE(servers, l, l2, svr)
+ EINA_LIST_FOREACH_SAFE(servers, l, l2, obj)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
Ecore_Con_Event_Server_Add *ev;
svr->delete_me = EINA_TRUE;
/* some pointer hacks here to prevent double frees if people are being stupid */
EINA_LIST_FREE(svr->event_count, ev)
ev->server = NULL;
- _ecore_con_server_free(svr);
+ _ecore_con_server_free(obj);
}
ecore_con_socks_shutdown();
}
EOLIAN static Eina_Bool
-_ecore_con_lookup(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED, const char *name, Ecore_Con_Dns_Cb done_cb, const void *data)
+_ecore_con_lookup(Eo *kls_obj EINA_UNUSED, void *pd EINA_UNUSED, const char *name, Ecore_Con_Dns_Cb done_cb, const void *data)
{
- Ecore_Con_Server *svr;
+ Ecore_Con_Server *obj;
Ecore_Con_Lookup *lk;
struct addrinfo hints;
if (!name || !done_cb)
return EINA_FALSE;
- svr = calloc(1, sizeof(Ecore_Con_Server));
+ obj = eo_add(ECORE_CON_SERVER_CLASS, NULL);
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
if (!svr)
return EINA_FALSE;
hints.ai_next = NULL;
hints.ai_addr = NULL;
- if (ecore_con_info_get(svr, _ecore_con_lookup_done, svr,
+ if (ecore_con_info_get(obj, _ecore_con_lookup_done, svr,
&hints))
return EINA_TRUE;
free(svr->name);
on_error:
free(lk);
- free(svr);
+ eo_del(obj);
return EINA_FALSE;
}
int port,
const void *data)
{
- Ecore_Con_Server *svr;
+ Ecore_Con_Server *obj;
Ecore_Con_Type type;
if (port < 0 || !name)
/* 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;
+ obj = eo_add(ECORE_CON_SERVER_CLASS, NULL);
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
- ECORE_MAGIC_SET(svr, ECORE_MAGIC_CON_SERVER);
svr->fd = -1;
svr->start_time = ecore_time_get();
svr->type = compl_type;
svr->clients = NULL;
svr->ppid = getpid();
- servers = eina_list_append(servers, svr);
+ servers = eina_list_append(servers, obj);
svr->name = strdup(name);
if (!svr->name)
goto error;
- if (ecore_con_ssl_server_prepare(svr, compl_type & ECORE_CON_SSL))
+ if (ecore_con_ssl_server_prepare(obj, compl_type & ECORE_CON_SSL))
goto error;
type = compl_type & ECORE_CON_TYPE;
(type == ECORE_CON_LOCAL_ABSTRACT))
/* Local */
#ifdef _WIN32
- if (!ecore_con_local_listen(svr))
+ if (!ecore_con_local_listen(obj))
goto error;
#else
- if (!ecore_con_local_listen(svr, _ecore_con_svr_tcp_handler, svr))
+ if (!ecore_con_local_listen(obj, _ecore_con_svr_tcp_handler, obj))
goto error;
#endif
(type == ECORE_CON_REMOTE_CORK))
{
/* TCP */
- if (!ecore_con_info_tcp_listen(svr, _ecore_con_cb_tcp_listen,
- svr))
+ if (!ecore_con_info_tcp_listen(obj, _ecore_con_cb_tcp_listen,
+ obj))
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))
+ if (!ecore_con_info_udp_listen(obj, _ecore_con_cb_udp_listen,
+ obj))
goto error;
- return svr;
+ return obj;
error:
if (svr->delete_me) return NULL;
- _ecore_con_server_kill(svr);
+ _ecore_con_server_kill(obj);
return NULL;
}
int port,
const void *data)
{
- Ecore_Con_Server *svr;
+ Ecore_Con_Server *obj;
Ecore_Con_Type type;
if ((!name) || (!name[0]))
/* 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;
+ obj = eo_add(ECORE_CON_SERVER_CLASS, NULL);
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
- ECORE_MAGIC_SET(svr, ECORE_MAGIC_CON_SERVER);
svr->fd = -1;
svr->type = compl_type;
svr->port = port;
svr->clients = NULL;
svr->client_limit = -1;
- servers = eina_list_append(servers, svr);
+ servers = eina_list_append(servers, obj);
svr->name = strdup(name);
if (!svr->name)
svr->ecs_state = ECORE_CON_PROXY_STATE_RESOLVED;
}
}
- EINA_SAFETY_ON_TRUE_GOTO(ecore_con_ssl_server_prepare(svr, compl_type & ECORE_CON_SSL), error);
+ EINA_SAFETY_ON_TRUE_GOTO(ecore_con_ssl_server_prepare(obj, compl_type & ECORE_CON_SSL), error);
EINA_SAFETY_ON_TRUE_GOTO(((type == ECORE_CON_REMOTE_TCP) ||
(type == ECORE_CON_REMOTE_NODELAY) ||
(type == ECORE_CON_LOCAL_ABSTRACT))
/* Local */
#ifdef _WIN32
- if (!ecore_con_local_connect(svr, _ecore_con_cl_handler)) goto error;
+ if (!ecore_con_local_connect(obj, _ecore_con_cl_handler)) goto error;
#else
- if (!ecore_con_local_connect(svr, _ecore_con_cl_handler, svr)) goto error;
+ if (!ecore_con_local_connect(obj, _ecore_con_cl_handler, obj)) goto error;
#endif
if ((type == ECORE_CON_REMOTE_TCP) ||
(type == ECORE_CON_REMOTE_CORK))
{
/* TCP */
- EINA_SAFETY_ON_FALSE_GOTO(ecore_con_info_tcp_connect(svr, _ecore_con_cb_tcp_connect, svr), error);
+ EINA_SAFETY_ON_FALSE_GOTO(ecore_con_info_tcp_connect(obj, _ecore_con_cb_tcp_connect, obj), error);
}
else if ((type == ECORE_CON_REMOTE_UDP) || (type == ECORE_CON_REMOTE_BROADCAST))
/* UDP and MCAST */
- EINA_SAFETY_ON_FALSE_GOTO(ecore_con_info_udp_connect(svr, _ecore_con_cb_udp_connect, svr), error);
+ EINA_SAFETY_ON_FALSE_GOTO(ecore_con_info_udp_connect(obj, _ecore_con_cb_udp_connect, obj), error);
- return svr;
+ return obj;
error:
if (svr->delete_me) return NULL;
- _ecore_con_server_kill(svr);
+ _ecore_con_server_kill(obj);
return NULL;
}
EAPI void
-ecore_con_server_timeout_set(Ecore_Con_Server *svr,
- double timeout)
+ecore_con_server_timeout_set(Ecore_Con *obj, double timeout)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, "ecore_con_server_timeout_set");
- return;
- }
+ eo_do((Ecore_Con *)obj, ecore_con_obj_timeout_set(timeout));
+}
+EOLIAN static void
+_ecore_con_server_ecore_con_timeout_set(Eo *obj, Ecore_Con_Server_Data *svr, double timeout)
+{
if (svr->created)
svr->client_disconnect_time = timeout;
else
svr->disconnect_time = timeout;
- _ecore_con_server_timer_update(svr);
+ _ecore_con_server_timer_update(obj);
}
EAPI double
-ecore_con_server_timeout_get(Ecore_Con_Server *svr)
+ecore_con_server_timeout_get(const Ecore_Con *obj)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, "ecore_con_server_timeout_get");
- return 0;
- }
+ return eo_do((Ecore_Con *)obj, ecore_con_obj_timeout_get());
+}
+EOLIAN static double
+_ecore_con_server_ecore_con_timeout_get(Eo *obj EINA_UNUSED, Ecore_Con_Server_Data *svr)
+{
return svr->created ? svr->client_disconnect_time : svr->disconnect_time;
}
EAPI void *
-ecore_con_server_del(Ecore_Con_Server *svr)
+ecore_con_server_del(Ecore_Con_Server *obj)
{
- if (!svr) return NULL;
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, "ecore_con_server_del");
- return NULL;
- }
+ if (!obj) return NULL;
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
if (svr->delete_me)
return NULL;
- _ecore_con_server_kill(svr);
+ _ecore_con_server_kill(obj);
return svr->data;
}
EAPI void *
-ecore_con_server_data_get(Ecore_Con_Server *svr)
+ecore_con_server_data_get(Ecore_Con_Server *obj)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, "ecore_con_server_data_get");
- return NULL;
- }
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
+ if (!svr)
+ return NULL;
return svr->data;
}
EAPI void *
-ecore_con_server_data_set(Ecore_Con_Server *svr,
+ecore_con_server_data_set(Ecore_Con_Server *obj,
void *data)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
+ if (!svr)
+ return NULL;
void *ret = NULL;
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, "ecore_con_server_data_get");
- return NULL;
- }
-
ret = svr->data;
svr->data = data;
return ret;
}
EAPI Eina_Bool
-ecore_con_server_connected_get(Ecore_Con_Server *svr)
+ecore_con_server_connected_get(const Ecore_Con *obj)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, "ecore_con_server_connected_get");
- return EINA_FALSE;
- }
-
- if (svr->connecting)
- return EINA_FALSE;
-
- return EINA_TRUE;
+ return eo_do((Ecore_Con *)obj, ecore_con_obj_connected_get());
}
-EAPI const Eina_List *
-ecore_con_server_clients_get(Ecore_Con_Server *svr)
+EOLIAN static Eina_Bool
+_ecore_con_server_ecore_con_connected_get(Eo *obj EINA_UNUSED, Ecore_Con_Server_Data *svr)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER,
- "ecore_con_server_clients_get");
- return NULL;
- }
+ return !svr->connecting;
+}
+EOLIAN const Eina_List *
+_ecore_con_server_clients_get(Eo *obj EINA_UNUSED, Ecore_Con_Server_Data *svr)
+{
return svr->clients;
}
-EAPI const char *
-ecore_con_server_name_get(Ecore_Con_Server *svr)
+EOLIAN static const char *
+_ecore_con_server_name_get(Eo *obj EINA_UNUSED, Ecore_Con_Server_Data *svr)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER,
- "ecore_con_server_name_get");
- return NULL;
- }
-
return svr->name;
}
EAPI int
-ecore_con_server_port_get(Ecore_Con_Server *svr)
+ecore_con_server_port_get(const Ecore_Con *obj)
+{
+ return eo_do((Ecore_Con *)obj, ecore_con_obj_port_get());
+}
+
+EOLIAN static int
+_ecore_con_server_ecore_con_port_get(Eo *obj EINA_UNUSED, Ecore_Con_Server_Data *svr)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER,
- "ecore_con_server_port_get");
- return -1;
- }
return svr->port;
}
EAPI int
-ecore_con_server_send(Ecore_Con_Server *svr,
- const void *data,
- int size)
+ecore_con_server_send(Ecore_Con *obj, const void *data, int size)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, "ecore_con_server_send");
- return 0;
- }
+ return eo_do((Ecore_Con *)obj, ecore_con_obj_send(data, size));
+}
+EOLIAN static int
+_ecore_con_server_ecore_con_send(Eo *obj EINA_UNUSED, Ecore_Con_Server_Data *svr, const void *data, int size)
+{
EINA_SAFETY_ON_TRUE_RETURN_VAL(svr->delete_me, 0);
EINA_SAFETY_ON_NULL_RETURN_VAL(data, 0);
return size;
}
-EAPI void
-ecore_con_server_client_limit_set(Ecore_Con_Server *svr,
+EOLIAN static void
+_ecore_con_server_client_limit_set(Eo *obj EINA_UNUSED, Ecore_Con_Server_Data *svr,
int client_limit,
char reject_excess_clients)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER,
- "ecore_con_server_client_limit_set");
- return;
- }
-
svr->client_limit = client_limit;
svr->reject_excess_clients = reject_excess_clients;
}
+EOLIAN static void
+_ecore_con_server_client_limit_get(Eo *obj EINA_UNUSED, Ecore_Con_Server_Data *svr,
+ int *client_limit,
+ char *reject_excess_clients)
+{
+ if (client_limit) *client_limit = svr->client_limit;
+ if (reject_excess_clients) *reject_excess_clients = svr->reject_excess_clients;
+}
+
EAPI const char *
-ecore_con_server_ip_get(Ecore_Con_Server *svr)
+ecore_con_server_ip_get(const Ecore_Con *obj)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, "ecore_con_server_ip_get");
- return NULL;
- }
+ return eo_do(obj, ecore_con_obj_ip_get());
+}
+EOLIAN static const char *
+_ecore_con_server_ecore_con_ip_get(Eo *obj EINA_UNUSED, Ecore_Con_Server_Data *svr)
+{
return svr->ip;
}
EAPI double
-ecore_con_server_uptime_get(Ecore_Con_Server *svr)
+ecore_con_server_uptime_get(const Ecore_Con *obj)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, "ecore_con_server_uptime_get");
- return -1;
- }
+ return eo_do(obj, ecore_con_obj_uptime_get());
+}
+EOLIAN static double
+_ecore_con_server_ecore_con_uptime_get(Eo *obj EINA_UNUSED, Ecore_Con_Server_Data *svr)
+{
return ecore_time_get() - svr->start_time;
}
EAPI void
-ecore_con_server_flush(Ecore_Con_Server *svr)
+ecore_con_server_flush(Ecore_Con *obj)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, "ecore_con_server_flush");
- return;
- }
+ eo_do((Ecore_Con *)obj, ecore_con_obj_flush());
+}
- _ecore_con_server_flush(svr);
+EOLIAN static void
+_ecore_con_server_ecore_con_flush(Eo *obj, Ecore_Con_Server_Data *svr EINA_UNUSED)
+{
+ _ecore_con_server_flush(obj);
}
/**
EOLIAN static int
_ecore_con_client_ecore_con_send(Eo *obj EINA_UNUSED, Ecore_Con_Client_Data *cl, const void *data, int size)
{
+ Ecore_Con_Server_Data *host_server = NULL;
EINA_SAFETY_ON_TRUE_RETURN_VAL(cl->delete_me, 0);
EINA_SAFETY_ON_NULL_RETURN_VAL(data, 0);
if (cl->fd_handler)
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,
+ if (cl->host_server)
+ host_server = eo_data_scope_get(cl->host_server, ECORE_CON_CLIENT_CLASS);
+
+
+ if (cl->host_server && ((host_server->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_UDP))
+ sendto(host_server->fd, data, size, 0, (struct sockaddr *)cl->client_addr,
cl->client_addr_len);
else
{
cl->buf = eina_binbuf_new();
EINA_SAFETY_ON_NULL_RETURN_VAL(cl->buf, 0);
#ifdef TCP_CORK
- if ((cl->fd >= 0) && ((cl->host_server->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_CORK))
+ if ((cl->fd >= 0) && ((host_server->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_CORK))
{
int state = 1;
if (setsockopt(cl->fd, IPPROTO_TCP, TCP_CORK, (char *)&state, sizeof(int)) < 0)
}
EAPI int
-ecore_con_server_fd_get(Ecore_Con_Server *svr)
+ecore_con_server_fd_get(const Ecore_Con *obj)
+{
+ return eo_do((Ecore_Con *)obj, ecore_con_obj_fd_get());
+}
+
+EOLIAN static int
+_ecore_con_server_ecore_con_fd_get(Eo *obj EINA_UNUSED, Ecore_Con_Server_Data *svr)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, __func__);
- return -1;
- }
if (svr->created) return -1;
if (svr->delete_me) return -1;
return ecore_main_fd_handler_fd_get(svr->fd_handler);
*/
void
-ecore_con_event_proxy_bind(Ecore_Con_Server *svr)
+ecore_con_event_proxy_bind(Ecore_Con_Server *obj)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
Ecore_Con_Event_Proxy_Bind *e;
int ev = ECORE_CON_EVENT_PROXY_BIND;
EINA_SAFETY_ON_NULL_RETURN(e);
svr->event_count = eina_list_append(svr->event_count, e);
- _ecore_con_server_timer_update(svr);
- e->server = svr;
+ _ecore_con_server_timer_update(obj);
+ e->server = obj;
e->ip = svr->proxyip;
e->port = svr->proxyport;
ecore_event_add(ev, e,
}
void
-ecore_con_event_server_add(Ecore_Con_Server *svr)
+ecore_con_event_server_add(Ecore_Con_Server *obj)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
/* we got our server! */
Ecore_Con_Event_Server_Add *e;
int ev = ECORE_CON_EVENT_SERVER_ADD;
svr->connecting = EINA_FALSE;
svr->start_time = ecore_time_get();
svr->event_count = eina_list_append(svr->event_count, e);
- _ecore_con_server_timer_update(svr);
- e->server = svr;
+ _ecore_con_server_timer_update(obj);
+ e->server = obj;
if (svr->upgrade) ev = ECORE_CON_EVENT_SERVER_UPGRADE;
ecore_event_add(ev, e,
_ecore_con_event_server_add_free, NULL);
}
void
-ecore_con_event_server_del(Ecore_Con_Server *svr)
+ecore_con_event_server_del(Ecore_Con_Server *obj)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
Ecore_Con_Event_Server_Del *e;
svr->delete_me = EINA_TRUE;
EINA_SAFETY_ON_NULL_RETURN(e);
svr->event_count = eina_list_append(svr->event_count, e);
- _ecore_con_server_timer_update(svr);
- e->server = svr;
+ _ecore_con_server_timer_update(obj);
+ e->server = obj;
if (svr->ecs)
{
svr->ecs_state = svr->ecs->lookup ? ECORE_CON_PROXY_STATE_RESOLVED : ECORE_CON_PROXY_STATE_DONE;
}
void
-ecore_con_event_server_write(Ecore_Con_Server *svr, int num)
+ecore_con_event_server_write(Ecore_Con_Server *obj, int num)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
Ecore_Con_Event_Server_Write *e;
e = ecore_con_event_server_write_alloc();
INF("Wrote %d bytes", num);
svr->event_count = eina_list_append(svr->event_count, e);
- e->server = svr;
+ e->server = obj;
e->size = num;
ecore_event_add(ECORE_CON_EVENT_SERVER_WRITE, e,
(Ecore_End_Cb)_ecore_con_event_server_write_free, NULL);
}
void
-ecore_con_event_server_data(Ecore_Con_Server *svr, unsigned char *buf, int num, Eina_Bool duplicate)
+ecore_con_event_server_data(Ecore_Con_Server *obj, unsigned char *buf, int num, Eina_Bool duplicate)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
Ecore_Con_Event_Server_Data *e;
e = ecore_con_event_server_data_alloc();
EINA_SAFETY_ON_NULL_RETURN(e);
svr->event_count = eina_list_append(svr->event_count, e);
- _ecore_con_server_timer_update(svr);
- e->server = svr;
+ _ecore_con_server_timer_update(obj);
+ e->server = obj;
if (duplicate)
{
e->data = malloc(num);
e = ecore_con_event_client_add_alloc();
EINA_SAFETY_ON_NULL_RETURN(e);
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+
cl->event_count = eina_list_append(cl->event_count, e);
- cl->host_server->event_count = eina_list_append(cl->host_server->event_count, e);
+ host_server->event_count = eina_list_append(host_server->event_count, e);
_ecore_con_cl_timer_update(obj);
cl->start_time = ecore_time_get();
e->client = obj;
EINA_SAFETY_ON_NULL_RETURN(e);
cl->event_count = eina_list_append(cl->event_count, e);
- cl->host_server->event_count = eina_list_append(cl->host_server->event_count, e);
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+
+ host_server->event_count = eina_list_append(host_server->event_count, e);
_ecore_con_cl_timer_update(obj);
e->client = obj;
ecore_event_add(ECORE_CON_EVENT_CLIENT_DEL, e,
e = ecore_con_event_client_write_alloc();
EINA_SAFETY_ON_NULL_RETURN(e);
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+
cl->event_count = eina_list_append(cl->event_count, e);
- cl->host_server->event_count = eina_list_append(cl->host_server->event_count, e);
+ host_server->event_count = eina_list_append(host_server->event_count, e);
e->client = obj;
e->size = num;
ecore_event_add(ECORE_CON_EVENT_CLIENT_WRITE, e,
e = ecore_con_event_client_data_alloc();
EINA_SAFETY_ON_NULL_RETURN(e);
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+
cl->event_count = eina_list_append(cl->event_count, e);
- cl->host_server->event_count = eina_list_append(cl->host_server->event_count, e);
+ host_server->event_count = eina_list_append(host_server->event_count, e);
_ecore_con_cl_timer_update(obj);
e->client = obj;
if ((duplicate) && (num > 0))
}
void
-ecore_con_server_infos_del(Ecore_Con_Server *svr, void *info)
+ecore_con_server_infos_del(Ecore_Con_Server *obj, void *info)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
svr->infos = eina_list_remove(svr->infos, info);
}
void
-_ecore_con_event_server_error(Ecore_Con_Server *svr, char *error, Eina_Bool duplicate)
+_ecore_con_event_server_error(Ecore_Con_Server *obj, char *error, Eina_Bool duplicate)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
Ecore_Con_Event_Server_Error *e;
e = ecore_con_event_server_error_alloc();
EINA_SAFETY_ON_NULL_RETURN(e);
- e->server = svr;
+ e->server = obj;
e->error = duplicate ? strdup(error) : error;
DBG("%s", error);
svr->event_count = eina_list_append(svr->event_count, e);
e = ecore_con_event_client_error_alloc();
EINA_SAFETY_ON_NULL_RETURN(e);
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+
e->client = obj;
e->error = strdup(error);
DBG("%s", error);
cl->event_count = eina_list_append(cl->event_count, e);
- cl->host_server->event_count = eina_list_append(cl->host_server->event_count, e);
+ host_server->event_count = eina_list_append(host_server->event_count, e);
ecore_event_add(ECORE_CON_EVENT_CLIENT_ERROR, e, (Ecore_End_Cb)_ecore_con_event_client_error_free, cl->host_server);
eo_do(obj, eo_event_callback_call(ECORE_CON_EVENT_CONNECTION_ERROR, e->error));
_ecore_con_event_count++;
}
static void
-_ecore_con_server_free(Ecore_Con_Server *svr)
+_ecore_con_server_free(Ecore_Con_Server *obj)
+{
+ eo_del(obj);
+}
+
+EOLIAN static void
+_ecore_con_server_eo_base_destructor(Eo *obj, Ecore_Con_Server_Data *svr)
{
Ecore_Con_Client *cl_obj;
double t_start, t;
t_start = ecore_time_get();
while (svr->buf && (!svr->delete_me))
{
- _ecore_con_server_flush(svr);
+ _ecore_con_server_flush(obj);
t = ecore_time_get();
if ((t - t_start) > 0.5)
{
ecore_con_local_win32_server_del(svr);
#endif
if (svr->event_count) return;
- ECORE_MAGIC_SET(svr, ECORE_MAGIC_NONE);
if (svr->buf)
eina_binbuf_free(svr->buf);
if ((svr->created) && (svr->path) && (svr->ppid == getpid()))
unlink(svr->path);
- ecore_con_ssl_server_shutdown(svr);
+ ecore_con_ssl_server_shutdown(obj);
free(svr->name);
free(svr->path);
if (svr->until_deletion)
ecore_timer_del(svr->until_deletion);
- servers = eina_list_remove(servers, svr);
+ servers = eina_list_remove(servers, obj);
svr->data = NULL;
- free(svr);
+
+ eo_do_super(obj, ECORE_CON_SERVER_CLASS, eo_destructor());
}
static void
break;
}
}
- cl->host_server->clients = eina_list_remove(cl->host_server->clients, obj);
- --cl->host_server->client_count;
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+
+ host_server->clients = eina_list_remove(host_server->clients, obj);
+ --host_server->client_count;
#ifdef _WIN32
ecore_con_local_win32_client_del(cl);
if (cl->buf) eina_binbuf_free(cl->buf);
- if (cl->host_server->type & ECORE_CON_SSL)
+ if (host_server->type & ECORE_CON_SSL)
ecore_con_ssl_client_shutdown(obj);
if (cl->fd_handler)
}
static Eina_Bool
-_ecore_con_server_timer(Ecore_Con_Server *svr)
+_ecore_con_server_timer(Ecore_Con_Server *obj)
{
- ecore_con_server_del(svr);
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
+ ecore_con_server_del(obj);
svr->until_deletion = NULL;
return ECORE_CALLBACK_CANCEL;
}
static void
-_ecore_con_server_timer_update(Ecore_Con_Server *svr)
+_ecore_con_server_timer_update(Ecore_Con_Server *obj)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
if (svr->disconnect_time)
{
if (svr->disconnect_time > 0)
ecore_timer_reset(svr->until_deletion);
}
else
- svr->until_deletion = ecore_timer_add(svr->disconnect_time, (Ecore_Task_Cb)_ecore_con_server_timer, svr);
+ svr->until_deletion = ecore_timer_add(svr->disconnect_time, (Ecore_Task_Cb)_ecore_con_server_timer, obj);
}
else if (svr->until_deletion)
{
}
else
{
- if (cl->host_server->client_disconnect_time > 0)
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+
+ if (host_server->client_disconnect_time > 0)
{
if (cl->until_deletion)
{
- ecore_timer_interval_set(cl->until_deletion, cl->host_server->client_disconnect_time);
+ ecore_timer_interval_set(cl->until_deletion, host_server->client_disconnect_time);
ecore_timer_reset(cl->until_deletion);
}
else
- cl->until_deletion = ecore_timer_add(cl->host_server->client_disconnect_time, (Ecore_Task_Cb)_ecore_con_client_timer, cl);
+ cl->until_deletion = ecore_timer_add(host_server->client_disconnect_time, (Ecore_Task_Cb)_ecore_con_client_timer, cl);
}
else if (cl->until_deletion)
{
_ecore_con_cb_tcp_listen(void *data,
Ecore_Con_Info *net_info)
{
- Ecore_Con_Server *svr;
+ Ecore_Con_Server *obj = data;
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
struct linger lin;
const char *memerr = NULL;
- svr = data;
-
errno = 0;
if (!net_info) /* error message has already been handled */
{
fd_ready:
#endif
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, obj, NULL, NULL);
if (!svr->fd_handler)
{
memerr = "Memory allocation failure";
return;
error:
- if (errno || memerr) ecore_con_event_server_error(svr, memerr ? : strerror(errno));
- ecore_con_ssl_server_shutdown(svr);
- _ecore_con_server_kill(svr);
+ if (errno || memerr) ecore_con_event_server_error(obj, memerr ? : strerror(errno));
+ ecore_con_ssl_server_shutdown(obj);
+ _ecore_con_server_kill(obj);
}
static void
_ecore_con_cb_udp_listen(void *data,
Ecore_Con_Info *net_info)
{
- Ecore_Con_Server *svr;
+ Ecore_Con_Server *obj = data;
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
Ecore_Con_Type type;
struct ip_mreq mreq;
#ifdef HAVE_IPV6
const int on = 1;
const char *memerr = NULL;
- svr = data;
type = svr->type;
type &= ECORE_CON_TYPE;
#endif
svr->fd_handler =
ecore_main_fd_handler_add(svr->fd, ECORE_FD_READ,
- _ecore_con_svr_udp_handler, svr, NULL, NULL);
+ _ecore_con_svr_udp_handler, obj, NULL, NULL);
if (!svr->fd_handler)
{
memerr = "Memory allocation failure";
return;
error:
- if (errno || memerr) ecore_con_event_server_error(svr, memerr ? : strerror(errno));
- ecore_con_ssl_server_shutdown(svr);
- _ecore_con_server_kill(svr);
+ if (errno || memerr) ecore_con_event_server_error(obj, memerr ? : strerror(errno));
+ ecore_con_ssl_server_shutdown(obj);
+ _ecore_con_server_kill(obj);
}
static void
_ecore_con_cb_tcp_connect(void *data,
Ecore_Con_Info *net_info)
{
- Ecore_Con_Server *svr;
+ Ecore_Con_Server *obj = data;
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
int res;
int curstate = 0;
const char *memerr = NULL;
- svr = data;
-
errno = 0;
if (!net_info) /* error message has already been handled */
{
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_con_cl_handler, obj, NULL, NULL);
}
else
svr->fd_handler = ecore_main_fd_handler_add(svr->fd, ECORE_FD_READ,
- _ecore_con_cl_handler, svr, NULL, NULL);
+ _ecore_con_cl_handler, obj, NULL, NULL);
if (svr->type & ECORE_CON_SSL)
{
svr->handshaking = EINA_TRUE;
svr->ssl_state = ECORE_CON_SSL_STATE_INIT;
DBG("%s ssl handshake", svr->ecs_state ? "Queuing" : "Beginning");
- if ((!svr->ecs_state) && ecore_con_ssl_server_init(svr))
+ if ((!svr->ecs_state) && ecore_con_ssl_server_init(obj))
goto error;
}
return;
error:
- ecore_con_event_server_error(svr,
+ ecore_con_event_server_error(obj,
memerr ? : errno ? strerror(errno) : "DNS error");
- ecore_con_ssl_server_shutdown(svr);
- _ecore_con_server_kill(svr);
+ ecore_con_ssl_server_shutdown(obj);
+ _ecore_con_server_kill(obj);
}
static void
_ecore_con_cb_udp_connect(void *data,
Ecore_Con_Info *net_info)
{
- Ecore_Con_Server *svr;
+ Ecore_Con_Server *obj = data;
int curstate = 0;
int broadcast = 1;
const char *memerr = NULL;
- svr = data;
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
errno = 0;
if (!net_info) /* error message has already been handled */
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, obj, NULL, NULL);
if (!svr->fd_handler)
{
return;
error:
- if (errno || memerr) ecore_con_event_server_error(svr, memerr ? : strerror(errno));
- ecore_con_ssl_server_shutdown(svr);
- _ecore_con_server_kill(svr);
+ if (errno || memerr) ecore_con_event_server_error(obj, memerr ? : strerror(errno));
+ ecore_con_ssl_server_shutdown(obj);
+ _ecore_con_server_kill(obj);
}
static Ecore_Con_State
-svr_try_connect_plain(Ecore_Con_Server *svr)
+svr_try_connect_plain(Ecore_Con_Server *obj)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
int res;
int so_err = 0;
socklen_t size = sizeof(int);
if (so_err)
{
/* we lost our server! */
- ecore_con_event_server_error(svr, strerror(so_err));
+ ecore_con_event_server_error(obj, strerror(so_err));
ERR("Connection lost: %s", strerror(so_err));
- _ecore_con_server_kill(svr);
+ _ecore_con_server_kill(obj);
return ECORE_CON_DISCONNECTED;
}
{
if (svr->ecs)
{
- if (ecore_con_socks_svr_init(svr))
+ if (ecore_con_socks_svr_init(obj))
return ECORE_CON_INPROGRESS;
}
else
- ecore_con_event_server_add(svr);
+ ecore_con_event_server_add(obj);
}
if (svr->fd_handler)
_ecore_con_svr_tcp_handler(void *data,
Ecore_Fd_Handler *fd_handler EINA_UNUSED)
{
- Ecore_Con_Server *svr;
+ Ecore_Con_Server *svr_obj = data;
Ecore_Con_Client *obj = NULL;
unsigned char client_addr[256];
unsigned int client_addr_len;
const char *clerr = NULL;
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(svr_obj, ECORE_CON_SERVER_CLASS);
- svr = data;
if (svr->delete_me)
return ECORE_CALLBACK_RENEW;
Ecore_Con_Client_Data *cl = eo_data_scope_get(obj, ECORE_CON_CLIENT_CLASS);
if (!cl)
{
- ecore_con_event_server_error(svr, "Memory allocation failure when attempting to add a new client");
+ ecore_con_event_server_error(svr_obj, "Memory allocation failure when attempting to add a new client");
return ECORE_CALLBACK_RENEW;
}
- cl->host_server = svr;
+ cl->host_server = svr_obj;
client_addr_len = sizeof(client_addr);
memset(&client_addr, 0, client_addr_len);
}
}
free(cl);
- if (clerr || errno) ecore_con_event_server_error(svr, clerr ? : strerror(errno));
+ if (clerr || errno) ecore_con_event_server_error(svr_obj, clerr ? : strerror(errno));
return ECORE_CALLBACK_RENEW;
}
static void
-_ecore_con_cl_read(Ecore_Con_Server *svr)
+_ecore_con_cl_read(Ecore_Con_Server *obj)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
int num = 0;
Eina_Bool lost_server = EINA_TRUE;
unsigned char buf[READBUFSIZ];
DBG("svr=%p", svr);
/* only possible with non-ssl connections */
- if (svr->connecting && (svr_try_connect_plain(svr) != ECORE_CON_CONNECTED))
+ if (svr->connecting && (svr_try_connect_plain(obj) != ECORE_CON_CONNECTED))
return;
if (svr->handshaking && (!svr->ecs_state))
{
DBG("Continuing ssl handshake");
- if (!ecore_con_ssl_server_init(svr))
+ if (!ecore_con_ssl_server_init(obj))
lost_server = EINA_FALSE;
- _ecore_con_server_timer_update(svr);
+ _ecore_con_server_timer_update(obj);
}
if (svr->ecs_state || !(svr->type & ECORE_CON_SSL))
if ((num > 0) || ((num < 0) && (errno == EAGAIN)))
lost_server = EINA_FALSE;
else if (num < 0)
- ecore_con_event_server_error(svr, strerror(errno));
+ ecore_con_event_server_error(obj, strerror(errno));
}
else
{
- num = ecore_con_ssl_server_read(svr, buf, sizeof(buf));
+ num = ecore_con_ssl_server_read(obj, buf, sizeof(buf));
/* this is not an actual 0 return, 0 here just means non-fatal error such as EAGAIN */
if (num >= 0)
lost_server = EINA_FALSE;
if ((!svr->delete_me) && (num > 0))
{
if (svr->ecs_state)
- ecore_con_socks_read(svr, buf, num);
+ ecore_con_socks_read(obj, buf, num);
else
- ecore_con_event_server_data(svr, buf, num, EINA_TRUE);
+ ecore_con_event_server_data(obj, buf, num, EINA_TRUE);
}
if (lost_server)
- _ecore_con_server_kill(svr);
+ _ecore_con_server_kill(obj);
}
static Eina_Bool
_ecore_con_cl_handler(void *data,
Ecore_Fd_Handler *fd_handler)
{
- Ecore_Con_Server *svr;
+ Ecore_Con_Server *obj = data;
Eina_Bool want_read, want_write;
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
- svr = data;
if (svr->delete_me)
return ECORE_CALLBACK_RENEW;
DBG("%zu bytes in buffer", len);
}
#endif
- if (ecore_con_ssl_server_init(svr))
+ if (ecore_con_ssl_server_init(obj))
{
ERR("ssl handshaking failed!");
svr->handshaking = EINA_FALSE;
}
else if (!svr->ssl_state)
- ecore_con_event_server_add(svr);
+ ecore_con_event_server_add(obj);
return ECORE_CALLBACK_RENEW;
}
if (svr->ecs && svr->ecs_state && (svr->ecs_state < ECORE_CON_PROXY_STATE_READ) && (!svr->ecs_buf))
INF("PROXY STATE++");
svr->ecs_state++;
}
- if (ecore_con_socks_svr_init(svr)) return ECORE_CALLBACK_RENEW;
+ if (ecore_con_socks_svr_init(obj)) return ECORE_CALLBACK_RENEW;
}
if (want_read)
- _ecore_con_cl_read(svr);
+ _ecore_con_cl_read(obj);
else if (want_write) /* only possible with non-ssl connections */
{
- if (svr->connecting && (!svr_try_connect_plain(svr)) && (!svr->ecs_state))
+ if (svr->connecting && (!svr_try_connect_plain(obj)) && (!svr->ecs_state))
return ECORE_CALLBACK_RENEW;
- _ecore_con_server_flush(svr);
+ _ecore_con_server_flush(obj);
}
return ECORE_CALLBACK_RENEW;
{
unsigned char buf[READBUFSIZ];
int num;
- Ecore_Con_Server *svr;
+ Ecore_Con_Server *obj = data;
Eina_Bool want_read, want_write;
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
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);
- svr = data;
if (svr->delete_me || ((!want_read) && (!want_write)))
return ECORE_CALLBACK_RENEW;
if (want_write)
{
- _ecore_con_server_flush(svr);
+ _ecore_con_server_flush(obj);
return ECORE_CALLBACK_RENEW;
}
num = read(svr->fd, buf, READBUFSIZ);
if ((!svr->delete_me) && (num > 0))
- ecore_con_event_server_data(svr, buf, num, EINA_TRUE);
+ ecore_con_event_server_data(obj, buf, num, EINA_TRUE);
if (num < 0 && (errno != EAGAIN) && (errno != EINTR))
{
- ecore_con_event_server_error(svr, strerror(errno));
- _ecore_con_server_kill(svr);
+ ecore_con_event_server_error(obj, strerror(errno));
+ _ecore_con_server_kill(obj);
}
return ECORE_CALLBACK_RENEW;
unsigned char client_addr[256];
socklen_t client_addr_len = sizeof(client_addr);
int num;
- Ecore_Con_Server *svr;
+ Ecore_Con_Server *svr_obj = data;
Ecore_Con_Client *obj = NULL;
- svr = data;
-
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(svr_obj, ECORE_CON_SERVER_CLASS);
if (svr->delete_me)
return ECORE_CALLBACK_RENEW;
if (num < 0 && (errno != EAGAIN) && (errno != EINTR))
{
- ecore_con_event_server_error(svr, strerror(errno));
+ ecore_con_event_server_error(svr_obj, strerror(errno));
if (!svr->delete_me)
ecore_con_event_client_del(NULL);
- _ecore_con_server_kill(svr);
+ _ecore_con_server_kill(svr_obj);
return ECORE_CALLBACK_CANCEL;
}
Ecore_Con_Client_Data *cl = eo_data_scope_get(obj, ECORE_CON_CLIENT_CLASS);
EINA_SAFETY_ON_NULL_RETURN_VAL(cl, ECORE_CALLBACK_RENEW);
- cl->host_server = svr;
+ cl->host_server = svr_obj;
cl->client_addr = malloc(client_addr_len);
if (!cl->client_addr)
{
_ecore_con_cl_timer_update(obj);
}
- if (!(cl->host_server->type & ECORE_CON_SSL) && (!cl->upgrade))
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+ if (!(host_server->type & ECORE_CON_SSL) && (!cl->upgrade))
{
num = read(cl->fd, buf, sizeof(buf));
/* 0 is not a valid return value for a tcp socket */
}
static void
-_ecore_con_server_flush(Ecore_Con_Server *svr)
+_ecore_con_server_flush(Ecore_Con_Server *obj)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
int count;
size_t num;
size_t buf_len;
if ((!svr->ecs_state) && svr->handshaking)
{
DBG("Continuing ssl handshake");
- if (ecore_con_ssl_server_init(svr))
- _ecore_con_server_kill(svr);
- _ecore_con_server_timer_update(svr);
+ if (ecore_con_ssl_server_init(obj))
+ _ecore_con_server_kill(obj);
+ _ecore_con_server_timer_update(obj);
return;
}
if (svr->ecs_state || (!(svr->type & ECORE_CON_SSL)))
count = write(svr->fd, buf + *buf_offset, num);
else
- count = ecore_con_ssl_server_write(svr, buf + *buf_offset, num);
+ count = ecore_con_ssl_server_write(obj, buf + *buf_offset, num);
if (count < 0)
{
if ((errno != EAGAIN) && (errno != EINTR))
{
- ecore_con_event_server_error(svr, strerror(errno));
- _ecore_con_server_kill(svr);
+ ecore_con_event_server_error(obj, strerror(errno));
+ _ecore_con_server_kill(obj);
}
return;
}
- if (count && (!svr->ecs_state)) ecore_con_event_server_write(svr, count);
+ if (count && (!svr->ecs_state)) ecore_con_event_server_write(obj, count);
if (!eina_binbuf_remove(buf_p, 0, count))
*buf_offset += count;
if (!cl->buf) return;
num = eina_binbuf_length_get(cl->buf) - cl->buf_offset;
if (num <= 0) return;
- if (!(cl->host_server->type & ECORE_CON_SSL) && (!cl->upgrade))
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+ if (!(host_server->type & ECORE_CON_SSL) && (!cl->upgrade))
count = write(cl->fd, eina_binbuf_string_get(cl->buf) + cl->buf_offset, num);
else
count = ecore_con_ssl_client_write(obj, eina_binbuf_string_get(cl->buf) + cl->buf_offset, num);
eina_binbuf_free(cl->buf);
cl->buf = NULL;
#ifdef TCP_CORK
- if ((cl->host_server->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_CORK)
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+ if ((host_server->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_CORK)
{
int state = 0;
if (setsockopt(cl->fd, IPPROTO_TCP, TCP_CORK, (char *)&state, sizeof(int)) < 0)
}
static void
-_ecore_con_event_client_add_free(Ecore_Con_Server *svr,
+_ecore_con_event_client_add_free(Ecore_Con_Server *obj,
void *ev)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
Ecore_Con_Event_Client_Add *e;
e = ev;
cl->event_count = eina_list_remove(cl->event_count, e);
if (cl->host_server)
{
- cl->host_server->event_count = eina_list_remove(cl->host_server->event_count, ev);
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+ host_server->event_count = eina_list_remove(host_server->event_count, ev);
if ((!svr->event_count) && (svr->delete_me))
{
- _ecore_con_server_free(svr);
+ _ecore_con_server_free(obj);
svrfreed = EINA_TRUE;
}
}
}
static void
-_ecore_con_event_client_del_free(Ecore_Con_Server *svr,
+_ecore_con_event_client_del_free(Ecore_Con_Server *obj,
void *ev)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
Ecore_Con_Event_Client_Del *e;
e = ev;
cl->event_count = eina_list_remove(cl->event_count, e);
if (cl->host_server)
{
- cl->host_server->event_count = eina_list_remove(cl->host_server->event_count, ev);
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+ host_server->event_count = eina_list_remove(host_server->event_count, ev);
if ((!svr->event_count) && (svr->delete_me))
{
- _ecore_con_server_free(svr);
+ _ecore_con_server_free(obj);
svrfreed = EINA_TRUE;
}
}
}
static void
-_ecore_con_event_client_write_free(Ecore_Con_Server *svr,
+_ecore_con_event_client_write_free(Ecore_Con_Server *obj,
Ecore_Con_Event_Client_Write *e)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
if (e->client)
{
Ecore_Con_Client_Data *cl = eo_data_scope_get(e->client, ECORE_CON_CLIENT_CLASS);
cl->event_count = eina_list_remove(cl->event_count, e);
if (cl->host_server)
{
- cl->host_server->event_count = eina_list_remove(cl->host_server->event_count, e);
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+ host_server->event_count = eina_list_remove(host_server->event_count, e);
if ((!svr->event_count) && (svr->delete_me))
{
- _ecore_con_server_free(svr);
+ _ecore_con_server_free(obj);
svrfreed = EINA_TRUE;
}
}
if (!svrfreed)
{
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
if (((!cl->event_count) && (cl->delete_me)) ||
((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))))
+ ((host_server->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_UDP ||
+ (host_server->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_MCAST))))
ecore_con_client_del(e->client);
}
}
}
static void
-_ecore_con_event_client_data_free(Ecore_Con_Server *svr,
+_ecore_con_event_client_data_free(Ecore_Con_Server *obj,
void *ev)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
Ecore_Con_Event_Client_Data *e;
e = ev;
cl->event_count = eina_list_remove(cl->event_count, e);
if (cl->host_server)
{
- cl->host_server->event_count = eina_list_remove(cl->host_server->event_count, ev);
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+ host_server->event_count = eina_list_remove(host_server->event_count, ev);
}
if ((!svr->event_count) && (svr->delete_me))
{
- _ecore_con_server_free(svr);
+ _ecore_con_server_free(obj);
svrfreed = EINA_TRUE;
}
if (!svrfreed)
{
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
if (((!cl->event_count) && (cl->delete_me)) ||
((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))))
+ ((host_server->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_UDP ||
+ (host_server->type & ECORE_CON_TYPE) == ECORE_CON_REMOTE_MCAST))))
ecore_con_client_del(e->client);
}
}
e = ev;
if (e->server)
{
- e->server->event_count = eina_list_remove(e->server->event_count, ev);
- if ((!e->server->event_count) && (e->server->delete_me))
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(e->server, ECORE_CON_SERVER_CLASS);
+ svr->event_count = eina_list_remove(svr->event_count, ev);
+ if ((!svr->event_count) && (svr->delete_me))
_ecore_con_server_free(e->server);
}
ecore_con_event_server_add_free(e);
e = ev;
if (e->server)
{
- e->server->event_count = eina_list_remove(e->server->event_count, ev);
- if (!e->server->event_count)
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(e->server, ECORE_CON_SERVER_CLASS);
+ svr->event_count = eina_list_remove(svr->event_count, ev);
+ if (!svr->event_count)
_ecore_con_server_free(e->server);
}
ecore_con_event_server_del_free(e);
{
if (e->server)
{
- e->server->event_count = eina_list_remove(e->server->event_count, e);
- if ((!e->server->event_count) && (e->server->delete_me))
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(e->server, ECORE_CON_SERVER_CLASS);
+ svr->event_count = eina_list_remove(svr->event_count, e);
+ if ((!svr->event_count) && (svr->delete_me))
_ecore_con_server_free(e->server);
}
e = ev;
if (e->server)
{
- e->server->event_count = eina_list_remove(e->server->event_count, ev);
- if ((!e->server->event_count) && (e->server->delete_me))
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(e->server, ECORE_CON_SERVER_CLASS);
+ svr->event_count = eina_list_remove(svr->event_count, ev);
+ if ((!svr->event_count) && (svr->delete_me))
_ecore_con_server_free(e->server);
}
{
if (e->server)
{
- e->server->event_count = eina_list_remove(e->server->event_count, e);
- if ((!e->server->event_count) && (e->server->delete_me))
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(e->server, ECORE_CON_SERVER_CLASS);
+ svr->event_count = eina_list_remove(svr->event_count, e);
+ if ((!svr->event_count) && (svr->delete_me))
_ecore_con_server_free(e->server);
}
free(e->error);
}
static void
-_ecore_con_event_client_error_free(Ecore_Con_Server *svr, Ecore_Con_Event_Client_Error *e)
+_ecore_con_event_client_error_free(Ecore_Con_Server *obj, Ecore_Con_Event_Client_Error *e)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
if (e->client)
{
Ecore_Con_Client_Data *cl = eo_data_scope_get(e->client, ECORE_CON_CLIENT_CLASS);
if (!svrfreed)
{
if ((!svr->event_count) && (svr->delete_me))
- _ecore_con_server_free(svr);
+ _ecore_con_server_free(obj);
}
}
free(e->error);
_ecore_con_lookup_done(void *data,
Ecore_Con_Info *infos)
{
- Ecore_Con_Server *svr;
+ Ecore_Con_Server *obj = data;
Ecore_Con_Lookup *lk;
- svr = data;
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
lk = svr->data;
if (infos)
#include "ecore_con.eo.c"
#include "ecore_con_client.eo.c"
+#include "ecore_con_server.eo.c"
}
static Eina_Bool
-_ecore_con_socks_svr_init_v4(Ecore_Con_Server *svr, Ecore_Con_Socks_v4 *v4)
+_ecore_con_socks_svr_init_v4(Ecore_Con_Server *obj, Ecore_Con_Socks_v4 *v4)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
size_t addrlen, buflen, ulen = 1;
unsigned char *sbuf;
sbuf = malloc(buflen);
if (!sbuf)
{
- ecore_con_event_server_error(svr, "Memory allocation failure!");
- _ecore_con_server_kill(svr);
+ ecore_con_event_server_error(obj, "Memory allocation failure!");
+ _ecore_con_server_kill(obj);
return EINA_FALSE;
}
/* http://en.wikipedia.org/wiki/SOCKS */
}
static Eina_Bool
-_ecore_con_socks_svr_init_v5(Ecore_Con_Server *svr, Ecore_Con_Socks_v5 *v5)
+_ecore_con_socks_svr_init_v5(Ecore_Con_Server *obj, Ecore_Con_Socks_v5 *v5)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
size_t buflen;
unsigned int x;
unsigned char *sbuf;
sbuf = malloc(buflen);
if (!sbuf)
{
- ecore_con_event_server_error(svr, "Memory allocation failure!");
- _ecore_con_server_kill(svr);
+ ecore_con_event_server_error(obj, "Memory allocation failure!");
+ _ecore_con_server_kill(obj);
return EINA_FALSE;
}
/* http://en.wikipedia.org/wiki/SOCKS
data = buf
static void
-_ecore_con_socks_read_v4(Ecore_Con_Server *svr, Ecore_Con_Socks_v4 *v4 EINA_UNUSED, const unsigned char *buf, unsigned int num)
+_ecore_con_socks_read_v4(Ecore_Con_Server *obj, Ecore_Con_Socks_v4 *v4 EINA_UNUSED, const unsigned char *buf, unsigned int num)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
const unsigned char *data;
DBG("SOCKS: %d bytes", num);
ECORE_CON_SOCKS_READ(8);
break;
case 91:
- ecore_con_event_server_error(svr, "proxy request rejected or failed");
+ ecore_con_event_server_error(obj, "proxy request rejected or failed");
goto error;
case 92:
- ecore_con_event_server_error(svr, "proxying SOCKS server could not perform authentication");
+ ecore_con_event_server_error(obj, "proxying SOCKS server could not perform authentication");
goto error;
case 93:
- ecore_con_event_server_error(svr, "proxy request authentication rejected");
+ ecore_con_event_server_error(obj, "proxy request authentication rejected");
goto error;
default:
- ecore_con_event_server_error(svr, "garbage data from proxy");
+ ecore_con_event_server_error(obj, "garbage data from proxy");
goto error;
}
if (svr->ecs->bind)
if (!inet_ntop(AF_INET, &data[4], naddr, sizeof(naddr))) goto error;
svr->proxyip = eina_stringshare_add(naddr);
- ecore_con_event_proxy_bind(svr);
+ ecore_con_event_proxy_bind(obj);
}
svr->ecs_state = ECORE_CON_PROXY_STATE_DONE;
INF("PROXY CONNECTED");
svr->ecs_buf_offset = svr->ecs_addrlen = 0;
memset(svr->ecs_addr, 0, sizeof(svr->ecs_addr));
if (!svr->ssl_state)
- ecore_con_event_server_add(svr);
+ ecore_con_event_server_add(obj);
if (svr->ssl_state || (svr->buf && eina_binbuf_length_get(svr->buf)))
ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_READ | ECORE_FD_WRITE);
return;
error:
- _ecore_con_server_kill(svr);
+ _ecore_con_server_kill(obj);
}
static Eina_Bool
-_ecore_con_socks_auth_v5(Ecore_Con_Server *svr, Ecore_Con_Socks_v5 *v5)
+_ecore_con_socks_auth_v5(Ecore_Con_Server *obj, Ecore_Con_Socks_v5 *v5)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
size_t size;
unsigned char *data;
switch (v5->method)
}
static void
-_ecore_con_socks_read_v5(Ecore_Con_Server *svr, Ecore_Con_Socks_v5 *v5, const unsigned char *buf, unsigned int num)
+_ecore_con_socks_read_v5(Ecore_Con_Server *obj, Ecore_Con_Socks_v5 *v5, const unsigned char *buf, unsigned int num)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
const unsigned char *data;
DBG("SOCKS: %d bytes", num);
if (data[0] != 5) goto error;
if (data[1] == 0xFF)
{
- ecore_con_event_server_error(svr, "proxy authentication methods rejected");
+ ecore_con_event_server_error(obj, "proxy authentication methods rejected");
goto error;
}
v5->method = data[1];
- if (!_ecore_con_socks_auth_v5(svr, v5)) goto error;
+ if (!_ecore_con_socks_auth_v5(obj, v5)) goto error;
if (svr->ecs_state == ECORE_CON_PROXY_STATE_REQUEST)
{
/* run again to skip auth reading */
- _ecore_con_socks_read_v5(svr, v5, NULL, 0);
+ _ecore_con_socks_read_v5(obj, v5, NULL, 0);
return;
}
ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_WRITE);
case ECORE_CON_SOCKS_V5_METHOD_USERPASS:
if (data[0] != 1)
{
- ecore_con_event_server_error(svr, "protocol error");
+ ecore_con_event_server_error(obj, "protocol error");
goto error; /* wrong version */
}
if (data[1])
{
- ecore_con_event_server_error(svr, "proxy request authentication rejected");
+ ecore_con_event_server_error(obj, "proxy request authentication rejected");
goto error;
}
sbuf = malloc(buflen);
if (!sbuf)
{
- ecore_con_event_server_error(svr, "Memory allocation failure!");
+ ecore_con_event_server_error(obj, "Memory allocation failure!");
goto error;
}
sbuf[0] = 5;
break;
default:
- ecore_con_event_server_error(svr, "protocol error");
+ ecore_con_event_server_error(obj, "protocol error");
goto error;
}
/* at this point, we finally know exactly how much we need to read */
if (data[0] != 5)
{
- ecore_con_event_server_error(svr, "protocol error");
+ ecore_con_event_server_error(obj, "protocol error");
goto error; /* wrong version */
}
switch (data[1])
break;
case 1:
- ecore_con_event_server_error(svr, "general proxy failure");
+ ecore_con_event_server_error(obj, "general proxy failure");
goto error;
case 2:
- ecore_con_event_server_error(svr, "connection not allowed by ruleset");
+ ecore_con_event_server_error(obj, "connection not allowed by ruleset");
goto error;
case 3:
- ecore_con_event_server_error(svr, "network unreachable");
+ ecore_con_event_server_error(obj, "network unreachable");
goto error;
case 4:
- ecore_con_event_server_error(svr, "host unreachable");
+ ecore_con_event_server_error(obj, "host unreachable");
goto error;
case 5:
- ecore_con_event_server_error(svr, "connection refused by destination host");
+ ecore_con_event_server_error(obj, "connection refused by destination host");
goto error;
case 6:
- ecore_con_event_server_error(svr, "TTL expired");
+ ecore_con_event_server_error(obj, "TTL expired");
goto error;
case 7:
- ecore_con_event_server_error(svr, "command not supported / protocol error");
+ ecore_con_event_server_error(obj, "command not supported / protocol error");
goto error;
case 8:
- ecore_con_event_server_error(svr, "address type not supported");
+ ecore_con_event_server_error(obj, "address type not supported");
default:
goto error;
}
if (data[2])
{
- ecore_con_event_server_error(svr, "protocol error");
+ ecore_con_event_server_error(obj, "protocol error");
goto error;
}
memset(svr->ecs_addr, 0, sizeof(svr->ecs_addr));
if (!svr->ssl_state)
- ecore_con_event_server_add(svr);
+ ecore_con_event_server_add(obj);
if (svr->ssl_state || (svr->buf && eina_binbuf_length_get(svr->buf)))
ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_READ | ECORE_FD_WRITE);
svr->ecs_buf_offset = svr->ecs_addrlen = 0;
return;
error:
- _ecore_con_server_kill(svr);
+ _ecore_con_server_kill(obj);
}
/////////////////////////////////////////////////////////////////////////////////////
}
void
-ecore_con_socks_read(Ecore_Con_Server *svr, unsigned char *buf, int num)
+ecore_con_socks_read(Ecore_Con_Server *obj, unsigned char *buf, int num)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
ECORE_CON_SOCKS_VERSION_CHECK(svr->ecs);
ECORE_CON_SOCKS_CAST(svr->ecs);
if (svr->ecs_state < ECORE_CON_PROXY_STATE_READ) return;
- if (v4) _ecore_con_socks_read_v4(svr, v4, buf, (unsigned int)num);
- else _ecore_con_socks_read_v5(svr, v5, buf, (unsigned int)num);
+ if (v4) _ecore_con_socks_read_v4(obj, v4, buf, (unsigned int)num);
+ else _ecore_con_socks_read_v5(obj, v5, buf, (unsigned int)num);
}
Eina_Bool
-ecore_con_socks_svr_init(Ecore_Con_Server *svr)
+ecore_con_socks_svr_init(Ecore_Con_Server *obj)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
ECORE_CON_SOCKS_VERSION_CHECK_RETURN(svr->ecs, EINA_FALSE);
ECORE_CON_SOCKS_CAST(svr->ecs);
if (svr->ecs_buf) return EINA_FALSE;
if (svr->ecs_state != ECORE_CON_PROXY_STATE_INIT) return EINA_FALSE;
ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_WRITE);
- if (v4) return _ecore_con_socks_svr_init_v4(svr, v4);
- return _ecore_con_socks_svr_init_v5(svr, v5);
+ if (v4) return _ecore_con_socks_svr_init_v4(obj, v4);
+ return _ecore_con_socks_svr_init_v5(obj, v5);
}
void
-ecore_con_socks_dns_cb(const char *canonname EINA_UNUSED, const char *ip, struct sockaddr *addr, int addrlen EINA_UNUSED, Ecore_Con_Server *svr)
+ecore_con_socks_dns_cb(const char *canonname EINA_UNUSED, const char *ip, struct sockaddr *addr, int addrlen EINA_UNUSED, Ecore_Con_Server *obj)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
svr->ip = eina_stringshare_add(ip);
svr->ecs_state++;
if (addr->sa_family == AF_INET)
svr->ecs_addrlen = 16;
}
#endif
- ecore_con_socks_svr_init(svr);
+ ecore_con_socks_svr_init(obj);
}
void
}
Ecore_Con_Ssl_Error
-ecore_con_ssl_server_init(Ecore_Con_Server *svr)
+ecore_con_ssl_server_init(Ecore_Con_Server *obj)
{
- if (!(svr->type & ECORE_CON_SSL))
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
+ if (!svr || !(svr->type & ECORE_CON_SSL))
return ECORE_CON_SSL_ERROR_NONE;
- return SSL_SUFFIX(_ecore_con_ssl_server_init) (svr);
+ return SSL_SUFFIX(_ecore_con_ssl_server_init) (obj);
}
Ecore_Con_Ssl_Error
-ecore_con_ssl_server_shutdown(Ecore_Con_Server *svr)
+ecore_con_ssl_server_shutdown(Ecore_Con_Server *obj)
{
- if (!(svr->type & ECORE_CON_SSL))
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
+ if (!svr || !(svr->type & ECORE_CON_SSL))
return ECORE_CON_SSL_ERROR_NONE;
- return SSL_SUFFIX(_ecore_con_ssl_server_shutdown) (svr);
+ return SSL_SUFFIX(_ecore_con_ssl_server_shutdown) (obj);
}
int
ecore_con_ssl_client_init(Ecore_Con_Client *obj)
{
Ecore_Con_Client_Data *cl = eo_data_scope_get(obj, ECORE_CON_CLIENT_CLASS);
- if (!(cl->host_server->type & ECORE_CON_SSL))
+ if (!cl)
+ return ECORE_CON_SSL_ERROR_NONE;
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+ if (host_server || !(host_server->type & ECORE_CON_SSL))
return ECORE_CON_SSL_ERROR_NONE;
return SSL_SUFFIX(_ecore_con_ssl_client_init) (obj);
}
ecore_con_ssl_client_shutdown(Ecore_Con_Client *obj)
{
Ecore_Con_Client_Data *cl = eo_data_scope_get(obj, ECORE_CON_CLIENT_CLASS);
- if (!(cl->host_server->type & ECORE_CON_SSL))
+ if (!cl)
+ return ECORE_CON_SSL_ERROR_NONE;
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+ if (!host_server || !(host_server->type & ECORE_CON_SSL))
return ECORE_CON_SSL_ERROR_NONE;
return SSL_SUFFIX(_ecore_con_ssl_client_shutdown) (obj);
}
* @param svr The server object
*/
EAPI void
-ecore_con_ssl_server_verify(Ecore_Con_Server *svr)
+ecore_con_ssl_server_verify(Ecore_Con_Server *obj)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, "ecore_con_ssl_server_verify");
- return;
- }
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
+ if (!svr) return;
+
svr->verify = EINA_TRUE;
}
* @since 1.1
*/
EAPI void
-ecore_con_ssl_server_verify_basic(Ecore_Con_Server *svr)
+ecore_con_ssl_server_verify_basic(Ecore_Con_Server *obj)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, __func__);
- return;
- }
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
+ if (!svr) return;
+
svr->verify_basic = EINA_TRUE;
}
* @since 1.2
*/
EAPI void
-ecore_con_ssl_server_verify_name_set(Ecore_Con_Server *svr, const char *name)
+ecore_con_ssl_server_verify_name_set(Ecore_Con_Server *obj, const char *name)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, __func__);
- return;
- }
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
+ if (!svr) return;
+
eina_stringshare_replace(&svr->verify_name, name);
}
* @since 1.2
*/
EAPI const char *
-ecore_con_ssl_server_verify_name_get(Ecore_Con_Server *svr)
+ecore_con_ssl_server_verify_name_get(Ecore_Con_Server *obj)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, __func__);
- return NULL;
- }
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
+ if (!svr) return NULL;
+
return svr->verify_name ? : svr->name;
}
*/
EAPI Eina_Bool
-ecore_con_ssl_server_cert_add(Ecore_Con_Server *svr,
+ecore_con_ssl_server_cert_add(Ecore_Con_Server *obj,
const char *cert)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, "ecore_con_ssl_server_cert_add");
- return EINA_FALSE;
- }
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
+ if (!svr) return EINA_FALSE;
if (!svr->ssl_prepared)
{
svr->use_cert = EINA_TRUE;
svr->type |= ECORE_CON_USE_MIXED | ECORE_CON_LOAD_CERT;
- if (ecore_con_ssl_server_prepare(svr, svr->type & ECORE_CON_SSL))
+ if (ecore_con_ssl_server_prepare(obj, svr->type & ECORE_CON_SSL))
return EINA_FALSE;
}
- return SSL_SUFFIX(_ecore_con_ssl_server_cert_add) (svr, cert);
+ return SSL_SUFFIX(_ecore_con_ssl_server_cert_add) (obj, cert);
}
/**
*/
EAPI Eina_Bool
-ecore_con_ssl_server_cafile_add(Ecore_Con_Server *svr,
+ecore_con_ssl_server_cafile_add(Ecore_Con_Server *obj,
const char *ca_file)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, "ecore_con_ssl_server_cafile_add");
- return EINA_FALSE;
- }
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
+ if (!svr) return EINA_FALSE;
if (!svr->ssl_prepared)
{
svr->use_cert = EINA_TRUE;
svr->type |= ECORE_CON_USE_MIXED | ECORE_CON_LOAD_CERT;
- if (ecore_con_ssl_server_prepare(svr, svr->type & ECORE_CON_SSL))
+ if (ecore_con_ssl_server_prepare(obj, svr->type & ECORE_CON_SSL))
return EINA_FALSE;
}
- return SSL_SUFFIX(_ecore_con_ssl_server_cafile_add) (svr, ca_file);
+ return SSL_SUFFIX(_ecore_con_ssl_server_cafile_add) (obj, ca_file);
}
/**
*/
EAPI Eina_Bool
-ecore_con_ssl_server_privkey_add(Ecore_Con_Server *svr,
+ecore_con_ssl_server_privkey_add(Ecore_Con_Server *obj,
const char *key_file)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, "ecore_con_ssl_server_privkey_add");
- return EINA_FALSE;
- }
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
+ if (!svr) return EINA_FALSE;
if (!svr->ssl_prepared)
{
svr->use_cert = EINA_TRUE;
svr->type |= ECORE_CON_USE_MIXED | ECORE_CON_LOAD_CERT;
- if (ecore_con_ssl_server_prepare(svr, svr->type & ECORE_CON_SSL))
+ if (ecore_con_ssl_server_prepare(obj, svr->type & ECORE_CON_SSL))
return EINA_FALSE;
}
- return SSL_SUFFIX(_ecore_con_ssl_server_privkey_add) (svr, key_file);
+ return SSL_SUFFIX(_ecore_con_ssl_server_privkey_add) (obj, key_file);
}
/**
*/
EAPI Eina_Bool
-ecore_con_ssl_server_crl_add(Ecore_Con_Server *svr,
+ecore_con_ssl_server_crl_add(Ecore_Con_Server *obj,
const char *crl_file)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, "ecore_con_ssl_server_crl_add");
- return EINA_FALSE;
- }
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
+ if (!svr) return EINA_FALSE;
if (!svr->ssl_prepared)
{
svr->use_cert = EINA_TRUE;
svr->type |= ECORE_CON_USE_MIXED | ECORE_CON_LOAD_CERT;
- if (ecore_con_ssl_server_prepare(svr, svr->type & ECORE_CON_SSL))
+ if (ecore_con_ssl_server_prepare(obj, svr->type & ECORE_CON_SSL))
return EINA_FALSE;
}
- return SSL_SUFFIX(_ecore_con_ssl_server_crl_add) (svr, crl_file);
+ return SSL_SUFFIX(_ecore_con_ssl_server_crl_add) (obj, crl_file);
}
/**
*/
EAPI Eina_Bool
-ecore_con_ssl_server_upgrade(Ecore_Con_Server *svr, Ecore_Con_Type ssl_type)
+ecore_con_ssl_server_upgrade(Ecore_Con_Server *obj, Ecore_Con_Type ssl_type)
{
- if (!ECORE_MAGIC_CHECK(svr, ECORE_MAGIC_CON_SERVER))
- {
- ECORE_MAGIC_FAIL(svr, ECORE_MAGIC_CON_SERVER, __func__);
- return EINA_FALSE;
- }
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
+ if (!svr) return EINA_FALSE;
#if _ECORE_CON_SSL_AVAILABLE == 0
return EINA_FALSE;
#endif
if (!svr->ssl_prepared)
{
- if (ecore_con_ssl_server_prepare(svr, ssl_type))
+ if (ecore_con_ssl_server_prepare(obj, ssl_type))
return EINA_FALSE;
}
if (!svr->use_cert)
svr->upgrade = EINA_TRUE;
svr->handshaking = EINA_TRUE;
svr->ssl_state = ECORE_CON_SSL_STATE_INIT;
- return !SSL_SUFFIX(_ecore_con_ssl_server_init) (svr);
+ return !SSL_SUFFIX(_ecore_con_ssl_server_init) (obj);
}
/**
return EINA_FALSE;
#endif
- if (!cl->host_server->ssl_prepared)
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
+ if (!host_server->ssl_prepared)
{
if (ecore_con_ssl_server_prepare(cl->host_server, ssl_type))
return EINA_FALSE;
}
- if (!cl->host_server->use_cert)
- cl->host_server->type |= ssl_type;
+ if (!host_server->use_cert)
+ host_server->type |= ssl_type;
cl->upgrade = EINA_TRUE;
- cl->host_server->upgrade = EINA_TRUE;
+ host_server->upgrade = EINA_TRUE;
cl->handshaking = EINA_TRUE;
cl->ssl_state = ECORE_CON_SSL_STATE_INIT;
return SSL_SUFFIX(_ecore_con_ssl_client_init) (obj);
}
static Ecore_Con_Ssl_Error
-_ecore_con_ssl_server_prepare_openssl(Ecore_Con_Server *svr,
+_ecore_con_ssl_server_prepare_openssl(Ecore_Con_Server *obj,
int ssl_type)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
long options;
int dh = 0;
}
else
_openssl_print_errors(svr, ECORE_CON_EVENT_SERVER_ERROR);
- _ecore_con_ssl_server_shutdown_openssl(svr);
+ _ecore_con_ssl_server_shutdown_openssl(obj);
return ECORE_CON_SSL_ERROR_SERVER_INIT_FAILED;
}
static Ecore_Con_Ssl_Error
-_ecore_con_ssl_server_init_openssl(Ecore_Con_Server *svr)
+_ecore_con_ssl_server_init_openssl(Ecore_Con_Server *obj)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
int ret = -1;
switch (svr->ssl_state)
error:
_openssl_print_errors(svr, ECORE_CON_EVENT_SERVER_ERROR);
- _ecore_con_ssl_server_shutdown_openssl(svr);
+ _ecore_con_ssl_server_shutdown_openssl(obj);
return ECORE_CON_SSL_ERROR_SERVER_INIT_FAILED;
}
static Eina_Bool
-_ecore_con_ssl_server_cafile_add_openssl(Ecore_Con_Server *svr,
+_ecore_con_ssl_server_cafile_add_openssl(Ecore_Con_Server *obj,
const char *ca_file)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
struct stat st;
if (stat(ca_file, &st)) return EINA_FALSE;
}
static Eina_Bool
-_ecore_con_ssl_server_crl_add_openssl(Ecore_Con_Server *svr,
+_ecore_con_ssl_server_crl_add_openssl(Ecore_Con_Server *obj,
const char *crl_file)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
X509_STORE *st;
X509_LOOKUP *lu;
static Eina_Bool flag = EINA_FALSE;
}
static Eina_Bool
-_ecore_con_ssl_server_privkey_add_openssl(Ecore_Con_Server *svr,
+_ecore_con_ssl_server_privkey_add_openssl(Ecore_Con_Server *obj,
const char *key_file)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
FILE *fp = NULL;
EVP_PKEY *privkey = NULL;
}
static Eina_Bool
-_ecore_con_ssl_server_cert_add_openssl(Ecore_Con_Server *svr,
+_ecore_con_ssl_server_cert_add_openssl(Ecore_Con_Server *obj,
const char *cert_file)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
FILE *fp = NULL;
X509 *cert = NULL;
}
static Ecore_Con_Ssl_Error
-_ecore_con_ssl_server_shutdown_openssl(Ecore_Con_Server *svr)
+_ecore_con_ssl_server_shutdown_openssl(Ecore_Con_Server *obj)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
if (svr->ssl)
{
if (!SSL_shutdown(svr->ssl))
}
static int
-_ecore_con_ssl_server_read_openssl(Ecore_Con_Server *svr,
+_ecore_con_ssl_server_read_openssl(Ecore_Con_Server *obj,
unsigned char *buf,
int size)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
int num;
if (!svr->ssl) return -1;
}
static int
-_ecore_con_ssl_server_write_openssl(Ecore_Con_Server *svr,
+_ecore_con_ssl_server_write_openssl(Ecore_Con_Server *obj,
const unsigned char *buf,
int size)
{
+ Ecore_Con_Server_Data *svr = eo_data_scope_get(obj, ECORE_CON_SERVER_CLASS);
int num;
num = SSL_write(svr->ssl, buf, size);
_ecore_con_ssl_client_init_openssl(Ecore_Con_Client *obj)
{
Ecore_Con_Client_Data *cl = eo_data_scope_get(obj, ECORE_CON_CLIENT_CLASS);
+ Ecore_Con_Server_Data *host_server = eo_data_scope_get(cl->host_server, ECORE_CON_SERVER_CLASS);
int ret = -1;
switch (cl->ssl_state)
{
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(!(cl->ssl = SSL_new(host_server->ssl_ctx)));
SSL_ERROR_CHECK_GOTO_ERROR(!SSL_set_fd(cl->ssl, cl->fd));
SSL_set_accept_state(cl->ssl);
}
_openssl_print_session(cl->ssl);
- if (!cl->host_server->verify)
+ if (!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);