static struct ccn_charbuf *
collect_stats_xml(struct ccnd_handle *h)
{
struct ccnd_stats stats = {0};
struct ccn_charbuf *b = ccn_charbuf_create();
int i;
ccnd_collect_stats(h, &stats);
ccn_charbuf_putf(b,
"<ccnd>"
"<identity>"
"<ccndid>");
for (i = 0; i < sizeof(h->ccnd_id); i++)
ccn_charbuf_putf(b, "%02X", h->ccnd_id[i]);
ccn_charbuf_putf(b, "</ccndid>"
"<apiversion>%d</apiversion>"
"<starttime>%ld.%06u</starttime>"
"<now>%ld.%06u</now>"
"</identity>",
(int)CCN_API_VERSION,
h->starttime, h->starttime_usec,
h->sec,
h->usec);
ccn_charbuf_putf(b,
"<cobs>"
"<accessioned>%llu</accessioned>"
"<stored>%d</stored>"
"<stale>%lu</stale>"
"<sparse>%d</sparse>"
"<duplicate>%lu</duplicate>"
"<sent>%lu</sent>"
"</cobs>"
"<interests>"
"<names>%d</names>"
"<pending>%ld</pending>"
"<propagating>%ld</propagating>"
"<noted>%ld</noted>"
"<accepted>%lu</accepted>"
"<dropped>%lu</dropped>"
"<sent>%lu</sent>"
"<stuffed>%lu</stuffed>"
"</interests>",
(unsigned long long)h->accession,
hashtb_n(h->content_tab),
h->n_stale,
hashtb_n(h->sparse_straggler_tab),
h->content_dups_recvd,
h->content_items_sent,
hashtb_n(h->nameprefix_tab), stats.total_interest_counts,
hashtb_n(h->interest_tab) - stats.total_flood_control,
stats.total_flood_control,
h->interests_accepted, h->interests_dropped,
h->interests_sent, h->interests_stuffed);
collect_faces_xml(h, b);
collect_forwarding_xml(h, b);
ccn_charbuf_putf(b, "</ccnd>" NL);
return(b);
}
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_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
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);
}
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);
}
int
get_number_of_next_hop(char *dest_router)
{
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;
}
else if(res == HT_NEW_ENTRY)
{
hashtb_delete(e);
ret=NO_NEXT_HOP;
}
hashtb_end(e);
return ret;
}
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
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);
}
// 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);
}
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;
}
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);
}
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);
}
int
get_mapping_no(char *router)
{
struct map_entry *me;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
int res;
int ret;
int n = hashtb_n(nlsr->map);
if ( n < 1)
{
return NO_MAPPING_NUM;
}
hashtb_start(nlsr->map, e);
res = hashtb_seek(e, router, strlen(router), 0);
if( res == HT_OLD_ENTRY )
{
me=e->data;
ret=me->mapping;
}
else if(res == HT_NEW_ENTRY)
{
hashtb_delete(e);
ret=NO_MAPPING_NUM;
}
hashtb_end(e);
return ret;
}
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_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);
}
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;
}
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");
}
static struct ccn_charbuf *
collect_stats_html(struct ccnd_handle *h)
{
struct ccnd_stats stats = {0};
struct ccn_charbuf *b = ccn_charbuf_create();
int pid;
struct utsname un;
const char *portstr;
portstr = getenv(CCN_LOCAL_PORT_ENVNAME);
if (portstr == NULL || portstr[0] == 0 || strlen(portstr) > 10)
portstr = CCN_DEFAULT_UNICAST_PORT;
uname(&un);
pid = getpid();
ccnd_collect_stats(h, &stats);
ccn_charbuf_putf(b,
"<html xmlns='http://www.w3.org/1999/xhtml'>"
"<head>"
"<title>%s ccnd[%d]</title>"
//"<meta http-equiv='refresh' content='3'>"
"<style type='text/css'>"
"/*<![CDATA[*/"
"p.header {color: white; background-color: blue; width: 100%%} "
"table.tbl {border-style: solid; border-width: 1.0px 1.0px 1.0px 1.0px; border-color: black} "
"td {border-style: solid; "
"border-width: 1.0px 1.0px 1.0px 1.0px; "
"border-color: #808080 #808080 #808080 #808080; "
"padding: 6px 6px 6px 6px; "
"margin-left: auto; margin-right: auto; "
"text-align: center"
"} "
"td.left {text-align: left} "
"/*]]>*/"
"</style>"
"</head>" NL
"<body bgcolor='#%06X'>"
"<p class='header'>%s ccnd[%d] local port %s api %d start %ld.%06u now %ld.%06u</p>" NL
"<div><b>Content items:</b> %llu accessioned,"
" %d stored, %lu stale, %d sparse, %lu duplicate, %lu sent</div>" NL
"<div><b>Interests:</b> %d names,"
" %ld pending, %ld propagating, %ld noted</div>" NL
"<div><b>Interest totals:</b> %lu accepted,"
" %lu dropped, %lu sent, %lu stuffed</div>" NL,
un.nodename,
pid,
ccnd_colorhash(h),
un.nodename,
pid,
portstr,
(int)CCN_API_VERSION,
h->starttime, h->starttime_usec,
h->sec,
h->usec,
(unsigned long long)h->accession,
hashtb_n(h->content_tab),
h->n_stale,
hashtb_n(h->sparse_straggler_tab),
h->content_dups_recvd,
h->content_items_sent,
hashtb_n(h->nameprefix_tab), stats.total_interest_counts,
hashtb_n(h->interest_tab) - stats.total_flood_control,
stats.total_flood_control,
h->interests_accepted, h->interests_dropped,
h->interests_sent, h->interests_stuffed);
if (0)
ccn_charbuf_putf(b,
"<div><b>Active faces and listeners:</b> %d</div>" NL,
hashtb_n(h->faces_by_fd) + hashtb_n(h->dgram_faces));
collect_faces_html(h, b);
collect_face_meter_html(h, b);
collect_forwarding_html(h, b);
ccn_charbuf_putf(b,
"</body>"
"</html>" NL);
return(b);
}
int main(int argc, char *argv[])
{
const char *progname = argv[0];
struct ccn_ping_client client = {.sent = 0, .received = 0, .total = -1, .number = -1, .interval = 1};
struct ccn_closure in_content = {.p = &incoming_content};
struct hashtb_param param = {0};
int res;
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = &handle_interrupt;
sigaction(SIGINT, &sa, &osa);
memset(&sta, 0, sizeof(sta));
gettimeofday(&sta.start, 0);
sta.min = INT_MAX;
while ((res = getopt(argc, argv, "hi:c:n:")) != -1) {
switch (res) {
case 'c':
client.total = atol(optarg);
if (client.total <= 0)
usage(progname);
break;
case 'i':
client.interval = atof(optarg);
if (client.interval < PING_MIN_INTERVAL)
usage(progname);
break;
case 'n':
client.number = atol(optarg);
if (client.number < 0)
usage(progname);
break;
case 'h':
default:
usage(progname);
break;
}
}
if (client.number < 0)
srandom(time(NULL));
argc -= optind;
argv += optind;
if (argv[0] == NULL)
usage(progname);
sta.prefix = argv[0];
client.original_prefix = argv[0];
client.prefix = ccn_charbuf_create();
res = ccn_name_from_uri(client.prefix, argv[0]);
if (res < 0) {
fprintf(stderr, "%s: bad ccn URI: %s\n", progname, argv[0]);
exit(1);
}
if (argv[1] != NULL)
fprintf(stderr, "%s warning: extra arguments ignored\n", progname);
//append "/ping" to the given name prefix
res = ccn_name_append_str(client.prefix, PING_COMPONENT);
if (res < 0) {
fprintf(stderr, "%s: error constructing ccn URI: %s/%s\n", progname, argv[0], PING_COMPONENT);
exit(1);
}
/* Connect to ccnd */
client.h = ccn_create();
if (ccn_connect(client.h, NULL) == -1) {
perror("Could not connect to ccnd");
exit(1);
}
client.closure = &in_content;
in_content.data = &client;
client.ccn_ping_table = hashtb_create(sizeof(struct ccn_ping_entry), ¶m);
client.sched = ccn_schedule_create(&client, &ccn_ping_ticker);
client.event = ccn_schedule_event(client.sched, 0, &do_ping, NULL, 0);
printf("CCNPING %s\n", client.original_prefix);
res = 0;
while (res >= 0 && (client.total <= 0 || client.sent < client.total || hashtb_n(client.ccn_ping_table) > 0))
{
if (client.total <= 0 || client.sent < client.total)
ccn_schedule_run(client.sched);
res = ccn_run(client.h, 10);
}
ccn_schedule_destroy(&client.sched);
ccn_destroy(&client.h);
ccn_charbuf_destroy(&client.prefix);
print_statistics();
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);
}
