📄 cllicense.c

📁 PGP8.0源码请认真阅读您的文件包然后写出其具体功能
💻 C
📖 第 1 页 / 共 3 页
字号:
12 3 下一页
/*____________________________________________________________________________
	Copyright (C) 2002 PGP Corporation
	All rights reserved.

	CLlicense.c - code to handle displaying and entering lns

	$Id: CLlicense.c,v 1.47.2.1 2002/11/28 00:03:51 jeffc Exp $
____________________________________________________________________________*/
#include "pgpPFLConfig.h"

// project header files
#include "pgpclx.h"
#include "transbmp.h"
#include "pgpsockets.h"
#include "stdio.h"
#include "pgpBuild.h"
#include "UTF8Edit.h"
#include "pgpUnicodeWin32.h"

#include <process.h>


extern HINSTANCE g_hInst;

#include "..\..\..\libs2\shared\pgplicensenumber.h"
#include "resource.h"

typedef struct _ECL
{
	HWND hwndLNEdit[6];
	HWND hwndLicense;
	HWND hwndAuthorize;
	WNDPROC origEditProc;
	PGPContextRef context;
	BOOL bManual;
	HBITMAP hLNKey;
	HPALETTE hPalette;
} ECL;

typedef struct _PNL
{
	char *szNotifyText;
	char *szLicenseReq;
} PNL;

typedef struct _PROGRESSSTRUCT
{
	HWND	hwndParent;
	BOOL	bDestroy;
	INT		iStatusValue;
	INT		iStatusDirection;

} PROGRESSSTRUCT;

#define VERTICAL_SHIFT		8
#define PROGRESSTIMERID		222
#define LEDTIMERPERIOD		150L
#define NUMLEDS				12
#define LEDSPACING			4
#define LEDWIDTH			9
#define HORSIZEDIF			2
#define VERTSIZEDIF			2
#define TOTALLEDWIDTH		(NUMLEDS*(LEDWIDTH+LEDSPACING+1))

// local globals
static DWORD aNoLicenseIds[] = {			// Help IDs
    IDC_UPGRADE,		IDH_PGPCLLIC_NOLICENSEUPGRADE, 
    0,0 
}; 

static DWORD aLicenseDisplayIds[] = {		// Help IDs
	IDC_LENAME,				IDH_PGPCLLIC_DISPLAYUSERNAME,
	IDC_LEORG,				IDH_PGPCLLIC_DISPLAYCOMPANYNAME,
	IDC_LESEAT,				IDH_PGPCLLIC_DISPLAYSEATS,
	IDC_LEDATE,				IDH_PGPCLLIC_DISPLAYEXPIRATION,
	IDC_CHANGE,				IDH_PGPCLLIC_DISPLAYCHANGE,
    IDC_PURCHASE,			IDH_PGPCLLIC_DISPLAYPURCHASE,
	IDC_ENTERPRISESTATUS,	IDH_PGPCLLIC_DISPLAYENTERPRISE,
	IDC_DESKTOPSTATUS,		IDH_PGPCLLIC_DISPLAYDESKTOP,
	IDC_PGPDISKSTATUS,		IDH_PGPCLLIC_DISPLAYPGPDISK,
	IDC_PGPMAILSTATUS,		IDH_PGPCLLIC_DISPLAYPGPMAIL,
    0,0 
}; 

static DWORD aEnterLicenseIds[] = {			// Help IDs
	IDC_LNUSER,			IDH_PGPCLLIC_ENTERUSERNAME,
	IDC_LNCOMPANY,		IDH_PGPCLLIC_ENTERCOMPANYNAME,
	IDC_LNEDIT1,		IDH_PGPCLLIC_ENTERLN,
	IDC_LNEDIT2,		IDH_PGPCLLIC_ENTERLN,
	IDC_LNEDIT3,		IDH_PGPCLLIC_ENTERLN,
	IDC_LNEDIT4,		IDH_PGPCLLIC_ENTERLN,
	IDC_LNEDIT5,		IDH_PGPCLLIC_ENTERLN,
	IDC_LNEDIT6,		IDH_PGPCLLIC_ENTERLN,
	IDC_MANUALEDIT,		IDH_PGPCLLIC_ENTERMANUALLA,
	IDCANCEL,			IDH_PGPCLLIC_ENTERLATER,
	IDOK,				IDH_PGPCLLIC_ENTERAUTHORIZE,
	IDC_MANUAL,			IDH_PGPCLLIC_ENTERMANUAL,
    IDC_PURCHASE,		IDH_PGPCLLIC_ENTERPURCHASE, 
    0,0 
}; 

///#if PGP_BETA
#if FALSE
#define NUM_AUTHORIZE_URLS	1
static char* s_pszAuthorizeURLs[] = {
		"http://authorize.foo.com/authorize1"};
#else
#define NUM_AUTHORIZE_URLS	3
static char* s_pszAuthorizeURLs[] = {
		"http://authorize1.pgp.com/authorize1",	
		"http://authorize2.pgp.com/authorize1",
		"http://authorize3.pgp.com/authorize1"};
#endif

#define NUMBASE32SYMBOLS 65

static int base32[NUMBASE32SYMBOLS][2]={
	{'A','A'},{'C','C'},{'D','D'},{'E','E'},{'F','F'},{'G','G'},{'H','H'},
	{'J','J'},{'K','K'},{'L','L'},{'M','M'},{'N','N'},{'P','P'},{'Q','Q'},{'R','R'},
	{'T','T'},{'U','U'},{'V','V'},{'W','W'},{'X','X'},{'Y','Y'},{'Z','Z'},{'2','2'},
	{'3','3'},{'4','4'},{'6','6'},{'7','7'},{'9','9'},{'B','B'},{'0','0'},{'1','1'},
	{'5','5'},{'8','8'},{'O','O'},{'I','I'},{'S','S'},
	{'a','A'},{'c','C'},{'d','D'},{'e','E'},{'f','F'},{'g','G'},{'h','H'},
	{'j','J'},{'k','K'},{'l','L'},{'m','M'},{'n','N'},{'p','P'},{'q','Q'},{'r','R'},
	{'t','T'},{'u','U'},{'v','V'},{'w','W'},{'x','X'},{'y','Y'},{'z','Z'},
	{'b','B'},
	{'o','O'},{'i','I'},{'s','S'}};

static void*
sRetrieveClipboardData(HWND hwnd, UINT* pClipboardFormat, 
							DWORD* pDataSize)
{
	void* ReturnValue = 0;
	DWORD dwBufferSize = 0;
	void* pLocalDataBuffer = NULL;
	void* pClipboardBuffer = NULL;
	HANDLE hClipboardData = NULL;

	// See if we can gain access to the clipboard
	if(OpenClipboard(hwnd)) 
	{
		*pClipboardFormat = CF_TEXT;

		hClipboardData = GetClipboardData(*pClipboardFormat);

		if(hClipboardData && IsClipboardFormatAvailable(CF_TEXT))
		{
			pClipboardBuffer = GlobalLock(hClipboardData);
			if(pClipboardBuffer)
			{
				dwBufferSize = lstrlen (pClipboardBuffer) +1;
				pLocalDataBuffer = malloc(dwBufferSize);
				memset(pLocalDataBuffer, '\0', 
					dwBufferSize * sizeof(BYTE));

				if(pLocalDataBuffer)
				{
					*pDataSize = dwBufferSize -1;
					memcpy(pLocalDataBuffer, pClipboardBuffer, dwBufferSize);

					ReturnValue = pLocalDataBuffer;
				}

				GlobalUnlock(hClipboardData);
			}
		}
		CloseClipboard();
	}
	return ReturnValue;
}

static int 
sLicenseChar(int in)
{
	int i,out;

	i=0;

	do
	{
		if(in==base32[i][0])
		{
			out=base32[i][1];
			break;
		}

		i++;
	} while(i<NUMBASE32SYMBOLS);

	if(i==NUMBASE32SYMBOLS)
		return (-1);

	return out;
}

static PGPBoolean 
sCheckLicenseLength(HWND hwnd,ECL *ecl)
{
	PGPBoolean bAuthorize;
	int i;

	bAuthorize=TRUE;

	for(i=0;i<5;i++)
	{
		if(GetWindowTextLength (ecl->hwndLNEdit[i]) != 5)
			bAuthorize=FALSE;
	}

	if(GetWindowTextLength (ecl->hwndLNEdit[5]) != 3)
		bAuthorize=FALSE;

	return bAuthorize;
}

static LRESULT WINAPI 
sLNMaskedEditWndProc(HWND hwnd, UINT msg, 
                     WPARAM wParam, LPARAM lParam)
{
	ECL *ecl;

	ecl=(ECL *)GetWindowLong (GetParent(hwnd), GWL_USERDATA);

    switch(msg)
    {
		case WM_PASTE:
		{
			char *szClip;
			DWORD dwSize,ClipFormat;
			int ClipIndex,PasteIndex;
			char szPaste[29];
			char c;

//			if(hwnd==ecl->hwndLNEdit[0]) //better this way?
			{
				szClip=sRetrieveClipboardData(hwnd,&ClipFormat,&dwSize);

				if(szClip)
				{
					PasteIndex=0;
					memset(szPaste,0x00,29);

					// Filter out bad characters
					for(ClipIndex=0;
							((ClipIndex<(int)dwSize)&&(PasteIndex<28));
							ClipIndex++)
					{
						c=sLicenseChar(szClip[ClipIndex]);
			
						if(c!=(-1))
						{
							szPaste[PasteIndex]=c;
							PasteIndex++;
						}
					}

					// OK now paste em in
					SetWindowText(ecl->hwndLNEdit[5],&(szPaste[25]));
					szPaste[25]=0;
					SetWindowText(ecl->hwndLNEdit[4],&(szPaste[20]));
					szPaste[20]=0;
					SetWindowText(ecl->hwndLNEdit[3],&(szPaste[15]));
					szPaste[15]=0;
					SetWindowText(ecl->hwndLNEdit[2],&(szPaste[10]));
					szPaste[10]=0;
					SetWindowText(ecl->hwndLNEdit[1],&(szPaste[5]));
					szPaste[5]=0;
					SetWindowText(ecl->hwndLNEdit[0],&(szPaste[0]));
					szPaste[0]=0;

					free(szClip);

					EnableWindow(ecl->hwndAuthorize,
							sCheckLicenseLength(hwnd,ecl));
				}

				return 0;
			}
			break;
		}

		case WM_CHAR:
		{
			int index,i;

			if(isprint(wParam))
			{
				wParam=sLicenseChar(wParam);
		
				if(wParam==(-1))
					return 0;
			}

			CallWindowProc (ecl->origEditProc, hwnd, msg, wParam, lParam); 

			EnableWindow(ecl->hwndAuthorize,sCheckLicenseLength(hwnd,ecl));

			for(i=0;i<6;i++)
			{
				if(hwnd==ecl->hwndLNEdit[i])
					index=i;
			}

			if((GetWindowTextLength (hwnd) == 5)&&(index!=5))
				SetFocus(ecl->hwndLNEdit[index+1]);

			return 0;
		}
	}

    //  Pass all non-custom messages to old window proc
    return CallWindowProc(ecl->origEditProc, hwnd, 
                           msg, wParam, lParam ) ;
}

static BOOL 
sResizeLicenseDialog(HWND hdlg,ECL *ecl)
{
	int show;
	BOOL enable;
	int buttbase;
	int purchasebase;
	int windowsize;
	RECT rc,rcclient;
	CHAR sz[16];

	if(!(ecl->bManual))
	{
		LoadString (g_hInst, IDS_LICENSEMANUAL, sz, sizeof(sz));
		SetWindowText(GetDlgItem(hdlg,IDC_MANUAL),sz);
		show=SW_HIDE;
		enable=FALSE;
		GetWindowRect(GetDlgItem(hdlg,IDC_MANUALSTATIC),&rc);
		ScreenToClient(hdlg, (LPPOINT)&rc);
		buttbase=purchasebase=rc.top;
		GetClientRect(GetDlgItem(hdlg,IDC_PURCHASESTATIC),&rc);
		buttbase=buttbase+(rc.bottom-rc.top);
		buttbase=buttbase+10;
		GetClientRect(GetDlgItem(hdlg,IDOK),&rc);
		windowsize=buttbase+(rc.bottom-rc.top)+10;
	}
	else
	{
		LoadString (g_hInst, IDS_LICENSEAUTO, sz, sizeof(sz));
		SetWindowText(GetDlgItem(hdlg,IDC_MANUAL),sz);
		show=SW_SHOW;
		enable=TRUE;
		GetWindowRect(GetDlgItem(hdlg,IDC_MANUALEDIT),&rc);
		ScreenToClient(hdlg, (LPPOINT)&(rc.right));
		buttbase=purchasebase=rc.bottom+10;
		GetClientRect(GetDlgItem(hdlg,IDC_PURCHASESTATIC),&rc);
		buttbase=buttbase+(rc.bottom-rc.top);
		buttbase=buttbase+10;
		GetClientRect(GetDlgItem(hdlg,IDOK),&rc);
		windowsize=buttbase+(rc.bottom-rc.top)+10;
	}

	EnableWindow(GetDlgItem(hdlg,IDC_MANUALSTATIC),enable);
	EnableWindow(GetDlgItem(hdlg,IDC_MANUALEDIT),enable);
	ShowWindow(GetDlgItem(hdlg,IDC_MANUALSTATIC),show);
	ShowWindow(GetDlgItem(hdlg,IDC_MANUALEDIT),show);

	GetWindowRect(GetDlgItem(hdlg,IDC_MANUAL),&rc);
	ScreenToClient(hdlg, (LPPOINT)&rc);
	ScreenToClient(hdlg, (LPPOINT)&(rc.right));
	MoveWindow(GetDlgItem(hdlg,IDC_MANUAL),
		rc.left,buttbase,rc.right-rc.left,rc.bottom-rc.top,TRUE);
	GetWindowRect(GetDlgItem(hdlg,IDOK),&rc);
	ScreenToClient(hdlg, (LPPOINT)&rc);
	ScreenToClient(hdlg, (LPPOINT)&(rc.right));
	MoveWindow(GetDlgItem(hdlg,IDOK),
		rc.left,buttbase,rc.right-rc.left,rc.bottom-rc.top,TRUE);
	GetWindowRect(GetDlgItem(hdlg,IDCANCEL),&rc);
	ScreenToClient(hdlg, (LPPOINT)&rc);
	ScreenToClient(hdlg, (LPPOINT)&(rc.right));
	MoveWindow(GetDlgItem(hdlg,IDCANCEL),
		rc.left,buttbase,rc.right-rc.left,rc.bottom-rc.top,TRUE);
	GetWindowRect(GetDlgItem(hdlg,IDC_PURCHASE),&rc);
	ScreenToClient(hdlg, (LPPOINT)&rc);
	ScreenToClient(hdlg, (LPPOINT)&(rc.right));
	MoveWindow(GetDlgItem(hdlg,IDC_PURCHASE),
		rc.left,buttbase,rc.right-rc.left,rc.bottom-rc.top,TRUE);
	GetWindowRect(GetDlgItem(hdlg,IDC_PURCHASESTATIC),&rc);
	ScreenToClient(hdlg, (LPPOINT)&rc);
	ScreenToClient(hdlg, (LPPOINT)&(rc.right));
	MoveWindow(GetDlgItem(hdlg,IDC_PURCHASESTATIC),
		rc.left,purchasebase,rc.right-rc.left,rc.bottom-rc.top,TRUE);

	GetWindowRect(hdlg,&rc);
	ScreenToClient(hdlg,(LPPOINT)&rc);
	GetClientRect(hdlg,&rcclient);

	// include titlebar
	windowsize=windowsize+(rcclient.top-rc.top);

	GetWindowRect(hdlg,&rc);
	SetWindowPos(hdlg,0,0,0,rc.right-rc.left,windowsize,SWP_NOMOVE|SWP_NOZORDER);
	
	return TRUE;
}

static PGPError
sLicenseErrorBox (
		HWND		hwnd,
		UINT		iLocString,
		PGPError	errIn) 
{
	PGPError	err				= kPGPError_NoErr;
	UINT		uIDS			= 0;
	CHAR		szMessage[768];
	CHAR		szCaption[64];
	UINT		uCaptionID;
	UINT		uCaptionType;
	UINT		uFlags;
	UINT		len;

	LoadString(g_hInst,iLocString,szMessage,768);

	strcat(szMessage,"\n\n");
	len=strlen(szMessage);

	switch (iLocString) {
	case IDS_IMPORTLN :
		switch (errIn) {
		case kPGPError_CorruptData :
		case kPGPError_LNCorrupt :
			uIDS = IDS_LICENSEINVALIDLN;
			uCaptionType = kPGPclErrorType_Alert;
			break;
		}
		break;

	case IDS_IMPORTLA :
		uIDS = IDS_LICENSEMALFORMEDLA;
		uCaptionType = kPGPclErrorType_Alert;
		break;

	case IDS_OBTAINLA :
		if ((errIn >= kPGPError_SocketsNetworkDown) &&
			(errIn < kPGPError_X509AttributeNotSupported))
		{
			// these should all be PGP Sockets errors
			uIDS = IDS_LICENSELANETWORKERROR;
			uCaptionType = kPGPclErrorType_Information;
		}
		else
		{
			switch (errIn) {
			case kPGPError_NetworkOpFailed :
			case kPGPError_NetLARefused :
				uIDS = IDS_LICENSELASERVERERROR;
				uCaptionType = kPGPclErrorType_Information;
				break;

			case kPGPError_NetLAMismatch :
				uIDS = IDS_LICENSELAMISMATCH;
				uCaptionType = kPGPclErrorType_Alert;
				break;

			case kPGPError_NetLATooManyRetrievals :
				uIDS = IDS_LICENSETOOMANYTRIES;
				uCaptionType = kPGPclErrorType_Alert;
				break;
			}
		}
		break;

	case IDS_VERIFYLA :
		uIDS = IDS_LICENSEINVALIDLA;
		uCaptionType = kPGPclErrorType_Alert;
		break;
	}

	if (uIDS != 0)
	{
		LoadString (g_hInst, uIDS, &(szMessage[len]), sizeof(szMessage)-len);
		err = errIn;
	}
	else
	{
		err = PGPclErrorToString (errIn, 
				&(szMessage[len]), sizeof(szMessage)-len, &uCaptionType);
	}

	if (IsPGPError (err)) 
	{
		uFlags = MB_OK|MB_SETFOREGROUND|MB_TASKMODAL|MB_TOPMOST;

		switch (uCaptionType) {
		case kPGPclErrorType_Warning :
			uFlags |= MB_ICONEXCLAMATION;
			uCaptionID = IDS_CAPTIONWARNING;
			break;

		case kPGPclErrorType_Alert :
			uFlags |= MB_ICONEXCLAMATION;
			uCaptionID = IDS_CAPTIONALERT;
			break;

		case kPGPclErrorType_Information :
			uFlags |= MB_ICONINFORMATION;
			uCaptionID = IDS_CAPTIONINFO;
			break;

		default :
			uFlags |= MB_ICONSTOP;
			uCaptionID = IDS_CAPTIONERROR;
			break;
		}

		LoadString (g_hInst, uCaptionID, szCaption, sizeof(szCaption));
		MessageBox (hwnd, szMessage, szCaption, uFlags);
	}

	return errIn;
}

//	____________________________________
//
//  Draw the "LED" progress indicator

static VOID
sDrawStatus (
		HWND			hwnd,
		PROGRESSSTRUCT*	pps)
{
	HBRUSH			hBrushLit, hBrushOld;
	HPEN			hPen, hPenOld;
	INT				i, itop, ibot, ileft, iright;
	HDC				hdc;
	RECT			rc;
	PAINTSTRUCT		ps;

	if (pps->iStatusValue < -1) 
		return;
	
	hdc = BeginPaint (hwnd, &ps);
12 3 下一页
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -