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_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 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 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 lisp_fix_rloc_encap_state_entry(mc, parms): lisp_sockets, rloc, port, hostname = parms addr = "{}:{}".format(rloc.print_address_no_iid(), port) eid = lisp.green(mc.print_eid_tuple(), False) msg = "Changed '{}' translated address:port to {} for EID {}, {} {}". \ format(hostname, lisp.red(addr, False), eid, "{}", "{}") for rloc_entry in mc.rloc_set: if (rloc_entry.rle): for rle_node in rloc_entry.rle.rle_nodes: if (rle_node.rloc_name != hostname): continue rle_node.store_translated_rloc(rloc, port) old_addr = rle_node.address.print_address_no_iid() + ":" + \ str(rle_node.translated_port) lisp.lprint(msg.format("RLE", old_addr)) #endfor #endif if (rloc_entry.rloc_name != hostname): continue # # Update lisp-crypto encap array. Put keys in new dictionary array # location since translated address and port changed. We don't want # to rekey because of a NAT change. # old_addr = rloc_entry.rloc.print_address_no_iid() + ":" + \ str(rloc_entry.translated_port) if (lisp.lisp_crypto_keys_by_rloc_encap.has_key(old_addr)): keys = lisp.lisp_crypto_keys_by_rloc_encap[old_addr] lisp.lisp_crypto_keys_by_rloc_encap[addr] = keys #endif # # Update translated information with new information. # rloc_entry.delete_from_rloc_probe_list(mc.eid, mc.group) rloc_entry.store_translated_rloc(rloc, port) rloc_entry.add_to_rloc_probe_list(mc.eid, mc.group) lisp.lprint(msg.format("RLOC", old_addr)) # # Trigger RLOC-probe if enabled. # if (lisp.lisp_rloc_probing): seid = None if (mc.group.is_null()) else mc.eid deid = mc.eid if (mc.group.is_null()) else mc.group lisp.lisp_send_map_request(lisp_sockets, 0, seid, deid, rloc_entry) #endif #endfor # # Write change to external data-plane. # lisp.lisp_write_ipc_map_cache(True, mc) return(True, parms)
def lisp_timeout_pubsub(): lisp.lisp_set_exception() # # Return quickly if inject mode is not enabled. # lisp_ms_scale_inject() now = lisp.lisp_get_timestamp() delete_list = [] for e in lisp.lisp_pubsub_cache: for pubsub in lisp.lisp_pubsub_cache[e].values(): ttl = pubsub.ttl * 60 if (pubsub.uptime + ttl > now): continue delete_list.append([e, pubsub.xtr_id]) #endfor #endfor # # Remove entries from delete queue. # for e, xtr_id in delete_list: eid = lisp.green(e, False) lisp.lprint("Pubsub state {} for xtr-id 0x{} has {}".format( eid, lisp.lisp_hex_string(xtr_id), lisp.bold("timed out", False))) # # Remove entry from dictionary array. And explictly free memory. # entry = lisp.lisp_pubsub_cache[e][xtr_id] lisp.lisp_pubsub_cache[e].pop(xtr_id) del (entry) # # If not more subscriptions for this EID-prefix, remove EID-prefix # from parent dictionary array. # if (len(lisp.lisp_pubsub_cache[e]) == 0): lisp.lisp_pubsub_cache.pop(e) #endif #endfor # # Restart periodic timer. # lisp_pubsub_timer = threading.Timer( \ lisp.LISP_PUBSUB_TIMEOUT_CHECK_INTERVAL, lisp_timeout_pubsub, []) lisp_pubsub_timer.start() return
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 lisp_itr_data_plane(packet, device, input_interface, macs, my_sa): global lisp_send_sockets global lisp_ephem_port global lisp_raw_socket, lisp_raw_v6_socket global lisp_ipc_listen_socket # # Check RLOC-probe Map-Reply. We need to grab the TTL from IP header. # orig_packet = packet packet, source, port, ttl = lisp.lisp_is_rloc_probe(packet, 1) if (orig_packet != packet): if (source == None): return lisp.lisp_parse_packet(lisp_send_sockets, packet, source, port, ttl) return #endif packet = lisp.lisp_packet(packet) if (packet.decode(False, None, None) == None): return # # For locally source packets from this system, the MAC address may # be the default router. Check source to see if assigned to this system, # and if so, accept on interface "device". # if (my_sa): input_interface = device # # Get instance-ID for incoming interface. # source_eid = packet.inner_source iid = lisp.lisp_get_interface_instance_id(input_interface, source_eid) packet.inner_dest.instance_id = iid packet.inner_source.instance_id = iid # # Print some useful header fields and strip outer headers.. # if (macs != ""): macs = ", MACs: " + macs + "," packet.print_packet("Receive {}{}".format(device, macs), False) # # Drop packet if input interface not found based on MAC address used. # if (device != input_interface and device != "lispers.net"): lisp.dprint("Not our MAC address on interface {}, pcap interface {}". \ format(input_interface, device)) return #endif lisp_decent = lisp.lisp_decent_push_configured if (lisp_decent): multicast = packet.inner_dest.is_multicast_address() local = packet.inner_source.is_local() lisp_decent = (local and multicast) #endif if (lisp_decent == False): # # Only forward packets from source-EIDs. # db = lisp.lisp_db_for_lookups.lookup_cache(packet.inner_source, False) if (db == None): lisp.dprint("Packet received from non-EID source") return #endif # # Check to see if we are doing dynamic-EID discovery. # if (db.dynamic_eid_configured()): i = lisp.lisp_allow_dynamic_eid(input_interface, packet.inner_source) if (i): lisp.lisp_itr_discover_eid(db, packet.inner_source, input_interface, i, lisp_ipc_listen_socket) else: e = lisp.green(packet.inner_source.print_address(), False) lisp.dprint("Disallow dynamic-EID {} on interface {}".format(e, input_interface)) return #endif #endif if (packet.inner_source.is_local() and packet.udp_dport == lisp.LISP_CTRL_PORT): return #endif # # Do input processing for currently supported packet types.. # if (packet.inner_version == 4): igmp, packet.packet = lisp.lisp_ipv4_input(packet.packet) if (packet.packet == None or igmp): return packet.inner_ttl -= 1 elif (packet.inner_version == 6): packet.packet = lisp.lisp_ipv6_input(packet) if (packet.packet == None): return packet.inner_ttl -= 1 else: packet.packet = lisp.lisp_mac_input(packet.packet) if (packet.packet == None): return packet.encap_port = lisp.LISP_L2_DATA_PORT #endif # # First check if destination is to any local EID-prefixes from database- # mapping commands. In this case, we need to natively forward. # if (lisp_xtr_loopback == False): db = lisp.lisp_db_for_lookups.lookup_cache(packet.inner_dest, False) if (db and db.dynamic_eid_configured == False): lisp.dprint(("Packet destined to local EID-prefix {}, " + \ "natively forwarding").format(db.print_eid_tuple())) packet.send_packet(lisp_raw_socket, packet.inner_dest) return #endif #endif # # Do map-cache lookup. # mc = lisp.lisp_map_cache_lookup(packet.inner_source, packet.inner_dest) # # If "secondary-iid" is configured, we want to check the secondary # map-cache if a lookup miss occured in the default IID for this source # EID-prefix. If destination EID found in secondary map-cache, use it. # Otherwise, send Map-Request for EID in default IID. # secondary_iid = db.secondary_iid if (db != None) else None if (secondary_iid and mc and mc.action == lisp.LISP_NATIVE_FORWARD_ACTION): dest_eid = packet.inner_dest dest_eid.instance_id = secondary_iid mc = lisp.lisp_map_cache_lookup(packet.inner_source, dest_eid) #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, reason="map-cache miss") #endif 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, native forward, or encapsulate-and-replciate packet. # dest_rloc, dest_port, nonce, action, rle, rloc_entry = \ mc.select_rloc(packet, lisp_ipc_listen_socket) 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, reason="not an EID") #endif return #endif r = "No reachable RLOCs found" lisp.dprint(r) if (packet.is_trace()): lisp.lisp_trace_append(packet, reason=r) return #endif if (dest_rloc and dest_rloc.is_null()): r = "Drop action RLOC found" lisp.dprint(r) if (packet.is_trace()): lisp.lisp_trace_append(packet, reason=r) 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.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, rloc_entry=rloc_entry) \ == 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. Since we are an ITR, replicate to # level-0 RTRs (or ETRs) only (or first-level boxes only).. # level = rle.rle_nodes[0].level orig_len = len(packet.packet) for node in rle.rle_forwarding_list: if (node.level != level): return packet.outer_dest.copy_address(node.address) if (lisp_decent): packet.inner_dest.instance_id = 0xffffff 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 # # Replicate out on raw socket. # 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::] #endfor #endif # # Don't need packet structure anymore. # del(packet) return
def lisp_itr_get_capture_info(): global lisp_pcap_lock lisp.lisp_set_exception() # # Wait for database-mapping commands to execute. We need to retrieve # EID-prefixes we need to listen on. # sources, dyn_eids = lisp_itr_get_local_eid_prefixes() # # If "ipc-data-plane = yes" is configured, we do not need to do any # data-plane forwarding. There is another module running with the # lispers.net control-plane that is doing data-plane forwarding. We'll # get punts via the lispers.net-itr named socket. But we do have to # packet capture RLOC-probe replies. Also capture multicast Map-Register # messages for LISP-Decent. # cp_pfilter = None if (lisp.lisp_ipc_data_plane): lisp.lprint(lisp.bold("Data-plane packet capture disabled", False)) cp_pfilter = "(udp src port 4342 and ip[28] == 0x28)" + \ " or (ip[16] >= 224 and ip[16] < 240 and (ip[28] & 0xf0) == 0x30)" lisp.lprint("Control-plane capture: '{}'".format(cp_pfilter)) else: lisp.lprint("Capturing packets for source-EIDs {}".format( \ lisp.green(str(sources), False))) #endif if (lisp.lisp_pitr): lisp.lprint("Configured for PITR functionality") # # We want the kernel to handle any packets with source AND destination # that matches any EID-prefixes for the site. Any other case, we want # the pcap filters to get the packet to this lisp-itr process. # l2_overlay = lisp.lisp_l2_overlay if (l2_overlay == False): if (lisp.lisp_is_linux()): lisp_itr_kernel_filter(sources, dyn_eids) #endif # # Build packet capture filter so we get packets for configured source EID- # prefixes. # if (cp_pfilter == None): if (lisp.lisp_pitr): pfilter = lisp_itr_build_pcap_filter(sources, [], False, True) else: pfilter = lisp_itr_build_pcap_filter(sources, dyn_eids, l2_overlay, False) #endif else: pfilter = cp_pfilter #endif # # User can select which interfaces to pcap on. # interfaces = lisp_get_active_interfaces() pcap_list = os.getenv("LISP_PCAP_LIST") if (pcap_list == None): us = "" rloc_interfaces = [] else: eid_interfaces = list(set(pcap_list.split()) & set(interfaces)) rloc_interfaces = list(set(pcap_list.split()) ^ set(interfaces)) us = "user-selected " lisp.lprint("User pcap-list: {}, active-interfaces: {}".format( \ pcap_list, interfaces)) interfaces = eid_interfaces #endif # # Start a pcap thread so we can receive packets from applications on this # system. But make sure the device is up on A10 devices. If ethernet MAC # capturing, do not listen on non ethernet interfaces. # mac_capturing = (pfilter.find("ether host") != -1) for device in interfaces: if (device in ["lo", "lispers.net"] and mac_capturing): lisp.lprint(("Capturing suppressed on interface {}, " + \ "MAC filters configured").format(device)) continue #endif args = [device, pfilter, lisp_pcap_lock] lisp.lprint("Capturing packets on {}interface {}".format(us, device)) threading.Thread(target=lisp_itr_pcap_thread, args=args).start() #endfor if (cp_pfilter): return # # Start a pcap thread so we can receive RLOC-probe Map-Replies packets on # RLOC interfaces. This is only called when LISP_PCAP_LIST is set. # probe_pfilter = "(udp src port 4342 and ip[28] == 0x28)" for device in rloc_interfaces: args = [device, probe_pfilter, lisp_pcap_lock] lisp.lprint("Capture RLOC-probe replies on RLOC interface {}".format( \ device)) threading.Thread(target=lisp_itr_pcap_thread, args=args).start() #endfor return
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 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_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)
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
def II1i1IiiIIi11(mc, parms): iI1Ii11iII1, Oo0O0O0ooO0O, IIIIii, O0o0 = parms if 71 - 71: OOooOOo + ooOoO0o % i11iIiiIii + I1ii11iIi11i - IiII oO0OOoO0 = "{}:{}".format(Oo0O0O0ooO0O.print_address_no_iid(), IIIIii) I111Ii111 = lisp.green(mc.print_eid_tuple(), False) i111IiI1I = "Changed '{}' translated address:port to {} for EID {}, {} {}".format( O0o0, lisp.red(oO0OOoO0, False), I111Ii111, "{}", "{}") if 70 - 70: Ii1I.Oo0Ooo / o0oOOo0O0Ooo.Ii1I - O0 / IiII if 62 - 62: iIii1I11I1II1 * OoOoOO00 for i1 in mc.rloc_set: if (i1.rle): for OOO in i1.rle.rle_nodes: if (OOO.rloc_name != O0o0): continue OOO.store_translated_rloc(Oo0O0O0ooO0O, IIIIii) Oo0oOOo = OOO.address.print_address_no_iid() + ":" + str( OOO.translated_port) if 58 - 58: II111iiii * OOooOOo * I1ii11iIi11i / OOooOOo lisp.lprint(i111IiI1I.format("RLE", Oo0oOOo)) if 75 - 75: oO0o if 50 - 50: Ii1I / Oo0Ooo - oO0o - I11i % iII111i - oO0o if 91 - 91: OoO0O00 / I11i - II111iiii.I11i if (i1.rloc_name != O0o0): continue if 18 - 18: o0oOOo0O0Ooo if 98 - 98: iII111i * iII111i / iII111i + I11i if 34 - 34: ooOoO0o if 15 - 15: I11i * ooOoO0o * Oo0Ooo % i11iIiiIii % OoOoOO00 - OOooOOo if 68 - 68: I1Ii111 % i1IIi.IiII.I1ii11iIi11i if 92 - 92: iII111i.I1Ii111 Oo0oOOo = i1.rloc.print_address_no_iid() + ":" + str( i1.translated_port) if 31 - 31: I1Ii111.OoOoOO00 / O0 if (lisp.lisp_crypto_keys_by_rloc_encap.has_key(Oo0oOOo)): o000O0o = lisp.lisp_crypto_keys_by_rloc_encap[Oo0oOOo] lisp.lisp_crypto_keys_by_rloc_encap[oO0OOoO0] = o000O0o if 42 - 42: OoOoOO00 if 41 - 41: Oo0Ooo.ooOoO0o + O0 * o0oOOo0O0Ooo % Oo0Ooo * Oo0Ooo if 19 - 19: iII111i if 46 - 46: I1ii11iIi11i - Ii1I.iIii1I11I1II1 / I1ii11iIi11i if 7 - 7: i1IIi / I1IiiI * I1Ii111.IiII.iIii1I11I1II1 i1.delete_from_rloc_probe_list(mc.eid, mc.group) i1.store_translated_rloc(Oo0O0O0ooO0O, IIIIii) i1.add_to_rloc_probe_list(mc.eid, mc.group) lisp.lprint(i111IiI1I.format("RLOC", Oo0oOOo)) if 13 - 13: OOooOOo / i11iIiiIii if 2 - 2: I1IiiI / O0 / o0oOOo0O0Ooo % OoOoOO00 % Ii1I if 52 - 52: o0oOOo0O0Ooo if 95 - 95: Ii1I if (lisp.lisp_rloc_probing): O0oOO0O = None if (mc.group.is_null()) else mc.eid oO = mc.eid if (mc.group.is_null()) else mc.group lisp.lisp_send_map_request(iI1Ii11iII1, 0, O0oOO0O, oO, i1) if 7 - 7: o0oOOo0O0Ooo - I1IiiI if 100 - 100: oO0o + I11i.OOooOOo * Ii1I if 73 - 73: i1IIi + I1IiiI if 46 - 46: OoO0O00.Oo0Ooo - OoooooooOO if 93 - 93: iII111i if 10 - 10: I11i lisp.lisp_write_ipc_map_cache(True, mc) return (True, parms) if 82 - 82: I1ii11iIi11i - iIii1I11I1II1 / OOooOOo + Ii1I if 87 - 87: oO0o * I1ii11iIi11i + OOooOOo / iIii1I11I1II1 / iII111i if 37 - 37: iII111i - ooOoO0o * oO0o % i11iIiiIii - I1Ii111 if 83 - 83: I11i / I1IiiI if 34 - 34: IiII if 57 - 57: oO0o.I11i.i1IIi if 42 - 42: I11i + I1ii11iIi11i % O0