def lisp_itr_timeout_dynamic_eids(lisp_socket):
lisp.lisp_set_exception()
now = lisp.lisp_get_timestamp()
for db in lisp.lisp_db_list:
if (db.dynamic_eid_configured() == False): continue
delete_list = []
for dyn_eid in db.dynamic_eids.values():
ts = dyn_eid.last_packet
if (ts == None): continue
if (ts + dyn_eid.timeout > now): continue
#
# Check hardware if dyn-EID has had packets SENT to. We want the
# opposite but this is all we get from Arista.
#
if (lisp.lisp_program_hardware):
prefix = dyn_eid.dynamic_eid.print_prefix_no_iid()
if (lisp.lisp_arista_is_alive(prefix)):
lisp.lprint(("Hardware indicates dynamic-EID {} " + \
"still active").format(lisp.green(prefix, False)))
continue
#endif
#endif
#
# Tell ETR process so it can register dynamic-EID.
#
eid_str = dyn_eid.dynamic_eid.print_address()
ipc = "learn%{}%None".format(eid_str)
ipc = lisp.lisp_command_ipc(ipc, "lisp-itr")
lisp.lisp_ipc(ipc, lisp_socket, "lisp-etr")
lisp.lprint("Dynamic-EID {}".format( \
lisp.bold(lisp.green(eid_str, False) + " activity timeout",
False)))
delete_list.append(eid_str)
#endfor
#
# Remove the timed out entries from db.dynamic_eids{}.
#
for eid_str in delete_list:
db.dynamic_eids.pop(eid_str)
#endfor
#
# Restart periodic timer.
#
threading.Timer(lisp.LISP_DEFAULT_DYN_EID_TIMEOUT,
lisp_itr_timeout_dynamic_eids, [lisp_socket]).start()
return
def lisp_mr_parse_packet(packet, source_str, sport):
header = lisp.lisp_control_header()
if (header.decode(packet) == None):
lisp.lprint("Could not decode control header")
return
#endif
#
# Store source in internal lisp_address() format.
#
source = lisp.lisp_address(lisp.LISP_AFI_NONE, "", 0, 0)
source.store_address(source_str)
#
# If this is an ECM and since we are a Map-Resolver, check if the
# Map-Server is colocated on the same machine. If so, have it process
# the ECM when there is no DDT configured for the Map-Resolver.
#
if (header.type == lisp.LISP_ECM):
ddt_roots_exist = (len(lisp_ddt_roots) > 0)
if (lisp.lisp_is_running("lisp-ms") and ddt_roots_exist == False):
packet = lisp.lisp_packet_ipc(packet, source_str, sport)
lisp.lisp_ipc(packet, lisp_send_internal_socket, "lisp-ms")
return
#endif
#
# Process the Map-Request as a DDT-based Map-Resolver.
#
if (ddt_roots_exist):
lisp.lisp_process_ecm(lisp_send_sockets, packet, source, sport)
return
#endif
lisp.lprint("Map-Resolver dropping ECM, DDT or Map-Server not " + \
"configured")
return
#endif
#
# Process Map-Referral.
#
if (header.type == lisp.LISP_MAP_REFERRAL):
lisp.lisp_process_map_referral(lisp_send_sockets, packet, source)
return
#endif
#
# This process processes only ECMs and Map-Referral messages.
#
lisp.lprint("Map-Resolver received an unexpected LISP packet, type: {}". \
format(header.type))
return
def o0(packet, source_str, sport):
if 30 - 30: O0 * OoooooooOO
I1iIIIi1 = lisp.lisp_control_header()
if (I1iIIIi1.decode(packet) == None):
lisp.lprint("Could not decode control header")
return
if 17 - 17:
iIii1I11I1II1.OoooooooOO / I11i % II111iiii % i1IIi / i11iIiiIii
if 58 - 58: Oo0Ooo.II111iiii + oO0o - i11iIiiIii / II111iiii / O0
if 85 - 85: OoOoOO00 + OOooOOo
if 10 - 10: IiII / OoO0O00 + OoOoOO00 / i1IIi
if 27 - 27: Ii1I
oO0OO0 = lisp.lisp_address(lisp.LISP_AFI_NONE, "", 0, 0)
oO0OO0.store_address(source_str)
if 82 - 82: IiII - IiII + OoOoOO00
if 8 - 8: o0oOOo0O0Ooo % iII111i * oO0o % Ii1I.ooOoO0o / ooOoO0o
if 81 - 81: OoO0O00
if 99 - 99: oO0o * II111iiii * I1Ii111
if 92 - 92: Oo0Ooo
if 40 - 40: OoOoOO00 / IiII
if (I1iIIIi1.type == lisp.LISP_ECM):
OOOoO000 = (len(II1Ii1iI1i) > 0)
if (lisp.lisp_is_running("lisp-ms") and OOOoO000 == False):
packet = lisp.lisp_packet_ipc(packet, source_str, sport)
lisp.lisp_ipc(packet, i111I, "lisp-ms")
return
if 57 - 57: II111iiii
if 54 - 54: Oo0Ooo + oO0o + i11iIiiIii
if 28 - 28: oO0o
if 70 - 70: IiII
if 34 - 34: I1Ii111 % IiII
if (OOOoO000):
lisp.lisp_process_ecm(II1iII1i, packet, oO0OO0, sport)
return
if 3 - 3: II111iiii / OOooOOo + IiII.ooOoO0o.OoO0O00
lisp.lprint("Map-Resolver dropping ECM, DDT or Map-Server not " +
"configured")
if 83 - 83: oO0o + OoooooooOO
return
if 22 - 22: Ii1I % iII111i * OoooooooOO - o0oOOo0O0Ooo / iIii1I11I1II1
if 86 - 86:
OoooooooOO.iII111i % OoOoOO00 / I11i * iII111i / o0oOOo0O0Ooo
if 64 - 64: i11iIiiIii
if 38 - 38: IiII / I1IiiI - IiII.I11i
if 69 - 69: OoooooooOO + I1ii11iIi11i
if (I1iIIIi1.type == lisp.LISP_MAP_REFERRAL):
lisp.lisp_process_map_referral(II1iII1i, packet, oO0OO0)
return
if 97 - 97: OOooOOo - OoO0O00 / Ii1I.i11iIiiIii % oO0o * oO0o
if 1 - 1: I1IiiI % ooOoO0o
if 65 - 65: I1IiiI + OoOoOO00 / OOooOOo
if 83 - 83: o0oOOo0O0Ooo.iII111i - Oo0Ooo
if 65 - 65: iIii1I11I1II1 / ooOoO0o.IiII - II111iiii
lisp.lprint(
"Map-Resolver received an unexpected LISP packet, type: {}".format(
I1iIIIi1.type))
if 72 - 72: iIii1I11I1II1 / IiII % iII111i % OOooOOo - I11i % OOooOOo
return
if 100 - 100: Oo0Ooo + i11iIiiIii
if 71 - 71: I11i / o0oOOo0O0Ooo / I1Ii111 % OOooOOo
if 51 - 51: IiII * O0 / II111iiii.Ii1I % OOooOOo / I1IiiI
if 9 - 9: I1IiiI % I1IiiI % II111iiii
if 30 - 30: IiII + I1Ii111 - IiII.IiII - II111iiii + O0
if 86 - 86: i1IIi
if 41 - 41: OoOoOO00 * I11i / OoOoOO00 % oO0o
def II11iI111i1(packet, source_str, sport):
if 95 - 95: OoooooooOO - IiII * I1IiiI + OoOoOO00
iIi1 = lisp.lisp_control_header()
if (iIi1.decode(packet) == None):
lisp.lprint("Could not decode control header")
return
if 21 - 21: I11i
if 92 - 92: i11iIiiIii / I1Ii111 - iII111i % ooOoO0o * I1Ii111 + Oo0Ooo
if 11 - 11: OoooooooOO.I1Ii111
if 80 - 80:
OoooooooOO - OOooOOo * Ii1I * I1ii11iIi11i / I1IiiI / OOooOOo
if 13 - 13: I1Ii111 * ooOoO0o + i11iIiiIii * I1Ii111 - ooOoO0o
Ii1i1i1i1I1Ii = lisp.lisp_address(lisp.LISP_AFI_NONE, "", 0, 0)
Ii1i1i1i1I1Ii.store_address(source_str)
if 25 - 25: II111iiii
if 11 - 11: Oo0Ooo
if 74 - 74: OoOoOO00 * o0oOOo0O0Ooo + OoOoOO00.OOooOOo * OoooooooOO % O0
if 85 - 85: ooOoO0o / O0
if 18 - 18: o0oOOo0O0Ooo % O0 * I1ii11iIi11i
if 62 - 62: I1Ii111.IiII.OoooooooOO
if (iIi1.type == lisp.LISP_ECM):
i111 = (len(oo00) > 0)
if (lisp.lisp_is_running("lisp-ms") and i111 == False):
packet = lisp.lisp_packet_ipc(packet, source_str, sport)
lisp.lisp_ipc(packet, o0oO0, "lisp-ms")
return
if 27 - 27: i11iIiiIii / I1ii11iIi11i
if 84 - 84: Oo0Ooo
if 43 - 43: oO0o - OoooooooOO
if 3 - 3: O0 / iII111i
if 31 - 31: OOooOOo + o0oOOo0O0Ooo.OoooooooOO
if (i111):
lisp.lisp_process_ecm(i1I1ii1II1iII, packet, Ii1i1i1i1I1Ii, sport)
return
if 89 - 89: II111iiii + i1IIi + II111iiii
lisp.lprint("Map-Resolver dropping ECM, DDT or Map-Server not " +
"configured")
if 7 - 7: O0 % o0oOOo0O0Ooo + I1ii11iIi11i * iII111i - iII111i
return
if 42 - 42: OoOoOO00 * OoOoOO00 * I1Ii111.I11i
if 51 - 51:
OOooOOo % iIii1I11I1II1 - OoooooooOO % ooOoO0o * iIii1I11I1II1 % OoO0O00
if 99 - 99: oO0o * II111iiii * I1Ii111
if 92 - 92: Oo0Ooo
if 40 - 40: OoOoOO00 / IiII
if (iIi1.type == lisp.LISP_MAP_REFERRAL):
lisp.lisp_process_map_referral(i1I1ii1II1iII, packet, Ii1i1i1i1I1Ii)
return
if 79 - 79: OoO0O00 - iIii1I11I1II1 + Ii1I - I1Ii111
if 93 - 93: II111iiii.I1IiiI - Oo0Ooo + OoOoOO00
if 61 - 61: II111iiii
if 15 - 15: i11iIiiIii % I1IiiI * I11i / I1Ii111
if 90 - 90: iII111i
lisp.lprint(
"Map-Resolver received an unexpected LISP packet, type: {}".format(
iIi1.type))
if 31 - 31: OOooOOo + O0
return
if 87 - 87: ooOoO0o
if 45 - 45: OoO0O00 / OoooooooOO - iII111i / Ii1I % IiII
if 83 - 83: I1IiiI.iIii1I11I1II1 - IiII * i11iIiiIii
if 20 - 20: i1IIi * I1Ii111 + II111iiii % o0oOOo0O0Ooo % oO0o
if 13 - 13: Oo0Ooo
if 60 - 60: I1ii11iIi11i * I1IiiI
if 17 - 17: OOooOOo % Oo0Ooo / I1ii11iIi11i.IiII * OOooOOo - II111iiii
