CTry: Integer;
  handled: boolean;
begin
  RemoteAddress.sin_addr.S_addr := Inet_Addr(StrPCopy(buf, FRemoteHost));
  if RemoteAddress.sin_addr.S_addr = SOCKET_ERROR then
      {If given name not an IP address already}
  begin
    CTry := 0;
    repeat
      Wait_Flag := False; {Reset flag indicating wait over}
         {Resolve IP address}
      wsaasyncgethostbyname(FSocketWindow, WM_ASYNCHRONOUSPROCESS, buf, PChar(RemoteHostS), MAXGETHOSTSTRUCT);
      repeat
        Wait;
      until Wait_Flag or Canceled; {Till host name resolved, Timed out or cancelled}
         {Handle errors}
      if Canceled then
        raise UDPSockError.Create(Cons_Msg_Lkp);
      if Succeed = False then
      begin
        if CTry < 1 then
        begin
          CTry := CTry + 1;
          handled := False;
          if Assigned(FOnInvalidHost) then FOnInvalidHost(handled);
          if not handled then UDPSockError.Create(Cons_Msg_Lkp);
        end {_ if CTry < 1 then _}
        else {_ NOT if CTry < 1 then _}  raise UDPSockError.Create(Cons_Msg_Lkp);
      end {_ if Succeed = FALSE then _}
      else {_ NOT if Succeed = FALSE then _}
            {Fill up remote host information with retreived results}
        with RemoteAddress.sin_addr.S_un_b do
        begin
          s_b1 := RemoteHostS.h_addr_list^[0];
          s_b2 := RemoteHostS.h_addr_list^[1];
          s_b3 := RemoteHostS.h_addr_list^[2];
          s_b4 := RemoteHostS.h_addr_list^[3];
        end; {_ with RemoteAddress.sin_addr.S_un_b do _}
    until Succeed = True;
  end; {_ if remoteaddress.sin_addr.S_addr = SOCKET_ERROR then _}
end; {_ procedure TNMUDP.ResolveRemoteHost; _}

procedure TNMUDP.SendStream(DataStream: TStream);
var CTry, i: Integer;
  buf: array[0..2047] of char;
  handled: boolean;
begin
  CTry := 0;
  while DataStream.size = 0 do
    if CTry > 0 then raise Exception.Create(Cons_Msg_InvStrm)
    else {_ NOT if CTry > 0 then raise Exception.create(Cons_Msg_InvStrm) _}
      if not Assigned(FOnStreamInvalid) then raise Exception.Create(Cons_Msg_InvStrm)
      else {_ NOT if not assigned(FOnStreamInvalid) then raise Exception.create(Cons_Msg_InvStrm) _}
      begin
        handled := False;
        FOnStreamInvalid(handled, DataStream);
        if not handled then raise Exception.Create(Cons_Msg_InvStrm)
        else {_ NOT if not Handled then raise Exception.create(Cons_Msg_InvStrm) _}  CTry := CTry + 1;
      end; {_ NOT if not assigned(FOnStreamInvalid) then raise Exception.create(Cons_Msg_InvStrm) _}
  Canceled := False; {Turn Canceled off}
  ResolveRemoteHost; {Resolve the IP address of remote host}
  if RemoteAddress.sin_addr.S_addr = 0 then
    raise UDPSockError.Create(Cons_Err_Addr); {If Resolving failed raise exception}
  StatusMessage(Status_Basic, Cons_Msg_Data); {Inform status}
  RemoteAddress.sin_family := AF_INET; {Make connected true}
{$R-}
  RemoteAddress.sin_port := htons(FRemotePort); {If no proxy get port from Port property}
{$R+}
  i := SizeOf(RemoteAddress); {i := size of remoteaddress structure}
   {Connect to remote host}
  DataStream.position := 0;
  DataStream.ReadBuffer(buf, DataStream.size);
  Winsock.SendTo(ThisSocket, buf, DataStream.size, 0, RemoteAddress, i);
  if Assigned(FOnDataSend) then FOnDataSend(self);
end; {_ procedure TNMUDP.SendStream(DataStream: TStream); _}

procedure TNMUDP.SendBuffer(Buff: array of char; Length: Integer);
var CTry, i: Integer;
  handled: boolean;
begin
  CTry := 0;
  while Length = 0 do
    if CTry > 0 then raise Exception.Create(Cons_Err_Buffer)
    else {_ NOT if CTry > 0 then raise Exception.create(Cons_Err_Buffer) _}
      if not Assigned(FOnBufferInvalid) then raise Exception.Create(Cons_Err_Buffer)
      else {_ NOT if not assigned(FOnBufferInvalid) then raise Exception.create(Cons_Err_Buffer) _}
      begin
        handled := False;
        FOnBufferInvalid(handled, Buff, Length);
        if not handled then raise Exception.Create(Cons_Err_Buffer)
        else {_ NOT if not Handled then raise Exception.create(Cons_Err_Buffer) _}  CTry := CTry + 1;
      end; {_ NOT if not assigned(FOnBufferInvalid) then raise Exception.create(Cons_Err_Buffer) _}
  Canceled := False; {Turn Canceled off}
  ResolveRemoteHost; {Resolve the IP address of remote host}
  if RemoteAddress.sin_addr.S_addr = 0 then
    raise UDPSockError.Create(Cons_Err_Addr); {If Resolving failed raise exception}
  StatusMessage(Status_Basic, Cons_Msg_Data); {Inform status}
  RemoteAddress.sin_family := AF_INET; {Make connected true}
{$R-}
  RemoteAddress.sin_port := htons(FRemotePort); {If no proxy get port from Port property}
{$R+}
  i := SizeOf(RemoteAddress); {i := size of remoteaddress structure}
  Winsock.SendTo(ThisSocket, Buff, Length, 0, RemoteAddress, i);
  if Assigned(FOnDataSend) then FOnDataSend(self);
end; {_ procedure TNMUDP.SendBuffer(Buff: array of char; length: integer); _}
{*******************************************************************************************
Handle Power socket error
********************************************************************************************}

function TNMUDP.ErrorManager(ignore: word): string;
var
  slasterror: string;
begin
  StatusMessage(Status_Trace, Cons_Msg_Echk); {Report Status}
  FLastErrorno := wsagetlasterror; {Set last error}
  if (FLastErrorno and ignore) <> ignore then
      {If the error is not the error to be ignored}
  begin
    slasterror := SocketErrorStr(FLastErrorno); {Get the description string for error}
    if Assigned(FOnErrorEvent) then
         {If error handler present excecute it}
      FOnErrorEvent(self, FLastErrorno, slasterror);
    raise UDPSockError.Create(slasterror); {Raise exception}
  end; {_ if (FLastErrorno and ignore) <> ignore then _}
  result := slasterror; {return error string}
end; {_ function TNMUDP.ErrorManager(ignore: word): string; _}

{*******************************************************************************************
Return Error Message Corresponding To Error number
********************************************************************************************}

function TNMUDP.SocketErrorStr(errno: word): string;
begin
  if errno <> 0 then
      {If error exits}
  begin
      (*for x := 0 to 50 do                                {Get error string}
        if winsockmessage[x].errorcode = errno then
          Result := inttostr( winsockmessage[x].errorcode ) + ':' + winsockmessage[x].text; *)
    if result = '' then {If not found say unknown error}
      result := Cons_Msg_Eno + IntToStr(errno);
  end; {_ if ErrNo <> 0 then _}
  StatusMessage(Status_Debug, Cons_Msg_ELkp + result); {Status message}
end; {_ function TNMUDP.SocketErrorStr(ErrNo: word): string; _}

{*******************************************************************************************
Output a Status message: depends on current Reporting Level
********************************************************************************************}

procedure TNMUDP.StatusMessage(Level: byte; value: string);
begin
  if Level <= FReportLevel then
      {If level of error less than present report level}
  begin
    _status := value; {Set status to vale of error}
    if Assigned(FOnStatus) then
      FOnStatus(self, _status); {If Status handler present excecute it}
  end; {_ if level <= FReportLevel then _}
end; {_ procedure TNMUDP.StatusMessage(Level: byte; value: string); _}

{*******************************************************************************************
Socket Message handler
********************************************************************************************}

procedure TNMUDP.WndProc(var message: TMessage);
begin
  if _ProcMsg then {If Processing of messages enabled}
    with message do
      if msg = WM_ASYNCHRONOUSPROCESS then
      begin
        if lparamLo = FD_READ then
          ProcessIncomingdata
        else {_ NOT if lparamLo = FD_Read then _}
        begin
          Wait_Flag := True;
          if lparamhi > 0 then
                  {If no error}
            Succeed := False {Succed flag not set}
          else {_ NOT if lparamhi > 0 then _}
            Succeed := True;
        end; {_ NOT if lparamLo = FD_Read then _}
        SetEvent(EventHandle);
      end {_ if msg = WM_ASYNCHRONOUSPROCESS then _}
      else
        result := DefWindowProc(FSocketWindow, msg, wParam, lParam);
end; {_ procedure TNMUDP.WndProc(var message: TMessage); _}


procedure TNMUDP.ProcessIncomingdata;
var
  From: TSockAddr;
  i: Integer;
  s1: string;
  p1: u_short; 
begin
  i := SizeOf(From);
  IBuffSize := Winsock.RecvFrom(ThisSocket, IBuff, 2048, 0, From, i);
  if Assigned(FOnDataReceived) then
  begin
    s1 := Format('%d.%d.%d.%d', [Ord(From.sin_addr.S_un_b.s_b1), Ord(From.sin_addr.S_un_b.s_b2), Ord(From.sin_addr.S_un_b.s_b3), Ord(From.sin_addr.S_un_b.s_b4)]);
    p1 := ntohs(From.sin_port);
    FOnDataReceived(self, IBuffSize, s1, p1);
  end; {_ if assigned(FOnDataReceived) then _}
end; {_ procedure TNMUDP.ProcessIncomingdata; _}

procedure TNMUDP.ReadStream(DataStream: TStream);

begin
  DataStream.WriteBuffer(IBuff, IBuffSize);
  DataStream.position := 0;
end; {_ procedure TNMUDP.ReadStream(DataStream: TStream); _}

procedure TNMUDP.Wait;
begin
  WaitforSync(EventHandle);
  ResetEvent(EventHandle);
end;

procedure TNMUDP.ReadBuffer(var Buff: array of char; var Length: Integer);
begin
  Move(IBuff, Buff, IBuffSize);
  Length := IBuffSize;
end; {_ procedure TNMUDP.ReadBuffer(var Buff: array of char; var length: integer); _}


end.