packet32seh.pas

linux program to read packet data

unit Packet32seh;
{
     PACKET32.PAS

     Original source is PACKET32.H
     Written by Sang-Eun Han
     ([e-mail],  http://widecomm.korea.ac.kr/~seh).
     Convert to Delphi 4.0 by: Jagad ([e-mail])
     Some updates by [e-mail] (see below)
     Use static link to Packet32.DLL

     Note:
      - BOOLEAN convert to Boolean, don't convert to BOOL because
        BOOL is LongBool.
      - ULONG convert to BOOL if it's return TRUE or FALSE
     Updates:
      May 10, 1999  Jagad   Add Directive to support D3
      May 10, 1999          Change UINT to Longint for D3
      May 10, 1999  FPiette confirm update: OVERLAPPED changes
                            TOverlapped for D3
      May 17, 1999  FPiette Added automatic Delphi3/Delphi4 detection
                    FPiette introduced USLONG type to unify between D3 and D4
                    with simplified directives
}

(*
 * $Id: Packet32seh.pas,v 1.4 2002/11/02 14:05:37 owns Exp $
 * defines some of the functions of Packet32
 * The original file is from FPiette but I have added the function : isSehSnifferAvailable
 * and I use LoadLibrary
 * This file is used only on windows.
 *)


{$ALIGN ON}

interface
uses windows,u_SysInfo;

const

//copied from Ndis.h
//the following constants are to be used to direct
//the underlying NIC driver to choose which type of
//packet can be delivered to the upper bound driver,
//that is, our snoop driver.
NDIS_PACKET_TYPE_DIRECTED =           $0001;
NDIS_PACKET_TYPE_MULTICAST =          $0002;
NDIS_PACKET_TYPE_ALL_MULTICAST =      $0004;
NDIS_PACKET_TYPE_BROADCAST =          $0008;
NDIS_PACKET_TYPE_SOURCE_ROUTING =     $0010;
NDIS_PACKET_TYPE_PROMISCUOUS =        $0020; //for snoop
NDIS_PACKET_TYPE_SMT =                $0040;
NDIS_PACKET_TYPE_MAC_FRAME =          $8000;
NDIS_PACKET_TYPE_FUNCTIONAL =         $4000;
NDIS_PACKET_TYPE_ALL_FUNCTIONAL =     $2000;
NDIS_PACKET_TYPE_GROUP =              $1000;
//

MAX_LINK_NAME_LENGTH =   5;

type
{ Jagad like to have DELPHI3/DELPHI4 defined for lisibility }
{ VER100 is automatically defined by Delphi3 compiler       }
{ VER120 is automatically defined by Delphi4 compiler       }
{$IFDEF VER100}
    {$DEFINE DELPHI3}
{$ELSE}
    {$DEFINE DELPHI4}
{$ENDIF}

{$IFDEF DELPHI3}
    USLONG = LongInt;
{$ELSE}
    USLONG = LongWord;
{$ENDIF}

//typedef struct tagADAPTER {
//	HANDLE     hFile;
//	TCHAR      szAdapterName[MAX_LINK_NAME_LENGTH];
//	TCHAR      SymbolicLink[MAX_PATH];
//} ADAPTER, *LPADAPTER;
ADAPTER = packed record
  hFile:                THandle;
  szAdapterName:        array [0..MAX_LINK_NAME_LENGTH-1] of Char;
  SymbolicLink:         array [0..MAX_PATH-1] of Char;
end;
LPADAPTER = ^ADAPTER;

//typedef struct tagPACKET {
//	HANDLE       hEvent;
//	OVERLAPPED   OverLapped;
//	PVOID        Buffer;
//	UINT         Length;
//} PACKET, *LPPACKET;
PACKET = packed record
  hEvent:      THandle;
  xOverlapped: TOVERLAPPED;    // FPiette May 10, 1999
  Buffer:      PChar;
  Length:      USLONG;         // FPiette May 17, 1999
end;
LPPACKET = ^PACKET;

//typedef struct tagADAPTER_DESC {
//	TCHAR	szAdapterName[MAX_LINK_NAME_LENGTH];
//	TCHAR	szAdapterDesc[MAX_PATH];
//} ADAPTER_DESC, *LPADAPTER_DESC;
ADAPTER_DESC = packed record
  szAdapterName:     array[0..MAX_LINK_NAME_LENGTH-1] of Char;
  szAdapterDesc:     array[0..MAX_PATH-1] of Char;
end;
LPADAPTER_DESC = ^ADAPTER_DESC;

function isSehSnifferAvailable : boolean;

var
  PacketOpenAdapter : function ( AdapterName: LPSTR ): DWORD; stdcall;
  PacketSendPacket : function ( AdapterObject: LPADAPTER;plpPacket:     LPPACKET;Sync:Boolean ): Boolean; stdcall;
  PacketAllocatePacket : function ( AdapterObject: LPADAPTER ): DWORD; stdcall;
  PacketInitPacket : procedure (plpPacket: LPPACKET;Buffer:    PChar;Length:    USLONG); stdcall;  // FPiette May 17, 1999
  PacketFreePacket : procedure ( plpPacket: LPPACKET ); stdcall;
  PacketResetAdapter : function ( AdapterObject: LPADAPTER ): Boolean; stdcall;
  PacketGetAddress : function ( AdapterObject: LPADAPTER;AddressByffer: PUCHAR;cbBytes:DWORD;lpcbBytes:LPDWORD): Boolean; stdcall;
  PacketWaitPacket : function ( AdapterObject: LPADAPTER;plpPacket:LPPACKET;BytesReceived: PULONG): Boolean; stdcall;
  PacketReceivePacket : function ( AdapterObject: LPADAPTER;plpPacket:LPPACKET;Sync: Boolean;BytesReceived: PULONG): Boolean; stdcall;
  PacketCloseAdapter : procedure ( AdapterObject: LPADAPTER ); stdcall;
  PacketSetFilter : function ( AdapterObject: LPADAPTER;Filter: ULONG): Boolean; stdcall;
  PacketGetAdapterNames : function (pAdapterDescs: PChar;nAdapterDescs: USLONG;pnAdapterDescsMax:  PUINT ): BOOL; stdcall;
  PacketAdapterDesc : function ( AdapterObject:  LPADAPTER;lpszVendorSays: LPSTR;cbBytes:DWORD;lpcbBytes:      LPDWORD ): Boolean; stdcall;
//  PacketSetLookAhead : function(AdapterObject:  LPADAPTER;LookAhead : ULONG) : Boolean; stdcall;

implementation

var
  FHandle: THandle;


// tells if we can use seh Sniffer (dll present ?, 95/98/Me ?)  
function isSehSnifferAvailable : boolean;
begin
  result := ((getPlatformId = VER_PLATFORM_WIN32_WINDOWS) and (FHandle <> 0));
end;


initialization
begin
  FHandle := LoadLibrary('Packet32.dll');
  if FHandle <> 0 then
  begin
    @PacketOpenAdapter := GetProcAddress(FHandle, 'PacketOpenAdapter');
    @PacketSendPacket := GetProcAddress(FHandle, 'PacketSendPacket');
    @PacketAllocatePacket := GetProcAddress(FHandle, 'PacketAllocatePacket');
    @PacketInitPacket := GetProcAddress(FHandle, 'PacketInitPacket');
    @PacketFreePacket := GetProcAddress(FHandle, 'PacketFreePacket');
    @PacketResetAdapter := GetProcAddress(FHandle, 'PacketResetAdapter');
    @PacketGetAddress := GetProcAddress(FHandle, 'PacketGetAddress');
    @PacketWaitPacket := GetProcAddress(FHandle, 'PacketWaitPacket');
    @PacketReceivePacket := GetProcAddress(FHandle, 'PacketReceivePacket');
    @PacketCloseAdapter := GetProcAddress(FHandle, 'PacketCloseAdapter');
    @PacketSetFilter := GetProcAddress(FHandle, 'PacketSetFilter');
    @PacketGetAdapterNames := GetProcAddress(FHandle, 'PacketGetAdapterNames');
    @PacketAdapterDesc := GetProcAddress(FHandle, 'PacketAdapterDesc');
//    @PacketSetLookAhead := GetProcAddress(FHandle, 'PacketSetLookAhead');
  end;
end;

finalization
begin
  if FHandle <> 0 Then FreeLibrary(FHandle);
end;


end.