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); }
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); }
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 async_closelog(struct async_syslog_state *state) { if (state == NULL) //may happend upon initialization return; size_t i; for (i = 0; i < ASYNC_SYSLOG_BUFFER_SIZE; i++) evbuffer_free(state->buffers[i]); if (state->fd >= 0) { event_del(&state->event); close(state->fd); } free(state->ident); free(state); }
/* 处理模块 */ 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); }
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); }
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); }
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); }
//----------------------------------------------------------------------------- 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 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); }
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; }
/** * @brief * Handle the creation of a B+Tree session for this Tapioca connection without * destroying anything and providing the execution id * * @param[in] bpt_id * @param[in] open_flags * @param[in] execution_id * @param[out] rv - 0 if session already created; -1 on error ; otherwise bpt_id is returned */ static void handle_bptree_initialize_bpt_session_no_commit(tcp_client* c, struct evbuffer* buffer) { int rv; client_bpt_id *c_b = malloc(sizeof(client_bpt_id)); bptree_session *bps = malloc(sizeof(bptree_session)); memset(bps, 0,sizeof(bptree_session)); uint16_t bpt_id; enum bptree_open_flags open_flags; enum bptree_insert_flags insert_flags; uint32_t execution_id; struct evbuffer* b = evbuffer_copy(buffer); transaction_set_get_cb(c->t, on_bptree_initialize_bpt_session_no_commit, c); if (bptree_message_incomplete(b)) return; c_b->id = c->id; evbuffer_remove(b,&bpt_id, sizeof(uint16_t)); evbuffer_remove(b,&open_flags, sizeof(enum bptree_open_flags)); evbuffer_remove(b,&insert_flags, sizeof(enum bptree_insert_flags)); evbuffer_remove(b,&execution_id, sizeof(uint32_t)); c_b->bpt_id = bpt_id; bps->bpt_id = bpt_id; bps->execution_id = execution_id; bps->tapioca_client_id = c->id; bps->insert_count = 0; bps->t = c->t; bps->cursor_node = NULL; rv = bptree_initialize_bpt_session_no_commit( bps, bpt_id, open_flags, insert_flags, execution_id); if (rv == BPTREE_OP_TAPIOCA_NOT_READY) return; if (rv == BPTREE_OP_SUCCESS) { bptree_session *bps2; // assert(hashtable_search(client_bpt_ids, c_b) == NULL); bps2 = hashtable_search(client_bpt_ids, c_b); if (bps2 != NULL) free(bps2); assert(hashtable_insert(client_bpt_ids, c_b, bps)); printf("Session_nocomm: %d:%d\n", c_b->id, c_b->bpt_id); fflush(stdout); } evbuffer_free(b); evbuffer_drain(buffer, evbuffer_get_length(buffer)); send_result(c->buffer_ev, rv); }
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); }
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); }
static struct evbuffer * mxml_to_evbuf(mxml_node_t *tree) { struct evbuffer *evbuf; char *xml; int ret; evbuf = evbuffer_new(); if (!evbuf) { DPRINTF(E_LOG, L_RSP, "Could not create evbuffer for RSP reply\n"); return NULL; } xml = mxmlSaveAllocString(tree, MXML_NO_CALLBACK); if (!xml) { DPRINTF(E_LOG, L_RSP, "Could not finalize RSP reply\n"); evbuffer_free(evbuf); return NULL; } ret = evbuffer_add(evbuf, xml, strlen(xml)); free(xml); if (ret < 0) { DPRINTF(E_LOG, L_RSP, "Could not load evbuffer for RSP reply\n"); evbuffer_free(evbuf); return NULL; } return evbuf; }
int msg_attack_assign(struct msg *msg, const struct kill* value) { struct evbuffer *tmp = NULL; if (msg->attack_set) { kill_clear(msg->attack_data); msg->attack_set = 0; } else { msg->attack_data = kill_new(); if (msg->attack_data == NULL) { event_warn("%s: kill_new()", __func__); goto error; } } if ((tmp = evbuffer_new()) == NULL) { event_warn("%s: evbuffer_new()", __func__); goto error; } kill_marshal(tmp, value); if (kill_unmarshal(msg->attack_data, tmp) == -1) { event_warnx("%s: kill_unmarshal", __func__); goto error; } msg->attack_set = 1; evbuffer_free(tmp); return (0); error: if (tmp != NULL) evbuffer_free(tmp); if (msg->attack_data != NULL) { kill_free(msg->attack_data); msg->attack_data = NULL; } return (-1); }
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; }
void cweb_request_handler(struct evhttp_request *req, void *arg) { struct evbuffer *returnbuffer = evbuffer_new(); struct page *dest = http_router(req->uri); if (dest == NULL) { if (strstr(req->uri, ".html") != NULL) evbuffer_add_printf(returnbuffer, "<!doctype html>\n<html lang=zh>\n<head>\n\t" "<title>404 Not Found</title>\n</head>\n<body>\n</body>\n</html>"); } else dest->get(returnbuffer); evhttp_send_reply(req, HTTP_OK, "Client", returnbuffer); evbuffer_free(returnbuffer); return; }
static void badchunk_length_cb(evhtp_request_t * req, void * arg) { evbuf_t * buf = evbuffer_new(); evbuf_t * output; /* Start the chunk */ evhtp_send_reply_chunk_start(req, EVHTP_RES_OK); /* Send some data */ send_chunk(req, "SUCCESS", "%d\r\n", strlen("SUCCESS")); /* Close the chunk */ evhtp_send_reply_chunk_end(req); evbuffer_free(buf); }
bool NFCHttpServer::ResponseMsg(const NFHttpRequest& req, const std::string& strMsg, NFWebStatus code, const std::string& strReason) { evhttp_request* pHttpReq = (evhttp_request*) req.req; //create buffer struct evbuffer* eventBuffer = evbuffer_new(); //send data evbuffer_add_printf(eventBuffer, strMsg.c_str()); evhttp_add_header(evhttp_request_get_output_headers(pHttpReq), "Content-Type", "text/html"); evhttp_send_reply(pHttpReq, code, strReason.c_str(), eventBuffer); //free evbuffer_free(eventBuffer); return true; }
static void task_free( struct tr_web_task * task ) { if( task->slist != NULL ) curl_slist_free_all( task->slist ); if( task->timer_event_isSet ) evtimer_del( &task->timer_event ); evbuffer_free( task->response ); tr_free( task->host ); tr_free( task->range ); tr_free( task->resolved_url ); tr_free( task->url ); memset( task, TR_MEMORY_TRASH, sizeof( struct tr_web_task ) ); tr_free( task ); }
void httpd_put_holddowns_html (struct evhttp_request *req, void *arg) { struct evbuffer *buf; buf = evbuffer_new(); httpd_put_html_start(buf, "Hold downs", TRUE); evbuffer_add_printf(buf, "<tr><th>Blocked IP</th>%s<th>Triggered By</th><th>Count</th><th>Velocity</th><th>Soft</th><th>Hard</th><th>Recent</th><th>Reason</th>%s</tr>", geoip_header, (http_password?"<th>Actions</th>":"")); g_tree_foreach(current_blocks, (GTraverseFunc) fill_http_blocks_html, buf); httpd_put_html_end(buf); evhttp_add_header(req->output_headers, "Content-Type", "text/html"); evhttp_send_reply(req, HTTP_OK, "OK", buf); evbuffer_free(buf); }
void httpd_put_connections_html (struct evhttp_request *req, void *arg) { struct evbuffer *buf; buf = evbuffer_new(); httpd_put_html_start(buf, "Connections", TRUE); evbuffer_add_printf(buf, "<tr><th>Address</th><th>Port</th><th>Requests</th><th>Connection Date</th><th>Last Date</th></tr>"); g_slist_foreach(current_connections, (GFunc) fill_current_connections_html, buf); httpd_put_html_end(buf); evhttp_add_header(req->output_headers, "Content-Type", "text/html"); evhttp_send_reply(req, HTTP_OK, "OK", buf); evbuffer_free(buf); }
void evhtp_send_reply(evhtp_request_t * request, evhtp_res code) { evhtp_connection_t * c= request->conn; evbuf_t * reply_buf; request->finished = 1; if (!(reply_buf = _evhtp_create_reply(request, code))) { delete request->conn; return ; } bufferevent_write_buffer(c->bev, reply_buf); evbuffer_free(reply_buf); }
void httpd_put_uris_html (struct evhttp_request *req, void *arg) { struct evbuffer *buf; buf = evbuffer_new(); httpd_put_html_start(buf, "URIs", TRUE); evbuffer_add_printf(buf, "<tr><th>Address</th>%s<th>Connections</th><th>Timeout</th><th>Reason</th><th>URI (80 char max)</th>%s</tr>",geoip_header, (http_password?"<th>Actions</th>":"")); g_hash_table_foreach(uri_table, (GHFunc) fill_http_uri_html, buf); httpd_put_html_end(buf); evhttp_add_header(req->output_headers, "Content-Type", "text/html"); evhttp_send_reply(req, HTTP_OK, "OK", buf); 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); evbuffer_add_buffer(output,tempbuf); evbuffer_free(tempbuf); }
static void send_simple_response (struct evhttp_request * req, int code, const char * text) { const char * code_text = tr_webGetResponseStr (code); struct evbuffer * body = evbuffer_new (); evbuffer_add_printf (body, "<h1>%d: %s</h1>", code, code_text); if (text) evbuffer_add_printf (body, "%s", text); evhttp_send_reply (req, code, code_text, body); evbuffer_free (body); }
/** * Spin out an error item to the client * * @param client placeholder with client request * @param text error message text */ static void handle_error(client_t *client, char *text) { struct evbuffer *evb; char *buffer; assert(client); assert(client->request); if((!client) || (!client->request)) { /* can't happen -- dispatcher catches this */ close_client(client); return; } evb = evbuffer_new(); buffer = (char*)malloc(strlen(text) + 10); /* "3%s\t\t\t\n\r.\n\r", text */ if(!buffer) { ERROR("malloc error"); evbuffer_free(evb); close_client(client); return; } sprintf(buffer, "3%s\t\t\t\n\r.\n\r", text); evbuffer_add(evb, (void*)buffer, strlen(buffer)); DEBUG("Queueing %d bytes for write on fd %d", strlen(buffer), client->fd); /* write low-water should already be zero */ bufferevent_enable(client->buf_ev, EV_WRITE); bufferevent_write_buffer(client->buf_ev, evb); evbuffer_free(evb); 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); }