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; }