SentPkts SentPkts_ctor(int capacity, int retryCount) {
SentPkts self = ALLOCSELF;
self->capacity = capacity;
self->index = hashtb_create(sizeof(SentPktRec), NULL);
self->retryCount = retryCount;
return self;
}
int main(int argc, char* argv[]) {
struct dirent **namelist;
int n;
struct hashtb* stats = NULL;
char filename[512];
stats = hashtb_create(sizeof(struct stats_entry), NULL);
n = scandir(".", &namelist, &selector, alphasort);
if (n < 0)
perror("scandir");
else {
while (n--) {
sprintf(filename, "%s/stats.csv", namelist[n]->d_name);
read_stats(stats, filename);
free(namelist[n]);
}
free(namelist);
}
output_statistics(stats, "combined.csv");
hashtb_destroy(&stats);
return 0;
}
void testHASH() {
int rand, key;
FILE *fp, *fr;
char rand_line[10];
char key_line[10];
struct timeval start, end;
struct hashtb *newht;
newht=NULL;
newht=hashtb_create();
fp=fopen("rand_data.txt","r");
fr=fopen("rand_keys.txt","r");
gettimeofday(&start,NULL);
while(fgets(rand_line,10,fp) != NULL && fgets(key_line,10,fr) != NULL ) {
sscanf(rand_line, "%d", &rand);
sscanf(key_line, "%d", &key);
hashtb_add_element(newht,key,rand);
}
fclose(fp);
rewind(fr);
while(fgets(key_line,10,fr) != NULL) {
sscanf(key_line, "%d", &key);
hashtb_lookup(newht,key);
}
fclose(fr);
gettimeofday(&end,NULL);
free(newht);
printf("Total time: %ld microseconds\n", ((end.tv_sec * 1000000 + end.tv_usec)
- (start.tv_sec * 1000000 + start.tv_usec)));
printf("Test complete!\n");
}
void
add_next_hop_router(char *dest_router)
{
if ( strcmp(dest_router,nlsr->router_name)== 0)
{
return ;
}
struct routing_table_entry *rte;//=(struct routing_table_entry *)malloc(sizeof(struct routing_table_entry));
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
int res;
hashtb_start(nlsr->routing_table, e);
res = hashtb_seek(e, dest_router, strlen(dest_router), 0);
if( res == HT_NEW_ENTRY )
{
rte=e->data;
rte->dest_router=(char *)malloc(strlen(dest_router)+1);
memset(rte->dest_router,0,strlen(dest_router)+1);
memcpy(rte->dest_router,dest_router,strlen(dest_router));
//rte->next_hop_face=NO_NEXT_HOP;
struct hashtb_param param_fle = {0};
rte->face_list=hashtb_create(sizeof(struct face_list_entry), ¶m_fle);
add_npt_entry(dest_router, dest_router, 0, NULL, NULL);
}
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);
}
int main(int argc, char ** argv){
char* nid="123";
int chunk=1;
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
struct hashtb* conetht = hashtb_create(sizeof(struct conet_entry), NULL);
hashtb_start(conetht, e);
struct conet_entry* ce;
int res=hashtb_seek(e, nid, strlen(nid), 0);
if (res < 0)
perror("errore nel seek dell'ht");
ce = e->data;
if (res == HT_NEW_ENTRY) {
ce->prev=NULL;
ce->next=NULL;
ce->chunk_number=chunk;
ce->m_req_wnd=1;
ce->m_segment_size=1046;
ce->nid=nid;
}
hashtb_end(e);
}
LMD LMD_ctor(NBS nbs, SockAddr localAddr, size_t mtu) {
if (!NBS_isDgram(nbs)) return NULL;
LMD self = ALLOCSELF;
self->nbs = nbs;
if (localAddr != NULL) self->localAddr = SockAddr_clone(localAddr);
self->mtu = mtu;
self->demux = hashtb_create(sizeof(LMDRec), NULL);
return self;
}
int mainAndreaInutile(int argc, char *argv[])
{
size_t item_size=1;
const struct hashtb_param param;
hashtb_create(item_size, ¶m); //from hashtb.h
fprintf(stderr,"Starting to setup raw socket\n");
int rawsock=setup_raw_socket_listener(); //from conet_net.h
fprintf(stderr,"Raw sock=%d\n",rawsock);
return 0;
}
struct ccn_proxy_server *
ccn_proxy_server_init(const char *filter_uri, const char *prefix_uri)
{
struct ccn_proxy_server *server = calloc(1, sizeof(struct ccn_proxy_server));
server->proxy = ccn_proxy_init(filter_uri, prefix_uri);
server->hash_param.finalize = &ccn_proxy_server_finalize_entry;
server->cname_to_iname = hashtb_create(sizeof(struct ccn_charbuf *), &(server->hash_param));
return(server);
}
struct andana_server *
andana_server_init(const char *key_uri,
const char *filter_uri,
const char *prefix_uri)
{
struct andana_server *server =
calloc(1, sizeof(struct andana_server));
DEBUG_PRINT("%d %s andana_server_init invoked\n", __LINE__, __func__);
server->proxy = ccn_proxy_init(key_uri, filter_uri, prefix_uri);
struct ccn_closure *int_handler = calloc(1, sizeof(*int_handler));
int_handler->p = &andana_server_decap_interest;
int_handler->data = server;
struct ccn_closure *content_handler = calloc(1, sizeof(*content_handler));
content_handler->p = &andana_server_encap_content;
content_handler->data = server;
ccn_proxy_set_handlers(server->proxy, int_handler, content_handler);
server->ENC = server->proxy->prefix_ncomps;
server->SESSION_FLAG = server->proxy->prefix_ncomps;
server->SESSION_ENC = server->SESSION_FLAG + 1;
server->privkey = ccn_crypto_privkey_load_default();
server->node_key = ccn_crypto_symkey_init(128);
server->session_hash_params.finalize = &andana_server_finalize;
server->session_to_key = hashtb_create(sizeof(struct ccn_pkey *), &(server->session_hash_params));
server->cname_hash_params.finalize = &andana_server_finalize;
server->cname_to_pair = hashtb_create(sizeof(struct andana_server_pair *), &(server->cname_hash_params));
return(server);
}
struct andana_client *
andana_client_init(const char *prefix_uri,
struct andana_path *path)
{
struct andana_client *aclient = calloc(1, sizeof(*aclient));
aclient->proxy = ccn_proxy_client_init(prefix_uri);
struct ccn_closure *int_handler = calloc(1, sizeof(*int_handler));
int_handler->p = &andana_client_encap_interest;
int_handler->data = aclient;
struct ccn_closure *content_handler = calloc(1, sizeof(*content_handler));
content_handler->p = &andana_client_decap_content;
content_handler->data = aclient;
ccn_proxy_set_handlers(aclient->proxy, int_handler, content_handler);
aclient->path = andana_path_copy(path);
aclient->path_hash_params.finalize = &andana_client_finalize;
aclient->name_to_path = hashtb_create(sizeof(struct ccn_charbuf *), &(aclient->path_hash_params));
return(aclient);
}
/**
* Create a new ndnr instance
* @param progname - name of program binary, used for locating helpers
* @param logger - logger function
* @param loggerdata - data to pass to logger function
*/
PUBLIC struct ndnr_handle *
r_init_create(const char *progname, ndnr_logger logger, void *loggerdata)
{
char *sockname = NULL;
const char *portstr = NULL;
const char *listen_on = NULL;
const char *d = NULL;
struct ndnr_handle *h = NULL;
struct hashtb_param param = {0};
struct ndn_charbuf *config = NULL;
int res;
h = calloc(1, sizeof(*h));
if (h == NULL)
return(h);
h->notify_after = 0; //NDNR_MAX_ACCESSION;
h->logger = logger;
h->loggerdata = loggerdata;
h->logpid = (int)getpid();
h->progname = progname;
h->debug = -1;
config = r_init_read_config(h);
if (config == NULL)
goto Bail;
r_init_parse_config(h, config, 0); /* silent pass to pick up NDNR_DEBUG */
h->debug = 1; /* so that we see any complaints */
h->debug = r_init_debug_getenv(h, "NDNR_DEBUG");
res = r_init_parse_config(h, config, 1);
if (res < 0) {
h->running = -1;
goto Bail;
}
r_init_parse_config(h, config, 2);
sockname = r_net_get_local_sockname();
h->skiplinks = ndn_indexbuf_create();
h->face_limit = 10; /* soft limit */
h->fdholder_by_fd = calloc(h->face_limit, sizeof(h->fdholder_by_fd[0]));
param.finalize_data = h;
param.finalize = &r_fwd_finalize_nameprefix;
h->nameprefix_tab = hashtb_create(sizeof(struct nameprefix_entry), ¶m);
param.finalize = 0; // PRUNED &r_fwd_finalize_propagating;
h->propagating_tab = hashtb_create(sizeof(struct propagating_entry), ¶m);
param.finalize = &r_proto_finalize_enum_state;
h->enum_state_tab = hashtb_create(sizeof(struct enum_state), ¶m);
h->min_stale = ~0;
h->max_stale = 0;
h->unsol = ndn_indexbuf_create();
h->ticktock.descr[0] = 'C';
h->ticktock.micros_per_base = 1000000;
h->ticktock.gettime = &r_util_gettime;
h->ticktock.data = h;
h->sched = ndn_schedule_create(h, &h->ticktock);
h->starttime = h->sec;
h->starttime_usec = h->usec;
h->oldformatcontentgrumble = 1;
h->oldformatinterestgrumble = 1;
h->cob_limit = 4201;
h->start_write_scope_limit = r_init_confval(h, "NDNR_START_WRITE_SCOPE_LIMIT", 0, 3, 3);
h->debug = 1; /* so that we see any complaints */
h->debug = r_init_debug_getenv(h, "NDNR_DEBUG");
h->syncdebug = r_init_debug_getenv(h, "NDNS_DEBUG");
portstr = getenv("NDNR_STATUS_PORT");
if (portstr == NULL || portstr[0] == 0 || strlen(portstr) > 10)
portstr = "";
h->portstr = portstr;
ndnr_msg(h, "NDNR_DEBUG=%d NDNR_DIRECTORY=%s NDNR_STATUS_PORT=%s", h->debug, h->directory, h->portstr);
listen_on = getenv("NDNR_LISTEN_ON");
if (listen_on != NULL && listen_on[0] != 0)
ndnr_msg(h, "NDNR_LISTEN_ON=%s", listen_on);
if (ndnr_init_repo_keystore(h, NULL) < 0) {
h->running = -1;
goto Bail;
}
r_util_reseed(h);
r_store_init(h);
if (h->running == -1) goto Bail;
while (h->active_in_fd >= 0) {
r_dispatch_process_input(h, h->active_in_fd);
r_store_trim(h, h->cob_limit);
ndn_schedule_run(h->sched);
}
ndnr_msg(h, "Repository file is indexed");
if (h->face0 == NULL) {
struct fdholder *fdholder;
fdholder = calloc(1, sizeof(*fdholder));
if (dup2(open("/dev/null", O_RDONLY), 0) == -1)
ndnr_msg(h, "stdin: %s", strerror(errno));
fdholder->filedesc = 0;
fdholder->flags = (NDNR_FACE_GG | NDNR_FACE_NORECV);
r_io_enroll_face(h, fdholder);
}
ndnr_direct_client_start(h);
d = getenv("NDNR_SKIP_VERIFY");
#if (NDN_API_VERSION >= 4004)
if (d != NULL && strcmp(d, "1") == 0) {
ndnr_msg(h, "NDNR_SKIP_VERIFY=%s", d);
ndn_defer_verification(h->direct_client, 1);
}
#endif
if (ndn_connect(h->direct_client, NULL) != -1) {
int af = 0;
int bufsize;
int flags;
int fd;
struct fdholder *fdholder;
fd = ndn_get_connection_fd(h->direct_client);
// Play a dirty trick here - if this wins, we can fix it right in the c lib later on...
af = try_tcp_instead(fd);
flags = NDNR_FACE_NDND;
if (af == AF_INET)
flags |= NDNR_FACE_INET;
else if (af == AF_INET6)
flags |= NDNR_FACE_INET6;
else
flags |= NDNR_FACE_LOCAL;
fdholder = r_io_record_fd(h, fd, "NDND", 5, flags);
if (fdholder == NULL) abort();
ndnr_uri_listen(h, h->direct_client, "ndn:/%C1.M.S.localhost/%C1.M.SRV/repository",
&ndnr_answer_req, OP_SERVICE);
ndnr_uri_listen(h, h->direct_client, "ndn:/%C1.M.S.neighborhood/%C1.M.SRV/repository",
&ndnr_answer_req, OP_SERVICE);
bufsize = r_init_confval(h, "NDNR_MIN_SEND_BUFSIZE", 1, 2097152, 16384);
establish_min_send_bufsize(h, fd, bufsize);
}
else
ndn_disconnect(h->direct_client); // Apparently ndn_connect error case needs work.
if (1 == r_init_confval(h, "NDNS_ENABLE", 0, 1, 1)) {
h->sync_plumbing = calloc(1, sizeof(struct sync_plumbing));
h->sync_plumbing->ndn = h->direct_client;
h->sync_plumbing->sched = h->sched;
h->sync_plumbing->client_methods = &sync_client_methods;
h->sync_plumbing->client_data = h;
h->sync_base = SyncNewBaseForActions(h->sync_plumbing);
}
if (-1 == load_policy(h))
goto Bail;
r_net_listen_on(h, listen_on);
ndnr_internal_client_start(h);
r_proto_init(h);
r_proto_activate_policy(h, h->parsed_policy);
if (merge_files(h) == -1)
r_init_fail(h, __LINE__, "Unable to merge additional repository data files.", errno);
if (h->running == -1) goto Bail;
if (h->sync_plumbing) {
// Start sync running
// returns < 0 if a failure occurred
// returns 0 if the name updates should fully restart
// returns > 0 if the name updates should restart at last fence
res = h->sync_plumbing->sync_methods->sync_start(h->sync_plumbing, NULL);
if (res < 0) {
r_init_fail(h, __LINE__, "starting sync", res);
abort();
}
else if (res > 0) {
// XXX: need to work out details of starting from last fence.
// By examination of code, SyncActions won't take this path
}
}
Bail:
if (sockname)
free(sockname);
sockname = NULL;
ndn_charbuf_destroy(&config);
if (h->running == -1)
r_init_destroy(&h);
return(h);
}
PUBLIC void
r_store_init(struct ccnr_handle *h)
{
struct ccn_btree *btree = NULL;
struct ccn_btree_node *node = NULL;
struct hashtb_param param = {0};
int i;
int j;
int res;
struct ccn_charbuf *path = NULL;
struct ccn_charbuf *msgs = NULL;
off_t offset;
path = ccn_charbuf_create();
param.finalize_data = h;
param.finalize = 0;
h->cob_limit = r_init_confval(h, "CCNR_CONTENT_CACHE", 16, 2000000, 4201);
h->cookie_limit = choose_limit(h->cob_limit, (ccnr_cookie)(~0U));
h->content_by_cookie = calloc(h->cookie_limit, sizeof(h->content_by_cookie[0]));
CHKPTR(h->content_by_cookie);
h->content_by_accession_tab = hashtb_create(sizeof(struct content_by_accession_entry), NULL);
CHKPTR(h->content_by_accession_tab);
h->btree = btree = ccn_btree_create();
CHKPTR(btree);
FAILIF(btree->nextnodeid != 1);
ccn_charbuf_putf(path, "%s/index", h->directory);
res = mkdir(ccn_charbuf_as_string(path), 0700);
if (res != 0 && errno != EEXIST)
r_init_fail(h, __LINE__, ccn_charbuf_as_string(path), errno);
else {
msgs = ccn_charbuf_create();
btree->io = ccn_btree_io_from_directory(ccn_charbuf_as_string(path), msgs);
if (btree->io == NULL)
res = errno;
if (msgs->length != 0 && CCNSHOULDLOG(h, sffdsdf, CCNL_WARNING)) {
ccnr_msg(h, "while initializing %s - %s",
ccn_charbuf_as_string(path),
ccn_charbuf_as_string(msgs));
}
ccn_charbuf_destroy(&msgs);
if (btree->io == NULL)
r_init_fail(h, __LINE__, ccn_charbuf_as_string(path), res);
}
node = ccn_btree_getnode(btree, 1, 0);
if (btree->io != NULL)
btree->nextnodeid = btree->io->maxnodeid + 1;
CHKPTR(node);
if (node->buf->length == 0) {
res = ccn_btree_init_node(node, 0, 'R', 0);
CHKSYS(res);
}
ccn_charbuf_destroy(&path);
if (h->running == -1)
return;
r_store_read_stable_point(h);
h->active_in_fd = -1;
h->active_out_fd = r_io_open_repo_data_file(h, "repoFile1", 1); /* output */
offset = lseek(h->active_out_fd, 0, SEEK_END);
h->startupbytes = offset;
if (offset != h->stable || node->corrupt != 0) {
ccnr_msg(h, "Index not current - resetting");
ccn_btree_init_node(node, 0, 'R', 0);
node = NULL;
ccn_btree_destroy(&h->btree);
path = ccn_charbuf_create();
/* Remove old index files to avoid confusion */
for (i = 1, j = 0; i > 0 && j < 3; i++) {
path->length = 0;
res = ccn_charbuf_putf(path, "%s/index/%d", h->directory, i);
if (res >= 0)
res = unlink(ccn_charbuf_as_string(path));
if (res < 0)
j++;
}
h->btree = btree = ccn_btree_create();
path->length = 0;
ccn_charbuf_putf(path, "%s/index", h->directory);
btree->io = ccn_btree_io_from_directory(ccn_charbuf_as_string(path), msgs);
CHKPTR(btree->io);
btree->io->maxnodeid = 0;
btree->nextnodeid = 1;
node = ccn_btree_getnode(btree, 1, 0);
btree->nextnodeid = btree->io->maxnodeid + 1;
ccn_btree_init_node(node, 0, 'R', 0);
h->stable = 0;
h->active_in_fd = r_io_open_repo_data_file(h, "repoFile1", 0); /* input */
ccn_charbuf_destroy(&path);
if (CCNSHOULDLOG(h, dfds, CCNL_INFO))
ccn_schedule_event(h->sched, 50000, r_store_reindexing, NULL, 0);
}
if (CCNSHOULDLOG(h, weuyg, CCNL_FINEST)) {
FILE *dumpfile = NULL;
path = ccn_charbuf_create();
ccn_charbuf_putf(path, "%s/index/btree_check.out", h->directory);
dumpfile = fopen(ccn_charbuf_as_string(path), "w");
res = ccn_btree_check(btree, dumpfile);
if (dumpfile != NULL) {
fclose(dumpfile);
dumpfile = NULL;
}
else
path->length = 0;
ccnr_msg(h, "ccn_btree_check returned %d (%s)",
res, ccn_charbuf_as_string(path));
ccn_charbuf_destroy(&path);
if (res < 0)
r_init_fail(h, __LINE__, "index is corrupt", res);
}
btree->full = r_init_confval(h, "CCNR_BTREE_MAX_FANOUT", 4, 9999, 1999);
btree->full0 = r_init_confval(h, "CCNR_BTREE_MAX_LEAF_ENTRIES", 4, 9999, 1999);
btree->nodebytes = r_init_confval(h, "CCNR_BTREE_MAX_NODE_BYTES", 1024, 8388608, 2097152);
btree->nodepool = r_init_confval(h, "CCNR_BTREE_NODE_POOL", 16, 2000000, 512);
if (h->running != -1)
r_store_index_needs_cleaning(h);
}
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;
}
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;
}