/** * @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; }