filesystem/MirrorFileModel.cpp at master · zyh329/filesystem · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
// MirrorFileModel.cpp: implementation of the MirrorFileModel class.
//
//////////////////////////////////////////////////////////////////////

//#include <afx.h>
#include "MirrorFileModel.h"
#include "MemFSService.h"
#include "WinDiskFSService.h"

// #ifdef _DEBUG
// #undef THIS_FILE
// static char THIS_FILE[]=__FILE__;
// #define new DEBUG_NEW
// #endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

MirrorFile::MirrorFile()
{
	m_pFSService = NULL;
	m_fHandle = NULL;
}

MirrorFile::~MirrorFile()
{
	if (m_pFSService)
	{
		delete m_pFSService;
		m_pFSService = NULL;
	}
}

BOOL	MirrorFile::SetDiskFilePointer(HANDLE hFile,  LONG lDistanceToMove,	PLONG lpDistanceToMoveHigh,	DWORD dwMoveMethod)
{
	m_pFSService->FSSetFilePointer((FSHANDLE)m_fHandle ,lDistanceToMove , lpDistanceToMoveHigh , dwMoveMethod);
	return TRUE;
}

BOOL	MirrorFile::ReadDiskFile(HANDLE hFile ,  LPVOID lpBuffer,	DWORD nNumberOfBytesToRead,	LPDWORD lpNumberOfBytesRead , LPOVERLAPPED lpOverlapped)
{
	return m_pFSService->FSReadFile((FSHANDLE)m_fHandle , lpBuffer , nNumberOfBytesToRead , lpNumberOfBytesRead , lpOverlapped);

}

BOOL	MirrorFile::WriteDiskFile(HANDLE hFile,LPCVOID lpBuffer,DWORD nNumberOfBytesToWrite,LPDWORD lpNumberOfBytesWritten,LPOVERLAPPED lpOverlapped)
{
	return m_pFSService->FSWriteFile((FSHANDLE)m_fHandle , lpBuffer , nNumberOfBytesToWrite , lpNumberOfBytesWritten , lpOverlapped);
}

FSHANDLE	MirrorFile::CreateDiskFile(		LPCSTR lpFileName,          // pointer to name of the file
						   DWORD dwDesiredAccess,       // access (read-write) mode
						   DWORD dwShareMode,           // share mode
						   SECURITY_ATTRIBUTES* lpSecurityAttributes,
						   // pointer to security attributes
						   DWORD dwCreationDisposition,  // how to create
						   DWORD dwFlagsAndAttributes,  // file attributes
						   FSHANDLE hTemplateFile         // handle to file with attributes to
						   )
{
	return m_pFSService->FSCreateFile(lpFileName , dwDesiredAccess , dwShareMode , lpSecurityAttributes ,
			dwCreationDisposition , dwFlagsAndAttributes  , hTemplateFile);
}

void	MirrorFile::IniFSService(CFSService::FSType type)
{
	if (m_pFSService)
	{
		delete m_pFSService;
		m_pFSService = NULL;
	}

	if(CFSService::FS_MEM==type)
	{
		m_pFSService=new CMemFSService;
	}
	else
	{
		m_pFSService=new CWinDiskFSService;
	}
}

BOOL	MirrorFile::CreateDiskFile(LPCSTR lpFileName)
{
	if (m_fHandle) CloseDiskFile();

	SECURITY_ATTRIBUTES sa;
	sa.nLength = sizeof(sa);
	sa.lpSecurityDescriptor = NULL;
	sa.bInheritHandle =  0;
	//	_lpImgFileName = new char[MAX_PATH];

	// map creation flags
	// map read/write mode
	DWORD dwAccess = 0;
	dwAccess = GENERIC_READ|GENERIC_WRITE;

	// map share mode
	DWORD dwShareMode = 0;
	dwShareMode = FILE_SHARE_WRITE|FILE_SHARE_READ;
	// map creation flags
	DWORD dwCreateFlag;

	dwCreateFlag = CREATE_ALWAYS;
	// attempt file creation
	// attempt file creation

	int ret = 0;

	FSHANDLE hFile = CreateDiskFile(lpFileName, dwAccess, dwShareMode, &sa,
		OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);  //已有的，就打开，没有的就会返回0xfffffff,就在下面再创建


	if(hFile == (FSHANDLE)-1 || hFile == (FSHANDLE)0)
	{
		//printf("hFile is %d", hFile);

		hFile = CreateDiskFile(lpFileName, dwAccess, dwShareMode, &sa,
			dwCreateFlag, FILE_ATTRIBUTE_NORMAL, NULL);

		if(hFile == (FSHANDLE)-1 || hFile == (FSHANDLE)0)
			return FALSE;

		ret = 2;//disk not format

	}
	else ret = 1;//disk exists

	m_fHandle = (HANDLE)hFile;

	return ret;
}

BOOL	MirrorFile::CloseDiskFile()
{
	if (m_fHandle)
	{
		// fill zero to fit sector
		ULONGLONG dwPos = m_pFSService->FSSetFilePointer((FSHANDLE)m_fHandle , 0 , 0 , FILE_END);

		if (dwPos % 512 != 0 )
		{
			ULONGLONG offset = 0;
			offset = 512 - dwPos % 512;
			BYTE buf[512];
			memset(buf , 0 , 512);

			DWORD nWritten = 0;
			m_pFSService->FSWriteFile( (FSHANDLE)m_fHandle, buf , (DWORD)offset , &nWritten , NULL);
		}

		BOOL ret = m_pFSService->FSCloseHandle((FSHANDLE)m_fHandle);
		m_fHandle = NULL;
		return ret;
	}

	return TRUE;
}