scwipe.c

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

/*__________________________________________________________________________
 Copyright (C) 2002 PGP Corporation
 All rights reserved.
 
 $Id: SCwipe.c,v 1.23 2002/11/17 18:46:10 wjb Exp $
__________________________________________________________________________*/
#include "precomp.h"
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "shlobj.h"

#include "PGPsdkDriver.h"
#include "NotifyShell.h"

BOOL WipeError(HWND hwnd,FILELIST *FileEntry,UINT error)
{
	int ErrMsg;
	char StrRes[500];
	int nMsgBoxResult;
	BOOL bCancel = FALSE;
	UINT MBoxFlag;

	MBoxFlag=MB_OKCANCEL;

	switch(error)
	{
		case WIPE_NOTOPEN:
			ErrMsg=IDS_WIPENOTOPEN;
			break;
		case WIPE_USERABORT:
			ErrMsg=IDS_WIPEUSERABORT;
			bCancel = TRUE;
			break;
		case WIPE_NOSTATS:
			ErrMsg=IDS_WIPENOSTATS;
			break;

		case WIPE_NOREMOVE:
			ErrMsg=IDS_WIPENOREMOVE;
			break;
	
		case WIPE_NOFLUSH:
			ErrMsg=IDS_WIPENOFLUSH;
			break;

		case WIPE_NOFILEMAP:
			ErrMsg=IDS_WIPENOFILEMAP;
			break;

		case WIPE_NOMEMMAP:
			ErrMsg=IDS_WIPENOMEMMAP;
			break;

		case WIPE_ALREADYOPEN:
			ErrMsg=IDS_WIPEALREADYOPEN;
			break;

		case WIPE_WRITEPROTECT:
			ErrMsg=IDS_WIPEPROTECT;
			break;
	}

	LoadString (g_hinst, ErrMsg, StrRes, sizeof(StrRes));

	// There is no next file, so we don't put up both...
	if(FileEntry->next==NULL)
		MBoxFlag=MB_OK;

	nMsgBoxResult = MessageBox(hwnd,StrRes,PGPscJustFile(FileEntry->name),
						MBoxFlag|MB_ICONSTOP|MB_SETFOREGROUND);

	if (nMsgBoxResult == IDCANCEL)
		bCancel = TRUE;

	return bCancel;
}

BOOL WINAPI DeleteDlgProc(HWND hdlg, UINT uMsg, 
                             WPARAM wParam, LPARAM lParam)
{
    switch(uMsg)
    {
        case WM_INITDIALOG:
		{
			FILELIST *flist;
			int maxwidth,namelen;
			SIZE sizeString;
			HDC hdc;
			HWND hwndLB;
			int retval;
			HBITMAP hBmp;
			DWORD bits,bmp;
			HFONT hFont,hOldFont;

			flist=(FILELIST *)lParam;
			maxwidth=0;

			hwndLB=GetDlgItem(hdlg,IDC_FILELIST);

			hFont = (HFONT) GetStockObject(ANSI_VAR_FONT);
			SendMessage(hwndLB, WM_SETFONT, (WPARAM) hFont, 
				MAKELPARAM(TRUE, 0));

			hdc=GetDC(hwndLB);

			hOldFont=SelectObject(hdc,hFont);

			// Determine which bitmap will be displayed 
			bits = GetDeviceCaps (hdc, BITSPIXEL) * GetDeviceCaps (hdc, PLANES);

			if (bits <= 1)
				bmp = IDB_WIPEWIZ1;
			else if (bits <= 8) 
				bmp = IDB_WIPEWIZ4;
			else 
				bmp = IDB_WIPEWIZ8; 

			hBmp = LoadBitmap(g_hinst, MAKEINTRESOURCE(bmp));

			SendDlgItemMessage(	hdlg, 
				IDC_SECUREPIC, 
				STM_SETIMAGE, 
				IMAGE_BITMAP, 
				(LPARAM) hBmp);

			while(flist!=0)
			{
				SendMessage(hwndLB,
					LB_ADDSTRING,0,(LPARAM)flist->name);

				namelen=strlen(flist->name);
				retval=GetTextExtentPoint32(hdc, flist->name, namelen, &sizeString);
				
				sizeString.cx+=GetSystemMetrics(SM_CXVSCROLL);

				if(sizeString.cx>maxwidth)
					maxwidth=sizeString.cx;

				flist=flist->next;
			}

			SelectObject(hdc,hOldFont);

			ReleaseDC(hwndLB,hdc);

			SendMessage(hwndLB,
				LB_SETHORIZONTALEXTENT,(WPARAM)maxwidth,0);

			ShowWindow(hdlg,SW_SHOW);
			SetForegroundWindow(hdlg);

			return TRUE;
		}

		case WM_CLOSE:
		case WM_QUIT:
		case WM_DESTROY:
		{
			EndDialog(hdlg, FALSE);
			break;
		}

        case WM_COMMAND:
        {
            switch(wParam)
            {
				case IDYES:
				{
					EndDialog(hdlg, TRUE);
					break;
				}

				case IDNO:
				{
					EndDialog(hdlg, FALSE);
					break;
				}
			}
			break;
		}
	}
	return FALSE;
}

PGPError WipeFileListStub (MYSTATE *ms) 
{
	PGPContextRef context;
	FILELIST *FileCurrent;
	UINT WipeReturn;
	char StrRes[500];
	PGPError err;

	err=kPGPError_NoErr;

	context=ms->context;

	FileCurrent=ms->ListHead;

	while(!(PGPscProgressGetCancel(ms->hwndWorking))&&(FileCurrent!=0)&&(IsntPGPError(err)))
	{    
		if(FileCurrent->IsDirectory)
		{
			int result;

			result=_rmdir(FileCurrent->name);

			if(result!=0)
			{
				LoadString (g_hinst, IDS_DIRNOTREMOVED, StrRes, sizeof(StrRes));

				MessageBox(ms->hwndWorking,FileCurrent->name,StrRes,
					MB_OK|MB_ICONSTOP|MB_SETFOREGROUND);
				err=kPGPError_UnknownError;
			}

			FileCurrent=FileCurrent->next;
			continue;
		}

		WipeReturn=WipeStreams(ms->context,
			ms->hwndWorking,
			FileCurrent->name,WIPE_DEFAULT,0);

//		return WIPE_OK; For testing wiping of streams

		if(WipeReturn!=WIPE_OK)
		{
			if(!((BOOL)(ms->dwWipeFlags&WIPE_DONOTERROR)))
			{
				if (WipeError(ms->hwndWorking,FileCurrent,WipeReturn))
					err=kPGPError_UnknownError;
			}
		}
		else
		{
			WipeReturn=InternalFileWipe(ms->context,
				ms->hwndWorking,FileCurrent->name,ms->dwWipeFlags,
				ms->dwPasses,0);

			if(WipeReturn!=WIPE_OK)
			{
				if(!((BOOL)(ms->dwWipeFlags&WIPE_DONOTERROR)))
				{
					if (WipeError(ms->hwndWorking,FileCurrent,WipeReturn))
						err=kPGPError_UnknownError;
				}
			}
		}

		FileCurrent=FileCurrent->next;				
	}

	return err;
}


BOOL PGPscWipeFileList(HWND hwnd,void *PGPsc,FILELIST *ListHead,DWORD dwWipeFlags,
					   DWORD dwPasses)
{
	MYSTATE *ms;
	PGPBoolean bWarnOnWipe;
	BOOL DeleteThem;
	PGPContextRef context;
	PGPError err;

	err=kPGPError_NoErr;

	context=(PGPContextRef)PGPsc;

	bWarnOnWipe=FALSE;

	if(!(BOOL)(dwWipeFlags&WIPE_DONOTWARN))
	{
		// This way we can avoid the pref via WIPE_DONOTWARN
		ReadWipePref(context,&bWarnOnWipe);
	}

	if(bWarnOnWipe)
	{
		DeleteThem=DialogBoxParam(g_hinst, 
			MAKEINTRESOURCE( IDD_DELETEDLG),
            hwnd, 
            (DLGPROC) DeleteDlgProc, 
            (LPARAM) ListHead);

		if(!DeleteThem)
		{
			return FALSE;
		}
	}

	ms=(MYSTATE *)malloc(sizeof(MYSTATE));

	if(ms)
	{
		memset(ms, 0x00, sizeof(MYSTATE) );

		ms->context=context;
		ms->ListHead=ListHead;
		ms->Operation=MS_WIPEFILELIST;
		ms->dwWipeFlags=dwWipeFlags;
		ms->dwPasses=dwPasses;
	
		if((BOOL)(dwWipeFlags&WIPE_DONOTPROGRESS))
		{
			err=WipeFileListStub (ms);
		}
		else
		{
			err=PGPscProgressDialog(hwnd,DoWorkThread,ms,
			  0,"Wiping File(s)...",
			  "","",IDR_ERASEAVI);
		}

		free(ms);
	}
	
	PGPscFreeFileList(ListHead);

	if(IsPGPError(err))
		return FALSE;

	return TRUE;
}

// Windows 95 IFSmgr _VolFlush call
BOOL Win95Flush(HANDLE hDriver,char *szFilename)
{
	PGPWIPEDELETESTRUCT pwds;
	DWORD dwLen;

	memset(&pwds,0x00,sizeof(PGPWIPEDELETESTRUCT));

	pwds.ulVolume=toupper(szFilename[0])-'A'; // zero based
	pwds.ulOperation=kPGPUDOperation_VolFlush;

	if(hDriver!=0)
	{
		if(DeviceIoControl(hDriver, IOCTL_PGPUTIL_WIPEDELETE,
			&pwds, sizeof(PGPWIPEDELETESTRUCT),
			&pwds, sizeof(PGPWIPEDELETESTRUCT),
			&dwLen, NULL ))
		{
//			MessageBox(NULL,"DeviceIO OK!","Ha!",MB_OK);
			return TRUE;
		}
	}

	return FALSE;
}

static const char	kPGPMemLockDriver95Name[] = "\\\\.\\PGPsdk.vxd";

#define MEGABYTE (1024*1024)
#define ONETWENTYEIGHT 128*1024

#define LOLONG(l)           ((PGPUInt32)(l))
#define HILONG(l)           ((PGPUInt32)(((PGPUInt64)(l) >> 32) & 0xFFFFFFFF))

UINT InternalFileWipe(PGPContextRef context,HWND hwnd,
					  char *FileName,DWORD dwWipeFlags,
					  DWORD dwPasses,PGPUInt64 dwSizeADS)
{

	PGPUInt64 ui64Size;
	PGPUInt64 Zap64Size;
	DWORD dwPageSize;
	PGPUInt64 ui64NumPages;
	DWORD lastError;

	SYSTEM_INFO sysinfo;
	HANDLE hFile;
	HANDLE hMap;
	LPSTR lpFile;
	int count = 0;
    BOOL CancelOperation;
	BOOL bMoveFileSuccess;
	struct _stati64 buf;
	UINT wipe_err = 0;
	MYSTATE *ms;
	int staterror;
	char NewFileName[MAX_PATH+1];
	int retval;
	DWORD dwFileAttributes;
	char *name;
	char letter;
	FILE *ftest;

	PGPError		error			= kPGPError_NoErr;
	PGPDiskWipeRef	wipeRef			= NULL;