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); }
static void drain_body(struct request_ctx *req, struct bufferevent *bev) { struct evbuffer *buf; struct evbuffer *saved; int before, after; if (req->chunked && req->chunk_size == -1) { /* Transfer-Encoding: chunked but we don't have size yet. */ if (read_chunk_size(req, bev) != 0) { verbose(ERROR, "%s(): could not read chunk size!\n", __func__); } } buf = bufferevent_get_input(bev); saved = NULL; before = evbuffer_get_length(buf); if (req->chunked && req->chunk_size > 0 && req->chunk_left < before) { /* * Save the real buffer away and give the callback * a temporary one, just the chunk that remains. */ saved = buf; buf = evbuffer_new(); evbuffer_remove_buffer(saved, buf, req->chunk_left); before = evbuffer_get_length(buf); } req->cb_ops->read(buf, req->cb_arg); after = evbuffer_get_length(buf); req->consumed += before - after; req->chunk_left -= (before - after); if (req->chunk_size > 0 && req->chunk_left == 0) { /* We've consumed the whole chunk. * Signal that we need another one. */ req->chunk_size = -1; } if (saved != NULL) { /* saved is actually the buffer in bev */ evbuffer_prepend_buffer(saved, buf); evbuffer_free(buf); } if ((req->chunked && req->chunk_size == 0) || (req->content_length > 0 && req->consumed == req->content_length)) { set_read_state(req, READ_DONE); } }
void http_dispatcher_cb(struct evhttp_request *req, void *arg) { struct evbuffer *evb = evbuffer_new(); event_debug(("%s: called\n", __func__)); evbuffer_add_printf(evb, "DISPATCHER_TEST"); evhttp_send_reply(req, HTTP_OK, "Everything is fine", evb); evbuffer_free(evb); }
static void on_output_timer (evutil_socket_t fd, short event, void *ctx) { OutData *out = (OutData *) ctx; struct timeval tv; struct evbuffer *out_buf; char *buf; char c; LOG_debug (HTTP_TEST, "SRV: on output timer .."); if (out->test_id < TID_body && out->timer_count >= evbuffer_get_length (out->out_buf)) { bufferevent_free (out->bev); evconnlistener_disable (out->listener); event_base_loopbreak (out->evbase); LOG_debug (HTTP_TEST, "SRV: All headers data sent !! "); return; } out_buf = evbuffer_new (); if (out->test_id < TID_body) { buf = (char *)evbuffer_pullup (out->out_buf, -1); c = buf[out->timer_count]; evbuffer_add (out_buf, &c, sizeof (c)); out->timer_count++; LOG_debug (HTTP_TEST, "SRV: Sending %zd bytes:\n>>%s<<\n", evbuffer_get_length (out_buf), evbuffer_pullup (out_buf, -1)); } else { if (!out->header_sent) { evbuffer_add_buffer (out_buf, out->out_buf); out->header_sent = TRUE; } /* if (evbuffer_get_length (out->in_file) < 1) { bufferevent_free (out->bev); evconnlistener_disable (out->listener); event_base_loopbreak (out->evbase); LOG_debug (HTTP_TEST, "SRV: All data sent !! "); return; }*/ evbuffer_remove_buffer (out->in_file, out_buf, 1024*100); LOG_debug (HTTP_TEST, "SRV: Sending BODY %zd bytes", evbuffer_get_length (out_buf)); } bufferevent_write_buffer (out->bev, out_buf); evbuffer_free (out_buf); evutil_timerclear(&tv); tv.tv_sec = 0; tv.tv_usec = 500; event_add(out->timeout, &tv); }
static void http_basic_cb(struct evhttp_request *req, void *arg) { struct evbuffer *evb = evbuffer_new(); evbuffer_add(evb, content, content_len); /* allow sending of an empty reply */ evhttp_send_reply(req, HTTP_OK, "Everything is fine", evb); evbuffer_free(evb); }
CDBuffer* CD_CreateBuffer (void) { CDBuffer* self = CD_malloc(sizeof(CDBuffer)); self->raw = evbuffer_new(); self->external = false; evbuffer_enable_locking(self->raw, NULL); return self; }
int Server::pub(struct evhttp_request *req){ if(evhttp_request_get_command(req) != EVHTTP_REQ_GET){ evhttp_send_reply(req, 405, "Invalid Method", NULL); return 0; } HttpQuery query(req); const char *cb = query.get_str("cb", NULL); std::string cname = query.get_str("cname", ""); const char *content = query.get_str("content", ""); Channel *channel = NULL; channel = this->get_channel_by_name(cname); if(!channel || channel->idle == -1){ channel = this->new_channel(cname); if(!channel){ evhttp_send_reply(req, 429, "Too Many Channels", NULL); return 0; } int expires = ServerConfig::channel_timeout; log_debug("auto sign channel on pub, cname:%s, t:%s, expires:%d", cname.c_str(), channel->token.c_str(), expires); channel->idle = expires/CHANNEL_CHECK_INTERVAL; /* struct evbuffer *buf = evbuffer_new(); log_trace("cname[%s] not connected, not pub content: %s", cname.c_str(), content); evbuffer_add_printf(buf, "cname[%s] not connected\n", cname.c_str()); evhttp_send_reply(req, 404, "Not Found", buf); evbuffer_free(buf); return 0; */ } log_debug("channel: %s, subs: %d, pub content: %s", channel->name.c_str(), channel->subs.size, content); // response to publisher evhttp_add_header(req->output_headers, "Content-Type", "text/javascript; charset=utf-8"); struct evbuffer *buf = evbuffer_new(); if(cb){ evbuffer_add_printf(buf, "%s(", cb); } evbuffer_add_printf(buf, "{\"type\":\"ok\"}"); if(cb){ evbuffer_add(buf, ");\n", 3); }else{ evbuffer_add(buf, "\n", 1); } evhttp_send_reply(req, 200, "OK", buf); evbuffer_free(buf); // push to subscribers channel->send("data", content); return 0; }
int Server::sign(struct evhttp_request *req){ HttpQuery query(req); int expires = query.get_int("expires", -1); const char *cb = query.get_str("cb", NULL); std::string cname = query.get_str("cname", ""); if(expires <= 0){ expires = ServerConfig::channel_timeout; } Channel *channel = this->get_channel_by_name(cname); if(!channel){ channel = this->new_channel(cname); } if(!channel){ evhttp_send_reply(req, 429, "Too Many Channels", NULL); return 0; } if(channel->idle == -1){ log_debug("%s:%d sign cname:%s, t:%s, expires:%d", req->remote_host, req->remote_port, cname.c_str(), channel->token.c_str(), expires); }else{ log_debug("%s:%d re-sign cname:%s, t:%s, expires:%d", req->remote_host, req->remote_port, cname.c_str(), channel->token.c_str(), expires); } channel->idle = expires/CHANNEL_CHECK_INTERVAL; evhttp_add_header(req->output_headers, "Content-Type", "text/html; charset=utf-8"); struct evbuffer *buf = evbuffer_new(); if(cb){ evbuffer_add_printf(buf, "%s(", cb); } evbuffer_add_printf(buf, "{\"type\":\"sign\",\"cname\":\"%s\",\"seq\":%d,\"token\":\"%s\",\"expires\":%d,\"sub_timeout\":%d}", channel->name.c_str(), channel->msg_seq_min(), channel->token.c_str(), expires, ServerConfig::polling_timeout); if(cb){ evbuffer_add(buf, ");\n", 3); }else{ evbuffer_add(buf, "\n", 1); } evhttp_send_reply(req, 200, "OK", buf); evbuffer_free(buf); return 0; }
void serve_control_javascript(struct evhttp_request *request, void *arg) { struct evbuffer *databuf = evbuffer_new(); assert(databuf != NULL); evhttp_add_header(request->output_headers, "Content-Type", "text/javascript"); evbuffer_add(databuf, control_js, strlen(control_js)); /* send along our data */ evhttp_send_reply(request, HTTP_OK, "OK", databuf); evbuffer_free(databuf); }
void httpsrv_process_req(struct evhttp_request* req) { struct evbuffer* buf = evbuffer_new(); if (NULL == buf) return; evbuffer_add_printf(buf, "server response by thread %u, request uri:%s\n", pthread_self(), evhttp_request_get_uri(req)); evhttp_send_reply(req, HTTP_OK, "OK", buf); evbuffer_free(buf); buf = NULL; }
//simple function for the LED blick command static void led_blink(struct evhttp_request* req, void* arg) { printf("Received a request for %s\nDispatching dbb command\n", evhttp_request_get_uri(req)); //dispatch command executeCommand("{\"led\" : \"toggle\"}", "0000", [](const std::string& cmdOut) { }); //form a response, mind, no cmd result is available at this point, at the moment we don't block the http response thread struct evbuffer* out = evbuffer_new(); evbuffer_add_printf(out, "Command dispatched\n"); evhttp_send_reply(req, 200, "OK", out); }
int Server::ping(struct evhttp_request *req){ HttpQuery query(req); const char *cb = query.get_str("cb", DEFAULT_JSONP_CALLBACK); struct evbuffer *buf = evbuffer_new(); evbuffer_add_printf(buf, "%s({\"type\":\"ping\",\"sub_timeout\":%d});\n", cb, ServerConfig::polling_timeout); evhttp_send_reply(req, HTTP_OK, "OK", buf); evbuffer_free(buf); return 0; }
//----------------------------------------------------------------------------- void HTTPHandler::admin_handle(struct evhttp_request *req, void *arg) { //TODO(binfei): need ssl and sepecial command to do admin privilege LOG(INFO) << "Request for server admin."; // TODO(binfei): need memory pool struct evbuffer *databuf = evbuffer_new(); evbuffer_add_printf(databuf, "Server will be stoped."); evhttp_send_reply_start(req, 200, "OK"); evhttp_send_reply_chunk(req, databuf); evhttp_send_reply_end(req); evbuffer_free(databuf); HTTPServer *server = static_cast<HTTPServer*>(arg); server->Stop(); }
void httpd_driver(struct evhttp_request *req, void *arg) { struct evbuffer *buf; buf = evbuffer_new(); evhttp_add_header(req->output_headers, "Content-Type", "text/plain"); evbuffer_add_printf(buf, "Thrashd version: %s [%s]\n", VERSION, process_name); evhttp_send_reply(req, HTTP_OK, "OK", buf); evbuffer_free(buf); }
int NeubotPoller_resolve(struct NeubotPoller *poller, const char *family, const char *address, neubot_hook_vos callback, void *opaque) { struct ResolveContext *rc; int result; (void) poller; rc = calloc(1, sizeof (*rc)); if (rc == NULL) { neubot_warn("resolve: calloc() failed"); goto failure; } rc->callback = callback; rc->opaque = opaque; rc->names = evbuffer_new(); if (rc->names == NULL) { neubot_warn("resolve: evbuffer_new() failed"); goto failure; } if (strcmp(family, "PF_INET6") == 0) result = evdns_resolve_ipv6(address, DNS_QUERY_NO_SEARCH, NeubotPoller_resolve_callback_internal, rc); else if (strcmp(family, "PF_INET") == 0) result = evdns_resolve_ipv4(address, DNS_QUERY_NO_SEARCH, NeubotPoller_resolve_callback_internal, rc); else { neubot_warn("resolve: invalid family"); goto failure; } if (result != 0) { neubot_warn("resolve: evdns_resolve_ipvX() failed"); goto failure; } return (0); failure: if (rc != NULL && rc->names != NULL) evbuffer_free(rc->names); if (rc != NULL) free(rc); return (-1); }
void buf_read_callback(struct bufferevent *incoming, void *arg) { struct evbuffer *evreturn; char *req; req = evbuffer_readline(incoming->input); if (req == NULL) return; evreturn = evbuffer_new(); evbuffer_add_printf(evreturn, "You said %s\n", req); bufferevent_write_buffer(incoming, evreturn); evbuffer_free(evreturn); free(req); }
int init_db_log(void) { DBLog * const db_log = &app_context.db_log; *db_log = (DBLog) { .db_log_file_name = NULL, .db_log_fd = -1, .log_buffer = NULL, .journal_buffer_size = DEFAULT_JOURNAL_BUFFER_SIZE, .fsync_period = DEFAULT_FSYNC_PERIOD, .journal_rewrite_process = (pid_t) -1, .offset_before_fork = (off_t) -1, .last_ts = (time_t) -1 }; return 0; } int open_db_log(void) { DBLog * const db_log = &app_context.db_log; const char *db_log_file_name = db_log->db_log_file_name; if (db_log_file_name == NULL) { db_log->db_log_fd = -1; return 1; } db_log->last_ts = (time_t) -1; int flags = O_RDWR | O_CREAT | O_APPEND; #ifdef O_EXLOCK flags |= O_EXLOCK; #endif #ifdef O_NOATIME flags |= O_NOATIME; #endif #ifdef O_LARGEFILE flags |= O_LARGEFILE; #endif db_log->db_log_fd = open(db_log_file_name, flags, (mode_t) 0600); if (db_log->db_log_fd == -1) { logfile(NULL, LOG_ERR, "Can't open [%s]: [%s]", db_log_file_name, strerror(errno)); free_db_log(); return -1; } if ((db_log->log_buffer = evbuffer_new()) == NULL) { free_db_log(); return -1; } return 0; }
static void setup() { event_init(); __parser_info = ws_parser_init(message, error, (void *)CB_ARG_VALUE); fail_unless(__parser_info != NULL, "ws_parser_init"); __buf = evbuffer_new(); __waiting_error = WS_PARSE_ERROR; __call_count = __call_info = 0; __waiting_call_info = __waiting_call_count = 0; }
void HTTPHandler::info_handle(struct evhttp_request *req, void *arg) { if (evhttp_request_get_command(req) != EVHTTP_REQ_GET) return; LOG(INFO) << "Request for server infomation."; // TODO(binfei): need memory pool struct evbuffer *databuf = evbuffer_new(); evbuffer_add_printf(databuf, "hello world"); evhttp_send_reply_start(req, 200, "OK"); evhttp_send_reply_chunk(req, databuf); evhttp_send_reply_end(req); evbuffer_free(databuf); }
static void send_reply_header(evhtp_request_t * req, const char * header) { evbuf_t * buf = evbuffer_new(); const char* found = evhtp_header_find(req->headers_in, header); evhtp_send_reply_chunk_start(req, EVHTP_RES_OK); evbuffer_add(buf, found, strlen(found)); evhtp_send_reply_chunk(req, buf); evbuffer_drain(buf, -1); evhtp_send_reply_chunk_end(req); evbuffer_free(buf); }
/** * This method sends a handshake to a connected server via proxy * The sever connection is handled with player->bev * * @remarks Scope: private * * @param player player struct to connect with */ void send_proxyhandshake(struct PL_entry *player) { //struct evbuffer *output = bufferevent_get_output(player->sev); struct evbuffer *tempbuf = evbuffer_new(); uint8_t pid = PID_HANDSHAKE; int16_t n_ulen = htons(player->username->slen); evbuffer_add(tempbuf, &pid, sizeof(pid)); evbuffer_add(tempbuf, &n_ulen, sizeof(n_ulen)); evbuffer_add(tempbuf, player->username->data, player->username->slen); newOutputWq(tempbuf,player,player->sev,&player->sevoutlock); }
void web_json(struct evhttp_request *req, cJSON *root) { struct evbuffer *evb = evbuffer_new(); char *out; out = cJSON_Print(root); cJSON_Delete(root); evbuffer_add(evb, out, strlen(out)); evhttp_add_header(req->output_headers, "Content-Type", "application/json"); evhttp_send_reply(req, HTTP_OK, "Everything is fine", evb); evbuffer_free(evb); free(out); }
static void server_rpc_cb(struct evhttp_request *req, void *arg) { struct rpc_context *rpc_context = (struct rpc_context *)arg; char *json = read_req_buffer(req); if(!json) { evhttp_send_error(req, 500, "Internal server error"); return; } struct method_t *method = deserialize_method_call(json); if(!method) { evhttp_send_error(req, 500, "Error deserializing method call"); free(json); return; } void *satellite_data; rpc_method_impl_t impl = search_method_entry(rpc_context->lookup, method->name, &satellite_data); if(!impl) { evhttp_send_error(req, 500, "Method not found"); } else { //impl should also throw error char *err; struct data_t *result = impl(method->params, method->nparams, &err, satellite_data); char *json_result = NULL; struct evbuffer *evb = evbuffer_new(); if(result && (json_result = serialize_result(result, NULL)) && evb) { if(evbuffer_add(evb, json_result, strlen(json_result))) { evhttp_send_error(req, 500, "Internal server error"); } else { evhttp_send_reply(req, 200, "OK", evb); } } else { if(err) { evhttp_send_error(req, 500, err); free(err); } else { evhttp_send_error(req, 500, "Internal server error"); } } if(evb) evbuffer_free(evb); if(json_result) free(json_result); if(result) free_data_t(result); } free(json); free_method_t(method); }
/* 处理模块 */ 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_metrics_request_cb(struct evhttp_request *req, void *arg) { struct http *http = (struct http *)arg; struct evbuffer *evb = NULL; const char *uri = NULL; struct evhttp_uri *decoded = NULL; const char *query; struct metric_history *mh; uri = evhttp_request_get_uri(req); /* Decode the URI */ decoded = evhttp_uri_parse(uri); if (!decoded) { evhttp_send_error(req, HTTP_BADREQUEST, 0); goto exit; } query = evhttp_uri_get_query(decoded); printf("metrics request %s\n", query ? query : "null"); /* This holds the content we're sending. */ evb = evbuffer_new(); mh = http_find_metrics_from_query(http->metrics, query); if (!mh) { printf("Series not found in query: %s\n", query); http_format_error_response(evb, "metric not found"); } else { http_format_metric_response(evb,mh); } /* add headers */ evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", "application/json"); /* send the response */ evhttp_send_reply(req, 200, "OK", evb); exit: if (decoded) evhttp_uri_free(decoded); if (evb) evbuffer_free(evb); }
CDBuffer* CD_BufferRemoveBuffer (CDBuffer* self) { struct evbuffer* buffer = evbuffer_new(); CDBuffer* result; evbuffer_remove_buffer(self->raw, buffer, CD_BufferLength(self)); result = CD_WrapBuffer(buffer); result->external = false; return result; }
static void ui_new(evutil_socket_t fd, short what, void *arg) { int newfd; struct uiclient *client; if ((newfd = accept(fd, NULL, NULL)) == -1) { warn("%s: accept"); return; } if ((client = calloc(1, sizeof(struct uiclient))) == NULL) { warn("%s: calloc", __func__); close(newfd); return; } client->fd = newfd; client->inbuf = evbuffer_new(); client->outbuf = evbuffer_new(); if (client->inbuf == NULL || client->outbuf == NULL) err(1, "%s: evbuffer_new"); syslog(LOG_NOTICE, "%s: New ui connection on fd %d", __func__, newfd); client->ev_read = event_new(honeyd_base_ev, newfd, EV_READ, ui_handler, client); event_priority_set(client->ev_read, 0); event_add(client->ev_read, NULL); client->ev_write = event_new(honeyd_base_ev, newfd, EV_WRITE, ui_writer, client); event_priority_set(client->ev_write, 0); /* event_add(client->ev_write, NULL); -- is this missing? */ ui_greeting(client); ui_write_prompt(client); }
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); }
int HttpServerMsgHandler::processMessage(void *arg) { struct evhttp_request *req = (struct evhttp_request *)arg; const char *cmdtype; struct evkeyvalq *headers; struct evkeyval *header; 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; } printf("Received a %s request for %s\nHeaders:\n", cmdtype, evhttp_request_get_uri(req)); headers = evhttp_request_get_input_headers(req); for (header = headers->tqh_first; header; header = header->next.tqe_next) { printf(" %s: %s\n", header->key, header->value); } ConnectionManager *conn = ConnectionManager::getInstance(); struct evbuffer *return_buffer=evbuffer_new(); long long total_req = conn->getTotalRequests(); long long total_res = conn->getTotalResponses(); unsigned int conns = conn->getConnections(); long long timeouts = conn->getTimeoutRequests(); long long err_res = conn->getErrorResponses(); long long conn_except = conn->getConnExceptions(); long long ok_res = conn->getOkResponses(); evbuffer_add_printf(return_buffer," total request: %lld<br> total response: %lld<br> connnections: %u<br><br><hr><br> ok: %lld \ <br> timeout: %lld<br> http error: %lld<br> connExcept: %u<br>" , total_req, total_res, conns, ok_res, timeouts, err_res, conn_except); evhttp_send_reply(req, HTTP_OK, "OK", return_buffer); evbuffer_free(return_buffer); return 0; }
void get_master_pgn(struct evhttp_request *req, void *context) { if (evhttp_request_get_command(req) != EVHTTP_REQ_GET) { evhttp_send_error(req, HTTP_BADMETHOD, "Method Not Allowed"); return; } const struct evhttp_uri *uri = evhttp_request_get_evhttp_uri(req); if (!uri) { puts("evhttp_request_get_evhttp_uri failed"); return; } const char *path = evhttp_uri_get_path(uri); if (!path) { puts("evhttp_uri_get_path failed"); return; } char game_id[9] = {}; int end; if (1 != sscanf(path, "/master/pgn/%8s%n", game_id, &end) || strlen(game_id) != 8 || strlen(path) != end) { evhttp_send_error(req, HTTP_NOTFOUND, "Not Found"); return; } size_t pgn_size; char *pgn = kcdbget(master_pgn_db, game_id, 8, &pgn_size); if (!pgn) { evhttp_send_error(req, HTTP_NOTFOUND, "Master PGN Not Found"); return; } struct evbuffer *res = evbuffer_new(); if (!res) { puts("could not allocate response buffer"); abort(); } struct evkeyvalq *headers = evhttp_request_get_output_headers(req); evhttp_add_header(headers, "Content-Type", "application/vnd.chess-pgn; charset=utf-8"); evbuffer_add(res, pgn, pgn_size); kcfree(pgn); evhttp_send_reply(req, HTTP_OK, "OK", res); evbuffer_free(res); }