BOOLEAN PacketDelMulticast( LPADAPTER AdapterObject, LPBYTE address )
{
BOOLEAN Status = FALSE;
LPBYTE p;
int i, count;
LPPACKET lpPacket, lpPacket2;
D(bug("PacketDelMulticast\n"));
if(packet_filter & (NDIS_PACKET_TYPE_ALL_MULTICAST|NDIS_PACKET_TYPE_PROMISCUOUS)) {
D(bug("PacketDelMulticast: already listening for all multicast\n"));
return TRUE;
}
lpPacket = PacketQueryOid( AdapterObject, OID_802_3_MULTICAST_LIST, MAX_MULTICAST_SZ );
#define OidData ((PPACKET_OID_DATA)(lpPacket->Buffer))
if(lpPacket) {
count = OidData->Length / ETH_802_3_ADDRESS_LENGTH;
D(bug("PacketDelMulticast: %d old addresses\n",count));
Status = FALSE;
p = (LPBYTE)OidData->Data;
for( i=0; i<count; i++ ) {
int tail_len;
if(memcmp(p,address,ETH_802_3_ADDRESS_LENGTH) == 0) {
D(bug("PacketDelMulticast: address found, deleting\n"));
ULONG IoCtlBufferLength = (sizeof(PACKET_OID_DATA)+ETH_802_3_ADDRESS_LENGTH*(count-1)-1);
lpPacket2 = PacketAllocatePacket( AdapterObject, IoCtlBufferLength );
#define OidData2 ((PPACKET_OID_DATA)(lpPacket2->Buffer))
if ( lpPacket2 ) {
OidData2->Oid = OID_802_3_MULTICAST_LIST;
OidData2->Length = ETH_802_3_ADDRESS_LENGTH*(count-1);
tail_len = ETH_802_3_ADDRESS_LENGTH * (count-i-1);
if(tail_len) memmove( p, p+ETH_802_3_ADDRESS_LENGTH, tail_len );
if(OidData2->Length) memcpy( OidData2->Data, OidData->Data, OidData2->Length );
if(count == 1) memset( OidData2->Data, 0, ETH_802_3_ADDRESS_LENGTH ); // eh...
Status = PacketRequest( AdapterObject, lpPacket2, TRUE );
PacketFreePacket( lpPacket2 );
D(bug("PacketDelMulticast: PacketRequest returned status 0x%X, last error = 0x%X\n",Status,GetLastError()));
}
break;
#undef OidData2
}
p += ETH_802_3_ADDRESS_LENGTH;
}
if( i == count ) {
D(bug("PacketDelMulticast: cannot delete, was not defined\n"));
}
PacketFreePacket( lpPacket );
#undef OidData
}
// return Status;
return TRUE;
}
LPPACKET PacketQueryOid(
LPADAPTER lpAdapter,
ULONG ulOid,
ULONG ulLength
)
{
ULONG ioctl;
LPPACKET lpPacket;
#define pOidData ((PPACKET_OID_DATA)(lpPacket->Buffer))
lpPacket = PacketAllocatePacket( lpAdapter, sizeof(PACKET_OID_DATA)-1+ulLength );
if( lpPacket ) {
ioctl = IOCTL_PROTOCOL_QUERY_OID;
pOidData->Oid = ulOid;
pOidData->Length = ulLength;
if (PacketRequest( lpAdapter, lpPacket, FALSE )) {
return lpPacket;
}
PacketFreePacket( lpPacket );
}
#undef pOidData
return 0;
}
BOOLEAN PacketSendPacket(
LPADAPTER AdapterObject,
LPPACKET lpPacket,
BOOLEAN Sync,
BOOLEAN RecyclingAllowed
)
{
BOOLEAN Result;
#if DEBUG_PACKETS
D(bug("Packet32: PacketSendPacket bytes=%d, sync=%d\n",lpPacket->Length,Sync));
#endif
lpPacket->OverLapped.Offset = 0;
lpPacket->OverLapped.OffsetHigh = 0;
lpPacket->bIoComplete = FALSE;
if(Sync) {
Result = WriteFile(
AdapterObject->hFile,
lpPacket->Buffer,
lpPacket->Length,
&lpPacket->BytesReceived,
&lpPacket->OverLapped
);
if(Result) {
Result = GetOverlappedResult(
AdapterObject->hFile,
&lpPacket->OverLapped,
&lpPacket->BytesReceived,
TRUE
);
} else {
D(bug("Packet32: PacketSendPacket WriteFile failed, err=%d\n",(int)GetLastError()));
}
lpPacket->bIoComplete = TRUE;
if(RecyclingAllowed) PacketFreePacket(lpPacket);
#if DEBUG_PACKETS
D(bug("Packet32: PacketSendPacket result=%d, bytes=%d\n",(int)Result,(int)lpPacket->BytesReceived));
#endif
} else {
// don't care about the result
Result = WriteFileEx(
AdapterObject->hFile,
lpPacket->Buffer,
lpPacket->Length,
&lpPacket->OverLapped,
PacketSendCompletionRoutine
);
#if DEBUG_PACKETS
D(bug("Packet32: PacketSendPacket result=%d\n",(int)Result));
#endif
if(!Result && RecyclingAllowed) {
recycle_write_packet(lpPacket);
}
}
return Result;
}
//关闭网络网卡
void NetworkInterface::PacketClose(LPADAPTER &lpAdapter, LPPACKET &lpPacket)
{
//free a PACKET structure
delete (lpPacket->Buffer);
lpPacket->Length = 0;
PacketFreePacket(lpPacket);
//关闭网卡并退出
PacketCloseAdapter(lpAdapter);
}
INT PacketSendPackets(LPADAPTER AdapterObject,
PVOID PacketBuff,
ULONG Size,
BOOLEAN Sync)
{
struct dump_bpf_hdr *winpcap_hdr;
PCHAR EndOfUserBuff = (PCHAR)PacketBuff + Size;
LPPACKET PacketToSend;
BOOLEAN res;
// Start from the first packet
winpcap_hdr = (struct dump_bpf_hdr*)PacketBuff;
if( (PCHAR)winpcap_hdr + winpcap_hdr->caplen + sizeof(struct dump_bpf_hdr) > EndOfUserBuff )
{
// Malformed buffer
return 0;
}
while( TRUE ){
if(winpcap_hdr->caplen ==0 || winpcap_hdr->caplen > 65536)
{
// Malformed header
return 0;
}
// Set up the LPPACKET structure
PacketToSend=PacketAllocatePacket();
PacketInitPacket(PacketToSend,
(PCHAR)winpcap_hdr + sizeof(struct dump_bpf_hdr),
winpcap_hdr->caplen);
// Send the packet
res = PacketSendPacket (AdapterObject, PacketToSend, TRUE);
// Free the just used LPPACKET structure
PacketFreePacket(PacketToSend);
if(res == FALSE){
// Error sending the packet
return (PCHAR)winpcap_hdr - (PCHAR)PacketBuff;
}
// Step to the next packet in the buffer
(PCHAR)winpcap_hdr += winpcap_hdr->caplen + sizeof(struct dump_bpf_hdr);
// Check if the end of the user buffer has been reached
if( (PCHAR)winpcap_hdr >= EndOfUserBuff )
{
return (PCHAR)winpcap_hdr - (PCHAR)PacketBuff;
}
}
}
static void free_write_packets( void )
{
LPPACKET next;
int i = 0;
while(write_packet_pool) {
next = write_packet_pool->next;
D(bug("Freeing write packet %ld\n",++i));
PacketFreePacket(write_packet_pool);
write_packet_pool = next;
}
}
/* Send a packet to the network */
int
pcap_sendpacket(pcap_t *p, u_char *buf, int size){
LPPACKET PacketToSend;
if (p->adapter==NULL)
{
snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Writing a packet is allowed only on a physical adapter");
return -1;
}
PacketToSend=PacketAllocatePacket();
PacketInitPacket(PacketToSend,buf,size);
if(PacketSendPacket(p->adapter,PacketToSend,TRUE) == FALSE){
PacketFreePacket(PacketToSend);
return -1;
}
PacketFreePacket(PacketToSend);
return 0;
}
eth_t *
eth_close(eth_t *eth)
{
if (eth != NULL) {
if (eth->pkt != NULL)
PacketFreePacket(eth->pkt);
if (eth->lpa != NULL)
PacketCloseAdapter(eth->lpa);
free(eth);
}
return (NULL);
}
/**
* Close the adapter (no more packets can be sent or received)
*
* @param adapter adapter handle received by a call to init_adapter, invalid on return
*/
void
shutdown_adapter(void *adapter)
{
struct packet_adapter *pa = (struct packet_adapter*)adapter;
if (pa != NULL) {
if (pa->lpPacket) {
PacketFreePacket(pa->lpPacket);
}
if (pa->lpAdapter) {
PacketCloseAdapter(pa->lpAdapter);
}
free(pa);
}
}
long sockSendData(void *pData, int Size) {
u8 *data = (u8*)pData;
// printf("_sendPacket %d (time=%d)\n", Size, timeGetTime());
while (Size > 0) {
PacketInitPacket(lpSendPacket, data, Size > 1024 ? 1024 : Size);
if(PacketSendPacket(lpAdapter,lpSendPacket,FALSE)==FALSE){
printf("Error: PacketSendPacket failed\n");
return (-1);
}
data+= 1024; Size-= 1024;
PacketFreePacket(lpSendPacket);
}
return 0;
}
//发包
int NetworkInterface::SendPacket(u_char *buffer, int packetLen, int repeatNum)
{
LPPACKET lpPacket;
memcpy((buffer + 6), srcMAC, 6);
//分配并初始化一个包结构，将用于发送数据包
if ( (lpPacket = PacketAllocatePacket()) == NULL )
{
LastErrCode = GetLastError();
strcpy_s(LastErrStr, "Error: failed to allocate the LPPACKET structure.");
return (-1);
}
PacketInitPacket(lpPacket, buffer, packetLen);
if (PacketSetNumWrites(adapter.lpAdapter, repeatNum) == FALSE)
{
LastErrCode = GetLastError();
strcpy_s(LastErrStr, "Unable to send more than one packet in a single write!");
PacketFreePacket(lpPacket);
return -1;
}
if(PacketSendPacket(adapter.lpAdapter, lpPacket, TRUE) == FALSE)
{
LastErrCode = GetLastError();
strcpy_s(LastErrStr, "Error sending the packets!");
PacketFreePacket(lpPacket);
return -1;
}
PacketFreePacket(lpPacket);
//将发送的数据包转存到文件中
//PrintPacket(buffer, packetLen, 1);
return 0;
}
/**
* Send a packet
*
* @param adapter adapter handle received by a call to init_adapter
* @param buffer complete packet to send (including ETH header; without CRC)
* @param len length of the packet (including ETH header; without CRC)
*/
int
packet_send(void *adapter, void *buffer, int len)
{
struct packet_adapter *pa = (struct packet_adapter*)adapter;
LPPACKET lpPacket;
if (pa == NULL) {
return -1;
}
if ((lpPacket = PacketAllocatePacket()) == NULL) {
return -1;
}
PacketInitPacket(lpPacket, buffer, len);
if (!PacketSendPacket(pa->lpAdapter, lpPacket, TRUE)) {
return -1;
}
PacketFreePacket(lpPacket);
return 0;
}
static bool tap_send_packet(
LPADAPTER fd,
LPPACKET lpPacket,
BOOLEAN Sync,
BOOLEAN RecyclingAllowed)
{
BOOLEAN Result;
lpPacket->OverLapped.Offset = 0;
lpPacket->OverLapped.OffsetHigh = 0;
lpPacket->bIoComplete = FALSE;
if (Sync) {
Result = WriteFile(fd->hFile,
lpPacket->Buffer,
lpPacket->Length,
&lpPacket->BytesReceived,
&lpPacket->OverLapped);
if (Result) {
GetOverlappedResult(fd->hFile,
&lpPacket->OverLapped,
&lpPacket->BytesReceived,
TRUE);
}
lpPacket->bIoComplete = TRUE;
if (RecyclingAllowed)
PacketFreePacket(lpPacket);
}
else {
Result = WriteFileEx(fd->hFile,
lpPacket->Buffer,
lpPacket->Length,
&lpPacket->OverLapped,
tap_write_completion);
if (!Result && RecyclingAllowed)
recycle_write_packet(lpPacket);
}
return Result;
}
long sockRecvData(void *pData, int Size) {
int ret;
ret = _recvPacket(pData);
if (ret > 0) return ret;
PacketInitPacket(lpRecvPacket, buffer, BUFFER_SIZE);
if(PacketReceivePacket(lpAdapter,lpRecvPacket,TRUE)==FALSE){
printf("Error: PacketReceivePacket failed");
return (-1);
}
lbytes = lpRecvPacket->ulBytesReceived;
tbytes+= lbytes;
// DEV9_LOG("PacketReceivePacket %d:\n", lbytes);
if (lbytes == 0) return 0;
memcpy(buffer, lpRecvPacket->Buffer, lbytes);
buf = buffer;
PacketFreePacket(lpRecvPacket);
return _recvPacket(pData);
}
eth_t *
eth_close(eth_t *eth)
{
HANDLE pcapMutex;
DWORD wait;
if (eth != NULL) {
if (eth->pkt != NULL)
PacketFreePacket(eth->pkt);
if (eth->lpa != NULL)
{
pcapMutex = CreateMutex(NULL, 0, "Global\\DnetPcapHangAvoidanceMutex");
wait = WaitForSingleObject(pcapMutex, INFINITE);
PacketCloseAdapter(eth->lpa);
if (wait == WAIT_ABANDONED || wait == WAIT_OBJECT_0) {
ReleaseMutex(pcapMutex);
}
CloseHandle(pcapMutex);
}
free(eth);
}
return (NULL);
}
BOOLEAN PacketGetMAC( LPADAPTER AdapterObject, LPBYTE address, BOOL permanent )
{
BOOLEAN Status;
LPPACKET lpPacket;
lpPacket = PacketQueryOid(
AdapterObject,
permanent ? OID_802_3_PERMANENT_ADDRESS : OID_802_3_CURRENT_ADDRESS,
ETH_802_3_ADDRESS_LENGTH
);
if(lpPacket) {
memcpy( address,
((BYTE *)(lpPacket->Buffer)) + sizeof(PACKET_OID_DATA) - 1,
ETH_802_3_ADDRESS_LENGTH );
PacketFreePacket( lpPacket );
Status = TRUE;
} else {
Status = FALSE;
}
return Status;
}
BOOLEAN PacketSetFilter( LPADAPTER AdapterObject, ULONG Filter )
{
BOOLEAN Status;
ULONG IoCtlBufferLength = (sizeof(PACKET_OID_DATA)+sizeof(ULONG)-1);
LPPACKET lpPacket;
lpPacket = PacketAllocatePacket( AdapterObject, IoCtlBufferLength );
#define lpOidData ((PPACKET_OID_DATA)(lpPacket->Buffer))
if ( lpPacket ) {
lpOidData->Oid = OID_GEN_CURRENT_PACKET_FILTER;
lpOidData->Length = sizeof(ULONG);
*((PULONG)lpOidData->Data) = Filter;
Status = PacketRequest( AdapterObject, lpPacket, TRUE );
PacketFreePacket( lpPacket );
} else {
Status = FALSE;
}
#undef lpOidData
return Status;
}
bool SniffPacketThread::OpenAdapter(char *theAdapterName)
{
m_lpa = PacketOpenAdapter(theAdapterName);
if(m_lpa == NULL)
{
TRACE0("PacketOpenAdapter failed");
return(FALSE);
}
// Allocate packet mem
m_lpp = PacketAllocatePacket();
if( m_lpp == NULL)
{
TRACE0("PacketAllocatePacket failed");
PacketCloseAdapter(m_lpa);
return(FALSE);
}
PacketInitPacket(m_lpp, m_pbuf, 512000);
// Set Kernel Buffer Size
if( PacketSetBuff(m_lpa, 512000) == FALSE
||
PacketSetReadTimeout(m_lpa, 1000) == FALSE)
{
PacketCloseAdapter(m_lpa);
PacketFreePacket(m_lpp);
m_enabled = FALSE;
m_handle = NULL;
return(FALSE);
}
PacketSetHwFilter(m_lpa, NDIS_PACKET_TYPE_PROMISCUOUS);
return(TRUE);
}
int main()
{
//define a pointer to an ADAPTER structure
LPADAPTER lpAdapter = 0;
//define a pointer to a PACKET structure
LPPACKET lpPacket;
int i;
DWORD dwErrorCode;
//ascii strings
char AdapterName[8192]; // string that contains a list of the network adapters
char *temp,*temp1;
int AdapterNum=0,Open;
ULONG AdapterLength;
char buffer[256000]; // buffer to hold the data coming from the driver
struct bpf_stat stat;
//
// Obtain the name of the adapters installed on this machine
//
printf("Packet.dll test application. Library version:%s\n", PacketGetVersion());
printf("Adapters installed:\n");
i=0;
AdapterLength = sizeof(AdapterName);
if(PacketGetAdapterNames(AdapterName,&AdapterLength)==FALSE){
printf("Unable to retrieve the list of the adapters!\n");
return -1;
}
temp=AdapterName;
temp1=AdapterName;
while ((*temp!='\0')||(*(temp-1)!='\0'))
{
if (*temp=='\0')
{
memcpy(AdapterList[i],temp1,temp-temp1);
temp1=temp+1;
i++;
}
temp++;
}
AdapterNum=i;
for (i=0;i<AdapterNum;i++)
printf("\n%d- %s\n",i+1,AdapterList[i]);
printf("\n");
do
{
printf("Select the number of the adapter to open : ");
scanf("%d",&Open);
if (Open>AdapterNum) printf("\nThe number must be smaller than %d",AdapterNum);
} while (Open>AdapterNum);
lpAdapter = PacketOpenAdapter(AdapterList[Open-1]);
if (!lpAdapter || (lpAdapter->hFile == INVALID_HANDLE_VALUE))
{
dwErrorCode=GetLastError();
printf("Unable to open the adapter, Error Code : %lx\n",dwErrorCode);
return -1;
}
// set the network adapter in promiscuous mode
if(PacketSetHwFilter(lpAdapter,NDIS_PACKET_TYPE_PROMISCUOUS)==FALSE){
printf("Warning: unable to set promiscuous mode!\n");
}
// set a 512K buffer in the driver
if(PacketSetBuff(lpAdapter,512000)==FALSE){
printf("Unable to set the kernel buffer!\n");
return -1;
}
// set a 1 second read timeout
if(PacketSetReadTimeout(lpAdapter,1000)==FALSE){
printf("Warning: unable to set the read tiemout!\n");
}
//allocate and initialize a packet structure that will be used to
//receive the packets.
if((lpPacket = PacketAllocatePacket())==NULL){
printf("\nError: failed to allocate the LPPACKET structure.");
return (-1);
}
PacketInitPacket(lpPacket,(char*)buffer,256000);
//main capture loop
while(!kbhit())
{
// capture the packets
if(PacketReceivePacket(lpAdapter,lpPacket,TRUE)==FALSE){
printf("Error: PacketReceivePacket failed");
return (-1);
}
PrintPackets(lpPacket);
}
//print the capture statistics
if(PacketGetStats(lpAdapter,&stat)==FALSE){
printf("Warning: unable to get stats from the kernel!\n");
}
else
printf("\n\n%d packets received.\n%d Packets lost",stat.bs_recv,stat.bs_drop);
PacketFreePacket(lpPacket);
// close the adapter and exit
PacketCloseAdapter(lpAdapter);
return (0);
}
BOOLEAN PacketAddMulticast( LPADAPTER AdapterObject, LPBYTE address )
{
BOOLEAN Status = FALSE;
LPBYTE p;
int i, count;
LPPACKET lpPacket;
D(bug("PacketAddMulticast\n"));
/*
if(packet_filter & (NDIS_PACKET_TYPE_ALL_MULTICAST|NDIS_PACKET_TYPE_PROMISCUOUS)) {
D(bug("PacketAddMulticast: already listening for all multicast\n"));
return TRUE;
}
*/
lpPacket = PacketQueryOid( AdapterObject, OID_802_3_MULTICAST_LIST, MAX_MULTICAST_SZ );
#define OidData ((PPACKET_OID_DATA)(lpPacket->Buffer))
if(lpPacket) {
count = OidData->Length / ETH_802_3_ADDRESS_LENGTH;
D(bug("PacketAddMulticast: %d old addresses\n",count));
p = (LPBYTE)OidData->Data;
for( i=0; i<count; i++ ) {
if(memcmp(p,address,ETH_802_3_ADDRESS_LENGTH) == 0) {
// This multicast is already defined -- error or not?
Status = TRUE;
D(bug("PacketAddMulticast: address already defined\n"));
break;
}
p += ETH_802_3_ADDRESS_LENGTH;
}
if(i == count) {
if(i >= MAX_MULTICAST) {
D(bug("PacketAddMulticast: too many addresses\n"));
Status = FALSE;
} else {
D(bug("PacketAddMulticast: adding a new address\n"));
// ULONG IoCtlBufferLength = (sizeof(PACKET_OID_DATA)+ETH_802_3_ADDRESS_LENGTH*1-1);
ULONG IoCtlBufferLength = (sizeof(PACKET_OID_DATA)+ETH_802_3_ADDRESS_LENGTH*(count+1)-1);
LPPACKET lpPacket2 = PacketAllocatePacket( AdapterObject, IoCtlBufferLength );
#define OidData2 ((PPACKET_OID_DATA)(lpPacket2->Buffer))
if ( lpPacket2 ) {
OidData2->Oid = OID_802_3_MULTICAST_LIST;
// OidData2->Length = ETH_802_3_ADDRESS_LENGTH*1;
// memcpy( OidData2->Data, address, ETH_802_3_ADDRESS_LENGTH );
memcpy( OidData2->Data, OidData->Data, ETH_802_3_ADDRESS_LENGTH*count );
memcpy( OidData2->Data+ETH_802_3_ADDRESS_LENGTH*count, address, ETH_802_3_ADDRESS_LENGTH );
OidData2->Length = ETH_802_3_ADDRESS_LENGTH*(count+1);
Status = PacketRequest( AdapterObject, lpPacket2, TRUE );
PacketFreePacket( lpPacket2 );
}
#undef OidData2
}
}
PacketFreePacket( lpPacket );
}
#undef OidData
// return Status;
return TRUE;
}
int
libnet_win32_write_raw_ipv4(libnet_t *l, const uint8_t *payload, uint32_t payload_s)
{
static BYTE dst[ETHER_ADDR_LEN];
static BYTE src[ETHER_ADDR_LEN];
uint8_t *packet = NULL;
uint32_t packet_s;
LPPACKET lpPacket = NULL;
DWORD remoteip = 0;
DWORD BytesTransfered;
NetType type;
struct libnet_ipv4_hdr *ip_hdr = NULL;
memset(dst, 0, sizeof(dst));
memset(src, 0, sizeof(src));
packet_s = payload_s + l->link_offset;
packet = (uint8_t *)malloc(packet_s);
if (packet == NULL)
{
snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
"%s(): failed to allocate packet\n", __func__);
return (-1);
}
/* we have to do the IP checksum */
if (libnet_do_checksum(l, payload, IPPROTO_IP, LIBNET_IPV4_H) == -1)
{
/* error msg set in libnet_do_checksum */
return (-1);
}
/* MACs, IPs and other stuff... */
ip_hdr = (struct libnet_ipv4_hdr *)payload;
memcpy(src, libnet_get_hwaddr(l), sizeof(src));
remoteip = ip_hdr->ip_dst.S_un.S_addr;
/* check if the remote station is the local station */
if (remoteip == libnet_get_ipaddr4(l))
{
memcpy(dst, src, sizeof(dst));
}
else
{
memcpy(dst, libnet_win32_get_remote_mac(l, remoteip), sizeof(dst));
}
PacketGetNetType(l->lpAdapter, &type);
switch(type.LinkType)
{
case NdisMedium802_3:
libnet_win32_build_fake_ethernet(dst, src, ETHERTYPE_IP, payload,
payload_s, packet, l , 0);
break;
case NdisMedium802_5:
libnet_win32_build_fake_token(dst, src, ETHERTYPE_IP, payload,
payload_s, packet, l, 0);
break;
case NdisMediumFddi:
break;
case NdisMediumWan:
case NdisMediumAtm:
case NdisMediumArcnet878_2:
default:
snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
"%s(): network type (%d) is not supported\n", __func__,
type.LinkType);
return (-1);
break;
}
BytesTransfered = -1;
if ((lpPacket = PacketAllocatePacket()) == NULL)
{
snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
"%s(): failed to allocate the LPPACKET structure\n", __func__);
return (-1);
}
PacketInitPacket(lpPacket, packet, packet_s);
/* PacketSendPacket returns a BOOLEAN */
if (PacketSendPacket(l->lpAdapter, lpPacket, TRUE))
{
BytesTransfered = packet_s;
}
PacketFreePacket(lpPacket);
free(packet);
return (BytesTransfered);
}
static void free_read_packets(void)
{
for( int i=0; i<PACKET_POOL_COUNT; i++ ) {
PacketFreePacket(packets[i]);
}
}
LPADAPTER PacketOpenAdapter (LPTSTR AdapterName)
{
LPPACKET lpSupport;
LPADAPTER nAdapter;
DWORD error;
BOOL res;
OPENVXDHANDLE OpenVxDHandle;
DWORD KernEvent;
UINT BytesReturned;
struct _timeb time;
ODSEx ("Packet32: PacketOpenAdapter, opening %s\n", AdapterName);
nAdapter = (LPADAPTER) GlobalAllocPtr (GMEM_MOVEABLE | GMEM_ZEROINIT,sizeof (ADAPTER));
if (nAdapter == NULL)
{
error=GetLastError();
ODS ("Packet32: PacketOpenAdapter GlobalAlloc Failed\n");
ODSEx("Error=%d\n",error);
//set the error to the one on which we failed
SetLastError(error);
return NULL;
}
wsprintf (nAdapter->SymbolicLink,
TEXT ("\\\\.\\%s"),
TEXT ("NPF.VXD"));
nAdapter->hFile = CreateFile (nAdapter->SymbolicLink,
GENERIC_WRITE | GENERIC_READ,
0,
NULL,
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED | FILE_FLAG_DELETE_ON_CLOSE,
0);
if (nAdapter->hFile == INVALID_HANDLE_VALUE)
{
error=GetLastError();
ODS ("Packet32: PacketOpenAdapter Could not open adapter, 1\n");
ODSEx("Error=%d\n",error);
GlobalFreePtr (nAdapter);
//set the error to the one on which we failed
SetLastError(error);
return NULL;
}
lpSupport=PacketAllocatePacket();
PacketInitPacket(lpSupport,AdapterName,strlen(AdapterName));
if (nAdapter && (nAdapter->hFile != INVALID_HANDLE_VALUE))
{
res=PacketDeviceIoControl(nAdapter,
lpSupport,
(ULONG) IOCTL_OPEN,
TRUE);
if (res==FALSE || ((char*)lpSupport->Buffer)[0]=='\0'){
SetLastError(ERROR_FILE_NOT_FOUND);
goto err;
}
PacketFreePacket(lpSupport);
// Set the time zone
_ftime(&time);
if(DeviceIoControl(nAdapter->hFile,pBIOCSTIMEZONE,&time.timezone,2,NULL,0,&BytesReturned,NULL)==FALSE){
error=GetLastError();
ODS ("Packet32: PacketOpenAdapter Could not open adapter, 2\n");
ODSEx("Error=%d\n",error);
GlobalFreePtr (nAdapter);
//set the error to the one on which we failed
SetLastError(error);
return NULL;
}
// create the read event
nAdapter->ReadEvent=CreateEvent(NULL, TRUE, FALSE, NULL);
// obtain the pointer of OpenVxDHandle in KERNEL32.DLL.
// It is not possible to reference statically this function, because it is present only in Win9x
OpenVxDHandle = (OPENVXDHANDLE) GetProcAddress(GetModuleHandle("KERNEL32"),"OpenVxDHandle");
// map the event to kernel mode
KernEvent=(DWORD)(OpenVxDHandle)(nAdapter->ReadEvent);
// pass the event to the driver
if(DeviceIoControl(nAdapter->hFile,pBIOCEVNAME,&KernEvent,4,NULL,0,&BytesReturned,NULL)==FALSE){
error=GetLastError();
ODS("Packet32: PacketOpenAdapter Could not open adapter, 3\n");
ODSEx("Error=%d\n",error);
GlobalFreePtr (nAdapter);
//set the error to the one on which we failed
SetLastError(error);
return NULL;
}
//set the maximum lookhahead size allowable with this NIC driver
PacketSetMaxLookaheadsize(nAdapter);
//set the number of times a single write will be repeated
PacketSetNumWrites(nAdapter,1);
return nAdapter;
}
err:
error=GetLastError();
ODS ("Packet32: PacketOpenAdapter Could not open adapter, 4\n");
ODSEx("Error=%d\n",error);
//set the error to the one on which we failed
SetLastError(error);
return NULL;
}
