static void upnpc_desc_received(struct evhttp_request * req, void * pvoid)
{
size_t len;
unsigned char * data;
struct evbuffer * input_buffer;
struct IGDdatas igd;
struct xmlparser parser;
upnpc_device_t * d = (upnpc_device_t *)pvoid;
if(req == NULL) {
debug_printf("%s(%p, %p) NULL argument !\n", __func__, req, pvoid);
return;
}
input_buffer = evhttp_request_get_input_buffer(req);
len = evbuffer_get_length(input_buffer);
data = evbuffer_pullup(input_buffer, len);
debug_printf("%s %d (%d bytes)\n", __func__, evhttp_request_get_response_code(req), (int)len);
if(evhttp_request_get_response_code(req) != HTTP_OK) {
d->parent->ready_cb(evhttp_request_get_response_code(req), d->parent, d, d->parent->cb_data);
return;
}
if(data == NULL) {
d->parent->ready_cb(UPNPC_ERR_ROOT_DESC_ERROR, d->parent, d, d->parent->cb_data);
return;
}
debug_printf("%.*s\n", (int)len, (char *)data);
memset(&igd, 0, sizeof(struct IGDdatas));
memset(&parser, 0, sizeof(struct xmlparser));
parser.xmlstart = (char *)data;
parser.xmlsize = len;
parser.data = &igd;
parser.starteltfunc = IGDstartelt;
parser.endeltfunc = IGDendelt;
parser.datafunc = IGDdata;
parsexml(&parser);
#ifdef DEBUG
printIGD(&igd);
#endif /* DEBUG */
d->control_conn_url = build_url_string(igd.urlbase, d->root_desc_location, igd.first.controlurl);
d->event_conn_url = build_url_string(igd.urlbase, d->root_desc_location, igd.first.eventsuburl);
d->conn_service_type = strdup(igd.first.servicetype);
d->control_cif_url = build_url_string(igd.urlbase, d->root_desc_location, igd.CIF.controlurl);
d->event_cif_url = build_url_string(igd.urlbase, d->root_desc_location, igd.CIF.eventsuburl);
d->cif_service_type = strdup(igd.CIF.servicetype);
debug_printf("control_conn_url='%s'\n (service_type='%s')\n",
d->control_conn_url, d->conn_service_type);
debug_printf("event_conn_url='%s'\n", d->event_conn_url);
debug_printf("control_cif_url='%s'\n (service_type='%s')\n",
d->control_cif_url, d->cif_service_type);
if((d->cif_service_type == NULL)
|| (strlen(d->cif_service_type) == 0)
|| (!COMPARE(d->cif_service_type, "urn:schemas-upnp-org:service:WANCommonInterfaceConfig:"))) {
d->parent->ready_cb(UPNPC_ERR_NOT_IGD, d->parent, d, d->parent->cb_data);
} else {
d->state |= UPNPC_DEVICE_GETSTATUS;
upnpc_get_status_info(d);
}
}
static void upnpc_subscribe_response(struct evhttp_request * req, void * pvoid)
{
size_t len;
unsigned char * data;
struct evbuffer * input_buffer;
upnpc_device_t * d = (upnpc_device_t *)pvoid;
if(req == NULL) {
debug_printf("%s(%p, %p) NULL argument !\n", __func__, req, pvoid);
return;
}
input_buffer = evhttp_request_get_input_buffer(req);
len = evbuffer_get_length(input_buffer);
data = evbuffer_pullup(input_buffer, len);
debug_printf("%s %d (%d bytes)\n", __func__, evhttp_request_get_response_code(req), (int)len);
d->state &= ~UPNPC_DEVICE_SOAP_REQ;
if(evhttp_request_get_response_code(req) != HTTP_OK) {
/* TODO ERROR */
} else {
const char * sid;
struct evkeyvalq * headers = evhttp_request_get_input_headers(req);
sid = evhttp_find_header(headers, "sid");
debug_printf("SID=%s\n", sid);
if(sid) {
if(d->event_conn_sid)
free(d->event_conn_sid);
d->event_conn_sid = strdup(sid);
}
}
}
/* never called on an empty response */
static void
ev_write_cb(struct evhttp_request *ev_req,
void *data)
{
struct op *op = (struct op *)data;
size_t len;
uint64_t num_bytes;
int ret;
struct evbuffer *ev_in_buf;
assert(op->req.ev_http == ev_req);
ev_in_buf = evhttp_request_get_input_buffer(ev_req);
if (ev_in_buf == NULL) {
dbg(0, "invalid NULL input buffer in write callback!\n");
conn_op_cancel(op);
return;
}
len = evbuffer_get_length(ev_in_buf);
if (len <= 0) {
dbg(0, "invalid input buffer len: %d\n", (int)len);
conn_op_cancel(op);
return;
}
num_bytes = len;
op->rsp.write_cbs++;
dbg(9, "ev write cb %" PRIu64 "\n", op->rsp.write_cbs);
/* alloc content buffer on the first callback, or if clen is unknown */
if ((op->rsp.write_cbs == 1) || (op->rsp.clen_recvd == false)) {
int ret_code;
/*
* should already have the http response code.
* XXX what if the response code hasn't arrived yet?
*/
ret_code = evhttp_request_get_response_code(ev_req);
op->rsp.err_code = ret_code;
op->rsp.is_error = op_rsp_is_error(op->opcode, ret_code);
if (op->rsp.is_error) {
ret = ev_write_alloc_err(op, num_bytes);
} else {
ret = ev_write_alloc_std(op, num_bytes);
}
if (ret < 0) {
dbg(0, "failed to allocate response buffer\n");
conn_op_cancel(op);
return;
}
}
if (op->rsp.is_error) {
ret = ev_write_err(op, ev_in_buf, num_bytes);
} else {
ret = ev_write_std(op, ev_in_buf, num_bytes);
}
if (ret < 0) {
conn_op_cancel(op);
return;
}
return;
}
/*
******************************************************************************
* dgadmin_rest_sync_response_handler -- *//**
*
* \brief This routine handles response:
* . copy out request input buffer
* . return response code
*
* \param [in] req A pointer to a evhttp_request data structure.
*
* \param [out] arg A pointer to a dgadmin_rest_sync_response_args_t
* data structure including a pointer to input buffer
* and response code.
*
* \retval None
*
*****************************************************************************/
static void dgadmin_rest_sync_response_handler(struct evhttp_request *req, void *arg)
{
dgadmin_rest_sync_response_args_t *args = (dgadmin_rest_sync_response_args_t *)arg;
struct evbuffer *req_body = NULL;
unsigned int buf_len;
int n;
/* sanity check */
if (req == NULL)
{
log_notice(ServiceUtilLogLevel,"ERROR");
return;
}
/* extract request body */
if ((req_body = evhttp_request_get_input_buffer(req)) == NULL)
{
log_notice(ServiceUtilLogLevel,"ERROR");
return;
}
buf_len = evbuffer_get_length(req_body)+1;
args->req_body_buf = (char *)malloc(buf_len);
n = evbuffer_copyout(req_body, args->req_body_buf, buf_len);
args->req_body_buf[n]='\0';
args->res_code = evhttp_request_get_response_code(req);
return;
}
static void s3http_connection_on_responce_cb (struct evhttp_request *req, void *ctx)
{
RequestData *data = (RequestData *) ctx;
struct evbuffer *inbuf;
const char *buf = NULL;
size_t buf_len;
LOG_debug (CON_LOG, "Got HTTP response from server !");
if (!req) {
LOG_err (CON_LOG, "Request failed !");
if (data->error_cb)
data->error_cb (data->con, data->ctx);
goto done;
}
// XXX: handle redirect
// 200 and 204 (No Content) are ok
if (evhttp_request_get_response_code (req) != 200 && evhttp_request_get_response_code (req) != 204
&& evhttp_request_get_response_code (req) != 307) {
LOG_err (CON_LOG, "Server returned HTTP error: %d !", evhttp_request_get_response_code (req));
LOG_debug (CON_LOG, "Error str: %s", req->response_code_line);
if (data->error_cb)
data->error_cb (data->con, data->ctx);
goto done;
}
inbuf = evhttp_request_get_input_buffer (req);
buf_len = evbuffer_get_length (inbuf);
buf = (const char *) evbuffer_pullup (inbuf, buf_len);
if (data->responce_cb)
data->responce_cb (data->con, data->ctx, buf, buf_len, evhttp_request_get_input_headers (req));
else
LOG_debug (CON_LOG, ">>> NO callback function !");
done:
g_free (data);
}
static void http_request_done(struct evhttp_request *req, void *ctx) {
struct client_rpc_callback_with_data *m_ctx =
(struct client_rpc_callback_with_data *)ctx;
rpc_callback client_cb = m_ctx->cb;
void *data = m_ctx->data;
struct evhttp_connection *evcon = m_ctx->evcon;
free(m_ctx);
if(req == NULL) {
client_cb(NULL, "(req=NULL) Unknown error occurred while remote procedure", data);
return;
}
int res_code = evhttp_request_get_response_code(req);
char *res_code_line = "Internal server error";
printf("Got response for req %p with ctx = %p res_code = %d\n",
req, ctx, res_code);
if(res_code == 500) {
client_cb(NULL, res_code_line, data);
} else if(res_code != HTTP_OK) {
if(res_code == 0) {
client_cb(NULL, "host not reachable", data);
} else {
client_cb(NULL, "communication error", data);
}
} else {
char *json = read_req_buffer(req);
if(!json) {
client_cb(NULL, "(json=NULL) Unknown error occurred while remote procedure", data);
return;
}
char *err = NULL;
struct data_t *result = deserialize_result(json, &err);
client_cb(result, err, data);
if(result) {
free_data_t(result);
}
if(err) {
free(err);
}
if(json) {
free(json);
}
}
if(evcon) {
evhttp_connection_free(evcon);
}
}
/*
*****************************************************************************
* http_request_version_update -- *//**
*
* \brief This routine update local node version when success to handle the req.
*
* \param [in] req A pointer to a evhttp_request data structure.
*
* \retval 0 Success
* \retval >0 Failure
*
*****************************************************************************/
static int http_request_version_update(struct evhttp_request *req)
{
int local_version, version_create = 0, version_update = 0;
int res_code;
int ret = DOVE_STATUS_ERROR;
do
{
ret = dps_rest_sync_version_get_from_req(req, &version_create, &version_update);
log_info(RESTHandlerLogLevel,
"Get sync version from request status %s",
DOVEStatusToString(ret));
if (ret != DOVE_STATUS_OK)
{
break;
}
log_info(RESTHandlerLogLevel, "Got sync version: create %d, update %d",
version_create, version_update);
res_code = evhttp_request_get_response_code(req);
log_info(RESTHandlerLogLevel, "Response Code: %d", res_code);
if ((res_code != HTTP_OK) && (res_code != 201))
{
break;
}
/* update local node version if only sucess to handle the request */
//cmd_type = evhttp_request_get_command(req);
//if (cmd_type == EVHTTP_REQ_POST)
//{
// local_version = version_create;
//}
//else
{
local_version = version_update;
}
dps_cluster_node_heartbeat(&dcs_local_ip,
dps_cluster_is_local_node_active(),
local_version);
log_notice(RESTHandlerLogLevel,
"Updated local node DMC config version to %d",
local_version);
ret = DOVE_STATUS_OK;
} while(0);
return ret;
}
static void
http_request_done(struct evhttp_request *req, void *ctx)
{
char buffer[256];
int nread;
if (req == NULL) {
/* If req is NULL, it means an error occurred, but
* sadly we are mostly left guessing what the error
* might have been. We'll do our best... */
struct bufferevent *bev = (struct bufferevent *) ctx;
unsigned long oslerr;
int printed_err = 0;
int errcode = EVUTIL_SOCKET_ERROR();
fprintf(stderr, "some request failed - no idea which one though!\n");
/* Print out the OpenSSL error queue that libevent
* squirreled away for us, if any. */
while ((oslerr = bufferevent_get_openssl_error(bev))) {
ERR_error_string_n(oslerr, buffer, sizeof(buffer));
fprintf(stderr, "%s\n", buffer);
printed_err = 1;
}
/* If the OpenSSL error queue was empty, maybe it was a
* socket error; let's try printing that. */
if (! printed_err)
fprintf(stderr, "socket error = %s (%d)\n",
evutil_socket_error_to_string(errcode),
errcode);
return;
}
fprintf(stderr, "Response line: %d %s\n",
evhttp_request_get_response_code(req),
evhttp_request_get_response_code_line(req));
while ((nread = evbuffer_remove(evhttp_request_get_input_buffer(req),
buffer, sizeof(buffer)))
> 0) {
/* These are just arbitrary chunks of 256 bytes.
* They are not lines, so we can't treat them as such. */
fwrite(buffer, nread, 1, stdout);
}
}
static void upnpc_soap_response(struct evhttp_request * req, void * pvoid)
{
size_t len;
unsigned char * data;
struct evbuffer * input_buffer;
upnpc_device_t * d = (upnpc_device_t *)pvoid;
int code;
if(req == NULL) {
debug_printf("%s(%p, %p) NULL argument !\n", __func__, req, pvoid);
return;
}
code = evhttp_request_get_response_code(req);
input_buffer = evhttp_request_get_input_buffer(req);
len = evbuffer_get_length(input_buffer);
data = evbuffer_pullup(input_buffer, len);
debug_printf("%s %d (%d bytes)\n", __func__, code, (int)len);
debug_printf("%.*s\n", (int)len, (char *)data);
if(data == NULL)
return;
ClearNameValueList(&d->soap_response_data);
ParseNameValue((char *)data, (int)len,
&d->soap_response_data);
d->state &= ~UPNPC_DEVICE_SOAP_REQ;
if(d->state & UPNPC_DEVICE_READY) {
d->parent->soap_cb(code, d->parent, d, d->parent->cb_data);
} else if(d->state & UPNPC_DEVICE_GETSTATUS) {
const char * connection_status;
d->state &= ~UPNPC_DEVICE_GETSTATUS;
connection_status = GetValueFromNameValueList(&d->soap_response_data, "NewConnectionStatus");
d->state |= UPNPC_DEVICE_READY;
if((code == 200) && connection_status && (0 == strcmp("Connected", connection_status))) {
d->parent->ready_cb(code, d->parent, d, d->parent->cb_data);
d->state |= UPNPC_DEVICE_CONNECTED;
event_del(d->parent->ev_ssdp_recv);
} else {
d->parent->ready_cb(UPNPC_ERR_NOT_CONNECTED, d->parent, d, d->parent->cb_data);
}
}
}
static void http_request_done(struct evhttp_request *req, void *ctx)
{
HTTPReply *reply = static_cast<HTTPReply*>(ctx);
if (req == nullptr) {
/* If req is nullptr, it means an error occurred while connecting: the
* error code will have been passed to http_error_cb.
*/
reply->status = 0;
return;
}
reply->status = evhttp_request_get_response_code(req);
struct evbuffer *buf = evhttp_request_get_input_buffer(req);
if (buf)
{
size_t size = evbuffer_get_length(buf);
const char *data = (const char*)evbuffer_pullup(buf, size);
if (data)
reply->body = std::string(data, size);
evbuffer_drain(buf, size);
}
}
static void http_request_done(struct evhttp_request *req, void *ctx)
{
HTTPReply *reply = static_cast<HTTPReply*>(ctx);
if (req == nullptr) {
/* If req is nullptr, it means an error occurred while connecting, but
* I'm not sure how to find out which one. We also don't really care.
*/
reply->status = 0;
return;
}
reply->status = evhttp_request_get_response_code(req);
struct evbuffer *buf = evhttp_request_get_input_buffer(req);
if (buf)
{
size_t size = evbuffer_get_length(buf);
const char *data = (const char*)evbuffer_pullup(buf, size);
if (data)
reply->body = std::string(data, size);
evbuffer_drain(buf, size);
}
}
static void
http_request_done(struct evhttp_request *req, void *ctx) {
char buffer[256];
ev_ssize_t nread;
struct evkeyval *header;
if (req == NULL) {
/* If req is NULL, it means an error occurred, but
* sadly we are mostly left guessing what the error
* might have been. We'll do our best... */
struct bufferevent *bev = (struct bufferevent *) ctx;
int errcode = EVUTIL_SOCKET_ERROR();
fprintf(stderr, "some request failed - no idea which one though!\n");
/* Print out the OpenSSL error queue that libevent
* squirreled away for us, if any. */
/* If the OpenSSL error queue was empty, maybe it was a
* socket error; let's try printing that. */
fprintf(stderr, "socket error = %s (%d)\n",
evutil_socket_error_to_string(errcode),
errcode);
return;
}
/*fprintf(stderr, "Response line: %d %s\n",
evhttp_request_get_response_code(req),
evhttp_request_get_response_code_line(req));
struct evkeyvalq *headers = evhttp_request_get_input_headers(req);
if (NULL != headers) {
fprintf(stderr, "Response headers:\n");
TAILQ_FOREACH(header, headers, next) {
fprintf(stderr, "%s: %s\r\n",
header->key, header->value);
}
fprintf(stderr, "\n");
}*/
const int http_code = evhttp_request_get_response_code(req);
struct evhttp_connection *evcon = evhttp_request_get_connection(req);
if (HTTP_MOVEPERM == http_code || HTTP_MOVETEMP == http_code) {
const char *location = evhttp_find_header(evhttp_request_get_input_headers(req), "Location");
if (NULL != location) {
//fprintf(stderr, "Location: %s\n", location);
create_request(location);
}
}
if (HTTP_OK == http_code) {
struct evbuffer *input_buffer = evhttp_request_get_input_buffer(req);
int found = 0;
while ((nread = evbuffer_remove(input_buffer, buffer, sizeof (buffer))) > 0) {
if (0 == search_find(&search_list, buffer, nread)) {
found = 1;
break;
}
}
fprintf(stderr, "%s: %d\n", evhttp_find_header(evhttp_request_get_output_headers(req), "Host"), found);
}
if (--n_pending_requests == 0)
event_base_loopexit(base, NULL);
}
static int64_t HHVM_METHOD(EventHttpRequest, getResponseCode) {
EventHttpRequestResourceData *event_http_request_resource_data = FETCH_RESOURCE(this_, EventHttpRequestResourceData, s_event_http_request);
return evhttp_request_get_response_code((evhttp_request_t *) event_http_request_resource_data->getInternalResourceData());
}
static void dps_node_http_response_handler(struct evhttp_request *req, void *arg)
{
#if defined(NDEBUG)
const char *cmdtype;
#endif
struct evkeyvalq *headers;
struct evkeyval *header;
struct evbuffer *buf;
int response_code;
log_debug(RESTHandlerLogLevel, "Enter: Host");
do
{
if (NULL == req)
{
log_debug(RESTHandlerLogLevel, "NULL == req");
break;
}
log_debug(RESTHandlerLogLevel, "URI %s", evhttp_request_get_uri(req));
#if defined(NDEBUG)
switch (evhttp_request_get_command(req)) {
case EVHTTP_REQ_GET: cmdtype = "GET"; break;
case EVHTTP_REQ_POST: cmdtype = "POST"; break;
case EVHTTP_REQ_HEAD: cmdtype = "HEAD"; break;
case EVHTTP_REQ_PUT: cmdtype = "PUT"; break;
case EVHTTP_REQ_DELETE: cmdtype = "DELETE"; break;
case EVHTTP_REQ_OPTIONS: cmdtype = "OPTIONS"; break;
case EVHTTP_REQ_TRACE: cmdtype = "TRACE"; break;
case EVHTTP_REQ_CONNECT: cmdtype = "CONNECT"; break;
case EVHTTP_REQ_PATCH: cmdtype = "PATCH"; break;
default: cmdtype = "unknown"; break;
}
#endif
response_code = evhttp_request_get_response_code(req);
// 201 is created
if ((response_code != HTTP_OK) && (response_code != 201))
{
log_info(RESTHandlerLogLevel,
"FAILED, URI %s, Response Code NOT HTTP_OK [%d]",
evhttp_request_get_uri(req), response_code);
break;
}
//dps_rest_node_touch(req);
#if defined(NDEBUG)
log_debug(RESTHandlerLogLevel, "Received a %s request for %s",
cmdtype, evhttp_request_get_uri(req));
#endif
log_debug(RESTHandlerLogLevel, "Headers: <<<");
headers = evhttp_request_get_input_headers(req);
for (header = headers->tqh_first; header; header = header->next.tqe_next)
{
log_debug(RESTHandlerLogLevel,"[Key] %s: [Value] %s",
header->key, header->value);
}
log_debug(RESTHandlerLogLevel, "Headers: >>>");
/* Process the response for DPS_DOVE_CONTROLLER_QUERY_DPS_CLUSTER_INFO_URI
Get all the node info from DC response, and add the cluster node into our db
*/
buf = evhttp_request_get_input_buffer(req);
log_debug(RESTHandlerLogLevel, "Input data: <<<");
while (evbuffer_get_length(buf))
{
int n;
char cbuf[1024];
memset((void *)cbuf, 0, sizeof(cbuf));
n = evbuffer_remove(buf, cbuf, sizeof(cbuf)-1);
if (n > 0)
{
log_debug(RESTHandlerLogLevel,"%s", cbuf);
}
}
log_debug(RESTHandlerLogLevel,"Input data: >>>\n");
} while(0);
log_debug(RESTHandlerLogLevel, "Exit");
return;
}
/* Thread: main (pairing) */
static void
pairing_request_cb(struct evhttp_request *req, void *arg)
{
struct remote_info *ri;
struct evbuffer *input_buffer;
uint8_t *response;
char guid[17];
int buflen;
int response_code;
int len;
int i;
int ret;
ri = (struct remote_info *)arg;
if (!req)
{
DPRINTF(E_LOG, L_REMOTE, "Empty pairing request callback\n");
goto cleanup;
}
response_code = evhttp_request_get_response_code(req);
if (response_code != HTTP_OK)
{
DPRINTF(E_LOG, L_REMOTE, "Pairing failed with Remote %s/%s, HTTP response code %d\n", ri->pi.remote_id, ri->pi.name, response_code);
goto cleanup;
}
input_buffer = evhttp_request_get_input_buffer(req);
buflen = evbuffer_get_length(input_buffer);
if (buflen < 8)
{
DPRINTF(E_LOG, L_REMOTE, "Remote %s/%s: pairing response too short\n", ri->pi.remote_id, ri->pi.name);
goto cleanup;
}
response = evbuffer_pullup(input_buffer, -1);
if ((response[0] != 'c') || (response[1] != 'm') || (response[2] != 'p') || (response[3] != 'a'))
{
DPRINTF(E_LOG, L_REMOTE, "Remote %s/%s: unknown pairing response, expected cmpa\n", ri->pi.remote_id, ri->pi.name);
goto cleanup;
}
len = (response[4] << 24) | (response[5] << 16) | (response[6] << 8) | (response[7]);
if (buflen < 8 + len)
{
DPRINTF(E_LOG, L_REMOTE, "Remote %s/%s: pairing response truncated (got %d expected %d)\n",
ri->pi.remote_id, ri->pi.name, buflen, len + 8);
goto cleanup;
}
response += 8;
for (; len > 0; len--, response++)
{
if ((response[0] != 'c') || (response[1] != 'm') || (response[2] != 'p') || (response[3] != 'g'))
continue;
else
{
len -= 8;
response += 8;
break;
}
}
if (len < 8)
{
DPRINTF(E_LOG, L_REMOTE, "Remote %s/%s: cmpg truncated in pairing response\n", ri->pi.remote_id, ri->pi.name);
goto cleanup;
}
for (i = 0; i < 8; i++)
sprintf(guid + (2 * i), "%02X", response[i]);
ri->pi.guid = strdup(guid);
DPRINTF(E_LOG, L_REMOTE, "Pairing succeeded with Remote '%s' (id %s), GUID: %s\n", ri->pi.name, ri->pi.remote_id, guid);
ret = db_pairing_add(&ri->pi);
if (ret < 0)
{
DPRINTF(E_LOG, L_REMOTE, "Failed to register pairing!\n");
goto cleanup;
}
cleanup:
evhttp_connection_free(ri->evcon);
free_remote(ri);
}
static void
request_cb(struct evhttp_request *req, void *arg)
{
struct http_client_ctx *ctx;
const char *response_code_line;
int response_code;
ctx = (struct http_client_ctx *)arg;
if (ctx->headers_only)
{
ctx->ret = 0;
event_base_loopbreak(ctx->evbase);
return;
}
if (!req)
{
DPRINTF(E_WARN, L_HTTP, "Connection to %s failed: Connection timed out\n", ctx->url);
goto connection_error;
}
response_code = evhttp_request_get_response_code(req);
#ifndef HAVE_LIBEVENT2_OLD
response_code_line = evhttp_request_get_response_code_line(req);
#else
response_code_line = "no error text";
#endif
if (response_code == 0)
{
DPRINTF(E_WARN, L_HTTP, "Connection to %s failed: Connection refused\n", ctx->url);
goto connection_error;
}
else if (response_code != 200)
{
DPRINTF(E_WARN, L_HTTP, "Connection to %s failed: %s (error %d)\n", ctx->url, response_code_line, response_code);
goto connection_error;
}
ctx->ret = 0;
if (ctx->headers)
headers_save(ctx->headers, evhttp_request_get_input_headers(req));
if (ctx->body)
evbuffer_add_buffer(ctx->body, evhttp_request_get_input_buffer(req));
event_base_loopbreak(ctx->evbase);
return;
connection_error:
ctx->ret = -1;
event_base_loopbreak(ctx->evbase);
return;
}
