FHostName := IP2Str(RevertInt(FIP));
  Result := FHostName;
end;

procedure TURL.SetHostName(const NewHost: string);
begin
  FHostName := NewHost;
  FIP := Name2IP(FHostName);
end;

procedure TURL.SetIP(NewIP: u_long);
begin
  FIP := RevertInt(NewIP);
  FHostName := '';
  if FIP = $100007F then
    FHostName := 'localhost'
  else
    try
      FHostName := IP2Name(FIP);
    except
      FHostName := IP2Str(FIP);
    end;
end;

function TURL.GetURL: string;
begin
  if FPath = '' then
    FPath := HostName + ':' + IntToStr(FPort) + FileName;
  Result := FPath;
end;

procedure TURL.SetUrl(Value: string);
var
  Temp: string;
begin
  FPath  := Value;
  Temp   := StrTok(Value,':/@ ');
  FPort  := 0;
  FProto := '';
  if StrCmpBegin(Value, '://') then
  begin
    FProto := LowerCase(Temp);
    Value  := Copy(Value,4,Length(Value)-3);
    Temp   := StrTok(Value,':/@ ');
  end;

  if FProto = 'file' then
  begin
    FHostName := '';
    FIP       := 0;
    FFileName := Temp + StrTok(Value,'?');
  end
  else
  begin
    FHostName := Temp;
    FIP       := Name2IP(FHostName);
    if StrCmpBegin(Value,':') then
    begin
      Temp  := StrTok(Value,':/@ ');
      FPort := StrToIntDef(Temp,0);
    end;
    FFileName := Value;
  end;

  if FProto = '' then FProto := 'http';
  if FFileName = '' then FFileName := '/';

  if FProto <> 'file' then
  begin
    Temp := IP2Name(FIP);
    if Temp<>'' then FHostName := Temp;
  end;

  FPath := FProto + '://' + FHostName;
  if FPort <> 0 then FPath := FPath + IntToStr(FPort);
  if (FPath[Length(FPath)]<>'/') and (FFileName[1]<>'/') then
    FPath := FPath + '/';
  FPath := FPath + FFileName;

  if (FProto = 'http') and (FPort = 0) then FPort := 80;
  if (FProto = 'ftp') and (FPort = 0) then  FPort := 21;
end;

procedure TURL.Assign(NewURL: TURL);
begin
  FPort     := NewURL.FPort;
  FHostName := NewURL.FHostName;
  FFileName := NewURL.FFileName;
  FIP       := NewURL.FIP;
end;

{******************* TInetSocket implementation ***********************}

{ Check socket status }
function TInetSocket.IsGood: Boolean;
begin
  Result := (FSid >= 0);
end;

function TInetSocket.QueueSize: LongInt;
begin
  Result:=0;
  ioctlsocket(FSid, FIONREAD, Result);
end;

procedure TInetSocket.SetEvents(Handle: HWND; Msg: u_int; Event: LongInt);
begin
  WSAAsyncSelect(FSid, Handle, Msg, Event);
  WinSocketCheckError;
end;

procedure TInetSocket.SetOptions(Cmd: LongInt; var Arg: u_long);
begin
  ioctlsocket(FSid, cmd, arg);
end;

constructor TInetSocket.Create;
begin
  FServer := TURL.Create;
  FClient := TURL.Create;
  FSid    := 0;
end;

constructor TInetSocket.CreateByHandle(NewSid: Integer);
begin
  FServer := TURL.CreateByName('localhost', 0, '/');
  FClient := TURL.CreateByIP(0, 0, '/');
  FSid    := NewSid;
end;

destructor TInetSocket.Destroy;
begin
  try
    CloseConnect;
  finally
    FServer.Free;
    FClient.Free;
  end;
end;

procedure TInetSocket.CloseConnect;
begin
  shutdown (FSid,2);
//  WinSocketCheckError;
  closesocket(FSid);
//  WinSocketCheckError;
end;

{************** TInetClientSocket implementation ***************}

function TInetClientSocket.IsArrive: Boolean;
begin
  Result := (QueueSize > 0);
end;

function TInetClientSocket.Write(var Buf; Len,Flag: Integer): Integer;
begin
  Result := Send(FSid, Buf, Len, Flag );
  if Result = SOCKET_ERROR then WinSocketCheckError;
end;

function TInetClientSocket.Read(var Buf; Len,Flag: Integer ): Integer;
begin
  Result := Recv(FSid, Buf, Len, Flag);
  if Result = SOCKET_ERROR then WinSocketCheckError;
end;

constructor TInetClientSocket.Create;
begin
  FServer := TURL.Create;
  FClient := TURL.Create;
  FSid    := 0;
end;

constructor TInetClientSocket.CreateByName(const Name: string; Port: Integer);
begin
  FServer := TURL.CreateByName(Name, Port, '/');
  FClient := TURL.Create;
  FSid    := Socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
  if FSid = INVALID_SOCKET then WinSocketCheckError;
end;

constructor TInetClientSocket.CreateByIP(IP: u_long; Port: Integer);
begin
  FServer := TURL.CreateByIP(IP, Port, '/');
  FClient := TURL.Create;
  FSid    := Socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
  if FSid = INVALID_SOCKET then WinSocketCheckError;
end;

constructor TInetClientSocket.CreateByUrl(NewURL: TURL);
begin
  FServer := TURL.Create;
  FServer.Assign(newURL);
  FClient := TURL.Create;
  FSid    := Socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
  if FSid = INVALID_SOCKET then WinSocketCheckError;
end;

constructor TInetClientSocket.CreateByHandle(NewSid: Integer);
begin
  FServer := TURL.CreateByName('localhost', 0, '/');
  FClient := TURL.CreateByIP( 0, 0, '/');
  FSid    := NewSid;
end;

function TInetClientSocket.ConnectSocket(const HostNm: string; Port: Integer): Integer;
var
  Url: TURL;
begin
  Url := TURL.CreateByName(HostNm, Port, '/');
  try
    Result := ConnectSocketByURL(url);
  finally
    Url.Free;
  end;
end;

function TInetClientSocket.ConnectSocketByURL(Url: TURL): Integer;
var
  Addr: TSockAddrIn;
  Len:  Integer;
begin
  Len := url.FillAddr(Addr);
  FRc := Connect(FSid, Addr, Len);
  if FRc = SOCKET_ERROR then WinSocketCheckError;
  Result := FRc;
end;

{**************** TInetServerSocket implementation ***************}

function TInetServerSocket.BindSocket: Integer;
var
  addr: TSockAddrIn;
  len:  u_long;
begin
  FSid := socket(AF_INET, SOCK_STREAM, 0);
  WinSocketCheckError;
  len  := FServer.FillAddr( addr );
  FRc  := bind(FSid, addr, len);
  WinSocketCheckError;
  if FRc < 0 then
  begin
    FRc := getsockname(FSid, addr, len);
    if FRc < 0 then CloseConnect;
    FSid := -1;
  end;
  Result := FRc;
end;

constructor TInetServerSocket.Create;
begin
  FServer := TURL.Create;
  FClient := TURL.Create;
end;

constructor TInetServerSocket.CreateByName(const Name: string; Port: Integer);
begin
  FServer := TURL.CreateByName(Name, Port, '/');
  FClient := TURL.Create;
  BindSocket;
end;

constructor  TInetServerSocket.CreateByIP(IP: u_long; Port: Integer);
begin
  FServer := TURL.CreateByIP(IP, Port, '/');
  FClient := TURL.Create;
  BindSocket;
end;

constructor TInetServerSocket.CreateByURL(NewURL: TURL);
begin
  FServer := TURL.Create;
  FServer.Assign(NewURL);
  FClient := TURL.Create;
  BindSocket;
end;

constructor TInetServerSocket.CreateByHandle(NewSid: Integer);
begin
  FServer := TURL.CreateByName('localhost', 0, '/');
  FClient := TURL.Create;
  FSid    := NewSid;
end;

function TInetServerSocket.ListenConnect: Integer;
begin
  Result := listen(FSid,BACKLOG_NUM);
  WinSocketCheckError;
end;

function TInetServerSocket.AcceptConnect: TInetClientSocket;
var
  Sock: TInetClientSocket;
  Addr: TSockAddrIn;
  Len:  u_long;
begin
  Len := SizeOf(Addr);
  FRc := accept(FSid, @Addr, @Len);
//  WinSocketCheckError;
  if FRc > 0 then
  begin
    FClient.IP   := RevertInt(Addr.sin_addr.s_addr);
    FClient.Port := Addr.sin_port;
    Sock         := TInetClientSocket.CreateByHandle(FRc);
    Sock.Server.Assign(FServer);
    Sock.Client.Assign(FClient);
    Result       := Sock;
  end else
    Result := nil;
end;

function TInetServerSocket.ShutdownConnect(Mode: Integer): Integer;
begin
  Result := shutdown(FSid,Mode);
  WinSocketCheckError;
end;

initialization
  WinSocketStartup;
finalization
  WinSocketCleanup;
end.