able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/atm/arp/atmarpc/adapter.c

2719 lines
61 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
adapter.c - Adapter Interface routines.
Abstract:
Handlers for adapter events are here. The only exception is the
CoReceivePacket handler, which is in arppkt.c.
Revision History:
Who When What
-------- -------- ----------------------------------------------
arvindm 08-12-96 Created
Notes:
--*/
#include <precomp.h>
#define _FILENUMBER 'PADA'
ULONG MCastSendOk = 0;
ULONG MCastSendFail = 0;
ULONG MCastRcv = 0;
INT
AtmArpBindAdapterHandler(
OUT PNDIS_STATUS pStatus,
IN NDIS_HANDLE BindContext,
IN PNDIS_STRING pDeviceName,
IN PVOID SystemSpecific1,
IN PVOID SystemSpecific2
)
/*++
Routine Description:
This is called by NDIS when it has an adapter for which there is a
binding to the ATMARP client.
We first allocate an Adapter structure. Then we open our configuration
section for this adapter and save the handle in the Adapter structure.
Finally, we open the adapter.
We don't do anything more for this adapter until NDIS notifies us of
the presence of a Call manager (via our AfRegisterNotify handler).
Arguments:
pStatus - Place to return status of this call
BindContext - Not used, because we don't pend this call
pDeviceName - The name of the adapter we are requested to bind to
SystemSpecific1 - Opaque to us; to be used to access configuration info
SystemSpecific2 - Opaque to us; not used.
Return Value:
Always TRUE. We set *pStatus to an error code if something goes wrong before we
call NdisOpenAdapter, otherwise NDIS_STATUS_PENDING.
--*/
{
PATMARP_ADAPTER pAdapter; // Pointer to new adapter structure
PATMARP_ADAPTER * ppAdapter; // Used in case we need to delink
NDIS_STATUS Status;
NDIS_STATUS OpenStatus;
UINT MediumIndex;
ULONG Length;
PNDIS_STRING pAdapterConfigString;
#ifdef ATMARP_WIN98
PANSI_STRING pAnsiConfigString;
NDIS_STRING UnicodeConfigString;
#endif
AADEBUGP(AAD_LOUD,
("BindAdapter: Context 0x%x, pDevName 0x%x, SS1 0x%x, SS2 0x%x\n",
BindContext, pDeviceName, SystemSpecific1, SystemSpecific2));
#if DBG
if (AaSkipAll)
{
AADEBUGP(AAD_ERROR, ("BindAdapter: aborting\n"));
*pStatus = NDIS_STATUS_NOT_RECOGNIZED;
return ((INT)TRUE);
}
#endif // DBG
//
// Initialize.
//
pAdapter = NULL_PATMARP_ADAPTER;
Status = NDIS_STATUS_SUCCESS;
#ifdef ATMARP_WIN98
UnicodeConfigString.Buffer = NULL;
#endif
do
{
#ifndef ATMARP_WIN98
pAdapterConfigString = (PNDIS_STRING)SystemSpecific1;
#else
//
// SS1 is a pointer to an ANSI string. Convert it to Unicode.
//
pAnsiConfigString = (PANSI_STRING)SystemSpecific1;
AA_ALLOC_MEM(UnicodeConfigString.Buffer, WCHAR, sizeof(WCHAR)*(pAnsiConfigString->MaximumLength));
if (UnicodeConfigString.Buffer == NULL)
{
Status = NDIS_STATUS_RESOURCES;
break;
}
UnicodeConfigString.MaximumLength = sizeof(WCHAR) * (pAnsiConfigString->MaximumLength);
UnicodeConfigString.Length = 0;
NdisAnsiStringToUnicodeString(&UnicodeConfigString, pAnsiConfigString);
pAdapterConfigString = &UnicodeConfigString;
#endif
//
// Check if this is a device we have already bound to.
//
if (AtmArpIsDeviceAlreadyBound(pDeviceName))
{
Status = NDIS_STATUS_NOT_ACCEPTED;
AADEBUGP(AAD_WARNING, ("BindAdapter: already bound to %Z\n", pDeviceName));
break;
}
//
// Allocate an Adapter structure
//
Length = sizeof(ATMARP_ADAPTER) + pDeviceName->MaximumLength + sizeof(WCHAR) + pAdapterConfigString->MaximumLength;
AA_ALLOC_MEM(pAdapter, ATMARP_ADAPTER, Length);
if (pAdapter == NULL_PATMARP_ADAPTER)
{
Status = NDIS_STATUS_RESOURCES;
break;
}
//
// Initialize the Adapter structure
//
AA_SET_MEM(pAdapter, 0, Length);
#if DBG
pAdapter->aaa_sig = aaa_signature;
#endif // DBG
AA_INIT_BLOCK_STRUCT(&(pAdapter->Block));
pAdapter->SystemSpecific1 = SystemSpecific1;
pAdapter->SystemSpecific2 = SystemSpecific2;
pAdapter->BindContext = BindContext;
pAdapter->DeviceName.MaximumLength = pDeviceName->MaximumLength;
pAdapter->DeviceName.Length = pDeviceName->Length;
pAdapter->DeviceName.Buffer = (PWCHAR)((PUCHAR)pAdapter + sizeof(ATMARP_ADAPTER));
AA_COPY_MEM(pAdapter->DeviceName.Buffer,
pDeviceName->Buffer,
pDeviceName->Length);
//
// Copy in the string to be used when we want to open our
// configuration key for this adapter.
//
pAdapter->ConfigString.MaximumLength = pAdapterConfigString->MaximumLength;
pAdapter->ConfigString.Length = pAdapterConfigString->Length;
pAdapter->ConfigString.Buffer = (PWCHAR)((PUCHAR)pAdapter + sizeof(ATMARP_ADAPTER)+ pDeviceName->MaximumLength) + sizeof(WCHAR);
AA_COPY_MEM(pAdapter->ConfigString.Buffer,
pAdapterConfigString->Buffer,
pAdapterConfigString->Length);
AA_INIT_BLOCK_STRUCT(&pAdapter->UnbindBlock);
AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo);
//
// Link this Adapter structure to the global list of adapters.
//
pAtmArpGlobalInfo->AdapterCount++;
pAdapter->pNextAdapter = pAtmArpGlobalInfo->pAdapterList;
pAtmArpGlobalInfo->pAdapterList = pAdapter;
AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo);
//
// Open the adapter
//
pAdapter->Medium = NdisMediumAtm;
NdisOpenAdapter(
&Status,
&OpenStatus,
&(pAdapter->NdisAdapterHandle),
&(MediumIndex), // place to return selected medium index
&pAdapter->Medium, // Array of medium types
1, // Size of Media list
pAtmArpGlobalInfo->ProtocolHandle,
(NDIS_HANDLE)pAdapter, // our context for the adapter binding
pDeviceName,
0, // Open options
(PSTRING)NULL // Addressing Info...
);
if (Status != NDIS_STATUS_PENDING)
{
AtmArpOpenAdapterCompleteHandler(
(NDIS_HANDLE)pAdapter,
Status,
OpenStatus
);
}
Status = NDIS_STATUS_PENDING;
break;
}
while (FALSE);
if (Status != NDIS_STATUS_PENDING)
{
//
// We didn't make it upto NdisOpenAdapter. Clean up.
//
AADEBUGP(AAD_WARNING, ("BindAdapter: failed with Status 0x%x\n", Status));
if (pAdapter != NULL_PATMARP_ADAPTER)
{
//
// Free it. We know we haven't linked it to the global
// list of adapters.
//
AA_FREE_MEM(pAdapter);
}
}
#ifdef ATMARP_WIN98
if (UnicodeConfigString.Buffer != NULL)
{
AA_FREE_MEM(UnicodeConfigString.Buffer);
}
#endif // ATMARP_WIN98
*pStatus = Status;
AADEBUGP(AAD_INFO, ("BindAdapterHandler: returning Status 0x%x\n", Status));
return ((INT)TRUE);
}
VOID
AtmArpUnbindAdapterHandler(
OUT PNDIS_STATUS pStatus,
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE UnbindContext
)
/*++
Routine Description:
This routine is called by NDIS when it wants us to unbind
from an adapter. Or, this may be called from within our Unload
handler. We undo the sequence of operations we performed
in our BindAdapter handler.
Arguments:
pStatus - Place to return status of this operation
ProtocolBindingContext - Our context for this adapter binding, which
is a pointer to an ATMARP Adapter structure.
UnbindContext - This is NULL if this routine is called from
within our Unload handler. Otherwise (i.e.
NDIS called us), we retain this for later use
when calling NdisCompleteUnbindAdapter.
Return Value:
None. We set *pStatus to NDIS_STATUS_PENDING always.
--*/
{
PATMARP_ADAPTER pAdapter;
PATMARP_INTERFACE pInterface;
PATMARP_INTERFACE pNextInterface;
NDIS_STATUS Status;
#if DBG
AA_IRQL EntryIrq, ExitIrq;
#endif
AA_GET_ENTRY_IRQL(EntryIrq);
pAdapter = (PATMARP_ADAPTER)ProtocolBindingContext;
AA_STRUCT_ASSERT(pAdapter, aaa);
AADEBUGP(AAD_INFO, ("UnbindAdapterHandler: pAdapter 0x%x, UnbindContext 0x%x\n",
pAdapter, UnbindContext));
*pStatus = NDIS_STATUS_PENDING;
AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo);
//
// Save the unbind context for a possible later call to
// NdisCompleteUnbindAdapter.
//
pAdapter->UnbindContext = UnbindContext;
pAdapter->Flags |= AA_ADAPTER_FLAGS_UNBINDING;
//
// Wait for any AF register processing to finish.
//
while (pAdapter->Flags & AA_ADAPTER_FLAGS_PROCESSING_AF)
{
AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo);
AADEBUGP(AAD_FATAL, ("UnbindAdapter: pAdapter %x, Afregister going on!!!\n", pAdapter));
Status = AA_WAIT_ON_BLOCK_STRUCT(&(pAdapter->UnbindBlock));
AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo);
}
AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo);
//
// If there are no Interfaces on this adapter, we are done.
//
if (pAdapter->pInterfaceList == NULL_PATMARP_INTERFACE)
{
AtmArpCompleteUnbindAdapter(pAdapter);
AA_CHECK_EXIT_IRQL(EntryIrq, ExitIrq);
return;
}
//
// Mark all interfaces on this adapter.
//
for (pInterface = pAdapter->pInterfaceList;
pInterface != NULL_PATMARP_INTERFACE;
pInterface = pNextInterface)
{
pNextInterface = pInterface->pNextInterface;
AA_ACQUIRE_IF_LOCK(pInterface);
pInterface->AdminState = pInterface->State = IF_STATUS_DOWN;
pInterface->LastChangeTime = GetTimeTicks();
AA_RELEASE_IF_LOCK(pInterface);
}
//
// Now, bring down each of these interfaces. For each interface,
// we tear down the ARP table, and shut down the Call Manager
// interface. When this is complete, we will call IP's DelInterface
// entry point.
//
for (pInterface = pAdapter->pInterfaceList;
pInterface != NULL_PATMARP_INTERFACE;
pInterface = pNextInterface)
{
pNextInterface = pInterface->pNextInterface;
AtmArpShutdownInterface(pInterface);
}
AA_CHECK_EXIT_IRQL(EntryIrq, ExitIrq);
return;
}
VOID
AtmArpCompleteUnbindAdapter(
IN PATMARP_ADAPTER pAdapter
)
/*++
Routine Description:
Complete the process of adapter unbinding. All Interfaces on this
adapter are assumed to have been removed.
If we are unbinding from the adapter as a result of NDIS' call to
our UnbindAdapter handler, we complete that here.
Arguments:
pAdapter - Pointer to the adapter being unbound.
Return Value:
None
--*/
{
NDIS_HANDLE UnbindContext;
PATMARP_ADAPTER * ppAdapter;
NDIS_STATUS Status;
UnbindContext = pAdapter->UnbindContext;
AADEBUGP(AAD_INFO, ("CompleteUnbindAdapter: pAdapter 0x%x, UnbindContext 0x%x\n",
pAdapter, UnbindContext));
AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo);
if (pAdapter->Flags & AA_ADAPTER_FLAGS_CLOSING)
{
AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo);
return;
}
pAdapter->Flags |= AA_ADAPTER_FLAGS_CLOSING;
AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo);
#if ATMOFFLOAD
//
// Disable offload if enabled...
//
AtmArpDisableOffload(pAdapter);
#endif // ATMOFFLOAD
NdisCloseAdapter(
&Status,
pAdapter->NdisAdapterHandle
);
if (Status != NDIS_STATUS_PENDING)
{
AtmArpCloseAdapterCompleteHandler(
(NDIS_HANDLE) pAdapter,
Status
);
}
}
VOID
AtmArpOpenAdapterCompleteHandler(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS Status,
IN NDIS_STATUS OpenErrorStatus
)
/*++
Routine Description:
This is called by NDIS when a previous call to NdisOpenAdapter
that had pended has completed. We now complete the BindAdapter
that lead to this.
Arguments:
ProtocolBindingContext - Our context for this adapter binding, which
is a pointer to an ATMARP Adapter structure.
Status - Status of OpenAdapter
OpenErrorStatus - Error code in case of failure.
Return Value:
None
--*/
{
PATMARP_ADAPTER pAdapter;
PATMARP_ADAPTER * ppAdapter;
NDIS_HANDLE BindAdapterContext;
pAdapter = (PATMARP_ADAPTER)ProtocolBindingContext;
AA_STRUCT_ASSERT(pAdapter, aaa);
BindAdapterContext = pAdapter->BindContext;
if (Status != NDIS_STATUS_SUCCESS)
{
//
// Remove the adapter from the global list.
//
AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo);
ppAdapter = &(pAtmArpGlobalInfo->pAdapterList);
while (*ppAdapter != pAdapter)
{
ppAdapter = &((*ppAdapter)->pNextAdapter);
}
*ppAdapter = pAdapter->pNextAdapter;
pAtmArpGlobalInfo->AdapterCount--;
AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo);
AA_FREE_MEM(pAdapter);
}
#if ATMOFFLOAD
else
{
//
// Query and enable offloading
//
Status = AtmArpQueryAndEnableOffload(pAdapter);
if (Status != NDIS_STATUS_SUCCESS)
{
//
// AtmArpQueryAndEnableOffload is not supposed to return unless
// there's a fatal error -- we don't expect this.
//
AA_ASSERT(FALSE);
}
}
#endif //ATMOFFLOAD
AADEBUGP(AAD_INFO, ("OpenAdapterComplete: pAdapter 0x%x, Status 0x%x\n",
pAdapter, Status));
(*(pAtmArpGlobalInfo->pIPBindCompleteRtn))(
Status,
BindAdapterContext
);
return;
}
VOID
AtmArpCloseAdapterCompleteHandler(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS Status
)
/*++
Routine Description:
This is called by NDIS when a previous call to NdisCloseAdapter
that had pended has completed. The thread that called NdisCloseAdapter
would have blocked itself, so we simply wake it up now.
Arguments:
ProtocolBindingContext - Our context for this adapter binding, which
is a pointer to an ATMARP Adapter structure.
Status - Status of CloseAdapter
Return Value:
None
--*/
{
PATMARP_ADAPTER pAdapter;
NDIS_HANDLE UnbindContext;
PATMARP_ADAPTER * ppAdapter;
pAdapter = (PATMARP_ADAPTER)ProtocolBindingContext;
AA_STRUCT_ASSERT(pAdapter, aaa);
UnbindContext = pAdapter->UnbindContext;
AADEBUGP(AAD_INFO, ("CloseAdapterCompleteHandler: pAdapter 0x%x, UnbindContext 0x%x\n",
pAdapter, UnbindContext));
pAdapter->NdisAdapterHandle = NULL;
//
// Remove the adapter from the global list.
//
AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo);
ppAdapter = &(pAtmArpGlobalInfo->pAdapterList);
while (*ppAdapter != pAdapter)
{
ppAdapter = &((*ppAdapter)->pNextAdapter);
}
*ppAdapter = pAdapter->pNextAdapter;
pAtmArpGlobalInfo->AdapterCount--;
AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo);
//
// Free any structures attached to the adapter structure.
//
if (pAdapter->pDescrString != (PUCHAR)NULL)
{
AA_FREE_MEM(pAdapter->pDescrString);
}
if (pAdapter->IPConfigString.Buffer != NULL)
{
AA_FREE_MEM(pAdapter->IPConfigString.Buffer);
}
//
// Release the adapter structure.
//
AA_FREE_MEM(pAdapter);
//
// If NDIS had requested us to Unbind, complete the
// request now.
//
if (UnbindContext != (NDIS_HANDLE)NULL)
{
NdisCompleteUnbindAdapter(
UnbindContext,
NDIS_STATUS_SUCCESS
);
}
else
{
//
// We initiated the unbind from our Unload handler,
// which would have been waiting for us to complete.
// Wake up that thread now.
//
AA_SIGNAL_BLOCK_STRUCT(&(pAtmArpGlobalInfo->Block), NDIS_STATUS_SUCCESS);
}
}
VOID
AtmArpSendCompleteHandler(
IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_PACKET pNdisPacket,
IN NDIS_STATUS Status
)
/*++
Routine Description:
This is the Connection-less Send Complete handler, which signals
completion of such a Send. Since we don't ever use this feature,
we don't expect this routine to be called.
Arguments:
<Ignored>
Return Value:
None
--*/
{
AADEBUGP(AAD_ERROR, ("SendCompleteHandler unexpected\n"));
AA_ASSERT(FALSE);
}
VOID
AtmArpTransferDataCompleteHandler(
IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_PACKET pNdisPacket,
IN NDIS_STATUS Status,
IN UINT BytesTransferred
)
/*++
Routine Description:
This is the Connection-less Transfer Data Complete handler, which
signals completion of a call to NdisTransferData. Since we never
call NdisTransferData, this routine should never get called.
Arguments:
<Ignored>
Return Value:
None
--*/
{
AADEBUGP(AAD_ERROR, ("TransferDataComplete Handler unexpected!\n"));
AA_ASSERT(FALSE);
}
VOID
AtmArpResetCompleteHandler(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS Status
)
/*++
Routine Description:
This routine is called when the miniport indicates that a Reset
operation has just completed. We ignore this event.
Arguments:
ProtocolBindingContext - Our context for this adapter binding, which
is a pointer to an ATMARP Adapter structure.
Status - Status of the reset operation.
Return Value:
None
--*/
{
PATMARP_ADAPTER pAdapter;
pAdapter = (PATMARP_ADAPTER)ProtocolBindingContext;
AA_STRUCT_ASSERT(pAdapter, aaa);
AADEBUGP(AAD_INFO, ("Reset Complete on Adapter 0x%x\n", pAdapter));
}
VOID
AtmArpRequestCompleteHandler(
IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_REQUEST pNdisRequest,
IN NDIS_STATUS Status
)
/*++
Routine Description:
This is called by NDIS when a previous call we made to NdisRequest() has
completed. We would be blocked on our adapter structure, waiting for this
to happen -- wake up the blocked thread.
Arguments:
ProtocolBindingContext - Pointer to our Adapter structure
pNdisRequest - The request that completed
Status - Status of the request.
Return Value:
None
--*/
{
PATMARP_ADAPTER pAdapter;
pAdapter = (PATMARP_ADAPTER)ProtocolBindingContext;
AA_STRUCT_ASSERT(pAdapter, aaa);
AA_SIGNAL_BLOCK_STRUCT(&(pAdapter->Block), Status);
return;
}
NDIS_STATUS
AtmArpReceiveHandler(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE MacReceiveContext,
IN PVOID pHeaderBuffer,
IN UINT HeaderBufferSize,
IN PVOID pLookAheadBuffer,
IN UINT LookaheadBufferSize,
IN UINT PacketSize
)
/*++
Routine Description:
This is our Connection-less receive handler. Since we only use
Connection oriented services, this routine should never get called.
Arguments:
<Ignored>
Return Value:
None
--*/
{
AADEBUGP(AAD_ERROR, ("Connectionless ReceiveHandler unexpected\n"));
AA_ASSERT(FALSE);
return(NDIS_STATUS_NOT_RECOGNIZED);
}
VOID
AtmArpReceiveCompleteHandler(
IN NDIS_HANDLE ProtocolBindingContext
)
/*++
Routine Description:
This is called by NDIS when the miniport is done with receiving
a bunch of packets, meaning that it is now time to start processing
them. We simply pass this on to IP (on all IF's configured on this
adapter).
Arguments:
ProtocolBindingContext - Our context for this adapter binding, which
is a pointer to an ATMARP Adapter structure.
Return Value:
None
--*/
{
PATMARP_ADAPTER pAdapter;
PATMARP_INTERFACE pInterface;
pAdapter = (PATMARP_ADAPTER)ProtocolBindingContext;
AA_STRUCT_ASSERT(pAdapter, aaa);
for (pInterface = pAdapter->pInterfaceList;
pInterface != NULL_PATMARP_INTERFACE;
pInterface = pInterface->pNextInterface)
{
(*(pInterface->IPRcvCmpltHandler))();
}
}
INT
AtmArpReceivePacketHandler(
IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_PACKET pNdisPacket
)
/*++
Routine Description:
This is the Connectionless receive handler, which should never be
called, since we only use Connection Oriented miniport services.
Arguments:
<Ignored>
Return Value:
Reference count on the received packet. We always return 0.
--*/
{
AADEBUGP(AAD_ERROR, ("ReceivePacket Handler unexpected!\n"));
AA_ASSERT(FALSE);
return(0);
}
VOID
AtmArpStatusHandler(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS GeneralStatus,
IN PVOID pStatusBuffer,
IN UINT StatusBufferSize
)
/*++
Routine Description:
This routine is called when the miniport indicates an adapter-wide
status change. We ignore this.
Arguments:
<Ignored>
Return Value:
None
--*/
{
AADEBUGP(AAD_INFO, ("Status Handler: Bind Ctx 0x%x, Status 0x%x\n",
ProtocolBindingContext,
GeneralStatus));
}
VOID
AtmArpStatusCompleteHandler(
IN NDIS_HANDLE ProtocolBindingContext
)
/*++
Routine Description:
This routine is called when the miniport wants to tell us about
completion of a status change (?). Ignore this.
Arguments:
<Ignored>
Return Value:
None
--*/
{
AADEBUGP(AAD_INFO, ("Status Complete Handler: Bind Ctx 0x%x\n",
ProtocolBindingContext));
}
VOID
AtmArpCoSendCompleteHandler(
IN NDIS_STATUS Status,
IN NDIS_HANDLE ProtocolVcContext,
IN PNDIS_PACKET pNdisPacket
)
/*++
Routine Description:
This routine is called by NDIS when the ATM miniport is finished
with a packet we had previously sent via NdisCoSendPackets. We first
check if this packet was generated by us (e.g. ATMARP protocol packet):
if so, we free this here. Otherwise (packet sent by the IP layer), we
first remove any header buffer that we had attached to the packet and
free it, before calling IP's entry point for Transmit Complete.
Arguments:
Status - Status of the NdisCoSendPackets.
ProtocolVcContext - Our context for the VC on which the packet was sent
(i.e. pointer to ATMARP VC).
pNdisPacket - The packet whose "send" is being completed.
Return Value:
None
--*/
{
PATMARP_VC pVc;
PATMARP_INTERFACE pInterface;
PacketContext *PC; // IP/ARP Info about this packet
PNDIS_BUFFER pNdisBuffer; // First Buffer in this packet
UINT TotalLength;
AA_HEADER_TYPE HdrType;
ATMARP_VC_ENCAPSULATION_TYPE Encapsulation;
ULONG rc;
pVc = (PATMARP_VC)ProtocolVcContext;
AA_STRUCT_ASSERT(pVc, avc);
#ifdef VC_REFS_ON_SENDS
AA_ACQUIRE_VC_LOCK(pVc);
pInterface = pVc->pInterface;
Encapsulation = pVc->FlowSpec.Encapsulation;
rc = AtmArpDereferenceVc(pVc); // SendComplete
if (rc != 0)
{
pVc->OutstandingSends--;
if (AA_IS_FLAG_SET(
pVc->Flags,
AA_VC_CLOSE_STATE_MASK,
AA_VC_CLOSE_STATE_CLOSING) &&
(pVc->OutstandingSends == 0))
{
AtmArpCloseCall(pVc);
//
// VC lock is released above.
//
}
else
{
AA_RELEASE_VC_LOCK(pVc);
}
}
#else
pInterface = pVc->pInterface;
Encapsulation = pVc->FlowSpec.Encapsulation;
#endif // VC_REFS_ON_SENDS
AA_ASSERT(pNdisPacket->Private.Head != NULL);
#if DBG
#if DBG_CO_SEND
{
PULONG pContext;
extern ULONG OutstandingSends;
pContext = (PULONG)&(pNdisPacket->WrapperReserved[0]);;
// Check for duplicate completion:
AA_ASSERT(*pContext != 'BbBb');
*pContext = 'BbBb';
NdisInterlockedDecrement(&OutstandingSends);
}
#endif // DBG_CO_SEND
#endif // DBG
NdisQueryPacket(
pNdisPacket,
NULL, // we don't need PhysicalBufferCount
NULL, // we don't need BufferCount
NULL, // we don't need FirstBuffer (yet)
&TotalLength
);
if (Status == NDIS_STATUS_SUCCESS)
{
AA_IF_STAT_ADD(pInterface, OutOctets, TotalLength);
}
else if (Status == NDIS_STATUS_RESOURCES)
{
AA_IF_STAT_INCR(pInterface, OutDiscards);
}
else if (Status != NDIS_STATUS_SUCCESS)
{
AA_IF_STAT_INCR(pInterface, OutErrors);
}
PC = (PacketContext *)pNdisPacket->ProtocolReserved;
AADEBUGP(AAD_EXTRA_LOUD,
("CoSend complete[%s]: VC 0x%x, Pkt 0x%x, Status 0x%x:\n",
((PC->pc_common.pc_owner != PACKET_OWNER_LINK)? "IP": "ARP"),
pVc, pNdisPacket, Status));
//
// Check who generated this packet.
//
if (PC->pc_common.pc_owner != PACKET_OWNER_LINK)
{
//
// Belongs to IP. Check if we had prepended an LLC/SNAP header.
//
if (Encapsulation == ENCAPSULATION_TYPE_LLCSNAP)
{
PUCHAR pPacket;
UINT Length;
#ifdef BACK_FILL
NdisQueryPacket(pNdisPacket, NULL, NULL, &pNdisBuffer, NULL);
AA_ASSERT(pNdisBuffer != NULL);
NdisQueryBuffer(pNdisBuffer, &pPacket, &Length);
//
// Commmon part first: find the header type, and update
// statistics.
//
if (pPacket[5] == LLC_SNAP_OUI2)
{
HdrType = AA_HEADER_TYPE_UNICAST;
if (Status == NDIS_STATUS_SUCCESS)
{
AA_IF_STAT_INCR(pInterface, OutUnicastPkts);
}
}
else
{
HdrType = AA_HEADER_TYPE_NUNICAST;
if (Status == NDIS_STATUS_SUCCESS)
{
AA_IF_STAT_INCR(pInterface, OutNonUnicastPkts);
INCR_STAT(MCastSendOk);
}
else
{
INCR_STAT(MCastSendFail);
}
}
//
// Now check if we had attached a header buffer or not.
//
if (AtmArpDoBackFill && AA_BACK_FILL_POSSIBLE(pNdisBuffer))
{
ULONG HeaderLength;
//
// We would have back-filled IP's buffer with the LLC/SNAP
// header. Remove the back-fill.
//
HeaderLength = ((HdrType == AA_HEADER_TYPE_UNICAST)?
sizeof(AtmArpLlcSnapHeader) :
#ifdef IPMCAST
sizeof(AtmArpMcType1ShortHeader));
#else
0);
#endif // IPMCAST
(PUCHAR)pNdisBuffer->MappedSystemVa += HeaderLength;
pNdisBuffer->ByteOffset += HeaderLength;
pNdisBuffer->ByteCount -= HeaderLength;
}
else
{
//
// The first buffer would be our header buffer. Remove
// it from the packet and return to our pool.
//
NdisUnchainBufferAtFront(pNdisPacket, &pNdisBuffer);
AtmArpFreeHeader(pInterface, pNdisBuffer, HdrType);
}
#else
//
// Free the LLC/SNAP header buffer.
//
NdisUnchainBufferAtFront(pNdisPacket, &pNdisBuffer);
AA_ASSERT(pNdisBuffer != NULL);
NdisQueryBuffer(pNdisBuffer, &pPacket, &Length);
if (pPacket[5] == LLC_SNAP_OUI2)
{
HdrType = AA_HEADER_TYPE_UNICAST;
if (Status == NDIS_STATUS_SUCCESS)
{
AA_IF_STAT_INCR(pInterface, OutUnicastPkts);
}
}
else
{
HdrType = AA_HEADER_TYPE_NUNICAST;
if (Status == NDIS_STATUS_SUCCESS)
{
AA_IF_STAT_INCR(pInterface, OutNonUnicastPkts);
INCR_STAT(MCastSendOk);
}
else
{
INCR_STAT(MCastSendFail);
}
}
AtmArpFreeHeader(pInterface, pNdisBuffer, HdrType);
#endif // BACK_FILL
}
#ifdef PERF
AadLogSendComplete(pNdisPacket);
#endif // PERF
//
// Inform IP of send completion.
//
(*(pInterface->IPTxCmpltHandler))(
pInterface->IPContext,
pNdisPacket,
Status
);
}
else
{
//
// Packet generated by the ATMARP module. This would be an
// ATMARP protocol packet, so free the NDIS buffer now.
//
NdisUnchainBufferAtFront(pNdisPacket, &pNdisBuffer);
AA_ASSERT(pNdisBuffer != NULL);
#if DBG
{
ULONG ArpPktLength;
PUCHAR ArpPktStart;
NdisQueryBuffer(pNdisBuffer, (PVOID)&ArpPktStart, &ArpPktLength);
AADEBUGPDUMP(AAD_EXTRA_LOUD+100, ArpPktStart, ArpPktLength);
}
#endif // DBG
AtmArpFreeProtoBuffer(pInterface, pNdisBuffer);
AtmArpFreePacket(pInterface, pNdisPacket);
}
return;
}
VOID
AtmArpCoStatusHandler(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE ProtocolVcContext OPTIONAL,
IN NDIS_STATUS GeneralStatus,
IN PVOID pStatusBuffer,
IN UINT StatusBufferSize
)
/*++
Routine Description:
This routine is called when the miniport indicates a status
change, possibly on a VC. Ignore this.
Arguments:
<Ignored>
Return Value:
None
--*/
{
AADEBUGP(AAD_INFO, ("CoStatus Handler: Bind Ctx 0x%x, VC Ctx 0x%x, Status 0x%x\n",
ProtocolBindingContext,
ProtocolVcContext,
GeneralStatus));
}
/*++
AtmArpCoReceivePacketHandler -- is in arppkt.c
--*/
#ifdef _PNP_POWER_
NDIS_STATUS
AtmArpPnPReconfigHandler(
IN PATMARP_ADAPTER pAdapter OPTIONAL,
IN PNET_PNP_EVENT pNetPnPEvent
)
/*++
Routine Description:
Handle a reconfig message on the specified adapter. If no adapter
is specified, it is a global parameter that has changed.
Arguments:
pAdapter - Pointer to our adapter structure
pNetPnPEvent - Pointer to reconfig event
Return Value:
NDIS_STATUS_SUCCESS always, for now.
--*/
{
ATMARPC_PNP_RECONFIG_REQUEST UNALIGNED * pArpReconfigReq;
PIP_PNP_RECONFIG_REQUEST pIpReconfigReq;
NDIS_STATUS Status;
pIpReconfigReq = (PIP_PNP_RECONFIG_REQUEST)pNetPnPEvent->Buffer;
AA_ASSERT(pIpReconfigReq->arpConfigOffset != 0);
pArpReconfigReq = (ATMARPC_PNP_RECONFIG_REQUEST UNALIGNED *)
((PUCHAR)pIpReconfigReq + pIpReconfigReq->arpConfigOffset);
AADEBUGP(AAD_WARNING, ("AtmArpPnPReconfig: pIpReconfig 0x%x, arpConfigOffset 0x%x\n",
pIpReconfigReq, pIpReconfigReq->arpConfigOffset));
do
{
PATMARP_INTERFACE pInterface;
PATMARP_INTERFACE pNextInterface;
NDIS_STRING IPReconfigString;
//
// Locate the IP interface string passed in...
//
ULONG uOffset = pArpReconfigReq->IfKeyOffset;
if (uOffset == 0)
{
Status = NDIS_STATUS_FAILURE;
break;
}
else
{
//
// ((PUCHAR)pArpReconfigReq + uOffset) points to a
// "counted unicode string", which means that it's an array
// of words, with the 1st word being the length in characters of
// the string (there is no terminating null) and the following
// <length> words being the string itself.
// We need to create an NDIS_STRING based on this buffer in order
// to compare it with each interface's config string.
//
PWCH pwc = (PWCH) ((PUCHAR)pArpReconfigReq + uOffset);
IPReconfigString.Length = sizeof(WCHAR)*pwc[0];
IPReconfigString.MaximumLength = IPReconfigString.Length;
IPReconfigString.Buffer = pwc+1;
}
//
// Do we have a binding context?
//
if (pAdapter == NULL_PATMARP_ADAPTER)
{
Status = NDIS_STATUS_FAILURE;
break;
}
//
// We wrap the search in a try-except clause because the passed-in
// structure could be bogus. Note that we will only test at most
// as many characters of the passed-in string as the lengths of
// our internal set of interface config strings.
//
try
{
//
// Find the interface associated with this request.
//
AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo);
for (pInterface = pAdapter->pInterfaceList;
pInterface != NULL_PATMARP_INTERFACE;
pInterface = pNextInterface)
{
BOOLEAN IsEqual = FALSE;
pNextInterface = pInterface->pNextInterface;
AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo);
//
// Compare the IPReconfigString
// JJ TODO: NdisEqualUnicodeString must be called in PASSIVE level
// we know that the reconfig call is done at passive level,
// but how to assert that fact here?
// AA_ASSERT(EntryIrq == PASSIVE_LEVEL);
//
IsEqual = NdisEqualUnicodeString(
&IPReconfigString,
&(pInterface->IPConfigString),
TRUE // case insensitive
);
AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo);
if (IsEqual)
{
break; // found it!
}
}
AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo);
}
except (EXCEPTION_EXECUTE_HANDLER)
{
Status = NDIS_STATUS_FAILURE;
break;
}
//
// JJ We should find the interface if this adapter has any interfaces
// at all -- else it means that we're being sent bogus reconfig
// information.
//
AA_ASSERT(pInterface!= NULL || pAdapter->pInterfaceList==NULL);
if (pInterface != NULL_PATMARP_INTERFACE)
{
AA_ACQUIRE_IF_LOCK(pInterface);
//
// Set it's state to indicate that a reconfig is pending.
// and save away pNetPnPEvent for completion later.
//
if ( pInterface->ReconfigState != RECONFIG_NOT_IN_PROGRESS
|| pInterface->pReconfigEvent != NULL)
{
AA_RELEASE_IF_LOCK(pInterface);
//
// We should not get here because this means that
// we were asked to reconfigure when there was a
// pending reconfiguration, which is not supposed to happen.
//
Status = NDIS_STATUS_FAILURE;
AA_ASSERT(FALSE);
}
else
{
pInterface->ReconfigState = RECONFIG_SHUTDOWN_PENDING;
pInterface->pReconfigEvent = pNetPnPEvent;
pInterface->AdminState = IF_STATUS_DOWN;
AtmArpReferenceInterface(pInterface); // Reconfig
AA_RELEASE_IF_LOCK(pInterface);
//
// Initiate shutdown in preparation of a restart.
// AtmArpShutdown is responsible for
// completing the ndis reconfig request asynchronously.
//
AtmArpShutdownInterface(pInterface);
Status = NDIS_STATUS_PENDING;
}
}
else
{
//
// We didn't find the interface, fail the request...
//
Status = NDIS_STATUS_FAILURE;
}
} while (FALSE);
return (Status);
}
NDIS_STATUS
AtmArpPnPEventHandler(
IN NDIS_HANDLE ProtocolBindingContext,
IN PNET_PNP_EVENT pNetPnPEvent
)
/*++
Routine Description:
This is the NDIS entry point called when NDIS wants to inform
us about a PNP/PM event happening on an adapter. If the event
is for us, we consume it. Otherwise, we pass this event along
to IP along the first Interface on this adapter.
When IP is done with it, it will call our IfPnPEventComplete
routine.
Arguments:
ProtocolBindingContext - Our context for this adapter binding, which
is a pointer to an ATMARP Adapter structure.
pNetPnPEvent - Pointer to the event.
Return Value:
None
--*/
{
PATMARP_ADAPTER pAdapter;
PATMARP_INTERFACE pInterface;
NDIS_STATUS Status;
PIP_PNP_RECONFIG_REQUEST pIpReconfigReq;
ULONG Length;
pAdapter = (PATMARP_ADAPTER)ProtocolBindingContext;
#ifdef NT
do
{
pIpReconfigReq = (PIP_PNP_RECONFIG_REQUEST)pNetPnPEvent->Buffer;
Length = pNetPnPEvent->BufferLength;
//
// Is this directed to us?
//
if (pNetPnPEvent->NetEvent == NetEventReconfigure)
{
if (Length < sizeof(IP_PNP_RECONFIG_REQUEST))
{
Status = NDIS_STATUS_RESOURCES;
break;
}
if (pIpReconfigReq->arpConfigOffset != 0)
{
Status = AtmArpPnPReconfigHandler(pAdapter, pNetPnPEvent);
break;
}
}
//
// This belongs to IP. Do we have a binding context?
//
if (pAdapter == NULL_PATMARP_ADAPTER)
{
Status = NDIS_STATUS_FAILURE;
break;
}
AA_STRUCT_ASSERT(pAdapter, aaa);
pInterface = pAdapter->pInterfaceList;
if ((pInterface != NULL_PATMARP_INTERFACE) &&
(pInterface->IPContext != NULL))
{
AA_ASSERT(pInterface->IPPnPEventHandler != NULL);
Status = (*pInterface->IPPnPEventHandler)(
pInterface->IPContext,
pNetPnPEvent
);
}
else
{
Status = NDIS_STATUS_SUCCESS;
}
break;
}
while (FALSE);
#else
Status = NDIS_STATUS_SUCCESS;
#endif // NT
AADEBUGP(AAD_INFO,
("PnPEventHandler: pIF 0x%x, pEvent 0x%x, Evt 0x%x, Status 0x%x\n",
pInterface, pNetPnPEvent, pNetPnPEvent->NetEvent, Status));
return (Status);
}
#endif // _PNP_POWER_
NDIS_STATUS
AtmArpSendAdapterNdisRequest(
IN PATMARP_ADAPTER pAdapter,
IN PNDIS_REQUEST pNdisRequest,
IN NDIS_REQUEST_TYPE RequestType,
IN NDIS_OID Oid,
IN PVOID pBuffer,
IN ULONG BufferLength
)
/*++
Routine Description:
Send an NDIS Request to query an adapter for information.
If the request pends, block on the ATMARP Adapter structure
till it completes.
Arguments:
pAdapter - Points to ATMARP Adapter structure
pNdisRequest - Pointer to NDIS request structure
RequestType - Set/Query information
Oid - OID to be passed in the request
pBuffer - place for value(s)
BufferLength - length of above
Return Value:
The NDIS status of the request.
--*/
{
NDIS_STATUS Status;
//
// Fill in the NDIS Request structure
//
pNdisRequest->RequestType = RequestType;
if (RequestType == NdisRequestQueryInformation)
{
pNdisRequest->DATA.QUERY_INFORMATION.Oid = Oid;
pNdisRequest->DATA.QUERY_INFORMATION.InformationBuffer = pBuffer;
pNdisRequest->DATA.QUERY_INFORMATION.InformationBufferLength = BufferLength;
pNdisRequest->DATA.QUERY_INFORMATION.BytesWritten = 0;
pNdisRequest->DATA.QUERY_INFORMATION.BytesNeeded = BufferLength;
}
else
{
pNdisRequest->DATA.SET_INFORMATION.Oid = Oid;
pNdisRequest->DATA.SET_INFORMATION.InformationBuffer = pBuffer;
pNdisRequest->DATA.SET_INFORMATION.InformationBufferLength = BufferLength;
pNdisRequest->DATA.SET_INFORMATION.BytesRead = 0;
pNdisRequest->DATA.SET_INFORMATION.BytesNeeded = 0;
}
AA_INIT_BLOCK_STRUCT(&(pAdapter->Block));
NdisRequest(
&Status,
pAdapter->NdisAdapterHandle,
pNdisRequest
);
if (Status == NDIS_STATUS_PENDING)
{
Status = AA_WAIT_ON_BLOCK_STRUCT(&(pAdapter->Block));
}
return (Status);
}
NDIS_STATUS
AtmArpGetAdapterInfo(
IN PATMARP_ADAPTER pAdapter
)
/*++
Routine Description:
Query an adapter for hardware-specific information that we need:
- burnt in hardware address (ESI part)
- Max packet size
- line rate
Arguments:
pAdapter - Pointer to ATMARP adapter structure
Return Value:
NDIS_STATUS_SUCCESS on success.
Failure code on some non-ignorable failure (such as
device doesn't support MTU >= 8196).
--*/
{
NDIS_STATUS Status;
NDIS_REQUEST NdisRequest;
ULONG Value;
//
// Initialize.
//
AA_SET_MEM(pAdapter->MacAddress, 0, AA_ATM_ESI_LEN);
do
{
//
// Description string: we first query this with a 0 length buffer
// length, so that we get the actual # of bytes needed. Then we
// allocate a buffer for the descriptor string, and use that to
// get the actual string.
//
Status = AtmArpSendAdapterNdisRequest(
pAdapter,
&NdisRequest,
NdisRequestQueryInformation,
OID_GEN_CO_VENDOR_DESCRIPTION,
(PVOID)(pAdapter->pDescrString),
0
);
if ((Status == NDIS_STATUS_INVALID_LENGTH) ||
(Status == NDIS_STATUS_BUFFER_TOO_SHORT))
{
//
// Now allocate a buffer of the right length.
//
pAdapter->DescrLength = NdisRequest.DATA.QUERY_INFORMATION.BytesNeeded;
AA_ALLOC_MEM(pAdapter->pDescrString, UCHAR, pAdapter->DescrLength);
if (pAdapter->pDescrString != (PUCHAR)NULL)
{
Status = AtmArpSendAdapterNdisRequest(
pAdapter,
&NdisRequest,
NdisRequestQueryInformation,
OID_GEN_CO_VENDOR_DESCRIPTION,
(PVOID)(pAdapter->pDescrString),
pAdapter->DescrLength
);
}
else
{
pAdapter->DescrLength = 0;
}
AADEBUGP(AAD_LOUD, ("GetAdapterInfo: Query VENDOR Descr2 ret 0x%x, DescrLen %d\n",
Status, pAdapter->DescrLength));
}
else
{
AADEBUGP(AAD_LOUD, ("GetAdapterInfo: Query VENDOR Descr1 ret 0x%x\n", Status));
}
//
// MAC Address:
//
Status = AtmArpSendAdapterNdisRequest(
pAdapter,
&NdisRequest,
NdisRequestQueryInformation,
OID_ATM_HW_CURRENT_ADDRESS,
(PVOID)(pAdapter->MacAddress),
AA_ATM_ESI_LEN
);
//
// Max Frame Size:
//
Status = AtmArpSendAdapterNdisRequest(
pAdapter,
&NdisRequest,
NdisRequestQueryInformation,
OID_ATM_MAX_AAL5_PACKET_SIZE,
(PVOID)(&(pAdapter->MaxPacketSize)),
sizeof(ULONG)
);
if (Status != NDIS_STATUS_SUCCESS)
{
//
// Use the default.
//
pAdapter->MaxPacketSize = AA_DEF_ATM_MAX_PACKET_SIZE;
}
if (pAdapter->MaxPacketSize > AA_MAX_ATM_MAX_PACKET_SIZE)
{
pAdapter->MaxPacketSize = AA_MAX_ATM_MAX_PACKET_SIZE;
}
//
// Check that the adapter support the minimum.
//
if (pAdapter->MaxPacketSize < AA_MIN_ATM_MAX_PACKET_SIZE)
{
AADEBUGP(AAD_FATAL,
("GetAdapterInfo: (FATAL) MaxPacketSize of (%lu) is too small.\n",
pAdapter->MaxPacketSize));
Status = NDIS_STATUS_RESOURCES;
break;
}
//
// Link speed:
//
Status = AtmArpSendAdapterNdisRequest(
pAdapter,
&NdisRequest,
NdisRequestQueryInformation,
OID_GEN_CO_LINK_SPEED,
(PVOID)(&(pAdapter->LineRate)),
sizeof(pAdapter->LineRate)
);
if ((Status != NDIS_STATUS_SUCCESS) ||
(pAdapter->LineRate.Inbound == 0) ||
(pAdapter->LineRate.Outbound == 0))
{
//
// Use the default.
//
pAdapter->LineRate.Outbound = pAdapter->LineRate.Inbound = AA_DEF_ATM_LINE_RATE;
AADEBUGP(AAD_LOUD, ("Using default line rate %d bytes/sec\n",
AA_DEF_ATM_LINE_RATE));
}
else
{
//
// Convert from 100 bits/sec to bytes/sec
//
pAdapter->LineRate.Outbound = (pAdapter->LineRate.Outbound * 100)/8;
pAdapter->LineRate.Inbound = (pAdapter->LineRate.Inbound * 100)/8;
AADEBUGP(AAD_LOUD, ("Got line rates from miniport: In %d, Out %d bytes/sec\n",
pAdapter->LineRate.Outbound,
pAdapter->LineRate.Inbound));
}
Status = NDIS_STATUS_SUCCESS;
} while(FALSE);
return Status;
}
NDIS_STATUS
AtmArpSendNdisRequest(
IN PATMARP_ADAPTER pAdapter,
IN PNDIS_REQUEST pNdisRequest,
IN NDIS_REQUEST_TYPE RequestType,
IN NDIS_OID Oid,
IN PVOID pBuffer,
IN ULONG BufferLength
)
/*++
Routine Description:
Send an NDIS (non-Connection Oriented) request to the Miniport. We
allocate an NDIS_REQUEST structure, link the supplied buffer to it,
and send the request. If the request does not pend, we call our
completion routine from here.
Arguments:
pAdapter - Pointer to our Adapter structure representing
the adapter to which the request is to be sent
pNdisRequest - Pointer to NDIS request structure
RequestType - Set/Query information
Oid - OID to be passed in the request
pBuffer - place for value(s)
BufferLength - length of above
Return Value:
Status of the NdisRequest.
--*/
{
NDIS_STATUS Status;
//
// Fill in the NDIS Request structure
//
pNdisRequest->RequestType = RequestType;
if (RequestType == NdisRequestQueryInformation)
{
pNdisRequest->DATA.QUERY_INFORMATION.Oid = Oid;
pNdisRequest->DATA.QUERY_INFORMATION.InformationBuffer = pBuffer;
pNdisRequest->DATA.QUERY_INFORMATION.InformationBufferLength = BufferLength;
pNdisRequest->DATA.QUERY_INFORMATION.BytesWritten = 0;
pNdisRequest->DATA.QUERY_INFORMATION.BytesNeeded = BufferLength;
}
else
{
pNdisRequest->DATA.SET_INFORMATION.Oid = Oid;
pNdisRequest->DATA.SET_INFORMATION.InformationBuffer = pBuffer;
pNdisRequest->DATA.SET_INFORMATION.InformationBufferLength = BufferLength;
pNdisRequest->DATA.SET_INFORMATION.BytesRead = 0;
pNdisRequest->DATA.SET_INFORMATION.BytesNeeded = 0;
}
NdisRequest(
&Status,
pAdapter->NdisAdapterHandle,
pNdisRequest);
return (Status);
}
VOID
AtmArpShutdownInterface(
IN PATMARP_INTERFACE pInterface
)
/*++
Routine Description:
Bring down the specified ARP interface.
We tear down the ARP table, and shut down the Call Manager
interface. When this is complete, we will call IP's DelInterface
entry point.
Arguments:
pInterface - Points to the Interface to be shut down.
Return Value:
None
--*/
{
IP_STATUS Status;
INT i;
ULONG rc;
PATMARP_IP_ENTRY pIpEntry;
PATMARP_ATM_ENTRY pAtmEntry;
PATMARP_ATM_ENTRY pNextAtmEntry;
PATMARP_VC pVc;
PATMARP_VC pNextVc;
PATMARP_ADAPTER pAdapter;
BOOLEAN WasRunning;
#if DBG
AA_IRQL EntryIrq, ExitIrq;
#endif
AA_GET_ENTRY_IRQL(EntryIrq);
AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo);
pAdapter = pInterface->pAdapter;
//
// Wait for any AF register processing to finish.
//
while (pAdapter->Flags & AA_ADAPTER_FLAGS_PROCESSING_AF)
{
AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo);
AADEBUGP(AAD_FATAL, ("ShutdownIf: IF %p, pAdapter %x, Afregister going on!!!\n",
pInterface, pAdapter));
Status = AA_WAIT_ON_BLOCK_STRUCT(&(pAdapter->UnbindBlock));
AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo);
}
AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo);
//
// Stop any timer running on this interface
//
AA_ACQUIRE_IF_LOCK(pInterface);
if (AtmArpStopTimer(&(pInterface->Timer), pInterface))
{
rc = AtmArpDereferenceInterface(pInterface); // Timer ref
AA_ASSERT(rc != 0);
}
#ifdef IPMCAST
//
// Stop any Multicast timer running on this interface
//
if (AtmArpStopTimer(&(pInterface->McTimer), pInterface))
{
rc = AtmArpDereferenceInterface(pInterface); // Timer ref
AA_ASSERT(rc != 0);
}
#endif
AA_RELEASE_IF_LOCK(pInterface);
//
// Deregister all SAPs so that we don't get any more
// incoming calls.
//
AtmArpDeregisterSaps(pInterface);
AA_CHECK_EXIT_IRQL(EntryIrq, ExitIrq);
//
// We set the ARP Table state to "down" -- this will ensure that it
// will not grow while we are shutting down.
//
AA_ACQUIRE_IF_TABLE_LOCK(pInterface);
pInterface->ArpTableUp = FALSE;
//
// Go through the ARP Table and abort all IP entries
//
for (i = 0; i < ATMARP_TABLE_SIZE; i++)
{
while (pInterface->pArpTable[i] != NULL_PATMARP_IP_ENTRY)
{
pIpEntry = pInterface->pArpTable[i];
AA_ACQUIRE_IE_LOCK_DPC(pIpEntry);
AA_REF_IE(pIpEntry, IE_REFTYPE_TMP); // Shutdown Interface
AA_RELEASE_IE_LOCK_DPC(pIpEntry);
AA_RELEASE_IF_TABLE_LOCK(pInterface);
AA_ACQUIRE_IE_LOCK(pIpEntry);
if (AA_DEREF_IE(pIpEntry, IE_REFTYPE_TMP)) // Shutdown Interface
{
AtmArpAbortIPEntry(pIpEntry);
//
// IE Lock is released within the above.
//
}
AA_ACQUIRE_IF_TABLE_LOCK(pInterface);
}
}
AA_RELEASE_IF_TABLE_LOCK(pInterface);
AA_CHECK_EXIT_IRQL(EntryIrq, ExitIrq);
#ifdef IPMCAST
//
// Delete all Join Entries
//
AA_ACQUIRE_IF_LOCK(pInterface);
{
PATMARP_IPMC_JOIN_ENTRY pJoinEntry;
PATMARP_IPMC_JOIN_ENTRY pNextJoinEntry;
for (pJoinEntry = pInterface->pJoinList;
pJoinEntry != NULL_PATMARP_IPMC_JOIN_ENTRY;
pJoinEntry = pNextJoinEntry)
{
WasRunning = AtmArpStopTimer(&(pJoinEntry->Timer), pInterface);
pNextJoinEntry = pJoinEntry->pNextJoinEntry;
if (WasRunning)
{
rc = AA_DEREF_JE(pJoinEntry); // ShutdownIF: timer stopped
}
else
{
rc = pJoinEntry->RefCount;
}
if (rc != 0)
{
(VOID)AA_DEREF_JE(pJoinEntry); // ShutdownIF: kill Join Entry
}
}
pInterface->pJoinList = NULL_PATMARP_IPMC_JOIN_ENTRY;
}
AA_RELEASE_IF_LOCK(pInterface);
#endif
//
// We set the AtmEntry list state to "down" (this will ensure that it
// will not grow while we are shutting down), then
// go through the list of ATM Entries on this interface, and
// abort all of them.
//
AA_ACQUIRE_IF_ATM_LIST_LOCK(pInterface);
pInterface->AtmEntryListUp = FALSE;
pNextAtmEntry = pInterface->pAtmEntryList;
if (pNextAtmEntry != NULL_PATMARP_ATM_ENTRY)
{
AA_ACQUIRE_AE_LOCK_DPC(pNextAtmEntry);
AA_REF_AE(pNextAtmEntry, AE_REFTYPE_TMP); // ShutdownInterface
AA_RELEASE_AE_LOCK_DPC(pNextAtmEntry);
}
while (pNextAtmEntry != NULL_PATMARP_ATM_ENTRY)
{
pAtmEntry = pNextAtmEntry;
pNextAtmEntry = pAtmEntry->pNext;
//
// Note that we still have the lock to pInterface when
// we aquire the lock to pAtmEntry below. This order of aquiring
// locks must be strictly followed everywhere in order to prevent
// a deadlock.
//
// We can't release the LIST_LOCK without first addrefing pAtmEntry,
// otherwise while both locks are free someone else can delref and
// possibly deallocate pAtmEntry.
//
if (pNextAtmEntry != NULL_PATMARP_ATM_ENTRY)
{
AA_ACQUIRE_AE_LOCK_DPC(pNextAtmEntry);
AA_REF_AE(pNextAtmEntry, AE_REFTYPE_TMP); // ShutdownInterface
AA_RELEASE_AE_LOCK_DPC(pNextAtmEntry);
}
AA_RELEASE_IF_ATM_LIST_LOCK(pInterface);
AA_CHECK_EXIT_IRQL(EntryIrq, ExitIrq);
AA_ACQUIRE_AE_LOCK(pAtmEntry);
if (AA_DEREF_AE(pAtmEntry, AE_REFTYPE_TMP) != 0) // ShutdownInterface
{
AtmArpInvalidateAtmEntry(
pAtmEntry,
TRUE // we ARE shutting down
);
//
// The ATM Entry lock is released within the above.
//
}
AA_CHECK_EXIT_IRQL(EntryIrq, ExitIrq);
AA_ACQUIRE_IF_ATM_LIST_LOCK(pInterface);
}
AA_RELEASE_IF_ATM_LIST_LOCK(pInterface);
AA_CHECK_EXIT_IRQL(EntryIrq, ExitIrq);
//
// Go through the list of unresolved VCs on this interface,
// and close all of them.
//
AA_ACQUIRE_IF_LOCK(pInterface);
pVc = pInterface->pUnresolvedVcs;
pInterface->pUnresolvedVcs = NULL_PATMARP_VC;
while (pVc != NULL_PATMARP_VC)
{
pNextVc = pVc->pNextVc;
AA_RELEASE_IF_LOCK(pInterface);
AA_ACQUIRE_VC_LOCK(pVc);
if (AtmArpDereferenceVc(pVc) != 0) // Unresolved VC list entry
{
AtmArpCloseCall(pVc);
//
// the VC lock is released within the above.
//
}
pVc = pNextVc;
AA_ACQUIRE_IF_LOCK(pInterface);
}
AA_RELEASE_IF_LOCK(pInterface);
AA_CHECK_EXIT_IRQL(EntryIrq, ExitIrq);
//
// Close the Call Manager interface.
//
AtmArpCloseCallMgr(pInterface);
}
BOOLEAN
AtmArpIsDeviceAlreadyBound(
IN PNDIS_STRING pDeviceName
)
/*++
Routine Description:
Check if we have already bound to a device (adapter).
Arguments:
pDeviceName - Points to device name to be checked.
Return Value:
TRUE iff we already have an Adapter structure representing
this device.
--*/
{
PATMARP_ADAPTER pAdapter;
BOOLEAN bFound = FALSE;
AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo);
for (pAdapter = pAtmArpGlobalInfo->pAdapterList;
pAdapter != NULL_PATMARP_ADAPTER;
pAdapter = pAdapter->pNextAdapter)
{
if ((pDeviceName->Length == pAdapter->DeviceName.Length) &&
(AA_MEM_CMP(pDeviceName->Buffer,
pAdapter->DeviceName.Buffer,
pDeviceName->Length) == 0))
{
bFound = TRUE;
break;
}
}
AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo);
return (bFound);
}
#if ATMOFFLOAD
NDIS_STATUS
AtmArpQueryAndEnableOffload(
IN PATMARP_ADAPTER pAdapter
)
/*++
Routine Description:
Query the capabilities of the adapter and set all recognized offload capabilities.
Set pMaxOffLoadSize and pMinSegmentCount to the corresponding values, and
also set pInterface->OffloadFlags to the set of enabled tasks.
Arguments:
pAdapter - The adapter on which to enable offloading.
Return Value:
TRUE iff the operation was either succesful or no tasks were enabled. False
if there was a fatal error.
--*/
{
NDIS_STATUS Status = STATUS_BUFFER_OVERFLOW;
PNDIS_TASK_OFFLOAD_HEADER pHeader = NULL;
AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo);
pAdapter->Offload.Flags = 0;
pAdapter->Offload.MaxOffLoadSize = 0;
pAdapter->Offload.MinSegmentCount = 0;
AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo);
do
{
PNDIS_TASK_OFFLOAD pTask;
ULONG Flags = 0;
UINT MaxOffLoadSize = 0;
UINT MinSegmentCount = 0;
NDIS_TASK_IPSEC ipsecCaps;
UINT BufferSize = 0;
NDIS_REQUEST NdisRequest;
//
// Query capabilities
//
{
NDIS_TASK_OFFLOAD_HEADER Header;
AA_SET_MEM(&Header, 0, sizeof(Header));
Header.EncapsulationFormat.Flags.FixedHeaderSize = 1;
Header.EncapsulationFormat.EncapsulationHeaderSize =
AA_PKT_LLC_SNAP_HEADER_LENGTH;
Header.EncapsulationFormat.Encapsulation =
LLC_SNAP_ROUTED_Encapsulation;
Header.Version = NDIS_TASK_OFFLOAD_VERSION;
Header.Size = sizeof(Header);
AADEBUGP(AAD_INFO, ("Querying for Task offload\n"));
Status = AtmArpSendAdapterNdisRequest(
pAdapter,
&NdisRequest,
NdisRequestQueryInformation,
OID_TCP_TASK_OFFLOAD,
&Header,
sizeof(Header)
);
if ((Status == NDIS_STATUS_INVALID_LENGTH) ||
(Status == NDIS_STATUS_BUFFER_TOO_SHORT)) {
//
// Alloc the proper-sized buffer and query a 2nd time...
//
BufferSize = NdisRequest.DATA.QUERY_INFORMATION.BytesNeeded;
AA_ALLOC_MEM(pHeader, NDIS_TASK_OFFLOAD_HEADER, BufferSize);
if (pHeader != NULL)
{
*pHeader = Header; // struct copy.
Status = AtmArpSendAdapterNdisRequest(
pAdapter,
&NdisRequest,
NdisRequestQueryInformation,
OID_TCP_TASK_OFFLOAD,
pHeader,
BufferSize
);
}
}
}
if (Status != NDIS_STATUS_SUCCESS)
{
AADEBUGP(AAD_INFO, ("Query Offload failed. Status=%x\n", Status));
break;
}
if ( pHeader == NULL
|| pHeader->OffsetFirstTask == 0)
{
AADEBUGP(AAD_INFO, ("No tasks to offload\n"));
break;
}
AA_ASSERT(pHeader->OffsetFirstTask == sizeof(NDIS_TASK_OFFLOAD_HEADER));
AADEBUGP(AAD_WARNING,
("Something to Offload. Offload buffer size %x\n", BufferSize));
//
// Parse the buffer for Checksum and tcplargesend offload capabilities
//
for (
pTask = (NDIS_TASK_OFFLOAD *) ((UCHAR *)pHeader
+ pHeader->OffsetFirstTask);
1; // we break when done
pTask = (PNDIS_TASK_OFFLOAD) ((PUCHAR)pTask + pTask->OffsetNextTask))
{
if (pTask->Task == TcpIpChecksumNdisTask)
{
//
//this adapter supports checksum offload
//check if tcp and/or ip chksums bits are present
//
PNDIS_TASK_TCP_IP_CHECKSUM ChecksumInfo
= (PNDIS_TASK_TCP_IP_CHECKSUM) pTask->TaskBuffer;
// if (ChecksumInfo->V4Transmit.V4Checksum) (commented out in arpc.c)
{
AADEBUGP(AAD_INFO, ("V4 Checksum offload\n"));
if (ChecksumInfo->V4Transmit.TcpChecksum) {
Flags |= TCP_XMT_CHECKSUM_OFFLOAD;
AADEBUGP(AAD_INFO, (" Tcp Checksum offload\n"));
}
if (ChecksumInfo->V4Transmit.IpChecksum) {
Flags |= IP_XMT_CHECKSUM_OFFLOAD;
AADEBUGP(AAD_INFO, (" IP xmt Checksum offload\n"));
}
if (ChecksumInfo->V4Receive.TcpChecksum) {
Flags |= TCP_RCV_CHECKSUM_OFFLOAD;
AADEBUGP(AAD_INFO, (" Tcp Rcv Checksum offload\n"));
}
if (ChecksumInfo->V4Receive.IpChecksum) {
Flags |= IP_RCV_CHECKSUM_OFFLOAD;
AADEBUGP(AAD_INFO, (" IP rcv Checksum offload\n"));
}
}
}
else if (pTask->Task == TcpLargeSendNdisTask)
{
PNDIS_TASK_TCP_LARGE_SEND TcpLargeSend, in_LargeSend =
(PNDIS_TASK_TCP_LARGE_SEND)pTask->TaskBuffer;
Flags |= TCP_LARGE_SEND_OFFLOAD;
MaxOffLoadSize = in_LargeSend->MaxOffLoadSize;
MinSegmentCount = in_LargeSend->MinSegmentCount;
AADEBUGP(AAD_INFO, (" Tcp large send!! \n"));
}
else if (pTask->Task == IpSecNdisTask)
{
PNDIS_TASK_IPSEC pIPSecCaps =
(PNDIS_TASK_IPSEC) pTask->TaskBuffer;
//
// Save off the capabilities for setting them later.
//
ipsecCaps = *pIPSecCaps;
//
// CryptoOnly is assumed if we have IpSecNdisTask
//
Flags |= IPSEC_OFFLOAD_CRYPTO_ONLY;
//
// Do Support first
//
if (pIPSecCaps->Supported.AH_ESP_COMBINED) {
Flags |= IPSEC_OFFLOAD_AH_ESP;
AADEBUGP(AAD_INFO, ("AH_ESP\n"));
}
if (pIPSecCaps->Supported.TRANSPORT_TUNNEL_COMBINED) {
Flags |= IPSEC_OFFLOAD_TPT_TUNNEL;
AADEBUGP(AAD_INFO, ("TPT_TUNNEL\n"));
}
if (pIPSecCaps->Supported.V4_OPTIONS) {
Flags |= IPSEC_OFFLOAD_V4_OPTIONS;
AADEBUGP(AAD_INFO, ("V4_OPTIONS\n"));
}
if (pIPSecCaps->Supported.RESERVED) {
pIPSecCaps->Supported.RESERVED = 0;
//Flags |= IPSEC_OFFLOAD_QUERY_SPI;
AADEBUGP(AAD_INFO, ("QUERY_SPI\n"));
}
//
// Do V4AH next
//
if (pIPSecCaps->V4AH.MD5) {
Flags |= IPSEC_OFFLOAD_AH_MD5;
AADEBUGP(AAD_INFO, ("MD5\n"));
}
if (pIPSecCaps->V4AH.SHA_1) {
Flags |= IPSEC_OFFLOAD_AH_SHA_1;
AADEBUGP(AAD_INFO, ("SHA\n"));
}
if (pIPSecCaps->V4AH.Transport) {
Flags |= IPSEC_OFFLOAD_AH_TPT;
AADEBUGP(AAD_INFO, ("AH_TRANSPORT\n"));
}
if (pIPSecCaps->V4AH.Tunnel) {
Flags |= IPSEC_OFFLOAD_AH_TUNNEL;
AADEBUGP(AAD_INFO, ("AH_TUNNEL\n"));
}
if (pIPSecCaps->V4AH.Send) {
Flags |= IPSEC_OFFLOAD_AH_XMT;
AADEBUGP(AAD_INFO, ("AH_XMT\n"));
}
if (pIPSecCaps->V4AH.Receive) {
Flags |= IPSEC_OFFLOAD_AH_RCV;
AADEBUGP(AAD_INFO, ("AH_RCV\n"));
}
//
// Do V4ESP next
//
if (pIPSecCaps->V4ESP.DES) {
Flags |= IPSEC_OFFLOAD_ESP_DES;
AADEBUGP(AAD_INFO, ("ESP_DES\n"));
}
if (pIPSecCaps->V4ESP.RESERVED) {
pIPSecCaps->V4ESP.RESERVED = 0;
//Flags |= IPSEC_OFFLOAD_ESP_DES_40;
AADEBUGP(AAD_INFO, ("ESP_DES_40\n"));
}
if (pIPSecCaps->V4ESP.TRIPLE_DES) {
Flags |= IPSEC_OFFLOAD_ESP_3_DES;
AADEBUGP(AAD_INFO, ("ESP_3_DES\n"));
}
if (pIPSecCaps->V4ESP.NULL_ESP) {
Flags |= IPSEC_OFFLOAD_ESP_NONE;
AADEBUGP(AAD_INFO, ("ESP_NONE\n"));
}
if (pIPSecCaps->V4ESP.Transport) {
Flags |= IPSEC_OFFLOAD_ESP_TPT;
AADEBUGP(AAD_INFO, ("ESP_TRANSPORT\n"));
}
if (pIPSecCaps->V4ESP.Tunnel) {
Flags |= IPSEC_OFFLOAD_ESP_TUNNEL;
AADEBUGP(AAD_INFO, ("ESP_TUNNEL\n"));
}
if (pIPSecCaps->V4ESP.Send) {
Flags |= IPSEC_OFFLOAD_ESP_XMT;
AADEBUGP(AAD_INFO, ("ESP_XMT\n"));
}
if (pIPSecCaps->V4ESP.Receive) {
Flags |= IPSEC_OFFLOAD_ESP_RCV;
AADEBUGP(AAD_INFO, ("ESP_RCV\n"));
}
}
if (pTask->OffsetNextTask == 0)
{
break; // No more tasks.
}
} // for
//
// Done parsing supported tasks.
// Now construct the set of tasks we actually want to enable.
//
if (Flags)
{
UINT *pPrevOffset = &pHeader->OffsetFirstTask;
AADEBUGP(AAD_WARNING, ("Enabling H/W capabilities: %lx\n", Flags));
//
// Zero out the buffer beyond the task offload header structure
//
AA_SET_MEM(pTask, 0, BufferSize-sizeof(*pHeader));
pHeader->OffsetFirstTask = 0;
pTask = (NDIS_TASK_OFFLOAD *) (pHeader+1);
if ((Flags & TCP_XMT_CHECKSUM_OFFLOAD) ||
(Flags & IP_XMT_CHECKSUM_OFFLOAD) ||
(Flags & TCP_RCV_CHECKSUM_OFFLOAD) ||
(Flags & IP_RCV_CHECKSUM_OFFLOAD))
{
PNDIS_TASK_TCP_IP_CHECKSUM ChksumBuf =
(PNDIS_TASK_TCP_IP_CHECKSUM)pTask->TaskBuffer;
*pPrevOffset = (UINT) ((PUCHAR)pTask - (PUCHAR)pHeader);
pPrevOffset = &pTask->OffsetNextTask;
pTask->Task = TcpIpChecksumNdisTask;
pTask->TaskBufferLength = sizeof(NDIS_TASK_TCP_IP_CHECKSUM);
if (Flags & TCP_XMT_CHECKSUM_OFFLOAD)
{
ChksumBuf->V4Transmit.TcpChecksum = 1;
//ChksumBuf->V4Transmit.V4Checksum = 1;
}
if (Flags & IP_XMT_CHECKSUM_OFFLOAD)
{
ChksumBuf->V4Transmit.IpChecksum = 1;
//ChksumBuf->V4Transmit.V4Checksum = 1;
}
if (Flags & TCP_RCV_CHECKSUM_OFFLOAD)
{
ChksumBuf->V4Receive.TcpChecksum = 1;
//ChksumBuf->V4Receive.V4Checksum = 1;
}
if (Flags & IP_RCV_CHECKSUM_OFFLOAD)
{
ChksumBuf->V4Receive.IpChecksum = 1;
//ChksumBuf->V4Receive.V4Checksum = 1;
}
//
// Point to place where next task goes...
//
pTask = (PNDIS_TASK_OFFLOAD) (ChksumBuf+1);
}
if (Flags & TCP_LARGE_SEND_OFFLOAD)
{
PNDIS_TASK_TCP_LARGE_SEND out_LargeSend =
(PNDIS_TASK_TCP_LARGE_SEND)pTask->TaskBuffer;
*pPrevOffset = (UINT) ((PUCHAR)pTask - (PUCHAR)pHeader);
pPrevOffset = &pTask->OffsetNextTask;
pTask->Task = TcpLargeSendNdisTask;
pTask->TaskBufferLength = sizeof(NDIS_TASK_TCP_LARGE_SEND);
out_LargeSend->MaxOffLoadSize = MaxOffLoadSize;
out_LargeSend->MinSegmentCount = MinSegmentCount;
//
// Point to place where next task goes...
//
pTask = (PNDIS_TASK_OFFLOAD) (out_LargeSend+1);
}
if ((Flags & (IPSEC_OFFLOAD_AH_XMT |
IPSEC_OFFLOAD_AH_RCV |
IPSEC_OFFLOAD_ESP_XMT |
IPSEC_OFFLOAD_ESP_RCV)))
{
PNDIS_TASK_IPSEC pIPSecCaps =
(PNDIS_TASK_IPSEC)pTask->TaskBuffer;
*pPrevOffset = (UINT) ((PUCHAR)pTask - (PUCHAR)pHeader);
pPrevOffset = &pTask->OffsetNextTask;
//
// plunk down the advertised capabilities
//
pTask->Task = IpSecNdisTask;
pTask->TaskBufferLength = sizeof(NDIS_TASK_IPSEC);
//
// Point to place where next task goes...
//
pTask = (PNDIS_TASK_OFFLOAD) (pIPSecCaps+1);
}
}
//
// Having constructed the set of tasks to enable, we actually attempt
// to enable them...
//
if (pHeader->OffsetFirstTask)
{
//
// At least one task to enable, let's enable ...
//
UINT SetBufferSize = (UINT) ((PUCHAR)pTask - (PUCHAR)pHeader);
AA_ASSERT(SetBufferSize <= BufferSize);
AADEBUGP(AAD_WARNING,
("Setting offload tasks: %x bytes. Miniport returned %x bytes\n",
SetBufferSize, BufferSize));
Status = AtmArpSendAdapterNdisRequest(
pAdapter,
&NdisRequest,
NdisRequestSetInformation,
OID_TCP_TASK_OFFLOAD,
pHeader,
SetBufferSize
);
if (Status != NDIS_STATUS_SUCCESS)
{
AADEBUGP(AAD_WARNING,
("ARP: Failed to set offload tasks: %lx, status: %lx\n",
Flags, Status));
}
else
{
AADEBUGP(AAD_WARNING,
("ARP: Succeeded setting offload tasks: %lx:\n", Flags));
AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo);
pAdapter->Offload.Flags = Flags;
pAdapter->Offload.MaxOffLoadSize = MaxOffLoadSize;
pAdapter->Offload.MinSegmentCount = MinSegmentCount;
AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo);
}
}
} while (FALSE);
if (pHeader != NULL)
{
AA_FREE_MEM(pHeader);
}
//
// We return success unless there was a fatal error and there was none...
//
return NDIS_STATUS_SUCCESS;
}
VOID
AtmArpDisableOffload(
IN PATMARP_ADAPTER pAdapter
)
/*++
Routine Description:
Disable offload capabilities, if enabled for this interface.
Arguments:
pAdapter - The adapter on which to disable offloading.
Return Value:
TRUE iff the operation was either succesful or no tasks were enabled. False
if there was a fatal error.
--*/
{
ULONG Flags;
AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo);
Flags = pAdapter->Offload.Flags;
pAdapter->Offload.Flags = 0;
pAdapter->Offload.MaxOffLoadSize = 0;
pAdapter->Offload.MinSegmentCount = 0;
AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo);
if (Flags)
{
NDIS_REQUEST NdisRequest;
NDIS_TASK_OFFLOAD_HEADER Header;
AA_SET_MEM(&Header, 0, sizeof(Header));
Header.EncapsulationFormat.Flags.FixedHeaderSize = 1;
Header.EncapsulationFormat.EncapsulationHeaderSize = 2;
Header.EncapsulationFormat.Encapsulation =
LLC_SNAP_ROUTED_Encapsulation;
Header.Version = NDIS_TASK_OFFLOAD_VERSION;
Header.Size = sizeof(Header);
//
// Header.OffsetFirstTask == 0 tells the miniport to disable all tasks.
//
AADEBUGP(AAD_WARNING, ("Disabling all offloaded tasks for this adapter\n"));
AtmArpSendAdapterNdisRequest(
pAdapter,
&NdisRequest,
NdisRequestSetInformation,
OID_TCP_TASK_OFFLOAD,
&Header,
sizeof(Header)
);
}
}
#endif // ATMOFFLOAD
Reference in a new issue Copy permalink