miniport.cpp

来自「pppoe client」· C++ 代码 · 共 663 行 · 第 1/2 页

		uNeeded = sizeof(ulValue);
		break;

	case OID_GEN_CO_VENDOR_DRIVER_VERSION:
		ulValue = 1 << 8;
		pTempBuffer = &ulValue;
		uNeeded = sizeof(ulValue);
		break;

	case OID_CO_TAPI_CM_CAPS:
		{
			PCO_TAPI_CM_CAPS pCallManagerCaps = static_cast<PCO_TAPI_CM_CAPS>(pBuffer);
			uNeeded = sizeof(CO_TAPI_CM_CAPS);

			if(uNeeded <= uBufferLen)
			{
				pCallManagerCaps->ulCoTapiVersion = CO_TAPI_VERSION;
				pCallManagerCaps->ulFlags = 0;
				pCallManagerCaps->ulNumLines = g_pAdapter->m_ulNumChannels;
			}

			DebugInfo(("get call manager caps len = %d,version = 0x%x,lines = 0x%x\n",uBufferLen,CO_TAPI_VERSION,
						g_pAdapter->m_ulNumChannels));
		}
		break;

	case OID_CO_TAPI_LINE_CAPS:
		{
			PCO_TAPI_LINE_CAPS pLineCaps = static_cast<PCO_TAPI_LINE_CAPS>(pBuffer);
			uNeeded = sizeof(CO_TAPI_LINE_CAPS);

			if(uNeeded <= uBufferLen && pLineCaps->ulLineID < g_pAdapter->m_ulNumChannels)
			{
				*puWritten = uNeeded;

				NdisZeroMemory(pLineCaps, uNeeded);

				pLineCaps->LineDevCaps.ulTotalSize = uBufferLen - sizeof(CO_TAPI_LINE_CAPS) + sizeof(LINE_DEV_CAPS);;

				pLineCaps->ulFlags = 0;

				PCHANNEL pChannel = g_pAdapter->m_ppChannels[pLineCaps->ulLineID];

				pLineCaps->LineDevCaps.ulNeededSize = pLineCaps->LineDevCaps.ulUsedSize = sizeof(LINE_DEV_CAPS);
				pLineCaps->LineDevCaps.ulPermanentLineID = pChannel->m_ulLineId;				// id
				pLineCaps->LineDevCaps.ulStringFormat = STRINGFORMAT_UNICODE;					// unicode string
				pLineCaps->LineDevCaps.ulAddressModes = LINEADDRESSMODE_ADDRESSID;				// address id
				pLineCaps->LineDevCaps.ulNumAddresses = 1;										// only one address per channel
				pLineCaps->LineDevCaps.ulBearerModes = pChannel->m_ulBearerMode;				// bearer mode
				pLineCaps->LineDevCaps.ulMaxRate = pChannel->m_ulLinkSpeed;						// link speed
				pLineCaps->LineDevCaps.ulMediaModes = pChannel->m_ulMediaMode;					// media mode
				pLineCaps->LineDevCaps.ulDevCapFlags = LINEDEVCAPFLAGS_CLOSEDROP;				// dev cap
				pLineCaps->LineDevCaps.ulMaxNumActiveCalls = 1;									// only one call
				pLineCaps->LineDevCaps.ulAnswerMode = LINEANSWERMODE_DROP;						// drop this when answer another
				pLineCaps->LineDevCaps.ulRingModes = 1;											// one ring
				pLineCaps->LineDevCaps.ulLineStates = LINEDEVSTATE_RINGING | LINEDEVSTATE_CONNECTED | LINEDEVSTATE_DISCONNECTED |
													  LINEDEVSTATE_OPEN | LINEDEVSTATE_CLOSE;

				pLineCaps->LineDevCaps.ulLineFeatures = LINEFEATURE_MAKECALL;					// can make call

				UINT uInfoOffset = sizeof(pLineCaps->LineDevCaps);
				UINT uInfoLength = sizeof(_s_vendor_desc);

				pLineCaps->LineDevCaps.ulNeededSize += uInfoLength;
				uNeeded += uInfoOffset;
				if(pLineCaps->LineDevCaps.ulNeededSize <= pLineCaps->LineDevCaps.ulTotalSize)
				{
					pLineCaps->LineDevCaps.ulProviderInfoSize = uInfoLength;					// provider info
					pLineCaps->LineDevCaps.ulProviderInfoOffset = uInfoOffset;

					NdisMoveMemory(reinterpret_cast<PUCHAR>(&pLineCaps->LineDevCaps) + uInfoOffset, _s_vendor_desc,uInfoLength);
					pLineCaps->LineDevCaps.ulUsedSize += uInfoLength;
					uInfoOffset += uInfoLength;
				}
			}

			DebugInfo(("get line caps,len = %d,line id = %d,bearer mode = 0x%x,media mode = 0x%x,speed = %d\n",
						uBufferLen,pLineCaps->ulLineID,pLineCaps->LineDevCaps.ulBearerModes,pLineCaps->LineDevCaps.ulMediaModes,
						pLineCaps->LineDevCaps.ulMaxRate));
		}
		break;

	case OID_CO_TAPI_ADDRESS_CAPS:
		{
			PCO_TAPI_ADDRESS_CAPS pAddressCaps = static_cast<PCO_TAPI_ADDRESS_CAPS>(pBuffer);

			uNeeded = sizeof(CO_TAPI_ADDRESS_CAPS);
			if(uNeeded <= uBufferLen && pAddressCaps->ulLineID < g_pAdapter->m_ulNumChannels)
			{
				NdisZeroMemory(pAddressCaps,uNeeded);

				pAddressCaps->LineAddressCaps.ulTotalSize = uBufferLen - sizeof(CO_TAPI_ADDRESS_CAPS) + sizeof(LINE_ADDRESS_CAPS);

				pAddressCaps->ulFlags = 0;

				PCHANNEL pChannel = g_pAdapter->m_ppChannels[pAddressCaps->ulLineID];

				*puWritten = uNeeded;

				pAddressCaps->LineAddressCaps.ulNeededSize = pAddressCaps->LineAddressCaps.ulUsedSize = sizeof(LINE_ADDRESS_CAPS);

				pAddressCaps->LineAddressCaps.ulLineDeviceID = pChannel->m_ulLineId;

				pAddressCaps->LineAddressCaps.ulAddressSharing = LINEADDRESSSHARING_PRIVATE;
				pAddressCaps->LineAddressCaps.ulAddressStates = 0;

				pAddressCaps->LineAddressCaps.ulCallStates = LINECALLSTATE_IDLE | LINECALLSTATE_DIALING | LINECALLSTATE_OFFERING |
															 LINECALLSTATE_CONNECTED | LINECALLSTATE_DISCONNECTED;

				pAddressCaps->LineAddressCaps.ulDialToneModes = LINEDIALTONEMODE_NORMAL;
				pAddressCaps->LineAddressCaps.ulDisconnectModes = LINEDISCONNECTMODE_NORMAL | LINEDISCONNECTMODE_UNKNOWN | 
																  LINEDISCONNECTMODE_BUSY | LINEDISCONNECTMODE_NOANSWER;

				pAddressCaps->LineAddressCaps.ulMaxNumActiveCalls = 1;
				pAddressCaps->LineAddressCaps.ulAddrCapFlags = LINEADDRCAPFLAGS_DIALED;
				pAddressCaps->LineAddressCaps.ulCallFeatures = LINECALLFEATURE_ACCEPT | LINECALLFEATURE_ANSWER | 
															   LINECALLFEATURE_DROP;

				pAddressCaps->LineAddressCaps.ulAddressFeatures = LINEADDRFEATURE_MAKECALL;

				UINT InfoOffset = sizeof(pAddressCaps->LineAddressCaps);
				UINT InfoLength = sizeof(_s_address_name);

				pAddressCaps->LineAddressCaps.ulNeededSize += InfoLength;
				uNeeded += InfoLength;
				if(pAddressCaps->LineAddressCaps.ulNeededSize <= pAddressCaps->LineAddressCaps.ulTotalSize)
				{
					pAddressCaps->LineAddressCaps.ulAddressSize = InfoLength;
					pAddressCaps->LineAddressCaps.ulAddressOffset = InfoOffset;
					PWCHAR pBuffer = reinterpret_cast<PWCHAR>(&pAddressCaps->LineAddressCaps) + InfoOffset / 2;

					NdisMoveMemory(pBuffer,_s_address_name,InfoLength);

					pBuffer[(InfoLength - 4) / 2] = static_cast<WCHAR>(pAddressCaps->ulAddressID) + L'0';

					pAddressCaps->LineAddressCaps.ulUsedSize += InfoLength;
					InfoOffset += InfoLength;

					DebugInfo(("get addr caps,len = %d,line id = %d,addr id = %d,name = %ls\n",
								uBufferLen,pAddressCaps->ulLineID,pAddressCaps->ulAddressID,pBuffer));
				}
			}
		}
		break;

	case OID_802_3_PERMANENT_ADDRESS:
	case OID_802_3_CURRENT_ADDRESS:
	case OID_WAN_PERMANENT_ADDRESS:
	case OID_WAN_CURRENT_ADDRESS:
		pTempBuffer = _s_address;
		uNeeded = sizeof(_s_address);
		DebugInfo(("get eth address 0x%02x-0x%02x-0x%02x-0x%02x-0x%02x-0x%02x\n",
					_s_address[0],_s_address[1],_s_address[2],_s_address[3],_s_address[4],_s_address[5]));
		break;

	case OID_WAN_MEDIUM_SUBTYPE:
		//ulValue = NdisWanMediumIsdn;
		ulValue = NdisWanMediumPppoe;
		pTempBuffer = &ulValue;
		uNeeded = sizeof(ulValue);
		break;

	case OID_WAN_CO_GET_INFO:
		{
			PNDIS_WAN_CO_INFO pInfo = &g_pAdapter->m_wanCoInfo;
			pTempBuffer = pInfo;
			uNeeded = sizeof(g_pAdapter->m_wanCoInfo);

			DebugInfo(("wan co get info len = %d,DesiredACCM = %d,FramingBits = %d,MaxFrameSize = %d,MaxSendWindow = %d\n",
						uBufferLen,pInfo->DesiredACCM,pInfo->FramingBits,pInfo->MaxFrameSize,pInfo->MaxSendWindow));
		}
		break;

	case OID_WAN_CO_GET_LINK_INFO:
		if(!pChannel)
		{
			uNeeded = 0;
			status = NDIS_STATUS_INVALID_DATA;
		}
		else
		{
			PNDIS_WAN_CO_GET_LINK_INFO pInfo = &pChannel->m_wanCoLinkInfo;
			pTempBuffer = pInfo;
			uNeeded = sizeof(NDIS_WAN_CO_GET_LINK_INFO);

			DebugInfo(( "get link info size = %d,MaxRecvFrame = %d,MaxSendFrame = %d,RecvACCM = %d,RecvCompressionBits = %d,"
						"RecvFramingBits = %d,SendACCM= %d,SendCompressionBits = %d,SendFramingBits = %d,pChannel = 0x%x\n",
						uBufferLen,pInfo->MaxRecvFrameSize,pInfo->MaxSendFrameSize,
					    pInfo->RecvACCM,pInfo->RecvCompressionBits,pInfo->RecvFramingBits,pInfo->SendACCM,
					    pInfo->SendCompressionBits,pInfo->SendFramingBits,pChannel));
		}
		break;

	case OID_WAN_LINE_COUNT:
		ulValue = g_pAdapter->m_ulNumChannels;
		pTempBuffer = &ulValue;
		uNeeded = sizeof(ulValue);
		break;

	case OID_PNP_CAPABILITIES:
		PnpCapabilities.WakeUpCapabilities.MinMagicPacketWakeUp = NdisDeviceStateUnspecified;
		PnpCapabilities.WakeUpCapabilities.MinPatternWakeUp = NdisDeviceStateUnspecified;
		PnpCapabilities.WakeUpCapabilities.MinLinkChangeWakeUp = NdisDeviceStateUnspecified;
		pTempBuffer = &PnpCapabilities;
		uNeeded = sizeof(PnpCapabilities);
		break;

	case OID_PNP_QUERY_POWER:
		break;

	default:
		status = NDIS_STATUS_INVALID_OID;
		break;
	}

	if(uNeeded > uBufferLen)
	{
		*puNeeded = uNeeded;
		*puWritten = 0;
		status = NDIS_STATUS_INVALID_LENGTH;
	}
	else
	{
		if(pTempBuffer)
		{
			NdisMoveMemory(pBuffer,pTempBuffer,uNeeded);
		}

		*puNeeded = *puWritten = uNeeded;
	}

	return status;
}

// set quest DISPATCH_LEVEL
NDIS_STATUS SetRequest(PCHANNEL pChannel,NDIS_OID oid,PVOID pBuffer,UINT uBufferLen,PUINT puRead,PUINT puNeeded)
{
	NDIS_STATUS status = NDIS_STATUS_SUCCESS;

	*puRead = *puNeeded = 0;
	switch(oid)
	{
	case OID_GEN_CURRENT_LOOKAHEAD:
		DebugInfo(("set current lookahead.do nothing,total packet is lookahead buffer.\n"));
		*puRead = *puNeeded = sizeof(ULONG);
		break;

	case OID_WAN_CO_SET_LINK_INFO:
		{
			PNDIS_WAN_CO_SET_LINK_INFO pInfo = static_cast<PNDIS_WAN_CO_SET_LINK_INFO>(pBuffer);

			DebugInfo(( "set link info size = %d,MaxRecvFrame = %d,MaxSendFrame = %d,RecvACCM = %d,RecvCompressionBits = %d,"
						"RecvFramingBits = %d,SendACCM= %d,SendCompressionBits = %d,SendFramingBits = %d,pChannel = 0x%x\n",
						uBufferLen,pInfo->MaxRecvFrameSize,pInfo->MaxSendFrameSize,
					    pInfo->RecvACCM,pInfo->RecvCompressionBits,pInfo->RecvFramingBits,pInfo->SendACCM,
					    pInfo->SendCompressionBits,pInfo->SendFramingBits,pChannel));

			if(uBufferLen >= sizeof(NDIS_WAN_CO_SET_LINK_INFO))
			{
				if(pChannel)
				{
					NdisMoveMemory(&pChannel->m_wanCoLinkInfo,pBuffer,sizeof(NDIS_WAN_CO_SET_LINK_INFO));
					*puRead = sizeof(NDIS_WAN_CO_SET_LINK_INFO);
				}
			}
		}

		*puNeeded = sizeof(NDIS_WAN_CO_SET_LINK_INFO);
		break;

	case OID_PNP_SET_POWER:
	case OID_GEN_CO_PROTOCOL_OPTIONS:
		break;

	default:
		status = NDIS_STATUS_INVALID_OID;
		break;
	}

	return status;
}

// send packet
NDIS_STATUS SendPacket(PBIND_CONTEXT pBind,PPACKET pPacket)
{
	NDIS_STATUS status;

	pPacket->m_pBindContext = pBind;

	NdisSend(&status,pBind->m_pOpenBlock,pPacket->m_pNdisPacket);

	if(status != NDIS_STATUS_PENDING)
	{
		protocolSendComplete(pBind,pPacket->m_pNdisPacket,status);
	}

	return status;
}

// broadcast packet
BOOLEAN BroadcastPacket(PPACKET pPacket)
{
	BOOLEAN bRet = FALSE;

	NdisAcquireSpinLock(&g_lockBind);

	PLIST_ENTRY pEntry = g_ltBindsHead.Flink;
	for(; pEntry != &g_ltBindsHead; pEntry = pEntry->Flink)
	{
		bRet = TRUE;
		PBIND_CONTEXT pBind = CONTAINING_RECORD(pEntry,BIND_CONTEXT,m_ltBindAnchor);

		PPACKET pPacketClone = ClonePacket(pPacket);
		if(pPacketClone)
		{
			NdisMoveMemory(pPacketClone->m_pFrame->m_srcMac,pBind->m_macAddress,ETH_ADDR_LEN);

			ReferenceBind(pBind,TRUE);

			ReferencePacket(pPacketClone);

			SendPacket(pBind,pPacketClone);

			DereferencePacket(pPacketClone);
		}
	}

	NdisReleaseSpinLock(&g_lockBind);

	return bRet;
}