def lisp_mr_show_referral_cache_lookup(eid_str): eid, eid_exact, group, group_exact = \ lispconfig.lisp_get_lookup_string(eid_str) output = "<br>" entry = lisp.lisp_referral_cache_lookup(eid, group, eid_exact) if (entry == None): output += "{} {}".format(lisp.lisp_print_sans("Lookup not found for"), lisp.lisp_print_cour(eid_str)) else: ts = lisp.lisp_print_elapsed(entry.uptime) output += "{}{}{}{}{}{}".format( \ lisp.lisp_print_sans("{} match lookup for ".format("Exact" if \ eid_exact else "Longest")), lisp.lisp_print_cour(eid_str), lisp.lisp_print_sans(" found "), lisp.lisp_print_cour(entry.print_eid_tuple()), lisp.lisp_print_sans(", referral-type {}".format( \ lisp.lisp_print_cour(entry.print_referral_type()))), lisp.lisp_print_sans(" with uptime {}".format( \ lisp.lisp_print_cour(ts)))) #endif output += "<br>" return (output)
def lisp_ddt_show_delegations_lookup(eid_str): eid, eid_exact, group, group_exact = \ lispconfig.lisp_get_lookup_string(eid_str) output = "<br>" # # Do lookup in DDT-cache. # ddt_entry = lisp.lisp_ddt_cache_lookup(eid, group, eid_exact) if (ddt_entry == None): banner = "DDT entry not found for non-authoritative EID" output += "{} {}".format(lisp.lisp_print_sans(banner), lisp.lisp_print_cour(eid_str)) return (output + "<br>") #endif if (ddt_entry.is_auth_prefix()): if (group.is_null()): neg_prefix = lisp.lisp_ddt_compute_neg_prefix( eid, ddt_entry, lisp.lisp_ddt_cache) neg_prefix = lisp.lisp_print_cour(neg_prefix.print_prefix()), else: gneg_prefix = lisp.lisp_ddt_compute_neg_prefix( group, ddt_entry, lisp.lisp_ddt_cache) neg_prefix = lisp.lisp_ddt_compute_neg_prefix( eid, ddt_entry, ddt_entry.source_cache) neg_prefix = lisp.lisp_print_cour( \ "(" + neg_prefix.print_prefix() + ", ") gneg_prefix = lisp.lisp_print_cour( \ gneg_prefix.print_prefix() + ")") neg_prefix += gneg_prefix #endif output += "{} {} {} {} {} {}".format( \ lisp.lisp_print_sans("DDT authoritative-prefix entry"), lisp.lisp_print_cour(ddt_entry.print_eid_tuple()), lisp.lisp_print_sans("found for EID"), lisp.lisp_print_cour(eid_str), lisp.lisp_print_sans("<br><br>Computed negative-prefix"), neg_prefix) else: output += "{} {} {} {} {} {}".format( \ lisp.lisp_print_sans("DDT entry"), lisp.lisp_print_cour(ddt_entry.print_eid_tuple()), lisp.lisp_print_sans("found for EID"), lisp.lisp_print_cour(eid_str), lisp.lisp_print_sans(", delegation-type"), lisp.lisp_print_cour(ddt_entry.print_referral_type())) #endif return (output + "<br>")
def oOoooo0O0Oo(eid_str): o00ooO, OO0OO0O00oO0, oO, I1Ii1I1 = lispconfig.lisp_get_lookup_string( eid_str) if 28 - 28: O0 * Oo0Ooo - OOooOOo % iIii1I11I1II1 * Ii1I - i11iIiiIii if 7 - 7: Oo0Ooo + oO0o - I1Ii111 % Ii1I + I1ii11iIi11i ooo0OOOoo = "<br>" if 45 - 45: I1Ii111 / iIii1I11I1II1 + OoOoOO00 * OoO0O00 * OOooOOo.iII111i iI = lisp.lisp_referral_cache_lookup(o00ooO, oO, OO0OO0O00oO0) if (iI == None): ooo0OOOoo += "{} {}".format( lisp.lisp_print_sans("Lookup not found for"), lisp.lisp_print_cour(eid_str)) else: O0O0Oooo0o = lisp.lisp_print_elapsed(iI.uptime) ooo0OOOoo += "{}{}{}{}{}{}".format( lisp.lisp_print_sans("{} match lookup for ".format( "Exact" if OO0OO0O00oO0 else "Longest")), # iII111i + oO0o - I1IiiI . ooOoO0o # Ii1I - O0 % oO0o * OOooOOo + I1IiiI lisp.lisp_print_cour(eid_str), lisp.lisp_print_sans(" found "), lisp.lisp_print_cour(iI.print_eid_tuple()), lisp.lisp_print_sans(", referral-type {}".format( lisp.lisp_print_cour(iI.print_referral_type()))), # oO0o % ooOoO0o / I1Ii111 + iIii1I11I1II1 . OoooooooOO . I1IiiI lisp.lisp_print_sans(" with uptime {}".format( lisp.lisp_print_cour(O0O0Oooo0o)))) if 71 - 71: IiII * II111iiii * oO0o if 56 - 56: I1IiiI ooo0OOOoo += "<br>" return (ooo0OOOoo) if 54 - 54: I1Ii111 / OOooOOo.oO0o % iII111i if 57 - 57: i11iIiiIii.I1ii11iIi11i - Ii1I - oO0o + OoOoOO00 if 63 - 63: OoOoOO00 * iII111i if 69 - 69: O0.OoO0O00 if 49 - 49: I1IiiI - I11i if 74 - 74: iIii1I11I1II1 * I1ii11iIi11i + OoOoOO00 / i1IIi / II111iiii.Oo0Ooo if 62 - 62: OoooooooOO * I1IiiI
def oOO00O(eid_str): OOOoo0OO, oO0o0, iI1Ii11iIiI1, OO0Oooo0oOO0O = lispconfig.lisp_get_lookup_string( eid_str) if 62 - 62: I1IiiI if 100 - 100: Ii1I - O0 % oO0o * OOooOOo + I1IiiI Oo0O0oooo = "<br>" if 33 - 33: I1Ii111 + iII111i * oO0o / iIii1I11I1II1 - I1IiiI O0oO = lisp.lisp_referral_cache_lookup(OOOoo0OO, iI1Ii11iIiI1, oO0o0) if (O0oO == None): Oo0O0oooo += "{} {}".format( lisp.lisp_print_sans("Lookup not found for"), lisp.lisp_print_cour(eid_str)) else: OO0ooOOO0OOO = lisp.lisp_print_elapsed(O0oO.uptime) Oo0O0oooo += "{}{}{}{}{}{}".format( lisp.lisp_print_sans("{} match lookup for ".format( "Exact" if oO0o0 else "Longest")), # ooOoO0o / iII111i + II111iiii % O0 # OoO0O00 lisp.lisp_print_cour(eid_str), lisp.lisp_print_sans(" found "), lisp.lisp_print_cour(O0oO.print_eid_tuple()), lisp.lisp_print_sans(", referral-type {}".format( lisp.lisp_print_cour(O0oO.print_referral_type()))), # oO0o / I11i / I11i lisp.lisp_print_sans(" with uptime {}".format( lisp.lisp_print_cour(OO0ooOOO0OOO)))) if 87 - 87: Oo0Ooo.I1IiiI - II111iiii + O0 / Oo0Ooo / oO0o if 25 - 25: I1IiiI.I1IiiI - OoOoOO00 % OoOoOO00 - i11iIiiIii / I1Ii111 Oo0O0oooo += "<br>" return (Oo0O0oooo) if 51 - 51: Oo0Ooo / OoOoOO00.OOooOOo * o0oOOo0O0Ooo + OoO0O00 * IiII if 73 - 73: OoO0O00 + OoooooooOO - O0 - Ii1I - II111iiii if 99 - 99: ooOoO0o.Ii1I + I1Ii111 + OoooooooOO % o0oOOo0O0Ooo if 51 - 51: iIii1I11I1II1 if 34 - 34: oO0o + I1IiiI - oO0o if 17 - 17: II111iiii % iII111i + I11i - iII111i / OOooOOo + ooOoO0o if 59 - 59: OOooOOo % OoOoOO00.Ii1I * I1ii11iIi11i % I11i
def o000O0o(eid_str): iI1iII1, oO0OOoo0OO, O0ii1ii1ii, oooooOoo0ooo = lispconfig.lisp_get_lookup_string( eid_str) if 6 - 6: I11i - Ii1I + iIii1I11I1II1 - I1Ii111 - i11iIiiIii if 79 - 79: OoOoOO00 - O0 * OoO0O00 + OoOoOO00 % O0 * O0 oOOo0 = "<br>" if 54 - 54: O0 - IiII % OOooOOo if 77 - 77: OoOoOO00 / I1IiiI / OoO0O00 + OoO0O00.OOooOOo if 38 - 38: I1Ii111 if 7 - 7: O0.iII111i % I1ii11iIi11i - I1IiiI - iIii1I11I1II1 Oo0o0000o0o0 = lisp.lisp_ddt_cache_lookup(iI1iII1, O0ii1ii1ii, oO0OOoo0OO) if (Oo0o0000o0o0 == None): I111IIIiIii = "DDT entry not found for non-authoritative EID" oOOo0 += "{} {}".format(lisp.lisp_print_sans(I111IIIiIii), lisp.lisp_print_cour(eid_str)) return (oOOo0 + "<br>") if 85 - 85: I1ii11iIi11i % iII111i % ooOoO0o if 82 - 82: i11iIiiIii - iII111i * OoooooooOO / I11i if (Oo0o0000o0o0.is_auth_prefix()): if (O0ii1ii1ii.is_null()): i1oOo = lisp.lisp_ddt_compute_neg_prefix(iI1iII1, Oo0o0000o0o0, lisp.lisp_ddt_cache) i1oOo = lisp.lisp_print_cour(i1oOo.print_prefix()), else: oOO00Oo = lisp.lisp_ddt_compute_neg_prefix(O0ii1ii1ii, Oo0o0000o0o0, lisp.lisp_ddt_cache) i1oOo = lisp.lisp_ddt_compute_neg_prefix(iI1iII1, Oo0o0000o0o0, Oo0o0000o0o0.source_cache) i1oOo = lisp.lisp_print_cour("(" + i1oOo.print_prefix() + ", ") if 6 - 6: oO0o oOO00Oo = lisp.lisp_print_cour(oOO00Oo.print_prefix() + ")") if 68 - 68: OoOoOO00 - OoO0O00 i1oOo += oOO00Oo if 28 - 28: OoO0O00.OOooOOo / OOooOOo + Oo0Ooo.I1ii11iIi11i if 1 - 1: iIii1I11I1II1 / II111iiii oOOo0 += "{} {} {} {} {} {}".format( lisp.lisp_print_sans("DDT authoritative-prefix entry"), # I11i . OoooooooOO lisp.lisp_print_cour(Oo0o0000o0o0.print_eid_tuple()), lisp.lisp_print_sans("found for EID"), lisp.lisp_print_cour(eid_str), lisp.lisp_print_sans("<br><br>Computed negative-prefix"), i1oOo) else: oOOo0 += "{} {} {} {} {} {}".format( lisp.lisp_print_sans("DDT entry"), # o0oOOo0O0Ooo % iII111i * O0 lisp.lisp_print_cour(Oo0o0000o0o0.print_eid_tuple()), lisp.lisp_print_sans("found for EID"), lisp.lisp_print_cour(eid_str), lisp.lisp_print_sans(", delegation-type"), lisp.lisp_print_cour(Oo0o0000o0o0.print_referral_type())) if 87 - 87: i11iIiiIii return (oOOo0 + "<br>") if 93 - 93: I1ii11iIi11i - OoO0O00 % i11iIiiIii.iII111i / iII111i - I1Ii111 if 9 - 9: I1ii11iIi11i / Oo0Ooo - I1IiiI / OoooooooOO / iIii1I11I1II1 - o0oOOo0O0Ooo if 91 - 91: iII111i % i1IIi % iIii1I11I1II1 if 20 - 20: OOooOOo % Ii1I / Ii1I + Ii1I if 45 - 45: oO0o - IiII - OoooooooOO - OoO0O00.II111iiii / O0 if 51 - 51: O0 + iII111i if 8 - 8: oO0o * OoOoOO00 - Ii1I - OoO0O00 * OOooOOo % I1IiiI
def O0ooo0O0oo0(eid_str): oo0oOo, o000O0o, iI1iII1, oO0OOoo0OO = lispconfig.lisp_get_lookup_string( eid_str) if 65 - 65: Ii1I.iIii1I11I1II1 / O0 - Ii1I if 21 - 21: I1IiiI * iIii1I11I1II1 oooooOoo0ooo = "<br>" if 6 - 6: I11i - Ii1I + iIii1I11I1II1 - I1Ii111 - i11iIiiIii if 79 - 79: OoOoOO00 - O0 * OoO0O00 + OoOoOO00 % O0 * O0 if 61 - 61: II111iiii if 64 - 64: ooOoO0o / OoOoOO00 - O0 - I11i Oo0o0000o0o0 = lisp.lisp_ddt_cache_lookup(oo0oOo, iI1iII1, o000O0o) if (Oo0o0000o0o0 == None): O0oOoOOOoOO = "DDT entry not found for non-authoritative EID" oooooOoo0ooo += "{} {}".format(lisp.lisp_print_sans(O0oOoOOOoOO), lisp.lisp_print_cour(eid_str)) return (oooooOoo0ooo + "<br>") if 38 - 38: I1Ii111 if 7 - 7: O0.iII111i % I1ii11iIi11i - I1IiiI - iIii1I11I1II1 if (Oo0o0000o0o0.is_auth_prefix()): if (iI1iII1.is_null()): I111IIIiIii = lisp.lisp_ddt_compute_neg_prefix( oo0oOo, Oo0o0000o0o0, lisp.lisp_ddt_cache) I111IIIiIii = lisp.lisp_print_cour(I111IIIiIii.print_prefix()), else: oO0000OOo00 = lisp.lisp_ddt_compute_neg_prefix( iI1iII1, Oo0o0000o0o0, lisp.lisp_ddt_cache) I111IIIiIii = lisp.lisp_ddt_compute_neg_prefix( oo0oOo, Oo0o0000o0o0, Oo0o0000o0o0.source_cache) I111IIIiIii = lisp.lisp_print_cour("(" + I111IIIiIii.print_prefix() + ", ") if 27 - 27: I1IiiI % I1IiiI oO0000OOo00 = lisp.lisp_print_cour(oO0000OOo00.print_prefix() + ")") if 1 - 1: OoO0O00 - oO0o.I11i.OoO0O00 / Oo0Ooo + I11i I111IIIiIii += oO0000OOo00 if 78 - 78: O0.oO0o.II111iiii % OOooOOo if 49 - 49: Ii1I / OoO0O00.II111iiii oooooOoo0ooo += "{} {} {} {} {} {}".format( lisp.lisp_print_sans("DDT authoritative-prefix entry"), # OOooOOo + Oo0Ooo . i11iIiiIii - i1IIi / iIii1I11I1II1 lisp.lisp_print_cour(Oo0o0000o0o0.print_eid_tuple()), lisp.lisp_print_sans("found for EID"), lisp.lisp_print_cour(eid_str), lisp.lisp_print_sans("<br><br>Computed negative-prefix"), I111IIIiIii) else: oooooOoo0ooo += "{} {} {} {} {} {}".format( lisp.lisp_print_sans("DDT entry"), # i11iIiiIii / I11i lisp.lisp_print_cour(Oo0o0000o0o0.print_eid_tuple()), lisp.lisp_print_sans("found for EID"), lisp.lisp_print_cour(eid_str), lisp.lisp_print_sans(", delegation-type"), lisp.lisp_print_cour(Oo0o0000o0o0.print_referral_type())) if 18 - 18: o0oOOo0O0Ooo % iII111i * O0 return (oooooOoo0ooo + "<br>") if 87 - 87: i11iIiiIii if 93 - 93: I1ii11iIi11i - OoO0O00 % i11iIiiIii.iII111i / iII111i - I1Ii111 if 9 - 9: I1ii11iIi11i / Oo0Ooo - I1IiiI / OoooooooOO / iIii1I11I1II1 - o0oOOo0O0Ooo if 91 - 91: iII111i % i1IIi % iIii1I11I1II1 if 20 - 20: OOooOOo % Ii1I / Ii1I + Ii1I if 45 - 45: oO0o - IiII - OoooooooOO - OoO0O00.II111iiii / O0 if 51 - 51: O0 + iII111i
def lisp_ms_show_site_lookup(input_str): eid, eid_exact, group, group_exact = \ lispconfig.lisp_get_lookup_string(input_str) output = "<br>" # # Do lookup in site-cache first. # site_eid = lisp.lisp_site_eid_lookup(eid, group, eid_exact) if (site_eid and site_eid.is_star_g() == False): eid_str = site_eid.print_eid_tuple() registered = lisp.green("registered", True) if site_eid.registered \ else lisp.red("not registered", True) output += "{} '{}' {} {} {} {} {} {}".format( \ lisp.lisp_print_sans("Site"), lisp.lisp_print_cour(site_eid.site.site_name), lisp.lisp_print_sans("entry"), lisp.lisp_print_cour(eid_str), lisp.lisp_print_sans("found for EID"), lisp.lisp_print_cour(input_str), lisp.lisp_print_sans("site EID is"), lisp.lisp_print_cour(registered)) return (output + "<br>") #endif # # Compute negative prefixes. # neg_prefix, gneg_prefix, action = \ lisp.lisp_ms_compute_neg_prefix(eid, group) if (group.is_null()): neg_prefix = lisp.lisp_print_cour(neg_prefix.print_prefix()) else: gneg_prefix = lisp.lisp_print_cour(gneg_prefix.print_prefix()) neg_prefix = lisp.lisp_print_cour(neg_prefix.print_prefix()) neg_prefix = "(" + neg_prefix + ", " + gneg_prefix + ")" #endif if (action == lisp.LISP_DDT_ACTION_NOT_AUTH): banner = "Site entry not found for non-authoritative EID" output += "{} {} {} {}".format( lisp.lisp_print_sans(banner), lisp.lisp_print_cour(input_str), lisp.lisp_print_sans("<br><br>Computed negative-prefix"), neg_prefix) #endif # # Try to find a auth-prefix in the DDT-cache. # if (action == lisp.LISP_DDT_ACTION_DELEGATION_HOLE): ddt_entry = lisp.lisp_ddt_cache_lookup(eid, group, False) if (ddt_entry == None or ddt_entry.is_auth_prefix() == False): banner = "Could not find Authoritative-prefix entry for" output += "{} {} {} {}".format( lisp.lisp_print_sans(banner), lisp.lisp_print_cour(input_str), lisp.lisp_print_sans("<br><br>Computed negative-prefix"), neg_prefix) else: eid_str = ddt_entry.print_eid_tuple() output += "{} {} {} {} {} {}".format( \ lisp.lisp_print_sans("Authoritative-prefix entry"), lisp.lisp_print_cour(eid_str), lisp.lisp_print_sans("found for EID"), lisp.lisp_print_cour(input_str), lisp.lisp_print_sans("<br><br>Computed negative-prefix"), neg_prefix) #endif #endif return (output + "<br>")
def lisp_ms_show_site_detail_command(eid_key, group_key): eid = lisp.lisp_address(lisp.LISP_AFI_NONE, "", 0, 0) if (eid_key): if (eid_key == "[0]/0"): eid.store_iid_range(0, 0) else: eid.store_prefix(eid_key) #endif #endif group = lisp.lisp_address(lisp.LISP_AFI_NONE, "", 0, 0) if (group_key): group.store_prefix(group_key) eid_str = lisp.lisp_print_eid_tuple(eid, group) eid_str = lisp.lisp_print_cour(eid_str) # # Do longest match lookup. We do this so prefix slashes are not in URLs. # site_eid = lisp.lisp_site_eid_lookup(eid, group, True) if (site_eid == None): output = "Could not find EID {} in site cache".format(eid_str) return (output) #endif indent4 = lisp.space(4) indent8 = lisp.space(8) indent12 = lisp.space(12) yesno = lisp.green("yes", True) if site_eid.registered else \ lisp.red("no", True) output = '<font face="Sans-Serif">' sn = lisp.lisp_print_cour(site_eid.site.site_name) si = lisp.lisp_print_cour(str(site_eid.site_id)) xi = "0" if site_eid.xtr_id == 0 else lisp.lisp_hex_string(site_eid.xtr_id) xi = lisp.lisp_print_cour("0x" + xi) fr = lisp.lisp_print_elapsed(site_eid.first_registered) lr = lisp.lisp_print_elapsed(site_eid.last_registered) if (time.time() - site_eid.last_registered >= (site_eid.register_ttl / 2) and lr != "never"): lr = lisp.red(lr, True) #endif if (site_eid.last_registerer.afi == lisp.LISP_AFI_NONE): reger = "none" else: reger = site_eid.last_registerer.print_address() #endif reger = lisp.lisp_print_cour(reger) shutdown = ", " + lisp.lisp_print_cour("site is in admin-shutdown") if \ site_eid.site.shutdown else "" ams = ", accepting more specifics" if site_eid.accept_more_specifics \ else "" if (ams == "" and site_eid.dynamic): ams = ", dynamic" output += '''Site name: {}, EID-prefix: {}, registered: {}{}{} <br>'''.format(sn, eid_str, yesno, ams, shutdown) output += "{}Description: {}<br>".format( indent4, lisp.lisp_print_cour(site_eid.site.description)) output += "{}Last registerer: {}, xTR-ID: {}, site-ID: {}<br>".format( \ indent4, reger, xi, si) flags = site_eid.print_flags(False) flags = lisp.lisp_print_cour(flags) auth_type = "none" if (site_eid.registered): auth_type = "sha1" if (site_eid.auth_sha1_or_sha2) else "sha2" #endif output += ("{}First registered: {}, last registered: {}, auth-type: " + \ "{}, registration flags: {}<br>").format(indent4, lisp.lisp_print_cour(fr), lisp.lisp_print_cour(lr), lisp.lisp_print_cour(auth_type), flags) ttl = lisp.lisp_print_cour(str(site_eid.register_ttl) + " seconds") output += "{}{} registration timeout TTL: {}<br>".format( \ indent4, "Registered" if site_eid.use_register_ttl_requested else \ "Default", ttl) # # First print a policy line, if one is configured for this site-eid. # if (site_eid.policy): p = lisp.lisp_print_cour(site_eid.policy) output += "{}Apply policy: '{}'<br>".format(indent4, p) #endif # # Show proxy-reply settings. # yesno = "yes" if site_eid.force_proxy_reply else "no" yesno = lisp.lisp_print_cour(yesno) output += "{}Forcing proxy Map-Reply: {}<br>".format(indent4, yesno) if (site_eid.force_ttl != None): ttl = lisp.lisp_print_cour(str(site_eid.force_ttl) + " seconds") output += "{}Forced proxy Map-Reply TTL: {}<br>".format( \ indent4, ttl) #endif yesno = "yes" if site_eid.force_nat_proxy_reply else "no" yesno = lisp.lisp_print_cour(yesno) output += "{}Forcing proxy Map-Reply for xTRs behind NATs: {}<br>". \ format(indent4, yesno) yesno = "yes" if site_eid.pitr_proxy_reply_drop else "no" yesno = lisp.lisp_print_cour(yesno) output += "{}Send drop-action proxy Map-Reply to PITR: {}<br>".format( \ indent4, yesno) action = "not configured" if site_eid.proxy_reply_action == "" else \ site_eid.proxy_reply_action action = lisp.lisp_print_cour(action) output += "{}Proxy Map-Reply action: {}<br>".format(indent4, action) if (site_eid.force_proxy_reply and site_eid.echo_nonce_capable): yes = lisp.lisp_print_cour("yes") output += "{}RLOCs are echo-nonce capable: {}<br>".format(indent4, yes) #endif yesno = "yes" if site_eid.require_signature else "no" yesno = lisp.lisp_print_cour(yesno) output += "{}Require signatures: {}<br>".format(indent4, yesno) # # Print configured allowed RLOC-sets, if any. # any_rloc = "any" if len(site_eid.site.allowed_rlocs) == 0 else "" if (any_rloc != ""): any_rloc = lisp.lisp_print_cour(any_rloc) output += "{}Allowed RLOC-set: {}<br>".format(indent4, any_rloc) if (any_rloc == ""): for rloc in site_eid.site.allowed_rlocs.values(): a = lisp.lisp_print_cour(rloc.rloc.print_address()) s = lisp.lisp_print_cour(rloc.print_state()) up = lisp.lisp_print_cour(str(rloc.priority)) uw = lisp.lisp_print_cour(str(rloc.weight)) mp = lisp.lisp_print_cour(str(rloc.mpriority)) mw = lisp.lisp_print_cour(str(rloc.mweight)) rn = rloc.print_rloc_name(True) if (rn != ""): rn = ", " + rn output += '''{}{}, state: {}, up/uw/mp/mw: {}/{}/{}/{}{}<br>'''. \ format(indent8, a, s, up, uw, mp, mw, rn) #endfor #endif none = "none" if len(site_eid.registered_rlocs) == 0 else "" if (none != ""): none = lisp.lisp_print_cour(none) output += "<br>Registered RLOC-set ({}): {}<br>".format("merge-semantics" \ if (site_eid.merge_register_requested) else "replacement-semantics", none) if (none == ""): for rloc in site_eid.registered_rlocs: a = lisp.lisp_print_cour(rloc.rloc.print_address()) s = lisp.lisp_print_cour(rloc.print_state()) up = lisp.lisp_print_cour(str(rloc.priority)) uw = lisp.lisp_print_cour(str(rloc.weight)) mp = lisp.lisp_print_cour(str(rloc.mpriority)) mw = lisp.lisp_print_cour(str(rloc.mweight)) rn = rloc.print_rloc_name(True) if (rn != ""): rn = ", " + rn output += '''{}{}, state: {}, up/uw/mp/mw: {}/{}/{}/{}{}<br>'''.\ format(indent4, a, s, up, uw, mp, mw, rn) if (rloc.geo): geo = lisp.lisp_print_cour(rloc.geo.print_geo_url()) output += "{}geo: {}<br>".format(indent12, geo) #endif if (rloc.elp): elp = lisp.lisp_print_cour(rloc.elp.print_elp(False)) output += "{}elp: {}<br>".format(indent12, elp) #endif if (rloc.rle): rle = lisp.lisp_print_cour(rloc.rle.print_rle(True)) output += "{}rle: {}<br>".format(indent12, rle) #endif if (rloc.json): json = lisp.lisp_print_cour(rloc.json.print_json(True)) output += "{}json: {}<br>".format(indent12, json) #endif #endfor #endif none = "none" if len(site_eid.individual_registrations) == 0 else "" if (none == "none"): none = lisp.lisp_print_cour(none) elif (site_eid.inconsistent_registration): none = lisp.red("inconsistent registrations", True) none = lisp.lisp_print_cour(none) #endif output += "<br>Individual registrations: {}<br>".format(none) for site_eid in site_eid.individual_registrations.values(): yesno = lisp.green("yes", True) if site_eid.registered else \ lisp.red("no", True) auth_type = "sha1" if (site_eid.auth_sha1_or_sha2) else "sha2" auth_type = lisp.lisp_print_cour(auth_type) flags = site_eid.print_flags(False) flags = lisp.lisp_print_cour(flags) a = lisp.lisp_print_cour(site_eid.last_registerer.print_address()) fr = lisp.lisp_print_elapsed(site_eid.first_registered) fr = lisp.lisp_print_cour(fr) lr = lisp.lisp_print_elapsed(site_eid.last_registered) if (time.time() - site_eid.last_registered >= (site_eid.register_ttl / 2) and lr != "never"): lr = lisp.red(lr, True) #endif lr = lisp.lisp_print_cour(lr) si = lisp.lisp_print_cour(str(site_eid.site_id)) xi = lisp.lisp_print_cour(lisp.lisp_hex_string(site_eid.xtr_id)) output += ''' {}Registerer: {}, xTR-ID: 0x{}, site-id: {}, registered: {}<br> {}First registered: {}, last registered: {}, auth-type: {}, registration flags: {}<br> '''.format(indent4, a, xi, si, yesno, indent4, fr, lr, auth_type, flags) none = "none" if len(site_eid.registered_rlocs) == 0 else "" none = lisp.lisp_print_cour(none) output += "{}Registered RLOC-set: {}<br>".format(indent4, none) for rloc in site_eid.registered_rlocs: a = lisp.lisp_print_cour(rloc.rloc.print_address()) s = lisp.lisp_print_cour(rloc.print_state()) up = lisp.lisp_print_cour(str(rloc.priority)) uw = lisp.lisp_print_cour(str(rloc.weight)) mp = lisp.lisp_print_cour(str(rloc.mpriority)) mw = lisp.lisp_print_cour(str(rloc.mweight)) rn = rloc.print_rloc_name(True) if (rn != ""): rn = ", " + rn output += '''{}{}, state: {}, up/uw/mp/mw: {}/{}/{}/{}{}<br>'''.\ format(indent8, a, s, up, uw, mp, mw, rn) if (rloc.geo): geo = lisp.lisp_print_cour(rloc.geo.print_geo_url()) output += "{}geo: {}<br>".format(indent12, geo) #endif if (rloc.elp): elp = lisp.lisp_print_cour(rloc.elp.print_elp(False)) output += "{}elp: {}<br>".format(indent12, elp) #endif if (rloc.rle): rle = lisp.lisp_print_cour(rloc.rle.print_rle(True)) output += "{}rle: {}<br>".format(indent12, rle) #endif if (rloc.json): json = lisp.lisp_print_cour(rloc.json.print_json(True)) output += "{}json: {}<br>".format(indent12, json) #endif #endfor output += "<br>" #endif output += "</font>" return (output)