/* Thread: httpd */
static void
serve_file(struct evhttp_request *req, char *uri)
{
const char *host;
char *ext;
char path[PATH_MAX];
char *deref;
char *ctype;
char *passwd;
struct evbuffer *evbuf;
struct evkeyvalq *headers;
struct stat sb;
int fd;
int i;
int ret;
/* Check authentication */
passwd = cfg_getstr(cfg_getsec(cfg, "general"), "admin_password");
if (passwd)
{
DPRINTF(E_DBG, L_HTTPD, "Checking web interface authentication\n");
ret = httpd_basic_auth(req, "admin", passwd, PACKAGE " web interface");
if (ret != 0)
return;
DPRINTF(E_DBG, L_HTTPD, "Authentication successful\n");
}
else
{
host = evhttp_request_get_host(req);
if ((strcmp(host, "::1") != 0)
&& (strcmp(host, "127.0.0.1") != 0))
{
DPRINTF(E_LOG, L_HTTPD, "Remote web interface request denied; no password set\n");
evhttp_send_error(req, 403, "Forbidden");
return;
}
}
ret = snprintf(path, sizeof(path), "%s%s", WEBFACE_ROOT, uri + 1); /* skip starting '/' */
if ((ret < 0) || (ret >= sizeof(path)))
{
DPRINTF(E_LOG, L_HTTPD, "Request exceeds PATH_MAX: %s\n", uri);
evhttp_send_error(req, HTTP_NOTFOUND, "Not Found");
return;
}
ret = lstat(path, &sb);
if (ret < 0)
{
DPRINTF(E_LOG, L_HTTPD, "Could not lstat() %s: %s\n", path, strerror(errno));
evhttp_send_error(req, HTTP_NOTFOUND, "Not Found");
return;
}
if (S_ISDIR(sb.st_mode))
{
redirect_to_index(req, uri);
return;
}
else if (S_ISLNK(sb.st_mode))
{
deref = m_realpath(path);
if (!deref)
{
DPRINTF(E_LOG, L_HTTPD, "Could not dereference %s: %s\n", path, strerror(errno));
evhttp_send_error(req, HTTP_NOTFOUND, "Not Found");
return;
}
if (strlen(deref) + 1 > PATH_MAX)
{
DPRINTF(E_LOG, L_HTTPD, "Dereferenced path exceeds PATH_MAX: %s\n", path);
evhttp_send_error(req, HTTP_NOTFOUND, "Not Found");
free(deref);
return;
}
strcpy(path, deref);
free(deref);
ret = stat(path, &sb);
if (ret < 0)
{
DPRINTF(E_LOG, L_HTTPD, "Could not stat() %s: %s\n", path, strerror(errno));
evhttp_send_error(req, HTTP_NOTFOUND, "Not Found");
return;
}
if (S_ISDIR(sb.st_mode))
{
redirect_to_index(req, uri);
return;
}
}
if (path_is_legal(path) != 0)
{
evhttp_send_error(req, 403, "Forbidden");
return;
}
evbuf = evbuffer_new();
if (!evbuf)
{
DPRINTF(E_LOG, L_HTTPD, "Could not create evbuffer\n");
evhttp_send_error(req, HTTP_SERVUNAVAIL, "Internal error");
return;
}
fd = open(path, O_RDONLY);
if (fd < 0)
{
DPRINTF(E_LOG, L_HTTPD, "Could not open %s: %s\n", path, strerror(errno));
evhttp_send_error(req, HTTP_NOTFOUND, "Not Found");
return;
}
/* FIXME: this is broken, if we ever need to serve files here,
* this must be fixed.
*/
ret = evbuffer_read(evbuf, fd, sb.st_size);
close(fd);
if (ret < 0)
{
DPRINTF(E_LOG, L_HTTPD, "Could not read file into evbuffer\n");
evhttp_send_error(req, HTTP_SERVUNAVAIL, "Internal error");
return;
}
ctype = "application/octet-stream";
ext = strrchr(path, '.');
if (ext)
{
for (i = 0; ext2ctype[i].ext; i++)
{
if (strcmp(ext, ext2ctype[i].ext) == 0)
{
ctype = ext2ctype[i].ctype;
break;
}
}
}
headers = evhttp_request_get_output_headers(req);
evhttp_add_header(headers, "Content-Type", ctype);
evhttp_send_reply(req, HTTP_OK, "OK", evbuf);
evbuffer_free(evbuf);
}
int
httpd_basic_auth(struct evhttp_request *req, char *user, char *passwd, char *realm)
{
struct evbuffer *evbuf;
struct evkeyvalq *headers;
char *header;
const char *auth;
char *authuser;
char *authpwd;
int len;
int ret;
headers = evhttp_request_get_input_headers(req);
auth = evhttp_find_header(headers, "Authorization");
if (!auth)
{
DPRINTF(E_DBG, L_HTTPD, "No Authorization header\n");
goto need_auth;
}
if (strncmp(auth, "Basic ", strlen("Basic ")) != 0)
{
DPRINTF(E_LOG, L_HTTPD, "Bad Authentication header\n");
goto need_auth;
}
auth += strlen("Basic ");
authuser = b64_decode(auth);
if (!authuser)
{
DPRINTF(E_LOG, L_HTTPD, "Could not decode Authentication header\n");
goto need_auth;
}
authpwd = strchr(authuser, ':');
if (!authpwd)
{
DPRINTF(E_LOG, L_HTTPD, "Malformed Authentication header\n");
free(authuser);
goto need_auth;
}
*authpwd = '\0';
authpwd++;
if (user)
{
if (strcmp(user, authuser) != 0)
{
DPRINTF(E_LOG, L_HTTPD, "Username mismatch\n");
free(authuser);
goto need_auth;
}
}
if (strcmp(passwd, authpwd) != 0)
{
DPRINTF(E_LOG, L_HTTPD, "Bad password\n");
free(authuser);
goto need_auth;
}
free(authuser);
return 0;
need_auth:
len = strlen(realm) + strlen("Basic realm=") + 3;
header = (char *)malloc(len);
if (!header)
{
evhttp_send_error(req, HTTP_SERVUNAVAIL, "Internal Server Error");
return -1;
}
ret = snprintf(header, len, "Basic realm=\"%s\"", realm);
if ((ret < 0) || (ret >= len))
{
evhttp_send_error(req, HTTP_SERVUNAVAIL, "Internal Server Error");
return -1;
}
evbuf = evbuffer_new();
if (!evbuf)
{
evhttp_send_error(req, HTTP_SERVUNAVAIL, "Internal Server Error");
return -1;
}
headers = evhttp_request_get_output_headers(req);
evhttp_add_header(headers, "WWW-Authenticate", header);
evbuffer_add(evbuf, http_reply_401, strlen(http_reply_401));
evhttp_send_reply(req, 401, "Unauthorized", evbuf);
free(header);
evbuffer_free(evbuf);
return -1;
}
/* Thread: httpd */
void
httpd_stream_file(struct evhttp_request *req, int id)
{
struct media_file_info *mfi;
struct stream_ctx *st;
void (*stream_cb)(int fd, short event, void *arg);
struct stat sb;
struct timeval tv;
struct evhttp_connection *evcon;
struct evkeyvalq *input_headers;
struct evkeyvalq *output_headers;
const char *param;
const char *param_end;
const char *ua;
const char *client_codecs;
char buf[64];
int64_t offset;
int64_t end_offset;
off_t pos;
int transcode;
int ret;
offset = 0;
end_offset = 0;
input_headers = evhttp_request_get_input_headers(req);
param = evhttp_find_header(input_headers, "Range");
if (param)
{
DPRINTF(E_DBG, L_HTTPD, "Found Range header: %s\n", param);
/* Start offset */
ret = safe_atoi64(param + strlen("bytes="), &offset);
if (ret < 0)
{
DPRINTF(E_LOG, L_HTTPD, "Invalid start offset, will stream whole file (%s)\n", param);
offset = 0;
}
/* End offset, if any */
else
{
param_end = strchr(param, '-');
if (param_end && (strlen(param_end) > 1))
{
ret = safe_atoi64(param_end + 1, &end_offset);
if (ret < 0)
{
DPRINTF(E_LOG, L_HTTPD, "Invalid end offset, will stream to end of file (%s)\n", param);
end_offset = 0;
}
if (end_offset < offset)
{
DPRINTF(E_LOG, L_HTTPD, "End offset < start offset, will stream to end of file (%" PRIi64 " < %" PRIi64 ")\n", end_offset, offset);
end_offset = 0;
}
}
}
}
mfi = db_file_fetch_byid(id);
if (!mfi)
{
DPRINTF(E_LOG, L_HTTPD, "Item %d not found\n", id);
evhttp_send_error(req, HTTP_NOTFOUND, "Not Found");
return;
}
if (mfi->data_kind != DATA_KIND_FILE)
{
evhttp_send_error(req, 500, "Cannot stream radio station");
goto out_free_mfi;
}
st = (struct stream_ctx *)malloc(sizeof(struct stream_ctx));
if (!st)
{
DPRINTF(E_LOG, L_HTTPD, "Out of memory for struct stream_ctx\n");
evhttp_send_error(req, HTTP_SERVUNAVAIL, "Internal Server Error");
goto out_free_mfi;
}
memset(st, 0, sizeof(struct stream_ctx));
st->fd = -1;
ua = evhttp_find_header(input_headers, "User-Agent");
client_codecs = evhttp_find_header(input_headers, "Accept-Codecs");
transcode = transcode_needed(ua, client_codecs, mfi->codectype);
output_headers = evhttp_request_get_output_headers(req);
if (transcode)
{
DPRINTF(E_INFO, L_HTTPD, "Preparing to transcode %s\n", mfi->path);
stream_cb = stream_chunk_xcode_cb;
ret = transcode_setup(&st->xcode, mfi, &st->size, 1);
if (ret < 0)
{
DPRINTF(E_WARN, L_HTTPD, "Transcoding setup failed, aborting streaming\n");
evhttp_send_error(req, HTTP_SERVUNAVAIL, "Internal Server Error");
goto out_free_st;
}
if (!evhttp_find_header(output_headers, "Content-Type"))
evhttp_add_header(output_headers, "Content-Type", "audio/wav");
}
else
{
/* Stream the raw file */
DPRINTF(E_INFO, L_HTTPD, "Preparing to stream %s\n", mfi->path);
st->buf = (uint8_t *)malloc(STREAM_CHUNK_SIZE);
if (!st->buf)
{
DPRINTF(E_LOG, L_HTTPD, "Out of memory for raw streaming buffer\n");
evhttp_send_error(req, HTTP_SERVUNAVAIL, "Internal Server Error");
goto out_free_st;
}
stream_cb = stream_chunk_raw_cb;
st->fd = open(mfi->path, O_RDONLY);
if (st->fd < 0)
{
DPRINTF(E_LOG, L_HTTPD, "Could not open %s: %s\n", mfi->path, strerror(errno));
evhttp_send_error(req, HTTP_NOTFOUND, "Not Found");
goto out_cleanup;
}
ret = stat(mfi->path, &sb);
if (ret < 0)
{
DPRINTF(E_LOG, L_HTTPD, "Could not stat() %s: %s\n", mfi->path, strerror(errno));
evhttp_send_error(req, HTTP_NOTFOUND, "Not Found");
goto out_cleanup;
}
st->size = sb.st_size;
pos = lseek(st->fd, offset, SEEK_SET);
if (pos == (off_t) -1)
{
DPRINTF(E_LOG, L_HTTPD, "Could not seek into %s: %s\n", mfi->path, strerror(errno));
evhttp_send_error(req, HTTP_BADREQUEST, "Bad Request");
goto out_cleanup;
}
st->offset = offset;
st->end_offset = end_offset;
/* Content-Type for video files is different than for audio files
* and overrides whatever may have been set previously, like
* application/x-dmap-tagged when we're speaking DAAP.
*/
if (mfi->has_video)
{
/* Front Row and others expect video/<type> */
ret = snprintf(buf, sizeof(buf), "video/%s", mfi->type);
if ((ret < 0) || (ret >= sizeof(buf)))
DPRINTF(E_LOG, L_HTTPD, "Content-Type too large for buffer, dropping\n");
else
{
evhttp_remove_header(output_headers, "Content-Type");
evhttp_add_header(output_headers, "Content-Type", buf);
}
}
/* If no Content-Type has been set and we're streaming audio, add a proper
* Content-Type for the file we're streaming. Remember DAAP streams audio
* with application/x-dmap-tagged as the Content-Type (ugh!).
*/
else if (!evhttp_find_header(output_headers, "Content-Type") && mfi->type)
{
ret = snprintf(buf, sizeof(buf), "audio/%s", mfi->type);
if ((ret < 0) || (ret >= sizeof(buf)))
DPRINTF(E_LOG, L_HTTPD, "Content-Type too large for buffer, dropping\n");
else
evhttp_add_header(output_headers, "Content-Type", buf);
}
}
st->evbuf = evbuffer_new();
if (!st->evbuf)
{
DPRINTF(E_LOG, L_HTTPD, "Could not allocate an evbuffer for streaming\n");
evhttp_clear_headers(output_headers);
evhttp_send_error(req, HTTP_SERVUNAVAIL, "Internal Server Error");
goto out_cleanup;
}
ret = evbuffer_expand(st->evbuf, STREAM_CHUNK_SIZE);
if (ret != 0)
{
DPRINTF(E_LOG, L_HTTPD, "Could not expand evbuffer for streaming\n");
evhttp_clear_headers(output_headers);
evhttp_send_error(req, HTTP_SERVUNAVAIL, "Internal Server Error");
goto out_cleanup;
}
evutil_timerclear(&tv);
event_set(&st->ev, -1, EV_TIMEOUT, stream_cb, st);
event_base_set(evbase_httpd, &st->ev);
ret = event_add(&st->ev, &tv);
if (ret < 0)
{
DPRINTF(E_LOG, L_HTTPD, "Could not add one-shot event for streaming\n");
evhttp_clear_headers(output_headers);
evhttp_send_error(req, HTTP_SERVUNAVAIL, "Internal Server Error");
goto out_cleanup;
}
st->id = mfi->id;
st->start_offset = offset;
st->stream_size = st->size;
st->req = req;
if ((offset == 0) && (end_offset == 0))
{
/* If we are not decoding, send the Content-Length. We don't do
* that if we are decoding because we can only guesstimate the
* size in this case and the error margin is unknown and variable.
*/
if (!transcode)
{
ret = snprintf(buf, sizeof(buf), "%" PRIi64, (int64_t)st->size);
if ((ret < 0) || (ret >= sizeof(buf)))
DPRINTF(E_LOG, L_HTTPD, "Content-Length too large for buffer, dropping\n");
else
evhttp_add_header(output_headers, "Content-Length", buf);
}
evhttp_send_reply_start(req, HTTP_OK, "OK");
}
else
{
if (offset > 0)
st->stream_size -= offset;
if (end_offset > 0)
st->stream_size -= (st->size - end_offset);
DPRINTF(E_DBG, L_HTTPD, "Stream request with range %" PRIi64 "-%" PRIi64 "\n", offset, end_offset);
ret = snprintf(buf, sizeof(buf), "bytes %" PRIi64 "-%" PRIi64 "/%" PRIi64,
offset, (end_offset) ? end_offset : (int64_t)st->size, (int64_t)st->size);
if ((ret < 0) || (ret >= sizeof(buf)))
DPRINTF(E_LOG, L_HTTPD, "Content-Range too large for buffer, dropping\n");
else
evhttp_add_header(output_headers, "Content-Range", buf);
ret = snprintf(buf, sizeof(buf), "%" PRIi64, ((end_offset) ? end_offset + 1 : (int64_t)st->size) - offset);
if ((ret < 0) || (ret >= sizeof(buf)))
DPRINTF(E_LOG, L_HTTPD, "Content-Length too large for buffer, dropping\n");
else
evhttp_add_header(output_headers, "Content-Length", buf);
evhttp_send_reply_start(req, 206, "Partial Content");
}
#ifdef HAVE_POSIX_FADVISE
if (!transcode)
{
/* Hint the OS */
posix_fadvise(st->fd, st->start_offset, st->stream_size, POSIX_FADV_WILLNEED);
posix_fadvise(st->fd, st->start_offset, st->stream_size, POSIX_FADV_SEQUENTIAL);
posix_fadvise(st->fd, st->start_offset, st->stream_size, POSIX_FADV_NOREUSE);
}
#endif
evcon = evhttp_request_get_connection(req);
evhttp_connection_set_closecb(evcon, stream_fail_cb, st);
DPRINTF(E_INFO, L_HTTPD, "Kicking off streaming for %s\n", mfi->path);
free_mfi(mfi, 0);
return;
out_cleanup:
if (st->evbuf)
evbuffer_free(st->evbuf);
if (st->xcode)
transcode_cleanup(st->xcode);
if (st->buf)
free(st->buf);
if (st->fd > 0)
close(st->fd);
out_free_st:
free(st);
out_free_mfi:
free_mfi(mfi, 0);
}
/* This callback gets invoked when we get any http request that doesn't match
* any other callback. Like any evhttp server callback, it has a simple job:
* it must eventually call evhttp_send_error() or evhttp_send_reply().
*/
static void send_document_cb(struct evhttp_request *req, void *arg)
{
struct evbuffer *evb = NULL;
const char *docroot = arg;
const char *uri = evhttp_request_get_uri(req);
struct evhttp_uri *decoded = NULL;
const char *path;
char *decoded_path;
char *whole_path = NULL;
size_t len;
int fd = -1;
struct stat st;
if (evhttp_request_get_command(req) != EVHTTP_REQ_GET) {
dump_request_cb(req, arg);
return;
}
printf("Got a GET request for <%s>\n", uri);
/* Decode the URI */
decoded = evhttp_uri_parse(uri);
if (!decoded) {
printf("It's not a good URI. Sending BADREQUEST\n");
evhttp_send_error(req, HTTP_BADREQUEST, 0);
return;
}
/* Let's see what path the user asked for. */
path = evhttp_uri_get_path(decoded);
if (!path) path = "/";
/* We need to decode it, to see what path the user really wanted. */
decoded_path = evhttp_uridecode(path, 0, NULL);
if (decoded_path == NULL)
goto err;
/* Don't allow any ".."s in the path, to avoid exposing stuff outside
* of the docroot. This test is both overzealous and underzealous:
* it forbids aceptable paths like "/this/one..here", but it doesn't
* do anything to prevent symlink following." */
if (strstr(decoded_path, ".."))
goto err;
len = strlen(decoded_path)+strlen(docroot)+2;
if (!(whole_path = malloc(len))) {
perror("malloc");
goto err;
}
evutil_snprintf(whole_path, len, "%s/%s", docroot, decoded_path);
if (stat(whole_path, &st)<0) {
goto err;
}
/* This holds the content we're sending. */
evb = evbuffer_new();
if (S_ISDIR(st.st_mode)) {
/* If it's a directory, read the comments and make a little
* index page */
#ifdef WIN32
HANDLE d;
WIN32_FIND_DATAA ent;
char *pattern;
size_t dirlen;
#else
DIR *d;
struct dirent *ent;
#endif
const char *trailing_slash = "";
if (!strlen(path) || path[strlen(path)-1] != '/')
trailing_slash = "/";
#ifdef WIN32
dirlen = strlen(whole_path);
pattern = malloc(dirlen+3);
memcpy(pattern, whole_path, dirlen);
pattern[dirlen] = '\\';
pattern[dirlen+1] = '*';
pattern[dirlen+2] = '\0';
d = FindFirstFileA(pattern, &ent);
free(pattern);
if (d == INVALID_HANDLE_VALUE)
goto err;
#else
if (!(d = opendir(whole_path)))
goto err;
#endif
evbuffer_add_printf(evb, "<html>\n <head>\n"
" <title>%s</title>\n"
" <base href='%s%s%s'>\n"
" </head>\n"
" <body>\n"
" <h1>%s</h1>\n"
" <ul>\n",
decoded_path, /* XXX html-escape this. */
uri_root, path, /* XXX html-escape this? */
trailing_slash,
decoded_path /* XXX html-escape this */);
#ifdef WIN32
do {
const char *name = ent.cFileName;
#else
while ((ent = readdir(d))) {
const char *name = ent->d_name;
#endif
evbuffer_add_printf(evb,
" <li><a href=\"%s\">%s</a>\n",
name, name);/* XXX escape this */
#ifdef WIN32
} while (FindNextFileA(d, &ent));
#else
}
#endif
evbuffer_add_printf(evb, "</ul></body></html>\n");
#ifdef WIN32
FindClose(d);
#else
closedir(d);
#endif
evhttp_add_header(evhttp_request_get_output_headers(req),
"Content-Type", "text/html");
} else {
/** Callback to reject HTTP requests after shutdown. */
static void http_reject_request_cb(struct evhttp_request* req, void*)
{
LogPrint(BCLog::HTTP, "Rejecting request while shutting down\n");
evhttp_send_error(req, HTTP_SERVUNAVAIL, nullptr);
}
/**
* Callback used for doc request
*/
static void doc_request_cb(struct evhttp_request *req, void *arg)
{
std::chrono::high_resolution_clock::time_point t0 = std::chrono::high_resolution_clock::now();
if (evhttp_request_get_command(req) != EVHTTP_REQ_GET)
{
std::cerr << "Invalid query request! Needs to be GET" << std::endl;
evhttp_send_error(req, HTTP_BADREQUEST, 0);
}
else
{
struct evbuffer *evb = NULL;
const char *uri = evhttp_request_get_uri(req);
struct evhttp_uri *decoded = NULL;
// const char *path = NULL;
const char *query = NULL;
printf("Got a GET request for %s\n", uri);
// Decode the URI
decoded = evhttp_uri_parse(uri);
if (!decoded)
{
printf("It's not a good URI. Sending BADREQUEST\n");
evhttp_send_error(req, HTTP_BADREQUEST, 0);
return;
}
// path = evhttp_uri_get_path(decoded);
// std::cout << path << std::endl;
query = evhttp_uri_get_query(decoded);
// std::cout << query << std::endl;
// This holds the content we're sending
evb = evbuffer_new();
struct evkeyvalq params; // create storage for your key->value pairs
struct evkeyval *param; // iterator
int result = evhttp_parse_query_str(query, ¶ms);
if (result == 0)
{
bool found = false;
for (param = params.tqh_first; param; param = param->next.tqe_next)
{
std::string key(param->key);
std::string value(param->value);
// printf("%s %s\n", key.c_str(), value.c_str());
if (key.compare(zsearch::server::DOC_ID_KEY) == 0)
{
unsigned int docId = 0;
try
{
docId = ZUtil::getUInt(value);
std::cout << "retrieving document " << value << std::endl;
std::shared_ptr<IDocument> document = make_shared<DocumentImpl>();
if (engine->getDoc(docId, document))
{
std::stringstream ss;
document->write(ss);
const std::string docStr = ss.str();
// cout << docStr << endl;
evbuffer_add(evb, docStr.data(), docStr.size());
found = true;
}
}
// TODO: consider splitting out the errors so we know if the problem is getting the docId or in the engine
catch (const std::string& e)
{
// no need to do anything here
// evbuffer_add_printf(evb, "Invalid docId\n");
// evbuffer_add_printf(evb, e.c_str());
}
break; // break out of looping through parameters
}
}
if (found)
{
evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", "text/xml");
evhttp_send_reply(req, 200, "OK", evb);
}
else
{
/*
evbuffer_add_printf(evb, "Document not found or invalid docId");
evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", "text/html");
*/
evhttp_send_error(req, 404, "Document not found.");
}
}
else
{
evhttp_send_error(req, HTTP_BADREQUEST, 0);
}
evhttp_clear_headers(¶ms);
if (decoded)
{
evhttp_uri_free(decoded);
}
if (evb)
{
evbuffer_free(evb);
}
}
std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
std::chrono::nanoseconds timeTaken = std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0);
std::cout << ZUtil::printTimeTaken(timeTaken) << std::endl;
}
void NFCHttpServer::listener_cb(struct evhttp_request* req, void* arg)
{
NFCHttpServer* pNet = (NFCHttpServer*) arg;
NFHttpRequest request;
request.req = req;
//uri
const char* uri = evhttp_request_get_uri(req);
//std::cout << "Got a GET request:" << uri << std::endl;
//get decodeUri
struct evhttp_uri* decoded = evhttp_uri_parse(uri);
if (!decoded)
{
printf("It's not a good URI. Sending BADREQUEST\n");
evhttp_send_error(req, HTTP_BADREQUEST, 0);
return;
}
const char* decode1 = evhttp_uri_get_path(decoded);
if (!decode1)
decode1 = "/";
//The returned string must be freed by the caller.
const char* decodeUri = evhttp_uridecode(decode1, 0, NULL);
if (decodeUri == NULL)
{
printf("uri decode error\n");
evhttp_send_error(req, HTTP_BADREQUEST, "uri decode error");
return;
}
std::string strUri;
if (decodeUri[0] == '/')
{
strUri = decodeUri;
strUri.erase(0, 1);
decodeUri = strUri.c_str();
}
//get strCommand
auto cmdList = Split(strUri, "/");
std::string strCommand = "";
if (cmdList.size() > 0)
{
strCommand = cmdList[0];
}
request.url = decodeUri;
// call cb
if (pNet->mRecvCB)
{
pNet->mRecvCB(request, strCommand, decodeUri);
} else
{
pNet->ResponseMsg(request, "mRecvCB empty", NFWebStatus::WEB_ERROR);
}
//close
/*{
if (decoded)
evhttp_uri_free(decoded);
if (decodeUri)
free(decodeUri);
if (eventBuffer)
evbuffer_free(eventBuffer);
}*/
}
/**
* This callback gets invoked when we get any http request that doesn't match
* any other callback. Like any evhttp server callback, it has a simple job:
* it must eventually call evhttp_send_error() or evhttp_send_reply().
*/
static void generic_request_cb(struct evhttp_request *req, void *arg)
{
std::chrono::high_resolution_clock::time_point t0 = std::chrono::high_resolution_clock::now();
// if this is not a GET request error out
if (evhttp_request_get_command(req) != EVHTTP_REQ_GET)
{
std::cerr << "Invalid request! Needs to be GET" << std::endl;
evhttp_send_error(req, HTTP_BADREQUEST, 0);
}
else
{
struct evbuffer *evb = NULL;
const char *docroot = (char *) arg;
const char *uri = evhttp_request_get_uri(req);
struct evhttp_uri *decoded = NULL;
const char *path;
char *decoded_path;
char *whole_path = NULL;
size_t len;
int fd = -1;
struct stat st;
printf("Got a GET request for %s\n", uri);
// Decode the URI
decoded = evhttp_uri_parse(uri);
if (!decoded)
{
printf("It's not a good URI. Sending BADREQUEST\n");
evhttp_send_error(req, HTTP_BADREQUEST, 0);
return;
}
// Let's see what path the user asked for
path = evhttp_uri_get_path(decoded);
if (!path)
{
path = zsearch::server::ROOT.c_str();
}
// We need to decode it, to see what path the user really wanted
decoded_path = evhttp_uridecode(path, 0, NULL);
bool error = false;
if (decoded_path == NULL)
{
error = true;
}
else
{
// This holds the content we're sending
evb = evbuffer_new();
// add headers
evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", "text/html");
if (zsearch::server::POST_HTM.compare(decoded_path) == 0)
{
len = strlen(decoded_path)+strlen(docroot)+2;
whole_path = (char *) malloc(len);
if (whole_path)
{
evutil_snprintf(whole_path, len, "%s/%s", docroot, decoded_path);
if (stat(whole_path, &st)<0)
{
error = true;
}
else
{
if ((fd = open(whole_path, O_RDONLY)) < 0)
{
perror("open");
error = true;
}
else
{
if (fstat(fd, &st)<0)
{
// Make sure the length still matches, now that we opened the file :/
perror("fstat");
error = true;
}
else
{
evbuffer_add_file(evb, fd, 0, st.st_size);
}
}
}
}
else
{
perror("malloc");
error = true;
}
}
else // if (ROOT.compare(decoded_path) == 0)
{
evbuffer_add_printf(evb, "Invalid request <br />\n");
evbuffer_add_printf(evb, "%s to post data manually or %s to post via api<br />\n", zsearch::server::POST_HTM.c_str(), zsearch::server::INDEX_PATH.c_str());
evbuffer_add_printf(evb, "%s to search <br />\n", zsearch::server::SEARCH_PATH.c_str());
evbuffer_add_printf(evb, "%s to get document by id <br />\n", zsearch::server::DOC_PATH.c_str());
}
}
if (error)
{
if (fd >= 0)
close(fd);
evhttp_send_error(req, 404, "Document not found.");
}
else
{
evhttp_send_reply(req, 200, "OK", evb);
}
if (decoded)
evhttp_uri_free(decoded);
if (decoded_path)
free(decoded_path);
if (whole_path)
free(whole_path);
if (evb)
evbuffer_free(evb);
}
std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
std::chrono::nanoseconds timeTaken = std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0);
std::cout << ZUtil::printTimeTaken(timeTaken) << std::endl;
}
/**
* Call back used for a POST request
*/
static void post_request_cb(struct evhttp_request *req, void *arg)
{
std::chrono::high_resolution_clock::time_point t0 = std::chrono::high_resolution_clock::now();
/*
bool isPostRequest = false;
const char *cmdtype = NULL;
switch (evhttp_request_get_command(req))
{
case EVHTTP_REQ_GET: cmdtype = "GET"; break;
case EVHTTP_REQ_POST: cmdtype = "POST"; isPostRequest = true; 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;
}
if (!isPostRequest)
{
evhttp_send_error(req, HTTP_BADREQUEST, 0);
}
*/
if (evhttp_request_get_command(req) != EVHTTP_REQ_POST)
{
std::cerr << "Invalid request! Needs to be POST" << std::endl;
evhttp_send_error(req, HTTP_BADREQUEST, 0);
}
else
{
struct evbuffer *evb = NULL;
struct evkeyvalq *headers;
struct evkeyval *header;
struct evbuffer *buf;
printf("Received a POST request for %s\nHeaders:\n", 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);
}
buf = evhttp_request_get_input_buffer(req);
std::string postData;
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);
postData.append(cbuf, n);
}
}
// std::cout << "Post data: " << std::endl << postData << std::endl;
// do not remove this
struct evkeyvalq params; // create storage for your key->value pairs
struct evkeyval *param; // iterator
// working code to return the parameters as plain text ...
/*
std::string postDataDecoded;
if (result == 0)
{
for (param = params.tqh_first; param; param = param->next.tqe_next)
{
printf("%s %s\n", param->key, param->value);
postDataDecoded.append(param->key);
postDataDecoded.append(" ");
postDataDecoded.append(param->value);
postDataDecoded.append("\n");
}
evb = evbuffer_new();
evbuffer_add_printf(evb, postDataDecoded.c_str());
evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", "text/html");
evhttp_send_reply(req, 200, "OK", evb);
}
else
{
evhttp_send_error(req, HTTP_BADREQUEST, 0);
}
*/
// working code to decode and index data
int result = evhttp_parse_query_str(postData.c_str(), ¶ms);
// if we were able to parse post data ok
if (result == 0)
{
param = params.tqh_first;
std::string key(param->key);
std::string value(param->value);
// std::cout << value << std::endl;
evb = evbuffer_new();
// check that the first key is data
if (key.compare(zsearch::server::POST_DATA_KEY) == 0)
{
try
{
std::shared_ptr<IDocument> document = std::make_shared<DocumentImpl>(value);
unsigned int docId = engine->addDocument(document);
std::cout << "Added document: " << docId << std::endl;
evbuffer_add_printf(evb, "%d", docId);
}
catch (const std::string& e)
{
evbuffer_add_printf(evb, "Error parsing document. See documentation for more details\n");
evbuffer_add_printf(evb, "%s", e.c_str());
}
catch (const std::exception& e)
{
evbuffer_add_printf(evb, "Error parsing document. See documentation for more details\n");
evbuffer_add_printf(evb, "%s", e.what());
}
}
else
{
evbuffer_add_printf(evb, "Invalid post data, first key must be in the form of data -> {xml}. See documentation for more details\n");
}
evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", "text/html");
evhttp_send_reply(req, 200, "OK", evb);
}
else
{
evhttp_send_error(req, HTTP_BADREQUEST, 0);
}
evhttp_clear_headers(¶ms);
if (evb)
{
evbuffer_free(evb);
}
}
std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
std::chrono::nanoseconds timeTaken = std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0);
std::cout << ZUtil::printTimeTaken(timeTaken) << std::endl;
}
/**
* Callback used for search request
*/
static void search_request_cb(struct evhttp_request *req, void *arg)
{
std::chrono::high_resolution_clock::time_point t0 = std::chrono::high_resolution_clock::now();
if (evhttp_request_get_command(req) != EVHTTP_REQ_GET)
{
// evbuffer_add_printf(evb, "Invalid query request! Needs to be GET\n");
std::cerr << "Invalid query request! Needs to be GET" << std::endl;
evhttp_send_error(req, HTTP_BADREQUEST, 0);
}
else
{
struct evbuffer *evb = NULL;
const char *uri = evhttp_request_get_uri(req);
struct evhttp_uri *decoded = NULL;
// const char *path = NULL;
const char *query = NULL;
// struct evkeyvalq *headers;
// struct evkeyval *header;
printf("Got a GET request for %s\n", uri);
// Decode the URI
decoded = evhttp_uri_parse(uri);
if (!decoded) {
printf("It's not a good URI. Sending BADREQUEST\n");
evhttp_send_error(req, HTTP_BADREQUEST, 0);
return;
}
// path = evhttp_uri_get_path(decoded);
// std::cout << path << std::endl;
query = evhttp_uri_get_query(decoded);
// std::cout << query << std::endl;
// This holds the content we're sending
evb = evbuffer_new();
/*
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);
}
*/
struct evkeyvalq params; // create storage for your key->value pairs
struct evkeyval *param; // iterator
int result = evhttp_parse_query_str(query, ¶ms);
if (result == 0)
{
std::string query;
unsigned int start = 0;
unsigned int offset = 0;
for (param = params.tqh_first; param; param = param->next.tqe_next)
{
std::string key(param->key);
std::string value(param->value);
// std::cout << key << " " << value << std::endl;
if (key.compare(zsearch::server::GET_SEARCH_QUERY_KEY) == 0)
{
query = value;
}
if (key.compare(zsearch::server::GET_SEARCH_START_KEY) == 0)
{
try
{
start = ZUtil::getUInt(value);
}
catch (const string& e)
{
// do nothing
}
}
if (key.compare(zsearch::server::GET_SEARCH_OFFSET_KEY) == 0)
{
try
{
offset = ZUtil::getUInt(value);
}
catch (const string& e)
{
// do nothing
}
}
}
std::cout << "searching for " << query << " with start " << start << " and offset " << offset << std::endl;
auto docIdSet = engine->search(query, start, offset);
if (docIdSet.size())
{
for (auto docId : docIdSet)
{
evbuffer_add_printf(evb, "%u ", docId);
}
}
evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", "text/html");
evhttp_send_reply(req, 200, "OK", evb);
}
else
{
evhttp_send_error(req, HTTP_BADREQUEST, 0);
}
evhttp_clear_headers(¶ms);
if (decoded)
{
evhttp_uri_free(decoded);
}
if (evb)
{
evbuffer_free(evb);
}
}
std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
std::chrono::nanoseconds timeTaken = std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0);
std::cout << ZUtil::printTimeTaken(timeTaken) << std::endl;
}
/** Callback to reject HTTP requests after shutdown. */
static void http_reject_request_cb(struct evhttp_request* req, void*)
{
LogPrint("http", "Rejecting request while shutting down\n");
evhttp_send_error(req, HTTP_SERVUNAVAIL, NULL);
}
//
// Function called when a new HTTP request have been recieved.
//
static void http_handler(struct evhttp_request *request, void *userdata) {
struct owl_state* state = userdata;
// Setup general response headers
struct evkeyvalq *headers = evhttp_request_get_output_headers(request);
evhttp_add_header(headers, "Server", USER_AGENT);
// Get the requested URI
const char* uri = evhttp_request_get_uri(request);
const int http_method = evhttp_request_get_command(request);
if( http_method != EVHTTP_REQ_GET &&
http_method != EVHTTP_REQ_PUT &&
http_method != EVHTTP_REQ_POST) {
evhttp_send_error(request, 501, "Not Implemented");
return;
}
TRACE("Received HTTP request: %s (method %d)\n", uri, http_method);
// Keep the request for async usage
state->http_request = request;
//
// Retrieve application state (sync)
if(string_starts_with(uri, "/api/state") && http_method == EVHTTP_REQ_GET) {
state_action(state);
}
//
// Shutdown owl application (async)
else if(string_starts_with(uri, "/api/shutdown") && http_method == EVHTTP_REQ_GET) {
shutdown_action(state);
}
//
// Try to login to Spotify (async)
else if(string_starts_with(uri, "/api/login") && http_method == EVHTTP_REQ_GET) {
char* username = extract_uri_section(2, uri);
char* password = extract_uri_section(3, uri);
if(username != NULL && password != NULL) {
login_to_spotify_action(state, username, password);
}
else {
WARN("Could not extract username and password in order to login to Spotify!\n");
respond_error(request, OWL_HTTO_ERROR_NO_LOGIN_DETAILS, "No username or password given");
}
}
else if(string_starts_with(uri, "/api/login") && http_method == EVHTTP_REQ_POST) {
TRACE("POST LOGIN\n");
get_post_argument(request, "username");
evhttp_send_error(request, 501, "Not Implemented");
}
//
// Logout from spotify (async)
else if(string_starts_with(uri, "/api/logout") && http_method == EVHTTP_REQ_GET) {
if(state->state > OWL_STATE_LOGGING_IN && state->state < OWL_STATE_LOGGING_OUT)
logout_from_spotify_action(state);
else
respond_success(request);
}
//
// Clear the entire queue
else if(string_starts_with(uri, "/api/queue/clear") && http_method == EVHTTP_REQ_GET) {
if(state->state < OWL_STATE_IDLE || state->state > OWL_STATE_PLAYING) {
respond_error(request, OWL_HTTP_ERROR_NOT_LOGGED_IN, "Operation not allowed when not logged in");
}
else {
const int size = queue_size(state->spotify_state->queue);
for(int i = 0; i < size; i++) {
owl_track *track = pop_from_queue(state->spotify_state->queue);
free_track(track);
}
respond_success(request);
}
}
//
// Get the current playback queue (sync)
else if(string_starts_with(uri, "/api/queue") && http_method == EVHTTP_REQ_GET) {
if(state->state < OWL_STATE_IDLE || state->state > OWL_STATE_PLAYING) {
WARN("Operation not allowed at this state (%d)\n", state->state);
respond_error(request, OWL_HTTP_ERROR_NOT_LOGGED_IN, "Operation not allowed when not logged in");
}
else {
respond_with_queue(state->http_request, state->spotify_state->queue);
}
}
//
// Serve static file immediately
else {
// Create the buffer to retrn as content
struct evbuffer *content_buffer = evbuffer_new();
// If not a handler this is a static request
char *static_file = (char *) malloc(strlen(doc_root) + strlen(uri) + 1);
stpcpy(stpcpy(static_file, doc_root), uri);
TRACE("Looking for static file: %s\n", static_file);
bool file_exists = 1;
struct stat st;
if(stat(static_file, &st) == -1 || S_ISDIR(st.st_mode)) {
file_exists = 0;
evhttp_send_error(request, HTTP_NOTFOUND, "Not Found");
}
if(file_exists) {
const int file_size = st.st_size;
FILE *fp = fopen(static_file, "r");
const char* content_type = resolve_content_type(static_file);
evbuffer_add_file(content_buffer, fileno(fp), 0, file_size); // will close
TRACE("Resolving content type for filename: %s to: %s\n", static_file, content_type);
evhttp_add_header(headers, "Content-Type", content_type);
evhttp_send_reply(request, HTTP_OK, "OK", content_buffer);
}
free(static_file);
// Send the data
evhttp_send_reply(request, HTTP_OK, USER_AGENT, content_buffer);
// Free memrory
evbuffer_free(content_buffer);
}
return;
}
