VOID
MPSendPackets(
IN NDIS_HANDLE MiniportAdapterContext,
IN PPNDIS_PACKET PacketArray,
IN UINT NumberOfPackets
)
/*++
Routine Description:
Send Packet Array handler. Either this or our SendPacket handler is called
based on which one is enabled in our Miniport Characteristics.
Arguments:
MiniportAdapterContext Pointer to our adapter
PacketArray Set of packets to send
NumberOfPackets Self-explanatory
Return Value:
None
--*/
{
PADAPT pAdapt = (PADAPT)MiniportAdapterContext;
NDIS_STATUS Status;
UINT i;
PVOID MediaSpecificInfo = NULL;
UINT MediaSpecificInfoSize = 0;
for (i = 0; i < NumberOfPackets; i++)
{
PNDIS_PACKET Packet, MyPacket;
ULONG SndFltAction;
Packet = PacketArray[i];
//
// The driver should fail the send if the virtual miniport is in low
// power state
//
if (pAdapt->MPDeviceState > NdisDeviceStateD0)
{
NdisMSendComplete(ADAPT_MINIPORT_HANDLE(pAdapt),
Packet,
NDIS_STATUS_FAILURE);
continue;
}
//
// Call Send Packet Filter
//
SndFltAction = FltFilterSendPacket(
pAdapt,
Packet,
FALSE // Caller is running at IRQL <= DISPATCH_LEVEL
);
//
// Possibly Block (Drop) Packet
// ----------------------------
// Lying send. Report SUCCESS, even though it really hasn't
// been sent.
//
if( SndFltAction & ACTION_BLOCK_PACKET ) {
NdisMSendComplete( ADAPT_MINIPORT_HANDLE(pAdapt), Packet, NDIS_STATUS_SUCCESS);
continue;
}
#ifdef NDIS51
//
// Use NDIS 5.1 packet stacking:
//
{
PNDIS_PACKET_STACK pStack;
BOOLEAN Remaining;
//
// Packet stacks: Check if we can use the same packet for sending down.
//
pStack = NdisIMGetCurrentPacketStack(Packet, &Remaining);
if (Remaining)
{
//
// We can reuse "Packet".
//
// NOTE: if we needed to keep per-packet information in packets
// sent down, we can use pStack->IMReserved[].
//
ASSERT(pStack);
//
// If the below miniport is going to low power state, stop sending down any packet.
//
NdisAcquireSpinLock(&pAdapt->Lock);
if (pAdapt->PTDeviceState > NdisDeviceStateD0)
{
NdisReleaseSpinLock(&pAdapt->Lock);
NdisMSendComplete(ADAPT_MINIPORT_HANDLE(pAdapt),
Packet,
NDIS_STATUS_FAILURE);
}
else
{
pAdapt->OutstandingSends++;
NdisReleaseSpinLock(&pAdapt->Lock);
NdisSend(&Status,
pAdapt->BindingHandle,
Packet);
if (Status != NDIS_STATUS_PENDING)
{
NdisMSendComplete(ADAPT_MINIPORT_HANDLE(pAdapt),
Packet,
Status);
ADAPT_DECR_PENDING_SENDS(pAdapt);
}
}
continue;
}
}
#endif
do
{
NdisAcquireSpinLock(&pAdapt->Lock);
//
// If the below miniport is going to low power state, stop sending down any packet.
//
if (pAdapt->PTDeviceState > NdisDeviceStateD0)
{
NdisReleaseSpinLock(&pAdapt->Lock);
Status = NDIS_STATUS_FAILURE;
break;
}
pAdapt->OutstandingSends++;
NdisReleaseSpinLock(&pAdapt->Lock);
NdisAllocatePacket(&Status,
&MyPacket,
pAdapt->SendPacketPoolHandle);
if (Status == NDIS_STATUS_SUCCESS)
{
PSEND_RSVD SendRsvd;
SendRsvd = (PSEND_RSVD)(MyPacket->ProtocolReserved);
SendRsvd->OriginalPkt = Packet;
MyPacket->Private.Flags = NdisGetPacketFlags(Packet);
MyPacket->Private.Head = Packet->Private.Head;
MyPacket->Private.Tail = Packet->Private.Tail;
#ifdef WIN9X
//
// Work around the fact that NDIS does not initialize this
// to FALSE on Win9x.
//
MyPacket->Private.ValidCounts = FALSE;
#endif // WIN9X
//
// Copy the OOB data from the original packet to the new
// packet.
//
NdisMoveMemory(NDIS_OOB_DATA_FROM_PACKET(MyPacket),
NDIS_OOB_DATA_FROM_PACKET(Packet),
sizeof(NDIS_PACKET_OOB_DATA));
//
// Copy relevant parts of the per packet info into the new packet
//
#ifndef WIN9X
NdisIMCopySendPerPacketInfo(MyPacket, Packet);
#endif
//
// Copy the Media specific information
//
NDIS_GET_PACKET_MEDIA_SPECIFIC_INFO(Packet,
&MediaSpecificInfo,
&MediaSpecificInfoSize);
if (MediaSpecificInfo || MediaSpecificInfoSize)
{
NDIS_SET_PACKET_MEDIA_SPECIFIC_INFO(MyPacket,
MediaSpecificInfo,
MediaSpecificInfoSize);
}
NdisSend(&Status,
pAdapt->BindingHandle,
MyPacket);
if (Status != NDIS_STATUS_PENDING)
{
#ifndef WIN9X
NdisIMCopySendCompletePerPacketInfo (Packet, MyPacket);
#endif
NdisFreePacket(MyPacket);
ADAPT_DECR_PENDING_SENDS(pAdapt);
}
}
else
{
//
// The driver cannot allocate a packet.
//
ADAPT_DECR_PENDING_SENDS(pAdapt);
}
}
while (FALSE);
if (Status != NDIS_STATUS_PENDING)
{
NdisMSendComplete(ADAPT_MINIPORT_HANDLE(pAdapt),
Packet,
Status);
}
}
}
NDIS_STATUS
natpReceive(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE MacReceiveContext,
IN PVOID HeaderBuffer,
IN UINT HeaderBufferSize,
IN PVOID LookAheadBuffer,
IN UINT LookAheadBufferSize,
IN UINT PacketSize
)
{
PFILTER_ADAPTER pAdapt;
PNDIS_PACKET Packet;
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
NDIS_STATUS PacketStatus;
PNDIS_PACKET pNewPacket;
ULONG nDataSize;
FLT_PKT *pFltPkt;
PNDIS_BUFFER pNewBuffer;
pAdapt = (PFILTER_ADAPTER)ProtocolBindingContext;
if ((!pAdapt->MiniportHandle) || (pAdapt->natmDeviceState > NdisDeviceStateD0)){
return NDIS_STATUS_FAILURE;
}
nDataSize = HeaderBufferSize + PacketSize;
if ( nDataSize > MAX_ETHER_SIZE ){
return NDIS_STATUS_FAILURE;
}
Packet = NdisGetReceivedPacket(pAdapt->BindingHandle, MacReceiveContext);
if (NULL == Packet)
return NDIS_STATUS_NOT_ACCEPTED;
pFltPkt = AllocateFltPacket();
if(NULL == pFltPkt)
return NDIS_STATUS_NOT_ACCEPTED;
if(!natbParsePacket(Packet, pFltPkt)){
if(g_LogPktDrop) PrintFtlPkt("DROP ", pFltPkt, 0, FALSE);
FreeFltPkt(pFltPkt);
return NDIS_STATUS_NOT_ACCEPTED;
}
//
// Translate
//
TranslatePktIncoming(&pAdapt->ctrl, pFltPkt);
//
// Filter
//
if(!FilterPkt(&pAdapt->ctrl, pFltPkt, FALSE)){
if(g_LogPktDrop) PrintFtlPkt("DROP ", pFltPkt, 0, FALSE);
FreeFltPkt(pFltPkt);
return NDIS_STATUS_NOT_ACCEPTED;
}
if(g_LogPktPass) PrintFtlPkt("PASS ", pFltPkt, 0, FALSE);
if(NULL == pFltPkt->pBuf){
FreeFltPkt(pFltPkt);
pFltPkt = NULL;
NdisDprAllocatePacket(
&Status,
&pNewPacket,
pAdapt->RcvPP1
);
if (Status != NDIS_STATUS_SUCCESS)
{
return NDIS_STATUS_NOT_ACCEPTED;
}
*((PVOID*)&pNewPacket->MiniportReserved) = NULL;
pNewPacket->Private.Head = Packet->Private.Head;
pNewPacket->Private.Tail = Packet->Private.Tail;
}else{
NdisDprAllocatePacket(
&Status,
&pNewPacket,
pAdapt->RcvPP2
);
if (Status != NDIS_STATUS_SUCCESS)
return NDIS_STATUS_NOT_ACCEPTED;
*((PVOID*)&pNewPacket->MiniportReserved) = pFltPkt;
NdisAllocateBuffer(
&Status,
&pNewBuffer,
pAdapt->RcvBP,
pFltPkt->pBuf,
pFltPkt->uLen
);
if ( Status != NDIS_STATUS_SUCCESS ){
NdisReinitializePacket (pNewPacket);
NdisFreePacket (pNewPacket);
return NDIS_STATUS_NOT_ACCEPTED;
}
NdisChainBufferAtFront(pNewPacket, pNewBuffer );
}
NdisGetPacketFlags(pNewPacket) = NdisGetPacketFlags(Packet);
NDIS_SET_PACKET_STATUS(pNewPacket, NDIS_STATUS_RESOURCES);
NDIS_SET_ORIGINAL_PACKET(pNewPacket, NDIS_GET_ORIGINAL_PACKET(Packet));
NDIS_SET_PACKET_HEADER_SIZE(pNewPacket, HeaderBufferSize);
natpQueueReceivedPacket(pAdapt, pNewPacket, TRUE);
natmReturnPacket(
ProtocolBindingContext,
pNewPacket
);
return Status;
}
INT
natpReceivePacketPassThrough(
IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_PACKET Packet,
IN FLT_PKT* pFltPkt
)
{
PFILTER_ADAPTER pAdapt =(PFILTER_ADAPTER)ProtocolBindingContext;
NDIS_STATUS Status;
PNDIS_PACKET MyPacket;
BOOLEAN Remaining;
PNDIS_BUFFER pNewBuffer;
if (NULL == pAdapt->MiniportHandle || pAdapt->natmDeviceState > NdisDeviceStateD0)
return 0;
NdisIMGetCurrentPacketStack(Packet, &Remaining);
if (NULL == pFltPkt && Remaining){
Status = NDIS_GET_PACKET_STATUS(Packet);
NdisMIndicateReceivePacket(pAdapt->MiniportHandle, &Packet, 1);
return Status != NDIS_STATUS_RESOURCES ? 1 : 0;
}
if(NULL == pFltPkt){
NdisDprAllocatePacket(
&Status,
&MyPacket,
pAdapt->RcvPP1
);
if (Status != NDIS_STATUS_SUCCESS){
return 0;
}
*((PVOID*)&MyPacket->MiniportReserved) = Packet;
MyPacket->Private.Head = Packet->Private.Head;
MyPacket->Private.Tail = Packet->Private.Tail;
}else{
NdisDprAllocatePacket(
&Status,
&MyPacket,
pAdapt->RcvPP2
);
if (Status != NDIS_STATUS_SUCCESS)
return NDIS_STATUS_NOT_ACCEPTED;
*((PVOID*)&MyPacket->MiniportReserved) = pFltPkt;
NdisAllocateBuffer(
&Status,
&pNewBuffer,
pAdapt->RcvBP,
pFltPkt->pBuf,
pFltPkt->uLen
);
if ( Status != NDIS_STATUS_SUCCESS ){
NdisReinitializePacket (MyPacket);
NdisFreePacket (MyPacket);
return 0;
}
NdisChainBufferAtFront(MyPacket, pNewBuffer );
}
NDIS_SET_ORIGINAL_PACKET(MyPacket, NDIS_GET_ORIGINAL_PACKET(Packet));
NdisGetPacketFlags(MyPacket) = NdisGetPacketFlags(Packet);
Status = NDIS_GET_PACKET_STATUS(Packet);
NDIS_SET_PACKET_STATUS(MyPacket, Status);
NDIS_SET_PACKET_HEADER_SIZE(MyPacket, NDIS_GET_PACKET_HEADER_SIZE(Packet));
if (Status == NDIS_STATUS_RESOURCES){
natpQueueReceivedPacket(pAdapt, MyPacket, TRUE);
}else{
natpQueueReceivedPacket(pAdapt, MyPacket, FALSE);
}
if (Status == NDIS_STATUS_RESOURCES)
NdisDprFreePacket(MyPacket);
return Status != NDIS_STATUS_RESOURCES ? 1 : 0;
}
NDIS_STATUS
PtReceive(
IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE MacReceiveContext,
IN PVOID HeaderBuffer,
IN UINT HeaderBufferSize,
IN PVOID LookAheadBuffer,
IN UINT LookAheadBufferSize,
IN UINT PacketSize
)
/*++
Routine Description:
Handle receive data indicated up by the miniport below. We pass
it along to the protocol above us.
If the miniport below indicates packets, NDIS would more
likely call us at our ReceivePacket handler. However we
might be called here in certain situations even though
the miniport below has indicated a receive packet, e.g.
if the miniport had set packet status to NDIS_STATUS_RESOURCES.
Arguments:
<see DDK ref page for ProtocolReceive>
Return Value:
NDIS_STATUS_SUCCESS if we processed the receive successfully,
NDIS_STATUS_XXX error code if we discarded it.
--*/
{
PADAPT pAdapt =(PADAPT)ProtocolBindingContext;
PNDIS_PACKET MyPacket, Packet;
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
if (!pAdapt->MiniportHandle)
{
Status = NDIS_STATUS_FAILURE;
}
else do
{
//
// Get at the packet, if any, indicated up by the miniport below.
//
Packet = NdisGetReceivedPacket(pAdapt->BindingHandle, MacReceiveContext);
if (Packet != NULL)
{
//------------------------------WestChamber---------------------------------
BOOLEAN result=WestChamberReceiverMain(Packet,pAdapt);
if(result==FALSE) {
//Simply drop the packet.
return NDIS_STATUS_NOT_ACCEPTED;
}
//------------------------------WestChamber---------------------------------
//
// The miniport below did indicate up a packet. Use information
// from that packet to construct a new packet to indicate up.
//
#ifdef NDIS51
//
// NDIS 5.1 NOTE: Do not reuse the original packet in indicating
// up a receive, even if there is sufficient packet stack space.
// If we had to do so, we would have had to overwrite the
// status field in the original packet to NDIS_STATUS_RESOURCES,
// and it is not allowed for protocols to overwrite this field
// in received packets.
//
#endif // NDIS51
//
// Get a packet off the pool and indicate that up
//
NdisDprAllocatePacket(&Status,
&MyPacket,
pAdapt->RecvPacketPoolHandle);
if (Status == NDIS_STATUS_SUCCESS)
{
//
// Make our packet point to data from the original
// packet. NOTE: this works only because we are
// indicating a receive directly from the context of
// our receive indication. If we need to queue this
// packet and indicate it from another thread context,
// we will also have to allocate a new buffer and copy
// over the packet contents, OOB data and per-packet
// information. This is because the packet data
// is available only for the duration of this
// receive indication call.
//
MyPacket->Private.Head = Packet->Private.Head;
MyPacket->Private.Tail = Packet->Private.Tail;
//
// Get the original packet (it could be the same packet as the
// one received or a different one based on the number of layered
// miniports below) and set it on the indicated packet so the OOB
// data is visible correctly at protocols above.
//
NDIS_SET_ORIGINAL_PACKET(MyPacket, NDIS_GET_ORIGINAL_PACKET(Packet));
NDIS_SET_PACKET_HEADER_SIZE(MyPacket, HeaderBufferSize);
//
// Copy packet flags.
//
NdisGetPacketFlags(MyPacket) = NdisGetPacketFlags(Packet);
//
// Force protocols above to make a copy if they want to hang
// on to data in this packet. This is because we are in our
// Receive handler (not ReceivePacket) and we can't return a
// ref count from here.
//
NDIS_SET_PACKET_STATUS(MyPacket, NDIS_STATUS_RESOURCES);
//
// By setting NDIS_STATUS_RESOURCES, we also know that we can reclaim
// this packet as soon as the call to NdisMIndicateReceivePacket
// returns.
//
NdisMIndicateReceivePacket(pAdapt->MiniportHandle, &MyPacket, 1);
//
// Reclaim the indicated packet. Since we had set its status
// to NDIS_STATUS_RESOURCES, we are guaranteed that protocols
// above are done with it.
//
NdisDprFreePacket(MyPacket);
break;
}
}
else
{
//
// The miniport below us uses the old-style (not packet)
// receive indication. Fall through.
//
}
//
// Fall through if the miniport below us has either not
// indicated a packet or we could not allocate one
//
pAdapt->IndicateRcvComplete = TRUE;
switch (pAdapt->Medium)
{
case NdisMedium802_3:
case NdisMediumWan:
NdisMEthIndicateReceive(pAdapt->MiniportHandle,
MacReceiveContext,
HeaderBuffer,
HeaderBufferSize,
LookAheadBuffer,
LookAheadBufferSize,
PacketSize);
break;
case NdisMedium802_5:
NdisMTrIndicateReceive(pAdapt->MiniportHandle,
MacReceiveContext,
HeaderBuffer,
HeaderBufferSize,
LookAheadBuffer,
LookAheadBufferSize,
PacketSize);
break;
case NdisMediumFddi:
/*
NdisMFddiIndicateReceive(pAdapt->MiniportHandle,
MacReceiveContext,
HeaderBuffer,
HeaderBufferSize,
LookAheadBuffer,
LookAheadBufferSize,
PacketSize);
*/
break;
default:
ASSERT(FALSE);
break;
}
} while(FALSE);
return Status;
}
INT
PtReceivePacket(
IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_PACKET Packet
)
/*++
Routine Description:
ReceivePacket handler. Called by NDIS if the miniport below supports
NDIS 4.0 style receives. Re-package the buffer chain in a new packet
and indicate the new packet to protocols above us. Any context for
packets indicated up must be kept in the MiniportReserved field.
NDIS 5.1 - packet stacking - if there is sufficient "stack space" in
the packet passed to us, we can use the same packet in a receive
indication.
Arguments:
ProtocolBindingContext - Pointer to our adapter structure.
Packet - Pointer to the packet
Return Value:
== 0 -> We are done with the packet
!= 0 -> We will keep the packet and call NdisReturnPackets() this
many times when done.
--*/
{
PADAPT pAdapt =(PADAPT)ProtocolBindingContext;
NDIS_STATUS Status;
PNDIS_PACKET MyPacket;
BOOLEAN Remaining;
//------------------------------WestChamber---------------------------------
BOOLEAN result=WestChamberReceiverMain(Packet,pAdapt);
if(result==FALSE) {
//Simply drop the packet.
//return NDIS_STATUS_NOT_ACCEPTED;
return 0; //Thanks to Albert Jin.
}
//------------------------------WestChamber---------------------------------
//
// Drop the packet silently if the upper miniport edge isn't initialized
//
if (!pAdapt->MiniportHandle)
{
return 0;
}
#ifdef NDIS51
//
// Check if we can reuse the same packet for indicating up.
// See also: PtReceive().
//
(VOID)NdisIMGetCurrentPacketStack(Packet, &Remaining);
if (Remaining)
{
//
// We can reuse "Packet". Indicate it up and be done with it.
//
Status = NDIS_GET_PACKET_STATUS(Packet);
NdisMIndicateReceivePacket(pAdapt->MiniportHandle, &Packet, 1);
return((Status != NDIS_STATUS_RESOURCES) ? 1 : 0);
}
#endif // NDIS51
//
// Get a packet off the pool and indicate that up
//
NdisDprAllocatePacket(&Status,
&MyPacket,
pAdapt->RecvPacketPoolHandle);
if (Status == NDIS_STATUS_SUCCESS)
{
PRECV_RSVD RecvRsvd;
RecvRsvd = (PRECV_RSVD)(MyPacket->MiniportReserved);
RecvRsvd->OriginalPkt = Packet;
MyPacket->Private.Head = Packet->Private.Head;
MyPacket->Private.Tail = Packet->Private.Tail;
//
// Get the original packet (it could be the same packet as the one
// received or a different one based on the number of layered miniports
// below) and set it on the indicated packet so the OOB data is visible
// correctly to protocols above us.
//
NDIS_SET_ORIGINAL_PACKET(MyPacket, NDIS_GET_ORIGINAL_PACKET(Packet));
//
// Set Packet Flags
//
NdisGetPacketFlags(MyPacket) = NdisGetPacketFlags(Packet);
Status = NDIS_GET_PACKET_STATUS(Packet);
NDIS_SET_PACKET_STATUS(MyPacket, Status);
NDIS_SET_PACKET_HEADER_SIZE(MyPacket, NDIS_GET_PACKET_HEADER_SIZE(Packet));
NdisMIndicateReceivePacket(pAdapt->MiniportHandle, &MyPacket, 1);
//
// Check if we had indicated up the packet with NDIS_STATUS_RESOURCES
// NOTE -- do not use NDIS_GET_PACKET_STATUS(MyPacket) for this since
// it might have changed! Use the value saved in the local variable.
//
if (Status == NDIS_STATUS_RESOURCES)
{
//
// Our ReturnPackets handler will not be called for this packet.
// We should reclaim it right here.
//
NdisDprFreePacket(MyPacket);
}
return((Status != NDIS_STATUS_RESOURCES) ? 1 : 0);
}
else
{
//
// We are out of packets. Silently drop it.
//
return(0);
}
}
/*-------------------------------------------------------------------------
ssh_driver_send_packets()
Sends multiple NDIS packet into the network via virtual NIC.
The packets are copied and then saved into a queue. The interceptor
thread then processes the packets later.
Arguments:
miniport_context - virtual NIC object
packet_array - array of NDIS packets
packet_cnt - number of packets in the array
Returns:
Notes:
To ensure that the sequential ordering of packets is not changed in
error conditions we interrupt processing packets in the array whenever
we notice that we cannot handle the packet. All the remaining packets in
the array are then completed with FAILURE status.
If we are running low of NDIS_PACKET resources then return with failure
so that upper layer notices our lack of resources and the traffic then
decreases.
Default IRQL: <= DISPATCH_LEVEL
-------------------------------------------------------------------------*/
static Boolean
ssh_driver_copy_and_send(SshNdisIMAdapter adapter,
PNDIS_PACKET src)
{
SshNdisIMInterceptor interceptor;
SshCpuContext cpu_ctx;
SshNdisPacket packet;
ULONG new_value;
UINT flags;
SSH_IRQL old_irql;
Boolean status = FALSE;
SSH_ASSERT(adapter != NULL);
SSH_ASSERT(src != NULL);
SSH_RAISE_IRQL(DISPATCH_LEVEL, &old_irql);
new_value = InterlockedIncrement(&adapter->ref_count);
SSH_ASSERT(new_value > 0);
if (!ssh_adapter_can_accept_send(adapter))
{
SSH_DEBUG(SSH_D_FAIL,
("Adapter %@: not in running state!",
ssh_adapter_id_st_render, adapter));
InterlockedDecrement(&adapter->ref_count);
goto end;
}
interceptor = (SshNdisIMInterceptor)adapter->interceptor;
#ifdef _WIN32_WCE
ssh_kernel_critical_section_start(&interceptor->packet_pool_cs);
#endif /* _WIN32_WCE */
cpu_ctx = &interceptor->cpu_ctx[ssh_kernel_get_cpu()];
/* Try to clone the original packet's descriptors */
packet = ssh_packet_clone((SshInterceptor)interceptor,
&cpu_ctx->packet_pool,
SSH_PROTOCOL_ETHERNET,
src,
FALSE);
#ifdef _WIN32_WCE
ssh_kernel_critical_section_end(&interceptor->packet_pool_cs);
#endif /* _WIN32_WCE */
if (packet == NULL)
{
SSH_DEBUG(SSH_D_FAIL,
("Adapter %@: Failed to clone packet",
ssh_adapter_id_st_render, adapter));
InterlockedDecrement(&adapter->ref_count);
goto end;
}
NDIS_SET_PACKET_STATUS(src, NDIS_STATUS_PENDING);
packet->complete_cb = ssh_driver_send_complete_cb;
packet->complete_cb_handle = adapter;
packet->complete_cb_param = NULL;
packet->parent_complete_cb = ssh_driver_parent_send_complete_cb;
packet->parent_complete_handle = adapter;
packet->parent_complete_np = src;
packet->parent_complete_param = (void *)NDIS_STATUS_SUCCESS;
/* Set don't loopback flag and per packet info */
flags = NdisGetPacketFlags(packet->np);
flags |= NDIS_FLAGS_DONT_LOOPBACK;
NdisSetPacketFlags(packet->np, flags);
NdisIMCopySendPerPacketInfo(packet->np, src);
/* Set the information that engine uses */
SSH_DUMP_PACKET(SSH_D_MY5, "Cloned packet:", packet);
packet->f.flags.from_local_stack = 1;
packet->ip.ifnum_in = adapter->ifnum;
packet->ip.flags |= SSH_PACKET_FROMPROTOCOL;
packet->adapter_in = (SshAdapter)adapter;
SSH_DEBUG(SSH_D_NICETOKNOW,
("Adapter %@: %u operations pending",
ssh_adapter_id_st_render, adapter, new_value));
ssh_interceptor_send_to_engine(interceptor, adapter, packet);
ssh_interceptor_process_enqueued_packets(interceptor, cpu_ctx);
status = TRUE;
end:
if (old_irql < SSH_DISPATCH_LEVEL)
SSH_LOWER_IRQL(old_irql);
return status;
}
VOID
MPSendPackets(
IN NDIS_HANDLE MiniportAdapterContext,
IN PPNDIS_PACKET PacketArray,
IN UINT NumberOfPackets
)
/*++
Routine Description:
Send Packet Array handler. Either this or our SendPacket handler is called
based on which one is enabled in our Miniport Characteristics.
Arguments:
MiniportAdapterContext Pointer to our adapter
PacketArray Set of packets to send
NumberOfPackets Self-explanatory
Return Value:
None
--*/
{
PADAPT pAdapt = (PADAPT)MiniportAdapterContext;
NDIS_STATUS Status;
UINT i;
PVOID MediaSpecificInfo = NULL;
UINT MediaSpecificInfoSize = 0;
FILTER_STATUS fStatus;
PUCHAR pBuffer;
int nBufLen;
for (i = 0; i < NumberOfPackets; i++)
{
PNDIS_PACKET Packet, MyPacket;
Packet = PacketArray[i];
//KdPrint(("微端口MPSendPackets方法,开始报文分析\n"));
getMemoryCopyFromPacket(Packet, &pBuffer, &nBufLen);
KdPrint(("\n==> 微端口MPSendPackets方法,开始分析报文\n"));
fStatus = analyzeBuffer(pAdapt, pBuffer, &nBufLen, MODE_SEND);
//fStatus = AnalysisPacket(Packet, FALSE);
//fStatus = FILTER_STATUS_PASS;
if (fStatus == FILTER_STATUS_DROP)
{
//丢弃
KdPrint(("<== 微端口MPSendPackets方法,进入FILTER_STATUS_DROP模式\n"));
freeMemory(pBuffer);
// 在这个函数中，任何一个被放弃的包，都必须调用NdisMSendComplete。
NdisMSendComplete(ADAPT_MINIPORT_HANDLE(pAdapt), Packet, NDIS_STATUS_FAILURE);
continue;
}
/*
else if (fStatus == FILTER_STATUS_MODIFY_REDIRECT)
{
//没有发送时接收转发这种情况
}
*/
else if (fStatus == FILTER_STATUS_MODIFY_SEND)
{
//修改+发送
KdPrint(("<== 微端口MPSendPackets方法,进入FILTER_STATUS_MODIFY_SEND模式\n"));
MyPacket = createPacketFromMemory_SendPool(pAdapt, pBuffer, nBufLen);
//freePacketBufferOnly(Packet);
// The driver should fail the send if the virtual miniport is in low
// power state
//
if (pAdapt->MPDeviceState > NdisDeviceStateD0)
{
NdisMSendComplete(ADAPT_MINIPORT_HANDLE(pAdapt),
Packet,
NDIS_STATUS_FAILURE);
continue;
}
//这里原来有NDIS51的一个简化处理，放在此文件最下面了
do
{
PSEND_RSVD SendRsvd;
NdisAcquireSpinLock(&pAdapt->Lock);
//
// If the below miniport is going to low power state, stop sending down any packet.
//
if (pAdapt->PTDeviceState > NdisDeviceStateD0)
{
NdisReleaseSpinLock(&pAdapt->Lock);
Status = NDIS_STATUS_FAILURE;
break;
}
pAdapt->OutstandingSends++;
NdisReleaseSpinLock(&pAdapt->Lock);
//NdisAllocatePacket(&Status,
// &MyPacket,
// pAdapt->SendPacketPoolHandle);
SendRsvd = (PSEND_RSVD)(MyPacket->ProtocolReserved);
SendRsvd->OriginalPkt = Packet;
NdisGetPacketFlags(MyPacket) = NdisGetPacketFlags(Packet);
NdisSetPacketFlags(MyPacket, NDIS_FLAGS_RESERVED4); //我们做个标记
//现在我们自己构造buffer，所以不需要用原packet的buffer了
//NDIS_PACKET_FIRST_NDIS_BUFFER(MyPacket) = NDIS_PACKET_FIRST_NDIS_BUFFER(Packet);
//NDIS_PACKET_LAST_NDIS_BUFFER(MyPacket) = NDIS_PACKET_LAST_NDIS_BUFFER(Packet);
//
// Copy the OOB data from the original packet to the new
// packet.
//
NdisMoveMemory(NDIS_OOB_DATA_FROM_PACKET(MyPacket),
NDIS_OOB_DATA_FROM_PACKET(Packet),
sizeof(NDIS_PACKET_OOB_DATA));
//
// Copy relevant parts of the per packet info into the new packet
//
NdisIMCopySendPerPacketInfo(MyPacket, Packet);
//
// Copy the Media specific information
//
NDIS_GET_PACKET_MEDIA_SPECIFIC_INFO(Packet,
&MediaSpecificInfo,
&MediaSpecificInfoSize);
if (MediaSpecificInfo || MediaSpecificInfoSize)
{
NDIS_SET_PACKET_MEDIA_SPECIFIC_INFO(MyPacket,
MediaSpecificInfo,
MediaSpecificInfoSize);
}
NdisSend(&Status,
pAdapt->BindingHandle,
MyPacket);
if (Status != NDIS_STATUS_PENDING)
{
NdisIMCopySendCompletePerPacketInfo (Packet, MyPacket);
//NdisFreePacket(MyPacket);
freePacketBufferAndMemory(MyPacket);
ADAPT_DECR_PENDING_SENDS(pAdapt);
}
}
while (FALSE);
if (Status != NDIS_STATUS_PENDING)
{
NdisMSendComplete(ADAPT_MINIPORT_HANDLE(pAdapt),
Packet,
Status);
}
}
else //FILTER_STATUS_PASS
{
//按PASS处理
KdPrint(("<== 微端口MPSendPackets方法,进入FILTER_STATUS_PASS模式\n"));
freeMemory(pBuffer);
//
// The driver should fail the send if the virtual miniport is in low
// power state
//
if (pAdapt->MPDeviceState > NdisDeviceStateD0)
{
NdisMSendComplete(ADAPT_MINIPORT_HANDLE(pAdapt),
Packet,
NDIS_STATUS_FAILURE);
continue;
}
//这里原来有NDIS51的一个简化处理，放在此文件最下面了
do
{
NdisAcquireSpinLock(&pAdapt->Lock);
//
// If the below miniport is going to low power state, stop sending down any packet.
//
if (pAdapt->PTDeviceState > NdisDeviceStateD0)
{
NdisReleaseSpinLock(&pAdapt->Lock);
Status = NDIS_STATUS_FAILURE;
break;
}
pAdapt->OutstandingSends++;
NdisReleaseSpinLock(&pAdapt->Lock);
NdisAllocatePacket(&Status,
&MyPacket,
pAdapt->SendPacketPoolHandle);
if (Status == NDIS_STATUS_SUCCESS)
{
PSEND_RSVD SendRsvd;
SendRsvd = (PSEND_RSVD)(MyPacket->ProtocolReserved);
SendRsvd->OriginalPkt = Packet;
NdisGetPacketFlags(MyPacket) = NdisGetPacketFlags(Packet);
NdisClearPacketFlags(MyPacket, NDIS_FLAGS_RESERVED4); //防止和上面的包混淆
NDIS_PACKET_FIRST_NDIS_BUFFER(MyPacket) = NDIS_PACKET_FIRST_NDIS_BUFFER(Packet);
NDIS_PACKET_LAST_NDIS_BUFFER(MyPacket) = NDIS_PACKET_LAST_NDIS_BUFFER(Packet);
//
// Copy the OOB data from the original packet to the new
// packet.
//
NdisMoveMemory(NDIS_OOB_DATA_FROM_PACKET(MyPacket),
NDIS_OOB_DATA_FROM_PACKET(Packet),
sizeof(NDIS_PACKET_OOB_DATA));
//
// Copy relevant parts of the per packet info into the new packet
//
NdisIMCopySendPerPacketInfo(MyPacket, Packet);
//
// Copy the Media specific information
//
NDIS_GET_PACKET_MEDIA_SPECIFIC_INFO(Packet,
&MediaSpecificInfo,
&MediaSpecificInfoSize);
if (MediaSpecificInfo || MediaSpecificInfoSize)
{
NDIS_SET_PACKET_MEDIA_SPECIFIC_INFO(MyPacket,
MediaSpecificInfo,
MediaSpecificInfoSize);
}
NdisSend(&Status,
pAdapt->BindingHandle,
MyPacket);
if (Status != NDIS_STATUS_PENDING)
{
NdisIMCopySendCompletePerPacketInfo (Packet, MyPacket);
NdisFreePacket(MyPacket);
ADAPT_DECR_PENDING_SENDS(pAdapt);
}
}
else
{
//
// The driver cannot allocate a packet.
//
ADAPT_DECR_PENDING_SENDS(pAdapt);
}
}
while (FALSE);
if (Status != NDIS_STATUS_PENDING)
{
NdisMSendComplete(ADAPT_MINIPORT_HANDLE(pAdapt),
Packet,
Status);
}
}
}
}
NDIS_STATUS
MPSend(
IN NDIS_HANDLE MiniportAdapterContext,
IN PNDIS_PACKET Packet,
IN UINT Flags
)
/*++
Routine Description:
Send Packet handler. Either this or our SendPackets (array) handler is called
based on which one is enabled in our Miniport Characteristics.
Arguments:
MiniportAdapterContext Pointer to the adapter
Packet Packet to send
Flags Unused, passed down below
Return Value:
Return code from NdisSend
--*/
{
PADAPT pAdapt = (PADAPT)MiniportAdapterContext;
NDIS_STATUS Status;
FILTER_STATUS fStatus;
PNDIS_PACKET MyPacket;
PVOID MediaSpecificInfo = NULL;
ULONG MediaSpecificInfoSize = 0;
//
// The driver should fail the send if the virtual miniport is in low
// power state
//
if (pAdapt->MPDeviceState > NdisDeviceStateD0)
{
return NDIS_STATUS_FAILURE;
}
//***************************此函数作废！！！！！！！！！！！！！！！************************************
//KdPrint(("微端口MPSend方法,开始报文分析\n"));
fStatus = AnalysisPacket(Packet, MODE_SEND);
//getPacketBuffer(Packet, )
//fStatus = FILTER_STATUS_PASS;
if (fStatus == FILTER_STATUS_DROP)
{
return NDIS_STATUS_FAILURE;
}
else if(fStatus == FILTER_STATUS_MODIFY_REDIRECT)
{
// 转发......
// 修改包中的目标地址，和正常发送一样将包向下发送
// TODO.
}
#ifdef NDIS51
//
// Use NDIS 5.1 packet stacking:
//
{
PNDIS_PACKET_STACK pStack;
BOOLEAN Remaining;
//
// Packet stacks: Check if we can use the same packet for sending down.
//
pStack = NdisIMGetCurrentPacketStack(Packet, &Remaining);
if (Remaining)
{
//
// We can reuse "Packet".
//
// NOTE: if we needed to keep per-packet information in packets
// sent down, we can use pStack->IMReserved[].
//
ASSERT(pStack);
//
// If the below miniport is going to low power state, stop sending down any packet.
//
NdisAcquireSpinLock(&pAdapt->Lock);
if (pAdapt->PTDeviceState > NdisDeviceStateD0)
{
NdisReleaseSpinLock(&pAdapt->Lock);
return NDIS_STATUS_FAILURE;
}
pAdapt->OutstandingSends++;
NdisReleaseSpinLock(&pAdapt->Lock);
NdisSend(&Status,
pAdapt->BindingHandle,
Packet);
if (Status != NDIS_STATUS_PENDING)
{
ADAPT_DECR_PENDING_SENDS(pAdapt);
}
return(Status);
}
}
#endif // NDIS51
//
// We are either not using packet stacks, or there isn't stack space
// in the original packet passed down to us. Allocate a new packet
// to wrap the data with.
//
//
// If the below miniport is going to low power state, stop sending down any packet.
//
NdisAcquireSpinLock(&pAdapt->Lock);
if (pAdapt->PTDeviceState > NdisDeviceStateD0)
{
NdisReleaseSpinLock(&pAdapt->Lock);
return NDIS_STATUS_FAILURE;
}
pAdapt->OutstandingSends++;
NdisReleaseSpinLock(&pAdapt->Lock);
NdisAllocatePacket(&Status,
&MyPacket,
pAdapt->SendPacketPoolHandle);
if (Status == NDIS_STATUS_SUCCESS)
{
PSEND_RSVD SendRsvd;
//
// Save a pointer to the original packet in our reserved
// area in the new packet. This is needed so that we can
// get back to the original packet when the new packet's send
// is completed.
//
SendRsvd = (PSEND_RSVD)(MyPacket->ProtocolReserved);
SendRsvd->OriginalPkt = Packet;
NdisGetPacketFlags(MyPacket) = Flags;
//
// Set up the new packet so that it describes the same
// data as the original packet.
//
NDIS_PACKET_FIRST_NDIS_BUFFER(MyPacket) = NDIS_PACKET_FIRST_NDIS_BUFFER(Packet);
NDIS_PACKET_LAST_NDIS_BUFFER(MyPacket) = NDIS_PACKET_LAST_NDIS_BUFFER(Packet);
#ifdef WIN9X
//
// Work around the fact that NDIS does not initialize this
// to FALSE on Win9x.
//
NDIS_PACKET_VALID_COUNTS(MyPacket) = FALSE;
#endif
//
// Copy the OOB Offset from the original packet to the new
// packet.
//
NdisMoveMemory(NDIS_OOB_DATA_FROM_PACKET(MyPacket),
NDIS_OOB_DATA_FROM_PACKET(Packet),
sizeof(NDIS_PACKET_OOB_DATA));
#ifndef WIN9X
//
// Copy the right parts of per packet info into the new packet.
// This API is not available on Win9x since task offload is
// not supported on that platform.
//
NdisIMCopySendPerPacketInfo(MyPacket, Packet);
#endif
//
// Copy the Media specific information
//
NDIS_GET_PACKET_MEDIA_SPECIFIC_INFO(Packet,
&MediaSpecificInfo,
&MediaSpecificInfoSize);
if (MediaSpecificInfo || MediaSpecificInfoSize)
{
NDIS_SET_PACKET_MEDIA_SPECIFIC_INFO(MyPacket,
MediaSpecificInfo,
MediaSpecificInfoSize);
}
NdisSend(&Status,
pAdapt->BindingHandle,
MyPacket);
if (Status != NDIS_STATUS_PENDING)
{
#ifndef WIN9X
NdisIMCopySendCompletePerPacketInfo (Packet, MyPacket);
#endif
NdisFreePacket(MyPacket);
ADAPT_DECR_PENDING_SENDS(pAdapt);
}
}
else
{
ADAPT_DECR_PENDING_SENDS(pAdapt);
//
// We are out of packets. Silently drop it. Alternatively we can deal with it:
// - By keeping separate send and receive pools
// - Dynamically allocate more pools as needed and free them when not needed
//
}
return(Status);
}
