И снова WinSock. UDP. Прием данных.

char buf[1024];
sendCMD();
receiveINF(buf);
Memo1->Lines->Add(AnsiString(buf));

extern char *serverIP;
extern int serverPORT;
 
void sendCMD();
void sendCMD(char *command);
void receiveINF(char *buf);

#include <vcl.h>
#include "sendreceive.h"
#include <winsock2.h>
 
#define WM_ONSOCKET WM_USER+1
 
void sendCMD()
{
    ...
}
 
void sendCMD(char *command)
{
    ...
}
 
void receiveINF(char *buf)
{
    int iResult = 0;
 
    WSADATA wsd;
    SOCKET RecvSocket;
 
    struct sockaddr_in RecvAddr;
    int RecvAddrSize = sizeof (RecvAddr);
 
// Инициализируем сокет
    iResult = WSAStartup(MAKEWORD(2,2), &wsd);
    if (iResult != NO_ERROR)
    {
        ShowMessage("WSAStartup filed");
    }
 
// Создаем принимающий сокет для приема датаграм
    RecvSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (RecvSocket == INVALID_SOCKET)
    {
        ShowMessage("Socket failed");
    }
 
//ВЫЗЫВАЕМ ФУНКЦИЮ, которая сделает нашу функцию АСИНХРОННОЙ. Где-то тут  
//точно есть косяк, о нём после описания данного файла. Скорее всего
//это: Application->Handle надо чем-то заменять. 
//И еще я не разобрался, что же такое WM_ONSOCKET (сверху он в define определен)
//p.s. эту функцию взял на просторах msdn и интернета, по этому не понял, что это
//за зверь. Может есть на что её поменять?
    WSAAsyncSelect(RecvSocket, Application->Handle, WM_ONSOCKET, FD_READ);
 
// Биндим адрес к определенному порту и любому IPшнику
 
    RecvAddr.sin_family = AF_INET;
    RecvAddr.sin_port = htons(bindPORT);
    RecvAddr.sin_addr.s_addr = htonl(INADDR_ANY);
 
// Вызываем функцию для приема датаграм
    iResult = recvfrom(RecvSocket, buf, 1024, 0, (SOCKADDR *) & RecvAddr,
                                                               &RecvAddrSize);
    if (iResult == SOCKET_ERROR)
    {
        ShowMessage("Ошибка приема");
    }
 
// Закрываем сокет, когда приняли датаграммы
    iResult = closesocket(RecvSocket);
    if (iResult == SOCKET_ERROR)
    {
        ShowMessage("Ошибка закрытия сокета");
    }
 
//Очищаем все за собой, и выходим
    WSACleanup();
}

void sendCMD()
{
    WSADATA wsd;
    if (WSAStartup(MAKEWORD(2,2), &wsd)!=0)
    {
        ShowMessage("Не могу стартануть сокет"); 
    }
    else
    {
        SOCKET S;
        struct sockaddr_in servaddr;
        S=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        servaddr.sin_family=AF_INET;
        servaddr.sin_port=htons(serverPORT);
        servaddr.sin_addr.s_addr=inet_addr(serverIP);
 
        char *buf = "\xff\xff\xff\xff getstatus";
        sendto(S,buf,strlen(buf),0,(SOCKADDR *) & servaddr, sizeof (servaddr));
        closesocket(S);
    }
 
    WSACleanup();
}

  // Пример простого UDP-эхо сервера
  #include <stdio.h>
  #include <winsock2.h>
 
  #define PORT 666    // порт сервера
  #define sHELLO "Hello, %s [%s] Sailor\n"
 
  int main(int argc, char* argv[])
  {
    char buff[1024];
 
    printf("UDP DEMO echo-Server\n");
 
    // шаг 1 - подключение библиотеки 
    if (WSAStartup(0x202,(WSADATA *) &buff[0]))
    {
      printf("WSAStartup error: %d\n",
             WSAGetLastError());
      return -1;
    }
 
    // шаг 2 - создание сокета
    SOCKET my_sock;
    my_sock=socket(AF_INET,SOCK_DGRAM,0);
    if (my_sock==INVALID_SOCKET)
    {
      printf("Socket() error: %d\n",WSAGetLastError());
      WSACleanup();
      return -1;
    }
 
    // шаг 3 - связывание сокета с локальным адресом 
    sockaddr_in local_addr;
    local_addr.sin_family=AF_INET;
    local_addr.sin_addr.s_addr=INADDR_ANY;
    local_addr.sin_port=htons(PORT);
 
    if (bind(my_sock,(sockaddr *) &local_addr,
        sizeof(local_addr)))
    {
      printf("bind error: %d\n",WSAGetLastError());
      closesocket(my_sock);
      WSACleanup();
      return -1;
    }
 
    // шаг 4 обработка пакетов, присланных клиентами
    while(1)
    {
      sockaddr_in client_addr;
      int client_addr_size = sizeof(client_addr);
      int bsize=recvfrom(my_sock,&buff[0],
        sizeof(buff)-1,0,
        (sockaddr *) &client_addr, &client_addr_size);
      if (bsize==SOCKET_ERROR)
      printf("recvfrom() error: %d\n",
             WSAGetLastError());
 
      // Определяем IP-адрес клиента и прочие атрибуты
      HOSTENT *hst;
      hst=gethostbyaddr((char *)
            &client_addr.sin_addr,4,AF_INET);
      printf("+%s [%s:%d] new DATAGRAM!\n",
      (hst)?hst->h_name:"Unknown host",
      inet_ntoa(client_addr.sin_addr),
      ntohs(client_addr.sin_port));
 
      // добавление завершающего нуля
      buff[bsize]=0;
 
      // Вывод на экран 
      printf("C=>S:%s\n",&buff[0]);
 
      // посылка датаграммы клиенту
      sendto(my_sock,&buff[0],bsize,0,
        (sockaddr *)&client_addr, sizeof(client_addr));
    }
    return 0;
  }

  // пример простого UDP-клиента
  #include <stdio.h>
  #include <string.h>
  #include <winsock2.h>
  #include <windows.h>
 
  #define PORT 666
  #define SERVERADDR "127.0.0.1"
 
  int main(int argc, char* argv[])
  {
    char buff[10*1014];
    printf("UDP DEMO Client\nType quit to quit\n");
 
    // Шаг 1 - иницилизация библиотеки Winsocks
    if (WSAStartup(0x202,(WSADATA *)&buff[0]))
    {
      printf("WSAStartup error: %d\n",
             WSAGetLastError());
      return -1;
    }
 
    // Шаг 2 - открытие сокета
    SOCKET my_sock=socket(AF_INET, SOCK_DGRAM, 0);
    if (my_sock==INVALID_SOCKET)
    {
      printf("socket() error: %d\n",WSAGetLastError());
      WSACleanup();
      return -1;
    }
 
    // Шаг 3 - обмен сообщений с сервером
    HOSTENT *hst;
    sockaddr_in dest_addr;
 
    dest_addr.sin_family=AF_INET;
    dest_addr.sin_port=htons(PORT);
 
    // определение IP-адреса узла
    if (inet_addr(SERVERADDR))
      dest_addr.sin_addr.s_addr=inet_addr(SERVERADDR);
    else
      if (hst=gethostbyname(SERVERADDR))
        dest_addr.sin_addr.s_addr=((unsigned long **)
              hst->h_addr_list)[0][0];
    else
      {
        printf("Unknown host: %d\n",WSAGetLastError());
        closesocket(my_sock);
        WSACleanup();
        return -1;
      }
 
    while(1)
    {
      // чтение сообщения с клавиатуры
      printf("S<=C:");fgets(&buff[0],sizeof(buff)-1,
             stdin);
      if (!strcmp(&buff[0],"quit\n")) break;
 
      // Передача сообщений на сервер
      sendto(my_sock,&buff[0],strlen(&buff[0]),0,
        (sockaddr *) &dest_addr,sizeof(dest_addr));
 
      // Прием сообщения с сервера
      sockaddr_in server_addr;
      int server_addr_size=sizeof(server_addr);
 
      int n=recvfrom(my_sock,&buff[0],sizeof(buff)-1,0,
        (sockaddr *) &server_addr, &server_addr_size);
 
      if (n==SOCKET_ERROR)
      {
        printf("recvfrom() error:"\
          "%d\n",WSAGetLastError());
        closesocket(my_sock);
        WSACleanup();
        return -1;
      }
 
      buff[n]=0;
 
      // Вывод принятого с сервера сообщения на экран
      printf("S=>C:%s",&buff[0]);
    }
 
    // шаг последний - выход
    closesocket(my_sock);
    WSACleanup();
 
    return 0;
  }

// ***************** //
// Powered by MaZhor //
// ***************** //
#include <vcl.h>
#pragma hdrstop
 
#include <iostream>
#include <memory>
#include <tchar.h>
#include <IdUDPServer.hpp>
#include <IdUDPClient.hpp>
// ---------------------------------------------------------------------------
#pragma argsused
 
void __fastcall OnNotifyUDPRead(void*This, TIdUDPListenerThread* AThread,
    System::DynamicArray<System::Byte>AData,
    Idsockethandle::TIdSocketHandle* ABinding) {
    // обрабатываем приходящие данные
    std::wcout << BytesToString(AData, TEncoding::Default).c_str() << "\n";
}
 
int _tmain(int argc, _TCHAR* argv[]) {
    // ********************* //
    // СОЗДАНИЕ  UDP СЕРВЕРА //
    // ********************* //
    std::auto_ptr<TIdUDPServer>UDPServer(new TIdUDPServer(Application));
    UDPServer->DefaultPort = 3200;
    // приём сообщений будем производить в отдельном потоке
    UDPServer->ThreadedEvent = true;
    // создаём соединение
    TIdSocketHandle *Binding1 = UDPServer->Bindings->Add();
    Binding1->Port = 3200;
    Binding1->IP = "127.0.0.1";
    Binding1->IPVersion = Id_IPv4;
    // создаём метод с адресом нашей функции приёма сообщений
    TMethod MethodUDP;
    MethodUDP.Data = Application;
    MethodUDP.Code = OnNotifyUDPRead;
        // применяем метод к серверу
    UDPServer->OnUDPRead = *(TUDPReadEvent*)&MethodUDP;
    UDPServer->Active = true;
 
    // ********************* //
    // СОЗДАНИЕ  UDP КЛИЕНТА //
    // ********************* //
    std::auto_ptr<TIdUDPClient>UDPClient(new TIdUDPClient(Application));
    UDPClient->Port = 3200;
    UDPClient->Host = "127.0.0.1";
 
    // пока не будет нажата клавиша ESC будем слать данные на сервер
    while (GetKeyState(VK_ESCAPE) >= 0) {
        UDPClient->Send("test", TEncoding::Default);
        Sleep(16);
    }
 
    return 0;
}
// ---------------------------------------------------------------------------

#include <vcl.h>

AnsiString

ShowMessage

Application->Handle

// ---------------------------------------------------------------------------
AnsiString sDisplayString = "";
 
void __fastcall TForm1::DisplayInMemo() {
    Memo1->Lines->Add(sDisplayString);
}
 
// ---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender) {
    Memo1->Lines->Clear();
    // здесь я использую в качестве потока TIdThreadComponent
    // но если у тебя ненависть к Indy
    // можешь использовать <TThread> или <boost::thread>
    // в общем неважно, главное, чтобы это было в отдельном потоке
    IdThreadComponent1->Active = true;
}
 
// ---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender) {
    if (!IdThreadComponent1->Active) {
        ShowMessage("Server is not initialized!");
    }
    else {
        IdThreadComponent2->Active = true;
    }
}
 
 
// ---------------------------------------------------------------------------
void __fastcall TForm1::IdThreadComponent1Run(TIdThreadComponent *Sender) {
    WSADATA wData;
    struct sockaddr_in addr;
 
    if (WSAStartup(MAKEWORD(1, 1), &wData) != 0) {
        sDisplayString = "SERVER>socket is not initialized";
        Sender->Synchronize(&DisplayInMemo);
        WSACleanup();
        Sender->Active = false;
    }
    sDisplayString = "SERVER>socket is initialized";
    Sender->Synchronize(&DisplayInMemo);
 
    SOCKET listener = socket(AF_INET, SOCK_STREAM, NULL); // create socket
    sDisplayString = "SERVER>socket is created";
    Sender->Synchronize(&DisplayInMemo);
 
    addr.sin_family = AF_INET;
    addr.sin_port = htons(3000); // number port
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    int socket_name_size = sizeof(addr);
 
    if (bind(listener, (struct sockaddr*)&addr, socket_name_size) < 0) {
        sDisplayString = "SERVER>socket is not binded";
        Sender->Synchronize(&DisplayInMemo);
        shutdown(listener, 2);
        closesocket(listener);
        WSACleanup();
        Sender->Active = false;
    }
    sDisplayString = "SERVER>socket is binded";
    Sender->Synchronize(&DisplayInMemo);
 
    listen(listener, 1);
    sDisplayString = "SERVER>set listening";
    Sender->Synchronize(&DisplayInMemo);
 
    while (true) {
        SOCKET sock = accept(listener, NULL, NULL);
        if (sock < 0) {
            sDisplayString = "SERVER>accept error";
            Sender->Synchronize(&DisplayInMemo);
            break;
        }
 
        char buff[1024];
        int bytes_read = recv(sock, buff, 1024, 0);
        if (bytes_read < 0) {
            sDisplayString = "SERVER>bytes_read < 0";
            Sender->Synchronize(&DisplayInMemo);
            shutdown(sock, 2);
            closesocket(sock);
        }
 
        sDisplayString = "SERVER>Received text: " + AnsiString(buff);
        Sender->Synchronize(&DisplayInMemo);
 
        char buffer1[] = "Reply is sent from server!";
 
        send(sock, buffer1, sizeof(buffer1), 0);
 
        shutdown(sock, 2);
        closesocket(sock);
        break;
    }
    shutdown(listener, 2);
    closesocket(listener);
    WSACleanup();
 
    Sender->Active = false;
}
 
// ---------------------------------------------------------------------------
void __fastcall TForm1::IdThreadComponent2Run(TIdThreadComponent *Sender) {
    WSADATA wData;
    struct sockaddr_in addr, serv_addr;
 
    if (WSAStartup(MAKEWORD(1, 1), &wData) != 0) {
        sDisplayString = "CLIENT>socket is not initialized";
        Sender->Synchronize(&DisplayInMemo);
        WSACleanup();
        Sender->Active = false;
    }
    sDisplayString = "CLIENT>socket is initialized";
    Sender->Synchronize(&DisplayInMemo);
 
    SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock == -1) {
        sDisplayString = "CLIENT>socket is not created";
        Sender->Synchronize(&DisplayInMemo);
        WSACleanup();
        Sender->Active = false;
    }
 
    addr.sin_family = AF_INET;
    addr.sin_port = htons(3000);
    addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    bind(sock, (struct sockaddr *)&addr, sizeof(addr));
 
    char HostName[1024];
    DWORD HostIP = 0;
    LPHOSTENT lphost;
    gethostname(HostName, 1024);
    lphost = gethostbyname(HostName);
    serv_addr.sin_family = AF_INET;
    memcpy((char*)&serv_addr.sin_addr, lphost->h_addr, lphost->h_length);
    serv_addr.sin_port = htons(3000);
 
    int error;
    if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
        sDisplayString = "CLIENT>connection error";
        Sender->Synchronize(&DisplayInMemo);
        shutdown(sock, 2);
        closesocket(sock);
        WSACleanup();
        Sender->Active = false;
    }
    sDisplayString = "CLIENT>connection success";
    Sender->Synchronize(&DisplayInMemo);
 
    char message1[] = "Test message for sending from client!";
    send(sock, message1, sizeof(message1), 0);
 
    sDisplayString = "CLIENT>Send a message: " + AnsiString(message1);
    Sender->Synchronize(&DisplayInMemo);
 
    char buff[1024];
    recv(sock, buff, sizeof(buff), 0);
    sDisplayString = "CLIENT>answer " + AnsiString(buff);
    Sender->Synchronize(&DisplayInMemo);
    recv(sock, buff, sizeof(buff), 0);
    sDisplayString = "CLIENT>answer " + AnsiString(buff);
    Sender->Synchronize(&DisplayInMemo);
 
    shutdown(sock, 2);
    closesocket(sock);
    WSACleanup();
    Sender->Active = false;
}
 
// ---------------------------------------------------------------------------