 |
File: HNFileAdapter.pas {****************************************************************************
** **
** PSSDK HNFileAdapter module **
** Copyright (c) 1997 - 2007 microOLAP Technologies LTD, **
** Khalturin A.P., Naumov D.A. **
** **
****************************************************************************}
unit HNFileAdapter;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
HNPSManager, HNPsSdkDef;
type
TOnPacketReceive = procedure (Sender : TObject; ThParam: Pointer; hPacket: Pointer; pPacketData: Pointer; IncPacketSize: DWORD) of object;
TOnFileClose = procedure (Sender : TObject; ThParam: Pointer; Status: DWORD) of object;
TOnThreadBegin = procedure (Sender : TObject; Var ThParam: Pointer) of object;
TOnThreadEnd = procedure (Sender : TObject; ThParam: Pointer) of object;
//---------------------------------------------------------------------------
// Class THNFileAdapter
//---------------------------------------------------------------------------
THNFileAdapter = class
private
hFAdp : Pointer;
FOnPacketReceive: TOnPacketReceive;
FOnFileClose: TOnFileClose;
FOnThreadBegin: TOnThreadBegin;
FOnThreadEnd: TOnThreadEnd;
procedure SetUserFilter(Value: Pointer);
function GetUserFilter: Pointer;
procedure SetUserFilterActive(Value: BOOL);
function GetUserFilterActive: BOOL;
procedure SetUseFastUserFilter(Value: BOOL);
function GetUseFastUserFilter: BOOL;
procedure DoOnPacketReceive(ThParam: Pointer; hPacket: Pointer; pPacketData: Pointer; IncPacketSize: DWORD);
procedure DoOnFileClose(ThParam: Pointer; Status: DWORD);
procedure DoOnThreadBegin(Var ThParam: Pointer);
procedure DoOnThreadEnd(ThParam: Pointer);
procedure SetQueue(Value: Pointer);
function GetQueue: Pointer;
function GetMaxPacketSize: DWORD;
procedure SetMaxPacketSize(Value : DWORD);
function GetAutoMode: BOOL;
procedure SetAutoMode(Value : BOOL);
function GetSizeLimit: DWORD;
procedure SetSizeLimit(Value : DWORD);
function GetMediumType: DWORD;
procedure SetMediumType(Value : DWORD);
function GetCapFormat: DWORD;
procedure SetCapFormat(Value : DWORD);
protected
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
property UserFilter: Pointer read GetUserFilter write SetUserFilter;
property Queue: Pointer read GetQueue write SetQueue;
function IsValid: BOOL;
function OpenFile(lpFileName : String): DWORD;
function CreateFile(lpFileName : String): DWORD;
function CloseFile: DWORD;
function IsOpened: BOOL;
function Get_RecvCount(HiValue: PUINT): UINT;
function Get_AcceptCount(HiValue: PUINT): UINT;
function Get_RejectCount(HiValue: PUINT): UINT;
function Get_ProcessCount(HiValue: PUINT): UINT;
function Get_OpenTime(HiValue: PUINT): UINT;
function Get_FileSize(HiValue: PUINT): UINT;
function Get_GetNextPacket(hPacket: Pointer): DWORD;
function RewindFile(): DWORD;
function SyncSend(pPacket: Pointer; PacketSize: DWORD): DWORD;
function SyncSendEx(hPacket: Pointer): DWORD;
published
property AutoMode: BOOL read GetAutoMode write SetAutoMode;
property CapFormat: DWORD read GetCapFormat write SetCapFormat;
property MaxPacketSize: DWORD read GetMaxPacketSize write SetMaxPacketSize;
property MediumType: DWORD read GetMediumType write SetMediumType;
property SizeLimit: DWORD read GetSizeLimit write SetSizeLimit;
property UserFilterActive: BOOL read GetUserFilterActive write SetUserFilterActive;
property UseFastUserFilter: BOOL read GetUseFastUserFilter write SetUseFastUserFilter;
property OnPacketReceive: TOnPacketReceive read FOnPacketReceive write FOnPacketReceive;
property OnFileClose: TOnFileClose read FOnFileClose write FOnFileClose;
property OnThreadBegin: TOnThreadBegin read FOnThreadBegin write FOnThreadBegin;
property OnThreadEnd: TOnThreadEnd read FOnThreadEnd write FOnThreadEnd;
end;
implementation
{$INCLUDE 'HNPsSdkFun.pas'}
//---------------------------------------------------------------------------
// IntOnPacketReceive - OnPacketReceive event handler.
//---------------------------------------------------------------------------
procedure IntOnPacketReceive(Param: Pointer; ThParam: Pointer; hPacket: Pointer; pPacketData: Pointer; IncPacketSize: DWORD); stdcall;
var
pFAdp : THNFileAdapter;
begin
pFAdp := THNFileAdapter(Param);
pFAdp.DoOnPacketReceive(ThParam,hPacket,pPacketData,IncPacketSize);
end;
//---------------------------------------------------------------------------
// IntOnFileClose - OnFileClose event handler.
//---------------------------------------------------------------------------
procedure IntOnFileClose(Param: Pointer; ThParam: Pointer; Status: DWORD); stdcall;
var
pFAdp : THNFileAdapter;
begin
pFAdp := THNFileAdapter(Param);
pFAdp.DoOnFileClose(ThParam, Status);
end;
//---------------------------------------------------------------------------
// IntOnThreadBegin - OnThreadBegin event handler.
//---------------------------------------------------------------------------
procedure IntOnThreadBegin(Param: Pointer; Var ThParam: Pointer); stdcall;
var
pFAdp : THNFileAdapter;
begin
pFAdp := THNFileAdapter(Param);
pFAdp.DoOnThreadBegin(ThParam);
end;
//---------------------------------------------------------------------------
// IntOnThreadEnd - OnThreadEnd event handler.
//---------------------------------------------------------------------------
procedure IntOnThreadEnd(Param: Pointer; ThParam: Pointer); stdcall;
var
pFAdp : THNFileAdapter;
begin
pFAdp := THNFileAdapter(Param);
pFAdp.DoOnThreadEnd(ThParam);
end;
//---------------------------------------------------------------------------
// Create - constructor
//---------------------------------------------------------------------------
constructor THNFileAdapter.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
if(phn = nil) then Exit;
hFAdp := FAdpCreate();
FAdpSetOnPacketRecv (hFAdp,@IntOnPacketReceive,Self);
FAdpSetOnFileClose (hFAdp,@IntOnFileClose,Self);
FAdpSetOnThreadBegin (hFAdp,@IntOnThreadBegin,Self);
FAdpSetOnThreadEnd (hFAdp,@IntOnThreadEnd,Self);
end;
//---------------------------------------------------------------------------
// Destroy - destructor
//---------------------------------------------------------------------------
destructor THNFileAdapter.Destroy;
begin
if(phn = nil) then begin inherited Destroy; Exit; end;
FAdpSetOnPacketRecv (hFAdp,nil,nil);
FAdpSetOnFileClose (hFAdp,nil,nil);
FAdpSetOnThreadBegin (hFAdp,nil,nil);
FAdpSetOnThreadEnd (hFAdp,nil,nil);
FAdpDestroy(hFAdp);
inherited Destroy;
end;
//---------------------------------------------------------------------------
// Method - IsValid - Checks if the HNFileAdapter object is created correctly.
//---------------------------------------------------------------------------
function THNFileAdapter.IsValid: BOOL;
begin
Result := (hFAdp <> nil);
end;
//---------------------------------------------------------------------------
// Method - OpenFile - Opens the CAP file.
//---------------------------------------------------------------------------
function THNFileAdapter.OpenFile(lpFileName : String): DWORD;
begin
Result := FAdpOpenFileA(hFAdp,PChar(lpFileName));
end;
//---------------------------------------------------------------------------
// Method - CreateFile - Creates a CAP file.
//---------------------------------------------------------------------------
function THNFileAdapter.CreateFile(lpFileName : String): DWORD;
begin
Result := FAdpCreateFileA(hFAdp,PChar(lpFileName));
end;
//---------------------------------------------------------------------------
// Method - CloseFile - Close the CAP file.
//---------------------------------------------------------------------------
function THNFileAdapter.CloseFile: DWORD;
begin
Result := FAdpCloseFile(hFAdp);
end;
//---------------------------------------------------------------------------
// Method - Get_OpenTime - Return the timestamp of the first packet stored in a CAP file.
//---------------------------------------------------------------------------
function THNFileAdapter.Get_OpenTime(HiValue: PUINT): UINT;
begin
Result := FAdpGetOpenTime(hFAdp,PDWORD(HiValue));
end;
//---------------------------------------------------------------------------
// Method - IsOpened - Shows HNFileAdapter working status.
//---------------------------------------------------------------------------
function THNFileAdapter.IsOpened: BOOL;
begin
Result := FAdpIsOpened(hFAdp);
end;
//---------------------------------------------------------------------------
// Property - MaxPacketSize - Return maximal size of packet to be dumped to a CAP file (needed for some formats).
//---------------------------------------------------------------------------
function THNFileAdapter.GetMaxPacketSize(): DWORD;
begin
Result := FAdpGetMaxPacketSize(hFAdp);
end;
//---------------------------------------------------------------------------
// Property - MaxPacketSize - Set maximal size of packet to be dumped to a CAP file (needed for some formats).
//---------------------------------------------------------------------------
procedure THNFileAdapter.SetMaxPacketSize(Value : DWORD);
begin
FAdpSetMaxPacketSize(hFAdp,Value);
end;
//---------------------------------------------------------------------------
// Property - AutoMode - Return HNFileAdapter object automatic mode flag status.
//---------------------------------------------------------------------------
function THNFileAdapter.GetAutoMode(): BOOL;
begin
Result := FAdpGetAutoMode(hFAdp);
end;
//---------------------------------------------------------------------------
// Property - AutoMode - Set HNFileAdapter object automatic mode flag status.
//---------------------------------------------------------------------------
procedure THNFileAdapter.SetAutoMode(Value : BOOL);
begin
FAdpSetAutoMode(hFAdp,Value);
end;
//---------------------------------------------------------------------------
// Property - SizeLimit - Return CAP size limit for data recording operations.
//---------------------------------------------------------------------------
function THNFileAdapter.GetSizeLimit(): DWORD;
begin
Result := FAdpGetSizeLimit(hFAdp);
end;
//---------------------------------------------------------------------------
// Property - SizeLimit - Set CAP size limit for data recording operations.
//---------------------------------------------------------------------------
procedure THNFileAdapter.SetSizeLimit(Value : DWORD);
begin
FAdpSetSizeLimit(hFAdp,Value);
end;
//---------------------------------------------------------------------------
// Property - MediumType - Return network adapter type, in format of which the packets are dumped to a CAP file.
//---------------------------------------------------------------------------
function THNFileAdapter.GetMediumType(): DWORD;
begin
Result := FAdpGetMediumType(hFAdp);
end;
//---------------------------------------------------------------------------
// Property - MediumType - Set network adapter type, in format of which the packets are dumped to a CAP file.
//---------------------------------------------------------------------------
procedure THNFileAdapter.SetMediumType(Value : DWORD);
begin
FAdpSetMediumType(hFAdp,Value);
end;
//---------------------------------------------------------------------------
// Property - CapFormat - Returns the CAP file type.
//---------------------------------------------------------------------------
function THNFileAdapter.GetCapFormat(): DWORD;
begin
Result := FAdpGetCapFormat(hFAdp);
end;
//---------------------------------------------------------------------------
// Property - CapFormat - Sets the CAP file type.
//---------------------------------------------------------------------------
procedure THNFileAdapter.SetCapFormat(Value : DWORD);
begin
FAdpSetCapFormat(hFAdp,Value);
end;
//---------------------------------------------------------------------------
// Property - Queue - Sets the handle of HNQueue object.
//---------------------------------------------------------------------------
procedure THNFileAdapter.SetQueue(Value: Pointer);
begin
FAdpSetQueue(hFAdp,Value);
end;
//---------------------------------------------------------------------------
// Property - Queue - Returns the handle of HNQueue object.
//---------------------------------------------------------------------------
function THNFileAdapter.GetQueue: Pointer;
begin
Result := FAdpGetQueue(hFAdp);
end;
//---------------------------------------------------------------------------
// Property - UserFilter - Returns the handle of HNUserFilter object.
//---------------------------------------------------------------------------
procedure THNFileAdapter.SetUserFilter(Value: Pointer);
begin
FAdpSetUserFilter(hFAdp,Value);
end;
//---------------------------------------------------------------------------
// Property - UserFilter - Sets the handle of HNUserFilter object.
//---------------------------------------------------------------------------
function THNFileAdapter.GetUserFilter: Pointer;
begin
Result := FAdpGetUserFilter(hFAdp);
end;
//---------------------------------------------------------------------------
// Property - UserFilterActive - Sets the status flag of the user-settable packet filter using.
//---------------------------------------------------------------------------
procedure THNFileAdapter.SetUserFilterActive(Value: BOOL);
begin
FAdpSetUserFilterActive(hFAdp,Value);
end;
//---------------------------------------------------------------------------
// Property - UserFilterActive - Return the status flag of the user-settable packet filter using.
//---------------------------------------------------------------------------
function THNFileAdapter.GetUserFilterActive: BOOL;
begin
Result := FAdpGetUserFilterActive(hFAdp);
end;
//---------------------------------------------------------------------------
// Property - UseFastUserFilter - Sets the status flag of the FastBPF using.
//---------------------------------------------------------------------------
procedure THNFileAdapter.SetUseFastUserFilter(Value: BOOL);
begin
FAdpSetUseFastUserFilter(hFAdp,Value);
end;
//---------------------------------------------------------------------------
// Property - UseFastUserFilter - Returns the status flag of the FastBPF using.
//---------------------------------------------------------------------------
function THNFileAdapter.GetUseFastUserFilter: BOOL;
begin
Result := FAdpGetUseFastUserFilter(hFAdp);
end;
//---------------------------------------------------------------------------
// Method - Get_RecvCount - Return the number of packets read from the CAP file and received by BPF filter.
//---------------------------------------------------------------------------
function THNFileAdapter.Get_RecvCount(HiValue: PUINT): UINT;
begin
Result := FAdpGetRecvCount(hFAdp,PDWORD(HiValue));
end;
//---------------------------------------------------------------------------
// Method - Get_AcceptCount - Returns the number of the packets passed by the user-settable packet filter.
//---------------------------------------------------------------------------
function THNFileAdapter.Get_AcceptCount(HiValue: PUINT): UINT;
begin
Result := FAdpGetAcceptCount(hFAdp,PDWORD(HiValue));
end;
//---------------------------------------------------------------------------
// Method - Get_RejectCount - Return the number of packets rejected by the user-settable packet filter.
//---------------------------------------------------------------------------
function THNFileAdapter.Get_RejectCount(HiValue: PUINT): UINT;
begin
Result := FAdpGetRejectCount(hFAdp,PDWORD(HiValue));
end;
//---------------------------------------------------------------------------
// Method - Get_ProcessCount - Return the number of the packets transferred to the application.
//---------------------------------------------------------------------------
function THNFileAdapter.Get_ProcessCount(HiValue: PUINT): UINT;
begin
Result := FAdpGetProcessCount(hFAdp,PDWORD(HiValue));
end;
//---------------------------------------------------------------------------
// Method - Get_FileSize - Return current size of CAP file.
//---------------------------------------------------------------------------
function THNFileAdapter.Get_FileSize(HiValue: PUINT): UINT;
begin
Result := FAdpGetFileSize(hFAdp,PDWORD(HiValue));
end;
//---------------------------------------------------------------------------
// Method - Get_GetNextPacket - Retrieve next packet from CAP file opened for reading.
//---------------------------------------------------------------------------
function THNFileAdapter.Get_GetNextPacket(hPacket: Pointer): DWORD;
begin
Result := FAdpGetNextPacket(hFAdp,hPacket);
end;
//---------------------------------------------------------------------------
// Method - RewindFile - Repositions the packet pointer to the beginning of a file.
//---------------------------------------------------------------------------
function THNFileAdapter.RewindFile(): DWORD;
begin
Result := FAdpRewindFile(hFAdp);
end;
//---------------------------------------------------------------------------
// Method - SyncSend - Write packet to CAP file asynchronously.
//---------------------------------------------------------------------------
function THNFileAdapter.SyncSend(pPacket: Pointer; PacketSize: DWORD): DWORD;
begin
Result := FAdpSyncSend(hFAdp, pPacket,PacketSize);
end;
//---------------------------------------------------------------------------
// Method - SyncSendEx - Write packet to CAP file synchronously.
//---------------------------------------------------------------------------
function THNFileAdapter.SyncSendEx(hPacket: Pointer): DWORD;
begin
Result := FAdpSyncSendEx(hFAdp, hPacket);
end;
//---------------------------------------------------------------------------
// DoOnPacketReceive - Fire event handler OnPacketReceive
//---------------------------------------------------------------------------
procedure THNFileAdapter.DoOnPacketReceive(ThParam: Pointer; hPacket: Pointer; pPacketData: Pointer; IncPacketSize: DWORD);
begin
if Assigned(FOnPacketReceive) then FOnPacketReceive(Self,ThParam,hPacket,pPacketData,IncPacketSize);
end;
//---------------------------------------------------------------------------
// DoOnFileClose - Fire event handler OnFileClose
//---------------------------------------------------------------------------
procedure THNFileAdapter.DoOnFileClose(ThParam: Pointer; Status: DWORD);
begin
if Assigned(FOnFileClose) then FOnFileClose(Self,ThParam,Status);
end;
//---------------------------------------------------------------------------
// DoOnThreadBegin - Fire event handler OnThreadBegin
//---------------------------------------------------------------------------
procedure THNFileAdapter.DoOnThreadBegin(Var ThParam: Pointer);
begin
if Assigned(FOnThreadBegin) then FOnThreadBegin(Self,ThParam);
end;
//---------------------------------------------------------------------------
// DoOnThreadEnd - Fire event handler OnThreadEnd
//---------------------------------------------------------------------------
procedure THNFileAdapter.DoOnThreadEnd(ThParam: Pointer);
begin
if Assigned(FOnThreadEnd) then FOnThreadEnd(Self,ThParam);
end;
end.
|
