def _stub(cmd_name, stdin_name, stdout_name, stderr_name):
"""INTERNAL: Stub process that will start up the child process."""
# Open the 4 pipes (command, stdin, stdout, stderr)
cmd_pipe = CreateFile(cmd_name, GENERIC_READ|GENERIC_WRITE, 0, None,
OPEN_EXISTING, 0, None)
SetHandleInformation(cmd_pipe, HANDLE_FLAG_INHERIT, 1)
stdin_pipe = CreateFile(stdin_name, GENERIC_READ, 0, None,
OPEN_EXISTING, 0, None)
SetHandleInformation(stdin_pipe, HANDLE_FLAG_INHERIT, 1)
stdout_pipe = CreateFile(stdout_name, GENERIC_WRITE, 0, None,
OPEN_EXISTING, 0, None)
SetHandleInformation(stdout_pipe, HANDLE_FLAG_INHERIT, 1)
stderr_pipe = CreateFile(stderr_name, GENERIC_WRITE, 0, None,
OPEN_EXISTING, 0, None)
SetHandleInformation(stderr_pipe, HANDLE_FLAG_INHERIT, 1)
# Learn what we need to do..
header = _read_header(cmd_pipe)
input = _parse_header(header)
if 'command' not in input or 'args' not in input:
ExitProcess(2)
# http://msdn.microsoft.com/en-us/library/ms682499(VS.85).aspx
startupinfo = STARTUPINFO()
startupinfo.dwFlags |= STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW
startupinfo.hStdInput = stdin_pipe
startupinfo.hStdOutput = stdout_pipe
startupinfo.hStdError = stderr_pipe
startupinfo.wShowWindow = SW_HIDE
# Grant access so that our parent can open its grandchild.
if 'parent_sid' in input:
mysid = _get_current_sid()
parent = ConvertStringSidToSid(input['parent_sid'])
sattrs = _create_security_attributes(mysid, parent,
access=PROCESS_ALL_ACCESS)
else:
sattrs = None
try:
res = CreateProcess(input['command'], input['args'], sattrs, None,
True, CREATE_NEW_CONSOLE, os.environ, os.getcwd(),
startupinfo)
except WindowsError as e:
message = _quote_header(str(e))
WriteFile(cmd_pipe, 'status=error\nmessage=%s\n\n' % message)
ExitProcess(3)
else:
pid = res[2]
# Pass back results and exit
err, nbytes = WriteFile(cmd_pipe, 'status=ok\npid=%s\n\n' % pid)
ExitProcess(0)
def obtain_readwrite(volume):
# Optional protection that we are running on removable media only.
assert volume
#if drive_letter_safety:
# drive_containing_file = volume[0].upper()
# assert drive_containing_file >= drive_letter_safety.upper()
volume = '\\\\.\\' + volume
if volume[-1] == os.sep:
volume = volume.rstrip(os.sep)
# We need the FILE_SHARE flags so that this open call can succeed
# despite something on the volume being in use by another process.
#다른 프로세스에서 사용 중인 볼륨에서도 이 개방형 호출을 성공할 수 있도록 FILE_SHARE 플래그가 필요함.
#볼륨의 정보를 CreateFile를 통해 초기화
volume_handle = CreateFile(volume, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
None, OPEN_EXISTING,
FILE_FLAG_RANDOM_ACCESS |
FILE_FLAG_NO_BUFFERING |
FILE_FLAG_WRITE_THROUGH,
None)
#logger.debug("Opened volume %s", volume)
#volume_handle반환
return volume_handle
def modify_file_all_time(filePath, createTime):
"""
用来修改任意文件的相关时间属性，时间格式：YYYY-MM-DD HH:MM:SS 例如：2019-02-02 00:01:02
:param filePath: 文件路径名
:param createTime: 创建时间
:param modifyTime: 修改时间
:param accessTime: 访问时间
:param offset: 时间偏移的秒数,tuple格式，顺序和参数时间对应
"""
print(filePath, createTime)
try:
format = "%Y-%m-%d %H:%M:%S" # 时间格式
fh = CreateFile(filePath, GENERIC_READ | GENERIC_WRITE, 0, None,
OPEN_EXISTING, 0, 0)
createTimes, accessTimes, modifyTimes = GetFileTime(fh)
createTimes = Time(time.mktime(createTime))
accessTimes = Time(time.mktime(createTime))
modifyTimes = Time(time.mktime(createTime))
SetFileTime(fh, createTimes, accessTimes, modifyTimes)
CloseHandle(fh)
return 0
except Exception as e:
print(e)
return 1
def modifyFileTime(filePath, createTime, modifyTime, accessTime, offset):
"""
用来修改任意文件的相关时间属性，时间格式：YYYY-MM-DD HH:MM:SS 例如：2019-02-02 00:01:02
:param filePath: 文件路径名
:param createTime: 创建时间
:param modifyTime: 修改时间
:param accessTime: 访问时间
:param offset: 时间偏移的秒数,tuple格式，顺序和参数时间对应
"""
try:
format = "%Y-%m-%d %H:%M:%S" # 时间格式
cTime_t = timeOffsetAndStruct(createTime, format, offset[0])
mTime_t = timeOffsetAndStruct(modifyTime, format, offset[1])
aTime_t = timeOffsetAndStruct(accessTime, format, offset[2])
fh = CreateFile(filePath, GENERIC_READ | GENERIC_WRITE, 0, None,
OPEN_EXISTING, 0, 0)
createTimes, accessTimes, modifyTimes = GetFileTime(fh)
createTimes = Time(time.mktime(cTime_t))
accessTimes = Time(time.mktime(aTime_t))
modifyTimes = Time(time.mktime(mTime_t))
SetFileTime(fh, createTimes, accessTimes, modifyTimes)
CloseHandle(fh)
return 0
except:
return 1
def run(self):
root = self.rootPath
print("Start monitoring of '%s'" % root)
hDir = CreateFile(root, FILE_LIST_DIRECTORY,
FILE_SHARE_READ | FILE_SHARE_WRITE,
None,
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS,
None
)
while not self._exit_request:
changes = ReadDirectoryChangesW(hDir, 1024, True,
FILE_NOTIFY_CHANGE_FILE_NAME |
FILE_NOTIFY_CHANGE_DIR_NAME |
FILE_NOTIFY_CHANGE_SIZE |
FILE_NOTIFY_CHANGE_LAST_WRITE,
None,
None
)
for action, file in changes:
changed = join(root, file)
if changed == self.trigger_file:
continue
self.changes.put((action, file))
print(changed,
ACTIONS.get(action, "[unknown 0x%X]" % action)
)
print("Stop monitoring of '%s'" % root)
CloseHandle(hDir)
self.onExit()
def file_name(file_dir):
for root, dirs, files in os.walk(file_dir):
for filename in files:
fh = CreateFile(filename, GENERIC_READ | GENERIC_WRITE, 0, None, OPEN_EXISTING, 0, 0)
createTime, accessTime, modifyTime = GetFileTime(fh)
createTime = Time(time.mktime(time.gmtime(random.uniform(1514780000,1546300000))))
accessTime = Time(time.mktime(time.gmtime(random.uniform(1514780000,1546300000))))
modifyTime = Time(time.mktime(time.gmtime(random.uniform(1514780000,1546300000))))
SetFileTime(fh, createTime, accessTime, modifyTime)
CloseHandle(fh)
def set_mp4_timestamp(path):
'''用mvhd中的creation_time和modification_time设置mp4文件的创建时间和修改时间。
如果目标时间与当前文件的创建时间一致（时间差小于1s）则不修改。
如果creation_time和modification_time之中有1个为0，则用另一个赋值，都为零则不修改文件时间。
'''
try:
mvhd = get_mvhd(path)
except ValueError as error:
print(f'When processing {path} a error occurs: {error}. Skip it.')
return
# mvhd is FullBox，是Box的扩展，Box结构的基础上在Header中增加8bits version和24bits flags
try:
version = mvhd[8:9]
if version == b'\x00':
creation_time = struct.unpack('>I', mvhd[12:16])[0]
modification_time = struct.unpack('>I', mvhd[16:20])[0]
elif version == b'\x01':
creation_time = struct.unpack('>Q', mvhd[12:20])[0]
modification_time = struct.unpack('>Q', mvhd[20:28])[0]
except (IndexError, struct.error):
print(
f'{path} contains no valid mvhd box. May not be a valid mp4 file. Skip it.'
)
return
if creation_time + modification_time == 0:
print(
f'{path} contains no creation_time or modification_time. Skip it.')
return
if creation_time == 0:
creation_time = modification_time
if modification_time == 0:
modification_time = creation_time
new_ctimestamp = time.mktime(get_datetime(creation_time).timetuple())
new_mtimestamp = time.mktime(get_datetime(modification_time).timetuple())
mod_flag = False
old_mtimestamp = getmtime(path)
mtime = Time(old_mtimestamp)
if abs(old_mtimestamp - new_mtimestamp) >= 1:
mtime = Time(new_mtimestamp)
mod_flag = True
old_ctimestamp = getctime(path)
ctime = Time(old_ctimestamp)
if abs(old_ctimestamp - new_ctimestamp) >= 1:
ctime = Time(new_ctimestamp)
mod_flag = True
if mod_flag:
handle = CreateFile(path, GENERIC_WRITE, FILE_SHARE_WRITE, None,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, None)
SetFileTime(handle, ctime, None, mtime)
CloseHandle(handle)
def build_config(root):
curr_path = os.path.dirname(os.path.abspath(os.path.expanduser(__file__)))
save_path = os.path.join(curr_path, "save")
hasher0 = hashlib.sha1()
hasher0.update(root.encode("utf-8"))
save_path = os.path.join(save_path, str(hasher0.hexdigest()))
if not os.path.exists(save_path):
os.mkdir(save_path)
save_build_config = os.path.join(save_path, "build_config.h")
build_config = os.path.join(
root, "mxnet/3rdparty/dmlc-core/include/dmlc/build_config.h")
if not os.path.exists(build_config):
return
if not os.path.exists(save_build_config):
copyfile(build_config, save_build_config)
hasher1 = hashlib.sha512()
with open(build_config, 'rb') as afile:
buf = afile.read()
hasher1.update(buf)
hasher2 = hashlib.sha512()
with open(save_build_config, 'rb') as afile:
buf = afile.read()
hasher2.update(buf)
if hasher1.hexdigest() == hasher2.hexdigest():
fh = CreateFile(save_build_config, GENERIC_READ | GENERIC_WRITE, 0,
None, OPEN_EXISTING, 0, 0)
create_times, access_times, modify_times = GetFileTime(fh)
CloseHandle(fh)
fh = CreateFile(build_config, GENERIC_READ | GENERIC_WRITE, 0, None,
OPEN_EXISTING, 0, 0)
SetFileTime(fh, create_times, access_times, modify_times)
CloseHandle(fh)
else:
copyfile(build_config, save_build_config)
def _open_device(self):
try:
self.fd = CreateFile(self.path,
FILE_GENERIC_READ | FILE_GENERIC_WRITE, 0,
None, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
None)
except Exception as exc:
self._logger.exception('Exception opening GPLPV device:')
six.raise_from(
GPLPVDeviceOpenError("Error while opening {0!r}".format(
self.path)), exc)
def mod_ctime(path):
"""
increments file creation time by a nanosecond
parameters: string path, int mod_size | return: none
"""
ctime = os.path.getctime(path) + 0.001 # increment ctime by 0.001
fh = CreateFile(path, GENERIC_WRITE, FILE_SHARE_WRITE, None, OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS, 0)
SetFileTime(fh, datetime.datetime.fromtimestamp(ctime), None,
None) # update file ctime
CloseHandle(fh)
def spike_cluster(volume_handle, cluster, tmp_file_path):
spike_file_path = os.path.dirname(tmp_file_path)
if spike_file_path[-1] != os.sep:
spike_file_path += os.sep
spike_file_path += spike_file_name + str(cluster)
file_handle = CreateFile(spike_file_path, GENERIC_READ | GENERIC_WRITE, 0,
None, CREATE_ALWAYS, 0, None)
# 2000 bytes is enough to direct the file to its own cluster and not
# land entirely in the MFT.
write_zero_fill(file_handle, 2000)
move_file(volume_handle, file_handle, 0, cluster, 1)
CloseHandle(file_handle)
logger.debug("Spiked cluster %d with %s" % (cluster, spike_file_path))
def spike_cluster(volume_handle, cluster, tmp_file_path):
spike_file_path = os.path.join(os.path.dirname(tmp_file_path),
spike_file_name + str(cluster))
file_handle = CreateFile(
spike_file_path, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, None,
CREATE_ALWAYS, 0, None)
# 2000 bytes is enough to direct the file to its own cluster and not
# land entirely in the MFT.
write_zero_fill(file_handle, 2000)
move_file(volume_handle, file_handle, 0, cluster, 1)
CloseHandle(file_handle)
logging.debug("Spiked cluster %d with %s" % (cluster, spike_file_path))
def __init__(self):
QtCore.QThread.__init__(self)
self.path_to_watch = DEFAULT_PATH
self.hDir = CreateFile (
self.path_to_watch,
0x0001, # dunno, magic. FILE_LIST_DIRECTORY
win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE | win32con.FILE_SHARE_DELETE,
None,
win32con.OPEN_EXISTING,
win32con.FILE_FLAG_BACKUP_SEMANTICS,
None
)
def create_file(file_name, c_file, time, a_path, ftp):
current_file = open(file_name, "wb")
ftp.retrbinary("RETR " + a_path + "/" + c_file, current_file.write)
print('\tAdded:', file_name)
current_file.close()
win_file = CreateFile(
file_name, GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, None,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, None)
# noinspection PyUnresolvedReferences
win_time = Time(time)
SetFileTime(win_file, win_time, None, None)
CloseHandle(win_file)
def change_file_creation_time(log, path, time):
""" Change the creation time for a file.
'path' is the full path to the file.
'time' is the new windows time to set the file creation time to.
"""
log.trace("Changing creation time for %s to %s ..." % (path, time))
result = {}
# open file
winfile = CreateFile(
path, GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
None, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, None)
# set new creation time
SetFileTime(winfile, time, None, None)
# close file
winfile.close()
# return
return result
def change_f_time(f, f_create_time, f_access_time, f_modify_time):
"""
修改文件或文件夹的时间
f: 文件/文件夹的路径
f_create_time, f_access_time, f_modify_time: 文件/文件夹的创建时间、访问时间、修改时间
"""
f_type = 0 if os.path.isfile(f) else FILE_FLAG_BACKUP_SEMANTICS
file_handle = CreateFile(f, GENERIC_READ | GENERIC_WRITE, 0, None,
OPEN_EXISTING, f_type, 0)
# todo: f_type=0表示创建文件，=FILE_FLAG_BACKUP_SEMANTICS 表示创建文件夹！
f_create_time = Time(f_create_time)
f_access_time = f_create_time
f_modify_time = Time(f_modify_time)
SetFileTime(file_handle, f_create_time, f_access_time,
f_modify_time) # createTimes, accessTimes, modifyTimes
CloseHandle(file_handle)
def set_time(path, ctime=None, atime=None, mtime=None):
"""
changes file times to input times
parameters: string path, int ctime | return: none
"""
# get datetime value of time if time has a value
if ctime != None:
ctime = datetime.datetime.fromtimestamp(ctime)
if atime != None:
atime = datetime.datetime.fromtimestamp(atime)
if mtime != None:
mtime = datetime.datetime.fromtimestamp(mtime)
fh = CreateFile(path, GENERIC_WRITE, FILE_SHARE_WRITE, None, OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS, 0)
SetFileTime(fh, ctime, atime,
mtime) # update file times (None value keeps previous value)
CloseHandle(fh)
def randomizeFileTime(
file
): #uses os.utime to set a+m times and pywin_cstructs to set file creation times
name = os.path.basename(file)
rd = getRandomDate()
at = random.randint(200000000, 1000050000)
mt = random.randint(200000000, 1000050000)
os.utime(file, (at, mt))
ctimeform = "%d.%m.%Y %H:%M:%S"
off = 0
ct = time.localtime(time.mktime(time.strptime(
rd, ctimeform))) #prepares time in format specified
tmp = CreateFile(file, GENERIC_READ | GENERIC_WRITE, 0, None,
OPEN_EXISTING, 0, 0)
newct = Time(time.mktime(ct))
SetFileTime(tmp, newct)
CloseHandle(tmp)
print(name)
def get_serial_ports():
success = False
ports = []
global wmi
# try WMI first
try:
if wmi is None:
wmi = win32com.client.GetObject('winmgmts:')
for port in wmi.InstancesOf('Win32_SerialPort'):
ports.append((port.DeviceID, port.Name, ''))
success = True
except:
pass
if success:
return ports
ports = []
# fallback to simple filename probing, if WMI fails
for i in range(1, 256):
# FIXME: get friendly names
name = 'COM%u' % i
try:
hFile = CreateFile(
'\\\\.\\' + name,
win32con.GENERIC_READ | win32con.GENERIC_WRITE, 0, None,
win32con.OPEN_EXISTING, 0, None)
CloseHandle(hFile)
ports.append((name, name, name))
except pywintypes.error as e:
if e[0] in [
winerror.ERROR_ACCESS_DENIED,
winerror.ERROR_GEN_FAILURE,
winerror.ERROR_SHARING_VIOLATION,
winerror.ERROR_SEM_TIMEOUT
]:
ports.append((name, name, name))
return ports
def change_file_time(path, delta):
if not os.path.exists(path):
log_message("Pfad: " + path + " existiert nicht!", "info")
return
if platform.system() == "Windows":
# modify filetimes on Windows
fh = CreateFile(path, GENERIC_WRITE, FILE_SHARE_WRITE, None,
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0)
cTime, aTime, mTime = GetFileTime(fh)
cTime = datetime.fromtimestamp(cTime.timestamp() - delta)
aTime = datetime.fromtimestamp(aTime.timestamp() - delta)
mTime = datetime.fromtimestamp(mTime.timestamp() - delta)
SetFileTime(fh, cTime, aTime, mTime)
CloseHandle(fh)
else:
# modify filetimes on Linux/Mac
a_time = os.path.getatime(path)
m_time = os.path.getmtime(path)
a_time = a_time - delta
m_time = m_time - delta
os.utime(path, (a_time, m_time))
def modify_model_file_time(model_file_dir):
for root, dirs, files in os.walk(model_file_dir):
start_time=1514780000
latest_time=1546300000
for filename in files:
if filename!='untitled1.py':
fh = CreateFile(filename, GENERIC_READ | GENERIC_WRITE, 0, None, OPEN_EXISTING, 0, 0)
createTime, accessTime, modifyTime = GetFileTime(fh)
start=random.uniform(start_time,latest_time)
createTime = Time(time.mktime(time.gmtime(start)))
modify_time=start+random.uniform(0,latest_time-start)
modifyTime = Time(time.mktime(time.gmtime(modify_time)))
access_time=modify_time+random.uniform(0,latest_time-modify_time)
accessTime = Time(time.mktime(time.gmtime(access_time)))
SetFileTime(fh, createTime, accessTime, modifyTime)
CloseHandle(fh)
def _transact(self, query):
try:
h = CreateFile(
self.pipe_name, GENERIC_READ|GENERIC_WRITE, 0, None, OPEN_EXISTING, 0, None
)
packet = self._construct_query(query)
WriteFile(h, packet)
read = 0
err, out = ReadFile(h, DI_PIPE_BUF_SIZE)
length = struct.unpack('i', out[:SIZEOF_INT])[0]
while len(out[SIZEOF_INT:]) < length:
out += ReadFile(h, DI_PIPE_BUF_SIZE)[1]
data = json.loads(out[SIZEOF_INT:], encoding='utf-8')
except pywintypes.error as e:
print e
else:
return data
def exact(filePath):
starttime = time.time()
unZf = zipfile.ZipFile(filePath, 'r')
shutil.rmtree(myconfig['save_path'],ignore_errors=True)
time.sleep(0.1)
# os.makedirs(save_folder, exist_ok=True)
# unZf.extractall(path=save_folder,members=unZf.namelist())
for name in unZf.namelist():
unZfTarge = os.path.join(save_folder, name)
dirname = os.path.dirname(unZfTarge)
os.makedirs(dirname, exist_ok=True)
with open(unZfTarge, 'wb') as f:
f.write(unZf.read(name))
fh = CreateFile(unZfTarge, GENERIC_READ | GENERIC_WRITE, 0, None, OPEN_EXISTING, 0, 0)
#伪造写入时间
createtime = unZf.getinfo(name).date_time
time_formated = time.strptime(str(createtime), "(%Y, %m, %d, %H, %M, %S)")
time_win = Time(time.mktime(time_formated))
SetFileTime(fh,time_win,time_win,time_win)
unZf.close()
print(f"解压用时{time.time() - starttime}")
def modify_file_all_time(file_path, create_time):
"""
用来修改任意文件的相关时间属性，时间格式：YYYY-MM-DD HH:MM:SS 例如：2019-02-02 00:01:02
:param file_path: 文件路径名
:param create_time: 创建时间
:param modifyTime: 修改时间
:param accessTime: 访问时间
:param offset: 时间偏移的秒数,tuple格式，顺序和参数时间对应
"""
print(file_path, create_time)
try:
fh = CreateFile(file_path, GENERIC_READ | GENERIC_WRITE, 0, None,
OPEN_EXISTING, 0, 0)
final_create_time = Time(time.mktime(create_time))
final_access_time = Time(time.mktime(create_time))
final_modify_time = Time(time.mktime(create_time))
SetFileTime(fh, final_create_time, final_access_time,
final_modify_time)
CloseHandle(fh)
return 0
except Exception as e:
print(e)
return 1
def set_jpg_timestamp(path):
'''用保存在EXIF中的拍摄时间设置图片的创建时间和修改时间。
如果目标时间与当前文件的创建时间一致（时间差小于1s）则不修改。
'''
f = open(path, 'rb')
tags = exifread.process_file(f, details=False)
f.close()
# new_ctimestamp1 for timestamp found in file tags, new_ctimestamp2 for timestamp found in file name.
new_ctimestamp1 = None
new_ctimestamp2 = None
file_name = split(path)[1]
print(f' [{file_name}]')
# 尝试获取'Image DateTime'的时间
try:
new_ctimestamp1 = time.mktime(time.strptime(
tags['Image DateTime'].values, '%Y:%m:%d %H:%M:%S'))
print(' └─Found "Image DateTime"', end='')
except KeyError:
print(' └─"Image DateTime" not found, try next method.')
except ValueError:
print(' └─"Image DateTime" is not valid, try next method.')
# 尝试获取'EXIF DateTimeOriginal'的时间
if not new_ctimestamp1:
try:
new_ctimestamp1 = time.mktime(time.strptime(
tags['EXIF DateTimeOriginal'].values, '%Y:%m:%d %H:%M:%S'))
print(' └─Found "EXIF DateTimeOriginal"', end='')
except KeyError:
print(' └─"EXIF DateTimeOriginal" not found, try next method.')
except ValueError:
print(' └─"EXIF DateTimeOriginal" is not valid, try next method.')
# 尝试获取'EXIF DateTimeDigitized'的时间
if not new_ctimestamp1:
try:
new_ctimestamp1 = time.mktime(time.strptime(
tags['EXIF DateTimeDigitized'].values, '%Y:%m:%d %H:%M:%S'))
print(' └─Found "EXIF DateTimeDigitized"', end='')
except KeyError:
print(' └─"EXIF DateTimeDigitized" not found, try next method.')
except ValueError:
print(' └─"EXIF DateTimeDigitized" is not valid, try next method.')
# 尝试从文件名获取时间，文件名需形如'XXX_YYYYmmdd_HHMMSS(_XXXXX).jp(e)g'
file_name_no_ext = splitext(split(path)[1])[0]
try:
time_strs = file_name_no_ext.split('_')[1:3]
new_ctimestamp2 = time.mktime(time.strptime(
''.join(time_strs), '%Y%m%d%H%M%S'))
if new_ctimestamp1:
print(' and file name contains timestamp', end='')
else:
print(' └─File name contains timestamp', end='')
except (ValueError, OverflowError):
if not new_ctimestamp1:
print(
' └─File name dose not match XXX_YYYYmmdd_HHMMSS(_XXXXX).jp(e)g format.')
if new_ctimestamp1 or new_ctimestamp2:
if new_ctimestamp1 is None:
new_ctimestamp = new_ctimestamp2
elif new_ctimestamp2 is None:
new_ctimestamp = new_ctimestamp1
else:
new_ctimestamp = new_ctimestamp1 if new_ctimestamp1 < new_ctimestamp2 else new_ctimestamp2
old_ctimestamp = getctime(path)
if abs(old_ctimestamp - new_ctimestamp) >= 1:
ctime = Time(new_ctimestamp)
try:
handle = CreateFile(path, GENERIC_WRITE,
FILE_SHARE_WRITE, None, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, None)
SetFileTime(handle, ctime, None, ctime)
CloseHandle(handle)
print('. Done.')
except:
print(
'. Can not change ctime and mtime. Make sure you have right permission. Skip it.')
else:
print('. No need to change. Skip it.')
else:
print(' └─No valid timestamp found. Skip it.')
def edit_file_list_time(c_time, dir_path, file_name_list):
# get arguments
# c_time = "08.10.2018 15:34:44"
m_time = c_time
a_time = c_time
time_format = "%d.%m.%Y %H:%M:%S"
c_time_stripe = time.strptime(c_time, time_format)
m_time_stripe = time.strptime(m_time, time_format)
a_time_stripe = time.strptime(a_time, time_format)
c_time_second = time.mktime(c_time_stripe)
m_time_second = time.mktime(m_time_stripe)
a_time_second = time.mktime(a_time_stripe)
for fileName in file_name_list:
# f_name = "h:\Downloads\待处理文件\20180702.xls"
f_name = dir_path + fileName
# specify time format
offset = random.randint(60, 150) # in seconds
# create struct_time object
c_time_second = c_time_second + offset
m_time_second = m_time_second + offset
a_time_second = a_time_second + offset
c_time_t = time.localtime(c_time_second)
m_time_t = time.localtime(m_time_second)
a_time_t = time.localtime(a_time_second)
# visually check if conversion was ok
print()
print("FileName: %s" % f_name)
print("Create : %s --> %s OK" %
(c_time, time.strftime(time_format, c_time_t)))
print("Modify : %s --> %s OK" %
(m_time, time.strftime(time_format, m_time_t)))
print("Access : %s --> %s OK" %
(a_time, time.strftime(time_format, a_time_t)))
print()
# change timestamp of file
fh = CreateFile(f_name, GENERIC_READ | GENERIC_WRITE, 0, None,
OPEN_EXISTING, 0, 0)
create_time, access_time, modify_time = GetFileTime(fh)
print("Change Create from", create_time,
"to %s" % (time.strftime(time_format, c_time_t)))
print("Change Modify from", modify_time,
"to %s" % (time.strftime(time_format, m_time_t)))
print("Change Access from", access_time,
"to %s" % (time.strftime(time_format, a_time_t)))
print()
create_time = Time(time.mktime(c_time_t))
access_time = Time(time.mktime(a_time_t))
modify_time = Time(time.mktime(m_time_t))
SetFileTime(fh, create_time, access_time, modify_time)
CloseHandle(fh)
# check if all was ok
ctime = time.strftime(time_format,
time.localtime(os.path.getctime(f_name)))
mtime = time.strftime(time_format,
time.localtime(os.path.getmtime(f_name)))
atime = time.strftime(time_format,
time.localtime(os.path.getatime(f_name)))
print("CHECK MODIFICATION:")
print("FileName: %s" % f_name)
print("Create : %s" % ctime)
print("Modify : %s" % mtime)
print("Access : %s" % atime)
# create struct_time object
cTime_t = time.localtime(time.mktime(time.strptime(cTime, format)) + offset)
mTime_t = time.localtime(time.mktime(time.strptime(mTime, format)) + offset)
aTime_t = time.localtime(time.mktime(time.strptime(aTime, format)) + offset)
# visually check if conversion was ok
print()
print("FileName: %s" % fName)
print("Create : %s --> %s OK" % (cTime, time.strftime(format, cTime_t)))
print("Modify : %s --> %s OK" % (mTime, time.strftime(format, mTime_t)))
print("Access : %s --> %s OK" % (aTime, time.strftime(format, aTime_t)))
print()
# change timestamp of file
fh = CreateFile(fName, GENERIC_READ | GENERIC_WRITE, 0, None, OPEN_EXISTING, 0,
0)
createTime, accessTime, modifyTime = GetFileTime(fh)
print("Change Create from", createTime,
"to %s" % (time.strftime(format, cTime_t)))
print("Change Modify from", modifyTime,
"to %s" % (time.strftime(format, mTime_t)))
print("Change Access from", accessTime,
"to %s" % (time.strftime(format, aTime_t)))
print()
createTime = Time(time.mktime(cTime_t))
accessTime = Time(time.mktime(aTime_t))
modifyTime = Time(time.mktime(mTime_t))
SetFileTime(fh, createTime, accessTime, modifyTime)
CloseHandle(fh)
def wipe_extent_by_defrag(volume_handle, lcn_start, lcn_end, cluster_size,
total_clusters, tmp_file_path):
assert cluster_size > 0
logger.debug("Examining extent from %d to %d for wipe...", lcn_start,
lcn_end)
write_length = (lcn_end - lcn_start + 1) * cluster_size
# Check the state of the volume bitmap for the extent we want to
# overwrite. If any sectors are allocated, reduce the task
# into smaller parts.
# We also reduce to smaller pieces if the extent is larger than
# 2 megabytes. For no particular reason except to avoid the entire
# request failing because one cluster became allocated.
volume_bitmap, bitmap_size = get_volume_bitmap(volume_handle,
total_clusters)
# This option simulates another process that grabs clusters on disk
# from time to time.
# It should be moved away after QA is complete.
if not simulate_concurrency:
count_free, count_allocated = check_extents([(lcn_start, lcn_end)],
volume_bitmap)
else:
count_free, count_allocated = check_extents_concurrency(
[(lcn_start, lcn_end)], volume_bitmap, tmp_file_path,
volume_handle, total_clusters)
if count_allocated > 0 and count_free == 0:
return False
if count_allocated > 0 or write_length > write_buf_size * 4:
if lcn_start < lcn_end:
for split_s, split_e in split_extent(lcn_start, lcn_end):
wipe_extent_by_defrag(volume_handle, split_s, split_e,
cluster_size, total_clusters,
tmp_file_path)
return True
else:
return False
# Put the zero-fill file in place.
file_handle = CreateFile(tmp_file_path, GENERIC_READ | GENERIC_WRITE, 0,
None, CREATE_ALWAYS, FILE_ATTRIBUTE_HIDDEN, None)
write_zero_fill(file_handle, write_length)
new_extents = get_extents(file_handle)
# We know the original extent was contiguous.
# The new zero-fill file may not be contiguous, so it requires a
# loop to be sure of reaching the end of the new file's clusters.
new_vcn = 0
for new_lcn_start, new_lcn_end in new_extents:
# logger.debug("Zero-fill wrote from %d to %d",
# new_lcn_start, new_lcn_end)
cluster_count = new_lcn_end - new_lcn_start + 1
cluster_dest = lcn_start + new_vcn
if new_lcn_start != cluster_dest:
logger.debug("Move %d clusters to %d", cluster_count, cluster_dest)
try:
move_file(volume_handle, file_handle, new_vcn, cluster_dest,
cluster_count)
except:
# Move file failed, probably because another process
# has allocated a cluster on disk.
# Break into smaller pieces and do what we can.
logger.debug("!! Move encountered an error !!")
CloseHandle(file_handle)
if lcn_start < lcn_end:
for split_s, split_e in split_extent(lcn_start, lcn_end):
wipe_extent_by_defrag(volume_handle, split_s, split_e,
cluster_size, total_clusters,
tmp_file_path)
return True
else:
return False
else:
# If Windows put the zero-fill extent on the exact clusters we
# intended to place it, no need to attempt a move.
logging.debug("No need to move extent from %d", new_lcn_start)
new_vcn += cluster_count
CloseHandle(file_handle)
DeleteFile(tmp_file_path)
return True
def __init__(self,
program,
cmdline=None,
cwd=None,
env=None,
spawn_flags=WINPTY_SPAWN_FLAG_AUTO_SHUTDOWN
| WINPTY_SPAWN_FLAG_EXIT_AFTER_SHUTDOWN,
pty_flags=0,
pty_size=(80, 25),
pty_mouse=WINPTY_MOUSE_MODE_NONE):
self._closed = False
config = None
try:
with winpty_error() as error:
config = winpty_config_new(pty_flags, error)
cols, rows = pty_size
if cols and rows:
winpty_config_set_initial_size(config, cols, rows)
winpty_config_set_mouse_mode(config, pty_mouse)
with winpty_error() as error:
self._pty = winpty_open(config, error)
finally:
winpty_config_free(config)
self._conin = winpty_conin_name(self._pty)
self._conout = winpty_conout_name(self._pty)
self._conerr = winpty_conerr_name(self._pty)
self._process_handle = None
try:
self._conin_pipe = CreateFile(self._conin, GENERIC_WRITE, 0, None,
OPEN_EXISTING, 0, None)
self._conout_pipe = CreateFile(self._conout, GENERIC_READ, 0, None,
OPEN_EXISTING, 0, None)
if self._conerr:
self._conerr_pipe = CreateFile(self._conerr, GENERIC_READ, 0,
None, OPEN_EXISTING, 0, None)
else:
self._conerr_pipe = None
try:
spawn_ctx = None
process_handle = HANDLE()
thread_handle = HANDLE()
create_process_error = DWORD()
with winpty_error() as error:
spawn_ctx = winpty_spawn_config_new(
spawn_flags, program, cmdline, cwd, env, error)
with winpty_error() as error:
winpty_spawn(self._pty, spawn_ctx, pointer(process_handle),
pointer(thread_handle),
pointer(create_process_error), error)
self._process_handle = process_handle
finally:
winpty_spawn_config_free(spawn_ctx)
except:
self.close()
raise
tz = pytz.timezone(args.timezone)
shutil.copy2(source, dest)
if os.path.isdir(dest):
dest_file = os.path.join(dest, src_file_name)
else:
dest_file = dest
created = dt.fromtimestamp(os.path.getctime(source))
created = Time(tz.localize(created))
modified = dt.fromtimestamp(os.path.getmtime(source))
modified = Time(tz.localize(modified))
accessed = dt.fromtimestamp(os.path.getatime(source))
accessed = Time(tz.localize(accessed))
print("Source\n======")
print("Created: {}\nModified: {}\nAccessed: {}".format(
created, modified, accessed))
handle = CreateFile(dest_file, GENERIC_WRITE, FILE_SHARE_WRITE, None,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, None)
SetFileTime(handle, created, accessed, modified)
CloseHandle(handle)
created = tz.localize(dt.fromtimestamp(os.path.getctime(dest_file)))
modified = tz.localize(dt.fromtimestamp(os.path.getmtime(dest_file)))
accessed = tz.localize(dt.fromtimestamp(os.path.getatime(dest_file)))
print("\nDestination\n===========")
print("Created: {}\nModified: {}\nAccessed: {}".format(
created, modified, accessed))
def osnmopen(path, *args):
# CreateFile(path, FILE_GENERIC_READ|FILE_GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
# http://docs.activestate.com/activepython/2.7/pywin32/win32file__CreateFile_meth.html
# PyHANDLE = CreateFile(fileName, desiredAccess , shareMode , attributes , CreationDisposition , flagsAndAttributes , hTemplateFile )
return CreateFile(path, FILE_GENERIC_READ|FILE_GENERIC_WRITE, 0, None, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, None)