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
