proxy2.pas

httpanalyzer, source code for delphi

  else result:=p;
end;

function TProxyClient.On_P2_DataAvailable(p : pointer; VAR s : longint) : pointer;
begin;
  if Assigned(Proc_P2_DataReceived) then begin
      LockEvents.Acquire;
      try
       result:=Proc_P2_DataReceived(self,run_nr,p,s);
      finally
       LockEvents.Release;
      end;
  end
  else result:=p;
end;

procedure TProxyClient.On_P1_dbgout(p: pchar);
begin;
  if Assigned(Proc_P1_DbgOut) then begin;
      LockEvents.Acquire;
      try Proc_P1_DbgOut(self,p);
      finally LockEvents.Release; end;
  end;
end;

procedure TProxyClient.On_P2_dbgout(p: pchar);
begin;
    if Assigned(Proc_P2_DbgOut) then begin;
        LockEvents.Acquire;
        try Proc_P2_DbgOut(self,p);
        finally LockEvents.Release; end;
    end;
end;

procedure TProxyClient.On_VIP_dbgout(p: pchar);
begin;
    if Assigned(Proc_VIP_DbgOut) then begin;
        LockEvents.Acquire;
        try Proc_VIP_DbgOut(self,p);
        finally LockEvents.Release; end;
    end;
end;

procedure TProxyClient.before_work;
begin;
  //  if connectiontype=connect2sameproxy then begin;
      On_p2_dbgout(Pchar('Tries to connect to : '+dest_addr+' at Port:'+dest_port));
      got_addr:=true;
      FP2Socket.addr:=dest_addr;
      FP2Socket.Port:=dest_port;
      Do_Connect2;
  //  end;
end;

procedure TProxyClient.after_work;
begin;

end;


constructor TProxyClient.Create;
begin
    running_nr:=running_nr+1;
    run_nr:=running_nr;
    
close_p1_after_send:=false;
   del1:=true; del2:=true; del3:=true; del4:=true;
    LastTransmission:=-1;
    anyrec:=false;
    buf_p :=nil;
    buf_s :=0;
    buf_init := false;

    dest_addr := '0.0.0.0';
    dest_port := '80';
    dest_proto:= DC_TCP;
    
    already:=false;
    connected:=false;
    got_addr:=false;

    connectiontype := connect2net;
    proc_vip_dbgout:=nil;

    socksAuthentication := SocksNoAuthentication;
    socksLevel:='5';
    socksPassword:='';
    socksPort:='1080';
    socksServer:='';
    socksUserCode:='';

    (*
    ftp_ready:=false;

    tunnel_type:=255;


    proxy2_addr:='0.0.0.0';
    proxy2_port:='1';

    FP1HSocket  := P1HSocket; *)
    FreeOnTerminate := TRUE;
    inherited Create(TRUE);
end;


procedure TProxyClient.Release;
begin
   on_vip_dbgout('Release-> send WM_Quit');
   if Assigned(FP1Socket) then
    PostMessage(FP1Socket.Handle, WM_QUIT, 0, 0);
end;

procedure TProxyClient.P1_SessionClosed(
    Sender: TObject; Error: Word);
begin
LastTransmission:=-1;
On_p1_dbgout(Pchar('P1 Closed : '+WSocketErrorDesc(error)));
(*if error<>0 then begin;
  Do_Send1str('P1 Closed : '+WSocketErrorDesc(error));
end; *)
if already=false then begin;
 already:=true;
 On_p1_dbgout(Pchar('Schlie遝 nun P2 : '));
 if Assigned(FP2Socket) then begin
 // Do_p1_dbgout(Pchar('da sam ma '+state2text(FP2Socket.state)));

  if FP2Socket.state=wsconnected then Fp2Socket.close
  else begin
    On_p1_dbgout(Pchar('P2 gar nicht connected => Send WM_Quit now '));
    PostMessage(FP1Socket.Handle, WM_QUIT, 0, 0);
  end;

 end
 else begin
  On_p1_dbgout(Pchar('P2 gar nicht zugewiesen => Send WM_Quit now '));
  PostMessage(FP1Socket.Handle, WM_QUIT, 0, 0);
 end;

end
else begin
 On_p1_dbgout(Pchar('Send WM_Quit'));
 PostMessage(FP1Socket.Handle, WM_QUIT, 0, 0); // Der letze Socket der geschlossen
 // wird beendet erst den Thread
end;

end;


procedure TProxyClient.P1_Error(Sender: TObject);
var i : integer;
begin;
 i:= WSAGetLasterror;
 connected:=false;
 On_p1_dbgout(Pchar('P1 Error : '+WSocketErrorDesc(i)));
  if FP2Socket.state=wsconnected then begin
    On_p2_dbgout(Pchar('wg P1 Error  => P2 wird closed'));
    already:=true;
    FP2Socket.close;
   end else begin
     On_p1_dbgout(Pchar('wg P1 Error  => Send WM_Quit'));
     PostMessage(FP1Socket.Handle, WM_QUIT, 0, 0);
   end;


end;

procedure TProxyClient.P1_BgException(Sender: TObject; E: Exception; var CanClose: Boolean);
begin;
 connected:=false;
 On_p1_dbgout(Pchar('P1 BgException : '+E.message));
 Canclose:=true;
end;



destructor TProxyClient.Destroy;
begin
    On_vip_dbgout('Destroy Client Thread');
    if Assigned(FP1Socket) then begin
         FP1Socket.Destroy;
         FP1Socket := nil;
    end;
    if Assigned(FP2Socket) then begin
         FP2Socket.Destroy;
         FP2Socket := nil;
    end;
    inherited Destroy;
end;


procedure TProxyClient.close;
begin;
end;

procedure TProxyClient.pause;
begin;
end;

procedure TProxyClient.resume;
begin;
 inherited resume;
end;



procedure TProxyClient.execute;
(*var
    Peer       : String; *)
begin


    FP1Socket                 := TWSocket.Create(nil);
    FP1Socket.proto:=DC_TCP;
    FP1Socket.HSocket         := FP1HSocket;
    FP1Socket.OnDataAvailable := P1_DataAvailable;
    FP1Socket.OnDataSent      := p1_Datasent;
    FP1Socket.OnSessionClosed := P1_SessionClosed;
    FP1Socket.OnError := P1_Error;
    Fp1Socket.OnBgException:= P1_BgException;

    { Wants to know who is connected to display on screen }
    FP1Socket.GetPeerName(client_ip, Sizeof(client_ip));

    { User likes to see internet address in dot notation }
    Peer := IntToStr(ord(client_ip.sin_addr.S_un_b.s_b1)) + '.' +
            IntToStr(ord(client_ip.sin_addr.S_un_b.s_b2)) + '.' +
            IntToStr(ord(client_ip.sin_addr.S_un_b.s_b3)) + '.' +
            IntToStr(ord(client_ip.sin_addr.S_un_b.s_b4));
    On_P1_dbgout(PCHAR('Remote ' + Peer + ' connected'));

    FP2Socket := TWSocket.Create(nil);
    FP2Socket.proto:=DC_TCP;
    FP2Socket.OnSessionConnected := P2_SessionConnected;
    FP2Socket.OnDataAvailable := P2_DataAvailable;
    FP2Socket.OnSessionClosed := P2_SessionClosed;
    FP2Socket.OnDataSent := P2_DataSent;
    Fp2Socket.OnError := P2_Error;
    Fp2Socket.OnBgException:= P2_BgException;
    //NEW: 25.6.200
    fp2Socket.SocksAuthentication:=socksAuthentication;
    fp2socket.sockslevel:=socksLevel;
    fp2socket.sockspassword:=sockspassword;
    fp2socket.socksport:=socksport;
    fp2socket.socksserver:=socksserver;
    fp2socket.socksusercode:=socksusercode;


    before_work;

    FP1Socket.MessageLoop;

    after_work;

    if buf_init=true then begin;
      if (buf_p<>nil) and (buf_s>0) then freemem(buf_p,buf_s);
    end;
    ReturnValue := 0;
    On_vip_dbgout('returning from Clientthread.execute=> Onterminate now');
end;

procedure TProxyClient.P2_SessionConnected(Sender: TObject; Error: Word);
begin;
On_p2_dbgout(Pchar('P2 Connected : '+WSocketErrorDesc(error)));

if error<>0 then begin;
  Do_Send1str('P2 Connected : '+WSocketErrorDesc(error));
  exit;
end;

connected:=true;
if buf_init=true then begin;
 //if tunnel_type<>typ_ftp_proxy then begin;   //BEI FTP DEN BUFFER NOCH NICHT GLEICH SENDEN!!

  On_p2_dbgout(Pchar('P2 Buffer ('+inttostr(buf_s)+' sent (frm SessionConnected): '));
  Do_Send2(buf_p,buf_s);
  freemem(buf_p,buf_s);
  buf_p:=nil;
  buf_s:=0;
  buf_init:=false;
// end;

end;
end;


// in die Routinen p2_error, p2_bgexception, p2_datasent, p2_sessionclosed
// noch f黵 Http Mode ein entsprechende Fehlerr點kmeldungsseite einbauen!

procedure TProxyClient.P2_Error(Sender: TObject);
var i : integer;
begin;
 i:= WSAGetLasterror;
 connected:=false;
 On_p2_dbgout(Pchar('P2 Error : '+WSocketErrorDesc(i)));
// Do_Send1str('P2 Error : '+WSocketErrorDesc(i));
 if i=WSAHOST_NOT_FOUND  then begin;
   //Do_p2_dbgout('gaga');
   if FP1Socket.state=wsconnected then begin
    On_p2_dbgout(Pchar('wg P2 Error  => P1 wird closed'));
    already:=true;
    FP1Socket.close;
   end else begin
     On_p2_dbgout(Pchar('wg P2 Error  => Send WM_Quit'));
     PostMessage(FP1Socket.Handle, WM_QUIT, 0, 0);
   end;
 //  FP2Socket.abort;
 //  FP2Socket.close;


 end;
end;

procedure TProxyClient.P2_BgException(Sender: TObject; E: Exception; var CanClose: Boolean);
begin;
 connected:=false;
 On_p2_dbgout(Pchar('P2 BgException : '+E.message));
 Canclose:=true;
 Do_Send1str('P2 BgException : '+E.message);
 FP2Socket.close;
end;


procedure TProxyClient.P2_DataSent(Sender: TObject; Error: Word);
begin;
On_p2_dbgout(Pchar('P2 Data Sent : '+WSocketErrorDesc(error)));
if error<>0 then begin;
  Do_Send1str('P2 Data Sent : '+WSocketErrorDesc(error));
  exit;
end;
lasttransmission:=gettickcount;
end;

procedure TProxyClient.P2_SessionClosed(Sender: TObject; Error: Word);
begin;
On_p2_dbgout(Pchar('P2 Closed : '+WSocketErrorDesc(error)));
if error<>0 then begin;
  Do_Send1str('P2 Closed : '+WSocketErrorDesc(error));
end;
if already=false then begin;
 if fp1socket.allsent=true then begin

 already:=true;
 On_p2_dbgout(Pchar('Schlie遝 nun P1..'));
 if Fp1Socket.state=wsconnected then Fp1Socket.closedelayed
 else begin
  On_p2_dbgout(Pchar('P1 gar nicht connected => Send WM_Quit now '));
  sleep(10); // hoffe des f鋖lt nicht ins Gewicht!! bzgl. DDE
  PostMessage(FP2Socket.Handle, WM_QUIT, 0, 0);
  //FP2Socket.Closedelayed;
 end;

 end
 else close_p1_after_send:=true;

end
else begin;
  On_p2_dbgout(Pchar('Send WM_Quit'));
  PostMessage(FP2Socket.Handle, WM_QUIT, 0, 0); // Der letze Socket der geschlossen
 // wird beendet erst den Thread
  //FP2Socket.Closedelayed;
 end;
end;





procedure TProxyClient.look4addr;
begin;

end;

procedure TProxyClient.P1_DataAvailable(
    Sender: TObject;
    Error: Word);
var
    Buffer : array [0..4095] of char;
    Count  : Integer;

    new_bufp : pointer;
    new_bufs : longint;

    new_data : pointer; //Daten nach dem sie ueber die Handlerfunktion ver鋘dert werden kann
    new_size : longint;
begin
    { Receive as much data as possible                                      }
    Count := FP1Socket.Receive(@Buffer, SizeOf(Buffer)-1);

    //NEU04
    //copy buffer to new memory space
    new_size:=count;
    getmem(new_data,count);
    mem_copy(new_data,@buffer, count);

    new_data:=On_P1_DataAvailable(new_data,new_size);
    (*wird ein Handler von User implementiert muss dieser den alten Speicher manuell
     freigeben; modifizieren und neuen belegen *)


    { If data received, then process it                                     }
    if new_size > 0 then begin
        On_P1_dbgout(Pchar('P1 Data received ('+inttostr(new_size)+' Bytes'));
       // buffer[count]:=#0;
      //  Do_P1_dbgout(buffer);

        if (connected=false)  then begin;
          On_P1_dbgout('P1 not yet connected => write in Sendbuf');
          if buf_init=false then begin
            On_P1_dbgout('P1 INIT SENDBUF');
            getmem(buf_p,new_size);
            mem_copy(buf_p,new_data, new_size);
            buf_init:=true;
            buf_s:=new_size;
          end
          else begin
            On_P1_dbgout('P1 ADD TO SENDBUF');
            new_bufp:=mem_cat(buf_p,buf_s,new_data,new_size,  new_bufs);
            freemem(buf_p,buf_s);

            getmem(buf_p,new_bufs);

            buf_s:=new_bufs;
            mem_copy(buf_p,new_bufp,buf_s);

            freemem(new_bufp, new_bufs);
          end;

        end;
        if got_addr=false then begin;

           look4addr;

           // wenn gefunden dann Do_Connect2; exit;
        end;

        if connected=true then begin;

           Do_Send2(new_data,new_size);

        end;
    end;
    if ((new_data<>nil) and (new_size>0)) then freemem(new_data,new_size);
end;


procedure TProxyClient.P2_DataAvailable(Sender: TObject; Error: Word);

var
    Buffer : array [0..4095] of char;
    Count  : Integer;

    new_data : pointer; //Daten nach dem sie ueber die Handlerfunktion ver鋘dert werden kann
    new_size : longint;
begin
    lasttransmission:=gettickcount;
    anyrec:=true;
    { Receive as much data as possible                                      }
    Count := FP2Socket.Receive(@Buffer, SizeOf(Buffer)-1);

    //NEU04
    //copy buffer to new memory space
    new_size:=count;
    getmem(new_data,count);
    mem_copy(new_data,@buffer, count);

    new_data:=On_P2_DataAvailable(new_data,new_size);
    (*wird ein Handler von User implementiert muss dieser den alten Speicher manuell
     freigeben; modifizieren und neuen belegen *)

    { If data received, then process it                                     }
    if new_size > 0 then begin;


      On_P2_dbgout(Pchar('P2 Data received ('+inttostr(new_size)+' Bytes)'));
     // buffer[count]:=#0;
     // Do_P2_dbgout(buffer);

      if Fp1Socket.State=wsconnected then begin;
         Do_Send1(new_data,new_size);
      end;

    end;
    if ((new_data<>nil) and (new_size>0)) then freemem(new_data,new_size);
end;



procedure TProxyClient.P1_DataSent(Sender: TObject; Error: Word);
begin;
On_p1_dbgout(Pchar('P1 Data Sent : '+WSocketErrorDesc(error)));
if close_p1_after_send= true then begin;
 On_p2_dbgout(Pchar('DataSent.Schlie遝 nun P1..'));
 if Fp1Socket.state=wsconnected then Fp1Socket.closedelayed
 else begin
  On_p2_dbgout(Pchar('DataSent.P1 gar nicht connected => Send WM_Quit now '));
  PostMessage(FP2Socket.Handle, WM_QUIT, 0, 0);
 end;
end;

end;

initialization
  LockEvents:=TCriticalSection.Create

finalization
  LockEvents.Destroy;


end.