miniport.cpp

pppoe client

				ulNeeded = pAddrCaps->LineAddressCaps.ulNeededSize + 
													(sizeof(NDIS_TAPI_GET_ADDRESS_CAPS) - sizeof(LINE_ADDRESS_CAPS));
			}
		}
		break;

		// make call
	case OID_TAPI_MAKE_CALL:
		{
			ulNeeded = sizeof(NDIS_TAPI_MAKE_CALL);
			if(ulBufferLength >= ulNeeded)
			{
				PNDIS_TAPI_MAKE_CALL pMakeCall = static_cast<PNDIS_TAPI_MAKE_CALL>(pInformationBuffer);
				pMakeCall->LineCallParams.ulTotalSize = ulBufferLength - 
														(sizeof(NDIS_TAPI_MAKE_CALL) - sizeof(LINE_CALL_PARAMS));

				status = TspiMakeCall(pAdapter,pMakeCall);
			}
		}
		break;

		// pnp power and wake up
	case OID_PNP_QUERY_POWER:
	case OID_PNP_ENABLE_WAKE_UP:
		break;

		// pnp caps
	case OID_PNP_CAPABILITIES:
		{
			ulNeeded = sizeof(NDIS_PNP_CAPABILITIES);
			if(ulBufferLength >= ulNeeded)
			{
				PNDIS_PNP_CAPABILITIES pCaps = static_cast<PNDIS_PNP_CAPABILITIES>(pInformationBuffer);
				NdisZeroMemory(pCaps,sizeof(NDIS_PNP_CAPABILITIES));
			}
		}
		break;

		// tspi initialize
	case OID_TAPI_PROVIDER_INITIALIZE:
		{
			ulNeeded = sizeof(NDIS_TAPI_PROVIDER_INITIALIZE);
			if(ulBufferLength >= ulNeeded)
			{
				PNDIS_TAPI_PROVIDER_INITIALIZE pInit = static_cast<PNDIS_TAPI_PROVIDER_INITIALIZE>(pInformationBuffer);
				
				status = TspiInitialize(pAdapter,pInit);

				ulNeeded = sizeof(NDIS_TAPI_PROVIDER_INITIALIZE);
			}
		}
		break;

		// open
	case OID_TAPI_OPEN:
		{
			ulNeeded = sizeof(NDIS_TAPI_OPEN);
			if(ulBufferLength >= ulNeeded)
			{
				status = TspiOpen(pAdapter,static_cast<PNDIS_TAPI_OPEN>(pInformationBuffer));
			}
		}
		break;

		// version
	case OID_TAPI_NEGOTIATE_EXT_VERSION:
		{
			ulNeeded = sizeof(NDIS_TAPI_NEGOTIATE_EXT_VERSION);
			if(ulBufferLength >= ulNeeded)
			{
				status = TspiNegotiateExtVersion(pAdapter,static_cast<PNDIS_TAPI_NEGOTIATE_EXT_VERSION>(pInformationBuffer));
			}
		}
		break;

	default:
		status = NDIS_STATUS_INVALID_OID;
		break;
	}

	if(status != NDIS_STATUS_INVALID_OID && status != NDIS_STATUS_NOT_SUPPORTED)
	{
		if(ulNeeded > ulBufferLength)
		{
			drvDbgPrint("    buffer to small , need %d,supported %d.\n",ulNeeded,ulBufferLength);

			*pulBytesNeeded = ulNeeded;
			*pulBytesWritten = 0;
			status = NDIS_STATUS_INVALID_LENGTH;
		}
		else
		{
			if(pBuffer)
			{
				NdisMoveMemory(pInformationBuffer,pBuffer,ulNeeded);
				*pulBytesNeeded = 0;
				*pulBytesWritten = ulNeeded;
			}
		}
	}

	return status;
}

// set information
NDIS_STATUS miniportSetInformation(PADAPTER pAdapter,NDIS_OID oid,PVOID  pInbuf,ULONG ulBufLen,
								   PULONG pulBytesRead,PULONG pulBytesNeeded)
{
	ULONG i;
	for(i = 0;i < sizeof(_s_supported) / sizeof(OidArray); i ++)
	{
		if(_s_supported[i].oid == oid)
		{
			drvDbgPrint("oid = %s.\n",_s_supported[i].string);
			break;
		}
	}

	if(i == sizeof(_s_supported) / sizeof(OidArray))
	{
		drvDbgPrint("oid = unknown(0x%x)\n",oid);
	}

	NDIS_STATUS status = NDIS_STATUS_SUCCESS;

	ULONG ulNeeded = 0;

	switch(oid)
	{
		// provider shutdown
	case OID_TAPI_PROVIDER_SHUTDOWN:
		{
			ulNeeded = sizeof(NDIS_TAPI_PROVIDER_SHUTDOWN);
			if(ulBufLen >= ulNeeded)
				status = TspiShutdown(pAdapter,static_cast<PNDIS_TAPI_PROVIDER_SHUTDOWN>(pInbuf),TRUE);
		}
		break;

		// set link info
	case OID_WAN_SET_LINK_INFO:
		{
			ulNeeded = sizeof(NDIS_WAN_SET_LINK_INFO);
			if(ulBufLen >= ulNeeded)
			{
				PNDIS_WAN_SET_LINK_INFO pLinkInfo = static_cast<PNDIS_WAN_SET_LINK_INFO>(pInbuf);

				if(!pLinkInfo || !pAdapter)
				{
					status = NDIS_STATUS_TAPI_INVALPARAM;
					break;
				}

				PCALL_INFO pCall = GetCallPtrFromCallHandle(pAdapter->m_pCallHandleTable,(HDRV_CALL)pLinkInfo->NdisLinkHandle);
				if(!pCall)
				{
					status = NDIS_STATUS_FAILURE;
					break;
				}

				if( (pLinkInfo->SendFramingBits & ~(pAdapter->m_wanInfo.FramingBits))|| 
					(pLinkInfo->RecvFramingBits & ~(pAdapter->m_wanInfo.FramingBits)) )
				{
					status = NDIS_STATUS_FAILURE;
					break;
				}

				if(pLinkInfo->MaxRecvFrameSize)
					pCall->m_wanLinkInfo.MaxRecvFrameSize = pLinkInfo->MaxRecvFrameSize;

				if(pLinkInfo->MaxSendFrameSize)
					pCall->m_wanLinkInfo.MaxSendFrameSize = pLinkInfo->MaxSendFrameSize;

				pCall->m_wanLinkInfo.HeaderPadding = pLinkInfo->HeaderPadding;
				pCall->m_wanLinkInfo.TailPadding = pLinkInfo->TailPadding;
				pCall->m_wanLinkInfo.SendFramingBits = pLinkInfo->SendFramingBits;
				pCall->m_wanLinkInfo.RecvFramingBits = pLinkInfo->RecvFramingBits;
				pCall->m_wanLinkInfo.SendCompressionBits = pLinkInfo->SendCompressionBits;
				pCall->m_wanLinkInfo.RecvCompressionBits = pLinkInfo->RecvCompressionBits;
				pCall->m_wanLinkInfo.RecvACCM = pLinkInfo->RecvACCM;
				pCall->m_wanLinkInfo.SendACCM = pLinkInfo->SendACCM;
			}
		}
		break;

		// answer
	case OID_TAPI_ANSWER:
		{
			ulNeeded = sizeof(NDIS_TAPI_ANSWER);
			if(ulBufLen >= ulNeeded)
			{
				status = TspiAnswer(pAdapter,static_cast<PNDIS_TAPI_ANSWER>(pInbuf));
			}
		}
		break;

		// close
	case OID_TAPI_CLOSE:
		{
			ulNeeded = sizeof(NDIS_TAPI_CLOSE);
			if(ulBufLen >= ulNeeded)
				status = TspiClose(pAdapter,static_cast<PNDIS_TAPI_CLOSE>(pInbuf),TRUE);
		}
		break;

		// close call
	case OID_TAPI_CLOSE_CALL:
		{
			ulNeeded = sizeof(NDIS_TAPI_CLOSE_CALL);
			if(ulBufLen >= ulNeeded)
				status = TspiCloseCall(pAdapter,static_cast<PNDIS_TAPI_CLOSE_CALL>(pInbuf),TRUE);
		}
		break;

		// drop
	case OID_TAPI_DROP:
		{
			ulNeeded = sizeof(NDIS_TAPI_DROP);
			if(ulBufLen >= ulNeeded)
				status = TspiDrop(pAdapter,static_cast<PNDIS_TAPI_DROP>(pInbuf),0);
		}
		break;

		// set default media detection
	case OID_TAPI_SET_DEFAULT_MEDIA_DETECTION:
		{
			ulNeeded = sizeof(NDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION);
			if(ulBufLen >= ulNeeded)
				status = TspiSetDefaultMediaDetection(pAdapter,static_cast<PNDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION>(pInbuf));
		}
		break;

		// set status message
	case OID_TAPI_SET_STATUS_MESSAGES:
		{
			ulNeeded = sizeof(NDIS_TAPI_SET_STATUS_MESSAGES);
			if(ulBufLen >= ulNeeded)
				status = TspiSetStatusMessage(pAdapter,static_cast<PNDIS_TAPI_SET_STATUS_MESSAGES>(pInbuf));
		}
		break;

	case OID_PNP_SET_POWER:
	case OID_PNP_ENABLE_WAKE_UP:
		break;

	default:
		status = NDIS_STATUS_INVALID_OID;
		break;
	}

	if(status != NDIS_STATUS_NOT_SUPPORTED && status != NDIS_STATUS_INVALID_OID)
	{
		if(ulNeeded > ulBufLen)
		{
			drvDbgPrint("    buffer to small,need %d,suplied %d,\n",ulNeeded,ulBufLen);
			*pulBytesNeeded = ulNeeded;
			*pulBytesRead = 0;
			status = NDIS_STATUS_INVALID_LENGTH;
		}
		else
		{
			*pulBytesRead = ulNeeded;
			*pulBytesNeeded = 0;
		}
	}

	return status;
}

// halt
VOID miniportHalt(PADAPTER pAdapter)
{
	DbgEnterFunction();

	if(pAdapter)
	{
		NdisAcquireSpinLock(&pAdapter->m_lockSelf);

		// set halting flags
		pAdapter->m_ulAdapterFlags |= ADAPTER_HALTING;

		NdisReleaseSpinLock(&pAdapter->m_lockSelf);

		NDIS_TAPI_PROVIDER_SHUTDOWN dummy;
		
		// shutdown tspi
		TspiShutdown(pAdapter,&dummy,FALSE);

		// deref adapter
		DereferenceAdapter(pAdapter);

		// wait remove event
		NdisWaitEvent(&pAdapter->m_evRemove,0);

		// check send packets
		while(pAdapter->m_lSendPackets)
			NdisMSleep(1000);

		// free adapter
		FreeAdapter(pAdapter);

		// this should always true
		if(pAdapter == g_pAdapter)
		{
			g_pAdapter = NULL;
		}
	}

	DbgLeaveFunction();
}

// send packet
NDIS_STATUS miniportWanSendPacketHandler(PADAPTER pAdapter,HDRV_CALL hCall,PNDIS_WAN_PACKET pWanPacket)
{
	NDIS_STATUS status = NDIS_STATUS_FAILURE;

	PPPPOE_PACKET pPPPOEPacket = NULL;

	BOOLEAN bDereferenceProviderNeeded = FALSE;

	BOOLEAN bReleaseLockNeeded = TRUE;

	__try
	{
		NdisAcquireSpinLock(&pAdapter->m_lockSelf);

		if(PROVIDER_IN_WRONG_STATE(pAdapter))
			__leave;

		// tspi
		ReferenceTspiProvider(pAdapter,FALSE);

		bDereferenceProviderNeeded = TRUE;

		// get call info
		PCALL_INFO pCall = GetCallPtrFromCallHandle(pAdapter->m_pCallHandleTable,hCall);

		if(!pCall || !pCall->m_pBindContext)
			__leave;

		NdisAcquireSpinLock(&pCall->m_lockSelf);

		// build pppoe packet,here packet with ref count = 1
		pPPPOEPacket = BuildPPPOEPacketFromWanSendPacket(pAdapter,pCall->m_usSessionId,pCall->m_macPeer,
																	   pCall->m_macSelf,pWanPacket);

		if(pPPPOEPacket)
		{
			// ref the packet
			ReferencePacket(pPPPOEPacket);

			// add ref
			ReferenceBind(pCall->m_pBindContext,TRUE);
		}

		NdisReleaseSpinLock(&pCall->m_lockSelf);

		NdisReleaseSpinLock(&pAdapter->m_lockSelf);

		bReleaseLockNeeded = FALSE;

		// send it
		SendPPPOEPacket(pAdapter,pCall->m_pBindContext,pPPPOEPacket);

		// deref the packet
		DereferencePacket(pPPPOEPacket);

		status = NDIS_STATUS_PENDING;
	}
	__except(EXCEPTION_EXECUTE_HANDLER)
	{
	}

	if(bReleaseLockNeeded)
		NdisReleaseSpinLock(&pAdapter->m_lockSelf);

	// dereference tspi
	if(bDereferenceProviderNeeded)
		DereferenceTspiProvider(pAdapter);

	return status;
}

#ifdef NDIS51
// pnp event notify
VOID miniportPnPEventNotify(PADAPTER pAdapter,NDIS_DEVICE_PNP_EVENT PnPEvent,PVOID pInfoBuffer,ULONG ulLength)
{
}

// shut down
VOID miniportShutdown(PADAPTER pAdapter)
{
}
#endif