struct evhttp_request* EvHttpSyncClient::newReqest()
{
struct evhttp_request* pReq = evhttp_request_new(handleResponse, this);
if (pReq == NULL)
{
FX_LOG(ERROR, "evhttp_request_new FAILED");
setError(ST_ERROR, "evhttp_request_new FAILED");
return NULL;
}
int rv = evhttp_add_header(evhttp_request_get_output_headers(pReq),
"Host", m_sHost.c_str());
if (rv != 0)
{
FX_LOG(ERROR, "evhttp_add_header FAILED");
setError(ST_ERROR, "evhttp_add_header FAILED");
return NULL;
}
rv = evhttp_add_header(evhttp_request_get_output_headers(pReq),
"Connection", "keep-alive");
if (rv != 0)
{
FX_LOG(ERROR, "evhttp_add_header FAILED");
setError(ST_ERROR, "evhttp_add_header FAILED");
return NULL;
}
return pReq;
}
/**
* pthread entry point, running the reader event base.
*/
void *
comet_run_readers(void *ptr) {
struct reader_thread *rt = ptr;
int i, j;
rt->base = event_base_new();
for(i = 0; i < rt->channel_count; ++i) {
char *chan = rt->channels[i];
char *url = calloc(strlen(chan) + 17, 1);
sprintf(url, "/subscribe?name=%s", chan);
for(j = 0; j < rt->reader_per_chan; ++j) {
struct evhttp_connection *evcon = evhttp_connection_new(rt->hi->host, rt->hi->port);
struct evhttp_request *evreq = evhttp_request_new(on_end_of_subscribe, rt);
evhttp_connection_set_base(evcon, rt->base);
evhttp_request_set_chunked_cb(evreq, on_http_message_chunk);
evhttp_make_request(evcon, evreq, EVHTTP_REQ_GET, url);
/* printf("[SUBSCRIBE: http://127.0.0.1:1234%s]\n", url); */
}
}
event_base_dispatch(rt->base);
return NULL;
}
static int upnpc_get_desc(upnpc_device_t * d, const char * url)
{
char hostname[MAXHOSTNAMELEN+1];
char hostname_port[MAXHOSTNAMELEN+1+6];
unsigned short port;
char * path;
unsigned int scope_id;
struct evhttp_request * req;
struct evkeyvalq * headers;
/* if(d->root_desc_location == NULL) {
return -1;
} */
if(!parseURL(url/*d->root_desc_location*/, hostname, &port,
&path, &scope_id)) {
return -1;
}
if(port != 80)
snprintf(hostname_port, sizeof(hostname_port), "%s:%hu", hostname, port);
else
strncpy(hostname_port, hostname, sizeof(hostname_port));
if(d->desc_conn == NULL) {
d->desc_conn = evhttp_connection_base_new(d->parent->base, NULL, hostname, port);
}
#ifdef DEBUG
evhttp_connection_set_closecb(d->desc_conn, upnpc_conn_close_cb, d);
#endif /* DEBUG */
/*evhttp_connection_set_timeout(p->desc_conn, 600);*/
req = evhttp_request_new(upnpc_desc_received/*callback*/, d);
headers = evhttp_request_get_output_headers(req);
evhttp_add_header(headers, "Host", hostname_port);
evhttp_add_header(headers, "Connection", "close");
/*evhttp_add_header(headers, "User-Agent", "***");*/
return evhttp_make_request(d->desc_conn, req, EVHTTP_REQ_GET, path);
}
void
dispatch(struct evhttp_connection *evcon, int reqno)
{
struct evhttp_request *evreq;
struct request *req;
char *request_uri;
if((req = calloc(1, sizeof(*req))) == nil)
panic("calloc");
req->evcon = evcon;
req->evcon_reqno = reqno;
evreq = evhttp_request_new(&recvcb, req);
if(evreq == nil)
panic("evhttp_request_new");
req->evreq = evreq;
evreq->response_code = -1;
evhttp_add_header(evreq->output_headers, "Host", http_hosthdr);
gettimeofday(&req->starttv, nil);
evtimer_set(&req->timeoutev, timeoutcb,(void *)req);
evtimer_add(&req->timeoutev, &timeouttv);
request_uri = "/";
if (num_requests > 0) {
request_uri = requests[cur_request++];
cur_request = cur_request % (num_requests + 1);
}
evhttp_make_request(evcon, evreq, EVHTTP_REQ_GET, request_uri);
}
static void
http_readcb(struct bufferevent *bev, void *arg)
{
const char *what = "This is funny";
event_debug(("%s: %s\n", __func__, EVBUFFER_DATA(bev->input)));
if (evbuffer_find(bev->input,
(const unsigned char*) what, strlen(what)) != NULL) {
struct evhttp_request *req = evhttp_request_new(NULL, NULL);
enum message_read_status done;
req->kind = EVHTTP_RESPONSE;
done = evhttp_parse_firstline(req, bev->input);
if (done != ALL_DATA_READ)
goto out;
done = evhttp_parse_headers(req, bev->input);
if (done != ALL_DATA_READ)
goto out;
if (done == 1 &&
evhttp_find_header(req->input_headers,
"Content-Type") != NULL)
test_ok++;
out:
evhttp_request_free(req);
bufferevent_disable(bev, EV_READ);
if (base)
event_base_loopexit(base, NULL);
else
event_loopexit(NULL);
}
}
static void perform_ssl_connection (void)
{
struct evhttp_connection *con;
struct evhttp_request *req;
struct bufferevent *bev;
SSL_CTX *sctx;
SSL *ssl;
sctx = SSL_CTX_new (SSLv23_client_method ());
assert (sctx);
SSL_CTX_set_options (sctx, SSL_OP_NO_TLSv1_2);
//SSL_CTX_set_options (sctx, SSL_OP_ALL);
SSL_CTX_set_timeout (sctx, 3000);
SSL_CTX_set_verify (sctx, SSL_VERIFY_PEER, SSLX_CTX_verify_callback);
SSL_CTX_set_default_verify_paths (sctx);
SSL_CTX_set_cipher_list (sctx, "RC4-MD5");
ssl = SSL_new (sctx);
assert (ssl);
bev = bufferevent_openssl_socket_new (evbase, -1, ssl, BUFFEREVENT_SSL_CONNECTING , BEV_OPT_CLOSE_ON_FREE);
//bev = bufferevent_socket_new (evbase, -1, BEV_OPT_CLOSE_ON_FREE);
assert (bev);
con = evhttp_connection_base_bufferevent_new (evbase, dnsbase, bev, HOST, PORT);
evhttp_connection_set_closecb (con, on_connection_close, NULL);
evhttp_connection_set_timeout (con, 10);
req = evhttp_request_new (on_response_cb, NULL);
evhttp_add_header (req->output_headers, "Host", HOST);
// evhttp_add_header (req->output_headers, "Connection", "Keep-Alive");
evhttp_make_request (con, req, EVHTTP_REQ_GET, "/index.html");
}
void
dispatch(runner *run, int reqno)
{
struct evhttp_connection *evcon = run->evcon;
struct evhttp_request *evreq;
struct request *req;
if((req = calloc(1, sizeof(*req))) == nil)
panic("calloc");
run->req = req;
req->evcon = evcon;
req->evcon_reqno = reqno;
evreq = evhttp_request_new(&recvcb, run);
if(evreq == nil)
panic("evhttp_request_new");
req->evreq = evreq;
evreq->response_code = -1;
evhttp_add_header(evreq->output_headers, "Host", http_hosthdr);
gettimeofday(&req->starttv, nil);
evtimer_set(&req->timeoutev, timeoutcb, run);
evtimer_add(&req->timeoutev, &timeouttv);
debug("dispatch(): evtimer_add(&req->timeoutev, &timeouttv);\n");
counts.conns++;
evhttp_make_request(evcon, evreq, EVHTTP_REQ_GET, params.path);
}
void URLConnection::request( const std::string& url, URLConnectionCompleteCB callback, void* callback_data )
///
/// Function to request a page via the GET protocol
///
/// @param url
/// The url to request (note, this does NOT include the host)
///
/// @param callback
/// Callback to call on success / failure of the request
///
/// @param callback_data
/// Data to send back with callback
///
{
// create a struct for handling the real callback for the user of URLConnection
// should be deallocated in the url_connection_callback function
ConnectionCallbackData* cb_data = new ConnectionCallbackData();
cb_data->callback = callback;
cb_data->data = callback_data;
evhttp_request* request = evhttp_request_new(url_connection_callback, cb_data);
// set up appropriate headers for a GET request
char* host_address;
ev_uint16_t port;
evhttp_connection_get_peer(mConnection, &host_address, &port);
evhttp_add_header( request->output_headers, "Host", host_address );
evhttp_add_header( request->output_headers, "User-Agent", mUserAgent.c_str() );
evhttp_make_request(mConnection, request, EVHTTP_REQ_GET, url.c_str());
}
// create S3 and setup HTTP connection request
struct evhttp_request *s3http_connection_create_request (S3HttpConnection *con,
void (*cb)(struct evhttp_request *, void *), void *arg,
const gchar *auth_str)
{
struct evhttp_request *req;
gchar auth_key[300];
struct tm *cur_p;
time_t t = time(NULL);
struct tm cur;
char date[50];
//char hostname[1024];
gmtime_r(&t, &cur);
cur_p = &cur;
snprintf (auth_key, sizeof (auth_key), "AWS %s:%s", application_get_access_key_id (con->app), auth_str);
req = evhttp_request_new (cb, arg);
evhttp_add_header (req->output_headers, "Authorization", auth_key);
evhttp_add_header (req->output_headers, "Host", application_get_host_header (con->app));
if (strftime(date, sizeof(date), "%a, %d %b %Y %H:%M:%S GMT", cur_p) != 0) {
evhttp_add_header (req->output_headers, "Date", date);
}
return req;
}
static void
http_close_detection(int with_delay)
{
short port = -1;
struct evhttp_connection *evcon = NULL;
struct evhttp_request *req = NULL;
test_ok = 0;
fprintf(stdout, "Testing Connection Close Detection%s: ",
with_delay ? " (with delay)" : "");
http = http_setup(&port, NULL);
/* 2 second timeout */
evhttp_set_timeout(http, 2);
evcon = evhttp_connection_new("127.0.0.1", port);
if (evcon == NULL) {
fprintf(stdout, "FAILED\n");
exit(1);
}
delayed_client = evcon;
/*
* At this point, we want to schedule a request to the HTTP
* server using our make request method.
*/
req = evhttp_request_new(close_detect_cb, evcon);
/* Add the information that we care about */
evhttp_add_header(req->output_headers, "Host", "somehost");
/* We give ownership of the request to the connection */
if (evhttp_make_request(evcon,
req, EVHTTP_REQ_GET, with_delay ? "/largedelay" : "/test") == -1) {
fprintf(stdout, "FAILED\n");
exit(1);
}
event_dispatch();
if (test_ok != 1) {
fprintf(stdout, "FAILED\n");
exit(1);
}
/* at this point, the http server should have no connection */
if (TAILQ_FIRST(&http->connections) != NULL) {
fprintf(stdout, "FAILED (left connections)\n");
exit(1);
}
evhttp_connection_free(evcon);
evhttp_free(http);
fprintf(stdout, "OK\n");
}
virtual void SetUp() {
handler_.reset(new HTTPHandler(&DoMyFunc));
base_ = event_base_new();
dnsbase_ = evdns_base_new(base_, 1);
connection_ = evhttp_connection_base_new(base_, dnsbase_, "0.0.0.0", 8080);
request_ = evhttp_request_new(NULL, NULL);
evhttp_make_request(connection_, request_, EVHTTP_REQ_GET, "");
}
void
create_request(const char *url) {
struct evhttp_uri *http_uri = NULL;
const char *host;
struct bufferevent *bev;
struct evhttp_connection *evcon = NULL;
struct evhttp_request *req;
struct evkeyvalq *output_headers;
http_uri = evhttp_uri_parse(url);
if (NULL != http_uri) {
host = evhttp_uri_get_host(http_uri);
if (NULL != host) {
bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);
evcon = evhttp_connection_base_bufferevent_new(base, dnsbase, bev, host, HTTP_PORT);
if (NULL != evcon) {
evhttp_connection_set_timeout(evcon, TIMEOUT);
req = evhttp_request_new(http_request_done, bev);
if (NULL != req) {
output_headers = evhttp_request_get_output_headers(req);
evhttp_add_header(output_headers, "Accept", "text/plain;q=0.8");
evhttp_add_header(output_headers, "Host", host);
evhttp_add_header(output_headers, "User-Agent", "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36");
evhttp_add_header(output_headers, "Connection", "close");
if (0 == evhttp_make_request(evcon, req, EVHTTP_REQ_GET, url)) {
++n_pending_requests;
} else {
evhttp_request_free(req);
fprintf(stderr, "evhttp_make_request() failed\n");
}
//evhttp_request_free(req);
} else {
fprintf(stderr, "evhttp_request_new() failed\n");
}
//evhttp_connection_free(evcon);
} else {
fprintf(stderr, "evhttp_connection_base_bufferevent_new() failed\n");
}
} else {
fprintf(stderr, "url must have a host %s\n", url);
}
evhttp_uri_free(http_uri);
} else {
fprintf(stderr, "malformed url %s\n", url);
}
}
static void HHVM_METHOD(EventHttpRequest, __construct, const Object &callback, const Variant &data) {
evhttp_request_t *http_request;
Resource resource = Resource(NEWOBJ(EventHttpRequestResourceData(this_.get())));
SET_RESOURCE(this_, resource, s_event_http_request);
EventHttpRequestResourceData *resource_data = FETCH_RESOURCE(this_, EventHttpRequestResourceData, s_event_http_request);
http_request = evhttp_request_new(event_http_request_cb, (void *) resource_data);
evhttp_request_own(http_request);
resource_data->setInternalResourceData((void *) http_request);
callback.get()->incRefCount();
resource_data->setCallback(callback.get());
resource_data->setCallbackArg(data);
}
int upnpc_event_subscribe(upnpc_device_t * p)
{
char hostname[MAXHOSTNAMELEN+1];
char hostname_port[MAXHOSTNAMELEN+1+6];
unsigned short port;
char * path;
unsigned int scope_id;
struct evhttp_request * req;
struct evkeyvalq * headers;
char callback_header[7+15+1+5+9+2+1];
if(p->parent->http_server == NULL) {
/* HTTP server to receive event notifications */
p->parent->http_server = evhttp_new(p->parent->base);
if(p->parent->http_server == NULL) {
debug_printf("evhttp_new() FAILED\n");
return -1;
}
evhttp_set_ext_method_cmp(p->parent->http_server, ext_methods_cb);
evhttp_set_allowed_methods(p->parent->http_server, EVHTTP_REQ_NOTIFY);
evhttp_set_cb(p->parent->http_server, "/evt_conn", upnpc_event_conn_req, p);
if(evhttp_bind_socket(p->parent->http_server, p->parent->local_address, p->parent->local_port) < 0) {
debug_printf("evhttp_bind_socket() FAILED\n");
return -1;
}
}
/*if(!parseURL(p->event_cif_url, hostname, &port, &path, &scope_id)) {*/
if(!parseURL(p->event_conn_url, hostname, &port, &path, &scope_id)) {
return -1;
}
if(port != 80)
snprintf(hostname_port, sizeof(hostname_port), "%s:%hu", hostname, port);
else
strncpy(hostname_port, hostname, sizeof(hostname_port));
if(p->soap_conn == NULL) {
p->soap_conn = evhttp_connection_base_new(p->parent->base, NULL, hostname, port);
}
evhttp_connection_set_ext_method_cmp(p->soap_conn, ext_methods_cb);
req = evhttp_request_new(upnpc_subscribe_response, p);
headers = evhttp_request_get_output_headers(req);
/*buffer = evhttp_request_get_output_buffer(req);*/
evhttp_add_header(headers, "Host", hostname_port);
/*evhttp_add_header(headers, "User-Agent", "***");*/
snprintf(callback_header, sizeof(callback_header), "<http://%s:%hu/evt_conn>", p->parent->local_address, p->parent->local_port);
evhttp_add_header(headers, "Callback", callback_header);
evhttp_add_header(headers, "NT", "upnp:event");
/*evhttp_add_header(headers, "NTS", "");*/
evhttp_add_header(headers, "Timeout", "3600");
/*evbuffer_add(buffer, body, body_len);*/
evhttp_make_request(p->soap_conn, req, EVHTTP_REQ_SUBSCRIBE, path);
p->state |= UPNPC_DEVICE_SOAP_REQ;
return 0;
}
void HttpClient_YPL::post()
{
//char *url = "/portal/sss";
char *url = "/api/service";
struct evhttp_request *req = evhttp_request_new(onRequestDone, this);
evhttp_add_header(req->output_headers, "Host", m_host.c_str());
evhttp_make_request(m_conn, req, EVHTTP_REQ_POST, url);
evhttp_connection_set_timeout(req->evcon, 3);
evhttp_connection_set_closecb(req->evcon, onClose, this);
//evbuffer_add(req->output_buffer, "123", 3);
event_base_dispatch(m_base);
}
static void
http_dispatcher_test(void)
{
short port = -1;
struct evhttp_connection *evcon = NULL;
struct evhttp_request *req = NULL;
test_ok = 0;
fprintf(stdout, "Testing HTTP Dispatcher: ");
http = http_setup(&port, NULL);
evcon = evhttp_connection_new("127.0.0.1", port);
if (evcon == NULL) {
fprintf(stdout, "FAILED\n");
exit(1);
}
/* also bind to local host */
evhttp_connection_set_local_address(evcon, "127.0.0.1");
/*
* At this point, we want to schedule an HTTP GET request
* server using our make request method.
*/
req = evhttp_request_new(http_dispatcher_test_done, NULL);
if (req == NULL) {
fprintf(stdout, "FAILED\n");
exit(1);
}
/* Add the information that we care about */
evhttp_add_header(req->output_headers, "Host", "somehost");
if (evhttp_make_request(evcon, req, EVHTTP_REQ_GET, "/?arg=val") == -1) {
fprintf(stdout, "FAILED\n");
exit(1);
}
event_dispatch();
evhttp_connection_free(evcon);
evhttp_free(http);
if (test_ok != 1) {
fprintf(stdout, "FAILED: %d\n", test_ok);
exit(1);
}
fprintf(stdout, "OK\n");
}
static void
http_post_test(void)
{
short port = -1;
struct evhttp_connection *evcon = NULL;
struct evhttp_request *req = NULL;
test_ok = 0;
fprintf(stdout, "Testing HTTP POST Request: ");
http = http_setup(&port, NULL);
evcon = evhttp_connection_new("127.0.0.1", port);
if (evcon == NULL) {
fprintf(stdout, "FAILED\n");
exit(1);
}
/*
* At this point, we want to schedule an HTTP POST request
* server using our make request method.
*/
req = evhttp_request_new(http_postrequest_done, NULL);
if (req == NULL) {
fprintf(stdout, "FAILED\n");
exit(1);
}
/* Add the information that we care about */
evhttp_add_header(req->output_headers, "Host", "somehost");
evbuffer_add_printf(req->output_buffer, POST_DATA);
if (evhttp_make_request(evcon, req, EVHTTP_REQ_POST, "/postit") == -1) {
fprintf(stdout, "FAILED\n");
exit(1);
}
event_dispatch();
evhttp_connection_free(evcon);
evhttp_free(http);
if (test_ok != 1) {
fprintf(stdout, "FAILED: %d\n", test_ok);
exit(1);
}
fprintf(stdout, "OK\n");
}
int
pubsub_to_pubsub_main_path(char *source_address, int source_port, char *target_address, int target_port, int (*cb)(char *data, struct evbuffer *evb, char **target_path, void *arg), void *cbarg, char *target_path)
{
event_init();
struct evhttp_connection *evhttp_source_connection = NULL;
struct evhttp_connection *evhttp_target_connection = NULL;
struct evhttp_request *evhttp_source_request = NULL;
fprintf(stdout, "connecting to http://%s:%d/sub\n", source_address, source_port);
evhttp_source_connection = evhttp_connection_new(source_address, source_port);
if (evhttp_source_connection == NULL) {
fprintf(stdout, "FAILED CONNECT TO SOURCE %s:%d\n", source_address, source_port);
exit(1);
}
fprintf(stdout, "connecting to http://%s:%d/pub\n", target_address, target_port);
evhttp_target_connection = evhttp_connection_new(target_address, target_port);
if (evhttp_target_connection == NULL) {
fprintf(stdout, "FAILED CONNECT TO TARGET %s:%d\n", target_address, target_port);
exit(1);
}
struct global_data *data;
data = calloc(1, sizeof(*data));
data->evhttp_target_connection = evhttp_target_connection;
data->target_address = target_address;
data->target_path = calloc(4096, sizeof(char *));
strcpy(data->target_path, target_path);
data->cb = cb;
data->cbarg = cbarg;
evhttp_source_request = evhttp_request_new(http_chunked_request_done, data);
evhttp_add_header(evhttp_source_request->output_headers, "Host", source_address);
evhttp_request_set_chunked_cb(evhttp_source_request, source_callback);
if (evhttp_make_request(evhttp_source_connection, evhttp_source_request, EVHTTP_REQ_GET, "/sub") == -1) {
fprintf(stdout, "FAILED make_request to source\n");
exit(1);
}
event_dispatch();
evhttp_connection_free(evhttp_source_connection);
evhttp_connection_free(evhttp_target_connection);
fprintf(stdout, "EXITING\n");
return 0;
}
void stream_request_readcb(struct bufferevent *bev, void *arg)
{
struct evhttp_request *req;
struct StreamRequest *sr = (struct StreamRequest *)arg;
_DEBUG("stream_request_readcb()\n");
switch (sr->state) {
case read_firstline:
req = evhttp_request_new(NULL, NULL);
req->kind = EVHTTP_RESPONSE;
// 1 is the constant ALL_DATA_READ in http-internal.h
if (evhttp_parse_firstline(req, EVBUFFER_INPUT(bev)) == 1) {
sr->state = read_headers;
}
evhttp_request_free(req);
// dont break, try to parse the headers too
case read_headers:
req = evhttp_request_new(NULL, NULL);
req->kind = EVHTTP_RESPONSE;
// 1 is the constant ALL_DATA_READ in http-internal.h
if (evhttp_parse_headers(req, EVBUFFER_INPUT(bev)) == 1) {
if (sr->header_cb) {
sr->header_cb(sr->bev, req->input_headers, sr->arg);
}
sr->state = read_body;
}
evhttp_request_free(req);
break;
case read_body:
if (sr->read_cb) {
sr->read_cb(sr->bev, sr->arg);
}
break;
}
}
static void
close_detect_launch(int fd, short what, void *arg)
{
struct evhttp_connection *evcon = arg;
struct evhttp_request *req;
req = evhttp_request_new(close_detect_done, NULL);
/* Add the information that we care about */
evhttp_add_header(req->output_headers, "Host", "somehost");
/* We give ownership of the request to the connection */
if (evhttp_make_request(evcon, req, EVHTTP_REQ_GET, "/test") == -1) {
fprintf(stdout, "FAILED\n");
exit(1);
}
}
void
runcb(int fd, short what, void *arg)
{
Run *run;
Request *r;
Call *c;
Header *h;
struct evhttp_connection *conn;
struct evhttp_request *req;
enum evhttp_cmd_type cmd;
int i;
run = (Run*)arg;
r = &run->rs[rand() % run->rsiz];
if(run->cachedconn!=nil){
conn = run->cachedconn;
run->cachedconn = nil;
}else
conn = mkconn(run->host, run->port);
c = mal(sizeof(*c));
c->run = run;
c->conn = conn;
req = evhttp_request_new(&donecb, c);
if(strcasecmp(r->action, "get")==0)
cmd = EVHTTP_REQ_GET;
else if(strcasecmp(r->action, "post")==0)
cmd = EVHTTP_REQ_POST;
else
panic("invalid action \"%s\"", r->action);
for(i=0;i<r->nheader;i++){
h = &r->headers[i];
evhttp_add_header(
req->output_headers,
h->key, h->value);
}
evhttp_make_request(conn, req, cmd, r->uri);
event_add(&run->ev, &run->tv);
}
static void
http_negative_content_length_test(void)
{
short port = -1;
struct evhttp_connection *evcon = NULL;
struct evhttp_request *req = NULL;
test_ok = 0;
fprintf(stdout, "Testing HTTP Negative Content Length: ");
http = http_setup(&port, NULL);
evcon = evhttp_connection_new("127.0.0.1", port);
if (evcon == NULL) {
fprintf(stdout, "FAILED\n");
exit(1);
}
/*
* At this point, we want to schedule a request to the HTTP
* server using our make request method.
*/
req = evhttp_request_new(http_request_bad, NULL);
/* Cause the response to have a negative content-length */
evhttp_add_header(req->output_headers, "X-Negative", "makeitso");
/* We give ownership of the request to the connection */
if (evhttp_make_request(evcon, req, EVHTTP_REQ_GET, "/test") == -1) {
fprintf(stdout, "FAILED\n");
exit(1);
}
event_dispatch();
evhttp_free(http);
if (test_ok != 1) {
fprintf(stdout, "FAILED\n");
exit(1);
}
fprintf(stdout, "OK\n");
}
bool TestExtNetwork::test_get_http_request_size() {
//because no g_context in unit test,
//instead of testing f_get_http_request_size(),
//we test relevant code directly
evhttp_request* r=evhttp_request_new(nullptr, nullptr);
char* buf = "buffer";
evbuffer_add(r->input_buffer, buf, strlen(buf));
r->type=EVHTTP_REQ_POST;
evhttp_add_header(r->input_headers, "Host", "www.facebook.com");
r->uri = "/index.php";
r->major=1;
r->minor=1;
r->remote_host="127.0.0.1";
r->remote_port=1234;
LibEventTransport t(nullptr, r,0);
VERIFY(t.getRequestSize()==58);
return Count(true);
}
static void rpc_grneral_request(char *ip, int port, const char *rpcname,
void *req, marshal_func req_marshal,
void *resp, unmarshal_func resp_unmarshal)
{
struct evhttp_connection *evcon =
connection_pool_get_or_create_conn(conn_pool, ip, port);
struct evhttp_request *evreq =
evhttp_request_new(rpc_rpc_grneral_requestuest_cb, NULL);
evhttp_request_own(evreq); // this means that I should free it my self
req_marshal(evreq->output_buffer, req);
if (evhttp_make_request(evcon, evreq, EVHTTP_REQ_POST, rpcname))
logging(LOG_ERROR, "error on make_request");
event_dispatch();//TODO
if (resp_unmarshal(resp, evreq->input_buffer)) {
logging(LOG_ERROR, "error on statfs_response_unmarshal");
}
connection_pool_insert(conn_pool, ip, port, evcon);
evhttp_request_free(evreq);
}
void
source_callback (struct evhttp_request *req, void *arg){
if (DEBUG) fprintf(stdout, "source_callback\n");
// enum message_read_status done;
evhttp_clear_headers(req->input_headers);
evhttp_parse_headers(req, req->input_buffer);
char *content_len;
content_len = (char *) evhttp_find_header(req->input_headers, "Content-Length");
if (!content_len){return;}
int len = atoi(content_len);
size_t len_size;
len_size = (size_t)len;
if (DEBUG) fprintf(stdout, "received content_length:%d buffer has:%d\n", len, EVBUFFER_LENGTH(req->input_buffer));
struct global_data *client_data = (struct global_data *)arg;
struct evhttp_request *evhttp_target_request = NULL;
evhttp_target_request = evhttp_request_new(http_post_done, NULL);
evhttp_add_header(evhttp_target_request->output_headers, "Host", client_data->target_address);
char *data = calloc(len, sizeof(char *));
evbuffer_remove(req->input_buffer, data, len);
if (DEBUG)fprintf(stdout, "data has %d bytes\n", strlen(data));
if (DEBUG)fprintf(stdout, "data=%s\n", data);
// empty buffer
evbuffer_drain(req->input_buffer, EVBUFFER_LENGTH(req->input_buffer));
// write to output buffer
int flag = (*client_data->cb)(data, evhttp_target_request->output_buffer, &client_data->target_path, client_data->cbarg);
free(data);
if (!flag){return;} // don't make the request
if (evhttp_make_request(client_data->evhttp_target_connection, evhttp_target_request, EVHTTP_REQ_POST, client_data->target_path) == -1) {
fprintf(stdout, "FAILED make_request\n");
exit(1);
}
}
bool TEvhttpClientChannel::sendAndRecvMessage(
const VoidCallback& cob,
apache::thrift::transport::TMemoryBuffer* sendBuf,
apache::thrift::transport::TMemoryBuffer* recvBuf) {
cob_ = cob;
recvBuf_ = recvBuf;
struct evhttp_request* req = evhttp_request_new(response, this);
if (req == NULL) {
abort(); // XXX
}
int rv;
rv = evhttp_add_header(req->output_headers, "Host", host_.c_str());
if (rv != 0) {
abort(); // XXX
}
rv = evhttp_add_header(req->output_headers, "Content-Type", "application/x-thrift");
if (rv != 0) {
abort(); // XXX
}
uint8_t* obuf;
uint32_t sz;
sendBuf->getBuffer(&obuf, &sz);
rv = evbuffer_add(req->output_buffer, obuf, sz);
if (rv != 0) {
abort(); // XXX
}
rv = evhttp_make_request(conn_, req, EVHTTP_REQ_POST, path_.c_str());
if (rv != 0) {
abort(); // XXX
}
return true;
}
void URLConnection::requestPOST(const std::string& url, const std::string& payload, URLConnectionCompleteCB callback, void* callback_data )
///
/// Function to request a page via the POST protocol
///
/// @param url
/// The url to request (note, this does NOT include the host)
///
/// @param payload
/// POST payload to send
///
/// @param callback
/// Callback to call on success / failure of the request
///
/// @param callback_data
/// Data to send back with callback
///
{
// create a struct for handling the real callback for the user of URLConnection
// should be deallocated in the url_connection_callback function
ConnectionCallbackData* cb_data = new ConnectionCallbackData();
cb_data->callback = callback;
cb_data->data = callback_data;
evhttp_request* request = evhttp_request_new(url_connection_callback, cb_data);
// set up appropriate headers for a GET request
char* host_address;
ev_uint16_t port;
evhttp_connection_get_peer(mConnection, &host_address, &port);
evhttp_add_header( request->output_headers, "Host", host_address );
evhttp_add_header( request->output_headers, "User-Agent", mUserAgent.c_str() );
evhttp_add_header( request->output_headers, "Connection", "keep-alive" );
evhttp_add_header( request->output_headers, "Content-Type", "application/x-www-form-urlencoded; charset=UTF-8" );
evbuffer_add(request->output_buffer, payload.c_str(), payload.size());
evhttp_make_request(mConnection, request, EVHTTP_REQ_POST, url.c_str());
}
void
http_request::renew_request()
{
/* free connections & request */
if (m_cn)
evhttp_connection_free(m_cn);
#if !defined(_EVENT_NUMERIC_VERSION) || _EVENT_NUMERIC_VERSION < 0x02000000
m_cn = evhttp_connection_new(m_host.c_str(), m_port);
evhttp_connection_set_base(m_cn, m_base);
#else
m_cn = evhttp_connection_base_new(
m_base, NULL,
m_host.c_str(),
m_port);
#endif
m_req = evhttp_request_new(http_request::download_callback, this);
evhttp_make_request(m_cn, m_req, m_type, m_query.c_str());
evhttp_add_header(m_req->output_headers,
"Host", m_host.c_str());
}
static int upnpc_send_soap_request(upnpc_device_t * p, const char * url,
const char * service,
const char * method,
const struct upnp_args * args, int arg_count)
{
char action[128];
char * body;
const char fmt_soap[] =
"<?xml version=\"1.0\"?>\r\n"
"<" SOAPPREFIX ":Envelope "
"xmlns:" SOAPPREFIX "=\"http://schemas.xmlsoap.org/soap/envelope/\" "
SOAPPREFIX ":encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">"
"<" SOAPPREFIX ":Body>"
"<" SERVICEPREFIX ":%s xmlns:" SERVICEPREFIX "=\"%s\">"
"%s"
"</" SERVICEPREFIX ":%s>"
"</" SOAPPREFIX ":Body></" SOAPPREFIX ":Envelope>"
"\r\n";
int body_len;
char hostname[MAXHOSTNAMELEN+1];
char hostname_port[MAXHOSTNAMELEN+1+6];
unsigned short port;
char * path;
unsigned int scope_id;
char * args_xml = NULL;
struct evhttp_request * req;
struct evkeyvalq * headers;
struct evbuffer * buffer;
if(p->state & UPNPC_DEVICE_SOAP_REQ) {
debug_printf("%s: another SOAP request in progress\n", __func__);
return UPNPC_ERR_REQ_IN_PROGRESS;
}
if(arg_count > 0) {
int i;
size_t l, n;
for(i = 0, l = 0; i < arg_count; i++) {
/* <ELT>VAL</ELT> */
l += strlen(args[i].elt) * 2 + strlen(args[i].val) + 5;
}
args_xml = malloc(++l);
if(args_xml == NULL) {
return -1;
}
for(i = 0, n = 0; i < arg_count && n < l; i++) {
/* <ELT>VAL</ELT> */
n += snprintf(args_xml + n, l - n, "<%s>%s</%s>",
args[i].elt, args[i].val, args[i].elt);
}
}
body_len = snprintf(NULL, 0, fmt_soap, method, service, args_xml?args_xml:"", method);
body = malloc(body_len + 1);
if(body == NULL) {
free(args_xml);
return -1;
}
if(snprintf(body, body_len + 1, fmt_soap, method, service, args_xml?args_xml:"", method) != body_len) {
debug_printf("%s: snprintf() returned strange value...\n", __func__);
}
free(args_xml);
args_xml = NULL;
if(!parseURL(url, hostname, &port, &path, &scope_id)) {
free(body);
return -1;
}
if(port != 80)
snprintf(hostname_port, sizeof(hostname_port), "%s:%hu", hostname, port);
else
strncpy(hostname_port, hostname, sizeof(hostname_port));
snprintf(action, sizeof(action), "\"%s#%s\"", service, method);
if(p->soap_conn == NULL) {
p->soap_conn = evhttp_connection_base_new(p->parent->base, NULL, hostname, port);
}
req = evhttp_request_new(upnpc_soap_response, p);
headers = evhttp_request_get_output_headers(req);
buffer = evhttp_request_get_output_buffer(req);
evhttp_add_header(headers, "Host", hostname_port);
evhttp_add_header(headers, "SOAPAction", action);
evhttp_add_header(headers, "Content-Type", "text/xml");
/*evhttp_add_header(headers, "User-Agent", "***");*/
/*evhttp_add_header(headers, "Cache-Control", "no-cache");*/
/*evhttp_add_header(headers, "Pragma", "no-cache");*/
evbuffer_add(buffer, body, body_len);
evhttp_make_request(p->soap_conn, req, EVHTTP_REQ_POST, path);
free(body);
p->state |= UPNPC_DEVICE_SOAP_REQ;
return 0;
}
int
main(int argc, char **argv)
{
int r;
struct evhttp_uri *http_uri = NULL;
const char *url = NULL, *data_file = NULL;
const char *crt = "/etc/ssl/certs/ca-certificates.crt";
const char *scheme, *host, *path, *query;
char uri[256];
int port;
int retries = 0;
int timeout = -1;
SSL_CTX *ssl_ctx = NULL;
SSL *ssl = NULL;
struct bufferevent *bev;
struct evhttp_connection *evcon = NULL;
struct evhttp_request *req;
struct evkeyvalq *output_headers;
struct evbuffer *output_buffer;
int i;
int ret = 0;
enum { HTTP, HTTPS } type = HTTP;
for (i = 1; i < argc; i++) {
if (!strcmp("-url", argv[i])) {
if (i < argc - 1) {
url = argv[i + 1];
} else {
syntax();
goto error;
}
} else if (!strcmp("-crt", argv[i])) {
if (i < argc - 1) {
crt = argv[i + 1];
} else {
syntax();
goto error;
}
} else if (!strcmp("-ignore-cert", argv[i])) {
ignore_cert = 1;
} else if (!strcmp("-data", argv[i])) {
if (i < argc - 1) {
data_file = argv[i + 1];
} else {
syntax();
goto error;
}
} else if (!strcmp("-retries", argv[i])) {
if (i < argc - 1) {
retries = atoi(argv[i + 1]);
} else {
syntax();
goto error;
}
} else if (!strcmp("-timeout", argv[i])) {
if (i < argc - 1) {
timeout = atoi(argv[i + 1]);
} else {
syntax();
goto error;
}
} else if (!strcmp("-help", argv[i])) {
syntax();
goto error;
}
}
if (!url) {
syntax();
goto error;
}
#ifdef _WIN32
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD(2, 2);
err = WSAStartup(wVersionRequested, &wsaData);
if (err != 0) {
printf("WSAStartup failed with error: %d\n", err);
goto error;
}
}
#endif // _WIN32
http_uri = evhttp_uri_parse(url);
if (http_uri == NULL) {
err("malformed url");
goto error;
}
scheme = evhttp_uri_get_scheme(http_uri);
if (scheme == NULL || (strcasecmp(scheme, "https") != 0 &&
strcasecmp(scheme, "http") != 0)) {
err("url must be http or https");
goto error;
}
host = evhttp_uri_get_host(http_uri);
if (host == NULL) {
err("url must have a host");
goto error;
}
port = evhttp_uri_get_port(http_uri);
if (port == -1) {
port = (strcasecmp(scheme, "http") == 0) ? 80 : 443;
}
path = evhttp_uri_get_path(http_uri);
if (strlen(path) == 0) {
path = "/";
}
query = evhttp_uri_get_query(http_uri);
if (query == NULL) {
snprintf(uri, sizeof(uri) - 1, "%s", path);
} else {
snprintf(uri, sizeof(uri) - 1, "%s?%s", path, query);
}
uri[sizeof(uri) - 1] = '\0';
#if OPENSSL_VERSION_NUMBER < 0x10100000L
// Initialize OpenSSL
SSL_library_init();
ERR_load_crypto_strings();
SSL_load_error_strings();
OpenSSL_add_all_algorithms();
#endif
/* This isn't strictly necessary... OpenSSL performs RAND_poll
* automatically on first use of random number generator. */
r = RAND_poll();
if (r == 0) {
err_openssl("RAND_poll");
goto error;
}
/* Create a new OpenSSL context */
ssl_ctx = SSL_CTX_new(SSLv23_method());
if (!ssl_ctx) {
err_openssl("SSL_CTX_new");
goto error;
}
#ifndef _WIN32
/* TODO: Add certificate loading on Windows as well */
/* Attempt to use the system's trusted root certificates.
* (This path is only valid for Debian-based systems.) */
if (1 != SSL_CTX_load_verify_locations(ssl_ctx, crt, NULL)) {
err_openssl("SSL_CTX_load_verify_locations");
goto error;
}
/* Ask OpenSSL to verify the server certificate. Note that this
* does NOT include verifying that the hostname is correct.
* So, by itself, this means anyone with any legitimate
* CA-issued certificate for any website, can impersonate any
* other website in the world. This is not good. See "The
* Most Dangerous Code in the World" article at
* https://crypto.stanford.edu/~dabo/pubs/abstracts/ssl-client-bugs.html
*/
SSL_CTX_set_verify(ssl_ctx, SSL_VERIFY_PEER, NULL);
/* This is how we solve the problem mentioned in the previous
* comment. We "wrap" OpenSSL's validation routine in our
* own routine, which also validates the hostname by calling
* the code provided by iSECPartners. Note that even though
* the "Everything You've Always Wanted to Know About
* Certificate Validation With OpenSSL (But Were Afraid to
* Ask)" paper from iSECPartners says very explicitly not to
* call SSL_CTX_set_cert_verify_callback (at the bottom of
* page 2), what we're doing here is safe because our
* cert_verify_callback() calls X509_verify_cert(), which is
* OpenSSL's built-in routine which would have been called if
* we hadn't set the callback. Therefore, we're just
* "wrapping" OpenSSL's routine, not replacing it. */
SSL_CTX_set_cert_verify_callback(ssl_ctx, cert_verify_callback,
(void *) host);
#else // _WIN32
(void)crt;
#endif // _WIN32
// Create event base
base = event_base_new();
if (!base) {
perror("event_base_new()");
goto error;
}
// Create OpenSSL bufferevent and stack evhttp on top of it
ssl = SSL_new(ssl_ctx);
if (ssl == NULL) {
err_openssl("SSL_new()");
goto error;
}
#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
// Set hostname for SNI extension
SSL_set_tlsext_host_name(ssl, host);
#endif
if (strcasecmp(scheme, "http") == 0) {
bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);
} else {
type = HTTPS;
bev = bufferevent_openssl_socket_new(base, -1, ssl,
BUFFEREVENT_SSL_CONNECTING,
BEV_OPT_CLOSE_ON_FREE|BEV_OPT_DEFER_CALLBACKS);
}
if (bev == NULL) {
fprintf(stderr, "bufferevent_openssl_socket_new() failed\n");
goto error;
}
bufferevent_openssl_set_allow_dirty_shutdown(bev, 1);
// For simplicity, we let DNS resolution block. Everything else should be
// asynchronous though.
evcon = evhttp_connection_base_bufferevent_new(base, NULL, bev,
host, port);
if (evcon == NULL) {
fprintf(stderr, "evhttp_connection_base_bufferevent_new() failed\n");
goto error;
}
if (retries > 0) {
evhttp_connection_set_retries(evcon, retries);
}
if (timeout >= 0) {
evhttp_connection_set_timeout(evcon, timeout);
}
// Fire off the request
req = evhttp_request_new(http_request_done, bev);
if (req == NULL) {
fprintf(stderr, "evhttp_request_new() failed\n");
goto error;
}
output_headers = evhttp_request_get_output_headers(req);
evhttp_add_header(output_headers, "Host", host);
evhttp_add_header(output_headers, "Connection", "close");
if (data_file) {
/* NOTE: In production code, you'd probably want to use
* evbuffer_add_file() or evbuffer_add_file_segment(), to
* avoid needless copying. */
FILE * f = fopen(data_file, "rb");
char buf[1024];
size_t s;
size_t bytes = 0;
if (!f) {
syntax();
goto error;
}
output_buffer = evhttp_request_get_output_buffer(req);
while ((s = fread(buf, 1, sizeof(buf), f)) > 0) {
evbuffer_add(output_buffer, buf, s);
bytes += s;
}
evutil_snprintf(buf, sizeof(buf)-1, "%lu", (unsigned long)bytes);
evhttp_add_header(output_headers, "Content-Length", buf);
fclose(f);
}
r = evhttp_make_request(evcon, req, data_file ? EVHTTP_REQ_POST : EVHTTP_REQ_GET, uri);
if (r != 0) {
fprintf(stderr, "evhttp_make_request() failed\n");
goto error;
}
event_base_dispatch(base);
goto cleanup;
error:
ret = 1;
cleanup:
if (evcon)
evhttp_connection_free(evcon);
if (http_uri)
evhttp_uri_free(http_uri);
event_base_free(base);
if (ssl_ctx)
SSL_CTX_free(ssl_ctx);
if (type == HTTP && ssl)
SSL_free(ssl);
#if OPENSSL_VERSION_NUMBER < 0x10100000L
EVP_cleanup();
ERR_free_strings();
#ifdef EVENT__HAVE_ERR_REMOVE_THREAD_STATE
ERR_remove_thread_state(NULL);
#else
ERR_remove_state(0);
#endif
CRYPTO_cleanup_all_ex_data();
sk_SSL_COMP_free(SSL_COMP_get_compression_methods());
#endif /*OPENSSL_VERSION_NUMBER < 0x10100000L */
#ifdef _WIN32
WSACleanup();
#endif
return ret;
}
