/** * @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 char * _get_abbreviated_name(const char *prefix, const char *fname) { Eina_Strbuf *buf = eina_strbuf_new(); const char *last_p = strrchr(prefix, '_'); last_p = (last_p) ? (last_p + 1) : prefix; const char *tmp = strstr(fname, last_p); int len = strlen(last_p); if ((tmp) && ((tmp == fname) || (*(tmp - 1) == '_')) && ((*(tmp + len) == '\0') || (*(tmp + len) == '_'))) { int plen = strlen(prefix); len += (tmp - fname); if ((plen >= len) && !strncmp(prefix + plen - len, fname, len)) { eina_strbuf_append_n(buf, prefix, plen - len); } } if (eina_strbuf_length_get(buf) == 0) eina_strbuf_append_printf(buf, "%s_", prefix); eina_strbuf_append(buf, fname); char *ret = eina_strbuf_string_steal(buf); eina_strbuf_free(buf); return ret; }
int main(int argc, char **argv) { Eina_Strbuf *buf; eina_init(); buf = eina_strbuf_new(); eina_strbuf_append_length(buf, "buffe", 5); eina_strbuf_append_char(buf, 'r'); printf("%s\n", eina_strbuf_string_get(buf)); eina_strbuf_insert_escaped(buf, "my ", 0); printf("%s\n", eina_strbuf_string_get(buf)); eina_strbuf_reset(buf); eina_strbuf_append_escaped(buf, "my buffer"); printf("%s\n", eina_strbuf_string_get(buf)); eina_strbuf_reset(buf); eina_strbuf_append_printf(buf, "%s%c", "buffe", 'r'); eina_strbuf_insert_printf(buf, " %s: %d", 6, "length", eina_strbuf_length_get(buf)); printf("%s\n", eina_strbuf_string_get(buf)); eina_strbuf_remove(buf, 0, 7); printf("%s\n", eina_strbuf_string_get(buf)); eina_strbuf_replace_all(buf, "length", "size"); printf("%s\n", eina_strbuf_string_get(buf)); eina_strbuf_free(buf); eina_shutdown(); return 0; }
static void _match_append(Eina_Strbuf *match, const char *key, const char *value) { if (!value) return; if ((eina_strbuf_length_get(match) + strlen(",=''") + strlen(key) + strlen(value)) >= DBUS_MAXIMUM_MATCH_RULE_LENGTH) { ERR("cannot add match %s='%s' to %s: too long!", key, value, eina_strbuf_string_get(match)); return; } eina_strbuf_append_printf(match, ",%s='%s'", key, value); }
Eina_Bool send_smtp(Email *e) { char *buf; size_t size; Email_Message *msg; Email_Contact *ec; Eina_Strbuf *bbuf; e->current = EMAIL_OP_SEND; msg = e->op_ids->data; switch (e->smtp_state) { case 0: e->smtp_state++; case EMAIL_SMTP_STATE_FROM: if ((!msg->from) && (!msg->sender)) { char buf[1024]; snprintf(buf, sizeof(buf), "%s@%s", e->username, e->features.smtp_features.domain); msg->sender = email_contact_new(buf); } ec = msg->sender; size = sizeof(char) * (sizeof(EMAIL_SMTP_FROM) + strlen(ec->address)) - 2; buf = alloca(size); snprintf(buf, size, EMAIL_SMTP_FROM, ec->address); email_write(e, buf, size - 1); e->smtp_state++; e->internal_state = 0; break; case EMAIL_SMTP_STATE_TO: ec = eina_list_nth(msg->recipients, e->internal_state++); if (!ec) { e->smtp_state++; e->internal_state = 0; return send_smtp(e); } size = sizeof(char) * (sizeof(EMAIL_SMTP_TO) + strlen(ec->address)) - 2; buf = alloca(size); snprintf(buf, size, EMAIL_SMTP_TO, ec->address); email_write(e, buf, size - 1); break; case EMAIL_SMTP_STATE_DATA: email_write(e, EMAIL_SMTP_DATA, sizeof(EMAIL_SMTP_DATA) - 1); e->smtp_state++; e->internal_state = 0; break; default: bbuf = email_message_serialize(msg); e->smtp_state++; if (bbuf) { email_write(e, eina_strbuf_string_get(bbuf), eina_strbuf_length_get(bbuf)); eina_strbuf_free(bbuf); } else return EINA_FALSE; } return EINA_TRUE; }
/** * @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; }
static void _gen_func(const Eolian_Unit *src, const Eolian_Class *cl, const Eolian_Function *fid, Eolian_Function_Type ftype, Eina_Strbuf *buf, const Eolian_Implement *impl, Eina_Strbuf *lbuf) { Eina_Bool is_empty = eolian_implement_is_empty(impl, ftype); Eina_Bool is_auto = eolian_implement_is_auto(impl, ftype); if ((ftype != EOLIAN_PROP_GET) && (ftype != EOLIAN_PROP_SET)) ftype = eolian_function_type_get(fid); Eina_Bool is_prop = (ftype == EOLIAN_PROP_GET || ftype == EOLIAN_PROP_SET); Eina_Bool var_as_ret = EINA_FALSE; const Eolian_Expression *def_ret = NULL; const Eolian_Type *rtp = eolian_function_return_type_get(fid, ftype); if (rtp) { is_auto = EINA_FALSE; /* can't do auto if func returns */ def_ret = eolian_function_return_default_value_get(fid, ftype); } const char *func_suffix = ""; if (ftype == EOLIAN_PROP_GET) { func_suffix = "_get"; if (!rtp) { void *d1, *d2; Eina_Iterator *itr = eolian_property_values_get(fid, ftype); if (eina_iterator_next(itr, &d1) && !eina_iterator_next(itr, &d2)) { Eolian_Function_Parameter *pr = d1; rtp = eolian_parameter_type_get(pr); var_as_ret = EINA_TRUE; def_ret = eolian_parameter_default_value_get(pr); } eina_iterator_free(itr); } } else if (ftype == EOLIAN_PROP_SET) func_suffix = "_set"; Eina_Strbuf *params = eina_strbuf_new(); /* par1, par2, par3, ... */ Eina_Strbuf *params_full = eina_strbuf_new(); /* T par1, U par2, ... for decl */ Eina_Strbuf *params_full_imp = eina_strbuf_new(); /* as above, for impl */ Eina_Strbuf *params_init = eina_strbuf_new(); /* default value inits */ Eina_Stringshare *promise_param_name = NULL; Eina_Stringshare *promise_param_type = NULL; /* property keys */ { Eina_Iterator *itr = eolian_property_keys_get(fid, ftype); Eolian_Function_Parameter *pr; EINA_ITERATOR_FOREACH(itr, pr) { const char *prn = eolian_parameter_name_get(pr); const Eolian_Type *pt = eolian_parameter_type_get(pr); Eina_Stringshare *ptn = eolian_type_c_type_get(pt); if (eina_strbuf_length_get(params)) eina_strbuf_append(params, ", "); eina_strbuf_append(params, prn); eina_strbuf_append_printf(params_full, ", %s", ptn); eina_strbuf_append_printf(params_full_imp, ", %s", ptn); if (ptn[strlen(ptn) - 1] != '*') { eina_strbuf_append_char(params_full, ' '); eina_strbuf_append_char(params_full_imp, ' '); } eina_strbuf_append(params_full, prn); eina_strbuf_append(params_full_imp, prn); if (is_empty || is_auto) eina_strbuf_append(params_full_imp, " EINA_UNUSED"); eina_stringshare_del(ptn); } eina_iterator_free(itr); } /* property values or method params if applicable */ if (!var_as_ret) { Eina_Iterator *itr; if (is_prop) itr = eolian_property_values_get(fid, ftype); else itr = eolian_function_parameters_get(fid); Eolian_Function_Parameter *pr; EINA_ITERATOR_FOREACH(itr, pr) { Eolian_Parameter_Dir pd = eolian_parameter_direction_get(pr); const Eolian_Expression *dfv = eolian_parameter_default_value_get(pr); const char *prn = eolian_parameter_name_get(pr); const Eolian_Type *pt = eolian_parameter_type_get(pr); Eina_Stringshare *ptn = eolian_type_c_type_get(pt); Eina_Bool had_star = ptn[strlen(ptn) - 1] == '*'; const char *add_star = _get_add_star(ftype, pd); if (eina_strbuf_length_get(params)) eina_strbuf_append(params, ", "); eina_strbuf_append(params_full_imp, ", "); eina_strbuf_append(params_full_imp, ptn); if (!had_star) eina_strbuf_append_char(params_full_imp, ' '); eina_strbuf_append(params_full_imp, add_star); eina_strbuf_append(params_full_imp, prn); if (!dfv && is_empty) eina_strbuf_append(params_full_imp, " EINA_UNUSED"); eina_strbuf_append(params, prn); eina_strbuf_append(params_full, ", "); eina_strbuf_append(params_full, ptn); if (!had_star) eina_strbuf_append_char(params_full, ' '); eina_strbuf_append(params_full, add_star); eina_strbuf_append(params_full, prn); if (is_auto) { if (ftype == EOLIAN_PROP_SET) eina_strbuf_append_printf(params_init, " %s = pd->%s;\n", prn, prn); else { eina_strbuf_append_printf(params_init, " if (%s) *%s = pd->%s;\n", prn, prn, prn); } } else if ((ftype != EOLIAN_PROP_SET) && dfv) { Eolian_Value val = eolian_expression_eval(src, dfv, EOLIAN_MASK_ALL); if (val.type) { Eina_Stringshare *vals = eolian_expression_value_to_literal(&val); eina_strbuf_append_printf(params_init, " if (%s) *%s = %s;", prn, prn, vals); eina_stringshare_del(vals); if (eolian_expression_type_get(dfv) == EOLIAN_EXPR_NAME) { Eina_Stringshare *vs = eolian_expression_serialize(dfv); eina_strbuf_append_printf(params_init, " /* %s */", vs); eina_stringshare_del(vs); } eina_strbuf_append_char(params_init, '\n'); } } eina_stringshare_del(ptn); }
static Eina_Bool data(Shotgun_Auth *auth, int type __UNUSED__, Ecore_Con_Event_Server_Data *ev) { char *recv, *data, *p; size_t size; if ((auth != ecore_con_server_data_get(ev->server)) || (!auth)) return ECORE_CALLBACK_PASS_ON; ecore_timer_reset(auth->keepalive); if (ev->size == 1) { DBG("Received carriage return"); return ECORE_CALLBACK_RENEW; } else if ((ev->size == 38) && (!memcmp(ev->data, "<?xml version=\"1.0", sizeof("<?xml version=\"1.0") - 1)) && (((unsigned char*)ev->data)[ev->size - 1] == '>')) { DBG("Received xml version tag"); return ECORE_CALLBACK_RENEW; } if (eina_log_domain_level_check(shotgun_log_dom, EINA_LOG_LEVEL_DBG)) { recv = alloca(ev->size + 1); memcpy(recv, ev->data, ev->size); for (p = recv + ev->size - 1; isspace(*p); p--) *p = 0; recv[ev->size] = 0; DBG("Receiving %i bytes:\n%s", ev->size, recv); } if (!shotgun_data_detect(auth, ev)) return ECORE_CALLBACK_RENEW; if (auth->state < SHOTGUN_CONNECTION_STATE_CONNECTED) { shotgun_login(auth, ev); return ECORE_CALLBACK_RENEW; } data = auth->buf ? (char*)eina_strbuf_string_get(auth->buf) : (char*)ev->data; size = auth->buf ? eina_strbuf_length_get(auth->buf) : (size_t)ev->size; switch (shotgun_data_tokenize(auth, ev)) { case SHOTGUN_DATA_TYPE_MSG: shotgun_message_feed(auth, data, size); break; case SHOTGUN_DATA_TYPE_IQ: shotgun_iq_feed(auth, data, size); break; case SHOTGUN_DATA_TYPE_PRES: shotgun_presence_feed(auth, data, size); break; default: ERR("UNPARSABLE TAG %d", shotgun_data_tokenize(auth, ev)); break; } if (auth->buf) eina_strbuf_free(auth->buf); auth->buf = NULL; return ECORE_CALLBACK_RENEW; }
static Eina_Bool shotgun_data_detect(Shotgun_Auth *auth, Ecore_Con_Event_Server_Data *ev) { size_t len = ev->size; const char *tag, *data = (char*)ev->data; char buf[24] = {0}; if (((char*)ev->data)[ev->size - 1] != '>') { if (!auth->buf) { DBG("Creating event buffer"); auth->buf = eina_strbuf_new(); } if ((len >= 21) && (!memcmp(data, "<?xml version=", sizeof("<?xml version=") - 1))) { DBG("Received xml version tag"); data += 21, len -= 21; } DBG("Appending %zu to buffer", len); //fprintf(stdout, "%*s\n", len, (char*)data); eina_strbuf_append_length(auth->buf, data, len); return EINA_FALSE; } if (auth->buf) { DBG("Appending %i to buffer", ev->size); //fprintf(stdout, "%*s\n", ev->size, (char*)ev->data); eina_strbuf_append_length(auth->buf, ev->data, ev->size); } data = auth->buf ? (char*)eina_strbuf_string_get(auth->buf) : (char*)ev->data; len = auth->buf ? eina_strbuf_length_get(auth->buf) : (size_t)ev->size; if ((len >= 21) && (!memcmp(data, "<?xml version=", sizeof("<?xml version=") - 1))) { DBG("Received xml version tag"); data += 21, len -= 21; } tag = data + 1, len--;; while ((tag[0] != '>') && (tag[0] != ' ')) { //DBG("\ndata: '%s'\ntag: '%s'", data, tag); tag++, len--; } if (!memcmp(data, "<stream:stream", sizeof("<stream:stream") - 1)) return EINA_TRUE; if ((tag[len - 2] == '/') && (len >= 7) && memcmp(data, "<stream", 7)) return EINA_TRUE; //fprintf(stderr, "tag: %*s || end: %*s\n", tag - data - 1, data + 1, tag - data - 1, tag + len - (tag - data)); if ((data != tag + len - (tag - data) - 1) && (!memcmp(data + 1, tag + len - (tag - data), tag - data - 1))) { if (eina_log_domain_level_check(shotgun_log_dom, EINA_LOG_LEVEL_DBG)) { memcpy(buf, data + 1, sizeof(buf) - 1); DBG("'%s' and '%s' match!", buf, tag + len - (tag - data)); DBG("Releasing buffered event!"); } return EINA_TRUE; } memcpy(buf, data + 1, sizeof(buf) - 1); DBG("'%s' and '%s' do not match!", buf, tag + len - (tag - data)); if (!auth->buf) { DBG("Creating event buffer"); auth->buf = eina_strbuf_new(); DBG("Appending %i to buffer", ev->size); eina_strbuf_append_length(auth->buf, ev->data, ev->size); } return EINA_FALSE; }
static int _append_section(const char *desc, int ind, int curl, Eina_Strbuf *buf, Eina_Strbuf *wbuf, Eina_Bool use_legacy) { while (*desc) { eina_strbuf_reset(wbuf); while (*desc && isspace(*desc) && (*desc != '\n')) eina_strbuf_append_char(wbuf, *desc++); if (*desc == '\\') { desc++; if ((*desc != '@') && (*desc != '$')) eina_strbuf_append_char(wbuf, '\\'); eina_strbuf_append_char(wbuf, *desc++); } else if (*desc == '@') { const char *ref = ++desc; if (isalpha(*desc) || (*desc == '_')) { eina_strbuf_append(wbuf, "@ref "); while (isalnum(*desc) || (*desc == '.') || (*desc == '_')) ++desc; if (*(desc - 1) == '.') --desc; Eina_Stringshare *refn = eina_stringshare_add_length(ref, desc - ref); _generate_ref(refn, wbuf, use_legacy); eina_stringshare_del(refn); } else eina_strbuf_append_char(wbuf, '@'); } else if (*desc == '$') { desc++; if (isalpha(*desc)) eina_strbuf_append(wbuf, "@c "); else eina_strbuf_append_char(wbuf, '$'); } while (*desc && !isspace(*desc)) eina_strbuf_append_char(wbuf, *desc++); int limit = DOC_LIMIT(ind); int wlen = eina_strbuf_length_get(wbuf); if ((int)(curl + wlen) > limit) { curl = 3; eina_strbuf_append_char(buf, '\n'); curl += _indent_line(buf, ind); eina_strbuf_append(buf, " * "); if (*eina_strbuf_string_get(wbuf) == ' ') eina_strbuf_remove(wbuf, 0, 1); } curl += eina_strbuf_length_get(wbuf); eina_strbuf_append(buf, eina_strbuf_string_get(wbuf)); if (*desc == '\n') { desc++; eina_strbuf_append_char(buf, '\n'); while (*desc == '\n') { _indent_line(buf, ind); eina_strbuf_append(buf, " *\n"); desc++; } curl = _indent_line(buf, ind) + 3; eina_strbuf_append(buf, " * "); } } return curl; }
/** * @brief Send data to a client * * This function is used to queue arbitrary data to send to a client through its module. It will automatically * generate all http header strings from @p net (if provided) including the content-length (based on @p data). * @param module The client's #Azy_Server_Module object (NOT NULL) * @param net An #Azy_Net object containing http information to use * @param data The data to send * @return EINA_TRUE on success, else EINA_FALSE */ Eina_Bool azy_server_module_send(Azy_Server_Module *module, Azy_Net *net, const Azy_Net_Data *data) { Eina_Strbuf *header; char chunk_size[20]; Eina_Binbuf *chunk_data; Eina_Bool nullify = EINA_FALSE; if (!AZY_MAGIC_CHECK(module, AZY_MAGIC_SERVER_MODULE)) { AZY_MAGIC_FAIL(module, AZY_MAGIC_SERVER_MODULE); return EINA_FALSE; } if (net) { if (!module->client->current) { module->client->current = net; nullify = EINA_TRUE; } if (net->headers_sent) goto post_header; Eina_Bool s; if ((data) && (net->http.transfer_encoding != AZY_NET_TRANSFER_ENCODING_CHUNKED)) azy_net_content_length_set(net, data->size); if (!net->http.res.http_code) azy_net_code_set(net, 200); /* OK */ azy_net_type_set(net, AZY_NET_TYPE_RESPONSE); EINA_SAFETY_ON_TRUE_RETURN_VAL(!(header = azy_net_header_create(net)), EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(module->client->current->conn, EINA_FALSE); s = !!ecore_con_client_send(module->client->current->conn, eina_strbuf_string_get(header), eina_strbuf_length_get(header)); eina_strbuf_free(header); if (!s) { ERR("Could not queue header for sending!"); return EINA_FALSE; } net->headers_sent = EINA_TRUE; } post_header: if ((!net) || (net->http.transfer_encoding != AZY_NET_TRANSFER_ENCODING_CHUNKED)) { if (!data || !data->data) return EINA_TRUE; EINA_SAFETY_ON_NULL_RETURN_VAL(module->client->current->conn, EINA_FALSE); EINA_SAFETY_ON_TRUE_RETURN_VAL(!ecore_con_client_send(module->client->current->conn, data->data, data->size), EINA_FALSE); goto post_send; } if (!data || !data->data) { EINA_SAFETY_ON_NULL_RETURN_VAL(module->client->current->conn, EINA_FALSE); EINA_SAFETY_ON_TRUE_RETURN_VAL(!ecore_con_client_send(module->client->current->conn, "0\r\n\r\n", 5), EINA_FALSE); goto post_send; } net->refcount++; sprintf((char *)chunk_size, "%" PRIx64 "\r\n", data->size); chunk_data = eina_binbuf_new(); eina_binbuf_append_length(chunk_data, (unsigned char *)chunk_size, strlen(chunk_size)); eina_binbuf_append_length(chunk_data, data->data, data->size); eina_binbuf_append_length(chunk_data, (unsigned char *)"\r\n", 2); EINA_SAFETY_ON_NULL_RETURN_VAL(module->client->current->conn, EINA_FALSE); EINA_SAFETY_ON_TRUE_RETURN_VAL(!ecore_con_client_send(module->client->current->conn, eina_binbuf_string_get(chunk_data), eina_binbuf_length_get(chunk_data)), EINA_FALSE); eina_binbuf_free(chunk_data); post_send: if (nullify) module->client->current = NULL; return EINA_TRUE; }
static int _append_section(const Eolian_State *state, const char *desc, int ind, int curl, Eina_Strbuf *buf, Eina_Strbuf *wbuf) { Eina_Bool try_note = EINA_TRUE; while (*desc) { eina_strbuf_reset(wbuf); while (*desc && isspace(*desc) && (*desc != '\n')) eina_strbuf_append_char(wbuf, *desc++); if (try_note) { #define CHECK_NOTE(str) !strncmp(desc, str ": ", sizeof(str ":")) if (CHECK_NOTE("Note")) { eina_strbuf_append(wbuf, "@note "); desc += sizeof("Note:"); } else if (CHECK_NOTE("Warning")) { eina_strbuf_append(wbuf, "@warning "); desc += sizeof("Warning:"); } else if (CHECK_NOTE("Remark")) { eina_strbuf_append(wbuf, "@remark "); desc += sizeof("Remark:"); } else if (CHECK_NOTE("TODO")) { eina_strbuf_append(wbuf, "@todo "); desc += sizeof("TODO:"); } #undef CHECK_NOTE try_note = EINA_FALSE; } if (*desc == '\\') { desc++; if ((*desc != '@') && (*desc != '$')) eina_strbuf_append_char(wbuf, '\\'); eina_strbuf_append_char(wbuf, *desc++); } else if (*desc == '@') { const char *ref = ++desc; if (isalpha(*desc) || (*desc == '_')) { eina_strbuf_append(wbuf, "@ref "); while (isalnum(*desc) || (*desc == '.') || (*desc == '_')) ++desc; if (*(desc - 1) == '.') --desc; Eina_Stringshare *refn = eina_stringshare_add_length(ref, desc - ref); _generate_ref(state, refn, wbuf); eina_stringshare_del(refn); } else eina_strbuf_append_char(wbuf, '@'); } else if (*desc == '$') { desc++; if (isalpha(*desc)) eina_strbuf_append(wbuf, "@c "); else eina_strbuf_append_char(wbuf, '$'); } while (*desc && !isspace(*desc)) eina_strbuf_append_char(wbuf, *desc++); int limit = DOC_LIMIT(ind); int wlen = eina_strbuf_length_get(wbuf); if ((int)(curl + wlen) > limit) { curl = 3; eina_strbuf_append_char(buf, '\n'); curl += _indent_line(buf, ind); eina_strbuf_append(buf, " * "); if (*eina_strbuf_string_get(wbuf) == ' ') eina_strbuf_remove(wbuf, 0, 1); } curl += eina_strbuf_length_get(wbuf); eina_strbuf_append(buf, eina_strbuf_string_get(wbuf)); if (*desc == '\n') { desc++; eina_strbuf_append_char(buf, '\n'); while (*desc == '\n') { _indent_line(buf, ind); eina_strbuf_append(buf, " *\n"); desc++; try_note = EINA_TRUE; } curl = _indent_line(buf, ind) + 3; eina_strbuf_append(buf, " * "); } } return curl; }