wffat.c

vc环境下的pgp源码

			{
				dwStartCluster=((DWORD)(pd->deStartCluster))&0xfffff;
			}
			else
			{
				dwStartCluster=((DWORD)(pd->deEAhandle))&0xffff;
				dwStartCluster<<=16;
				dwStartCluster|=((DWORD)(pd->deStartCluster))&0xffff;
			}

			if((!strncmp(".       ",pd->deName,8))||
			   (!strncmp("..      ",pd->deName,8)))
			{
				// same and parent directory
			}
			// Check d attrib to see if directory
			else if(pd->deAttributes & 0x10)
			{
				// Store dir on stack for later processing...
				PushDirStack(&(vi->ds),dwStartCluster);
			}
			else if(dwStartCluster>=2) // 0 and 1 are weird stuff
			{
				char eightthree[12];

				memset(eightthree,0x00,12);
				memcpy(eightthree,pd->deName,11);

				// Wipe slack space for this file...
//				vErrorOut(fg_yellow,"%s %8x %d\n",
//					eightthree,dwStartCluster,dwTotalLength);
				err=DoFileSlack(vi,dwStartCluster,dwTotalLength);

				if(err!=WFE_NOERROR)
					RetVal=err;
			}

			pDir += sizeof( DIRENTRY );
		}

		if(pDir>=pEnd)   // Just in case it's completely full
			break;       // and there is no terminating zero
	}

	// We must keep trailing zero to show end of directory,
	// unless of course cluster is completely full
	pDir++;

	// Clear off slack at end of directory chain unless full
	if(pDir<pEnd)
	{
//		Patterns seem to be messing up directory structure
//		WritePattern(pDir,vi->pattern_buffer,pEnd-pDir);
		memset(pDir,0x00,pEnd-pDir);
	}

	return RetVal;
}

DWORD DoOldFatRootDirectory(VOLINFO *vi)
{
	DWORD bufsize,err,RetVal;
	unsigned char *pReadBuf;

	RetVal=WFE_NOERROR;

	bufsize = vi->FAT_DirSectorCount * vi->sector_size;
	pReadBuf = (BYTE *)malloc( bufsize );
	if(!pReadBuf)
	{
		RetVal=WFE_OUTOFMEMORY;
	}
	else
	{
//		This is just clearing the buffer
//		WritePattern(pReadBuf,vi->pattern_buffer, bufsize);
		memset( pReadBuf, 0x00, bufsize );

		err=ReadSectors(vi,vi->FAT_DirSector, 
			vi->FAT_DirSectorCount,pReadBuf);
		if(err!=WFE_NOERROR)
		{
			RetVal=err;
		}
		else
		{
			err=DoDirAndSlack(vi,pReadBuf,bufsize);
			if(err!=WFE_NOERROR)
			{
				RetVal=err;
			}
			else
			{
				err=WriteSectors(vi,vi->FAT_DirSector, 
					vi->FAT_DirSectorCount,pReadBuf);
				if(err!=WFE_NOERROR)
				{
					RetVal=err;
				}
			}
		}
		free(pReadBuf);
	}

	return RetVal;
}

DWORD GetBufferSize(VOLINFO *vi,
					DWORD dwIndexCluster,
					DWORD *bufsize)
{
	*bufsize=0;
	
	while(IsntEnd(vi,dwIndexCluster))
	{
		*bufsize+=vi->dwClusterSize;
		dwIndexCluster=FatItem(vi,dwIndexCluster);
	}

	if(IsClusterError(vi,dwIndexCluster))
		return WFE_CLUSTERERROR;

	return WFE_NOERROR;
}

DWORD ReadChainIntoBuffer(VOLINFO *vi,DWORD dwIndexCluster,
						  unsigned char *pReadBuf)
{
	DWORD dwIndexBuffer,RetVal,err;

	RetVal=WFE_NOERROR;
	dwIndexBuffer=0;

	while((IsntEnd(vi,dwIndexCluster))&&(RetVal==WFE_NOERROR))
	{
		err=ReadSectors(vi,
			ClusterToSector(vi,dwIndexCluster), 
			vi->sectors_per_clus,
			&(pReadBuf[dwIndexBuffer]));

		if(err!=WFE_NOERROR)
		{
			RetVal=err;
		}
		else
		{
			dwIndexBuffer+=vi->dwClusterSize;
			dwIndexCluster=FatItem(vi,dwIndexCluster);
		}
	}

	return RetVal;
}

DWORD WriteChainFromBuffer(VOLINFO *vi,DWORD dwIndexCluster,
						  unsigned char *pReadBuf)
{
	DWORD dwIndexBuffer,RetVal,err;

	RetVal=WFE_NOERROR;
	dwIndexBuffer=0;

	while((IsntEnd(vi,dwIndexCluster))&&(RetVal==WFE_NOERROR))
	{
		err=WriteSectors(vi,
			ClusterToSector(vi,dwIndexCluster), 
			vi->sectors_per_clus,
			&(pReadBuf[dwIndexBuffer]));

		if(err!=WFE_NOERROR)
		{
			RetVal=err;
		}
		else
		{
			dwIndexBuffer+=vi->dwClusterSize;
			dwIndexCluster=FatItem(vi,dwIndexCluster);
		}
	}

	return RetVal;
}

DWORD DoDirectories(VOLINFO *vi)
{
	DWORD bufsize,err,RetVal;
	unsigned char *pReadBuf;
	DWORD dwStartCluster;

	RetVal=WFE_NOERROR;
	vi->ds=0;

	if(vi->dwFS!=FS_FAT32)
	{
	// Do the nonstandard FAT16/FAT12 root directory
		err=DoOldFatRootDirectory(vi);
		if(err!=WFE_NOERROR)
			RetVal=err;
	}
	else
	{
	// FAT32 root is normal.. just push on stack.
		PushDirStack(&(vi->ds),vi->FAT32_DirCluster);
	}

	// If no errors so far, do operations on the stack
	while((PopDirStack(&(vi->ds),&dwStartCluster))&&
		  (RetVal==WFE_NOERROR))
	{
		// Starting cluster is invalid? Something wrong
		if(!IsntEnd(vi,dwStartCluster))
			return WFE_CLUSTERERROR;

		// Get the size of the buffer we'll need
		err=GetBufferSize(vi,dwStartCluster,&bufsize);

		if(err!=WFE_NOERROR)
		{
			RetVal=err;
		}
		else
		{
			pReadBuf = (BYTE*)malloc( bufsize );
			if(!pReadBuf)
			{
				RetVal=WFE_OUTOFMEMORY;
			}
			else
			{
//				This is just clearing the buffer
//				WritePattern(pReadBuf,vi->pattern_buffer, bufsize);
				memset( pReadBuf, 0x00, bufsize );

				// Read it in
				err=ReadChainIntoBuffer(vi,
					dwStartCluster,pReadBuf);
	
				if(err!=WFE_NOERROR)
				{
					RetVal=err;
				}
				else
				{
					// Clear entries and wipe slack
					err=DoDirAndSlack(vi,pReadBuf,
						bufsize); 
					if(err!=WFE_NOERROR)
					{
						RetVal=err;
					}
					else
					{
						// Write it out again.
						err=WriteChainFromBuffer(vi,
							dwStartCluster,pReadBuf);
						if(err!=WFE_NOERROR)
							RetVal=err;
					}
				}
			}
			free( pReadBuf );
		}
	}

	return RetVal;
}

BOOL IsFATOK(VOLINFO *vi)
{
	DWORD dwClusterValue,dwIndex;

	// Two is the first valid cluster
	for(dwIndex=2;dwIndex<vi->no_of_clusters;dwIndex++)
	{
		dwClusterValue=FatItem(vi,dwIndex);

		switch(vi->dwFS)
		{
			case FS_FAT12:
				if(!(((dwClusterValue>=0xff0)&&
				      (dwClusterValue<=0xfff))||
				      (dwClusterValue<=vi->no_of_clusters)))
					return FALSE;
				break;

			case FS_FAT16:
				if(!(((dwClusterValue>=0xfff0)&&
			 	      (dwClusterValue<=0xffff))||
				      (dwClusterValue<=vi->no_of_clusters)))
					return FALSE;
				break;

			case FS_FAT32:
				if(!(((dwClusterValue>=0x0ffffff0)&&
				      (dwClusterValue<=0x0fffffff))||
				      (dwClusterValue<=vi->no_of_clusters)))
					return FALSE;
				break;
		}
	}
	return TRUE;
}

DWORD ReadFAT(VOLINFO *vi,DWORD start_sector)
{
	DWORD bufsize,RetVal,err;

	RetVal=WFE_NOERROR;

	bufsize=vi->sector_size*vi->sectors_per_fat;
	vi->pFatBuf = (BYTE*)malloc(bufsize);

	if(!vi->pFatBuf)
	{
		RetVal=WFE_OUTOFMEMORY;
	}
	else
	{
//		This is just clearing the buffer
//		WritePattern(vi->pFatBuf,vi->pattern_buffer, bufsize);
		memset(vi->pFatBuf,0x00,bufsize);

		// Read in raw data
		err=ReadSectors(vi,start_sector, 
			vi->sectors_per_fat,vi->pFatBuf);

		if(err!=WFE_NOERROR)
		{
			free(vi->pFatBuf);
			RetVal=err;
		}
		else
		{
			if(!IsFATOK(vi))
			{
				RetVal=WFE_FATFAILED;
			}
		}
	}
	return RetVal;
}

DWORD WipeFreeClusters(VOLINFO *vi)
{
	DWORD i,err;
	
	WritePattern(vi->pClusterBuf,vi->pattern_buffer, vi->dwClusterSize);
	//memset(vi->pClusterBuf,0x00,vi->dwClusterSize);

	// Two is the first valid cluster
	for(i=2;i<vi->no_of_clusters;i++)
	{
		if(FatItem(vi,i)==0)
		{
			err=WriteSectors(vi,
				ClusterToSector(vi,i),
				vi->sectors_per_clus,
				vi->pClusterBuf);
			if(err!=WFE_NOERROR)
				return err;
		}
	}

	return WFE_NOERROR;
}

BOOL GetFileSystem(VOLINFO *vi,char *szRoot)
{
	char szFSName[256],szVolName[256];
	DWORD dwVolSerial,dwFileLen,dwFSFlags;

	if(!GetVolumeInformation(szRoot,
		szVolName,256,
		&dwVolSerial,
		&dwFileLen,
		&dwFSFlags,
		szFSName,256))
		return FALSE;

	vi->dwFS=FS_NOFS;

	// NTFS is also supported under WinNT
	// HPFS went away with 3.51, so we'll
	// forget about it
	if(vi->WinNT)
	{
		if(!strcmp(szFSName,"NTFS"))
			vi->dwFS=FS_NTFS;
	}

	if(!strcmp(szFSName,"FAT32"))
		vi->dwFS=FS_FAT32;
	else if(!strcmp(szFSName,"FAT"))
		vi->dwFS=FS_FAT;
	
	if(vi->dwFS==FS_NOFS)
		return FALSE;

	return TRUE;
}

void GetFatInfo(VOLINFO *vi,BOOTSECTOR *bs)
{
	vi->dwReservedSectors = bs->bsResSectors; 
	vi->sector_size = bs->bsBytesPerSec;
	vi->sectors_per_fat = bs->bsFATsecs;
	vi->fat_count=bs->bsFATs;
	vi->sectors_per_clus = bs->bsSecPerClust;
	 
	vi->sectors_total= bs->bsSectors ;
	if (vi->sectors_total==0)
		vi->sectors_total = bs->bsHugeSectors ;

	// Root direcory info
	vi->FAT_DirSectorCount=
		((32 * bs->bsRootDirEnts)+vi->sector_size - 1)/
		vi->sector_size;
	vi->FAT_DirSector=vi->dwReservedSectors+ 
		vi->sectors_per_fat*vi->fat_count;
	vi->dwStartSector=
		vi->FAT_DirSector+vi->FAT_DirSectorCount;
}

void GetFat32Info(VOLINFO *vi,BOOTSECTOR32 *bs32)
{
	vi->dwReservedSectors=bs32->bpb.A_BF_BPB_ReservedSectors;
	vi->sector_size=bs32->bpb.A_BF_BPB_BytesPerSector;
	vi->sectors_per_fat=
		(bs32->bpb.A_BF_BPB_BigSectorsPerFatHi<<16)+ 
		bs32->bpb.A_BF_BPB_BigSectorsPerFat;
	vi->fat_count=bs32->bpb.A_BF_BPB_NumberOfFATs;
	vi->sectors_per_clus=bs32->bpb.A_BF_BPB_SectorsPerCluster;
	vi->sectors_total=bs32->bpb.A_BF_BPB_TotalSectors;
	if(vi->sectors_total==0)
	{
		vi->sectors_total=
			(bs32->bpb.A_BF_BPB_BigTotalSectorsHigh<<16)+
			bs32->bpb.A_BF_BPB_BigTotalSectors;
	}

	// Root directory info
	vi->FAT32_DirCluster=
		(bs32->bpb.A_BF_BPB_RootDirStrtClusHi<<16)+ 
		bs32->bpb.A_BF_BPB_RootDirStrtClus;
	vi->dwStartSector = vi->dwReservedSectors + 
		vi->sectors_per_fat*vi->fat_count;
}

DWORD DoWipe(VOLINFO *vi)
{
	DWORD RetVal,err;
	char StrRes[500];

	RetVal=WFE_NOERROR;

	vi->pClusterBuf=
		(unsigned char *)malloc(vi->dwClusterSize);

	if(!vi->pClusterBuf)
	{
		RetVal=WFE_OUTOFMEMORY;
	}
	else
	{
		LoadString (g_hinst, IDS_READINGFAT, StrRes, sizeof(StrRes));

		StatusMessage(StrRes, FALSE);

		err=ReadFAT(vi,vi->dwReservedSectors);

		if(err!=WFE_NOERROR)
		{
			RetVal=err;
		}
		else
		{
			LoadString (g_hinst, IDS_WIPINGDELANDSLACK, StrRes, sizeof(StrRes));

			StatusMessage(StrRes, FALSE);
			err=DoDirectories(vi);

			WipeProgress(5);

			if(err!=WFE_NOERROR)
			{
				RetVal=err;
			}
			else
			{
				LoadString (g_hinst, IDS_WIPINGCLUSTERS, StrRes, sizeof(StrRes));

				StatusMessage(StrRes, FALSE);
				err=WipeFreeClusters(vi);

				WipeProgress(10); 

				if(err!=WFE_NOERROR)
				{
					RetVal=err;
				}
			}
			free(vi->pFatBuf);
		}

		free(vi->pClusterBuf);
	}

	return RetVal;
}

DWORD NinetyFiveWipeFree(HWND hwnd,VOLINFO *vi,char *szRoot,
			   DWORD* pattern, BOOL StartWipe)
{
	BYTE* pReadBuf;
	DWORD RetVal,err;
	char StrRes[500];

	// One-based volume, 'A'=1, 'B'=2, 'C'=3, etc.
	vi->vol1=toupper(szRoot[0])-'A'+1;
 
	// Open VWIN32
	vi->hVWin32 = CreateFile( "\\\\.\\vwin32",
		0,0,NULL,0,FILE_FLAG_DELETE_ON_CLOSE,NULL );

	// Get Level1 Exclusive Volume Lock
	if(LockLogicalVolume(vi->hVWin32,vi->vol1, 
		LEVEL1_LOCK, 
		LOCK_MAX_PERMISSION,
		(vi->dwFS==FS_FAT32))!=0)
	{
		RetVal=WFE_COULDNOTLOCK;
	}
	else
	{
		LoadString (g_hinst, IDS_READINGBOOT, StrRes, sizeof(StrRes));

		StatusMessage(StrRes, FALSE);

		// Read in boot sector
		pReadBuf = (BYTE*)malloc( 2048 );

		memset(pReadBuf,0x00,2048);

		err=ReadSectors(vi,0,1,pReadBuf);

		if(err!=WFE_NOERROR)
		{
			RetVal=err;
		}
		else
		{
			// Store some disk parameters
			if(vi->dwFS==FS_FAT32)
				GetFat32Info(vi,
					(BOOTSECTOR32 *)pReadBuf);
			else
				GetFatInfo(vi,
					(BOOTSECTOR *)pReadBuf);

			free(pReadBuf);

			if(vi->sectors_per_clus==0)
				vi->no_of_clusters=0;
			else
				vi->no_of_clusters=
					(vi->sectors_total-vi->dwStartSector)/
					vi->sectors_per_clus;

			vi->dwClusterSize=vi->sectors_per_clus*
				vi->sector_size;

			vi->fTotalCapacity=(float)vi->no_of_clusters*
				(float)vi->dwClusterSize;

			if(vi->dwFS==FS_FAT)
			{
				// Microsoft says 4086 here
				// FIPs says 4079. 4079 makes more sense,
				// but probably won't matter either way
				if(vi->no_of_clusters <= 4079)
					vi->dwFS=FS_FAT12;
				else
					vi->dwFS=FS_FAT16;
			}

			DisplayDiskStats(vi);

			// Do wipe if so. Otherwise report stats.
			if(StartWipe)
			{
				vi->bCountClusters=TRUE;
				RetVal=DoWipe(vi);
				if(RetVal==WFE_NOERROR)
				{
					vi->bCountClusters=FALSE;
					RetVal=DoWipe(vi);
				}
			}
		}
		// Free Level 1 lock
		UnlockLogicalVolume(
			vi->hVWin32, 
			vi->vol1, 
			(vi->dwFS==FS_FAT32));
	} 
	CloseHandle(vi->hVWin32);

	return RetVal;
}

// WipeFree
//
// Main entry point for Win95 and WinNT wiper. Does
// idiot checking first, then branches off
DWORD WipeFree(HWND hwnd,VOLINFO *vi,char *szRoot,
			   DWORD* pattern, BOOL StartWipe)
{
	DWORD RetVal;
	OSVERSIONINFO osid;
	UINT DriveType;

	bGlobalCancel=FALSE;
	RetVal=WFE_NOERROR;

	memset(vi,0x00,sizeof(VOLINFO));
	vi->hwnd=hwnd;
	
	if(pattern)
	{
		memcpy(vi->pattern_buffer, pattern, 256 * sizeof(DWORD));
	}

	if(*szRoot==0)
		return WFE_NODRIVESELECTED;

	DriveType=GetDriveType(szRoot);

	if((DriveType==DRIVE_REMOTE)||
		(DriveType==DRIVE_CDROM)||
		(DriveType==DRIVE_UNKNOWN)||
		(DriveType==DRIVE_NO_ROOT_DIR)||
		(DriveType==DRIVE_RAMDISK))
		return WFE_DRIVENOTSUPPORTED;

	osid.dwOSVersionInfoSize = sizeof (osid);
	GetVersionEx (&osid);   
	vi->WinNT=(osid.dwPlatformId == VER_PLATFORM_WIN32_NT);

	if(!GetFileSystem(vi,szRoot))
		return WFE_FSNOTSUPPORTED;

	// End of idiot testing. Time to do work
	if(vi->WinNT)
		return NTWipeFree(hwnd,vi,szRoot,
			   pattern, StartWipe);
	else
		return NinetyFiveWipeFree(hwnd,vi,szRoot,
			   pattern, StartWipe);
}