dxinternet.pas

Well known and usefull component for delphi 7

unit DXInternet;

interface

{$I DXSock.def}

Uses
   DXString,
   DXSocket,
   DXSock,
   Classes,
   ExtCtrls;

type
   TDX_OnConnecting=procedure(Sender:TObject;PeerAddress:String;PeerPort:Integer) of object;
   TDX_OnConnect=procedure(Sender:TObject;PeerAddress:String;PeerPort:Integer) of object;
   TDX_OnDisconnect=procedure(Sender:TObject;PeerAddress:String;PeerPort:Integer) of object;
   TDX_OnReadyToRead=procedure(Sender:TObject;KnownAvailable:Integer) of object;
   TDX_OnReadyForWrite=procedure(Sender:TObject) of object;

   TDXInternet=class (TDXComponent)
      private

         fHost:String;
         fPort:Integer;
         fUseNagle:Boolean;
         fUseBlocking:Boolean;
         fUseUDP:Boolean;

         fOnConnecting:TDX_OnConnect;
         fOnConnected:TDX_OnConnect;
         fOnDisconnected:TDX_OnDisconnect;
         fOnReadyToRead:TDX_OnReadyToRead;
         fOnReadyForWrite:TDX_OnReadyForWrite;

         AsynchTimer:TTimer;

         Ancestor:TDXSock;

      protected
         procedure InternalNotification(Sender:TObject);
         function GetReleaseDate:string;
         procedure SetReleaseDate (value:string) ;
         Function IsConnected:Boolean;
         Function CountWaiting:Integer;
         Function DidReadTimeout:Boolean;
         Function LastCommandStatus:Integer;
         Function GetLocalIPAddr:String;
         Function GetLocalPort:Integer;
      public
         fpSessionData:Pointer;
         constructor Create (AOwner:TComponent) ; override;
         destructor Destroy; override;
         function Connect:Boolean; virtual;
         procedure Disconnect; virtual;
         function SendBuf (const Buf;Count:Integer) :Integer; virtual;
         function ReceiveBuf (var Buf;Count:Integer) :Integer; virtual;
         function Write (c:Char) :Integer;overload; dynamic;
         function Write (const s:string) :Integer;overload; virtual;
         function Write (buf:Pointer;len:Integer) :Integer;overload; virtual;
         function WriteLn (const s:string) :Integer; virtual;
         function WriteResultCode (const Code:Integer;const Rslt:string) :Integer; dynamic;
         function WriteWithSize (S:string) :Boolean; dynamic;
         function WriteInteger (const n:integer) :integer; dynamic;
         function SendFrom (Stream:TStream;Range:Integer) :Boolean; overload; virtual;
         function SendFrom (Stream:TStream) :Boolean;overload; virtual;
         function SendFrom (var Handle:Integer) :boolean;overload; dynamic;
         function SendFrom (var Handle:file) :boolean;overload; dynamic;
         function SendFromStreamWithSize (Stream:TStream) :Boolean; dynamic;

         function Read (buf:Pointer;len:Integer) :Integer;overload; virtual;
         function Read:Char;overload; dynamic;
         function ReadInteger:integer; dynamic;
         function ReadStr (MaxLength:Integer) :string; dynamic;
         function ReadLn (Timeout:Longword) :string; virtual;
         function ReadToAnyDelimeter (Timeout:Longword;Delimeter:string) :string; dynamic;
         function ReadWithSize:string; dynamic;
         function SaveTo (Stream:TStream;Timeout:Longword) :Boolean;overload; virtual;
         function SaveTo (var Handle:Integer;Timeout:Longword) :boolean;overload; dynamic;
         function SaveTo (var Handle:file;Timeout:Longword) :boolean;overload; dynamic;
         function SaveToStreamWithSize (Stream:TStream;Timeout:Longword) :Boolean; dynamic;

         function DroppedConnection:Boolean; virtual;
         function WaitForData (timeout:Longint) :Boolean; virtual;
         procedure RestartCharactersPerSecondTimer;
         function CharactersPerSecondWritten:Integer;
         function CharactersPerSecondReceived:Integer;
      published
         property Host:String read fHost write fHost;
         property Port:Integer read fPort write fPort;
         property UseNagle:Boolean read fUseNagle write fUseNagle;
         property UseBlocking:Boolean read fUseBlocking write fUseBlocking;
         property UseUDP:Boolean read fuseUDP write fuseUDP;

         property Connected:Boolean read IsConnected;
         property CharactersToRead:Integer read CountWaiting;
         property LastReadTimeout:Boolean read DidReadTimeout;
//         property LastCommandStatus:Integer read FErrStatus write FErrStatus;
//         property OutputBufferSize:TDXBlockSizeFlags read fBlockSizeFlags
//            write SetfBlockSizeFlags;
//         property TooManyCharacters:Integer read fTooManyCharacters
//            write fTooManyCharacters;
         property LocalIPAddress:string read GetLocalIPAddr;
         property LocalPort:Integer read GetLocalPort;
         property ReleaseDate:string read GetReleaseDate
            write SetReleaseDate;

         property OnConnecting:TDX_OnConnect read fOnConnecting write fOnConnecting;
         property OnConnected:TDX_OnConnect read fOnConnected write fOnConnected;
         property OnDisconnected:TDX_OnDisconnect read fOnDisconnected write fOnDisconnected;
         property OnReadyToRead:TDX_OnReadyToRead read fOnReadyToRead write fOnReadyToRead;
         property OnReadyForWrite:TDX_OnReadyForWrite read fOnReadyForWrite write fOnReadyForWrite;
   End;

implementation

function TDXInternet.GetReleaseDate:string;
begin
   Result:=BPDX_RELEASE_DATE;
end;

procedure TDXInternet.SetReleaseDate (value:string) ;
begin
  // Absorb!
end;

constructor TDXInternet.Create (AOwner:TComponent) ;
Begin
   inherited Create(AOwner);
   Ancestor:=TDXSock.Create(Nil);
   AsynchTimer:=TTimer.Create(Nil);
   AsynchTimer.Enabled:=False;
   AsynchTimer.Interval:=100;
   AsynchTimer.OnTimer:=InternalNotification;
   fPort:=0;
   fHost:='127.0.0.1';
   fUseNagle:=False;
   fUseBlocking:=False;
   fUseUDP:=False;
End;

destructor TDXInternet.Destroy;
Begin
   AsynchTimer.Free;
   Ancestor.Free;
   inherited Destroy;
End;

function TDXInternet.Connect:Boolean;
Var
   NewConnect:TDXNewConnect;
Begin
   NewConnect:=TDXNewConnect.Create;
   NewConnect.Port:=fPort;
   NewConnect.ipADDRESS:=fHost;
   NewConnect.UseNAGLE:=fUseNagle;
   NewConnect.UseUDP:=fuseUDP;
   NewConnect.UseBLOCKING:=fUseBlocking;
   if Assigned(fOnConnecting) then
      fOnConnecting(Self,fHost,fPort);
   Result:=Ancestor.Connect(NewConnect);
   NewConnect.Free;
   If Result then Begin
      Ancestor.OutputBufferSize:=bsfHuge;
      AsynchTimer.Enabled:=True;
      if Assigned(fOnConnected) then
         fOnConnected(Self,fHost,fPort);
   End
   Else Begin
      AsynchTimer.Enabled:=False;
   End;
End;

procedure TDXInternet.Disconnect;
Begin
   Ancestor.Disconnect;
End;

function TDXInternet.SendBuf (const Buf;Count:Integer) :Integer;
Begin
   Result:=Ancestor.SendBuf(Buf,Count);
End;

function TDXInternet.ReceiveBuf (var Buf;Count:Integer) :Integer;
Begin
   Result:=Ancestor.ReceiveBuf(Buf,Count);
End;

function TDXInternet.Write (c:Char) :Integer;
Begin
   Result:=Ancestor.Write(c);
End;

function TDXInternet.Write (const s:string) :Integer;
Begin
   Result:=Ancestor.Write(S);
End;

function TDXInternet.Write (buf:Pointer;len:Integer) :Integer;
Begin
   Result:=Ancestor.Write(Buf,Len);
End;

function TDXInternet.WriteLn (const s:string) :Integer;
Begin
   Result:=Ancestor.WriteLn(S);
End;

function TDXInternet.WriteResultCode (const Code:Integer;const Rslt:string) :Integer;
Begin
   Result:=Ancestor.WriteResultCode(Code,Rslt);
End;

function TDXInternet.WriteWithSize (S:string) :Boolean;
Begin
   Result:=Ancestor.WriteWithSize(S);
End;

function TDXInternet.WriteInteger (const n:integer) :integer;
Begin
   Result:=Ancestor.WriteInteger(N);
End;

function TDXInternet.SendFrom (Stream:TStream;Range:Integer) :Boolean;
Begin
   Result:=Ancestor.SendFrom(Stream,Range);
End;

function TDXInternet.SendFrom (Stream:TStream) :Boolean;
Begin
   Result:=Ancestor.SendFrom(Stream);
End;

function TDXInternet.SendFrom (var Handle:Integer) :boolean;
Begin
   Result:=Ancestor.SendFrom(Handle);
End;

function TDXInternet.SendFrom (var Handle:file) :boolean;
Begin
   Result:=Ancestor.SendFrom(Handle);
End;

function TDXInternet.SendFromStreamWithSize (Stream:TStream) :Boolean;
Begin
   Result:=Ancestor.SendFromStreamWithSize(Stream);
End;


function TDXInternet.Read (buf:Pointer;len:Integer) :Integer;
Begin
   Result:=Ancestor.Read(Buf,Len);
End;

function TDXInternet.Read:Char;
Begin
   Result:=Ancestor.Read;
End;

function TDXInternet.ReadInteger:integer;
Begin
   Result:=Ancestor.ReadInteger;
End;

function TDXInternet.ReadStr (MaxLength:Integer) :string;
Begin
   Result:=Ancestor.ReadStr(Maxlength);
End;

function TDXInternet.ReadLn (Timeout:Longword) :string;
Begin
   Result:=Ancestor.ReadLn(Timeout);
End;

function TDXInternet.ReadToAnyDelimeter (Timeout:Longword;Delimeter:string) :string;
Begin
   Result:=Ancestor.ReadToAnyDelimiter(Timeout,Delimeter);
End;

function TDXInternet.ReadWithSize:string;
Begin
   Result:=Ancestor.ReadWithSize;
End;

function TDXInternet.SaveTo (Stream:TStream;Timeout:Longword) :Boolean;
Begin
   Result:=Ancestor.SaveTo(Stream,Timeout);
End;

function TDXInternet.SaveTo (var Handle:Integer;Timeout:Longword) :boolean;
Begin
   Result:=Ancestor.SaveTo(Handle,Timeout);
End;

function TDXInternet.SaveTo (var Handle:file;Timeout:Longword) :boolean;
Begin
   Result:=Ancestor.SaveTo(Handle,Timeout);
End;

function TDXInternet.SaveToStreamWithSize (Stream:TStream;Timeout:Longword) :Boolean;
Begin
   Result:=Ancestor.SaveToStreamWithSize(Stream,Timeout);
End;


function TDXInternet.DroppedConnection:Boolean;
Begin
   Result:=Ancestor.DroppedConnection;
End;

function TDXInternet.WaitForData (timeout:Longint) :Boolean;
Begin
   Result:=Ancestor.WaitForData(Timeout);
End;

procedure TDXInternet.RestartCharactersPerSecondTimer;
Begin
   Ancestor.RestartCharactersPerSecondTimer;
End;

function TDXInternet.CharactersPerSecondWritten:Integer;
Begin
   Result:=Ancestor.CharactersPerSecondWritten;
End;

function TDXInternet.CharactersPerSecondReceived:Integer;
Begin
   Result:=Ancestor.CharactersPerSecondReceived;
End;

procedure TDXInternet.InternalNotification(Sender:TObject);
Begin
   AsynchTimer.Enabled:=False;
try
   If Ancestor.Connected then Begin
      If Ancestor.Readable then Begin
         If Ancestor.CharactersToRead=0 then Begin
            Ancestor.Disconnect;
            if Assigned(fOnDisconnected) then
               fOnDisconnected(Self,fhost,fPort);
            Exit;
         End
         Else begin
            if Assigned(fOnReadyToRead) then
               fOnReadyToRead(Self,Ancestor.CharactersToRead);
         End;
      End
      Else Begin
         DoSleepEx(1);
         if Assigned(fOnReadyForWrite) then fOnReadyForWrite(Self);
      End;
   End;
finally
   AsynchTimer.Enabled:=True;
end;   
End;

Function TDXInternet.IsConnected:Boolean;
begin
   Result:=Ancestor.Connected;
End;

Function TDXInternet.CountWaiting:Integer;
begin
   Result:=Ancestor.CharactersToRead;
End;

Function TDXInternet.DidReadTimeout:Boolean;
begin
   Result:=Ancestor.LastReadTimeout;
End;

Function TDXInternet.LastCommandStatus:Integer;
begin
   Result:=Ancestor.LastCommandStatus;
End;

Function TDXInternet.GetLocalIPAddr:String;
begin
   Result:=Ancestor.LocalIPAddress;
End;

Function TDXInternet.GetLocalPort:Integer;
begin
   Result:=Ancestor.LocalPort;
End;

end.