clsend.c

来自「PGP8.0源码 请认真阅读您的文件包然后写出其具体功能」· C语言 代码 · 共 647 行 · 第 1/2 页

					EnableWindow (GetDlgItem (hDlg, IDC_SENDSHARES), TRUE);
				else
					EnableWindow (GetDlgItem (hDlg, IDC_SENDSHARES), FALSE);
			}
			break;
		}
		return TRUE;
	}
	return FALSE;
}


//	___________________________________________________
//
//  decode event handler

static PGPError
sHandlerDecode (
		PGPContextRef	context,
		PGPEvent*		event,
		PGPUserValue	userValue)
{
	PSENDSHARESSTRUCT	psss;
	PGPError			err;

	switch (event->type) {
	case kPGPEvent_PassphraseEvent:
	{
		PGPEventPassphraseData	*pData = &event->data.passphraseData;

		UINT		uLen;
		CHAR		szPrompt[64];

		psss = (PSENDSHARESSTRUCT)userValue;
		psss->bConventional = pData->fConventional;

		LoadString (g_hInst, IDS_DECRYPTSHARESPROMPT,
									szPrompt, sizeof(szPrompt));

		// free phrase if this is a retry
		if (psss->pszPhrase)
		{
			PGPclFreePhrase (psss->pszPhrase);
			psss->pszPhrase = NULL;
		}

		if (psss->pPasskey)
		{
			PGPclFreePasskey (psss->pPasskey, psss->sizePasskey);
			psss->pPasskey = NULL;
		}

		if (event->data.passphraseData.fConventional)
		{
			err = PGPclGetKeyPhrase (context, psss->tlsContext,
					psss->hwndParent, szPrompt, psss->keydb,
					NULL, &(psss->pszPhrase),
					&(psss->pPasskey), &(psss->sizePasskey));
		}
		else
		{
			psss->keyAuthenticating = NULL;
			err = PGPclGetDecryptionPhrase (context, psss->tlsContext,
					psss->hwndParent, szPrompt, psss->keydb,
					&psss->keyAuthenticating,
					psss->keysetDecryption,
					psss->iKeyIDCount, psss->keyidsDecryption,
					&psss->keydbToAdd,
					&(psss->pszPhrase),
					&(psss->pPasskey), &(psss->sizePasskey));
		}

		if (IsPGPError (err))
			return err;

		if (psss->pszPhrase)
		{
			uLen = lstrlen (psss->pszPhrase);
			PGPAddJobOptions (event->job,
					PGPOPassphraseBuffer (context, psss->pszPhrase, uLen),
					PGPOLastOption (context));
		}
		else
		{
			PGPAddJobOptions (event->job,
					PGPOPasskeyBuffer (context,
							psss->pPasskey, psss->sizePasskey),
					PGPOLastOption (context));
		}
		break;
	}

	case kPGPEvent_RecipientsEvent:
	{
		PGPEventRecipientsData	*pData = &event->data.recipientsData;
		PGPUInt32				i;

		psss = (PSENDSHARESSTRUCT)userValue;
		psss->keyAuthenticating = kInvalidPGPKeyDBObjRef;

		// Save recipient key set for passphrase dialog
		psss->keysetDecryption = pData->recipientSet;
		PGPIncKeySetRefCount (psss->keysetDecryption);

		// Save unknown keyids
		if (pData->keyCount > 0)
		{
			psss->iKeyIDCount = pData->keyCount;
			psss->keyidsDecryption =
					(PGPKeyID *)clAlloc (pData->keyCount * sizeof(PGPKeyID));

			for (i=0; i<pData->keyCount; i++)
			{
				psss->keyidsDecryption[i] = pData->keyIDArray[i];
			}
		}
		break;
	}
	}

	return kPGPError_NoErr;
}


//	___________________________________________________
//
//  send shares

PGPError PGPclExport
PGPclSendShares (
		PGPContextRef		context,
		PGPtlsContextRef	tlsContext,
		HWND				hwndParent,
		PGPKeyDBRef			keydbMain)
{
	PFLFileSpecRef		fileref				= NULL;
	PGPShareFileRef		sharefileref		= NULL;
	PGPOptionListRef	optionsDecode		= NULL;
	PGPError			err					= kPGPError_NoErr;

	OPENFILENAME		ofn;
	SENDSHARESSTRUCT	sss;
	CHAR				szFile[MAX_PATH];
	CHAR				szInitDir[MAX_PATH];
	CHAR				sz[256];
	CHAR				szTitle[64];
	CHAR*				p;
	PGPSize				size;

	// initialize struct
	sss.context				= context;
	sss.tlsContext			= tlsContext;
	sss.hwnd				= NULL;
	sss.hwndParent			= hwndParent;
	sss.keydb				= keydbMain;
	sss.keysetDecryption	= kInvalidPGPKeySetRef;
	sss.keyidsDecryption	= NULL;
	sss.keydbToAdd			= kInvalidPGPKeyDBRef;
	sss.keyAuthenticating	= kInvalidPGPKeyDBObjRef;
	sss.pszPhrase			= NULL;
	sss.pPasskey			= NULL;
	sss.shares				= NULL;
	sss.pszRemoteHost		= NULL;
	sss.bConventional		= FALSE;
	sss.bThreadRunning		= FALSE;
	sss.bFinished			= FALSE;

	// prompt user for name of share file to send
	szFile[0] = '\0';
	LoadString (g_hInst, IDS_SHAREFILEFILTER, sz, sizeof(sz));
	while (p = strrchr (sz, '@')) *p = '\0';
	LoadString (g_hInst, IDS_SHAREFILECAPTION, szTitle, sizeof(szTitle));
	PGPclGetPath (kPGPclDefaultOpenFolder, szInitDir, sizeof(szInitDir));

	ofn.lStructSize       = sizeof (OPENFILENAME);
	ofn.hwndOwner         = hwndParent;
	ofn.hInstance         = (HANDLE)g_hInst;
	ofn.lpstrFilter       = sz;
	ofn.lpstrCustomFilter = (LPTSTR)NULL;
	ofn.nMaxCustFilter    = 0L;
	ofn.nFilterIndex      = 1L;
	ofn.lpstrFile         = szFile;
	ofn.nMaxFile          = sizeof (szFile);
	ofn.lpstrFileTitle    = NULL;
	ofn.nMaxFileTitle     = 0;
	ofn.lpstrInitialDir   = szInitDir;
	ofn.lpstrTitle        = szTitle;
	ofn.Flags			  = OFN_HIDEREADONLY|OFN_NOCHANGEDIR;
	ofn.nFileOffset       = 0;
	ofn.nFileExtension    = 0;
	ofn.lpstrDefExt       = "";
	ofn.lCustData         = 0;

	if (GetOpenFileName (&ofn))
	{
		err = PFLNewFileSpecFromFullPath (
				PGPPeekContextMemoryMgr (context), szFile, &fileref);
		if (IsPGPError (err))
			goto SendCleanup;

		err = PGPOpenShareFile (fileref, &sharefileref);
		if (IsPGPError (err))
			goto SendCleanup;

		err = PGPGetShareFileUserID (sharefileref,
				sizeof(sss.szName), sss.szName, &size);

		if (IsPGPError (err))
			goto SendCleanup;

		sss.uNumShares = PGPGetNumSharesInFile (sharefileref);

		// decrypt specified share file
		PGPBuildOptionList(context, &optionsDecode,
				PGPOKeyDBRef (context, keydbMain),
				PGPOEventHandler (context, sHandlerDecode, &sss),
				PGPOLastOption (context));
		err = PGPCopySharesFromFile (context, sharefileref,
				optionsDecode, &sss.shares);

		if (IsPGPError (err))
			goto SendCleanup;

		// passphrase may have been cached, so we may not have
		// gotten the authentication key, so try to get it
		// directly from the file
		if (!PGPKeyDBObjRefIsValid (sss.keyAuthenticating))
		{
			PGPKeyID	keyid;

			err = PGPGetShareFileOwnerKeyID (sharefileref, &keyid);
			if (IsntPGPError (err))
			{
				err = PGPFindKeyByKeyID (keydbMain, 
						&keyid, &sss.keyAuthenticating);

				if (IsPGPError (err))
					goto SendCleanup;
			}
		}

		// file may be conventionally encrypted or keyid may not have
		// been set by creator, so get the authentication key directly
		// from the user
		if ((sss.bConventional) ||
			!PGPKeyDBObjRefIsValid (sss.keyAuthenticating))
		{
			// the phrase and passkey we got from user is no good here
			if (sss.pszPhrase)
			{
				PGPclFreePhrase (sss.pszPhrase);
				sss.pszPhrase = NULL;
			}

			if (sss.pPasskey)
			{
				PGPclFreePasskey (sss.pPasskey, sss.sizePasskey);
				sss.pPasskey = NULL;
			}

			// get new phrase
			LoadString (g_hInst, IDS_SENDAUTHPROMPT, sz, sizeof(sz));
			err = PGPclGetSigningKeyPhrase (context, tlsContext, hwndParent,
					sz, keydbMain, TRUE, &sss.keyAuthenticating,
					&sss.pszPhrase, &sss.pPasskey, &sss.sizePasskey);
			if (IsPGPError (err))
				goto SendCleanup;
		}

		// launch send key shares dialog
		DialogBoxParam (g_hInst, MAKEINTRESOURCE(IDD_SENDSHARES), hwndParent,
				sSendKeySharesDlgProc, (LPARAM)&sss);
	}

SendCleanup :
	if (sss.pszPhrase)
		PGPclFreePhrase (sss.pszPhrase);

	if (sss.pPasskey)
		PGPclFreePasskey (sss.pPasskey, sss.sizePasskey);

	if (sss.pszRemoteHost)
		clFree (sss.pszRemoteHost);

	if (sss.shares)
		PGPFreeShares (sss.shares);

	if (PGPKeySetRefIsValid (sss.keysetDecryption))
		PGPFreeKeySet (sss.keysetDecryption);

	if (sss.keyidsDecryption)
		clFree (sss.keyidsDecryption);

	if (sharefileref)
		PGPFreeShareFile (sharefileref);

	if (fileref)
		PFLFreeFileSpec (fileref);

	if (optionsDecode)
		PGPFreeOptionList(optionsDecode);

	if (PGPKeyDBRefIsValid (sss.keydbToAdd))
	{
		if (IsntPGPError (err))
		{
			PGPKeySetRef	keysetToAdd;

			PGPNewKeySet (sss.keydbToAdd, &keysetToAdd);
			PGPclImportKeys (context, tlsContext, hwndParent,
					keysetToAdd, keydbMain, kPGPclDefaultImportFlags);

			PGPFreeKeySet (keysetToAdd);
		}
		PGPFreeKeyDB (sss.keydbToAdd);
	}

	PGPclErrorBox (hwndParent, err);

	return err;
}