translators.c

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

					HANDLE hFile = NULL;
					DWORD dwBytes;
					DWORD dwLength;
					char *szFileData = NULL;
					char szLineEnd[] = "\r\n";

					hFile = CreateFile(out_file, GENERIC_READ | GENERIC_WRITE,
								0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
								NULL);

					dwLength = GetFileSize(hFile, NULL);

					szFileData = (char *) calloc(sizeof(char), dwLength+1);

					ReadFile(hFile, szFileData, dwLength, &dwBytes, NULL);
					SetFilePointer(hFile, 0, NULL, FILE_BEGIN);

					WriteFile(hFile, szLineEnd, strlen(szLineEnd), &dwBytes, 
						NULL);

					WriteFile(hFile, szFileData, dwLength, &dwBytes, NULL);

					CloseHandle(hFile);
					free(szFileData);
				}

				if (in_file == temp_file)
					DeleteFile(temp_file);

				if( IsntPGPError(error) )
				{
					if( out_mime )
					{
						if ( !*out_mime )
							*out_mime = (emsMIMEtypeP) calloc(1, 
														sizeof(emsMIMEtype));

						if(bMIME)
						{
							*out_mime = make_mime_type(	"multipart",
														"encrypted", 
														"1.0");

							if( *out_mime )
							{
								pluginReturn = EMSR_OK;

								add_mime_parameter(	*out_mime, 
													"boundary", 
													mimeSeparator);

								add_mime_parameter(	*out_mime, 
													"PGPFormat", 
													"PGPMIME-encrypted");
							}
						}
						else
						{
							if( *out_mime )
							{
								pluginReturn = EMSR_OK;

								*out_mime = make_mime_type(	"text",
															"plain", 
															"1.0");
							}
						}
					}
				}
			}

			break;
		}

		case kDecryptTranslatorID:
		case kVerifyTranslatorID:
		{
			bManual = FALSE;
		}
		case kManualDecryptVerifyTranslatorID:
		{
			char *szTempFile = NULL;
			BOOL bFYEO = FALSE;
			void *pOutput = NULL;
			PGPSize outSize = 0;
			HANDLE hCheckFile = INVALID_HANDLE_VALUE;
			char *szBuffer = NULL;
			
			hCheckFile = CreateFile((char *) in_file, GENERIC_READ, 0, 
							NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 
							NULL);

			if (hCheckFile != INVALID_HANDLE_VALUE)
			{
				DWORD dwFileSize;
				char *szHeaderEnd;
				char cOldEnd = 0;
				char *szLine;
				char *szLineEnd;
				UINT nPGPBlock = 0;
				char szBeginMessage[] = "-----BEGIN PGP MESSAGE";
				char szBeginSigned[] = "-----BEGIN PGP SIGNED";
				char szEndPGP[] = "-----END PGP";
				char szAttachment[] = "Attachment Converted: ";
				UINT nBeginMessage = strlen(szBeginMessage);
				UINT nBeginSigned = strlen(szBeginSigned);
				UINT nEndPGP = strlen(szEndPGP);
				UINT nAttachment = strlen(szAttachment);

				dwFileSize = GetFileSize(hCheckFile, NULL);
				szBuffer = (char *) calloc(1, dwFileSize + 1);
				ReadFile(hCheckFile, szBuffer, dwFileSize, &dwFileSize, NULL);
				CloseHandle(hCheckFile);
				
				szLine = szBuffer;
				szLineEnd = strstr(szLine, "\r\n");
				while (szLine)
				{
					if (!strncmp(szLine, szBeginMessage, nBeginMessage) ||
						!strncmp(szLine, szBeginSigned, nBeginSigned))
					{
						nPGPBlock++;
					}
					else if (!strncmp(szLine, szEndPGP, nEndPGP))
					{
						nPGPBlock--;
					}

					if (!nPGPBlock)
					{
						if (!strncmp(szLine, szAttachment, nAttachment))
						{
							char szTitle[255];
							char szMsg[1024];
							
							LoadString(g_hinst, IDS_EXE, szTitle, 254);
							LoadString(g_hinst, IDS_Q_HASATTACHMENT, szMsg, 1023);
							
							if (MessageBox(hwndMain, szMsg, szTitle, MB_YESNO)
								== IDNO)
							{
								free(szBuffer);
								return EMSR_UNKNOWN_FAIL;
							}

							break;
						}
					}

					if (szLineEnd != NULL)
					{
						szLine = szLineEnd + 2;
						szLineEnd = strstr(szLine, "\r\n");
					}
					else
						szLine = NULL;
				}

				szHeaderEnd = strstr(szBuffer, "\r\n\r\n");
				if (szHeaderEnd != NULL)
				{
					if (strlen(szHeaderEnd) > 4)
					{
						cOldEnd = szHeaderEnd[4];
						szHeaderEnd[4] = 0;
					}
				}

				if (strstr(szBuffer, "Mime-Version: ") &&
					strstr(szBuffer, "Content-Type: multipart") &&
					strstr(szBuffer, "protocol=\"application/pgp"))
				{
					if (bManual)
					{
						char szTitle[255];
						char szMsg[1024];

						LoadString(g_hinst, IDS_TITLE_PGPERROR, szTitle, 254);
						LoadString(g_hinst, IDS_E_PGPMIME, szMsg, 1023);

						MessageBox(hwndMain, szMsg, szTitle, MB_ICONEXCLAMATION);
						free(szBuffer);
						return EMSR_UNKNOWN_FAIL;
					}
					else
					{
						char *szBoundary;

						szBoundary = strstr(szBuffer, "boundary=");
						szBoundary += strlen("boundary=");
						if (*szBoundary != '\"')
						{
							char *szEndBoundary;
							DWORD dwBytes;

							szEndBoundary = szBoundary + 
												strcspn(szBoundary, ";\r\n");

							if (cOldEnd)
								szHeaderEnd[4] = cOldEnd;

							hCheckFile = CreateFile((char *) in_file, 
											GENERIC_WRITE, 0, NULL, 
											OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, 
											NULL);

							WriteFile(hCheckFile, szBuffer,
								szBoundary - szBuffer, &dwBytes, NULL);
							WriteFile(hCheckFile, "\"", 1, &dwBytes, NULL);
							WriteFile(hCheckFile, szBoundary,
								szEndBoundary - szBoundary, &dwBytes, NULL);
							WriteFile(hCheckFile, "\"", 1, &dwBytes, NULL);
							WriteFile(hCheckFile, szEndBoundary,
								strlen(szEndBoundary), &dwBytes, NULL);
							CloseHandle(hCheckFile);
						}
					}
				}
				
				free(szBuffer);
			}

			error = DecryptVerifyFile(g_hinst, hwndMain, g_pgpContext, 
						g_tlsContext, szExe, szDll, (char *) in_file, 
						!bManual, FALSE, &szTempFile, &pOutput, &outSize,
						&bFYEO);

			if( IsntPGPError(error) ) 
			{
				char szHex[] = "00000000";
				PGPUInt32 nFileNum;
				int nFileStart;

				if ((bFYEO)||(PGPscGetSecureViewerPref((void *)g_pgpContext)))
					PGPscTempestViewer((void *)g_pgpContext,hwndMain,
						pOutput,outSize,bFYEO);

				CopyFile(szTempFile, out_file, FALSE);
				DeleteFile(szTempFile);

				if( out_mime )
				{
					ParseFileForMIMEType( out_file, out_mime );
				}

				if ((bFYEO)||(PGPscGetSecureViewerPref((void *)g_pgpContext)))
					pluginReturn = EMSR_UNKNOWN_FAIL;
				else
					pluginReturn = EMSR_OK;

				g_szWipeFile = (char *) calloc(1, strlen(out_file) + 1);
				
				strcpy(g_szWipeFile, out_file);
				nFileStart = strlen(g_szWipeFile) - 10;
				memcpy(&(g_szWipeFile[nFileStart]), "tmp", 3);
				memcpy(&(szHex[5]), &(g_szWipeFile[nFileStart+3]), 3);

				nFileNum = pgpHexToPGPUInt32(szHex);
				pgpPGPUInt32ToHex(nFileNum + 1, FALSE, szHex);
				memcpy(&(g_szWipeFile[nFileStart+3]), &(szHex[5]), 3);

				SetTimer(g_hwndHidden, 1, 3000, NULL);
			}

			if (szTempFile != NULL)
				PGPFreeData(szTempFile);
			if (pOutput != NULL)
				PGPFreeData(pOutput);

			break;
		}

	}

	return pluginReturn;
}


long CanTranslateMIMEType(
	long					transContext,
	emsMIMEtypeP			mimeType,
	const char*				type,
	const char*				subType)
{
	long	err	= EMSR_CANT_TRANS;
	
	if ( mimeType )
	{
		BOOL		haveValidContext;
		const long	kValidContextMask = EMSF_ON_DISPLAY | EMSF_ON_ARRIVAL;
		
		haveValidContext	= ( transContext & kValidContextMask ) != 0;
		
		if ( haveValidContext )
		{
			BOOL haveMatch;
			
			haveMatch = match_mime_type( mimeType, type, subType );

			if( haveMatch )
			{
				const char* PGPMimeParam = NULL;

				PGPMimeParam = get_mime_parameter(	mimeType, 
													"protocol");

				if(	PGPMimeParam && 
					(!strcmp(PGPMimeParam, "application/pgp-encrypted") || 
					!strcmp(PGPMimeParam, "application/pgp-signature") ) 
				)
				{
					haveMatch = TRUE;
				}
				else
				{
					haveMatch = FALSE;
				}
			}
			
			if ( haveMatch )
			{
	 		    if( transContext == EMSF_ON_ARRIVAL )
	 		    {
		   	        err = EMSR_NOT_NOW;
		   	    }
		   	    else
		   	    {
		   		    err = EMSR_NOW;
		   		}
			}
		}
	}
	
	return( err );
}


BOOL CALLBACK WarnYesNoDlgProc(HWND hwndDlg, 
							   UINT uMsg, 
							   WPARAM wParam, 
							   LPARAM lParam)
{
	BOOL bReturnCode = FALSE;
	DWORD dwResult;

	switch(uMsg)
	{
	case WM_INITDIALOG:
		{
			SetWindowText(GetDlgItem(hwndDlg, IDC_WARNING), (char *) lParam);
			break;
		}

	case WM_COMMAND:
		switch (LOWORD(wParam))
		{
		case IDC_YESCONTINUE:
			if (IsDlgButtonChecked(hwndDlg, IDC_NOWARN) == BST_CHECKED)
				dwResult = CONTINUE_BIT;
			else
				dwResult = CONTINUE_BIT | WARN_BIT;

			EndDialog(hwndDlg, dwResult);
			bReturnCode = TRUE;
			break;

		case IDC_NOCONTINUE:
			if (IsDlgButtonChecked(hwndDlg, IDC_NOWARN) == BST_CHECKED)
				dwResult = 0;
			else
				dwResult = WARN_BIT;

			EndDialog(hwndDlg, dwResult);
			bReturnCode = TRUE;
			break;
		}
		break;
	}

	return(bReturnCode);
}


BOOL UIWarnYesNo(HWND hwnd, UINT nID, UINT nPrefIndex)
{
	char szMessage[1024];
	PGPPrefRef prefRef;
	PGPBoolean bWarn;
	BOOL bContinue;
	DWORD dwResult;
	PGPError err = kPGPError_NoErr;

	LoadString(g_hinst, nID, szMessage, 1023);

	err = PGPclPeekClientLibPrefRefs(&prefRef, NULL);
	if (IsPGPError(err))
	{
		PGPclErrorBox(hwnd, err);
		return FALSE;
	}

	err = PGPGetPrefBoolean(prefRef, nPrefIndex, &bWarn);
	if (IsPGPError(err))
		bWarn = TRUE;

	if (!bWarn)
		return TRUE;

	dwResult = DialogBoxParam(g_hinst, MAKEINTRESOURCE(IDD_WARN), 
					hwnd, (DLGPROC) WarnYesNoDlgProc, (LPARAM) szMessage);

	bWarn = (dwResult & WARN_BIT) == WARN_BIT;
	bContinue = (dwResult & CONTINUE_BIT) == CONTINUE_BIT;

	err = PGPclPeekClientLibPrefRefs(&prefRef, NULL);
	if (IsPGPError(err))
	{
		PGPclErrorBox(hwnd, err);
		return FALSE;
	}

	PGPSetPrefBoolean(prefRef, nPrefIndex, bWarn);
	PGPclFlushClientLibPrefs(prefRef, NULL);

	return bContinue;
}


/*__Editor_settings____

	Local Variables:
	tab-width: 4
	End:
	vi: ts=4 sw=4
	vim: si
_____________________*/