static void new_indexnode_event (
const void *ctxt,
const char *host,
const char *port,
const char *fs2protocol,
const char *id
)
{
indexnodes_t *ins = (indexnodes_t *)ctxt;
indexnode_t *found_in, *new_in = NULL;
const char *version;
if (!parse_fs2protocol(fs2protocol, &version))
{
trace_info("Seen advert for indexnode %s at %s:%s (version %s)\n", id, host, port, version);
if ((found_in = indexnodes_list_find(CALLER_INFO ins->list, id)))
{
indexnode_seen(found_in);
indexnode_delete(CALLER_INFO found_in);
}
else
{
new_in = indexnode_new(CALLER_INFO host, port, version, id);
if (new_in)
{
rw_lock_wlock(ins->lock);
/* If it's not been seen before, add it */
indexnodes_list_add(ins->list, new_in);
rw_lock_wunlock(ins->lock);
}
else
{
free_const(version);
}
}
}
else
{
free_const(fs2protocol);
}
if (!new_in)
{
free_const(host); free_const(port); free_const(id);
}
}
void query_recommender::merge_recommended_queries(std::multimap<double,std::string,std::less<double> > &related_queries,
hash_map<const char*,double,hash<const char*>,eqstr> &update)
{
hash_map<const char*,double,hash<const char*>,eqstr>::iterator hit;
std::multimap<double,std::string,std::less<double> >::iterator mit
= related_queries.begin();
while(mit!=related_queries.end())
{
std::string rquery = (*mit).second;
if ((hit = update.find(rquery.c_str()))!=update.end())
{
(*hit).second = std::min((*mit).first,(*hit).second);
std::multimap<double,std::string,std::less<double> >::iterator mit2 = mit;
++mit;
related_queries.erase(mit2);
}
else ++mit;
}
hit = update.begin();
hash_map<const char*,double,hash<const char*>,eqstr>::iterator chit;
while(hit!=update.end())
{
related_queries.insert(std::pair<double,std::string>((*hit).second,std::string((*hit).first)));
chit = hit;
++hit;
free_const((*chit).first);
}
}
/* free map. */
void miscutil::free_map(hash_map<const char*,const char*,hash<const char*>,eqstr> *&the_map)
{
hash_map<const char*,const char*,hash<const char*>,eqstr>::iterator mit
= the_map->begin();
while (mit!=the_map->end())
{
const char *key = (*mit).first;
const char *value = (*mit).second;
hash_map<const char*,const char*,hash<const char*>,eqstr>::iterator mitc = mit;
++mit;
the_map->erase(mitc);
free_const(key);
if (value)
free_const(value);
}
delete the_map;
the_map = NULL;
}
stopwordlist::~stopwordlist()
{
hash_map<const char*,bool,hash<const char*>,eqstr>::iterator hit, hit2;
hit = _swlist.begin();
while (hit!=_swlist.end())
{
hit2 = hit;
++hit;
const char *key = (*hit2).first;
_swlist.erase(hit2);
free_const(key);
}
}
void miscutil::list_remove_all(std::list<const char*> *the_list)
{
assert(the_list);
std::list<const char*>::iterator lit = the_list->begin();
while (lit!=the_list->end())
{
if ((*lit))
free_const((*lit));
std::list<const char*>::iterator c**t = lit;
++lit;
the_list->erase(c**t);
}
the_list->clear();
}
http_response::~http_response()
{
if (this != &cgi::_cgi_error_memory_response)
{
freez(_status);
freez(_head);
freez(_body);
std::list<const char*>::iterator lit = _headers.begin();
while (lit!=_headers.end())
{
const char *head = (*lit);
lit = _headers.erase(lit);
free_const(head);
}
}
_head_length = 0;
}
static void
free_request_element(struct hbac_request_element *el,
bool free_group_ptrs)
{
size_t i;
if (el == NULL) {
return;
}
if (el->groups != NULL && free_group_ptrs) {
for (i=0; el->groups[i]; i++) {
free_const(el->groups[i]);
}
}
free(el->groups);
free(el);
}
int miscutil::list_remove_item(std::list<const char*> *the_list, const char *str)
{
assert(the_list);
int count = 0;
std::list<const char*>::iterator lit = the_list->begin();
while (lit!=the_list->end())
{
if ((*lit) && strcmp((*lit),str)==0)
{
free_const((*lit));
std::list<const char*>::iterator c**t = lit;
++lit;
the_list->erase(c**t);
count++;
}
else ++lit;
}
return count;
}
static int parse_fs2protocol (const char *fs2protocol, const char **version)
{
int rc = 1;
const char *prefix = "fs2protocol-";
const size_t prefix_len = strlen(prefix);
if (!strncmp(fs2protocol, prefix, prefix_len))
{
char *v = malloc((strlen(fs2protocol) - prefix_len + 1) * sizeof(char));
assert(sscanf(fs2protocol, "fs2protocol-%s", v) == 1);
*version = v;
rc = 0;
}
free_const(fs2protocol);
return rc;
}
void se_parser_yahoo::start_element(parser_context *pc,
const xmlChar *name,
const xmlChar **attributes)
{
const char *tag = (const char*)name;
if (strcasecmp(tag,"div") == 0)
{
const char *a_id = se_parser::get_attribute((const char**)attributes,"id");
const char *a_class = se_parser::get_attribute((const char**)attributes,"class");
if (!_start_results && a_id && strcasecmp(a_id,"web") == 0)
_start_results = true;
else if (_begin_results && a_class && (strcasecmp(a_class,"abstr") == 0
|| strcasecmp(a_class,"sm-abs") == 0))
_summary_flag = true;
else if (_begin_results && a_class && strncasecmp(a_class,"res",3) == 0)
{
// check on previous snippet, if any.
if (pc->_current_snippet)
{
post_process_snippet(pc->_current_snippet);
if (pc->_current_snippet)
{
//pc->_snippets->push_back(pc->_current_snippet);
pc->_current_snippet = NULL;
}
else pc->_snippets->pop_back();
}
// create new snippet.
search_snippet *sp = new search_snippet(_count++);
sp->_engine |= std::bitset<NSEs>(SE_YAHOO);
pc->_current_snippet = sp;
pc->_snippets->push_back(pc->_current_snippet);
}
}
else if (_start_results && strcasecmp(tag,"ol") == 0)
{
_begin_results = true;
}
else if (_begin_results && strcasecmp(tag,"h3") == 0)
{
_title_flag = true;
}
else if (strcasecmp(tag,"a") == 0)
{
const char *a_link = se_parser::get_attribute((const char**)attributes,"href");
if (a_link)
{
if (_title_flag && pc->_current_snippet)
{
std::string url_str = std::string(a_link);
size_t pos = 0;
if ((pos = url_str.find("rds.yahoo.com"))!=std::string::npos
|| (pos = url_str.find("search.yahoo.com"))!=std::string::npos)
if ((pos = url_str.find("/**",pos))!=std::string::npos)
{
try
{
url_str = url_str.substr(pos+3);
}
catch (std::exception &e)
{
// do nothing for now.
}
}
const char *url_dec_str = encode::url_decode(url_str.c_str());
url_str = std::string(url_dec_str);
free_const(url_dec_str);
pc->_current_snippet->set_url(url_str);
pc->_current_snippet->set_cite(url_str);
}
else if (_begin_results && pc->_current_snippet)
pc->_current_snippet->_cached = std::string(a_link);
}
}
}
