Python win32file.FILE_SHARE_WRITE属性代码示例

# 需要导入模块: import win32file [as 别名]
# 或者: from win32file import FILE_SHARE_WRITE [as 别名]
def _OpenFileForRead(self, path):
        try:
            fhandle = self.fhandle = win32file.CreateFile(
                path,
                win32file.GENERIC_READ,
                win32file.FILE_SHARE_READ | win32file.FILE_SHARE_WRITE,
                None,
                win32file.OPEN_EXISTING,
                win32file.FILE_ATTRIBUTE_NORMAL,
                None)

            self._closer = weakref.ref(
                self, lambda x: win32file.CloseHandle(fhandle))

            self.write_enabled = False
            return fhandle

        except pywintypes.error as e:
            raise IOError("Unable to open %s: %s" % (path, e)) 

# 需要导入模块: import win32file [as 别名]
# 或者: from win32file import FILE_SHARE_WRITE [as 别名]
def _OpenFileForWrite(self, path):
        try:
            fhandle = self.fhandle = win32file.CreateFile(
                path,
                win32file.GENERIC_READ | win32file.GENERIC_WRITE,
                win32file.FILE_SHARE_READ | win32file.FILE_SHARE_WRITE,
                None,
                win32file.OPEN_EXISTING,
                win32file.FILE_ATTRIBUTE_NORMAL,
                None)
            self.write_enabled = True
            self._closer = weakref.ref(
                self, lambda x: win32file.CloseHandle(fhandle))

            return fhandle

        except pywintypes.error as e:
            raise IOError("Unable to open %s: %s" % (path, e)) 

# 需要导入模块: import win32file [as 别名]
# 或者: from win32file import FILE_SHARE_WRITE [as 别名]
def CreateFile(self, fname, mode="r", bufsize=-1):
        "Open a file the same way a File Directory migration engine would."
        fname = cygwin2nt(fname)
        UserLog.msg("CreateFile", fname)
        if mode == "r":
            wmode = win32file.GENERIC_READ
        elif mode == "w":
            wmode = win32file.GENERIC_WRITE
        elif mode in ( 'r+', 'w+', 'a+'):
            wmode = win32file.GENERIC_READ | win32file.GENERIC_WRITE
        else:
            raise ValueError, "invalid file mode"
        h = win32file.CreateFile(
            fname,                           #  CTSTR lpFileName,
            wmode,                           #  DWORD dwDesiredAccess,
            win32file.FILE_SHARE_DELETE | win32file.FILE_SHARE_READ | win32file.FILE_SHARE_WRITE, #  DWORD dwShareMode,
            None,                            #  LPSECURITY_ATTRIBUTES lpSecurityAttributes,
            win32file.OPEN_EXISTING,         #  DWORD dwCreationDisposition,
            win32file.FILE_ATTRIBUTE_NORMAL, #  DWORD dwFlagsAndAttributes,
            0,                               #  HANDLE hTemplateFile
            )
        self._files[int(h)] = h
        return int(h) 

# 需要导入模块: import win32file [as 别名]
# 或者: from win32file import FILE_SHARE_WRITE [as 别名]
def csv_export_ram(self):
        """Dump ram using winpmem"""
        hSvc = create_driver_service(self.logger)
        start_service(hSvc, self.logger)
        try:
            fd = win32file.CreateFile(
                "\\\\.\\pmem",
                win32file.GENERIC_READ | win32file.GENERIC_WRITE,
                win32file.FILE_SHARE_READ | win32file.FILE_SHARE_WRITE,
                None,
                win32file.OPEN_EXISTING,
                win32file.FILE_ATTRIBUTE_NORMAL,
                None)
            try:
                t = time.time()
                image = _Image(fd)
                self.logger.info("Imaging to " + self.output_dir + '\\' + self.computer_name + '_memdump.raw')
                image.DumpWithRead(self.output_dir + '\\' + self.computer_name + '_memdump.raw')
                self.logger.info("Completed in %s seconds" % (time.time() - t))
            finally:
                win32file.CloseHandle(fd)
        finally:
            stop_and_delete_driver_service(hSvc) 

# 需要导入模块: import win32file [as 别名]
# 或者: from win32file import FILE_SHARE_WRITE [as 别名]
def win_tun_alloc(self, dev, flags):
		TAP_IOCTL_SET_MEDIA_STATUS 	= self.WIN_TAP_CONTROL_CODE(6, 0)
		import pywintypes

		guid = self.WIN_get_device_guid()
		if not guid:
			common.internal_print("Please install OpenVPN's Windows TAP driver (NDIS 6) to use XFLTReaT\r\nhttps://openvpn.net/index.php/open-source/downloads.html", -1)
			sys.exit(-1)

		# create a win32file for manipulating the TUN/TAP interface
		try:
			self.wintun = win32file.CreateFile("\\\\.\\Global\\{0}.tap".format(guid),
				win32file.GENERIC_READ | win32file.GENERIC_WRITE,
				win32file.FILE_SHARE_READ | win32file.FILE_SHARE_WRITE,
				None, win32file.OPEN_EXISTING,
				win32file.FILE_ATTRIBUTE_SYSTEM | win32file.FILE_FLAG_NO_BUFFERING | win32file.FILE_FLAG_OVERLAPPED,
				None)
		except pywintypes.error as e:
			if e.args[0] == 31: # A device attached to the system is not functioning.
				common.internal_print("The TUN device is already in use. Maybe another XFLTReaT is running.", -1)
				sys.exit(-1)	


		# have Windows consider the interface now connected
		win32file.DeviceIoControl(self.wintun, TAP_IOCTL_SET_MEDIA_STATUS, '\x01\x00\x00\x00', 1, None)

		return self.wintun 

# 需要导入模块: import win32file [as 别名]
# 或者: from win32file import FILE_SHARE_WRITE [as 别名]
def _preserve_timestamps(file_entry, output_path):
        """Obtain and set (to preserve) original timestamps of exported files."""

        stat_object = file_entry.GetStat()
        if os.name == WINDOWS_IDENTIFIER:
            accessed = created = modified = dt.now()

            if stat_object.atime:
                if stat_object.atime_nano:
                    accessed = dt.fromtimestamp((float(str(stat_object.atime) + '.' + str(stat_object.atime_nano))))
                else:
                    accessed = dt.fromtimestamp(stat_object.atime)

            if stat_object.crtime:
                if stat_object.crtime_nano:
                    created = dt.fromtimestamp((float(str(stat_object.crtime) + '.' + str(stat_object.crtime_nano))))
                else:
                    created = dt.fromtimestamp(stat_object.crtime)

            if stat_object.mtime:
                if stat_object.mtime_nano:
                    modified = dt.fromtimestamp((float(str(stat_object.mtime) + '.' + str(stat_object.mtime_nano))))
                else:
                    modified = dt.fromtimestamp(stat_object.mtime)

            handle = CreateFileW(output_path, GENERIC_WRITE, FILE_SHARE_WRITE, None, OPEN_EXISTING,
                                 FILE_ATTRIBUTE_NORMAL, None)
            SetFileTime(handle, created, accessed, modified)  # does not seem to preserve nano precision of timestamps
            CloseHandle(handle)
        else:
            os.utime(output_path, (stat_object.atime, stat_object.mtime)) 

# 需要导入模块: import win32file [as 别名]
# 或者: from win32file import FILE_SHARE_WRITE [as 别名]
def __init__(self, base, config, **kwargs):
        self.as_assert(base == None, 'Must be first Address Space')
        addrspace.AbstractRunBasedMemory.__init__(self, base, config, **kwargs)		

        self.fhandle = win32file.CreateFile(
            "\\\\.\\pmem",
            win32file.GENERIC_READ | win32file.GENERIC_WRITE,
            win32file.FILE_SHARE_READ | win32file.FILE_SHARE_WRITE,
            None,
            win32file.OPEN_EXISTING,
            win32file.FILE_ATTRIBUTE_NORMAL,
            None)
			
        self.ParseMemoryRuns() 

# 需要导入模块: import win32file [as 别名]
# 或者: from win32file import FILE_SHARE_WRITE [as 别名]
def openTunTap():
    '''
    \brief Open a TUN/TAP interface and switch it to TUN mode.
    
    \return The handler of the interface, which can be used for later
        read/write operations.
    '''
    
    # retrieve the ComponentId from the TUN/TAP interface
    componentId = get_tuntap_ComponentId()
    print('componentId = {0}'.format(componentId))
    
    # create a win32file for manipulating the TUN/TAP interface
    tuntap = win32file.CreateFile(
        r'\\.\Global\%s.tap' % componentId,
        win32file.GENERIC_READ    | win32file.GENERIC_WRITE,
        win32file.FILE_SHARE_READ | win32file.FILE_SHARE_WRITE,
        None,
        win32file.OPEN_EXISTING,
        win32file.FILE_ATTRIBUTE_SYSTEM | win32file.FILE_FLAG_OVERLAPPED,
        None
    )
    print('tuntap      = {0}'.format(tuntap.handle))
    
    # have Windows consider the interface now connected
    win32file.DeviceIoControl(
        tuntap,
        TAP_IOCTL_SET_MEDIA_STATUS,
        '\x00\x00\x00\x00',
        None
    )
    
    # prepare the parameter passed to the TAP_IOCTL_CONFIG_TUN commmand.
    # This needs to be a 12-character long string representing
    # - the tun interface's IPv4 address (4 characters)
    # - the tun interface's IPv4 network address (4 characters)
    # - the tun interface's IPv4 network mask (4 characters)
    configTunParam  = []
    configTunParam += TUN_IPv4_ADDRESS
    configTunParam += TUN_IPv4_NETWORK
    configTunParam += TUN_IPv4_NETMASK
    configTunParam  = ''.join([chr(b) for b in configTunParam])
    
    # switch to TUN mode (by default the interface runs in TAP mode)
    win32file.DeviceIoControl(
        tuntap,
        TAP_IOCTL_CONFIG_TUN,
        configTunParam,
        None
    )
    
    # return the handler of the TUN interface
    return tuntap

#=== misc 

# 需要导入模块: import win32file [as 别名]
# 或者: from win32file import FILE_SHARE_WRITE [as 别名]
def open_sparse_file(path, mode, length=0, overlapped=False):
    supported = get_sparse_files_support(path)
    flags = 0
    # some day I might support sparse files elsewhere
    if not supported and os.name != 'nt':
        return file(path, mode, 0)
    
    flags = win32file.FILE_FLAG_RANDOM_ACCESS
    if overlapped:
        flags |= win32file.FILE_FLAG_OVERLAPPED
    
    # If the hFile handle is opened with the
    # FILE_FLAG_NO_BUFFERING flag set, an application can move the
    # file pointer only to sector-aligned positions.  A
    # sector-aligned position is a position that is a whole number
    # multiple of the volume sector size. An application can
    # obtain a volume sector size by calling the GetDiskFreeSpace
    # function.
    #flags |= win32file.FILE_FLAG_NO_BUFFERING

    access = win32file.GENERIC_READ
    # Shared write is necessary because lock is assigned
    # per file handle. --Dave
    share = win32file.FILE_SHARE_READ | win32file.FILE_SHARE_WRITE
    #share = win32file.FILE_SHARE_READ #| win32file.FILE_SHARE_WRITE

    if is_open_for_write(mode):
        access |= win32file.GENERIC_WRITE

    if isinstance(path, unicode):
        CreateFile = win32file.CreateFileW
    else:
        CreateFile = win32file.CreateFile

    handle = CreateFile(path, access, share, None,
                        win32file.OPEN_ALWAYS,
                        flags, None)
    
    if supported and is_open_for_write(mode):
        _sparse_magic(handle, length)
    fd = win32file._open_osfhandle(handle, os.O_BINARY)
    handle.Detach()

    f = os.fdopen(fd, mode)
    return f