void rule_free(struct s_rule * rule)
{
if(rule->coverage)
avl_free_tree(rule->coverage);
if(rule->rule)
free(rule->rule);
free(rule);
}
int
daap_query_init(void)
{
avl_node_t *node;
struct dmap_query_field_map *dqfm;
int i;
dmap_query_fields_hash = avl_alloc_tree(dmap_query_field_map_compare, NULL);
if (!dmap_query_fields_hash)
{
DPRINTF(E_FATAL, L_DAAP, "DAAP query init could not allocate AVL tree\n");
return -1;
}
for (i = 0; dmap_query_fields[i].hash == 0; i++)
{
dmap_query_fields[i].hash = djb_hash(dmap_query_fields[i].dmap_field, strlen(dmap_query_fields[i].dmap_field));
node = avl_insert(dmap_query_fields_hash, &dmap_query_fields[i]);
if (!node)
{
if (errno != EEXIST)
DPRINTF(E_FATAL, L_DAAP, "DAAP query init failed; AVL insert error: %s\n", strerror(errno));
else
{
node = avl_search(dmap_query_fields_hash, &dmap_query_fields[i]);
dqfm = node->item;
DPRINTF(E_FATAL, L_DAAP, "DAAP query init failed; WARNING: duplicate hash key\n");
DPRINTF(E_FATAL, L_DAAP, "Hash %x, string %s\n", dmap_query_fields[i].hash, dmap_query_fields[i].dmap_field);
DPRINTF(E_FATAL, L_DAAP, "Hash %x, string %s\n", dqfm->hash, dqfm->dmap_field);
}
goto avl_insert_fail;
}
}
return 0;
avl_insert_fail:
avl_free_tree(dmap_query_fields_hash);
return -1;
}
int main() {
avl_tree* t = avl_new_tree(&cmp);
int* A = malloc(N*sizeof(int));
int i;
for (i = 0; i < N; i++) {
A[i] = i+1;
avl_insert(t, A+i);
//avl_preorder(t, &print_int);
//printf("\n");
}
for (i = 0; i < N; i++) {
avl_remove(t, A+i);
//avl_preorder(t, &print_int);
//printf("\n");
}
avl_free_tree(t);
free(A);
return 0;
}
int main(int argc, char ** argv)
{
unsigned int i;
pthread_t * threads;
unsigned int * ids;
double maxval;
double curval;
struct s_rule_link * root;
struct s_rule_link * prevlink;
struct s_rule_link * curlink;
struct s_rule_link * tmplink;
struct s_rule_link * maxlink;
int maxrulelen = 500;
avl_tree_t * oldcoverage;
avl_node_t * scoverage;
avl_node_t * scoverage2;
BLOOM_TYPE * bloom;
uint64_t curindex;
uint64_t nbleft;
double wordlistProcessingTime, candidateProcessingTime;
char * endptr;
setlimits();
if(argc<6)
usage();
matchlimit = atoi(argv[1]);
if(matchlimit == 0)
usage();
nbthreads = atoi(argv[2]);
if(nbthreads == 0)
nbthreads = 1;
wordlistProcessingTime = strtod(argv[3], &endptr);
// weak check
if(endptr == argv[3])
{
fprintf(stderr, "Could not parse wordlistProcessingTime\n");
usage();
}
candidateProcessingTime = strtod(argv[4], &endptr);
if(endptr == argv[4])
{
fprintf(stderr, "Could not parse candidateProcessingTime: %s\n", argv[4]);
usage();
}
fprintf(stderr, "Wordlist processing time: %es / Candidate processing time: %es/candidate\n", wordlistProcessingTime, candidateProcessingTime);
nbfiles = argc-5;
threads = xmalloc(sizeof(pthread_t)*nbthreads);
memset(threads, 0, sizeof(pthread_t)*nbthreads);
ids = xmalloc(sizeof(unsigned int)*nbthreads);
rulejob = xmalloc(sizeof(struct s_rulejob)*nbfiles);
bloom = xmalloc(BLOOM_STORAGE);
for(i=0;i<nbfiles;i++)
{
rulejob[i].root = NULL;
rulejob[i].tail = NULL;
rulejob[i].done_by = -1;
rulejob[i].filename = argv[i+5];
}
for(i=0;i<nbthreads;i++)
{
ids[i] = i;
if(pthread_create(&threads[i], NULL, load_rules, &ids[i]))
{
fprintf(stderr, "error, could not create thread for file %s\n", argv[i+4]);
perror("pthread_create");
return 1;
}
}
for(i=0;i<nbthreads;i++)
pthread_join( threads[i], NULL );
root = NULL;
for(i=0;i<nbfiles;i++)
{
if(rulejob[i].tail == NULL)
continue;
rulejob[i].tail->next = root;
root = rulejob[i].root;
}
free(rulejob);
fprintf(stderr, "start crunching\n");
oldcoverage = NULL;
while(1)
{
maxval = 0;
curlink = root;
prevlink = NULL;
maxlink = NULL;
nbleft = 0;
while(curlink)
{
if(curlink->coverage == NULL)
curval = 1e50;
else
{
if(oldcoverage)
{
/* coverage cleanup */
scoverage = curlink->coverage->head;
while(scoverage)
{
curindex = (uint64_t) scoverage->item;
if(GETBIT(bloom, curindex) && avl_search(oldcoverage, (void *) curindex))
{
scoverage2 = scoverage->next;
avl_delete_node(curlink->coverage, scoverage);
scoverage = scoverage2;
}
else
{
nbleft++;
scoverage = scoverage->next;
}
}
}
curval = ((double) avl_count(curlink->coverage)) / ( ((double) curlink->pwtested )*candidateProcessingTime + wordlistProcessingTime) ;
}
if( (curlink->coverage == NULL) || (avl_count(curlink->coverage) <matchlimit))
{
if(curlink->rule)
{
free(curlink->rule);
}
if(curlink->coverage)
{
avl_free_tree(curlink->coverage);
}
if(prevlink)
prevlink->next = curlink->next;
else
root = curlink->next;
tmplink = curlink;
curlink = curlink->next;
free(tmplink);
continue;
}
if(curval>maxval || (curval == maxval && strlen(curlink->rule) < maxrulelen ) )
{
maxrulelen = strlen(curlink->rule);
maxval = curval;
maxlink = curlink;
}
prevlink = curlink;
curlink = curlink->next;
}
if(maxlink == NULL)
break;
if(oldcoverage)
avl_free_tree(oldcoverage);
oldcoverage = maxlink->coverage;
/* build bloom filter */
memset(bloom, 0, BLOOM_STORAGE);
scoverage = oldcoverage->head;
while(scoverage)
{
//pcurindex = scoverage->item;
//curindex = *pcurindex;
curindex = (uint64_t) scoverage->item;
SETBIT(bloom, curindex);
scoverage = scoverage->next;
}
maxlink->coverage = NULL;
printf("%s NBPWD=%d [%f]\n", maxlink->rule, avl_count(oldcoverage), maxval);
fprintf(stderr, "%s NBPWD=%d [%f] NBRULES=%ld\n", maxlink->rule, avl_count(oldcoverage), maxval, nbleft);
}
return 0;
}
void flx_bbl_destroy(void){
uint16_t i;
for(i=0; i<NUM_BBL_TREES; ++i){
avl_free_tree(bbl_trees[i]);
}
}
void
daap_query_deinit(void)
{
avl_free_tree(dmap_query_fields_hash);
}
