cllicense.c

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

	// draw 3D shadow
	GetClientRect (hwnd, &rc);
	itop = rc.top;
	ibot = rc.bottom;

	hPen = CreatePen (PS_SOLID, 0, RGB (128, 128, 128));
	hPenOld = SelectObject (hdc, hPen);
	hBrushLit = CreateSolidBrush (RGB (0, 255, 0));

	ileft = rc.left + 4;

	// draw "Knight Rider" LEDs
	if (pps->iStatusDirection) 
	{
		hBrushOld = SelectObject (hdc, hBrushLit);
		for (i=0; i<NUMLEDS; i++) 
		{
			iright = ileft + LEDWIDTH;
	
			if (i == pps->iStatusValue) 
				Rectangle (hdc, ileft, itop, iright, ibot);
			else
			{
				//repaint the existing lit LED if any with standard system color
				RECT rectOfLitLed={ileft, itop, iright, ibot};
				FillRect(hdc, &rectOfLitLed, (HBRUSH)(COLOR_3DFACE+1));

				//now draw the unlit LED
				Rectangle (hdc, ileft+HORSIZEDIF, itop+VERTSIZEDIF, 
						iright-HORSIZEDIF, ibot-VERTSIZEDIF);
			}
	
			ileft += LEDWIDTH + LEDSPACING;
		}
	}

	// draw "progress bar" LEDs
	else 
	{ 
		if (pps->iStatusValue >= 0) 
		{
			hBrushOld = SelectObject (hdc, hBrushLit);

			for (i=0; i<NUMLEDS; i++) 
			{
				iright = ileft + LEDWIDTH;
		
				if (i <= pps->iStatusValue) 
					Rectangle (hdc, ileft, itop, iright, ibot);
			
				ileft += LEDWIDTH + LEDSPACING;
			}
		}
	}

	SelectObject (hdc, hBrushOld);
	SelectObject (hdc, hPenOld);
	DeleteObject (hPen);
	DeleteObject (hBrushLit);
}


static VOID
sInvalidateLEDs (
		HWND		hwnd,
		UINT		idc)
{
	RECT	rc;

	GetWindowRect (GetDlgItem (hwnd, idc), &rc);
	MapWindowPoints (NULL, hwnd, (LPPOINT)&rc, 2);
	InvalidateRect (hwnd, &rc, FALSE);
}

static INT_PTR CALLBACK 
sAuthProgressProc (
		HWND	hwnd, 
		UINT	uMsg, 
		WPARAM	wParam, 
		LPARAM	lParam)
{
	switch (uMsg) {
	case WM_INITDIALOG:
	{
		PROGRESSSTRUCT*	pps	= (PROGRESSSTRUCT*)lParam;
		RECT	rc1, rc2;
		INT		ileft, itop;

		SetWindowLong (hwnd, GWL_USERDATA, lParam);
		pps->iStatusDirection = 1;
		pps->iStatusValue = 0;
		SetTimer (hwnd, PROGRESSTIMERID, LEDTIMERPERIOD, 0);

		GetWindowRect (pps->hwndParent, &rc1);
		GetWindowRect (hwnd, &rc2);
		ileft = (rc1.right-rc1.left)/2 + rc1.left;
		ileft -= (rc2.right-rc2.left)/2;
		itop = (rc1.bottom-rc1.top)/2 + rc1.top;
		itop -= (rc2.bottom-rc2.top)/2;
		SetWindowPos (hwnd, NULL, ileft, itop, 0, 0, SWP_NOZORDER|SWP_NOSIZE);

		ShowWindow (hwnd, SW_SHOW);
		return FALSE;
	}

	case WM_PAINT :
	{
		PROGRESSSTRUCT*	pps	= (PROGRESSSTRUCT*)GetWindowLong (hwnd, GWL_USERDATA);
		sDrawStatus (GetDlgItem (hwnd, IDC_PROGRESS), pps);
		break;
	}

	case WM_TIMER:
	{
		PROGRESSSTRUCT*	pps	= (PROGRESSSTRUCT*)GetWindowLong (hwnd, GWL_USERDATA);
		if (pps->bDestroy)
			EndDialog (hwnd, 0);
		else
		{
			pps->iStatusValue += pps->iStatusDirection;
			if (pps->iStatusValue <= 0)
			{
				pps->iStatusValue = 0;
				pps->iStatusDirection = 1;
			}
			else if (pps->iStatusValue >= NUMLEDS-1)
			{
				pps->iStatusValue = NUMLEDS-1;
				pps->iStatusDirection = -1;
			}
			sInvalidateLEDs (hwnd, IDC_PROGRESS);
		}
		break;
	}

	case WM_DESTROY:
		KillTimer (hwnd, PROGRESSTIMERID);
		break;
	}

	return FALSE;
}

static VOID
sProgressThread (
	void	*pArgs)
{
	PROGRESSSTRUCT*	pps	= (PROGRESSSTRUCT*)pArgs;

	DialogBoxParam (g_hInst, 
			MAKEINTRESOURCE(IDD_AUTHORIZATIONPROGRESS), NULL, 
			sAuthProgressProc, (LPARAM)pps);
}

static VOID
sStartProgress (
	HWND			hdlg,
	PROGRESSSTRUCT*	pps)
{
	DWORD	dwThreadID;

	pps->bDestroy = FALSE;
	pps->hwndParent = hdlg;

	_beginthreadex (NULL, 0,
			(LPTHREAD_START_ROUTINE)sProgressThread,
			(void *)pps, 0, &dwThreadID);
}

static VOID
sStopProgress (
	PROGRESSSTRUCT*	pps)
{
	EnableWindow (pps->hwndParent, TRUE);
	pps->bDestroy = TRUE;
}

static VOID
sAuthorize (HWND hdlg)
{
	char szUser[512];
	char szOrganization[512];
	char szLN[100];
	char szLA[512];
	PGPError err;
	PGPPrefRef prefRef;
	PGPLicenseNumberRef pn;
	PGPLicenseAuthorizationRef la;
	ECL *ecl;
	PGPByte *laout;
	PGPByte lnout[kPGPLicenseNumberMaxSize];
	UINT errLoc;

	errLoc=0;

	ecl=(ECL *)GetWindowLong (hdlg, GWL_USERDATA);

	err = PGPclPeekClientLibPrefRefs (&prefRef, NULL);

	if(IsntPGPError(err))
	{
		GetWindowText(GetDlgItem(hdlg,IDC_LNEDIT1),&(szLN[0]),6);
		GetWindowText(GetDlgItem(hdlg,IDC_LNEDIT2),&(szLN[5]),6);
		GetWindowText(GetDlgItem(hdlg,IDC_LNEDIT3),&(szLN[10]),6);
		GetWindowText(GetDlgItem(hdlg,IDC_LNEDIT4),&(szLN[15]),6);
		GetWindowText(GetDlgItem(hdlg,IDC_LNEDIT5),&(szLN[20]),6);
		GetWindowText(GetDlgItem(hdlg,IDC_LNEDIT6),&(szLN[25]),4);

		err=PGPLNImportBase32(ecl->context,szLN,&pn);

		if(IsntPGPError(err))
		{
			PGPUInt8	uProductID;

			PGPLNGetProductID(ecl->context,pn,&uProductID);
			if (uProductID != PGPPRODUCTID)
				err = kPGPError_LNCorrupt;
		}

		if(IsPGPError(err))
		{
			errLoc=IDS_IMPORTLN;
		}
		else
		{
			UTF8EditGetText(GetDlgItem(hdlg,IDC_LNUSER),szUser,512);
			UTF8EditGetText(GetDlgItem(hdlg,IDC_LNCOMPANY),szOrganization,512);

			if(ecl->bManual)
			{
				GetWindowText(GetDlgItem(hdlg,IDC_MANUALEDIT),szLA,512);

				err=PGPLAImportBlocked(ecl->context,szLA,&la);
			}
			else
			{
				PGPSocketsThreadStorageRef storage;

				err = PGPsdkNetworkLibInit( 0 );

				if(IsntPGPError(err))
				{
					err=PGPSocketsInit();

					if(IsntPGPError(err))
					{
						err=PGPSocketsCreateThreadStorage(&storage);

						if(IsntPGPError(err))
						{
							PROGRESSSTRUCT	ps;
							int				i;

							i=0;
							sStartProgress (hdlg, &ps);

							do 
							{
								err = PGPLACreate( ecl->context, s_pszAuthorizeURLs[i++],
									pn, szUser, szOrganization, &la );

								if (err == kPGPError_NetLARefused)
									break;

								if (err == kPGPError_NetLAMismatch)
									break;

								if (err == kPGPError_NetLATooManyRetrievals)
									break;

							} while ((IsPGPError (err)) && 
									(i < NUM_AUTHORIZE_URLS));
					
							sStopProgress (&ps);

							PGPSocketsDisposeThreadStorage(storage);
						}
					PGPSocketsCleanup();
					}
				PGPsdkNetworkLibCleanup();
				}
			}

			if(IsPGPError(err))
			{
				if(ecl->bManual)
					errLoc=IDS_IMPORTLA;
				else
					errLoc=IDS_OBTAINLA;
			}
			else
			{
				err=PGPLAVerify(ecl->context,pn,la,szUser,szOrganization); 

				if(IsPGPError(err))
				{
					errLoc=IDS_VERIFYLA;
				}
				else
				{
					err=PGPLNExportBase32(ecl->context,pn,NULL,lnout);

					if(IsntPGPError(err))
					{
						err=PGPLAExportBase64(ecl->context,la,&laout);

						if(IsntPGPError(err))
						{
							err=PGPSetPrefString(prefRef, kPGPPrefLicenseName, szUser);

							if(IsntPGPError(err))
							{
								err=PGPSetPrefString(prefRef, kPGPPrefLicenseCompany, szOrganization);

								if(IsntPGPError(err))
								{
									err=PGPSetPrefData (prefRef, 
										kPGPPrefLicenseNumber, strlen(lnout)+1, lnout); // w/ NULL

									if(IsntPGPError(err))
									{
										err=PGPSetPrefData (prefRef, 
											kPGPPrefLicenseAuthorization, strlen(laout)+1,laout); // w/ NULL

										if(IsntPGPError(err))
										{
											err = PGPclFlushClientLibPrefs (prefRef, NULL); 
										}
									}
								}
							}

							PGPFreeData(laout);
						}
					}
				}

 				PGPLAFree(la);
			}

			PGPLNFree(pn);
		}

	}

	if (IsPGPError (err))
	{
		if (errLoc != 0)
		{
			sLicenseErrorBox (hdlg, errLoc, err);
		}
		else
		{
			PGPclErrorBox(hdlg, err);
		}
	}
	else
		EndDialog(hdlg, TRUE);
}


static BOOL WINAPI 
sEnterChangeLicenseDlgProc(HWND hdlg, UINT uMsg, 
							  WPARAM wParam, LPARAM lParam)
{
	switch(uMsg)
	{
		case WM_INITDIALOG:
		{
			ECL *ecl;

			ecl=(ECL *)lParam;
			SetWindowLong(hdlg,GWL_USERDATA,(long)lParam);

			UTF8EditInit (GetDlgItem (hdlg, IDC_LNUSER));
			UTF8EditInit (GetDlgItem (hdlg, IDC_LNCOMPANY));

			ecl->hwndLNEdit[0]=GetDlgItem(hdlg,IDC_LNEDIT1);
			ecl->hwndLNEdit[1]=GetDlgItem(hdlg,IDC_LNEDIT2);
			ecl->hwndLNEdit[2]=GetDlgItem(hdlg,IDC_LNEDIT3);
			ecl->hwndLNEdit[3]=GetDlgItem(hdlg,IDC_LNEDIT4);
			ecl->hwndLNEdit[4]=GetDlgItem(hdlg,IDC_LNEDIT5);
			ecl->hwndLNEdit[5]=GetDlgItem(hdlg,IDC_LNEDIT6);
			ecl->hwndAuthorize=GetDlgItem(hdlg,IDOK);

			SendMessage (ecl->hwndLNEdit[0], EM_SETLIMITTEXT, 5, 0);
			SendMessage (ecl->hwndLNEdit[1], EM_SETLIMITTEXT, 5, 0);
			SendMessage (ecl->hwndLNEdit[2], EM_SETLIMITTEXT, 5, 0);
			SendMessage (ecl->hwndLNEdit[3], EM_SETLIMITTEXT, 5, 0);
			SendMessage (ecl->hwndLNEdit[4], EM_SETLIMITTEXT, 5, 0);
			SendMessage (ecl->hwndLNEdit[5], EM_SETLIMITTEXT, 3, 0);

			ecl->origEditProc=(WNDPROC)SetWindowLong(ecl->hwndLNEdit[0], 
					GWL_WNDPROC, (LONG) sLNMaskedEditWndProc); 
			SetWindowLong(ecl->hwndLNEdit[1], 
					GWL_WNDPROC, (LONG) sLNMaskedEditWndProc); 
			SetWindowLong(ecl->hwndLNEdit[2], 
					GWL_WNDPROC, (LONG) sLNMaskedEditWndProc); 
			SetWindowLong(ecl->hwndLNEdit[3], 
					GWL_WNDPROC, (LONG) sLNMaskedEditWndProc); 
			SetWindowLong(ecl->hwndLNEdit[4], 
					GWL_WNDPROC, (LONG) sLNMaskedEditWndProc); 
			SetWindowLong(ecl->hwndLNEdit[5], 
					GWL_WNDPROC, (LONG) sLNMaskedEditWndProc); 

			sResizeLicenseDialog(hdlg,ecl);	
			return TRUE;
		}
	
		case WM_DESTROY:
		{
			int i;
			ECL *ecl;

			ecl=(ECL *)GetWindowLong (hdlg, GWL_USERDATA);

			for(i=0;i<6;i++)
			{
				SetWindowLong(ecl->hwndLNEdit[i], 
					GWL_WNDPROC, (LONG) ecl->origEditProc); 
			}

			UTF8EditDestroy (GetDlgItem (hdlg, IDC_LNUSER));
			UTF8EditDestroy (GetDlgItem (hdlg, IDC_LNCOMPANY));
			break;
		}

		case WM_HELP:
		case WM_CONTEXTMENU:
		{
			return PGPclHtmlHelp (hdlg, uMsg, wParam, lParam, 
					(char*)kPGPclHelpFile, aEnterLicenseIds);
		}

		case WM_QUIT:
		case WM_CLOSE:
		{
			EndDialog (hdlg, FALSE);
			break;
		} 
/*
		case WM_PAINT:
		{
			HDC	hDC;
			PAINTSTRUCT ps;
			ECL *ecl;
					
			ecl=(ECL *)GetWindowLong (hdlg, GWL_USERDATA);

			hDC = BeginPaint (hdlg, &ps);
			SelectPalette (hDC, ecl->hPalette, FALSE);
			RealizePalette (hDC);

			TransparentBitmap(ecl->hLNKey,72,88,RGB(255,0,0),hDC,15,10);
			
			EndPaint (hdlg, &ps);
			break;
		}
*/		
		case WM_COMMAND:
		{
			switch(wParam)
			{
				case IDC_MANUAL:
				{
					ECL *ecl;
					
					ecl=(ECL *)GetWindowLong (hdlg, GWL_USERDATA);

					ecl->bManual = !(ecl->bManual);

					sResizeLicenseDialog (hdlg, ecl);					
					break;
				}

				case IDOK:
				{
					sAuthorize (hdlg);
					break;
				}
				case IDCANCEL:
				{
					EndDialog (hdlg, FALSE);
					break;
				}

				case IDC_PURCHASE:
				{
					char szWebLink[100];

					Sleep (150);
					LoadString (g_hInst, IDS_PGPSTORE, 
							szWebLink, sizeof (szWebLink));
					PGPclWebBrowse (szWebLink);
					break;
				}
			}
			return TRUE;
		}

	}
	return FALSE;
}

static void 
sTMToSystemTime (
	struct tm*	ptm, 
	SYSTEMTIME* pst) 
{
	pst->wYear			= ptm->tm_year + 1900;
	pst->wMonth			= ptm->tm_mon + 1;
	pst->wDay			= ptm->tm_mday;
	pst->wDayOfWeek		= ptm->tm_wday;
	pst->wHour			= ptm->tm_hour;
	pst->wMinute		= ptm->tm_min;
	pst->wSecond		= ptm->tm_sec;
	pst->wMilliseconds	= 0;
}


static BOOL WINAPI 
sNoLicenseDlgProc(HWND hdlg, UINT uMsg, 
				 WPARAM wParam, LPARAM lParam)
{
	switch(uMsg)
	{
		case WM_INITDIALOG:
		{
			PNL *pnl;

			pnl=(PNL *)lParam;

			if (pnl->szLicenseReq[0])
				ShowWindow (GetDlgItem (hdlg, IDC_LICENSEREQGROUP), SW_SHOW);

			SetWindowText (GetDlgItem(hdlg,IDC_NOTIFYTEXT), pnl->szNotifyText);
			SetWindowText (GetDlgItem(hdlg,IDC_LICENSEREQ), pnl->szLicenseReq);