def conn_loop(self):
self.is_running = True
self.update_vars()
self.file_handle = win32file.CreateFile(
self.ipc_path, win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0,
None, win32file.OPEN_EXISTING, 0, None)
while self.is_running:
try:
while not self.write_queue.empty():
win32file.WriteFile(self.file_handle,
self.write_queue.get_nowait())
except win32file.error:
logger.debug('Exception while writing to pipe.', exc_info=True)
self.is_running = False
break
size = win32file.GetFileSize(self.file_handle)
if size > 0:
while size > 0:
# pipe has data to read
_, data = win32file.ReadFile(self.file_handle, 4096)
self.on_data(data)
size = win32file.GetFileSize(self.file_handle)
else:
time.sleep(1)
win32file.CloseHandle(self.file_handle)
logger.debug('Pipe closed.')
def testMoreFiles(self):
# Create a file in the %TEMP% directory.
testName = os.path.join(win32api.GetTempPath(), "win32filetest.dat")
desiredAccess = win32file.GENERIC_READ | win32file.GENERIC_WRITE
# Set a flag to delete the file automatically when it is closed.
fileFlags = win32file.FILE_FLAG_DELETE_ON_CLOSE
h = win32file.CreateFile(testName, desiredAccess,
win32file.FILE_SHARE_READ, None,
win32file.CREATE_ALWAYS, fileFlags, 0)
# Write a known number of bytes to the file.
data = "z" * 1025
win32file.WriteFile(h, data)
self.failUnless(
win32file.GetFileSize(h) == len(data),
"WARNING: Written file does not have the same size as the length of the data in it!"
)
# Ensure we can read the data back.
win32file.SetFilePointer(h, 0, win32file.FILE_BEGIN)
hr, read_data = win32file.ReadFile(h,
len(data) +
10) # + 10 to get anything extra
self.failUnless(hr == 0, "Readfile returned %d" % hr)
self.failUnless(read_data == data, "Read data is not what we wrote!")
# Now truncate the file at 1/2 its existing size.
newSize = len(data) / 2
win32file.SetFilePointer(h, newSize, win32file.FILE_BEGIN)
win32file.SetEndOfFile(h)
self.failUnless(
win32file.GetFileSize(h) == newSize,
"Truncated file does not have the expected size!")
# GetFileAttributesEx/GetFileAttributesExW tests.
self.failUnless(
win32file.GetFileAttributesEx(
testName) == win32file.GetFileAttributesExW(testName),
"ERROR: Expected GetFileAttributesEx and GetFileAttributesExW to return the same data"
)
attr, ct, at, wt, size = win32file.GetFileAttributesEx(testName)
self.failUnless(
size == newSize,
"Expected GetFileAttributesEx to return the same size as GetFileSize()"
)
self.failUnless(
attr == win32file.GetFileAttributes(testName),
"Expected GetFileAttributesEx to return the same attributes as GetFileAttributes"
)
h = None # Close the file by removing the last reference to the handle!
self.failUnless(not os.path.isfile(testName),
"After closing the file, it still exists!")
def __init__(self, base=None, filename=None, **kwargs):
self.as_assert(base == None, 'Must be first Address Space')
super(Win32FileAddressSpace, self).__init__(**kwargs)
path = filename or self.session.GetParameter("filename")
self.as_assert(
path, "Filename must be specified in session (e.g. "
"session.SetParameter('filename', 'MyFile.raw').")
self.fname = path
# The file is just a regular file, we open for reading.
fhandle = self._OpenFileForRead(path)
# If we can not get the file size it means this is not a regular file -
# maybe a device.
self.fhandle_as = Win32FileWrapper(fhandle)
try:
file_size = win32file.GetFileSize(fhandle)
self.add_run(0, 0, file_size, self.fhandle_as)
except pywintypes.error:
# This may be a device, we just read the whole space.
self.add_run(0, 0, 2**63, self.fhandle_as)
self.volatile = True
def __init__(self, base=None, filename=None, **kwargs):
self.as_assert(base == None, 'Must be first Address Space')
super(Win32FileAddressSpace, self).__init__(**kwargs)
path = filename or (self.session and self.session.GetParameter(
"filename"))
self.as_assert(path, "Filename must be specified in session (e.g. "
"session.GetParameter('filename', 'MyFile.raw').")
self.fname = path
# If the file is a device we try to talk to the winpmem driver.
if path.startswith("\\\\"):
try:
# First open for write in case the driver is in write mode.
self._OpenFileForWrite(path)
except IOError:
self._OpenFileForRead(path)
self.ParseMemoryRuns()
else:
# The file is just a regular file, we open for reading.
self._OpenFileForRead(path)
self.runs.insert((0, 0, win32file.GetFileSize(self.fhandle)))
def __init__(self, filename, mode='r', encoding=None):
if mode in ('r', 'r+'):
creationDisposition = win32file.OPEN_EXISTING
desiredAccess = win32con.GENERIC_READ
elif mode == 'w':
creationDisposition = win32con.CREATE_ALWAYS
desiredAccess = win32con.GENERIC_WRITE
elif mode in ('rw', 'wr', 'r+', 'w+', 'a+'):
creationDisposition = win32con.OPEN_ALWAYS
desiredAccess = win32con.GENERIC_READ | win32con.GENERIC_WRITE
elif mode == 'a':
creationDisposition = win32con.OPEN_ALWAYS
desiredAccess = win32con.GENERIC_WRITE
else:
raise ValueError('Invalid access mode')
self.filename = filename
# shareMode = (win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE |
# win32con.FILE_SHARE_DELETE)
shareMode = win32con.shareMode = (win32con.FILE_SHARE_READ
| win32con.FILE_SHARE_WRITE)
attributes = win32security.SECURITY_ATTRIBUTES()
# dwFlagsAndAttributes = win32con.FILE_ATTRIBUTE_NORMAL
dwFlagsAndAttributes = win32con.FILE_FLAG_WRITE_THROUGH
self.encoding = encoding or 'utf-8'
self.handle = win32file.CreateFile(filename, desiredAccess, shareMode,
attributes, creationDisposition,
dwFlagsAndAttributes, 0)
win32api.SetHandleInformation(self.handle,
win32con.HANDLE_FLAG_INHERIT, 0)
if mode in ('a', 'a+'):
self.seek(0, 2)
self.file_size = win32file.GetFileSize(self.handle)
self.is_closed = False
def _read_all_data(self):
"""Read all the remaining data on the pipe"""
data = b""
read_buf = win32file.AllocateReadBuffer(512)
while win32file.GetFileSize(self.file_handle):
_, d = win32file.ReadFile(self.file_handle, read_buf)
data += d
return data
def run(self):
import win32file
self.file_handle = win32file.CreateFile(
self.named_pipe_path,
win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0, None,
win32file.OPEN_EXISTING, 0, None)
log.info('Windows named pipe connected')
self.fire_connected()
while True:
# The following code is cleaner, than waiting for an exception while writing to detect pipe closing,
# but causes mpv to hang and crash while closing when closed at the wrong time.
# if win32file.GetFileAttributes(self.named_pipe_path) != win32file.FILE_ATTRIBUTE_NORMAL:
# # pipe was closed
# break
try:
while not self.write_queue.empty():
win32file.WriteFile(self.file_handle,
self.write_queue.get_nowait())
except win32file.error:
log.warning(
'Exception while writing to Windows named pipe. Assuming pipe closed.'
)
break
size = win32file.GetFileSize(self.file_handle)
if size > 0:
while size > 0:
# pipe has data to read
data = win32file.ReadFile(self.file_handle, 512)
self.on_data(data[1])
size = win32file.GetFileSize(self.file_handle)
else:
time.sleep(1)
log.info('Windows named pipe closed')
win32file.CloseHandle(self.file_handle)
self.file_handle = None
self.fire_disconnected()
def windows_get_size(path):
''' On windows file sizes are only accurately stored in the actual file,
not in the directory entry (which could be out of date). So we open the
file, and get the actual size. '''
import win32file
h = win32file.CreateFile(
path, 0, win32file.FILE_SHARE_READ | win32file.FILE_SHARE_WRITE
| win32file.FILE_SHARE_DELETE, None, win32file.OPEN_EXISTING, 0, None)
try:
return win32file.GetFileSize(h)
finally:
win32file.CloseHandle(h)
def read(self, bytes=-1):
import win32file as w
sz = w.GetFileSize(self._handle)
max = sz - self.tell()
if bytes < 0: bytes = max
bytes = min(max, bytes)
if bytes < 1:
return ''
hr, ans = w.ReadFile(self._handle, bytes, None)
if hr != 0:
raise IOError('Error reading file: %s' % hr)
return ans
def get_file_pos(self, path=None):
if path is None:
self.raise_if_notarget()
tpath = self.target_path
else:
tpath = path
self.ldebug("get_file_pos", "for {}".format(tpath))
try:
with OpenNoLock(tpath) as fh:
return win32file.GetFileSize(fh)
except pywintypes.error as e:
err = e[2]
if self.encoding:
err = err.decode(self.encoding).encode('utf8')
self.lerror("get_file_pos", "{} - {}".format(err, tpath))
raise
def __init__(self, path, mode=0, access=win32con.GENERIC_ALL):
self.name = path
access = 0
winmode = 0
if 'r' in mode:
winmode = win32con.OPEN_EXISTING
access |= win32con.GENERIC_READ
if 'w' in mode:
winmode |= win32con.CREATE_ALWAYS
access |= win32con.GENERIC_WRITE
if path.startswith("\\\\"):
self.size = _self.get_device_size(path) * 512
self.handle = win32file.CreateFile(
path, access,
win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE,
None, winmode, win32con.FILE_FLAG_RANDOM_ACCESS, None)
else:
self.handle = win32file.CreateFile(path, access, 0, None,
winmode, 0, None)
self.size = win32file.GetFileSize(self.handle)
def read_with_share_delete(filepath):
h = win32file.CreateFile(filepath,
win32file.GENERIC_READ,
win32file.FILE_SHARE_READ |
win32file.FILE_SHARE_WRITE |
win32file.FILE_SHARE_DELETE,
None,
win32file.OPEN_EXISTING,
0,
0)
if h != win32file.INVALID_HANDLE_VALUE:
try:
size = win32file.GetFileSize(h)
hr, contents = win32file.ReadFile(h, size, None)
if hr != 0:
raise Exception("Failed to ReadFile")
return contents.decode('utf-8').splitlines()
except:
win32file.CloseHandle(h)
else:
raise Exception("Failed to CreateFile")
def __init__(self, base=None, filename=None, **kwargs):
self.as_assert(base == None, 'Must be first Address Space')
super(Win32FileAddressSpace, self).__init__(**kwargs)
self.phys_base = self
path = filename or self.session.GetParameter("filename")
self.as_assert(
path, "Filename must be specified in session (e.g. "
"session.SetParameter('filename', 'MyFile.raw').")
self.fname = path
# The file is just a regular file, we open for reading.
self._OpenFileForRead(path)
# If we can not get the file size it means this is not a regular file -
# maybe a device.
try:
self.runs.insert((0, 0, win32file.GetFileSize(self.fhandle)))
except pywintypes.error:
raise addrspace.ASAssertionError("Not a regular file.")
def AdGetSize(self):
return win32file.GetFileSize(self.fhandle)
