NDIS send my packet?always return NDIS_STATUS_PENDING

NTDEV
1

Hi,
I wanna modified the received packets , then modified , send to our server machine , which ip address is 192.168.1.59(which network byte is 989964480(g_uDestIp) ), but NdisSend always return NDIS_STATUS_PENDING,What’s wrong? thanx.

here is code snippet ,

UCHAR g_server_mac = {0x00, 0x0c, 0x29, 0x33, 0x4a, 0xf8};
UCHAR g_client_mac = {0x00, 0x0c, 0x29, 0x5f, 0x78, 0xd4};

ULONG g_uSrcIp = 855746752;//192.168.1.51
ULONG g_uDestIp = 989964480;//192.168.1.59

**************************

NDIS_STATUS
FakePacket(
PNDIS_PACKET pPacket ,
PADAPT pAdapt ,
BOOLEAN bSender
)
{
NDIS_STATUS nRet = NDIS_STATUS_FAILURE;
PUCHAR pPacketContent = NULL;
PUCHAR pCustomPacketContent = NULL;
PNDIS_BUFFER NdisBuffer ;
UINT TotalPacketLength = 0;
UINT copysize = 0;
UINT DataOffset = 0 ;
UINT PhysicalBufferCount;
UINT BufferCount ;
PUCHAR tembuffer = NULL ;
UINT ActualDataLength=0;
PVOID VirtualAddress;
UINT Length=0;
UINT DataToCopy;
PNDIS_BUFFER Buffer;
UINT HeaderSize = 0;
PIP_HEADER pIpHeader;
UINT uOldPacketSize;
UINT uIpHeader = IP_HEADER_LENGTH;
UINT uTcpHeader = TCP_HEADER_LENGTH;
UINT uUdpHeader = UDP_HEADER_LENGTH;
UINT uIcmpHeader =ICMP_HEADER_LENGTH;
UINT uRealDataSize = 0;
UINT nIndex = 0;
UINT nHeaderLen = 0;
do
{
if ( pPacket == NULL ) break;
//if( g_nTimesSend == 0 ) break;

HeaderSize = NDIS_GET_PACKET_HEADER_SIZE(pPacket);

nRet = NdisAllocateMemoryWithTag( &pPacketContent, 2048, TAG);
if( nRet != NDIS_STATUS_SUCCESS ) break;
NdisZeroMemory( pPacketContent, 2048 ) ;

NdisQueryPacket(pPacket,
&PhysicalBufferCount,
&BufferCount,
&NdisBuffer,
&TotalPacketLength
);

while(TRUE){

NdisQueryBufferSafe(NdisBuffer,
&tembuffer,
&copysize,
NormalPagePriority
);

if(tembuffer != NULL){
NdisMoveMemory( pPacketContent + DataOffset , tembuffer, copysize) ;
DataOffset += copysize;
}

NdisGetNextBuffer(NdisBuffer , &NdisBuffer ) ;

if( NdisBuffer == NULL )
break ;
}

if(NTOHS(((PETHERNET_FRAME)pPacketContent)->FrameType)!=ETHERTYPE_IP)
{
DBGPRINT((“==========> IP packet\n”));
break;
}

if( bSender == TRUE )
{
if(TotalPacketLength<ethernet_frame_length> {
break;
}
else
pIpHeader=(PIP_HEADER)&pPacketContent[ETHERNET_FRAME_LENGTH];

switch(pIpHeader->Protocol)
{
case PROTOCOL_TCP:
uRealDataSize = TotalPacketLength - ETHERNET_FRAME_LENGTH - IP_HEADER_LENGTH - TCP_HEADER_LENGTH;
DBGPRINT((" ======> [TCP] uRealDataSize : %d\n" , uRealDataSize ));
nHeaderLen = ETHERNET_FRAME_LENGTH + IP_HEADER_LENGTH + TCP_HEADER_LENGTH;
break;
case PROTOCOL_UDP:
uRealDataSize = TotalPacketLength - ETHERNET_FRAME_LENGTH - IP_HEADER_LENGTH - UDP_HEADER_LENGTH;
DBGPRINT((" ======> [UDP] uRealDataSize : %d\n" , uRealDataSize ));
nHeaderLen = ETHERNET_FRAME_LENGTH + IP_HEADER_LENGTH + UDP_HEADER_LENGTH;
break;
case PROTOCOL_ICMP:
uRealDataSize = TotalPacketLength - ETHERNET_FRAME_LENGTH - IP_HEADER_LENGTH - ICMP_HEADER_LENGTH;
DBGPRINT((" ======> [ICMP] uRealDataSize : %d\n" , uRealDataSize ));
nHeaderLen = ETHERNET_FRAME_LENGTH + IP_HEADER_LENGTH + ICMP_HEADER_LENGTH;
break;
default: break;
}

if ( uRealDataSize > 0 )
{
custom_header_info csHeaderInfo = {0};

nRet = NdisAllocateMemoryWithTag( &pCustomPacketContent , uRealDataSize + sizeof(custom_header_info) , TAG );
if( nRet != NDIS_STATUS_SUCCESS ) break;
NdisZeroMemory( pCustomPacketContent, uRealDataSize + sizeof(custom_header_info) ) ;

//build our special header
RtlCopyMemory( csHeaderInfo.szMd5 , DEF_szMd5Flag , FLAG_LEN );
csHeaderInfo.protocol_type = _htons(CHALLENGE_PACKET);

//rebuild real data
NdisMoveMemory( pCustomPacketContent , &csHeaderInfo , sizeof(custom_header_info) );
NdisMoveMemory( pCustomPacketContent + sizeof(custom_header_info) , &pPacketContent[nHeaderLen] , uRealDataSize );

NdisZeroMemory( &pPacketContent[nHeaderLen], uRealDataSize ) ;
NdisMoveMemory( pPacketContent + nHeaderLen , pCustomPacketContent , uRealDataSize + sizeof(custom_header_info) );

pIpHeader->DestinationIp = g_uDestIp;
pIpHeader->SourceIp = g_uSrcIp;
//calc modified packet size
pIpHeader->DatagramLength = _htons( TotalPacketLength + sizeof(custom_header_info) );

//checksum IP header
pIpHeader->CheckSum = 0;
pIpHeader->CheckSum = checksum( &pPacketContent[ETHERNET_FRAME_LENGTH] , IP_HEADER_LENGTH );

DBGPRINT(( “[sender] FakePacket Checksum : 0x%x , DatagramLength : %d\n” , pIpHeader->CheckSum , NTOHS(pIpHeader->DatagramLength) ));

//send modified packet
nRet = MySendPacket(pAdapt->BindingHandle, pAdapt->SendPacketPoolHandle, &pPacketContent, NTOHS(pIpHeader->DatagramLength) );
if (nRet != NDIS_STATUS_SUCCESS && nRet != NDIS_STATUS_PENDING)
{
DbgPrint(“MySendPacket error : 0x%08x\n”, nRet);
}
}

}
} while (0);

if( pPacketContent != NULL )
NdisFreeMemory(pPacketContent, 0, 0);

if( pCustomPacketContent != NULL )
NdisFreeMemory(pCustomPacketContent, 0, 0);
return nRet;
}

***********************************

NDIS_STATUS
MySendPacket (
NDIS_HANDLE NdisBindingHandle,
NDIS_HANDLE NdisSendPacketPool,
PVOID pBuffer,
ULONG dwBufferLength
)
{
NDIS_STATUS status;
PNDIS_PACKET pSendPacket = NULL;
PNDIS_BUFFER pSendPacketBuffer = NULL;
PUCHAR pSendBuffer = NULL;
ULONG dwSendBufferLength;
NDIS_PHYSICAL_ADDRESS HighestAcceptableAddress;
PSEND_RSVD SendRsvd = NULL;

if (!NdisBindingHandle)
return NDIS_STATUS_FAILURE;

if (!pBuffer)
return NDIS_STATUS_FAILURE;

if (dwBufferLength > ETH_MAX_PACKET_SIZE)
return NDIS_STATUS_FAILURE;

HighestAcceptableAddress.QuadPart = -1;
dwSendBufferLength = max(dwBufferLength, ETH_MIN_PACKET_SIZE);

status = NdisAllocateMemory(&pSendBuffer, dwSendBufferLength, 0, HighestAcceptableAddress);
if (status != NDIS_STATUS_SUCCESS)
{
return status;
}

RtlZeroMemory(pSendBuffer, dwSendBufferLength);
RtlMoveMemory(pSendBuffer, pBuffer, dwSendBufferLength);

NdisAllocatePacket(&status, &pSendPacket, NdisSendPacketPool);
if (status != NDIS_STATUS_SUCCESS)
{
NdisFreeMemory(pSendBuffer, dwSendBufferLength, 0);

return status;
}

NdisAllocateBuffer( &status,
&pSendPacketBuffer,
NdisSendPacketPool,
pSendBuffer,
dwSendBufferLength );
if (status != NDIS_STATUS_SUCCESS)
{
NdisFreeMemory(pSendBuffer, dwSendBufferLength, 0);
NdisDprFreePacket(pSendPacket);

return status;
}

NdisChainBufferAtFront(pSendPacket, pSendPacketBuffer);

SendRsvd = (PSEND_RSVD)(pSendPacket->ProtocolReserved);
SendRsvd->OriginalPkt = NULL;

pSendPacket->Private.Head->Next=NULL;
pSendPacket->Private.Tail=NULL;

NdisSetPacketFlags(pSendPacket, NDIS_FLAGS_DONT_LOOPBACK);
NdisSend(&status, NdisBindingHandle, pSendPacket);
if (status != STATUS_PENDING)
{
NdisUnchainBufferAtFront(pSendPacket ,&pSendPacketBuffer);
NdisQueryBufferSafe( pSendPacketBuffer,
(PVOID *)&pSendBuffer,
&dwSendBufferLength,
HighPagePriority );
NdisFreeBuffer(pSendPacketBuffer);
NdisFreeMemory(pSendBuffer, dwSendBufferLength, 0);
NdisDprFreePacket(pSendPacket);
}

return status;
}</ethernet_frame_length>