void request_handler(struct evhttp_request *req, void *arg)
{
const char *uri;
uri = evhttp_request_uri(req);
if(strncmp(uri, "/updates/", 9) != 0){
evhttp_send_error(req, HTTP_NOTFOUND, "Not Found");
if (settings.verbose > 0)
fprintf(stderr, "URL not found.. needs to be /updates/... but was %s\n", uri);
return;
}
const char *rkey;
struct evkeyvalq args;
TAILQ_INIT(&args);
evhttp_parse_query(uri, &args);
rkey = evhttp_find_header(&args, "rkey");
if (NULL == rkey) {
evhttp_send_error(req, HTTP_BADREQUEST, "Bad Request");
if (settings.verbose > 0)
fprintf(stderr, "RKey param not found in request URI %s\n", uri);
evhttp_clear_headers(&args);
return;
}
fprintf(stderr, "Using RKey: %s\n", rkey);
char *cached = fetch_memcached(rkey);
if (NULL == cached) {
evhttp_send_error(req, HTTP_BADREQUEST, "Bad Request");
fprintf(stderr, "RKey %s not found in Memcache!\n", rkey);
evhttp_clear_headers(&args);
return;
}
int uid = atoi(cached);
fprintf(stderr, "Great, found RKey in Memcached: %s = %s and now UID %d\n", rkey, cached, uid);
struct evbuffer *buf = evbuffer_new();
evhttp_add_header(req->output_headers, "Content-Type", "text/html; charset=UTF-8");
evhttp_add_header(req->output_headers, "Connection", "keep-alive");
evhttp_add_header(req->output_headers, "Cache-Control", "no-cache");
evhttp_send_reply_start(req, HTTP_OK, "OK");
evbuffer_add_printf(buf, "Welcome, RKey: ‘%s’\n", rkey);
evhttp_send_reply_chunk(req, buf);
evbuffer_free(buf);
clients[uid] = req;
evhttp_clear_headers(&args);
free(cached);
evhttp_connection_set_closecb( req->evcon, cleanup, &slots[uid] );
}
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 HTTPConnectionManager::newRequest(void* req, std::string uri, std::string content)
{
HTTPReply m_reply;
// 取出对端的IP
ev_uint16_t port;
char *addr = NULL;
evhttp_connection_get_peer(((evhttp_request*)req)->evcon, &addr , &port);
char address[20];
strcpy(address, addr);
m_requestHandler->handleRequest(address, uri, content, m_reply);
//if(m_reply.status == > 0) // 如果是request处理好了，就回复
{
struct evbuffer *buf = evbuffer_new();
evbuffer_add_printf(buf, "%s", m_reply.m_content.c_str());
evhttp_add_header(evhttp_request_get_output_headers((evhttp_request*)req), "Connection", "close");
evhttp_add_header(evhttp_request_get_output_headers((evhttp_request*)req), \
m_reply.m_headers[0].m_name.c_str(), m_reply.m_headers[0].m_value.c_str());
evhttp_send_reply((evhttp_request*)req, HTTP_OK, "OK", buf);
evbuffer_free(buf);
LOG_T("<== [" << m_reply.m_content << "]");
}
}
// 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;
}
void Subscriber::start(){
bufferevent_enable(req->evcon->bufev, EV_READ);
evhttp_connection_set_closecb(req->evcon, on_sub_disconnect, this);
evhttp_add_header(req->output_headers, "Connection", "keep-alive");
//evhttp_add_header(req->output_headers, "Cache-Control", "no-cache");
//evhttp_add_header(req->output_headers, "Expires", "0");
evhttp_add_header(req->output_headers, "Content-Type", "text/html; charset=utf-8");
evhttp_send_reply_start(req, HTTP_OK, "OK");
if(this->type == POLL){
//
}else if(this->type == IFRAME){
struct evbuffer *buf = evhttp_request_get_output_buffer(this->req);
evbuffer_add_printf(buf, "%s\n", iframe_header.c_str());
evhttp_send_reply_chunk(this->req, buf);
}
// send buffered messages
if(this->seq_next == 0){
this->seq_next = channel->seq_next;
}
if(!channel->msg_list.empty() && channel->seq_next != this->seq_next){
this->send_old_msgs();
}
}
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;
}
static void http_set_headers(struct evhttp_request *req, struct server_socket *sock, bool longpoll)
{
evhttp_clear_headers(req->output_headers);
/* Add header to debug load balancing */
if (srv.ourhost)
evhttp_add_header(req->output_headers, "X-Server", srv.ourhost);
/* copy X-Forwarded-For header to remote_host, if a trusted proxy provides it */
if (sock->cfg->proxy && !strcmp(req->remote_host, sock->cfg->proxy)) {
const char *hdr;
hdr = evhttp_find_header(req->input_headers, "X-Forwarded-For");
if (hdr) {
free(req->remote_host);
req->remote_host = strdup(hdr);
}
}
evhttp_add_header(req->output_headers,
"Content-Type", "application/json");
if (!longpoll && !srv.disable_lp)
evhttp_add_header(req->output_headers, "X-Long-Polling", "/LP");
if (!srv.disable_roll_ntime)
evhttp_add_header(req->output_headers, "X-Roll-NTime", "Y");
}
void Subscriber::start(){
#ifndef WIN32
bufferevent_enable(req->evcon->bufev, EV_READ);
#endif
evhttp_connection_set_closecb(req->evcon, on_sub_disconnect, this);
evhttp_add_header(req->output_headers, "Connection", "keep-alive");
evhttp_add_header(req->output_headers, "Content-Type", "text/html;charset=UTF-8");
evhttp_send_reply_start(req, HTTP_OK, "OK");
if (this->type == POLL){
}
else if (this->type == IFRAME){
struct evbuffer *buf = evbuffer_new();
evbuffer_add_printf(buf, "%s\n", iframe_header.c_str());
evhttp_send_reply_chunk(this->req, buf);
evbuffer_free(buf);
}
if (this->seq_next == 0)
{
this->seq_next = channel->seq_next;
}
if (!channel->msg_list.empty() && channel->seq_next != this->seq_next){
this->send_old_msgs();
}
}
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());
}
static void
http_bad_header_test(void)
{
struct evkeyvalq headers;
fprintf(stdout, "Testing HTTP Header filtering: ");
TAILQ_INIT(&headers);
if (evhttp_add_header(&headers, "One", "Two") != 0)
goto fail;
if (evhttp_add_header(&headers, "One\r", "Two") != -1)
goto fail;
if (evhttp_add_header(&headers, "One\n", "Two") != -1)
goto fail;
if (evhttp_add_header(&headers, "One", "Two\r") != -1)
goto fail;
if (evhttp_add_header(&headers, "One", "Two\n") != -1)
goto fail;
evhttp_clear_headers(&headers);
fprintf(stdout, "OK\n");
return;
fail:
fprintf(stdout, "FAILED\n");
exit(1);
}
static void http_request_cb(struct evhttp_request *req, void *arg)
{
struct context *ctx = (struct context *) arg;
const char *uri = evhttp_request_get_uri(req);
struct evbuffer *evb = NULL;
const char *type;
if (evhttp_request_get_command(req) != EVHTTP_REQ_GET)
{
evhttp_send_error(req, HTTP_BADREQUEST, 0);
return;
}
printf("GET: %s", uri);
if (strcmp(uri,"/") == 0)
{
type = "text/html";
evb = evbuffer_new();
evbuffer_add_printf(evb, "<html><body><h1>Hello World!</h1></body></html>");
evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", type);
evhttp_send_reply(req, 200, "OK", evb);
printf(" - 200 - ok\n");
}
else if (strcmp(uri,"/sample") == 0)
{
evb = evbuffer_new();
if (get_sample(ctx) == 0)
{
if (format_sample_response(ctx, evb) == 0)
{
evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", "application/json");
evhttp_send_reply(req, 200, "OK", evb);
printf(" - 200 - ok\n");
}
else
{
internal_error(req, evb);
}
}
else
{
internal_error(req, evb);
}
}
else
{
type = "text/plain";
evb = evbuffer_new();
evbuffer_add_printf(evb, "Not Found");
evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", type);
evhttp_send_reply(req, 404, "Not Found", evb);
printf(" - 404 - not found\n");
}
if (evb)
evbuffer_free(evb);
}
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);
}
}
void http_handler(struct evhttp_request *req, void *arg)
{
if (strcmp(req->uri, JSON_RPC_ENDPOINT) == 0 || strcmp(req->uri, WS_ENDPOINT) == 0)
return;
char *path = (strcmp(req->uri, "/") == 0) ? get_path(ROOT_URI) : get_path(req->uri);
if (path == NULL)
goto error;
int len = get_file_size(path);
if (len == -1) {
evhttp_send_error(req, HTTP_NOT_FOUND_CODE, HTTP_NOT_FOUND_REASON);
free(path);
return;
}
void *buf = get_file_content(path);
if (buf == NULL)
goto error;
struct evbuffer *evbuf = evbuffer_new();
if (evbuf == NULL)
goto error;
if (evbuffer_add(evbuf, buf, len) == -1) {
evbuffer_free(evbuf);
goto error;
}
if (string_ends_by(path, CSS_POSTFIX)) {
evhttp_add_header(req->output_headers, "Content-Type", "text/css");
}
if (string_ends_by(path, JS_POSTFIX)) {
evhttp_add_header(req->output_headers, "Content-Type", "text/javascript");
}
if (string_ends_by(path, PNG_POSTFIX)) {
evhttp_add_header(req->output_headers, "Content-Type", "image/png");
}
evhttp_send_reply(req, HTTP_OK_CODE, HTTP_OK_REASON, evbuf);
free(path);
free(buf);
free(evbuf);
return;
error:
free(path);
free(buf);
evhttp_send_error(req, HTTP_INTERNAL_ERROR_CODE, HTTP_INTERNAL_ERROR_REASON);
}
static void got_api(struct evhttp_request* req, void* userdata)
{
struct req_data* d = (struct req_data*) userdata;
if(req->response_code != 200)
{
evhttp_send_error(d->req, 500, "Internal Server Error");
free_req_data(&d);
fprintf(stderr, "info.c:got_api(): api returned http status %d\n", (int)(req->response_code));
return;
}
XML_Parser parser = XML_ParserCreate(NULL);
int done;
int depth = 0;
XML_SetUserData(parser, d);
XML_SetElementHandler(parser, startElement, endElement);
XML_SetCharacterDataHandler(parser, xmlData);
char buf[4096];
int buflen;
while((buflen = evbuffer_remove(req->input_buffer, buf, 4096)) > 0)
{
if(XML_Parse(parser, buf, buflen, 0) == XML_STATUS_ERROR)
{
evhttp_send_error(d->req, 500, "Internal Server Error");
free_req_data(&d);
fprintf(stderr, "info.c:got_api(): error parsing xml: %s\n", XML_ErrorString(XML_GetErrorCode(parser)));
return;
}
}
XML_ParserFree(parser);
// return static result
struct evbuffer *evbuf;
evbuf = evbuffer_new();
if (buf == NULL)
{
evhttp_send_error(d->req, 500, "Internal Server Error");
free_req_data(&d);
fprintf(stderr, "info.c:got_api(): couldn't alloc evbuffer\n");
return;
}
evhttp_remove_header(d->req->output_headers, "content-type");
evhttp_add_header(d->req->output_headers, "content-type", "application/json");
evhttp_add_header(d->req->output_headers, "cache-control", "no-cache");
evbuffer_add_printf(evbuf, "{ \"eventName\": \"%s\", \"description\": \"%s\", \"serverTime\": %d, \"startTime\": %d, \"duration\": %d, \"login\": \"%s\", \"title\": \"%s\", \"profile_image\": \"%s\" }\n", d->event_title, d->description, (int)time(0), (int)(d->start), d->duration, d->login, d->channel_title, d->profile_image);
evhttp_send_reply(d->req, 200, "OK", evbuf);
evbuffer_free(evbuf);
free_req_data(&d);
}
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;
}
static void http_status(struct evhttp_request *r)
{
char *json;
struct evkeyvalq *headers = evhttp_request_get_output_headers(r);
http_header_base(headers, tick);
evhttp_add_header(headers, "Content-Type", "application/json; charset=UTF-8");
evhttp_add_header(headers, "Cache-Control", "max-age=9");
json = status_json_string(0, 0);
http_send_reply_ok(r, headers, json, strlen(json), 1);
free(json);
}
/* 处理模块 */
void httpcws_handler(struct evhttp_request *req, void *arg)
{
struct evbuffer *buf;
buf = evbuffer_new();
/* 分析URL参数 */
struct evkeyvalq httpcws_http_query;
evhttp_parse_query(evhttp_request_uri(req), &httpcws_http_query);
/* 接收POST表单信息 */
const char *tcsql_input_postbuffer = (const char*) EVBUFFER_DATA(req->input_buffer);
/* 接收GET表单参数 */
const char *httpcws_input_words = evhttp_find_header (&httpcws_http_query, "w");
const char *httpcws_output_tmp = NULL;
char *httpcws_output_words = "\0";
if (tcsql_input_postbuffer != NULL) {
char *tcsql_input_postbuffer_tmp = (char *) malloc(EVBUFFER_LENGTH(req->input_buffer)+1);
memset (tcsql_input_postbuffer_tmp, '\0', EVBUFFER_LENGTH(req->input_buffer)+1);
strncpy(tcsql_input_postbuffer_tmp, tcsql_input_postbuffer, EVBUFFER_LENGTH(req->input_buffer));
char *decode_uri = urldecode(tcsql_input_postbuffer_tmp);
free(tcsql_input_postbuffer_tmp);
httpcws_output_tmp = ICTCLAS_ParagraphProcess(decode_uri, 0);
free(decode_uri);
httpcws_output_words = strdup(httpcws_output_tmp);
trim (httpcws_output_words);
} else if (httpcws_input_words != NULL) {
char *httpcws_input_words_tmp = strdup(httpcws_input_words);
char *decode_uri = urldecode(httpcws_input_words_tmp);
free(httpcws_input_words_tmp);
httpcws_output_tmp = ICTCLAS_ParagraphProcess(decode_uri, 0);
free(decode_uri);
httpcws_output_words = strdup(httpcws_output_tmp);
trim (httpcws_output_words);
} else {
httpcws_output_words = strdup("");
}
/* 输出内容给客户端 */
evhttp_add_header(req->output_headers, "Server", "HTTPCWS/1.0.0");
evhttp_add_header(req->output_headers, "Content-Type", "text/plain; charset=GB2312");
evhttp_add_header(req->output_headers, "Connection", "close");
evbuffer_add_printf(buf, "%s", httpcws_output_words);
evhttp_send_reply(req, HTTP_OK, "OK", buf);
free(httpcws_output_words);
evhttp_clear_headers(&httpcws_http_query);
evbuffer_free(buf);
}
static void http_header_base(struct evkeyvalq *headers, int last_modified)
{
char dbuf[80];
http_date(dbuf, sizeof(dbuf), tick);
evhttp_add_header(headers, "Server", verstr_http);
evhttp_add_header(headers, "Date", dbuf);
if (last_modified) {
http_date(dbuf, sizeof(dbuf), last_modified);
evhttp_add_header(headers, "Last-Modified", dbuf);
}
}
static void httpd_handler(struct evhttp_request *req, void *arg) {
struct evbuffer *buf;
buf = evbuffer_new();
//get http request url
char *decode_uri = strdup((char*) evhttp_request_uri(req));
struct evkeyvalq httpd_query;
evhttp_parse_query(decode_uri, &httpd_query);
free(decode_uri);
//recive http params
const char *start = evhttp_find_header(&httpd_query, "start");
const char *httpd_charset = evhttp_find_header(&httpd_query, "charset");
//send http header charset
if (httpd_charset != NULL && strlen(httpd_charset) <= 40) {
char content_type[64] = { 0 };
sprintf(content_type, "text/plain; charset=%s", httpd_charset);
evhttp_add_header(req->output_headers, "Content-Type", content_type);
} else {
evhttp_add_header(req->output_headers, "Content-Type", "text/plain");
}
evhttp_add_header(req->output_headers, "Connection", "keep-alive");
evhttp_add_header(req->output_headers, "Cache-Control", "no-cache");
evbuffer_add_printf(buf, "%s\n", "HTTRACK_OK");
char start_t[255] = {0x00};
sprintf(start_t, "%s", start);
if (strcmp(start_t, "1") == 0) {
struct hts_proj proj;
proj.depth = 5;
proj.priority = PRIORITY_ONLY_HTML;
proj.action = ACTION_ONLY_FILES;
sprintf(proj.name, "%s", "dianying.yisou.com");
sprintf(proj.urls, "%s", "http://dianying.yisou.com/");
new_dl_thread();
}
//send content to client
evhttp_send_reply(req, HTTP_OK, "OK", buf);
//free buf
evhttp_clear_headers(&httpd_query);
evbuffer_free(buf);
}
void CHttpServer::http_reponse(struct evhttp_request *req,
struct evkeyvalq *params,
int statcode,
char *statreason)
{
struct evbuffer *buff = evbuffer_new();
evhttp_add_header(req->output_headers, "Content-Type", "text/plain; charset=UTF-8");
evhttp_add_header(req->output_headers, "Connection", "close");
evhttp_send_reply(req, statcode, statreason, buff);
evhttp_clear_headers(params);
evbuffer_free(buff);
return;
}
static void
rsp_send_error(struct evhttp_request *req, char *errmsg)
{
struct evbuffer *evbuf;
struct evkeyvalq *headers;
mxml_node_t *reply;
mxml_node_t *status;
mxml_node_t *node;
/* We'd use mxmlNewXML(), but then we can't put any attributes
* on the root node and we need some.
*/
reply = mxmlNewElement(MXML_NO_PARENT, RSP_XML_ROOT);
node = mxmlNewElement(reply, "response");
status = mxmlNewElement(node, "status");
/* Status block */
node = mxmlNewElement(status, "errorcode");
mxmlNewText(node, 0, "1");
node = mxmlNewElement(status, "errorstring");
mxmlNewText(node, 0, errmsg);
node = mxmlNewElement(status, "records");
mxmlNewText(node, 0, "0");
node = mxmlNewElement(status, "totalrecords");
mxmlNewText(node, 0, "0");
evbuf = mxml_to_evbuf(reply);
mxmlDelete(reply);
if (!evbuf)
{
httpd_send_error(req, HTTP_SERVUNAVAIL, "Internal Server Error");
return;
}
headers = evhttp_request_get_output_headers(req);
evhttp_add_header(headers, "Content-Type", "text/xml; charset=utf-8");
evhttp_add_header(headers, "Connection", "close");
httpd_send_reply(req, HTTP_OK, "OK", evbuf, HTTPD_SEND_NO_GZIP);
evbuffer_free(evbuf);
}
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);
}
/**
*
* @param *request the opaque data structure containing the request infos
* @param *privParams global parameters set when the callback was associated
* @return nothing
*/
void testing (struct evhttp_request *request, void *privParams) {
struct evbuffer *buffer;
struct evkeyvalq headers;
const char *q;
// Parse the query for later lookups
evhttp_parse_query (evhttp_request_get_uri (request), &headers);
// lookup the 'q' GET parameter
q = evhttp_find_header (&headers, "q");
// Create an answer buffer where the data to send back to the browser will be appened
buffer = evbuffer_new ();
evbuffer_add (buffer, "coucou !", 8);
evbuffer_add_printf (buffer, "%s", q);
// Add a HTTP header, an application/json for the content type here
evhttp_add_header (evhttp_request_get_output_headers (request),
"Content-Type", "text/plain");
// Tell we're done and data should be sent back
evhttp_send_reply(request, HTTP_OK, "OK", buffer);
// Free up stuff
evhttp_clear_headers (&headers);
evbuffer_free (buffer);
return;
}
int Server::close(struct evhttp_request *req){
HttpQuery query(req);
std::string cname = query.get_str("cname", "");
Channel *channel = this->get_channel_by_name(cname);
if(!channel){
log_warn("channel %s not found", cname.c_str());
struct evbuffer *buf = evhttp_request_get_output_buffer(req);
evbuffer_add_printf(buf, "channel[%s] not connected\n", cname.c_str());
evhttp_send_reply(req, 404, "Not Found", buf);
return 0;
}
log_debug("close channel: %s, subs: %d", cname.c_str(), channel->subs.size);
// response to publisher
evhttp_add_header(req->output_headers, "Content-Type", "text/html; charset=utf-8");
struct evbuffer *buf = evhttp_request_get_output_buffer(req);
evbuffer_add_printf(buf, "ok %d\n", channel->seq_next);
evhttp_send_reply(req, 200, "OK", buf);
channel->close();
this->free_channel(channel);
return 0;
}
static void http_handle_blob_get(struct evhttp_request *req) {
evkeyvalq* out_headers = evhttp_request_get_output_headers(req);
if (!out_headers) {
evhttp_send_reply(req, HTTP_INTERNAL, "can't get headers", 0);
return;
}
int r = evhttp_add_header(out_headers, "Content-Type", "text/plain");
if (r == -1) {
evhttp_send_reply(req, HTTP_INTERNAL, "can't add header", 0);
return;
}
evbuffer* out = evbuffer_new();
if (!out) {
evhttp_send_reply(req, HTTP_INTERNAL, "can't make buffer", 0);
return;
}
std::string hello("hello world");
evbuffer_add(out, &*hello.begin(), hello.length());
evhttp_send_reply(req, HTTP_OK, "OK", out);
evbuffer_free(out);
}
/**** uri: /pinyin?str=*
*
*/
static void http_pinyin_callback(struct evhttp_request *request, void *data) {
//parse uri
struct evkeyvalq params_get;
PARSE_URI(request, params_get);
SinoparserServer* serv = (SinoparserServer*) data;
//get "str"
char const *str;
PARAM_GET_STR(str, ¶ms_get, "str", true);
serv->parser.change_text((char*)str);
serv->parser.parse_against_index(serv->db.mandarin_words);
std::string pinyin = serv->parser.romanize();
//prepare output
struct evbuffer *buffer = evbuffer_new();
output_xml_header(buffer);
romanization_output_xml(pinyin, buffer);
output_xml_footer(buffer);
//send
evhttp_add_header(request->output_headers, "Content-Type", "TEXT/XML; charset=UTF8");
evhttp_send_reply(request, HTTP_OK, "", buffer);
}
void
httpd_put_favicon (struct evhttp_request *req, void *arg)
{
struct evbuffer *buf;
static unsigned char thrash_ico[] = {
0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x10, 0x10, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0xb0, 0x00,
0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x20, 0x00,
0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xb6, 0x6d,
0x00, 0x00, 0xb5, 0xad, 0x00, 0x00, 0x87, 0xad, 0x00, 0x00, 0xb4, 0x61, 0x00, 0x00, 0xb5, 0xed,
0x00, 0x00, 0xce, 0x6d, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xed, 0xad, 0x00, 0x00, 0xed, 0xad,
0x00, 0x00, 0xed, 0xab, 0x00, 0x00, 0xec, 0x23, 0x00, 0x00, 0xed, 0xad, 0x00, 0x00, 0x85, 0xa3,
0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
buf = evbuffer_new();
evhttp_add_header(req->output_headers, "Content-Type", "text/x-icon");
evbuffer_add(buf, thrash_ico, sizeof(thrash_ico));
evhttp_send_reply(req, HTTP_OK, "OK", buf);
evbuffer_free(buf);
}
int Server::info(struct evhttp_request *req){
HttpQuery query(req);
std::string cname = query.get_str("cname", "");
evhttp_add_header(req->output_headers, "Content-Type", "text/html; charset=utf-8");
struct evbuffer *buf = evbuffer_new();
if(!cname.empty()){
Channel *channel = this->get_channel_by_name(cname);
int onlines = channel? channel->subs.size : 0;
evbuffer_add_printf(buf,
"{\"cname\": \"%s\", \"subscribers\": %d}\n",
cname.c_str(),
onlines);
}else{
evbuffer_add_printf(buf,
"{\"version\": \"%s\", \"channels\": %d, \"subscribers\": %d}\n",
ICOMET_VERSION,
used_channels.size,
subscribers);
}
evhttp_send_reply(req, 200, "OK", buf);
evbuffer_free(buf);
return 0;
}
static void internal_error(struct evhttp_request *req, struct evbuffer *evb)
{
evbuffer_add_printf(evb, "{\"status\":\"failed\"}");
evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", "application/json");
evhttp_send_reply(req, 500, "Internal Error", evb);
printf(" - 500 - error\n");
}
void
http_basic_cb(struct evhttp_request *req, void *arg)
{
struct evbuffer *evb = evbuffer_new();
int empty = evhttp_find_header(req->input_headers, "Empty") != NULL;
event_debug(("%s: called\n", __func__));
evbuffer_add_printf(evb, "This is funny");
/* For multi-line headers test */
{
const char *multi =
evhttp_find_header(req->input_headers,"X-multi");
if (multi) {
if (strcmp("END", multi + strlen(multi) - 3) == 0)
test_ok++;
if (evhttp_find_header(req->input_headers, "X-Last"))
test_ok++;
}
}
/* injecting a bad content-length */
if (evhttp_find_header(req->input_headers, "X-Negative"))
evhttp_add_header(req->output_headers,
"Content-Length", "-100");
/* allow sending of an empty reply */
evhttp_send_reply(req, HTTP_OK, "Everything is fine",
!empty ? evb : NULL);
evbuffer_free(evb);
}
