int xtr_generic_process_request(uint32_t request_id, struct communication_fct * fct){
struct db_table * table;
struct db_node * rn = NULL;
struct prefix p;
struct db_node *node = NULL;
/* look for the eid */
fct->request_get_eid(request_id, &p);
table = ms_get_db_table(ms_db,&p);
rn = db_node_match_prefix(table, &p);
//show_eid_info(rn);
if(!rn){
_request_reply_negative(request_id, fct, rn, &p, 900, 0, 0, 0);
fct->request_terminate(request_id);
return (FALSE);
}
node = rn;
if(!rn->reserve){
node = ms_get_target(rn);
}
if ( ms_node_is_type(node, _MAPP_XTR)){
return _request_reply(request_id, fct, node, NULL);
}
else{
return _request_reply_negative(request_id, fct, node, &p, 60, 1, LISP_REFERRAL_MS_NOT_REGISTERED, 0);
}
return (0);
}
/* find all node matched special tag in tree */
int
ms_get_tree(struct db_node *node, struct list_t *rt, int flag)
{
if (!node)
return 0;
if (ms_node_is_type(node, flag))
list_insert(rt,node,NULL);
ms_get_tree(node->l_left,rt,flag);
ms_get_tree(node->l_right,rt,flag);
return rt->count;
}
/* make a map-referral reply */
int
_request_referral(void *data, struct communication_fct *fct, \
struct db_node * rn){
struct map_entry * e = NULL;
struct list_entry_t * _iter;
struct list_t * l = NULL;
uint8_t act;
struct mapping_flags * mflags = (struct mapping_flags *)rn->flags;
struct pk_rpl_entry *rpk;
struct pk_req_entry *pke = data;
/* create the referral container */
rpk = fct->referral_add(pke);
/* get the RLOCs and add each of them in the referral */
l = (struct list_t *)db_node_get_info(rn);
/* something bad happened */
if(!(_iter = l->head.next)){
fct->referral_error(pke);
return (FALSE);
}
/* Create one record container to put the locators */
if(!mflags->referral && ms_node_is_type(rn,_MAPP)){
act = LISP_REFERRAL_MS_ACK;
}
else{
act = mflags->referral-1;
}
fct->referral_add_record(rpk, mflags->iid, &rn->p, mflags->ttl,
l->count, mflags->version, mflags->A, act, mflags->incomplete, 0);
/* negative reply */
if(_iter == &l->tail){
fct->referral_terminate(rpk);
return TRUE;
}
/* add each locator into the record */
while(_iter != &l->tail){
e = (struct map_entry*)_iter->data;
fct->referral_add_locator(rpk, e);
_iter = _iter->next;
}
fct->referral_terminate(rpk);
return (TRUE);
}
/* processing with map-request for xTR */
int
xtr_generic_process_request(uint32_t request_id, struct communication_fct * fct){
struct db_table * table;
struct db_node * rn = NULL;
struct prefix p;
struct db_node *node = NULL;
int rt;
/* look for the eid */
fct->request_get_eid(request_id, &p);
table = ms_get_db_table(ms_db,&p);
rn = db_node_match_prefix(table, &p);
if(!rn){
_request_reply_negative(request_id, fct, rn, &p, 900, 0, 0, 0);
fct->request_terminate(request_id);
return (FALSE);
}
node = rn;
if(!(rn->flags) || !((struct mapping_flags *)rn->flags)->range){
node = ms_get_target(rn);
}
if ( ms_node_is_type(node, _MAPP_XTR)){
rt = _request_reply(request_id, fct, node, NULL);
fct->request_terminate(request_id);
return rt;
}
else{
rt = _request_reply_negative(request_id, fct, node, &p, 60, 1, 3, 0);
fct->request_terminate(request_id);
return rt;
}
fct->request_terminate(request_id);
return (TRUE);
}
int generic_process_request(uint32_t request_id, struct communication_fct * fct){
struct db_table * table;
struct db_node * rn = NULL;
struct prefix p;
int is_ddt;
struct db_node *node = NULL;
/* look for the eid */
fct->request_get_eid(request_id, &p);
table = ms_get_db_table(ms_db,&p);
rn = db_node_match_prefix(table, &p);
if(!rn){
//printf("no mapping found\n");
_request_reply_negative(request_id, fct, rn, &p, 900, 0, 0, 0);
fct->request_terminate(request_id);
return (FALSE);
}
fct->request_is_ddt(request_id, &is_ddt);
/* Received DDT request */
if(is_ddt){
//function of {map-register-with-DDT|DDT-node}
node = rn;
if(!rn->reserve){
node = ms_get_target(rn);
}
if (ms_node_is_type(node, _MAPP)){
if( ((struct mapping_flags *)node->flags)->referral && ((struct mapping_flags *)node->flags)->A){
return _request_referral(request_id, fct, node);
}
if( !((struct mapping_flags *)node->flags)->referral){
if(ms_node_is_proxy_reply(node))
return _request_reply(request_id, fct, node, NULL);
else{
fprintf(OUTPUT_STREAM, "Forwarding to ETR\n");
return _forward_to_etr(request_id,node);
}
}
}
else{
if ( ms_node_is_type(node,_EID) || ms_node_is_type(node,_GEID))
return _request_referral_negative(request_id, fct, node, &p, 60, 1, LISP_REFERRAL_MS_NOT_REGISTERED, 0, 1);
else if ( ms_node_is_type(node,_GREID) )
return _request_referral_negative(request_id, fct, rn, &p, 60, 0, LISP_REFERRAL_DELEGATION_HOLE,0, 1 );
else
return _request_reply_negative(request_id, fct, node, &p, 900, 0, LISP_REFERRAL_NOTE_AUTHORITATIVE, 0);
}
printf("Not process\n");
return (0);
}
/* Received non DDT request */
else{
//function of {map-resolver |map-register-with-no-DDD-function}
node = rn;
if(!rn->reserve){
node = ms_get_target(rn);
}
if ( ms_node_is_type(node, _MAPP)){
if( !ms_node_is_referral(node)){
if(ms_node_is_proxy_reply(node))
return _request_reply(request_id, fct, node, NULL);
else{
fprintf(OUTPUT_STREAM, "Forwarding to ETR\n");
return _forward_to_etr(request_id,node);
}
}
else{
return _request_ddt(request_id, fct, node);
}
}
else{
if ( ms_node_is_type(node,_EID) || ms_node_is_type(node,_GEID)){
return _request_reply_negative(request_id, fct, node, &p, 60, 1, LISP_REFERRAL_MS_NOT_REGISTERED, 0);
}
else{
if ( ms_node_is_type(node,_GREID) ) {
return _request_reply_negative(request_id, fct, node, &p, 900, 0, LISP_REFERRAL_DELEGATION_HOLE, 0);
}
else
return _request_reply_negative(request_id, fct, node, &p, 900, 0, LISP_REFERRAL_NOTE_AUTHORITATIVE, 0);
}
}
}
printf("Not process\n");
return (0);
assert(FALSE);
}
void
list_db(struct db_table *db)
{
struct db_node *rn;
static struct pool_node {
int n_direct;
struct db_node *link2node;
} node_list[50000];
char *sref[7];
sref[1] = "NODE";
sref[2] = "MS";
sref[3] = "MS_ACK";
sref[4] = "MS_NOT_REGISTERED";
sref[5] = "DELEGATION_HOLE";
sref[6] = "NOTE_AUTHORITATIVE";
int i = 0;
int j = 0;
int k;
int count_list = 0;
int trdeep[MAX_NODES];
assert(db);
assert(db->top);
rn = db->top;
for (i = 0; i< MAX_NODES ;i++ ) {
node_list[i].link2node = NULL;
}
node_list[count_list++].link2node = rn;
node_list[count_list].n_direct = _CENTER;
for (i = 0; i< MAX_NODES; i++)
trdeep[i] = 0;
trdeep[count_list] = 0;
while (rn != NULL) {
k = trdeep[j]+1;
if (rn->l_left != NULL) {
node_list[count_list].link2node = rn->l_left;
node_list[count_list++].n_direct = _LEFT;
trdeep[count_list]=k;
}
if (rn->l_right != NULL) {
node_list[count_list].link2node = rn->l_right;
node_list[count_list++].n_direct = _RIGHT;
trdeep[count_list]=k;
}
rn = node_list[++j].link2node;
}
int deep = 0;
int deep_avg = 0;
for (i = 0; i < MAX_NODES; i++) {
if (trdeep[i] > 0)
deep_avg += trdeep[i];
if (deep < trdeep[i])
deep = trdeep[i];
}
cp_log(LDEBUG, "Max deep of tree::%d\n",deep);
cp_log(LDEBUG, "Avg deep of tree::%d\n",deep_avg/count_list);
cp_log(LDEBUG, "Number of Node::%d\n",count_list);
char buf2[BSIZE];
struct list_t *info2;
char *s_direct;
char refe[50];
char buf[50];
struct list_entry_t *rl;
struct map_entry *e;
for (j = 0; j < count_list ; j++ ) {
rn = node_list[j].link2node;
if (rn == db->top)
s_direct = "ROOT";
else
s_direct = (node_list[j].n_direct == _LEFT ) ? "LEFT":"RIGHT";
bzero(buf2, BSIZE);
inet_ntop(rn->p.family, (void *)&rn->p.u.prefix, buf2, BSIZE);
if (rn->flags && ((struct mapping_flags *)rn->flags)->referral) {
sprintf(refe, "%s%s","Reference::",sref[((struct mapping_flags *)rn->flags)->referral]);
}
else
sprintf(refe, "%s"," ");
node_type2_str(rn, buf);
cp_log(LLOG, "%d:: %s - %s/%d - %s - %s \n", j, s_direct, buf2, rn->p.prefixlen,buf, refe);
if (ms_node_is_type(rn,_MAPP)) {
assert(rn->info);
info2 = (struct list_t *)rn->info;
rl = info2->head.next;
while (rl != &info2->tail) {
char buf[BSIZE];
bzero(buf, BSIZE);
e = (struct map_entry *)rl->data;
switch (e->rloc.sa.sa_family) {
case AF_INET:
inet_ntop(AF_INET, (void *)&e->rloc.sin.sin_addr, buf, BSIZE);
break;
case AF_INET6:
inet_ntop(AF_INET6, (void *)&e->rloc.sin6.sin6_addr, buf, BSIZE);
break;
default:
cp_log(LDEBUG, "unsuported family\n");
continue;
}
cp_log(LDEBUG, "\t[rloc=%s, priority=%u, weight=%u, m_priority=%u, m_weight=%u, r=%d]\n", \
buf, \
e->priority, \
e->weight, \
e->m_priority, \
e->m_weight, \
e->r);
rl = rl->next;
}
}
}
}
/* processing with map-request */
int
generic_process_request(uint32_t request_id, struct communication_fct * fct){
struct db_table * table;
struct db_node * rn = NULL;
struct prefix p;
int is_ddt;
struct db_node *node = NULL, *np;
int rt;
/* look for the eid */
fct->request_get_eid(request_id, &p);
table = ms_get_db_table(ms_db,&p);
rn = db_node_match_prefix(table, &p);
if(!rn){
_request_reply_negative(request_id, fct, rn, &p, 900, 0, 1, 0);
fct->request_terminate(request_id);
return (FALSE);
}
fct->request_is_ddt(request_id, &is_ddt);
/* Received DDT request */
if(is_ddt){
/*function of {map-register-with-DDT|DDT-node}*/
node = rn;
if( !rn->flags || !((struct mapping_flags *)rn->flags)->range){
node = ms_get_target(rn);
}
if (ms_node_is_type(node, _MAPP)){
/* Only send map-referrel for EDI-prefix auth */
if( !((struct mapping_flags *)node->flags)->referral){
if(ms_node_is_proxy_reply(node)){
rt = _request_reply(request_id, fct, node, NULL);
fct->request_terminate(request_id);
return rt;
}
else{
fprintf(OUTPUT_STREAM, "Forwarding to ETR\n");
_request_referral(request_id, fct, node);
rt = _forward_to_etr(request_id,node);
fct->request_terminate(request_id);
return rt;
}
}
if( ((struct mapping_flags *)node->flags)->referral && ((struct mapping_flags *)node->flags)->A){
rt = _request_referral(request_id, fct, node);
fct->request_terminate(request_id);
return rt;
}
if( ((struct mapping_flags *)node->flags)->referral && !((struct mapping_flags *)node->flags)->A){
np = node;
while(np != table->top){
if (((struct mapping_flags *)np->flags)->referral && ((struct mapping_flags *)np->flags)->A)
break;
np = np->parent;
}
if ( (np != table->top) && ((struct mapping_flags *)np->flags)->referral && ((struct mapping_flags *)np->flags)->A){
rt = _request_referral(request_id, fct, np);
fct->request_terminate(request_id);
return rt;
}
}
}
else{
if ( ms_node_is_type(node,_EID) || ms_node_is_type(node,_GEID)){
rt = _request_referral_negative(request_id, fct, node, &p, 60, 1, LISP_REFERRAL_MS_NOT_REGISTERED, 0, 1);
fct->request_terminate(request_id);
return rt;
}
else{
if ( ms_node_is_type(node,_GREID) ){
rt = _request_referral_negative(request_id, fct, rn, &p, 60, 0, LISP_REFERRAL_DELEGATION_HOLE,0, 1 );
fct->request_terminate(request_id);
return rt;
}
else{
rt = _request_reply_negative(request_id, fct, node, &p, 900, 0, 1, 0);
fct->request_terminate(request_id);
return rt;
}
}
}
printf("Not process\n");
return (0);
}
/* Received non DDT request */
else{
//function of {map-resolver |map-register-with-no-DDD-function}
node = rn;
if(!(rn->flags) || !((struct mapping_flags *)rn->flags)->range){
node = ms_get_target(rn);
}
if ( ms_node_is_type(node, _MAPP)){
if( !ms_node_is_referral(node)){
if(ms_node_is_proxy_reply(node)){
rt = _request_reply(request_id, fct, node, NULL);
fct->request_terminate(request_id);
return rt;
}
else{
fprintf(OUTPUT_STREAM, "Forwarding to ETR\n");
rt = _forward_to_etr(request_id,node);
fct->request_terminate(request_id);
return rt;
}
}
else{
pending_request(request_id, fct, node);
fct->request_terminate(request_id);
return 1;
}
}
else{
if ( ms_node_is_type(node,_EID) || ms_node_is_type(node,_GEID)){
if ( ms_node_is_type(node,_EID))
rt = _request_reply_negative(request_id, fct, node, &p, 60, 1, 1, 0);
else
rt = _request_reply_negative(request_id, fct, node, &p, 900, 1, 1, 0);
fct->request_terminate(request_id);
return rt;
}
else{
if ( ms_node_is_type(node,_GREID) ) {
rt = _request_reply_negative(request_id, fct, node, &p, 900, 0, 1, 0);
fct->request_terminate(request_id);
return rt;
}
else{
rt = _request_reply_negative(request_id, fct, node, &p, 900, 0, 1, 0);
fct->request_terminate(request_id);
return rt;
}
}
}
}
printf("Not process\n");
return (0);
assert(FALSE);
}
/* processing with map-request for xTR */
int
xtr_generic_process_request(void *data, struct communication_fct * fct){
struct db_table * table;
struct db_node * rn = NULL;
struct prefix p;
struct db_node *node = NULL;
int rt;
struct pk_req_entry *pke = data;
/* look for the eid */
fct->request_get_eid(pke, &p);
table = ms_get_db_table(ms_db,&p);
rn = db_node_match_prefix(table, &p);
if(pke->ecm){
/*ETR received this packet from MS */
if(!rn){
/* this can not happen because ECM is forwared from MS to ETR
it mean that MS has an old mapping of ETR
drop packet and wait for MS timeout mapping or refesh
with nex map-register from ETR
*/
return (FALSE);
}
node = rn;
if(!(rn->flags) || !((struct mapping_flags *)rn->flags)->range){
node = ms_get_target(rn);
}
if ( ms_node_is_type(node, _MAPP_XTR)){
rt = _request_reply(pke, fct, node, NULL);
return rt;
}
else{
/* similar the case rn is NULL */
return (FALSE);
}
}else { /* ETR received packet from xTR or PxTR */
/* process with SMR...?? */
if(!rn){
/*ITR has cached an old mapping.
Drop request and ITR will timeout and send map-request to mapping system
*/
return (FALSE);
}
node = rn;
if(!(rn->flags) || !((struct mapping_flags *)rn->flags)->range){
node = ms_get_target(rn);
}
if ( ms_node_is_type(node, _MAPP_XTR)){
rt = _request_reply(pke, fct, node, NULL);
return rt;
}
else{
/* similar the case rn is NULL */
return(FALSE);
}
}
return (FALSE);
}
/* processing with map-request - only MS|NODE|MR function*/
int
generic_process_request(void *data, struct communication_fct * fct){
struct db_table * table;
struct db_node * rn = NULL;
struct prefix p;
int is_ddt;
struct db_node *node = NULL;
int rt;
struct pk_req_entry *pke = data;
/* look for the eid */
fct->request_get_eid(pke, &p);
table = ms_get_db_table(ms_db,&p);
rn = db_node_match_prefix(table, &p);
fct->request_is_ddt(pke, &is_ddt);
/* Received DDT request */
if(is_ddt){
/*function of {map-register-with-DDT|DDT-node}*/
if(!rn){
/*If the requested XEID did not match either a configured delegation or
an authoritative XEID-prefix, then the request is dropped and a
negative Map-Referral with action code NOT-AUTHORITATIVE is returned.
*/
if(_fncs & _FNC_NODE){
rt = _request_referral_negative(pke, fct, node, &p, 0, 0, LISP_REFERRAL_NOT_AUTHORITATIVE, 0, 1);
}
return (TRUE);
}
node = rn;
if( !rn->flags || !((struct mapping_flags *)rn->flags)->range){
node = ms_get_target(rn);
}
/* existing mapping for request */
if (ms_node_is_type(node, _MAPP)){
/* not referral node, it must belong to MS */
if( !((struct mapping_flags *)node->flags)->referral){
/* do ms function: reply or foward to ETR */
if(_fncs & _FNC_MS){
if(ms_node_is_proxy_reply(node)){
rt = _request_reply(pke, fct, node, NULL);
return (TRUE);
}
cp_log(LDEBUG, "Forwarding to ETR\n");
_request_referral(pke, fct, node);
rt = _forward_to_etr(pke,node);
return (TRUE);
}
/*it not be here: it is not MS but is has normal mapping */
return FALSE;
}
/* referral node, must belong to NODE or MR*/
if ( _fncs & _FNC_NODE){
/*Auth EID referral - return with map-referral*/
if( ((struct mapping_flags *)node->flags)->A ){
rt = _request_referral(pke, fct, node);
return (TRUE);
}else{
while(node != table->top &&
(!node->flags ||
!((struct mapping_flags *)node->flags)->A))
node = node->parent;
if(node == table->top){
rt = _request_referral_negative(pke, fct, node, &p, 0, 0, LISP_REFERRAL_NOT_AUTHORITATIVE, 0, 1);
return TRUE;
}
rt = _request_referral(pke, fct, node);
return TRUE;
}
}
}
else{//not exist mapping
if ( _fncs & _FNC_MS || _fncs & _FNC_NODE){
/* node has type */
while (node != table->top &&
( !node->flags ||
!( ((struct mapping_flags *)node->flags)->range & (_EID | _GEID | _GREID)) ))
node = node->parent;
if(node == table->top){
rt = _request_referral_negative(pke, fct, node, &p, 0, 0, LISP_REFERRAL_NOT_AUTHORITATIVE, 0, 1);
return TRUE;
}else{
switch (((struct mapping_flags *)node->flags)->range){
case _EID: /* EID not is registered */
if ( _fncs & _FNC_MS){
rt = _request_referral_negative(pke, fct, node, &p, 60, 1, LISP_REFERRAL_MS_NOT_REGISTERED, 0, 1);
return TRUE;
}
break;
case _GEID:/* EID not assign for any ETR */
if ( _fncs & _FNC_MS){
/* in ieft, this case is same as _EID, but it think TTL must longer*/
rt = _request_referral_negative(pke, fct, node, &p, 900, 1, LISP_REFERRAL_MS_NOT_REGISTERED, 0, 1);
return TRUE;
}
break;
case _GREID:/* EID not delegated */
if ( _fncs & _FNC_NODE){
rt = _request_referral_negative(pke, fct, rn, &p, 60, 0, LISP_REFERRAL_DELEGATION_HOLE,0, 1 );
return TRUE;
}
break;
}
/*can not here or database has problem */
return FALSE;
}
}
}
cp_log(LDEBUG, "Not process...ignore packet\n");
return FALSE;
}
/* Received non DDT request */
else{
/*function of {map-resolver |map-register-with-no-DDD-function} */
node = rn;
if(!(rn->flags) || !((struct mapping_flags *)rn->flags)->range){
node = ms_get_target(rn);
}
if ( ms_node_is_type(node, _MAPP)){
/* node is MAPP, must belong to MS */
if( !ms_node_is_referral(node)){
if(_fncs & _FNC_MS){
if(ms_node_is_proxy_reply(node)){
rt = _request_reply(pke, fct, node, NULL);
return rt;
}
else{
cp_log(LDEBUG, "Forwarding to ETR\n");
rt = _forward_to_etr(pke,node);
return rt;
}
}
return FALSE;
}
else{
/* do MR function */
if(_fncs & _FNC_MR){
pending_request(pke, fct, node);
return 1;
}
}
}
else{/*node is not mapping */
while (node != table->top &&
( !node->flags ||
!( ((struct mapping_flags *)node->flags)->range & (_EID | _GEID)) ))
node = node->parent;
if(_fncs & _FNC_MS){
if(node == table->top)
return FALSE;
if ( ms_node_is_type(node,_EID))
rt = _request_reply_negative(pke, fct, node, &p, 60, 1, 1, 0);
else
rt = _request_reply_negative(pke, fct, node, &p, 900, 1, 1, 0);
return TRUE;
}
if(_fncs & _FNC_MR){
pending_request(pke, fct, node);
return TRUE;
}
}
}
cp_log(LDEBUG, "Not process...ignore packet\n");
return FALSE;
}
