def _run_method(self): self._receive_buffer = "" self._accumulated_output = "" if self._logger: self._logger.info("socket pump starting") # Keep looping around until we're asked to stop the thread. while not self._stop_thread: can_read, _, _ = select.select([self._socket], [], [], 0) if can_read and self._socket in can_read: try: new_bytes = seven.bitcast_to_string( self._socket.recv(4096)) if self._logger and new_bytes and len(new_bytes) > 0: self._logger.debug( "pump received bytes: {}".format(new_bytes)) except: # Likely a closed socket. Done with the pump thread. if self._logger: self._logger.debug( "socket read failed, stopping pump read thread\n" + traceback.format_exc(3)) break self._process_new_bytes(new_bytes) if self._logger: self._logger.info("socket pump exiting")
def _run(self): # For testing purposes, we only need to worry about one client # connecting just one time. try: # accept() is stubborn and won't fail even when the socket is # shutdown, so we'll use a timeout self._socket.settimeout(2.0) client, client_addr = self._socket.accept() self._client = client # The connected client inherits its timeout from self._socket, # but we'll use a blocking socket for the client self._client.settimeout(None) except: return self._shouldSendAck = True self._receivedData = "" self._receivedDataOffset = 0 data = None while True: try: data = seven.bitcast_to_string(self._client.recv(4096)) if data is None or len(data) == 0: break self._receive(data) except Exception as e: self._client.close() break
def run(self): # For testing purposes, we only need to worry about one client # connecting just one time. try: self._socket.accept() except: traceback.print_exc() return self._shouldSendAck = True self._receivedData = "" self._receivedDataOffset = 0 data = None try: while True: data = seven.bitcast_to_string(self._socket.recv()) if data is None or len(data) == 0: break self._receive(data) except self.TerminateConnectionException: pass except Exception as e: print("An exception happened when receiving the response from the gdb server. Closing the client...") traceback.print_exc() finally: self._socket.close_connection() self._socket.close_server()
def _run_method(self): self._receive_buffer = "" self._accumulated_output = "" if self._logger: self._logger.info("socket pump starting") # Keep looping around until we're asked to stop the thread. while not self._stop_thread: can_read, _, _ = select.select([self._socket], [], [], 0) if can_read and self._socket in can_read: try: new_bytes = seven.bitcast_to_string(self._socket.recv(4096)) if self._logger and new_bytes and len(new_bytes) > 0: self._logger.debug( "pump received bytes: {}".format(new_bytes)) except: # Likely a closed socket. Done with the pump thread. if self._logger: self._logger.debug( "socket read failed, stopping pump read thread\n" + traceback.format_exc(3)) break self._process_new_bytes(new_bytes) if self._logger: self._logger.info("socket pump exiting")
def readMemory(self, addr, length): if addr == 0xee1000: return "00" * 0x30 + "0020ee0000000000" elif addr == 0xee2000: return "01000000000000000030ee0000000000dead00000000000000000000000000000000000000000000" elif addr == 0xef0000: with open(self.testcase.getBuildArtifact("libmodule_load.so"), "rb") as f: contents = f.read(-1) return hex_encode_bytes(seven.bitcast_to_string(contents)) return ("baadf00d00" * 1000)[0:length * 2]
def _read(self, timeout_seconds, q): now = time.monotonic() deadline = now + timeout_seconds while q.empty() and now <= deadline: can_read, _, _ = select.select([self._socket], [], [], deadline-now) now = time.monotonic() if can_read and self._socket in can_read: try: new_bytes = seven.bitcast_to_string(self._socket.recv(4096)) if self._logger and new_bytes and len(new_bytes) > 0: self._logger.debug( "pump received bytes: {}".format(new_bytes)) except: # Likely a closed socket. Done with the pump thread. if self._logger: self._logger.debug( "socket read failed, stopping pump read thread\n" + traceback.format_exc(3)) break self._process_new_bytes(new_bytes) if q.empty(): raise queue.Empty() return q.get(True)
def expect_lldb_gdbserver_replay( asserter, server, test_sequence, timeout_seconds, logger=None): """Replay socket communication with lldb-gdbserver and verify responses. Args: asserter: the object providing assertEqual(first, second, msg=None), e.g. TestCase instance. test_sequence: a GdbRemoteTestSequence instance that describes the messages sent to the gdb remote and the responses expected from it. timeout_seconds: any response taking more than this number of seconds will cause an exception to be raised. logger: a Python logger instance. Returns: The context dictionary from running the given gdbremote protocol sequence. This will contain any of the capture elements specified to any GdbRemoteEntry instances in test_sequence. The context will also contain an entry, context["O_content"] which contains the text from the inferior received via $O packets. $O packets should not attempt to be matched directly since they are not entirely deterministic as to how many arrive and how much text is in each one. context["O_count"] will contain an integer of the number of O packets received. """ # Ensure we have some work to do. if len(test_sequence.entries) < 1: return {} context = {"O_count": 0, "O_content": ""} # Grab the first sequence entry. sequence_entry = test_sequence.entries.pop(0) # While we have an active sequence entry, send messages # destined for the stub and collect/match/process responses # expected from the stub. while sequence_entry: if sequence_entry.is_send_to_remote(): # This is an entry to send to the remote debug monitor. send_packet = sequence_entry.get_send_packet() if logger: if len(send_packet) == 1 and send_packet[0] == chr(3): packet_desc = "^C" else: packet_desc = send_packet logger.info( "sending packet to remote: {}".format(packet_desc)) server.send_raw(send_packet.encode()) else: # This is an entry expecting to receive content from the remote # debug monitor. # We'll pull from (and wait on) the queue appropriate for the type of matcher. # We keep separate queues for process output (coming from non-deterministic # $O packet division) and for all other packets. try: if sequence_entry.is_output_matcher(): # Grab next entry from the output queue. content = server.get_raw_output_packet() else: content = server.get_raw_normal_packet() content = seven.bitcast_to_string(content) except socket.timeout: asserter.fail( "timed out while waiting for '{}':\n{}".format(sequence_entry, server)) # Give the sequence entry the opportunity to match the content. # Output matchers might match or pass after more output accumulates. # Other packet types generally must match. asserter.assertIsNotNone(content) context = sequence_entry.assert_match( asserter, content, context=context) # Move on to next sequence entry as needed. Some sequence entries support executing multiple # times in different states (for looping over query/response # packets). if sequence_entry.is_consumed(): if len(test_sequence.entries) > 0: sequence_entry = test_sequence.entries.pop(0) else: sequence_entry = None # Fill in the O_content entries. context["O_count"] = 1 context["O_content"] = server.consume_accumulated_output() return context