static char *
path_escape(char *path)
{
size_t pathlen = strlen(path);
char *dedup, *ret;
char *src, *dst;
ret = malloc(pathlen * 4 + 1);
if (!ret)
return ret;
/* remove duplicate slashes */
dst = dedup = ret + pathlen * 3;
for (src = path; *src; ++src) {
if (src[0] != '/' || (src[1] && src[1] != '/'))
*dst++ = *src;
}
*dst = '\0';
/* root directory special case */
if (*dedup == '\0')
return strcpy(ret, "-");
dst = ret;
src = dedup;
if (*src == '/')
++src;
if (*src == '.')
dst = hex_escape(dst, *src++);
while (*src) {
if (*src == '/')
*dst++ = '-';
else if (!safe_unit_char(*src))
dst = hex_escape(dst, *src);
else
*dst++ = *src;
++src;
}
*dst = '\0';
return ret;
}
static void
print_node_info(struct gnutella_shell *sh, const struct gnutella_node *n)
{
gnet_node_flags_t flags;
time_delta_t up, con;
char buf[1024];
char vendor_escaped[50];
char uptime_buf[8];
char contime_buf[8];
g_return_if_fail(sh);
g_return_if_fail(n);
if (!node_fill_flags(NODE_ID(n), &flags))
return;
con = n->connect_date ? delta_time(tm_time(), n->connect_date) : 0;
up = n->up_date ? delta_time(tm_time(), n->up_date) : 0;
{
const char *vendor;
char *escaped;
vendor = node_vendor(n);
escaped = hex_escape(vendor, TRUE);
clamp_strcpy(vendor_escaped, sizeof vendor_escaped, escaped);
if (escaped != vendor) {
HFREE_NULL(escaped);
}
}
clamp_strcpy(uptime_buf, sizeof uptime_buf,
up > 0 ? compact_time(up) : "?");
clamp_strcpy(contime_buf, sizeof contime_buf,
con > 0 ? compact_time(con) : "?");
gm_snprintf(buf, sizeof buf,
"%-21.45s %5.1u %s %2.2s %6.6s %6.6s %.50s",
node_addr(n),
(unsigned) n->gnet_port,
node_flags_to_string(&flags),
iso3166_country_cc(n->country),
contime_buf,
uptime_buf,
vendor_escaped);
shell_write(sh, buf);
shell_write(sh, "\n"); /* Terminate line */
}
/**
* Do an actual search.
*
* @param table table containing organized entries to search from
* @param search_term the query string
* @param callback routine to invoke for each match
* @param ctx user-supplied data to pass on to callback
* @param max_res maximum amount of results to return
* @param qhv query hash vector built from query string, for routing
*
* @return number of hits we produced
*/
G_GNUC_HOT int
st_search(
search_table_t *table,
const char *search_term,
st_search_callback callback,
gpointer ctx,
int max_res,
query_hashvec_t *qhv)
{
char *search;
int key, nres = 0;
guint i, len;
struct st_bin *best_bin = NULL;
int best_bin_size = INT_MAX;
word_vec_t *wovec;
guint wocnt;
cpattern_t **pattern;
struct st_entry **vals;
guint vcnt;
int scanned = 0; /* measure search mask efficiency */
guint32 search_mask;
size_t minlen;
guint random_offset; /* Randomizer for search returns */
search = UNICODE_CANONIZE(search_term);
if (GNET_PROPERTY(query_debug) > 4 && 0 != strcmp(search, search_term)) {
char *safe_search = hex_escape(search, FALSE);
char *safe_search_term = hex_escape(search_term, FALSE);
g_debug("original search term: \"%s\"", safe_search_term);
g_debug("canonical search term: \"%s\"", safe_search);
if (safe_search != search)
HFREE_NULL(safe_search);
if (safe_search_term != search_term)
HFREE_NULL(safe_search_term);
}
len = strlen(search);
/*
* Find smallest bin
*/
if (len >= 2) {
for (i = 0; i < len - 1; i++) {
struct st_bin *bin;
if (is_ascii_space(search[i]) || is_ascii_space(search[i+1]))
continue;
key = st_key(table, search + i);
if ((bin = table->bins[key]) == NULL) {
best_bin = NULL;
break;
}
if (bin->nvals < best_bin_size) {
best_bin = bin;
best_bin_size = bin->nvals;
}
}
if (GNET_PROPERTY(matching_debug) > 4)
g_debug("MATCH st_search(): str=\"%s\", len=%d, best_bin_size=%d",
lazy_safe_search(search_term), len, best_bin_size);
}
/*
* If the best_bin is NULL, we did not find a matching bin, and we're
* sure we won't be able to find the search string.
*
* Note that on search strings like "r e m ", we always have a letter
* followed by spaces, so we won't search that.
* --RAM, 06/10/2001
*/
if (best_bin == NULL) {
/*
* If we have a `qhv', we need to compute the word vector anway,
* for query routing...
*/
if (qhv == NULL)
goto finish;
}
/*
* Prepare matching patterns
*/
wocnt = word_vec_make(search, &wovec);
/*
* Compute the query hashing information for query routing, if needed.
*/
if (qhv != NULL) {
for (i = 0; i < wocnt; i++) {
if (wovec[i].len >= QRP_MIN_WORD_LENGTH)
qhvec_add(qhv, wovec[i].word, QUERY_H_WORD);
}
}
if (wocnt == 0 || best_bin == NULL) {
if (wocnt > 0)
word_vec_free(wovec, wocnt);
goto finish;
}
g_assert(best_bin_size > 0); /* Allocated bin, it must hold something */
pattern = walloc0(wocnt * sizeof *pattern);
/*
* Prepare matching optimization, an idea from Mike Green.
*
* At library building time, we computed a mask hash, made from the
* lowercased file name, using one bit per different letter, roughly
* (see mask_hash() for the exact algorigthm).
*
* We're now going to compute the same mask on the query, and compare
* it bitwise with the mask for each file. If the file does not hold
* at least all the chars present in the query, it's no use applying
* the pattern matching algorithm, it won't match at all.
*
* --RAM, 01/10/2001
*/
search_mask = mask_hash(search);
/*
* Prepare second matching optimization: since all words in the query
* must match the exact amount of time, we can compute the minimum length
* the searched file must have. We add one character after each word
* but the last, to account for space between words.
* --RAM, 11/07/2002
*/
for (minlen = 0, i = 0; i < wocnt; i++)
minlen += wovec[i].len + 1;
minlen--;
g_assert(minlen <= INT_MAX);
/*
* Search through the smallest bin
*/
vcnt = best_bin->nvals;
vals = best_bin->vals;
random_offset = random_u32() % vcnt;
nres = 0;
for (i = 0; i < vcnt; i++) {
const struct st_entry *e;
shared_file_t *sf;
size_t canonic_len;
/*
* As we only return a limited count of results, pick a random
* offset, so that repeated searches will match different items
* instead of always the first - with some probability.
*/
e = vals[(i + random_offset) % vcnt];
if ((e->mask & search_mask) != search_mask)
continue; /* Can't match */
sf = e->sf;
canonic_len = shared_file_name_canonic_len(sf);
if (canonic_len < minlen)
continue; /* Can't match */
scanned++;
if (entry_match(e->string, canonic_len, pattern, wovec, wocnt)) {
if (GNET_PROPERTY(matching_debug) > 4) {
g_debug("MATCH \"%s\" matches %s",
search, shared_file_name_nfc(sf));
}
if ((*callback)(ctx, sf)) {
nres++;
if (nres >= max_res)
break;
}
}
}
if (GNET_PROPERTY(matching_debug) > 3)
g_debug("MATCH st_search(): scanned %d entr%s from the %d in bin, "
"got %d match%s",
scanned, 1 == scanned ? "y" : "ies",
best_bin_size, nres, 1 == nres ? "" : "es");
for (i = 0; i < wocnt; i++)
if (pattern[i]) /* Lazily compiled by entry_match() */
pattern_free(pattern[i]);
wfree(pattern, wocnt * sizeof *pattern);
word_vec_free(wovec, wocnt);
finish:
if (search != search_term) {
HFREE_NULL(search);
}
return nres;
}
