void
make_map(void)
{
int i, adj_lsdb_element;
struct alsa *adj_lsa;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
hashtb_start(nlsr->lsdb->adj_lsdb, e);
adj_lsdb_element=hashtb_n(nlsr->lsdb->adj_lsdb);
add_map_entry(nlsr->router_name);
for(i=0;i<adj_lsdb_element;i++)
{
adj_lsa=e->data;
add_adj_data_to_map(adj_lsa->header->orig_router->name,adj_lsa->body,adj_lsa->no_link);
hashtb_next(e);
}
hashtb_end(e);
}
void output_statistics(struct hashtb* stats, const char * filename) {
struct hashtb_enumerator ee;
struct hashtb_enumerator* hte = ⅇ
struct stats_entry * entry = NULL;
FILE* output = NULL;
output = fopen(filename, "w");
if (output == NULL) {
fprintf(stderr, "Could not output stats to file %s.\n", filename);
return;
}
fprintf(output, "Content \"Total Requests\" \"Satisfied Requests\"\n");
hashtb_start(stats, hte);
for (; hte->data != NULL; hashtb_next(hte)) {
entry = (struct stats_entry *) hte->data;
if (entry->name == NULL) {
continue;
}
if (strlen(entry->name) >= 5
&& (strncmp(entry->name, "/ccnx", 5) == 0)) {
continue;
}
if (strlen(entry->name) >= 1 && entry->name[0] != '/') {
continue;
}
if (strstr(entry->name, "KEY") != NULL) {
continue;
}
fprintf(output, "%s %lu %lu\n", entry->name, entry->num_req, entry->sat_req);
}
hashtb_end(hte);
fclose(output);
}
void
print_all_next_hop(long int *parent,long int source)
{
int i, map_element;
struct map_entry *me;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
hashtb_start(nlsr->map, e);
map_element=hashtb_n(nlsr->map);
for(i=0;i<map_element;i++)
{
me=e->data;
if(me->mapping != source)
{
if ( nlsr->debugging )
printf("Dest: %d Next Hop: %ld\n",me->mapping,get_next_hop_from_calculation(parent,me->mapping,source));
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"Dest: %d Next Hop: %ld\n",me->mapping,get_next_hop_from_calculation(parent,me->mapping,source));
}
hashtb_next(e);
}
hashtb_end(e);
}
void
destroy_keys(void)
{
int i, key_element;
struct nlsr_key *key;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
hashtb_start(nlsr->keys, e);
key_element=hashtb_n(nlsr->keys);
for(i=0;i<key_element;i++)
{
key=e->data;
free(key->key_name);
hashtb_next(e);
}
hashtb_end(e);
if( nlsr->keys )
hashtb_destroy(&nlsr->keys);
}
// TODO deferred cleaning
void hash_store_clean(struct hash_store* self) {
struct hashtb_enumerator ee; struct hashtb_enumerator* e = ⅇ
hashtb_start(self->btree->resident, e);
int overquota = 0;
if (self->btree->nodepool >= 16) overquota = hashtb_n(self->btree->resident) - self->btree->nodepool;
for (struct ndn_btree_node* node = e->data; node != NULL; node = e->data) {
if (overquota > 0 && node->activity == 0 && node->iodata == NULL && node->clean == node->buf->length) {
--overquota;
hashtb_delete(e);
continue;
}
//node->activity /= 2;
node->activity = 0;
if (node->clean != node->buf->length || (node->iodata != NULL && node->activity == 0)) {
int res = ndn_btree_chknode(node);
if (res < 0) continue;
if (node->clean != node->buf->length) {
res = self->btree->io->btwrite(self->btree->io, node);
if (res < 0) continue;
node->clean = node->buf->length;
}
if (node->iodata != NULL && node->activity == 0) {
res = ndn_btree_close_node(self->btree, node);
}
}
hashtb_next(e);
}
hashtb_end(e);
}
void
clear_old_routing_table(void)
{
if ( nlsr->debugging )
printf("clear_old_routing_table called\n");
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"clear_old_routing_table called\n");
int i,rt_element;
struct routing_table_entry *rte;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
hashtb_start(nlsr->routing_table, e);
rt_element=hashtb_n(nlsr->routing_table);
for(i=0;i<rt_element;i++)
{
rte=e->data;
hashtb_destroy(&rte->face_list);
struct hashtb_param param_fle = {0};
rte->face_list=hashtb_create(sizeof(struct face_list_entry), ¶m_fle);
hashtb_next(e);
}
hashtb_end(e);
}
void
make_adj_matrix(int **adj_matrix,int map_element)
{
init_adj_matrix(adj_matrix,map_element);
int i, adj_lsdb_element;
struct alsa *adj_lsa;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
hashtb_start(nlsr->lsdb->adj_lsdb, e);
adj_lsdb_element=hashtb_n(nlsr->lsdb->adj_lsdb);
for(i=0;i<adj_lsdb_element;i++)
{
adj_lsa=e->data;
assign_adj_matrix_for_lsa(adj_lsa,adj_matrix);
hashtb_next(e);
}
hashtb_end(e);
}
void
print_name_prefix_from_npl(void)
{
if ( nlsr->debugging )
printf("print_name_prefix_from_npl called \n");
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"print_name_prefix_from_npl called\n");
int i, npl_element;
//struct name_prefix *np;
struct name_prefix_list_entry *npe;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
hashtb_start(nlsr->npl, e);
npl_element=hashtb_n(nlsr->npl);
for(i=0;i<npl_element;i++)
{
npe=e->data;
if ( nlsr->debugging )
printf("Name Prefix: %s and Length: %d and LSA Id: %ld\n",npe->np->name,npe->np->length,npe->name_lsa_id);
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"Name Prefix: %s and Length: %d \n",npe->np->name,npe->np->length);
hashtb_next(e);
}
hashtb_end(e);
if ( nlsr->debugging )
printf("\n");
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"\n");
}
void
print_keys(void){
if ( nlsr->debugging )
printf("print_keys called \n");
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"print_keys called \n");
int i, key_element;
struct nlsr_key *key;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
hashtb_start(nlsr->keys, e);
key_element=hashtb_n(nlsr->keys);
for(i=0;i<key_element;i++)
{
key=e->data;
if ( nlsr->debugging )
printf("Key : %s \n",key->key_name);
hashtb_next(e);
}
hashtb_end(e);
}
void
update_routing_table_with_new_route(long int *parent, long int *dist,long int source)
{
if ( nlsr->debugging )
printf("update_routing_table_with_new_route called\n");
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"update_routing_table_with_new_route called\n");
int i, map_element;
struct map_entry *me;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
hashtb_start(nlsr->rev_map, e);
map_element=hashtb_n(nlsr->rev_map);
for(i=0;i<map_element;i++)
{
me=e->data;
if(me->mapping != source)
{
char *orig_router=get_router_from_rev_map(me->mapping);
if (orig_router != NULL )
{
int next_hop_router_num=get_next_hop_from_calculation(parent,me->mapping,source);
if ( next_hop_router_num == NO_NEXT_HOP )
{
if ( nlsr->debugging )
printf ("Orig_router: %s Next Hop Face: %d \n",orig_router,NO_FACE);
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"Orig_router: %s Next Hop Face: %d \n",orig_router,NO_FACE);
}
else
{
char *next_hop_router=get_router_from_rev_map(next_hop_router_num);
int next_hop_face=get_next_hop_face_from_adl(next_hop_router);
update_routing_table(orig_router,next_hop_face,dist[me->mapping]);
if ( nlsr->debugging )
printf ("Orig_router: %s Next Hop Face: %d \n",orig_router,next_hop_face);
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"Orig_router: %s Next Hop Face: %d \n",orig_router,next_hop_face);
}
}
}
hashtb_next(e);
}
hashtb_end(e);
}
static int
ccnd_collect_stats(struct ccnd_handle *h, struct ccnd_stats *ans)
{
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
long sum;
unsigned i;
for (sum = 0, hashtb_start(h->nameprefix_tab, e);
e->data != NULL; hashtb_next(e)) {
struct nameprefix_entry *npe = e->data;
struct ielinks *head = &npe->ie_head;
struct ielinks *ll;
ccnd_msg(h, "================= before inner for: head = %d, npt = %d, head->next = %d", head, npe, head->next);
for (ll = head->next; ll != head; ll = ll->next) {
//Shen Li: as ll is the first element in interest_entry, so &ll == &ie
struct interest_entry *ie = (struct interest_entry *)ll;
struct pit_face_item *p;
ccnd_msg(h, "=============== before inner inner for: ie->pfl = %d", ie->pfl);
for (p = ie->pfl; p != NULL; p = p->next){
ccnd_msg(h, "============ p = %d", p);
ccnd_msg(h, "============ ie->interest_msg = %d, ie->size = %d", ie->interest_msg, ie->size);
print_msg(ie->interest_msg, ie->size, 200);
ccnd_msg(h, "========== p->pfi_flags = %d, p->faceid = %d, p->next = %d", p->pfi_flags, p->faceid, p->next);
if ((p->pfi_flags & CCND_PFI_PENDING) != 0){
ccnd_msg(h, "============= in first if");
if (ccnd_face_from_faceid(h, p->faceid) != NULL){
ccnd_msg(h, "=============== in second if");
sum += 1;
}
}
ccnd_msg(h, "========== p->pfi_flags, p->faceid, p->next", p->pfi_flags, p->faceid, p->next);
}
ccnd_msg(h, "=============== after inner inner for: ie->pfl = %d", ie->pfl);
}
ccnd_msg(h, "================= after inner for: head = %d, npt = %d, head->next = %d", head, npe, head->next);
}
ans->total_interest_counts = sum;
hashtb_end(e);
ans->total_flood_control = 0; /* N/A */
/* Do a consistency check on pending interest counts */
for (sum = 0, i = 0; i < h->face_limit; i++) {
struct face *face = h->faces_by_faceid[i];
if (face != NULL)
sum += face->pending_interests;
}
if (sum != ans->total_interest_counts)
ccnd_msg(h, "ccnd_collect_stats found inconsistency %ld != %ld\n",
(long)sum, (long)ans->total_interest_counts);
ans->total_interest_counts = sum;
return(0);
}
int
get_next_hop(char *dest_router,int *faces, int *route_costs)
{
struct routing_table_entry *rte;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
int res,ret;
hashtb_start(nlsr->routing_table, e);
res = hashtb_seek(e, dest_router, strlen(dest_router), 0);
if( res == HT_OLD_ENTRY )
{
rte=e->data;
ret=hashtb_n(rte->face_list);
//nhl=rte->face_list;
int j,face_list_element;
struct face_list_entry *fle;
struct hashtb_enumerator eef;
struct hashtb_enumerator *ef = &eef;
hashtb_start(rte->face_list, ef);
face_list_element=hashtb_n(rte->face_list);
for(j=0;j<face_list_element;j++)
{
fle=ef->data;
//printf(" Face: %d Route_Cost: %d \n",fle->next_hop_face,fle->route_cost);
faces[j]=fle->next_hop_face;
route_costs[j]=fle->route_cost;
hashtb_next(ef);
}
hashtb_end(ef);
}
else if(res == HT_NEW_ENTRY)
{
hashtb_delete(e);
ret=NO_NEXT_HOP;
}
hashtb_end(e);
return ret;
}
static void
collect_forwarding_xml(struct ccnd_handle *h, struct ccn_charbuf *b)
{
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
struct ccn_forwarding *f;
int res;
struct ccn_charbuf *name = ccn_charbuf_create();
ccn_charbuf_putf(b, "<forwarding>");
hashtb_start(h->nameprefix_tab, e);
for (; e->data != NULL; hashtb_next(e)) {
struct nameprefix_entry *ipe = e->data;
for (f = ipe->forwarding, res = 0; f != NULL && !res; f = f->next) {
if ((f->flags & (CCN_FORW_ACTIVE | CCN_FORW_PFXO)) != 0)
res = 1;
}
if (res) {
ccn_name_init(name);
ccn_name_append_components(name, e->key, 0, e->keysize);
ccn_charbuf_putf(b, "<fentry>");
ccn_charbuf_putf(b, "<prefix>");
ccn_uri_append(b, name->buf, name->length, 1);
ccn_charbuf_putf(b, "</prefix>");
for (f = ipe->forwarding; f != NULL; f = f->next) {
if ((f->flags & (CCN_FORW_ACTIVE | CCN_FORW_PFXO)) != 0) {
ccn_charbuf_putf(b,
"<dest>"
"<faceid>%u</faceid>"
"<flags>%x</flags>"
"<expires>%d</expires>"
"</dest>",
f->faceid,
f->flags & CCN_FORW_PUBMASK,
f->expires);
}
}
ccn_charbuf_putf(b, "</fentry>");
}
}
hashtb_end(e);
ccn_charbuf_destroy(&name);
ccn_charbuf_putf(b, "</forwarding>");
}
static void
collect_forwarding_html(struct ccnd_handle *h, struct ccn_charbuf *b)
{
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
struct ccn_forwarding *f;
int res;
struct ccn_charbuf *name = ccn_charbuf_create();
ccn_charbuf_putf(b, "<h4>Forwarding</h4>" NL);
ccn_charbuf_putf(b, "<ul>");
hashtb_start(h->nameprefix_tab, e);
for (; e->data != NULL; hashtb_next(e)) {
struct nameprefix_entry *ipe = e->data;
ccn_name_init(name);
res = ccn_name_append_components(name, e->key, 0, e->keysize);
if (res < 0)
abort();
if (0) {
ccn_charbuf_putf(b, " <li>");
ccn_uri_append(b, name->buf, name->length, 1);
ccn_charbuf_putf(b, "</li>" NL);
}
for (f = ipe->forwarding; f != NULL; f = f->next) {
if ((f->flags & (CCN_FORW_ACTIVE | CCN_FORW_PFXO)) != 0) {
ccn_name_init(name);
ccn_name_append_components(name, e->key, 0, e->keysize);
ccn_charbuf_putf(b, " <li>");
ccn_uri_append(b, name->buf, name->length, 1);
ccn_charbuf_putf(b,
" <b>face:</b> %u"
" <b>flags:</b> 0x%x"
" <b>expires:</b> %d",
f->faceid,
f->flags & CCN_FORW_PUBMASK,
f->expires);
ccn_charbuf_putf(b, "</li>" NL);
}
}
}
hashtb_end(e);
ccn_charbuf_destroy(&name);
ccn_charbuf_putf(b, "</ul>");
}
void
do_old_routing_table_updates(void)
{
if ( nlsr->debugging )
printf("do_old_routing_table_updates called\n");
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"do_old_routing_table_updates called\n");
int i, rt_element;
int mapping_no;
struct routing_table_entry *rte;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
hashtb_start(nlsr->routing_table, e);
rt_element=hashtb_n(nlsr->routing_table);
for(i=0;i<rt_element;i++)
{
rte=e->data;
mapping_no=get_mapping_no(rte->dest_router);
if ( mapping_no == NO_MAPPING_NUM)
{
delete_orig_router_from_npt(rte->dest_router);
/*
char *router=(char *)malloc(strlen(rte->dest_router)+1);
memset(router,0,strlen(rte->dest_router)+1);
memcpy(router,rte->dest_router,strlen(rte->dest_router)+1);
nlsr->event = ccn_schedule_event(nlsr->sched, 1, &delete_empty_rte, (void *)router , 0);
*/
destroy_routing_table_entry_comp(rte);
hashtb_delete(e);
i++;
}
else
{
hashtb_next(e);
}
}
hashtb_end(e);
}
void
destroy_rev_map(void)
{
int i, map_element;
struct map_entry *me;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
hashtb_start(nlsr->rev_map, e);
map_element=hashtb_n(nlsr->rev_map);
for(i=0;i<map_element;i++)
{
me=e->data;
free(me->router);
hashtb_next(e);
}
hashtb_end(e);
}
void
destroy_routing_table(void)
{
int i, rt_element;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
struct routing_table_entry *rte;
hashtb_start(nlsr->routing_table, e);
rt_element=hashtb_n(nlsr->routing_table);
for(i=0;i<rt_element;i++)
{
rte=e->data;
free(rte->dest_router);
hashtb_destroy(&rte->face_list);
hashtb_next(e);
}
hashtb_end(e);
hashtb_destroy(&nlsr->routing_table);
}
void
assign_mapping_number(void)
{
int i, map_element;
struct map_entry *me;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
hashtb_start(nlsr->map, e);
map_element=hashtb_n(nlsr->map);
for(i=0;i<map_element;i++)
{
me=e->data;
me->mapping=i;
add_rev_map_entry(i,me->router);
hashtb_next(e);
}
hashtb_end(e);
}
void
print_all_path_from_source(long int *parent,long int source)
{
int i, map_element;
struct map_entry *me;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
hashtb_start(nlsr->map, e);
map_element=hashtb_n(nlsr->map);
if ( source != NO_MAPPING_NUM)
{
for(i=0;i<map_element;i++)
{
me=e->data;
if(me->mapping != source)
{
if ( nlsr->debugging )
{
print_path(parent,(long int)me->mapping);
printf("\n");
}
if ( nlsr->detailed_logging )
{
print_path(parent,(long int)me->mapping);
writeLogg(__FILE__,__FUNCTION__,__LINE__,"\n");
}
}
hashtb_next(e);
}
}
hashtb_end(e);
}
void
print_rev_map(void)
{
int i, map_element;
struct map_entry *me;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
hashtb_start(nlsr->map, e);
map_element=hashtb_n(nlsr->map);
for(i=0;i<map_element;i++)
{
me=e->data;
if ( nlsr->debugging )
printf("Mapping Number: %d Router: %s \n",me->mapping,me->router);
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"Mapping Number: %d Router: %s \n",me->mapping,me->router);
hashtb_next(e);
}
hashtb_end(e);
}
void
destroy_npl(void)
{
int i, npl_element;
struct name_prefix_list_entry *npe;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
hashtb_start(nlsr->npl, e);
npl_element=hashtb_n(nlsr->npl);
for(i=0;i<npl_element;i++)
{
npe=e->data;
destroy_npl_entry_component(npe);
hashtb_next(e);
}
hashtb_end(e);
if ( nlsr->npl)
hashtb_destroy(&nlsr->npl);
}
void
print_routing_table(void)
{
if ( nlsr->debugging )
printf("print_routing_table called\n");
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"print_routing_table called\n");
int i,j, rt_element,face_list_element;
struct routing_table_entry *rte;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
hashtb_start(nlsr->routing_table, e);
rt_element=hashtb_n(nlsr->routing_table);
for(i=0;i<rt_element;i++)
{
if ( nlsr->debugging )
printf("----------Routing Table Entry %d------------------\n",i+1);
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"----------Routing Table Entry %d------------------\n",i+1);
rte=e->data;
if ( nlsr->debugging )
printf(" Destination Router: %s \n",rte->dest_router);
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__," Destination Router: %s \n",rte->dest_router);
//rte->next_hop_face == NO_NEXT_HOP ? printf(" Next Hop Face: NO_NEXT_HOP \n") : printf(" Next Hop Face: %d \n", rte->next_hop_face);
struct face_list_entry *fle;
struct hashtb_enumerator eef;
struct hashtb_enumerator *ef = &eef;
hashtb_start(rte->face_list, ef);
face_list_element=hashtb_n(rte->face_list);
if ( face_list_element <= 0 )
{
if ( nlsr->debugging )
printf(" Face: No Face \n");
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__," Face: No Face \n");
}
else
{
for(j=0;j<face_list_element;j++)
{
fle=ef->data;
if ( nlsr->debugging )
printf(" Face: %d Route_Cost: %f \n",fle->next_hop_face,fle->route_cost);
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__," Face: %d Route_Cost: %d \n",fle->next_hop_face,fle->route_cost);
hashtb_next(ef);
}
}
hashtb_end(ef);
hashtb_next(e);
}
hashtb_end(e);
if ( nlsr->debugging )
printf("\n");
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"\n");
}
int
route_calculate(struct ccn_schedule *sched, void *clienth, struct ccn_scheduled_event *ev, int flags)
{
if(flags == CCN_SCHEDULE_CANCEL)
{
return -1;
}
nlsr_lock();
if ( nlsr->debugging )
printf("route_calculate called\n");
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"route_calculate called\n");
if( ! nlsr->is_build_adj_lsa_sheduled )
{
/* Calculate Route here */
print_routing_table();
print_npt();
//struct hashtb_param param_me = {0};
nlsr->map = hashtb_create(sizeof(struct map_entry), NULL);
nlsr->rev_map = hashtb_create(sizeof(struct map_entry), NULL);
make_map();
assign_mapping_number();
print_map();
print_rev_map();
do_old_routing_table_updates();
clear_old_routing_table();
print_routing_table();
print_npt();
int i;
int **adj_matrix;
int map_element=hashtb_n(nlsr->map);
adj_matrix=malloc(map_element * sizeof(int *));
for(i = 0; i < map_element; i++)
{
adj_matrix[i] = malloc(map_element * sizeof(int));
}
make_adj_matrix(adj_matrix,map_element);
if ( nlsr->debugging )
print_adj_matrix(adj_matrix,map_element);
long int source=get_mapping_no(nlsr->router_name);
int num_link=get_no_link_from_adj_matrix(adj_matrix, map_element ,source);
if ( nlsr->is_hyperbolic_calc == 1)
{
long int *links=(long int *)malloc(num_link*sizeof(long int));
long int *link_costs=(long int *)malloc(num_link*sizeof(long int));
get_links_from_adj_matrix(adj_matrix, map_element , links, link_costs, source);
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
for (hashtb_start(nlsr->rev_map, e); e->key != NULL; hashtb_next(e))
{
struct map_entry *me=e->data;
if ( me->mapping != source )
{
long int *faces=(long int *)calloc(num_link,sizeof(long int));
double *nbr_dist=(double *)calloc(num_link,sizeof(double));
double *nbr_to_dest=(double *)calloc(num_link,sizeof(double));
for ( i=0 ; i < num_link; i++)
{
int face=get_next_hop_face_from_adl(get_router_from_rev_map(links[i]));
double dist_to_nbr=get_hyperbolic_distance(source,links[i]);
double dist_to_dest_from_nbr=get_hyperbolic_distance(links[i],me->mapping);
faces[i]=face;
nbr_dist[i]=dist_to_nbr;
nbr_to_dest[i]= dist_to_dest_from_nbr;
}
sort_hyperbolic_route(nbr_to_dest,nbr_dist, faces,0,num_link);
if (nlsr->max_faces_per_prefix == 0 )
{
for ( i=0 ; i < num_link; i++)
{
update_routing_table_with_new_hyperbolic_route(me->mapping,faces[i],nbr_to_dest[i]);
}
}
else if ( nlsr->max_faces_per_prefix > 0 )
{
if ( num_link <= nlsr->max_faces_per_prefix )
{
for ( i=0 ; i < num_link; i++)
{
update_routing_table_with_new_hyperbolic_route(me->mapping,faces[i],nbr_to_dest[i]);
}
}
else if (num_link > nlsr->max_faces_per_prefix)
{
for ( i=0 ; i < nlsr->max_faces_per_prefix; i++)
{
update_routing_table_with_new_hyperbolic_route(me->mapping,faces[i],nbr_to_dest[i]);
}
}
}
free(faces);
free(nbr_dist);
free(nbr_to_dest);
}
}
hashtb_end(e);
free(links);
free(link_costs);
}
else if (nlsr->is_hyperbolic_calc == 0 )
{
long int *parent=(long int *)malloc(map_element * sizeof(long int));
long int *dist=(long int *)malloc(map_element * sizeof(long int));
if ( (num_link == 0) || (nlsr->max_faces_per_prefix == 1 ) )
{
calculate_path(adj_matrix,parent,dist, map_element, source);
print_all_path_from_source(parent,source);
print_all_next_hop(parent,source);
update_routing_table_with_new_route(parent, dist,source);
}
else if ( (num_link != 0) && (nlsr->max_faces_per_prefix == 0 || nlsr->max_faces_per_prefix > 1 ) )
{
long int *links=(long int *)malloc(num_link*sizeof(long int));
long int *link_costs=(long int *)malloc(num_link*sizeof(long int));
get_links_from_adj_matrix(adj_matrix, map_element , links, link_costs, source);
for ( i=0 ; i < num_link; i++)
{
adjust_adj_matrix(adj_matrix, map_element,source,links[i],link_costs[i]);
calculate_path(adj_matrix,parent,dist, map_element, source);
print_all_path_from_source(parent,source);
print_all_next_hop(parent,source);
update_routing_table_with_new_route(parent, dist,source);
}
free(links);
free(link_costs);
}
free(parent);
free(dist);
}
print_routing_table();
print_npt();
update_npt_with_new_route();
print_routing_table();
print_npt();
for(i = 0; i < map_element; i++)
{
free(adj_matrix[i]);
}
free(adj_matrix);
destroy_map();
destroy_rev_map();
//hashtb_destroy(&nlsr->map);
//hashtb_destroy(&nlsr->rev_map);
}
nlsr->is_route_calculation_scheduled=0;
nlsr_unlock();
return 0;
}
static int
r_store_index_cleaner(struct ccn_schedule *sched,
void *clienth,
struct ccn_scheduled_event *ev,
int flags)
{
struct ccnr_handle *h = clienth;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
struct ccn_btree_node *node = NULL;
int k;
int res;
int overquota;
(void)(sched);
(void)(ev);
if ((flags & CCN_SCHEDULE_CANCEL) != 0 ||
h->btree == NULL || h->btree->io == NULL) {
h->index_cleaner = NULL;
ccn_indexbuf_destroy(&h->toclean);
return(0);
}
/* First, work on cleaning the things we already know need cleaning */
if (h->toclean != NULL) {
for (k = 0; k < CCN_BT_CLEAN_BATCH && h->toclean->n > 0; k++) {
node = ccn_btree_rnode(h->btree, h->toclean->buf[--h->toclean->n]);
if (node != NULL && node->iodata != NULL) {
res = ccn_btree_chknode(node); /* paranoia */
if (res < 0 || CCNSHOULDLOG(h, sdfsdffd, CCNL_FINER))
ccnr_msg(h, "write index node %u (err %d)",
(unsigned)node->nodeid, node->corrupt);
if (res >= 0) {
if (node->clean != node->buf->length)
res = h->btree->io->btwrite(h->btree->io, node);
if (res < 0)
ccnr_msg(h, "failed to write index node %u",
(unsigned)node->nodeid);
else
node->clean = node->buf->length;
}
if (res >= 0 && node->iodata != NULL && node->activity == 0) {
if (CCNSHOULDLOG(h, sdfsdffd, CCNL_FINER))
ccnr_msg(h, "close index node %u",
(unsigned)node->nodeid);
res = ccn_btree_close_node(h->btree, node);
}
}
}
if (h->toclean->n > 0)
return(nrand48(h->seed) % (2U * CCN_BT_CLEAN_TICK_MICROS) + 500);
}
/* Sweep though and find the nodes that still need cleaning */
overquota = 0;
if (h->btree->nodepool >= 16)
overquota = hashtb_n(h->btree->resident) - h->btree->nodepool;
hashtb_start(h->btree->resident, e);
for (node = e->data; node != NULL; node = e->data) {
if (overquota > 0 &&
node->activity == 0 &&
node->iodata == NULL &&
node->clean == node->buf->length) {
overquota -= 1;
if (CCNSHOULDLOG(h, sdfsdffd, CCNL_FINEST))
ccnr_msg(h, "prune index node %u",
(unsigned)node->nodeid);
hashtb_delete(e);
continue;
}
node->activity /= 2; /* Age the node's activity */
if (node->clean != node->buf->length ||
(node->iodata != NULL && node->activity == 0)) {
if (h->toclean == NULL) {
h->toclean = ccn_indexbuf_create();
if (h->toclean == NULL)
break;
}
ccn_indexbuf_append_element(h->toclean, node->nodeid);
}
hashtb_next(e);
}
hashtb_end(e);
/* If nothing to do, shut down cleaner */
if ((h->toclean == NULL || h->toclean->n == 0) && overquota <= 0 &&
h->btree->io->openfds <= CCN_BT_OPEN_NODES_IDLE) {
h->btree->cleanreq = 0;
h->index_cleaner = NULL;
ccn_indexbuf_destroy(&h->toclean);
if (CCNSHOULDLOG(h, sdfsdffd, CCNL_FINE))
ccnr_msg(h, "index btree nodes all clean");
return(0);
}
return(nrand48(h->seed) % (2U * CCN_BT_CLEAN_TICK_MICROS) + 500);
}
