www.pudn.com > FileGuard.zip > KProtectedFileList.h

/////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
// 
//KProtectedFileList.h 
 
#if !defined(FG_KPROTECTEDFILELIST_H_1_1) 
#define FG_KPROTECTEDFILELIST_H_1_1 
 
#include "..\hookshr\comdef.h" 
 
#define MAX_DRIVE	16 
//drive numbers larger than MAX_DRIVE will change to 0. 
#define GetSafeEntry(i)		( ((i)>=0 && (i)<=MAX_DRIVE)? i: 0) 
//Convert drive to index in hash table. Drive A is drive 1, and drive numbers larger than MAX_DRIVE will to convert to 0. 
#define DriveToIndex(drive)		GetSafeEntry(drive-'A'+1)//(((drive)-'A'+1>=0 && (drive)-'A'+1<=MAX_DRIVE)? (drive)-'A'+1: 0) 
#define PathToIndex(path)	(DriveToIndex(*(path))) 
 
///////////////////////////////////////////////////////////// 
struct FILE_NODE            
{ 
	PROTECTED_FILE	protFile; 
	struct FILE_NODE *pNextFile; 
 
	FILE_NODE()	{ pNextFile=NULL; } 
 
	//debug 
	//Don't do this! you never know whether PF_pPath is pointing to a valid heap block. 
	//The destroyer is always olidged to free PF_pPath. 
	//~FILE_NODE()  { free(protFile.PF_pPath); }	//in most cases the object is destroy by calling free(). In that case the destroyer should free protFile.PF_pPath. 
}; 
 
class KProtectedFileList                //class to manipulate protected file. 
{ 
public: 
	static BYTE GetPriority(char *path); 
	BOOL Add(const char *pBCSPath, WORD protectionType); 
	FILE_NODE* IsInList(const char *pBCSPath); 
	BOOL IsHide(char *pBCSPath); 
	BOOL IsUnderDeleteProtection(char *pBCSPath); 
	BOOL IsUnderReadProtection(char *pBCSPath); 
	BOOL IsUnderWriteProtection(char *pBCSPath); 
	KProtectedFileList(); 
	~KProtectedFileList(); 
	BOOL Add(const char *pBCSPath); 
	//BOOL Add(ParsedPath *pParsedPath); 
	BOOL Add(PROTECTED_FILE *pProtFileNode); 
	BOOL Remove(const char *pBCSPath); 
	//BOOL Remove(ParsedPath *pParsedPath); 
	PROTECTED_FILE* IsUnderProtection(const char *pBCSPath, WORD filter=0xFFFF);       //todo: modify this function to return PROTECTED_FILE * . 
	PROTECTED_FILE *FindFirst(); 
	PROTECTED_FILE *FindNext(); 
	void Empty(); 
 
#ifdef FG_VXD 
	PROTECTED_FILE* IsUnderProtection(int drive, ParsedPath *pPPath, WORD filter=0xFFFF); 
	BOOL IsHide(int drive, ParsedPath *pPPath); 
	BOOL IsUnderWriteProtection(int drive, ParsedPath *pPPath); 
	BOOL IsUnderReadProtection(int drive, ParsedPath *pPPath); 
	BOOL IsUnderDeleteProtection(int drive, ParsedPath *pPPath); 
#endif 
 
protected: 
	void ChangeProtNum(WORD typeOld, WORD typeNew); 
	struct FILE_NODE *m_pHead[MAX_DRIVE+1]; 
	struct FILE_NODE  m_headNode[MAX_DRIVE+1]; 
	struct FILE_NODE *m_pFindIndex; 
 
	static char driveList[(MAX_DRIVE+1)*2]; 
 
public: 
	int bIsDelOn, bIsReadOn, bIsWriteOn, bIsHideOn; 
 
	//Protection options: 
	BOOL bDelBak;			//back up on delete. 
	BOOL bWriteBak;			//back up on writting. 
}; 
 
//deleted: 
/* 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
struct PROTECTED_DIR 
{ 
	char *PD_pDir; 
	UINT PD_priority; 
	struct PROTECTED_DIR *PF_pNextDir; 
}; 
 
class KProtectedDirList 
{ 
public: 
	KProtectedDirList(); 
	~KProtectedDirList(); 
	BOOL Add(char *pDir); 
	BOOL Remove(char *pDir); 
	BOOL IsUnderProtection(char *pDir); 
	void Empty(); 
	char *FindFirst(); 
	char *FindNext(); 
 
protected: 
	struct PROTECTED_DIR *m_pHead; 
	UINT m_pFindIndex; 
}; 
*/ 
 
#endif	//!defined(FG_KPROTECTEDFILELIST_H_1_1)