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
# local_addr = lisp.lisp_myrlocs[0].print_address_no_iid() itr_rloc = lisp.lisp_address(lisp.LISP_AFI_IPV4, local_addr, 32, 0) map_request.itr_rlocs.append(itr_rloc) map_request.dont_reply_bit = True # # Encode the Map-Request packet and then enter transmission loop. # packet = map_request.encode(None, 0) map_request.print_map_request() # # Build header to parse Map-Referral. # header = lisp.lisp_control_header() map_referral = lisp.lisp_map_referral() if (ddt_node.find(":") != -1): afi = lisp.LISP_AFI_IPV6 ml = 128 elif (ddt_node.find(".") != -1): afi = lisp.LISP_AFI_IPV4 ml = 32 else: lisp_close_all_sockets() print("Invalid DDT-node address {}".format(ddt_node)) exit(1) #endif ddt_node = lisp.lisp_address(afi, ddt_node, ml, 0) #
def lisp_rtr_data_plane(lisp_packet, thread_name): global lisp_send_sockets, lisp_ephem_prot, lisp_data_packet global lisp_raw_socket, lisp_raw_v6_socket packet = lisp_packet # # Check RLOC-probe Map-Request. We need to grab the TTL from IP header. # orig_pkt = packet.packet pkt = orig_pkt pkt, source, port, ttl = lisp.lisp_is_rloc_probe(pkt, -1) if (orig_pkt != pkt): if (source == None): return lisp.lisp_parse_packet(lisp_send_sockets, pkt, source, port, ttl) return #endif # # First check if we are assembling IPv4 fragments. # packet.packet = lisp.lisp_reassemble(packet.packet) if (packet.packet == None): return # # We need to cache the input encapsualted packet as well as the output # encapsulated packet. # if (lisp.lisp_flow_logging): packet = copy.deepcopy(packet) if (packet.decode(True, None, lisp.lisp_decap_stats) == None): return # # Print some useful header fields and strip outer headers.. # packet.print_packet("Receive-({})".format(thread_name), True) # # Strip outer headers and start inner header forwarding logic. # packet.strip_outer_headers() # # If instance-id is 0xffffff, this is a Info-Request packet encapsulated # to port 4341. We need to store the source port and source RLOC for # NAT-traversal reasons. # # We don't need to send an Info-Reply from the 4341 data port. There is no # information the xTR needs. It has the translated address from the # map-server, and the NAT is ready for packets from port 4341 since we # received this Info-Request. # if (packet.lisp_header.get_instance_id() == 0xffffff): header = lisp.lisp_control_header() header.decode(packet.packet) if (header.is_info_request()): info = lisp.lisp_info() info.decode(packet.packet) info.print_info() # # Store/refresh NAT state and Fix map-cache entries if there was # a change. # h = info.hostname if (info.hostname != None) else "" s = packet.outer_source p = packet.udp_sport if (lisp.lisp_store_nat_info(h, s, p)): lisp_fix_rloc_encap_state(lisp_send_sockets, h, s, p) #endif else: source = packet.outer_source.print_address_no_iid() ttl = packet.outer_ttl packet = packet.packet if (lisp.lisp_is_rloc_probe_request(packet[28]) == False and lisp.lisp_is_rloc_probe_reply(packet[28]) == False): ttl = -1 packet = packet[28::] lisp.lisp_parse_packet(lisp_send_sockets, packet, source, 0, ttl) #endif return #endif # # Packets are arriving on pcap interface. Need to check if another data- # plane is running. If so, don't deliver duplicates. # if (lisp.lisp_ipc_data_plane): lisp.dprint("Drop packet, external data-plane active") return #endif # # Increment global stats. # lisp.lisp_decap_stats["good-packets"].increment(len(packet.packet)) # # Process inner header (checksum and decrement ttl). # if (packet.inner_dest.is_mac()): packet.packet = lisp.lisp_mac_input(packet.packet) if (packet.packet == None): return packet.encap_port = lisp.LISP_VXLAN_DATA_PORT elif (packet.inner_version == 4): packet.packet = lisp.lisp_ipv4_input(packet.packet) if (packet.packet == None): return packet.inner_ttl = packet.outer_ttl elif (packet.inner_version == 6): packet.packet = lisp.lisp_ipv6_input(packet) if (packet.packet == None): return packet.inner_ttl = packet.outer_ttl else: lisp.dprint("Cannot parse inner packet header") return #endif # # Process decap node trace function. # if (packet.is_trace()): if (lisp.lisp_trace_append(packet, "decap") == False): return packet.outer_source.afi = lisp.LISP_AFI_NONE packet.outer_dest.afi = lisp.LISP_AFI_NONE #endif # # Do map-cache lookup. If no entry found, send Map-Request. # mc = lisp.lisp_map_cache_lookup(packet.inner_source, packet.inner_dest) # # Check if we are doing secondary-instance-ids only when we have a # map-cache entry in the IID that is possibly a non-LISP site. # if (mc and (mc.action == lisp.LISP_NATIVE_FORWARD_ACTION or mc.eid.address == 0)): db = lisp.lisp_db_for_lookups.lookup_cache(packet.inner_source, False) if (db and db.secondary_iid): dest_eid = packet.inner_dest dest_eid.instance_id = db.secondary_iid mc = lisp.lisp_map_cache_lookup(packet.inner_source, dest_eid) #endif #endif # # Map-cache lookup miss. # if (mc == None or mc.action == lisp.LISP_SEND_MAP_REQUEST_ACTION): if (lisp.lisp_rate_limit_map_request(packet.inner_source, packet.inner_dest)): return lisp.lisp_send_map_request(lisp_send_sockets, lisp_ephem_port, packet.inner_source, packet.inner_dest, None) if (packet.is_trace()): lisp.lisp_trace_append(packet) return #endif # # Send Map-Request to see if there is a RLOC change or to refresh an # entry that is about to time out. # if (mc and mc.is_active() and mc.has_ttl_elapsed()): lisp.lprint("Refresh map-cache entry {}".format( \ lisp.green(mc.print_eid_tuple(), False))) lisp.lisp_send_map_request(lisp_send_sockets, lisp_ephem_port, packet.inner_source, packet.inner_dest, None) #endif # # Update stats for entry. Stats per RLOC is done in lisp_mapping.select_ # rloc(). # mc.stats.increment(len(packet.packet)) # # Encapsulate or native forward packet. # dest_rloc, dest_port, nonce, action, rle = mc.select_rloc(packet, None) if (dest_rloc == None and rle == None): if (action == lisp.LISP_NATIVE_FORWARD_ACTION): lisp.dprint("Natively forwarding") packet.send_packet(lisp_raw_socket, packet.inner_dest) if (packet.is_trace()): lisp.lisp_trace_append(packet) return #endif lisp.dprint("No reachable RLOCs found") if (packet.is_trace()): lisp.lisp_trace_append(packet) return #endif if (dest_rloc and dest_rloc.is_null()): lisp.dprint("Drop action RLOC found") if (packet.is_trace()): lisp.lisp_trace_append(packet) return #endif # # Setup outer header for either unicast or multicast transmission.. # packet.outer_tos = packet.inner_tos packet.outer_ttl = packet.inner_ttl # # Do unicast encapsulation. # if (dest_rloc): packet.encap_port = dest_port if (dest_port == 0): packet.encap_port = lisp.LISP_DATA_PORT packet.outer_dest.copy_address(dest_rloc) version = packet.outer_dest.afi_to_version() packet.outer_version = version source_rloc = lisp.lisp_myrlocs[0] if (version == 4) else \ lisp.lisp_myrlocs[1] packet.outer_source.copy_address(source_rloc) if (packet.is_trace()): if (lisp.lisp_trace_append(packet) == False): return #endif # # Encode new LISP, UDP, and outer header. # if (packet.encode(nonce) == None): return if (len(packet.packet) <= 1500): packet.print_packet("Send", True) # # Send out on raw socket. # raw_socket = lisp_raw_v6_socket if version == 6 else lisp_raw_socket packet.send_packet(raw_socket, packet.outer_dest) elif (rle): # # Do replication of RLE is returned. # orig_len = len(packet.packet) for node in rle.rle_forwarding_list: packet.outer_dest.copy_address(node.address) packet.encap_port = lisp.LISP_DATA_PORT if \ node.translated_port == 0 else node.translated_port version = packet.outer_dest.afi_to_version() packet.outer_version = version source_rloc = lisp.lisp_myrlocs[0] if (version == 4) else \ lisp.lisp_myrlocs[1] packet.outer_source.copy_address(source_rloc) if (packet.is_trace()): if (lisp.lisp_trace_append(packet) == False): return #endif if (packet.encode(None) == None): return packet.print_packet("Replicate-to-L{}".format(node.level), True) packet.send_packet(lisp_raw_socket, packet.outer_dest) # # We need to strip the encapsulation header so we can add a new # one for the next replication. # strip_len = len(packet.packet) - orig_len packet.packet = packet.packet[strip_len::] if (lisp.lisp_flow_logging): packet = copy.deepcopy(packet) #endfor #endif # # Don't need packet structure anymore. # del(packet) 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 O0O(lisp_packet, thread_name): global II1iII1i, i1I1I, iiI1I global iiI1iIiI, OOo if 12 - 12: i11iIiiIii - i1IIi - OoO0O00.i1IIi - OOooOOo + O0 oO0OOOO0 = lisp_packet if 26 - 26: Ii1I if 35 - 35: Ii1I - I1IiiI % o0oOOo0O0Ooo.OoooooooOO % Ii1I if 47 - 47: iII111i - Ii1I.II111iiii + OoooooooOO.i11iIiiIii if 94 - 94: o0oOOo0O0Ooo * Ii1I / Oo0Ooo / Ii1I oO0 = oO0OOOO0.packet O0OO0O = oO0 O0OO0O, OO, IIIIii, OoOoO = lisp.lisp_is_rloc_probe(O0OO0O, -1) if (oO0 != O0OO0O): if (OO == None): return lisp.lisp_parse_packet(II1iII1i, O0OO0O, OO, IIIIii, OoOoO) return if 43 - 43: i11iIiiIii + Oo0Ooo * II111iiii * I1Ii111 * O0 if 64 - 64: OOooOOo % iIii1I11I1II1 * oO0o if 79 - 79: O0 if 78 - 78: I1ii11iIi11i + OOooOOo - I1Ii111 if 38 - 38: o0oOOo0O0Ooo - oO0o + iIii1I11I1II1 / OoOoOO00 % Oo0Ooo oO0OOOO0.packet = lisp.lisp_reassemble(oO0OOOO0.packet) if (oO0OOOO0.packet == None): return if 57 - 57: OoO0O00 / ooOoO0o if 29 - 29: iIii1I11I1II1 + OoOoOO00 * OoO0O00 * OOooOOo.I1IiiI * I1IiiI if 7 - 7: IiII * I1Ii111 % Ii1I - o0oOOo0O0Ooo if 13 - 13: Ii1I.i11iIiiIii if 56 - 56: I1ii11iIi11i % O0 - I1IiiI if (lisp.lisp_flow_logging): oO0OOOO0 = copy.deepcopy(oO0OOOO0) if 100 - 100: Ii1I - O0 % oO0o * OOooOOo + I1IiiI if (oO0OOOO0.decode(True, None, lisp.lisp_decap_stats) == None): return if 88 - 88: OoooooooOO - OoO0O00 * O0 * OoooooooOO.OoooooooOO if 33 - 33: I1Ii111 + iII111i * oO0o / iIii1I11I1II1 - I1IiiI if 54 - 54: I1Ii111 / OOooOOo.oO0o % iII111i if 57 - 57: i11iIiiIii.I1ii11iIi11i - Ii1I - oO0o + OoOoOO00 oO0OOOO0.print_packet("Receive-({})".format(thread_name), True) if 63 - 63: OoOoOO00 * iII111i if 69 - 69: O0.OoO0O00 if 49 - 49: I1IiiI - I11i if 74 - 74: iIii1I11I1II1 * I1ii11iIi11i + OoOoOO00 / i1IIi / II111iiii.Oo0Ooo oO0OOOO0.strip_outer_headers() if 62 - 62: OoooooooOO * I1IiiI if 58 - 58: OoOoOO00 % o0oOOo0O0Ooo if 50 - 50: I1Ii111.o0oOOo0O0Ooo if 97 - 97: O0 + OoOoOO00 if 89 - 89: o0oOOo0O0Ooo + OoO0O00 * I11i * Ii1I if 37 - 37: OoooooooOO - O0 - o0oOOo0O0Ooo if 77 - 77: OOooOOo * iIii1I11I1II1 if 98 - 98: I1IiiI % Ii1I * OoooooooOO if 51 - 51: iIii1I11I1II1.OoOoOO00 / oO0o + o0oOOo0O0Ooo if 33 - 33: ooOoO0o.II111iiii % iII111i + o0oOOo0O0Ooo if 71 - 71: Oo0Ooo % OOooOOo if (oO0OOOO0.lisp_header.get_instance_id() == 0xffffff): O00oO000O0O = lisp.lisp_control_header() O00oO000O0O.decode(oO0OOOO0.packet) if (O00oO000O0O.is_info_request()): I1i1i1iii = lisp.lisp_info() I1i1i1iii.decode(oO0OOOO0.packet) I1i1i1iii.print_info() if 16 - 16: Ii1I + IiII * O0 % i1IIi.I1IiiI if 67 - 67: OoooooooOO / I1IiiI * Ii1I + I11i if 65 - 65: OoooooooOO - I1ii11iIi11i / ooOoO0o / II111iiii / i1IIi if 71 - 71: I1Ii111 + Ii1I if 28 - 28: OOooOOo I11ii1IIiIi = I1i1i1iii.hostname if ( I1i1i1iii.hostname != None) else "" OoOOo0OOoO = oO0OOOO0.outer_source ooO0O00Oo0o = oO0OOOO0.udp_sport if (lisp.lisp_store_nat_info(I11ii1IIiIi, OoOOo0OOoO, ooO0O00Oo0o)): i1I1iI1iIi111i(II1iII1i, I11ii1IIiIi, OoOOo0OOoO, ooO0O00Oo0o) if 65 - 65: I1ii11iIi11i.I11i - I1Ii111 * IiII / I1Ii111 / ooOoO0o else: OO = oO0OOOO0.outer_source.print_address_no_iid() OoOoO = oO0OOOO0.outer_ttl oO0OOOO0 = oO0OOOO0.packet if (lisp.lisp_is_rloc_probe_request(oO0OOOO0[28]) == False and lisp.lisp_is_rloc_probe_reply(oO0OOOO0[28]) == False): OoOoO = -1 oO0OOOO0 = oO0OOOO0[28::] lisp.lisp_parse_packet(II1iII1i, oO0OOOO0, OO, 0, OoOoO) if 40 - 40: ooOoO0o * IiII * i11iIiiIii return if 57 - 57: ooOoO0o if 29 - 29: OoOoOO00 - IiII * OoooooooOO + OoooooooOO.II111iiii + OoooooooOO if 74 - 74: Ii1I - IiII / iII111i * O0 - OOooOOo if 19 - 19: I1IiiI if 25 - 25: Ii1I / ooOoO0o if 31 - 31: OOooOOo.O0 % I1IiiI.o0oOOo0O0Ooo + IiII if (lisp.lisp_ipc_data_plane): lisp.dprint("Drop packet, external data-plane active") return if 71 - 71: I1Ii111.II111iiii if 62 - 62: OoooooooOO.I11i if 61 - 61: OoOoOO00 - OOooOOo - i1IIi if 25 - 25: O0 * I11i + I1ii11iIi11i.o0oOOo0O0Ooo.o0oOOo0O0Ooo if 58 - 58: I1IiiI lisp.lisp_decap_stats["good-packets"].increment(len(oO0OOOO0.packet)) if 53 - 53: i1IIi if 59 - 59: o0oOOo0O0Ooo if 81 - 81: OoOoOO00 - OoOoOO00.iII111i if 73 - 73: I11i % i11iIiiIii - I1IiiI if (oO0OOOO0.inner_dest.is_mac()): oO0OOOO0.packet = lisp.lisp_mac_input(oO0OOOO0.packet) if (oO0OOOO0.packet == None): return oO0OOOO0.encap_port = lisp.LISP_VXLAN_DATA_PORT elif (oO0OOOO0.inner_version == 4): oO0OOOO0.packet = lisp.lisp_ipv4_input(oO0OOOO0.packet) if (oO0OOOO0.packet == None): return oO0OOOO0.inner_ttl = oO0OOOO0.outer_ttl elif (oO0OOOO0.inner_version == 6): oO0OOOO0.packet = lisp.lisp_ipv6_input(oO0OOOO0) if (oO0OOOO0.packet == None): return oO0OOOO0.inner_ttl = oO0OOOO0.outer_ttl else: lisp.dprint("Cannot parse inner packet header") return if 7 - 7: O0 * i11iIiiIii * Ii1I + ooOoO0o % OoO0O00 - ooOoO0o if 39 - 39: Oo0Ooo * OOooOOo % OOooOOo - OoooooooOO + o0oOOo0O0Ooo - I11i if 23 - 23: i11iIiiIii if 30 - 30: o0oOOo0O0Ooo - i1IIi % II111iiii + I11i * iIii1I11I1II1 if 81 - 81: IiII % i1IIi.iIii1I11I1II1 Ii1Iii1iIi = lisp.lisp_map_cache_lookup(oO0OOOO0.inner_source, oO0OOOO0.inner_dest) if 82 - 82: I1ii11iIi11i / I1IiiI % iIii1I11I1II1 / i1IIi - I1IiiI if 7 - 7: I1Ii111 * OoO0O00 - ooOoO0o + OOooOOo * I1IiiI % OoO0O00 if 15 - 15: OoOoOO00 % I1IiiI * I11i if 81 - 81: ooOoO0o - iIii1I11I1II1 - i1IIi / I1Ii111 - O0 * I11i if 20 - 20: oO0o % IiII if (Ii1Iii1iIi and (Ii1Iii1iIi.action == lisp.LISP_NATIVE_FORWARD_ACTION or Ii1Iii1iIi.eid.address == 0)): III1i1i11i = lisp.lisp_db_for_lookups.lookup_cache( oO0OOOO0.inner_source, False) if (III1i1i11i and III1i1i11i.secondary_iid): oOo0 = oO0OOOO0.inner_dest oOo0.instance_id = III1i1i11i.secondary_iid Ii1Iii1iIi = lisp.lisp_map_cache_lookup(oO0OOOO0.inner_source, oOo0) if 56 - 56: o0oOOo0O0Ooo + II111iiii + OoOoOO00 - ooOoO0o.OoOoOO00 if 84 - 84: OoO0O00 + i1IIi - II111iiii.I1ii11iIi11i * OoooooooOO + I1IiiI if 38 - 38: OOooOOo + II111iiii % ooOoO0o % OoOoOO00 - Ii1I / OoooooooOO if 73 - 73: o0oOOo0O0Ooo * O0 - i11iIiiIii if 85 - 85: Ii1I % iII111i + I11i / o0oOOo0O0Ooo.oO0o + OOooOOo if 62 - 62: i11iIiiIii + i11iIiiIii - o0oOOo0O0Ooo if (Ii1Iii1iIi == None or Ii1Iii1iIi.action == lisp.LISP_SEND_MAP_REQUEST_ACTION): if (lisp.lisp_rate_limit_map_request(oO0OOOO0.inner_source, oO0OOOO0.inner_dest)): return lisp.lisp_send_map_request(II1iII1i, II1Ii1iI1i, oO0OOOO0.inner_source, oO0OOOO0.inner_dest, None) return if 28 - 28: iII111i.iII111i % iIii1I11I1II1 * iIii1I11I1II1.o0oOOo0O0Ooo / iII111i if 27 - 27: OoO0O00 + ooOoO0o - i1IIi if 69 - 69: IiII - O0 % I1ii11iIi11i + i11iIiiIii.OoOoOO00 / OoO0O00 if 79 - 79: O0 * i11iIiiIii - IiII / IiII if 48 - 48: O0 if 93 - 93: i11iIiiIii - I1IiiI * I1ii11iIi11i * I11i % O0 + OoooooooOO if (Ii1Iii1iIi and Ii1Iii1iIi.is_active() and Ii1Iii1iIi.has_ttl_elapsed()): lisp.lprint("Refresh map-cache entry {}".format( lisp.green(Ii1Iii1iIi.print_eid_tuple(), False))) if 25 - 25: IiII + Ii1I / ooOoO0o.o0oOOo0O0Ooo % O0 * OoO0O00 lisp.lisp_send_map_request(II1iII1i, II1Ii1iI1i, oO0OOOO0.inner_source, oO0OOOO0.inner_dest, None) if 84 - 84: ooOoO0o % Ii1I + i11iIiiIii if 28 - 28: Oo0Ooo + OoO0O00 * OOooOOo % oO0o.I11i % O0 if 16 - 16: I11i - iIii1I11I1II1 / I1IiiI.II111iiii + iIii1I11I1II1 if 19 - 19: OoO0O00 - Oo0Ooo.O0 if 60 - 60: II111iiii + Oo0Ooo if 9 - 9: ooOoO0o * OoooooooOO - iIii1I11I1II1 + OoOoOO00 / OoO0O00.OoO0O00 Ii1Iii1iIi.stats.increment(len(oO0OOOO0.packet)) if 49 - 49: II111iiii if 25 - 25: OoooooooOO - I1IiiI.I1IiiI * oO0o if 81 - 81: iII111i + IiII if 98 - 98: I1IiiI o00o0, II1I, II1I1I1Ii, OOOOoO00o0O, I1I1I1IIi1III = Ii1Iii1iIi.select_rloc( oO0OOOO0, None) if 5 - 5: Oo0Ooo % ooOoO0o % i11iIiiIii + o0oOOo0O0Ooo / I1ii11iIi11i - I1ii11iIi11i if (o00o0 == None and I1I1I1IIi1III == None): if (OOOOoO00o0O == lisp.LISP_NATIVE_FORWARD_ACTION): lisp.dprint("Natively forwarding") oO0OOOO0.send_packet(iiI1iIiI, oO0OOOO0.inner_dest) return if 45 - 45: I1ii11iIi11i % I1IiiI - i11iIiiIii lisp.dprint("No reachable RLOCs found") return if 11 - 11: iIii1I11I1II1 * iIii1I11I1II1 * I1IiiI if (o00o0 and o00o0.is_null()): lisp.dprint("Drop action RLOC found") return if 46 - 46: OoOoOO00 + OoO0O00 if 70 - 70: iII111i / iIii1I11I1II1 if 85 - 85: OoooooooOO % i1IIi * OoooooooOO / I1ii11iIi11i if 96 - 96: OoooooooOO + oO0o if 44 - 44: oO0o oO0OOOO0.outer_tos = oO0OOOO0.inner_tos oO0OOOO0.outer_ttl = oO0OOOO0.inner_ttl if 20 - 20: I11i + Ii1I / O0 % iIii1I11I1II1 if 88 - 88: OoOoOO00 / II111iiii if 87 - 87: I1ii11iIi11i - I1ii11iIi11i - iII111i + oO0o if 82 - 82: oO0o / iIii1I11I1II1.I1IiiI.OOooOOo / o0oOOo0O0Ooo if (o00o0): oO0OOOO0.encap_port = II1I if (II1I == 0): oO0OOOO0.encap_port = lisp.LISP_DATA_PORT oO0OOOO0.outer_dest.copy_address(o00o0) iiI1I1 = oO0OOOO0.outer_dest.afi_to_version() oO0OOOO0.outer_version = iiI1I1 ooO = lisp.lisp_myrlocs[0] if (iiI1I1 == 4) else lisp.lisp_myrlocs[1] if 6 - 6: iIii1I11I1II1.ooOoO0o % o0oOOo0O0Ooo oO0OOOO0.outer_source.copy_address(ooO) if 50 - 50: iII111i + O0 + Ii1I.II111iiii / o0oOOo0O0Ooo if 17 - 17: Ii1I % iIii1I11I1II1 - iIii1I11I1II1 if 78 - 78: iII111i + I11i.ooOoO0o - iII111i.Ii1I if 30 - 30: I1IiiI + OoO0O00 % Ii1I * iII111i / Oo0Ooo - I11i if (oO0OOOO0.encode(II1I1I1Ii) == None): return if (len(oO0OOOO0.packet) <= 1500): oO0OOOO0.print_packet("Send", True) if 64 - 64: iIii1I11I1II1 if 21 - 21: Oo0Ooo.II111iiii if 54 - 54: II111iiii % II111iiii if 86 - 86: O0 % Ii1I * ooOoO0o * iIii1I11I1II1 * i1IIi * I11i OOOoOOO0oO = OOo if iiI1I1 == 6 else iiI1iIiI oO0OOOO0.send_packet(OOOoOOO0oO, oO0OOOO0.outer_dest) if 28 - 28: ooOoO0o + i11iIiiIii / I11i % OoOoOO00 % Oo0Ooo - O0 elif (I1I1I1IIi1III): if 54 - 54: i1IIi + II111iiii if 83 - 83: I1ii11iIi11i - I1IiiI + OOooOOo if 5 - 5: Ii1I if 46 - 46: IiII ii1iIi1iIiI1i = len(oO0OOOO0.packet) for iiI1iIii1i in I1I1I1IIi1III.rle_forwarding_list: oO0OOOO0.outer_dest.copy_address(iiI1iIii1i.address) oO0OOOO0.encap_port = lisp.LISP_DATA_PORT if iiI1iIii1i.translated_port == 0 else iiI1iIii1i.translated_port if 70 - 70: OoO0O00 * O0.I11i + I1IiiI.IiII if 14 - 14: iIii1I11I1II1 % iIii1I11I1II1 * i11iIiiIii - OoO0O00 - I11i iiI1I1 = oO0OOOO0.outer_dest.afi_to_version() oO0OOOO0.outer_version = iiI1I1 ooO = lisp.lisp_myrlocs[0] if (iiI1I1 == 4) else lisp.lisp_myrlocs[1] if 63 - 63: OoO0O00 oO0OOOO0.outer_source.copy_address(ooO) if 69 - 69: iIii1I11I1II1.I1ii11iIi11i % ooOoO0o + iIii1I11I1II1 / O0 / I1ii11iIi11i if (oO0OOOO0.encode(None) == None): return if 61 - 61: OOooOOo % OOooOOo * o0oOOo0O0Ooo / o0oOOo0O0Ooo oO0OOOO0.print_packet("Replicate-to-L{}".format(iiI1iIii1i.level), True) oO0OOOO0.send_packet(iiI1iIiI, oO0OOOO0.outer_dest) if 75 - 75: IiII.ooOoO0o if 50 - 50: OoOoOO00 if 60 - 60: ooOoO0o * iIii1I11I1II1 * I1ii11iIi11i * Oo0Ooo if 69 - 69: Ii1I * O0.i11iIiiIii / Ii1I.o0oOOo0O0Ooo if 63 - 63: I11i + o0oOOo0O0Ooo.II111iiii - I1IiiI oOOO00o000o = len(oO0OOOO0.packet) - ii1iIi1iIiI1i oO0OOOO0.packet = oO0OOOO0.packet[oOOO00o000o::] if 9 - 9: oO0o + I11i / I11i if (lisp.lisp_flow_logging): oO0OOOO0 = copy.deepcopy(oO0OOOO0) if 12 - 12: OoooooooOO % o0oOOo0O0Ooo * I11i % iIii1I11I1II1 / Ii1I if 27 - 27: i11iIiiIii % II111iiii % I11i.O0 - Oo0Ooo + OoOoOO00 if 57 - 57: iIii1I11I1II1 / I11i - i1IIi if 51 - 51: IiII if 25 - 25: OoooooooOO + IiII * I1ii11iIi11i if 92 - 92: I1IiiI + I11i + O0 / o0oOOo0O0Ooo + I1Ii111 del (oO0OOOO0) return if 18 - 18: ooOoO0o * OoOoOO00.iII111i / I1ii11iIi11i / i11iIiiIii if 21 - 21: oO0o / I1ii11iIi11i + Ii1I + OoooooooOO if 91 - 91: i11iIiiIii / i1IIi + iII111i + ooOoO0o * i11iIiiIii if 66 - 66: iIii1I11I1II1 % i1IIi - O0 + I11i * I1Ii111.IiII if 52 - 52: ooOoO0o + O0.iII111i.I1ii11iIi11i.OoO0O00 if 97 - 97: I1IiiI / iII111i if 71 - 71: II111iiii / i1IIi.I1ii11iIi11i % OoooooooOO.OoOoOO00
if 48 - 48: o0oOOo0O0Ooo - oO0o / OoooooooOO if 100 - 100: I1IiiI / o0oOOo0O0Ooo % II111iiii % Oo0Ooo % OOooOOo if 98 - 98: I11i % i11iIiiIii % ooOoO0o + Ii1I if 78 - 78: I1ii11iIi11i % oO0o / iII111i - iIii1I11I1II1 if 69 - 69: I1Ii111 if 11 - 11: I1IiiI if 16 - 16: Ii1I + IiII * O0 % i1IIi.I1IiiI if (oO0o0.source_eid.is_ipv6() and iiII1i1 != ""): oO0o0.signature_eid = oO0o0.source_eid oO0o0.privkey_filename = "./lisp-lig.pem" if 67 - 67: OoooooooOO / I1IiiI * Ii1I + I11i if 65 - 65: OoooooooOO - I1ii11iIi11i / ooOoO0o / II111iiii / i1IIi if 71 - 71: I1Ii111 + Ii1I if 28 - 28: OOooOOo if 38 - 38: ooOoO0o % II111iiii % I11i / OoO0O00 + OoOoOO00 / i1IIi OoOOo0OOoO = lisp.lisp_control_header() ooO0O00Oo0o = lisp.lisp_map_reply() OOO = lisp.lisp_map_notify(None) if (i11iIIIIIi1.find(":") != -1): iI1Ii11iIiI1 = lisp.LISP_AFI_IPV6 OO0Oooo0oOO0O = 128 elif (i11iIIIIIi1.find(".") != -1): iI1Ii11iIiI1 = lisp.LISP_AFI_IPV4 OO0Oooo0oOO0O = 32 else: print("Invalid Map-Resolver address {}".format(i11iIIIIIi1)) Ii11Ii1I(Oo0oO0oo0oO00) exit(1) if 73 - 73: OoooooooOO * OoooooooOO * ooOoO0o * OoOoOO00 + ooOoO0o * I1Ii111 i11iIIIIIi1 = lisp.lisp_address(iI1Ii11iIiI1, i11iIIIIIi1, OO0Oooo0oOO0O, 0)
if 67 - 67: I1Ii111.iII111i.O0 IIIIiiII111 = lisp.lisp_myrlocs[0].print_address_no_iid() OOoOoo = lisp.lisp_address(lisp.LISP_AFI_IPV4, IIIIiiII111, 32, 0) OOO0o.itr_rlocs.append(OOoOoo) OOO0o.dont_reply_bit = True if 85 - 85: I1ii11iIi11i % iII111i % ooOoO0o if 82 - 82: i11iIiiIii - iII111i * OoooooooOO / I11i if 31 - 31: IiII.OoO0O00 - iIii1I11I1II1 if 64 - 64: I11i iI11Ii = OOO0o.encode(None, 0) OOO0o.print_map_request() if 6 - 6: oO0o if 68 - 68: OoOoOO00 - OoO0O00 if 28 - 28: OoO0O00.OOooOOo / OOooOOo + Oo0Ooo.I1ii11iIi11i if 1 - 1: iIii1I11I1II1 / II111iiii iiI1I11i1i = lisp.lisp_control_header() III1Iiii1I11 = lisp.lisp_map_referral() if (i1iIIi1.find(":") != -1): IIi1i11111 = lisp.LISP_AFI_IPV6 ooOO00O00oo = 128 elif (i1iIIi1.find(".") != -1): IIi1i11111 = lisp.LISP_AFI_IPV4 ooOO00O00oo = 32 else: i11() print("Invalid DDT-node address {}".format(i1iIIi1)) exit(1) if 9 - 9: I1ii11iIi11i / Oo0Ooo - I1IiiI / OoooooooOO / iIii1I11I1II1 - o0oOOo0O0Ooo i1iIIi1 = lisp.lisp_address(IIi1i11111, i1iIIi1, ooOO00O00oo, 0) if 91 - 91: iII111i % i1IIi % iIii1I11I1II1
iIIiIi1iIII1 = lisp.lisp_myrlocs[0].print_address_no_iid() Ooo = lisp.lisp_address(lisp.LISP_AFI_IPV4, iIIiIi1iIII1, 32, 0) o0.itr_rlocs.append(Ooo) o0.dont_reply_bit = True if 62 - 62: OOooOOo / OoO0O00 + Ii1I / OoO0O00.II111iiii if 68 - 68: i11iIiiIii % I1ii11iIi11i + i11iIiiIii if 31 - 31: II111iiii.I1IiiI if 1 - 1: Oo0Ooo / o0oOOo0O0Ooo % iII111i * IiII.i11iIiiIii III1Iiii1I11 = o0.encode(None, 0) o0.print_map_request() 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 oo0o00O = lisp.lisp_control_header() o00O0OoO = lisp.lisp_map_referral() if (iI111I11I1I1.find(":") != -1): i1i = lisp.LISP_AFI_IPV6 I1I1iIiII1 = 128 elif (iI111I11I1I1.find(".") != -1): i1i = lisp.LISP_AFI_IPV4 I1I1iIiII1 = 32 else: o000o0o00o0Oo() print("Invalid DDT-node address {}".format(iI111I11I1I1)) exit(1) if 16 - 16: iIii1I11I1II1 iI111I11I1I1 = lisp.lisp_address(i1i, iI111I11I1I1, I1I1iIiII1, 0) if 90 - 90: o0oOOo0O0Ooo % i1IIi / OoO0O00 if 44 - 44: Oo0Ooo.OoO0O00 / I1ii11iIi11i + Ii1I
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