def initASAs(self, registrar, proxy):
###################################
# Main thread starts here
###################################
grasp.tprint("==========================")
grasp.tprint("GRASP Service is starting up.")
grasp.tprint("==========================")
#grasp.test_mode = True # tell everybody it's a test, will print extra diagnostics
#time.sleep(1) # time to read the text
####################################
# Register this ASA
####################################
# The ASA name is arbitrary - it just needs to be
# unique in the GRASP instance.
grasp.skip_dialogue(False, False, True)
_err, self._asa_nonce = grasp.register_asa("Pledge")
if not _err:
grasp.tprint("ASA Pledge registered OK")
else:
grasp.tprint("ASA registration failure:", grasp.etext[_err])
exit()
####################################
# Construct a GRASP objective
####################################
# This is an empty GRASP objective to find the proxy
# It's only used for get_flood so doesn't need to be filled in
if proxy:
proxy_obj = grasp.objective("AN_proxy")
proxy_obj.synch = True
else:
proxy_obj = None
if registrar:
reg_obj = grasp.objective("AN_join_registrar")
reg_obj.synch = True
else:
reg_obj = None
return proxy_obj, reg_obj
# The ASA name is arbitrary - it just needs to be
# unique in the GRASP instance.
_err, _asa_nonce = grasp.register_asa("ACPcontainer")
if not _err:
grasp.tprint("ASA ACPcontainer registered OK")
else:
grasp.tprint("ASA registration failure:", grasp.etext[_err])
exit()
####################################
# Construct GRASP objectives
####################################
acp_obj = grasp.objective("AN_ACP")
acp_obj.synch = True
acp_obj.discoverable = False #override default
acp_obj.value = "IKEv2"
# acp_obj.loop_count not set, the API forces it to 1 for link-local use
####################################
# Create an asa_locator for IKEv2
# communication with peers
####################################
acp_address = grasp._unspec_address # This is the unspecified address,
# which signals link-local address to API
acp_ttl = 120000 #milliseconds to live of the announcement
acp_locator = grasp.asa_locator(acp_address, 0, False)
acp_locator.is_ipaddress = True
grasp.skip_dialogue(selfing=True, quadsing=False)
#grasp.tprint("Encryption", grasp.crypto, "(should be False)")
####################################
# Register ASA/objectives
####################################
err, asa_nonce = grasp.register_asa("quadski")
if not err:
grasp.tprint("ASA quadski registered OK")
else:
exit()
keys_obj = grasp.objective("411:quadski")
keys_obj.loop_count = 4
keys_obj.neg = True
#The pledge sends the [encrypted_domain_password, pledge_PEM] as the
#value of this objective, as a list of bytes objects. The password is
#RSA encrypted with quadski's public key.
#quadski sends the key bytes and iv (initialisation vector) bytes
#file as the return value of this objective, as an array [key, iv]
#encoded in CBOR and then encrypted with the pledge's public key.
err = grasp.register_obj(asa_nonce, keys_obj)
if not err:
grasp.tprint("Objective", keys_obj.name, "registered OK")
else:
exit()
def run(self):
global cheat_nonce
iwant = grasp._prng.randint(10, 500)
grasp.tprint("Asking for $", iwant)
err, asa_nonce2 = grasp.register_asa("Neg2") #assume it worked
obj = grasp.objective("EX2")
obj.neg = True
#obj.loop_count = 2 #for testing purposes
while cheat_nonce == None:
time.sleep(
1) #we should exit after neg1 has registered the objective
asa_nonce = cheat_nonce #now we can pretend to own the objective
grasp.tprint("Got nonce", asa_nonce)
err, ll = grasp.discover(asa_nonce, obj, 5000)
if ll == []:
grasp.tprint("Discovery failed: exit")
return
grasp.tprint("Discovered locator", ll[0].locator)
#attempt to negotiate
obj.value = ["NZD", iwant]
if not iwant % 7:
obj.value = ["USD", iwant] # for testing purposes
err, snonce, answer = grasp.req_negotiate(asa_nonce, obj, ll[0], None)
if err:
if err == grasp.errors.declined and answer != "":
_t = answer
else:
_t = grasp.etext[err]
grasp.tprint("req_negotiate error:", _t)
elif (not err) and snonce:
grasp.tprint("requested, session_nonce:", snonce, "answer", answer)
if answer.value[1] < 0.75 * iwant:
answer.value[1] = int(0.75 * iwant)
err, temp, answer2 = grasp.negotiate_step(
asa_nonce, snonce, answer, 1000)
grasp.tprint("Step1 gave:", err, temp, answer2)
if (not err) and (not temp):
grasp.tprint("Negotiation succeeded", answer.value)
elif not err:
#not acceptable, try one more time
answer2.value[1] = int(0.6 * iwant)
#at random, throw an invalid format of message
if not iwant % 3:
grasp.tprint("Trying badmess")
grasp._make_badmess = True
err, temp, answer3 = grasp.negotiate_step(
asa_nonce, snonce, answer2, 1000)
grasp.tprint("Step2 gave:", err, temp, answer3)
if (not err) and (not temp):
grasp.tprint("Negotiation succeeded", answer3.value)
elif (not err):
#not acceptable
err = grasp.end_negotiate(asa_nonce,
snonce,
False,
reason="You are mean!")
if err:
grasp.tprint("end_negotiate error:",
grasp.etext[err])
else:
#other end rejected
grasp.tprint("Peer reject:", answer3)
else:
#other end rejected
grasp.tprint("Peer reject:", answer2)
else: #acceptable answer
err = grasp.end_negotiate(asa_nonce, snonce, True)
if not err:
grasp.tprint("Negotiation succeeded", answer.value)
else:
grasp.tprint("end_negotiate error:", grasp.etext[err])
else: #acceptable answer first time
grasp.tprint("Negotiation succeeded", answer.value)
grasp.tprint("Exit")
def run(self):
global cheat_nonce
reserves = grasp._prng.randint(100, 400)
wt = grasp._prng.randint(15000, 40000)
grasp.tprint("Reserves: $", reserves, "wait:", wt)
err, asa_nonce = grasp.register_asa("Neg1") #assume it worked
obj = grasp.objective("EX2")
obj.neg = True
#obj.loop_count = 2 #for testing purposes
grasp.register_obj(asa_nonce, obj) #assume it worked
cheat_nonce = asa_nonce #pass the nonce to the other negotiator!
#attempt to listen
err, snonce, answer = grasp.listen_negotiate(asa_nonce, obj)
if err:
grasp.tprint("listen_negotiate error:", grasp.etext[err])
else:
grasp.tprint("listened, answer", answer.name, answer.value)
grasp.tprint("Source was", snonce.id_source)
result = True
reason = None
concluded = False
if answer.value[0] != "NZD":
result = False
reason = "Invalid currency"
elif answer.value[1] > reserves / 2:
answer.value = ["NZD", int(reserves / 2)]
err, temp, answer2 = grasp.negotiate_step(
asa_nonce, snonce, answer, 1000)
grasp.tprint("Step1 gave:", err, temp, answer2)
if (not err) and (not temp):
concluded = True
grasp.tprint("Negotiation succeeded", answer2.value)
elif not err:
err1 = grasp.negotiate_wait(asa_nonce, snonce, wt)
grasp.tprint("Tried wait:", grasp.etext[err1])
time.sleep(
20) #note - if wt<20000 this tests anomaly handling
grasp.tprint("Woke up")
answer2.value = ["NZD", int(0.75 * reserves)]
err2, temp, answer3 = grasp.negotiate_step(
asa_nonce, snonce, answer2, 1000)
grasp.tprint("Step2 gave:", err2, temp, answer3)
if (not err2) and (not temp):
concluded = True
grasp.tprint("Negotiation succeeded", answer3.value)
elif not err2:
result = False
if reserves % 2:
reason = "Insufficient funds"
else:
reason = u"Недостаточно средств"
else:
#other end rejected
concluded = True
grasp.tprint("Peer reject2:", answer3)
else:
#other end rejected
concluded = True
grasp.tprint("Peer reject1:", answer2)
else: #can accept the requested value
pass
if not concluded:
err = grasp.end_negotiate(asa_nonce,
snonce,
result,
reason=reason)
if err:
grasp.tprint("end_negotiate error:", grasp.etext[err])
grasp.tprint("Exit")
def main(args):
###################################
# Main thread starts here
###################################
grasp.tprint("==========================")
grasp.tprint("Registrar initializing")
grasp.tprint("==========================")
grasp.test_mode = False # set if you want detailed diagnostics
#time.sleep(1) # time to read the text
####################################
# Register this ASA
####################################
# The ASA name is arbitrary - it just needs to be
# unique in the GRASP instance. If you wanted to
# run two registrars in one GRASP instance, they
# would need different names. For example the name
# could include a timestamp.
grasp.skip_dialogue(False, False, True)
_err, asa_nonce = grasp.register_asa("Reggie")
#grasp.tprint("TYPE: ", type(asa_nonce))
#.skip_dialogue(False,False,True)
if not _err:
grasp.tprint("ASA Registrar registered OK")
else:
grasp.tprint("ASA Registrar failure:", grasp.etext[_err])
exit() # demo code doesn't handle registration errors
#grasp.skip_dialogue(False,False,True)
####################################
# Create a TCP port for BRSKI-TCP
####################################
# For this demo, we just make up some numbers:
tcp_port = 80
tcp_proto = socket.IPPROTO_TCP
tcp_address = grasp._my_address # current address determined by GRASP kernel
####################################
# Construct a correponding GRASP ASA locator
####################################
tcp_locator = grasp.asa_locator(tcp_address, None, False)
tcp_locator.protocol = tcp_proto
tcp_locator.port = tcp_port
tcp_locator.is_ipaddress = True
####################################
# Create a IPv4 port for BRSKI-IPv4
####################################
# For this demo, we just make up some numbers:
ipv4_port = 80
ipv4_proto = socket.IPPROTO_TCP
#ipv4_address = '172.2.13.0' #grasp._my_address # current address determined by GRASP kernel
ipv4_address = findOwnIPv4() # current address determined by GRASP kernel
####################################
# Construct a correponding GRASP ASA locator
####################################
ipv4_locator = grasp.asa_locator(ipv4_address, None, False)
ipv4_locator.protocol = ipv4_proto
ipv4_locator.port = ipv4_port
#ipv4_locator.is_ipaddress = True
ipv4_locator.is_fqdn = True
####################################
# Construct the GRASP objective
####################################
radius = 255 # Limit the radius of flooding
reg_obj = grasp.objective("AN_join_registrar")
reg_obj.loop_count = radius
reg_obj.synch = True # needed for flooding
reg_obj.value = None
####################################
# Register the GRASP objective
####################################
_err = grasp.register_obj(asa_nonce, reg_obj)
if not _err:
grasp.tprint("Objective", reg_obj.name, "registered OK")
else:
grasp.tprint("Objective registration failure:", grasp.etext[_err])
exit() # demo code doesn't handle registration errors
####################################
# Start pretty printing
####################################
#grasp.init_bubble_text("BRSKI Join Registrar (flooding method)")
grasp.tprint("==========================")
grasp.tprint("Registrar starting now")
grasp.tprint("==========================")
####################################
# Start flooding thread
####################################
f = flooder(reg_obj, ipv4_locator, asa_nonce)
f.start()
#flooder().start()
grasp.tprint("Flooding", reg_obj.name, "for ever")
###################################
# Listen for requests
###################################
# Here, launch a thread to do the real work of the registrar
# via the various ports But for the demo, we just pretend...
#grasp.tprint("Pretending to listen to ports", tcp_port,",", udp_port,
# "and for IP-in-IP")
###################################
# Do whatever needs to be done in the main thread
###################################
# At a minimum, the main thread should keep an eye
# on the other threads and restart them if needed.
# For the demo, we just dump some diagnostic data...
try:
while True:
time.sleep(5)
#grasp.tprint("Registrar main loop diagnostic dump:")
#dump_some()
except KeyboardInterrupt:
print('interrupted!')
grasp.tprint("EXITTING")
f.stop()
exit()
grasp.tprint("that displays the talking process.")
grasp.tprint("==========================")
time.sleep(8) # so the user can read the text
####################################
# Register ASA/objectives
####################################
name = "TestClient"
err,asa_handle = grasp.register_asa(name)
if err:
exit()
grasp.tprint("ASA", name, "registered OK")
obj3 = grasp.objective("EX3")
obj3.neg = True
err = grasp.register_obj(asa_handle,obj3)
if not err:
grasp.tprint("Objective EX3 registered OK")
else:
exit()
grasp.init_bubble_text(name)
grasp.tprint("Ready to negotiate EX3 as client")
failct = 0
while True:
#grasp.test_mode = True # tell everybody it's a test
time.sleep(8) # so the user can read the text
failct = 0 # fail counter to control discovery retries
####################################
# Register ASA/objectives
####################################
err, asa_nonce = grasp.register_asa("AskDNSSD")
if not err:
grasp.tprint("ASA AskDNSSD registered OK")
else:
exit()
#This objective is for the negotiating test
obj3 = grasp.objective("411:DNSSD")
obj3.neg = True
obj3.loop_count = 4
err = grasp.register_obj(asa_nonce, obj3)
if not err:
grasp.tprint("Objective", obj3.name, "registered OK")
else:
exit()
###################################
# Set up pretty printing
###################################
grasp.init_bubble_text("AskDNSSD")
grasp.tprint("Ready to negotiate", obj3.name, "as requester")
#grasp.test_mode = True # tell everybody it's a test
time.sleep(8) # so the user can read the text
failct = 0 # fail counter to control discovery retries
####################################
# Register ASA/objectives
####################################
err, asa_nonce = grasp.register_asa("AskDNSSD2")
if not err:
grasp.tprint("ASA AskDNSSD2 registered OK")
else:
exit()
#This objective is for the negotiating test
obj3 = grasp.objective("SRV.")
obj3.neg = True
err = grasp.register_obj(asa_nonce, obj3)
if not err:
grasp.tprint("Objective", obj3.name, "registered OK")
else:
exit()
###################################
# Set up pretty printing
###################################
grasp.init_bubble_text("AskDNSSD2")
grasp.tprint("Ready to negotiate", obj3.name, "as requester")
_err, _asa_nonce = grasp.register_asa("Procksy")
if not _err:
grasp.tprint("ASA Procksy registered OK")
else:
grasp.tprint("ASA registration failure:", grasp.etext[_err])
exit()
####################################
# Construct a GRASP objective
####################################
# This is an empty GRASP objective to find the registrar
# It's only used for get_flood so doesn't need to be filled in
reg_obj = grasp.objective("AN_join_registrar")
reg_obj.synch = True
####################################
# Create ports for the proxy's communication
# with pledges
####################################
# For this demo, we just make up some numbers:
t_port = 11800 + grasp._prng.randint(0, 5) #slightly random for demo
u_port = 11900 + grasp._prng.randint(0, 5) #slightly random for demo
proxy_address = grasp._unspec_address # This is the unspecified address,
# which signals link-local address to API
proxy_ttl = 180000 #milliseconds to live of the announcement
time.sleep(8) # so the user can read the text
grasp.skip_dialogue(selfing=True)
####################################
# Register ASA/objective
####################################
err, asa_nonce = grasp.register_asa("pusher")
if not err:
grasp.tprint("ASA pusher registered OK")
else:
exit()
supported_obj = grasp.objective("411:mvFile")
supported_obj.loop_count = 4
supported_obj.neg = True
err = grasp.register_obj(asa_nonce, supported_obj)
if not err:
grasp.tprint("Objective", supported_obj.name, "registered OK")
else:
exit()
###################################
# Set up pretty printing
###################################
grasp.init_bubble_text("pusher")
grasp.tprint("pusher is listening")
####################################
# Construct a correponding GRASP ASA locator
####################################
ipip_locator = grasp.asa_locator(ipip_address, None, False)
ipip_locator.protocol = ipip_proto
ipip_locator.port = ipip_port
ipip_locator.is_ipaddress = True
####################################
# Construct the GRASP objective
####################################
radius = 255 # Limit the radius of flooding
reg_obj = grasp.objective("AN_join_registrar")
reg_obj.loop_count = radius
reg_obj.synch = True # needed for flooding
reg_obj.value = None
####################################
# Register the GRASP objective
####################################
_err = grasp.register_obj(asa_nonce, reg_obj)
if not _err:
grasp.tprint("Objective", reg_obj.name, "registered OK")
else:
grasp.tprint("Objective registration failure:", grasp.etext[_err])
exit() # demo code doesn't handle registration errors
grasp.skip_dialogue(selfing=True)
time.sleep(8) # so the user can read the text
failct = 0 # fail counter to control discovery retries
####################################
# Register ASA/objectives
####################################
err, asa_nonce = grasp.register_asa("getter")
if not err:
grasp.tprint("ASA getter registered OK")
else:
exit()
#This objective is for the negotiating test
requested_obj = grasp.objective("411:mvFile")
requested_obj.neg = True
requested_obj.loop_count = 4
err = grasp.register_obj(asa_nonce, requested_obj)
if not err:
grasp.tprint("Objective", requested_obj.name, "registered OK")
else:
exit()
###################################
# Set up pretty printing
###################################
grasp.init_bubble_text("getter")
grasp.tprint("Ready to negotiate", requested_obj.name, "as requester")
_err, _asa_nonce = grasp.register_asa("Pledji")
if not _err:
grasp.tprint("ASA Pledji registered OK")
else:
grasp.tprint("ASA registration failure:", grasp.etext[_err])
exit()
####################################
# Construct a GRASP objective
####################################
# This is an empty GRASP objective to find the proxy
# It's only used for get_flood so doesn't need to be filled in
proxy_obj = grasp.objective("AN_proxy")
proxy_obj.synch = True
grasp.init_bubble_text("BRSKI Pledge (flooding method)")
grasp.tprint("Pledge starting now")
###################################
# Now find the proxy(s)
###################################
while True:
proxy = None
_err, _results = grasp.get_flood(_asa_nonce, proxy_obj)
if not _err:
# _results contains all the unexpired tagged objectives
grasp.tprint("Found", len(_results), "result(s)")
pass
btext = "Pfxm3 Delegator"
####################################
# Register ASA/objectives
####################################
_err, asa_nonce = grasp.register_asa("pfxm3")
if not _err:
grasp.tprint("ASA pfxm3 registered OK")
else:
grasp.tprint("Fatal error:", grasp.etext[_err])
exit()
obj1 = grasp.objective("PrefixManager")
obj1.loop_count = 4
obj1.neg = True
obj1.value = None
# Value is defined as a list [IPversion, length, prefix]
## Value is defined as a list [IPversion, PDcapable, length, prefix]
# Offset definitions:
ipv = 0
PD = ipv #not used in this version
lgth = PD + 1
pfx = lgth + 1
_err = grasp.register_obj(asa_nonce, obj1)
if not _err:
#grasp.test_mode = True # set if you want detailed diagnostics
time.sleep(8) # so the user can read the text
####################################
# Register ASA/objective
####################################
err,asa_nonce = grasp.register_asa("GetDNSSD2")
if not err:
grasp.tprint("ASA GetDNSSD2 registered OK")
else:
exit()
obj1 = grasp.objective("SRV.")
obj1.loop_count = 4
obj1.neg = True
err = grasp.register_obj(asa_nonce,obj1)
if not err:
grasp.tprint("Objective", obj1.name, "registered OK")
else:
exit()
###################################
# Hack to get round nameservers that can't resolve the test domain
###################################
try:
time.sleep(8) # so the user can read the text
_prng = random.SystemRandom() # best PRNG we can get
####################################
# Register ASA/objectives
####################################
err, asa_nonce = grasp.register_asa("Gray")
if not err:
grasp.tprint("ASA Gray registered OK")
else:
exit()
#This objective is for the flooding test
#so doesn't need to be registered
obj1 = grasp.objective("EX1")
obj1.loop_count = 4
obj1.synch = True
#This objective is for the synchronizing test
#so doesn't need to be registered
obj2 = grasp.objective("EX2")
obj2.loop_count = 4
obj2.synch = True
#This objective is for the negotiating test
obj3 = grasp.objective("EX3")
obj3.neg = True
err = grasp.register_obj(asa_nonce, obj3)
if not err:
#grasp.test_mode = True # set if you want detailed diagnostics
time.sleep(8) # so the user can read the text
####################################
# Register ASA/objectives
####################################
err, asa_nonce = grasp.register_asa("Briggs")
if not err:
grasp.tprint("ASA Briggs registered OK")
else:
exit()
obj1 = grasp.objective("EX1")
obj1.loop_count = 4
obj1.synch = True
err = grasp.register_obj(asa_nonce, obj1)
if not err:
grasp.tprint("Objective EX1 registered OK")
else:
exit()
obj2 = grasp.objective("EX2")
obj2.loop_count = 4
obj2.synch = True
err = grasp.register_obj(asa_nonce, obj2, rapid=True)
if not err:
####################################
# Register ASA/objectives
####################################
asa_name = "Mudslinger"
err, asa_nonce = grasp.register_asa("asa_name")
if not err:
grasp.tprint("ASA", asa_name, "registered OK")
else:
grasp.tprint("ASA registration failure:", grasp.etext[err])
time.sleep(60)
exit()
obj_name = "411:MUDURL"
obj3 = grasp.objective(obj_name)
obj3.neg = True
err = grasp.register_obj(asa_nonce, obj3)
if not err:
grasp.tprint("Objective", obj_name, "registered OK")
else:
grasp.tprint("Objective registration failure:", grasp.etext[err])
time.sleep(60)
exit()
if grasp.test_mode:
dump_some()
###################################
# Negotiate MUDURL as initiator to send URL
# The ASA name is arbitrary - it just needs to be
# unique in the GRASP instance.
_err, _asa_nonce = grasp.register_asa("ACPcontainer")
if not _err:
grasp.tprint("ASA ACPcontainer registered OK")
else:
grasp.tprint("ASA registration failure:", grasp.etext[_err])
exit()
####################################
# Construct GRASP objectives
####################################
acp_obj = grasp.objective("AN_ACP")
acp_obj.synch = True
acp_obj.discoverable = False #override default
acp_obj.value = "IKEv2"
# acp_obj.loop_count not set, the API forces it to 1 for link-local use
est_obj = grasp.objective("SRV.est")
est_obj.synch = True
est_obj.discoverable = False #override default
est_obj.value = "EST-TLS" #for RFC7030
# est_obj.loop_count not set, the API forces it to 1 for link-local use
####################################
# Create an asa_locator for IKEv2
# communication with peers
####################################
def run(self):
time.sleep(1) # avoid printing glitch
grasp.tprint(
"WARNING: you can't run this test suite more than once without restarting the Python context; it leaves GRASP data structures dirty!\n"
)
grasp.skip_dialogue(testing=True, selfing=True, diagnosing=True)
time.sleep(1) # just to avoid mixed up print output
####################################
# Test code: register ASA/objective#
####################################
test_obj = grasp.objective("EX1")
test_obj.loop_count = 2
test_obj.synch = True
err, test_nonce = grasp.register_asa("ASA-1")
if not err:
err = grasp.register_obj(test_nonce, test_obj, ttl=10000)
if not err:
grasp.tprint("ASA-1 and EX1 Registered OK")
####################################
# Test code: discover EX1 #
####################################
err, test_ll = grasp.discover(test_nonce, test_obj, 10000)
if len(test_ll) > 0:
grasp.tprint("EX1 discovery result", test_ll[0].locator)
else:
grasp.tprint("No EX1 discovery response")
####################################
# Test code: register and discover #
# Boot ASA/objective #
####################################
err, boot_nonce = grasp.register_asa("Boot")
if err:
#we've got a problem...
raise RuntimeError("Can't register Boot as ASA")
boot_obj = grasp.objective("Boot")
boot_obj.loop_count = 2
boot_obj.synch = True
err = grasp.register_obj(boot_nonce, boot_obj, discoverable=True)
if err:
#we've got a different problem...
raise RuntimeError("Can't register Boot objective")
for i in range(3):
#test discovery 3 times, including artificial Divert
grasp.tprint("Test ASA: grasp.test_divert", grasp.test_divert)
err, boot_ll = grasp.discover(boot_nonce, boot_obj, 5000)
if len(boot_ll) > 0:
grasp.tprint("Boot discovery result", boot_ll[0].locator)
grasp.test_divert = True
else:
grasp.tprint("No Boot discovery response")
time.sleep(5)
grasp.test_divert = False
####################################
# Test code: send Flood messages
####################################
obj1 = grasp.objective("Money")
obj1.synch = True
obj1.loop_count = 2
err = grasp.register_obj(test_nonce, obj1)
obj1.value = [100, "NZD"]
obj2 = grasp.objective("Bling")
obj2.synch = True
obj2.loop_count = 2
err = grasp.register_obj(test_nonce, obj2)
obj2.value = ["Diamonds", "Rubies"]
err = grasp.register_obj(test_nonce, obj2)
if err:
grasp.tprint(grasp.etext[err])
obj3 = grasp.objective("Intent.PrefixManager")
obj3.synch = True
obj3.loop_count = 2
err = grasp.register_obj(test_nonce, obj3)
#obj3.value = '{"autonomic_intent":[{"model_version": "1.0"},{"intent_type": "Network management"},{"autonomic_domain": "Customer_X_intranet"},{"intent_name": "Prefix management"},{"intent_version": 73},{"Timestamp": "20150606 00:00:00"},{"Lifetime": "Permanent"},{"signature":"XXXXXXXXXXXXXXXXXXX"},{"content":[{"role": [{"role_name": "RSG"},{"role_characteristic":[{"prefix_length":"34"}]}]},{"role": [{"role_name": "ASG"},{"role_characteristic":[{"prefix_length": "44"}]}]},{"role": [{"role_name": "CSG"},{"role_characteristic":[{"prefix_length": "56"}]}]}]}]}'
#obj3.value = '{"autonomic_intent dummy text"}'
#obj3.value = bytes.fromhex('48deadbeefdeadbeef') #dummy CBOR
obj3.value = cbor.dumps(["Some", "embedded", "CBOR", [1, 2, 3]])
grasp.flood(test_nonce, 0, grasp.tagged_objective(obj1, None),
grasp.tagged_objective(obj2, None),
grasp.tagged_objective(obj3, None))
###################################
# Test code: Listen Synchronize as from Boot ASA
###################################
boot_obj.value = [1, "two", 3]
boot_obj.synch = True
err = grasp.listen_synchronize(boot_nonce, boot_obj)
grasp.tprint("Listen synch", grasp.etext[err])
grasp.tprint(grasp._obj_registry[1].objective.name, "value",
grasp._obj_registry[1].objective.value)
###################################
# Test code: call Synchronize as from EX1
###################################
time.sleep(5)
err, result = grasp.synchronize(test_nonce, obj2, None, 5000)
if not err:
grasp.tprint("Flooded synch obj2", result.value)
else:
grasp.tprint("Synch fail obj2", grasp.etext[err])
err, result = grasp.synchronize(test_nonce, obj3, None, 5000)
if not err:
grasp.tprint("Flooded synch obj3", result.value)
else:
grasp.tprint("Synch fail obj3", grasp.etext[err])
#this should fail as test_obj was neither flooded or listened for.
err, result = grasp.synchronize(test_nonce, test_obj, None, 5000)
if not err:
grasp.tprint("Synch test_obj (should fail)", result.value)
else:
grasp.tprint("Synch fail test_obj (should fail)", grasp.etext[err])
boot2_obj = grasp.objective("Boot")
boot2_obj.synch = True
err, result = grasp.synchronize(test_nonce, boot2_obj, None, 5000)
if not err:
grasp.tprint("Synch boot2_obj", result.name, result.value)
else:
grasp.tprint("Synch fail boot2_obj", grasp.etext[err])
###################################
# Test code: print obj_registry
# and flood cache
###################################
grasp.tprint("Objective registry contents:")
for x in grasp._obj_registry:
o = x.objective
grasp.tprint(o.name, "ASA:", x.asa_id, "Listen:", x.listening,
"Neg:", o.neg, "Synch:", o.synch, "Count:",
o.loop_count, "Value:", o.value)
grasp.tprint("Flood cache contents:")
for x in grasp._flood_cache:
grasp.tprint(x.objective.name, "count:", x.objective.loop_count,
"value:", x.objective.value, "source:", x.source)
time.sleep(5)
###################################
# Test code: check flood cache for Tag 24 case
###################################
flobj = grasp.objective("Intent.PrefixManager")
flobj.synch = True
err, tobs = grasp.get_flood(test_nonce, flobj)
if not err:
for x in tobs:
try:
grasp.tprint("Flooded CBOR", x.objective.name,
cbor.loads(x.objective.value))
except:
grasp.tprint("Flooded raw", x.objective.name,
x.objective.value)
###################################
# Test code: deregister and then
# attempt synch
###################################
err = grasp.deregister_obj(boot_nonce, boot_obj)
if not err:
grasp.tprint("Deregistered Boot", )
else:
grasp.tprint("Deregister failure", grasp.etext[err])
err, result = grasp.synchronize(test_nonce, boot2_obj, None, 5000)
if not err:
grasp.tprint("Synch boot2_obj (should fail)", result.name,
result.value)
else:
grasp.tprint("Synch fail boot2_obj (should fail)",
grasp.etext[err])
###################################
# Test code: start in-host negotiate test
###################################
cheat_nonce = None
Neg1().start()
time.sleep(10)
Neg2().start()
#####################################
# Test code:
# test deregistering an ASA,
# and exit the thread
#####################################
grasp.deregister_asa(test_nonce, "ASA-1")
grasp.tprint("Exiting ASA test thread")
