cshellext.cpp

vc环境下的pgp源码

			{
				helpString = 
					GetCommonString(kPGPdiskShellExtDescribeUnmountString);
			}
			else
			{
				helpString = 
					GetCommonString(kPGPdiskShellExtDescribeMountString);
			}
			break;

		case 1:
			helpString = 
				GetCommonString(kPGPdiskShellExtDescribeAddPassString);
			break;

		case 2:
			helpString = 
				GetCommonString(kPGPdiskShellExtDescribeChangePassString);
			break;

		case 3:
			if (mShiftKeyDown)
			{
				helpString = 
					GetCommonString(kPGPdiskShellExtDescribeRemoveAltsString);
			}
			else
			{
				helpString = 
					GetCommonString(kPGPdiskShellExtDescribeRemovePassString);
			}
			break;

		case 4:
			helpString = 
				GetCommonString(kPGPdiskShellExtDescribePubKeysString);
			break;

		case 5:
			helpString = 
				GetCommonString(kPGPdiskShellExtDescribeHelpString);
			break;
		}

		// Convert to Unicode under NT.
		if (IsWinNT4CompatibleMachine())
		{
			if (!(MultiByteToWideChar(CP_ACP, 0, helpString, -1, 
				(LPWSTR) pszName, cchMax / 2)))
			{
				((LPWSTR) pszName)[0] = NULL;
			}
		}
		else
		{
			SmartStringCopy(pszName, helpString, cchMax);
		}
	}
	catch (CMemoryException *ex)
	{
		ex->Delete();
	}

	return NOERROR;
}

// AddRef increases the reference count for this class object.

STDMETHODIMP_(ULONG) 
CShellExt::AddRef()
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	return ++mRefCount;
}

// Release decreases the reference count for this class object.

STDMETHODIMP_(ULONG) 
CShellExt::Release()
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	if (--mRefCount)
		return mRefCount;

    if (mPDataObj)
        mPDataObj->Release();

	delete this;

	return 0;
}

// Initialize is called before initializing the context menu.

STDMETHODIMP 
CShellExt::Initialize(
	LPCITEMIDLIST	pIDFolder, 
	LPDATAOBJECT	pDataObj, 
	HKEY			hRegKey)
{
	DualErr derr;

	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	// Initialize can be called more than once.
	if (mPDataObj)
		mPDataObj->Release();

	// Duplicate the object pointer and registry handle, and extract the path
	// of the file or drive being operated on.

	if (IsntNull(pDataObj))
	{
		mPDataObj = pDataObj;
		pDataObj->AddRef();

		derr = PreparePathsAndCommandLine();
	}

	if (derr.IsntError())
		return NOERROR;
	else
		return E_OUTOFMEMORY;
}


/////////////////////////////////////////////
// Class CShellExt protected member functions
/////////////////////////////////////////////

// DeletePathsAndCommandLine releases memory allocated by
// PreparePathsAndCommandLine.

void 
CShellExt::DeletePathsAndCommandLine()
{
	if (IsntNull(mTargets))
	{
		delete[] mTargets;
		mTargets = NULL;
	}
}

// ProcessTarget is a helper function for PreparePathsAndCommandLine.

DualErr 
CShellExt::ProcessTarget(HDROP hDrop, PGPUInt32 i)
{
	DualErr derr;

	pgpAssert(IsntNull(hDrop));
	pgpAssert(i <= mNumDropped);

	try
	{
		char		ext[_MAX_EXT];
		PGPBoolean	isAPGPdisk;

		mTargets[i].isVolume			= FALSE;
		mTargets[i].isPGPdisk			= FALSE;
		mTargets[i].isMountedPGPdisk	= FALSE;

		// Get the path.
		DragQueryFile((HDROP) hDrop, i, 
			mTargets[i].path.GetBuffer(kMaxStringSize), kMaxStringSize);

		mTargets[i].path.ReleaseBuffer();

		// Is this a volume being pointed at?
		mTargets[i].isVolume = IsPlainLocalRoot(mTargets[i].path);

		// Check if it is a mounted PGPdisk.
		if (mTargets[i].isVolume)
		{
			PGPUInt8 drive;

			// It's a volume, but is a PGPdisk volume (mounted)?
			drive = DriveLetToNum(mTargets[i].path[0]);
			derr = IsVolumeAPGPdisk(drive, &isAPGPdisk);

			if (derr.IsntError())
			{
				if (isAPGPdisk)
				{
					mNumTotalPGPdisks++;
					mNumMountedPGPdisks++;

					mTargets[i].isPGPdisk			= TRUE;
					mTargets[i].isMountedPGPdisk	= TRUE;
				}
			}
		}
		else
		{
			// It's a file, but is it a PGPdisk file (mounted or unmounted)?
			_splitpath(mTargets[i].path, NULL, NULL, NULL, ext);
			mTargets[i].isPGPdisk = !_stricmp(ext, kPGPdiskFileExtension);

			if (mTargets[i].isPGPdisk)
			{
				PGPBoolean isLoopedBack;

				mNumTotalPGPdisks++;

				// Resolve looped UNC paths.
				if (IsUNCPath(mTargets[i].path))
				{
					derr = CheckIfLoopedBack(mTargets[i].path, 
						&mTargets[i].path, &isLoopedBack);
				}

				// Is this a mounted PGPdisk?
				derr = IsFileAPGPdisk(mTargets[i].path, &isAPGPdisk);

				if (derr.IsntError())
				{
					mTargets[i].isMountedPGPdisk = isAPGPdisk;

					if (isAPGPdisk)
						mNumMountedPGPdisks++;
				}
			}
		}

	}
	catch (CMemoryException *ex)
	{
		derr = DualErr(kPGDMinorError_OutOfMemory);
		ex->Delete();
	}

	return derr;
}

// PreparePathsAndCommandLine prepares the list of targets and space for the
// command line for the app.

DualErr 
CShellExt::PreparePathsAndCommandLine()
{
	DualErr		derr;
	PGPBoolean	createdTargets	= FALSE;

	try
	{
		FORMATETC	fmte = {CF_HDROP, (DVTARGETDEVICE FAR *) NULL, 
			DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
		PGPBoolean	createdTargets	= FALSE;
		PGPUInt32	i;
		STGMEDIUM	medium;

		mPDataObj->GetData(&fmte, &medium);

		// Get the number of targets.
		mNumDropped = DragQueryFile((HDROP) medium.hGlobal, 0xFFFFFFFF, NULL, 
			NULL);

		if (mNumDropped == 0)
			derr = DualErr(kPGDMinorError_FailSilently);

		if (derr.IsntError())
		{
			mNumTotalPGPdisks = mNumMountedPGPdisks = 0;

			// Get space for the target array.
			mTargets = new TargetInfo[mNumDropped];
			createdTargets = TRUE;

			// Get info about each of them.
			for (i = 0; i < mNumDropped; i++)
			{
				derr = ProcessTarget((HDROP) medium.hGlobal, i);

				if (derr.IsError())
					break;
			}
		}
	}
	catch (CMemoryException *ex)
	{
		derr = DualErr(kPGDMinorError_OutOfMemory);
		ex->Delete();
	}

	// Cleanup if error.
	if (derr.IsError())
	{
		if (createdTargets)
		{
			delete[] mTargets;

			mTargets = NULL;
		}

		mNumDropped = mNumTotalPGPdisks = mNumMountedPGPdisks = 0;
	}

	return derr;
}

// SendRequestToApp asks the PGPdisk application to perform a command on the
// PGPdisk targets. A "non-targeted" command does not take a pathname
// argument.

void 
CShellExt::SendRequestToApp(LPCSTR command, PGPBoolean isNonTargeted)
{
	try
	{
		CString		appName, temp;
		PGPUInt32	result;

		pgpAssertStrValid(command);

		// For each PGPdisk target, add a command to the command line
		// we are building.

		if (isNonTargeted)
		{
			mCommandLine += command;
		}
		else
		{
			for (PGPUInt32 i=0; i < mNumDropped; i++)
			{
				if (mTargets[i].isPGPdisk)
				{
					PGPInt32 length;
					
					length = mTargets[i].path.GetLength();

					// If slash on end, double it.
					if (mTargets[i].path[length - 1] == '\\')
						mTargets[i].path += "\\";

					temp.Format(" %s \"%s\"", command, mTargets[i].path);
					mCommandLine += temp;
				}
			}
		}

		// Execute the command line.
		appName = kPGPdiskAppName;
		appName += ".exe";

		result = (PGPUInt32) ShellExecute(NULL, "open", appName, 
			mCommandLine, NULL, SW_SHOWNORMAL);

		if (result < 32)
			ReportError(kPGDMajorError_CouldntFindAppString);
	}
	catch (CMemoryException *ex)
	{
		ex->Delete();
	}
}