static void
_gc_shutdown(E_Gadcon_Client *gcc)
{
Instance *inst;
Forecasts *w;
inst = gcc->data;
w = inst->forecasts;
if (inst->popup) _forecasts_popup_destroy(inst);
if (inst->check_timer)
ecore_timer_del(inst->check_timer);
if (inst->add_handler)
ecore_event_handler_del(inst->add_handler);
if (inst->data_handler)
ecore_event_handler_del(inst->data_handler);
if (inst->del_handler)
ecore_event_handler_del(inst->del_handler);
if (inst->server)
ecore_con_server_del(inst->server);
if (inst->area)
eina_stringshare_del(inst->area);
eina_strbuf_free(inst->buffer);
inst->server = NULL;
forecasts_config->instances =
eina_list_remove(forecasts_config->instances, inst);
evas_object_event_callback_del(w->forecasts_obj, EVAS_CALLBACK_MOUSE_DOWN,
_forecasts_cb_mouse_down);
_forecasts_free(w);
E_FREE(inst);
}
static Eina_Bool
_forecasts_cb_check(void *data)
{
Instance *inst;
/* check that data is valid */
if (!(inst = data)) return EINA_FALSE;
/* if we have a previous server, delete it */
if (inst->server) ecore_con_server_del(inst->server);
/* server deleted, set variable to NULL */
inst->server = NULL;
if (proxy.port != 0)
inst->server =
ecore_con_server_connect(ECORE_CON_REMOTE_NODELAY,
proxy.host, proxy.port, inst);
else
inst->server =
ecore_con_server_connect(ECORE_CON_REMOTE_NODELAY, inst->ci->host, 80, inst);
if (!inst->server) return EINA_FALSE;
return EINA_TRUE;
}
void
shotgun_disconnect(Shotgun_Auth *auth)
{
if (!auth) return;
if (auth->svr_name)
ecore_event_add(SHOTGUN_EVENT_DISCONNECT, auth, shotgun_fake_free, NULL);
if (auth->ev_add) ecore_event_handler_del(auth->ev_add);
if (auth->ev_del) ecore_event_handler_del(auth->ev_del);
if (auth->ev_data) ecore_event_handler_del(auth->ev_data);
if (auth->ev_error) ecore_event_handler_del(auth->ev_error);
if (auth->ev_upgrade) ecore_event_handler_del(auth->ev_upgrade);
if (auth->ev_write) ecore_event_handler_del(auth->ev_write);
if (auth->svr) ecore_con_server_del(auth->svr);
if (auth->keepalive) ecore_timer_del(auth->keepalive);
if (auth->et_ping) ecore_timer_del(auth->et_ping);
if (auth->et_ping_timeout) ecore_timer_del(auth->et_ping_timeout);
auth->keepalive = NULL;
auth->ev_add = NULL;
auth->ev_del = NULL;
auth->ev_data = NULL;
auth->ev_error = NULL;
auth->ev_upgrade = NULL;
auth->ev_write = NULL;
auth->svr = NULL;
auth->state = 0;
memset(&auth->features, 0, sizeof(auth->features));
auth->pending_ping = 0;
}
static Eina_Bool
_weather_cb_check(void *data)
{
Instance *inst;
printf("CHECK\n");
if (!(inst = data)) return EINA_FALSE;
if (inst->server) ecore_con_server_del(inst->server);
inst->server = NULL;
if (inst->weather->proxy.port != 0)
inst->server =
ecore_con_server_connect(ECORE_CON_REMOTE_SYSTEM, inst->weather->proxy.host,
inst->weather->proxy.port, inst);
else
{
inst->server =
ecore_con_server_connect(ECORE_CON_REMOTE_SYSTEM, inst->host, 80, inst);
printf("CHECX %p\n", inst->server);
}
if (!inst->server) return EINA_FALSE;
ecore_timer_interval_set(inst->check_timer, inst->weather->poll_time);
return EINA_TRUE;
}
static Eina_Bool
_weather_cb_check(void *data)
{
Instance *inst;
if (!(inst = data)) return EINA_FALSE;
if (inst->server) ecore_con_server_del(inst->server);
inst->server = NULL;
if (inst->weather->proxy.port != 0)
inst->server =
ecore_con_server_connect(ECORE_CON_REMOTE_SYSTEM, inst->weather->proxy.host,
inst->weather->proxy.port, inst);
else
inst->server =
ecore_con_server_connect(ECORE_CON_REMOTE_SYSTEM, inst->host, 80, inst);
if (!inst->server)
{
inst->check_timer = NULL;
return ECORE_CALLBACK_CANCEL;
}
ecore_timer_interval_set(inst->check_timer, inst->weather->poll_time);
return ECORE_CALLBACK_RENEW;
}
HttpServer::~HttpServer()
{
ecore_con_server_del(tcp_server);
tcp_server = NULL;
ecore_event_handler_del(event_handler_client_add);
ecore_event_handler_del(event_handler_client_del);
ecore_event_handler_del(event_handler_data_get);
ecore_event_handler_del(event_handler_client_write);
cDebugDom("network");
}
static Eina_Bool
disc(Shotgun_Auth *auth, int type __UNUSED__, Ecore_Con_Event_Server_Del *ev)
{
if ((auth != ecore_con_server_data_get(ev->server)) || (!auth))
return ECORE_CALLBACK_PASS_ON;
INF("Disconnected");
ecore_con_server_del(auth->svr);
auth->svr = NULL;
shotgun_disconnect(auth);
return EINA_FALSE;
}
static Eina_Bool
disc(Enfeeble *enf, int type __UNUSED__, Ecore_Con_Event_Server_Del *ev)
{
if ((enf != ecore_con_server_data_get(ev->server)) || (!enf))
return ECORE_CALLBACK_PASS_ON;
INF("Disconnected");
ecore_con_server_del(enf->svr);
enf->svr = NULL;
enf->ev_del = NULL;
ecore_event_add(ENFEEBLE_EVENT_DISCONNECT, enf, enfeeble_fake_free, NULL);
return EINA_FALSE;
}
// Button disconnect pressed
static void
btn_disconnect(void *data, Evas_Object *obj, void *event)
{
Window *a = data ;
// Stop connection
ecore_con_server_del(a->svr) ;
}
void
enfeeble_disconnect(Enfeeble *enf)
{
if (!enf) return;
if (enf->ev_add) ecore_event_handler_del(enf->ev_add);
if (enf->ev_del) ecore_event_handler_del(enf->ev_del);
if (enf->ev_data) ecore_event_handler_del(enf->ev_data);
if (enf->ev_error) ecore_event_handler_del(enf->ev_error);
if (enf->svr) ecore_con_server_del(enf->svr);
enf->ev_add = NULL;
enf->ev_del = NULL;
enf->ev_data = NULL;
enf->ev_error = NULL;
enf->svr = NULL;
}
int
protocol_irc_disconnect(const char *server)
{
Ecore_Con_Server *serv = NULL;
char buf[512];
int len = 0;
if (!server) return 0;
if (!(serv = eina_hash_find(_irc_servers, server))) return 0;
if (!ecore_con_server_connected_get(serv)) return 0;
len = snprintf(buf, sizeof(buf), "QUIT\r\n");
ecore_con_server_send(serv, buf, len);
ecore_con_server_flush(serv);
ecore_con_server_del(serv);
return 1;
}
void
ipc_shutdown(void)
{
char *ipc;
if (!method || !strcmp(method, "fifo"))
{
ipc = getenv("EXQUISITE_IPC");
if (!ipc) ipc = "/tmp/exquisite";
unlink(ipc);
}
else if (strstr(method, "socket"))
{
if (sock) ecore_con_server_del(sock);
ecore_con_shutdown();
}
}
static void _shutdown(EWeather *eweather)
{
Instance *inst = eweather->plugin.data;
if (inst->host) eina_stringshare_del(inst->host);
if (inst->buffer) free(inst->buffer);
if (inst->check_timer) ecore_timer_del(inst->check_timer);
if (inst->add_handler) ecore_event_handler_del(inst->add_handler);
if (inst->data_handler) ecore_event_handler_del(inst->data_handler);
if (inst->err_handler) ecore_event_handler_del(inst->err_handler);
if (inst->del_handler) ecore_event_handler_del(inst->del_handler);
if (inst->server) ecore_con_server_del(inst->server);
ecore_con_shutdown();
free(inst);
}
/**
* @brief Close a client's connection
*
* This function is the opposite of azy_client_connect, it
* terminates an existing connection.
* @param client The client (NOT NULL)
*/
void
azy_client_close(Azy_Client *client)
{
DBG("(client=%p)", client);
if (!AZY_MAGIC_CHECK(client, AZY_MAGIC_CLIENT))
{
AZY_MAGIC_FAIL(client, AZY_MAGIC_CLIENT);
return;
}
EINA_SAFETY_ON_FALSE_RETURN(client->connected);
EINA_SAFETY_ON_NULL_RETURN(client->net);
ecore_con_server_del(client->net->conn);
azy_net_free(client->net);
client->net = NULL;
client->connected = EINA_FALSE;
}
Eina_Bool
azy_events_connection_kill(void *conn,
Eina_Bool server_client,
const char *msg)
{
DBG("(conn=%p, server_client=%i, msg='%s')", conn, server_client, msg);
if (msg)
{
if (server_client)
ecore_con_client_send(conn, msg, strlen(msg));
else
ecore_con_server_send(conn, msg, strlen(msg));
}
if (server_client)
ecore_con_client_del(conn);
else
ecore_con_server_del(conn);
return ECORE_CALLBACK_RENEW;
}
static Eina_Bool
_forecasts_server_del(void *data, int type, void *event)
{
Instance *inst;
Ecore_Con_Event_Server_Del *ev;
int ret;
inst = data;
ev = event;
if ((!inst->server) || (inst->server != ev->server))
return EINA_TRUE;
ecore_con_server_del(inst->server);
inst->server = NULL;
ret = _forecasts_parse(inst);
_forecasts_converter(inst);
_forecasts_display_set(inst, ret);
eina_strbuf_string_free(inst->buffer);
return EINA_FALSE;
}
static Eina_Bool
_server_del(void *data, int type, void *event)
{
Instance *inst;
Ecore_Con_Event_Server_Del *ev;
int ret;
inst = data;
ev = event;
if ((!inst->server) || (inst->server != ev->server)) return EINA_TRUE;
ecore_con_server_del(inst->server);
inst->server = NULL;
ret = _parse(inst);
inst->bufsize = 0;
inst->cursize = 0;
if(inst->buffer) free(inst->buffer);
inst->buffer = NULL;
return EINA_FALSE;
}
void
email_login_pop(Email *e, Ecore_Con_Event_Server_Data *ev)
{
char *buf;
size_t size;
switch (e->state)
{
case EMAIL_STATE_SSL:
if (!email_op_ok(ev->data, ev->size))
{
ERR("Could not create secure connection!");
ecore_con_server_del(ev->server);
return;
}
ecore_con_ssl_server_upgrade(e->svr, ECORE_CON_USE_MIXED);
ecore_con_ssl_server_verify_basic(e->svr);
e->flags = ECORE_CON_USE_MIXED;
return;
case EMAIL_STATE_INIT:
if (!email_op_ok(ev->data, ev->size))
{
ERR("Not a POP3 server!");
ecore_con_server_del(ev->server);
return;
}
if (ev->size > 20)
{
const unsigned char *end;
end = memrchr(ev->data + 3, '>', ev->size - 3);
if (end)
{
const unsigned char *start;
start = memrchr(ev->data + 3, '<', end - (unsigned char*)ev->data);
if (start)
{
e->features.pop_features.apop = EINA_TRUE;
e->features.pop_features.apop_str = eina_binbuf_new();
eina_binbuf_append_length(e->features.pop_features.apop_str, start, end - start + 1);
}
}
}
if (e->secure && (!e->flags))
{
email_write(e, "STLS\r\n", sizeof("STLS\r\n") - 1);
e->state++;
return;
}
e->state = EMAIL_STATE_USER;
ev = NULL;
case EMAIL_STATE_USER:
if (!ev)
{
unsigned char digest[16];
char md5buf[33];
if (!e->features.pop_features.apop)
{
INF("Beginning AUTH PLAIN");
size = sizeof(char) * (sizeof("USER ") - 1 + sizeof("\r\n") - 1 + strlen(e->username)) + 1;
buf = alloca(size);
snprintf(buf, size, "USER %s\r\n", e->username);
email_write(e, buf, size - 1);
return;
}
INF("Beginning AUTH APOP");
e->state++;
eina_binbuf_append_length(e->features.pop_features.apop_str, (unsigned char*)e->password, strlen(e->password));
md5_buffer((char*)eina_binbuf_string_get(e->features.pop_features.apop_str), eina_binbuf_length_get(e->features.pop_features.apop_str), digest);
email_md5_digest_to_str(digest, md5buf);
size = sizeof(char) * (sizeof("APOP ") - 1 + sizeof("\r\n") - 1 + strlen(e->username)) + sizeof(md5buf);
buf = alloca(size);
snprintf(buf, size, "APOP %s %s\r\n", e->username, md5buf);
email_write(e, buf, size - 1);
return;
}
if (!email_op_ok(ev->data, ev->size))
{
ERR("Username invalid!");
ecore_con_server_del(e->svr);
return;
}
size = sizeof(char) * (sizeof("PASS ") - 1 + sizeof("\r\n") - 1 + strlen(e->password)) + 1;
buf = alloca(size);
snprintf(buf, size, "PASS %s\r\n", e->password);
DBG("Sending password");
ecore_con_server_send(e->svr, buf, size - 1);
e->state++;
return;
case EMAIL_STATE_PASS:
if (!email_op_ok(ev->data, ev->size))
{
ERR("Credentials invalid!");
ecore_con_server_del(e->svr);
return;
}
INF("Logged in successfully!");
e->state++;
ecore_event_add(EMAIL_EVENT_CONNECTED, e, (Ecore_End_Cb)email_fake_free, NULL);
default:
break;
}
}
Eina_Bool
data_smtp(Email *e, int type __UNUSED__, Ecore_Con_Event_Server_Data *ev)
{
char *recv;
Email_Send_Cb cb;
Email_Cb qcb;
if (e != ecore_con_server_data_get(ev->server))
{
DBG("Event mismatch");
return ECORE_CALLBACK_PASS_ON;
}
if (eina_log_domain_level_check(email_log_dom, EINA_LOG_LEVEL_DBG))
{
recv = alloca(ev->size + 1);
memcpy(recv, ev->data, ev->size);
recv[ev->size] = 0;
DBG("Receiving %i bytes:\n%s", ev->size, recv);
}
if (e->state < EMAIL_STATE_CONNECTED)
{
email_login_smtp(e, ev);
return ECORE_CALLBACK_RENEW;
}
if (!e->current) return ECORE_CALLBACK_RENEW;
cb = eina_list_data_get(e->cbs);
qcb = eina_list_data_get(e->cbs);
if (e->current == EMAIL_OP_QUIT)
{
if ((ev->size < 3) || (memcmp(ev->data, "221", 3)))
ERR("Could not QUIT properly!");
if (qcb) qcb(e);
ecore_con_server_del(e->svr);
return ECORE_CALLBACK_RENEW;
}
switch (e->smtp_state)
{
case EMAIL_SMTP_STATE_BODY:
if ((ev->size < 3) || (memcmp(ev->data, "354", 3)))
{
if (cb) cb(e->op_ids->data, EINA_FALSE);
next_smtp(e);
return ECORE_CALLBACK_RENEW;
}
if (!send_smtp(e))
{
if (cb) cb(e->op_ids->data, EINA_FALSE);
next_smtp(e);
}
break;
default:
if ((ev->size < 3) || (memcmp(ev->data, "250", 3)))
{
if (cb) cb(e->op_ids->data, EINA_FALSE);
next_smtp(e);
}
else if (e->smtp_state > EMAIL_SMTP_STATE_BODY)
{
if (cb) cb(e->op_ids->data, EINA_TRUE);
next_smtp(e);
}
else
{
if (!send_smtp(e))
{
if (cb) cb(e->op_ids->data, EINA_FALSE);
next_smtp(e);
}
}
}
return ECORE_CALLBACK_RENEW;
}
Eina_Bool event_hup(void *data, int ev_type, void *ev)
{
printf("Hup signal! Remove the server.\n");
ecore_con_server_del(svr);
return EINA_TRUE;
}
Eina_Bool
data_pop(Email *e, int type __UNUSED__, Ecore_Con_Event_Server_Data *ev)
{
char *recv;
if (e != ecore_con_server_data_get(ev->server))
{
DBG("Event mismatch");
return ECORE_CALLBACK_PASS_ON;
}
recv = alloca(ev->size + 1);
memcpy(recv, ev->data, ev->size);
recv[ev->size] = 0;
DBG("Receiving %i bytes:\n%s", ev->size, recv);
if (e->state < EMAIL_STATE_CONNECTED)
{
email_login_pop(e, ev);
return ECORE_CALLBACK_RENEW;
}
if (!e->current) return ECORE_CALLBACK_RENEW;
switch (e->current)
{
case EMAIL_OP_STAT:
if (!email_pop3_stat_read(e, recv, ev->size)) return ECORE_CALLBACK_RENEW;
break;
case EMAIL_OP_LIST:
if (!email_pop3_list_read(e, ev)) return ECORE_CALLBACK_RENEW;
break;
case EMAIL_OP_RETR:
if (!email_pop3_retr_read(e, ev)) return ECORE_CALLBACK_RENEW;
break;
case EMAIL_OP_DELE:
case EMAIL_OP_QUIT:
{
Ecore_Cb cb;
cb = e->cbs->data;
e->cbs = eina_list_remove_list(e->cbs, e->cbs);
if (!email_op_ok(ev->data, ev->size))
{
if (e->current == EMAIL_OP_DELE) ERR("Error with DELE");
else ERR("Error with QUIT");
}
else
{
if (e->current == EMAIL_OP_DELE) INF("DELE successful");
else INF("QUIT");
}
if (cb) cb(e);
if (e->current == EMAIL_OP_QUIT) ecore_con_server_del(e->svr);
break;
}
default:
break;
}
next_pop(e);
return ECORE_CALLBACK_RENEW;
}
