u_libpcap.pas

linux program to read packet data

(*
 * One Way Network Sniffer (OWNS)
 * Copyright (C) 2001-2002 OWNS
 *
 * http://owns.sourceforge.net/
 * http://www.owns.st
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *)

(*
 * $Id: u_LibpCap.pas,v 1.4 2002/11/23 21:49:50 owns Exp $
 * defines some of the functions of libpcap
 *
 *)

unit u_LibpCap;

interface

uses classes
{$IFDEF MSWINDOWS}
     ,Windows
{$ENDIF}
{$IFDEF LINUX}
     ,libc
{$ENDIF}
     ;

// When you compile libpcap from sources (at least for 0.7.1), you get a ".a"
// file (and ".o" object files)
// With Kylix, we can link with these o files using {$LINK bpf_dump.o} ...
// But I had an error "Bad global symbol definition 'no_optimize' in object file gencode.o" for an
// unknown reason
//
// So I created a so file by :
// - adding -fPIC to CCOPT option in Makefile.in
// - gcc -shared -Wl,-soname,libpcap.so.0 -olibpcap.so.0.7.1 *.o -lc
// see : http://www.tldp.org/HOWTO/Program-Library-HOWTO/shared-libraries.html
// Note that I used version 0.7.1 from sourceforge : it does not have the trojan included ;-)


type
  Tpcap_timeval = record
    tv_Sec,            // Secs since 1/1/1970
    tv_uSec: Integer;     // microseconds
  end;

  // Item in a list of interfaces, used by pcap_findalldevs().
  PPpcap_if = ^Ppcap_if;
  Ppcap_if = ^Tpcap_if;
  Tpcap_if = record
    next        : Ppcap_if; // if not NULL, a pointer to the next element in the list; NULL for the last element of the list
    name        : PChar;    // a pointer to a string giving a name for the device to pass to pcap_open_live().
    description : PChar;    // if not NULL, a pointer to a string giving a human-readable description of the device
    addresses   : Pointer;  // a pointer to the first element of a list of addresses for the interface.
    flags       : Longword; // PCAP_IF_ interface flags. Currently the only possible flag is PCAP_IF_LOOPBACK, that is set if the interface is a loopback interface
  end;

  Ppcap_pkthdr = ^Tpcap_pkthdr;
  Tpcap_pkthdr = record
    ts     : Tpcap_timeval;	// time stamp
    caplen : Longword;          // length of portion present
    len    : Longword;	        // length this packet (off wire)
  end;

  pcap_t = Pointer;
  pcap_dumper_t = Pointer;

  Tbpf_program = record
    bf_len : Cardinal;
    bpf_insn : Pointer;
  end;

  Pbpf_program = ^Tbpf_program;
  PCardinal = ^Cardinal;

  pcap_handler = procedure(parameter : pointer; const header : Ppcap_pkthdr; const pkt_data : Pchar); cdecl;

function getAdaptersNames(p_Adapters : PChar) : TStrings;
function isLibpCapInstalled : Boolean;
function getLibpcapLastError : String;

const
 PCAP_ERRBUF_SIZE     = 256;
 WTAP_MAX_PACKET_SIZE = 65535;

var
  errbuf : array[0..PCAP_ERRBUF_SIZE-1] of char;

var
  pcap_open_live     : function(device:pchar;snaplen : integer;promisc : integer; to_ms : integer; ebuf :pchar) : pcap_t; cdecl;
  pcap_open_offline  : function (fname : PChar; ebuf : PChar) : pointer; cdecl;
  pcap_dump_open     : function (p : pcap_t; fname : PChar) : pcap_dumper_t; cdecl;
  pcap_lookupdev     : function(errbuf : Pchar) : PChar; cdecl;
  pcap_dispatch      : Function(p : pcap_t;cnt : integer; callback : pcap_handler; user : Pointer) : Integer; cdecl;
  pcap_loop          : Function(p : pcap_t;cnt : integer; callback : pcap_handler; user : Pointer) : Integer; cdecl;
  pcap_dump          : procedure(user : PChar; h : Ppcap_pkthdr; sp : PChar); cdecl;
  pcap_next          : function (p : pcap_t; h : Ppcap_pkthdr) : PChar; cdecl;
  pcap_snapshot      : function (p : pcap_t) : integer; cdecl;
  pcap_is_swapped    : function (p : pcap_t) : Integer; cdecl;
  pcap_major_version : function(p : pcap_t) : Integer; cdecl;
  pcap_minor_version : function (p : pcap_t) : Integer; cdecl;
  pcap_fileno        : function(p : pcap_t) : Integer; cdecl;
  pcap_geterr        : function(p : pcap_t) : PChar;cdecl;
  pcap_close         : procedure (p : pcap_t); cdecl;
  pcap_dump_close    : procedure (p : pcap_dumper_t); cdecl;
  pcap_compile       : function(p : pcap_t; fp : Pbpf_program;buf : PChar; optimize : integer;mask : Cardinal) : integer; cdecl;
  pcap_setfilter     : function(p : pcap_t; fp : Pbpf_program) : Integer; cdecl;
  pcap_lookupnet     : function(device : PChar;netp : PCardinal; maskp : PCardinal;errBuf : PChar) : Integer;cdecl;
  pcap_findalldevs   : function(Palldevsp : PPpcap_if; ebuf : PChar) : Integer; cdecl;
  pcap_freealldevs   : procedure(alldevsp : Ppcap_if); cdecl;

implementation

var
{$IFDEF MSWINDOWS}
  FHandle: THandle;
{$ENDIF}
{$IFDEF LINUX}
  FHandle : Pointer;
{$ENDIF}

// get last error string
// errbuf must be used as parameter to pcap functions
function getLibpcapLastError : String;
var
  i : Integer;
  errStr : String;
begin
  i := 0;
  while (errbuf[i] <> #0) do
  begin
     errStr := errStr+errbuf[i];
    inc(i);
  end;
  result := errStr;
end;


function isLibpCapInstalled : Boolean;
begin
{$IFDEF MSWINDOWS}
  result := FHandle <> 0;
{$ENDIF}
{$IFDEF LINUX}
  result := FHandle <> nil;
{$ENDIF}
end;

{$IFDEF MSWINDOWS}
function getAdaptersNames(p_Adapters : PChar) : TStrings;
var
  l_info : OSVERSIONINFO;
  l_NameList : Array [0..(1024*2)-1] of char;
  l_BufferLength : Longword;
  l_Adapters : String;
  i          : Integer;
begin
  result := TStringList.create;
  l_BufferLength := 1024;

  // on d閠ermine quelle est la version de windows utilis閑
  l_info.dwOSVersionInfoSize := Sizeof(OSVERSIONINFO);
  GetVersionEx(l_Info);

  if (l_info.dwPlatformId = VER_PLATFORM_WIN32_WINDOWS) then
  begin
    i :=0;
    // 95 ou 98 (8bits per character)
     while ((p_Adapters[i]<> #0) or (p_Adapters[i+1] <> #0)) do
     begin
       if (p_Adapters[i]= #0) and (p_Adapters[i+1] <> #0) then p_Adapters[i]:=',';
       inc(i);
     end;
     l_Adapters := p_Adapters;
  end
  else
  if (l_info.dwPlatformId = VER_PLATFORM_WIN32_NT) then
  begin
    // NT ou 2000 (16bits per character)
    i :=0;
    while ((Pwidechar(p_Adapters)[i] <> #0) or (PwideChar(p_Adapters)[i+1]<>#0)) do
    begin
       if (Pwidechar(p_Adapters)[i]=#0)and (PwideChar(p_Adapters)[i+1]<>#0) then
         PwideChar(p_Adapters)[i]:= WideChar(',');
       inc(i);
    end;

     l_Adapters := WideCharToString(PWideChar(p_Adapters)) ;
  end;
  result.commatext := l_Adapters;
end;
{$ENDIF}

{$IFDEF LINUX}

function getAdaptersNames(p_Adapters : PChar) : TStrings;
var
  i          : Integer;
  l_Adapters : String;
begin
  i :=0;
  result := TStringList.create;
  while ((p_Adapters[i]<> #0) or (p_Adapters[i+1] <> #0)) do
  begin
    if (p_Adapters[i]= #0) and (p_Adapters[i+1] <> #0) then p_Adapters[i]:=',';
    inc(i);
  end;
  l_Adapters := p_Adapters;
  result.commatext := l_Adapters;
end;
{$ENDIF}

initialization
begin
  errbuf[0] := #0;
{$IFDEF MSWINDOWS}
  FHandle := LoadLibrary('Wpcap.dll');
  if FHandle <> 0 then
  begin
    @pcap_open_live := GetProcAddress(FHandle, 'pcap_open_live');
    @pcap_open_offline := GetProcAddress(FHandle, 'pcap_open_offline');
    @pcap_dump_open := GetProcAddress(FHandle, 'pcap_dump_open');
    @pcap_lookupdev := GetProcAddress(FHandle, 'pcap_lookupdev');
    @pcap_dispatch := GetProcAddress(FHandle, 'pcap_dispatch');
    @pcap_loop := GetProcAddress(FHandle, 'pcap_loop');
    @pcap_dump := GetProcAddress(FHandle, 'pcap_dump');
    @pcap_next := GetProcAddress(FHandle, 'pcap_next');
    @pcap_snapshot := GetProcAddress(FHandle, 'pcap_snapshot');
    @pcap_is_swapped := GetProcAddress(FHandle, 'pcap_is_swapped');
    @pcap_major_version := GetProcAddress(FHandle, 'pcap_major_version');
    @pcap_minor_version := GetProcAddress(FHandle, 'pcap_minor_version');
    @pcap_fileno := GetProcAddress(FHandle, 'pcap_fileno');
    @pcap_geterr := GetProcAddress(FHandle, 'pcap_geterr');
    @pcap_close := GetProcAddress(FHandle, 'pcap_close');
    @pcap_dump_close := GetProcAddress(FHandle, 'pcap_dump_close');
    @pcap_compile := GetProcAddress(FHandle, 'pcap_compile');
    @pcap_lookupnet := GetProcAddress(FHandle, 'pcap_lookupnet');
    @pcap_setfilter := GetProcAddress(FHandle, 'pcap_setfilter');
    @pcap_findalldevs := GetProcAddress(FHandle, 'pcap_findalldevs');
    @pcap_freealldevs := GetProcAddress(FHandle, 'pcap_freealldevs');
  end;
{$ENDIF}
{$IFDEF LINUX}
  FHandle := dlopen('libpcap.so.0.7.1',RTLD_NOW);
  if FHandle <> nil then
  begin
    @pcap_open_live := dlsym(FHandle, 'pcap_open_live');
    @pcap_open_offline := dlsym(FHandle, 'pcap_open_offline');
    @pcap_dump_open := dlsym(FHandle, 'pcap_dump_open');
    @pcap_lookupdev := dlsym(FHandle, 'pcap_lookupdev');
    @pcap_dispatch := dlsym(FHandle, 'pcap_dispatch');
    @pcap_loop := dlsym(FHandle, 'pcap_loop');
    @pcap_dump := dlsym(FHandle, 'pcap_dump');
    @pcap_next := dlsym(FHandle, 'pcap_next');
    @pcap_snapshot := dlsym(FHandle, 'pcap_snapshot');
    @pcap_is_swapped := dlsym(FHandle, 'pcap_is_swapped');
    @pcap_major_version := dlsym(FHandle, 'pcap_major_version');
    @pcap_minor_version := dlsym(FHandle, 'pcap_minor_version');
    @pcap_fileno := dlsym(FHandle, 'pcap_fileno');
    @pcap_geterr := dlsym(FHandle, 'pcap_geterr');
    @pcap_close := dlsym(FHandle, 'pcap_close');
    @pcap_dump_close := dlsym(FHandle, 'pcap_dump_close');
    @pcap_compile := dlsym(FHandle, 'pcap_compile');
    @pcap_lookupnet := dlsym(FHandle, 'pcap_lookupnet');
    @pcap_setfilter := dlsym(FHandle, 'pcap_setfilter');
    @pcap_findalldevs := dlsym(FHandle, 'pcap_findalldevs');
    @pcap_freealldevs := dlsym(FHandle, 'pcap_freealldevs');
  end;
{$ENDIF}
end;

finalization
begin
{$IFDEF MSWINDOWS}
  if FHandle <> 0 Then FreeLibrary(FHandle);
{$ENDIF}
{$IFDEF LINUX}
  if FHandle <> nil then dlclose(Fhandle);
{$ENDIF}
end;

end.