Beispiel #1
0
def lisp_itr_process_nonce_ipc(ipc):
    x, opcode, rloc_str, nonce = ipc.split("%")
    nonce = int(nonce, 16)

    echo_nonce = lisp.lisp_get_echo_nonce(None, rloc_str)
    if (echo_nonce == None): echo_nonce = lisp.lisp_echo_nonce(rloc_str)

    #
    # If we are in request-nonce mode, exit it, so we can echo the nonce the
    # other side is requesting.
    #
    if (opcode == "R"):
        echo_nonce.request_nonce_rcvd = nonce
        echo_nonce.last_request_nonce_rcvd = lisp.lisp_get_timestamp()
        echo_nonce.echo_nonce_sent = nonce
        echo_nonce.last_new_echo_nonce_sent = lisp.lisp_get_timestamp()
        lisp.lprint("Start echo-nonce mode for {}, nonce 0x{}".format( \
            lisp.red(echo_nonce.rloc_str, False), lisp.lisp_hex_string(nonce)))
    #endif

    if (opcode == "E"):
        echo_nonce.echo_nonce_rcvd = nonce
        echo_nonce.last_echo_nonce_rcvd = lisp.lisp_get_timestamp()

        if (echo_nonce.request_nonce_sent == nonce):
            en = lisp.bold("echoed nonce", False)
            lisp.lprint("Received {} {} from {}".format(en,
                lisp.lisp_hex_string(nonce), 
                lisp.red(echo_nonce.rloc_str, False)))

            echo_nonce.request_nonce_sent = None
            lisp.lprint("Stop request-nonce mode for {}".format( \
                lisp.red(echo_nonce.rloc_str, False)))
            echo_nonce.last_good_echo_nonce_rcvd = lisp.lisp_get_timestamp()
        else:
            rns = "none"
            if (echo_nonce.request_nonce_sent):
                rns = lisp.lisp_hex_string(echo_nonce.request_nonce_sent)
            #endif
            lisp.lprint(("Received echo-nonce 0x{} from {}, but request-" + \
                "nonce is {}").format(lisp.lisp_hex_string(nonce),
                lisp.red(echo_nonce.rloc_str, False), rns))
        #endif
    #endif
    return
Beispiel #2
0
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
Beispiel #3
0
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)
Beispiel #4
0
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
Beispiel #5
0
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])
Beispiel #6
0
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)
Beispiel #7
0
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>")
Beispiel #8
0
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)
Beispiel #9
0
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