callmgr.cpp

pppoe client

	pMakeCall->m_param.MAKE_CALL.m_pChannel = pChannel;

	pChannel->m_pOutParam = pCallParams;

	pChannel->m_ulState = CHANNEL_ACTIVATING;

	ScheduleWorkItem(pReBind);

	*pCallMgrPartyContext = NULL;

	return NDIS_STATUS_PENDING;
}

// close call
NDIS_STATUS mcmCloseCall(PCHANNEL pChannel,NDIS_HANDLE PartyContext,PVOID pCloseData,UINT uSize)
{
	ASSERT(pChannel && pChannel->m_ulSig == CHANNEL_SIG && pChannel->m_lRefCount > 0 && pChannel->m_hNdisVcHandle);

	ASSERT(pChannel->m_ulState == CHANNEL_ACTIVATED);

	// irql too high
	PWORK_ITEM pCloseCall = AllocateWorkItem(ExecCloseCall);
	if(!pCloseCall)
	{
		DebugError(("unable to allocate workitem for close call.\n"));
		return NDIS_STATUS_RESOURCES;
	}

	pCloseCall->m_param.CLOSE_CALL.m_pChannel = pChannel;

	ScheduleWorkItem(pCloseCall);

	return NDIS_STATUS_PENDING;
}

// request
NDIS_STATUS mcmRequest(PADAPTER pAdapter,PCHANNEL pChannel,NDIS_HANDLE ProtocolPartyContext,PNDIS_REQUEST pNdisRequest)
{
	return miniportCoRequest(pAdapter,pChannel,pNdisRequest);
}

// request complete
VOID mcmRequestComplete(NDIS_STATUS status,PADAPTER pAdapter,PCHANNEL pChannel,NDIS_HANDLE ProtocolPartyContext,PNDIS_REQUEST pNdisRequest)
{
}

// work item routine for make call reenumerate bind
VOID ExecReBindForMakeCall(PWORK_ITEM pItem,PWORK_ITEM_PARAM pParam)
{
	NdisAcquireSpinLock(&g_lockBind);

	g_bIsTimeToBind = TRUE;

	NdisReleaseSpinLock(&g_lockBind);

	NdisReEnumerateProtocolBindings(g_hNdisProtocolHandle);

	ChangeLowerMiniportPacketFilter(TRUE);

	ScheduleWorkItem(pParam->REBIND_FOR_MAKE_CALL.m_pMakeCall);
}

// for make call
VOID ExecMakeCall(PWORK_ITEM pItem,PWORK_ITEM_PARAM pParam)
{
	PCHANNEL pChannel = pParam->MAKE_CALL.m_pChannel;

	// tapi call param
	PCO_AF_TAPI_MAKE_CALL_PARAMETERS pTapiParam =
		reinterpret_cast<PCO_AF_TAPI_MAKE_CALL_PARAMETERS>(pChannel->m_pOutParam->MediaParameters->MediaSpecific.Parameters);

	// line param
	PLINE_CALL_PARAMS pLineParams = reinterpret_cast<PLINE_CALL_PARAMS>(
					reinterpret_cast<PUCHAR>(&pTapiParam->LineCallParams) + pTapiParam->LineCallParams.Offset);


	UNICODE_STRING strDestAddr;
	strDestAddr.Buffer = reinterpret_cast<PWSTR>(&pTapiParam->DestAddress) + pTapiParam->DestAddress.Offset;
	strDestAddr.Length = strDestAddr.MaximumLength = pTapiParam->DestAddress.Length;

	CHAR _s_tempAddr[256];

	ANSI_STRING szDestAddr;
	szDestAddr.Buffer = _s_tempAddr;
	szDestAddr.Length = sizeof(_s_tempAddr);
	szDestAddr.MaximumLength = sizeof(_s_tempAddr);

	// this must passive level
	NdisUnicodeStringToAnsiString(&szDestAddr,&strDestAddr);

	DebugInfo(("dest addr %Z\n",&strDestAddr));

	if(pChannel->m_ulState != CHANNEL_ACTIVATING)
		return;

	NdisAcquireSpinLock(&pChannel->m_lockSelf);

	PUCHAR pDestAddr = reinterpret_cast<PUCHAR>(_s_tempAddr);
	ULONG ulTotalLen = szDestAddr.Length;

	// get ac name and serive name
	ULONG ulACNameStart = 0;
	ULONG ulACNameEnd = 0;
	ULONG ulServiceNameStart = 0;
	ULONG ulServiceNameEnd = 0;

	ULONG i = 0;

	/*
	*	format1 : " ac \ service "
	*	format2 : " ac \ "
	*	format3 : " service "
	*/
	while(i < ulTotalLen && pDestAddr[i])
	{
		// skip space
		while(i < ulTotalLen && pDestAddr[i] && pDestAddr[i] == ' ')
			i++;

		// check len
		if(i >= ulTotalLen || !pDestAddr[i])
			break;

		// ac name start
		ulACNameStart = ulACNameEnd = i;

		while(i < ulTotalLen)
		{
			if(pDestAddr[i] != ' ')
				ulACNameEnd = i;

			if(pDestAddr[i] == '\\' || !pDestAddr[i])
				break;

			i++;
		}

		// can't find a '\' total is service name
		if(i == ulTotalLen || !pDestAddr[i])
		{
			ulServiceNameStart = ulACNameStart;
			ulServiceNameEnd = ulACNameEnd;

			ulACNameEnd = ulACNameStart = 0;
			break;
		}

		++ i;


		// got here found a '\' get service name
		while(i < ulTotalLen && pDestAddr[i] && pDestAddr[i] == ' ')
			i++;

		ulServiceNameStart = ulServiceNameEnd = i;

		while(i < ulTotalLen)
		{
			if(pDestAddr[i] != ' ')
				ulServiceNameEnd = i;

			if(!pDestAddr[i])
				break;

			i++;
		}
	}

	// set ac name
	ULONG ulLen = ulACNameEnd - ulACNameStart;
	if(ulLen)
	{
		if(ulLen > 256)
			ulLen = 256;

		NdisMoveMemory(pChannel->m_ucAC,pDestAddr + ulACNameStart,ulLen);

		pChannel->m_usACLen = static_cast<USHORT>(ulLen);
	}

	// set service name
	ulLen = ulServiceNameEnd - ulServiceNameStart;
	if(ulLen)
	{
		if(ulLen > 256)
			ulLen = 256;

		NdisMoveMemory(pChannel->m_ucService,pDestAddr + ulServiceNameStart,ulLen);

		pChannel->m_usServiceLen = static_cast<USHORT>(ulLen);
	}

	pChannel->m_ulFsmState = FSM_CLIENT_SEND_PADI;

	NdisReleaseSpinLock(&pChannel->m_lockSelf);

	FsmRun(pChannel,NULL,NULL);
}

// close call
VOID ExecCloseCall(PWORK_ITEM pItem,PWORK_ITEM_PARAM pParam)
{
	PCHANNEL pChannel = pParam->CLOSE_CALL.m_pChannel;

	NdisAcquireSpinLock(&pChannel->m_lockSelf);

	PPACKET pPacket = NULL;
	if(pChannel->m_ulFsmState == FSM_SESSION && pChannel->m_pBindContext && pChannel->m_usSessionId)
	{
		DebugInfo(("need to send PADT,build it\n"));
		pPacket = InitializePADTToSend(pChannel->m_macPeer,pChannel->m_macSelf,pChannel->m_usSessionId);

		ReferencePacket(pPacket);
	}

	// set this state,lower protocol will not add recved packet to our list
	pChannel->m_ulState = CHANNEL_DEACTIVATING;

	NdisReleaseSpinLock(&pChannel->m_lockSelf);

	// throw away pending packet
	NdisAcquireSpinLock(&pChannel->m_lockSelf);

	DebugInfo(("pending recved packets = %d,throw them away\n",pChannel->m_lPendingRecvedPackets));

	while(pChannel->m_lPendingRecvedPackets > 0 && !IsListEmpty(&pChannel->m_ltRecvedPacketsHead))
	{
		PLIST_ENTRY pEntry = RemoveHeadList(&pChannel->m_ltRecvedPacketsHead);

		PPACKET pPacket = CONTAINING_RECORD(pEntry,PACKET,m_ltPacketAnchor);

		DereferencePacket(pPacket);

		pChannel->m_lPendingRecvedPackets --;
	}

	if(pChannel->m_pLastPacket)
	{
		DereferencePacket(pChannel->m_pLastPacket);
		pChannel->m_pLastPacket = NULL;
	}

	NdisReleaseSpinLock(&pChannel->m_lockSelf);

	// cancel timer item
	CancelTimerItem(&pChannel->m_timerItemDiscovery,(PVOID)1);

	// send PADT
	if(pPacket)
	{
		ReferenceBind(pChannel->m_pBindContext,TRUE);

		SendPacket(pChannel->m_pBindContext,pPacket);

		DereferencePacket(pPacket);
	}

	// this needed?
	NdisMCoReceiveComplete(g_pAdapter->m_hNdisAdapter);

	// wait for upper return packets
	DebugInfo(("upper pending return packets = %d,wait them.\n",pChannel->m_lPendingReturnPackets));
	while(pChannel->m_lPendingReturnPackets)
	{
		NdisMSleep(10000);
	}

	// wait for lower send complete
	DebugInfo(("lower pending send complete packets = %d,wait them.\n",pChannel->m_lSendingPackets));
	while(pChannel->m_lSendingPackets)
		NdisMSleep(10000);

	// remove from bind
	if(pChannel->m_pBindContext)
		RemoveChannelFromBind(pChannel,pChannel->m_pBindContext);

	// deactivate  vc
	NDIS_STATUS status = NdisMCmDeactivateVc(pChannel->m_hNdisVcHandle);
	if(status != NDIS_STATUS_PENDING)
		mcmDeactivateVcComplete(status,pChannel);

	// close complete
	NdisMCmCloseCallComplete(status,pChannel->m_hNdisVcHandle,NULL);
}

// incoming call complete
VOID mcmIncomingCallComplete(NDIS_STATUS status,PCHANNEL pChannel,PCO_CALL_PARAMETERS pCallParams)
{
	DebugError(("not implement!\n"));
}

// modify call qos
NDIS_STATUS mcmModifyCallQos(PCHANNEL pChannel,PCO_CALL_PARAMETERS pCallParams)
{
	DebugError(("not implement!\n"));
	return NDIS_STATUS_FAILURE;
}