/*
* Compare lisp_addr_t of two locators.
* Returns:
* -1: If they are from different afi
* 0: Both address are the same
* 1: Addr1 is bigger than addr2
* 2: Addr2 is bigger than addr1
*/
inline int
locator_cmp_addr (
locator_t *loct1,
locator_t *loct2)
{
return (lisp_addr_cmp(locator_addr(loct1),locator_addr(loct2)));
}
static locator_t *
get_locator_with_afi(mapping_t *m, int afi)
{
glist_t *loct_list = NULL;
glist_entry_t *it_list = NULL;
glist_entry_t *it_loct = NULL;
locator_t *loct = NULL;
lisp_addr_t *addr = NULL;
int lafi = 0;
int afi_type = 0;
glist_for_each_entry(it_list,mapping_locators_lists(m)){
loct_list = (glist_t *)glist_entry_data(it_list);
locator_list_lafi_type(loct_list,&lafi,&afi_type);
if (lafi == LM_AFI_NO_ADDR || (lafi == LM_AFI_IP && afi_type != afi)){
continue;
}
glist_for_each_entry(it_loct,loct_list){
loct = (locator_t *)glist_entry_data(it_loct);
if (locator_state(loct) == DOWN){
continue;
}
addr = locator_addr(loct);
addr = lisp_addr_get_ip_addr(addr);
if (lisp_addr_ip_afi (addr) == afi){
return (loct);
}
}
/*
* Get lafi and type of a list
*/
void locator_list_lafi_type (
glist_t *loct_list,
int *lafi,
int *type)
{
locator_t *loct = NULL;
lisp_addr_t *addr = NULL;
*lafi = 0;
*type = 0;
if (loct_list == NULL || glist_size(loct_list) == 0){
return;
}
loct = (locator_t *)glist_first_data(loct_list);
addr = locator_addr(loct);
*lafi = lisp_addr_lafi(addr);
switch(*lafi){
case LM_AFI_NO_ADDR:
*type = 0;
return;
case LM_AFI_IP:
*type = lisp_addr_ip_afi(addr);
return;
case LM_AFI_IPPREF:
LMLOG(LDBG_2, "locator_list_lafi_type: locator list should not contain prefixes");
return;
case LM_AFI_LCAF:
*type = lisp_addr_lcaf_type(addr);
return;
}
}
int locator_cmp(locator_t *l1, locator_t *l2)
{
int ret = 0;
if ((ret = lisp_addr_cmp(locator_addr(l1), locator_addr(l2))) != 0) {
return (1);
}
if (l1->priority != l2->priority)
return (1);
if (l1->weight != l2->weight)
return (1);
if (l1->mpriority != l2->mpriority)
return (1);
if (l1->mweight != l2->mweight)
return (1);
return (0);
}
int
lisp_msg_parse_mapping_record_split(lbuf_t *b, lisp_addr_t *eid,
glist_t *loc_list, locator_t **probed_)
{
void *mrec_hdr = NULL, *loc_hdr = NULL;
locator_t *loc = NULL, *probed = NULL;
int i = 0, len = 0;
probed = NULL;
mrec_hdr = lbuf_data(b);
lbuf_pull(b, sizeof(mapping_record_hdr_t));
len = lisp_addr_parse(lbuf_data(b), eid);
if (len <= 0) {
return(BAD);
}
lbuf_pull(b, len);
lisp_addr_set_plen(eid, MAP_REC_EID_PLEN(mrec_hdr));
OOR_LOG(LDBG_1, " %s eid: %s", mapping_record_hdr_to_char(mrec_hdr),
lisp_addr_to_char(eid));
for (i = 0; i < MAP_REC_LOC_COUNT(mrec_hdr); i++) {
loc_hdr = lbuf_data(b);
loc = locator_new();
if (lisp_msg_parse_loc(b, loc) != GOOD) {
return(BAD);
}
glist_add(loc, loc_list);
if (LOC_PROBED(loc_hdr)) {
if (probed != NULL) {
OOR_LOG(LDBG_1, "Multiple probed locators! Probing only the first one: %s",
lisp_addr_to_char(locator_addr(loc)));
}else{
probed = loc;
}
}
}
if (probed_ != NULL) {
*probed_ = probed;
}
return(GOOD);
}
char *
locator_to_char(locator_t *l)
{
static char buf[5][500];
static int i=0;
if (l == NULL){
sprintf(buf[i], "_NULL_");
return (buf[i]);
}
/* hack to allow more than one locator per line */
i++; i = i % 5;
*buf[i] = '\0';
sprintf(buf[i] + strlen(buf[i]), "%s, ", lisp_addr_to_char(locator_addr(l)));
sprintf(buf[i] + strlen(buf[i]), "%s, ", l->state ? "Up" : "Down");
sprintf(buf[i] + strlen(buf[i]), "%d/%-d, %d/%d", l->priority, l->weight,
l->mpriority, l->mweight);
return (buf[i]);
}
/* Return the locator from the list that contains the address passed as a
* parameter */
locator_t *
locator_list_get_locator_with_addr(
glist_t *loct_list,
lisp_addr_t *addr)
{
locator_t *locator = NULL;
glist_entry_t *it = NULL;
if (!loct_list || glist_size(loct_list) == 0 || addr == NULL){
return (NULL);
}
glist_for_each_entry(it,loct_list){
locator = (locator_t *)glist_entry_data(it);
if (lisp_addr_cmp(locator_addr(locator), addr) == 0) {
return (locator);
}
}
int
lisp_msg_parse_loc(lbuf_t *b, locator_t *loc)
{
int len;
void *hdr;
hdr = lbuf_data(b);
len = locator_parse(lbuf_data(b), loc);
if (len <= 0) {
return(BAD);
}
lbuf_pull(b, len);
OOR_LOG(LDBG_1, " %s, addr: %s", locator_record_hdr_to_char(hdr),
lisp_addr_to_char(locator_addr(loc)));
return(GOOD);
}
