def run(self):
"""Execute conversation"""
node = self.conversation
try:
while node is not None:
msg = None
if node.is_command():
# update connection state
node.process(self.state)
node = node.child
continue
elif node.is_expect():
# check peer response
try:
header, parser = self.state.msg_sock.recvMessageBlocking(
)
except TLSAbruptCloseError:
close_node = next((n for n in node.get_all_siblings() \
if isinstance(n, ExpectClose)), None)
if close_node:
node = close_node.child
continue
else:
raise AssertionError(
"Unexpected closure from peer")
msg = Message(header.type, parser.bytes)
node = next((proc for proc in node.get_all_siblings()
if proc.is_match(msg)), None)
if node is None:
# since we're aborting, the user can't clean up
self.state.msg_sock.sock.close()
raise AssertionError("Unexpected message from peer: " +
str(msg.contentType) + ", " +
str(msg.write()[0]))
node.process(self.state, msg)
node = node.child
continue
elif node.is_generator():
# send message to peer
msg = node.generate(self.state)
self.state.msg_sock.sendMessageBlocking(msg)
node.post_send(self.state)
node = node.child
continue
else:
raise AssertionError("Unknown decision tree node")
except:
# TODO put into a log
print("Error encountered while processing node " + str(node) +
" with last message being: " + repr(msg))
raise
def run(self):
"""Execute conversation"""
node = self.conversation
try:
while node is not None:
old_node = None
msg = None
if node.is_command():
# update connection state
node.process(self.state)
node = node.child
continue
elif node.is_expect():
# check peer response
try:
header, parser = self.state.msg_sock.recvMessageBlocking()
except (TLSAbruptCloseError, socket.error):
close_node = next((n for n in node.get_all_siblings() \
if isinstance(n, ExpectClose)), None)
if close_node:
node = close_node.child
continue
else:
raise AssertionError("Unexpected closure from peer")
msg = Message(header.type, parser.bytes)
old_node = node
node = next((proc for proc in node.get_all_siblings()
if proc.is_match(msg)), None)
if node is None:
# since we're aborting, the user can't clean up
self.state.msg_sock.sock.close()
raise AssertionError("Unexpected message from peer: " +
guess_response(msg.contentType,
msg.write()))
node.process(self.state, msg)
node = node.child
continue
elif node.is_generator():
# send message to peer
msg = node.generate(self.state)
try:
self.state.msg_sock.sendMessageBlocking(msg)
except socket.error:
close_node = next((n for n in node.get_all_siblings()
if isinstance(n, ExpectClose)), None)
if close_node:
node = close_node.child
continue
else:
raise AssertionError("Unexpected closure from peer")
node.post_send(self.state)
node = node.child
continue
else:
raise AssertionError("Unknown decision tree node")
except:
# TODO put into a log
if node is None:
node = old_node
print("Error encountered while processing node " + str(node) +
" (child: " + str(node.child) + ") with last message " +
"being: " + repr(msg))
raise
def run(self):
"""Execute conversation"""
node = self.conversation
try:
while node is not None:
old_node = None
msg = None
if node.is_command():
# update connection state
node.process(self.state)
node = node.child
continue
elif node.is_expect():
# check peer response
try:
header, parser = self.state.msg_sock.recvMessageBlocking()
except (TLSAbruptCloseError, socket.error):
close_node = next((n for n in node.get_all_siblings() \
if isinstance(n, ExpectClose)), None)
if close_node:
close_node.process(self.state, None)
node = close_node.child
continue
else:
raise AssertionError("Unexpected closure from peer")
msg = Message(header.type, parser.bytes)
old_node = node
node = next((proc for proc in node.get_all_siblings()
if proc.is_match(msg)), None)
if node is None:
# since we're aborting, the user can't clean up
self.state.msg_sock.sock.close()
raise AssertionError("Unexpected message from peer: " +
guess_response(\
msg.contentType,
msg.write(),
isinstance(header,
RecordHeader2)))
node.process(self.state, msg)
node = node.child
continue
elif node.is_generator():
# send message to peer
msg = node.generate(self.state)
try:
if msg.write():
# sendMessageBlocking is buffered and fragmenting
# that means that 0-length messages would get lost
self.state.msg_sock.sendMessageBlocking(msg)
else:
for _ in self.state.msg_sock.sendRecord(msg):
# make the method into a blocking one
pass
except socket.error:
close_node = next((n for n in node.get_all_siblings()
if isinstance(n, ExpectClose)), None)
if close_node:
node = close_node.child
continue
else:
raise AssertionError("Unexpected closure from peer")
# allow generators to perform actions after the message
# was sent like updating handshake hashes
node.post_send(self.state)
node = node.child
continue
else:
raise AssertionError("Unknown decision tree node")
except:
if self.state.msg_sock:
self.state.msg_sock.sock.close()
# TODO put into a log
if node is None:
node = old_node
print("Error encountered while processing node " + str(node) +
" (child: " + str(node.child) + ") with last message " +
"being: " + repr(msg))
raise
def run(self):
"""Execute conversation"""
node = self.conversation
try:
while node is not None:
old_node = None
msg = None
if node.is_command():
# update connection state
node.process(self.state)
node = node.child
continue
elif node.is_expect():
if isinstance(node, ExpectNoMessage):
old_timeout = self.state.msg_sock.sock.gettimeout()
self.state.msg_sock.sock.settimeout(node.timeout)
# check peer response
try:
header, parser = self.state.msg_sock.\
recvMessageBlocking()
except (TLSAbruptCloseError, socket.error) as exc:
if isinstance(exc, socket.timeout) and \
isinstance(node, ExpectNoMessage):
# for ExpectNoMessage we have nothing to do
# but to continue
self.state.msg_sock.sock.settimeout(old_timeout)
node = node.child
continue
close_node = next((n for n in node.get_all_siblings()
if isinstance(n, ExpectClose)),
None)
# timeout will happen if the other side hanged, to
# try differentiated between (when no alerts are sent)
# allow for close only when the connection was actively
# closed
if close_node and not isinstance(exc, socket.timeout):
close_node.process(self.state, None)
node = close_node.child
continue
else:
if isinstance(exc, socket.timeout):
raise AssertionError(
"Timeout when waiting for peer message")
else:
raise AssertionError(
"Unexpected closure from peer")
msg = Message(header.type, parser.bytes)
old_node = node
node = next((proc for proc in node.get_all_siblings()
if proc.is_match(msg)), None)
if node is None:
# since we're aborting, the user can't clean up
self.state.msg_sock.sock.close()
raise AssertionError("Unexpected message from peer: " +
guess_response(\
msg.contentType,
msg.write(),
isinstance(header,
RecordHeader2)))
node.process(self.state, msg)
node = node.child
continue
elif node.is_generator():
# send message to peer
msg = node.generate(self.state)
try:
if msg.write():
# sendMessageBlocking is buffered and fragmenting
# that means that 0-length messages would get lost
self.state.msg_sock.sendMessageBlocking(msg)
else:
for _ in self.state.msg_sock.sendRecord(msg):
# make the method into a blocking one
pass
except socket.error:
close_node = next(
(n for n in node.get_all_siblings()
if isinstance(n, (ExpectClose, ExpectAlert))),
None)
if close_node:
node = close_node.child
continue
else:
raise AssertionError(
"Unexpected closure from peer")
# allow generators to perform actions after the message
# was sent like updating handshake hashes
node.post_send(self.state)
node = node.child
continue
else:
raise AssertionError("Unknown decision tree node")
except:
if self.state.msg_sock:
self.state.msg_sock.sock.close()
# TODO put into a log
if node is None:
node = old_node
print("Error encountered while processing node " + str(node) +
" (child: " + str(node.child) + ") with last message " +
"being: " + repr(msg))
raise