able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/rras/ndis/raspppoe/miniport.c

3966 lines
119 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Module Name:
miniport.c
Abstract:
This module contains all the Miniport interface processing routines.
Author:
Hakan Berk - Microsoft, Inc. (hakanb@microsoft.com) Feb-2000
Environment:
Windows 2000 kernel mode Miniport driver or equivalent.
Revision History:
---------------------------------------------------------------------------*/
#include <ntddk.h>
#include <ntddndis.h>
#include <ndis.h>
#include <ndiswan.h>
#include <ndistapi.h>
#include <ntverp.h>
#include "debug.h"
#include "timer.h"
#include "bpool.h"
#include "ppool.h"
#include "util.h"
#include "packet.h"
#include "protocol.h"
#include "miniport.h"
#include "tapi.h"
#include "fsm.h"
//
// This is our global adapter context
//
ADAPTER* gl_pAdapter = NULL;
//
// Lock that controls access to gl_pAdapter.
// This lock is necesarry for requests submitted from the bindings as
// they will not know if the adapter is halted or not.
//
NDIS_SPIN_LOCK gl_lockAdapter;
//
// We need a flag to indicate if lock is allocated or not
//
BOOLEAN gl_fLockAllocated = FALSE;
//
// The timer queue that handles the scheduled timer events.
//
TIMERQ gl_TimerQ;
//
// This is used to create a unique identifier in packets
//
ULONG gl_UniqueCounter = 0;
VOID
CreateUniqueValue(
IN HDRV_CALL hdCall,
OUT CHAR* pUniqueValue,
OUT USHORT* pSize
)
{
CHAR* pBuf = pUniqueValue;
ULONG usUniqueValue = InterlockedIncrement( &gl_UniqueCounter );
NdisMoveMemory( pBuf, (CHAR*) &hdCall, sizeof( HDRV_CALL ) );
pBuf += sizeof( HDRV_CALL );
NdisMoveMemory( pBuf, (CHAR*) &usUniqueValue, sizeof( ULONG ) );
*pSize = sizeof( HDRV_CALL ) + sizeof( ULONG );
}
HDRV_CALL
RetrieveHdCallFromUniqueValue(
IN CHAR* pUniqueValue,
IN USHORT Size
)
{
if ( Size != sizeof( HDRV_CALL ) + sizeof( ULONG ) )
return (HDRV_CALL) NULL;
return ( * (UNALIGNED HDRV_CALL*) pUniqueValue );
}
////////////////////////////////////
//
// Local function prototypes
//
////////////////////////////////////
VOID
ReferenceAdapter(
IN ADAPTER* pAdapter,
IN BOOLEAN fAcquireLock
);
VOID DereferenceAdapter(
IN ADAPTER* pAdapter
);
ADAPTER* AllocAdapter();
VOID FreeAdapter(
ADAPTER* pAdapter
);
NDIS_STATUS MpInitialize(
OUT PNDIS_STATUS OpenErrorStatus,
OUT PUINT SelectedMediumIndex,
IN PNDIS_MEDIUM MediumArray,
IN UINT MediumArraySize,
IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_HANDLE WrapperConfigurationContext
);
VOID MpHalt(
IN NDIS_HANDLE MiniportAdapterContext
);
NDIS_STATUS MpReset(
OUT PBOOLEAN AddressingReset,
IN NDIS_HANDLE MiniportAdapterContext
);
NDIS_STATUS MpWanSend(
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_HANDLE NdisLinkHandle,
IN PNDIS_WAN_PACKET WanPacket
);
NDIS_STATUS MpQueryInformation(
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN ULONG InformationBufferLength,
OUT PULONG BytesWritten,
OUT PULONG BytesNeeded
);
NDIS_STATUS MpSetInformation(
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN ULONG InformationBufferLength,
OUT PULONG BytesWritten,
OUT PULONG BytesNeeded
);
////////////////////////////////////
//
// Interface functions definitions
//
////////////////////////////////////
NDIS_STATUS
MpRegisterMiniport(
IN PDRIVER_OBJECT pDriverObject,
IN PUNICODE_STRING pRegistryPath,
OUT NDIS_HANDLE* pNdisWrapperHandle
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will be called from DriverEntry() to register the miniport
and create an instance of the adapter.
Parameters:
DriverObject _ Pointer to driver object created by the system.
RegistryPath _ Pointer to registery path name used to read registry
parameters.
Return Values:
NDIS_STATUS_SUCCESFUL: Miniport registered succesfully.
NDIS_STATUS_FAILURE: Miniport failed to register succesfully.
---------------------------------------------------------------------------*/
{
NDIS_HANDLE NdisWrapperHandle;
NDIS_STATUS status;
NDIS_MINIPORT_CHARACTERISTICS nmc;
TRACE( TL_I, TM_Mp, ("+MpRegisterMiniport") );
NdisMInitializeWrapper( &NdisWrapperHandle,
pDriverObject,
pRegistryPath,
NULL );
//
// Fill in the miniport characteristics
//
NdisZeroMemory( &nmc, sizeof( NDIS_MINIPORT_CHARACTERISTICS ) );
nmc.MajorNdisVersion = MP_NDIS_MajorVersion;
nmc.MinorNdisVersion = MP_NDIS_MinorVersion;
nmc.Reserved = NDIS_USE_WAN_WRAPPER;
nmc.InitializeHandler = MpInitialize;
nmc.ResetHandler = MpReset;
nmc.HaltHandler = MpHalt;
nmc.QueryInformationHandler = MpQueryInformation;
nmc.SetInformationHandler = MpSetInformation;
nmc.WanSendHandler = MpWanSend;
// no CheckForHangHandler
// no DisableInterruptHandler
// no EnableInterruptHandler
// no HandleInterruptHandler
// no ISRHandler
// no SendHandler (see WanSendHandler)
// no TransferDataHandler
// no WanTransferDataHandler
// no ReturnPacketHandler
// no SendPacketsHandler (see WanSendHandler)
// no AllocateCompleteHandler
// no CoActivateVcHandler
// no CoDeactivateVcHandler
// no CoSendPacketsHandler
// no CoRequestHandler
//
// Set the characteristics registering the miniport
//
status = NdisMRegisterMiniport( NdisWrapperHandle,
&nmc,
sizeof( NDIS_MINIPORT_CHARACTERISTICS ) );
//
// If registeration of miniport was not successful,
// undo the initialization of wrapper
//
if ( status != NDIS_STATUS_SUCCESS )
{
NdisTerminateWrapper( NdisWrapperHandle, NULL );
}
else
{
*pNdisWrapperHandle = NdisWrapperHandle;
}
TRACE( TL_I, TM_Mp, ("-MpRegisterMiniport=$%x",status) );
return status;
}
////////////////////////////////////
//
// Local function definitions
//
////////////////////////////////////
VOID
ReferenceAdapter(
IN ADAPTER* pAdapter,
IN BOOLEAN fAcquireLock
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will increment the reference count on the adapter object.
CAUTION: If fAcquireLock is set, this function will acquire the lock for the
call, otherwise it will assume the caller owns the lock.
Parameters:
pAdapter _ A pointer to our call information structure.
fAcquireLock _ Indicates if the caller already has the lock or not.
Caller must set this flag to FALSE if it has the lock,
otherwise it must be supplied as TRUE.
Return Values:
None
---------------------------------------------------------------------------*/
{
LONG lRef;
ASSERT( VALIDATE_ADAPTER( pAdapter ) );
TRACE( TL_V, TM_Mp, ("+ReferenceAdapter") );
if ( fAcquireLock )
NdisAcquireSpinLock( &pAdapter->lockAdapter );
lRef = ++pAdapter->lRef;
if ( fAcquireLock )
NdisReleaseSpinLock( &pAdapter->lockAdapter );
TRACE( TL_V, TM_Mp, ("-ReferenceAdapter=$%d",lRef) );
}
VOID
DereferenceAdapter(
IN ADAPTER* pAdapter
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will decrement the reference count on the adapter object
If the ref count drops to 0 (which means the adapter has been halted),
it will set fire pAdapter->eventAdapterHalted.
Parameters:
pAdapter _ A pointer ot our call information structure.
Return Values:
None
---------------------------------------------------------------------------*/
{
LONG lRef;
BOOLEAN fSignalAdapterHaltedEvent = FALSE;
ASSERT( VALIDATE_ADAPTER( pAdapter ) );
TRACE( TL_V, TM_Mp, ("+DereferenceAdapter") );
NdisAcquireSpinLock( &pAdapter->lockAdapter );
lRef = --pAdapter->lRef;
if ( lRef == 0 )
{
pAdapter->ulMpFlags &= ~MPBF_MiniportInitialized;
pAdapter->ulMpFlags &= ~MPBF_MiniportHaltPending;
pAdapter->ulMpFlags |= MPBF_MiniportHalted;
fSignalAdapterHaltedEvent = TRUE;
}
NdisReleaseSpinLock( &pAdapter->lockAdapter );
//
// Signal the halting of the adapter if we need to
//
if ( fSignalAdapterHaltedEvent )
NdisSetEvent( &pAdapter->eventAdapterHalted );
TRACE( TL_V, TM_Mp, ("-DereferenceAdapter=$%x",lRef) );
}
ADAPTER*
AllocAdapter()
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will allocate the resources for the adapter object and return
a pointer to it.
Parameters:
None
Return Values:
pAdapter: A pointer to the newly allocated adapter object.
NULL: Resources were not available to create the adapter.
---------------------------------------------------------------------------*/
{
ADAPTER* pAdapter = NULL;
TRACE( TL_N, TM_Mp, ("+AllocAdapter") );
if ( ALLOC_ADAPTER( &pAdapter ) != NDIS_STATUS_SUCCESS )
{
TRACE( TL_A, TM_Mp, ("AllocAdapter: Could not allocate context") );
TRACE( TL_N, TM_Mp, ("-AllocAdapter") );
return NULL;
}
//
// Clear the memory
//
NdisZeroMemory( pAdapter, sizeof( ADAPTER ) );
//
// Initialize adapter tag
//
pAdapter->tagAdapter = MTAG_ADAPTER;
//
// Allocate the lock that controls access to the adapter
//
NdisAllocateSpinLock( &pAdapter->lockAdapter );
//
// Initialize the state
//
pAdapter->ulMpFlags = MPBF_MiniportIdle;
TRACE( TL_N, TM_Mp, ("-AllocAdapter") );
return pAdapter;
}
NDIS_STATUS
ReadRegistrySettings(
IN OUT ADAPTER* pAdapter,
IN NDIS_HANDLE WrapperConfigurationContext
)
{
NDIS_STATUS status = NDIS_STATUS_FAILURE;
NDIS_HANDLE hCfg = 0;
NDIS_CONFIGURATION_PARAMETER* pncp = 0;
BOOLEAN fMaxLinesDefinedInRegistry = FALSE;
TRACE( TL_N, TM_Mp, ("+ReadRegistrySettings") );
do
{
//
// Open the Ndis configuration, it will be closed at the end of the
// while loop before we exit it.
//
NdisOpenConfiguration( &status,
&hCfg,
WrapperConfigurationContext );
if ( status != NDIS_STATUS_SUCCESS )
{
TRACE( TL_A, TM_Mp, ("ReadRegistrySettings: NdisOpenConfiguration() failed") );
break;
}
//
// Read fClientRole value from the registry
//
{
NDIS_STRING nstr = NDIS_STRING_CONST( "fClientRole" );
NdisReadConfiguration( &status,
&pncp,
hCfg,
&nstr,
NdisParameterInteger );
if (status == NDIS_STATUS_SUCCESS)
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Read fClientRole from registry") );
pAdapter->fClientRole = ( pncp->ParameterData.IntegerData > 0 ) ? TRUE : FALSE;
}
else
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Could not read fClientRole from registry, using default value") );
pAdapter->fClientRole = TRUE;
status = NDIS_STATUS_SUCCESS;
}
}
//
// Read ServiceName and ServiceNameLength values from the registry.
// These are server side only values.
//
{
NDIS_STRING nstr = NDIS_STRING_CONST( "ServiceName" );
NdisReadConfiguration( &status,
&pncp,
hCfg,
&nstr,
NdisParameterString );
if (status == NDIS_STATUS_SUCCESS)
{
ANSI_STRING AnsiString;
NdisZeroMemory( &AnsiString, sizeof( ANSI_STRING ) );
status = RtlUnicodeStringToAnsiString( &AnsiString, &pncp->ParameterData.StringData, TRUE );
if ( status == STATUS_SUCCESS )
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Read ServiceName from registry") );
pAdapter->nServiceNameLength = ( MAX_SERVICE_NAME_LENGTH < AnsiString.Length ) ?
MAX_SERVICE_NAME_LENGTH : AnsiString.Length;
NdisMoveMemory( pAdapter->ServiceName, AnsiString.Buffer, pAdapter->nServiceNameLength ) ;
RtlFreeAnsiString( &AnsiString );
}
}
if ( status != NDIS_STATUS_SUCCESS )
{
PWSTR wszKeyName = L"ComputerName";
PWSTR wszPath = L"ComputerName\\ComputerName";
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
UNICODE_STRING UnicodeStr;
WCHAR wszName[ MAX_COMPUTERNAME_LENGTH + 1];
NdisZeroMemory( QueryTable, 2 * sizeof( RTL_QUERY_REGISTRY_TABLE ) );
QueryTable[0].QueryRoutine = NULL;
QueryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_DIRECT;
QueryTable[0].Name = wszKeyName;
QueryTable[0].EntryContext = (PVOID) &UnicodeStr;
NdisZeroMemory( &UnicodeStr, sizeof( UNICODE_STRING ) );
UnicodeStr.Length = 0;
UnicodeStr.MaximumLength = MAX_COMPUTERNAME_LENGTH + 1;
UnicodeStr.Buffer = wszName;
status = RtlQueryRegistryValues( RTL_REGISTRY_CONTROL,
wszPath,
QueryTable,
NULL,
NULL );
if ( status == STATUS_SUCCESS )
{
ANSI_STRING AnsiString;
NdisZeroMemory( &AnsiString, sizeof( ANSI_STRING ) );
status = RtlUnicodeStringToAnsiString( &AnsiString, &UnicodeStr, TRUE );
if ( status == STATUS_SUCCESS )
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Using Machine Name as ServiceName") );
NdisMoveMemory( pAdapter->ServiceName, AnsiString.Buffer, AnsiString.Length );
NdisMoveMemory( pAdapter->ServiceName + AnsiString.Length,
SERVICE_NAME_EXTENSION,
sizeof( SERVICE_NAME_EXTENSION ) );
//
// -1 is to ignore the terminating NULL character
//
pAdapter->nServiceNameLength = AnsiString.Length + sizeof( SERVICE_NAME_EXTENSION ) - 1;
RtlFreeAnsiString( &AnsiString );
status = NDIS_STATUS_SUCCESS;
}
}
}
if ( status != NDIS_STATUS_SUCCESS )
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Using default hardcoded service name") );
NdisMoveMemory( pAdapter->ServiceName, "MS-RAS PPPoE", sizeof( "MS-RAS PPPoE" ) );
pAdapter->nServiceNameLength = ( sizeof( "MS-RAS PPPoE" ) / sizeof( CHAR ) ) - 1;
status = NDIS_STATUS_SUCCESS;
}
//
// Future: Convert service name to UTF-8
// It turns out that we can not do this conversion from a kernel module,
// so the value read from the registry must be in UTF-8 format itself.
//
}
//
// Read AC-Name and AC-NameLength values from the registry.
// These are server side only values.
//
{
NDIS_STRING nstr = NDIS_STRING_CONST( "ACName" );
NdisReadConfiguration( &status,
&pncp,
hCfg,
&nstr,
NdisParameterString );
if (status == NDIS_STATUS_SUCCESS)
{
ANSI_STRING AnsiString;
NdisZeroMemory( &AnsiString, sizeof( ANSI_STRING ) );
status = RtlUnicodeStringToAnsiString( &AnsiString, &pncp->ParameterData.StringData, TRUE );
if ( status == STATUS_SUCCESS )
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Read AC-Name from registry") );
pAdapter->nACNameLength = ( MAX_AC_NAME_LENGTH < AnsiString.Length ) ?
MAX_AC_NAME_LENGTH : AnsiString.Length;
NdisMoveMemory( pAdapter->ACName, AnsiString.Buffer, pAdapter->nACNameLength ) ;
RtlFreeAnsiString( &AnsiString );
}
}
if ( status != NDIS_STATUS_SUCCESS )
{
PWSTR wszKeyName = L"ComputerName";
PWSTR wszPath = L"ComputerName\\ComputerName";
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
UNICODE_STRING UnicodeStr;
WCHAR wszName[ MAX_COMPUTERNAME_LENGTH + 1];
NdisZeroMemory( QueryTable, 2 * sizeof( RTL_QUERY_REGISTRY_TABLE ) );
QueryTable[0].QueryRoutine = NULL;
QueryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_DIRECT;
QueryTable[0].Name = wszKeyName;
QueryTable[0].EntryContext = (PVOID) &UnicodeStr;
NdisZeroMemory( &UnicodeStr, sizeof( UNICODE_STRING ) );
UnicodeStr.Length = 0;
UnicodeStr.MaximumLength = MAX_COMPUTERNAME_LENGTH + 1;
UnicodeStr.Buffer = wszName;
status = RtlQueryRegistryValues( RTL_REGISTRY_CONTROL,
wszPath,
QueryTable,
NULL,
NULL );
if ( status == STATUS_SUCCESS )
{
ANSI_STRING AnsiString;
NdisZeroMemory( &AnsiString, sizeof( ANSI_STRING ) );
status = RtlUnicodeStringToAnsiString( &AnsiString, &UnicodeStr, TRUE );
if ( status == STATUS_SUCCESS )
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Using Machine Name as AC-Name") );
NdisMoveMemory( pAdapter->ACName, AnsiString.Buffer, AnsiString.Length );
pAdapter->nACNameLength = AnsiString.Length;
RtlFreeAnsiString( &AnsiString );
status = NDIS_STATUS_SUCCESS;
}
}
}
if ( status != NDIS_STATUS_SUCCESS )
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Using default hardcoded value for AC-Name") );
NdisMoveMemory( pAdapter->ACName, "MS-RAS Access Concentrator", sizeof( "MS-RAS Access Concentrator" ) );
pAdapter->nACNameLength = ( sizeof( "MS-RAS Access Concentrator" ) / sizeof( CHAR ) ) - 1;
status = NDIS_STATUS_SUCCESS;
}
//
// Future: Convert AC name to UTF-8
// It turns out that we can not do this conversion from a kernel module,
// so the value read from the registry must be in UTF-8 format itself.
//
}
//
// Read nClientQuota value
// These is a server side only value.
//
{
NDIS_STRING nstr = NDIS_STRING_CONST( "ClientQuota" );
NdisReadConfiguration( &status,
&pncp,
hCfg,
&nstr,
NdisParameterInteger );
if (status == NDIS_STATUS_SUCCESS)
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Read ClientQuota from registry") );
pAdapter->nClientQuota = (UINT) pncp->ParameterData.IntegerData;
}
else
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Could not read ClientQuota from registry, using default value") );
pAdapter->nClientQuota = 3;
status = NDIS_STATUS_SUCCESS;
}
}
//
// Read MaxLines value
//
{
NDIS_STRING nstr = NDIS_STRING_CONST( "MaxLines" );
NdisReadConfiguration( &status,
&pncp,
hCfg,
&nstr,
NdisParameterInteger );
if (status == NDIS_STATUS_SUCCESS)
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Read MaxLines from registry") );
pAdapter->nMaxLines = (UINT) pncp->ParameterData.IntegerData;
fMaxLinesDefinedInRegistry = TRUE;
}
else
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Could not read MaxLines from registry, using default value") );
pAdapter->nMaxLines = 1;
status = NDIS_STATUS_SUCCESS;
}
}
//
// Read CallsPerLine value
//
{
NDIS_STRING nstr = NDIS_STRING_CONST( "CallsPerLine" );
NdisReadConfiguration( &status,
&pncp,
hCfg,
&nstr,
NdisParameterInteger );
if (status == NDIS_STATUS_SUCCESS)
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Read CallsPerLine from registry") );
pAdapter->nCallsPerLine = (UINT) pncp->ParameterData.IntegerData;
}
else
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Could not read CallsPerLine from registry, using default value") );
pAdapter->nCallsPerLine = 1;
status = NDIS_STATUS_SUCCESS;
}
}
//
// Read WanEndPoints if MaxLines was not defined in registry
//
if ( !fMaxLinesDefinedInRegistry )
{
NDIS_STRING nstr = NDIS_STRING_CONST( "WanEndPoints" );
NdisReadConfiguration( &status,
&pncp,
hCfg,
&nstr,
NdisParameterInteger );
if (status == NDIS_STATUS_SUCCESS)
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Read WanEndPoints from registry") );
pAdapter->nMaxLines = 1;
pAdapter->nCallsPerLine = (UINT) pncp->ParameterData.IntegerData;
}
status = NDIS_STATUS_SUCCESS;
}
//
// Read MaxTimeouts value
//
{
NDIS_STRING nstr = NDIS_STRING_CONST( "MaxTimeouts" );
NdisReadConfiguration( &status,
&pncp,
hCfg,
&nstr,
NdisParameterInteger );
if (status == NDIS_STATUS_SUCCESS)
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Read MaxTimeouts from registry") );
pAdapter->nMaxTimeouts = (UINT) pncp->ParameterData.IntegerData;
}
else
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Could not read MaxTimeouts from registry, using default value") );
pAdapter->nMaxTimeouts = 3;
status = NDIS_STATUS_SUCCESS;
}
}
//
// Read SendTimeout value
//
{
NDIS_STRING nstr = NDIS_STRING_CONST( "SendTimeout" );
NdisReadConfiguration( &status,
&pncp,
hCfg,
&nstr,
NdisParameterInteger );
if (status == NDIS_STATUS_SUCCESS)
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Read SendTimeout from registry") );
pAdapter->ulSendTimeout = (ULONG) pncp->ParameterData.IntegerData;
}
else
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Could not read SendTimeout from registry, using default value") );
pAdapter->ulSendTimeout = 5000;
status = NDIS_STATUS_SUCCESS;
}
}
//
// Read RecvTimeout value
//
{
NDIS_STRING nstr = NDIS_STRING_CONST( "RecvTimeout" );
NdisReadConfiguration( &status,
&pncp,
hCfg,
&nstr,
NdisParameterInteger );
if (status == NDIS_STATUS_SUCCESS)
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Read RecvTimeout from registry") );
pAdapter->ulRecvTimeout = (ULONG) pncp->ParameterData.IntegerData;
}
else
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Could not read RecvTimeout from registry, using default value") );
pAdapter->ulRecvTimeout = 5000;
status = NDIS_STATUS_SUCCESS;
}
}
//
// Read fAcceptAnyService value from the registry
//
{
NDIS_STRING nstr = NDIS_STRING_CONST( "fAcceptAnyService" );
NdisReadConfiguration( &status,
&pncp,
hCfg,
&nstr,
NdisParameterInteger );
if (status == NDIS_STATUS_SUCCESS)
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Read fAcceptAnyService from registry") );
pAdapter->fAcceptAnyService = ( pncp->ParameterData.IntegerData > 0 ) ? TRUE : FALSE;
}
else
{
TRACE( TL_N, TM_Mp, ("ReadRegistrySettings: Could not read fAcceptAnyService from registry, using default value") );
pAdapter->fAcceptAnyService = TRUE;
status = NDIS_STATUS_SUCCESS;
}
}
//
// Close the Ndis configuration
//
NdisCloseConfiguration( hCfg );
} while ( FALSE );
TRACE( TL_N, TM_Mp, ("-ReadRegistrySettings=$%x",status) );
return status;
}
NDIS_STATUS
InitializeAdapter(
IN ADAPTER* pAdapter,
IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_HANDLE WrapperConfigurationContext
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will initialize the contents of the adapter object.
It will be called from inside MpInitialize() and it will read the necesarry
values from the registry to initialize the adapter context.
Parameters:
pAdapter _ A pointer to our adapter information structure.
Return Values:
None
---------------------------------------------------------------------------*/
{
NDIS_STATUS status = NDIS_STATUS_SUCCESS;
NDIS_PHYSICAL_ADDRESS HighestAcceptableAddress = NDIS_PHYSICAL_ADDRESS_CONST(-1,-1);
ASSERT( VALIDATE_ADAPTER( pAdapter ) );
TRACE( TL_N, TM_Mp, ("+InitializeAdapter") );
//
// Initialize and reset the adapter halted event
//
NdisInitializeEvent( &pAdapter->eventAdapterHalted );
NdisResetEvent( &pAdapter->eventAdapterHalted );
//
// Set the state
//
pAdapter->ulMpFlags = MPBF_MiniportInitialized;
//
// Set NDIS's corresponding handle
//
pAdapter->MiniportAdapterHandle = MiniportAdapterHandle;
//
// Read values from registry
//
status = ReadRegistrySettings( pAdapter, WrapperConfigurationContext );
pAdapter->nMaxSendPackets = 1;
//
// Initialize the NdisWanInfo structure
//
pAdapter->NdisWanInfo.MaxFrameSize = PACKET_PPP_PAYLOAD_MAX_LENGTH;
pAdapter->NdisWanInfo.MaxTransmit = 1;
pAdapter->NdisWanInfo.HeaderPadding = PPPOE_PACKET_HEADER_LENGTH;
pAdapter->NdisWanInfo.TailPadding = 0;
pAdapter->NdisWanInfo.Endpoints = pAdapter->nCallsPerLine * pAdapter->nMaxLines;
pAdapter->NdisWanInfo.MemoryFlags = 0;
pAdapter->NdisWanInfo.HighestAcceptableAddress = HighestAcceptableAddress;
pAdapter->NdisWanInfo.FramingBits = PPP_FRAMING |
// PPP_COMPRESS_ADDRESS_CONTROL |
// PPP_COMPRESS_PROTOCOL_FIELD |
TAPI_PROVIDER;
pAdapter->NdisWanInfo.DesiredACCM = 0;
TRACE( TL_N, TM_Mp, ("-InitializeAdapter=$%x",status) );
return status;
}
VOID
FreeAdapter(
ADAPTER* pAdapter
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will deallocate the resources for the adapter object.
Parameters:
pAdapter _ A pointer to our adapter information structure.
Return Values:
None
---------------------------------------------------------------------------*/
{
ASSERT( VALIDATE_ADAPTER( pAdapter ) );
TRACE( TL_N, TM_Mp, ("+FreeAdapter") );
NdisFreeSpinLock( &pAdapter->lockAdapter );
FREE_ADAPTER( pAdapter );
TRACE( TL_N, TM_Mp, ("-FreeAdapter") );
}
NDIS_STATUS
MpInitialize(
OUT PNDIS_STATUS OpenErrorStatus,
OUT PUINT SelectedMediumIndex,
IN PNDIS_MEDIUM MediumArray,
IN UINT MediumArraySize,
IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_HANDLE WrapperConfigurationContext
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
The MiniportInitialize request is called to have the Miniport driver
initialize the adapter.
No other request will be outstanding on the Miniport when this routine
is called. No other request will be submitted to the Miniport until
the operation is completed.
The wrapper will supply an array containing a list of the media types
that it supports. The Miniport driver reads this array and returns
the index of the media type that the wrapper should treat her as.
If the Miniport driver is impersonating a media type that is different
from the true media type, this must be done completely transparently to
the wrapper.
If the Miniport driver cannot find a media type supported by both it
and the wrapper, it returns NDIS_STATUS_UNSUPPORTED_MEDIA.
The status value NDIS_STATUS_OPEN_ERROR has a special meaning. It
indicates that the OpenErrorStatus parameter has returned a valid status
which the wrapper can examine to obtain more information about the error.
This routine is called with interrupts enabled, and a call to MiniportISR
will occur if the adapter generates any interrupts. During this routine
MiniportDisableInterrupt and MiniportEnableInterrupt will not be called,
so it is the responsibility of the Miniport driver to acknowledge and
clear any interrupts generated.
This routine will be called from the context of MpRegisterMiniport().
Parameters:
OpenErrorStatus _ Returns more information about the reason for the
failure. Currently, the only values defined match those
specified as Open Error Codes in Appendix B of the IBM
Local Area Network Technical Reference.
SelectedMediumIndex _ Returns the index in MediumArray of the medium type
that the Miniport driver wishes to be viewed as.
Note that even though the NDIS interface may complete
this request asynchronously, it must return this
index on completion of this function.
MediumArray _ An array of medium types which the wrapper supports.
MediumArraySize _ The number of elements in MediumArray.
MiniportAdapterHandle _ A handle identifying the Miniport. The Miniport
driver must supply this handle in future requests
that refer to the Miniport.
WrapperConfigurationContext _ The handle used for calls to NdisOpenConfiguration.
Return Values:
NDIS_STATUS_ADAPTER_NOT_FOUND
NDIS_STATUS_FAILURE
NDIS_STATUS_NOT_ACCEPTED
NDIS_STATUS_OPEN_ERROR
NDIS_STATUS_RESOURCES
NDIS_STATUS_SUCCESS
NDIS_STATUS_UNSUPPORTED_MEDIA
---------------------------------------------------------------------------*/
{
NDIS_STATUS status = NDIS_STATUS_SUCCESS;
ADAPTER* pAdapter = NULL;
UINT i;
TRACE( TL_I, TM_Mp, ("+MpInitialize") );
do
{
//
// Select the medium
//
for (i=0; i<MediumArraySize; i++)
{
if ( MediumArray[i] == NdisMediumWan )
break;
}
//
// Check if we have found a medium supported
//
if ( i < MediumArraySize )
{
*SelectedMediumIndex = i;
}
else
{
TRACE( TL_A, TM_Mp, ("MpInitialize: Unsupported Media") );
status = NDIS_STATUS_UNSUPPORTED_MEDIA;
break;
}
//
// Allocate the adapter block
//
pAdapter = AllocAdapter();
if ( pAdapter == NULL )
{
TRACE( TL_A, TM_Mp, ("MpInitialize: Resources unavailable") );
status = NDIS_STATUS_FAILURE;
break;
}
//
// Initialize the adapter
//
status = InitializeAdapter( pAdapter,
MiniportAdapterHandle,
WrapperConfigurationContext );
if ( status != NDIS_STATUS_SUCCESS )
{
TRACE( TL_A, TM_Mp, ("MpInitialize: InitializeAdapter() failed") );
break;
}
//
// Inform NDIS about our miniport adapter context
//
NdisMSetAttributesEx(MiniportAdapterHandle,
pAdapter,
0,
NDIS_ATTRIBUTE_IGNORE_PACKET_TIMEOUT |
NDIS_ATTRIBUTE_IGNORE_REQUEST_TIMEOUT |
NDIS_ATTRIBUTE_NO_HALT_ON_SUSPEND |
NDIS_ATTRIBUTE_DESERIALIZE,
NdisInterfaceInternal );
//
// Do the global initialization
//
gl_pAdapter = pAdapter;
//
// Allocate the packet pools
//
PacketPoolInit();
//
// Do one-time only initialization of global members
//
if ( !gl_fLockAllocated )
{
//
// Allocate the spin lock
//
NdisAllocateSpinLock( &gl_lockAdapter );
//
// Initialize the timer queue
//
TimerQInitialize( &gl_TimerQ );
//
// Finally set lock allocated flag, and start giving access
// to the adapter context for requests from the protocol
//
gl_fLockAllocated = TRUE;
}
//
// Reference the adapter for initialization.
// This reference will be removed in MpHalt().
//
ReferenceAdapter( pAdapter, TRUE );
} while ( FALSE );
if ( status != NDIS_STATUS_SUCCESS )
{
if ( pAdapter != NULL )
{
FreeAdapter( pAdapter );
}
}
TRACE( TL_I, TM_Mp, ("-MpInitialize=$%x",status) );
return status;
}
VOID
MpHalt(
IN NDIS_HANDLE MiniportAdapterContext
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
The MiniportHalt request is used to halt the adapter such that it is
no longer functioning. The Miniport driver should stop the adapter
and deregister all of its resources before returning from this routine.
It is not necessary for the Miniport to complete all outstanding
requests and no other requests will be submitted to the Miniport
until the operation is completed.
Interrupts are enabled during the call to this routine.
Parameters:
MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes
during MiniportInitialize.
Return Values:
None.
---------------------------------------------------------------------------*/
{
ADAPTER* pAdapter = MiniportAdapterContext;
TRACE( TL_I, TM_Mp, ("+MpHalt") );
//
// Make sure adapter context is a valid one
//
if ( !VALIDATE_ADAPTER( pAdapter ) )
{
TRACE( TL_I, TM_Mp, ("-MpHalt") );
return;
}
//
// Lock the adapter and set halt pending bit
//
NdisAcquireSpinLock( &pAdapter->lockAdapter );
pAdapter->ulMpFlags |= MPBF_MiniportHaltPending;
NdisReleaseSpinLock( &pAdapter->lockAdapter );
//
// Shutdown the tapi provider
//
{
NDIS_TAPI_PROVIDER_SHUTDOWN DummyRequest;
NdisZeroMemory( &DummyRequest, sizeof( NDIS_TAPI_PROVIDER_SHUTDOWN ) );
TpProviderShutdown( pAdapter, &DummyRequest, FALSE);
}
//
// Remove the reference added in MpInitialize()
//
DereferenceAdapter( pAdapter );
//
// Wait for all references to be removed
//
NdisWaitEvent( &pAdapter->eventAdapterHalted, 0 );
//
// All references have been removed, now wait for all packets owned by NDIS
// to be returned.
//
// Note that no synchronization is necesarry for reading the value of NumPacketsOwnedByNdis
// at this point since it can only be incremented when there is at least 1 reference on the
// binding - at this point ref count is 0 -, and because it can not be incremented, it can
// only reach 0 once.
//
while ( pAdapter->NumPacketsOwnedByNdiswan )
{
NdisMSleep( 10000 );
}
//
// Do deallocation of global resources first
//
NdisAcquireSpinLock( &gl_lockAdapter );
gl_pAdapter = NULL;
PacketPoolUninit();
NdisReleaseSpinLock( &gl_lockAdapter );
//
// Now we can clean up the adapter context
//
FreeAdapter( pAdapter );
TRACE( TL_I, TM_Mp, ("-MpHalt") );
}
NDIS_STATUS
MpReset(
OUT PBOOLEAN AddressingReset,
IN NDIS_HANDLE MiniportAdapterContext
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
The MiniportReset request instructs the Miniport driver to issue a
hardware reset to the network adapter. The Miniport driver also
resets its software state.
The MiniportReset request may also reset the parameters of the adapter.
If a hardware reset of the adapter resets the current station address
to a value other than what it is currently configured to, the Miniport
driver automatically restores the current station address following the
reset. Any multicast or functional addressing masks reset by the
hardware do not have to be reprogrammed by the Miniport.
NOTE: This is change from the NDIS 3.0 driver specification. If the
multicast or functional addressing information, the packet filter, the
lookahead size, and so on, needs to be restored, the Miniport indicates
this with setting the flag AddressingReset to TRUE.
It is not necessary for the Miniport to complete all outstanding requests
and no other requests will be submitted to the Miniport until the
operation is completed. Also, the Miniport does not have to signal
the beginning and ending of the reset with NdisMIndicateStatus.
NOTE: These are different than the NDIS 3.0 driver specification.
The Miniport driver must complete the original request, if the orginal
call to MiniportReset return NDIS_STATUS_PENDING, by calling
NdisMResetComplete.
If the underlying hardware does not provide a reset function under
software control, then this request completes abnormally with
NDIS_STATUS_NOT_RESETTABLE. If the underlying hardware attempts a
reset and finds recoverable errors, the request completes successfully
with NDIS_STATUS_SOFT_ERRORS. If the underlying hardware resets and,
in the process, finds nonrecoverable errors, the request completes
successfully with the status NDIS_STATUS_HARD_ERRORS. If the
underlying hardware reset is accomplished without any errors,
the request completes successfully with the status NDIS_STATUS_SUCCESS.
Interrupts are in any state during this call.
Parameters:
MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes
during MiniportInitialize.
AddressingReset _ The Miniport indicates if the wrapper needs to call
MiniportSetInformation to restore the addressing
information to the current values by setting this
value to TRUE.
Return Values:
NDIS_STATUS_HARD_ERRORS
NDIS_STATUS_NOT_ACCEPTED
NDIS_STATUS_NOT_RESETTABLE
NDIS_STATUS_PENDING
NDIS_STATUS_SOFT_ERRORS
NDIS_STATUS_SUCCESS
---------------------------------------------------------------------------*/
{
TRACE( TL_I, TM_Mp, ("+MpReset") );
TRACE( TL_I, TM_Mp, ("-MpReset") );
return NDIS_STATUS_NOT_RESETTABLE;
}
NDIS_STATUS
MpWanSend(
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_HANDLE NdisLinkHandle,
IN PNDIS_WAN_PACKET WanPacket
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
The Ndis(M)WanSend instructs a WAN driver to transmit a packet through the
adapter onto the medium.
Ownership of both the packet descriptor and the packet data is transferred
to the WAN driver until the request is completed, either synchronously or
asynchronously. If the WAN driver returns a status other than
NDIS_STATUS_PENDING, then the request is complete, and ownership of the
packet immediately reverts to the protocol. If the WAN driver returns
NDIS_STATUS_PENDING, then the WAN driver must later indicate completion
of the request by calling Ndis(M)WanSendComplete.
The WAN driver should NOT return a status of NDIS_STATUS_RESOURCES to
indicate that there are not enough resources available to process the
transmit. Instead, the miniport should queue the send for a later time
or lower the MaxTransmits value.
The WAN miniport can NOT call NdisMSendResourcesAvailable.
The packet passed in Ndis(M)WanSend will contain simple HDLC PPP framing
if PPP framing is set. For SLIP or RAS framing, the packet contains only
the data portion with no framing whatsoever.
A WAN driver must NOT provide software loopback or promiscuous mode
loopback. Both of these are fully provided for in the WAN wrapper.
NOTE: The MacReservedx section as well as the WanPacketQueue section of
the NDIS_WAN_PACKET is fully available for use by the WAN driver.
Interrupts are in any state during this routine.
Parameters:
MacBindingHandle _ The handle to be passed to NdisMWanSendComplete().
NdisLinkHandle _ The Miniport link handle passed to NDIS_LINE_UP
WanPacket _ A pointer to the NDIS_WAN_PACKET strucutre. The structure
contains a pointer to a contiguous buffer with guaranteed
padding at the beginning and end. The driver may manipulate
the buffer in any way.
typedef struct _NDIS_WAN_PACKET
{
LIST_ENTRY WanPacketQueue;
PUCHAR CurrentBuffer;
ULONG CurrentLength;
PUCHAR StartBuffer;
PUCHAR EndBuffer;
PVOID ProtocolReserved1;
PVOID ProtocolReserved2;
PVOID ProtocolReserved3;
PVOID ProtocolReserved4;
PVOID MacReserved1; // Link
PVOID MacReserved2; // MacBindingHandle
PVOID MacReserved3;
PVOID MacReserved4;
} NDIS_WAN_PACKET, *PNDIS_WAN_PACKET;
The available header padding is simply CurrentBuffer-StartBuffer.
The available tail padding is EndBuffer-(CurrentBuffer+CurrentLength).
Return Values:
NDIS_STATUS_INVALID_DATA
NDIS_STATUS_INVALID_LENGTH
NDIS_STATUS_INVALID_OID
NDIS_STATUS_NOT_ACCEPTED
NDIS_STATUS_NOT_SUPPORTED
NDIS_STATUS_PENDING
NDIS_STATUS_SUCCESS
NDIS_STATUS_FAILURE
---------------------------------------------------------------------------*/
{
ADAPTER* pAdapter = MiniportAdapterContext;
NDIS_STATUS status = NDIS_STATUS_FAILURE;
CALL* pCall = NULL;
BINDING* pBinding = NULL;
PPPOE_PACKET* pPacket = NULL;
BOOLEAN fTapiProvReferenced = FALSE;
TRACE( TL_V, TM_Mp, ("+MpWanSend($%x,$%x,$%x)",MiniportAdapterContext,NdisLinkHandle,WanPacket) );
do
{
//
// Make sure adapter context is a valid one
//
if ( !VALIDATE_ADAPTER( pAdapter ) )
{
TRACE( TL_A, TM_Tp, ("MpWanSend($%x,$%x,$%x): Invalid adapter handle supplied",
MiniportAdapterContext,
NdisLinkHandle,
WanPacket) );
break;
}
NdisAcquireSpinLock( &pAdapter->lockAdapter );
//
// Make sure the handle table will not be freed as long as we need it
// in this function
//
if ( !( pAdapter->TapiProv.ulTpFlags & TPBF_TapiProvShutdownPending ) &&
( pAdapter->TapiProv.ulTpFlags & TPBF_TapiProvInitialized ) )
{
fTapiProvReferenced = TRUE;
ReferenceTapiProv( pAdapter, FALSE );
}
else
{
NdisReleaseSpinLock( &pAdapter->lockAdapter );
TRACE( TL_A, TM_Tp, ("MpWanSend($%x,$%x,$%x): Tapi provider not initialized, or shutting down",
MiniportAdapterContext,
NdisLinkHandle,
WanPacket) );
break;
}
//
// Map the handle to the pointer for the call context
//
pCall = RetrieveFromHandleTable( pAdapter->TapiProv.hCallTable, NdisLinkHandle );
if ( pCall == NULL )
{
NdisReleaseSpinLock( &pAdapter->lockAdapter );
TRACE( TL_A, TM_Tp, ("MpWanSend($%x,$%x,$%x): Invalid call handle supplied",
MiniportAdapterContext,
NdisLinkHandle,
WanPacket) );
break;
}
NdisAcquireSpinLock( &pCall->lockCall );
if ( pCall->pBinding == NULL )
{
NdisReleaseSpinLock( &pCall->lockCall );
NdisReleaseSpinLock( &pAdapter->lockAdapter );
TRACE( TL_A, TM_Tp, ("MpWanSend($%x,$%x,$%x): Binding not found",
MiniportAdapterContext,
NdisLinkHandle,
WanPacket) );
break;
}
status = PacketInitializePAYLOADToSend( &pPacket,
pCall->SrcAddr,
pCall->DestAddr,
pCall->usSessionId,
WanPacket,
pCall->pLine->pAdapter );
if ( status != NDIS_STATUS_SUCCESS )
{
NdisReleaseSpinLock( &pCall->lockCall );
NdisReleaseSpinLock( &pAdapter->lockAdapter );
TRACE( TL_N, TM_Tp, ("MpWanSend($%x,$%x,$%x): Could not init payload packet to send",
MiniportAdapterContext,
NdisLinkHandle,
WanPacket) );
break;
}
pBinding = pCall->pBinding;
ReferenceBinding( pBinding, TRUE );
//
// Reference the packet so that if PrSend() pends,
// packet still exists around
//
ReferencePacket( pPacket );
//
// Release the locks to send the packet
//
NdisReleaseSpinLock( &pCall->lockCall );
NdisReleaseSpinLock( &pAdapter->lockAdapter );
//
// Packet is ready, so send it
//
status = PrSend( pBinding, pPacket );
//
// Since the result of send will always be completed by a call to NdisMWanSendComplete(),
// we have to return NDIS_STATUS_PENDING from this function.
//
status = NDIS_STATUS_PENDING;
//
// We can free the packet as we have a reference on the packet
//
PacketFree( pPacket );
} while ( FALSE );
//
// If a reference is added on the tapi provider, remove it
//
if ( fTapiProvReferenced )
{
DereferenceTapiProv( pAdapter );
}
TRACE( TL_V, TM_Mp, ("-MpWanSend($%x,$%x,$%x)=$%x",MiniportAdapterContext,NdisLinkHandle,WanPacket,status) );
return status;
}
typedef struct
_SUPPORTED_OIDS
{
NDIS_OID ndisOid;
CHAR szOidName[64];
}
SUPPORTED_OIDS;
SUPPORTED_OIDS
SupportedOidsArray[] = {
{ OID_GEN_CURRENT_LOOKAHEAD, "OID_GEN_CURRENT_LOOKAHEAD" },
{ OID_GEN_DRIVER_VERSION, "OID_GEN_DRIVER_VERSION" },
{ OID_GEN_HARDWARE_STATUS, "OID_GEN_HARDWARE_STATUS" },
{ OID_GEN_LINK_SPEED, "OID_GEN_LINK_SPEED" },
{ OID_GEN_MAC_OPTIONS, "OID_GEN_MAC_OPTIONS" },
{ OID_GEN_MAXIMUM_LOOKAHEAD, "OID_GEN_MAXIMUM_LOOKAHEAD" },
{ OID_GEN_MAXIMUM_FRAME_SIZE, "OID_GEN_MAXIMUM_FRAME_SIZE" },
{ OID_GEN_MAXIMUM_TOTAL_SIZE, "OID_GEN_MAXIMUM_TOTAL_SIZE" },
{ OID_GEN_MEDIA_SUPPORTED, "OID_GEN_MEDIA_SUPPORTED" },
{ OID_GEN_MEDIA_IN_USE, "OID_GEN_MEDIA_IN_USE" },
{ OID_GEN_RCV_ERROR, "OID_GEN_RCV_ERROR" },
{ OID_GEN_RCV_OK, "OID_GEN_RCV_OK" },
{ OID_GEN_RECEIVE_BLOCK_SIZE, "OID_GEN_RECEIVE_BLOCK_SIZE" },
{ OID_GEN_RECEIVE_BUFFER_SPACE, "OID_GEN_RECEIVE_BUFFER_SPACE" },
{ OID_GEN_SUPPORTED_LIST, "OID_GEN_SUPPORTED_LIST" },
{ OID_GEN_TRANSMIT_BLOCK_SIZE, "OID_GEN_TRANSMIT_BLOCK_SIZE" },
{ OID_GEN_TRANSMIT_BUFFER_SPACE, "OID_GEN_TRANSMIT_BUFFER_SPACE" },
{ OID_GEN_VENDOR_DESCRIPTION, "OID_GEN_VENDOR_DESCRIPTION" },
{ OID_GEN_VENDOR_ID, "OID_GEN_VENDOR_ID" },
{ OID_GEN_XMIT_ERROR, "OID_GEN_XMIT_ERROR" },
{ OID_GEN_XMIT_OK, "OID_GEN_XMIT_OK" },
{ OID_PNP_CAPABILITIES, "OID_PNP_CAPABILITIES" },
{ OID_PNP_SET_POWER, "OID_PNP_SET_POWER" },
{ OID_PNP_QUERY_POWER, "OID_PNP_QUERY_POWER" },
{ OID_PNP_ENABLE_WAKE_UP, "OID_PNP_ENABLE_WAKE_UP" },
{ OID_TAPI_CLOSE, "OID_TAPI_CLOSE" },
{ OID_TAPI_DROP, "OID_TAPI_DROP" },
{ OID_TAPI_GET_ADDRESS_CAPS, "OID_TAPI_GET_ADDRESS_CAPS" },
{ OID_TAPI_GET_ADDRESS_STATUS, "OID_TAPI_GET_ADDRESS_STATUS" },
{ OID_TAPI_GET_CALL_INFO, "OID_TAPI_GET_CALL_INFO" },
{ OID_TAPI_GET_CALL_STATUS, "OID_TAPI_GET_CALL_STATUS" },
{ OID_TAPI_GET_DEV_CAPS, "OID_TAPI_GET_DEV_CAPS" },
{ OID_TAPI_GET_EXTENSION_ID, "OID_TAPI_GET_EXTENSION_ID" },
{ OID_TAPI_MAKE_CALL, "OID_TAPI_MAKE_CALL" },
{ OID_TAPI_CLOSE_CALL, "OID_TAPI_CLOSE_CALL" },
{ OID_TAPI_NEGOTIATE_EXT_VERSION, "OID_TAPI_NEGOTIATE_EXT_VERSION"},
{ OID_TAPI_OPEN, "OID_TAPI_OPEN" },
{ OID_TAPI_ANSWER, "OID_TAPI_ANSWER" },
{ OID_TAPI_PROVIDER_INITIALIZE, "OID_TAPI_PROVIDER_INITIALIZE" },
{ OID_TAPI_PROVIDER_SHUTDOWN, "OID_TAPI_PROVIDER_SHUTDOWN" },
{ OID_TAPI_SET_STATUS_MESSAGES, "OID_TAPI_SET_STATUS_MESSAGES" },
{ OID_TAPI_SET_DEFAULT_MEDIA_DETECTION, "OID_TAPI_SET_DEFAULT_MEDIA_DETECTION" },
{ OID_WAN_CURRENT_ADDRESS, "OID_WAN_CURRENT_ADDRESS" },
{ OID_WAN_GET_BRIDGE_INFO, "OID_WAN_GET_BRIDGE_INFO" },
{ OID_WAN_GET_COMP_INFO, "OID_WAN_GET_COMP_INFO" },
{ OID_WAN_GET_INFO, "OID_WAN_GET_INFO" },
{ OID_WAN_GET_LINK_INFO, "OID_WAN_GET_LINK_INFO" },
{ OID_WAN_GET_STATS_INFO, "OID_WAN_GET_STATS_INFO" },
{ OID_WAN_HEADER_FORMAT, "OID_WAN_HEADER_FORMAT" },
{ OID_WAN_LINE_COUNT, "OID_WAN_LINE_COUNT" },
{ OID_WAN_MEDIUM_SUBTYPE, "OID_WAN_MEDIUM_SUBTYPE" },
{ OID_WAN_PERMANENT_ADDRESS, "OID_WAN_PERMANENT_ADDRESS" },
{ OID_WAN_PROTOCOL_TYPE, "OID_WAN_PERMANENT_ADDRESS" },
{ OID_WAN_QUALITY_OF_SERVICE, "OID_WAN_QUALITY_OF_SERVICE" },
{ OID_WAN_SET_BRIDGE_INFO, "OID_WAN_SET_BRIDGE_INFO" },
{ OID_WAN_SET_COMP_INFO, "OID_WAN_SET_COMP_INFO" },
{ OID_WAN_SET_LINK_INFO, "OID_WAN_SET_LINK_INFO" },
{ (NDIS_OID) 0, "UNKNOWN OID" }
};
CHAR* GetOidName(
NDIS_OID Oid
)
{
//
// Calculate the number of oids we support.
// (Subtract one for unknown oid)
//
UINT nNumOids = ( sizeof( SupportedOidsArray ) / sizeof( SUPPORTED_OIDS ) ) - 1;
UINT i;
for ( i = 0; i < nNumOids; i++ )
{
if ( Oid == SupportedOidsArray[i].ndisOid )
break;
}
return SupportedOidsArray[i].szOidName;
}
#define ENFORCE_SAFE_TOTAL_SIZE(mainStruct, embeddedStruct) \
((mainStruct*) InformationBuffer)->embeddedStruct.ulTotalSize = InformationBufferLength - FIELD_OFFSET(mainStruct, embeddedStruct)
#define RETRIEVE_NEEDED_AND_USED_LENGTH(mainStruct, embeddedStruct) \
{ \
NeededLength = ((mainStruct*) InformationBuffer)->embeddedStruct.ulNeededSize + FIELD_OFFSET(mainStruct, embeddedStruct); \
UsedLength = ((mainStruct*) InformationBuffer)->embeddedStruct.ulUsedSize + FIELD_OFFSET(mainStruct, embeddedStruct); \
}
NDIS_STATUS
MpQueryInformation(
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN ULONG InformationBufferLength,
OUT PULONG BytesWritten,
OUT PULONG BytesNeeded
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
The MiniportQueryInformation request allows the inspection of the
Miniport driver's capabilities and current status.
If the Miniport does not complete the call immediately (by returning
NDIS_STATUS_PENDING), it must call NdisMQueryInformationComplete to
complete the call. The Miniport controls the buffers pointed to by
InformationBuffer, BytesWritten, and BytesNeeded until the request
completes.
No other requests of the following kind will be submitted to the Miniport
driver until this request has been completed:
1. MiniportQueryInformation()
2. MiniportSetInformation()
3. MiniportHalt()
Note that the wrapper will intercept all queries of the following OIDs:
OID_GEN_CURRENT_PACKET_FILTER,
OID_GEN_PROTOCOL_OPTIONS,
OID_802_5_CURRENT_FUNCTIONAL,
OID_802_3_MULTICAST_LIST,
OID_FDDI_LONG_MULTICAST_LIST,
OID_FDDI_SHORT_MULTICAST_LIST.
Interrupts are in any state during this call.
Parameters:
MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes
during MiniportInitialize.
Oid _ The OID. (See section 7.4 of the NDIS 3.0 specification for a
complete description of OIDs.)
InformationBuffer _ The buffer that will receive the information.
(See section 7.4 of the NDIS 3.0 specification
for a description of the length required for each
OID.)
InformationBufferLength _ The length in bytes of InformationBuffer.
BytesWritten _ Returns the number of bytes written into
InformationBuffer.
BytesNeeded _ This parameter returns the number of additional bytes
needed to satisfy the OID.
Return Values:
NDIS_STATUS_INVALID_DATA
NDIS_STATUS_INVALID_LENGTH
NDIS_STATUS_INVALID_OID
NDIS_STATUS_NOT_ACCEPTED
NDIS_STATUS_NOT_SUPPORTED
NDIS_STATUS_PENDING
NDIS_STATUS_RESOURCES
NDIS_STATUS_FAILURE
NDIS_STATUS_SUCCESS
---------------------------------------------------------------------------*/
{
ADAPTER* pAdapter = (ADAPTER*) MiniportAdapterContext;
NDIS_STATUS status = NDIS_STATUS_FAILURE;
ULONG GenericUlong;
PVOID SourceBuffer = NULL;
ULONG NeededLength = 0;
ULONG UsedLength = 0;
//
// This can be any string that represents PPPoE as a MAC address, but
// it must be up to 6 chars long.
//
UCHAR PPPoEWanAddress[6] = { '3', 'P', 'o', 'E', '0', '0' };
TRACE( TL_I, TM_Mp, ("+MpQueryInformation($%x):%s",(ULONG) Oid, GetOidName( Oid ) ) );
//
// Make sure adapter context is a valid one
//
if ( !VALIDATE_ADAPTER( pAdapter ) )
return status;
switch ( Oid )
{
case OID_GEN_MAXIMUM_LOOKAHEAD:
{
NeededLength = sizeof( GenericUlong );
GenericUlong = pAdapter->NdisWanInfo.MaxFrameSize;
SourceBuffer = &GenericUlong;
status = NDIS_STATUS_SUCCESS;
break;
}
case OID_GEN_MAC_OPTIONS:
{
NeededLength = sizeof( GenericUlong );
GenericUlong = NDIS_MAC_OPTION_TRANSFERS_NOT_PEND;
SourceBuffer = &GenericUlong;
status = NDIS_STATUS_SUCCESS;
break;
}
case OID_GEN_SUPPORTED_LIST:
{
//
// Calculate the number of oids we support.
// (Subtract one for unknown oid)
//
UINT nNumOids = ( sizeof( SupportedOidsArray ) / sizeof( SUPPORTED_OIDS ) ) - 1;
NeededLength = nNumOids * sizeof( NDIS_OID );
if ( InformationBufferLength >= NeededLength )
{
NDIS_OID* NdisOidArray = (NDIS_OID*) InformationBuffer;
UINT i;
for ( i = 0; i < nNumOids; i++ )
{
NdisOidArray[i] = SupportedOidsArray[i].ndisOid;
}
status = NDIS_STATUS_SUCCESS;
}
break;
}
case OID_GEN_RCV_ERROR:
case OID_GEN_RCV_OK:
case OID_GEN_XMIT_ERROR:
case OID_GEN_XMIT_OK:
case OID_GEN_CURRENT_LOOKAHEAD:
case OID_GEN_DRIVER_VERSION:
case OID_GEN_HARDWARE_STATUS:
case OID_GEN_LINK_SPEED:
case OID_GEN_MAXIMUM_FRAME_SIZE:
case OID_GEN_MAXIMUM_TOTAL_SIZE:
case OID_GEN_MEDIA_SUPPORTED:
case OID_GEN_MEDIA_IN_USE:
case OID_GEN_RECEIVE_BLOCK_SIZE:
case OID_GEN_RECEIVE_BUFFER_SPACE:
case OID_GEN_TRANSMIT_BLOCK_SIZE:
case OID_GEN_TRANSMIT_BUFFER_SPACE:
case OID_GEN_VENDOR_DESCRIPTION:
case OID_GEN_VENDOR_ID:
{
status = NDIS_STATUS_NOT_SUPPORTED;
break;
}
case OID_TAPI_GET_ADDRESS_CAPS:
{
NeededLength = sizeof( NDIS_TAPI_GET_ADDRESS_CAPS );
if ( InformationBufferLength < NeededLength )
{
break;
}
ENFORCE_SAFE_TOTAL_SIZE(
NDIS_TAPI_GET_ADDRESS_CAPS,
LineAddressCaps
);
status = TpGetAddressCaps( pAdapter,
(PNDIS_TAPI_GET_ADDRESS_CAPS) InformationBuffer );
RETRIEVE_NEEDED_AND_USED_LENGTH(
NDIS_TAPI_GET_ADDRESS_CAPS,
LineAddressCaps
);
break;
}
case OID_TAPI_GET_CALL_INFO:
{
NeededLength = sizeof( NDIS_TAPI_GET_CALL_INFO );
if ( InformationBufferLength < NeededLength )
{
break;
}
ENFORCE_SAFE_TOTAL_SIZE(
NDIS_TAPI_GET_CALL_INFO,
LineCallInfo
);
status = TpGetCallInfo( pAdapter,
(PNDIS_TAPI_GET_CALL_INFO) InformationBuffer );
RETRIEVE_NEEDED_AND_USED_LENGTH(
NDIS_TAPI_GET_CALL_INFO,
LineCallInfo
);
break;
}
case OID_TAPI_GET_CALL_STATUS:
{
NeededLength = sizeof( NDIS_TAPI_GET_CALL_STATUS );
if ( InformationBufferLength < NeededLength )
{
break;
}
ENFORCE_SAFE_TOTAL_SIZE(
NDIS_TAPI_GET_CALL_STATUS,
LineCallStatus
);
status = TpGetCallStatus( pAdapter,
(PNDIS_TAPI_GET_CALL_STATUS) InformationBuffer );
RETRIEVE_NEEDED_AND_USED_LENGTH(
NDIS_TAPI_GET_CALL_STATUS,
LineCallStatus
);
break;
}
case OID_TAPI_GET_DEV_CAPS:
{
NeededLength = sizeof( NDIS_TAPI_GET_DEV_CAPS );
if ( InformationBufferLength < NeededLength )
{
break;
}
ENFORCE_SAFE_TOTAL_SIZE(
NDIS_TAPI_GET_DEV_CAPS,
LineDevCaps
);
status = TpGetDevCaps( pAdapter,
(PNDIS_TAPI_GET_DEV_CAPS) InformationBuffer );
RETRIEVE_NEEDED_AND_USED_LENGTH(
NDIS_TAPI_GET_DEV_CAPS,
LineDevCaps
);
break;
}
case OID_TAPI_GET_ID:
{
NeededLength = sizeof( NDIS_TAPI_GET_ID );
if ( InformationBufferLength < NeededLength )
{
break;
}
ENFORCE_SAFE_TOTAL_SIZE(
NDIS_TAPI_GET_ID,
DeviceID
);
status = TpGetId( pAdapter,
(PNDIS_TAPI_GET_ID) InformationBuffer,
InformationBufferLength );
RETRIEVE_NEEDED_AND_USED_LENGTH(
NDIS_TAPI_GET_ID,
DeviceID
);
break;
}
case OID_TAPI_GET_ADDRESS_STATUS:
{
NeededLength = sizeof( NDIS_TAPI_GET_ADDRESS_STATUS );
if ( InformationBufferLength < NeededLength )
{
break;
}
ENFORCE_SAFE_TOTAL_SIZE(
NDIS_TAPI_GET_ADDRESS_STATUS,
LineAddressStatus
);
status = TpGetAddressStatus( pAdapter,
(PNDIS_TAPI_GET_ADDRESS_STATUS) InformationBuffer );
RETRIEVE_NEEDED_AND_USED_LENGTH(
NDIS_TAPI_GET_ADDRESS_STATUS,
LineAddressStatus
);
break;
}
case OID_TAPI_GET_EXTENSION_ID:
{
NeededLength = sizeof( NDIS_TAPI_GET_EXTENSION_ID );
if ( InformationBufferLength < NeededLength )
{
break;
}
status = TpGetExtensionId( pAdapter,
(PNDIS_TAPI_GET_EXTENSION_ID) InformationBuffer );
break;
}
case OID_TAPI_MAKE_CALL:
{
NeededLength = sizeof( NDIS_TAPI_MAKE_CALL );
if ( InformationBufferLength < NeededLength )
{
break;
}
ENFORCE_SAFE_TOTAL_SIZE(
NDIS_TAPI_MAKE_CALL,
LineCallParams
);
status = TpMakeCall( pAdapter,
(PNDIS_TAPI_MAKE_CALL) InformationBuffer,
InformationBufferLength );
break;
}
case OID_TAPI_NEGOTIATE_EXT_VERSION:
{
NeededLength = sizeof( NDIS_TAPI_NEGOTIATE_EXT_VERSION );
if ( InformationBufferLength < NeededLength )
{
break;
}
status = TpNegotiateExtVersion( pAdapter,
(PNDIS_TAPI_NEGOTIATE_EXT_VERSION) InformationBuffer );
break;
}
case OID_TAPI_OPEN:
{
NeededLength = sizeof( NDIS_TAPI_OPEN );
if ( InformationBufferLength < NeededLength )
{
break;
}
status = TpOpenLine( pAdapter,
(PNDIS_TAPI_OPEN) InformationBuffer );
break;
}
case OID_TAPI_PROVIDER_INITIALIZE:
{
NeededLength = sizeof( NDIS_TAPI_PROVIDER_INITIALIZE );
if ( InformationBufferLength < NeededLength )
{
break;
}
status = TpProviderInitialize( pAdapter,
(PNDIS_TAPI_PROVIDER_INITIALIZE) InformationBuffer );
break;
}
case OID_WAN_GET_INFO:
{
NeededLength = sizeof( NDIS_WAN_INFO );
if ( InformationBufferLength < NeededLength )
{
break;
}
status = MpWanGetInfo( pAdapter,
(PNDIS_WAN_INFO) InformationBuffer );
break;
}
case OID_WAN_MEDIUM_SUBTYPE:
{
NeededLength = sizeof( GenericUlong );
GenericUlong = NdisWanMediumPppoe;
SourceBuffer = &GenericUlong;
status = NDIS_STATUS_SUCCESS;
break;
}
case OID_WAN_CURRENT_ADDRESS:
case OID_WAN_PERMANENT_ADDRESS:
{
NeededLength = sizeof( PPPoEWanAddress );
SourceBuffer = PPPoEWanAddress;
status = NDIS_STATUS_SUCCESS;
break;
}
case OID_WAN_GET_LINK_INFO:
{
NeededLength = sizeof( NDIS_WAN_GET_LINK_INFO );
if ( InformationBufferLength < NeededLength )
{
break;
}
status = MpWanGetLinkInfo( pAdapter,
(PNDIS_WAN_GET_LINK_INFO) InformationBuffer );
break;
}
case OID_WAN_GET_BRIDGE_INFO:
case OID_WAN_GET_STATS_INFO:
case OID_WAN_HEADER_FORMAT:
case OID_WAN_LINE_COUNT:
case OID_WAN_PROTOCOL_TYPE:
case OID_WAN_QUALITY_OF_SERVICE:
case OID_WAN_SET_BRIDGE_INFO:
case OID_WAN_SET_COMP_INFO:
case OID_WAN_SET_LINK_INFO:
case OID_WAN_GET_COMP_INFO:
{
status = NDIS_STATUS_NOT_SUPPORTED;
break;
}
case OID_PNP_CAPABILITIES:
{
NDIS_PNP_CAPABILITIES UNALIGNED * pPnpCaps = (NDIS_PNP_CAPABILITIES UNALIGNED *) InformationBuffer;
NeededLength = sizeof( NDIS_PNP_CAPABILITIES );
if ( InformationBufferLength < NeededLength )
{
break;
}
pPnpCaps->Flags = 0;
pPnpCaps->WakeUpCapabilities.MinMagicPacketWakeUp = NdisDeviceStateUnspecified;
pPnpCaps->WakeUpCapabilities.MinPatternWakeUp = NdisDeviceStateUnspecified;
pPnpCaps->WakeUpCapabilities.MinLinkChangeWakeUp = NdisDeviceStateUnspecified;
status = NDIS_STATUS_SUCCESS;
break;
}
case OID_PNP_QUERY_POWER:
case OID_PNP_ENABLE_WAKE_UP:
{
NeededLength = 0;
status = NDIS_STATUS_SUCCESS;
break;
}
default:
{
//
// Unknown OID
//
status = NDIS_STATUS_INVALID_OID;
break;
}
}
if ( status != NDIS_STATUS_NOT_SUPPORTED &&
status != NDIS_STATUS_INVALID_OID )
{
if ( InformationBufferLength >= NeededLength )
{
if ( status == NDIS_STATUS_SUCCESS )
{
if ( SourceBuffer )
{
NdisMoveMemory( InformationBuffer, SourceBuffer, NeededLength );
}
*BytesWritten = NeededLength;
}
else if ( status == NDIS_STATUS_INVALID_LENGTH )
{
*BytesWritten = 0;
*BytesNeeded = NeededLength;
}
}
else
{
*BytesWritten = 0;
*BytesNeeded = NeededLength;
status = NDIS_STATUS_INVALID_LENGTH;
}
}
TRACE( TL_I, TM_Mp, ("-MpQueryInformation()=$%x",status) );
return status;
}
NDIS_STATUS
MpSetInformation(
IN NDIS_HANDLE MiniportAdapterContext,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN ULONG InformationBufferLength,
OUT PULONG BytesWritten,
OUT PULONG BytesNeeded
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
The MiniportSetInformation request allows for control of the Miniport
by changing information maintained by the Miniport driver.
Any of the settable NDIS Global Oids may be used. (see section 7.4 of
the NDIS 3.0 specification for a complete description of the NDIS Oids.)
If the Miniport does not complete the call immediately (by returning
NDIS_STATUS_PENDING), it must call NdisMSetInformationComplete to
complete the call. The Miniport controls the buffers pointed to by
InformationBuffer, BytesRead, and BytesNeeded until the request completes.
Interrupts are in any state during the call, and no other requests will
be submitted to the Miniport until this request is completed.
Parameters:
MiniportAdapterContext _ The adapter handle passed to NdisMSetAttributes
during MiniportInitialize.
Oid _ The OID. (See section 7.4 of the NDIS 3.0 specification for
a complete description of OIDs.)
InformationBuffer _ The buffer that will receive the information.
(See section 7.4 of the NDIS 3.0 specification for
a description of the length required for each OID.)
InformationBufferLength _ The length in bytes of InformationBuffer.
BytesRead_ Returns the number of bytes read from InformationBuffer.
BytesNeeded _ This parameter returns the number of additional bytes
expected to satisfy the OID.
Return Values:
NDIS_STATUS_INVALID_DATA
NDIS_STATUS_INVALID_LENGTH
NDIS_STATUS_INVALID_OID
NDIS_STATUS_NOT_ACCEPTED
NDIS_STATUS_NOT_SUPPORTED
NDIS_STATUS_PENDING
NDIS_STATUS_RESOURCES
NDIS_STATUS_SUCCESS
---------------------------------------------------------------------------*/
{
ADAPTER* pAdapter = MiniportAdapterContext;
NDIS_STATUS status = NDIS_STATUS_FAILURE;
PVOID SourceBuffer = NULL;
ULONG NeededLength = 0;
ULONG GenericUlong;
TRACE( TL_I, TM_Mp, ("+MpSetInformation($%x):%s",(ULONG) Oid, GetOidName( Oid ) ) );
//
// Make sure adapter context is a valid one
//
if ( !VALIDATE_ADAPTER( pAdapter ) )
return status;
switch ( Oid )
{
case OID_TAPI_ANSWER:
{
NeededLength = sizeof( NDIS_TAPI_ANSWER );
if ( InformationBufferLength < NeededLength )
{
break;
}
status = TpAnswerCall( pAdapter,
(PNDIS_TAPI_ANSWER) InformationBuffer );
break;
}
case OID_TAPI_CLOSE:
{
NeededLength = sizeof( NDIS_TAPI_CLOSE );
if ( InformationBufferLength < NeededLength )
{
break;
}
status = TpCloseLine( pAdapter,
(PNDIS_TAPI_CLOSE) InformationBuffer,
TRUE);
break;
}
case OID_TAPI_CLOSE_CALL:
{
NeededLength = sizeof( NDIS_TAPI_CLOSE_CALL );
if ( InformationBufferLength < NeededLength )
{
break;
}
status = TpCloseCall( pAdapter,
(PNDIS_TAPI_CLOSE_CALL) InformationBuffer,
TRUE );
break;
}
case OID_TAPI_DROP:
{
NeededLength = sizeof( NDIS_TAPI_DROP );
if ( InformationBufferLength < NeededLength )
{
break;
}
status = TpDropCall( pAdapter,
(PNDIS_TAPI_DROP) InformationBuffer,
0 );
break;
}
case OID_TAPI_PROVIDER_SHUTDOWN:
{
NeededLength = sizeof( NDIS_TAPI_PROVIDER_SHUTDOWN );
if ( InformationBufferLength < NeededLength )
{
break;
}
status = TpProviderShutdown( pAdapter,
(PNDIS_TAPI_PROVIDER_SHUTDOWN) InformationBuffer,
TRUE );
break;
}
case OID_TAPI_SET_DEFAULT_MEDIA_DETECTION:
{
NeededLength = sizeof( NDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION );
if ( InformationBufferLength < NeededLength )
{
break;
}
status = TpSetDefaultMediaDetection( pAdapter,
(PNDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION) InformationBuffer );
break;
}
case OID_TAPI_SET_STATUS_MESSAGES:
{
NeededLength = sizeof( NDIS_TAPI_SET_STATUS_MESSAGES );
if ( InformationBufferLength < NeededLength )
{
break;
}
status = TpSetStatusMessages( pAdapter,
(PNDIS_TAPI_SET_STATUS_MESSAGES) InformationBuffer );
break;
}
case OID_WAN_SET_LINK_INFO:
{
NeededLength = sizeof( NDIS_WAN_SET_LINK_INFO );
if ( InformationBufferLength < NeededLength )
{
break;
}
status = MpWanSetLinkInfo( pAdapter,
(PNDIS_WAN_SET_LINK_INFO) InformationBuffer );
break;
}
case OID_PNP_SET_POWER:
case OID_PNP_ENABLE_WAKE_UP:
{
NeededLength = 0;
status = NDIS_STATUS_SUCCESS;
break;
}
default:
{
//
// Unknown OID
//
status = NDIS_STATUS_INVALID_OID;
break;
}
}
if ( status != NDIS_STATUS_NOT_SUPPORTED &&
status != NDIS_STATUS_INVALID_OID )
{
if ( InformationBufferLength >= NeededLength )
{
if ( SourceBuffer )
NdisMoveMemory( InformationBuffer, SourceBuffer, NeededLength );
*BytesWritten = NeededLength;
}
else
{
*BytesWritten = 0;
*BytesNeeded = NeededLength;
status = NDIS_STATUS_INVALID_LENGTH;
}
}
TRACE( TL_I, TM_Mp, ("-MpSetInformation()=$%x",status) );
return status;
}
VOID
MpNotifyBindingRemoval(
BINDING* pBinding
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will be called by the protocol module to notify the miniport
about the removal of a binding.
Miniport identifies and drops the calls over the binding..
Parameters:
pBinding _ A pointer to our binding information structure.
Return Values:
None
---------------------------------------------------------------------------*/
{
ADAPTER* pAdapter = NULL;
ASSERT( VALIDATE_BINDING( pBinding ) );
TRACE( TL_N, TM_Mp, ("+MpNotifyBindingRemoval($%x)",pBinding) );
if ( !gl_fLockAllocated )
{
TRACE( TL_A, TM_Mp, ("MpNotifyBindingRemoval($%x): Global lock not allocated yet",pBinding) );
TRACE( TL_N, TM_Mp, ("-MpNotifyBindingRemoval($%x)",pBinding) );
return;
}
NdisAcquireSpinLock( &gl_lockAdapter );
if ( gl_pAdapter &&
!( gl_pAdapter->ulMpFlags & MPBF_MiniportHaltPending ) &&
( gl_pAdapter->ulMpFlags & MPBF_MiniportInitialized ) )
{
pAdapter = gl_pAdapter;
NdisAcquireSpinLock( &pAdapter->lockAdapter );
if ( !( pAdapter->TapiProv.ulTpFlags & TPBF_TapiProvShutdownPending ) &&
( pAdapter->TapiProv.ulTpFlags & TPBF_TapiProvInitialized ) )
{
ReferenceTapiProv( pAdapter, FALSE );
NdisReleaseSpinLock( &pAdapter->lockAdapter );
}
else
{
NdisReleaseSpinLock( &pAdapter->lockAdapter );
pAdapter = NULL;
}
}
NdisReleaseSpinLock( &gl_lockAdapter );
if ( pAdapter == NULL )
{
TRACE( TL_A, TM_Mp, ("MpNotifyBindingRemoval($%x): Tapi provider not initialized or no adapters found",pBinding) );
TRACE( TL_N, TM_Mp, ("-MpNotifyBindingRemoval($%x)",pBinding) );
return;
}
//
// Complete any queued received packets in case PrReceiveComplete()
// is not called
//
PrReceiveComplete( pBinding );
NdisAcquireSpinLock( &pAdapter->lockAdapter );
do
{
HANDLE_TABLE hCallTable = NULL;
UINT hCallTableSize = 0;
UINT i = 0;
CALL* pCall;
HDRV_CALL hdCall;
//
// Traverse the call handle table and drop calls over
// the removed binding
//
hCallTableSize = pAdapter->nMaxLines * pAdapter->nCallsPerLine;
hCallTable = pAdapter->TapiProv.hCallTable;
for ( i = 0; i < hCallTableSize; i++ )
{
NDIS_TAPI_DROP DummyRequest;
BOOLEAN fDropCall = FALSE;
pCall = RetrieveFromHandleTableByIndex( hCallTable, (USHORT) i );
if ( pCall == NULL )
continue;
NdisAcquireSpinLock( &pCall->lockCall );
if ( pCall->pBinding == pBinding )
{
//
// This call is over the removed binding,
// so it should be dropped
//
ReferenceCall( pCall, FALSE );
fDropCall = TRUE;
}
NdisReleaseSpinLock( &pCall->lockCall );
if ( !fDropCall )
{
pCall = NULL;
continue;
}
NdisReleaseSpinLock( &pAdapter->lockAdapter );
//
// Initialize the request, and drop the call
//
DummyRequest.hdCall = pCall->hdCall;
TpDropCall( pAdapter, &DummyRequest, LINEDISCONNECTMODE_UNREACHABLE );
//
// Remove the reference added above
//
DereferenceCall( pCall );
//
// Re-acquire the adapter's lock
//
NdisAcquireSpinLock( &pAdapter->lockAdapter );
}
} while ( FALSE );
NdisReleaseSpinLock( &pAdapter->lockAdapter );
//
// Remove the reference added above
//
DereferenceTapiProv( pAdapter );
TRACE( TL_N, TM_Mp, ("-MpNotifyBindingRemoval($%x)",pBinding) );
}
CALL*
MpMapPacketWithSessionIdToCall(
IN ADAPTER* pAdapter,
IN PPPOE_PACKET* pPacket
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will be called to map an in session packet to a call in
call handle table.
If such a call is identified, it will be referenced and a pointer to
it will be returned. It is the caller's responsibility to remove the
added reference.
Parameters:
pAdapter _ A pointer to our adapter information structure.
pPacket _ A PPPoE packet received over the wire.
Return Values:
A pointer to the call context that the packet must be dispatched to.
NULL if no such calls could be identified.
---------------------------------------------------------------------------*/
{
CALL* pCall = NULL;
CALL* pReturnCall = NULL;
TRACE( TL_V, TM_Mp, ("+MpMapPacketWithSessionIdToCall($%x)",pPacket) );
NdisAcquireSpinLock( &pAdapter->lockAdapter );
if ( pAdapter->fClientRole )
{
HANDLE_TABLE hCallTable = NULL;
UINT hCallTableSize = 0;
UINT i = 0;
CHAR* pSrcAddr = PacketGetSrcAddr( pPacket );
CHAR* pDestAddr = PacketGetDestAddr( pPacket );
USHORT usSessionId = PacketGetSessionId( pPacket );
//
// Miniport acting as a client:
// Our algorithm is to search for the call handle table
// to find the matching call
//
hCallTableSize = pAdapter->nMaxLines * pAdapter->nCallsPerLine;
hCallTable = pAdapter->TapiProv.hCallTable;
for ( i = 0; i < hCallTableSize ; i++ )
{
pCall = RetrieveFromHandleTableByIndex( hCallTable, (USHORT) i );
if ( pCall == NULL )
continue;
if ( ( pCall->usSessionId == usSessionId ) &&
( NdisEqualMemory( pCall->SrcAddr, pDestAddr, 6 * sizeof( CHAR ) ) ) &&
( NdisEqualMemory( pCall->DestAddr, pSrcAddr, 6 * sizeof( CHAR ) ) ) )
{
//
// The packet is intended for this call
//
ReferenceCall( pCall, TRUE );
pReturnCall = pCall;
break;
}
}
}
else
{
HANDLE_TABLE hCallTable = NULL;
CHAR* pSrcAddr = PacketGetSrcAddr( pPacket );
CHAR* pDestAddr = PacketGetDestAddr( pPacket );
USHORT usSessionId = PacketGetSessionId( pPacket );
//
// Miniport acting as a server:
// Our algorithm is to use the session id directly as the index
// to the call handle table
//
hCallTable = pAdapter->TapiProv.hCallTable;
pCall = RetrieveFromHandleTableBySessionId( hCallTable, usSessionId );
if ( pCall )
{
if ( ( pCall->usSessionId == usSessionId ) &&
( NdisEqualMemory( pCall->SrcAddr, pDestAddr, 6 * sizeof( CHAR ) ) ) &&
( NdisEqualMemory( pCall->DestAddr, pSrcAddr, 6 * sizeof( CHAR ) ) ) )
{
ReferenceCall( pCall, TRUE );
pReturnCall = pCall;
}
}
}
NdisReleaseSpinLock( &pAdapter->lockAdapter );
TRACE( TL_V, TM_Mp, ("-MpMapPacketWithSessionIdToCall($%x)=$%x",pPacket,pReturnCall) );
return pReturnCall;
}
CALL*
MpMapPacketWithoutSessionIdToCall(
IN ADAPTER* pAdapter,
IN PPPOE_PACKET* pPacket
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will be called to map an out of session packet to a call that
is in connecting state.
If such a call is identified, it will be referenced and a pointer to
it will be returned. It is the caller's responsibility to remove the
added reference.
This function will only be called for PADO or PADS packets.
We use the HostUnique tags to save the handle to the call, and
use them to map the returned packet back to the related call. This provides a
very efficient mapping for these control packets.
Our HostUnique tags are prepared in this way. We append hdCall,
which is unique for a call, to a uniquely generated ULONG value to come up with
a longer unique value. And when we receive the packet we decode the unique value to reach
hdCall and use that to retrieve the call pointer.
Parameters:
pAdapter _ A pointer to our adapter information structure.
pPacket _ A PPPoE packet received over the wire.
Return Values:
A pointer to the call context that the packet must be dispatched to.
NULL if no such calls could be identified.
---------------------------------------------------------------------------*/
{
USHORT usCode = PacketGetCode( pPacket );
CHAR* pUniqueValue = NULL;
USHORT UniqueValueSize = 0;
HDRV_CALL hdCall = (HDRV_CALL) NULL;
CALL* pCall = NULL;
TRACE( TL_N, TM_Mp, ("+MpMapPacketWithoutSessionIdToCall($%x)",pPacket) );
PacketRetrieveHostUniqueTag( pPacket,
&UniqueValueSize,
&pUniqueValue );
if ( pUniqueValue == NULL )
{
TRACE( TL_A, TM_Mp, ("MpMapPacketWithoutSessionIdToCall($%x): Could not retrieve HostUnique tag",pPacket) );
TRACE( TL_N, TM_Mp, ("-MpMapPacketWithoutSessionIdToCall($%x)",pPacket) );
return NULL;
}
//
// Decode the unique value and retrieve the call handle
//
hdCall = RetrieveHdCallFromUniqueValue( pUniqueValue, UniqueValueSize );
if ( hdCall == (HDRV_CALL) NULL )
{
TRACE( TL_A, TM_Mp, ("MpMapPacketWithoutSessionIdToCall($%x): Could not retrieve call handle from unique value",pPacket) );
TRACE( TL_N, TM_Mp, ("-MpMapPacketWithoutSessionIdToCall($%x)",pPacket) );
return NULL;
}
NdisAcquireSpinLock( &pAdapter->lockAdapter );
//
// Retrieve the call pointer using the call handle
//
pCall = RetrieveFromHandleTable( pAdapter->TapiProv.hCallTable,
(NDIS_HANDLE) hdCall );
if ( pCall )
{
if ( !( pCall->ulClFlags & CLBF_CallDropped ||
pCall->ulClFlags & CLBF_CallClosePending ) )
{
ReferenceCall( pCall, TRUE );
}
else
{
pCall = NULL;
}
}
NdisReleaseSpinLock( &pAdapter->lockAdapter );
TRACE( TL_N, TM_Mp, ("-MpMapPacketWithoutSessionIdToCall($%x)=$%x",pPacket,pCall) );
return pCall;
}
BOOLEAN
MpVerifyServiceName(
IN ADAPTER* pAdapter,
IN PPPOE_PACKET* pPacket,
IN BOOLEAN fAcceptEmptyServiceNameTag
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will be called to verify that a requested service name is
supported by our server.
CAUTION: Do not attempt to lock anything inside this function, and make sure
not to call any function that may do it because it must be lock free
(caller might be holding locks).
Parameters:
pAdapter _ Pointer to the adapter structure that received the packet.
pPacket _ A PADI or PADR packet received.
fAcceptEmptyServiceNameTag _ An empty service name tag is valid in a PADI
packet but not in a PADR packet. This flag
indicates this behavior.
Return Values:
None
---------------------------------------------------------------------------*/
{
BOOLEAN fRet = FALSE;
USHORT tagServiceNameLength = 0;
CHAR* tagServiceNameValue = NULL;
TRACE( TL_V, TM_Mp, ("+MpVerifyServiceName($%x)",pPacket) );
RetrieveTag( pPacket,
tagServiceName,
&tagServiceNameLength,
&tagServiceNameValue,
0,
NULL,
FALSE );
do
{
if ( fAcceptEmptyServiceNameTag )
{
if ( tagServiceNameLength == 0 && tagServiceNameValue != NULL )
{
fRet = TRUE;
break;
}
}
if ( tagServiceNameLength == pAdapter->nServiceNameLength &&
NdisEqualMemory( tagServiceNameValue, pAdapter->ServiceName, tagServiceNameLength) )
{
fRet = TRUE;
}
} while ( FALSE );
TRACE( TL_V, TM_Mp, ("-MpVerifyServiceName($%x)=$%x",pPacket,fRet) );
return fRet;
}
VOID
MpReplyToPADI(
IN ADAPTER* pAdapter,
IN BINDING* pBinding,
IN PPPOE_PACKET* pPADI
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will be called when a PADI packet is received.
It will look at the services we offer and reply to the PADI packet with a
PADO packet informing the client of our services.
Parameters:
pAdapter _ Pointer to the adapter structure that received the packet.
pBinding _ Pointer to the binding that the packet is received over.
pPacket _ A received PADI packet.
Return Values:
None
---------------------------------------------------------------------------*/
{
TRACE( TL_N, TM_Mp, ("+MpReplyToPADI") );
//
// Verify the requested service name and
//
if ( MpVerifyServiceName( pAdapter, pPADI, TRUE ) )
{
NDIS_STATUS status;
PPPOE_PACKET* pPADO = NULL;
status = PacketInitializePADOToSend( pPADI,
&pPADO,
pBinding->LocalAddress,
pAdapter->nServiceNameLength,
pAdapter->ServiceName,
pAdapter->nACNameLength,
pAdapter->ACName,
TRUE );
if ( status == NDIS_STATUS_SUCCESS )
{
//
// Insert the empty generic service name tag
//
status = PacketInsertTag( pPADO,
tagServiceName,
0,
NULL,
NULL );
if ( status == NDIS_STATUS_SUCCESS )
{
UINT i;
ReferencePacket( pPADO );
ReferenceBinding( pBinding, TRUE );
PrSend( pBinding, pPADO );
PacketFree( pPADO );
}
}
}
TRACE( TL_N, TM_Mp, ("-MpReplyToPADI") );
}
BOOLEAN
MpCheckClientQuota(
IN ADAPTER* pAdapter,
IN PPPOE_PACKET* pPacket
)
{
BOOLEAN fRet = FALSE;
HANDLE_TABLE hCallTable = NULL;
UINT hCallTableSize = 0;
CALL* pCall;
CHAR *pSrcAddr = NULL;
UINT nNumCurrentConn = 0;
UINT i;
TRACE( TL_N, TM_Mp, ("+MpCheckClientQuota") );
pSrcAddr = PacketGetSrcAddr( pPacket );
NdisAcquireSpinLock( &pAdapter->lockAdapter );
hCallTableSize = pAdapter->nMaxLines * pAdapter->nCallsPerLine;
hCallTable = pAdapter->TapiProv.hCallTable;
for ( i = 0; i < hCallTableSize; i++ )
{
pCall = RetrieveFromHandleTableByIndex( hCallTable, (USHORT) i );
if ( pCall == NULL )
continue;
if ( NdisEqualMemory( pCall->DestAddr, pSrcAddr, 6 * sizeof( CHAR ) ) )
{
nNumCurrentConn++;
continue;
}
}
NdisReleaseSpinLock( &pAdapter->lockAdapter );
if ( nNumCurrentConn < pAdapter->nClientQuota )
{
fRet = TRUE;
}
TRACE( TL_N, TM_Mp, ("-MpCheckClientQuota=$%d",(UINT) fRet) );
return fRet;
}
VOID
MpSendPADSWithError(
IN BINDING* pBinding,
IN PPPOE_PACKET* pPADR,
IN ULONG ulErrorCode
)
{
NDIS_STATUS status;
PPPOE_PACKET* pPADS = NULL;
TRACE( TL_N, TM_Mp, ("+MpSendPADSWithError") );
status = PacketInitializePADSToSend( pPADR,
&pPADS,
(USHORT) 0 );
if ( status == NDIS_STATUS_SUCCESS )
{
switch (ulErrorCode)
{
case PPPOE_ERROR_SERVICE_NOT_SUPPORTED:
status = PacketInsertTag( pPADS,
tagServiceNameError,
PPPOE_ERROR_SERVICE_NOT_SUPPORTED_MSG_SIZE,
PPPOE_ERROR_SERVICE_NOT_SUPPORTED_MSG,
NULL );
break;
case PPPOE_ERROR_INVALID_AC_COOKIE_TAG:
status = PacketInsertTag( pPADS,
tagGenericError,
PPPOE_ERROR_INVALID_AC_COOKIE_TAG_MSG_SIZE,
PPPOE_ERROR_INVALID_AC_COOKIE_TAG_MSG,
NULL );
break;
case PPPOE_ERROR_CLIENT_QUOTA_EXCEEDED:
status = PacketInsertTag( pPADS,
tagACSystemError,
PPPOE_ERROR_CLIENT_QUOTA_EXCEEDED_MSG_SIZE,
PPPOE_ERROR_CLIENT_QUOTA_EXCEEDED_MSG,
NULL );
break;
}
}
if ( status == NDIS_STATUS_SUCCESS )
{
ReferencePacket( pPADS );
ReferenceBinding( pBinding, TRUE );
PrSend( pBinding, pPADS );
}
if ( pPADS )
{
PacketFree( pPADS );
}
TRACE( TL_N, TM_Mp, ("-MpSendPADSWithError") );
}
VOID
MpRecvCtrlPacket(
IN BINDING* pBinding,
IN PPPOE_PACKET* pPacket
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will be called by MpRecvPacket() when the packet received
is a control packet.
Caller (MpRecPacket()) will make sure that in the context of this function
gl_pAdapter, gl_pAdapter->TapiProv.hCallTable and gl_pAdapter->TapiProv.hLineTable
are valid. It will also reference and dereference TapiProv correctly.
This function will identify the call the packet is for and dispatch the
packet to it.
Parameters:
pBinding _ Pointer to the binding structure that packet was received over.
pPacket _ A PPPoE packet received over the wire.
Return Values:
None
---------------------------------------------------------------------------*/
{
ADAPTER* pAdapter = NULL;
BOOLEAN fIndicateReceive = FALSE;
USHORT usCode;
CALL* pCall = NULL;
TRACE( TL_N, TM_Mp, ("+MpRecvCtrlPacket($%x)",pPacket) );
pAdapter = gl_pAdapter;
usCode = PacketGetCode( pPacket );
switch( usCode )
{
case PACKET_CODE_PADI:
//
// Ignore the received PADI packets unless we act as a server and we have open lines.
//
if ( !pAdapter->fClientRole && ( pAdapter->TapiProv.nActiveLines > 0 ) )
{
TRACE( TL_N, TM_Mp, ("MpRecvCtrlPacket($%x): PADI received",pPacket) );
MpReplyToPADI( pAdapter, pBinding, pPacket );
}
break;
case PACKET_CODE_PADR:
//
// Ignore the received PADR packets unless we act as a server.
//
if ( !pAdapter->fClientRole )
{
ULONG ulErrorCode = PPPOE_NO_ERROR;
TRACE( TL_N, TM_Mp, ("MpRecvCtrlPacket($%x): PADR received",pPacket) );
//
// Verify the requested service name and validate the AC Cookie
// tag, and if they look OK, then start receiving the call.
//
if ( !MpVerifyServiceName( pAdapter, pPacket, TRUE ) )
{
ulErrorCode = PPPOE_ERROR_SERVICE_NOT_SUPPORTED;
}
else if ( !PacketValidateACCookieTagInPADR( pPacket ) )
{
ulErrorCode = PPPOE_ERROR_INVALID_AC_COOKIE_TAG;
}
else if ( !MpCheckClientQuota( pAdapter, pPacket ) )
{
ulErrorCode = PPPOE_ERROR_CLIENT_QUOTA_EXCEEDED;
}
if ( ulErrorCode == PPPOE_NO_ERROR )
{
TpReceiveCall( pAdapter, pBinding, pPacket );
}
else
{
MpSendPADSWithError( pBinding, pPacket, ulErrorCode );
}
}
break;
case PACKET_CODE_PADO:
if ( pAdapter->fClientRole )
{
TRACE( TL_N, TM_Mp, ("MpRecvCtrlPacket($%x): PADO received",pPacket) );
//
// Retrieve the call handle from the PADO packet
//
pCall = MpMapPacketWithoutSessionIdToCall( pAdapter, pPacket );
if ( pCall )
{
//
// Dispatch the packet to related call
//
FsmRun( pCall, pBinding, pPacket, NULL );
//
// Remove the reference added in MpMapPacketWithoutSessionIdToCall()
//
DereferenceCall( pCall );
}
}
break;
case PACKET_CODE_PADS:
if ( pAdapter->fClientRole )
{
TRACE( TL_N, TM_Mp, ("MpRecvCtrlPacket($%x): PADS received",pPacket) );
//
// Retrieve the call handle from the PADS packet
//
pCall = MpMapPacketWithoutSessionIdToCall( pAdapter, pPacket );
if ( pCall )
{
//
// For PADS packet, we must make sure that no other calls
// between the same 2 machines already have the same session id.
//
{
HANDLE_TABLE hCallTable = NULL;
UINT hCallTableSize = 0;
UINT i = 0;
USHORT usSessionId = PacketGetSessionId( pPacket );
CHAR* pSrcAddr = PacketGetSrcAddr( pPacket );
CHAR* pDestAddr = PacketGetDestAddr( pPacket );
BOOLEAN fDuplicateFound = FALSE;
CALL* pTempCall = NULL;
TRACE( TL_N, TM_Mp, ("MpRecvCtrlPacket($%x): Checking for duplicate session",pPacket) );
NdisAcquireSpinLock( &pAdapter->lockAdapter );
hCallTableSize = pAdapter->nMaxLines * pAdapter->nCallsPerLine;
hCallTable = pAdapter->TapiProv.hCallTable;
for ( i = 0; i < hCallTableSize ; i++ )
{
pTempCall = RetrieveFromHandleTableByIndex( hCallTable, (USHORT) i );
if ( pTempCall == NULL )
continue;
if ( ( pTempCall->usSessionId == usSessionId ) &&
( NdisEqualMemory( pTempCall->SrcAddr, pSrcAddr, 6 * sizeof( CHAR ) ) ) &&
( NdisEqualMemory( pTempCall->DestAddr, pDestAddr, 6 * sizeof( CHAR ) ) ) )
{
//
// Another call has been detected between the 2 machines with the same
// session id, so do not accept this session
//
fDuplicateFound = TRUE;
break;
}
}
NdisReleaseSpinLock( &pAdapter->lockAdapter );
if ( fDuplicateFound )
{
//
// We have found another session with the same machine that has the
// same session id, so we can not accept this new session.
//
// Remove the reference added in MpMapPacketWithoutSessionId() and
// drop the packet
//
TRACE( TL_A, TM_Mp, ("MpRecvCtrlPacket($%x): Packet dropped - Duplicate session found",pPacket) );
DereferenceCall( pCall );
break;
}
}
TRACE( TL_N, TM_Mp, ("MpRecvCtrlPacket($%x): No duplicate sessions found",pPacket) );
//
// Dispatch the packet to related call
//
FsmRun( pCall, pBinding, pPacket, NULL );
//
// Remove the reference added in MpMapPacketWithoutSessionIdToCall()
//
DereferenceCall( pCall );
} // if ( pCall ) ...
} // if ( fClientRole ) ...
break;
case PACKET_CODE_PADT:
TRACE( TL_N, TM_Mp, ("MpRecvCtrlPacket($%x): PADT received",pPacket) );
//
// PADT packet must have a session id.
// Identify the session and drop the call.
//
pCall = MpMapPacketWithSessionIdToCall( pAdapter, pPacket );
if ( pCall )
{
NDIS_TAPI_DROP DummyRequest;
TRACE( TL_N, TM_Mp, ("MpRecvCtrlPacket($%x): Call being dropped - PADT received",pPacket) );
//
// Initialize the request, and drop the call
//
DummyRequest.hdCall = pCall->hdCall;
TpDropCall( pAdapter, &DummyRequest, LINEDISCONNECTMODE_NORMAL );
//
// Remove the reference added in MpMapPacketWithSessionIdToCall()
//
DereferenceCall( pCall );
}
break;
default:
break;
}
TRACE( TL_N, TM_Mp, ("-MpRecvCtrlPacket($%x)",pPacket) );
}
VOID
MpRecvPacket(
IN BINDING* pBinding,
IN PPPOE_PACKET* pPacket
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will be called by the protocol module to notify the miniport
when a packet is received.
If packet is a control packet, it will call MpRecvCtrlPacket(), otherwise
it will identify the call and notify NDISWAN about the packet received.
Parameters:
pBinding _ Pointer to the binding structure that packet was received over.
pPacket _ A PPPoE packet received over the wire.
Return Values:
None
---------------------------------------------------------------------------*/
{
ADAPTER* pAdapter = NULL;
CALL* pCall = NULL;
TRACE( TL_V, TM_Mp, ("+MpReceivePacket($%x)",pPacket) );
if ( !gl_fLockAllocated )
{
TRACE( TL_V, TM_Mp, ("-MpReceivePacket($%x): Lock not allocated",pPacket) );
return;
}
NdisAcquireSpinLock( &gl_lockAdapter );
if ( gl_pAdapter &&
!( gl_pAdapter->ulMpFlags & MPBF_MiniportHaltPending ) &&
( gl_pAdapter->ulMpFlags & MPBF_MiniportInitialized ) )
{
pAdapter = gl_pAdapter;
NdisAcquireSpinLock( &pAdapter->lockAdapter );
if ( !( pAdapter->TapiProv.ulTpFlags & TPBF_TapiProvShutdownPending ) &&
( pAdapter->TapiProv.ulTpFlags & TPBF_TapiProvInitialized ) )
{
ReferenceTapiProv( pAdapter, FALSE );
NdisReleaseSpinLock( &pAdapter->lockAdapter );
}
else
{
NdisReleaseSpinLock( &pAdapter->lockAdapter );
pAdapter = NULL;
}
}
NdisReleaseSpinLock( &gl_lockAdapter );
if ( pAdapter == NULL )
{
TRACE( TL_V, TM_Mp, ("-MpReceivePacket($%x): Adapter not found",pPacket) );
return;
}
if ( PacketGetCode( pPacket ) == PACKET_CODE_PAYLOAD )
{
//
// Payload packet is received
//
pCall = MpMapPacketWithSessionIdToCall( pAdapter, pPacket );
if ( pCall )
{
NdisAcquireSpinLock( &pCall->lockCall );
//
// Make sure call is not dropped, closed or closing, and receive window is still open
//
if ( !( pCall->ulClFlags & ( CLBF_CallDropped | CLBF_CallClosePending | CLBF_CallClosed ) ) &&
( pCall->nReceivedPackets < MAX_RECEIVED_PACKETS ) )
{
//
// Reference the packet. It will be dereferenced when indicated to NDISWAN, or
// when the queue is destroyed because the call is getting cleaned up.
//
ReferencePacket( pPacket );
//
// Insert into the receive queue and bump up the received packet count
//
InsertTailList( &pCall->linkReceivedPackets, &pPacket->linkPackets );
pCall->nReceivedPackets++;
//
// Try to schedule an IndicateReceivedPackets handler
//
MpScheduleIndicateReceivedPacketsHandler( pCall );
}
NdisReleaseSpinLock( &pCall->lockCall );
//
// Remove the reference added by MpMapPacketWithSessionIdToCall()
//
DereferenceCall( pCall );
}
}
else
{
//
// Control packet is received, process it
//
MpRecvCtrlPacket( pBinding, pPacket );
}
//
// Remove the reference added above
//
DereferenceTapiProv( pAdapter );
TRACE( TL_V, TM_Mp, ("-MpReceivePacket($%x)",pPacket) );
}
VOID
MpIndicateReceivedPackets(
IN TIMERQITEM* pTqi,
IN VOID* pContext,
IN TIMERQEVENT event
)
{
ULONG ulPacketsToIndicate = MAX_INDICATE_RECEIVED_PACKETS;
CALL* pCall = (CALL*) pContext;
PPPOE_PACKET* pPacket = NULL;
LIST_ENTRY* pLink = NULL;
ASSERT( VALIDATE_CALL( pCall ) );
NdisAcquireSpinLock( &pCall->lockCall );
while ( ulPacketsToIndicate > 0 &&
pCall->stateCall == CL_stateSessionUp &&
pCall->nReceivedPackets > 0)
{
ulPacketsToIndicate--;
pLink = RemoveHeadList( &pCall->linkReceivedPackets );
pCall->nReceivedPackets--;
NdisReleaseSpinLock( &pCall->lockCall );
{
NDIS_STATUS status;
CHAR* pPayload = NULL;
USHORT usSize = 0;
pPacket = (PPPOE_PACKET*) CONTAINING_RECORD( pLink, PPPOE_PACKET, linkPackets );
PacketRetrievePayload( pPacket,
&pPayload,
&usSize );
//
// Future: Make sure the size of the packet is less than the max of what NDISWAN expects
//
// if ( usSize > pCall->NdisWanLinkInfo.MaxRecvFrameSize )
// {
// TRACE( TL_A, TM_Mp, ("MpReceivePacket($%x): PAYLOAD too large to be indicated to NDISWAN",pPacket) );
// }
// else
TRACE( TL_V, TM_Mp, ("MpReceivePacket($%x): PAYLOAD is being indicated to NDISWAN",pPacket) );
NdisMWanIndicateReceive( &status,
pCall->pLine->pAdapter->MiniportAdapterHandle,
pCall->NdisLinkContext,
pPayload,
(UINT) usSize );
DereferencePacket( pPacket );
}
NdisAcquireSpinLock( &pCall->lockCall );
}
//
// Check if there are more packets to indicate
//
if ( pCall->stateCall == CL_stateSessionUp &&
pCall->nReceivedPackets > 0)
{
//
// More packets to indicate, so schedule another timer manually.
// We can not use MpScheduleIndicateReceivedPacketsHandler() function here
// because of performance reasons, so we do it manually.
//
// Since we are scheduling another handler, we do not dereference and reference
// the call context.
//
TimerQInitializeItem( &pCall->timerReceivedPackets );
TimerQScheduleItem( &gl_TimerQ,
&pCall->timerReceivedPackets,
(ULONG) RECEIVED_PACKETS_TIMEOUT,
MpIndicateReceivedPackets,
(PVOID) pCall );
NdisReleaseSpinLock( &pCall->lockCall );
}
else
{
//
// We are done, so let's remove the reference on the call context, and
// reset the CLBF_CallReceivePacketHandlerScheduled flag
//
pCall->ulClFlags &= ~CLBF_CallReceivePacketHandlerScheduled;
NdisReleaseSpinLock( &pCall->lockCall );
DereferenceCall( pCall );
}
}
VOID
MpScheduleIndicateReceivedPacketsHandler(
CALL* pCall
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will be called to schedule MpIndicateReceivedPackets() handler.
It will check if we are allowed to schedule it first, and if we are, then it
will schedule it and reference the call context.
CAUTION :Caller MUST be holding pCall->lockCall.
Parameters:
pCall _ Pointer to our call context.
Return Values:
NONE
---------------------------------------------------------------------------*/
{
if ( !( pCall->ulClFlags & CLBF_CallReceivePacketHandlerScheduled ) &&
pCall->stateCall == CL_stateSessionUp &&
pCall->nReceivedPackets > 0 )
{
pCall->ulClFlags |= CLBF_CallReceivePacketHandlerScheduled;
TimerQInitializeItem( &pCall->timerReceivedPackets );
TimerQScheduleItem( &gl_TimerQ,
&pCall->timerReceivedPackets,
(ULONG) RECEIVED_PACKETS_TIMEOUT,
MpIndicateReceivedPackets,
(PVOID) pCall );
ReferenceCall( pCall, FALSE );
}
}
NDIS_STATUS
MpWanGetInfo(
IN ADAPTER* pAdapter,
IN PNDIS_WAN_INFO pWanInfo
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will be called when miniport receives an OID_WAN_GET_INFO
query from NDISWAN. It will acquire the necesarry information and return it
back to NDISWAN.
All the info is initialized when the adapter is initialized except for
MaxFrameSize which depends on the active bindings. That's why we query
the protocol to get the current MaxFrameSize, and pass it back.
Parameters:
pAdapter _ Pointer to our adapter context.
pWanInfo _ Pointer to the NDIS_WAN_INFO structure to be filled in.
Return Values:
NDIS_STATUS_SUCCESS
---------------------------------------------------------------------------*/
{
NDIS_STATUS status = NDIS_STATUS_SUCCESS;
TRACE( TL_N, TM_Mp, ("+MpWanGetInfo") );
//
// Retrieve the current MaxFrameSize from protocol
//
pAdapter->NdisWanInfo.MaxFrameSize = PrQueryMaxFrameSize();
//
// Pass data back to NDISWAN
//
*pWanInfo = pAdapter->NdisWanInfo;
TRACE( TL_N, TM_Mp, ("-MpWanGetInfo()=$%x",status) );
return status;
}
NDIS_STATUS
MpWanGetLinkInfo(
IN ADAPTER* pAdapter,
IN PNDIS_WAN_GET_LINK_INFO pWanLinkInfo
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will be called when miniport receives an OID_WAN_GET_LINK_INFO
query from NDISWAN. It will acquire the necesarry information and return it
back to NDISWAN.
All the info is initialized in TpCallStateChangeHandler() when TAPI is signaled
to LINECALLSTATE_CONNECTED state.
Parameters:
pAdapter _ Pointer to our adapter context.
pWanLinkInfo _ Pointer to the NDIS_WAN_GET_LINK_INFO structure to be filled in.
Return Values:
NDIS_STATUS_FAILURE
NDIS_STATUS_SUCCESS
---------------------------------------------------------------------------*/
{
NDIS_STATUS status = NDIS_STATUS_FAILURE;
CALL* pCall = NULL;
TRACE( TL_N, TM_Mp, ("+MpWanGetLinkInfo") );
pCall = RetrieveFromHandleTable( pAdapter->TapiProv.hCallTable,
pWanLinkInfo->NdisLinkHandle );
if ( pCall )
{
*pWanLinkInfo = pCall->NdisWanLinkInfo;
status = NDIS_STATUS_SUCCESS;
}
TRACE( TL_N, TM_Mp, ("-MpWanGetLinkInfo()=$%x",status) );
return status;
}
NDIS_STATUS
MpWanSetLinkInfo(
IN ADAPTER* pAdapter,
IN PNDIS_WAN_SET_LINK_INFO pWanLinkInfo
)
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Functional Description:
This function will be called when miniport receives an OID_WAN_SET_LINK_INFO
request from NDISWAN. It will do some checks on the passed in params, and if
the values are acceptiable it will copy them onto the call context.
Parameters:
pAdapter _ Pointer to our adapter context.
pWanLinkInfo _ Pointer to the NDIS_WAN_SET_LINK_INFO structure.
Return Values:
NDIS_STATUS_FAILURE
NDIS_STATUS_SUCCESS
---------------------------------------------------------------------------*/
{
NDIS_STATUS status = NDIS_STATUS_FAILURE;
CALL* pCall = NULL;
TRACE( TL_N, TM_Mp, ("+MpWanSetLinkInfo") );
pCall = RetrieveFromHandleTable( pAdapter->TapiProv.hCallTable,
pWanLinkInfo->NdisLinkHandle );
if ( pCall )
{
do
{
if ( pWanLinkInfo->MaxSendFrameSize > pCall->ulMaxFrameSize )
{
TRACE( TL_A, TM_Mp, ("MpWanSetLinkInfo: Requested MaxSendFrameSize is larger than NIC's") );
}
if ( pWanLinkInfo->MaxRecvFrameSize < pCall->ulMaxFrameSize )
{
TRACE( TL_A, TM_Mp, ("MpWanSetLinkInfo: Requested MaxRecvFrameSize is smaller than NIC's") );
}
if ( pWanLinkInfo->HeaderPadding != pAdapter->NdisWanInfo.HeaderPadding )
{
TRACE( TL_A, TM_Mp, ("MpWanSetLinkInfo: Requested HeaderPadding is different than what we asked for") );
}
if ( pWanLinkInfo->SendFramingBits & ~pAdapter->NdisWanInfo.FramingBits )
{
TRACE( TL_A, TM_Mp, ("MpWanSetLinkInfo: Unknown send framing bits requested") );
break;
}
if ( pWanLinkInfo->RecvFramingBits & ~pAdapter->NdisWanInfo.FramingBits )
{
TRACE( TL_A, TM_Mp, ("MpWanSetLinkInfo: Unknown recv framing bits requested") );
break;
}
pCall->NdisWanLinkInfo = * ( (PNDIS_WAN_GET_LINK_INFO) pWanLinkInfo );
status = NDIS_STATUS_SUCCESS;
} while ( FALSE );
}
TRACE( TL_N, TM_Mp, ("-MpWanSetLinkInfo()=$%x",status) );
return status;
}
Reference in a new issue Copy permalink