/**
* @brief Send arbitrary data to a connected server
*
* This function is used to send arbitrary data to a connected server using @p client through HTTP PUT.
* It relies on the user to set required headers by operating on the client's #Azy_Net object.
* @param client The client (NOT NULL)
* @param send_data The data+length to send (NOT NULL)
* @param data Optional data to pass to associated callbacks
* @return The #Azy_Client_Call_Id of the transmission, to be used with azy_client_callback_set,
* or 0 on failure
* @see azy_net_header_set
*/
Azy_Client_Call_Id
azy_client_put(Azy_Client *client,
const Azy_Net_Data *send_data,
void *data)
{
Eina_Strbuf *msg;
Azy_Client_Handler_Data *hd;
if (!AZY_MAGIC_CHECK(client, AZY_MAGIC_CLIENT))
{
AZY_MAGIC_FAIL(client, AZY_MAGIC_CLIENT);
return 0;
}
EINA_SAFETY_ON_NULL_RETURN_VAL(send_data, 0);
EINA_SAFETY_ON_NULL_RETURN_VAL(send_data->data, 0);
azy_net_message_length_set(client->net, send_data->size);
azy_net_type_set(client->net, AZY_NET_TYPE_PUT);
msg = azy_net_header_create(client->net);
EINA_SAFETY_ON_NULL_GOTO(msg, error);
#ifdef ISCOMFITOR
DBG("\nSENDING >>>>>>>>>>>>>>>>>>>>>>>>\n%.*s%.*s\n>>>>>>>>>>>>>>>>>>>>>>>>",
eina_strbuf_length_get(msg), eina_strbuf_string_get(msg), (int)send_data->size, send_data->data);
#endif
EINA_SAFETY_ON_TRUE_GOTO(!ecore_con_server_send(client->net->conn, eina_strbuf_string_get(msg), eina_strbuf_length_get(msg)), error);
INFO("Send [1/2] complete! %zi bytes queued for sending.", eina_strbuf_length_get(msg));
eina_strbuf_free(msg);
msg = NULL;
EINA_SAFETY_ON_TRUE_GOTO(!ecore_con_server_send(client->net->conn, send_data->data, send_data->size), error);
INFO("Send [2/2] complete! %" PRIi64 " bytes queued for sending.", send_data->size);
ecore_con_server_flush(client->net->conn);
EINA_SAFETY_ON_TRUE_RETURN_VAL(!(hd = calloc(1, sizeof(Azy_Client_Handler_Data))), 0);
if (!client->conns)
{
client->recv = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA,
(Ecore_Event_Handler_Cb)_azy_client_handler_data, hd);
ecore_con_server_data_set(client->net->conn, client);
}
hd->client = client;
hd->content_data = data;
hd->type = AZY_NET_TYPE_PUT;
AZY_MAGIC_SET(hd, AZY_MAGIC_CLIENT_DATA_HANDLER);
while (++azy_client_send_id__ < 1) ;
hd->id = azy_client_send_id__;
client->conns = eina_list_append(client->conns, hd);
return azy_client_send_id__;
error:
if (msg)
eina_strbuf_free(msg);
return 0;
}
static Eina_Bool
_server_add(void *data, int type, void *event)
{
Instance *inst;
Ecore_Con_Event_Server_Add *ev;
char buf[1024];
char *s;
int i;
printf("SERVER ADD\n");
if (!(inst = data)) return EINA_TRUE;
if(!inst->weather->code) return EINA_FALSE;
ev = event;
if ((!inst->server) || (inst->server != ev->server)) return EINA_TRUE;
s = strdup(inst->weather->code);
for(i=0; i<strlen(s); i++)
if(s[i] == ' ')
s[i] = '+';
snprintf(buf, sizeof(buf), "GET http://%s/ig/api?weather=%s HTTP/1.1\r\nHost: %s\r\n\r\n",
inst->host, s, inst->host);
ecore_con_server_send(inst->server, buf, strlen (buf));
return EINA_FALSE;
}
void AVReceiver::sendRequest(std::vector<char> request)
{
if (!econ || !isConnected) return;
cDebugDom("output") << request.size() << " bytes";
ecore_con_server_send(econ, &request[0], request.size());
}
void AVReceiver::sendRequest(std::string request)
{
if (!econ || !isConnected) return;
cDebugDom("output") << "Command: " << request;
request += command_suffix;
ecore_con_server_send(econ, request.c_str(), request.length());
}
int
protocol_irc_invite(const char *server, const char *channel, const char *nick)
{
Ecore_Con_Server *serv = NULL;
char buf[512];
int len = 0;
if ((!server) || (!channel) || (!nick)) 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), "INVITE %s %s\r\n", nick, channel);
ecore_con_server_send(serv, buf, len);
return 1;
}
int
protocol_irc_back(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), "AWAY\r\n");
ecore_con_server_send(serv, buf, len);
return 1;
}
int
protocol_irc_ghost(const char *server, const char *nick, const char *pass)
{
Ecore_Con_Server *serv = NULL;
char buf[512];
int len = 0;
if ((!server) || (!nick) || (!pass)) 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), "GHOST %s %s\r\n", nick, pass);
ecore_con_server_send(serv, buf, len);
return 1;
}
int
protocol_irc_user_whois(const char *server, const char *nick)
{
Ecore_Con_Server *serv = NULL;
char buf[512];
int len = 0;
if ((!server) || (!nick)) 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), "WHOIS %s\r\n", nick);
ecore_con_server_send(serv, buf, len);
return 1;
}
int
protocol_irc_pong(const char *server, const char *msg)
{
Ecore_Con_Server *serv = NULL;
char buf[512];
int len = 0;
if ((!server) || (!msg)) 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), "PONG %s\n", msg);
ecore_con_server_send(serv, buf, len);
return 1;
}
int
protocol_irc_names(const char *server, const char *channel)
{
Ecore_Con_Server *serv = NULL;
char buf[512];
int len = 0;
if ((!server) || (!channel)) 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), "NAMES %s\r\n", channel);
ecore_con_server_send(serv, buf, len);
return 1;
}
int
protocol_irc_action(const char *server, const char *channel, const char *action)
{
Ecore_Con_Server *serv = NULL;
char buf[512];
int len = 0;
if ((!server) || (!channel) || (!action)) 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),
"PRIVMSG %s :\001ACTION %s\001\r\n", channel, action);
ecore_con_server_send(serv, buf, len);
return 1;
}
int
protocol_irc_message(const char *server, const char *chan, const char *message)
{
Ecore_Con_Server *serv = NULL;
char buf[512];
int len = 0;
if ((!server) || (!chan) || (!message)) 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), "PRIVMSG %s :%s\r\n", chan, message);
ecore_con_server_send(serv, buf, len);
return 1;
}
int
protocol_irc_user(const char *server, const char *nick)
{
Ecore_Con_Server *serv = NULL;
char buf[512], host[64];
int len = 0;
if ((!server) || (!nick)) return 0;
if (!(serv = eina_hash_find(_irc_servers, server))) return 0;
if (!ecore_con_server_connected_get(serv)) return 0;
gethostname(host, 63);
len = snprintf(buf, sizeof(buf), "USER %s %s %s :%s\r\n",
nick, host, server, "Emote Tester");
ecore_con_server_send(serv, buf, len);
return 1;
}
int main (int argc, char *argv[]) {
const char msg[] = "Hello Server\n";
if (argc != 3)
{
fprintf(stderr, "Usage: con_tcp_client_example host port\n");
return 1;
}
ecore_con_init();
ecore_event_handler_add(ECORE_EVENT_SIGNAL_HUP,
event_hup, NULL);
svr = ecore_con_server_connect(ECORE_CON_REMOTE_TCP | ECORE_CON_USE_SSL3, argv[1], atoi(argv[2]), NULL);
if( !svr )
{
printf("Unable to connect\n");
return 1;
}
else
{
printf("Trying to connect\n");
}
printf("Server handle: 0x%08x\n", svr);
ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD,
(Handler_Func)server_add, NULL);
ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DEL,
(Handler_Func)server_del, NULL);
ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_ADD,
(Handler_Func)client_add, NULL);
ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DEL,
(Handler_Func)client_del, NULL);
ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA,
(Handler_Func)server_data, NULL);
ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DATA,
(Handler_Func)client_data, NULL);
ecore_con_server_send(svr, msg, sizeof(msg));
ecore_main_loop_begin();
ecore_con_shutdown();
return 0;
}
int
protocol_irc_channels_list(const char *server, const char *arg)
{
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;
if (arg[0])
len = snprintf(buf, sizeof(buf), "LIST %s\r\n", arg);
else
len = snprintf(buf, sizeof(buf), "LIST\r\n");
ecore_con_server_send(serv, buf, len);
return 1;
}
int
protocol_irc_part(const char *server, const char *channel, const char *reason)
{
Ecore_Con_Server *serv = NULL;
char buf[512];
int len = 0;
if ((!server) || (!channel)) return 0;
if (!(serv = eina_hash_find(_irc_servers, server))) return 0;
if (!ecore_con_server_connected_get(serv)) return 0;
if (reason[0])
len = snprintf(buf, sizeof(buf), "PART %s :%s\r\n", channel, reason);
else
len = snprintf(buf, sizeof(buf), "PART %s\r\n", channel);
ecore_con_server_send(serv, buf, len);
return 1;
}
int
protocol_irc_ping(const char *server, const char *to, const char *timestring)
{
Ecore_Con_Server *serv = NULL;
char buf[512];
int len = 0;
if ((!server) || (!timestring)) return 0;
if (!(serv = eina_hash_find(_irc_servers, server))) return 0;
if (!ecore_con_server_connected_get(serv)) return 0;
if ((to) && (to[0]))
len = snprintf(buf, sizeof(buf),
"PRIVMSG %s :\001PING %s\001\r\n", to, timestring);
else
len = snprintf(buf, sizeof(buf), "PING %s\r\n", timestring);
ecore_con_server_send(serv, buf, len);
return 1;
}
int
protocol_irc_topic(const char *server, const char *channel, const char *topic)
{
Ecore_Con_Server *serv = NULL;
char buf[512];
int len = 0;
if ((!server) || (!channel)) return 0;
if (!(serv = eina_hash_find(_irc_servers, server))) return 0;
if (!ecore_con_server_connected_get(serv)) return 0;
if (!topic)
len = snprintf(buf, sizeof(buf), "TOPIC %s :\r\n", channel);
else if (topic[0])
len = snprintf(buf, sizeof(buf), "TOPIC %s :%s\r\n", channel, topic);
else
len = snprintf(buf, sizeof(buf), "TOPIC %s\r\n", channel);
ecore_con_server_send(serv, buf, len);
return 1;
}
static Eina_Bool
_server_add(void *data, int type, void *event)
{
Instance *inst;
Ecore_Con_Event_Server_Add *ev;
char buf[1024];
if (!(inst = data)) return EINA_TRUE;
if(!inst->weather->code) return EINA_FALSE;
ev = event;
if ((!inst->server) || (inst->server != ev->server)) return EINA_TRUE;
snprintf(buf, sizeof(buf), "GET http://%s/forecastrss?w=%s HTTP/1.1\r\nHost: %s\r\n\r\n",
inst->host, inst->weather->code, inst->host);
ecore_con_server_send(inst->server, buf, strlen (buf));
return EINA_FALSE;
}
static Eina_Bool
_forecasts_server_add(void *data, int type, void *event)
{
Instance *inst;
Ecore_Con_Event_Server_Add *ev;
char buf[1024];
char forecast[1024];
char degrees;
int err_server;
Eina_Strbuf *city;
city = eina_strbuf_new();
inst = data;
if (!inst)
return EINA_TRUE;
ev = event;
if ((!inst->server) || (inst->server != ev->server))
return EINA_TRUE;
if (inst->ci->degrees == DEGREES_F)
degrees = 'f';
else
degrees = 'c';
if (inst->ci->by_code == WOEID_CITY)
{
city = url_normalize_str(inst->ci->code);
snprintf(forecast, sizeof(forecast), "/v1/public/yql?q=select%%20*%%20from%%20weather.forecast%%20where%%20woeid%%20in%%20%%28select%%20woeid%%20from%%20geo.places%%281%%29%%20where%%20text=\"%s\"%%20%%29%%20and%%20u='%c'", eina_strbuf_string_get(city), degrees);
eina_strbuf_free(city);
}
else
snprintf(forecast, sizeof(forecast), "/v1/public/yql?q=select%%20*%%20from%%20weather.forecast%%20where%%20woeid%%3D%s%%20and%%20u%%3D%%27%c%%27", inst->ci->code, degrees);
snprintf(buf, sizeof(buf), "GET http://%s%s HTTP/1.1\r\n"
"Host: %s\r\n"
"Connection: close\r\n\r\n",
inst->ci->host, forecast, inst->ci->host);
DEBUG("Server: %s", buf);
err_server=ecore_con_server_send(inst->server, buf, strlen(buf));
DEBUG("Server error: %d", err_server);
return EINA_FALSE;
}
int
protocol_irc_away(const char *server, const char *reason)
{
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;
if (reason)
{
if (!reason[0]) reason = " ";
}
else
reason = " ";
len = snprintf(buf, sizeof(buf), "AWAY :%s\r\n", reason);
ecore_con_server_send(serv, buf, len);
return 1;
}
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;
}
// Button connect pressed
static void
btn_connect(void *data, Evas_Object *obj, void *event)
{
Window *a = data ;
int port = 1234 ;
// Get ip from user
const char *address = elm_object_text_get(a->ip) ;
// Get port from user
// int port = atoi(elm_object_text_get(a->port)) ;
// Create connection
if (!(a->svr = ecore_con_server_connect(ECORE_CON_REMOTE_TCP, address, port, NULL)))
{
printf("could not connect to the server: %s, port %d.\n", address, port) ;
exit(2);
}
/* set event handler for server connect */
ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD, (Ecore_Event_Handler_Cb)_add, a);
/* set event handler for server disconnect */
ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DEL, (Ecore_Event_Handler_Cb)_del, a);
/* set event handler for receiving server data */
ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA, (Ecore_Event_Handler_Cb)_data, a);
char welcome[] = "Connection" ;
ecore_con_server_send(a->svr, welcome, sizeof(welcome)) ;
}
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;
}
}
/**
* @brief Make an HTTP GET or POST request using a connected client with no HTTP BODY
*
* This function is used to make a GET or POST request using @p client to the uri of the client's
* #Azy_Net object (azy_net_get(client)) using HTTP method @p type, content-type
* defined by @p transport, and the optional deserialization function specified by @p cb.
* @param client The client (NOT NULL)
* @param type The HTTP method to use (NOT NULL)
* @param netdata The HTTP BODY to send with a POST
* @param cb The deserialization callback to use for the response
* @param data The user data to be passed to resulting callbacks
* @return The #Azy_Client_Call_Id of the transmission, to be used with azy_client_callback_set,
* or 0 on failure
*/
Azy_Client_Call_Id
azy_client_blank(Azy_Client *client,
Azy_Net_Type type,
Azy_Net_Data *netdata,
Azy_Content_Cb cb,
void *data)
{
Eina_Strbuf *msg;
Azy_Client_Handler_Data *hd;
DBG("(client=%p, net=%p)", client, client->net);
if (!AZY_MAGIC_CHECK(client, AZY_MAGIC_CLIENT))
{
AZY_MAGIC_FAIL(client, AZY_MAGIC_CLIENT);
return 0;
}
EINA_SAFETY_ON_NULL_RETURN_VAL(client->net, 0);
EINA_SAFETY_ON_TRUE_RETURN_VAL((type != AZY_NET_TYPE_GET) && (type != AZY_NET_TYPE_POST), 0);
while (++azy_client_send_id__ < 1) ;
client->net->type = type;
if (!client->net->http.req.http_path)
{
WARN("NULL URI passed, defaulting to \"/\"");
azy_net_uri_set(client->net, "/");
}
if (netdata && netdata->size && (type == AZY_NET_TYPE_POST))
azy_net_message_length_set(client->net, netdata->size);
msg = azy_net_header_create(client->net);
EINA_SAFETY_ON_NULL_GOTO(msg, error);
#ifdef ISCOMFITOR
char buf[64];
snprintf(buf, sizeof(buf), "\nSENDING >>>>>>>>>>>>>>>>>>>>>>>>\n%%.%zus\n>>>>>>>>>>>>>>>>>>>>>>>>",
eina_strbuf_length_get(msg));
DBG(buf, eina_strbuf_string_get(msg));
#endif
EINA_SAFETY_ON_TRUE_GOTO(!ecore_con_server_send(client->net->conn, eina_strbuf_string_get(msg), eina_strbuf_length_get(msg)), error);
if (netdata && netdata->size && (type == AZY_NET_TYPE_POST))
{
INFO("Send [1/2] complete! %zu bytes queued for sending.", eina_strbuf_length_get(msg));
EINA_SAFETY_ON_TRUE_GOTO(!ecore_con_server_send(client->net->conn, netdata->data, netdata->size), error);
INFO("Send [2/2] complete! %" PRIi64 " bytes queued for sending.", netdata->size);
}
else
INFO("Send [1/1] complete! %zu bytes queued for sending.", eina_strbuf_length_get(msg));
eina_strbuf_free(msg);
msg = NULL;
ecore_con_server_flush(client->net->conn);
hd = calloc(1, sizeof(Azy_Client_Handler_Data));
EINA_SAFETY_ON_NULL_RETURN_VAL(hd, 0);
hd->client = client;
hd->callback = cb;
hd->type = type;
hd->content_data = data;
if (netdata && netdata->size && (type == AZY_NET_TYPE_POST))
{
hd->send = eina_strbuf_new();
eina_strbuf_append_length(hd->send, (char *)netdata->data, netdata->size);
}
hd->id = azy_client_send_id__;
AZY_MAGIC_SET(hd, AZY_MAGIC_CLIENT_DATA_HANDLER);
if (!client->conns)
{
client->recv = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA,
(Ecore_Event_Handler_Cb)_azy_client_handler_data, hd);
ecore_con_server_data_set(client->net->conn, client);
}
client->conns = eina_list_append(client->conns, hd);
DBG("(client=%p, net=%p, hd=%p)", client, client->net, hd);
return azy_client_send_id__;
error:
if (msg) eina_strbuf_free(msg);
return 0;
}
/**
* @brief Make a method call using a connected client
*
* This function is used to make a method call on @p client as defined in
* @p content, using content-type defined by @p transport and the deserialization
* function specified by @p cb. This should generally not be used by users, as azy_parser
* will automatically generate the correct calls from a .azy file.
* @param client The client (NOT NULL)
* @param content The content containing the method name and parameters (NOT NULL)
* @param transport The content-type (xml/json/etc) to use
* @param cb The deserialization callback to use for the response
* @return The #Azy_Client_Call_Id of the transmission, to be used with azy_client_callback_set,
* or 0 on failure
*/
Azy_Client_Call_Id
azy_client_call(Azy_Client *client,
Azy_Content *content,
Azy_Net_Transport transport,
Azy_Content_Cb cb)
{
Eina_Strbuf *msg;
Azy_Client_Handler_Data *hd;
DBG("(client=%p, net=%p, content=%p)", client, client->net, content);
if (!AZY_MAGIC_CHECK(client, AZY_MAGIC_CLIENT))
{
AZY_MAGIC_FAIL(client, AZY_MAGIC_CLIENT);
return 0;
}
EINA_SAFETY_ON_NULL_RETURN_VAL(client->net, 0);
EINA_SAFETY_ON_NULL_RETURN_VAL(content, 0);
EINA_SAFETY_ON_NULL_RETURN_VAL(content->method, 0);
INFO("New method call: '%s'", content->method);
while (++azy_client_send_id__ < 1) ;
content->id = azy_client_send_id__;
azy_net_transport_set(client->net, transport);
if (!azy_content_serialize_request(content, transport))
return 0;
azy_net_type_set(client->net, AZY_NET_TYPE_POST);
if (!client->net->http.req.http_path)
{
WARN("URI currently set to NULL, defaulting to \"/\"");
azy_net_uri_set(client->net, "/");
}
azy_net_message_length_set(client->net, content->length);
msg = azy_net_header_create(client->net);
EINA_SAFETY_ON_NULL_GOTO(msg, error);
if (azy_rpc_log_dom >= 0)
{
char buf[64];
snprintf(buf, sizeof(buf), "\nSENDING >>>>>>>>>>>>>>>>>>>>>>>>\n%%.%is%%.%llis\n>>>>>>>>>>>>>>>>>>>>>>>>",
eina_strbuf_length_get(msg), content->length);
RPC_DBG(buf, eina_strbuf_string_get(msg), content->buffer);
}
EINA_SAFETY_ON_TRUE_GOTO(!ecore_con_server_send(client->net->conn, eina_strbuf_string_get(msg), eina_strbuf_length_get(msg)), error);
INFO("Send [1/2] complete! %zu bytes queued for sending.", eina_strbuf_length_get(msg));
eina_strbuf_free(msg);
msg = NULL;
EINA_SAFETY_ON_TRUE_GOTO(!ecore_con_server_send(client->net->conn, content->buffer, content->length), error);
INFO("Send [2/2] complete! %lli bytes queued for sending.", content->length);
ecore_con_server_flush(client->net->conn);
hd = calloc(1, sizeof(Azy_Client_Handler_Data));
EINA_SAFETY_ON_NULL_RETURN_VAL(hd, 0);
hd->client = client;
hd->method = eina_stringshare_ref(content->method);
hd->callback = cb;
hd->type = AZY_NET_TYPE_POST;
hd->content_data = content->data;
hd->send = eina_strbuf_new();
eina_strbuf_append_length(hd->send, (char *)content->buffer, content->length);
hd->id = azy_client_send_id__;
AZY_MAGIC_SET(hd, AZY_MAGIC_CLIENT_DATA_HANDLER);
if (!client->conns)
{
client->recv = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA,
(Ecore_Event_Handler_Cb)_azy_client_handler_data, hd);
ecore_con_server_data_set(client->net->conn, client);
}
client->conns = eina_list_append(client->conns, hd);
DBG("(client=%p, net=%p, content=%p, hd=%p)", client, client->net, content, hd);
return azy_client_send_id__;
error:
if (msg)
eina_strbuf_free(msg);
return 0;
}
int
epsilon_ipc_server_send(Ecore_Con_Server *srv, Epsilon_Message *msg)
{
return ecore_con_server_send(srv, msg,
sizeof(Epsilon_Message) + msg->bufsize);
}
static Eina_Bool
keepalive(Shotgun_Auth *auth)
{
ecore_con_server_send(auth->svr, " ", 1);
return EINA_TRUE;
}
