static void*
handle_suggest(enum mg_event event,
struct mg_connection *conn,
const struct mg_request_info *request_info) {
++nreq;
if (building) {
print_HTTP_response(conn, 412, "Busy");
return (void*)"";
}
std::string q = get_qs(request_info, "q");
std::string sn = get_qs(request_info, "n");
std::string cb = get_qs(request_info, "callback");
std::string type = get_qs(request_info, "type");
DCERR("handle_suggest::q:"<<q<<", sn:"<<sn<<", callback: "<<cb<<endl);
unsigned int n = sn.empty() ? NMAX : atoi(sn.c_str());
if (n > NMAX) {
n = NMAX;
}
const bool has_cb = !cb.empty();
if (has_cb && !is_valid_cb(cb)) {
print_HTTP_response(conn, 400, "Invalid Request");
return (void*)"";
}
print_HTTP_response(conn, 200, "OK");
str_lowercase(q);
vp_t results = suggest(pm, st, q, n);
/*
for (size_t i = 0; i < results.size(); ++i) {
mg_printf(conn, "%s:%d\n", results[i].first.c_str(), results[i].second);
}
*/
if (has_cb) {
mg_printf(conn, "%s(%s);\n", cb.c_str(), results_json(q, results, type).c_str());
}
else {
mg_printf(conn, "%s\n", results_json(q, results, type).c_str());
}
return (void*)"";
}
static void handle_suggest(client_t *client, parsed_url_t &url) {
++nreq;
std::string body;
headers_t headers;
headers["Cache-Control"] = "no-cache";
if (building) {
write_response(client, 412, "Busy", headers, body);
return;
}
std::string q = unescape_query(url.query["q"]);
std::string sn = url.query["n"];
std::string cb = unescape_query(url.query["callback"]);
std::string type = unescape_query(url.query["type"]);
DCERR("handle_suggest::q:"<<q<<", sn:"<<sn<<", callback: "<<cb<<endl);
unsigned int n = sn.empty() ? NMAX : atoi(sn.c_str());
if (n > NMAX) {
n = NMAX;
}
if (n < 1) {
n = 1;
}
const bool has_cb = !cb.empty();
str_lowercase(q);
vp_t results = suggest(pm, st, q, n);
/*
for (size_t i = 0; i < results.size(); ++i) {
mg_printf(conn, "%s:%d\n", results[i].first.c_str(), results[i].second);
}
*/
headers["Content-Type"] = "text/plain; charset=UTF-8";
if (has_cb) {
body = cb + "(" + results_json(q, results, type) + ");\n";
}
else {
body = results_json(q, results, type) + "\n";
}
write_response(client, 200, "OK", headers, body);
}
/* Returns a pointer to a dynamically allocated structure whose
value can be used to tell whether two files are actually the
same file. Returns a null pointer if no information about the
file is available, perhaps because it does not exist. The
caller is responsible for freeing the structure with
fn_free_identity() when finished. */
struct file_identity *
fn_get_identity (const char *file_name)
{
struct file_identity *identity = xmalloc (sizeof *identity);
#if !(defined _WIN32 || defined __WIN32__)
struct stat s;
if (lstat (file_name, &s) == 0)
{
identity->device = s.st_dev;
identity->inode = s.st_ino;
identity->name = NULL;
}
else
{
char *dir = dir_name (file_name);
if (last_component (file_name) != NULL && stat (dir, &s) == 0)
{
identity->device = s.st_dev;
identity->inode = s.st_ino;
identity->name = base_name (file_name);
}
else
{
identity->device = 0;
identity->inode = 0;
identity->name = xstrdup (file_name);
}
free (dir);
}
#else /* Windows */
char cname[PATH_MAX];
int ok = GetFullPathName (file_name, sizeof cname, cname, NULL);
identity->device = 0;
identity->inode = 0;
identity->name = xstrdup (ok ? cname : file_name);
str_lowercase (identity->name);
#endif /* Windows */
return identity;
}
/*
* For an ascii string denoting a plist command, return its code and
* optionally its argument(s)
*/
int
plist_cmd(const char *s, char **arg)
{
char cmd[FILENAME_MAX + 20]; /* 20 == fudge for max cmd len */
char *cp;
const char *sp;
strcpy(cmd, s);
str_lowercase(cmd);
cp = cmd;
sp = s;
while (*cp) {
if (isspace(*cp)) {
*cp = '\0';
while (isspace(*sp)) /* Never sure if macro, increment later */
++sp;
break;
}
++cp, ++sp;
}
if (arg)
*arg = (char *)sp;
if (!strcmp(cmd, "cwd"))
return PLIST_CWD;
else if (!strcmp(cmd, "srcdir"))
return PLIST_SRC;
else if (!strcmp(cmd, "cd"))
return PLIST_CWD;
else if (!strcmp(cmd, "exec"))
return PLIST_CMD;
else if (!strcmp(cmd, "unexec"))
return PLIST_UNEXEC;
else if (!strcmp(cmd, "mode"))
return PLIST_CHMOD;
else if (!strcmp(cmd, "owner"))
return PLIST_CHOWN;
else if (!strcmp(cmd, "group"))
return PLIST_CHGRP;
else if (!strcmp(cmd, "noinst"))
return PLIST_NOINST;
else if (!strcmp(cmd, "comment")) {
if (!strncmp(*arg, "ORIGIN:", 7)) {
*arg += 7;
return PLIST_ORIGIN;
} else if (!strncmp(*arg, "DEPORIGIN:", 10)) {
*arg += 10;
return PLIST_DEPORIGIN;
}
return PLIST_COMMENT;
} else if (!strcmp(cmd, "ignore"))
return PLIST_IGNORE;
else if (!strcmp(cmd, "ignore_inst"))
return PLIST_IGNORE_INST;
else if (!strcmp(cmd, "name"))
return PLIST_NAME;
else if (!strcmp(cmd, "display"))
return PLIST_DISPLAY;
else if (!strcmp(cmd, "pkgdep"))
return PLIST_PKGDEP;
else if (!strcmp(cmd, "conflicts"))
return PLIST_CONFLICTS;
else if (!strcmp(cmd, "mtree"))
return PLIST_MTREE;
else if (!strcmp(cmd, "dirrm"))
return PLIST_DIR_RM;
else if (!strcmp(cmd, "option"))
return PLIST_OPTION;
else
return FAIL;
}
int
do_import(std::string file, int sorted, uint_t limit,
int &rnadded, int &rnlines) {
#if defined USE_CXX_IO
std::ifstream fin(file.c_str());
#else
FILE *fin = fopen(file.c_str(), "r");
#endif
int fd = open(file.c_str(), O_RDONLY);
// Potential race condition + not checking for return value
if_length = file_size(file.c_str());
DCERR("handle_import::file:"<<file<<endl);
if (!fin || !fd) {
return -IMPORT_FILE_NOT_FOUND;
}
else {
building = true;
int nlines = 0;
int foffset = 0;
if (if_mmap_addr) {
munmap(if_mmap_addr, if_length);
}
// mmap() the input file in
if_mmap_addr = (char*)mmap(NULL, if_length, PROT_READ, MAP_SHARED, fd, 0);
if (!if_mmap_addr) {
fclose(fin);
close(fd);
return -IMPORT_FILE_NOT_FOUND;
}
pm.repr.clear();
char buff[INPUT_LINE_SIZE];
while (
#if defined USE_CXX_IO
fin
#else
!feof(fin)
#endif
&& limit--) {
buff[0] = '\0';
#if defined USE_CXX_IO
fin.getline(buff, INPUT_LINE_SIZE);
const int llen = fin.gcount();
buff[INPUT_LINE_SIZE - 1] = '\0';
#else
char *got = fgets(buff, INPUT_LINE_SIZE, fin);
if (!got) {
break;
}
const int llen = strlen(buff);
if (llen && buff[llen-1] == '\n') {
buff[llen-1] = '\0';
}
#endif
++nlines;
int weight = 0;
std::string phrase;
StringProxy snippet;
InputLineParser(if_mmap_addr, foffset, buff, &weight, &phrase, &snippet).start_parsing();
foffset += llen;
if (!phrase.empty()) {
str_lowercase(phrase);
DCERR("Adding: "<<weight<<", "<<phrase<<", "<<std::string(snippet)<<endl);
pm.insert(weight, phrase, snippet);
}
}
fclose(fin);
pm.finalize(sorted);
vui_t weights;
for (size_t i = 0; i < pm.repr.size(); ++i) {
weights.push_back(pm.repr[i].weight);
}
st.initialize(weights);
rnadded = weights.size();
rnlines = nlines;
building = false;
}
return 0;
}
int
do_import(std::string file, uint_t limit,
int &rnadded, int &rnlines) {
bool is_input_sorted = true;
#if defined USE_CXX_IO
std::ifstream fin(file.c_str());
#else
FILE *fin = fopen(file.c_str(), "r");
#endif
int fd = open(file.c_str(), O_RDONLY);
DCERR("handle_import::file:" << file << "[fin: " << (!!fin) << ", fd: " << fd << "]" << endl);
if (!fin || fd == -1) {
perror("fopen");
return -IMPORT_FILE_NOT_FOUND;
}
else {
building = true;
int nlines = 0;
int foffset = 0;
if (if_mmap_addr) {
int r = munmap(if_mmap_addr, if_length);
if (r < 0) {
perror("munmap");
building = false;
return -IMPORT_MUNMAP_FAILED;
}
}
// Potential race condition + not checking for return value
if_length = file_size(file.c_str());
// mmap() the input file in
if_mmap_addr = (char*)mmap(NULL, if_length, PROT_READ, MAP_SHARED, fd, 0);
if (if_mmap_addr == MAP_FAILED) {
fprintf(stderr, "length: %llu, fd: %d\n", if_length, fd);
perror("mmap");
if (fin) { fclose(fin); }
if (fd != -1) { close(fd); }
building = false;
return -IMPORT_MMAP_FAILED;
}
pm.repr.clear();
char buff[INPUT_LINE_SIZE];
std::string prev_phrase;
while (!is_EOF(fin) && limit--) {
buff[0] = '\0';
int llen = -1;
get_line(fin, buff, INPUT_LINE_SIZE, llen);
if (llen == -1) {
break;
}
++nlines;
int weight = 0;
std::string phrase;
StringProxy snippet;
InputLineParser(if_mmap_addr, foffset, buff, &weight, &phrase, &snippet).start_parsing();
foffset += llen;
if (!phrase.empty()) {
str_lowercase(phrase);
DCERR("Adding: " << weight << ", " << phrase << ", " << std::string(snippet) << endl);
pm.insert(weight, phrase, snippet);
}
if (is_input_sorted && prev_phrase <= phrase) {
prev_phrase.swap(phrase);
} else if (is_input_sorted) {
is_input_sorted = false;
}
}
DCERR("Creating PhraseMap::Input is " << (!is_input_sorted ? "NOT " : "") << "sorted\n");
fclose(fin);
pm.finalize(is_input_sorted);
vui_t weights;
for (size_t i = 0; i < pm.repr.size(); ++i) {
weights.push_back(pm.repr[i].weight);
}
st.initialize(weights);
rnadded = weights.size();
rnlines = nlines;
building = false;
}
return 0;
}