/*****************************************************************************
*
* Copyright (c) 1998-1999 Microsoft Corporation
*
* CALL.C - PPTP Call layer functionality
*
* Author: Stan Adermann (stana)
*
* Created: 7/28/1998
*
*****************************************************************************/
#include "raspptp.h"
ULONG CallStateToLineCallStateMap[NUM_CALL_STATES] = {
LINECALLSTATE_UNKNOWN, // STATE_CALL_INVALID
LINECALLSTATE_UNKNOWN, // STATE_CALL_CLOSED
LINECALLSTATE_IDLE, // STATE_CALL_IDLE
LINECALLSTATE_IDLE, // STATE_CALL_OFFHOOK
LINECALLSTATE_OFFERING, // STATE_CALL_OFFERING
LINECALLSTATE_OFFERING, // STATE_CALL_PAC_OFFERING
LINECALLSTATE_OFFERING, // STATE_CALL_PAC_WAIT
LINECALLSTATE_DIALING, // STATE_CALL_DIALING
LINECALLSTATE_PROCEEDING, // STATE_CALL_PROCEEDING
LINECALLSTATE_CONNECTED, // STATE_CALL_ESTABLISHED
LINECALLSTATE_CONNECTED, // STATE_CALL_WAIT_DISCONNECT
LINECALLSTATE_DISCONNECTED, // STATE_CALL_CLEANUP
};
ULONG CallSerialNumber = 0;
VOID
CallpAckTimeout(
IN PVOID SystemSpecific1,
IN PVOID Context,
IN PVOID SystemSpecific2,
IN PVOID SystemSpecific3
);
VOID
CallpCloseTimeout(
IN PVOID SystemSpecific1,
IN PVOID Context,
IN PVOID SystemSpecific2,
IN PVOID SystemSpecific3
);
VOID
CallpDialTimeout(
IN PVOID SystemSpecific1,
IN PVOID Context,
IN PVOID SystemSpecific2,
IN PVOID SystemSpecific3
);
VOID
CallProcessRxPackets(
IN PVOID SystemSpecific1,
IN PVOID Context,
IN PVOID SystemSpecific2,
IN PVOID SystemSpecific3
);
VOID
CallpFinalDeref(IN PCALL_SESSION pCall);
VOID
InitCallLayer()
{
LARGE_INTEGER Time;
NdisGetCurrentSystemTime(&Time);
CallSerialNumber = Time.HighPart;
}
VOID
CallAssignSerialNumber(
PCALL_SESSION pCall
)
{
ASSERT(IS_CALL(pCall));
ASSERT_LOCK_HELD(&pCall->Lock);
pCall->SerialNumber = (USHORT)NdisInterlockedIncrement(&CallSerialNumber);
}
PCALL_SESSION
CallAlloc(PPPTP_ADAPTER pAdapter)
{
PCALL_SESSION pCall;
DEBUGMSG(DBG_FUNC, (DTEXT("+CallAlloc\n")));
pCall = MyMemAlloc(sizeof(CALL_SESSION), TAG_PPTP_CALL);
if (pCall)
{
NdisZeroMemory(pCall, sizeof(CALL_SESSION));
pCall->Signature = TAG_PPTP_CALL;
pCall->pAdapter = pAdapter;
pCall->Close.Checklist = CALL_CLOSE_COMPLETE;
NdisAllocateSpinLock(&pCall->Lock);
NdisInitializeListHead(&pCall->RxPacketList);
NdisInitializeListHead(&pCall->TxPacketList);
NdisMInitializeTimer(&pCall->Close.Timer,
pAdapter->hMiniportAdapter,
CallpCloseTimeout,
pCall);
NdisMInitializeTimer(&pCall->Ack.Timer,
pAdapter->hMiniportAdapter,
CallpAckTimeout,
pCall);
NdisMInitializeTimer(&pCall->DialTimer,
pAdapter->hMiniportAdapter,
CallpDialTimeout,
pCall);
PptpInitializeDpc(&pCall->ReceiveDpc,
pAdapter->hMiniportAdapter,
CallProcessRxPackets,
pCall);
pCall->Ack.Packet.StartBuffer = pCall->Ack.PacketBuffer;
pCall->Ack.Packet.EndBuffer = pCall->Ack.PacketBuffer + sizeof(pCall->Ack.PacketBuffer);
pCall->Ack.Packet.CurrentBuffer = pCall->Ack.Packet.EndBuffer;
pCall->Ack.Packet.CurrentLength = 0;
INIT_REFERENCE_OBJECT(pCall, CallpFinalDeref);
//
// Instead of calling:
// CallSetState(pCall, STATE_CALL_CLOSED, 0, UNLOCKED);
//
// it is better to set the state manually since the former creates an exception to our locking
// scheme (First lock call, then lock adapter) exposing a potential deadlock in CallFindAndLock():
//
// - CallFindAndLock takes the Call lock then the Adapter lock.
// - CallFindAndLock takes the adapter lock then calls CallAlloc which calls
// setcallstate which takes the Call lock.
//
// Although this is a hypothetical scenario since the deadlock will never occur as the new
// call context is not in the adapter's call array yet, but let's be consistent.
//
pCall->State = STATE_CALL_CLOSED;
}
DEBUGMSG(DBG_FUNC|DBG_CALL, (DTEXT("-CallAlloc %08x\n"), pCall));
return pCall;
}
VOID
CallpCleanup(
IN PPPTP_WORK_ITEM pWorkItem
)
{
PCALL_SESSION pCall = pWorkItem->Context;
BOOLEAN SignalLineDown = FALSE;
BOOLEAN Cancelled;
BOOLEAN FreeNow = FALSE;
DEBUGMSG(DBG_FUNC|DBG_CALL, (DTEXT("+CallpCleanup %08x\n"), pCall));
ASSERT(IS_CALL(pCall));
NdisAcquireSpinLock(&pCall->Lock);
// Signal CLEANUP state
if (!(pCall->Close.Checklist&CALL_CLOSE_CLEANUP_STATE))
{
if (pCall->State!=STATE_CALL_CLEANUP)
{
CallSetState(pCall, STATE_CALL_CLEANUP, 0, LOCKED);
}
pCall->Close.Checklist |= CALL_CLOSE_CLEANUP_STATE;
}
if (REFERENCE_COUNT(pCall)>2)
{
DEBUGMSG(DBG_CALL, (DTEXT("CallpCleanup: too many references (%d)\n"), REFERENCE_COUNT(pCall)));
goto ccDone;
}
if (pCall->Close.Expedited)
{
if ((pCall->Close.Checklist&CALL_CLOSE_DROP) &&
!(pCall->Close.Checklist&CALL_CLOSE_DROP_COMPLETE))
{
pCall->Close.Checklist |= CALL_CLOSE_DROP_COMPLETE;
DEBUGMSG(DBG_CALL, (DTEXT("TapiDrop Completed\n")));
NdisReleaseSpinLock(&pCall->Lock);
NdisMSetInformationComplete(pCall->pAdapter->hMiniportAdapter, NDIS_STATUS_SUCCESS);
NdisAcquireSpinLock(&pCall->Lock);
}
if (!(pCall->Close.Checklist&CALL_CLOSE_DISCONNECT))
{
pCall->Close.Checklist |= CALL_CLOSE_DISCONNECT;
if (pCall->pCtl)
{
NdisReleaseSpinLock(&pCall->Lock);
CtlDisconnectCall(pCall);
NdisAcquireSpinLock(&pCall->Lock);
}
}
if (!(pCall->Close.Checklist&CALL_CLOSE_LINE_DOWN) &&
(pCall->Close.Checklist&CALL_CLOSE_DROP_COMPLETE))
{
SignalLineDown = TRUE;
pCall->Close.Checklist |= CALL_CLOSE_LINE_DOWN;
NdisReleaseSpinLock(&pCall->Lock);
TapiLineDown(pCall);
NdisAcquireSpinLock(&pCall->Lock);
}
}
else // !Expedited
{
if (!(pCall->Close.Checklist&CALL_CLOSE_DISCONNECT))
{
pCall->Close.Checklist |= CALL_CLOSE_DISCONNECT;
if (pCall->pCtl)
{
NdisReleaseSpinLock(&pCall->Lock);
CtlDisconnectCall(pCall);
NdisAcquireSpinLock(&pCall->Lock);
}
}
if (!(pCall->Close.Checklist&CALL_CLOSE_DROP))
{
goto ccDone;
}
if (!(pCall->Close.Checklist&CALL_CLOSE_DROP_COMPLETE))
{
pCall->Close.Checklist |= CALL_CLOSE_DROP_COMPLETE;
DEBUGMSG(DBG_CALL, (DTEXT("TapiDrop Completed 2\n")));
NdisReleaseSpinLock(&pCall->Lock);
NdisMSetInformationComplete(pCall->pAdapter->hMiniportAdapter, NDIS_STATUS_SUCCESS);
NdisAcquireSpinLock(&pCall->Lock);
}
if (!(pCall->Close.Checklist&CALL_CLOSE_LINE_DOWN) &&
(pCall->Close.Checklist&CALL_CLOSE_DROP_COMPLETE))
{
DEBUGMSG(DBG_CALL, (DTEXT("Signalling Line Down 2\n")));
pCall->Close.Checklist |= CALL_CLOSE_LINE_DOWN;
NdisReleaseSpinLock(&pCall->Lock);
TapiLineDown(pCall);
NdisAcquireSpinLock(&pCall->Lock);
}
}
if ((pCall->Close.Checklist&CALL_CLOSE_COMPLETE)!=CALL_CLOSE_COMPLETE)
{
goto ccDone;
}
NdisReleaseSpinLock(&pCall->Lock);
NdisMCancelTimer(&pCall->DialTimer, &Cancelled);
NdisMCancelTimer(&pCall->Close.Timer, &Cancelled);
NdisMCancelTimer(&pCall->Ack.Timer, &Cancelled);
NdisAcquireSpinLock(&pCall->Lock);
if (Cancelled)
{
pCall->Ack.PacketQueued = FALSE;
}
//pCall->hTapiLine = 0;
//pCall->DeviceId = 0;
pCall->Close.Expedited = FALSE;
pCall->UseUdp = (PptpTunnelConfig&CONFIG_INITIATE_UDP) ? TRUE : FALSE;
pCall->CallerId[0] = '\0';
NdisZeroMemory(&pCall->Remote, sizeof(pCall->Remote));
pCall->Packet.SequenceNumber = pCall->Packet.AckNumber = 0;
CallSetState(pCall,
#if SINGLE_LINE
STATE_CALL_IDLE,
#else
(pCall->Open ? STATE_CALL_IDLE : STATE_CALL_CLOSED),
#endif
0, LOCKED);
DEBUGMSG(DBG_CALL, (DTEXT("Call:%08x Cleanup complete, state==%d\n"),
pCall, pCall->State));
#if SINGLE_LINE
#if 0 // Keep these structures and reuse the memory. They will be cleaned up in AdapterFree()
if (REFERENCE_COUNT(pCall)==1)
{
CallDetachFromAdapter(pCall);
DEREFERENCE_OBJECT(pCall); // For the initial reference.
FreeNow = TRUE;
}
#endif
#else
if (!pCall->Open && !REFERENCE_COUNT(pCall))
{
FreeNow = TRUE;
}
#endif
ccDone:
pCall->Close.Scheduled = FALSE;
NdisReleaseSpinLock(&pCall->Lock);
DEBUGMSG(DBG_FUNC, (DTEXT("-CallpCleanup Checklist:%08x\n"), pCall->Close.Checklist));
if (FreeNow)
{
CallFree(pCall);
}
}
VOID
CallCleanup(
PCALL_SESSION pCall,
BOOLEAN Locked
)
{
DEBUGMSG(DBG_FUNC, (DTEXT("+CallCleanup\n")));
if (!Locked)
{
NdisAcquireSpinLock(&pCall->Lock);
}
ASSERT_LOCK_HELD(&pCall->Lock);
if (!(pCall->Close.Scheduled) &&
ScheduleWorkItem(CallpCleanup, pCall, NULL, 0)==NDIS_STATUS_SUCCESS)
{
pCall->Close.Scheduled = TRUE;
}
if (!Locked)
{
NdisReleaseSpinLock(&pCall->Lock);
}
DEBUGMSG(DBG_FUNC, (DTEXT("-CallCleanup\n")));
}
// Call lock must be held when calling this.
VOID
CallDetachFromAdapter(PCALL_SESSION pCall)
{
DEBUGMSG(DBG_FUNC, (DTEXT("+CallDetachFromAdapter %08x\n"), pCall));
NdisAcquireSpinLock(&pCall->pAdapter->Lock);
#if SINGLE_LINE
pCall->pAdapter->pCallArray[pCall->DeviceId] = NULL;
#else
pCall->pAdapter->pCallArray[DeviceIdToIndex(pCall->pAdapter, pCall->DeviceId)] = NULL;
#endif
NdisReleaseSpinLock(&pCall->pAdapter->Lock);
pCall->Open = FALSE;
DEBUGMSG(DBG_FUNC, (DTEXT("-CallDetachFromAdapter\n")));
}
VOID
CallFree(PCALL_SESSION pCall)
{
BOOLEAN NotUsed;
if (!pCall)
{
return;
}
DEBUGMSG(DBG_FUNC|DBG_CALL, (DTEXT("+CallFree %p\n"), pCall));
ASSERT(IS_CALL(pCall));
// This duplicates some of the cleanup code, but attempting to stop
// the driver without first stopping tapi can result in an ungraceful
// shutdown.
NdisMCancelTimer(&pCall->DialTimer, &NotUsed);
NdisMCancelTimer(&pCall->Close.Timer, &NotUsed);
NdisMCancelTimer(&pCall->Ack.Timer, &NotUsed);
ASSERT(pCall->Signature==TAG_PPTP_CALL);
ASSERT(IsListEmpty(&pCall->RxPacketList));
ASSERT(IsListEmpty(&pCall->TxPacketList));
NdisFreeSpinLock(&pCall->Lock);
MyMemFree(pCall, sizeof(CALL_SESSION));
DEBUGMSG(DBG_FUNC, (DTEXT("-CallFree\n")));
}
PCALL_SESSION FASTCALL
CallGetCall(
IN PPPTP_ADAPTER pAdapter,
IN ULONG_PTR ulDeviceId
)
{
PCALL_SESSION pCall = NULL;
DEBUGMSG(DBG_FUNC, (DTEXT("+CallGetCall %d\n"), ulDeviceId));
NdisAcquireSpinLock(&pAdapter->Lock);
#if SINGLE_LINE
if (ulDeviceId<pAdapter->Info.Endpoints)
{
pCall = pAdapter->pCallArray[ulDeviceId];
}
#else
if (ulDeviceId>=pAdapter->Tapi.DeviceIdBase &&
ulDeviceId<pAdapter->Tapi.DeviceIdBase+pAdapter->Info.Endpoints)
{
pCall = pAdapter->pCallArray[ulDeviceId - pAdapter->Tapi.DeviceIdBase];
}
#endif
NdisReleaseSpinLock(&pAdapter->Lock);
DEBUGMSG(DBG_FUNC, (DTEXT("-CallGetCall %08x\n"), pCall));
return pCall;
}
BOOLEAN FASTCALL
CallIsValidCall(
IN PPPTP_ADAPTER pAdapter,
IN ULONG_PTR ulDeviceId
)
{
BOOLEAN IsValid = FALSE;
DEBUGMSG(DBG_FUNC, (DTEXT("+CallIsValidCall %d\n"), ulDeviceId));
#if SINGLE_LINE
if (ulDeviceId==pAdapter->Tapi.DeviceIdBase)
{
IsValid = TRUE;
}
#else
if (ulDeviceId>=pAdapter->Tapi.DeviceIdBase &&
ulDeviceId<pAdapter->Tapi.DeviceIdBase+pAdapter->Info.Endpoints)
{
IsValid = TRUE;
}
#endif
DEBUGMSG(DBG_FUNC, (DTEXT("-CallIsValidCall %d\n"), IsValid));
return IsValid;
}
PCALL_SESSION
CallFindAndLock(
IN PPPTP_ADAPTER pAdapter,
IN CALL_STATE State,
IN ULONG Flags
)
{
LONG i, inc;
PCALL_SESSION pCall = NULL;
BOOLEAN fNewCallCreated = FALSE;
DEBUGMSG(DBG_FUNC, (DTEXT("+CallFindAndLock %d\n"), State));
do
{
if (pCall)
{
NdisReleaseSpinLock(&pCall->Lock);
}
pCall = NULL;
// Find a call that matches our state. Start from the beginning (again)
// This shouldn't be an infinite loop because we will either hit the end
// or find a valid call in just a couple tries.
NdisAcquireSpinLock(&pAdapter->Lock);
if (Flags&FIND_INCOMING)
{
// Outgoing calls start top down
inc = -1;
i = pAdapter->Info.Endpoints - 1;
}
else
{
// Incoming calls start bottom up (0)
inc = 1;
i = 0;
}
while ( (Flags&FIND_INCOMING) ? (i>=0) : (i<(signed)pAdapter->Info.Endpoints) )
{
if (!pAdapter->pCallArray[i])
{
if (State==STATE_CALL_IDLE)
{
pCall = CallAlloc(pAdapter);
if (pCall)
{
fNewCallCreated = TRUE;
pCall->DeviceId = (unsigned)i;
break;
}
}
}
else if (pAdapter->pCallArray[i]->State == State)
{
pCall = pAdapter->pCallArray[i];
break;
}
i += inc;
}
NdisReleaseSpinLock(&pAdapter->Lock);
if (pCall)
{
NdisAcquireSpinLock( &pCall->Lock );
if ( fNewCallCreated )
{
CallSetState(pCall, STATE_CALL_IDLE, 0, LOCKED);
NdisAcquireSpinLock( &pAdapter->Lock );
pAdapter->pCallArray[i] = pCall;
NdisReleaseSpinLock( &pAdapter->Lock );
}
}
// The state could change while we were taking the lock, so look again.
} while ( pCall && pCall->State!=State );
DEBUGMSG(DBG_FUNC, (DTEXT("-CallFindAndLock %08x\n"), pCall));
return pCall;
}
NDIS_STATUS
CallEventCallClearRequest(
PCALL_SESSION pCall,
UNALIGNED PPTP_CALL_CLEAR_REQUEST_PACKET *pPacket,
PCONTROL_TUNNEL pCtl
)
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
PPPTP_CALL_DISCONNECT_NOTIFY_PACKET pReply;
DEBUGMSG(DBG_FUNC|DBG_CALL, (DTEXT("+CallEventCallClearRequest\n")));
pReply = CtlAllocPacket(pCall->pCtl, CALL_DISCONNECT_NOTIFY);
// We don't really care if we fail this allocation because PPTP can clean up
// along other avenues, and the cleanup just won't be as pretty.
if (pReply)
{
pReply->CallId = htons(pCall->Packet.CallId);
Status = CtlSend(pCtl, pReply);
}
CallCleanup(pCall, UNLOCKED);
DEBUGMSG(DBG_FUNC|DBG_ERR(Status), (DTEXT("-CallEventCallClearRequest %08x\n"), Status));
return Status;
}
NDIS_STATUS
CallEventCallDisconnectNotify(
PCALL_SESSION pCall,
UNALIGNED PPTP_CALL_DISCONNECT_NOTIFY_PACKET *pPacket
)
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
DEBUGMSG(DBG_FUNC|DBG_CALL, (DTEXT("+CallEventCallDisconnectNotify\n")));
if (IS_CALL(pCall))
{
CallCleanup(pCall, UNLOCKED);
}
DEBUGMSG(DBG_FUNC|DBG_ERR(Status), (DTEXT("-CallEventCallDisconnectNotify %08x\n"), Status));
return Status;
}
NDIS_STATUS
CallEventCallInConnect(
IN PCALL_SESSION pCall,
IN UNALIGNED PPTP_CALL_IN_CONNECT_PACKET *pPacket
)
{
DEBUGMSG(DBG_FUNC, (DTEXT("+CallEventCallInConnect\n")));
ASSERT(IS_CALL(pCall));
NdisAcquireSpinLock(&pCall->Lock);
if (pCall->State==STATE_CALL_PAC_WAIT)
{
pCall->Speed = htonl(pPacket->ConnectSpeed);
CallSetState(pCall, STATE_CALL_ESTABLISHED, htonl(pPacket->ConnectSpeed), LOCKED);
}
NdisReleaseSpinLock(&pCall->Lock);
DEBUGMSG(DBG_FUNC, (DTEXT("-CallEventCallInConnect\n")));
return NDIS_STATUS_SUCCESS;
}
NDIS_STATUS
CallEventCallInRequest(
IN PPPTP_ADAPTER pAdapter,
IN PCONTROL_TUNNEL pCtl,
IN UNALIGNED PPTP_CALL_IN_REQUEST_PACKET *pPacket
)
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
PCALL_SESSION pCall;
DEBUGMSG(DBG_FUNC, (DTEXT("+CallEventCallInRequest\n")));
pCall = CallFindAndLock(pAdapter, STATE_CALL_IDLE, FIND_INCOMING);
if (pCall)
{
NDIS_TAPI_EVENT TapiEvent;
// We have a call in idle state, spinlock acquired
pCall->Inbound = TRUE;
pCall->Remote.CallId = htons(pPacket->CallId);
pCall->Remote.Address = pCtl->Remote.Address;
pCall->Remote.Address.Address[0].Address[0].sin_port = htons(PptpUdpPort);
pCall->SerialNumber = htons(pPacket->SerialNumber);
pCall->Close.Checklist &= ~CALL_CLOSE_DISCONNECT;
CallConnectToCtl(pCall, pCtl, TRUE);
NdisReleaseSpinLock(&pCall->Lock);
pPacket->DialingNumber[MAX_PHONE_NUMBER_LENGTH-1] = '\0';
strcpy(pPacket->DialingNumber, pCall->CallerId);
#if SINGLE_LINE
TapiEvent.htLine = pAdapter->Tapi.hTapiLine;
#else
TapiEvent.htLine = pCall->hTapiLine;
#endif
LOGMSG(FLL_DETAILED, (DTEXT(LOGHDRS"LINE_NEWCALL:%d\n"),
LOGHDR(27, pCall->Remote.Address.Address[0].Address[0].in_addr),
pCall->DeviceId));
TapiEvent.htCall = 0;
TapiEvent.ulMsg = LINE_NEWCALL;
TapiEvent.ulParam1 = pCall->DeviceId;
TapiEvent.ulParam2 = 0;
TapiEvent.ulParam3 = 0;
NdisMIndicateStatus(pCall->pAdapter->hMiniportAdapter,
NDIS_STATUS_TAPI_INDICATION,
&TapiEvent,
sizeof(TapiEvent));
NdisAcquireSpinLock(&pCall->Lock);
pCall->hTapiCall = TapiEvent.ulParam2;
CallSetState(pCall, STATE_CALL_PAC_OFFERING, 0, LOCKED);
NdisReleaseSpinLock(&pCall->Lock);
DEBUGMSG(DBG_TAPI, (DTEXT("LINE_NEWCALL on %d returned htCall %d\n"),
pCall->DeviceId, TapiEvent.ulParam2));
DEBUGMSG(DBG_CALL, (DTEXT("New in call request: Call:%08x Ctl:%08x Addr:%08x\n"),
pCall, pCtl, pCall->Remote.Address.Address[0].Address[0].in_addr));
}
else
{
PPTP_CALL_OUT_REPLY_PACKET *pReply = CtlAllocPacket(pCtl, CALL_IN_REPLY);
if (pReply)
{
pReply->PeerCallId = pPacket->CallId;
pReply->ResultCode = RESULT_CALL_IN_ERROR;
pReply->ErrorCode = PPTP_STATUS_INSUFFICIENT_RESOURCES;
// No call was available. Send a rejection.
Status = CtlSend(pCtl, pReply);
}
}
DEBUGMSG(DBG_FUNC|DBG_ERR(Status), (DTEXT("-CallEventCallInRequest %08x\n"), Status));
return Status;
}
NDIS_STATUS
CallEventCallOutRequest(
IN PPPTP_ADAPTER pAdapter,
IN PCONTROL_TUNNEL pCtl,
IN UNALIGNED PPTP_CALL_OUT_REQUEST_PACKET *pPacket
)
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
PCALL_SESSION pCall;
DEBUGMSG(DBG_FUNC|DBG_CALL, (DTEXT("+CallEventCallOutRequest\n")));
pCall = CallFindAndLock(pAdapter, STATE_CALL_IDLE, FIND_INCOMING);
if (pCall)
{
NDIS_TAPI_EVENT TapiEvent;
// We have a call in idle state, spinlock acquired
pCall->Inbound = TRUE;
pCall->Remote.CallId = htons(pPacket->CallId);
pCall->Remote.Address = pCtl->Remote.Address;
pCall->Remote.Address.Address[0].Address[0].sin_port = htons(PptpUdpPort);
pCall->SerialNumber = htons(pPacket->SerialNumber);
IpAddressToString(htonl(pCtl->Remote.Address.Address[0].Address[0].in_addr), pCall->CallerId);
pCall->Close.Checklist &= ~CALL_CLOSE_DISCONNECT;
CallConnectToCtl(pCall, pCtl, TRUE);
NdisReleaseSpinLock(&pCall->Lock);
#if SINGLE_LINE
TapiEvent.htLine = pAdapter->Tapi.hTapiLine;
#else
TapiEvent.htLine = pCall->hTapiLine;
#endif
LOGMSG(FLL_DETAILED, (DTEXT(LOGHDRS"LINE_NEWCALL:%d\n"),
LOGHDR(27, pCall->Remote.Address.Address[0].Address[0].in_addr),
pCall->DeviceId));
TapiEvent.htCall = 0;
TapiEvent.ulMsg = LINE_NEWCALL;
TapiEvent.ulParam1 = pCall->DeviceId;
TapiEvent.ulParam2 = 0;
TapiEvent.ulParam3 = 0;
NdisMIndicateStatus(pCall->pAdapter->hMiniportAdapter,
NDIS_STATUS_TAPI_INDICATION,
&TapiEvent,
sizeof(TapiEvent));
NdisAcquireSpinLock(&pCall->Lock);
pCall->hTapiCall = TapiEvent.ulParam2;
CallSetState(pCall, STATE_CALL_OFFERING, 0, LOCKED);
NdisReleaseSpinLock(&pCall->Lock);
DEBUGMSG(DBG_TAPI, (DTEXT("LINE_NEWCALL on %d returned htCall %d\n"),
pCall->DeviceId, TapiEvent.ulParam2));
DEBUGMSG(DBG_CALL, (DTEXT("New call request: Call:%08x Ctl:%08x Addr:%hs\n"),
pCall, pCtl, pCall->CallerId));
}
else
{
PPTP_CALL_OUT_REPLY_PACKET *pReply = CtlAllocPacket(pCtl, CALL_OUT_REPLY);
if (pReply)
{
pReply->PeerCallId = pPacket->CallId;
pReply->ResultCode = RESULT_CALL_OUT_ERROR;
pReply->ErrorCode = PPTP_STATUS_INSUFFICIENT_RESOURCES;
// No call was available. Send a rejection.
Status = CtlSend(pCtl, pReply);
}
}
DEBUGMSG(DBG_FUNC|DBG_ERR(Status), (DTEXT("-CallEventCallOutRequest %08x\n"), Status));
return Status;
}
NDIS_STATUS
CallEventCallOutReply(
IN PCALL_SESSION pCall,
IN UNALIGNED PPTP_CALL_OUT_REPLY_PACKET *pPacket
)
{
DEBUGMSG(DBG_FUNC|DBG_CALL, (DTEXT("+CallEventCallOutReply\n")));
OsFileLogFlush(); // After the last connection message do a flush
ASSERT(IS_CALL(pCall));
NdisAcquireSpinLock(&pCall->Lock);
if (pPacket->ResultCode==RESULT_CALL_OUT_CONNECTED)
{
if (pCall->State!=STATE_CALL_PROCEEDING ||
pCall->Packet.CallId!=htons(pPacket->PeerCallId))
{
// Something's wrong. Ignore it.
}
else
{
LOGMSG(FLL_USER, (DTEXT(LOGHDRS"Call Successfully Established\n"),
LOGHDR(25, pCall->pCtl->Remote.Address.Address[0].Address[0].in_addr)));
pCall->Remote.CallId = htons(pPacket->CallId);
pCall->Speed = pCall->pCtl->Speed;
CallSetState(pCall, STATE_CALL_ESTABLISHED, htonl(pPacket->ConnectSpeed), LOCKED);
}
}
else
{
// The call fails for some reason.
CallCleanup(pCall, LOCKED);
}
NdisReleaseSpinLock(&pCall->Lock);
DEBUGMSG(DBG_FUNC, (DTEXT("-CallEventCallOutReply\n")));
return NDIS_STATUS_SUCCESS;
}
NDIS_STATUS
CallEventDisconnect(
PCALL_SESSION pCall
)
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
DEBUGMSG(DBG_FUNC|DBG_CALL, (DTEXT("+CallEventDisconnect %08x\n"), pCall));
ASSERT(IS_CALL(pCall));
CallCleanup(pCall, UNLOCKED);
DEBUGMSG(DBG_FUNC|DBG_ERR(Status), (DTEXT("-CallEventDisconnect %08x\n"), Status));
return Status;
}
NDIS_STATUS
CallEventConnectFailure(
PCALL_SESSION pCall,
NDIS_STATUS FailureReason
)
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
ULONG DisconnectMode;
DEBUGMSG(DBG_FUNC|DBG_CALL, (DTEXT("+CallEventConnectFailure %08x\n"), FailureReason));
ASSERT(IS_CALL(pCall));
switch (FailureReason)
{
case STATUS_CONNECTION_REFUSED:
case STATUS_IO_TIMEOUT:
DisconnectMode = LINEDISCONNECTMODE_NOANSWER;
break;
case STATUS_BAD_NETWORK_PATH:
case STATUS_NETWORK_UNREACHABLE:
case STATUS_HOST_UNREACHABLE:
DisconnectMode = LINEDISCONNECTMODE_UNREACHABLE;
break;
case STATUS_CONNECTION_ABORTED:
DisconnectMode = LINEDISCONNECTMODE_REJECT;
break;
case STATUS_REMOTE_NOT_LISTENING:
DisconnectMode = LINEDISCONNECTMODE_BADADDRESS;
break;
default:
DisconnectMode = LINEDISCONNECTMODE_UNKNOWN;
break;
}
CallSetState(pCall, STATE_CALL_CLEANUP, DisconnectMode, UNLOCKED);
CallCleanup(pCall, UNLOCKED);
DEBUGMSG(DBG_FUNC, (DTEXT("-CallEventConnectFailure\n")));
return Status;
}
NDIS_STATUS
CallEventOutboundTunnelEstablished(
IN PCALL_SESSION pCall,
IN NDIS_STATUS EventStatus
)
{
DEBUGMSG(DBG_FUNC|DBG_CALL, (DTEXT("+CallEventOutboundTunnelEstablished %08x\n"), EventStatus));
ASSERT(IS_CALL(pCall));
DEBUGMSG(DBG_CALL, (DTEXT("Tunnel Established:Inbound:%d State:%d\n"),
pCall->Inbound, pCall->State));
if (!pCall->Inbound && pCall->State==STATE_CALL_DIALING)
{
PPTP_CALL_OUT_REQUEST_PACKET *pPacket = CtlAllocPacket(pCall->pCtl, CALL_OUT_REQUEST);
if (!pPacket)
{
// Fatal for this call.
CallCleanup(pCall, UNLOCKED);
}
else
{
BOOLEAN Cancelled;
USHORT NewCallId;
NdisAcquireSpinLock(&pCall->Lock);
CallSetState(pCall, STATE_CALL_PROCEEDING, 0, LOCKED);
NdisMCancelTimer(&pCall->DialTimer, &Cancelled);
CallAssignSerialNumber(pCall);
NewCallId = (USHORT)((pCall->SerialNumber << CALL_ID_INDEX_BITS) + pCall->DeviceId);
if (pCall->Packet.CallId == NewCallId)
{
// Don't allow a line to have the same CallId twice in a row.
NewCallId += (1<<CALL_ID_INDEX_BITS);
}
pCall->Packet.CallId = NewCallId;
// Our call ID is a function of the serial number (initially random)
// and the DeviceId. This is so we can (CallId&0xfff) on incoming packets
// and instantly have the proper id.
pPacket->CallId = htons(pCall->Packet.CallId);
pPacket->SerialNumber = htons(pCall->SerialNumber);
pPacket->MinimumBPS = htonl(300);
pPacket->MaximumBPS = htonl(100000000);
pPacket->BearerType = htonl(BEARER_ANALOG|BEARER_DIGITAL); // Either
pPacket->FramingType = htonl(FRAMING_ASYNC|FRAMING_SYNC); // Either
pPacket->RecvWindowSize = htons(PPTP_RECV_WINDOW); // ToDo: make configurable
pPacket->ProcessingDelay = 0;
pPacket->PhoneNumberLength = htons((USHORT)strlen(pCall->CallerId));
strcpy(pPacket->PhoneNumber, pCall->CallerId);
// ToDo: subaddress
NdisReleaseSpinLock(&pCall->Lock);
CtlSend(pCall->pCtl, pPacket); // ToDo: return value
}
}
DEBUGMSG(DBG_FUNC, (DTEXT("-CallEventOutboundTunnelEstablished\n")));
return NDIS_STATUS_SUCCESS;
}
NDIS_STATUS
CallReceiveDatagramCallback(
IN PVOID pContext,
IN PTRANSPORT_ADDRESS pAddress,
IN PUCHAR pBuffer,
IN ULONG ulLength
)
{
PPPTP_ADAPTER pAdapter = (PPPTP_ADAPTER)pContext;
PTA_IP_ADDRESS pIpAddress = (PTA_IP_ADDRESS)pAddress;
PCALL_SESSION pCall = NULL;
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
PIP4_HEADER pIp = (PIP4_HEADER)pBuffer;
PGRE_HEADER pGre = (PGRE_HEADER)(pIp + 1);
PVOID pPayload;
LONG GreLength, PayloadLength;
BOOLEAN ReturnBufferNow = TRUE;
PDGRAM_CONTEXT pDgContext = ALIGN_UP_POINTER(pBuffer+ulLength, ULONG_PTR);
DEBUGMSG(DBG_FUNC, (DTEXT("+CallReceiveDatagramCallback\n")));
ASSERT(sizeof(IP4_HEADER)==20);
DEBUGMEM(DBG_PACKET, pBuffer, ulLength, 1);
NdisInterlockedIncrement(&Counters.PacketsReceived);
// First line of defense against bad packets.
if (pIp->HeaderLength*4!=sizeof(IP4_HEADER) ||
pIp->Version!=4 ||
pIp->Protocol!=PptpProtocolNumber ||
ulLength<sizeof(IP4_HEADER)+sizeof(GRE_HEADER)+sizeof(ULONG) ||
pIpAddress->TAAddressCount!=1 ||
pIpAddress->Address[0].AddressLength!=TDI_ADDRESS_LENGTH_IP ||
pIpAddress->Address[0].AddressType!=TDI_ADDRESS_TYPE_IP)
{
DEBUGMSG(DBG_PACKET|DBG_RX, (DTEXT("Rx: IP header invalid\n")));
Status = NDIS_STATUS_FAILURE;
goto crdcDone;
}
GreLength = sizeof(GRE_HEADER) +
(pGre->SequenceNumberPresent ? sizeof(ULONG) : 0) +
(pGre->AckSequenceNumberPresent ? sizeof(ULONG) : 0);
pPayload = (PUCHAR)pGre + GreLength;
PayloadLength = (signed)ulLength - sizeof(IP4_HEADER) - GreLength;
if (htons(pGre->KeyLength)>PayloadLength ||
pGre->StrictSourceRoutePresent ||
pGre->RecursionControl ||
!pGre->KeyPresent ||
pGre->RoutingPresent ||
pGre->ChecksumPresent ||
pGre->Version!=1 ||
pGre->Flags ||
pGre->ProtocolType!=GRE_PROTOCOL_TYPE_NS)
{
DEBUGMSG(DBG_PACKET|DBG_RX, (DTEXT("Rx: GRE header invalid\n")));
DEBUGMEM(DBG_PACKET, pGre, GreLength, 1);
Status = NDIS_STATUS_FAILURE;
goto crdcDone;
}
else
{
// Just in case the datagram is longer than necessary, take only what
// the GRE header indicates.
PayloadLength = htons(pGre->KeyLength);
}
// Demultiplex the packet
pCall = CallGetCall(pAdapter, CallIdToDeviceId(htons(pGre->KeyCallId)));
if (!IS_CALL(pCall))
{
Status = NDIS_STATUS_FAILURE;
goto crdcDone;
}
if(!PptpValidateAddress || pIpAddress->Address[0].Address[0].in_addr == pCall->Remote.Address.Address[0].Address[0].in_addr)
{
pDgContext->pBuffer = pBuffer;
pDgContext->pGreHeader = pGre;
pDgContext->hCtdi = pAdapter->hCtdiDg;
NdisAcquireSpinLock(&pCall->Lock);
pCall->UseUdp = FALSE;
NdisReleaseSpinLock(&pCall->Lock);
if (CallQueueReceivePacket(pCall, pDgContext)==NDIS_STATUS_SUCCESS)
{
REFERENCE_OBJECT(pCall);
ReturnBufferNow = FALSE;
}
}
else
{
Status = NDIS_STATUS_FAILURE;
}
crdcDone:
if (ReturnBufferNow)
{
(void)
CtdiReceiveComplete(pAdapter->hCtdiDg, pBuffer);
}
if (Status!=NDIS_STATUS_SUCCESS)
{
NdisInterlockedIncrement(&Counters.PacketsRejected);
}
DEBUGMSG(DBG_FUNC|DBG_ERR(Status), (DTEXT("-CallReceiveDatagramCallback %08x\n"), Status));
return Status;
}
NDIS_STATUS
CallReceiveUdpCallback(
IN PVOID pContext,
IN PTRANSPORT_ADDRESS pAddress,
IN PUCHAR pBuffer,
IN ULONG ulLength
)
{
PPPTP_ADAPTER pAdapter = (PPPTP_ADAPTER)pContext;
PTA_IP_ADDRESS pIpAddress = (PTA_IP_ADDRESS)pAddress;
PCALL_SESSION pCall = NULL;
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
PGRE_HEADER pGre = (PGRE_HEADER)pBuffer;
PVOID pPayload;
LONG GreLength, PayloadLength;
BOOLEAN ReturnBufferNow = TRUE;
PDGRAM_CONTEXT pDgContext = ALIGN_UP_POINTER(pBuffer+ulLength, ULONG_PTR);
DEBUGMSG(DBG_FUNC, (DTEXT("+CallReceiveDatagramCallback\n")));
DEBUGMEM(DBG_PACKET, pBuffer, ulLength, 1);
NdisInterlockedIncrement(&Counters.PacketsReceived);
// First line of defense against bad packets.
if (pIpAddress->Address[0].Address[0].sin_port!=ntohs(PptpProtocolNumber) ||
ulLength<sizeof(GRE_HEADER)+sizeof(ULONG) ||
pIpAddress->TAAddressCount!=1 ||
pIpAddress->Address[0].AddressLength!=TDI_ADDRESS_LENGTH_IP ||
pIpAddress->Address[0].AddressType!=TDI_ADDRESS_TYPE_IP)
{
DEBUGMSG(DBG_PACKET|DBG_RX, (DTEXT("Rx: GRE header invalid\n")));
Status = NDIS_STATUS_FAILURE;
goto crdcDone;
}
GreLength = sizeof(GRE_HEADER) +
(pGre->SequenceNumberPresent ? sizeof(ULONG) : 0) +
(pGre->AckSequenceNumberPresent ? sizeof(ULONG) : 0);
pPayload = (PUCHAR)pGre + GreLength;
PayloadLength = (signed)ulLength - GreLength;
if (htons(pGre->KeyLength)>PayloadLength ||
pGre->StrictSourceRoutePresent ||
pGre->RecursionControl ||
!pGre->KeyPresent ||
pGre->RoutingPresent ||
pGre->ChecksumPresent ||
pGre->Version!=1 ||
pGre->Flags ||
pGre->ProtocolType!=GRE_PROTOCOL_TYPE_NS)
{
DEBUGMSG(DBG_PACKET|DBG_RX, (DTEXT("Rx: GRE header invalid\n")));
DEBUGMEM(DBG_PACKET, pGre, GreLength, 1);
Status = NDIS_STATUS_FAILURE;
goto crdcDone;
}
else
{
// Just in case the datagram is longer than necessary, take only what
// the GRE header indicates.
PayloadLength = htons(pGre->KeyLength);
}
// Demultiplex the packet
pCall = CallGetCall(pAdapter, CallIdToDeviceId(htons(pGre->KeyCallId)));
if (!IS_CALL(pCall))
{
Status = NDIS_STATUS_FAILURE;
goto crdcDone;
}
pDgContext->pBuffer = pBuffer;
pDgContext->pGreHeader = pGre;
pDgContext->hCtdi = pAdapter->hCtdiUdp;
NdisAcquireSpinLock(&pCall->Lock);
pCall->UseUdp = TRUE;
NdisReleaseSpinLock(&pCall->Lock);
if (CallQueueReceivePacket(pCall, pDgContext)==NDIS_STATUS_SUCCESS)
{
REFERENCE_OBJECT(pCall);
ReturnBufferNow = FALSE;
}
crdcDone:
if (ReturnBufferNow)
{
(void)
CtdiReceiveComplete(pAdapter->hCtdiUdp, pBuffer);
}
if (Status!=NDIS_STATUS_SUCCESS)
{
NdisInterlockedIncrement(&Counters.PacketsRejected);
// ToDo: cleanup?
}
DEBUGMSG(DBG_FUNC|DBG_ERR(Status), (DTEXT("-CallReceiveDatagramCallback %08x\n"), Status));
return Status;
}
BOOLEAN
CallConnectToCtl(
IN PCALL_SESSION pCall,
IN PCONTROL_TUNNEL pCtl,
IN BOOLEAN CallLocked
)
{
BOOLEAN Connected = FALSE;
DEBUGMSG(DBG_FUNC, (DTEXT("+CallConnectCtl\n")));
if (!CallLocked)
{
NdisAcquireSpinLock(&pCall->Lock);
}
ASSERT_LOCK_HELD(&pCall->Lock);
NdisAcquireSpinLock(&pCall->pAdapter->Lock);
if (!pCall->pCtl)
{
pCall->pCtl = pCtl;
InsertTailList(&pCtl->CallList, &pCall->ListEntry);
Connected = TRUE;
REFERENCE_OBJECT(pCtl); // Pair in CallDisconnectFromCtl
}
NdisReleaseSpinLock(&pCall->pAdapter->Lock);
if (!CallLocked)
{
NdisReleaseSpinLock(&pCall->Lock);
}
DEBUGMSG(DBG_FUNC, (DTEXT("-CallConnectCtl %d\n"), Connected));
return Connected;
}
VOID
CallDisconnectFromCtl(
IN PCALL_SESSION pCall,
IN PCONTROL_TUNNEL pCtl
)
{
BOOLEAN Deref = FALSE;
DEBUGMSG(DBG_FUNC, (DTEXT("+CallDisconnectFromCtl\n")));
NdisAcquireSpinLock(&pCall->Lock);
NdisAcquireSpinLock(&pCall->pAdapter->Lock);
ASSERT(pCall->pCtl==pCtl);
if (pCall->pCtl==pCtl)
{
pCall->pCtl = NULL;
RemoveEntryList(&pCall->ListEntry);
Deref = TRUE;
}
NdisReleaseSpinLock(&pCall->pAdapter->Lock);
NdisReleaseSpinLock(&pCall->Lock);
if (Deref)
{
DEREFERENCE_OBJECT(pCtl);
}
DEBUGMSG(DBG_FUNC, (DTEXT("-CallDisconnectFromCtl\n")));
}
NDIS_STATUS
CallSetLinkInfo(
PPPTP_ADAPTER pAdapter,
IN PNDIS_WAN_SET_LINK_INFO pRequest
)
{
PCALL_SESSION pCall;
PCONTROL_TUNNEL pCtl;
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
PPPTP_SET_LINK_INFO_PACKET pPacket;
DEBUGMSG(DBG_FUNC, (DTEXT("+CallSetLinkInfo\n")));
// Verify the ID
pCall = CallGetCall(pAdapter, LinkHandleToId(pRequest->NdisLinkHandle));
if (!pCall)
{
Status = NDIS_STATUS_FAILURE;
goto csliDone;
}
ASSERT(IS_CALL(pCall));
NdisAcquireSpinLock(&pCall->Lock);
pCall->WanLinkInfo = *pRequest;
#if 0
DBG_X(DBG_NDIS, pCall->WanLinkInfo.MaxSendFrameSize);
DBG_X(DBG_NDIS, pCall->WanLinkInfo.MaxRecvFrameSize);
DBG_X(DBG_NDIS, pCall->WanLinkInfo.HeaderPadding);
DBG_X(DBG_NDIS, pCall->WanLinkInfo.TailPadding);
DBG_X(DBG_NDIS, pCall->WanLinkInfo.SendACCM);
DBG_X(DBG_NDIS, pCall->WanLinkInfo.RecvACCM);
#endif
pCtl = pCall->pCtl;
NdisReleaseSpinLock(&pCall->Lock);
// Report the new ACCMs to the peer.
pPacket = CtlAllocPacket(pCtl, SET_LINK_INFO);
if (!pPacket)
{
Status = NDIS_STATUS_RESOURCES;
}
else
{
pPacket->PeerCallId = ntohs(pCall->Remote.CallId);
pPacket->SendAccm = ntohl(pCall->WanLinkInfo.SendACCM);
pPacket->RecvAccm = ntohl(pCall->WanLinkInfo.RecvACCM);
Status = CtlSend(pCtl, pPacket);
}
csliDone:
DEBUGMSG(DBG_FUNC|DBG_ERR(Status), (DTEXT("-CallSetLinkInfo %08x\n"), Status));
return Status;
}
VOID
CallSetState(
IN PCALL_SESSION pCall,
IN CALL_STATE State,
IN ULONG_PTR StateParam,
IN BOOLEAN Locked
)
{
ULONG OldLineCallState = CallGetLineCallState(pCall->State);
ULONG NewLineCallState = CallGetLineCallState(State);
DEBUGMSG(DBG_FUNC, (DTEXT("+CallSetState %d\n"), State));
if (State!=pCall->State)
{
LOGMSG(FLL_DETAILED, (DTEXT(LOGHDRS"Call(%d) state change. Old:%d New:%d\n"),
LOGHDR(26, pCall->Remote.Address.Address[0].Address[0].in_addr),
pCall->DeviceId, pCall->State, State));
}
ASSERT(IS_CALL(pCall));
if (!Locked)
{
NdisAcquireSpinLock(&pCall->Lock);
}
ASSERT_LOCK_HELD(&pCall->Lock);
pCall->State = State;
if (!Locked)
{
NdisReleaseSpinLock(&pCall->Lock);
}
if (OldLineCallState!=NewLineCallState &&
pCall->hTapiCall)
{
NDIS_TAPI_EVENT TapiEvent;
DEBUGMSG(DBG_TAPI|DBG_NDIS, (DTEXT("PPTP: Indicating new LINE_CALLSTATE %x\n"), NewLineCallState));
#if SINGLE_LINE
TapiEvent.htLine = pCall->pAdapter->Tapi.hTapiLine;
#else
TapiEvent.htLine = pCall->hTapiLine;
#endif
TapiEvent.htCall = pCall->hTapiCall;
TapiEvent.ulMsg = LINE_CALLSTATE;
TapiEvent.ulParam1 = NewLineCallState;
TapiEvent.ulParam2 = StateParam;
TapiEvent.ulParam3 = LINEMEDIAMODE_DIGITALDATA; // ToDo: is this required?
if (Locked)
{
NdisReleaseSpinLock(&pCall->Lock);
}
NdisMIndicateStatus(pCall->pAdapter->hMiniportAdapter,
NDIS_STATUS_TAPI_INDICATION,
&TapiEvent,
sizeof(TapiEvent));
if (Locked)
{
NdisAcquireSpinLock(&pCall->Lock);
}
}
DEBUGMSG(DBG_FUNC, (DTEXT("-CallSetState\n")));
}
GRE_HEADER DefaultGreHeader = {
0, // Recursion control
0, // Strict source route present
0, // Sequence Number present
1, // Key present
0, // Routing present
0, // Checksum present
1, // Version
0, // Flags
0, // Ack present
GRE_PROTOCOL_TYPE_NS
};
VOID
CallpSendCompleteDeferred(
IN PPPTP_WORK_ITEM pWorkItem
)
{
PCALL_SESSION pCall = pWorkItem->Context;
PNDIS_WAN_PACKET pPacket = pWorkItem->pBuffer;
NDIS_STATUS Result = pWorkItem->Length;
DEBUGMSG(DBG_FUNC, (DTEXT("+CallpSendCompleteDeferred\n")));
NdisMWanSendComplete(pCall->pAdapter->hMiniportAdapter,
pPacket,
Result);
DEREFERENCE_OBJECT(pCall);
DEBUGMSG(DBG_FUNC, (DTEXT("-CallpSendCompleteDeferred\n")));
}
VOID
CallpSendComplete(
IN PVOID pContext,
IN PVOID pDatagramContext,
IN PUCHAR pBuffer,
IN NDIS_STATUS Result
)
{
PCALL_SESSION pCall = pContext;
PNDIS_WAN_PACKET pPacket = pDatagramContext;
DEBUGMSG(DBG_FUNC|DBG_TX, (DTEXT("+CallpSendComplete pCall=%x, pPacket=%x, Result=%x\n"), pCall, pPacket, Result));
ASSERT(IS_CALL(pCall));
if (Result!=NDIS_STATUS_SUCCESS)
{
DEBUGMSG(DBG_ERROR, (DTEXT("Failed to send datagram %08x\n"), Result));
NdisInterlockedIncrement(&Counters.PacketsSentError);
}
if (pPacket==&pCall->Ack.Packet)
{
NdisAcquireSpinLock(&pCall->Lock);
pCall->Ack.PacketQueued = FALSE;
NdisReleaseSpinLock(&pCall->Lock);
}
else
{
// When we complet packets immediately, we can get into trouble if a
// packet has recursed. We need a way to short-circuit a recursing
// completion so we don't blow the stack.
// We store a count of times we've completed a packet in the same
// context and defer to a thread after a certain number of trips through.
if ((NdisInterlockedIncrement(&pCall->SendCompleteRecursion)<PptpSendRecursionLimit) ||
ScheduleWorkItem(CallpSendCompleteDeferred, pCall, pPacket, Result)!=NDIS_STATUS_SUCCESS)
{
NdisMWanSendComplete(pCall->pAdapter->hMiniportAdapter,
pPacket,
Result);
DEREFERENCE_OBJECT(pCall);
}
NdisInterlockedDecrement(&pCall->SendCompleteRecursion);
}
DEBUGMSG(DBG_FUNC, (DTEXT("-CallpSendComplete\n")));
}
#define TRANSMIT_SEND_SEQ 1
#define TRANSMIT_SEND_ACK 2
#define TRANSMIT_MASK 0x3
ULONG GreSize[4] = {
sizeof(GRE_HEADER),
sizeof(GRE_HEADER) + sizeof(ULONG),
sizeof(GRE_HEADER) + sizeof(ULONG),
sizeof(GRE_HEADER) + sizeof(ULONG) * 2
};
NDIS_STATUS
CallTransmitPacket(
PCALL_SESSION pCall,
PNDIS_WAN_PACKET pPacket,
ULONG Flags,
ULONG SequenceNumber,
ULONG Ack
)
{
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
ULONG Length;
PULONG pSequence, pAck;
PGRE_HEADER pGreHeader;
DEBUGMSG(DBG_FUNC, (DTEXT("+CallTransmitPacket\n")));
if (!IS_CALL(pCall) || pCall->State!=STATE_CALL_ESTABLISHED)
{
goto ctpDone;
}
Length = GreSize[Flags&TRANSMIT_MASK];
pGreHeader = (PGRE_HEADER) (pPacket->CurrentBuffer - Length);
pSequence = pAck = (PULONG)(pGreHeader + 1);
*pGreHeader = DefaultGreHeader;
if (Flags&TRANSMIT_SEND_SEQ)
{
pGreHeader->SequenceNumberPresent = 1;
*pSequence = htonl(SequenceNumber);
pAck++;
}
pGreHeader->KeyLength = htons((USHORT)pPacket->CurrentLength);
pGreHeader->KeyCallId = htons(pCall->Remote.CallId);
if (Flags&TRANSMIT_SEND_ACK)
{
pGreHeader->AckSequenceNumberPresent = 1;
*pAck = htonl(Ack);
}
Status = CtdiSendDatagram((pCall->UseUdp ? pCall->pAdapter->hCtdiUdp : pCall->pAdapter->hCtdiDg),
CallpSendComplete,
pCall,
pPacket,
(PTRANSPORT_ADDRESS)&pCall->Remote.Address,
(PVOID)pGreHeader,
pPacket->CurrentLength + Length);
NdisInterlockedIncrement(&Counters.PacketsSent);
ctpDone:
DEBUGMSG(DBG_FUNC|DBG_ERR(Status), (DTEXT("-CallTransmitPacket %08x\n"), Status));
return Status;
}
VOID
CallProcessRxPackets(
IN PVOID SystemSpecific1,
IN PVOID Context,
IN PVOID SystemSpecific2,
IN PVOID SystemSpecific3
)
{
PCALL_SESSION pCall = Context;
ULONG_PTR ReceiveMax = 100;
NDIS_STATUS Status;
DEBUGMSG(DBG_FUNC, (DTEXT("+CallProcessRxPackets\n")));
ASSERT(IS_CALL(pCall));
NdisAcquireSpinLock(&pCall->Lock);
// First send up any received packets.
while (ReceiveMax-- && !IsListEmpty(&pCall->RxPacketList))
{
PDGRAM_CONTEXT pDgram;
PLIST_ENTRY pListEntry = RemoveHeadList(&pCall->RxPacketList);
pCall->RxPacketsPending--;
pDgram = CONTAINING_RECORD(pListEntry,
DGRAM_CONTEXT,
ListEntry);
if (pCall->State==STATE_CALL_ESTABLISHED &&
htons(pDgram->pGreHeader->KeyCallId)==pCall->Packet.CallId &&
IS_LINE_UP(pCall))
{
LONG GreLength, PayloadLength;
PVOID pPayload;
BOOLEAN SetAckTimer = FALSE;
ULONG Sequence;
if (pDgram->pGreHeader->SequenceNumberPresent)
{
// Call is still in good state, indicate the packet.
Sequence = htonl(GreSequence(pDgram->pGreHeader));
pCall->Remote.SequenceNumber = Sequence + 1;
if (IsListEmpty(&pCall->TxPacketList) && !pCall->Ack.PacketQueued && pDgram->pGreHeader->KeyLength)
{
// We only ack if there aren't already other transmits sent, and this
// isn't an ack-only packet.
SetAckTimer = pCall->Ack.PacketQueued = TRUE;
}
}
if (!PptpEchoAlways)
{
pCall->pCtl->Echo.Needed = FALSE;
}
NdisReleaseSpinLock(&pCall->Lock);
if (SetAckTimer)
{
NdisMSetTimer(&pCall->Ack.Timer, 100);
}
GreLength = sizeof(GRE_HEADER) +
(pDgram->pGreHeader->SequenceNumberPresent ? sizeof(ULONG) : 0) +
(pDgram->pGreHeader->AckSequenceNumberPresent ? sizeof(ULONG) : 0);
pPayload = (PUCHAR)pDgram->pGreHeader + GreLength;
PayloadLength = htons(pDgram->pGreHeader->KeyLength);
if (PayloadLength && pDgram->pGreHeader->SequenceNumberPresent)
{
NdisMWanIndicateReceive(&Status,
pCall->pAdapter->hMiniportAdapter,
pCall->NdisLinkContext,
pPayload,
PayloadLength);
if (Status==NDIS_STATUS_SUCCESS)
{
NdisMWanIndicateReceiveComplete(pCall->pAdapter->hMiniportAdapter,
pCall->NdisLinkContext);
}
}
NdisAcquireSpinLock(&pCall->Lock);
}
else if (pCall->State!=STATE_CALL_ESTABLISHED || !IS_LINE_UP(pCall))
{
// If this call is being torn down, we want to put priority on
// clearing out any packets left over. It should go fast since
// we're not indicating them up.
ReceiveMax = 100;
}
DEREFERENCE_OBJECT(pCall);
(void)CtdiReceiveComplete(pDgram->hCtdi, pDgram->pBuffer);
}
if (IsListEmpty(&pCall->RxPacketList))
{
pCall->Receiving = FALSE;
}
else
{
PptpQueueDpc(&pCall->ReceiveDpc);
}
NdisReleaseSpinLock(&pCall->Lock);
DEREFERENCE_OBJECT(pCall);
DEBUGMSG(DBG_FUNC, (DTEXT("-CallProcessRxPackets\n")));
}
BOOLEAN
CallProcessPackets(
PCALL_SESSION pCall,
ULONG TransferMax
)
{
LIST_ENTRY LocalList;
BOOLEAN MorePacketsToTransfer = FALSE;
ULONG TransmitFlags = 0;
NDIS_STATUS Status;
ULONG Ack, Seq;
ULONG ReceiveMax = TransferMax;
DEBUGMSG(DBG_FUNC, (DTEXT("+CallProcessPackets\n")));
ASSERT(sizeof(GRE_HEADER)==8);
ASSERT(IS_CALL(pCall));
REFERENCE_OBJECT(pCall);
InitializeListHead(&LocalList);
NdisAcquireSpinLock(&pCall->Lock);
Seq = pCall->Packet.SequenceNumber;
while (TransferMax-- && !IsListEmpty(&pCall->TxPacketList))
{
PLIST_ENTRY pListEntry = RemoveHeadList(&pCall->TxPacketList);
InsertTailList(&LocalList, pListEntry);
if (CONTAINING_RECORD(pListEntry,
NDIS_WAN_PACKET,
WanPacketQueue)!=&pCall->Ack.Packet)
{
pCall->Packet.SequenceNumber++;
}
}
if (!IsListEmpty(&pCall->TxPacketList) || !IsListEmpty(&pCall->RxPacketList))
{
MorePacketsToTransfer = TRUE;
}
else
{
pCall->Transferring = FALSE;
}
if (!IsListEmpty(&LocalList) &&
pCall->Packet.AckNumber!=pCall->Remote.SequenceNumber)
{
TransmitFlags |= TRANSMIT_SEND_ACK;
pCall->Packet.AckNumber = pCall->Remote.SequenceNumber;
// Ack tracks the Remote.SequenceNumber, which is actually the
// sequence of the NEXT packet, so we need to translate when
// we prepare to send an ack.
Ack = pCall->Remote.SequenceNumber - 1;
}
NdisReleaseSpinLock(&pCall->Lock);
while (!IsListEmpty(&LocalList))
{
PNDIS_WAN_PACKET pPacket;
PLIST_ENTRY pListEntry = RemoveHeadList(&LocalList);
pPacket = CONTAINING_RECORD(pListEntry,
NDIS_WAN_PACKET,
WanPacketQueue);
if (pPacket!=&pCall->Ack.Packet || TransmitFlags&TRANSMIT_SEND_ACK)
{
if (pPacket==&pCall->Ack.Packet)
{
TransmitFlags &= ~TRANSMIT_SEND_SEQ;
}
else
{
TransmitFlags |= TRANSMIT_SEND_SEQ;
Seq++;
}
Status = CallTransmitPacket(pCall, pPacket, TransmitFlags, Seq-1, Ack);
if (Status!=NDIS_STATUS_PENDING && pPacket!=&pCall->Ack.Packet)
{
if (pPacket==&pCall->Ack.Packet)
{
NdisAcquireSpinLock(&pCall->Lock);
pCall->Ack.PacketQueued = FALSE;
NdisReleaseSpinLock(&pCall->Lock);
}
else
{
// We didn't send the packet, so tell NDIS we're done with it.
NdisMWanSendComplete(pCall->pAdapter->hMiniportAdapter,
pPacket,
NDIS_STATUS_SUCCESS); // so I lied. Sue me.
DEREFERENCE_OBJECT(pCall);
}
}
}
else
{
// it was the ack-only packet, and we already sent an ack.
NdisAcquireSpinLock(&pCall->Lock);
pCall->Ack.PacketQueued = FALSE;
NdisReleaseSpinLock(&pCall->Lock);
}
TransmitFlags &= ~TRANSMIT_SEND_ACK;
}
DEREFERENCE_OBJECT(pCall);
DEBUGMSG(DBG_FUNC, (DTEXT("-CallProcessPackets %d\n"), MorePacketsToTransfer));
return MorePacketsToTransfer;
}
VOID
CallpAckTimeout(
IN PVOID SystemSpecific1,
IN PVOID Context,
IN PVOID SystemSpecific2,
IN PVOID SystemSpecific3
)
{
PCALL_SESSION pCall = Context;
DEBUGMSG(DBG_FUNC, (DTEXT("+CallpAckTimeout\n")));
if (IS_CALL(pCall))
{
if (pCall->State!=STATE_CALL_ESTABLISHED ||
CallQueueTransmitPacket(pCall, &pCall->Ack.Packet)!=NDIS_STATUS_PENDING)
{
NdisAcquireSpinLock(&pCall->Lock);
pCall->Ack.PacketQueued = FALSE;
NdisReleaseSpinLock(&pCall->Lock);
}
}
DEBUGMSG(DBG_FUNC, (DTEXT("-CallpAckTimeout\n")));
}
VOID
CallpDialTimeout(
IN PVOID SystemSpecific1,
IN PVOID Context,
IN PVOID SystemSpecific2,
IN PVOID SystemSpecific3
)
{
PCALL_SESSION pCall = Context;
DEBUGMSG(DBG_FUNC, (DTEXT("+CallpDialTimeout\n")));
LOGMSG(FLL_USER, (DTEXT(LOGHDRS"Call(%d) timed out in dialing state\n"),
LOGHDR(4, pCall->Remote.Address.Address[0].Address[0].in_addr),
pCall->DeviceId));
ASSERT(IS_CALL(pCall));
if (pCall->State==STATE_CALL_DIALING)
{
CallCleanup(pCall, UNLOCKED);
}
DEBUGMSG(DBG_FUNC, (DTEXT("-CallpDialTimeout\n")));
}
VOID
CallpCloseTimeout(
IN PVOID SystemSpecific1,
IN PVOID Context,
IN PVOID SystemSpecific2,
IN PVOID SystemSpecific3
)
{
PCALL_SESSION pCall = Context;
DEBUGMSG(DBG_FUNC, (DTEXT("+CallpCloseTimeout\n")));
ASSERT(IS_CALL(pCall));
pCall->Close.Expedited = TRUE;
CallCleanup(pCall, UNLOCKED);
// ToDo: check for failure.
DEBUGMSG(DBG_FUNC, (DTEXT("-CallpCloseTimeout\n")));
}
VOID CallpFinalDeref(PCALL_SESSION pCall)
{
DEBUGMSG(DBG_FUNC|DBG_CALL, (DTEXT("+CallpFinalDeref\n")));
}
VOID CallpCleanupLooseEnds(PPPTP_ADAPTER pAdapter)
{
ULONG i;
DEBUGMSG(DBG_FUNC, (DTEXT("+CallpCleanupLooseEnds\n")));
for (i=0; i<pAdapter->Info.Endpoints; i++)
{
PCALL_SESSION pCall = pAdapter->pCallArray[i];
if (IS_CALL(pCall))
{
NdisAcquireSpinLock(&pCall->Lock);
if (IS_CALL(pCall) && pCall->State==STATE_CALL_CLEANUP)
{
CallCleanup(pCall, LOCKED);
}
NdisReleaseSpinLock(&pCall->Lock);
}
}
DEBUGMSG(DBG_FUNC, (DTEXT("-CallpCleanupLooseEnds\n")));
}