def connect_pipe(pipe, pipeName): overLap = pywintypes.OVERLAPPED() overLap.hEvent = win32event.CreateEvent(None, 1, 0, None) if overLap.hEvent == 0: raise PipeError('Could not create hEvent') try: # Wait for a pipe client connection ret = win32pipe.ConnectNamedPipe(pipe, overLap) if not ret in (0, ERROR_PIPE_CONNECTED): if ret == ERROR_IO_PENDING: ret = win32event.WaitForSingleObject( overLap.hEvent, 1000 * CONNECT_TIMEOUT_SECS) if ret != win32event.WAIT_OBJECT_0: # Timeout error raise PipeError('Timeout error') else: # API error raise PipeError('API error') ret = win32pipe.GetOverlappedResult(pipe, overLap, True) if not ret in (0, ERROR_PIPE_CONNECTED): # API Error raise PipeError('API error 2') except PipeError: # Named pipe exception win32file.CancelIo(pipe) pipe.close() raise except BaseException, err: win32file.CancelIo(pipe) pipe.close() pipe = None raise PipeError('BaseException : ' + str(err))
def close(self): """Similar to 'close' of file descriptor. """ if self._handle: try: flags = win32pipe.GetNamedPipeInfo(self._handle)[0] except Exception: flags = 0 if flags & win32con.PIPE_SERVER_END: win32pipe.DisconnectNamedPipe(self._handle) # TODO: if pipe, need to call FlushFileBuffers? def _close_(rc, n): win32file.CloseHandle(self._handle) self._overlap = None if self._notifier: self._notifier.unregister(self._handle) self._handle = None self._read_result = self._write_result = None self._read_task = self._write_task = None self._buflist = [] if self._overlap.object: self._overlap.object = _close_ win32file.CancelIo(self._handle) else: _close_(0, 0)
def close(self): """Close file. """ if self._handle: try: flags = win32pipe.GetNamedPipeInfo(self._handle)[0] except: flags = 0 if flags & win32con.PIPE_SERVER_END: win32pipe.DisconnectNamedPipe(self._handle) # TODO: if pipe, need to call FlushFileBuffers? def _close_(self, rc, n): win32file.CloseHandle(self._handle) self._overlap = None _AsyncFile._notifier.unregister(self._handle) self._handle = None self._read_result = self._write_result = None self._read_coro = self._write_coro = None self._buflist = [] if self._overlap.object: self._overlap.object = partial_func(_close_, self) win32file.CancelIo(self._handle) else: _close_(self, 0, 0)
def conn_loop(self): self.file_handle = win32file.CreateFile( self.ipc_path, win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0, None, win32file.OPEN_EXISTING, win32file.FILE_FLAG_OVERLAPPED, None) if self.file_handle == win32file.INVALID_HANDLE_VALUE: err = win32api.FormatMessage(win32api.GetLastError()) logging.error(f"Failed to connect to pipe: {err}") self.file_handle = None return # needed for blocking on read overlapped = win32file.OVERLAPPED() overlapped.hEvent = win32event.CreateEvent(None, 0, 0, None) # needed for transactions win32pipe.SetNamedPipeHandleState(self.file_handle, win32pipe.PIPE_READMODE_MESSAGE, None, None) self.is_running = True while self.is_running: val = self._call(win32file.ReadFile, self.file_handle, self._read_buf, overlapped) if not self.is_running: break err, data = val if err != 0 and err != ERROR_IO_PENDING: logger.warning(f"Unexpected read result {err}. Quitting.") logger.debug(f"data={bytes(data)}") self.is_running = False break if err == ERROR_IO_PENDING: err = win32event.WaitForSingleObject(overlapped.hEvent, self.read_timeout) if err == win32event.WAIT_OBJECT_0: # data is available data = bytes(data) line = data[:data.find(b"\n")] self.on_line(line) while not self.write_queue.empty(): # first see if mpv sent some data that needs to be read data = self._call(self._read_all_data) if not self.is_running: break if data: self.on_data(data) # cancel all remaining reads/writes. Should be benign win32file.CancelIo(self.file_handle) write_data = self.write_queue.get_nowait() data = self._call(self._transact, write_data) if not self.is_running: break self.on_line(data[:-1]) self.is_running = False self.file_handle.close() self.file_handle = None logger.debug('Pipe closed.')
def _timed_out(self): """Internal use only. """ if self._read_task: if self._buflist: buf, self._buflist = ''.join(self._buflist), [] self._read_task._proceed_(buf) self._read_task = None else: self._read_task.throw(IOError('timedout')) self._read_task = None win32file.CancelIo(self._handle)
def flush(self): """ This wil flush the usb channel. If the device handle is None it will try to open to flush Args: Returns: bytes: flushed data Raises: """ if self.http_usb_handle != None: self.close() http_usb_handle = self.open( flags_and_attributes=win32file.FILE_FLAG_OVERLAPPED) buffer = bytes() overlapped = pywintypes.OVERLAPPED() overlapped.hEvent = win32event.CreateEvent(None, 0, 0, None) try: while True: _, data = win32file.ReadFile(http_usb_handle, READ_BUFFER_SIZE, overlapped) rc2 = win32event.WaitForSingleObject(overlapped.hEvent, 60) if rc2 == win32event.WAIT_TIMEOUT or rc2 == win32event.WAIT_ABANDONED: break elif rc2 == win32event.WAIT_FAILED: log.debug("Error = {}".format(win32.GetLastError())) n = win32file.GetOverlappedResult(http_usb_handle, overlapped, False) log.debug("n data = {}".format(n)) if n: buffer += data[:n] else: # no data to read break win32event.ResetEvent(overlapped.hEvent) win32file.CancelIo(http_usb_handle) finally: win32file.CloseHandle(http_usb_handle) self.http_usb_handle = self.open() return buffer
def recv_command_win(self): INFO(1, None, None, "Reading PIPE %s" % self.ipc_obj_name) #using winAFL implementation for ReadFile with timeout res, res_str = win32file.ReadFile(self.pipe_in, 1, self.overlap_read) if res == winerror.ERROR_IO_PENDING: rc = win32event.WaitForSingleObject(self.overlap_read.hEvent, self.timeout * 100) if rc != win32event.WAIT_OBJECT_0: # winAFL: took longer than specified timeout or other error - cancel read win32file.CancelIo(self.pipe_in) # wait for cancelation to finish properly. win32event.WaitForSingleObject(self.overlap_read.hEvent, win32event.INFINITE) return "T" res_str = bytes(res_str) INFO(1, None, None, "Received %s, result code: %d" % (res_str, res)) try: # TODO: it would be probably better to use OVERLAPPED API functions here res_str = res_str.decode("utf-8") except: # it means that the target failed to answer us for some reason res_str = "" return res_str
def close_pipe(pipe): win32file.CancelIo(pipe) pipe.close()
def close(self): if self.handle is not None: win32file.CancelIo(self.handle) win32file.CloseHandle(self.handle) if self.event is not None: win32file.CloseHandle(self.event)
def close_watch(watch): if watch._hDir is not None: win32file.CancelIo(watch._hDir) win32file.CloseHandle(watch._hDir) watch._hDir = None