def ooo00Ooo(referral, delete_list):
if 93 - 93: i11iIiiIii - I1IiiI * I1ii11iIi11i * I11i % O0 + OoooooooOO
if (referral.expires == 0): return ([True, delete_list])
if 25 - 25: IiII + Ii1I / ooOoO0o.o0oOOo0O0Ooo % O0 * OoO0O00
o0O0oo0OO0O = lisp.lisp_get_timestamp()
if (referral.uptime + referral.referral_ttl > o0O0oo0OO0O):
return ([True, delete_list])
if 68 - 68: oO0o.I11i % OoooooooOO.I11i
if 64 - 64: iIii1I11I1II1 / I1IiiI.II111iiii + OoooooooOO.OoO0O00
if 56 - 56: Oo0Ooo.I1ii11iIi11i.I1IiiI
if 39 - 39: O0 + I1Ii111
if 91 - 91:
OoooooooOO - iIii1I11I1II1 + OoOoOO00 / OoO0O00.OoOoOO00 + O0
iIiii1iI1 = lisp.lisp_print_elapsed(referral.uptime)
i11ii1ii11i = referral.print_eid_tuple()
lisp.lprint(
"Referral for EID-prefix {} has timed out, had uptime of {}".format(
lisp.green(i11ii1ii11i, False), iIiii1iI1))
if 70 - 70: i1IIi - iII111i + Oo0Ooo
if 12 - 12: o0oOOo0O0Ooo - I1ii11iIi11i % OoOoOO00 * I11i
if 44 - 44: iII111i % Ii1I
if 41 - 41: i1IIi - I11i - Ii1I
if 8 - 8: OoO0O00 + I1Ii111 - o0oOOo0O0Ooo % Oo0Ooo % o0oOOo0O0Ooo * oO0o
delete_list.append(referral)
return ([True, delete_list])
if 9 - 9: Oo0Ooo - i11iIiiIii - OOooOOo * Ii1I + ooOoO0o
if 44 - 44: II111iiii
if 52 - 52: I1ii11iIi11i - Oo0Ooo + I1ii11iIi11i % o0oOOo0O0Ooo
if 35 - 35: iIii1I11I1II1
if 42 - 42: I1Ii111.I1IiiI.i1IIi + OoOoOO00 + OOooOOo + I1IiiI
if 31 - 31: iII111i.OOooOOo - ooOoO0o.OoooooooOO / OoooooooOO
if 56 - 56: OoO0O00 / oO0o / i11iIiiIii + OoooooooOO - Oo0Ooo - I11i
if 21 - 21: O0 % IiII.I1IiiI / II111iiii + IiII
def lisp_timeout_site_eid(site_eid, delete_list):
now = lisp.lisp_get_timestamp()
if (site_eid.registered == False): return (delete_list)
if (site_eid.last_registered + site_eid.register_ttl > now):
return (delete_list)
#endif
#
# Timed out.
#
m_or_r = "merge" if site_eid.merge_register_requested else "replacement"
dynamic = "dynamic " if site_eid.dynamic else ""
site_eid.registered = False
lisp.lisp_registered_count -= 1
elapsed = lisp.lisp_print_elapsed(site_eid.first_registered)
prefix_str = site_eid.print_eid_tuple()
registerer = site_eid.last_registerer.print_address_no_iid()
lisp.lprint(("Registration timeout for {}EID-prefix {} site '{}' " + \
"from {}, was registered for {}, {}-semantics").format(dynamic,
lisp.green(prefix_str, False), site_eid.site.site_name, registerer,
elapsed, m_or_r))
if (delete_list == None): return (None)
#
# Remove entries from site-cache for dynamic entries. For individual
# registrations, we put on the delete-list just to tell the caller if
# anything change so we can recommpute the merged set..
#
delete_list.append(site_eid)
return (delete_list)
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 OooooO0oOOOO(referral, delete_list):
if 100 - 100: iII111i % OOooOOo
if (referral.expires == 0): return ([True, delete_list])
if 86 - 86: Oo0Ooo.O0 - OoooooooOO.OoO0O00 + Ii1I
OOo = lisp.lisp_get_timestamp()
if (referral.uptime + referral.referral_ttl > OOo):
return ([True, delete_list])
if 22 - 22: OoOoOO00 * O0.IiII * i11iIiiIii - I1IiiI * ooOoO0o
if 59 - 59: Oo0Ooo % OoooooooOO.iII111i / IiII + I1IiiI
if 76 - 76: ooOoO0o
if 73 - 73: O0 * iII111i + Ii1I + ooOoO0o
if 40 - 40: II111iiii.OoOoOO00 * I1Ii111 + OOooOOo + OOooOOo
I1ii1I1iiii = lisp.lisp_print_elapsed(referral.uptime)
iiI = referral.print_eid_tuple()
lisp.lprint(
"Referral for EID-prefix {} has timed out, had uptime of {}".format(
lisp.green(iiI, False), I1ii1I1iiii))
if 56 - 56: Oo0Ooo.I1ii11iIi11i.I1IiiI
if 39 - 39: O0 + I1Ii111
if 91 - 91: OoooooooOO - iIii1I11I1II1 + OoOoOO00 / OoO0O00.OoOoOO00 + O0
if 26 - 26: I1ii11iIi11i - OoooooooOO
if 11 - 11: I1IiiI * oO0o
delete_list.append(referral)
return ([True, delete_list])
if 81 - 81: iII111i + IiII
if 98 - 98: I1IiiI
if 95 - 95: ooOoO0o / ooOoO0o
if 30 - 30: I1ii11iIi11i + Oo0Ooo / Oo0Ooo % I1ii11iIi11i.I1ii11iIi11i
if 55 - 55: ooOoO0o - I11i + II111iiii + iII111i % Ii1I
if 41 - 41: i1IIi - I11i - Ii1I
if 8 - 8: OoO0O00 + I1Ii111 - o0oOOo0O0Ooo % Oo0Ooo % o0oOOo0O0Ooo * oO0o
if 9 - 9: Oo0Ooo - i11iIiiIii - OOooOOo * Ii1I + ooOoO0o
def oOOo0(ref, output):
if 54 - 54: O0 - IiII % OOooOOo
OOoO = lisp.lisp_print_elapsed(ref.uptime)
iII = lisp.lisp_print_future(ref.expires)
ii1ii11IIIiiI = ref.print_eid_tuple()
if 67 - 67: I11i * oO0o * I1ii11iIi11i + OOooOOo / i1IIi
I1I111 = "configured" if (ref.referral_source.not_set(
)) else ref.referral_source.print_address_no_iid()
if 82 - 82: i11iIiiIii - iII111i * OoooooooOO / I11i
if 31 - 31: IiII.OoO0O00 - iIii1I11I1II1
ooOOO00Ooo = "--"
if (ref.eid.is_ultimate_root()):
IiIIIi1iIi = "root"
elif (I1I111 == "configured"):
IiIIIi1iIi = "any"
else:
IiIIIi1iIi = ref.print_referral_type()
if (ref.is_referral_negative()):
IiIIIi1iIi = lisp.red(IiIIIi1iIi, True)
if 68 - 68: i11iIiiIii % I1ii11iIi11i + i11iIiiIii
ooOOO00Ooo = "{}<br>{}".format(iII, str(ref.referral_ttl / 60))
if 31 - 31: II111iiii.I1IiiI
if 1 - 1: Oo0Ooo / o0oOOo0O0Ooo % iII111i * IiII.i11iIiiIii
if (len(ref.referral_set) == 0):
output += lispconfig.lisp_table_row(ii1ii11IIIiiI, OOoO, ooOOO00Ooo,
IiIIIi1iIi, I1I111, "--", "--",
"--")
if 2 - 2: I1ii11iIi11i * I11i - iIii1I11I1II1 + I1IiiI.oO0o % iII111i
if 92 - 92: iII111i
for O0OOO0OOoO0O in list(ref.referral_set.values()):
IIiIiiIi = O0OOO0OOoO0O.referral_address.print_address_no_iid()
IIiIiiIi += "<br>up" if O0OOO0OOoO0O.updown else "<br>down"
if 51 - 51:
I11i + iII111i % iIii1I11I1II1 / oO0o / OOooOOo % OoooooooOO
output += lispconfig.lisp_table_row(
ii1ii11IIIiiI, OOoO, ooOOO00Ooo, IiIIIi1iIi, I1I111, IIiIiiIi,
str(O0OOO0OOoO0O.priority) + "<br>" + str(O0OOO0OOoO0O.weight),
str(O0OOO0OOoO0O.map_requests_sent) + "<br>" +
str(O0OOO0OOoO0O.no_responses))
if 78 - 78: Ii1I % I1Ii111 + I1ii11iIi11i
if (ii1ii11IIIiiI != ""):
ii1ii11IIIiiI = ""
OOoO = ""
ooOOO00Ooo = ""
I1I111 = ""
IiIIIi1iIi = ""
if 64 - 64: oO0o * O0.I1IiiI + II111iiii
if 6 - 6: OoOoOO00 / iII111i.IiII.IiII
return ([True, output])
if 62 - 62: I1ii11iIi11i + IiII % iII111i + OOooOOo
if 33 - 33: O0.IiII.I1IiiI
if 72 - 72: i1IIi / OoO0O00 + OoooooooOO - Oo0Ooo
if 29 - 29: I1ii11iIi11i + oO0o % O0
if 10 - 10: I11i / I1Ii111 - I1IiiI * iIii1I11I1II1 - I1IiiI
if 97 - 97: I1ii11iIi11i + I1IiiI * Ii1I + OOooOOo % iII111i
if 74 - 74: oO0o - Oo0Ooo + OoooooooOO + I1Ii111 / OoOoOO00
if 23 - 23: O0
def iiii(ref, output):
if 1 - 1: Oo0Ooo / o0oOOo0O0Ooo % iII111i * IiII.i11iIiiIii
III1Iiii1I11 = lisp.lisp_print_elapsed(ref.uptime)
IIII = lisp.lisp_print_future(ref.expires)
iiIiI = ref.print_eid_tuple()
if 91 - 91: iII111i % i1IIi % iIii1I11I1II1
IIi1I11I1II = "configured" if (ref.referral_source.not_set(
)) else ref.referral_source.print_address_no_iid()
if 63 - 63: OoooooooOO - OoO0O00.II111iiii / o0oOOo0O0Ooo.OoOoOO00 / O0
if 84 - 84: IiII
OOO00O0O = "--"
if (ref.eid.is_ultimate_root()):
iii = "root"
elif (IIi1I11I1II == "configured"):
iii = "any"
else:
iii = ref.print_referral_type()
if (ref.is_referral_negative()):
iii = lisp.red(iii, True)
if 90 - 90: o0oOOo0O0Ooo % i1IIi / OoO0O00
OOO00O0O = "{}<br>{}".format(IIII, str(ref.referral_ttl / 60))
if 44 - 44: Oo0Ooo.OoO0O00 / I1ii11iIi11i + Ii1I
if 65 - 65: O0
if (len(ref.referral_set) == 0):
output += lispconfig.lisp_table_row(iiIiI, III1Iiii1I11, OOO00O0O, iii,
IIi1I11I1II, "--", "--", "--")
if 68 - 68: OOooOOo % I1Ii111
if 88 - 88: iIii1I11I1II1 - ooOoO0o + OOooOOo
for O0O0OoOO0 in ref.referral_set.values():
IiI111111IIII = O0O0OoOO0.referral_address.print_address_no_iid()
IiI111111IIII += "<br>up" if O0O0OoOO0.updown else "<br>down"
if 37 - 37: I1Ii111 / OoOoOO00
output += lispconfig.lisp_table_row(
iiIiI, III1Iiii1I11, OOO00O0O, iii, IIi1I11I1II, IiI111111IIII,
str(O0O0OoOO0.priority) + "<br>" + str(O0O0OoOO0.weight),
str(O0O0OoOO0.map_requests_sent) + "<br>" +
str(O0O0OoOO0.no_responses))
if 23 - 23: O0
if (iiIiI != ""):
iiIiI = ""
III1Iiii1I11 = ""
OOO00O0O = ""
IIi1I11I1II = ""
iii = ""
if 85 - 85: Ii1I
if 84 - 84:
I1IiiI.iIii1I11I1II1 % OoooooooOO + Ii1I % OoooooooOO % OoO0O00
return ([True, output])
if 42 - 42: OoO0O00 / I11i / o0oOOo0O0Ooo + iII111i / OoOoOO00
if 84 - 84: ooOoO0o * II111iiii + Oo0Ooo
if 53 - 53: iII111i % II111iiii.IiII - iIii1I11I1II1 - IiII * II111iiii
if 77 - 77: iIii1I11I1II1 * OoO0O00
if 95 - 95: I1IiiI + i11iIiiIii
if 6 - 6: ooOoO0o / i11iIiiIii + iII111i * oO0o
if 80 - 80: II111iiii
if 83 - 83: I11i.i11iIiiIii + II111iiii.o0oOOo0O0Ooo * I11i
def lisp_display_referral_cache(ref, output):
uts = lisp.lisp_print_elapsed(ref.uptime)
ets = lisp.lisp_print_future(ref.expires)
prefix = ref.print_eid_tuple()
ref_source = "configured" if (ref.referral_source.not_set()) else \
ref.referral_source.print_address_no_iid()
time_str = "--"
if (ref.eid.is_ultimate_root()):
ref_type = "root"
elif (ref_source == "configured"):
ref_type = "any"
else:
ref_type = ref.print_referral_type()
if (ref.is_referral_negative()):
ref_type = lisp.red(ref_type, True)
#endif
time_str = "{}<br>{}".format(ets, str(ref.referral_ttl / 60))
#endif
if (len(ref.referral_set) == 0):
output += lispconfig.lisp_table_row(prefix, uts, time_str, ref_type,
ref_source, "--", "--", "--")
#endif
for ref_node in ref.referral_set.values():
addr = ref_node.referral_address.print_address_no_iid()
addr += "<br>up" if ref_node.updown else "<br>down"
output += lispconfig.lisp_table_row(
prefix, uts, time_str, ref_type, ref_source, addr,
str(ref_node.priority) + "<br>" + str(ref_node.weight),
str(ref_node.map_requests_sent) + "<br>" +
str(ref_node.no_responses))
if (prefix != ""):
prefix = ""
uts = ""
time_str = ""
ref_source = ""
ref_type = ""
#endif
#endfor
return ([True, output])
def lisp_timeout_referral_entry(referral, delete_list):
if (referral.expires == 0): return ([True, delete_list])
now = lisp.lisp_get_timestamp()
if (referral.uptime + referral.referral_ttl > now):
return ([True, delete_list])
#endif
#
# Timed out.
#
elapsed = lisp.lisp_print_elapsed(referral.uptime)
prefix_str = referral.print_eid_tuple()
lisp.lprint("Referral for EID-prefix {} has timed out, had uptime of {}". \
format(lisp.green(prefix_str, False), elapsed))
#
# Add to delete-list to remove after this loop.
#
delete_list.append(referral)
return ([True, delete_list])
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 lisp_ms_show_site_command(parameter):
#
# Do detailed display.
#
if (parameter != ""):
if (parameter.find("@lookup") != -1):
parameter = parameter.split("@")
return (lisp_ms_show_site_lookup(parameter[0]))
#endif
eid = parameter.split("%")[0]
group = parameter.split("%")[1]
return (lisp_ms_show_site_detail_command(eid, group))
#endif
#
# Top part of display has the form for doing a specific lookup.
#
banner = "Enter EID for Site-Cache lookup:"
input_rectangle = \
lisp.lisp_eid_help_hover('<input type="text" name="eid" />')
output = '''
<form action="/lisp/show/site/lookup" method="post">
<i><font face="Courier New" size="3">
{} {}
<input style="background-color:transparent;border-radius:10px;" type="submit" value="Submit" />
</font></i></form>
'''.format(lisp.lisp_print_sans(banner), input_rectangle)
#
# First display auth-prefix and map-server-peer configuration, if any.
#
if (lisp.lisp_ddt_cache.cache_count != 0):
output += lisp_ms_show_ddt_entries()
#endif
#
# Do table display.
#
hover = ("{} sites & {} eid-prefixes configured\n{} eid-prefixes " + \
"registered").format(len(lisp_sites_by_name),
lisp.lisp_sites_by_eid.cache_size(), lisp.lisp_registered_count)
title = lisp.lisp_span("LISP-MS Site Information:", hover)
output += lispconfig.lisp_table_header(title, "Site Name",
"EID-Prefix or (S,G)", "Registered",
"Last Registerer",
"Last Registered",
"First Registered",
"Registration Flags")
for site_name in lisp_sites_by_name_sorted:
site = lisp_sites_by_name[site_name]
first = True
for key in site.allowed_prefixes_sorted:
site_eid = site.allowed_prefixes[key]
output = lisp_display_site_eid_entry(site_eid, site, first, output)
if (first): first = False
for ms_site_eid in site_eid.more_specific_registrations:
output = lisp_display_site_eid_entry(ms_site_eid, site, first,
output)
#endfor
#endfor
#endfor
output += lispconfig.lisp_table_footer()
#
# Show NAT-traversal lisp_nat_state_info table for an RTR. In the future
# show this. Problem know is that the lisp-core process will process
# Info-Requests for the control-plane port 4342.
#
# output = lispconfig.lisp_display_nat_info(output, "Control")
if (lisp.lisp_pubsub_cache == {}): return (output)
#
# Display pubsub cache.
#
title = "LISP-MS Subscriber Information:"
output += lispconfig.lisp_table_header(title, "EID-prefix",
"Uptime<br>TTL", "Subscriber RLOC",
"xTR-ID", "Nonce",
"Map-Notifies<br>Sent")
for e in lisp.lisp_pubsub_cache:
eid = e
for pubsub in lisp.lisp_pubsub_cache[e].values():
rloc_str = pubsub.itr.print_address_no_iid() + ":" + \
str(pubsub.port)
ut = lisp.lisp_print_elapsed(pubsub.uptime) + "<br>" + \
str(pubsub.ttl) + " mins"
xtr_id = "--"
if (pubsub.xtr_id != None):
xtr_id = "0x" + lisp.lisp_hex_string(pubsub.xtr_id)
#endif
nonce = "0x" + lisp.lisp_hex_string(pubsub.nonce)
c = pubsub.map_notify_count
output += lispconfig.lisp_table_row(eid, ut, rloc_str, xtr_id,
nonce, c)
eid = ""
#endfor
#endfor
output += lispconfig.lisp_table_footer()
return (output)
def lisp_display_site_eid_entry(site_eid, site, first, output):
eid_str = site_eid.print_eid_tuple()
eid_str = eid_str.replace("no-address/0", "")
#
# Create URL format for all of (*,G), (S,G), and an EID-prefix.
#
eid = site_eid.eid
group = site_eid.group
if (eid.is_null() and group.is_null() == False):
url = "{}-*-{}".format(group.instance_id, group.print_prefix_url())
eid_str = "<a href='/lisp/show/site/{}'>{}</a>".format(url, eid_str)
#endif
if (eid.is_null() == False and group.is_null()):
url = "{}".format(eid.print_prefix_url())
#
# Distinguished-Name EIDs have "'"s in them.
#
if (url.find("'") != -1):
url = url.replace("'", "name-", 1)
url = url.replace("'", "")
else:
#
# E.164 EIDs have "+"s in them.
#
url = url.replace("+", "plus-")
#endif
eid_str = "<a href='/lisp/show/site/{}'>{}</a>".format(url, eid_str)
#endif
if (eid.is_null() == False and group.is_null() == False):
url = "{}-{}".format(eid.print_prefix_url(), group.print_prefix_url())
eid_str = "<a href='/lisp/show/site/{}'>{}</a>".format(url, eid_str)
#endif
site_name = site.site_name if first else ""
flags = "--"
if (site_eid.registered): flags = site_eid.print_flags(True)
registerer = "--"
if (site_eid.last_registerer.afi != lisp.LISP_AFI_NONE):
registerer = site_eid.last_registerer.print_address()
#endif
registered = lisp.green("yes", True) if site_eid.registered else \
lisp.red("no", True)
if (site.shutdown): registered = lisp.red("admin-shutdown", True)
if (site_eid.dynamic):
registered += " (dynamic)"
elif (site_eid.accept_more_specifics):
registered = "(ams)"
#endif
lts = lisp.lisp_print_elapsed(site_eid.last_registered)
if (time.time() - site_eid.last_registered >= (site_eid.register_ttl / 2)
and lts != "never"):
lts = lisp.red(lts, True)
#endif
fts = lisp.lisp_print_elapsed(site_eid.first_registered)
if (site_eid.accept_more_specifics):
num = len(site_eid.more_specific_registrations)
hover = "{} EID-prefixes registered".format(num)
eid_str = lisp.lisp_span(eid_str, hover)
#endif
output += lispconfig.lisp_table_row(site_name, eid_str, registered,
registerer, lts, fts, flags)
return (output)
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)
def oO0o0o0oo(parameter):
if 32 - 32: OOooOOo
if 42 - 42: IiII * O0 % i1IIi.OOooOOo / o0oOOo0O0Ooo
if 32 - 32: I1IiiI * Oo0Ooo
if 78 - 78: OOooOOo - OoooooooOO - I1ii11iIi11i / ooOoO0o / II111iiii
if (parameter != ""):
return (oOO00O(parameter))
if 29 - 29: I1IiiI % I1IiiI
if 94 - 94: iIii1I11I1II1 / Oo0Ooo % iII111i * iII111i * II111iiii
if 29 - 29: OoO0O00 + OoOoOO00 / o0oOOo0O0Ooo / OOooOOo * iIii1I11I1II1
if 62 - 62: OOooOOo / oO0o - OoO0O00.I11i
if 11 - 11: I1ii11iIi11i.OoO0O00 * IiII * OoooooooOO + ooOoO0o
IiII111i1i11 = "Enter EID for Referral-Cache lookup:"
i111iIi1i1II1 = lisp.lisp_eid_help_hover(
'<input type="text" name="eid" />')
if 86 - 86: iIii1I11I1II1 / OoOoOO00.II111iiii
Oo0O0oooo = '''
<form action="/lisp/show/referral/lookup" method="post">
<i><font face="Courier New" size="3">
{} {}
<input style="background-color:transparent;border-radius:10px;" type="submit" value="Submit" />
</font></i></form>
'''.format(lisp.lisp_print_sans(IiII111i1i11), i111iIi1i1II1)
if 19 - 19: I1ii11iIi11i % OoooooooOO % IiII * o0oOOo0O0Ooo % O0
if 67 - 67: I1IiiI.i1IIi
if 27 - 27: ooOoO0o % I1IiiI
if 73 - 73: OOooOOo
ooO = len(lisp.lisp_ddt_map_requestQ)
if (ooO != 0):
Ooo0oOooo0 = "{} entries in map-request queue".format(ooO)
oOOOoo00 = lisp.lisp_span("LISP-MR Map-Request Queue:", Ooo0oOooo0)
if 9 - 9: O0 % O0 - o0oOOo0O0Ooo
Oo0O0oooo += lispconfig.lisp_table_header(
oOOOoo00, "EID-Prefix or (S,G)", "Nonce", "Uptime",
"Map-Request Source", "Retry Count", "Tried DDT-Root",
"Last Request Sent To", "Last Map-Referral EID-Prefix")
if 51 - 51: I1IiiI.iIii1I11I1II1 - I1ii11iIi11i / O0
for OOOoO00 in lisp.lisp_ddt_map_requestQ:
IIiIi11i1i = lisp.lisp_ddt_map_requestQ[OOOoO00]
I1II1I11I1I = lisp.lisp_print_elapsed(IIiIi11i1i.uptime)
OoOO0o = IIiIi11i1i.last_request_sent_to
OoOO0o = "--" if (OoOO0o
== None) else OoOO0o.print_address_no_iid()
if 1 - 1: II111iiii
O0oOo00o = IIiIi11i1i.itr
O0oOo00o = "--" if (O0oOo00o == None) else (
O0oOo00o.print_address_no_iid() +
"<br>({}ITR)".format("P" if IIiIi11i1i.from_pitr else ""))
if 81 - 81: IiII % i1IIi.iIii1I11I1II1
if 4 - 4: i11iIiiIii % OoO0O00 % i1IIi / IiII
I11iI = IIiIi11i1i.last_cached_prefix[0]
ooOoo = IIiIi11i1i.last_cached_prefix[1]
I1III1111iIi = "--" if (
I11iI == None) else lisp.lisp_print_eid_tuple(I11iI, ooOoo)
if 38 - 38: iII111i + I11i / I1Ii111 % ooOoO0o - I1ii11iIi11i
if 14 - 14: oO0o / I1Ii111
Oo0O0oooo += lispconfig.lisp_table_row(
IIiIi11i1i.print_eid_tuple(),
"0x" + lisp.lisp_hex_string(IIiIi11i1i.nonce), I1II1I11I1I,
O0oOo00o, IIiIi11i1i.retry_count,
"yes" if IIiIi11i1i.tried_root else "no", OoOO0o, I1III1111iIi)
if 85 - 85: I11i
if 20 - 20: oO0o % IiII
Oo0O0oooo += lispconfig.lisp_table_footer()
if 19 - 19: I1ii11iIi11i % IiII + ooOoO0o / I1Ii111.ooOoO0o
if 12 - 12: i1IIi + i1IIi - I1ii11iIi11i * Oo0Ooo % Oo0Ooo - II111iiii
Ooo0oOooo0 = "{} entries in referral-cache".format(
lisp.lisp_referral_cache.cache_size())
if 52 - 52: ooOoO0o.iII111i + I1Ii111
oOOOoo00 = lisp.lisp_span("LISP-MR Referral-Cache:", Ooo0oOooo0)
if 38 - 38: i1IIi - II111iiii.I1Ii111
Oo0O0oooo += lispconfig.lisp_table_header(
oOOOoo00, "EID-Prefix or (S,G)", "Uptime", "Expires<br>TTL",
"Referral Type", "Map-Referral Source",
"Referral Address<br>Node Status", "Priority<br>Weight",
"Map-Requests Sent<br>No Responses")
if 58 - 58: I1IiiI.iII111i + OoOoOO00
Oo0O0oooo = lisp.lisp_referral_cache.walk_cache(oooO0, Oo0O0oooo)
if 66 - 66: iII111i / oO0o * OoooooooOO + OoooooooOO % I11i
Oo0O0oooo += lispconfig.lisp_table_footer()
return (Oo0O0oooo)
if 49 - 49: oO0o - i11iIiiIii.I1Ii111 * Ii1I % iII111i + i1IIi
if 71 - 71: o0oOOo0O0Ooo
if 38 - 38: oO0o % OoOoOO00 + I1ii11iIi11i.i11iIiiIii
if 53 - 53: i11iIiiIii * iII111i
if 68 - 68: iIii1I11I1II1 * iIii1I11I1II1.o0oOOo0O0Ooo / II111iiii % Oo0Ooo
if 38 - 38: ooOoO0o - OOooOOo / iII111i
if 66 - 66: O0 % I1ii11iIi11i + i11iIiiIii.OoOoOO00 / Ii1I + I1ii11iIi11i
def lisp_mr_show_referral_cache_command(parameter):
#
# Do lookup if there is a parameter supplied.
#
if (parameter != ""):
return (lisp_mr_show_referral_cache_lookup(parameter))
#endif
#
# Top part of display has the form for doing a specific lookup.
#
banner = "Enter EID for Referral-Cache lookup:"
input_rectangle = \
lisp.lisp_eid_help_hover('<input type="text" name="eid" />')
output = '''
<form action="/lisp/show/referral/lookup" method="post">
<i><font face="Courier New" size="3">
{} {}
<input style="background-color:transparent;border-radius:10px;" type="submit" value="Submit" />
</font></i></form>
'''.format(lisp.lisp_print_sans(banner), input_rectangle)
#
# Display the DDT Map-Request queue contents if anything is in it.
#
queue_size = len(lisp.lisp_ddt_map_requestQ)
if (queue_size != 0):
hover = "{} entries in map-request queue".format(queue_size)
title = lisp.lisp_span("LISP-MR Map-Request Queue:", hover)
output += lispconfig.lisp_table_header(title, "EID-Prefix or (S,G)",
"Nonce", "Uptime",
"Map-Request Source",
"Retry Count", "Tried DDT-Root",
"Last Request Sent To",
"Last Map-Referral EID-Prefix")
for key in lisp.lisp_ddt_map_requestQ:
mr = lisp.lisp_ddt_map_requestQ[key]
ut = lisp.lisp_print_elapsed(mr.uptime)
last_sent = mr.last_request_sent_to
last_sent = "--" if (last_sent == None) else \
last_sent.print_address_no_iid()
itr = mr.itr
itr = "--" if (itr == None) else (itr.print_address_no_iid() + \
"<br>({}ITR)".format("P" if mr.from_pitr else ""))
last_eid = mr.last_cached_prefix[0]
last_group = mr.last_cached_prefix[1]
last_prefix = "--" if (last_eid == None) else \
lisp.lisp_print_eid_tuple(last_eid, last_group)
output += lispconfig.lisp_table_row(
mr.print_eid_tuple(), "0x" + lisp.lisp_hex_string(mr.nonce),
ut, itr, mr.retry_count, "yes" if mr.tried_root else "no",
last_sent, last_prefix)
#endfor
output += lispconfig.lisp_table_footer()
#endif
hover = "{} entries in referral-cache".format( \
lisp.lisp_referral_cache.cache_size())
title = lisp.lisp_span("LISP-MR Referral-Cache:", hover)
output += lispconfig.lisp_table_header(
title, "EID-Prefix or (S,G)", "Uptime", "Expires<br>TTL",
"Referral Type", "Map-Referral Source",
"Referral Address<br>Node Status", "Priority<br>Weight",
"Map-Requests Sent<br>No Responses")
output = lisp.lisp_referral_cache.walk_cache(lisp_walk_referral_cache,
output)
output += lispconfig.lisp_table_footer()
return (output)
def oOOOoo0O0oO(parameter):
if 6 - 6: OOooOOo * o0oOOo0O0Ooo + iII111i
if 44 - 44: Ii1I % OoO0O00 + OoooooooOO - O0 - Ii1I - II111iiii
if 99 - 99: ooOoO0o.Ii1I + I1Ii111 + OoooooooOO % o0oOOo0O0Ooo
if 51 - 51: iIii1I11I1II1
if (parameter != ""):
return (oOoooo0O0Oo(parameter))
if 34 - 34: oO0o + I1IiiI - oO0o
if 17 - 17: II111iiii % iII111i + I11i - iII111i / OOooOOo + ooOoO0o
if 59 - 59: OOooOOo % OoOoOO00.Ii1I * I1ii11iIi11i % I11i
if 59 - 59: oO0o - iII111i
if 15 - 15: I1Ii111.i11iIiiIii.OoooooooOO / OoO0O00 % Ii1I
OooooOOoo0 = "Enter EID for Referral-Cache lookup:"
i1I1IiiIi1i = lisp.lisp_eid_help_hover('<input type="text" name="eid" />')
if 29 - 29: I1IiiI % I1IiiI
ooo0OOOoo = '''
<form action="/lisp/show/referral/lookup" method="post">
<i><font face="Courier New" size="3">
{} {}
<input style="background-color:transparent;border-radius:10px;" type="submit" value="Submit" />
</font></i></form>
'''.format(lisp.lisp_print_sans(OooooOOoo0), i1I1IiiIi1i)
if 94 - 94: iIii1I11I1II1 / Oo0Ooo % iII111i * iII111i * II111iiii
if 29 - 29: OoO0O00 + OoOoOO00 / o0oOOo0O0Ooo / OOooOOo * iIii1I11I1II1
if 62 - 62: OOooOOo / oO0o - OoO0O00.I11i
if 11 - 11: I1ii11iIi11i.OoO0O00 * IiII * OoooooooOO + ooOoO0o
IiII111i1i11 = len(lisp.lisp_ddt_map_requestQ)
if (IiII111i1i11 != 0):
i111iIi1i1II1 = "{} entries in map-request queue".format(IiII111i1i11)
oooO = lisp.lisp_span("LISP-MR Map-Request Queue:", i111iIi1i1II1)
if 26 - 26: Ii1I % I1ii11iIi11i
ooo0OOOoo += lispconfig.lisp_table_header(
oooO, "EID-Prefix or (S,G)", "Nonce", "Uptime",
"Map-Request Source", "Retry Count", "Tried DDT-Root",
"Last Request Sent To", "Last Map-Referral EID-Prefix")
if 76 - 76: IiII * iII111i
for ooooooo00o in lisp.lisp_ddt_map_requestQ:
o0oooOO00 = lisp.lisp_ddt_map_requestQ[ooooooo00o]
iiIiii1IIIII = lisp.lisp_print_elapsed(o0oooOO00.uptime)
o00o = o0oooOO00.last_request_sent_to
o00o = "--" if (o00o == None) else o00o.print_address_no_iid()
if 45 - 45:
I1ii11iIi11i.o0oOOo0O0Ooo.I1ii11iIi11i - I1IiiI.o0oOOo0O0Ooo
iiI1IIIi = o0oooOO00.itr
iiI1IIIi = "--" if (iiI1IIIi == None) else (
iiI1IIIi.print_address_no_iid() +
"<br>({}ITR)".format("P" if o0oooOO00.from_pitr else ""))
if 47 - 47: Oo0Ooo % I11i % i11iIiiIii - O0 + ooOoO0o
if 94 - 94: I1Ii111
i11II1I11I1 = o0oooOO00.last_cached_prefix[0]
OOoOO0ooo = o0oooOO00.last_cached_prefix[1]
II1iIi11 = "--" if (i11II1I11I1
== None) else lisp.lisp_print_eid_tuple(
i11II1I11I1, OOoOO0ooo)
if 12 - 12: Ii1I + i11iIiiIii * iIii1I11I1II1 / I1ii11iIi11i.I11i
if 5 - 5: i1IIi + IiII / o0oOOo0O0Ooo.iII111i / I11i
ooo0OOOoo += lispconfig.lisp_table_row(
o0oooOO00.print_eid_tuple(),
"0x" + lisp.lisp_hex_string(o0oooOO00.nonce), iiIiii1IIIII,
iiI1IIIi, o0oooOO00.retry_count,
"yes" if o0oooOO00.tried_root else "no", o00o, II1iIi11)
if 32 - 32: I1IiiI % iIii1I11I1II1 / i1IIi - I1IiiI
if 7 - 7: I1Ii111 * OoO0O00 - ooOoO0o + OOooOOo * I1IiiI % OoO0O00
ooo0OOOoo += lispconfig.lisp_table_footer()
if 15 - 15: OoOoOO00 % I1IiiI * I11i
if 81 - 81: ooOoO0o - iIii1I11I1II1 - i1IIi / I1Ii111 - O0 * I11i
i111iIi1i1II1 = "{} entries in referral-cache".format(
lisp.lisp_referral_cache.cache_size())
if 20 - 20: oO0o % IiII
oooO = lisp.lisp_span("LISP-MR Referral-Cache:", i111iIi1i1II1)
if 19 - 19: I1ii11iIi11i % IiII + ooOoO0o / I1Ii111.ooOoO0o
ooo0OOOoo += lispconfig.lisp_table_header(
oooO, "EID-Prefix or (S,G)", "Uptime", "Expires<br>TTL",
"Referral Type", "Map-Referral Source",
"Referral Address<br>Node Status", "Priority<br>Weight",
"Map-Requests Sent<br>No Responses")
if 12 - 12: i1IIi + i1IIi - I1ii11iIi11i * Oo0Ooo % Oo0Ooo - II111iiii
ooo0OOOoo = lisp.lisp_referral_cache.walk_cache(o00oO0oOo00, ooo0OOOoo)
if 52 - 52: ooOoO0o.iII111i + I1Ii111
ooo0OOOoo += lispconfig.lisp_table_footer()
return (ooo0OOOoo)
if 38 - 38: i1IIi - II111iiii.I1Ii111
if 58 - 58: I1IiiI.iII111i + OoOoOO00
if 66 - 66: iII111i / oO0o * OoooooooOO + OoooooooOO % I11i
if 49 - 49: oO0o - i11iIiiIii.I1Ii111 * Ii1I % iII111i + i1IIi
if 71 - 71: o0oOOo0O0Ooo
if 38 - 38: oO0o % OoOoOO00 + I1ii11iIi11i.i11iIiiIii
if 53 - 53: i11iIiiIii * iII111i
