static void add_cb(evhtp_request_t* req, void* a) {
if (req->method != htp_method_POST) {
evhtp_send_reply(req, EVHTP_RES_METHNALLOWED);
return;
}
size_t len;
auto buf = extract_body(req, &len);
if (!buf) {
evhtp_send_reply(req, EVHTP_RES_500);
return;
}
StaticJsonBuffer<10 * 1024> jsonBuffer;
auto& root = jsonBuffer.parseObject(buf);
if (!root.success()) {
const auto err = "JsonBuffer::parseObject() failed";
evbuffer_add(req->buffer_out, err, strlen(err));
evhtp_send_reply(req, EVHTP_RES_500);
return;
}
const char* id = root["id"];
evbuffer_add(req->buffer_out, "OK:", 3);
evbuffer_add(req->buffer_out, id, strlen(id));
evhtp_send_reply(req, EVHTP_RES_OK);
}
void
receive_plurals(evhtp_request_t * req, void * a) {
if (req->method != htp_method_POST) {
evhtp_send_reply(req, EVHTP_RES_BADREQ);
return;
}
int max_len = 1024;
int len = evbuffer_get_length(req->buffer_in);
if (len == 0 || len >= max_len) {
evhtp_send_reply(req, EVHTP_RES_BADREQ);
return;
}
char buf[max_len];
evbuffer_remove(req->buffer_in, buf, len);
buf[len] = '\0';
if (buf[0] != 'd' || buf[1] != '=' || strstr(buf + 2, "=") != NULL || strstr(buf, "&") != NULL) {
evhtp_send_reply(req, EVHTP_RES_BADREQ);
return;
}
printf("d: %s\n", buf + 2);
evhtp_send_reply(req, EVHTP_RES_OK);
}
static void add_cb(evhtp_request_t* req, void* a) {
if (req->method != htp_method_POST) {
evhtp_send_reply(req, EVHTP_RES_METHNALLOWED);
return;
}
size_t len;
auto buf = extract_body(req, &len);
if (!buf) {
evhtp_send_reply(req, EVHTP_RES_500);
return;
}
char* endptr;
JsonValue value;
JsonAllocator allocator;
int status = jsonParse(buf, &endptr, &value, allocator);
if (status != JSON_OK) {
evhtp_send_reply(req, EVHTP_RES_500);
return;
}
evbuffer_add(req->buffer_out, "OK:", 3);
// TODO: how to retrieve id?
// evbuffer_add(req->buffer_out, id.c_str(), id.size());
evhtp_send_reply(req, EVHTP_RES_OK);
}
/**
* Serves a PNG file of the hash.
*/
void route_image(evhtp_request_t *req, void *arg) {
// redisReply *reply;
evhtp_uri_t *uri = req->uri;
int side = 128;
char *hash = "";
char *res = uri->path->full;
int ind = 0;
res = strtok((char *) res, "/");
while (res != NULL) {
if (ind == 0) {
if (strlen(res) == 32) {
hash = res;
} else if (strcmp(res, "avatar") == 0) {
ind--;
} else {
route_400(req);
return;
}
}
if (ind == 1) {
side = atoi(res);
if (side == 0) {
side = defsize;
} else if (side < minsize) {
side = minsize;
} else if (side > maxsize) {
side = maxsize;
}
}
res = strtok(NULL, "/");
ind++;
}
char *etag = malloc(sizeof(char) * 1024);
sprintf(etag, "\"%s-%d\"", hash, side);
evhtp_kv_t *etagin = evhtp_headers_find_header(req->headers_in, "If-None-Match");
if(etagin && strcmp(etag, etagin->val) == 0) {
free(etag);
evhtp_send_reply(req, 304);
return;
}
make_image(hash, req->buffer_out, side);
evhtp_headers_add_header(req->headers_out,
evhtp_header_new("Content-Type", "image/png", 0, 0));
evhtp_headers_add_header(req->headers_out,
evhtp_header_new("Cache-Control", "public", 0, 0));
evhtp_headers_add_header(req->headers_out,
evhtp_header_new("ETag", etag, 0, 1));
free(etag);
evhtp_send_reply(req, 200);
}
void cm_img(evhtp_request_t *req, void *arg) {
int fd = open("../resource/players.png", O_RDONLY);
if (fd == -1){
evhtp_send_reply(req, EVHTP_RES_OK);
return;
}
int len = lseek(fd , 0 , SEEK_END);
evbuffer_add_file(req->buffer_out, fd, 0, len);
evhtp_send_reply(req, EVHTP_RES_OK);
//close(fd);
}
/**
* @brief echo_cb Callback function of echo test.
*
* @param req The request of a test url.
* @param arg It is not useful.
*/
void echo_cb(evhtp_request_t *req, void *arg)
{
evbuffer_add_printf(req->buffer_out, "<html><body><h1>zimg works!</h1></body></html>");
evhtp_headers_add_header(req->headers_out, evhtp_header_new("Server", settings.server_name, 0, 1));
evhtp_headers_add_header(req->headers_out, evhtp_header_new("Content-Type", "text/html", 0, 0));
evhtp_send_reply(req, EVHTP_RES_OK);
}
static void
redirect_to_upload_error (evhtp_request_t *req,
const char *repo_id,
const char *parent_dir,
const char *filename,
int error_code)
{
char *seahub_url, *escaped_path, *escaped_fn = NULL;
char url[1024];
seahub_url = seaf->session->base.service_url;
escaped_path = g_uri_escape_string (parent_dir, NULL, FALSE);
if (filename) {
escaped_fn = g_uri_escape_string (filename, NULL, FALSE);
snprintf(url, 1024, "%s/repo/upload_error/%s?p=%s&fn=%s&err=%d",
seahub_url, repo_id, escaped_path, escaped_fn, error_code);
} else {
snprintf(url, 1024, "%s/repo/upload_error/%s?p=%s&err=%d",
seahub_url, repo_id, escaped_path, error_code);
}
g_free (escaped_path);
g_free (escaped_fn);
evhtp_headers_add_header(req->headers_out,
evhtp_header_new("Location",
url, 0, 0));
evhtp_send_reply(req, EVHTP_RES_FOUND);
}
static void
test_500_cb(evhtp_request_t * req, void * arg ) {
evbuffer_add_reference(req->buffer_out,
"test_500_cb\n", 12, NULL, NULL);
evhtp_send_reply(req, EVHTP_RES_SERVERR);
}
static void
test_max_body(evhtp_request_t * req, void * arg) {
evbuffer_add_reference(req->buffer_out,
"test_max_body\n", 14, NULL, NULL);
evhtp_send_reply(req, EVHTP_RES_OK);
}
/**
* Index route, serves a static file and handles a redirect.
*/
void route_index(evhtp_request_t *req, void *arg) {
evhtp_uri_t *uri = req->uri;
evhtp_query_t *query = uri->query;
const char *parq = evhtp_kv_find(query, "q");
const char *pars = evhtp_kv_find(query, "s");
const char *parm = evhtp_kv_find(query, "m");
if (parq) {
char *m = malloc(sizeof (char)*64);
char *tmp = makelower(parq, strlen(parq));
char *md = md5((const char *) tmp, strlen(parq));
free(tmp);
if (parm) {
sprintf(m, "/meta/%s", md);
} else if (pars) {
sprintf(m, "/%s/%d", md, atoi(pars));
} else {
sprintf(m, "/%s", md);
}
free(md);
evhtp_headers_add_header(req->headers_out,
evhtp_header_new("Location", m, 0, 1));
free(m);
evhtp_send_reply(req, 301);
} else {
serve_static(req, "static/index.html", "text/html");
}
}
void cm_diguser_info(evhtp_request_t *req, void *arg) {
enum {
err_nologin = -1,
err_db = -2,
};
redisContext *redis = cm_get_context()->redis;
if (redis->err) {
return cm_send_error(err_db, req);
}
cm_session session;
int err = cm_find_session(req, session);
if (err) {
return cm_send_error(err_nologin, req);
}
redisReply *reply = (redisReply*)redisCommand(redis, "HMGET diguser:%s x y", session.userid.c_str());
Autofree _af_reply(reply, freeReplyObject);
if (reply == NULL || reply->type != REDIS_REPLY_ARRAY || reply->elements != 2) {
return cm_send_error(err_db, req);
}
const char *x = reply->element[0]->str;
const char *y = reply->element[1]->str;
if (x == NULL || y == NULL) { //not saved
x = "-1";
y = "-1";
}
evbuffer_add_printf(req->buffer_out, "{\"error\":0, \"x\":\"%s\", \"y\":\"%s\"}", x, y);
evhtp_send_reply(req, EVHTP_RES_OK);
}
static void
dynamic_cb(evhtp_request_t * r, void * arg) {
const char * name = arg;
evbuffer_add_printf(r->buffer_out, "dynamic_cb = %s\n", name);
evhtp_send_reply(r, EVHTP_RES_OK);
}
/**
* @brief dump_request_cb The callback of a dump request.
*
* @param req The request you want to dump.
* @param arg It is not useful.
*/
void dump_request_cb(evhtp_request_t *req, void *arg)
{
const char *uri = req->uri->path->full;
//switch (evhtp_request_t_get_command(req)) {
int req_method = evhtp_request_get_method(req);
if(req_method >= 16)
req_method = 16;
LOG_PRINT(LOG_DEBUG, "Received a %s request for %s", method_strmap[req_method], uri);
evbuffer_add_printf(req->buffer_out, "uri : %s\r\n", uri);
evbuffer_add_printf(req->buffer_out, "query : %s\r\n", req->uri->query_raw);
evhtp_headers_for_each(req->uri->query, print_headers, req->buffer_out);
evbuffer_add_printf(req->buffer_out, "Method : %s\n", method_strmap[req_method]);
evhtp_headers_for_each(req->headers_in, print_headers, req->buffer_out);
evbuf_t *buf = req->buffer_in;;
puts("Input data: <<<");
while (evbuffer_get_length(buf)) {
int n;
char cbuf[128];
n = evbuffer_remove(buf, cbuf, sizeof(buf)-1);
if (n > 0)
(void) fwrite(cbuf, 1, n, stdout);
}
puts(">>>");
evhtp_headers_add_header(req->headers_out, evhtp_header_new("Server", settings.server_name, 0, 1));
evhtp_headers_add_header(req->headers_out, evhtp_header_new("Content-Type", "text/plain", 0, 0));
evhtp_send_reply(req, EVHTP_RES_OK);
}
/* **********************************
* Websocket
* **********************************/
static int do_ws_handshake(evhtp_request_t *req) {
const char *upgrade = evhtp_header_find(req->headers_in, "Upgrade");
const char *connection = evhtp_header_find(req->headers_in, "Connection");
const char *ws_key = evhtp_header_find(req->headers_in, "Sec-WebSocket-Key");
if (upgrade && connection && ws_key) {
if (!strstrcase(upgrade, "websocket") ||
!strstrcase(connection, "Upgrade")){
return EVHTP_RES_ERROR;
}
static const char *magic = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
unsigned char *str = calloc(strlen(ws_key)+strlen(magic)+1, sizeof(unsigned char));
strcpy((char *)str, ws_key);
strcat((char *)str, magic);
unsigned char hash[SHA_DIGEST_LENGTH];
SHA1(str, strlen((char *)str), hash);
free(str);
char ws_accept[29];
ws_accept[28] = '\0';
base64encode(&hash[0], sizeof(hash), &ws_accept[0], sizeof(ws_accept)-1);
ws_headers_add_header(req->headers_out, "Connection", "Upgrade" );
ws_headers_add_header(req->headers_out, "Sec-WebSocket-Accept", &ws_accept[0]);
ws_headers_add_header(req->headers_out, "Upgrade", "websocket");
evhtp_send_reply(req, EVHTP_RES_SWITCH_PROTO);
return EVHTP_RES_SWITCH_PROTO;
}
return EVHTP_RES_OK;
}
static void
response_cb(evhtp_request_t * r, void * a) {
evbuffer_add_reference(r->buffer_out,
(const char *)a, payload_sz, NULL, NULL);
evhtp_send_reply(r, EVHTP_RES_OK);
}
static void
test_default_cb(evhtp_request_t * req, void * arg) {
evbuffer_add_reference(req->buffer_out,
"test_default_cb\n", 16, NULL, NULL);
evhtp_send_reply(req, EVHTP_RES_OK);
}
static void
test_regex(evhtp_request_t * req, void * arg) {
evbuffer_add_printf(req->buffer_out,
"start = '%s', end = '%s\n",
req->uri->path->match_start,
req->uri->path->match_end);
evhtp_send_reply(req, EVHTP_RES_OK);
}
void common_invalid_reply(evhtp_request_t * req, evhtp_kv_t* kv_jscb)
{
if (!kv_jscb) {
evbuffer_add_printf(req->buffer_out, "invalid params");
} else {
evbuffer_add_printf(req->buffer_out, "%s({\"status\" : \"invalid params\"})", kv_jscb->val);
}
evhtp_send_reply(req, EVHTP_RES_OK);
}
static void
upload_progress_cb(evhtp_request_t *req, void *arg)
{
const char *progress_id;
const char *callback;
Progress *progress;
GString *buf;
progress_id = evhtp_kv_find (req->uri->query, "X-Progress-ID");
if (!progress_id) {
seaf_warning ("[get pg] Progress id not found in url.\n");
evhtp_send_reply (req, EVHTP_RES_BADREQ);
return;
}
callback = evhtp_kv_find (req->uri->query, "callback");
if (!callback) {
seaf_warning ("[get pg] callback not found in url.\n");
evhtp_send_reply (req, EVHTP_RES_BADREQ);
return;
}
pthread_mutex_lock (&pg_lock);
progress = g_hash_table_lookup (upload_progress, progress_id);
pthread_mutex_unlock (&pg_lock);
if (!progress) {
/* seaf_warning ("[get pg] No progress found for %s.\n", progress_id); */
evhtp_send_reply (req, EVHTP_RES_BADREQ);
return;
}
/* Return JSONP formated data. */
buf = g_string_new (NULL);
g_string_append_printf (buf,
"%s({\"uploaded\": %lld, \"length\": %lld});",
callback, progress->uploaded, progress->size);
evbuffer_add (req->buffer_out, buf->str, buf->len);
seaf_debug ("JSONP: %s\n", buf->str);
evhtp_send_reply (req, EVHTP_RES_OK);
g_string_free (buf, TRUE);
}
void
zxy_end_request(
zxy_request_context *context,
zxy_http_status status
)
{
evhtp_send_reply(context->request, status);
session_end(context);
zxy_destroy_request_context(context);
}
void wshtp_send_reply(wshtp_conn_t *conn) {
if (conn->is_websocket) {
return;
} else {
if (conn->reply.code == 0) {
conn->reply.code = 200;
}
evhtp_send_reply(conn->request, conn->reply.code);
}
}
void webif_default(evhtp_request_t * req, void * a)
{
char* path = req->uri->path->full;
if (!strncasecmp(path, "/webif/", 7)) {
webif(req, a);
} else {
evbuffer_add_printf(req->buffer_out, "invalid request");
evhtp_send_reply(req, EVHTP_RES_OK);
}
}
// Wrapper around evhtp_send_reply to ensure that all responses are
// logged to the access log and SAS.
void HttpStack::send_reply_internal(Request& req, int rc, SAS::TrailId trail)
{
LOG_VERBOSE("Sending response %d to request for URL %s, args %s", rc, req.req()->uri->path->full, req.req()->uri->query_raw);
unsigned long latency_us = 0;
req.get_latency(latency_us);
log(std::string(req.req()->uri->path->full), req.method_as_str(), rc, latency_us);
req.sas_log_tx_http_rsp(trail, rc, 0);
evhtp_send_reply(req.req(), rc);
}
static void
create_callback(evhtp_request_t * r, void * arg) {
char * uri;
char * nuri;
size_t urilen;
uri = r->uri->path->match_start;
urilen = strlen(uri);
if (urilen == 0) {
return evhtp_send_reply(r, EVHTP_RES_BADREQ);
}
nuri = calloc(urilen + 2, 1);
snprintf(nuri, urilen + 2, "/%s", uri);
evhtp_set_cb(r->htp, nuri, dynamic_cb, nuri);
evhtp_send_reply(r, EVHTP_RES_OK);
}
void webif(evhtp_request_t * req, void * a)
{
char path[MAX_PATH];
int len = strlen(req->uri->path->full) + 3;
if (len > MAX_PATH) {
evbuffer_add_printf(req->buffer_out, "File name too long");
evhtp_send_reply(req, EVHTP_RES_OK);
return;
}
sprintf(path, "/data/%s", req->uri->path->full);
send_file(req, path);
}
void cm_dig(evhtp_request_t *req, void *arg) {
enum {
err_param = -1,
err_db = -2,
};
int err = 0;
int x = kvs_find_int32(&err, req->uri->query, "x");
int y = kvs_find_int32(&err, req->uri->query, "y");
if (err) {
return cm_send_error(err_param, req);
}
if (x < 0 || x >= CELL_MAX || y < 0 || y >= CELL_MAX) {
return cm_send_error(err_param, req);
}
int undig = kvs_find_int32(&err, req->uri->query, "undig");
int blockX = x/CELLS_PER_BLOCK_SIDE;
int blockY = y/CELLS_PER_BLOCK_SIDE;
int idx = (y%CELLS_PER_BLOCK_SIDE)*CELLS_PER_BLOCK_SIDE+(x%CELLS_PER_BLOCK_SIDE);
redisContext *redis = cm_get_context()->redis;
if (redis->err) {
return cm_send_error(err_db, req);
}
if (undig)
redisAppendCommand(redis, "SETBIT block:%u,%u %u 0", blockX, blockY, idx);
else
redisAppendCommand(redis, "SETBIT block:%u,%u %u 1", blockX, blockY, idx);
redisAppendCommand(redis, "GET block:%u,%u", blockX, blockY);
redisReply *reply;
redisGetReply(redis, (void**)&reply);
freeReplyObject(reply);
redisGetReply(redis, (void**)&reply);
char buf[CELLS_PER_BLOCK_SIDE*CELLS_PER_BLOCK_SIDE/8] = {0};
if (reply->type == REDIS_REPLY_STRING && reply->len <= (int)sizeof(buf)) {
memcpy(buf, reply->str, reply->len);
char *b64 = base64_cf(buf, sizeof(buf));
evbuffer_add_printf(req->buffer_out, "{\"error\":0, \"data\":\"%s\"}", b64);
evhtp_send_reply(req, EVHTP_RES_OK);
free(b64);
} else {
cm_send_error(err_db, req);
}
freeReplyObject(reply);
}
static void
backend_cb(evhtp_request_t * backend_req, void * arg) {
evhtp_request_t * frontend_req = (evhtp_request_t *)arg;
evbuffer_prepend_buffer(frontend_req->buffer_out, backend_req->buffer_in);
evhtp_headers_add_headers(frontend_req->headers_out, backend_req->headers_in);
/*
* char body[1024] = { '\0' };
* ev_ssize_t len = evbuffer_copyout(frontend_req->buffer_out, body, sizeof(body));
* printf("Backend %zu: %s\n", len, body);
*/
evhtp_send_reply(frontend_req, EVHTP_RES_OK);
evhtp_request_resume(frontend_req);
}
/**
* Serves meta information in JSON about a hash.
*/
void route_meta(evhtp_request_t *req, void *arg) {
evhtp_uri_t *uri = req->uri;
char *res = uri->path->full;
char *hash = "";
res = strtok((char *) res, "/");
while (res != NULL) {
if (strlen(res) == 32) {
hash = res;
break;
}
res = strtok(NULL, "/");
}
char *color = malloc(sizeof (char)*7);
make_color_hex(hash, color);
int i[8][8];
make_pattern(hash, i);
char *pattern = malloc(sizeof (char)*146);
sprintf(pattern, "[[%d,%d,%d,%d,%d,%d,%d,%d],"
"[%d,%d,%d,%d,%d,%d,%d,%d],"
"[%d,%d,%d,%d,%d,%d,%d,%d],"
"[%d,%d,%d,%d,%d,%d,%d,%d],"
"[%d,%d,%d,%d,%d,%d,%d,%d],"
"[%d,%d,%d,%d,%d,%d,%d,%d],"
"[%d,%d,%d,%d,%d,%d,%d,%d],"
"[%d,%d,%d,%d,%d,%d,%d,%d]]",
i[0][0], i[0][1], i[0][2], i[0][3], i[0][4], i[0][5], i[0][6], i[0][7],
i[1][0], i[1][1], i[1][2], i[1][3], i[1][4], i[1][5], i[1][6], i[1][7],
i[2][0], i[2][1], i[2][2], i[2][3], i[2][4], i[2][5], i[2][6], i[2][7],
i[3][0], i[3][1], i[3][2], i[3][3], i[3][4], i[3][5], i[3][6], i[3][7],
i[4][0], i[4][1], i[4][2], i[4][3], i[4][4], i[4][5], i[4][6], i[4][7],
i[5][0], i[5][1], i[5][2], i[5][3], i[5][4], i[5][5], i[5][6], i[5][7],
i[6][0], i[6][1], i[6][2], i[6][3], i[6][4], i[6][5], i[6][6], i[6][7],
i[7][0], i[7][1], i[7][2], i[7][3], i[7][4], i[7][5], i[7][6], i[7][7]
);
pattern[145] = 0;
evbuffer_add_printf(req->buffer_out, "{\"hash\":\"%s\",\"modified\":false,\"color\":\"%s\",\"pattern\":%s}", hash, color, pattern);
free(color);
free(pattern);
evhtp_headers_add_header(req->headers_out,
evhtp_header_new("Content-Type", "application/json", 0, 0));
evhtp_send_reply(req, 200);
}
static void
redirect_to_success_page (evhtp_request_t *req,
const char *repo_id,
const char *parent_dir)
{
char *seahub_url, *escaped_path;
char url[1024];
seahub_url = seaf->session->base.service_url;
escaped_path = g_uri_escape_string (parent_dir, NULL, FALSE);
snprintf(url, 1024, "%s/repo/%s?p=%s", seahub_url, repo_id, escaped_path);
g_free (escaped_path);
evhtp_headers_add_header(req->headers_out,
evhtp_header_new("Location",
url, 0, 0));
evhtp_send_reply(req, EVHTP_RES_FOUND);
}
void
provide_score(evhtp_request_t * req, void * a) {
if (req->method != htp_method_POST) {
evhtp_send_reply(req, EVHTP_RES_BADREQ);
return;
}
int max_len = 1024;
int len = evbuffer_get_length(req->buffer_in);
if (len == 0 || len >= max_len) {
evhtp_send_reply(req, EVHTP_RES_BADREQ);
return;
}
char buf[max_len];
evbuffer_remove(req->buffer_in, buf, len);
buf[len] = '\0';
char* amp_pos = strchr(buf, '&');
if (amp_pos == NULL || amp_pos != strrchr(buf, '&')) {
evhtp_send_reply(req, EVHTP_RES_BADREQ);
return;
}
buf[amp_pos - buf] = '\0';
if (buf[0] == 'u') {
if (buf[1] != '=' || strstr(buf + 2, "=") != NULL || strstr(buf, "&") != NULL || amp_pos[2] != '=' || strstr(amp_pos + 3, "=") != NULL || amp_pos[1] != 'd') {
evhtp_send_reply(req, EVHTP_RES_BADREQ);
return;
}
printf("u: %s\n", buf + 2);
printf("d: %s\n", amp_pos + 3);
} else {
if (buf[0] == 'd') {
if (buf[1] != '=' || strstr(buf + 2, "=") != NULL || strstr(buf, "&") != NULL || amp_pos[2] != '=' || strstr(amp_pos + 3, "=") != NULL || amp_pos[1] != 'u') {
evhtp_send_reply(req, EVHTP_RES_BADREQ);
return;
}
printf("u: %s\n", amp_pos + 3);
printf("d: %s\n", buf + 2);
} else {
evhtp_send_reply(req, EVHTP_RES_BADREQ);
return;
}
}
evhtp_send_reply(req, EVHTP_RES_OK);
}
