pgpnetkernelworker.cpp

vc环境下的pgp源码

			// the index.
			g_pConfig->startReading();
			PGPNetHostEntry * host =
				g_pConfig->data().findHostByIndex(queueElem.ipAddress());

			if (host) {
				if (host->childOf != -1) {
					PGPNetHostEntry * gw =
						g_pConfig->data().findHostByIndex(host->childOf);
					// Ask for tunnel SA
					doSARequest(
						gw,
						gw->ipAddress,
						host->ipAddress,
						host->ipMask);
				}
				if (host->hostType == kPGPnetSecureHost) {
					// Ask for transport SA
					doSARequest(host, host->ipAddress, 0, 0);
				}
				if (host->hostType == kPGPnetSecureGateway) {
					// Ask for tunnel SA with itself
					doSARequest(host, 
						host->ipAddress,
						host->ipAddress,
						host->ipMask);
				}
			}
			g_pConfig->stopReading();
			break;
		}
		default:
			break;
		}
	}
	g_KernelQueue.resetEvent();

	debugMsg(__LINE__, "<< processQueue");
}

#ifdef BOGUS_SAREQUEST
const char *        kTestSharedKey          = "test";
PGPUInt32 localIP;

void
CPGPnetKernelWorker::generateBogusSARequest()
{
	PGPikeMTSASetup tS;
	PGPBoolean found = FALSE;
	PGPInt32 i = 0;
	PGPNetHostEntry *host = 0;

	pgpClearMemory( &tS, sizeof( PGPikeMTSASetup ) );

	// fill in the values that I can right now
	tS.approved = TRUE;
	tS.doi = kPGPike_DOI_IPSEC;
	tS.u.ipsec.packetMode = kPGPike_PM_Transport;

	g_pConfig->startReading();

	host = &(g_pConfig->data().config()->pHostList[0]); // just grab the first one

	//struct hostent *hent;
    //hent = gethostbyname("www.nai.com");
	//pgpCopyMemory(hent->h_addr_list[0], &localIP, sizeof(localIP));

	localIP = PGPStorageToUInt32(host->ipAddress);

	tS.ipAddress = localIP;
	/*
	tS.sharedKey = (PGPByte*)host->sharedSecret;
	tS.sharedKeySize = kMaxNetHostSharedSecretLength + 1;
	tS.u.ipsec.idType = (PGPipsecIdentity)PGPStorageToUInt32(host->identityType);
	tS.u.ipsec.idData = host->identity;
	tS.u.ipsec.idDataSize = kMaxNetHostIdentityLength + 1;
	*/

	/* draft-ietf-ipsec-internet-key-00.txt */
	tS.sharedKey			= (PGPByte *) kTestSharedKey;
	tS.sharedKeySize		= strlen(kTestSharedKey);
	tS.u.ipsec.idData		= (PGPByte *)&localIP;
	tS.u.ipsec.idDataSize	= sizeof(localIP);
	tS.u.ipsec.idType		= kPGPike_ID_IPV4_Addr;

	g_pConfig->stopReading();

	g_IKEQueue.startWriting();

	g_IKEQueue.data().push(CPGPnetQueueElement(sizeof(tS),
		&tS, 
		kPGPike_MT_SARequest, 0));

	g_IKEQueue.stopWriting();

	g_IKEQueue.setEvent();
}
#endif

HANDLE __stdcall OpenVxDHandle(
    HANDLE   hEvent                    
    )
{
	typedef DWORD (FAR WINAPI *FUNCPTR)(HANDLE);

    HINSTANCE   hModInst;
    FUNCPTR		lpOpenVxDHandle = NULL;
    HANDLE      hVxdEvent = hEvent;

    hModInst = LoadLibrary( "KERNEL32.DLL" );
    
    if (hModInst)
    {
        lpOpenVxDHandle = (FUNCPTR) GetProcAddress(hModInst, (LPSTR)"OpenVxDHandle");
        if (lpOpenVxDHandle)
        {
            hVxdEvent = (HANDLE) (*lpOpenVxDHandle) (hEvent);
        }
        else
        {
			CPGPnetDebugLog::instance()->dbgOut("KernelWorker\t:\tGetProcAddress FAILED");
        }
        FreeLibrary(hModInst);
    }
    return (hVxdEvent);
}

PGPBoolean
CPGPnetKernelWorker::createKernelEvent(PPGPEVENT_CONTEXT pPgpEvent)
{
    ULONG               dwBytesReturned = 0;
    BOOLEAN             result = FALSE;
    HANDLE              hEvent;

	debugMsg(__LINE__, ">> createKernelEvent");

	pgpClearMemory(pPgpEvent, sizeof(*pPgpEvent));

	if (g_platformID == VER_PLATFORM_WIN32_WINDOWS) {
		static UCHAR        EventName[] = "PgpTstEvent";
		pgpCopyMemory(EventName /*src*/, 
			(PWCHAR)pPgpEvent->EventName /*dest*/,
			sizeof(EventName));
		
		hEvent = CreateEventA(NULL, FALSE, FALSE, (char*)EventName);
		if (hEvent)
		{
			pPgpEvent->Win32EventHandle = hEvent;
			pPgpEvent->DriverEventHandle = OpenVxDHandle(hEvent);
			if (!sendKernelRequest(OID_PGP_EVENT_CREATE, pPgpEvent, 
				sizeof(*pPgpEvent), &dwBytesReturned)
				|| dwBytesReturned != sizeof(*pPgpEvent))
			{
				debugMsg(__LINE__, "createKernelEvent FAILED - Unexpected size=%d or errorCode=%d",
					dwBytesReturned,
					GetLastError());
			}
			else if (pPgpEvent->DriverEventHandle == NULL)
			{
				debugMsg(__LINE__, "OID_PGP_EVENT_CREATE FAILED");
			}
			else
			{
		        result = TRUE;
			}
		}
		else
		{
			debugMsg(__LINE__,  "OID_PGP_EVENT_CREATE FAILED. Not able to create Win32 event.");
		}
	} else if (g_platformID == VER_PLATFORM_WIN32_NT) {
	    static WCHAR        EventName[] = L"PgpTstEvent";
		pgpCopyMemory(EventName /*src*/, 
			(PWCHAR)pPgpEvent->EventName /*dest*/,
			sizeof(EventName));

		debugMsg(__LINE__, "Sending OID_PGP_EVENT_CREATE request");
		if (!sendKernelRequest(OID_PGP_EVENT_CREATE, pPgpEvent, 
			sizeof(*pPgpEvent), &dwBytesReturned)
			|| dwBytesReturned != sizeof(*pPgpEvent))
		{
			debugMsg(__LINE__, "createKernelEvent FAILED - Unexpected size=%d or errorCode=%d\n",
				dwBytesReturned,
				GetLastError());
		}
		else if (pPgpEvent->DriverEventHandle == NULL)
		{
	        debugMsg(__LINE__, "OID_PGP_EVENT_CREATE FAILED\n");
		}
		else
		{
	        hEvent = OpenEventW(SYNCHRONIZE, FALSE, EventName);
			if (hEvent)
			{
	            pPgpEvent->Win32EventHandle = hEvent;
				result = TRUE;
			}
			else
			{
	            debugMsg(__LINE__, "CreateEvent ErrorCode=%d - sending OID_PGP_EVENT_DESTROY", GetLastError());
            
				if (!sendKernelRequest(OID_PGP_EVENT_DESTROY, pPgpEvent, 
					sizeof(*pPgpEvent), &dwBytesReturned)
					|| dwBytesReturned != sizeof(*pPgpEvent))
				{
	                debugMsg(__LINE__, "Unexpected size=%d or errorCode=%d\n",
						dwBytesReturned, GetLastError());
				}
			}
		}
	}

	debugMsg(__LINE__, "<< createKernelEvent(%d)", result);
    return (result);
}

void
CPGPnetKernelWorker::deleteKernelEvent(PPGPEVENT_CONTEXT pPgpEvent)
{
    ULONG	dwBytesReturned = 0;

	debugMsg(__LINE__, ">> deleteKernelEvent");
	if (pPgpEvent) {
		if (g_platformID == VER_PLATFORM_WIN32_NT) {
			if (pPgpEvent->Win32EventHandle) {
				CloseHandle(pPgpEvent->Win32EventHandle);
				pPgpEvent->Win32EventHandle = NULL;
			}
		}
		if (pPgpEvent->DriverEventHandle) {
			sendKernelRequest(OID_PGP_EVENT_DESTROY, 
				pPgpEvent, 
				sizeof(*pPgpEvent), 
				&dwBytesReturned);
			pPgpEvent->DriverEventHandle = NULL;
		}
	}
	debugMsg(__LINE__, "<< deleteKernelEvent");
}

PGPBoolean
CPGPnetKernelWorker::createSharedMemory()
{
    ULONG       dwBytesReturned = 0;
    PVOID       tempPtr = NULL;
    HANDLE      ProcessHandle;

	debugMsg(__LINE__, ">> createSharedMemory");
    ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION,
                                FALSE,
                                GetCurrentProcessId());
 
    if (ProcessHandle == NULL)
    { 
		debugMsg(__LINE__, "OpenProcess failed, ErrorCode=%d",
			GetLastError());
    } 
    else
    {
        tempPtr = static_cast<void*>(ProcessHandle);
		debugMsg(__LINE__, "sending OID_PGP_SHARED_MEM_ALLOC");
        if (!sendKernelRequest(OID_PGP_SHARED_MEM_ALLOC, &tempPtr, 
                      sizeof(tempPtr), &dwBytesReturned)
            || dwBytesReturned != sizeof(tempPtr))
        {
			debugMsg(__LINE__, "Unexpected size=%d or errorCode=%d\n",
				dwBytesReturned, GetLastError());
            tempPtr = NULL;
        }
        CloseHandle(ProcessHandle);
    }
    
	m_pSharedMem = static_cast<PGPByte*>(tempPtr);

	debugMsg(__LINE__, "<< createSharedMemory(%d)", (m_pSharedMem != NULL));
    return (m_pSharedMem != NULL);
}

PGPBoolean
CPGPnetKernelWorker::createMsgQueue()
{
    ULONG       dwBytesReturned = 0;

	PGPMESSAGE_CONTEXT*	userMessageContext;
	
	userMessageContext = (PGPMESSAGE_CONTEXT*)(m_pSharedMem);
	
	debugMsg(__LINE__, ">> createMsgQueue");

	pgpClearMemory(userMessageContext, sizeof(PGPMESSAGE_CONTEXT));
	userMessageContext->header.head = 0;
	userMessageContext->header.tail = 0;
	userMessageContext->header.maxSlots = MaxSlots;
	userMessageContext->header.maxSlotSize = MaxSlotSize;

	debugMsg(__LINE__, "Sending OID_PGP_QUEUE_INITIALIZE");
	if (!sendKernelRequest(OID_PGP_QUEUE_INITIALIZE,
			userMessageContext,
			sizeof(PGPMESSAGE_CONTEXT),
			&dwBytesReturned))	{
		debugMsg(__LINE__, "Error creating message queue: %d",
			GetLastError());
		userMessageContext = NULL;
	}

	m_pMsgQueue = userMessageContext;

	debugMsg(__LINE__, "<< createMsgQueue(%d)", (m_pMsgQueue != 0));
	return (m_pMsgQueue != 0);
}

void
CPGPnetKernelWorker::deleteMsgQueue()
{
	ULONG       dwBytesReturned = 0;

	debugMsg(__LINE__, ">> deleteMsgQueue");
	sendKernelRequest(OID_PGP_QUEUE_RELEASE, NULL, 0, &dwBytesReturned);
	debugMsg(__LINE__, "<< deleteMsgQueue");
}

void
CPGPnetKernelWorker::deleteSharedMemory()
{
	ULONG       dwBytesReturned = 0;

	debugMsg(__LINE__, ">> deleteSharedMemory");
	if (!m_pSharedMem)
		return;

	HANDLE ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION,
		FALSE,
		GetCurrentProcessId());
 
	if (ProcessHandle != NULL) { 
		sendKernelRequest(OID_PGP_SHARED_MEM_FREE,
			&ProcessHandle,
			sizeof(ProcessHandle),
			NULL);
		CloseHandle(ProcessHandle);
	}
	debugMsg(__LINE__, "<< deleteSharedMemory");
}    

void
CPGPnetKernelWorker::processKernelEvent()
{
	PGPMESSAGE_CONTEXT	*	userMessageContext;
	PGPMESSAGE_CONTEXT	*	currentMsg;
	PGPnetMessageHeader *	userMessageHeader;

	debugMsg(__LINE__, ">> processKernelEvent");

	userMessageContext = m_pMsgQueue;
	userMessageHeader = &userMessageContext->header;

	debugMsg(__LINE__, "starting to process kernel events");
	while (userMessageHeader->tail != userMessageHeader->head)
	{
		userMessageHeader->tail++;

		if (userMessageHeader->tail > userMessageHeader->maxSlots)
			userMessageHeader->tail = 1;

		currentMsg = &userMessageContext[userMessageHeader->tail];

		switch (currentMsg->messageType)
		{
		case PGPnetMessageHeaderType:

			debugMsg(__LINE__, "should never get a HeaderType message!");
			break;

		case PGPnetMessageSARequest:
		{
			debugMsg(__LINE__, "Got SARequest");

			PGPnetSARequestMsg *	pSARequestMsg = 0;
			pSARequestMsg = (PGPnetSARequestMsg*)&currentMsg->message;
			if (pSARequestMsg)
				doSARequest(pSARequestMsg->ipAddress, pSARequestMsg->ipAddrStart, pSARequestMsg->ipMaskEnd);
			break;
		}

		case PGPnetMessageSARekey:
		{
			debugMsg(__LINE__, "Got SARekey");

			PGPnetSARekeyMsg *	pSARekeyMsg = 0;
			pSARekeyMsg = (PGPnetSARekeyMsg*)&currentMsg->message;
			if (pSARekeyMsg)
				doSARekey(pSARekeyMsg->spi);
			
			break;

		}
		case PGPnetMessageSADied:
		{
			debugMsg(__LINE__, "Got SADied");

			PGPnetSADiedMsg *	pSADiedMsg = 0;